def _send_socket(self, cmd, rtnCmd, ip, port): socket = self._socket try: _LOGGER.debug('Sending to GW {0}'.format(cmd)) self._read_unwanted_data() socket.settimeout(30.0) socket.sendto(cmd.encode(), (ip, port)) socket.settimeout(30.0) data, addr = socket.recvfrom(1024) if len(data) is not None: resp = json.loads(data.decode()) _LOGGER.debug('Recieved from GW {0}'.format(resp)) if resp["cmd"] == rtnCmd: return resp else: _LOGGER.error( "Response from {0} does not match return cmd".format( ip)) _LOGGER.error(data) else: _LOGGER.error("No response from Gateway") except socket.timeout: _LOGGER.error("Cannot connect to Gateway") socket.close()
def run(self): if self.timeout: socket.settimeout(self.timeout) while self.connected: try: recv=self.channel.recv(1024) if recv: new=b'' for r in recv: if not r ==b'\0': new+=r elif r==b'\0': newmsg=msg(new[:5],new[5:-5],new[-5]) MGSS.append(newmsg) self.OnMsgRecv(newmsg) new=b'' newmsg=0 ## Errors ## except socket.error as e: if e.errno==errno.ETIMEDOUT: continue else: self.connected=False except socket.herror as e: error_report(e) self.channel.close() self.connected=False
def connect(self): # Initialize context self.socket = None if self.secure: client_pfile, client_cert_file, ca_cert_file = self.secure #server_pkey=crypto.load_privatekey(crypto.FILETYPE_PEM,server_ptext) #server_cert=crypto.load_certificate(crypto.FILETYPE_PEM,server_cert_text) #ca_cert=crypto.load_certificate(crypto.FILETYPE_PEM,ca_cert_text) ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.set_verify(SSL.VERIFY_PEER, verify_client_certificate) # Demand a certificate #ctx.use_privatekey(server_pkey) #ctx.use_certificate(server_cert) #ctx.use_verify_locations(ca_cert) ctx.use_privatekey_file(client_pfile) ctx.use_certificate_file(client_cert_file) ctx.load_verify_locations(ca_cert_file) self.socket = SSL.Connection( ctx, socket.socket(socket.AF_INET, socket.SOCK_STREAM)) else: self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) if self.timeout and socket != None: try: socket.settimeout(self.timeout) except: pass self.socket.connect((self.hostname, self.port)) register_cmd = (0, "Register_Client", (os.environ["USER"], os.environ["HOSTNAME"])) self.queueCmd(register_cmd)
def sendFile(fname, socket): blockSize = 32000 msg = '' try: source = open(fname, 'rb') sizeBytes = os.path.getsize(fname) utils.log('Sending file ' + fname + ' of ' + str(sizeBytes) + ' bytes') bytesOut = 0 start = utils.getUTCTime() prev = 0 for data in utils.chunked(source, blockSize): utils.log('sending data ' + str(len(data))) socket.sendall(data) bytesOut += len(data) if (bytesOut - sizeBytes) > 1024: utils.log('WARNING - truncating send because send file appears to be growing.') break; diff = utils.getSecondsBetweenTwoDates(start, utils.getUTCTime()) diff = (int(diff/30))*30 if diff > prev: prev = diff utils.log('So far sent ' + str(bytesOut) + ' read') utils.log('Completed send of ' + str(bytesOut) + ' bytes') socket.settimeout(20) c = socket.recv(4096) utils.log('Received ' + repr(c)) return msg #except(socket.error): #utils.log("timeout in sendFile - possibly no received confirmation data") except Exception, errorcode: if errorcode[0] != "timed out": utils.logTrace('Exception ' + repr(errorcode))
def __init__(self, socket, buffer): self.__dict__['_socket'] = socket self.__dict__['_buffer'] = buffer self.__dict__['_io_refs'] = 0 self.__dict__['_closed'] = False self.__dict__['_timeout'] = socket.gettimeout() # We are setting the socket timeout to zero here, regardless of what it # was before, because we want to operate the socket in non-blocking # mode. This requires some context. # # Python sockets have three modes: blocking, non-blocking, and timeout. # However, "real" (OS-level) sockets only have two: blocking and # non-blocking. Internally, Python builds sockets with timeouts by # using the select syscall to implement the timeout. # # We would also like to use select (and friends) in this wrapped # socket, so that we can ensure that timeouts apply per # ``send``/``recv`` call, as they do with normal Python sockets. # However, if we did that without setting the socket timeout to zero # we'd end up with *two* selectors for each socket: one used in this # class, and one used in the socket. That's gloriously silly. So # instead we take responsibility for managing the socket timeout # ourselves. socket.settimeout(0)
def threadPool(self, socket): self.newslot.acquire() while self.tcount >= self.MaxThreads: self.newslot.wait() # wait for new client slots self.tcount += 1 # update client counts self.newslot.release() while 1: socket.settimeout( 10 ) # set and update timeout at setup or after every input received try: strings = socket.recv( 1024) # try to recive input if connection is still valid while len(strings) > 0: strings = eval_input( strings, socket) # parsing, checking and operating commands except: self.newslot.acquire() self.tcount += -1 # update client counts when clients drop out self.newslot.notify( ) # notify a waiting client for the new slot avaliable self.newslot.release() socket.sendall('connection closed: timed out\n') socket.close() print('Disconnect one inactive connection.\n') break
def recv(socket, size): '''Recieve and decode data''' try: socket.settimeout(0) recvd = socket.recv(size) byteArray = recvd if len(byteArray) > 0: datalength = byteArray[1] & 127 indexFirstMask = 2 if datalength == 126: indexFirstMask = 4 elif datalength == 127: indexFirstMask = 10 masks = [m for m in byteArray[indexFirstMask : indexFirstMask+4]] indexFirstDataByte = indexFirstMask + 4 decodedChars = [] i = indexFirstDataByte j = 0 while i < len(byteArray): decodedChars.append( chr(byteArray[i] ^ masks[j % 4]) ) i += 1 j += 1 ret = u''.join(decodedChars).encode('utf-8') print('\033[32m' + ret.decode('utf-8') + '\033[0m') return ret else: return None except BlockingIOError: return None except TimeoutError: return None
def send_data(data, socket, timeout=None): if timeout is not None and timeout < 0: raise Exception("Timeout cannot be lower than 0") msg = pickle.dumps(data) msg = bytes(f"{len(msg):<{HEADERSIZE}}", 'utf-8') + msg socket.settimeout(timeout) socket.sendall(msg)
def __init__(self, asyncSocketsPool, socket, recvBufSlot=None, sendBufSlot=None): if type(self) is XAsyncSocket: raise XAsyncSocketException( 'XAsyncSocket is an abstract class and must be implemented.') self._asyncSocketsPool = asyncSocketsPool self._socket = socket self._recvBufSlot = recvBufSlot self._sendBufSlot = sendBufSlot self._expireTimeSec = None self._state = None self._onClosed = None try: socket.settimeout(0) socket.setblocking(0) if (recvBufSlot is not None and type(recvBufSlot) is not XBufferSlot) or \ (sendBufSlot is not None and type(sendBufSlot) is not XBufferSlot) : raise Exception() asyncSocketsPool.AddAsyncSocket(self) except: raise XAsyncSocketException( 'XAsyncSocket : Arguments are incorrects.')
def check(): try: newstatus = [] #pick a timeout fast so that it can finish within (freq) seconds socket.settimeout(self.timeout) #perform a check on the ports for port in self.ports: #create socket to check port active = socket.socket(socket.AF_INET, socket.SOCK_STREAM) if (sock.connect_ex((self.host, port))): #nonzero return means closed newstatus.append(False) else: #zero means it's open newstatus.append(True) #close socket to check port active.close() except socket.error: #socket may have other errors I'm not expecting, but... log.error("Couldn't (re)connect to server at " + self.host) #to represent this error to any API newstatus = "connection error" finally: #update variables self.safe = False tmp = self.status self.status = newstatus self.prev = tmp self.safe = True
def run(self): """ Run the loop """ while True: readable, writable, exceptable = select.select( self.INPUTS, self.INPUTS, []) for socket in readable: # receive data from socket socket.settimeout(5) data = socket.recv(1024) socket.settimeout(None) # there is data to be received if data: # check the data data = data.decode("utf-8") print(data) self.check_data(data) # register on server if not self.CONNECTED_SERVER: self.handshake() # join a channel if self.CONNECTED_SERVER and not self.JOINED: self.join() # listen for commands if self.CONNECTED_SERVER and self.JOINED and not self.PONG: self.cmds(data) # connection was closed else: self.CONNECTED_SOCKET = False for socket in writable: try: # get the msg next_msg = self.MESSAGES[socket].get_nowait() except queue.Empty: # shutdown if self.SHUTDOWN: sys.exit(0) # redo handshake and close socket if self.MIGRATE: self.handshake() self.MIGRATE = False self.OLD_SCKT.close() continue else: # send the msg socket.send(next_msg)
def check(): try: newstatus=[] #pick a timeout fast so that it can finish within (freq) seconds socket.settimeout(self.timeout) #perform a check on the ports for port in self.ports: #create socket to check port active = socket.socket(socket.AF_INET, socket.SOCK_STREAM) if(sock.connect_ex((self.host, port))): #nonzero return means closed newstatus.append(False) else: #zero means it's open newstatus.append(True) #close socket to check port active.close() except socket.error: #socket may have other errors I'm not expecting, but... log.error("Couldn't (re)connect to server at " + self.host) #to represent this error to any API newstatus="connection error" finally: #update variables self.safe=False tmp=self.status self.status=newstatus self.prev=tmp self.safe=True
def listen(self, count): self.sock.listen(count) #пауза socket.settimeout(0.1) logging.info("Server is listenning")
def connectTo(peer): socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM) socket.settimeout(10) try: socket.connect(peer) except: return False return True
def __init__(self, socket, target_obj): self.socket = socket if socket.timeout is None: socket.settimeout(.1) self.target_obj = weakref.ref(target_obj) self.thread = threading.Thread(target=self, daemon=True) self.thread.start() self.poison_ev = threading.Event()
def do_check(nowip, condition): result = False import OpenSSL import socket import re context = OpenSSL.SSL.Context(OpenSSL.SSL.TLSv1_METHOD) socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) socket.settimeout(1) connection = OpenSSL.SSL.Connection(context, socket) if condition["sni"]: connection.set_tlsext_host_name(condition["host"]) try: connection.connect( (nowip, condition["port"])) except KeyboardInterrupt: exit() except: print(nowip + " Error") return connection.setblocking(True) try: connection.do_handshake() except KeyboardInterrupt: exit() except OpenSSL.SSL.WantReadError: print(nowip + " Timeout") return except: print(nowip + " Error") return cert = connection.get_peer_certificate() data = [] for no in range(0, cert.get_extension_count()): if cert.get_extension(no).get_short_name() != b"subjectAltName": continue data = re.sub( r"\\[\s\S]", "#", re.sub( r"\\x[0-9a-zA-Z]{2}", "#", (str(cert.get_extension(no).get_data()) .replace(r"b\"", "").replace("\"", "") .replace(r"b'", "") .replace(r"'", "").replace("\\\\", "\\")))).split("#") for item in data: if item != "" and item != "0": if item.find(condition["common_name_has"]) != -1: print(nowip + " True, DNS Name=" + item) result = True else: print(nowip + " False, DNS Name=" + item) if len(data) == 0: certname = OpenSSL.crypto.X509Name(cert.get_subject()) if certname.commonName.find(condition["common_name_has"]) != -1: print(nowip + " True, CN=" + certname.commonName) result = True else: print(nowip + " False, CN=" + certname.commonName) return result
def jnr_updater(): print("Starting jnr_updater") # start session with database Session = sessionmaker(bind=engine) session = Session() # create socket and listen sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind(("0.0.0.0", JNRCOUNTER_PORT)) sock.listen(10) while True: # wait for connection client, address = sock.accept() # timeout the connection if the client takes to long to send a response sock.settimeout(6) print(f"Connection from {address[0]} on jnr port") # TODO: replace this verification system with SSL # create random string of bytes for verification plaintext = bytes([random.randint(0, 0xff) for _ in range(16)]) # send encrypted verification string print("Sending verification string") client.send(aesenc.encrypt(plaintext) + b"\n") try: # receive new string and check if the connecting client can decrypt it msg = client.recv(16) if msg == plaintext: print("Verification succeeded") while True: # once verification has succeeded, no time limit is required sock.settimeout(None) # receive the update to the number of people in the junior library (+x or -x) print("Recieving message") msg = client.recv(1024) print(msg) inc = eval( msg + b"+0" ) # add a "+0" at the end in case the string has a trailing + or - (due to weird bug where requests get merged) print(inc) # update the count in the junior library session.query(Count).first().jnrvalue += inc session.commit() else: # if verification is failed, raise an error and let the try/except statement catch it raise Exception("Verification failed") except Exception as e: socket.settimeout(None) # print the error (due to verification taking too long, verification being unsuccessful, client closing the connection or some other unknown error print(repr(e), "(recieved from jnr port)") client.close()
def send(addr_dest, data, socket, filename, timeout): ##get print("\n") print("Requête get du fichier ", filename, " vers l'adresse de destination = ", addr_dest) data = data.decode() data = data.split("\x00") try: blksize = data[4] blksize = int(blksize) except: blksize = 512 print(blksize) ack = 1 filename = filename isExist = os.path.exists(filename) if (not isExist): print("Le fichier n'existe pas") ack_error_msg = b'\x00\x05\x00\x11' + bytes("FILE NOT FOUND", 'utf-8') + b'\x00' socket.sendto(ack_error_msg, addr_dest) socket.close() return with open(filename, mode='rb') as f: while True: data_bytes = f.read(blksize) print('data_bytes=', data_bytes) data_paquet = b'\x00\x03' + ack.to_bytes(2, 'big') + data_bytes print("Envoi du paquet", data_paquet) socket.sendto(data_paquet, addr_dest) socket.settimeout(timeout) try: data_ack, _ = socket.recvfrom(512) #ACK donc a ne pas changer except: print("Timeout exceeded") timeout_error_msg = b'\x00\x05\x00\x05' + bytes( "TIMEOUT", 'utf-8') + b'\x00' socket.sendto(timeout_error_msg, addr_dest) break socket.settimeout(None) print("Reception ACK:", data_ack) ack_msg = (b'\x00\x04') + ack.to_bytes(2, byteorder='big') if (ack_msg != data_ack): print("Le ACK attendu ne correspond pas au ACK reçu") ack_error_msg = b'\x00\x05\x00\x10' + bytes( "ACK ERR", 'utf-8') + b'\x00' socket.sendto(ack_error_msg, addr_dest) break ack += 1 if (len(data_bytes) < blksize): print("Fin de l'envoi") f.close() socket.close() break f.close() socket.close() print("Requête get du fichier ", filename, "terminé")
def __init__(self, ip, socket, rQue, tQue): threading.Thread.__init__(self) self.threadDoneFlag = False # TODO: increate timeout for dicrease network control interval socket.settimeout(2.0) self.trapData = ClientData(ip, socket, self, rQue, tQue) self.logger = logging.getLogger("ClientThread[" + str(ip) + "]") self.logger.setLevel(logging.DEBUG)
def scan_port(ip, port): try: socket.settimeout(2) # default family=2, type=1, proto=0 s = socket.socket() s.connect((ip, port)) s.close() return True except: return False
def accept(self): socket, addr = self._socket.accept() socket.settimeout(STCPSocket.DEFAULT_TIME_OUT) # timeout for non-blocking socket self._log(StdUsers.USER, StdLevels.INFO, "Server accepted {}.".format(addr)) self._log(StdUsers.DEV, StdLevels.INFO, "Server accepted {}.".format(addr)) socket = self._fromsocket(socket, addr, start_serve=True) socket._is_working = True return socket, addr
def __init__(self, socket, address, port, groups): self.socket = socket self.groups = groups self.address = address self.port = int(port) self.id = "%s:%s" % (self.address, self.port) self.stop_running = False socket.settimeout(TIMEOUT) threading.Thread.__init__(self)
def __init__(self, socket, *, max_message_bytes=0): ''' A max_message_bytes of <= 0 means unlimited, otherwise a positive value indicates this many bytes to limit the message size by. This is used by get(), which will raise MessageSizeExceeded if the message size received is larger than max_message_bytes. ''' self.socket = socket socket.settimeout(0) self.recv_time = time.time() self.max_message_bytes = max_message_bytes self.recv_buf = bytearray() self.send_buf = bytearray()
def register(self, socket, address, read=True, write=True, timeout=60): socket.settimeout(timeout) socket.setblocking(False) events = (selectors.EVENT_READ if read else 0) | (selectors.EVENT_WRITE if write else 0) connection = Connection(address) data = types.SimpleNamespace( connection=connection, address=address, ) self.selector.register(socket, events, data=data) return connection
def receive_from(self, socket): buffer = "" socket.settimeout(1) try: while True: data = socket.recv(4096) if not data: break buffer += data except: pass return buffer
def handler(socket): socket.settimeout(30.0) while (True): message = "" try: request = str(socket.recv(lilith_defines.recv_val)) except: socket.close() return if (len(request) == 0): socket.close() return method = request.split("\r\n")[0].split(" ") if method[0] == "GET": if (-1 == request.split("\r\n")[0].split(" ")[1].find("?")): content, content_type, g_status = get.get( request, lilith_defines.server_root) message = make_http_header(status=g_status, server=lilith_defines.server_name, Content_Length=str(len(content)), Content_Type=content_type) + content else: R = request.split("\r\n")[0].split(" ")[1].split("?")[0] content, content_type, p_status = Lilith_action.post.post( "POST " + R + " HTTP/1.1\r\n\r\n" + request.split("\r\n")[0].split(" ")[1]) message = make_http_header(status=p_status, server=lilith_defines.server_name, Content_Length=str(len(content)), Content_Type=content_type) + content elif method[0] == "POST": content, content_type, p_status = Lilith_action.post.post(request) message = make_http_header(status=p_status, server=lilith_defines.server_name, Content_Length=str(len(content)), Content_Type=content_type) + content elif method[0] == "BOST": while True: if (request[-5:] == "[END]"): break try: data = str(socket.recv(lilith_defines.recv_val)) except: socket.close() return request += data content, content_type, p_status = Lilith_action.post.post( request[:-5]) message = make_http_header(status=p_status, server=lilith_defines.server_name, Content_Length=str(len(content)), Content_Type=content_type) + content socket.send(message)
def handleClient(): """Check for new client connection and process the request """ global server, poller # Note:don't call poll() with 0, that would randomly cause # reset with "Fatal exception 28(LoadProhibitedCause)" message res = poller.poll(1) if res: # There's a new client connection (socket, sockaddr) = server.accept() socket.settimeout(0.02) # set timeout for readline to avoid blocking handle(socket) socket.close()
def listen(self): self.sock.listen(10) while True: socket, address = self.sock.accept() address = addressToBinary(address[0]) socket.settimeout(1) self.clients[socket] = (None, address) print("New connection: " + textIp(address)) thr1 = threading.Thread(target=self.listenToClient, args=(socket, address)).start() thr2 = threading.Thread(target=self.keepAliveClient, args=(socket, 42)).start()
def __init__(self, socket): self.udp_socket = socket socket.settimeout(0) self.vehicle_index = {} self.team_index = {} self._renderer = None self.my_id = None self._running = False self._thread = None
def scanPortsTask(port): import socket socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) socket.settimeout(1.0) try: socket.connect((targetForScan, port)) with lock_output: click.echo('port:' + str(port) + ' is open') except Exception as e: pass
def tem_bastao(clisock, server_address): global bastao, meunumero, first, tipobastao, maxtimeout if (not first): try: # set timeout 5 second socket.settimeout(10) data, address = sock.recvfrom(const) except: print("Timeout! Tentando novamente...") if (maxtimeout > 0): maxtimeout-=1 tem_bastao(clisock, server_address) else: print('Cheque sua conexão e tente novamente') clisock.close() sys.exit(0) message = data[1:-1].split(',') sender = int(message[1]) # print ('enviado por "%d"' % sender) # print ('recebido por "%d"' % meunumero) if (meunumero == sender): acertor = message[4] if (acertor == 'True'): print('Você destruiu um navio inimigo. Aguarde sua próxima jogada.') else: print ('Ataque enviado. Você atirou no vazio do oceano. Aguarde a sua vez.') passa_o_bastao() return message = data[1:-1].split(',') sender = int(message[1]) # print ('enviado por "%d"' % sender) # print ('recebido por "%d"' % meunumero) if (meunumero == sender): acertor = message[4] if (acertor == 'True'): print('Voce destruiu um navio inimigo. Aguarde sua proxima jogada.') else: print ('Ataque enviado. Aguarde a sua vez.') passa_o_bastao() return # print ('first') print('Sua vez!') first = False targ = int(raw_input('Qual mapa deseja atacar? ')) xy = int(raw_input('Qual coordenada desse mapa? (De 1 a 25) ')) message = (tipojogada, meunumero, targ, xy, False) # Send data # print ('sending "%s"' % (message,)) sent = clisock.sendto(str(message), server_address) print ('enviei')
def run(self): cmd_input = threading.Thread(target=self.input).start() while True: readable, writable, exceptable = select.select( self.INPUTS, self.INPUTS, []) for socket in readable: if not self.STATE is None: time.sleep(5) socket.settimeout(5) data = socket.recv(1024) socket.settimeout(None) # there is data to be received if data: # check the data data = data.decode("utf-8") # self.check_data(data) # register on server if not self.CONNECTED_SERVER: self.handshake() # join a channel if self.CONNECTED_SERVER and not self.JOINED: self.join() # connection was closed else: self.CONNECTED_SOCKET = False for socket in writable: try: # get the msg next_msg = self.MESSAGES[socket].get_nowait() except queue.Empty: # shutdown if self.SHUTDOWN: sys.exit(0) continue else: # send the msg socket.send(next_msg)
def __init__(self, socket): def condition(): for thread in enumerate_threads(): if thread.name == Logger.name: return False return True super(LogServerSession, self).__init__(name=LogServerSession.name, condition=condition, countdown=COUNTDOWN, latter=True) self._mapping = {} self._stream = LogSocketStream(self, socket) socket.settimeout(self.quantum)
def __init__(self, socket, timeout = 1.0, bufsize = 4096): threading.Thread.__init__(self) self.message_buffer = {} self.message_events = {} self.open = False self.socket = socket self.write_lock = threading.Lock() self.handler = None self.bufsize = bufsize socket.settimeout(timeout) self.address = socket.getpeername()
def recMessage (socket): socket.settimeout(2) # time out of 2000ms length,address = receivingData(socket) length_str = str(length[0:]) ACK = '1' # ACK: 1 for message received, 0 for vise versea #sendSeg(ACK,socket,host,port) socket.sendto(ACK,address) #print length_str recData,address = receivingData(socket) socket.sendto(ACK,address) counter = recData[0] recData = recData[1:] return recData, address, counter
def receive_from(socket): buffer = "" #We need to set a timer because of the network latency socket.settimeout(2) try: while True: data = socket.recv(4096) if not data: break buffer += data except: pass return buffer
def KlientKeep(): socket.settimeout(20) try: recv = socket.recvfrom(13)[0] except: print("Spojenie bolo stratene") return 1 else: Keep = '1' HEAD = struct.pack(">ciii", Keep[0].encode('ascii'), 0, 0, 0) socket.sendto(HEAD, addr) print("Spojenie je stale aktivne") return 2
def recieve(addr_dest, data, socket, filename, timeout): #Put data = data.decode() # data = data.split("\x00") try: blksize = data[4] blksize = int(blksize) except: blksize = 512 socket.sendto(b'\x00\x04\x00\x00', addr_dest) #On envoie l'ACK0 numPaquet = 1 with open( filename, "wb" ) as f: #On ouvre un fichier dans lequel écrire les dats qu'on reçoit while (True): socket.settimeout(timeout) try: data, _ = socket.recvfrom(1500) except: print("Timeout exceeded") timeout_error_msg = b'\x00\x05\x00\x05' + bytes( "TIMEOUT", 'utf-8') + b'\x00' socket.sendto(timeout_error_msg, addr_dest) break socket.settimeout(None) if (data[:2] != b'\x00\x03'): #On vérifie l'opcode du paquet print( "Erreur : L'opcode du paquet reçu n'est pas celui attendu") sys.exit(1) onlyData = data[4:] f.write(onlyData) socket.sendto( b'\x00\x04' + numPaquet.to_bytes(2, 'big'), addr_dest) #On envoie un ACK avec le bon numéro de block if ( len(onlyData) != blksize ): #Si le data reçu est plus petit que blksize, c'est le dernier paquet... #... donc on ferme la socket et on break break numPaquet += 1 socket.close() pass
def Aztec(socket): string = "" socket.settimeout(1) try: while True: data = socket.recv(4096) if not data: break string += data except: pass return string
def run_server(self, server): socket, file = self._server_accept_connection(server) threading.Thread(target=self._writer, args=[file]).start() try: while True: line = file.readline() if not line: break resp = json.loads(line) self._process_response(resp) socket.settimeout(HEARTBEAT_TIMEOUT) finally: self.close()
def _server_alive_watchog(self, socket, list_of_servers): '''The watch dog listens if the server is still alive. If not - sets a particular flag. ''' socket.settimeout(WATCHDOG_PING) try: while self.is_alive: message, address = socket.recvfrom(8192) if message == '\DIE': if address == globvar[1]: # If the registered server is the one that broadcasted, then it's alive self.is_alive = False print 'Watchdog thread ended!' socket.close() except Exception: socket.close()
def recv_from(socket): buffer = b"" socket.settimeout(TIMEOUT) try: while True: data = socket.recv(4096) if not data: break buffer += data except: pass return buffer
def read_socket(socket, addr): print 'Waiting for data from:', addr socket.settimeout(None) data = None try: msg = socket.recv(2048) while msg: if data: data = data + msg else: data = msg msg = socket.recv(2048) except socket.timeout as msg: print msg except socket.error as msg: print msg return data
def sendSeg (data,socket,address,counter): ACKreceived = False socket.sendto(counter+data, address) ACK = '0' for i in range (0,2): ACK,address = receivingData(socket) #print ('inside loop' + ACK) if ACK == '1': #if the message sent is received #print ('sent onceeee') counter = toggle(counter) ACKreceived = True return True,counter break socket.sendto(counter+data,address) socket.settimeout(0.5) # time out of 500ms if ACKreceived == False: print >> sys.stderr, "Failed to send message. Terminating" sys.stdout.flush() exit(1)
def getMsg(socket): global list try: ret=socket.recv(4096) socket.settimeout(.1) if str(ret) == "/quit" or str(ret) == "/Quit": host,port=socket.getpeername() print ("["+str(host)+" :"+str(port)+"] ha salido.") list.remove(socket) socket.close() return None return ret except: host,port=socket.getpeername() print ("["+str(host)+" :"+str(port)+"] ha salido.") list.remove(socket) return None
def receive(socket): global message_buf while True: if message_buf.find('\r\n') != -1: break else: try: socket.settimeout(10) message_buf += socket.recv(500) socket.settimeout(None) except socket.error: print('client> time out') return message_return = message_buf[0:message_buf.find('\r\n')] message_buf = message_buf[message_buf.find('\r\n')+2: ] return message_return
def listen_for_incoming_server(self,socket): print "Listening for incoming packets from the server" print "Receiving data..." response = socket.recv(8192) self.return_response_to_client(response) print "Timeout: " + str(socket.gettimeout()) data = response try: while len(data) > 0: socket.settimeout(socket.gettimeout() + 0.01) print "Timeout: " + str(socket.gettimeout()) data = socket.recv(8192) self.return_response_to_client(data) print "Receiving more data..." print "Length: " + str(len(data)) finally: print "Response Length: " + str(len(response)) socket.close() print "Killing thread..." return
def take_picture(): cam = cv2.VideoCapture(0) ret, img = cam.read() socket.settimeout(1) sock = socket.socket() neterror = sock.connect_ex((HOST_IP, HOST_PORT)) if neterror: return img else: encode_param=[int(cv2.IMWRITE_JPEG_QUALITY),90] result, imgencode = cv2.imencode('.jpg', img, encode_param) data = numpy.array(imgencode) stringData = data.tostring() sock.send( str(len(stringData)).ljust(16)); sock.send( stringData ); sock.close() return img
def readsocket(self, socket): if (len(self.bufferLines)==0): totalData=''; data=''; try: socket.settimeout(self.Timeout); data = socket.recv(1024); while (data): totalData +=data; data = socket.recv(1024); except: pass; self.bufferLines=totalData.split('\n'); if (len(self.bufferLines) > 0): self.bufferLines.pop(-1); if (len(self.bufferLines) > 0): result=self.bufferLines.pop(0); else: result = ''; return result;
def __init__(self, microWebSrv, socket, addr) : socket.settimeout(2) self._microWebSrv = microWebSrv self._socket = socket self._addr = addr self._method = None self._path = None self._httpVer = None self._resPath = "/" self._queryString = "" self._queryParams = { } self._headers = { } self._contentType = None self._contentLength = 0 if hasattr(socket, 'readline'): # MicroPython self._socketfile = self._socket else: # CPython self._socketfile = self._socket.makefile('rwb') self._processRequest()
def __init__(self, ip, port, socket, auth, handle, logger): super(ClientThread, self).__init__() self.ip = ip self.port = port self.name = "Client: {0}:{1}".format(ip, port) self.socket = socket # time out the connection on purpose to check for events # TODO: maybe find a better way socket.settimeout(2) self.logger = logger self._kick = threading.Event() self._handle_function = handle self._auth_function = auth self._authenticated = False self._auth_tries_left = 3 self.logger.debug("New thread spwaned for %s:%s" % (self.ip, self.port))
def handle(self): if self.request[0].strip(): try: data = json.loads(self.request[0].strip()) except ValueError: return; socket = self.request[1] socket.settimeout(1); if data.has_key('ctime') and data.has_key('logtype'): #print 'connection from', self.client_address, #print data['logtype'], data['ctime']; sqlitedbfile = self.server.log_dirname + "/postgresql.log.sqlite" conn = sqlite.connect(sqlitedbfile); cur = conn.cursor(); if data['logtype'] != "duration": res = cur.execute("select * from %s_log where ctime = ?" % (data['logtype']), [data['ctime'][0]]); else: #duration if data['ctime'][1] > 0: wherectime = "ctime >= %d and ctime <= (%d + %d)" % (data['ctime'][0], data['ctime'][0], data['ctime'][1]); else: wherectime = "ctime = %d" % (data['ctime'][0]); if data['ctime'][2] == data['ctime'][3]: wherectime += " and query_pos = %d" % (data['ctime'][2]); else: if data['ctime'][3] < 0: wherectime += " and query_pos >= %d" % (data['ctime'][2]); else: wherectime += " and query_pos >= %d and query_pos <= %d" % (data['ctime'][2], data['ctime'][3]); res = cur.execute("select * from %s_log where %s" % (data['logtype'], wherectime)); rows = res.fetchall(); del res; cur.close(); conn.close(); try: for row in rows: socket.sendto(json.dumps(row), self.client_address) socket.sendto('bye', self.client_address) except: print 'except!' pass;
def invoke(self, request, retfile=False): """ Open a connection. @param request: A suds Request @type Request: suds.transport.Request @param retfile: indicates if a file-like object is to be returned @type: bool @return: A file-like object or a suds Reply @rtype: file or suds.transport.Reply """ tm = self.options.timeout request = self.prerequest(request) u2request = urllib2.Request(request.url, request.message, request.headers) self.addcookies(u2request) request.headers = u2request.headers log.debug('request final headers:\n%s', request.headers) urlopener = self.u2opener() try: if self.u2ver() < 2.6: socket.settimeout(tm) u2response = urlopener.open(u2request) else: u2response = urlopener.open(u2request, timeout=tm) except urllib2.HTTPError, e: # This error is to mimic the original exception code if not retfile and e.code in (202, 204): result = None else: # use the same postreply() call to decode an error response body = e.read() reply = Reply(e.code, e.headers, body) reply = self.postreply(reply) memfile = cStringIO.StringIO(reply.message) raise TransportError(reply.message, e.code, memfile)
def fetch(self, url): import time # Delay to ensure we don't anger the API server while self.last + self.delay > time.time(): time.sleep(0.001) # Nab if self.debug: print "Fetching %s" % url else: pass #print >> sys.stderr, "Fetching %s" % url try: socket.settimeout(10) handle = urllib.urlopen(url) data = handle.read() #print >> sys.stderr, dict(handle.headers), "for", url except (AttributeError, IOError): try: time.sleep(0.1) data = urllib.urlopen(url).read() except (AttributeError, IOError): try: time.sleep(0.2+random.random()*0.2) data = urllib.urlopen(url).read() except (AttributeError, IOError): try: time.sleep(0.3) data = urllib.urlopen(url).read() except (AttributeError, IOError): try: time.sleep(0.4) data = urllib.urlopen(url).read() except (AttributeError, IOError): raise IOError("Cannot contact last.fm") self.last = time.time() return data
def send(socket, data, fStopped=None, bClose=True, fPercentUpdate=None): if fStopped: socket.settimeout(SOCKET_TIMEOUT) total = 0 data = pack.pack(data) size = len(data) data = str(size) + ';' + data size = float(len(data)) while 1: try: sent = socket.sendall(data[total:]) total += sent if fPercentUpdate: fPercentUpdate(total/size) if total >= size: if bClose: socket.close() return True except AttributeError, e: if fStopped and fStopped(): if bClose: socket.close() return False
def __init__(self, socket, initiator, db_name, db, usersdb, server_send_sockets): Thread.__init__(self) self.daemon = True socket.settimeout(None) self.socket = socket self.unprocessed_packets = "" self.command = "" self.otherSocketName = "" self.db_name = db_name self.db = db self.usersdb = usersdb self.server_send_sockets = server_send_sockets # only need this for command print("tyring to print server connection") print(self.server_send_sockets) print("finsihed tryign to print") self.server_send_sockets = server_send_sockets if initiator: print("I am the initator and am trying to figure it out") self.otherSocketName = self.socket.recv(500) self.socket.send(self.db_name) else: print("trying to send and am not the initator") self.socket.send(self.db_name) self.otherSocketName = self.socket.recv(500)
if len(sys.argv)<2: print("Usage: echo msg | %s <channel1> <channel2>" %(sys.argv[0])) sys.exit(1) # comment out to disable import imp passwords = imp.load_source("passwords", os.path.join(os.path.dirname(__file__), "passwords.py")) username = passwords.username password = passwords.password channels = set(sys.argv[1:]) template = "JOIN $CHANNEL$\n" for line in sys.stdin: template += "SAY $CHANNEL$ " + line + "\n" buf = 'LOGIN ' + username + ' ' + password + ' 0 * TASClient 0.33\t0\tcl sp p\n' for channel in channels: buf += template.replace("$CHANNEL$", channel) buf += "EXIT Thanks for using rapid! https://github.com/spring/RapidTools\n" socket = socket.socket() socket.settimeout(2.0) socket.connect(('lobby.springrts.com', 8200)) socket.sendall(buf) time.sleep(1.0) socket.close()
def __init__(self, socket): # In case that the default timeout is not None. socket.settimeout(None) self._socket = socket self._buf = ''