def generate_packet_list(self, packet_amount, maximum_length,
current_message):
packet_list = []
for packet_increment in range(packet_amount):
if packet_amount == 1:
packet = IP(
src=self.source_ip,
dst=self.destination_ip) / UDP() / UDPN() / PAYLOAD()
else:
packet = IP(src=self.source_ip, dst=self.destination_ip) / UDP(
) / UDPN() / OPT() / PAYLOAD()
packet.sport = self.source_port
packet.dport = self.destination_port
if packet_amount == 1:
packet[PAYLOAD].message = current_message
packet[UDPN].message_length = packet[UDPN].header_length + len(
packet[PAYLOAD].message)
else:
packet[
UDPN].header_length = UDPN_header_length + OPT_header_length
packet[OPT].segment_id = packet_increment
if (len(current_message[maximum_length * packet_increment:]) >
maximum_length):
packet[PAYLOAD].message = current_message[
maximum_length * packet_increment:maximum_length *
(packet_increment + 1)]
packet[UDPN].message_length = packet[
UDPN].header_length + len(packet[PAYLOAD].message)
else:
packet[PAYLOAD].message = current_message[
maximum_length * packet_increment:]
packet[UDPN].message_length = packet[
UDPN].header_length + len(packet[PAYLOAD].message)
packet[OPT].last = 1
packet_list.append(packet)
return packet_list
def send_udp_notif(self):
start = time.time()
npackets = 0
observation_domains = []
message_ids = {}
for i in range(1 + self.additional_domains):
observation_domains.append(self.initial_domain + i)
message_ids[observation_domains[i]] = 0
self.log_used_args()
message = self.generate_mock_message()
maximum_length = self.mtu - UDPN_header_length
message_increment = 0
messages_lost = 0
while message_increment < self.message_amount:
message_increment += 1
segment_list = []
if message_increment != 0:
# TODO: may be a better way to do that ?
if self.message_type == "rand":
message = self.generate_mock_message()
time.sleep(self.sleep_time)
domain = observation_domains[message_increment %
len(observation_domains)]
# SEGMENTATION
if len(message) > maximum_length:
maximum_length = self.mtu - UDPN_header_length - OPT_header_length
segment_amount = len(message) // maximum_length
if len(message) % maximum_length != 0:
segment_amount += 1
for segment_increment in range(segment_amount):
segment = IP(src=self.source_ip, dst=self.destination_ip
) / UDP() / UDPN() / OPT() / PAYLOAD()
segment.sport = self.source_port
segment.dport = self.destination_port
segment[UDPN].observation_domain_id = domain
segment[UDPN].message_id = message_ids[domain]
segment[
UDPN].header_length = UDPN_header_length + OPT_header_length
segment[OPT].segment_id = segment_increment
if (len(message[maximum_length * segment_increment:]) >
maximum_length):
segment[PAYLOAD].message = message[
maximum_length * segment_increment:maximum_length *
(segment_increment + 1)]
segment[UDPN].message_length = segment[
UDPN].header_length + len(segment[PAYLOAD].message)
else:
segment[PAYLOAD].message = message[maximum_length *
segment_increment:]
segment[UDPN].message_length = segment[
UDPN].header_length + len(segment[PAYLOAD].message)
segment[OPT].last = 1
message_ids[domain] += 1
self.log_segment(segment_increment, segment)
segment_list.append(segment)
self.save_pcap('filtered.pcap', segment)
# NO SEGMENTATION
else:
packet = IP(
src=self.source_ip,
dst=self.destination_ip) / UDP() / UDPN() / PAYLOAD()
packet.sport = self.source_port
packet.dport = self.destination_port
packet[PAYLOAD].message = message
packet[UDPN].message_length = packet[UDPN].header_length + len(
packet[PAYLOAD].message)
packet[UDPN].observation_domain_id = domain
packet[UDPN].message_id = message_ids[domain]
message_ids[domain] += 1
self.log_packet(packet)
if self.loss_probability == 0:
send(packet, verbose=0)
npackets += 1
self.save_pcap('filtered.pcap', packet)
elif random.randint(1, int(1 / self.loss_probability)) != 1:
send(packet, verbose=0)
npackets += 1
self.save_pcap('filtered.pcap', packet)
else:
messages_lost += 1
logging.info("simulating packet " +
str(packet[UDPN].message_id) + " lost")
if (self.random_order == 1):
random.shuffle(segment_list)
for i in range(len(segment_list)):
if (self.loss_probability == 0):
send(segment_list[i], verbose=0)
npackets += 1
elif random.randint(1, int(
1000 * (1 / self.loss_probability))) >= 1000:
send(segment_list[i], verbose=0)
npackets += 1
else:
messages_lost += 1
logging.info("simulating segment " +
str(segment_list[i][OPT].segment_id) +
" from message " +
str(segment_list[i][UDPN].message_id) +
" lost")
end = time.time()
duration = end - start
logging.info('Sent ' + str(npackets) + ' in ' + str(duration))
logging.info('Simulated %d lost messages from %d total messages',
messages_lost, (npackets + messages_lost))
return
