def send(self, x):
pkt_src_mac_field,pkt_src_mac_val = x.getfield_and_val('src')
if self.__use_iface and pkt_src_mac_val is None:
iff = self.iface
if iff:
try:
src_mac = scapy.arch.get_if_hwaddr(iff)
except:
pass
if src_mac is None:
src_mac = "00:00:00:00:00:00"
x.src = scapy.fields.MACField.i2h(pkt_src_mac_field, x, src_mac)
if x.haslayer('IP') :
pkt_src_ip_field,pkt_src_ip_val = x['IP'].getfield_and_val('src')
if isinstance(pkt_src_ip_field,scapy.fields.Emph):
pkt_src_ip_field = pkt_src_ip_field.fld
if self.__use_iface and pkt_src_ip_val is None:
iff = self.iface
if iff:
try:
src_ip = scapy.arch.get_if_addr(iff)
except:
pass
x['IP'].src = scapy.fields.SourceIPField.i2h(pkt_src_ip_field, x, src_ip)
SuperSocket.send(self, x)
def close(self):
if self.closed:
return
self.closed = 1
if self.promisc:
set_promisc(self.ins, self.iface, 0)
SuperSocket.close(self)
def close(self):
if self.closed:
return
self.closed = 1
if self.promisc:
set_promisc(self.ins, self.iface, 0)
SuperSocket.close(self)
def close(self):
if self.closed:
return
self.closed = 1
if self.promisc:
for i in self.iff:
set_promisc(self.ins, i, 0)
SuperSocket.close(self)
def close(self):
if self.closed:
return
self.closed = 1
if self.promisc:
for i in self.iff:
set_promisc(self.ins, i, 0)
SuperSocket.close(self)
def close(self):
if self.closed:
return
try:
if self.promisc and self.ins:
set_promisc(self.ins, self.iface, 0)
except (AttributeError, OSError):
pass
SuperSocket.close(self)
def __init__(self, peer="127.0.0.1"):
SuperSocket.__init__(self, socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)
self.rx_addr = (peer, 52002)
self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 0)
try:
self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 0)
except AttributeError:
pass
self.ins.bind(self.rx_addr)
def close(self):
# type: () -> None
if self.closed:
return
try:
if self.promisc and getattr(self, "ins", None):
set_promisc(self.ins, self.iface, 0)
except (AttributeError, OSError):
pass
SuperSocket.close(self)
def send(self, x):
try:
return SuperSocket.send(self, x)
except socket.error as msg:
if msg.errno == 22 and len(x) < conf.min_pkt_size:
padding = b"\x00" * (conf.min_pkt_size - len(x))
if isinstance(x, Packet):
return SuperSocket.send(self, x / Padding(load=padding))
else:
return SuperSocket.send(self, raw(x) + padding)
raise
def send(self, x):
try:
return SuperSocket.send(self, x)
except socket.error as msg:
if msg[0] == 22 and len(x) < conf.min_pkt_size:
padding = b"\x00" * (conf.min_pkt_size - len(x))
if isinstance(x, Packet):
return SuperSocket.send(self, x / Padding(load=padding))
else:
return SuperSocket.send(self, raw(x) + padding)
raise
def __init__(self, peer="127.0.0.1"):
SuperSocket.__init__(self, socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
self.outs = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
self.tx_addr = (peer, 52001)
self.rx_addr = (peer, 52002)
self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.outs.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
self.ins.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
self.outs.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
except AttributeError:
pass
self.ins.bind(self.rx_addr)
def recv(self, x=MTU):
# type: (int) -> Optional[Packet]
pkt = SuperSocket.recv(self, x)
if pkt and self.lvl == 2:
pkt.payload.time = pkt.time
return pkt.payload
return pkt
def recv(self, x=BPF_BUFFER_LENGTH):
"""Receive on layer 3"""
r = SuperSocket.recv(self, x)
if r:
r.payload.time = r.time
return r.payload
return r
def recv(self, x=0xffff):
msg = SuperSocket.recv(self, x)
if hasattr(msg, "src"):
msg.src = self.src
if hasattr(msg, "dst"):
msg.dst = self.dst
if hasattr(msg, "exsrc"):
msg.exsrc = self.exsrc
if hasattr(msg, "exdst"):
msg.exdst = self.exdst
return msg
def send(self, x):
try:
if hasattr(x, "sent_time"):
x.sent_time = time.time()
# need to change the byteoder of the first four bytes,
# required by the underlying Linux SocketCAN frame format
bs = bytes(x)
bs = bs + b'\x00' * (CAN_FRAME_SIZE - len(bs))
bs = struct.pack("<I12s", *struct.unpack(">I12s", bs))
return SuperSocket.send(self, bs)
except socket.error as msg:
raise msg
def send(self, x):
try:
if hasattr(x, "sent_time"):
x.sent_time = time.time()
# need to change the byteoder of the first four bytes,
# required by the underlying Linux SocketCAN frame format
bs = bytes(x)
bs = bs + b'\x00' * (CAN_FRAME_SIZE - len(bs))
bs = struct.pack("<I12s", *struct.unpack(">I12s", bs))
return SuperSocket.send(self, bs)
except socket.error as msg:
raise msg
def recv(self, x=0xffff):
# type: (int) -> Optional[Packet]
msg = SuperSocket.recv(self, x)
if msg is None:
return msg
if hasattr(msg, "src"):
msg.src = self.src
if hasattr(msg, "dst"):
msg.dst = self.dst
if hasattr(msg, "exsrc"):
msg.exsrc = self.exsrc
if hasattr(msg, "exdst"):
msg.exdst = self.exdst
return msg
def recv(self, x=0xffff):
# type: (int) -> Optional[Packet]
msg = SuperSocket.recv(self, x)
if msg is None:
return msg
if hasattr(msg, "tx_id"):
msg.tx_id = self.tx_id
if hasattr(msg, "rx_id"):
msg.rx_id = self.rx_id
if hasattr(msg, "ext_address"):
msg.ext_address = self.ext_address
if hasattr(msg, "rx_ext_address"):
msg.rx_ext_address = self.rx_ext_address
return msg
def close(self):
"""Close the socket and stop the receiving thread"""
self.can_socket.close()
self.rx_thread.stop()
SuperSocket.close(self)
def sniff(self, *args, **kargs):
# type: (Any, Any) -> PacketList
if six.PY3:
return SuperSocket.sniff(self, *args, **kargs)
else:
return SuperSocket.sniff.im_func(self, *args, **kargs)
def recv(self, x=MTU):
# cls, pkt, ts, direction = self.recv_raw()
# [Dissection stuff]
pkt = SuperSocket.recv(self, x)
# pkt.direction = direction
return pkt
def recv(self, x=MTU):
# cls, pkt, ts, direction = self.recv_raw()
# [Dissection stuff]
pkt = SuperSocket.recv(self, x)
# pkt.direction = direction
return pkt
def recv(self, x=MTU):
pkt = SuperSocket.recv(self, x)
if pkt and self.lvl == 2:
pkt = pkt.payload
return pkt
def sr1(self, *args, **kargs):
# type: (Any, Any) -> Optional[Packet]
if six.PY3:
return SuperSocket.sr1(self, *args, **kargs)
else:
return SuperSocket.sr1.im_func(self, *args, **kargs)
def recv(self, x=MTU): # type: ignore
# type: (int) -> Optional[Packet]
return SuperSocket.recv(self, x=x)
def close(self):
SuperSocket.close(self)
self.usbpcap_proc.kill()
def close(self):
SuperSocket.close(self)
self.usbpcap_proc.kill()
def recv(self, x=MTU):
pkt = SuperSocket.recv(self, x)
if pkt and self.lvl == 2:
pkt.payload.time = pkt.time
return pkt.payload
return pkt
def recv(self, x=MTU):
# type: (int) -> Optional[Packet]
if six.PY3:
return SuperSocket.recv(self, x)
else:
return SuperSocket.recv.im_func(self, x)
