def process_rerr_message(self, message): self.logger.debug("Processing RERR message %s" % message) message_type = message['type'] sender = message['sender'] dest_addr = message['dest_addr'] dest_sequence = message['dest_sequence'] # IF THERE IS ADDINTIONAL INFO IN THE PACKET, PROCESS THIS FIRST if message.get('op_info'): additional_info = message.get('op_info') for rt in additional_info: route = bd_connect.consult_target(rt['dest_addr']) if route: if route[0].get('next_hop') == sender: bd_connect.update_routing_table( ('status', 0, 'ID', route[0].get('ID'))) # Process message only if there is an active route # to the destination where next hop IP address is the same # as the sender IP address in the packet received. target = bd_connect.consult_target(dest_addr) if target: if target[0].get('next_hop') == sender: bd_connect.update_routing_table( ('status', 0, 'ID', target[0].get('ID'))) self.forward_rerr(message)
def process_rrep(self, message): self.logger.debug("Processing RREP message %s" % message) sender = message["sender"] source_addr = message["source_addr"] hop_count = int(message["hop_cnt"]) + 1 message['hop_cnt'] = str(hop_count) dest_addr = message["dest_addr"] dest_sequence = message["dest_sequence"] routing_list = ( source_addr, sender, dest_sequence, hop_count, 1, 1, ) if self.localhost == dest_addr: record = bd_connect.consult_target(source_addr) if record: if record[0].get('hop_count') > hop_count: bd_connect.insert_routing_table(routing_list) else: bd_connect.insert_routing_table(routing_list) find_rt_end_time = time.time() final_time = find_rt_end_time - self.times_dict[source_addr] self.logger.info("Route to %s found in %s" % (source_addr, final_time)) for msg in self.message_pend_list: self.logger.debug("[process_rrep] Evaluating: %s" % msg) if msg['dest_addr'] == source_addr: next_hop = sender self.send(next_hop, msg) self.message_pend_list.remove(msg) else: record = bd_connect.consult_target(source_addr) if record: bd_connect.update_routing_table( ('status', 1, 'ID', record[0].get('ID'))) bd_connect.update_routing_table( ('target_seq_number', dest_sequence, 'ID', record[0].get('ID'))) else: bd_connect.insert_routing_table(routing_list) record = bd_connect.consult_target(dest_addr) self.forward_rrep(message, record[0].get('next_hop'))
def process_user_message(self, message): source = message['source_addr'] dest = message['dest_addr'] data = message['data'] if self.localhost == dest: self.logger.info('Message received: %s' % data) else: route = bd_connect.consult_target(dest) self.send(route[0].get('next_hop'), message)
def process_neighbor_timeout(self, node): self.logger.debug("Timeout activated for %s" % node) target = bd_connect.consult_target(node) bd_connect.update_routing_table( ('status', 0, 'ID', target[0].get('ID'))) next_hop_list = bd_connect.consult_next_hop(node) route_nh_list = [] for rt in next_hop_list: obj = {} obj['dest_addr'] = rt['target_address'] obj['dest_sequence'] = rt['target_seq_number'] route_nh_list.append(obj) # Send RERR self.send_rerr(node, target[0].get('target_seq_number'), route_nh_list)
def notify_network(self, msg): self.logger.debug("Notifying to nodes %s" % self.nodes) if self.nodes: #CONSULT NEIGHBOR IP ADDRESS IN BD ROUTING TABLE for ngh in self.nodes: message = { 'type': 'notify', 'source_addr': self.localhost, 'dest_addr': ngh, 'data': msg } target = bd_connect.consult_target(ngh) self.logger.debug("Record %s" % target) if target: self.logger.info("Target %s found " % ngh) self.send(target[0].get('next_hop'), message) else: self.logger.info("Target %s not found" % ngh) self.times_dict[ngh] = time.time() self.send_rreq(ngh, -1) self.message_pend_list.append(message)
def process_hello_message(self, message): sender = message['sender'] try: if sender in self.neighbors.keys(): ngh = self.neighbors[sender] timer = ngh['timer'] timer.cancel() timer = th.Timer(AODV_HELLO_TIMEOUT, self.process_neighbor_timeout, [sender]) self.neighbors[sender] = {'neighbor': sender, 'timer': timer} timer.start() else: timer = th.Timer(AODV_HELLO_TIMEOUT, self.process_neighbor_timeout, [sender]) self.neighbors[sender] = {'neighbor': sender, 'timer': timer} timer.start() self.logger.debug("Neighbor added: %s" % sender) if bd_connect.consult_target(sender): #RESTART ROUTE LIFETIME (PENDING) pass else: route = ( sender, #Target sender, #Next_hop 1, #Target sequence number 1, #Hop count 1, #Status 1, #Lifetime ) bd_connect.insert_routing_table(route) #RESTART ROUTE LIFETIME (PENDING) except: pass
def process_rreq(self, message): self.logger.debug("Processing RREQ message %s" % message) message = message message_type = message['type'] sender = message['sender'] hop_count = int(message['hop_cnt']) + 1 message['hop_cnt'] = str(hop_count) broadcast_id = int(message['broadcast_id']) dest_addr = message['dest_addr'] dest_sequence = int(message['dest_sequence']) source_addr = message['source_addr'] source_sequence = int(message['source_sequence']) routing_list = ( source_addr, sender, dest_sequence, hop_count, 1, #Lifetime 1, #status ) # Discard this RREQ if we have already received this before rt_record = bd_connect.consult_target(source_addr) if bd_connect.consult_duplicate((source_addr, broadcast_id)): self.logger.debug("RREQ duplicate found!") return elif rt_record: # 1. If originator sequence number in packet is bigger than destination sequence in routing table # Update target sequence number in DB. # # 2. If originator sequence number and destination sequence number are equal, but hop count in DB # is bigger than hop count in packet, update hop count in DB. # # 3. If detination sequence number is unknown (-1), update sequence number in DB. if int(rt_record[0].get("target_seq_number")) < source_sequence: bd_connect.update_routing_table( ("target_seq_number", source_sequence, 'ID', rt_record[0].get("ID"))) elif int(rt_record[0].get("target_seq_number")) == source_sequence: if rt_record[0].get("hop_count") > hop_count: bd_connect.update_routing_table( ("hop_count", hop_count, 'ID', rt_record[0].get("ID"))) bd_connect.update_routing_table( ("next_hop", sender, 'ID', rt_record[0].get("ID"))) elif int(rt_record[0].get("target_seq_number") == -1): bd_connect.update_routing_table( ("target_seq_number", source_sequence, 'ID', rt_record[0].get("ID"))) else: # If there's no route to destination, and originator is not the # same as node IP address, add entry if source_addr != self.localhost: bd_connect.insert_routing_table(routing_list) bd_connect.insert_rreq((source_addr, broadcast_id)) # Check if localhost is the destination. If it is, generate and send an # RREP back. if (self.localhost == dest_addr): self.send_rrep(source_addr, sender, dest_addr, dest_addr, 0, 0) # Localhost is not the destination. Check if this node has a valid route # to the destination. If it does, generate and send back an # RREP. else: target = bd_connect.consult_target(dest_addr) self.logger.debug("[process_rreq] Target Record %s" % target) if (target): # Verify that the route is valid and has a higher seq number if target[0].get("target_seq_number") >= dest_sequence: self.send_rrep(source_addr, sender, self.localhost, dest_addr, target[0].get("target_seq_number"), target[0].get("hop_count")) else: self.forward_rreq(message)