Exemplo n.º 1
0
 def __on_bind(self, socket):
     """Called when the server socket is bound."""
     self.port = socket.getsockname()[1]
     if self.__info_file:
         with open(self.__info_file, "w") as f:
             logging.info("Writing info file: %s", self.__info_file)
             f.write(str(self.port))
     logging.info("Listening: %s", socket.getsockname())
Exemplo n.º 2
0
def get_nick_for_socket(nick_dico, socket): #get the nickname of a socket
    try:
        (ip,a,b,c) = socket.getsockname()   #get the ip of the socket
        res = nick_dictionnary[ip]          #check if a nick is linked to this ip
    except KeyError:    #if user doesnt have any nick
        res = ip
    return res
Exemplo n.º 3
0
 def handle(self, socket):
     self.set_ready()
     self.logger.debug("Connected to leader")
     client_address = self.client_hostname or socket.getsockname()[0]
     socket.send('%s\n' % client_address)
     # TODO: Use TCP keepalives
     keepalive = self._server_keepalive(socket)
     try:
         for line in util.line_protocol(socket, strip=False):
             if line == '\n':
                 # Keepalive ack from leader
                 keepalive.kill()
                 keepalive = self._server_keepalive(socket)
             else:
                 cluster = json.loads(line)
                 if 'leader' in cluster:
                     # Means you have the wrong leader, redirect
                     host = cluster['leader']
                     port = cluster.get('port', self.leader_address[1])
                     self.leader_address = (host, port)
                     self.logger.info("Redirected to %s:%s..." % 
                                         self.leader_address)
                     raise NewLeader()
                 elif client_address in cluster['cluster']:
                     # Only report cluster once I'm a member
                     self.manager.cluster = set(cluster['cluster'])
                     self.manager.trigger_callback()
         self._leader_election()
     except NewLeader:
         self.manager.trigger_callback()
         if self.leader_address[0] == client_address:
             self.manager.is_leader = True
             self.stop()
         else:
             return
Exemplo n.º 4
0
def broadcast (server_socket, sock, message):
    for socket in SOCKET_LIST:
        # send the message only to peer
        if socket != server_socket and socket != sock :
            try :
               address = socket.getsockname()
               print("sending broadcast XML to" + address[0])
               print(message)
                # try to push directly
               
               pushTCP(address[0], CLIENT_PORT, message)
                #also broadcast
               socket.send(message)
                #socket.send(str.encode(message))
                #socket.send(bytes(message, "utf8"))
                #encoded = base64.b64encode(bytes(message,'utf-8'))

                #socket.send( encoded)
                #time.sleep(4)
               resp = socket.recv(4096).decode('utf-8')
               try:
                    print("response is:") 
                    print(str(resp))
               except Exception as m:
                # broken socket connection
                    print('broadcast response is borken. exception is: '  + str(m))

            except Exception as e:
                # broken socket connection
                print('exception by broadcasting! '  + str(e))
                socket.close()
                # broken socket, remove it
                if socket in SOCKET_LIST:
                    SOCKET_LIST.remove(socket)
Exemplo n.º 5
0
def delete_nick(nick_dico,socket):
    try:
        (ip,a,b,c) = socket.getsockname()
        nick_dico[ip] = "Guest"
    except:
        print("got an error while deleting a nick")
        pass
Exemplo n.º 6
0
 def __init__(self, socket, signal_bus, is_reactive_conn=False):
     # Validate input.
     if socket is None:
         raise ValueError('Invalid arguments passed.')
     activity_name = ('BgpProtocol %s, %s, %s' % (
         is_reactive_conn, socket.getpeername(), socket.getsockname())
     )
     Activity.__init__(self, name=activity_name)
     # Intialize instance variables.
     self._peer = None
     self._recv_buff = ''
     self._socket = socket
     self._signal_bus = signal_bus
     self._holdtime = None
     self._keepalive = None
     self._expiry = None
     # Add socket to Activity's socket container for managing it.
     if is_reactive_conn:
         self._asso_socket_map['passive_conn'] = self._socket
     else:
         self._asso_socket_map['active_conn'] = self._socket
     self._open_msg = None
     self.state = BGP_FSM_CONNECT
     self._is_reactive = is_reactive_conn
     self.sent_open_msg = None
     self.recv_open_msg = None
     self._is_bound = False
