def protocol4(ps): next_frame_to_send = protocol.SequenceNumber(0, MAX_SEQ) frame_expected = protocol.SequenceNumber(0, MAX_SEQ) r = protocol.Frame() s = protocol.Frame() buffer = protocol.Packet() ps.from_network_layer(buffer) s.info = buffer s.seq = next_frame_to_send.copy() s.ack = frame_expected.opposite() ps.to_physical_layer(s) ps.start_timer(s.seq.value) while True: event = ps.wait_for_event() if event == protocol.frame_arrival: r = ps.from_physical_layer() if r.seq == frame_expected: ps.to_network_layer(r.info) frame_expected.inc() if r.ack == next_frame_to_send: ps.stop_timer(r.ack.value) ps.from_network_layer(buffer) next_frame_to_send.inc() s.info = buffer s.seq = next_frame_to_send.copy() s.ack = frame_expected.opposite() ps.to_physical_layer(s) ps.start_timer(s.seq.value)
def sender1(ps): while True: buffer = protocol.Packet() ps.from_network_layer(buffer) s = protocol.Frame() s.info = buffer ps.to_physical_layer(s)
def protocol5(ps): ack_expected = protocol.SequenceNumber(0,MAX_SEQ) next_frame_to_send = protocol.SequenceNumber(0,MAX_SEQ) frame_expected = protocol.SequenceNumber(0,MAX_SEQ) nbuffered = 0 buffer = map(lambda x:protocol.Packet(),range(MAX_SEQ+1)) ps.enable_network_layer() while True: event = ps.wait_for_event() if event == protocol.network_layer_ready: ps.from_network_layer(buffer[next_frame_to_send.value]) nbuffered = nbuffered + 1 send_data(next_frame_to_send,frame_expected,buffer,ps) next_frame_to_send.inc() elif event == protocol.frame_arrival: r = ps.from_physical_layer() if r.seq == frame_expected: ps.to_network_layer(r.info) frame_expected.inc() while (r.ack.between(ack_expected,next_frame_to_send)): nbuffered = nbuffered-1 ps.stop_timer(ack_expected.value) ack_expected.inc() elif event == protocol.timeout: next_frame_to_send = ack_expected.copy() for i in range(1,nbuffered+1): send_data(next_frame_to_send,frame_expected,buffer,ps) next_frame_to_send.inc() if nbuffered < MAX_SEQ: ps.enable_network_layer() else: ps.disable_network_layer()
def process_triggered_updates(self, routes): """ Processes the triggered updates. """ sock = self.input_ports[0] for output_port in self.config.output_ports: packet_routes = [{ "destination": route.destination, "cost": 16, "next-hop": self.config.router_id } for route in routes] p = protocol.Packet(output_port.cost, packet_routes) sock.sendto(p.to_data(), ('localhost', output_port.port))
def sender3(ps): buffer = protocol.Packet() ps.from_network_layer(buffer) next_frame_to_send = 0 while True: s = protocol.Frame() s.info = buffer s.seq = next_frame_to_send print("sending", s.seq) ps.to_physical_layer(s) print("starting", s.seq) ps.start_timer(s.seq) event = ps.wait_for_event() if event == protocol.frame_arrival: s = ps.from_physical_layer() print("got ack", s.ack) if s.ack == next_frame_to_send: print("ack was desired") print("stopping", s.ack) ps.stop_timer(s.ack) ps.from_network_layer(buffer) # in stop-and-wait PAR, seq changes as next_frame_to_send = 1 - next_frame_to_send
def process_periodic_update(self, dt): """ Called when the periodic timer is triggered. """ # send destination, next hop and total cost of each routing entry to each input port sock = self.input_ports[0] for output_port in self.config.output_ports: # add self to the routes routes = [{ "destination": self.config.router_id, "cost": 0, "next-hop": self.config.router_id }] # if len(self.rt) == 0: # self.log("advertising self to " + str(output_port.router_id)) for route in self.rt: cost = route.cost destination = route.destination # poison reverse by setting cost to 16 when announcing routes back from where they were learned if self.rt[destination].nextHop == output_port.router_id: cost = 16 routes.append({ "destination": destination, "cost": cost, "next-hop": self.config.router_id }) packet = protocol.Packet(output_port.cost, routes) sock.sendto(packet.to_data(), ('localhost', output_port.port))
def process_incoming_data(self, addr, data): """ Called when incoming data is received. The data returned from this function is sent back through the socket. If None is returned, nothing will be sent. """ triggered_updates = [] packet = protocol.Packet() if not packet.from_data(data): self.log("invalid packet hash") return if packet.link_cost < 0: return for route in packet.routes: route_destination = route["destination"] route_cost = route["cost"] route_next_hop = route["next-hop"] destination_entry = self.rt[route_destination] # Check route is valid before any processing is done # route lists ourself as the destination (useless) or as the next hop (invalid) and should be dropped if route_destination == self.config.router_id or route_next_hop == self.config.router_id: continue # don't process if the route is invalid if not self.is_valid_route(route_destination, route_cost, route_next_hop): continue # route is valid and should be processed # total cost is the link cost added to the cost contained in the packet total_destination_cost = route_cost + packet.link_cost is_destination_unreachable = (total_destination_cost >= 16) # clamp cost to maximum of 16 if is_destination_unreachable: total_destination_cost = 16 # is the destination routerID known is_destination_in_table = destination_entry is not None # New valid route if not is_destination_in_table and not is_destination_unreachable: # put the destination in the table self.rt.add_entry(route_destination, route_next_hop, total_destination_cost) self.log("added new router " + str(route_destination) + " via " + str(route_next_hop) + " with a cost of " + str(total_destination_cost)) # Route already exists in table elif is_destination_in_table: is_destination_garbage = destination_entry.garbage # Check for a better route. if total_destination_cost < destination_entry.cost: self.rt.set_cost(route_destination, total_destination_cost) self.rt.set_garbage(route_destination, False) self.rt.set_next_hop(route_destination, route_next_hop) self.log("found new route to " + str(route_destination) + " via " + str(route_next_hop) + " with a cost of " + str(total_destination_cost)) # Check for worse route from the same hop elif route_next_hop == destination_entry.nextHop and total_destination_cost > destination_entry.cost: if is_destination_unreachable: # garbage it if we haven't seen it before, otherwise ignore it if not is_destination_garbage: self.rt.set_garbage(route_destination, True) triggered_updates.append(destination_entry) self.log("processed a triggered update from " + str(packet.routes[0]["next-hop"]) + " marked " + str(route_destination) + " as garbage") # We got a worse route from the samehop but its not infinite. As a neighbour we MUST update to the higher cost. else: self.rt.set_cost(route_destination, total_destination_cost) self.rt.reset_age(route_destination) # Check for worse route from a different hop and ignore it elif total_destination_cost > destination_entry.cost: #self.log("Worse route to " + str(route_destination) + " ignoring it") continue # Check for same route and keep it alive elif route_next_hop == destination_entry.nextHop and total_destination_cost == destination_entry.cost: # We dont want to keep alive infinite weight routes if not is_destination_garbage: self.rt.reset_age(route_destination) if len(triggered_updates) > 0: self.log("sending triggered updates") self.process_triggered_updates(triggered_updates) return None
HEAD = protocol.HEAD TAIL = protocol.TAIL DISCONNECT_MESSAGE = '!DISCONNECT' client = protocol.Client() client.connect() try: PKT_BUFFER = int(input("Enter packet buffer size: ")) except: PKT_BUFFER = 10 first_acknowledgement = str(PKT_BUFFER) client.send(first_acknowledgement) packet = protocol.Packet(PKT_BUFFER) message = "Hello, I am a client. I am sending this message. Happy coding!" packet.append_msg(message) active = True while active: # input() buffer = protocol.from_network_layer(packet) if buffer == None: print(f"[NOTE] No more message left.") more_msg = input( "Enter new message to send OR press ENTER to DISCONNECT: ") if more_msg: packet.append_msg(more_msg) continue
def send_ack(self, pid, error = False): self.log("Sending ACT to: %d" % pid, log.DEBUG) p = pr.Packet(pr.PACKET_ACK, {"error": error, "id": pid}) self.ack_bin_data += self.packet_to_bin(p)
def protocol6(ps): global no_nak r = protocol.Frame() out_buf = mod_list(map(lambda x: protocol.Packet(), range(NR_BUFS))) in_buf = mod_list(map(lambda x: protocol.Packet(), range(NR_BUFS))) arrived = mod_list(map(lambda x: False, range(NR_BUFS))) def dump(): for i in range(NR_BUFS): ps.println(str(("dump", i, "arrived", arrived[i]))) for i in range(NR_BUFS): ps.println(str(("dump", i, "in_buf", in_buf[i].data))) for i in range(NR_BUFS): ps.println(str(("dump", i, "out_buf", out_buf[i].data))) ps.enable_network_layer() ack_expected = protocol.SequenceNumber(0, MAX_SEQ) next_frame_to_send = protocol.SequenceNumber(0, MAX_SEQ) frame_expected = protocol.SequenceNumber(0, MAX_SEQ) too_far = protocol.SequenceNumber(NR_BUFS, MAX_SEQ) nbuffered = 0 while True: event = ps.wait_for_event() if event == protocol.network_layer_ready: nbuffered = nbuffered + 1 ps.from_network_layer(out_buf[next_frame_to_send.value]) send_frame(protocol.data, next_frame_to_send, frame_expected, out_buf, ps) next_frame_to_send.inc() elif event == protocol.frame_arrival: r = ps.from_physical_layer() if r.kind == protocol.data: if r.seq != frame_expected and no_nak: send_frame(protocol.nak, protocol.SequenceNumber(0, MAX_SEQ), frame_expected, out_buf, ps) else: ps.start_ack_timer() if r.seq.between(frame_expected, too_far) and arrived[r.seq.value] == False: arrived[r.seq.value] = True in_buf[r.seq.value] = r.info while (arrived[frame_expected.value]): ps.to_network_layer(in_buf[frame_expected.value]) no_nak = False arrived[frame_expected.value] = False frame_expected.inc() too_far.inc() ps.start_ack_timer() else: if r.seq.between(frame_expected, too_far): pass else: pass if arrived[r.seq.value] == False: pass else: pass if r.kind == protocol.nak and r.ack.copy().inc().between( ack_expected, next_frame_to_send): send_frame(protocol.data, r.ack.copy().inc(), frame_expected, out_buf, ps) while r.ack.between(ack_expected, next_frame_to_send): nbuffered = nbuffered - 1 ps.stop_timer(ack_expected.value) ack_expected.inc() elif event == protocol.cksum_err: if no_nak: send_frame(protocol.nak, protocol.SequenceNumber(0, MAX_SEQ), frame_expected, out_buf, ps) elif event == protocol.timeout: send_frame(protocol.data, protocol.SequenceNumber(event.value, MAX_SEQ), frame_expected, out_buf, ps) elif event == protocol.ack_timeout: send_frame(protocol.ack, protocol.SequenceNumber(0, MAX_SEQ), frame_expected, out_buf, ps) if nbuffered < NR_BUFS: ps.enable_network_layer() else: ps.disable_network_layer()