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