def __init__(self, scrobble_queue):
super().__init__(scrobble_queue)
self.file_handle = None
self.is_running = False
self._read_buf = win32file.AllocateReadBuffer(1024)
self._transact_buf = win32file.AllocateReadBuffer(512)
self._read_all_buf = win32file.AllocateReadBuffer(512)
def read(self, size=1):
"""Read size bytes from the serial port. If a timeout is set it may
return less characters as requested. With no timeout it will block
until the requested number of bytes is read."""
if not self.hComPort: raise portNotOpenError
if size > 0:
win32event.ResetEvent(self._overlappedRead.hEvent)
flags, comstat = win32file.ClearCommError(self.hComPort)
if self.timeout == 0:
n = min(comstat.cbInQue, size)
if n > 0:
rc, buf = win32file.ReadFile(
self.hComPort, win32file.AllocateReadBuffer(n),
self._overlappedRead)
win32event.WaitForSingleObject(self._overlappedRead.hEvent,
win32event.INFINITE)
read = str(buf)
else:
read = ''
else:
rc, buf = win32file.ReadFile(
self.hComPort, win32file.AllocateReadBuffer(size),
self._overlappedRead)
n = win32file.GetOverlappedResult(self.hComPort,
self._overlappedRead, 1)
read = str(buf[:n])
else:
read = ''
return read
def read(self, size=1):
"read num bytes from serial port"
if not self.hComPort: raise portNotOpenError
read = ''
if size > 0:
overlapped = win32file.OVERLAPPED()
overlapped.hEvent = win32event.CreateEvent(None, 1, 0, None)
if self.timeout == 0:
flags, comstat = win32file.ClearCommError(self.hComPort)
n = min(comstat.cbInQue, size)
if n > 0:
rc, buf = win32file.ReadFile(
self.hComPort, win32file.AllocateReadBuffer(n),
overlapped)
win32event.WaitForSingleObject(overlapped.hEvent,
win32event.INFINITE)
read = str(buf)
else:
flags, comstat = win32file.ClearCommError(self.hComPort)
rc, buf = win32file.ReadFile(
self.hComPort, win32file.AllocateReadBuffer(size),
overlapped)
n = win32file.GetOverlappedResult(self.hComPort, overlapped, 1)
read = str(buf[:n])
return read
def serialReadEvent(self):
#get that character we set up
n = win32file.GetOverlappedResult(self._serial.hComPort,
self._overlappedRead, 0)
if n:
first = str(self.read_buf[:n])
#now we should get everything that is already in the buffer
flags, comstat = win32file.ClearCommError(self._serial.hComPort)
if comstat.cbInQue:
win32event.ResetEvent(self._overlappedRead.hEvent)
rc, buf = win32file.ReadFile(
self._serial.hComPort,
win32file.AllocateReadBuffer(comstat.cbInQue),
self._overlappedRead)
n = win32file.GetOverlappedResult(self._serial.hComPort,
self._overlappedRead, 1)
#handle all the received data:
self.protocol.dataReceived(first + str(buf[:n]))
else:
#handle all the received data:
self.protocol.dataReceived(first)
#set up next one
win32event.ResetEvent(self._overlappedRead.hEvent)
rc, self.read_buf = win32file.ReadFile(self._serial.hComPort,
win32file.AllocateReadBuffer(1),
self._overlappedRead)
def receivebyte(self, RDtimeout=0):
"""read num bytes from serial port"""
if not self.hComPort: raise portNotOpenError
timeouts = (win32con.MAXDWORD, win32con.MAXDWORD, int(RDtimeout * 100),
0, 0) # timeouts in 100 ms units...
win32file.SetCommTimeouts(self.hComPort, timeouts)
win32event.ResetEvent(self._overlappedRead.hEvent)
flags, comstat = win32file.ClearCommError(self.hComPort)
n = comstat.cbInQue
if n > 0: # there is data in buffer
rc, buf = win32file.ReadFile(self.hComPort,
win32file.AllocateReadBuffer(1),
self._overlappedRead)
win32event.WaitForSingleObject(self._overlappedRead.hEvent,
win32event.INFINITE)
read = buf[0]
else:
rc, buf = win32file.ReadFile(self.hComPort,
win32file.AllocateReadBuffer(1),
self._overlappedRead)
n = win32file.GetOverlappedResult(self.hComPort,
self._overlappedRead, 1)
if n > 0:
read = buf[0]
else:
read = -1
return read
def open(self):
self._olapped_io = win32file.OVERLAPPED()
if 'w' in self.mode:
self._olapped_io.hEvent = win32event.CreateEvent(
None, False, False, None)
self.reactor.addEvent(self._olapped_io.hEvent, self, 'pipeWrite')
else:
self._olapped_io.hEvent = win32event.CreateEvent(
None, True, False, None)
self.reactor.addEvent(self._olapped_io.hEvent, self, 'pipeRead')
self._olapped_connect = win32file.OVERLAPPED()
self._olapped_connect.hEvent = win32event.CreateEvent(
None, True, False, None)
self._connect_deferred = defer.Deferred()
win32pipe.ConnectNamedPipe(self._handle, self._olapped_connect)
self.reactor.addEvent(self._olapped_connect.hEvent, self, '_connected')
yield self._connect_deferred
self.reactor.removeEvent(self._olapped_connect.hEvent)
if 'r' in self.mode:
self._read_buffer = win32file.AllocateReadBuffer(8192)
win32file.ReadFile(self._handle, self._read_buffer,
self._olapped_io)
def readuntil(self, char):
"read bytes from serial port until char is hit"
if not self.hComPort: raise portNotOpenError
print thetime(), "readuntil entered"
overlapped = win32file.OVERLAPPED()
overlapped.hEvent = win32event.CreateEvent(None, 1, 0, None)
dcb = win32file.GetCommState(self.hComPort)
oldevt = dcb.EvtChar
dcb.EvtChar = char
rc = win32file.SetCommState(self.hComPort, dcb)
print thetime(), "setcommstate returned", rc
oldmask = win32file.GetCommMask(self.hComPort)
rc = win32file.SetCommMask(self.hComPort, win32file.EV_RXFLAG)
print thetime(), "setcommmask returned", rc
rc, mask = win32file.WaitCommEvent(self.hComPort, overlapped)
print thetime(), "waitcommevent returned", rc, mask
rc = win32event.WaitForSingleObject(overlapped.hEvent, 10000)
print thetime(), "waitforsingleobject returned", rc
n = win32file.GetOverlappedResult(self.hComPort, overlapped, 0)
print thetime(), "getoverlappedresult returned", n
win32file.SetCommMask(self.hComPort, oldmask)
flags, comstat = win32file.ClearCommError(self.hComPort)
print thetime(), "clearcommerror", flags, comstat.cbInQue
rc, buf = win32file.ReadFile(
self.hComPort, win32file.AllocateReadBuffer(comstat.cbInQue),
overlapped)
print thetime(), "readfile retrurned", rc
n = win32file.GetOverlappedResult(self.hComPort, overlapped, 1)
print thetime(), "getoverlappedresult returned", n
read = str(buf[:n])
return read
def post_authentication_server(self, control_message, additional_data):
c = self.lookup_client_pub(additional_data)
if c.get_initiated():
c.set_authenticated(True)
self.packetselector.add_client(c)
if c.get_pipe_r() not in self.rlist:
self.rlist.append(c.get_pipe_r())
if self.os_type == common.OS_WINDOWS:
# creating objects and adding to corresponding lists
import win32event
import win32file
import pywintypes
hEvent_pipe = win32event.CreateEvent(
None, 0, 0, None) # for reading from the pipe
overlapped_pipe = pywintypes.OVERLAPPED()
overlapped_pipe.hEvent = hEvent_pipe
message_buffer = win32file.AllocateReadBuffer(4096)
self.olist.append(overlapped_pipe)
self.elist.append(hEvent_pipe)
self.mlist.append(message_buffer)
self.ulist.append(len(self.elist) - 1)
return True
return False
def run(self):
continueloop = True
n = 1
waitingOnRead = False
buf = win32file.AllocateReadBuffer(n)
while continueloop:
if self.EVENT.isSet():
win32event.SetEvent(self.stopevent)
if not waitingOnRead:
win32event.ResetEvent(self.serial._overlappedRead.hEvent)
hr, _ = win32file.ReadFile(self.serial.hComPort, buf, self.serial._overlappedRead)
if hr == 997: waitingOnRead = True
elif hr == 0: pass
else: raise
rc = win32event.MsgWaitForMultipleObjects((self.serial._overlappedRead.hEvent, self.stopevent),
0, 1000, win32event.QS_ALLINPUT)
if rc == win32event.WAIT_OBJECT_0:
n = win32file.GetOverlappedResult(self.serial.hComPort, self.serial._overlappedRead, 1)
if n and not self.EVENT.isSet(): self.plugin.Decode(ord(buf[0]))
waitingOnRead = False
elif rc == win32event.WAIT_OBJECT_0+1: continueloop = False
elif rc == win32event.WAIT_TIMEOUT: pass
else: pass
self.serial.close()
def transact(self, name, writeData):
buf = win32file.AllocateReadBuffer(length)
win32pipe.TransactNamedPipe(name, writeData, buf, None)
"""
string/buffer = TransactNamedPipe(pipeName, writeData , buffer/bufSize , overlapped )
Combines the functions that write a message to and read a message from the specified named pipe into a single network operation.
Parameters
pipeName : PyUNICODE
The name of the pipe.
writeData : string/buffer
The data to write to the pipe.
buffer/bufSize : PyOVERLAPPEDReadBuffer/int
Size of the buffer to create for the result, or a buffer to fill
with the result. If a buffer object and overlapped is passed, the
result is the buffer itself. If a buffer but no overlapped is passed,
the result is a new string object, built from the buffer, but with a
length that reflects the data actually read.
overlapped=None : PyOVERLAPPED
An overlapped structure or None
"""
pass
def _watcherThreadOverlapped(self, dn, dh, changes):
flags = win32con.FILE_NOTIFY_CHANGE_FILE_NAME
buf = win32file.AllocateReadBuffer(8192)
overlapped = pywintypes.OVERLAPPED()
overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None)
while 1:
win32file.ReadDirectoryChangesW(
dh,
buf,
False, #sub-tree
flags,
overlapped)
# Wait for our event, or for 5 seconds.
rc = win32event.WaitForSingleObject(overlapped.hEvent, 5000)
if rc == win32event.WAIT_OBJECT_0:
# got some data! Must use GetOverlappedResult to find out
# how much is valid! 0 generally means the handle has
# been closed. Blocking is OK here, as the event has
# already been set.
nbytes = win32file.GetOverlappedResult(dh, overlapped, True)
if nbytes:
bits = win32file.FILE_NOTIFY_INFORMATION(buf, nbytes)
changes.extend(bits)
else:
# This is "normal" exit - our 'tearDown' closes the
# handle.
# print "looks like dir handle was closed!"
return
else:
print("ERROR: Watcher thread timed-out!")
return # kill the thread!
def __init__(self, path, flags):
self.flags = flags
self.handle = None
self.event = None
try:
self.handle = win32file.CreateFileW(
path,
0x0001, # FILE_LIST_DIRECTORY
win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE,
None,
win32con.OPEN_EXISTING,
win32con.FILE_FLAG_BACKUP_SEMANTICS
| win32con.FILE_FLAG_OVERLAPPED,
None)
self.buffer = win32file.AllocateReadBuffer(8192)
self.event = win32event.CreateEvent(None, True, False, None)
self.overlapped = pywintypes.OVERLAPPED()
self.overlapped.hEvent = self.event
self._start()
except:
self.close()
raise
def open(self):
"""
Open named-pipe, starts up reading/writing
:return: a deferred firing when the named pipe is opened
:rtype: twisted.internet.deferred.Deferred
"""
self._olapped_io = win32file.OVERLAPPED()
if 'w' in self.mode:
self._olapped_io.hEvent = win32event.CreateEvent(
None, False, False, None)
self.reactor.addEvent(self._olapped_io.hEvent, self, 'pipeWrite')
else:
self._olapped_io.hEvent = win32event.CreateEvent(
None, True, False, None)
self.reactor.addEvent(self._olapped_io.hEvent, self, 'pipeRead')
self._olapped_connect = win32file.OVERLAPPED()
self._olapped_connect.hEvent = win32event.CreateEvent(
None, True, False, None)
self._connect_deferred = defer.Deferred()
win32pipe.ConnectNamedPipe(self._handle, self._olapped_connect)
self.reactor.addEvent(self._olapped_connect.hEvent, self, '_connected')
yield self._connect_deferred
self.reactor.removeEvent(self._olapped_connect.hEvent)
if 'r' in self.mode:
self._read_buffer = win32file.AllocateReadBuffer(8192)
win32file.ReadFile(self._handle, self._read_buffer,
self._olapped_io)
def __init__(self, name=None, pipeBufferSize=65536, readBuffSize=8192):
self.pipe_name = r"\\.\pipe\\" + name if name is not None else r"\\.\pipe\defaultPipe"
self.pipe_buffer_size = pipeBufferSize
self.read_buf = win32file.AllocateReadBuffer(readBuffSize)
self.read_msg = None
self.pipe_open = False
self.pipe_handle = None
def acceptWorker(self, port, running_event, stopped_event):
listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
listener.bind(('', port))
listener.listen(200)
# create accept socket
accepter = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# An overlapped
overlapped = pywintypes.OVERLAPPED()
overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None)
# accept the connection.
# We used to allow strings etc to be passed here, and they would be
# modified! Obviously this is evil :)
buffer = " " * 1024 # EVIL - SHOULD NOT BE ALLOWED.
self.assertRaises(TypeError, win32file.AcceptEx, listener, accepter,
buffer, overlapped)
# This is the correct way to allocate the buffer...
buffer = win32file.AllocateReadBuffer(1024)
rc = win32file.AcceptEx(listener, accepter, buffer, overlapped)
self.failUnlessEqual(rc, winerror.ERROR_IO_PENDING)
# Set the event to say we are all ready
running_event.set()
# and wait for the connection.
rc = win32event.WaitForSingleObject(overlapped.hEvent, 2000)
if rc == win32event.WAIT_TIMEOUT:
self.fail("timed out waiting for a connection")
nbytes = win32file.GetOverlappedResult(listener.fileno(), overlapped,
False)
#fam, loc, rem = win32file.GetAcceptExSockaddrs(accepter, buffer)
accepter.send(buffer[:nbytes])
# NOT set in a finally - this means *successfully* stopped!
stopped_event.set()
def accept(self, endpoint):
sock2 = WinSock(socket.socket(socket.AF_INET, socket.SOCK_STREAM))
buf = win32file.AllocateReadBuffer(CalculateSocketEndPointSize(sock2))
# need to attach sock2 to iocp too
overlapped = self._get_overlapped(self._accept_done, sock2, buf)
rc, _ = win32file.AcceptEx(self._handle, sock2._handle, buf,
overlapped)
def testTransactNamedPipeAsync(self):
event = threading.Event()
overlapped = pywintypes.OVERLAPPED()
overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None)
self.startPipeServer(event, 0.5)
open_mode = win32con.GENERIC_READ | win32con.GENERIC_WRITE
hpipe = win32file.CreateFile(
self.pipename,
open_mode,
0, # no sharing
None, # default security
win32con.OPEN_EXISTING,
win32con.FILE_FLAG_OVERLAPPED,
None,
)
# set to message mode.
win32pipe.SetNamedPipeHandleState(
hpipe, win32pipe.PIPE_READMODE_MESSAGE, None, None
)
buffer = win32file.AllocateReadBuffer(1024)
hr, got = win32pipe.TransactNamedPipe(
hpipe, str2bytes("foo\0bar"), buffer, overlapped
)
self.assertEqual(hr, winerror.ERROR_IO_PENDING)
nbytes = win32file.GetOverlappedResult(hpipe, overlapped, True)
got = buffer[:nbytes]
self.assertEqual(got, str2bytes("bar\0foo"))
event.wait(5)
self.assertTrue(event.isSet(), "Pipe server thread didn't terminate")
def testTransactNamedPipeBlockingBuffer(self):
# Like testTransactNamedPipeBlocking, but a pre-allocated buffer is
# passed (not really that useful, but it exercises the code path)
event = threading.Event()
self.startPipeServer(event)
open_mode = win32con.GENERIC_READ | win32con.GENERIC_WRITE
hpipe = win32file.CreateFile(
self.pipename,
open_mode,
0, # no sharing
None, # default security
win32con.OPEN_EXISTING,
0, # win32con.FILE_FLAG_OVERLAPPED,
None,
)
# set to message mode.
win32pipe.SetNamedPipeHandleState(
hpipe, win32pipe.PIPE_READMODE_MESSAGE, None, None
)
buffer = win32file.AllocateReadBuffer(1024)
hr, got = win32pipe.TransactNamedPipe(
hpipe, str2bytes("foo\0bar"), buffer, None
)
self.assertEqual(got, str2bytes("bar\0foo"))
event.wait(5)
self.assertTrue(event.isSet(), "Pipe server thread didn't terminate")
def testSimpleOverlapped(self):
# Create a file in the %TEMP% directory.
import win32event
testName = os.path.join(win32api.GetTempPath(), "win32filetest.dat")
desiredAccess = win32file.GENERIC_WRITE
overlapped = pywintypes.OVERLAPPED()
evt = win32event.CreateEvent(None, 0, 0, None)
overlapped.hEvent = evt
# Create the file and write shit-loads of data to it.
h = win32file.CreateFile(testName, desiredAccess, 0, None, win32file.CREATE_ALWAYS, 0, 0)
chunk_data = str2bytes("z") * 0x8000
num_loops = 512
expected_size = num_loops * len(chunk_data)
for i in range(num_loops):
win32file.WriteFile(h, chunk_data, overlapped)
win32event.WaitForSingleObject(overlapped.hEvent, win32event.INFINITE)
overlapped.Offset = overlapped.Offset + len(chunk_data)
h.Close()
# Now read the data back overlapped
overlapped = pywintypes.OVERLAPPED()
evt = win32event.CreateEvent(None, 0, 0, None)
overlapped.hEvent = evt
desiredAccess = win32file.GENERIC_READ
h = win32file.CreateFile(testName, desiredAccess, 0, None, win32file.OPEN_EXISTING, 0, 0)
buffer = win32file.AllocateReadBuffer(0xFFFF)
while 1:
try:
hr, data = win32file.ReadFile(h, buffer, overlapped)
win32event.WaitForSingleObject(overlapped.hEvent, win32event.INFINITE)
overlapped.Offset = overlapped.Offset + len(data)
if not data is buffer:
self.fail("Unexpected result from ReadFile - should be the same buffer we passed it")
except win32api.error:
break
h.Close()
def test_connect_without_payload(self):
giveup_event = win32event.CreateEvent(None, 0, 0, None)
t = threading.Thread(target=self.connect_thread_runner,
args=(False, giveup_event))
t.start()
time.sleep(0.1)
s2 = socket.socket()
ol = pywintypes.OVERLAPPED()
s2.bind(('0.0.0.0', 0)) # connectex requires the socket be bound beforehand
try:
win32file.ConnectEx(s2, self.addr, ol)
except win32file.error as exc:
win32event.SetEvent(giveup_event)
if exc.winerror == 10022: # WSAEINVAL
raise TestSkipped("ConnectEx is not available on this platform")
raise # some error error we don't expect.
win32file.GetOverlappedResult(s2.fileno(), ol, 1)
ol = pywintypes.OVERLAPPED()
buff = win32file.AllocateReadBuffer(1024)
win32file.WSARecv(s2, buff, ol, 0)
length = win32file.GetOverlappedResult(s2.fileno(), ol, 1)
self.response = buff[:length]
self.assertEqual(self.response, str2bytes('some expected response'))
t.join(5)
self.failIf(t.isAlive(), "worker thread didn't terminate")
def _loop_asynchronous(self, callback):
buf = win32file.AllocateReadBuffer(8192)
overlapped = pywintypes.OVERLAPPED()
overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None)
while not self._stopped:
win32file.ReadDirectoryChangesW(self._hdir, buf, self._recurse,
self._filter, overlapped)
##
## This will block until notification OR timeout.
##
rc = win32event.WaitForSingleObject(overlapped.hEvent,
self._timeout)
if rc == win32event.WAIT_OBJECT_0:
## got event: determine data length ..
n = win32file.GetOverlappedResult(self._hdir, overlapped, True)
if n:
## retrieve data
results = win32file.FILE_NOTIFY_INFORMATION(buf, n)
r = [(DirWatcher._ACTIONS.get(x[0], "UNKNOWN"), x[1])
for x in results]
if len(r) > 0:
callback(r)
else:
# directory handled was closed
self._stopped = True
else:
## timeout
pass
def __init__(self, protocol, deviceNameOrPortNumber, reactor,
baudrate = 9600, bytesize = EIGHTBITS, parity = PARITY_NONE,
stopbits = STOPBITS_ONE, xonxoff = 0, rtscts = 0):
self._serial = serial.Serial(deviceNameOrPortNumber, baudrate=baudrate,
bytesize=bytesize, parity=parity,
stopbits=stopbits, timeout=None,
xonxoff=xonxoff, rtscts=rtscts)
self.flushInput()
self.flushOutput()
self.reactor = reactor
self.protocol = protocol
self.outQueue = []
self.closed = 0
self.closedNotifies = 0
self.writeInProgress = 0
self.protocol = protocol
self._overlappedRead = win32file.OVERLAPPED()
self._overlappedRead.hEvent = win32event.CreateEvent(None, 1, 0, None)
self._overlappedWrite = win32file.OVERLAPPED()
self._overlappedWrite.hEvent = win32event.CreateEvent(None, 0, 0, None)
self.reactor.addEvent(self._overlappedRead.hEvent, self, 'serialReadEvent')
self.reactor.addEvent(self._overlappedWrite.hEvent, self, 'serialWriteEvent')
self.protocol.makeConnection(self)
flags, comstat = win32file.ClearCommError(self._serial.hComPort)
rc, self.read_buf = win32file.ReadFile(self._serial.hComPort,
win32file.AllocateReadBuffer(1),
self._overlappedRead)
def testAcceptEx(self):
port = 4680
running = threading.Event()
stopped = threading.Event()
t = threading.Thread(target=self.acceptWorker,
args=(port, running, stopped))
t.start()
running.wait(2)
if not running.isSet():
self.fail("AcceptEx Worker thread failed to start")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(('127.0.0.1', port))
win32file.WSASend(s, str2bytes("hello"), None)
overlapped = pywintypes.OVERLAPPED()
overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None)
# Like above - WSARecv used to allow strings as the receive buffer!!
buffer = " " * 10
self.assertRaises(TypeError, win32file.WSARecv, s, buffer, overlapped)
# This one should work :)
buffer = win32file.AllocateReadBuffer(10)
win32file.WSARecv(s, buffer, overlapped)
nbytes = win32file.GetOverlappedResult(s.fileno(), overlapped, True)
got = buffer[:nbytes]
self.failUnlessEqual(got, str2bytes("hello"))
# thread should have stopped
stopped.wait(2)
if not stopped.isSet():
self.fail("AcceptEx Worker thread failed to successfully stop")
def Receive(self):
# Receive data from server
bufObject = win32file.AllocateReadBuffer(ReadClient.BUFFER_SIZE)
while True:
try:
(readRtn, data) = win32file.ReadFile(self.hPipe, bufObject)
if readRtn != 0 and readRtn != winerror.ERROR_MORE_DATA:
showFormat = 'ReadFile failed, w/err: {0} {1}: {2}'
showInfo = showFormat.format(
win32api.FormatMessage(win32api.GetLastError()),
*get_file_line())
win32api.OutputDebugString(showInfo)
break
data_list = data.split(ReadClient.MSG_HEAD_FLAG)
if self.receiver:
for item in data_list:
if len(item) > 0:
self.receiver(item)
except pywintypes.error as e:
showFormat = '{0} failed, w/err: {1} {2}: {3}'
showInfo = showFormat.format(e.args[1], e.args[2],
*get_file_line())
win32api.OutputDebugString(showInfo)
break
def run(self):
global sock, handle, mtu_size, verbose
buf = win32file.AllocateReadBuffer(2000)
while True:
rc, bytes_recvd = win32file.WSARecv(sock.fileno(), buf,
self.overlapped_rx)
assert rc == 0 or rc == win32file.WSA_IO_PENDING
bytes_recvd = yield
p = buf[:bytes_recvd]
p = netmsg_to_local(p)
p = unpack_header(p)
if p:
if verbose:
print 'tunnel send: '
if (ord(p[0]) & 0xf0) == 0x40:
pprint(IP(p))
elif (ord(p[0]) & 0xf0) == 0x60:
pprint(IP6(p))
else:
print 'Unknown layer 3 protocol'
win32file.WriteFile(handle, p, self.overlapped_tx)
yield
def enqueue_recv(self, size):
overlapped = win32file.OVERLAPPED()
buf = win32file.AllocateReadBuffer(size)
rc, _ = win32file.WSARecv(self.fileno(), buf, overlapped, 0)
self._recv_buffers[overlapped] = buf
overlapped.object = self.recv_done
self.keep(overlapped.object)
self.keep(overlapped)
def _read_all_data(self):
"""Read all the remaining data on the pipe"""
data = b""
read_buf = win32file.AllocateReadBuffer(512)
while win32file.GetFileSize(self.file_handle):
_, d = win32file.ReadFile(self.file_handle, read_buf)
data += d
return data
def run(self):
rxbuffer = win32file.AllocateReadBuffer(self.ETHERNET_MTU)
while self.goOn:
l, data = win32file.ReadFile(self.tun_handle, rxbuffer, self.overlappedRx)
win32event.WaitForSingleObject(self.overlappedRx.hEvent, win32event.INFINITE)
self.overlappedRx.Offset = self.overlappedRx.Offset + len(data)
self.wsfactory.tunnel_write(data)
def _transact(self, write_data):
"""Wrapper over TransactNamedPipe"""
read_buf = win32file.AllocateReadBuffer(512)
err, data = win32pipe.TransactNamedPipe(self.file_handle, write_data,
read_buf)
while err == ERROR_MORE_DATA:
err, d = win32file.ReadFile(self.file_handle, read_buf)
data += d
return data
def read(self, timeout=0, buf_sz=0):
if self.transport == Pipe.Transport.ASYNCHRONOUS:
if timeout is None:
evTimeout = 50 # 50ms is the default value per MSDN docs.
elif int(timeout) == 0:
evTimeout = 50 # 50ms is the default value per MSDN docs.
else:
evTimeout = int(timeout)
stream = self._getOverlappedStruct()
if buf_sz <= 0:
buf_sz = 2048
ov_buf = w32f.AllocateReadBuffer(buf_sz)
pipe_data = ''
while True:
try:
pipe_status, pipe_buffer = w32f.ReadFile(
self.__hPipe, ov_buf, stream
)
except WinT.error, e:
if e.args[0] == werr.ERROR_BROKEN_PIPE:
return 1, stream.Offset, pipe_data
else:
raise
if pipe_status == 0 or \
pipe_status == werr.ERROR_IO_PENDING:
#TODO: Return stream and then prompt user to fetch data.
if pipe_status == werr.ERROR_IO_PENDING:
self.__waitForEvent(stream, evTimeout)
try:
read_bytes = w32f.GetOverlappedResult(
self.__hPipe, stream, False
)
except WinT.error, e:
if e.args[0] == werr.ERROR_MORE_DATA:
ov_buf = self.__expandBufferPipe(buf_sz)
stream.Offset += len(pipe_buffer)
pipe_data += pipe_buffer
continue
elif e.args[0] == werr.ERROR_BROKEN_PIPE:
return 1, stream.Offset, pipe_data
else:
raise
elif pipe_status == werr.ERROR_MORE_DATA:
ov_buf = self.__expandBufferPipe(buf_sz)
stream.Offset += len(pipe_buffer)
pipe_data += pipe_buffer
continue
else:
raise PipeError(
'Pipe encountered a fatal error!',
'error_code',
w32api.GetLastError()
)
stream.Offset += read_bytes
pipe_data += pipe_buffer[:read_bytes]
if read_bytes < len(pipe_buffer):
return 0, stream.Offset, pipe_data