Exemplo n.º 7
0
    def get_local_host_ip(self, user_fd=None):
        if user_fd in self.user_fd_to_socket_fd.keys():
            socket = self.socket_fileno_info[
                self.user_fd_to_socket_fd[user_fd]]['socket']
            try:
                return socket.getsockname()[0]
            except Exception as e:
                logger.error(traceback.format_exc())
                return None
        else:
            ifconfig_pipe = subprocess.Popen(
                ['busybox', 'ifconfig', 'wlan0'],
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
            )
            ifconfig_info, error = ifconfig_pipe.communicate()
            ifconfig_pipe.kill()

            if len(error) != 0:
                # get wlan0 error
                return None

            ifconfig_info = ifconfig_info.decode('utf-8')

            inet_addr_str = ifconfig_info.split('\n')[1]

            local_host_ip = None
            if 'inet addr' in inet_addr_str:
                local_host_ip = inet_addr_str.split(':')[1].split(' ')[0]

            return local_host_ip
Exemplo n.º 8
0
 def __init__(self, socket, signal_bus, is_reactive_conn=False):
     # Validate input.
     if socket is None:
         raise ValueError('Invalid arguments passed.')
     activity_name = (
         'BgpProtocol %s, %s, %s' %
         (is_reactive_conn, socket.getpeername(), socket.getsockname()))
     Activity.__init__(self, name=activity_name)
     # Intialize instance variables.
     self._peer = None
     self._recv_buff = ''
     self._socket = socket
     self._socket.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
     self._sendlock = semaphore.Semaphore()
     self._signal_bus = signal_bus
     self._holdtime = None
     self._keepalive = None
     self._expiry = None
     # Add socket to Activity's socket container for managing it.
     if is_reactive_conn:
         self._asso_socket_map['passive_conn'] = self._socket
     else:
         self._asso_socket_map['active_conn'] = self._socket
     self._open_msg = None
     self.state = BGP_FSM_CONNECT
     self._is_reactive = is_reactive_conn
     self.sent_open_msg = None
     self.recv_open_msg = None
     self._is_bound = False
Exemplo n.º 9
0
def get_free_port():
    import socket
    socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    socket.bind(("", 0))
    free_port = socket.getsockname()[1]
    socket.close()
    return free_port
Exemplo n.º 10
0
def get_unused_port() -> int:
    import socket
    s = socket.socket()
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)  # just in case
    s.bind(('', 0))
    port = s.getsockname()[1]
    s.close()
    return port
Exemplo n.º 11
0
	def on_close(self, socket):
		worker = self.workers.pop(socket, None)
		if worker:
			self.log.info('%s - %s closed.' % (self.name, worker['name']))
		else:
			host, port = socket.getsockname()
			self.log.info('%s - socket <%s:%d> closed.' % (self.name, host, port))
		return worker
Exemplo n.º 12
0
 def get_pseudo_header(self, socket):
     src_host, _src_port = socket.getsockname()
     dst_host, _dst_port = socket.getpeername()
     src_quad = [int(i) for i in src_host.split(".")]
     dst_quad = [int(i) for i in dst_host.split(".")]
     pseudo_header_info = src_quad + dst_quad + [0, socket.proto, len(self)]
     pseudo_header_fmt = ("!" "BBBB" "BBBB" "B" "B" "H")
     return struct.pack(pseudo_header_fmt, *pseudo_header_info)
	def __init__(self, socket, HTTPHandler, request_callback=None):
		HTTPServer.__init__(self, socket.getsockname(), HTTPHandler, False)
		self.socket = socket
		self.server_bind = self.server_close = lambda self: None
		self.HTTPHandler = HTTPHandler
		self.request_callback = request_callback

		threading.Thread.__init__(self)
		self.daemon = True
Exemplo n.º 14
0
 def _assign(self, socket: socket.socket):
     self._socket = socket
     self._host = socket.getsockname()
     self._remote = socket.getpeername()
     self._handler = threading.Thread(target=self._receiverHandler,
                                      args=(socket, ))
     self._stop = False
     self._handler.daemon = True
     self._handler.start()
