def init_trigger_update(self, changed, src):
for neighbour in self.neighbours:
if neighbour != src:
packet = Packet(self.router_id, neighbour, changed)
self.send_packet(packet)
return
def send_package(self):
for i in self.neighbours:
print 'enviando custos para o vizinho: ', i
p = Packet(self.id, i, self.paths)
self.tolayer2(p)
def genPacket(self):
packet = Packet(self.tickCounter, self.packetServiceTime)
self.totalGenPacket += 1
self.sendPacket(packet)
def send_client_port(self, socket, address):
self.client_num += 1
self.client_port = self.port+self.client_num
pkt = Packet(seqno=0, data=self.client_port.__str__().encode()).pack()
socket.sendto(pkt, address)
def create_user_exists_response(addr, socket):
packet = Packet()
packet.pack(type=RESPONSE, message="User already registered")
send_response(addr, packet, socket)
print("-> Response sent to user.")
def menu():
choice = '1'
nazwa = str
obraz = int
damageSize = int
zbiorPakietow = []
kolejka = []
kolejkaZwrotna = []
pakiety = []
# xSize = int
# ySize = int
efektPrawieKoncowy = []
while choice != '0':
print("Co chcesz zrobić?\n")
print(
"1. Wczytaj plik\n2. Ustaw prawdopodobienstwo bledu\n3. Przesylaj plik za pomoca StopAndWait"
)
print(
"4. Przesylaj plik za pomoca GoBackN\n5. Zapisz plik\n6. Wyswietl pomiary\n\n0. Wyjscie\n\nTwoj wybor: "
)
choice = input()
if (choice == '1'):
print("\nPodaj nazwe pliku: ")
nazwa = input()
# nazwa = "lena.bmp"
obraz = loadImage(nazwa)
xSize = obraz[0].size
ySize = int(obraz.size / xSize)
for line in obraz:
for element in line:
pakiety.append(Packet(int(element)))
print("\nObraz załadowany pomyślnie!")
# print(pakiety[100].checkIfDamaged())
# pakiety[100].damageData(0.01)
# print(pakiety[100].checkIfDamaged())
# print(pakiety[100].getIndex())
elif (choice == '2'):
print("Podaj szansę na wystąpienie błędu (0 - 100%): ")
damageSize = int(input())
# damageSize = 10.01
damageSize = damageSize / 100
elif (choice == '3'):
notEnd = True
canSend = True
iterator = 0
packetsSent = 0
packetsReceived = 0
packetsRetransmitted = 0
damagedPacketsSent = 0
sent = []
kolejka.append(0)
kolejka.append(0)
kolejka.append(0)
kolejka.append(0)
kolejkaZwrotna.append(0)
kolejkaZwrotna.append(0)
kolejkaZwrotna.append(0)
kolejkaZwrotna.append(0)
print(len(kolejka))
while notEnd:
if kolejkaZwrotna[len(kolejkaZwrotna) - 1] == 2:
packetsSent = packetsSent - 1
print("Otrzymano polecenie retransmiji")
packetsRetransmitted = packetsRetransmitted + 1
canSend = True
if kolejkaZwrotna[len(kolejkaZwrotna) - 1] == 1:
print("Otrzmano żądanie kolejnego pakietu")
canSend = True
kolejkaZwrotna.pop()
if canSend:
toSend = copy.deepcopy(pakiety[packetsSent])
toSend.damageData(damageSize)
packetsSent = packetsSent + 1
print("Wyslano pakiet nr " + str(packetsSent))
if toSend != 0:
sent.insert(0, toSend)
toSend = 0
canSend = False
kolejka.insert(0, 1)
else:
kolejka.insert(0, 0)
if kolejka[len(kolejka) - 1] == 1:
recieved = sent[0]
sent.pop()
if not recieved.checkIfDamaged():
if recieved.checkIfDamagedCRC():
damagedPacketsSent = damagedPacketsSent + 1
packetsReceived = packetsReceived + 1
zmienna = 0
for i, bit in enumerate(recieved.data):
zmienna = zmienna + recieved.data[i] * pow(
2, Packet.PACKET_SIZE - 1 - i)
efektPrawieKoncowy.append(zmienna)
kolejkaZwrotna.insert(0, 1)
print("Otrzymano pakiet nr " + str(packetsReceived))
print("Wysylam żądanie następnego pakietu")
elif recieved.checkIfDamaged():
kolejkaZwrotna.insert(0, 2)
packetsRetransmitted = packetsRetransmitted + 1
print(
"Pakiet uszkodzony! Wysyłam żądanie retransmisji")
print("Upłynęło jednostek czasu " + str(iterator))
elif kolejka[len(kolejka) - 1] == 0:
# kolejkaZwrotna.append(0)
kolejkaZwrotna.insert(0, 0)
kolejka.pop()
iterator = iterator + 1
if packetsReceived == obraz.size:
notEnd = False
print(packetsRetransmitted)
elif (choice == '4'):
notEnd = True
canSend = True
window = 5
iterator = 0
# packetsSent = 0
neededPacket = 0
packetsReceived = 0
packetsRetransmitted = 0
toResend = []
sent = []
kolejka.append(0)
kolejka.append(0)
kolejka.append(0)
kolejka.append(0)
kolejkaZwrotna.append(0)
kolejkaZwrotna.append(0)
kolejkaZwrotna.append(0)
kolejkaZwrotna.append(0)
damagedPacketsSent = 0
Sn = 0 #sequencenumber
Sb = 0 #sequencebase
Sm = window - 1 #sequencemax
print(len(kolejka))
while notEnd:
if kolejkaZwrotna[len(kolejkaZwrotna) - 1] == 2:
Sb = copy.deepcopy(toResend[len(toResend) - 1])
Sn = copy.deepcopy(Sb)
toResend.pop()
print("Otrzymano polecenie retransmiji pakietu " + str(Sb))
if kolejkaZwrotna[len(kolejkaZwrotna) - 1] == 1:
if Sm < obraz.size:
Sb = Sb + 1
Sm = Sm + 1
if Sn < Sm and Sn < obraz.size:
toSend = copy.deepcopy(pakiety[Sn])
toSend.damageData(damageSize)
Sn = Sn + 1
print("Wyslano pakiet nr " + str(Sn - 1))
kolejkaZwrotna.pop()
if toSend != 0:
sent.insert(0, toSend)
toSend = 0
kolejka.insert(0, 1)
else:
kolejka.insert(0, 0)
if kolejka[len(kolejka) - 1] == 1:
recieved = copy.deepcopy(sent[len(sent) - 1])
sent.pop()
packetNumber = recieved.getIndex()
# print("PacketNumber: " + str(packetNumber))
# print("NeededPacket: " + str(neededPacket))
if not recieved.checkIfDamaged():
if packetNumber == neededPacket:
if recieved.checkIfDamagedCRC():
damagedPacketsSent = damagedPacketsSent + 1
neededPacket = neededPacket + 1
packetsReceived = packetsReceived + 1
zmienna = 0
for i, bit in enumerate(recieved.data):
zmienna = zmienna + recieved.data[i] * pow(
2, Packet.PACKET_SIZE - 1 - i)
efektPrawieKoncowy.append(zmienna)
kolejkaZwrotna.insert(0, 1)
print("Otrzymano pakiet nr " + str(packetNumber))
print("Wysylam żądanie pakietu " +
str(neededPacket))
else:
kolejkaZwrotna.insert(0, 0)
elif recieved.checkIfDamaged():
kolejkaZwrotna.insert(0, 2)
packetsRetransmitted = packetsRetransmitted + 1
print(
"Pakiet uszkodzony! Wysyłam żądanie retransmisji pakietu "
+ str(neededPacket))
toResend.insert(0, copy.deepcopy(neededPacket))
elif kolejka[len(kolejka) - 1] == 0:
kolejkaZwrotna.insert(0, 0)
kolejka.pop()
iterator = iterator + 1
print("Upłynęło jednostek czasu " + str(iterator))
if len(efektPrawieKoncowy) == obraz.size:
notEnd = False
# print(packetsRetransmitted)
elif (choice == '5'):
efektKoncowy = np.ndarray((ySize, xSize), np.int32)
i2 = xSize + 1
i3 = xSize
ii = 0
ii2 = 0
for i, zmienna2 in enumerate(efektPrawieKoncowy):
if (i % i2 == i3):
i2 = xSize
i3 = 0
ii = ii + 1
ii2 = 0
efektKoncowy[ii][ii2] = np.int32(zmienna2)
ii2 = ii2 + 1
saveImage(efektKoncowy, ("sent" + nazwa))
print("Obraz zapisano pomyślnie!")
elif (choice == '6'):
print("\nRozmiar pliku = " + str(obraz.size))
print("Wymiary: " + str(xSize) + "x" + str(ySize))
print("Uzycie pasma transmisji w %: " +
str((obraz.size + packetsRetransmitted) / iterator * 100))
print("Uszkodzone pakiety przeslane jako poprawne: " +
str(damagedPacketsSent))
print("Ilosc pakietow wyslana ponownie: " +
str(packetsRetransmitted))
print(
"Ilosc jednostek czasu ktorych wymagalo przeslanie obrazka dla czasu przesylu 4: "
+ str(iterator))
print("Prawdopodobienstwo odwrocenia bitu w %: " +
str(damageSize * 100) + "\n\n")
elif (choice == '0'):
choice = '0'
else:
choice = '1'
def start(self):
"""
Starts the send/receive loop of the Selective Repeat server
"""
# get first packet that has the file name
request_pkt = Packet(packet_bytes=self.client_entry.queue.get())
file_name = request_pkt.data
LOGGER.info('Recieved Request for file: {}'.format(file_name))
# List of packets
packets = Packet.get_file_packets(file_name, PACKET_LENGTH, WINDOW_SIZE)
LOGGER.info("Sending file consisting of {} packets".format(len(packets)))
# List of packet sequence numbers
packets_sequences = [pkt.seq_num for pkt in packets]
# List of threads and timers for every packet in window
# FIXME: Too much memory
self.threads_and_timers = [
[Thread(target=self.send_packet,args=[i, pkt]),
Timer(TIMEOUT_TIME, self.send_packet, args=[i, pkt])]
for i, pkt in enumerate(packets)
]
# While there are things to send
while self.send_base < len(packets):
LOGGER.info("Entered sending loop with send_base: {}, next_seq_num: {}".format(self.send_base, self.next_seq_num))
sent = 0
for thread, _ in self.threads_and_timers[self.next_seq_num: min(self.send_base+WINDOW_SIZE, len(packets))]:
thread.start()
sent += 1
self.next_seq_num += sent
LOGGER.info("Sent {} packets".format(sent))
try:
# stop sending ack'ed packets in the window
ack_packet = Packet(packet_bytes=self.client_entry.queue.get())
LOGGER.info("Received ack_packet: {}".format(ack_packet))
# look for seq_num in window (packets starting at send_base)
# .. raises ValueError if find doesn't find seq_num
LOGGER.info("snd_window is in: {} ".format(packets_sequences[self.send_base: self.send_base+ WINDOW_SIZE]))
index = packets_sequences.index(ack_packet.seq_num, self.send_base, min(self.send_base+WINDOW_SIZE, len(packets)))
# LOGGER.info("Waiting for lock to stop timer")
with self.timers_lock:
# LOGGER.info("Acquired lock")
_, timer = self.threads_and_timers[index]
LOGGER.info("ack_packet in window, stopping timer")
timer.cancel()
self.threads_and_timers[index] = None
# LOGGER.info("Released lock")
# sliding
if ack_packet.seq_num == packets[self.send_base].seq_num:
old_send_base = self.send_base
d = {packets_sequences[self.send_base+i]: t_h for i, t_h in enumerate(self.threads_and_timers[self.send_base: min(self.send_base+WINDOW_SIZE, len(packets))])}
LOGGER.info("{}".format(d))
for i in range(self.send_base, min(self.send_base+WINDOW_SIZE, len(packets))):
# LOGGER.info("Waiting for lock to slide")
with self.timers_lock:
# LOGGER.info("Acquired lock")
if self.threads_and_timers[i] is None:
LOGGER.info("packet with seq_num #{} is None".format(packets_sequences[i]))
self.send_base += 1
else:
break
# LOGGER.info("Released lock")
LOGGER.info("\n\n\nSlid send_base from {} to {}".format(old_send_base, self.send_base))
# No acks maybe in yet
except queue.Empty:
LOGGER.error("queue empty too many times")
pass
# Acked sequence number may not be in range
except ValueError:
LOGGER.error("ack_packet not in window, no effect")
pass
LOGGER.info("\n Done sending all {} packets".format(self.send_base))
self.close_connection_callback()
def parse_Ethernet(raw_data):
eth_length = 14
destination_mac, source_mac, proto = divide_packet([6, 6, 2], raw_data)
headers = Headers.EthernetHeader(destination_mac, source_mac, proto)
return Packet(headers, raw_data[eth_length:])
def main():
"""
Initializes and starts MurmurWall
Downloads the latest words to make Packets with,
Initializes all the ports, the LED Matrices and the LED Strand state.
Runs main animation
Empties MurmurWall every RESTART_LENGTH
Restarts when packets run out
Adds in a buzz word in every PRIORITY_LENGTH
Rests to maintain FRAMES_PER_SECOND
Raises:
KeyboardInterrupt: detects when user manual exits system. Shutsdown the system
SystemExit: detects when python shuts the program down. Shuts down the system
IOError: an error in the serial communication. Restarts the system.
"""
requests.packages.urllib3.disable_warnings()
led_port_1 = None
led_port_2 = None
matrix_port_1 = None
matrix_port_2 = None
matrix_port_3 = None
matrix_port_4 = None
matrix_port_5 = None
matrix_port_6 = None
led_matrices = None
led_strand_left = None
led_strand_right = None
GPIO.setmode(GPIO.BCM)
GPIO.setup(RELAY_PIN_1, GPIO.OUT)
GPIO.setup(RELAY_PIN_2, GPIO.OUT)
GPIO.setup(RELAY_PIN_3, GPIO.OUT)
GPIO.setup(RELAY_PIN_4, GPIO.OUT)
GPIO.output(RELAY_PIN_1, GPIO.LOW)
GPIO.output(RELAY_PIN_2, GPIO.LOW)
GPIO.output(RELAY_PIN_3, GPIO.LOW)
GPIO.output(RELAY_PIN_4, GPIO.LOW)
sleep(2)
try:
sleep(2)
print date.strftime("%d/%m/%Y")
print date.strftime("%H:%M:%S")
print 'Getting words'
related_terms_queue = update_queue()
# QUEUE
whispers_queue = Queue()
rt = RepeatedTimer(5, check_whispers, whispers_queue)
packets = []
print 'Adding packets'
add_new_packets(1, packets, related_terms_queue, True)
print 'Getting ports'
led_port_1, led_port_2, matrix_port_1, matrix_port_2, matrix_port_3, matrix_port_4, matrix_port_5, matrix_port_6 = get_ports(
)
led_matrices = {
MATRIX_POSITIONS[0]:
LedMatrix(matrix_port_1, MATRIX_POSITIONS[0], MATRIX_POSITIONS[1]),
MATRIX_POSITIONS[1]:
LedMatrix(matrix_port_2, MATRIX_POSITIONS[1], MATRIX_POSITIONS[2]),
MATRIX_POSITIONS[2]:
LedMatrix(matrix_port_3, MATRIX_POSITIONS[2], MATRIX_POSITIONS[3]),
MATRIX_POSITIONS[3]:
LedMatrix(matrix_port_4, MATRIX_POSITIONS[3], MATRIX_POSITIONS[4]),
MATRIX_POSITIONS[4]:
LedMatrix(matrix_port_5, MATRIX_POSITIONS[4], MATRIX_POSITIONS[5]),
MATRIX_POSITIONS[5]:
LedMatrix(matrix_port_6, MATRIX_POSITIONS[5], END_PIX)
}
led_strand_left = LedStrand(led_port_1, NUM_PIXELS_LEFT,
(BACKGROUND_R, BACKGROUND_G, BACKGROUND_B))
led_strand_right = LedStrand(
led_port_2, NUM_PIXELS_RIGHT,
(BACKGROUND_R, BACKGROUND_G, BACKGROUND_B))
if led_port_1 is None or led_port_2 is None or matrix_port_1 is None or matrix_port_2 is None or matrix_port_3 is None or matrix_port_4 is None or matrix_port_5 is None or matrix_port_6 is None:
restart_murmurwall(led_matrices, led_strand_left, led_strand_right,
rt)
sleep_time = 0
updating = False
emptying = False
starting = True
last_time = time()
prev_curated_time = time()
curated_pos = 0
restart_time = time()
starting_time = time()
buzz_time = time()
emptying_time = 0
CURATED_WORDS = get_currated_words()
while True:
print ""
print "Packets"
print len(packets)
print "Whispers"
print whispers_queue.qsize()
print "CuratedWords"
print len(CURATED_WORDS)
print ""
print "Related Terms"
print related_terms_queue.qsize()
if not whispers_queue.empty() and not emptying:
#color = (chr(255), chr(255), chr(255))
whispers_packet = Packet(4.0, 4.0,
(chr(255), chr(255), chr(255)),
whispers_queue.get(), START_PIX,
MATRIX_POSITIONS[0], START_PIX, False,
True)
packets.append(whispers_packet)
if starting and time() - starting_time >= STARTING_TIME:
starting_time = time()
if not emptying:
add_new_packets(1, packets, related_terms_queue, True)
if len(packets) == NUM_PACKETS:
starting = False
if len(packets) == 0:
print "Done emptying, restarting"
restart_murmurwall(led_matrices, led_strand_left,
led_strand_right, rt)
if emptying and time() - emptying_time >= EMPTYING_LENGTH:
print "Done emptying, restarting"
restart_murmurwall(led_matrices, led_strand_left,
led_strand_right, rt)
if time() - prev_curated_time >= CURATED_LENGTH and not emptying:
prev_curated_time = time()
curated_packet = Packet(4.0, 4.0, CURATED_COLOR,
CURATED_WORDS[curated_pos], START_PIX,
MATRIX_POSITIONS[0], START_PIX, False,
True)
packets.append(curated_packet)
curated_pos += 1
curated_pos %= len(CURATED_WORDS)
if not emptying and time() - restart_time >= RESTART_LENGTH:
emptying = True
emptying_time = time()
for packet in packets:
packet.target_position = END_PIX
animate_mumurwall(packets, led_strand_left, led_strand_right,
related_terms_queue, led_matrices, emptying)
sleep(0.10)
except (KeyboardInterrupt, SystemExit):
shutdown_murmurwall(led_matrices, led_strand_left, led_strand_right,
rt)
except IOError:
print '\nIOError, Shutting down MurmurWall\n'
restart_murmurwall(led_matrices, led_strand_left, led_strand_right, rt)
def parse_UDP(raw_data):
s_port, d_port, length, checksum = divide_packet([2, 2, 2, 2], raw_data)
return Packet(Headers.UDPHeader(s_port, d_port, length, checksum),
raw_data[8:])
def parse_ICMP(raw_data):
icmp_type, code, checksum = divide_packet([1, 1, 2], raw_data)
return Packet(Headers.ICMPHeader(icmp_type, code, checksum), raw_data[4:])
from struct import unpack
import socket
import Headers
from Packet import Packet
from collections import defaultdict
PLUGINS = defaultdict(lambda: lambda raw_data: Packet(None, raw_data))
def register(func):
"""Register a function as a plug-in"""
PLUGINS[func.__name__] = func
return func
def parse_raw_packet(raw_data, protocol_type):
pack = PLUGINS[f"parse_{protocol_type}"](raw_data)
if type(pack.header) is Headers.IPv4Header:
proto = str(pack.header.protocol_type)
elif type(pack.header) is Headers.EthernetHeader:
proto = str(pack.header.ether_type)
else:
return pack
return Packet(pack.header, parse_raw_packet(pack.data, proto))
@register
def parse_Ethernet(raw_data):
eth_length = 14
destination_mac, source_mac, proto = divide_packet([6, 6, 2], raw_data)
def recv_port_num(self):
pkt, adr = self.socket.recvfrom(600)
unpkd = Packet(pkd_data=pkt)
self.server_port = int(unpkd.data.decode())
self.socket.connect((self.server_ip, self.server_port))
def read_packet(self, data):
in_packet = Packet(0, self.router_id,
{}) # Initialise class as placeholder
rte_table = in_packet.decode(data) # Decode the data
packet_src = in_packet.src
self.update_rt_tbl(packet_src, rte_table) # Update the routing table
def __init(self):
self.p = Packet("some data", "data", 0, 0)
def sniff(device):
session = pcapy.open_live(device, 65536, 1, 0)
#session.setfilter("")
for i in packets:
del (i)
counter = 0
while (not stop):
(header, packet) = session.next()
hdrs.append(header) # HEADERS CAPTURED IN PCAP FORMAT
pckts.append(packet) # PACKETS CAPTURED IN PCAP FORMAT
# HDRS & PCKTS USED IN ORDER TO SAVE CAPTURED PACKETS IN PCAP FORMAT
packets.append(Packet(packet))
localtime = time.asctime(time.localtime(
time.time())) # TIME THE PACKET WAS CAPTURED
packets[counter].set_time(localtime)
eth_length = 14
ip_length = 20
tcp_length = 20
udp_length = 8
icmp_length = 12
eth_header = packet[:eth_length]
eth = unpack(
'!6s6sH', eth_header
) # UNPACK : Convert Packet Binaries Into Mentioned Data Types In Arguments
packets[counter].parse_ether(eth)
ip = packet[eth_length:eth_length + 20]
ip_header = unpack('!BBHHHBBH4s4s', ip)
if (packets[counter].get_eth_data_type() == "IP"):
packets[counter].parse_ip(ip_header)
if (packets[counter].get_ip_protocol_code() == 6):
tcp = packet[eth_length + ip_length:eth_length + ip_length +
tcp_length]
tcp_header = unpack('!HHLLHHHH', tcp)
packets[counter].parse_tcp(tcp_header)
elif (packets[counter].get_ip_protocol_code() == 17):
udp = packet[eth_length + ip_length:eth_length + ip_length +
udp_length]
udp_header = unpack('!HHHH ', udp)
packets[counter].parse_udp(udp_header)
elif (packets[counter].get_ip_protocol_code() == 1):
packed_hdr = packet[eth_length + ip_length:eth_length + ip_length +
icmp_length]
icmp_header = unpack('BBHHH 4s', packed_hdr)
packets[counter].parse_icmp(icmp_header)
data = packet[eth_length + ip_length + udp_length:len(packet) - 1]
length = len((data))
string = '!' + str(length) + 's'
payload = unpack(string, data)
packets[counter].set_payload(data)
packets[counter].set_unpacked_payload(payload)
packets[counter].parse_payload(payload)
counter += 1
def setup_connection(self, packet):
dst_router = get_router_by_id(packet.dst_ip)
if (len(self.clients) +
len(self.neighbors)) >= 10 and packet.packet_type == 'start':
print('all the interfaces are connected to routers.')
else:
if packet.packet_type == 'start':
self.state = 'Init'
new_packet = Packet(self.id, packet.dst_ip, 'first_hello',
self.neighbors)
dst_router.setup_connection(new_packet)
else:
packet_sender = get_router_by_id(packet.src_ip)
if packet.packet_type == 'first_hello':
self.neighbors.append(packet_sender)
self.state = 'Init'
if monitor_mode:
print(
str(self.id) +
': Hello packet received from router ' +
str(packet.src_ip))
new_packet = Packet(self.id, packet_sender.id,
'first_hello_ack', self.neighbors)
packet_sender.setup_connection(new_packet)
elif packet.packet_type == 'first_hello_ack':
for neighbor in packet_sender.neighbors:
if self.id == neighbor.id:
self.state = '2-way'
if monitor_mode:
print(
str(self.id) +
': Hello packet received from router ' +
str(packet.src_ip))
self.neighbors.append(packet_sender)
new_packet = Packet(self.id, packet_sender.id,
'final_hello', self.neighbors)
packet_sender.setup_connection(new_packet)
elif packet.packet_type == 'final_hello':
for neighbor in packet_sender.neighbors:
if self.id == neighbor.id:
self.state = '2-way'
new_packet = Packet(self.id, packet_sender.id,
'final_hello_ack',
self.neighbors)
packet_sender.setup_connection(new_packet)
elif packet.packet_type == 'final_hello_ack':
self.state = 'Full'
new_packet = Packet(self.id, packet_sender.id,
'LSDB_update', self.neighbors)
packet_sender.setup_connection(new_packet)
elif packet.packet_type == 'LSDB_update':
if monitor_mode:
print(
str(self.id) +
': DBD packet received from router ' +
str(packet.src_ip))
self.LSDB.update(packet_sender.LSDB)
self.state = 'Full'
new_packet = Packet(self.id, packet_sender.id,
'LSDB_update_ack', self.neighbors)
packet_sender.setup_connection(new_packet)
elif packet.packet_type == 'LSDB_update_ack':
if monitor_mode:
print(
str(self.id) +
': DBD packet received from router ' +
str(packet.src_ip))
self.LSDB.update(packet_sender.LSDB)
self.state = 'Full'
elif packet.packet_type == 'liveness_packet':
if monitor_mode:
print(
str(self.id) +
': liveness packet received from router ' +
str(packet.src_ip))
self.neighbors_last_time[get_router_by_id(
packet.src_ip)] = time_elapsed
elif packet.packet_type == 'flood_packet':
if monitor_mode:
print(
str(self.id) +
': LSA packet received from router ' +
str(packet.src_ip))
self.LSDB.update(get_router_by_id(packet.src_ip).LSDB)
self.update_RT()
elif packet.packet_type == 'update':
self.update_RT()
self.flood()
elif packet.packet_type == 'ping':
if monitor_mode and self.id != packet.src_ip:
print(
str(self.id) +
': Ping packet received from router ' +
str(packet.src_ip))
dest_router = packet.msg.router
if self.id == dest_router.id and packet.msg in self.clients:
print(str(self.id) + ' ' + packet.msg.ip)
return
print(str(self.id), end=' ')
found = False
unreachable_flag = False
for key in self.RT:
if dest_router.id == key.id:
unreachable_flag = True
if Link.get_link_by_routers(
self, self.RT[key]) is not None:
link = Link.get_link_by_routers(
self, self.RT[key])
ping_packet = Packet(self.id, self.RT[key].id,
'ping', packet.msg)
link.transfer_packet(self, self.RT[key],
ping_packet)
found = True
else:
print('unreachable')
if found is False and unreachable_flag is False:
print('invalid')
def createPacket(self, predictionSample, sequenceNumber):
packet = Packet()
packet.predictionSample = copy( predictionSample )
packet.sequenceNumber = sequenceNumber
packet.timeTransmitted = predictionSample.sample.time
return packet
def newPacket(self, pName, pSize):
return Packet(pName, pSize)
def applyCountermeasure(trace, metadata):
[targetBursts] = metadata
rndmIndx = random.randint(0,
len(targetBursts) -
1) # pick a trace from target at random
# burst tuple = (direction, size, number, timeDiff, burstPackets)
# pick one trace randomly [(tuple), (tuple), ...]
targetBurstsList = targetBursts[rndmIndx]
sourceBurstsList = trace.getBurstsListWithPackets()
newTrace = Trace(trace.getId())
pointer = 0 # to loop over burst tuples in src and trgt in order until one is exhausted
# first packet time
newPktTime = sourceBurstsList[pointer][4][0].getTime()
lastSrcPktTime = 0
while True:
if pointer >= len(sourceBurstsList) or pointer >= len(
targetBurstsList):
break
sourceBurstPackets = sourceBurstsList[pointer][
4] # list of packets for that burst
targetBurstPackets = targetBurstsList[pointer][4]
srcPktTimes = []
for packet in sourceBurstPackets:
srcPktTimes.append(packet.getTime())
lastSrcPktTime = srcPktTimes[
-1] # for extra burst padding down below, before pop
if len(sourceBurstPackets) < len(targetBurstPackets):
for packet in targetBurstPackets:
#-#if len(srcPktTimes) != 0:
#-#newPktTime = srcPktTimes.pop(0) # remove first from the queue
# eventually last src packet time is repeated
# to make sure we don't exceed original burst transimission time
newPktTime += 1
newPkt = Packet(packet.getDirection(), newPktTime,
packet.getLength())
newTrace.addPacket(newPkt)
else:
for packet in sourceBurstPackets:
newPktTime += 1
newPkt = Packet(packet.getDirection(), newPktTime,
packet.getLength())
newTrace.addPacket(newPkt)
pointer += 1
# for calculating time overhead
config.TIME_ORIGINAL += lastSrcPktTime # last
config.TIME_EXTRA += newPktTime
#print 'source id:' + str(trace.getId())
#print 'orig. end time:' + str(config.TIME_ORIGINAL)
#print 'extra end time:' + str(config.TIME_EXTRA)
#print "---------"
# end: for calculating time overhead
while pointer < len(sourceBurstsList):
sourceBurstPackets = sourceBurstsList[pointer][4]
for packet in sourceBurstPackets:
newPktTime += 1
newPkt = Packet(packet.getDirection(), newPktTime,
packet.getLength())
newTrace.addPacket(newPkt)
pointer += 1
# extra bursts tail
# '''
while pointer < len(targetBurstsList):
targetBurstPackets = targetBurstsList[pointer][4]
for packet in targetBurstPackets:
lastSrcPktTime += 1
newPkt = Packet(packet.getDirection(), lastSrcPktTime,
packet.getLength())
newTrace.addPacket(newPkt)
pointer += 1
# '''
#print str(trace.getId())
#print str(trace.getPacketCount())
#print str(newTrace.getPacketCount())
#print "--------------"
return newTrace
from Packet import Packet
import socket
from Constants import *
rx_port = 7735
rx_ip = '127.0.0.1'
my_ip = '127.0.0.1'
my_port = 7000
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((my_ip, my_port))
# p0 = Packet('Hello')
# p1 = Packet(' World')
#
# s0 = p0.generate_udp_payload()
# s1 = p1.generate_udp_payload()
with open('RFC 882.txt', 'r') as f:
while True:
s = f.read(512)
#print s
p = Packet(s)
sock.sendto(p.generate_udp_payload(), (rx_ip, rx_port))
del p
if (len(s) < 512):
end_p = Packet(TERMINATOR)
sock.sendto(end_p, (rx_ip, rx_port))
break
def bcast(sskt):
while (1): #replace with flag for getting new sample later on
spkt = Packet(1, 0, 1) #test packet
sskt.send((spkt.build_str()).encode()) #replace with packet encoding
time.sleep(2)
# A simple program to test the Packet class from Packet import Packet p1 = Packet(seq_num=3, payload="A") print(p1) p2 = Packet(seq_num=4, payload="B") print(p2) p2.corrupt() print(p2)
def naive_client():
# client
address = ('127.0.0.1', 3306)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(address)
data = s.recv(512)
print '========== hand shake ==========='
print '++++++++++ server to client +++++++++++++'
print repr(data)
print b2a_hex(data)
pk = Packet()
mg = ServerHandShakeMessage()
pk.parse(data)
mg.parse(pk.payload_length(), pk.payload())
(response_packet, pack_len) = package_handshake_response(pk, mg)
print '++++++++++ client to server +++++++++++++'
print repr(response_packet)
print b2a_hex(response_packet)
s.send(response_packet)
data = s.recv(512)
print repr(data)
print b2a_hex(data)
print '========== register ==========='
(reg_packet, reg_pack_len) = package_register()
print '++++++++++ client to server +++++++++++++'
print repr(reg_packet)
print b2a_hex(reg_packet)
s.send(reg_packet)
data = s.recv(1024)
print '++++++++++ server to client +++++++++++++'
print repr(data)
print '========== query service id ==========='
query_packet = a2b_hex(query_service_id)
print '++++++++++ client to server +++++++++++++'
print query_service_id
s.send(query_packet)
data = s.recv(1024)
print '++++++++++ server to client +++++++++++++'
print repr(data)
print b2a_hex(data)
print '========== dump ==========='
(dump_packet, dump_pack_len) = package_dump()
print '++++++++++ client to server +++++++++++++'
print repr(dump_packet)
print b2a_hex(dump_packet)
s.send(dump_packet)
print '++++++++++ server to client header +++++++++++++'
data = s.recv(1024)
read_data = data
while len(data) == 1024:
s.recv(1024)
read_data += data
print repr(read_data)
print b2a_hex(read_data)
packetManage = PacketManage()
(packet_list, count) = packetManage.parse(read_data)
print '++++++++++ server to client header +++++++++++++'
s.close()
def create_user_logged_response(addr, socket):
packet = Packet()
packet.pack(type=RESPONSE, message="User Created")
send_response(addr, packet, socket)
print("-> Response sent to user.")
def generatePacket(self, serverId, time):
self.requestId += 1
return Packet(self.requestId, self.carId, serverId,
self.calculatePacketSize(self.resolution), 0, time)
class StudentNetworkSimulator(NetworkSimulator, object):
"""
* Predefined Constants (static member variables):
*
* int MAXDATASIZE : the maximum size of the Message data and
* Packet payload
*
* int A : a predefined integer that represents entity A
* int B : a predefined integer that represents entity B
*
*
* Predefined Member Methods:
*
* stopTimer(int entity):
* Stops the timer running at "entity" [A or B]
* startTimer(int entity, double increment):
* Starts a timer running at "entity" [A or B], which will expire in
* "increment" time units, causing the interrupt handler to be
* called. You should only call this with A.
* toLayer3(int callingEntity, Packet p)
* Puts the packet "p" into the network from "callingEntity" [A or B]
* toLayer5(int entity, String dataSent)
* Passes "dataSent" up to layer 5 from "entity" [A or B]
* getTime()
* Returns the current time in the simulator. Might be useful for
* debugging.
* printEventList()
* Prints the current event list to stdout. Might be useful for
* debugging, but probably not.
*
*
* Predefined Classes:
*
* Message: Used to encapsulate a message coming from layer 5
* Constructor:
* Message(String inputData):
* creates a new Message containing "inputData"
* Methods:
* boolean setData(String inputData):
* sets an existing Message's data to "inputData"
* returns true on success, false otherwise
* String getData():
* returns the data contained in the message
* Packet: Used to encapsulate a packet
* Constructors:
* Packet (Packet p):
* creates a new Packet that is a copy of "p"
* Packet (int seq, int ack, int check, String newPayload)
* creates a new Packet with a sequence field of "seq", an
* ack field of "ack", a checksum field of "check", and a
* payload of "newPayload"
* Packet (int seq, int ack, int check)
* chreate a new Packet with a sequence field of "seq", an
* ack field of "ack", a checksum field of "check", and
* an empty payload
* Methods:
* boolean setSeqnum(int n)
* sets the Packet's sequence field to "n"
* returns true on success, false otherwise
* boolean setAcknum(int n)
* sets the Packet's ack field to "n"
* returns true on success, false otherwise
* boolean setChecksum(int n)
* sets the Packet's checksum to "n"
* returns true on success, false otherwise
* boolean setPayload(String newPayload)
* sets the Packet's payload to "newPayload"
* returns true on success, false otherwise
* int getSeqnum()
* returns the contents of the Packet's sequence field
* int getAcknum()
* returns the contents of the Packet's ack field
* int getChecksum()
* returns the checksum of the Packet
* int getPayload()
* returns the Packet's payload
*
"""
# Add any necessary class/static variables here. Remember, you cannot use
# these variables to send messages error free! They can only hold
# state information for A or B.
# Also add any necessary methods (e.g. checksum of a String)
# alternating bit set-up
# message_in_transit = False
# global_message = ""
# alternating_bit_a = 0
# alternating_bit_b = 0
# send_packet_b = Packet(0, 0, 0, "")
# message_to_5 = ""
# GBN set up
next_sequence_num = 0
base = 0
N = 8
buffer = []
send_packets = {}
expected_sequence_num = 0
message_to_5 = Message("")
send_packet_b = Packet(0, 0, 0, "")
timer_amount = 10
buffer_used = 0
# Stats in A
received_messages = 0
sent_packets = 0
received_acks = 0
successful_acks = 0
corrupt_acks = 0
incorrect_acks = 0
resent_messages = 0
resent_message = False
message_discarded = 0
# IN B
received_packets_from_a = 0
corrupt_packets_from_a = 0
sent_acks = 0
correct_sequence_nums = 0
incorrect_sequence_nums = 0
# Shared
lost_packets_or_acks = 0
# This is the constructor. Don't touch!
def __init__(self, num_messages, loss, corrupt, avg_delay, trace, seed):
super(StudentNetworkSimulator,
self).__init__(num_messages, loss, corrupt, avg_delay, trace,
seed)
# This routine will be called whenever the upper layer at the sender [A]
# has a message to send. It is the job of your protocol to insure that
# the data in such a message is delivered in-order, and correctly, to
# the receiving upper layer.
def a_output(self, message):
"""
args[0]=sequence number
args[1]=acknowledgement number
args[2]=checksum
args[3]=payload string
"""
# statistic for output
self.received_messages = self.received_messages + 1
# reject any calls from layer 5 if there is a packet already being sent and waiting for an awk
if self.next_sequence_num < self.base + self.N:
# checksum to check for corruption when it gets to b
checksum = 0
for char in message.get_data():
checksum += ord(char)
checksum = checksum + self.next_sequence_num + self.next_sequence_num
# create the packet to send to the transport layer
packet2 = Packet(self.next_sequence_num, self.next_sequence_num,
checksum, message.get_data())
# add to send packets data
if self.next_sequence_num in self.send_packets:
print("ERROR: SEQUENCE NUMBER ALREADY IN USE!")
else:
self.send_packets[self.next_sequence_num] = packet2
# send the packet to the transport layer
self.to_layer3(0, packet2)
# start timer to check for a timeout
if self.base == self.next_sequence_num:
self.start_timer(0, self.timer_amount)
# increment sequence number
self.next_sequence_num = self.next_sequence_num + 1
# statistic for output
self.sent_packets = self.sent_packets + 1
else:
if len(self.buffer) < 50:
self.buffer.append(message)
self.buffer_used = self.buffer_used + 1
else:
print(
"message discarded because a current message is in progress"
)
print('message: ', message.get_data())
self.message_discarded = self.message_discarded + 1
return
# This routine will be called whenever a packet sent from the B-side
# (i.e. as a result of a toLayer3() being done by a B-side procedure)
# arrives at the A-side. "packet" is the (possibly corrupted) packet
# sent from the B-side.
def a_input(self, packet):
"""
args[0]=sequence number
args[1]=acknowledgement number
args[2]=checksum
args[3]=payload string
"""
self.received_acks = self.received_acks + 1
# extract the payload from the packet received from layer 3 and turn it into a message
message_from_b = Message(packet.get_payload())
# corruption calculation
checksum_check = 0
for char in message_from_b.get_data():
checksum_check += ord(char)
checksum_check = checksum_check + packet.get_acknum(
) + packet.get_seqnum()
# check if checksum is correct
if packet.get_checksum() != checksum_check or packet.get_seqnum(
) != packet.get_acknum():
print("Corruption detected: bad checksum for ack")
self.corrupt_acks = self.corrupt_acks + 1
return
print("ack number received: ", packet.get_acknum())
if self.successful_acks + 1 != self.base:
# awk received okay, change the base to ack + 1
self.successful_acks = self.successful_acks + 1
# increment the timer amount
if self.timer_amount == 10:
self.timer_amount = 15
elif self.timer_amount == 15:
self.timer_amount = 20
elif self.timer_amount == 20:
self.timer_amount = 25
elif self.timer_amount == 25:
self.timer_amount = 30
elif self.timer_amount == 30:
self.timer_amount = 35
elif self.timer_amount == 35:
self.timer_amount = 40
self.base = packet.get_acknum() + 1
print("base number: ", self.base)
delete_nums = []
for seq_num, packet_stored in self.send_packets.items():
if packet.get_acknum() >= seq_num:
delete_nums.append(seq_num)
for x in delete_nums:
del self.send_packets[x]
if self.base == self.next_sequence_num:
self.stop_timer(0)
while len(self.buffer) > 0:
self.a_output(self.buffer.pop(0))
elif self.next_sequence_num - self.base < self.N:
self.stop_timer(0)
if len(self.buffer) > 0:
while len(
self.buffer
) > 0 and self.next_sequence_num - self.base < self.N:
self.a_output(self.buffer.pop(0))
self.start_timer(0, self.timer_amount)
return
# This routine will be called when A's timer expires (thus generating a
# timer interrupt). You'll probably want to use this routine to control
# the retransmission of packets. See startTimer() and stopTimer(), above,
# for how the timer is started and stopped.
def a_timer_interrupt(self):
self.lost_packets_or_acks = self.lost_packets_or_acks + 1
# Retransmitting window data
print("Timeout detected: Packet or ack loss)")
for seq_num, packet in self.send_packets.items():
print("retransmitting: ", self.send_packets[seq_num].get_payload())
# increase resent count
self.resent_messages = self.resent_messages + 1
# resend the message to layer 3 from A
self.to_layer3(0, packet)
if self.base == seq_num:
self.start_timer(0, self.timer_amount)
# This routine will be called once, before any of your other A-side
# routines are called. It can be used to do any required
# initialization (e.g. of member variables you add to control the state
# of entity A).
def a_init(self):
# sequence number for packets being sent out
self.next_sequence_num = 0
# number of the base of the sliding window
self.base = 0
# size of the sliding window
self.N = 8
# dictionary for packets to be stored in case of a drop of the packets
self.send_packets = {}
# timer amount until the A resends a message
self.timer_amount = 10
# Stats in A
self.received_messages = 0
self.sent_packets = 0
self.successful_acks = 0
self.corrupt_acks = 0
self.received_acks = 0
self.incorrect_acks = 0
self.resent_messages = 0
self.resent_message = False
self.message_discarded = 0
self.buffer = []
self.buffer_used = 0
# Shared
self.lost_packets_or_acks = 0
return
# This routine will be called whenever a packet sent from the B-side
# (i.e. as a result of a toLayer3() being done by an A-side procedure)
# arrives at the B-side. "packet" is the (possibly corrupted) packet
# sent from the A-side.
def b_input(self, packet):
self.received_packets_from_a = self.received_packets_from_a + 1
# extract the payload from the packet received from layer 3 and turn it into a message
self.message_to_5 = Message(packet.get_payload())
# check for corrupt packet
checksum_check = 0
for char in self.message_to_5.get_data():
checksum_check += ord(char)
checksum_check = checksum_check + packet.get_seqnum(
) + packet.get_acknum()
if checksum_check != packet.get_checksum() or packet.get_seqnum(
) != packet.get_acknum():
print('Corruption Detected!')
print('Checksum Field: ', packet.get_checksum())
print('calculated: ', checksum_check)
self.corrupt_packets_from_a = self.corrupt_packets_from_a + 1
self.sent_acks = self.sent_acks + 1
self.to_layer3(1, self.send_packet_b)
return
# if correct alternating bit not rec, send the awk of the of the number you wish to receive
if packet.get_seqnum() != self.expected_sequence_num:
print('Received wrong sequence number!')
print('Expected: ', self.expected_sequence_num)
print('Received: ', packet.get_seqnum())
self.incorrect_sequence_nums = self.incorrect_sequence_nums + 1
self.sent_acks = self.sent_acks + 1
self.to_layer3(1, self.send_packet_b)
return
# correct packet number received
self.correct_sequence_nums = self.correct_sequence_nums + 1
# deliver the packet to layer 5
self.to_layer5(1, self.message_to_5)
checksum = 0
for char in packet.get_payload():
checksum += ord(char)
checksum = checksum + self.expected_sequence_num + self.expected_sequence_num
# create an awk packet of the correct packet being seen
self.send_packet_b = Packet(self.expected_sequence_num,
self.expected_sequence_num, checksum,
packet.get_payload())
self.sent_acks = self.sent_acks + 1
# send the awk packet back to A
self.to_layer3(1, self.send_packet_b)
# change the expected sequence number to the next
self.expected_sequence_num = self.expected_sequence_num + 1
return
# This routine will be called once, before any of your other B-side
# routines are called. It can be used to do any required
# initialization (e.g. of member variables you add to control the state
# of entity B).
def b_init(self):
# Set the expected sequence number for B
self.expected_sequence_num = 0
# Set a message object that will be transported to top layer 5 from B
self.message_to_5 = Message("")
self.send_packet_b = Packet(-1, -1, 0, "")
# IN B
self.corrupt_packets_from_a = 0
self.sent_acks = 0
self.correct_sequence_nums = 0
self.received_packets_from_a = 0
self.incorrect_sequence_nums = 0
return
def receive_ack(self):
ack = ""
# For test, which will be drawn in bar chart or line chart
if self.srtt < 0:
self.info["RTO"] = []
self.info["SRTT"] = []
self.info[self.cal_type] = []
self.info["cwnd"] = []
self.info["ssthresh"] = []
# Receive ack from proxy
try:
self.sock.settimeout(max(2, self.srtt))
ack, address = self.sock.recvfrom(size)
# Packet loss or ACK loss, ack for rwnd from proxy
except socket.timeout:
self.number_in_flight = 0
self.send_packet(IS_DATA, "data", self.proxy_address, self.seq, -1)
logging.info("The client does not receive ack from proxy")
print("%s %s"%(len(self.data_list), self.cwnd))
if ack != "":
pkt = Packet(0, 0, 0, 0, 0, 0, ack)
pkt.decode_buf()
self.number_in_flight -= 1
# Slow start
if self.cwnd < self.ssthresh:
self.cwnd += 1
# Congestion control
else:
self.cwnd += 1.0 / self.cwnd
self.info["cwnd"].append(self.cwnd)
self.info["ssthresh"].append(self.ssthresh)
# Receive ack of data
next_seq = int(pkt.msg.split(delimiter)[0])
self.rwnd = int(pkt.msg.split(delimiter)[1])
if len(self.data_list) != 0:
# Remove data that are ensured to be received
for i in list(self.data_list.keys()):
if self.data_list[i]["seq"] <= next_seq - 1:
self.data_list.pop(i)
# Check if the packet is in packets in flight
if i in self.packets_in_flight.keys():
send_time = self.packets_in_flight[i]["time"]
self.packets_in_flight.pop(i)
# Calculate SRTT and RTO
receive_time = t.time()
rtt = receive_time - send_time
# srtt, Jacobson / Karels algorithm to modify rto and srtt
if self.srtt < 0:
# First time setting srtt
self.srtt = rtt
self.devrtt = rtt / 2
self.rto = self.srtt + 4 * self.devrtt
else:
alpha = 0.125
beta = 0.25
self.srtt = self.srtt + alpha * (rtt - self.srtt)
self.devrtt = (1 - beta) * self.devrtt + beta * abs(rtt - self.srtt)
self.rto = self.srtt + 4 * self.devrtt
self.rto = max(self.rto, 1) # Always round up RTO.
self.rto = min(self.rto, 60) # Maximum value 60 seconds.
# For test, which will be drawn in bar chart or line chart
self.info["RTO"].append(self.rto)
self.info["SRTT"].append(self.srtt)
self.info[self.cal_type].append(t.time() - self.time)
# Record duplicate ack
elif self.data_list[i]["seq"] == next_seq:
self.data_list[i]["duplicate acks"] += 1
break
# When sending all packets and receiving acks, send FIN to server
if len(self.data_list) == 0:
print("finish sending")
self.state_history = FIN
self.state = FIN
if self.state != FIN and self.packets_in_flight != {}:
# Situation of losing packets: timeout
for key in list(self.packets_in_flight.keys()):
if t.time() - self.packets_in_flight[key]["time"] >= self.rto:
self.packets_retransmit[key] = ""
self.packets_in_flight.pop(key)
# If the interval between two packets loss is large enough
# Decrease CWND and SSTHRESH
if t.time() - self.time_last_lost > self.srtt:
self.ssthresh = 1 / 2 * self.cwnd
self.cwnd = 3
self.time_last_lost = t.time()
else:
break
def broadcast_data(skt, braking, steering, speed):
skt.send((Packet(braking, steering, speed).build_str()).encode())
def test_set_flags(self):
p = Packet()
p.set_flags(Packet.Flags.SYN, Packet.Flags.ACK)
self.assertEqual(p.flags, Packet.Flags.SYN | Packet.Flags.ACK)
