我们从Python开源项目中，提取了以下33个代码示例，用于说明如何使用errno.EISCONN。
def connect(self, ip, port): """ Estabilishes a connection to IP:port. :param ip: the IP to connect to. :param port: the port to connect to. """ try: self.conn.connect(ip, port) except OSError as e: if e.errno == errno.EISCONN: return # Already connected, no need to re-set everything up else: raise self._send_counter = 0 if self._mode == ConnectionMode.TCP_ABRIDGED: self.conn.write(b'\xef') elif self._mode == ConnectionMode.TCP_INTERMEDIATE: self.conn.write(b'\xee\xee\xee\xee') elif self._mode == ConnectionMode.TCP_OBFUSCATED: self._setup_obfuscation()
def __init__(self, head = HEAD_WORD_LSB): self.sock = None # socket object self.send_buf = '' # send buffer self.recv_buf = '' # recv buffer self.state = NET_STATE_STOP self.errd = [ errno.EINPROGRESS, errno.EALREADY, errno.EWOULDBLOCK ] self.conn = ( errno.EISCONN, 10057, 10053 ) self.errc = 0 self.headmsk = False self.headraw = False self.__head_init(head) self.crypts = None self.cryptr = None self.ipv6 = False self.eintr = () if 'EINTR' in errno.__dict__: self.eintr = (errno.__dict__['EINTR'],) if 'WSAEWOULDBLOCK' in errno.__dict__: self.errd.append(errno.WSAEWOULDBLOCK) self.errd = tuple(self.errd) self.block = False
def connectThread(self): while not self.connected: try: self.client.connect((HOST, PORT)) except socket.error as e: pass finally: if e.errno == errno.EINPROGRESS: time.sleep(1.0) elif e.errno == errno.ECONNREFUSED: time.sleep(1.0) elif e.errno == errno.EALREADY: time.sleep(1.0) elif e.errno == errno.EINVAL: break elif e.errno == errno.EISCONN: logger.log("[button]: Connected to Artoo.") self.connected = True self.buttonsInitialized = False else: logger.log("[button]: Unexpected socket exception: %s" % e) time.sleep(1.0)
def _connect(self, sock, sa): while not self._canceled and not ABORT_FLAG_FUNCTION(): time.sleep(0.01) self._check_timeout() # this should be done at the beginning of each loop status = sock.connect_ex(sa) if not status or status in (errno.EISCONN, WIN_EISCONN): break elif status in (errno.EINPROGRESS, WIN_EWOULDBLOCK): self.deadline = time.time() + self._timeout.getConnectTimeout() # elif status in (errno.EWOULDBLOCK, errno.EALREADY) or (os.name == 'nt' and status == errno.WSAEINVAL): # pass yield if self._canceled or ABORT_FLAG_FUNCTION(): raise CanceledException('Request canceled') error = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR) if error: # TODO: determine when this case can actually happen raise socket.error((error,))
def __init__ (self): self.sock = None # socket object self.send_buf = [] # send buffer self.recv_buf = [] # recv buffer self.pend_buf = '' # send pending self.state = NET_STATE_CLOSED self.errd = [ errno.EINPROGRESS, errno.EALREADY, errno.EWOULDBLOCK ] self.conn = ( errno.EISCONN, 10057, 10053 ) self.errc = 0 self.ipv6 = False self.eintr = () if 'EINTR' in errno.__dict__: self.eintr = (errno.__dict__['EINTR'],) if 'WSAEWOULDBLOCK' in errno.__dict__: self.errd.append(errno.WSAEWOULDBLOCK) self.errd = tuple(self.errd) self.timeout = 0 self.timecon = 0
def connect(self, *addr): timeout = self.timeout sock = self.sock try: # Non-blocking mode sock.setblocking(0) sock.connect(*addr) sock.setblocking(timeout != 0) return 1 except socket.error,why: if not timeout: raise sock.setblocking(1) if len(why.args) == 1: code = 0 else: code, why = why if code not in ( errno.EINPROGRESS, errno.EALREADY, errno.EWOULDBLOCK ): raise _,w,_ = select.select([],[sock],[],timeout) if w: try: sock.connect(*addr) return 1 except socket.error,why: if len(why.args) == 1: code = 0 else: code, why = why if code in (errno.EISCONN, WSAEINVAL): return 1 raise raise TimeoutError('socket connect() timeout.')
def connect(self, *addr): timeout = self.timeout sock = self.sock try: # Non-blocking mode sock.setblocking(0) apply(sock.connect, addr) sock.setblocking(timeout != 0) return 1 except socket.error,why: if not timeout: raise sock.setblocking(1) if len(why.args) == 1: code = 0 else: code, why = why if code not in ( errno.EINPROGRESS, errno.EALREADY, errno.EWOULDBLOCK ): raise r,w,e = select.select([],[sock],[],timeout) if w: try: apply(sock.connect, addr) return 1 except socket.error,why: if len(why.args) == 1: code = 0 else: code, why = why if code in (errno.EISCONN, WSAEINVAL): return 1 raise raise TimeoutError('socket connect() timeout.')
def connect(self, dest): with self.lock: if not self.state.CLOSED: self.err("connect() in socket state {0}".format(self.state)) if self.state.ESTABLISHED: raise err.Error(errno.EISCONN) if self.state.CONNECT: raise err.Error(errno.EALREADY) raise err.Error(errno.EPIPE) if isinstance(dest, (bytes, bytearray)): send_pdu = pdu.Connect(1, self.addr, self.recv_miu, self.recv_win, bytes(dest)) elif isinstance(dest, int): send_pdu = pdu.Connect(dest, self.addr, self.recv_miu, self.recv_win) else: raise TypeError("connect destination must be int or bytes") self.state.CONNECT = True self.send_queue.append(send_pdu) try: rcvd_pdu = super(DataLinkConnection, self).recv() except IndexError: raise err.Error(errno.EPIPE) if rcvd_pdu.name == "DM": logstr = "connect rejected with reason {}" self.log(logstr.format(rcvd_pdu.reason)) self.state.CLOSED = True raise err.ConnectRefused(rcvd_pdu.reason) elif rcvd_pdu.name == "CC": self.peer = rcvd_pdu.ssap self.recv_buf = self.recv_win self.send_miu = rcvd_pdu.miu self.send_win = rcvd_pdu.rw self.state.ESTABLISHED = True return else: # pragma: no cover raise RuntimeError("CC or DM expected, not " + rcvd_pdu.name)
def connect(self, address): if self.timeout == 0.0: return self._sock.connect(address) sock = self._sock if isinstance(address, tuple): r = getaddrinfo(address[0], address[1], sock.family, sock.type, sock.proto) address = r[0][-1] if self.timeout is not None: timer = Timeout.start_new(self.timeout, timeout('timed out')) else: timer = None try: while True: err = sock.getsockopt(SOL_SOCKET, SO_ERROR) if err: raise error(err, strerror(err)) result = sock.connect_ex(address) if not result or result == EISCONN: break elif (result in (EWOULDBLOCK, EINPROGRESS, EALREADY)) or (result == EINVAL and is_windows): self._wait(self._write_event) else: raise error(result, strerror(result)) finally: if timer is not None: timer.cancel()
def connect(self, address): if isinstance(address, tuple) and len(address) == 2: address = gethostbyname(address[0]), address[1] if self.timeout == 0.0: return self._sock.connect(address) sock = self._sock if self.timeout is None: while True: err = sock.getsockopt(SOL_SOCKET, SO_ERROR) if err: raise error(err, strerror(err)) result = sock.connect_ex(address) if not result or result == EISCONN: break elif (result in (EWOULDBLOCK, EINPROGRESS, EALREADY)) or (result == EINVAL and is_windows): wait_readwrite(sock.fileno(), event=self._rw_event) else: raise error(result, strerror(result)) else: end = time.time() + self.timeout while True: err = sock.getsockopt(SOL_SOCKET, SO_ERROR) if err: raise error(err, strerror(err)) result = sock.connect_ex(address) if not result or result == EISCONN: break elif (result in (EWOULDBLOCK, EINPROGRESS, EALREADY)) or (result == EINVAL and is_windows): timeleft = end - time.time() if timeleft <= 0: raise timeout('timed out') wait_readwrite(sock.fileno(), timeout=timeleft, event=self._rw_event) else: raise error(result, strerror(result))
def connect(self, dest): with self.lock: if not self.state.CLOSED: self.err("connect() in socket state {0}".format(self.state)) if self.state.ESTABLISHED: raise Error(errno.EISCONN) if self.state.CONNECT: raise Error(errno.EALREADY) raise Error(errno.EPIPE) if type(dest) is StringType: pdu = Connect(1, self.addr, self.recv_miu, self.recv_win, dest) elif type(dest) is IntType: pdu = Connect(dest, self.addr, self.recv_miu, self.recv_win) else: raise TypeError("connect() arg *dest* must be int or string") self.state.CONNECT = True self.send_queue.append(pdu) try: pdu = super(DataLinkConnection, self).recv() except IndexError: raise Error(errno.EPIPE) if isinstance(pdu, DisconnectedMode): self.log("connect rejected with reason {0}".format(pdu.reason)) self.state.CLOSED = True raise ConnectRefused(pdu.reason) if isinstance(pdu, ConnectionComplete): self.peer = pdu.ssap self.recv_buf = self.recv_win self.send_miu = pdu.miu self.send_win = pdu.rw self.state.ESTABLISHED = True return raise RuntimeError("only CC or DM expected, not " + pdu.name)
def connect(self, user=None, password=None): "Connect to the server" if not self._alive: self._last_user = user self._last_pass = password try: log.i("Client connecting to server at: {}".format(self._server)) try: self._sock.connect(self._server) except socket.error as e: if e.errno == errno.EISCONN and self.session: # already connected self._alive = True return else: raise self._alive = True if not self.session: self._handshake(self._recv(), user, password) else: self._accepted = True self._recv() except socket.error as e: self._disconnect() raise exceptions.ServerDisconnectError( self.name, "{}".format(e))
def doConnect(self): """I connect the socket. Then, call the protocol's makeConnection, and start waiting for data. """ if not hasattr(self, "connector"): # this happens when connection failed but doConnect # was scheduled via a callLater in self._finishInit return err = self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR) if err: self.failIfNotConnected(error.getConnectError((err, os.strerror(err)))) return # doConnect gets called twice. The first time we actually need to # start the connection attempt. The second time we don't really # want to (SO_ERROR above will have taken care of any errors, and if # it reported none, the mere fact that doConnect was called again is # sufficient to indicate that the connection has succeeded), but it # is not /particularly/ detrimental to do so. This should get # cleaned up some day, though. try: connectResult = self.socket.connect_ex(self.realAddress) except socket.error, se: connectResult = se.args[0] if connectResult: if connectResult == EISCONN: pass # on Windows EINVAL means sometimes that we should keep trying: # http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winsock/winsock/connect_2.asp elif ((connectResult in (EWOULDBLOCK, EINPROGRESS, EALREADY)) or (connectResult == EINVAL and platformType == "win32")): self.startReading() self.startWriting() return else: self.failIfNotConnected(error.getConnectError((connectResult, os.strerror(connectResult)))) return # If I have reached this point without raising or returning, that means # that the socket is connected. del self.doWrite del self.doRead # we first stop and then start, to reset any references to the old doRead self.stopReading() self.stopWriting() self._connectDone()
def connect(self, address, _hostname_hint=None): """connect(address) Connect the socket to a remote address. For IP sockets, the address is a pair (host, port). """ if not self._created: if self.gettimeout() is None: self._CreateSocket(address=address, address_hostname_hint=_hostname_hint) return else: self._CreateSocket() if not self._socket_descriptor: raise error(errno.EBADF, os.strerror(errno.EBADF)) if self._connected: raise error(errno.EISCONN, os.strerror(errno.EISCONN)) request = remote_socket_service_pb.ConnectRequest() request.set_socket_descriptor(self._socket_descriptor) self._SetProtoFromAddr(request.mutable_remote_ip(), address, _hostname_hint) if self.gettimeout() is not None: request.set_timeout_seconds(self.gettimeout()) reply = remote_socket_service_pb.ConnectReply() try: apiproxy_stub_map.MakeSyncCall('remote_socket', 'Connect', request, reply) except apiproxy_errors.ApplicationError, e: translated_e = _SystemExceptionFromAppError(e) if translated_e.errno == errno.EISCONN: self._bound = True self._connected = True elif translated_e.errno == errno.EINPROGRESS: self._connect_in_progress = True raise translated_e self._bound = True self._connected = True
def sendto(self, data, *args): """sendto(data[, flags], address) -> count Like send(data, flags) but allows specifying the destination address. For IP sockets, the address is a pair (hostaddr, port). """ if len(args) == 1: flags, address = 0, args[0] elif len(args) == 2: flags, address = args if not self._created: self._CreateSocket() if not self._socket_descriptor: raise error(errno.EBADF, os.strerror(errno.EBADF)) if self._shutdown_write: raise error(errno.EPIPE, os.strerror(errno.EPIPE)) request = remote_socket_service_pb.SendRequest() request.set_socket_descriptor(self._socket_descriptor) if len(data) > 512*1024: request.set_data(data[:512*1024]) else: request.set_data(data) request.set_flags(flags) request.set_stream_offset(self._stream_offset) if address: if self._connected: raise error(errno.EISCONN, os.strerror(errno.EISCONN)) if self.type != SOCK_DGRAM: raise error(errno.ENOTCONN, os.strerror(errno.ENOTCONN)) self._SetProtoFromAddr(request.mutable_send_to(), address) else: if not (self._connected or self._connect_in_progress): raise error(errno.ENOTCONN, os.strerror(errno.ENOTCONN)) if self.gettimeout() is not None: request.set_timeout_seconds(self.gettimeout()) reply = remote_socket_service_pb.SendReply() try: apiproxy_stub_map.MakeSyncCall('remote_socket', 'Send', request, reply) except apiproxy_errors.ApplicationError, e: raise _SystemExceptionFromAppError(e) if self._connect_in_progress: self._connect_in_progress = False self._connected = True nbytes = reply.data_sent() assert nbytes >= 0 if self.type == SOCK_STREAM: self._stream_offset += nbytes return nbytes
def doConnect(self): """ Initiate the outgoing connection attempt. @note: Applications do not need to call this method; it will be invoked internally as part of L{IReactorTCP.connectTCP}. """ self.doWrite = self.doConnect self.doRead = self.doConnect if not hasattr(self, "connector"): # this happens when connection failed but doConnect # was scheduled via a callLater in self._finishInit return err = self.socket.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR) if err: self.failIfNotConnected(error.getConnectError((err, strerror(err)))) return # doConnect gets called twice. The first time we actually need to # start the connection attempt. The second time we don't really # want to (SO_ERROR above will have taken care of any errors, and if # it reported none, the mere fact that doConnect was called again is # sufficient to indicate that the connection has succeeded), but it # is not /particularly/ detrimental to do so. This should get # cleaned up some day, though. try: connectResult = self.socket.connect_ex(self.realAddress) except socket.error as se: connectResult = se.args[0] if connectResult: if connectResult == EISCONN: pass # on Windows EINVAL means sometimes that we should keep trying: # http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winsock/winsock/connect_2.asp elif ((connectResult in (EWOULDBLOCK, EINPROGRESS, EALREADY)) or (connectResult == EINVAL and platformType == "win32")): self.startReading() self.startWriting() return else: self.failIfNotConnected(error.getConnectError((connectResult, strerror(connectResult)))) return # If I have reached this point without raising or returning, that means # that the socket is connected. del self.doWrite del self.doRead # we first stop and then start, to reset any references to the old doRead self.stopReading() self.stopWriting() self._connectDone()