Exemplo n.º 15
0
def server(interface,port):
    sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    sock.bind(interface,port)#bind the socket to a public  host
    
    print('listening for datagrams at {}'.format(socket.getsockname()))
    while True:
        data,address=sock.recvfrom(bufsize)
        text=data.decode('ascii')
        print('the client at {} says :{!r}'.format(address,text))
Exemplo n.º 16
0
def get_addr():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect(("msn.com", 80))
    name = s.getsockname()[0]
    if name is None:
        name = socket.getsockname()
    if name is None:
        name = "<undefined>"
    return name
Exemplo n.º 17
0
 def __init__(self, name, terminal, socket):
     self.name = name
     self.terminal = terminal
     self.terminal.init(self)
     self.sent = {}
     self.cameras = []
     self.selector = Selector()
     self.connection = self.selector.register(socket, socket.getsockname())
     self.delay = 0.0001
Exemplo n.º 18
0
    def get_socket_ip(self, socket):
        if socket == self.node.nodes_node.socket:
            return self.ip

        result = socket.getpeername()[0]
        if result == self.ip:
            result = socket.getsockname()[0]

        return result
Exemplo n.º 19
0
def leave_channel(socket,channel_to_leave):
    (ip,a,b,c) = socket.getsockname()   #get the ip of the socket and some useless informations
    print(ip + "left the channel " + channel_to_leave)
    try:
        channel_dictionnary[ip].remove(channel_to_leave)    #we remove the channel to the channel list linked to this ip
        res = "Vous avez quitté le channel " + str(channel_to_leave) +"\n"
        socket.send(res.encode())   #we inform the user that he just left the channel
        broadcast_on_channel((ip+" left the channel "+channel_to_leave+"\n"), channel_to_leave, socket_list)#we broadcast a msg to the channel which inform the users that one has left
    except ValueError:              #if the channel_name isnt on the list linked to this ip of the dictionnary
        print("you are not on this channel")
Exemplo n.º 20
0
def port(socket,portnumber):
    high,low = splitBytes(portnumber)
    client = socket.getsockname()[0]
    octet = client.split('.')
    socket.send(bytes('PORT '+octet[0]+','+octet[1]+','+octet[2]+','+octet[3]+','+str(high)+','+str(low),'ASCII')+b'\x0d\x0a')
    data = socket.recv(1024)
    print(data.decode('ASCII'),end='')
    if int(data.decode('ASCII')[:3]) == 200:
        return True
    else:
        return False
Exemplo n.º 21
0
    async def start(self):
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.bind((self.hostname, self.port))

        if self.port == 0:
            self.port = socket.getsockname()[1]

        tls_context = self.tls_context if self.use_tls else None
        self.server = await asyncio.start_server(self.on_connect,
                                                 ssl=tls_context,
                                                 sock=sock,
                                                 loop=self.loop)
Exemplo n.º 22
0
    def __init__(self, socket: socket.socket, servidor: object):
        ''' Método construtor da classe Par
        
        :parameter socket: socket pelo qual o par se comunica
        :parameter servidor: servidor
        '''
        threading.Thread.__init__(self)
        self.__socket = socket
        self.__servidor = servidor
        self.__name = str(socket.getsockname())

        self.start()
Exemplo n.º 23
0
	def handle_request(socket, client_address, server):
		s = ServerInfo(software=server_version, multiconnection=True, multithread=False, multiprocess=False)
		c = ConnectionInfo(server=s)

		c.server.addr = LazyAddress(socket.family, lambda: socket.getsockname())
		c.remote.addr = Address(socket.family, client_address)

		c.socket = socket

		with socket.makefile('r') as input:
			with socket.makefile('w') as output:
				app(input, output, sys.stderr, c)
