def serialize_value(self): args = [] for f in self._VALUE_FIELDS: args.append(getattr(self, f)) buf = bytearray() msg_pack_into(self._VALUE_PACK_STR, buf, 0, *args) return buf
def serialize(self): # fixup self.length = len(self.value) buf = bytearray() msg_pack_into(self._PACK_STR, buf, 0, self.type, self.length) return buf + bytes(self.value)
def serialize_value(self): buf = bytearray() for comm in self.communities: bincomm = bytearray() msg_pack_into(self._VALUE_PACK_STR, bincomm, 0, comm) buf += bincomm return buf
def serialize_value(self): buf = bytearray() ifaddr = ipv4.text_to_bin(self.ifaddr) area_id = ipv4.text_to_bin(self.area_id) router_id = ipv4.text_to_bin(self.router_id) msg_pack_into(self._VALUE_PACK_STR, buf, 0, ifaddr, area_id, router_id, status, 0) return buf
def serialize(self): # fixup value = self.serialize_value() self.length = len(value) buf = bytearray() msg_pack_into(self._PACK_STR, buf, 0, self.type, self.length) return buf + value
def serialize_value(self): buf = bytearray() msg_pack_into(self._VALUE_PACK_STR, buf, 0, self.afi, self.safi) binnlri = bytearray() for n in self.withdrawn_routes: binnlri += n.serialize() buf += binnlri return buf
def serialize_cap_value(self): # fixup self.reserved = 0 buf = bytearray() msg_pack_into(self._CAP_PACK_STR, buf, 0, self.afi, self.reserved, self.safi) return buf
def _serialize_subfield(subfield): (field, ofs) = subfield buf = bytearray() n = ofp.oxm_from_user_header(field) ofp.oxm_serialize_header(n, buf, 0) assert len(buf) == 4 # only 4-bytes NXM/OXM are defined msg_pack_into('!H', buf, 4, ofs) return buf
def serialize_value(self): # fixup cap_value = self.serialize_cap_value() self.cap_length = len(cap_value) buf = bytearray() msg_pack_into(self._CAP_HDR_PACK_STR, buf, 0, self.cap_code, self.cap_length) return buf + cap_value
def serialize(self, buf, offset): """ Serialize PushGPRSNS action into buffer. """ super(GPRSActionPushGPRSNS,self).serialize(buf, offset) imsi_bytes = imsi_to_bytes(self.imsi) LOG.debug("push_gprsns.serialize self="+pprint.pformat(self)) ofproto_parser.msg_pack_into("!HxxIHBBHBBBBBBBBBx", buf, offset+8, self.subtype, self.tlli, self.bvci, self.sapi, self.nsapi, self.drx_param, len(imsi_bytes), *imsi_bytes)
def serialize_value(self): args = [] for f in self._VALUE_FIELDS: v = getattr(self, f) if f == 'ipv4_address': v = bytes(addrconv.ipv4.text_to_bin(v)) args.append(v) buf = bytearray() msg_pack_into(self._VALUE_PACK_STR, buf, 0, *args) return buf
def serialize(self): # fixup self.length = len(self.value) if self.length > 255: self.flags |= BGP_ATTR_FLAG_EXTENDED_LENGTH len_pack_str = self._PACK_STR_EXT_LEN else: self.flags &= ~BGP_ATTR_FLAG_EXTENDED_LENGTH len_pack_str = self._PACK_STR_LEN buf = bytearray() msg_pack_into(self._PACK_STR, buf, 0, self.flags, self.type) msg_pack_into(len_pack_str, buf, len(buf), self.length) return buf + bytes(self.value)
def serialize_value(self): # fixup self.next_hop_len = len(self.next_hop) self.reserved = '\0' buf = bytearray() msg_pack_into(self._VALUE_PACK_STR, buf, 0, self.afi, self.safi, self.next_hop_len) buf += self.next_hop buf += self.reserved binnlri = bytearray() for n in self.nlri: binnlri += n.serialize() buf += binnlri return buf
def serialize_value(self): buf = bytearray() offset = 0 for e in self.value: if isinstance(e, set): type_ = self._AS_SET elif isinstance(e, list): type_ = self._AS_SEQUENCE l = list(e) num_as = len(l) msg_pack_into(self._SEG_HDR_PACK_STR, buf, offset, type_, num_as) offset += struct.calcsize(self._SEG_HDR_PACK_STR) for i in l: msg_pack_into(self._AS_PACK_STR, buf, offset, i) offset += struct.calcsize(self._AS_PACK_STR) return buf
def serialize(self): # fixup byte_length = (self.length + 7) / 8 bin_addr = self._to_bin(self.addr) if (self.length % 8) == 0: bin_addr = bin_addr[:byte_length] else: # clear trailing bits in the last octet. # rfc doesn't require this. mask = 0xff00 >> (self.length % 8) last_byte = chr(ord(bin_addr[byte_length - 1]) & mask) bin_addr = bin_addr[:byte_length - 1] + last_byte self.addr = self._to_text(bin_addr) buf = bytearray() msg_pack_into(self._PACK_STR, buf, 0, self.length) return buf + bytes(bin_addr)
def serialize(self): # fixup byte_length = (self.length + 7) / 8 bin_ip_addr = addrconv.ipv4.text_to_bin(self.ip_addr) if (self.length % 8) == 0: bin_ip_addr = bin_ip_addr[:byte_length] else: # clear trailing bits in the last octet. # rfc doesn't require this. mask = 0xff00 >> (self.length % 8) last_byte = chr(ord(bin_ip_addr[byte_length - 1]) & mask) bin_ip_addr = bin_ip_addr[:byte_length - 1] + last_byte self.ip_addr = addrconv.ipv4.bin_to_text(pad(bin_ip_addr, 4)) buf = bytearray() msg_pack_into(self._PACK_STR, buf, 0, self.length) return buf + bytes(bin_ip_addr)
def serialize(self, buf, offset): # fixup data = bytearray() msg_pack_into(NXActionRegMove._fmt_str, data, 0, self.n_bits, self.src_ofs, self.dst_ofs) # src field n = ofp.oxm_from_user_header(self.src_field) ofp.oxm_serialize_header(n, data, len(data)) # dst field n = ofp.oxm_from_user_header(self.dst_field) ofp.oxm_serialize_header(n, data, len(data)) payload_offset = ( ofp.OFP_ACTION_EXPERIMENTER_HEADER_SIZE + struct.calcsize(NXAction._fmt_str) ) self.len = utils.round_up(payload_offset + len(data), 8) super(NXActionRegMove, self).serialize(buf, offset) msg_pack_into('!%ds' % len(data), buf, offset + payload_offset, bytes(data))
def serialize(self): # fixup if not self._ATTR_FLAGS is None: self.flags = self.flags \ & ~(BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANSITIVE) \ | self._ATTR_FLAGS value = self.serialize_value() self.length = len(value) if self.length > 255: self.flags |= BGP_ATTR_FLAG_EXTENDED_LENGTH len_pack_str = self._PACK_STR_EXT_LEN else: self.flags &= ~BGP_ATTR_FLAG_EXTENDED_LENGTH len_pack_str = self._PACK_STR_LEN buf = bytearray() msg_pack_into(self._PACK_STR, buf, 0, self.flags, self.type) msg_pack_into(len_pack_str, buf, len(buf), self.length) return buf + value
def serialize(self, buf, offset): # fixup data = bytearray() msg_pack_into(NXActionLearn._fmt_str, data, 0, self.idle_timeout, self.hard_timeout, self.priority, self.cookie, self.flags, self.table_id, self.fin_idle_timeout, self.fin_hard_timeout) for spec in self.specs: data += spec.serialize() payload_offset = ( ofp.OFP_ACTION_EXPERIMENTER_HEADER_SIZE + struct.calcsize(NXAction._fmt_str) ) self.len = utils.round_up(payload_offset + len(data), 8) super(NXActionLearn, self).serialize(buf, offset) msg_pack_into('!%ds' % len(data), buf, offset + payload_offset, bytes(data))
def _test_msg_pack_into(self, offset_type='e'): fmt = '!HH' len_ = struct.calcsize(fmt) buf = bytearray(len_) offset = len_ arg1 = 1 arg2 = 2 if offset_type == 'l': offset += 1 elif offset_type == 'g': offset -= 1 ofproto_parser.msg_pack_into(fmt, buf, offset, arg1, arg2) check_offset = len(buf) - len_ res = struct.unpack_from(fmt, buffer(buf), check_offset) eq_(arg1, res[0]) eq_(arg2, res[1]) return True
def _test_msg_pack_into(self, offset_type='e'): fmt = '!HH' len_ = struct.calcsize(fmt) buf = bytearray().zfill(len_) offset = len_ arg1 = 1 arg2 = 2 if offset_type == 'l': offset += 1 elif offset_type == 'g': offset -= 1 ofproto_parser.msg_pack_into(fmt, buf, offset, arg1, arg2) check_offset = len(buf) - len_ res = struct.unpack_from(fmt, buffer(buf), check_offset) eq_(arg1, res[0]) eq_(arg2, res[1]) return True
def serialize(self): buf = bytearray() if isinstance(self.src, tuple): src_type = 0 # subfield else: src_type = 1 # immediate # header val = (src_type << 13) | (self._dst_type << 11) | self.n_bits msg_pack_into(self._hdr_fmt_str, buf, 0, val) # src if src_type == 0: # subfield buf += self._serialize_subfield(self.src) elif src_type == 1: # immediate src_len = (self.n_bits + 15) / 16 * 2 buf += type_desc.IntDescr(size=src_len).from_user(self.src) # dst if self._dst_type == 0: # match buf += self._serialize_subfield(self.dst) elif self._dst_type == 1: # load buf += self._serialize_subfield(self.dst) elif self._dst_type == 2: # output pass # empty return buf
def serialize_tail(self): # fixup binroutes = bytearray() for r in self.withdrawn_routes: binroutes += r.serialize() self.withdrawn_routes_len = len(binroutes) binpathattrs = bytearray() for pa in self.path_attributes: binpathattrs += pa.serialize() self.total_path_attribute_len = len(binpathattrs) binnlri = bytearray() for n in self.nlri: binnlri += n.serialize() msg = bytearray() offset = 0 msg_pack_into('!H', msg, offset, self.withdrawn_routes_len) msg += binroutes offset += 2 + self.withdrawn_routes_len msg_pack_into('!H', msg, offset, self.total_path_attribute_len) msg += binpathattrs offset += 2 + self.total_path_attribute_len msg += binnlri return msg
def serialize(self, buf, offset): """ Serialize PushUDPIP action into buffer. """ super(GPRSActionPushUDPIP,self).serialize(buf, offset) ofproto_parser.msg_pack_into("!Hxx4s4sHH", buf, offset+8, self.subtype, self.da, self.sa, self.dp, self.sp)
def serialize(self): buf = bytearray() msg_pack_into(self._PACK_STR, buf, 0, self.type, bytes(self.serialize_value())) return buf
def serialize(self, buf, offset): """ Serialize action into buffer. """ super(GPRSAction,self).serialize(buf, offset) ofproto_parser.msg_pack_into("!H", buf, offset+8, self.subtype)
def serialize(self, buf, offset): """ Serialize PushGPRSNS action into buffer. """ super(GPRSActionPushGPRSNS,self).serialize(buf, offset) ofproto_parser.msg_pack_into("!HxxIHBBxxxx", buf, offset+8, self.subtype, self.tlli, self.bvci, self.sapi, self.nsapi)
def serialize(self, buf, offset): """ Serialize PushGPRSNS action into buffer. """ super(GPRSActionPushGPRSNS, self).serialize(buf, offset) ofproto_parser.msg_pack_into("!HxxIHBBxxxx", buf, offset + 8, self.subtype, self.tlli, self.bvci, self.sapi, self.nsapi)
def serialize_value(self): buf = bytearray() msg_pack_into(self._VALUE_PACK_STR, buf, 0, self.value) return buf
def serialize_cap_value(self): buf = bytearray() msg_pack_into(self._CAP_PACK_STR, buf, 0, self.as_number) return buf
def serialize_value(self): buf = bytearray() msg_pack_into(self._VALUE_PACK_STR, buf, 0, self.as_number, addrconv.ipv4.text_to_bin(self.addr)) return buf
def serialize_value(self): buf = bytearray() msg_pack_into(self._VALUE_PACK_STR, buf, 0, self.as_number, addrconv.ipv4.text_to_bin(self.ip_addr)) return buf
def serialize(self, buf, offset): super(NXAction, self).serialize(buf, offset) msg_pack_into(NXAction._fmt_str, buf, offset + ofp.OFP_ACTION_EXPERIMENTER_HEADER_SIZE, self.subtype)
def serialize_value(self): buf = bytearray() ifaddr = ipv4.text_to_bin(self.ifaddr) msg_pack_into(self._VALUE_PACK_STR, buf, 0, ifaddr) return buf