OXIESEC PANEL

Name	Size	Modified	Perms
📁 ..	-	03/31/2022 06:22:38 AM	rwxr-xr-x
📄 __init__.py	521 bytes	09/08/2017 10:38:36 AM	rw-r--r--
📁 __pycache__	-	03/31/2022 06:22:39 AM	rwxr-xr-x
📄 _baseprocess.py	1.87 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 _dumbwin32proc.py	12.8 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 _glibbase.py	12.51 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 _idna.py	1.36 KB	09/08/2017 10:38:35 AM	rw-r--r--
📄 _newtls.py	9.11 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 _pollingfile.py	8.77 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 _posixserialport.py	1.95 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 _posixstdio.py	4.58 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 _producer_helpers.py	3.7 KB	09/08/2017 10:38:35 AM	rw-r--r--
📄 _resolver.py	8.33 KB	09/08/2017 10:38:35 AM	rw-r--r--
📄 _signals.py	2.65 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 _sslverify.py	68.83 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 _threadedselect.py	11.49 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 _win32serialport.py	4.63 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 _win32stdio.py	3.13 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 abstract.py	18.99 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 address.py	6.53 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 asyncioreactor.py	10.31 KB	09/08/2017 10:38:35 AM	rw-r--r--
📄 base.py	42.56 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 cfreactor.py	17.09 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 default.py	1.89 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 defer.py	66.49 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 endpoints.py	74.57 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 epollreactor.py	8.29 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 error.py	12.35 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 fdesc.py	3.15 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 gireactor.py	5.98 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 glib2reactor.py	1.09 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 gtk2reactor.py	3.53 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 gtk3reactor.py	2.2 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 inotify.py	14.35 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 interfaces.py	93.75 KB	09/08/2017 10:38:36 AM	rw-r--r--
📁 iocpreactor	-	03/31/2022 06:22:38 AM	rwxr-xr-x
📄 kqreactor.py	10.05 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 main.py	1.03 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 pollreactor.py	5.88 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 posixbase.py	25.74 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 process.py	37.98 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 protocol.py	26.34 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 pyuisupport.py	817 bytes	09/08/2017 10:38:36 AM	rw-r--r--
📄 reactor.py	1.82 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 selectreactor.py	6.07 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 serialport.py	2.26 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 ssl.py	8.25 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 stdio.py	1.02 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 task.py	30.39 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 tcp.py	42 KB	09/08/2017 10:38:36 AM	rw-r--r--
📁 test	-	03/31/2022 06:22:38 AM	rwxr-xr-x
📄 threads.py	3.86 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 tksupport.py	2 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 udp.py	18.13 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 unix.py	21.42 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 utils.py	7.69 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 win32eventreactor.py	14.84 KB	09/08/2017 10:38:36 AM	rw-r--r--
📄 wxreactor.py	5.14 KB	03/22/2022 11:03:56 AM	rw-r--r--
📄 wxsupport.py	1.33 KB	09/08/2017 10:38:36 AM	rw-r--r--

Editing: _pollingfile.py