Exemplo n.º 24
0
def do_Send():
	global currentState, user
	inputData = userentry.get()
	if len(inputData.strip(' ')) == 0:
		print('Detect nothing to send!\n')
		return
	CmdWin.insert(1.0, "\nPress Send")
	# check stage
	stateLock.acquire()
	checkFlag = currentState.isAfter(States['NAMED'])
	stateLock.release()
	if not checkFlag:
		CmdWin.insert(1.0, "\nSend Error: You are not in any chatroom, please join a chatroom first!")
		return
	
	# check for all back and forward link
	sendingList = []
	stateLock.acquire()
	forwardLinkTuple = currentState._getforwardlink()
	if forwardLinkTuple is not None:
		forwardLink = forwardLinkTuple[1] 
		sendingList.append(forwardLink)
	backwardLinkTupleList = currentState._getbackwardlinks()
	backwardLinks = [i[1] for i in backwardLinkTupleList]
	roomName = currentState._getroomname()
	stateLock.release()
	if len(backwardLinks) > 0 :
		sendingList = sendingList + backwardLinks
	# get all infos desired by sending Text message
	userInfoLock.acquire()
	userName = user._getname()
	userIp = user._getip()
	userPort = user._getport()
	# update msgID
	msgID = currentState.newMsgID()
	userInfoLock.release()

	# construct the protocal message
	originHID = sdbm_hash(userName+userIp+str(userPort))
	message = [roomName, str(originHID), userName, str(msgID), str(len(inputData)), inputData]
	requestMessage = 'T:' + ':'.join(message) + PROTOCAL_END
	print("\nMain Thread: perform the sending process, dispatch data to other peers\n")

	print('Message:', requestMessage)
	for socket in sendingList:
		output = socketOperation(socket, requestMessage, receive = False)
		if output == Exceptions['SOCKET_ERROR']:
			print('Send Error: cannot sent the message to', socket.getsockname())
	MsgWin.insert(1.0, '\n['+userName+']: '+inputData)

	# clear the entry if success
	userentry.delete(0, END)
Exemplo n.º 25
0
def handshake(socket):
    socket.send(createMessage(msg_type=MSG_JOIN,
                              org_ip=socket.getsockname()[0]))
    response = socket.recv(1024)
    header, payload = parseReceivedMessage(response)
    # Join was successful
    if payload == ('0200'):
        global neighbours
        neighbours.append((header[6], header[4]))
        # Send PING type b to expand neighbourhood
        socket.send(createMessage(ttl=5, org_port=socket.getsockname()[1],
                                  org_ip=socket.getsockname()[0]))
        response = socket.recv(1024)
        header, payload = parseReceivedMessage(response)
        if len(payload) > 0:
            # Iterate through payload
            for i in range(1, len(payload)):
                # Add to neighbours if not already there
                if not (payload[i][0], payload[i][1]) in neighbours:
                    neighbours.append((payload[i][0], payload[i][1]))
            print("Neighbours:")
            print(neighbours)
Exemplo n.º 26
0
    def _bind_socket(self):
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            sock.bind((self.hostname, self.port))
        except OSError:
            logger.exception("Error occurred binding to %s on port %s",
                             self.hostname, self.port)
            raise

        if self.port == 0:
            self.port = socket.getsockname()[1]

        return sock
Exemplo n.º 27
0
 def __init__(self, socket):
     gps.GPSTransport.__init__(self)
     self.address = '%s:%s' % socket.getpeername()
     self.localaddress = '%s:%s' % socket.getsockname()
     self.socket = socket
     self.closeReason = None
     self.socketStatsEnabled = prefs.GetValue('socketStatsEnabled', False)
     self.statsBytesReadPerPacket = macho.EWMA.FromSampleCounts(GPSSTATS_BYTESREADPERPACKET_PERIODS)
     self.statsBytesWrittenPerPacket = macho.EWMA.FromSampleCounts(GPSSTATS_BYTESWRITTENPERPACKET_PERIODS)
     self.statsBytesRead = macho.EWMA.FromSampleCounts(GPSSTATS_BYTESREAD_PERIODS)
     self.statsBytesWritten = macho.EWMA.FromSampleCounts(GPSSTATS_BYTESWRITTEN_PERIODS)
     self.statsPacketsRead = macho.EWMA.FromSampleCounts(GPSSTATS_PACKETSREAD_PERIODS)
     self.statsPacketsWritten = macho.EWMA.FromSampleCounts(GPSSTATS_PACKETSWRITTEN_PERIODS)
