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