def send(self, msg): """Send message (TCP).""" message = networking.build_message(networking.SEND, id=self.id, payload=msg) # print '[ParrotSocket %s] send: %s' % (self.id, message) self.comm_chan.send_cmd(message, self)
def connect(self, sender, **params): # Incoming client connection request client_cid, server_ip, server_port = (params['id'], params['ip'], params['port']) server_cids =self.lookup(server_ip, server_port) if not server_cids: print "\033[31m" print "NO MATCHING SERVER" print " Message: ", params print " Network: ", self.description() print " Sender: ", sender.description() print "-------------\033[0m" return False # Inform the server server_cid = server_cids[0] server_connection_cid = str(uuid.uuid4()) server_interface = self.listeners[server_cid]['interface'] msg = networking.build_message(networking.NEW_CONN, id=server_cid, new_id=server_connection_cid) server_interface.send(msg) # Mapping from connection_id to interface self.mapping[client_cid] = server_interface self.mapping[server_connection_cid] = sender self.connections[client_cid] = server_connection_cid self.connections[server_connection_cid] = client_cid return True
def accept(self, sender, **params): # Acknowledge to other end of connection src_cid = params['id'] dst = self.mapping[src_cid] msg = networking.build_message(networking.ACCEPTED, id=self.connections[src_cid]) dst.send(msg) return True
def __init__(self, node, family=AF_INET, type=SOCK_STREAM, proto=0, **kwargs): """ Create a ParrotSocket node -- node for which this socket is simulated (caller) family -- only AF_INET (default) supported type -- either SOCK_STREAM (default) or SOCK_DGRAM proto -- protocol number, usually zero (default) kwargs -- internal use only, see implementation of accept() """ self.node = node self._family = family self._type = type self._proto = proto self.comm_chan = node.comm_chan self.ip = "0.0.0.0" self.port = None self.pending_op = None self.pending_params = None self.queue = Queue.Queue() self.name = kwargs.get('iface_name', 'UNASSIGNED') new_uuid = str(uuid.uuid4()) self.id = kwargs.get('id', new_uuid) # is_connect_event implies socket was created in response to a CONNECT is_connect_event = (self.id != new_uuid) # NB. While it's OK to register a serial device as ser0, ser1, etc., # that is NOT possible for sockets, so we use the id instead. self.comm_chan.register_handler_for_interface(self.id, self._set_data) if is_connect_event: msg = networking.build_message(networking.ACCEPT, id=self.id) self.comm_chan.send_cmd(msg, self)
def send(self, sender, **params): # Relay to other end of connection src_cid, payload = (params['id'], params['payload']) dst = self.mapping[src_cid] msg = networking.build_message(networking.RECEIVED, id=self.connections[src_cid], payload=payload) dst.send(msg) return True
def close(self): """Close the socket.""" if self.comm_chan.has_registered_handler(self.id): # self._dump_queue() message = networking.build_message(networking.DISCONN, id=self.id) self.comm_chan.send_cmd(message, self) self.comm_chan.unregister_handler_for_interface(self.id)
def sendto(self, data, address): """Send `data` (UDP) to an `address` which is a tuple of (ip, port).""" if not self.port: self._assign_port() message = networking.build_message(networking.SENDTO, id=self.id, src_port=self.port, dst_ip=address[0], dst_port=address[1], payload=data) # print '[ParrotSocket %s] send: %s' % (self.id, message) self.comm_chan.send_cmd(message, self)
def listen(self, backlog=5): """Listen for connections made to the socket. The `backlog` argument is currently unused.""" # FIXME: backlog msg = networking.build_message(networking.LISTEN, id=self.id, ip=self.ip, port=self.port) self.comm_chan.send_cmd(msg, self)
def _become_active_listener(self, assign_port = True): ## Inform BP that we are listening. if not self.port: if not assign_port: raise SocketException("Parrot UDP socket has no assigned port") else: self._assign_port() message = networking.build_message(networking.RECVFROM, id=self.id, ip=self.ip, port=self.port) self.comm_chan.send_cmd(message, self)
def disconnect(self, sender, **params): src_cid = params['id'] # If source is TCP inform other end of connection that we're closing if src_cid in self.mapping: dst = self.mapping[src_cid] msg = networking.build_message(networking.DISCONN, id=self.connections[src_cid]) dst.send(msg) self.remove_from_map(src_cid) return True
def _become_active_listener(self, assign_port=True): ## Inform BP that we are listening. if not self.port: if not assign_port: raise SocketException("Parrot UDP socket has no assigned port") else: self._assign_port() message = networking.build_message(networking.RECVFROM, id=self.id, ip=self.ip, port=self.port) self.comm_chan.send_cmd(message, self)
def connect(self, address): """Connect to an address where `address` is a tuple of (ip, port).""" self.name = self.interface_lookup(address[0]); message = networking.build_message(networking.CONNECT, id=self.id, ip=address[0], port=address[1]) # print '[ParrotSocket %s] connect: %s (%s)' % (self.id, message, self.name) self.comm_chan.send_cmd(message, self) # Block here waiting for ACCEPT from server message = self.queue.get() op, params = networking.parse_message(message) if op != networking.ACCEPTED or params['id'] != self.id: raise SocketException("Failed in connecting")
def sendto(self, sender, **params): # e.g. SENDTO 79c1fb86-3c97-4c19-80ae-92e9e02251c1 2137 10.1.2.2 4321 Hello over UDP (src_cid, src_port, dest_ip, dest_port, payload) = (params['id'], params['src_port'], params['dst_ip'], params['dst_port'], params['payload']) src_ip = sender.properties['ip'] dest_ids = self.lookup(dest_ip, dest_port) if not dest_ids: return True # This is UDP, no guarantees! dst_id = dest_ids[0] dst = self.listeners[dst_id]['interface'] msg = networking.build_message(networking.RECDFROM, id=dst_id, dst_port=dest_port, src_ip=src_ip, src_port=src_port, payload=payload) dst.send(msg) return True
def connect(self, address): """Connect to an address where `address` is a tuple of (ip, port).""" self.name = self.interface_lookup(address[0]) message = networking.build_message(networking.CONNECT, id=self.id, ip=address[0], port=address[1]) # print '[ParrotSocket %s] connect: %s (%s)' % (self.id, message, self.name) self.comm_chan.send_cmd(message, self) # Block here waiting for ACCEPT from server message = self.queue.get() op, params = networking.parse_message(message) if op != networking.ACCEPTED or params['id'] != self.id: raise SocketException("Failed in connecting")