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. with pytest.raises(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) assert 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 run(self): try: while 1: rc,b,c,ol = win32file.GetQueuedCompletionStatus( self.hiocp, 1000 ) if ol: #print rc,b,c,ol otype = len(ol.object) if otype == 2 : [userdata, fd] = ol.object if self.onresult : self.onresult( fd, rc, userdata, self.fds[fd][3], b ) elif otype == 1: #print rc, b,c,ol assert rc == 0 sock = ol.object[0] self.addsocket( self.infds[sock].insock ) if self.onaccept : self.onaccept( sock,self.infds[sock].insock , 0, self.infds[sock].data ) self.infds[sock].insock = socket.socket( socket.AF_INET, socket.SOCK_STREAM) win32file.AcceptEx( sock, self.infds[sock].insock, self.infds[sock].buffer, self.infds[sock].ol ) elif otype == 3: ol.object[1](*ol.object[2]) elif otype == 4 : fd = ol.object[1] if self.ondata : self.ondata( fd, ol.object[2][:b], ol.object[0], self.fds[fd][3] ) if b == 0: win32file.CloseHandle( fd.fileno() ) del self.fds[fd] except KeyboardInterrupt, r: self.stop = 1
def connect_thread_runner(self, expect_payload, giveup_event): # As Windows 2000 doesn't do ConnectEx, we need to use a non-blocking # accept, as our test connection may never come. May as well use # AcceptEx for this... listener = socket.socket() self.addr = ('localhost', random.randint(10000, 64000)) listener.bind(self.addr) listener.listen(1) # 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. if expect_payload: buf_size = 1024 else: # when we don't expect data we must be careful to only pass the # exact number of bytes for the endpoint data... buf_size = win32file.CalculateSocketEndPointSize(listener) buffer = win32file.AllocateReadBuffer(buf_size) win32file.AcceptEx(listener, accepter, buffer, overlapped) # wait for the connection or our test to fail. events = giveup_event, overlapped.hEvent rc = win32event.WaitForMultipleObjects(events, False, 2000) if rc == win32event.WAIT_TIMEOUT: self.fail("timed out waiting for a connection") if rc == win32event.WAIT_OBJECT_0: # Our main thread running the test failed and will never connect. return # must be a connection. nbytes = win32file.GetOverlappedResult(listener.fileno(), overlapped, False) if expect_payload: self.request = buffer[:nbytes] accepter.send(str2bytes('some expected response'))
def listen(self, port, data = None ): sock = self.ListenSocket( port, data ) win32file.CreateIoCompletionPort( sock.socket().fileno(), self.hiocp, 0,1) self.infds[sock.socket()] = sock sock.insock = socket.socket( socket.AF_INET, socket.SOCK_STREAM) win32file.AcceptEx( sock.socket(), sock.insock, sock.buffer, sock.ol )