class udpv4(pcs.Packet):
layout = pcs.Layout()
def __init__(self, bytes=None):
"""Initialize a UDP packet for IPv4"""
sport = pcs.Field("sport", 16)
dport = pcs.Field("dport", 16)
length = pcs.Field("length", 16)
checksum = pcs.Field("checksum", 16)
pcs.Packet.__init__(self, [sport, dport, length, checksum], bytes)
class ymsg_key_value(pcs.Packet):
_layout = pcs.Layout()
def __init__(self, bytes=None, **kv):
"""The actual message is a set of key/value pairs encoded
after the header.
"""
key = pcs.LengthValueField("key", 16)
value = pcs.LengthValueField("value", 16)
pcs.Packet.__init__(self, [key, value], bytes=bytes, **kv)
class icmpv4(pcs.Packet):
"""ICMPv4"""
_layout = pcs.Layout()
_map = icmp_map
_descr = descr
def __init__(self, bytes=None, timestamp=None, **kv):
"""initialize a ICMPv4 packet"""
type = pcs.Field("type", 8, discriminator=True)
code = pcs.Field("code", 8)
cksum = pcs.Field("checksum", 16)
pcs.Packet.__init__(self, [type, code, cksum], bytes, **kv)
self.description = "ICMPv4"
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if bytes is not None:
offset = self.sizeof()
# XXX Workaround Packet.next() -- it only returns something
# if it can discriminate.
self.data = self.next(bytes[offset:len(bytes)],
timestamp=timestamp)
if self.data is None:
from pcs.packets.payload import payload
self.data = payload(bytes[offset:len(bytes)])
else:
self.data = None
def calc_checksum(self):
"""Calculate and store the checksum for this ICMP header.
ICMP checksums are computed over payloads, but not IP headers."""
self.checksum = 0
tmpbytes = self.getbytes()
if not self._head is None:
tmpbytes += self._head.collate_following(self)
from pcs.packets.ipv4 import ipv4
self.checksum = ipv4.ipv4_cksum(tmpbytes)
def rdiscriminate(self, packet, discfieldname=None, map=icmp_map):
"""Reverse-map an encapsulated packet back to a discriminator
field value. Like next() only the first match is used."""
print "reverse discriminating %s" % type(packet)
return pcs.Packet.rdiscriminate(self, packet, "type", map)
def __str__(self):
"""Walk the entire packet and pretty print the values of the fields."""
retval = self._descr[self.type] + "\n"
for field in self._layout:
retval += "%s %s\n" % (field.name, field.value)
return retval
class dnslabel(pcs.Packet):
"""DNS Label"""
_layout = pcs.Layout()
def __init__(self, bytes=None):
"""initialize a DNS label, which is a component of a domain name"""
name = pcs.LengthValueField("name", 8)
pcs.Packet.__init__(self, [name], bytes=bytes)
self.description = "DNS Label"
class dnsquery(pcs.Packet):
"""A DNS query class"""
layout = pcs.Layout()
def __init__(self, bytes=None):
"""initialize a DNS query packet, which is a query for information"""
type = pcs.Field("type", 16)
qclass = pcs.Field("query_class", 16)
pcs.Packet.__init__(self, [type, qclass], bytes=bytes)
self.description = "DNS Query"
class stp(pcs.Packet):
"""IEEE 802.1d STP PDU"""
_layout = pcs.Layout()
_flagbits = "\x01ACK\x02AGREE\x03FORWARDING\x04LEARNING\x05BACKUP" \
"\x06ROOT\x07PROPOSAL\x08CHANGED"
def __init__(self, bytes=None, timestamp=None, **kv):
version = pcs.Field("version", 8)
type = pcs.Field("type", 8)
flags = pcs.Field("flags", 8)
root = pcs.StringField("root", 8 * 8)
cost = pcs.Field("cost", 32)
src = pcs.StringField("src", 8 * 8)
pid = pcs.Field("pid", 16)
age = pcs.Field("age", 16)
maxage = pcs.Field("maxage", 16)
interval = pcs.Field("interval", 16)
delay = pcs.Field("delay", 16)
#opt = pcs.OptionListField("opt")
pcs.Packet.__init__(self, [ version, type, flags, root, \
cost, src, pid, age, maxage, interval, \
delay ], bytes = bytes, **kv)
self.description = "IEEE 802.1d STP PDU"
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if bytes is not None:
offset = self.sizeof()
curr = offset
remaining = len(bytes) - offset
# 802.1d shouldn't have any trailers.
self.data = payload.payload(bytes[curr:remaining], \
timestamp = timestamp)
else:
self.data = None
def __str__(self):
"""Walk the entire packet and pretty print the values of the fields."""
s = self._descr[self.type] + "\n"
for fn in self._layout:
f = self._fieldnames[fn.name]
if fn.name == "flags":
bs = bsprintf(f.value, self._flagbits)
s += "%s %s\n" % (fn.name, bs)
else:
s += "%s %s\n" % (fn.name, f.value)
return s
class arp(pcs.Packet):
layout = pcs.Layout()
def __init__(self, bytes=None):
"""initialize an ARP packet"""
hrd = pcs.Field("hrd", 16, default=1)
pro = pcs.Field("pro", 16, default=0x800)
hln = pcs.Field("hln", 8, default=6)
pln = pcs.Field("pln", 8, default=4)
op = pcs.Field("op", 16)
sha = pcs.StringField("sha", 48)
spa = pcs.Field("spa", 32)
tha = pcs.StringField("tha", 48)
tpa = pcs.Field("tpa", 32)
pcs.Packet.__init__(self, [hrd, pro, hln, pln, op, sha, spa, tha, tpa],
bytes=bytes)
self.description = "ARP"
self.data = None
def __str__(self):
"""return a human readable version of an ARP packet"""
retval = "ARP\n"
retval += "hrd: "
retval += "%d\n" % self.hrd
retval += "pro: "
retval += "%d\n" % self.pro
retval += "hln: "
retval += "%d\n" % self.hln
retval += "pln: "
retval += "%d\n" % self.pln
retval += "op: "
retval += "%d\n" % self.op
retval += "sha: "
for byte in range(0, 5):
retval += "%s:" % hex(ord(self.sha[byte]))[2:4]
retval += "%s\n" % hex(ord(self.sha[5]))[2:4]
retval += "spa: "
retval += "%s\n" % inet_ntop(AF_INET, struct.pack('!L', self.spa))
retval += "tha: "
for byte in range(0, 5):
retval += "%s:" % hex(ord(self.tha[byte]))[2:4]
retval += "%s\n" % hex(ord(self.tha[5]))[2:4]
retval += "tpa: "
retval += "%s\n" % inet_ntop(AF_INET, struct.pack('!L', self.tpa))
return retval
class rt_msg(pcs.Packet):
"""BSD Routing socket -- routing message"""
_layout = pcs.Layout()
_map = None
_descr = None
_flagbits = "\x01UP\x02GATEWAY\x03HOST\x04REJECT\x05DYNAMIC"\
"\x06MODIFIED\x07DONE\x09CLONING\x0aXRESOLVE\x0bLLINFO"\
"\x0cSTATIC\x0dBLACKHOLE\x0ePROTO2\x0fPROTO1\x10PRCLONING"\
"\x11WASCLONED\x12PROTO3\x14PINNED\x15LOCAL\x16BROADCAST"\
"\x17MULTICAST"
def __init__(self, bytes=None, timestamp=None, **kv):
""" Define the common rtmsg header; see <net/route.h>. """
index = pcs.Field("index", 16)
flags = pcs.Field("flags", 32)
addrs = pcs.Field("addrs", 32)
pid = pcs.Field("pid", 32)
seq = pcs.Field("seq", 32)
errno = pcs.Field("errno", 32)
fmask = pcs.Field("fmask", 32)
inits = pcs.Field("inits", 32)
# 14 * sizeof(long) on platform; arch-specific.
#rmx = pcs.Field("rmx", 32)
pcs.Packet.__init__(self, [index, flags, addrs, pid, seq, errno, \
fmask, inits], bytes = bytes, **kv)
self.description = " Define the common rtmsg header; see <net/route.h>. "
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if bytes is not None:
offset = self.sizeof()
self.data = payload.payload(bytes[offset:len(bytes)])
else:
self.data = None
def __str__(self):
"""Walk the entire packet and pretty print the values of the fields."""
s = self._descr[self.type] + "\n"
for fn in self._layout:
f = self._fieldnames[fn.name]
if fn.name == "flags":
bs = bsprintf(f.value, self._flagbits)
s += "%s %s\n" % (fn.name, bs)
else:
s += "%s %s\n" % (fn.name, f.value)
return s
class pseudoipv6(pcs.Packet):
"""A class that create an IPv6 pseudo header used
for upper-layer checksums."""
_layout = pcs.Layout()
def __init__(self, bytes=None, timestamp=None):
"""IPv6 pseudo header from RFC 2460"""
src = pcs.StringField("src", 16 * 8)
dst = pcs.StringField("dst", 16 * 8)
length = pcs.Field("length", 32)
zero = pcs.Field("zero", 24)
nh = pcs.Field("next_header", 8)
pcs.Packet.__init__(self, [src, dst, length, zero, nh], bytes)
class nd6_solicit(pcs.Packet):
"""Neighbor Discovery"""
_layout = pcs.Layout()
def __init__(self, bytes=None, timestamp=None, **kv):
"""initialize a Neighbor Solicitaion header"""
reserved = pcs.Field("reserved", 32)
target = pcs.Field("target", 128)
pcs.Packet.__init__(self, [reserved, target], bytes, **kv)
self.description = "initialize a Neighbor Solicitaion header"
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
class frag(pcs.Packet):
"""A class that contains the IPv6 fragmentation extension-headers."""
layout = pcs.Layout()
def __init__(self, bytes=None):
"""IPv6 fragmentation extension header from RFC 2460"""
next = pcs.Field("next_header", 8)
reserved = pcs.Field("reserved", 8)
offset = pcs.Field("offset", 13)
res = pcs.Field("res", 2)
m = pcs.Field("m", 1)
identification = pcs.Field("identification", 32)
pcs.Packet.__init__(self,
[next, reserved, offset, res, m, identification],
bytes)
class rtmsghdr(pcs.Packet):
"""BSD Routing socket -- message header (common to all messages)"""
_layout = pcs.Layout()
_map = rtmsg_map
_descr = descr
def __init__(self, bytes=None, timestamp=None, **kv):
""" Define the common rtmsg header; see <net/route.h>. """
msglen = pcs.Field("msglen", 16)
version = pcs.Field("version", 8, default=RTM_VERSION)
type = pcs.Field("type", 8, discriminator=True)
# XXX There's implicit padding all over the shop here.
pad0 = pcs.Field("type", 16)
pcs.Packet.__init__(self, [msglen, version, type, pad0], \
bytes = bytes, **kv)
self.description = " Define the common rtmsg header; see <net/route.h>. "
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if bytes is not None:
# XXX Workaround Packet.next() -- it only returns something
# if it can discriminate.
# XXX Should try rtmsg next, next.
offset = self.sizeof()
self.data = self.next(bytes[offset:len(bytes)],
timestamp=timestamp)
if self.data is None:
self.data = payload.payload(bytes[offset:len(bytes)])
else:
self.data = None
def rdiscriminate(self, packet, discfieldname=None, map=rtmsg_map):
"""Reverse-map an encapsulated packet back to a discriminator
field value. Like next() only the first match is used."""
return pcs.Packet.rdiscriminate(self, packet, "type", map)
def __str__(self):
"""Walk the entire packet and pretty print the values of the fields."""
s = self._descr[self.type] + "\n"
for field in self._layout:
s += "%s %s\n" % (field.name, field.value)
return s
class testPacket(pcs.Packet):
"""Define a packet containing a TLV field for use in testing."""
_layout = pcs.Layout()
def __init__(self, bytes=None):
f1 = pcs.Field("f1", 32)
f2 = pcs.TypeLengthValueField("f2", pcs.Field("t", 8),
pcs.Field("l", 8),
pcs.StringField("v", 10 * 8))
pcs.Packet.__init__(self, [f1, f2], bytes=None)
def __str__(self):
"""Walk the entire packet and pretty print the values of the fields."""
retval = "TEST\n"
for field in self._layout:
retval += "%s %s\n" % (field.name, self.__dict__[field.name])
return retval
class dnsrr(pcs.Packet):
"""A DNS Resource Record"""
layout = pcs.Layout()
def __init__(self, bytes=None):
"""initialize a DNS resource record, which encodes data returned from a query"""
name = pcs.LengthValueField("name", 8)
type = pcs.Field("type", 16)
qclass = pcs.Field("query_class", 16)
ttl = pcs.Field("ttl", 16)
rdata = pcs.LengthValueField("rdata", 16)
pcs.Packet.__init__(self, [name, type, qclass, ttl, rdata],
bytes=bytes)
self.description = "DNS Resource Record"
class ethernet(pcs.Packet):
layout = pcs.Layout()
def __init__(self, bytes = None):
"""initialize an ethernet packet"""
src = pcs.StringField("src", 48)
dst = pcs.StringField("dst", 48)
type = pcs.Field("type", 16)
etherlen = 14
pcs.Packet.__init__(self, [dst, src, type], bytes = bytes)
self.description = "Ethernet"
if (bytes != None):
self.data = self.next(bytes[etherlen:len(bytes)])
else:
self.data = None
def __str__(self):
"""return a human readable version of an Ethernet packet"""
retval = "Ethernet\n"
retval += "dst: "
for byte in range(0,5):
retval += "%s:" % hex(ord(self.dst[byte]))[2:4]
retval += "%s" % hex(ord(self.dst[5]))[2:4]
retval += "\nsrc: "
for byte in range(0,5):
retval += "%s:" % hex(ord(self.src[byte]))[2:4]
retval += "%s" % hex(ord(self.src[5]))[2:4]
retval += "\ntype: %s" % hex(self.type)
return retval
def next(self, bytes):
"""Decode the type of a packet and return the correct higher
level protocol object"""
## the ethertype of the packet
if self.type == ETHERTYPE_ARP:
return arp(bytes)
if self.type == ETHERTYPE_IP:
return ipv4(bytes)
if self.type == ETHERTYPE_IPV6:
return ipv6(bytes)
return None
class boundaryPacket(pcs.Packet):
"""Define a packet full of bit fields for use in testing.
"""
_layout = pcs.Layout()
def __init__(self, bytes=None):
f1 = pcs.Field("f1", 1)
f2 = pcs.Field("f2", 2)
f3 = pcs.Field("f3", 3)
f4 = pcs.Field("f4", 4)
f5 = pcs.Field("f5", 5)
f6 = pcs.Field("f6", 6)
f7 = pcs.Field("f7", 7)
f8 = pcs.Field("f8", 8)
f9 = pcs.Field("f9", 9)
f10 = pcs.Field("f10", 10)
f11 = pcs.Field("f11", 11)
f12 = pcs.Field("f12", 12)
f13 = pcs.Field("f13", 13)
f14 = pcs.Field("f14", 14)
f15 = pcs.Field("f15", 15)
f16 = pcs.Field("f16", 16)
f17 = pcs.Field("f17", 17)
f18 = pcs.Field("f18", 18)
f19 = pcs.Field("f19", 19)
f20 = pcs.Field("f20", 20)
f21 = pcs.Field("f21", 21)
f22 = pcs.Field("f22", 22)
f23 = pcs.Field("f23", 23)
f24 = pcs.Field("f24", 24)
f25 = pcs.Field("f25", 25)
f26 = pcs.Field("f26", 26)
f27 = pcs.Field("f27", 27)
f28 = pcs.Field("f28", 28)
f29 = pcs.Field("f29", 29)
f30 = pcs.Field("f30", 30)
f31 = pcs.Field("f31", 31)
f32 = pcs.Field("f32", 32)
pcs.Packet.__init__(self, [
f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15,
f16, f17, f18, f19, f20, f21, f22, f23, f24, f25, f26, f27, f28,
f29, f30, f31, f32
],
bytes=None)
class tcp(pcs.Packet):
"""A TCP class for IPv4"""
layout = pcs.Layout()
def __init__(self, bytes = None):
"""initialize a TCP packet"""
sport = pcs.Field("sport", 16)
dport = pcs.Field("dport", 16)
seq = pcs.Field("sequence", 32)
acknum = pcs.Field("ack_number", 32)
off = pcs.Field("offset", 4)
reserved = pcs.Field("reserved", 6)
urg = pcs.Field("urgent", 1)
ack = pcs.Field("ack", 1)
psh = pcs.Field("push", 1)
rst = pcs.Field("reset", 1)
syn = pcs.Field("syn", 1)
fin = pcs.Field("fin", 1)
window = pcs.Field("window", 16)
cksum = pcs.Field("checksum", 16)
urgp = pcs.Field("urg_pointer",16)
pcs.Packet.__init__(self, [sport, dport, seq, acknum, off, reserved,
urg, ack, psh, rst, syn, fin, window,
cksum, urgp],
bytes = bytes)
self.description = "TCP"
if (bytes != None):
offset = 20
self.data = payload.payload(bytes[offset:len(bytes)])
else:
self.data = None
def __str__(self):
"""Walk the entire packet and pretty print the values of the fields. Addresses are printed if and only if they are set and not 0."""
retval = ""
for field in self.layout:
retval += "%s %d\n" % (field.name, self.__dict__[field.name])
#if (field.type == str):
# retval += "%s %s\n" % (field.name, self.__dict__[field.name])
#else:
# retval += "%s %d\n" % (field.name, self.__dict__[field.name])
return retval
class ieee80211_leave_event(pcs.Packet):
"""BSD Routing socket -- IEEE 802.11 leave event"""
_layout = pcs.Layout()
_map = None
_descr = None
def __init__(self, bytes=None, timestamp=None, **kv):
address = pcs.Field("address", 6 * 8)
pcs.Packet.__init__(self, [address], bytes=bytes, **kv)
self.description = "BSD Routing socket -- IEEE 802.11 leave event"
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if bytes is not None:
offset = self.sizeof()
self.data = payload.payload(bytes[offset:len(bytes)])
else:
self.data = None
class if_link_msg(pcs.Packet):
"""BSD Routing socket -- link-state message (if_msghdr)"""
_layout = pcs.Layout()
_map = None
_descr = None
_flagbits = _iff_flagbits
def __init__(self, bytes=None, timestamp=None, **kv):
addrs = pcs.Field("addrs", 32)
flags = pcs.Field("flags", 32)
index = pcs.Field("index", 16)
pad00 = pcs.Field("pad00", 16) # XXX very likely it's padded
# XXX We don't decode if_data yet.
# Its length (and widths) are arch-dependent!
data = pcs.Field("data", 152 * 8)
pcs.Packet.__init__(self, [addrs, flags, index, pad00, ifdata], \
bytes = bytes, **kv)
self.description = "BSD Routing socket -- link-state message (if_msghdr)"
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if bytes is not None:
offset = self.sizeof()
self.data = payload.payload(bytes[offset:len(bytes)])
else:
self.data = None
def __str__(self):
"""Walk the entire packet and pretty print the values of the fields."""
s = self._descr[self.type] + "\n"
for fn in self._layout:
f = self._fieldnames[fn.name]
if fn.name == "flags":
bs = bsprintf(f.value, self._flagbits)
s += "%s %s\n" % (fn.name, bs)
else:
s += "%s %s\n" % (fn.name, f.value)
return s
class Common(pcs.Packet):
"""PTP Common Header"""
_layout = pcs.Layout()
_map = ptp_map.map
def __init__(self, bytes = None, timestamp = None, **kv):
"""initialize the common header """
transportSpecific = pcs.Field("transportSpecific", 4)
messageType = pcs.Field("versionNetwork", 4, discriminator = True)
reserved0 = pcs.Field("reserved0", 4)
versionPTP = pcs.Field("versionPTP", 4)
messageLength = pcs.Field("messageLength", 16)
domainNumber = pcs.Field("domainNumber", 8)
reserved1 = pcs.Field("reserved1", 8)
flagField = pcs.Field("flagField", 16)
correctionField = pcs.Field("correctionField", 64)
reserved2 = pcs.Field("reserved2", 32)
sourcePortIdentity = pcs.Field("sourcePortIdentity", 80)
sequenceId = pcs.Field("sequenceId", 16)
controlField = pcs.Field("controlField", 8)
logMessageInterval = pcs.Field("logMessageInterval", 8)
pcs.Packet.__init__(self, [transportSpecific, messageType,
reserved0,
versionPTP, messageLength, domainNumber,
reserved1,
flagField, correctionField,
reserved2,
sourcePortIdentity, sequenceId, controlField,
logMessageInterval],
bytes = bytes, **kv)
self.description = "PTP Common Header"
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if (bytes is not None):
self.data = self.next(bytes[self.sizeof():len(bytes)],
timestamp = timestamp)
else:
self.data = None
class ipcomp(pcs.Packet):
_layout = pcs.Layout()
def __init__(self, bytes=None, **kv):
"A class that contains the IPComp header. RFC3173"
nx = pcs.Field("next_header", 8)
flags = pcs.Field("flags", 8)
cpi = pcs.Field("cpi", 16)
pcs.Packet.__init__(self, [nx, flags, cpi], bytes=bytes, **kv)
def __str__(self):
"""Walk the entire packet and pretty print the values
of the fields. Addresses are printed if and only if
they are set and not 0."""
retval = ""
for field in self._layout:
retval += "%s %d\n" % (field.name, field.value)
return retval
class ah(pcs.Packet):
"""AH"""
_layout = pcs.Layout()
def __init__(self, bytes=None, timestamp=None, **kv):
"""initialize an AH packet header"""
next = pcs.Field("next_header", 8)
plen = pcs.Field("payload_len", 8)
rsvrd = pcs.Field("reserved", 16)
spi = pcs.Field("SPI", 32)
seq = pcs.Field("sequence", 32)
auth = pcs.Field("auth_data", 128)
pcs.Packet.__init__(self, [next, plen, rsvrd, spi, seq, auth], bytes,
**kv)
self.description = "initialize an AH packet header"
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
class rthdr(pcs.Packet):
"""A class that contains the IPv6 routing extension-headers."""
layout = pcs.Layout()
def __init__(self, bytes=None):
"""IPv6 routing extension header from RFC 2460"""
next = pcs.Field("next_header", 8)
len = pcs.Field("length", 8)
type = pcs.Field("type", 8)
segments_left = pcs.Field("segments_left", 8)
pcs.Packet.__init__(self, [next, len, type, segments_left], bytes)
def rthdr0(self, seg=1, bytes=None):
"""IPv6 routing extension header type 0"""
reserved = pcs.Field("reserved", 32, default=0)
header = [reserved]
for i in range(seg):
header.append(pcs.StringField("address" + str(i), 128))
pcs.Packet.__add__(self, header)
class icmpv6option(pcs.Packet):
layout = pcs.Layout()
def __init__(self, type=0, bytes=None):
"""add icmp6 option header RFC2461"""
ty = pcs.Field("type", 8, default=type)
length = pcs.Field("length", 8)
# Source Link-Layer Address.
if type == 1:
source = pcs.Field("source", 48)
pcs.Packet.__init__(self, [ty, length, source], bytes)
# Target Link-Layer Address
elif type == 2:
target = pcs.Field("target", 48)
pcs.Packet.__init__(self, [ty, length, target], bytes)
# Prefix Information.
elif type == 3:
plength = pcs.Field("prefix_length", 8)
l = pcs.Field("L", 1)
a = pcs.Field("A", 1)
reserved1 = pcs.Field("reserved1", 6)
vlf = pcs.Field("valid_lifetime", 32)
plf = pcs.Field("preferred_lifetime", 32)
reserved2 = pcs.Field("reserved2", 32)
prefix = pcs.Field("prefix", 16 * 8, type=str)
pcs.Packet.__init__(self, [
ty, length, plength, l, a, reserved1, vlf, plf, reserved2,
prefix
], bytes)
# Redirected Header.
elif type == 4:
reserved = pcs.Field("reserved", 48)
pcs.Packet.__init__(self, [ty, length, reserved], bytes)
# MTU
elif type == 5:
reserved = pcs.Field("reserved", 16)
mtu = pcs.Field("mtu", 32)
pcs.Packet.__init__(self, [ty, length, reserved, mtu], bytes)
else:
pcs.Packet.__init__(self, [ty, length], bytes)
class CommonV1(pcs.Packet):
"""PTPv1 Common Header"""
_layout = pcs.Layout()
_map = ptp_map.map
def __init__(self, bytes=None, timestamp=None, **kv):
"""initialize the common header """
versionPTP = pcs.Field("versionPTP", 16)
versionNetwork = pcs.Field("versionNetwork", 16)
subdomain = pcs.StringField("subdomain", PTP_SUBDOMAIN_NAME_LENGTH * 8)
messageType = pcs.Field("messageType", 8)
sourceCommunicationTechnology = pcs.Field(
"sourceCommunicationTechnology", 8)
sourceUuid = pcs.StringField("sourceUuid", PTP_UUID_LENGTH * 8)
sourcePortId = pcs.Field("sourcePortId", 16)
sequenceId = pcs.Field("sequenceId", 16)
control = pcs.Field("control", 8, discriminator=True)
zero1 = pcs.Field("zero1", 8, default=0)
flags = pcs.Field("flags", 16)
zero2 = pcs.Field("zero2", 32, default=0)
pcs.Packet.__init__(self, [
versionPTP, versionNetwork, subdomain, messageType,
sourceCommunicationTechnology, sourceUuid, sourcePortId,
sequenceId, control, zero1, flags, zero2
],
bytes=bytes,
**kv)
self.description = "initialize the common header "
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if (bytes is not None):
self.data = self.next(bytes[self.sizeof():len(bytes)],
timestamp=timestamp)
else:
self.data = None
class ifinfomsg(pcs.Packet):
"""RFC 3549 interface information message."""
_layout = pcs.Layout()
_map = None
_descr = None
_flag_bits = \
"\x01UP\x02BROADCAST\x03DEBUG\x04LOOPBACK"\
"\x05POINTOPOINT\x06NOTRAILERS\x07RUNNING"\
"\x08NOARP\x09PROMISC\x0aALLMULTI"\
"\x0bMASTER\x0cSLAVE\x0dMULTICAST"\
"\x0ePORTSEL\x0fAUTOMEDIA\x10DYNAMIC"\
"\x11LOWER_UP\x12DORMANT\x13ECHO"
def __init__(self, bytes=None, timestamp=None, **kv):
family = pcs.Field("family", 8)
pad00 = pcs.Field("pad00", 8)
type = pcs.Field("type", 16)
index = pcs.Field("index", 32)
flags = pcs.Field("flags", 32)
change = pcs.Field("change", 32)
#tlvs = pcs.OptionListField("tlvs")
pcs.Packet.__init__(self, [family, pad00, type, index, flags, change],\
bytes = bytes, **kv)
self.description = "RFC 3549 interface information message."
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if bytes is not None:
offset = self.sizeof()
remaining = len(bytes) - offset
# TODO demux TLVs.
if self.data is None:
self.data = payload.payload(bytes[offset:remaining], \
timestamp=timestamp)
else:
self.data = None
class cookie_ack(pcs.Packet):
"""SCTP Cookie ACK"""
_layout = pcs.Layout()
def __init__(self, bytes=None, timestamp=None, **kv):
"""common header initialization"""
type = pcs.Field("type", 8, default=11)
flags = pcs.Field("flags", 8)
length = pcs.Field("length", 16, default=4)
pcs.Packet.__init__(self, [type, flags, length], bytes=bytes, **kv)
self.description = "SCP Cookie ACK"
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if (bytes is not None):
self.data = self.next(bytes[0:len(bytes)], timestamp=timestamp)
else:
self.data = None
class localhost(pcs.Packet):
"""Localhost"""
_layout = pcs.Layout()
_map = localhost_map.map
def __init__(self, bytes=None, timestamp=None, **kv):
"""initialize a localhost header, needed to read or write to lo0"""
type = pcs.Field("type", 32, discriminator=True)
lolen = 4
pcs.Packet.__init__(self, [type], bytes=bytes, **kv)
self.description = "Localhost"
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if (bytes is not None):
self.data = self.next(bytes[lolen:len(bytes)], timestamp=timestamp)
else:
self.data = None
class payload(pcs.Packet):
"""A raw data packet.
A payload is a raw, set of bytes, and can be used to terminate any
packet chain. When data is not part of a packet, or the packet is
not known this class is used to encapsulate the data."""
layout = pcs.Layout()
def __init__(self, bytes=None):
"""initialize a payload packet"""
payload = pcs.Field("payload", len(bytes) * 8)
pcs.Packet.__init__(self, [payload], bytes=bytes)
self.description = "Data"
# Unconditionally the last packet in a chain
self.data = None
def __str__(self):
"""return a readable version of a payload object"""
retval = "%s" % self.payload
class DelayResponseV1(pcs.Packet):
"""PTPv1 Delay Response"""
_layout = pcs.Layout()
def __init__(self, bytes=None, timestamp=None, **kv):
"""Followup Header """
delayReceiptTimestampSeconds = pcs.Field(
"delayReceiptTimestampSeconds", 32)
delayReceiptTimestampNanoseconds = pcs.Field(
"delayReceiptTimestampNanoseconds", 32)
zero1 = pcs.Field("zero1", 8, default=0)
requestingSourceCommunicationTechnology = pcs.Field(
"requestingSourceCommunicationTechnology", 8)
requestingSourceUuid = pcs.StringField("requestingSourceUuid",
PTP_UUID_LENGTH * 8)
requestingSourcePortId = pcs.Field("requestingSourcePortId", 16)
requestingSourceSequenceId = pcs.Field("requestingSourceSequenceId",
16)
pcs.Packet.__init__(self, [
delayReceiptTimestampSeconds, delayReceiptTimestampNanoseconds,
zero1, requestingSourceCommunicationTechnology,
requestingSourceUuid, requestingSourcePortId,
requestingSourceSequenceId
],
bytes=bytes,
**kv)
self.description = "Followup Header "
if timestamp is None:
self.timestamp = time.time()
else:
self.timestamp = timestamp
if (bytes is not None):
self.data = self.next(bytes[self.sizeof():len(bytes)],
timestamp=timestamp)
else:
self.data = None
