seq = 0x0
###[ Padding ]###
load = 'RT\x00\xca]\x0b\xaa\xbb\xcc\xdd\xee\xff\x08\x06\x00\x01\x08\x00'
- >>> rxq._proc.terminate()
"""
import socket
+import select
import os
import time
from multiprocessing import Queue, Process
from scapy.layers.inet6 import IPv6
__all__ = ['RxQueue', 'TxQueue', 'Interface', 'create_gratuitous_arp_request',
- 'auto_pad']
+ 'auto_pad', 'checksum_equal']
# TODO: http://stackoverflow.com/questions/320232/ensuring-subprocesses-are-dead-on-exiting-python-program
self._sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW,
ETH_P_ALL)
self._sock.bind((interface_name, ETH_P_ALL))
+ self._ifname = interface_name
def extract_one_packet(buf):
sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, ETH_P_ALL)
sock.bind((interface_name, ETH_P_ALL))
- buf = ""
while True:
- recvd = sock.recv(1500)
- buf = buf + recvd
-
- pkt = extract_one_packet(buf)
- while pkt is not None:
- if pkt is None:
- break
- queue.put(pkt)
- buf = buf[len(pkt):]
- pkt = extract_one_packet(buf)
+ pkt = sock.recv(0x7fff)
+ queue.put(pkt)
class RxQueue(PacketVerifier):
def __init__(self, interface_name):
PacketVerifier.__init__(self, interface_name)
- self._queue = Queue()
- self._proc = Process(target=packet_reader, args=(interface_name,
- self._queue))
- self._proc.daemon = True
- self._proc.start()
- time.sleep(2)
+ #self._queue = Queue()
+ #self._proc = Process(target=packet_reader, args=(interface_name,
+ # self._queue))
+ #self._proc.daemon = True
+ #self._proc.start()
+ #time.sleep(2)
def recv(self, timeout=3, ignore=None):
"""Read next received packet.
:rtype: scapy.Ether
"""
- pkt = self._queue.get(True, timeout=timeout)
+ #pkt = self._queue.get(True, timeout=timeout)
+ (rlist, _, _) = select.select([self._sock], [], [], timeout)
+ if self._sock not in rlist:
+ return None
+
+ pkt = self._sock.recv(0x7fff)
+ pkt_pad = auto_pad(pkt)
+ print 'Received packet on {0} of len {1}'.format(self._ifname, len(pkt))
+ Ether(pkt).show2()
+ print
if ignore is not None:
for i, ig_pkt in enumerate(ignore):
# Auto pad all packets in ignore list
ignore[i] = auto_pad(ig_pkt)
for ig_pkt in ignore:
- if ig_pkt == pkt:
+ if ig_pkt == pkt_pad:
# Found the packet in ignore list, get another one
# TODO: subtract timeout - time_spent in here
ignore.remove(ig_pkt)
:param pkt: Packet to send.
:type pkt: string or scapy Packet derivative.
"""
- if isinstance(pkt, Packet):
- pkt = str(pkt)
- pkt = auto_pad(pkt)
+ print 'Sending packet out of {0} of len {1}'.format(self._ifname,
+ len(pkt))
+ Ether(str(pkt)).show2()
+ print
+
+ pkt = auto_pad(str(pkt))
self._sock.send(pkt)
def __init__(self, if_name):
self.if_name = if_name
self.sent_packets = []
- self.txq = TxQueue(if_name)
self.rxq = RxQueue(if_name)
+ self.txq = TxQueue(if_name)
def send_pkt(self, pkt):
self.sent_packets.append(pkt)
self.txq.send(pkt)
def recv_pkt(self, timeout=3):
- while True:
- pkt = self.rxq.recv(timeout, self.sent_packets)
- # TODO: FIX FOLLOWING: DO NOT SKIP RARP IN ALL TESTS!!!
- if pkt.type != 32821: # Skip RARP packets
- return pkt
-
- def close(self):
- self.rxq._proc.terminate()
+ return self.rxq.recv(timeout, self.sent_packets)
def create_gratuitous_arp_request(src_mac, src_ip):
padded += ('\0' * (60 - len(padded)))
return padded
+
+def checksum_equal(chksum1, chksum2):
+ """Compares two checksums in one's complement notation.
+
+ Checksums to be compared are calculated as 16 bit one's complement of the
+ one's complement sum of 16 bit words of some buffer.
+ In one's complement notation 0x0000 (positive zero) and 0xFFFF
+ (negative zero) are equivalent.
+
+ :param chksum1: First checksum.
+ :param chksum2: Second checksum.
+ :type chksum1: uint16
+ :type chksum2: uint16
+
+ :return: True if checksums are equivalent, False otherwise.
+ :rtype: boolean
+ """
+ if chksum1 == 0xFFFF:
+ chksum1 = 0
+ if chksum2 == 0xFFFF:
+ chksum2 = 0
+ return chksum1 == chksum2