Exemplo n.º 28
0
def cmd(socket, command_message):
    socket.send('2')
    prompt_str = socket.getsockname()[0] + ':' + str(socket.getsockname()[1])

    while True:
        try:
            print 'cmd mode'
            command = raw_input(prompt_str + ">")
            if len(command.split()) != 0:
                socket.send(command)
            else:
                continue
        except EOFError:
            print(
                "Invalid input, type 'help' to get a list of implemented commands.\n"
            )
            continue

        if command == "quit":
            break

        data = socket.recv(SOCKET_RECV_BYTES)
        print(data + "\n")
Exemplo n.º 29
0
def send_packet(socket, priority, poll, others, pdns):
    others_list = {}
    #pdns_list = []
    for o in others:
        #print socket.getpeername(), others[o]
        others_list[others[o]['ip']] = others[o]['priority']
    #for p in json.loads(pdns.value):
    #    pdns_list.append(p['ip'])
    packet = {  'ip': socket.getsockname()[0],
                'priority': priority.value,
                'last_poll': poll.value,
                'known_others': others_list }
                #'known_pdns': json.loads(pdns.value) }
    socket.sendall(json.dumps(packet)+"EOT")
Exemplo n.º 30
0
	def InputCmd(self,socket,port):   #此处使用的是控制信道
		state = True
		addr, socport = socket.getsockname()
		dataport = Createport()
		socket.send(b"DataPort="+bytes(dataport))
		while state:
			cmd = input('请输入命令')
			socket.send(bytes(cmd, encoding="utf-8"))  ##传输命令到服务器端
    		result = socket.recv(1024)
    		if result == b"0":
        		state = False
        		print("you are quit")
        	else:
    			DataTranfer(dataport,host,cmd)
Exemplo n.º 31
0
 def serveClient(self, key):
     clientSocket = key.fileobj
     data = key.data
     recivedData = clientSocket.recv(512)
     if (len(recivedData) > 0):
         print(f'Recived Data : {str(recivedData,ENCODIING)}')
         self.broadCastSend(
             f'{data["userName"]}:{str(recivedData,ENCODIING)}')
     else:
         print(f'Closing connection to{data["adress"]}')
         sel.unregister(clientSocket)
         for i, socket in enumerate(self.clients):
             if (socket.getsockname()[1] == clientSocket.getsockname()[1]):
                 del self.clients[i]
         clientSocket.close()
Exemplo n.º 32
0
def keep_socket_connection(socket):
    failed_attempts = 0
    while True:
        print "running"
        try:
            socket.send(' ')
            failed_attempts = 0
        except:
            if failed_attempts < NUM_OR_RETRIES:
                print 'Retry connecting to {socket} '.format(socket=socket)
                failed_attempts += 1
            else:
                break  # stop retrying
        sleep(1)
    print 'close connection the socket ', socket.getsockname()
Exemplo n.º 33
0
    def is_remote_mitm_server(self, host, port):
        """Check if the remote host:port is one of the MiTM server sockets.
        These connections should be avoided otherwise loops can be created where
        the MiTM tries to connect to the MiTM which then sees the remote as the MiTM
        and tries to connection and so on. This is best effort only, routing can still
        cause these loops.

        Returns if host:port belongs to one of the server sockets."""
        local_v4, local_v6 = util.get_interface_addresses()
        if host in local_v4 or host in local_v6:
            for socket in self._local_server_sockets:
                local = socket.getsockname()
                if local[1] == port:
                    return True
        return False
Exemplo n.º 34
0
def broadcast(server_socket, sock, message):
    for socket in SOCKET_LIST:
        # send the message only to peer
        if socket != server_socket and socket != sock:
            try:
                print("Sending message to")
                socket.sendto(message.encode('utf-8'), socket.getsockname())
            except:
                print(
                    "There was a broken connection and a message was aborted")
                # broken socket connection
                socket.close()
                # broken socket, remove it
                if socket in SOCKET_LIST:
                    SOCKET_LIST.remove(socket)
