def _win_thread_fn(read_side, write_side, buf_size): """This method serves as a server that connects a writer client to a reader client. This methods will run as a thread, and will only be called on Windows platforms. """ import win32pipe, win32file, pywintypes # type: ignore try: # Connect to both ends of the pipe before starting the transfer. # This funciton is blocking. If no process is connected yet, it will wait # indefinitely. win32pipe.ConnectNamedPipe(read_side) win32pipe.ConnectNamedPipe(write_side) while True: # Writer -> read_side -> write_side -> Reader _, data = win32file.ReadFile(read_side, buf_size) win32file.WriteFile(write_side, data) except Exception as ex: # Remove the pipes from the system. win32file.CloseHandle(read_side) win32file.CloseHandle(write_side) # If the error was due to one of the processes shutting down, just exit normally. if isinstance(ex, pywintypes.error) and ex.args[0] in [109, 232]: return 0 # Otherwise, raise that error. raise ex
def connect(self, timeout=0, buf_sz=0): if self.transport == Pipe.Transport.ASYNCHRONOUS: if timeout == 0: event_timeout = w32ev.INFINITE stream = self.__getOverlappedStruct() # Asynchronous named pipes return immediately! status_code = w32p.ConnectNamedPipe( self.__hPipe, stream ) if status_code != werr.ERROR_IO_PENDING: raise PipeError( 'Failed to create unsynchronous named pipe connection!', 'status_code', status_code ) self.__waitForEvent(stream, event_timeout) else: status_code = w32p.ConnectNamedPipe(self.__hPipe, None) if status_code != 0: raise PipeError( 'Failed to create synchronous named pipe connection!', 'status_code', status_code ) return 0
def start_listen(pipe_name): pipe = win32pipe.CreateNamedPipe( pipe_name, win32pipe.PIPE_ACCESS_DUPLEX, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT, 1, 65536, 65536, 0, None) # Waiting for client win32pipe.ConnectNamedPipe(pipe, None) win32pipe.SetNamedPipeHandleState( pipe, win32pipe.PIPE_READMODE_MESSAGE, None, None) while True: # Got client try: # Trying to read the message received in the pipe get_command = win32file.ReadFile(pipe, 6) decoded_message = str(get_command[1].decode()) # If the message is *STOP*, we break from the loop if decoded_message == "*STOP*": break except pywintypes.error as e: pass if pipe is not None: win32pipe.DisconnectNamedPipe(pipe) win32pipe.ConnectNamedPipe(pipe, None) win32file.CloseHandle(pipe) return
def connect(self): try: return win32pipe.ConnectNamedPipe(self.pipe, None) == 0 except WinError as e: win32api.CloseHandle(self.pipe) self.create_pipe() return win32pipe.ConnectNamedPipe(self.pipe, None) == 0
def open(self, mode='read', pipe_wait=True): wait = win32pipe.PIPE_WAIT if pipe_wait: wait = win32pipe.PIPE_WAIT else: wait = win32pipe.PIPE_NOWAIT create_file = False try: self.__fifo = win32pipe.CreateNamedPipe(rf'\\.\pipe\{self.__pipe}', win32pipe.PIPE_ACCESS_DUPLEX, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | wait, 1, 65536, 65536, 0, None) print('Waiting for the client to connect') win32pipe.ConnectNamedPipe(self.__fifo, None) print('Client connected') except pywintypes.error as err: if mode == 'read': if err.args[0] == 231: create_file = True else: raise else: raise if mode == 'read' and create_file: self.__fifo = win32file.CreateFile(rf'\\.\pipe\{self.__pipe}', win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0, None, win32file.OPEN_EXISTING, win32file.FILE_ATTRIBUTE_NORMAL, None) result = win32pipe.SetNamedPipeHandleState(self.__fifo, win32pipe.PIPE_READMODE_MESSAGE, None, None) if result == 0: raise Exception('Could not connect to any PIPE') return True
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 heart(self, lock): try: while self.flag: print("心跳") try: conn = win32pipe.ConnectNamedPipe(self.named_pipe, None) if conn: _str = tobuff(8, 202, b'{}') print(f'写入ipc管道的信息为== {_str}') with lock: win32file.WriteFile(self.named_pipe, _str) print("写入心跳结束") time.sleep(5) else: time.sleep(0.1) print("心跳命名管道还未连接") continue except BaseException as e: print("read1 exception:", e) break print("命名管道要关闭通道啦") finally: try: print('关闭通道') win32pipe.DisconnectNamedPipe(self.named_pipe) except: pass
def accept_client(self, timeout=None): """Blocks until a client connects to the server. One the client has connected, then the `write` method can be used to write to it. @param timeout: The maximum number of seconds to wait for the client to connect before raising an `RedirectorError` exception. @type timeout: float|None @return: True if a client has been connected, otherwise False. @rtype: bool """ scaled_timeout = None if timeout is not None: scaled_timeout = int(timeout * 1000) self.__pipe_handle = win32pipe.CreateNamedPipe( self.__full_pipe_name, win32pipe.PIPE_ACCESS_OUTBOUND, win32pipe.PIPE_TYPE_BYTE | win32pipe.PIPE_WAIT, 1, 65536, 65536, scaled_timeout, None, ) return win32pipe.ConnectNamedPipe(self.__pipe_handle, None) == 0
def connect_pipe(pipe, pipeName): overLap = pywintypes.OVERLAPPED() overLap.hEvent = win32event.CreateEvent(None, 1, 0, None) if overLap.hEvent == 0: raise PipeError('Could not create hEvent') try: # Wait for a pipe client connection ret = win32pipe.ConnectNamedPipe(pipe, overLap) if not ret in (0, ERROR_PIPE_CONNECTED): if ret == ERROR_IO_PENDING: ret = win32event.WaitForSingleObject( overLap.hEvent, 1000 * CONNECT_TIMEOUT_SECS) if ret != win32event.WAIT_OBJECT_0: # Timeout error raise PipeError('Timeout error') else: # API error raise PipeError('API error') ret = win32pipe.GetOverlappedResult(pipe, overLap, True) if not ret in (0, ERROR_PIPE_CONNECTED): # API Error raise PipeError('API error 2') except PipeError: # Named pipe exception win32file.CancelIo(pipe) pipe.close() raise except BaseException, err: win32file.CancelIo(pipe) pipe.close() pipe = None raise PipeError('BaseException : ' + str(err))
def open_pipe(self, pipe_name=None, num_allowed_instances=1): if pipe_name is None: pipe_name = CommunicationHandler.RLGYM_GLOBAL_PIPE_NAME if self.is_connected(): self.close_pipe() self._connected = False pool = ThreadPool(processes=1) pool.apply_async(CommunicationHandler.handle_diemwin_potential, args=[self.is_connected]) #win32pipe.PIPE_UNLIMITED_INSTANCES self._pipe = win32pipe.CreateNamedPipe( pipe_name, win32pipe.PIPE_ACCESS_DUPLEX | win32file.FILE_FLAG_OVERLAPPED, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT, num_allowed_instances, CommunicationHandler.RLGYM_DEFAULT_PIPE_SIZE, CommunicationHandler.RLGYM_DEFAULT_PIPE_SIZE, 0, None) win32pipe.ConnectNamedPipe(self._pipe) self._current_pipe_name = pipe_name self._connected = True pool.terminate() pool.join()
def pipe_server(name): pipe = win32pipe.CreateNamedPipe( name, win32pipe.PIPE_ACCESS_DUPLEX, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE, 1, 65536, 65536, 0, None) win32pipe.ConnectNamedPipe(pipe, None)
def write_to_ipc(self, data): #print (f'socket服务端收到的信息为=={data}') try: conn = win32pipe.ConnectNamedPipe(self.named_pipe, None) if conn: print("write_to_ipc 的信息为%s" % data) # print(data) if (len(data) > 0): _str = tobuff(2018, 2018, data) try: with lock: print( f'ipc管道发给互动端的信息为=={_str+bytes(data,encoding="utf-8")}' ) win32file.WriteFile( self.named_pipe, _str + bytes(data, encoding="utf-8")) print("writefile finish") except Exception as e: print("答题信息出错:%s" % e) else: _str = tobuff(8, 202, b'{}') print(f'写入ipc管道的信息为== {_str}') try: with lock: print('heart begin') win32file.WriteFile(self.named_pipe, _str) print("heart finish") except Exception as e: print("心跳出错:%s" % e) except BaseException as e: print("write_to_ipc 出错了:", e)
def Initialize(self): """ 入力パイプを初期化します。 :param self: """ ### コマンド未登録チェック if self.__comm_list__ == None: raise IpcException.IpcCommInvalidException() try: if (not (self.__is_initialize__) and not (self.__is_finalize__)): # パイプ作成 self.__pipe_in__ = win32pipe.CreateNamedPipe( r'\\.\pipe\biassys_pipeout', win32pipe.PIPE_ACCESS_INBOUND, win32pipe.PIPE_WAIT | win32pipe.PIPE_TYPE_BYTE, 1, 65536, 0, 10000, None) if self.__pipe_in__ != None: if win32pipe.ConnectNamedPipe( self.__pipe_in__) == 0: # パイプ接続確認 self.__is_initialize__ = True return True except pywintypes.error: return False return False
def connect_pipe(self): ''' struct pcap_file_header { uint32_t magic_number; /* magic number */ uint16_t version_major; /* major version number */ uint16_t version_minor; /* minor version number */ int32_t thiszone; /* GMT to local correction */ uint32_t sigfigs; /* accuracy of timestamps */ uint32_t snaplen; /* max length of captured packets, in octets */ uint32_t linktype; /* data link type */ } ''' win32pipe.ConnectNamedPipe(self.pipe, None) global_header = struct.pack( 'IHHiIII', self.magic_num, # magic number 4 self.major_ver, # major version number 2 self.minor_ver, # minor version number 2 0, # GMT to local correction 4 0, # accuracy of timestamps 4 0, # max length of captured packets, in octets 4 self.link_type # data link type 4 ) win32file.WriteFile(self.pipe, global_header)
def create(cls, name, path='', host=PIPE_LOCALHOST, blocking=True, msgLimit=0, logger=logging.getLogger("k_os.ipc"), level=logging.INFO): pname = cls.getCanoicalName(host, path, name) sa = pywintypes.SECURITY_ATTRIBUTES() instance = cls(logger, level) blockingMode = win32pipe.PIPE_WAIT if blocking else win32pipe.PIPE_NOWAIT pmode = win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | blockingMode instance.name = name instance.handle = win32pipe.CreateNamedPipe( pname, win32pipe.PIPE_ACCESS_DUPLEX, pmode, win32pipe.PIPE_UNLIMITED_INSTANCES, 100, 100, win32pipe.NMPWAIT_USE_DEFAULT_WAIT, sa) NamedPipeServer.numberOfInstances += 1 instance._logger.debug("Created NamedPipe '%s'." % pname) instance._logger.debug("Current # of instances = %u." % NamedPipeServer.numberOfInstances) res = win32pipe.ConnectNamedPipe(instance.handle, None) instance._logger.debug("Client connected to NamedPipe.") return instance
def send_event_thread(): event_buffer = [str(i) + "\n" for i in range(300)] event_buffer[-1] = event_buffer[-1][:-1] pipe = win32pipe.CreateNamedPipe( "\\\\.\\pipe\\" + PIPE_NAME, win32pipe.PIPE_ACCESS_DUPLEX, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT, 1, 65536, 65536, 0, None ) try: print("Waiting for client...\n") win32pipe.ConnectNamedPipe(pipe, None) print("Client connected.\n") while True: text = win32file.ReadFile(pipe, 64*1024) print(text) finally: win32file.CloseHandle(pipe)
def open(name, options): if options == os.O_WRONLY: opt = win32file.GENERIC_WRITE dbg("open %s GENERIC_WRITE" % (name)) else: opt = win32file.GENERIC_READ dbg("open %s GENERIC_READ" % (name)) fileName = PIPE_PREFIX % name fileName = fileName.replace("\\", "/") fileName = fileName.replace(":", "_") try: overlapped = pywintypes.OVERLAPPED() #TODO: this check is more a workaround than a real solution! if name in PIPE_HANDLES: pipe_handle = PIPE_HANDLES[name] overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None) rc = win32pipe.ConnectNamedPipe(pipe_handle, overlapped) if rc == winerror.ERROR_PIPE_CONNECTED: win32event.SetEvent(overlapped.hEvent) return FileIO(pipe_handle, fileName, overlapped, opt, True) else: wh = win32file.CreateFile(fileName, opt, 0, None, win32file.OPEN_EXISTING, win32file.FILE_FLAG_OVERLAPPED, None) #dbg("SetNamedPipeHandleState %s" % wh) #win32pipe.SetNamedPipeHandleState(wh, # win32pipe.PIPE_READMODE_BYTE, None, None) overlapped.hEvent = win32event.CreateEvent(None, 0, 0, None) return FileIO(wh, fileName, overlapped, opt, False) except: raise
def run(self): import win32pipe, win32file, winerror, win32api def as_unicode(err): try: self.err_msg = type('')(err) except Exception: self.err_msg = repr(err) try: try: rc = win32pipe.ConnectNamedPipe(self.pipe_handle) except Exception as err: as_unicode(err) return if rc != 0: self.err_msg = 'Failed to connect to client over named pipe: 0x%x' % rc return while True: try: hr, data = win32file.ReadFile(self.pipe_handle, 1024 * 50, None) except Exception as err: if getattr(err, 'winerror', None) == winerror.ERROR_BROKEN_PIPE: break # pipe was closed at the other end as_unicode(err) break if hr not in (winerror.ERROR_MORE_DATA, 0): self.err_msg = 'ReadFile on pipe failed with hr=%d' % hr break if not data: break self.data += data finally: win32api.CloseHandle(self.pipe_handle) self.pipe_handle = None
def __send_buffer_thread_windows(self): event_queue_pipe = win32pipe.CreateNamedPipe( "\\\\.\\pipe\\" + self.__EVENT_QUEUE_PIPE_NAME, win32pipe.PIPE_ACCESS_DUPLEX, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_BYTE | win32pipe.PIPE_WAIT, 1, 65536, 65536, 0, None) win32pipe.ConnectNamedPipe(event_queue_pipe, None) self.__connection_lock.acquire() self.__send_connected = True self.__connection_lock.notify_all() self.__connection_lock.release() while len(self.__event_buffer) > 0 or not self.__should_destroy: with self.__event_buffer_lock: message = self.__EVENT_SEPARATOR.join( self.__event_buffer) + "\n" self.__event_buffer = [] if message != "\n": win32file.WriteFile(event_queue_pipe, bytes(message, "ascii")) time.sleep(self.__SEND_INTERVAL)
def __get_robot_state_thread_windows(self): info_pipe = win32pipe.CreateNamedPipe( "\\\\.\\pipe\\" + self.__INFO_PIPE_NAME, win32pipe.PIPE_ACCESS_DUPLEX, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_BYTE | win32pipe.PIPE_WAIT, 1, 65536, 65536, 0, None) win32pipe.ConnectNamedPipe(info_pipe, None) while not self.__should_destroy: info_text = utility.get_most_recent_message_windows(info_pipe) tmp_dict = json.loads(info_text) self.__info_dict = tmp_dict tmp_info = RobotInfo(self.__info_dict) if self.info: tmp_info.coordinates_are_inverted = self.info.coordinates_are_inverted self.info = tmp_info if not self.__get_connected: self.__connection_lock.acquire() self.__get_connected = True self.__connection_lock.notify_all() self.__connection_lock.release() time.sleep(self.__GET_INTERVAL)
def pipe_ws(string): print("pipe server") pipe = win32pipe.CreateNamedPipe( r'\\.\pipe\Foo', # name of pipe win32pipe.PIPE_ACCESS_DUPLEX, # openmode win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT, #pipe mode 1, 65536, 65536, # nMaxinstances , nOutBufferSize , nInbufferSize 0, # nDrfaultTimeOut None) # pysecurity attributes try: print("waiting for client") win32pipe.ConnectNamedPipe( pipe, # handle None) # overlapped print("got client") #print(f"writing message {count}") # convert to bytes data = header.yHdr_ws(string) #print(f"data to send : {data}") win32file.WriteFile(pipe, data) #win32file.WriteFile(pipe, b'hello pipe...!') time.sleep(1) print("finished now") finally: win32file.CloseHandle(pipe)
def get_mouse_data(): import win32file import win32pipe PIPE_NAME = r'\\.\pipe\test_pipe' PIPE_BUFFER_SIZE = 1 while True: named_pipe = win32pipe.CreateNamedPipe( PIPE_NAME, win32pipe.PIPE_ACCESS_DUPLEX, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_WAIT | win32pipe.PIPE_READMODE_MESSAGE, win32pipe.PIPE_UNLIMITED_INSTANCES, PIPE_BUFFER_SIZE, PIPE_BUFFER_SIZE, 500, None) while True: try: win32pipe.ConnectNamedPipe(named_pipe, None) data = win32file.ReadFile(named_pipe, PIPE_BUFFER_SIZE, None) # if data is None or len(data) < 2: # continue print('receive msg:', int.from_bytes(data[1], 'big')) except BaseException as e: print("exception:", e) break win32pipe.DisconnectNamedPipe(named_pipe)
def main(): while True: #create pipe in windows pipe = create_winpipe() #wait until client(game) is started print(">>waiting for client") win32pipe.ConnectNamedPipe(pipe, None) print(">>got client, connecting to host") #connect to socat host try: sock = socket.create_connection((HOST,PORT)) except (ConnectionRefusedError, socket.gaierror): print(">>couldn't connect to host, check config") sys.exit() print(">>connected, starting loop") #start the connection loop request_loop(pipe, sock) #close the windows pipe and socket so new ones can be created win32file.CloseHandle(pipe) sock.close()
def pipe_server(): """ create a server pipe to read and write file from and to the client """ print("pipe server") pipe = win32pipe.CreateNamedPipe( r'\\.\pipe\Foo', win32pipe.PIPE_ACCESS_DUPLEX, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT, 1, 65536, 65536, 0, None) try: print("waiting for client") win32pipe.ConnectNamedPipe(pipe, None) print("got client") while True: # convert to bytes answer = random.choice(responses) print(f"The Magic 8 Ball says: {answer}") some_data = str.encode(f"{answer}") win32file.WriteFile(pipe, some_data) time.sleep(1) finally: win32file.CloseHandle(pipe)
def server(name, callback_func): buffer = 4096 timeout = 1000 error = False while True: if error: time.sleep(1) error = False handle = win32pipe.CreateNamedPipe( name, win32pipe.PIPE_ACCESS_INBOUND, win32pipe.PIPE_TYPE_BYTE | win32pipe.PIPE_READMODE_BYTE | win32pipe.PIPE_WAIT, win32pipe.PIPE_UNLIMITED_INSTANCES, buffer, buffer, timeout, None) if handle == win32file.INVALID_HANDLE_VALUE: error = True continue try: if win32pipe.ConnectNamedPipe(handle) != 0: error = True else: code, message = win32file.ReadFile(handle, buffer, None) if code == 0: callback_func(message) else: error = True except Exception: error = True finally: win32pipe.DisconnectNamedPipe(handle) win32file.CloseHandle(handle)
def send_pipe(): print("pipe server") count = 0 pipe = win32pipe.CreateNamedPipe( r'\\.\pipe\Foo', # name of pipe win32pipe.PIPE_ACCESS_DUPLEX, # openmode win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT, # pipe mode 1, 65536, 65536, # nMaxinstances , nOutBufferSize , nInbufferSize 0, # nDrfaultTimeOut None) # pysecurity attributes try: print("waiting for client") win32pipe.ConnectNamedPipe(pipe, # handle None) # overlapped print("got client") while count < 10: print(f"writing message {count}") some_data = str.encode(f"{count}") # byte로 인코딩 win32file.WriteFile(pipe, some_data) time.sleep(1) count += 1 print("finished now") finally: win32file.CloseHandle(pipe)
def _StartMsrServerIfNeeded(self): if self._msr_server_handle: return _InstallWinRing0() pipe_name = r"\\.\pipe\msr_server_pipe_{}".format(os.getpid()) # Try to open a named pipe to receive a msr port number from server process. pipe = win32pipe.CreateNamedPipe( pipe_name, win32pipe.PIPE_ACCESS_INBOUND, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_WAIT, 1, 32, 32, 300, None) parameters = ( os.path.join(os.path.dirname(__file__), 'msr_server_win.py'), pipe_name, ) self._msr_server_handle = self.LaunchApplication( sys.executable, parameters, elevate_privilege=True) if pipe != win32file.INVALID_HANDLE_VALUE: if win32pipe.ConnectNamedPipe(pipe, None) == 0: self._msr_server_port = int(win32file.ReadFile(pipe, 32)[1]) win32api.CloseHandle(pipe) # Wait for server to start. try: socket.create_connection(('127.0.0.1', self._msr_server_port), 5).close() except socket.error: self.CloseMsrServer() atexit_with_log.Register(TerminateProcess, self._msr_server_handle)
def start(self): '''Start the handler''' win32pipe.ConnectNamedPipe(self.pipe, None) if not self.link_type_tap: win32file.WriteFile(self.pipe, PCAP_HDR_BYTES_1) else: win32file.WriteFile(self.pipe, PCAP_HDR_BYTES_2)
def pipe_server(): print("pipe server") reader = win32pipe.CreateNamedPipe( r'\\.\pipe\setPassword', win32pipe.PIPE_ACCESS_DUPLEX, win32pipe.PIPE_TYPE_MESSAGE | win32pipe.PIPE_READMODE_MESSAGE | win32pipe.PIPE_WAIT, 1, 65536, 65536, 0, None) try: print("waiting for client") sys.stdout.flush() win32pipe.ConnectNamedPipe(reader, None) print("got client") resp = win32file.ReadFile(reader, 64 * 1024) my_json = resp[1].decode('utf8').replace("'", '"') result = client.execute(my_json) json_obj = json.loads(result) print(json_obj) res = json_obj['data']['update_user'] some_data = str.encode(f"{res}") win32file.WriteFile(reader, some_data) print("finished now") finally: win32file.CloseHandle(reader)
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)