# -*- test-case-name: twisted.internet.test.test_pollingfile -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Implements a simple polling interface for file descriptors that don't work with
select() - this is pretty much only useful on Windows.
"""

from __future__ import absolute_import, division

from zope.interface import implementer
from twisted.internet.interfaces import IConsumer, IPushProducer
from twisted.python.compat import unicode

MIN_TIMEOUT = 0.000000001
MAX_TIMEOUT = 0.1

class _PollableResource:
    active = True

def activate(self):
        self.active = True

def deactivate(self):
        self.active = False

class _PollingTimer:
    # Everything is private here because it is really an implementation detail.

def __init__(self, reactor):
        self.reactor = reactor
        self._resources = []
        self._pollTimer = None
        self._currentTimeout = MAX_TIMEOUT
        self._paused = False

def _addPollableResource(self, res):
        self._resources.append(res)
        self._checkPollingState()

def _checkPollingState(self):
        for resource in self._resources:
            if resource.active:
                self._startPolling()
                break
        else:
            self._stopPolling()

def _startPolling(self):
        if self._pollTimer is None:
            self._pollTimer = self._reschedule()

def _stopPolling(self):
        if self._pollTimer is not None:
            self._pollTimer.cancel()
            self._pollTimer = None

def _pause(self):
        self._paused = True

def _unpause(self):
        self._paused = False
        self._checkPollingState()

def _reschedule(self):
        if not self._paused:
            return self.reactor.callLater(self._currentTimeout, self._pollEvent)

def _pollEvent(self):
        workUnits = 0.
        anyActive = []
        for resource in self._resources:
            if resource.active:
                workUnits += resource.checkWork()
                # Check AFTER work has been done
                if resource.active:
                    anyActive.append(resource)

newTimeout = self._currentTimeout
        if workUnits:
            newTimeout = self._currentTimeout / (workUnits + 1.)
            if newTimeout < MIN_TIMEOUT:
                newTimeout = MIN_TIMEOUT
        else:
            newTimeout = self._currentTimeout * 2.
            if newTimeout > MAX_TIMEOUT:
                newTimeout = MAX_TIMEOUT
        self._currentTimeout = newTimeout
        if anyActive:
            self._pollTimer = self._reschedule()

# If we ever (let's hope not) need the above functionality on UNIX, this could
# be factored into a different module.

import win32pipe
import win32file
import win32api
import pywintypes

@implementer(IPushProducer)
class _PollableReadPipe(_PollableResource):

def __init__(self, pipe, receivedCallback, lostCallback):
        # security attributes for pipes
        self.pipe = pipe
        self.receivedCallback = receivedCallback
        self.lostCallback = lostCallback

def checkWork(self):
        finished = 0
        fullDataRead = []

while 1:
            try:
                buffer, bytesToRead, result = win32pipe.PeekNamedPipe(self.pipe, 1)
                # finished = (result == -1)
                if not bytesToRead:
                    break
                hr, data = win32file.ReadFile(self.pipe, bytesToRead, None)
                fullDataRead.append(data)
            except win32api.error:
                finished = 1
                break

dataBuf = b''.join(fullDataRead)
        if dataBuf:
            self.receivedCallback(dataBuf)
        if finished:
            self.cleanup()
        return len(dataBuf)

def cleanup(self):
        self.deactivate()
        self.lostCallback()

def close(self):
        try:
            win32api.CloseHandle(self.pipe)
        except pywintypes.error:
            # You can't close std handles...?
            pass

def stopProducing(self):
        self.close()

def pauseProducing(self):
        self.deactivate()

def resumeProducing(self):
        self.activate()

FULL_BUFFER_SIZE = 64 * 1024

@implementer(IConsumer)
class _PollableWritePipe(_PollableResource):

def __init__(self, writePipe, lostCallback):
        self.disconnecting = False
        self.producer = None
        self.producerPaused = False
        self.streamingProducer = 0
        self.outQueue = []
        self.writePipe = writePipe
        self.lostCallback = lostCallback
        try:
            win32pipe.SetNamedPipeHandleState(writePipe,
                                              win32pipe.PIPE_NOWAIT,
                                              None,
                                              None)
        except pywintypes.error:
            # Maybe it's an invalid handle.  Who knows.
            pass

def close(self):
        self.disconnecting = True

def bufferFull(self):
        if self.producer is not None:
            self.producerPaused = True
            self.producer.pauseProducing()

def bufferEmpty(self):
        if self.producer is not None and ((not self.streamingProducer) or
                                          self.producerPaused):
            self.producer.producerPaused = False
            self.producer.resumeProducing()
            return True
        return False

# almost-but-not-quite-exact copy-paste from abstract.FileDescriptor... ugh

def registerProducer(self, producer, streaming):
        """Register to receive data from a producer.

This sets this selectable to be a consumer for a producer.  When this
        selectable runs out of data on a write() call, it will ask the producer
        to resumeProducing(). A producer should implement the IProducer
        interface.

FileDescriptor provides some infrastructure for producer methods.
        """
        if self.producer is not None:
            raise RuntimeError(
                "Cannot register producer %s, because producer %s was never "
                "unregistered." % (producer, self.producer))
        if not self.active:
            producer.stopProducing()
        else:
            self.producer = producer
            self.streamingProducer = streaming
            if not streaming:
                producer.resumeProducing()

def unregisterProducer(self):
        """Stop consuming data from a producer, without disconnecting.
        """
        self.producer = None

def writeConnectionLost(self):
        self.deactivate()
        try:
            win32api.CloseHandle(self.writePipe)
        except pywintypes.error:
            # OMG what
            pass
        self.lostCallback()

def writeSequence(self, seq):
        """
        Append a C{list} or C{tuple} of bytes to the output buffer.

@param seq: C{list} or C{tuple} of C{str} instances to be appended to
            the output buffer.

@raise TypeError: If C{seq} contains C{unicode}.
        """
        if unicode in map(type, seq):
            raise TypeError("Unicode not allowed in output buffer.")
        self.outQueue.extend(seq)

def write(self, data):
        """
        Append some bytes to the output buffer.

@param data: C{str} to be appended to the output buffer.
        @type data: C{str}.

@raise TypeError: If C{data} is C{unicode} instead of C{str}.
        """
        if isinstance(data, unicode):
            raise TypeError("Unicode not allowed in output buffer.")
        if self.disconnecting:
            return
        self.outQueue.append(data)
        if sum(map(len, self.outQueue)) > FULL_BUFFER_SIZE:
            self.bufferFull()

def checkWork(self):
        numBytesWritten = 0
        if not self.outQueue:
            if self.disconnecting:
                self.writeConnectionLost()
                return 0
            try:
                win32file.WriteFile(self.writePipe, b'', None)
            except pywintypes.error:
                self.writeConnectionLost()
                return numBytesWritten
        while self.outQueue:
            data = self.outQueue.pop(0)
            errCode = 0
            try:
                errCode, nBytesWritten = win32file.WriteFile(self.writePipe,
                                                             data, None)
            except win32api.error:
                self.writeConnectionLost()
                break
            else:
                # assert not errCode, "wtf an error code???"
                numBytesWritten += nBytesWritten
                if len(data) > nBytesWritten:
                    self.outQueue.insert(0, data[nBytesWritten:])
                    break
        else:
            resumed = self.bufferEmpty()
            if not resumed and self.disconnecting:
                self.writeConnectionLost()
        return numBytesWritten