Exemplo n.º 35
0
 def broadcast(self, server_socket, sock, message):
     for socket in self.socket_lst:
         # Don't send message to server or who it came from
         if socket != server_socket and socket != sock:
             try:
                 print('sending msg')
                 socket.sendto(message.encode('utf-8'),
                               socket.getsockname())
                 print('sent', end='')
             except:
                 # socket broken
                 socket.close()
                 # broken sockets removed
                 if socket in self.socket_lst:
                     self.socket_lst.remove(socket)
    def is_remote_mitm_server(self, host, port):
        """Check if the remote host:port is one of the MiTM server sockets.
        These connections should be avoided otherwise loops can be created where
        the MiTM tries to connect to the MiTM which then sees the remote as the MiTM
        and tries to connection and so on. This is best effort only, routing can still
        cause these loops.

        Returns if host:port belongs to one of the server sockets."""
        local_v4, local_v6 = util.get_interface_addresses()
        if host in local_v4 or host in local_v6:
            for socket in self._local_server_sockets:
                local = socket.getsockname()
                if local[1] == port:
                    return True
        return False
Exemplo n.º 37
0
 def __init__(self, workerid, ppid, socket, app, timeout):
     self.id = workerid
     self.ppid = ppid
     self.timeout = timeout
     fd, tmpname = tempfile.mkstemp()
     self.tmp = os.fdopen(fd, "r+b")
     self.tmpname = tmpname
     
     # prevent inherientence
     self.close_on_exec(socket)
     self.close_on_exec(fd)
     
     self.socket = socket
     self.address = socket.getsockname()
     
     self.app = app
     self.alive = True
     
     self.log = logging.getLogger(__name__)
Exemplo n.º 38
0
 def __init__(self, socket, authtoken, handler=None, server=None):
     """Create a new message bus connection.
     
     The `socket` argument must be a connected socket and the `authtoken`
     argument must be the shared secret for hmac-magic-cookie-sha1
     authentication.  The `handler` argument, if provided, must be a
     MessageBusHandler instance that will be used to dispatch signals and
     method calls. If no handler is provided, signals and method calls to
     this connection end point will be ignored. The `server` argument, if
     provided, must be a MessageBusServer instance, and incidates that this
     connection is a server connection. Without a server argument this
     connection will be a client connection.
     """
     self.socket = socket
     self.authtoken = authtoken
     self.handler = handler
     self.server = server
     if self.server is None:
         self.name = str(socket.getsockname())
     else:
         self.name = self.server.name
     self.peer_name = str(socket.getpeername())
     self.next_serial = 1
     self.closed = False
     self.tracefile = None
     self.callbacks = []
     logger = logging.getLogger('bluepass.messagebus')
     context = 'connection %s:%s' % (self.name, self.peer_name)
     self.logger = logging.ContextLogger(logger, context)
     self.loop = self.Loop()
     self.method_calls = {}
     self._read_event = self.loop.create_watch(socket, self.loop.READ,
                                               self._do_read)
     self._write_event = self.loop.create_watch(socket, self.loop.WRITE,
                                                self._do_write)
     self._inbuf = self._outbuf = ''
     self._incoming = []; self._outgoing = []
     self._reading = self._writing = True
Exemplo n.º 39
0
def get_port(socket):
    """Return the port to which a socket is bound."""
    addr, port = socket.getsockname()
    return port
Exemplo n.º 40
0
 def __init__(self, socket, proto):
     self.host = socket.getsockname()
     self.peer = socket.getpeername()
     self.protocall = proto
     self.recevied_time = time.time()
Exemplo n.º 41
0
    def test_tcp_listener(self):
        socket = eventlet.listen(('0.0.0.0', 0))
        assert socket.getsockname()[0] == '0.0.0.0'
        socket.close()

        check_hub()
