def _create_remote_socket(self, ip, port): if self._remote_udp: addrs_v6 = socket.getaddrinfo("::", 0, 0, socket.SOCK_DGRAM, socket.SOL_UDP) addrs = socket.getaddrinfo("0.0.0.0", 0, 0, socket.SOCK_DGRAM, socket.SOL_UDP) else: addrs = socket.getaddrinfo(ip, port, 0, socket.SOCK_STREAM, socket.SOL_TCP) if len(addrs) == 0: raise Exception("getaddrinfo failed for %s:%d" % (ip, port)) af, socktype, proto, canonname, sa = addrs[0] if self._forbidden_iplist: if common.to_str(sa[0]) in self._forbidden_iplist: raise Exception('IP %s is in forbidden list, reject' % common.to_str(sa[0])) remote_sock = socket.socket(af, socktype, proto) self._remote_sock = remote_sock self._fd_to_handlers[remote_sock.fileno()] = self if self._remote_udp: af, socktype, proto, canonname, sa = addrs_v6[0] remote_sock_v6 = socket.socket(af, socktype, proto) self._remote_sock_v6 = remote_sock_v6 self._fd_to_handlers[remote_sock_v6.fileno()] = self remote_sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1024 * 32) remote_sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1024 * 32) remote_sock_v6.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1024 * 32) remote_sock_v6.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1024 * 32) remote_sock.setblocking(False) if self._remote_udp: pass else: remote_sock.setsockopt(socket.SOL_TCP, socket.TCP_NODELAY, 1) return remote_sock
def handle(client_socket, address): global totalnewconns global mysql_stats totalnewconns += 1 mysql_sockets = [] # First connection is always master, it gets all modifications mysql_socket1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) state = "alive" try: # TODO: add a timer here to wait 10s if a server is dead before # trying to reconnect again mysql_socket1.connect(('192.168.127.3', 3306)) mysql_stats[0]["globalstate"] = "alive" state = "alive" except socket.error as err: mysql_stats[0]["globalstate"] = "dead" state = "dead" mysql_sockets.append({"conn": mysql_socket1, "state":state, "stats":mysql_stats[0]}) mysql_socket2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) state = "alive" try: # TODO: add a timer here to wait 10s if a server is dead before # trying to reconnect again mysql_socket2.connect(('192.168.127.4', 3306)) mysql_stats[1]["globalstate"] = "alive" state = "alive" except socket.error as err: mysql_stats[1]["globalstate"] = "dead" state = "dead" mysql_sockets.append({"conn": mysql_socket2, "state":state, "stats":mysql_stats[1]}) do_handshake(client_socket, mysql_sockets) do_commands(client_socket, mysql_sockets)
def send_to_client(self, sctag, msg): #msg is json in str msg_ = check_smsg('send', sctag, msg) if msg_ == None: logging.error('msg is not proto-good') return cp_info = self.commpair_info_dict[sctag] proto = cp_info['proto'] #sock = cp_info['sock'] sock = None c_addr = cp_info['c_addr'] # response = None if proto == 'tcp': try: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect(c_addr) sock.sendall(msg) response = sock.recv(1024) except IOError as e: if e.errno == errno.EPIPE: #due to insuffient recv_buffer at the other end logging.error('broken pipe err, check recv_buffer') finally: sock.close() elif proto == 'udp': sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.sendto(msg, c_addr) response = sock.recv(1024) # logging.info('sent to %s_client=%s, datasize=%sBs', proto,c_addr,sys.getsizeof(msg)) logging.info('response=%s', response)
def on_ONLINE_mouseClick(self, event): global ONline Switch = self.components.ONLINE.checked if Switch == True: UDP_IP = self.components.UDP_IP.text UDP_PORT = self.components.UDP_PORT.text UDP_PORT = int(UDP_PORT) time.sleep(1) ONline = 1 self.components.ONLINE.label = "Go Offline" #easygui.msgbox("Server>> Online!") time.sleep(2) sock = socket.socket(socket.AF_INET, # Internet socket.SOCK_DGRAM) # UDP sock.sendto("Server>> Online!", (UDP_IP, UDP_PORT)) if Switch == False: UDP_IP = self.components.UDP_IP.text UDP_PORT = self.components.UDP_PORT.text UDP_PORT = int(UDP_PORT) time.sleep(1) ONline = 0 self.components.ONLINE.label = "Go Online" #easygui.msgbox("Server>> Offline!") time.sleep(2) sock = socket.socket(socket.AF_INET, # Internet socket.SOCK_DGRAM) # UDP sock.sendto("Server>> Offline!", (UDP_IP, UDP_PORT))
def getFreeAddresses(self): import socket s = socket.socket() s.bind(('',0)) port0 = s.getsockname()[1] s1 = socket.socket() s1.bind(('',0)) port1 = s1.getsockname()[1] s.close() s1.close() if port0 <= 0 or port1 <= 0: #This happens in Jython... from java.net import ServerSocket s0 = ServerSocket(0) port0 = s0.getLocalPort() s1 = ServerSocket(0) port1 = s1.getLocalPort() s0.close() s1.close() assert port0 != port1 assert port0 > 0 assert port1 > 0 return port0, port1
def reuse_socket_address(self): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) old_state = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) print "Old socket state: ", old_state # 激活套接字重用 sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) new_state = sock.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) print "New socket state: ", new_state local_port = 8282 srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM) srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) srv.bind(('', local_port)) srv.listen(1) print "Listen On Port: ", local_port while True: try: connection, addr = srv.accept() print "Connect by %s:%s"%(addr[0],addr[1]) except KeyboardInterrupt: break except socket.error, msg: print '%s' % msg
def run(self): while True: snap_shot() #time.sleep(.05) #HOST = 'u1204vm.local' #CPORT = 9091 #MPORT = 9090 #FILE = sys.argv[1] print "sending image" cs = socket.socket(socket.AF_INET, socket.SOCK_STREAM) cs.connect((self.host, self.cport)) cs.send("SEND " + self.filetosend) cs.close() time.sleep(0.05) ms = socket.socket(socket.AF_INET, socket.SOCK_STREAM) ms.connect((self.host, self.mport)) f = open(self.filetosend, "rb") data = f.read() f.close() ms.send(data) ms.close() print "waiting one second before sending another image"
def portscan(target,ports,tcp,udp,verbose): #target=IPaddr,ports=list of ports,tcp=true/false,udp=true/false,verbose=true/false printmsg(("Now scanning %s" % (target))) tcpports=[] udpports=[] if tcp: for portnum in ports: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(0.01) s.connect((target, portnum)) except Exception: failvar = 0 if verbose: print "%d/tcp \tclosed" % (portnum) else: print "%d/tcp \topen"% (portnum) tcpports.append(portnum) s.close() if udp: for portnum in ports: try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.settimeout(0.1) s.sendto("--TEST LINE--", (target, portnum)) recv, svr = s.recvfrom(255) except Exception, e: try: errno, errtxt = e except ValueError: print "%d/udp \topen"% (portnum) udpports.append(portnum) else: if verbose: print "%d/udp \tclosed" % (portnum) s.close()
def testDefaultTimeout(self): # Testing default timeout # The default timeout should initially be None self.assertEqual(socket.getdefaulttimeout(), None) s = socket.socket() self.assertEqual(s.gettimeout(), None) s.close() # Set the default timeout to 10, and see if it propagates socket.setdefaulttimeout(10) self.assertEqual(socket.getdefaulttimeout(), 10) s = socket.socket() self.assertEqual(s.gettimeout(), 10) s.close() # Reset the default timeout to None, and see if it propagates socket.setdefaulttimeout(None) self.assertEqual(socket.getdefaulttimeout(), None) s = socket.socket() self.assertEqual(s.gettimeout(), None) s.close() # Check that setting it to an invalid value raises ValueError self.assertRaises(ValueError, socket.setdefaulttimeout, -1) # Check that setting it to an invalid type raises TypeError self.assertRaises(TypeError, socket.setdefaulttimeout, "spam")
def minecraft(phenny, input): if input.sender.startswith('#'): return phenny.reply("This command only available in private message.") # Set up s = socket.socket() t = socket.socket() u = socket.socket() v = socket.socket() gamerx = cprossu = packethumper = bitviper = "UP" # Attempt connections try: s.connect(('gamerxreviews.net', 25565)) except: gamerx = "DOWN" try: t.connect(('72.222.196.252',25565)) except: cprossu = "DOWN" try: u.connect(('minecraft.nerderosity.com',25565)) except: packethumper = "DOWN" try: v.connect(('minecraft.bitviper.org',25565)) except: bitviper = "DOWN" # output phenny.reply( "GuardianZozo's minecraft server: gamerxreviews.net:25565. Server Status: {}".format(gamerx) ) phenny.reply( "Cprossu's minecraft server: 72.222.196.252:25565. Server Status: {}".format(cprossu) ) phenny.reply( "PacketHumper's minecraft server: minecraft.nerderosity.com:25565. Server Status: {}".format(packethumper) ) phenny.reply( "BitViper's minecraft server: minecraft.bitviper.org:25565. Server Status: {}".format(bitviper) )
def create_persistent(address): """ Create a new process, returning a persistent communications channel between the creating process and the created process. This channel can be disconnected from the creating process and connected to another process, and thus can be used to collect results from daemon processes. In order to be able to reconnect to created processes, the 'address' of the communications endpoint for the created process needs to be provided. This should be a filename. """ parent = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) child = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) child.bind(address) for s in [parent, child]: s.setblocking(1) pid = os.fork() if pid == 0: parent.close() return PersistentChannel(pid, child, address) else: child.close() #parent.connect(address) return Channel(pid, parent.makefile("r", 0), parent.makefile("w", 0))
def pick_random_port(): """Bind to an ephemeral port, force it into the TIME_WAIT state, and unbind it. This means that further ephemeral port alloctions won't pick this "reserved" port, but subprocesses can still bind to it explicitly, given that they use SO_REUSEADDR. By default on linux you have a grace period of 60 seconds to reuse this port. To check your own particular value: $ cat /proc/sys/net/ipv4/tcp_fin_timeout 60 """ s = socket.socket() s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind(('127.0.0.1', 0)) s.listen(0) sockname = s.getsockname() # these three are necessary just to get the port into a TIME_WAIT state s2 = socket.socket() s2.connect(sockname) s.accept() return sockname[1]
def createSockByType(self, sockType): if sockType == socktypes.UDP_CLIENT_LOCAL: self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) elif sockType == socktypes.TCP_CLIENT_LOCAL: self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) else: logger.error("***** ERROR SOCKTYPE *****")
def make_dummy_socket_pair(): """Create a pair of sockets connected to each other on the local interface. Used to implement SocketHandler.wakeup(). On Unixish systems, port 0 will pick the next available port. But that appears to have problems on Windows possibly with firewall software. So if we hit a socketerror with port 0, we try ports between 50000 and 65500. """ attempts = 0 port = 0 family, addr = localhost_family_and_addr() while 1: attempts += 1 try: dummy_server = socket.socket(family, socket.SOCK_STREAM) dummy_server.bind((addr, port)) dummy_server.listen(1) server_address = dummy_server.getsockname() first = socket.socket(dummy_server.family, socket.SOCK_STREAM) first.connect(server_address) second, address = dummy_server.accept() dummy_server.close() return first, second except socket.error: # if we hit this, then it's hopeless--give up if port > 65500: sys.stderr.write(("Tried %s bind attempts and failed on " "addr %s port %d\n") % (attempts, addr, port)) raise # bump us into ephemeral ports if we need to try a bunch if port == 0: port = 50000 else: port += 10
def test_get_conns(self): sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock1.bind(('127.0.0.1', 0)) sock1.listen(1) sock1ipport = '%s:%s' % sock1.getsockname() sock2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock2.bind(('127.0.0.1', 0)) sock2.listen(1) orig_port = memcached.DEFAULT_MEMCACHED_PORT try: sock2ip, memcached.DEFAULT_MEMCACHED_PORT = sock2.getsockname() sock2ipport = '%s:%s' % (sock2ip, memcached.DEFAULT_MEMCACHED_PORT) # We're deliberately using sock2ip (no port) here to test that the # default port is used. memcache_client = memcached.MemcacheRing([sock1ipport, sock2ip]) one = two = True while one or two: # Run until we match hosts one and two key = uuid4().hex for conn in memcache_client._get_conns(key): peeripport = '%s:%s' % conn[2].getpeername() self.assert_(peeripport in (sock1ipport, sock2ipport)) if peeripport == sock1ipport: one = False if peeripport == sock2ipport: two = False finally: memcached.DEFAULT_MEMCACHED_PORT = orig_port
def connect(self, server, port, channel): self.server = server self.port = port self.channel = channel if self.ssl: self.socket = ssl.wrap_socket( socket.socket(socket.AF_INET, socket.SOCK_STREAM)) else: self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.connect((self.server, self.port)) # Send user's info if self.password: self.send('PASS %s' % self.password) self.send('NICK %s' % self.nick) self.send( 'USER %s %s %s %s' % (self.nick, self.nick, self.nick, self.nick)) # Wait for commands while True: self.send('PING %s' % self.server) data = recv_timeout(self.socket) try: self.parse_data(data) except Exception: pass
def init(): # socket setting global receiver global sender receiver = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) receiver.bind(("", RECEIVE_PORT)) sender = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sender.bind(("", SEND_PORT)) # arduino setting global arduino try: arduino = serial.Serial(SERIAL_PORT, 9600) except: arduino = serial.Serial(SERIAL_PORT2, 9600) arduino.flushInput() # thread setting global receiver_thread global sender_thread global gps_thread receiver_thread = threading.Thread(target=receive_thread) sender_thread = threading.Thread(target=send_thread) gps_thread = gps_drive_class() # GPS setting global gpsd gpsd = gps.gps("127.0.0.1", "2947") gpsd.stream(gps.WATCH_ENABLE|gps.WATCH_NEWSTYLE)
def __init__(self, name): ThreadManagement.ThreadManagement(name) socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.__target = None self.__listen_type = HyperSocket.__LOCAL self.__connect_type = None self.accept_queue = Queue.Queue(maxsize = 0)
def __init__(self, listeners=None, send=False): self.sendSocket = None self.receiveSocket = None self.sendSeq = 0 self.receiveSeq = None self.listeners = listeners if listeners is not None else [] for L in self.listeners: assert isinstance(L, Listener) if send: self.sendSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) self.sendSocket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 2) else: ## similar to sending, but need to do the group membership setup self.receiveSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) self.receiveSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.receiveSocket.bind(('', Feed.MCAST_PORT)) mreq = struct.pack("4sl", socket.inet_aton(Feed.MCAST_GRP), socket.INADDR_ANY) self.receiveSocket.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq) self.receiveSocket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 256*1024) ## see /proc/sys/net/core/rmem_* ##print "receiveBuf = ", self.receiveSocket.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF) ## start the thread to handle any listeners through the callback mechanism if len(self.listeners): self.thread = threading.Thread(target=self.run, name="Feed") self.thread.daemon = True self.thread.start()
def send_option(option): if option==4: s=socket.socket() s.connect((hosta, porta)) s.send(str(option)) op=int(s.recv(1024)) if option==op: print "option sent" s.close() else: s=socket.socket() s.connect((hosta, porta)) s.send(str(option)) op=int(s.recv(1024)) if option==op: print "option sent" s.close() s=socket.socket() if (option!=op and option==2) or option!=2: s.connect((hostb, portb)) s.send(str(option)) op=int(s.recv(1024)) if option==op: print "option sent" s.close() tryb=True
def checkInbox(threadName, delay, counter): while True: if ONline == True: #test = str(raw_input("test: ")) #if test == "break": # break sock = socket.socket(socket.AF_INET, # Internet socket.SOCK_DGRAM) # UDP sock.bind((S_IP, int(S_PORT))) data, addr = sock.recvfrom(int(S_BUFFERSIZE)) #buffer size in bytes now = datetime.datetime.now() if data != "CC": print "Server>> ", now, " ", str(addr) + data easygui.msgbox(str(addr) + data, now) #self.components.chathistory.text = self.components.chathistory.text + "\n\n" + str(now) + " " + UDP_SENDERIP + ": " + data if data == "CC": print data, str(addr) #send "heartbeat" to connected client sock = socket.socket(socket.AF_INET, # Internet socket.SOCK_DGRAM) # UDP sock.sendto(S_IP+" You have Succesfully connected to: "+ S_IP, (addr)) elif ONline == False: print "Server>> OFFLINE!" time.sleep(1)
def scanfiles(self): for root, dirs, files in os.walk("files"): for file_ in files: check = root+"/"+file_ if check not in self.files: try: self.files[check] = hash(open(check).read()) sock = socket.socket() sock.connect((self.host, self.port)) upload.upload(sock, check, self.username, self.password) print "{0} Outgoing file transfer {1}".format(datetime.datetime.now(), check) except Exception, e: #print e del self.files[check] time.sleep(0.5) else: with open(check, 'rb') as file: hashc = hash(file.read()) if hashc != self.files[check]: try: sock = socket.socket() sock.connect((self.host, self.port)) upload.upload(sock, check, self.username, self.password) print "{0} Outgoing file transfer {1}".format(datetime.datetime.now(), check) self.files[check] = hash(open(check).read()) except Exception, e: pass time.sleep(0.5)
def send_cmd_info(): global SERVER_IP,SERVER_PORT,DETECT_TIME sk=socket.socket(socket.AF_INET,socket.SOCK_STREAM) sec=86400 res,hostname=commands.getstatusoutput('hostname') while True: begin,end,script,log=parse_history_log_file('/tmp/.history_cmd.log') try: sk=socket.socket(socket.AF_INET,socket.SOCK_STREAM) sk.connect((SERVER_IP,SERVER_PORT)) for i in range(begin,end): cmd=script+' '+str(i)+' '+log res,info=commands.getstatusoutput(cmd) if info: str_list=info.split('@_@') dicts={'type':'cmd'} dicts['time']=str_list[0].rstrip(' ') dicts['user']=str_list[1] dicts['ip']=str_list[2] dicts['cmd']=str_list[3] dicts['host']=hostname json=simplejson.dumps(dicts) if dicts['ip'] == '' or dicts['user'] == '': continue sk.sendall(json) except Exception as e: print e finally: sk.close() time.sleep(DETECT_TIME)
def connect (self,fname): '''Connect to the server. Return True if the connection was established.''' trace = False and not g.unitTesting if trace: g.trace(fname,socket) if hasattr(socket,'AF_UNIX'): try: # pylint: disable=E1101 # E1101:LProtoClient.connect: Module 'socket' has no 'AF_UNIX' member self.socket = socket.socket(socket.AF_UNIX,socket.SOCK_STREAM) self.socket.connect(fname) return True except Exception: g.es_print('lproto.py: failed to connect!',fname) g.es_exception(full=False,c=None) return False else: try: host = '172.16.0.0' # host is a local address. port = 1 self.socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self.socket.connect((host,port),) self.socket.connect(fname) return True except Exception: g.es_print('lproto.py: failed to connect! host: %s, port: %s' % ( host,port)) g.es_exception(full=False,c=None) return False
def create_socket(self): if self.protocol == 'TCP': self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) elif self.protocol == 'UDP': self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) else: self.socket = socket.socket()
def create_sock_pair(port=0): '''Create socket pair. Works also on windows by using an ephemeral TCP port.''' if hasattr(socket, 'socketpair'): client_sock, srv_sock = socket.socketpair() return client_sock, srv_sock # Create a non-blocking temporary server socket temp_srv_sock = socket.socket() temp_srv_sock.setblocking(False) temp_srv_sock.bind(('localhost', port)) port = temp_srv_sock.getsockname()[1] temp_srv_sock.listen(1) with closing(temp_srv_sock): # Create non-blocking client socket client_sock = socket.socket() client_sock.setblocking(False) while True: try: client_sock.connect(('localhost', port)) except socket.error as err: # EWOULDBLOCK is not an error, as the socket is non-blocking if err.errno not in socket_errors_nonblocking: raise # Use select to wait for connect() to succeed. timeout = 1 readable = select.select([temp_srv_sock], [], [], timeout)[0] if temp_srv_sock not in readable: raise Exception('Client socket not connected in {} second(s)'.format(timeout)) srv_sock = temp_srv_sock.accept()[0] client_sock.setblocking(True) return client_sock, srv_sock
def connect(self): assert self.server_hostname assert self.server_port assert self.nickname self.username = self.username or self.nickname self.realname = self.realname or self.nickname if self.ipv4: self._socket = socket.socket() else: self._socket = socket.socket(socket.AF_INET6) if self.bindhost: self._socket.bind((self.bindhost, 0)) try: self._socket.connect((self.server_hostname, self.server_port)) except Exception as e: raise e if self.ssl: try: self._socket = self.ssl_wrap(self._socket) except ssl.SSLError: self.ssl_verify = False if self.connect(): self.connected = True return False if self._socket: self.send_pass(self.password) self.send_user(self.username, self.realname) self.send_nick(self.nickname) self.connected = True self._socket.setblocking(False) return True return False
def test_F_port_forwarding(self): """ verify that a client can forward new connections from a locally- forwarded port. """ self.setup_test_server() chan = self.tc.open_session() chan.exec_command('yes') schan = self.ts.accept(1.0) # open a port on the "server" that the client will ask to forward to. greeting_server = socket.socket() greeting_server.bind(('127.0.0.1', 0)) greeting_server.listen(1) greeting_port = greeting_server.getsockname()[1] cs = self.tc.open_channel(b'direct-tcpip', ('127.0.0.1', greeting_port), ('', 9000)) sch = self.ts.accept(1.0) cch = socket.socket() cch.connect(self.server._tcpip_dest) ss, _ = greeting_server.accept() ss.send(b'Hello!\n') ss.close() sch.send(cch.recv(8192)) sch.close() self.assertEquals(b'Hello!\n', cs.recv(7)) cs.close()
def downloadFile(self, listadapter, *args): try: self.interface.log("ABOUT TO DOWNLOAD FROM " + listadapter.selection[0].text) s = listadapter.selection[0].text i = self.app.context["peers_addr"].index(s) print("INSIDE DOWNLOAD ") key = str(i)+"_"+str(s) if(self.app.context["downloads_available"][str(key)]): peer = self.app.context["downloads_available"][str(key)] print(peer) ##possiamo far partire il download del file destination = (s , int(peer["porta"])) print(destination) print(peer["md5"]) self.connection_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) self.connection_socket.connect(destination) message = "RETR"+str(peer["md5"]) self.connection_socket.send(message) message_type = self.connection_socket.recv(4) num_chunks = self.connection_socket.recv(6) f = open('shared/'+peer["nome"].strip(" "), "wb") if int(num_chunks) > 0 : print("num chunks " + str(num_chunks)) self.interface.progress.max = int(num_chunks) for i in range(int(num_chunks)): len_chunk = self.connection_socket.recv(5) if (int(len_chunk) > 0): self.interface.progress.value = self.interface.progress.value + 1 chunk = self.connection_socket.recv(int(len_chunk)) #f.write(chunk) #print("downloading chunk " + str(len_chunk)) while len(chunk) < int(len_chunk): new_data = self.connection_socket.recv(int(len_chunk)-len(chunk)) #f.write(new_data) chunk = chunk + new_data f.write(chunk) f.close() self.connection_socket.close() self.interface.progress.value = 0 ## scriviamo alla directory che abbiamo finito il download self.connection_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) self.connection_socket.connect(self.directory) message = "DREG" + self.app.context["sessionid"] + peer["md5"] self.connection_socket.send(message) ack = self.connection_socket.recv(4) n_down = self.connection_socket.recv(5) self.interface.log("RECEIVED "+ str(ack)) self.interface.log("#DOWNLOAD " + str(n_down)) self.connection_socket.close() else: print("NOT AVAILABLE") except: print("exception!!") print(sys.exc_info()[0]) print(sys.exc_info()[1]) print(sys.exc_info()[2])
def read_chat(self): #wait for connection from spatulabot bot_s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) bot_s.bind(('', 9000)) bot_s.listen(10) conn, addr = bot_s.accept() print 'Connected with ' + addr[0] + ':' + str(addr[1]) #connect to twitch s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((cfg.HOST, cfg.PORT)) s.send("PASS {}\r\n".format(cfg.PASS).encode("utf-8")) s.send("NICK {}\r\n".format(cfg.NICK).encode("utf-8")) s.send("JOIN {}\r\n".format(cfg.CHAN).encode("utf-8")) done_wait = datetime.datetime.now() while self.running: response = s.recv(1024).decode("utf-8") if datetime.datetime.now() < done_wait: continue for r in response.split('\r\n'): if r == "PING :tmi.twitch.tv\r\n": s.send("PONG :tmi.twitch.tv\r\n".encode("utf-8")) elif len(r) > 0 and CHAT_MSG.match(r): username = re.search(r"\w+", r).group(0) # return the entire match message = CHAT_MSG.sub("", r) self.add_line(username, message) #check if matches a command for c in CHAT_COMMANDS: if message in c[0]: bot_s.send(c[1]+'\r\n') #timeout done_wait = datetime.datetime.now() + datetime.timedelta(seconds=12) s.close() bot_s.close()