Exemplo n.º 42
0
                '''
                sendPacket.ref_timestamp = recvTimestamp-5
                sendPacket.SetOriginTimeStamp(timeStamp_high,timeStamp_low)
                sendPacket.recv_timestamp = recvTimestamp
                sendPacket.tx_timestamp = system_to_ntp_time(time.time())
                socket.sendto(sendPacket.to_data(),addr)
                print "Sended to %s:%d" % (addr[0],addr[1])
            except Queue.Empty:
                continue


listenIp = "0.0.0.0"
listenPort = 123
socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
socket.bind((listenIp,listenPort))
print "local socket: ", socket.getsockname();
recvThread = RecvThread(socket)
recvThread.start()
workThread = WorkThread(socket)
workThread.start()

while True:
    try:
        time.sleep(0.5)
    except KeyboardInterrupt:
        print "Exiting..."
        stopFlag = True
        recvThread.join()
        workThread.join()
        #socket.close()
        print "Exited"
Exemplo n.º 43
0
def process_message(header, payload, socket):
    # Discard messages with invalid version or ttl
    global q_searches
    global connections
    global neighbours
    if (header[0] == 1 or header[1] < 1 or header[1] > 5):
        if header[2] == MSG_PING:
            # Type a
            if header[1] == 1:
                print("Respond with PONG A")
                socket.send(createMessage(msg_type=MSG_PONG,
                                          org_port=socket.getsockname()[1],
                                          org_ip=socket.getsockname()[0]))
            # Type b
            else:
                tmp = list(neighbours)
                if (header[6], header[4]) in tmp:
                    tmp.remove((header[6], header[4]))
                response = tmp[:5]
                data = bytearray()
                if(len(response) > 0):
                    data.extend(struct.pack('>HH', len(response), 0))
                    for item in response:
                        data.extend(struct.pack('>IHH', ipToNum(item[0]),
                                                item[1], 0))
                print("Respond with PONG B")
                socket.send(createMessage(msg_type=MSG_PONG,
                                          org_port=socket.getsockname()[1],
                                          org_ip=socket.getsockname()[0],
                                          payload=data))
        elif header[2] == MSG_PONG:
            # Pong type b
            if len(payload) > 0:
                # Iterate through payload
                for i in range(1, len(payload)):
                    # Add to neighbours if not already there
                    if not (payload[i][0], payload[i][1]) in neighbours:
                        neighbours.append((payload[i][0], payload[i][1]))
        elif header[2] == MSG_BYE:
            if (header[6], header[4]) in neighbours:
                neighbours.remove((header[6], header[4]))
                print("Neighbours:")
                print(neighbours)
            if (header[6], socket) in connections:
                connections.remove((header[6], socket))

        elif header[2] == MSG_JOIN:
            if not (header[6], header[4]) in neighbours:
                neighbours.append((header[6], header[4]))
                print("Neighbours:")
                print(neighbours)
            data = bytearray()
            data.append(0x02)
            data.append(0x00)
            print("Respond with JOIN OK")
            socket.send(createMessage(msg_type=MSG_JOIN,
                                      org_port=socket.getsockname()[1],
                                      org_ip=socket.getsockname()[0],
                                      payload=data))
        elif header[2] == MSG_QUERY:
            # Check if key is known
            if payload[0] in keys:
                data = struct.pack('>HHHH4s', 1, 0, 1, 0,
                                   binascii.unhexlify(keys[payload[0]]))
                print("Respond with QUERY HIT")
                socket.send(createMessage(msg_type=MSG_QHIT,
                                          org_port=socket.getsockname()[1],
                                          org_ip=socket.getsockname()[0],
                                          payload=data, msg_id=header[7]))
            # Save search
            q_searches.append((header[6], header[7]))
            # Forward to other nodes
            forward(header, payload, socket)
        elif header[2] == MSG_QHIT:
            # Check if known message id
            for (x, y) in q_searches:
                if y == header[7]:
                    # Check if connection exists with given ip address
                    for (a, b) in connections:
                        if a == x:
                            data = bytearray()
                            data.extend(struct.pack('>HH', payload[0], 0))
                            for i in range(payload[0]):
                                data.extend(
                                    struct.pack('>HH4s', i+1, 0,
                                                binascii.unhexlify(
                                                    payload[1][i+1])))
                            b.send(createMessage(msg_type=MSG_QHIT,
                                                 org_port=header[4],
                                                 org_ip=header[6],
                                                 payload=data, msg_id=y))
Exemplo n.º 44
0
 def recvFrom(self, socket):
   print "Listening on ".format(socket.getsockname())
   while True:
     chunk = self.readChunk(socket)
     audio = self.netToAudio.convert(chunk)
     self.speaker.play(audio)