Gitiles
Code Review Sign In
gerrit.opencord.org / fabric-oftest / 8f3f705d0e930048ac6a2ed89a9dcacd4c88b8f4 / . / src / python / loxi / of13 / bsn_tlv.py
blob: 073d5c4f180c32cc8e5e789c9780937b59f9b72e [file] [log] [blame]
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]1# Copyright (c) 2008 The Board of Trustees of The Leland Stanford Junior University
2# Copyright (c) 2011, 2012 Open Networking Foundation
3# Copyright (c) 2012, 2013 Big Switch Networks, Inc.
4# See the file LICENSE.pyloxi which should have been included in the source distribution
5
6# Automatically generated by LOXI from template module.py
7# Do not modify
8
9import struct
10import loxi
11import const
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]12import bsn_tlv
13import meter_band
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]14import instruction
15import oxm
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]16import common
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]17import instruction_id
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]18import action
19import message
20import action_id
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]21import util
22import loxi.generic_util
23
24class bsn_tlv(loxi.OFObject):
25 subtypes = {}
26
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]27
28 def __init__(self, type=None):
29 if type != None:
30 self.type = type
31 else:
32 self.type = 0
33 return
34
35 def pack(self):
36 packed = []
37 packed.append(struct.pack("!H", self.type))
38 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
39 length = sum([len(x) for x in packed])
40 packed[1] = struct.pack("!H", length)
41 return ''.join(packed)
42
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]43 @staticmethod
44 def unpack(reader):
45 subtype, = reader.peek('!H', 0)
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]46 subclass = bsn_tlv.subtypes.get(subtype)
47 if subclass:
48 return subclass.unpack(reader)
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]49
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]50 obj = bsn_tlv()
51 obj.type = reader.read("!H")[0]
52 _length = reader.read("!H")[0]
53 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]54 reader = orig_reader.slice(_length, 4)
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]55 return obj
56
57 def __eq__(self, other):
58 if type(self) != type(other): return False
59 if self.type != other.type: return False
60 return True
61
62 def pretty_print(self, q):
63 q.text("bsn_tlv {")
64 with q.group():
65 with q.indent(2):
66 q.breakable()
67 q.breakable()
68 q.text('}')
69
70
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]71class actor_key(bsn_tlv):
72 type = 44
73
74 def __init__(self, value=None):
75 if value != None:
76 self.value = value
77 else:
78 self.value = 0
79 return
80
81 def pack(self):
82 packed = []
83 packed.append(struct.pack("!H", self.type))
84 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
85 packed.append(struct.pack("!H", self.value))
86 length = sum([len(x) for x in packed])
87 packed[1] = struct.pack("!H", length)
88 return ''.join(packed)
89
90 @staticmethod
91 def unpack(reader):
92 obj = actor_key()
93 _type = reader.read("!H")[0]
94 assert(_type == 44)
95 _length = reader.read("!H")[0]
96 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]97 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]98 obj.value = reader.read("!H")[0]
99 return obj
100
101 def __eq__(self, other):
102 if type(self) != type(other): return False
103 if self.value != other.value: return False
104 return True
105
106 def pretty_print(self, q):
107 q.text("actor_key {")
108 with q.group():
109 with q.indent(2):
110 q.breakable()
111 q.text("value = ");
112 q.text("%#x" % self.value)
113 q.breakable()
114 q.text('}')
115
116bsn_tlv.subtypes[44] = actor_key
117
118class actor_port_num(bsn_tlv):
119 type = 43
120
121 def __init__(self, value=None):
122 if value != None:
123 self.value = value
124 else:
125 self.value = 0
126 return
127
128 def pack(self):
129 packed = []
130 packed.append(struct.pack("!H", self.type))
131 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
132 packed.append(struct.pack("!H", self.value))
133 length = sum([len(x) for x in packed])
134 packed[1] = struct.pack("!H", length)
135 return ''.join(packed)
136
137 @staticmethod
138 def unpack(reader):
139 obj = actor_port_num()
140 _type = reader.read("!H")[0]
141 assert(_type == 43)
142 _length = reader.read("!H")[0]
143 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]144 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]145 obj.value = reader.read("!H")[0]
146 return obj
147
148 def __eq__(self, other):
149 if type(self) != type(other): return False
150 if self.value != other.value: return False
151 return True
152
153 def pretty_print(self, q):
154 q.text("actor_port_num {")
155 with q.group():
156 with q.indent(2):
157 q.breakable()
158 q.text("value = ");
159 q.text("%#x" % self.value)
160 q.breakable()
161 q.text('}')
162
163bsn_tlv.subtypes[43] = actor_port_num
164
165class actor_port_priority(bsn_tlv):
166 type = 42
167
168 def __init__(self, value=None):
169 if value != None:
170 self.value = value
171 else:
172 self.value = 0
173 return
174
175 def pack(self):
176 packed = []
177 packed.append(struct.pack("!H", self.type))
178 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
179 packed.append(struct.pack("!H", self.value))
180 length = sum([len(x) for x in packed])
181 packed[1] = struct.pack("!H", length)
182 return ''.join(packed)
183
184 @staticmethod
185 def unpack(reader):
186 obj = actor_port_priority()
187 _type = reader.read("!H")[0]
188 assert(_type == 42)
189 _length = reader.read("!H")[0]
190 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]191 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]192 obj.value = reader.read("!H")[0]
193 return obj
194
195 def __eq__(self, other):
196 if type(self) != type(other): return False
197 if self.value != other.value: return False
198 return True
199
200 def pretty_print(self, q):
201 q.text("actor_port_priority {")
202 with q.group():
203 with q.indent(2):
204 q.breakable()
205 q.text("value = ");
206 q.text("%#x" % self.value)
207 q.breakable()
208 q.text('}')
209
210bsn_tlv.subtypes[42] = actor_port_priority
211
Rich Lane2e079da2014-10-29 15:30:24 -0700[diff] [blame]212class actor_state(bsn_tlv):
213 type = 53
214
215 def __init__(self, value=None):
216 if value != None:
217 self.value = value
218 else:
219 self.value = 0
220 return
221
222 def pack(self):
223 packed = []
224 packed.append(struct.pack("!H", self.type))
225 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
226 packed.append(struct.pack("!B", self.value))
227 length = sum([len(x) for x in packed])
228 packed[1] = struct.pack("!H", length)
229 return ''.join(packed)
230
231 @staticmethod
232 def unpack(reader):
233 obj = actor_state()
234 _type = reader.read("!H")[0]
235 assert(_type == 53)
236 _length = reader.read("!H")[0]
237 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]238 reader = orig_reader.slice(_length, 4)
Rich Lane2e079da2014-10-29 15:30:24 -0700[diff] [blame]239 obj.value = reader.read("!B")[0]
240 return obj
241
242 def __eq__(self, other):
243 if type(self) != type(other): return False
244 if self.value != other.value: return False
245 return True
246
247 def pretty_print(self, q):
248 q.text("actor_state {")
249 with q.group():
250 with q.indent(2):
251 q.breakable()
252 q.text("value = ");
253 q.text("%#x" % self.value)
254 q.breakable()
255 q.text('}')
256
257bsn_tlv.subtypes[53] = actor_state
258
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]259class actor_system_mac(bsn_tlv):
260 type = 41
261
262 def __init__(self, value=None):
263 if value != None:
264 self.value = value
265 else:
266 self.value = [0,0,0,0,0,0]
267 return
268
269 def pack(self):
270 packed = []
271 packed.append(struct.pack("!H", self.type))
272 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
273 packed.append(struct.pack("!6B", *self.value))
274 length = sum([len(x) for x in packed])
275 packed[1] = struct.pack("!H", length)
276 return ''.join(packed)
277
278 @staticmethod
279 def unpack(reader):
280 obj = actor_system_mac()
281 _type = reader.read("!H")[0]
282 assert(_type == 41)
283 _length = reader.read("!H")[0]
284 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]285 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]286 obj.value = list(reader.read('!6B'))
287 return obj
288
289 def __eq__(self, other):
290 if type(self) != type(other): return False
291 if self.value != other.value: return False
292 return True
293
294 def pretty_print(self, q):
295 q.text("actor_system_mac {")
296 with q.group():
297 with q.indent(2):
298 q.breakable()
299 q.text("value = ");
300 q.text(util.pretty_mac(self.value))
301 q.breakable()
302 q.text('}')
303
304bsn_tlv.subtypes[41] = actor_system_mac
305
306class actor_system_priority(bsn_tlv):
307 type = 40
308
309 def __init__(self, value=None):
310 if value != None:
311 self.value = value
312 else:
313 self.value = 0
314 return
315
316 def pack(self):
317 packed = []
318 packed.append(struct.pack("!H", self.type))
319 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
320 packed.append(struct.pack("!H", self.value))
321 length = sum([len(x) for x in packed])
322 packed[1] = struct.pack("!H", length)
323 return ''.join(packed)
324
325 @staticmethod
326 def unpack(reader):
327 obj = actor_system_priority()
328 _type = reader.read("!H")[0]
329 assert(_type == 40)
330 _length = reader.read("!H")[0]
331 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]332 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]333 obj.value = reader.read("!H")[0]
334 return obj
335
336 def __eq__(self, other):
337 if type(self) != type(other): return False
338 if self.value != other.value: return False
339 return True
340
341 def pretty_print(self, q):
342 q.text("actor_system_priority {")
343 with q.group():
344 with q.indent(2):
345 q.breakable()
346 q.text("value = ");
347 q.text("%#x" % self.value)
348 q.breakable()
349 q.text('}')
350
351bsn_tlv.subtypes[40] = actor_system_priority
352
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]353class broadcast_query_timeout(bsn_tlv):
354 type = 10
355
356 def __init__(self, value=None):
357 if value != None:
358 self.value = value
359 else:
360 self.value = 0
361 return
362
363 def pack(self):
364 packed = []
365 packed.append(struct.pack("!H", self.type))
366 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
367 packed.append(struct.pack("!L", self.value))
368 length = sum([len(x) for x in packed])
369 packed[1] = struct.pack("!H", length)
370 return ''.join(packed)
371
372 @staticmethod
373 def unpack(reader):
374 obj = broadcast_query_timeout()
375 _type = reader.read("!H")[0]
376 assert(_type == 10)
377 _length = reader.read("!H")[0]
378 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]379 reader = orig_reader.slice(_length, 4)
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]380 obj.value = reader.read("!L")[0]
381 return obj
382
383 def __eq__(self, other):
384 if type(self) != type(other): return False
385 if self.value != other.value: return False
386 return True
387
388 def pretty_print(self, q):
389 q.text("broadcast_query_timeout {")
390 with q.group():
391 with q.indent(2):
392 q.breakable()
393 q.text("value = ");
394 q.text("%#x" % self.value)
395 q.breakable()
396 q.text('}')
397
398bsn_tlv.subtypes[10] = broadcast_query_timeout
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]399
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]400class bucket(bsn_tlv):
401 type = 64
402
403 def __init__(self, value=None):
404 if value != None:
405 self.value = value
406 else:
407 self.value = []
408 return
409
410 def pack(self):
411 packed = []
412 packed.append(struct.pack("!H", self.type))
413 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
414 packed.append(loxi.generic_util.pack_list(self.value))
415 length = sum([len(x) for x in packed])
416 packed[1] = struct.pack("!H", length)
417 return ''.join(packed)
418
419 @staticmethod
420 def unpack(reader):
421 obj = bucket()
422 _type = reader.read("!H")[0]
423 assert(_type == 64)
424 _length = reader.read("!H")[0]
425 orig_reader = reader
426 reader = orig_reader.slice(_length, 4)
427 obj.value = loxi.generic_util.unpack_list(reader, bsn_tlv.bsn_tlv.unpack)
428 return obj
429
430 def __eq__(self, other):
431 if type(self) != type(other): return False
432 if self.value != other.value: return False
433 return True
434
435 def pretty_print(self, q):
436 q.text("bucket {")
437 with q.group():
438 with q.indent(2):
439 q.breakable()
440 q.text("value = ");
441 q.pp(self.value)
442 q.breakable()
443 q.text('}')
444
445bsn_tlv.subtypes[64] = bucket
446
Rich Lane1b75abf2014-02-05 11:23:20 -0800[diff] [blame]447class circuit_id(bsn_tlv):
448 type = 14
449
450 def __init__(self, value=None):
451 if value != None:
452 self.value = value
453 else:
454 self.value = ''
455 return
456
457 def pack(self):
458 packed = []
459 packed.append(struct.pack("!H", self.type))
460 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
461 packed.append(self.value)
462 length = sum([len(x) for x in packed])
463 packed[1] = struct.pack("!H", length)
464 return ''.join(packed)
465
466 @staticmethod
467 def unpack(reader):
468 obj = circuit_id()
469 _type = reader.read("!H")[0]
470 assert(_type == 14)
471 _length = reader.read("!H")[0]
472 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]473 reader = orig_reader.slice(_length, 4)
Rich Lane1b75abf2014-02-05 11:23:20 -0800[diff] [blame]474 obj.value = str(reader.read_all())
475 return obj
476
477 def __eq__(self, other):
478 if type(self) != type(other): return False
479 if self.value != other.value: return False
480 return True
481
482 def pretty_print(self, q):
483 q.text("circuit_id {")
484 with q.group():
485 with q.indent(2):
486 q.breakable()
487 q.text("value = ");
488 q.pp(self.value)
489 q.breakable()
490 q.text('}')
491
492bsn_tlv.subtypes[14] = circuit_id
493
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]494class convergence_status(bsn_tlv):
495 type = 45
496
497 def __init__(self, value=None):
498 if value != None:
499 self.value = value
500 else:
501 self.value = 0
502 return
503
504 def pack(self):
505 packed = []
506 packed.append(struct.pack("!H", self.type))
507 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
508 packed.append(struct.pack("!B", self.value))
509 length = sum([len(x) for x in packed])
510 packed[1] = struct.pack("!H", length)
511 return ''.join(packed)
512
513 @staticmethod
514 def unpack(reader):
515 obj = convergence_status()
516 _type = reader.read("!H")[0]
517 assert(_type == 45)
518 _length = reader.read("!H")[0]
519 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]520 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]521 obj.value = reader.read("!B")[0]
522 return obj
523
524 def __eq__(self, other):
525 if type(self) != type(other): return False
526 if self.value != other.value: return False
527 return True
528
529 def pretty_print(self, q):
530 q.text("convergence_status {")
531 with q.group():
532 with q.indent(2):
533 q.breakable()
534 q.text("value = ");
535 q.text("%#x" % self.value)
536 q.breakable()
537 q.text('}')
538
539bsn_tlv.subtypes[45] = convergence_status
540
Rich Lane5587ab12014-06-30 11:19:09 -0700[diff] [blame]541class crc_enabled(bsn_tlv):
542 type = 22
543
544 def __init__(self, value=None):
545 if value != None:
546 self.value = value
547 else:
548 self.value = 0
549 return
550
551 def pack(self):
552 packed = []
553 packed.append(struct.pack("!H", self.type))
554 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
555 packed.append(struct.pack("!B", self.value))
556 length = sum([len(x) for x in packed])
557 packed[1] = struct.pack("!H", length)
558 return ''.join(packed)
559
560 @staticmethod
561 def unpack(reader):
562 obj = crc_enabled()
563 _type = reader.read("!H")[0]
564 assert(_type == 22)
565 _length = reader.read("!H")[0]
566 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]567 reader = orig_reader.slice(_length, 4)
Rich Lane5587ab12014-06-30 11:19:09 -0700[diff] [blame]568 obj.value = reader.read("!B")[0]
569 return obj
570
571 def __eq__(self, other):
572 if type(self) != type(other): return False
573 if self.value != other.value: return False
574 return True
575
576 def pretty_print(self, q):
577 q.text("crc_enabled {")
578 with q.group():
579 with q.indent(2):
580 q.breakable()
581 q.text("value = ");
582 q.text("%#x" % self.value)
583 q.breakable()
584 q.text('}')
585
586bsn_tlv.subtypes[22] = crc_enabled
587
Rich Laneccd32ed2014-11-10 17:48:24 -0800[diff] [blame]588class data(bsn_tlv):
589 type = 55
590
591 def __init__(self, value=None):
592 if value != None:
593 self.value = value
594 else:
595 self.value = ''
596 return
597
598 def pack(self):
599 packed = []
600 packed.append(struct.pack("!H", self.type))
601 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
602 packed.append(self.value)
603 length = sum([len(x) for x in packed])
604 packed[1] = struct.pack("!H", length)
605 return ''.join(packed)
606
607 @staticmethod
608 def unpack(reader):
609 obj = data()
610 _type = reader.read("!H")[0]
611 assert(_type == 55)
612 _length = reader.read("!H")[0]
613 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]614 reader = orig_reader.slice(_length, 4)
Rich Laneccd32ed2014-11-10 17:48:24 -0800[diff] [blame]615 obj.value = str(reader.read_all())
616 return obj
617
618 def __eq__(self, other):
619 if type(self) != type(other): return False
620 if self.value != other.value: return False
621 return True
622
623 def pretty_print(self, q):
624 q.text("data {")
625 with q.group():
626 with q.indent(2):
627 q.breakable()
628 q.text("value = ");
629 q.pp(self.value)
630 q.breakable()
631 q.text('}')
632
633bsn_tlv.subtypes[55] = data
634
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]635class eth_dst(bsn_tlv):
636 type = 33
637
638 def __init__(self, value=None):
639 if value != None:
640 self.value = value
641 else:
642 self.value = [0,0,0,0,0,0]
643 return
644
645 def pack(self):
646 packed = []
647 packed.append(struct.pack("!H", self.type))
648 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
649 packed.append(struct.pack("!6B", *self.value))
650 length = sum([len(x) for x in packed])
651 packed[1] = struct.pack("!H", length)
652 return ''.join(packed)
653
654 @staticmethod
655 def unpack(reader):
656 obj = eth_dst()
657 _type = reader.read("!H")[0]
658 assert(_type == 33)
659 _length = reader.read("!H")[0]
660 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]661 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]662 obj.value = list(reader.read('!6B'))
663 return obj
664
665 def __eq__(self, other):
666 if type(self) != type(other): return False
667 if self.value != other.value: return False
668 return True
669
670 def pretty_print(self, q):
671 q.text("eth_dst {")
672 with q.group():
673 with q.indent(2):
674 q.breakable()
675 q.text("value = ");
676 q.text(util.pretty_mac(self.value))
677 q.breakable()
678 q.text('}')
679
680bsn_tlv.subtypes[33] = eth_dst
681
682class eth_src(bsn_tlv):
683 type = 32
684
685 def __init__(self, value=None):
686 if value != None:
687 self.value = value
688 else:
689 self.value = [0,0,0,0,0,0]
690 return
691
692 def pack(self):
693 packed = []
694 packed.append(struct.pack("!H", self.type))
695 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
696 packed.append(struct.pack("!6B", *self.value))
697 length = sum([len(x) for x in packed])
698 packed[1] = struct.pack("!H", length)
699 return ''.join(packed)
700
701 @staticmethod
702 def unpack(reader):
703 obj = eth_src()
704 _type = reader.read("!H")[0]
705 assert(_type == 32)
706 _length = reader.read("!H")[0]
707 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]708 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]709 obj.value = list(reader.read('!6B'))
710 return obj
711
712 def __eq__(self, other):
713 if type(self) != type(other): return False
714 if self.value != other.value: return False
715 return True
716
717 def pretty_print(self, q):
718 q.text("eth_src {")
719 with q.group():
720 with q.indent(2):
721 q.breakable()
722 q.text("value = ");
723 q.text(util.pretty_mac(self.value))
724 q.breakable()
725 q.text('}')
726
727bsn_tlv.subtypes[32] = eth_src
728
Rich Lanecc80d422014-09-24 14:54:09 -0700[diff] [blame]729class external_gateway_ip(bsn_tlv):
730 type = 26
731
732 def __init__(self, value=None):
733 if value != None:
734 self.value = value
735 else:
736 self.value = 0
737 return
738
739 def pack(self):
740 packed = []
741 packed.append(struct.pack("!H", self.type))
742 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
743 packed.append(struct.pack("!L", self.value))
744 length = sum([len(x) for x in packed])
745 packed[1] = struct.pack("!H", length)
746 return ''.join(packed)
747
748 @staticmethod
749 def unpack(reader):
750 obj = external_gateway_ip()
751 _type = reader.read("!H")[0]
752 assert(_type == 26)
753 _length = reader.read("!H")[0]
754 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]755 reader = orig_reader.slice(_length, 4)
Rich Lanecc80d422014-09-24 14:54:09 -0700[diff] [blame]756 obj.value = reader.read("!L")[0]
757 return obj
758
759 def __eq__(self, other):
760 if type(self) != type(other): return False
761 if self.value != other.value: return False
762 return True
763
764 def pretty_print(self, q):
765 q.text("external_gateway_ip {")
766 with q.group():
767 with q.indent(2):
768 q.breakable()
769 q.text("value = ");
770 q.text(util.pretty_ipv4(self.value))
771 q.breakable()
772 q.text('}')
773
774bsn_tlv.subtypes[26] = external_gateway_ip
775
Rich Lane18ec5352014-10-02 09:09:17 -0700[diff] [blame]776class external_gateway_mac(bsn_tlv):
777 type = 29
778
779 def __init__(self, value=None):
780 if value != None:
781 self.value = value
782 else:
783 self.value = [0,0,0,0,0,0]
784 return
785
786 def pack(self):
787 packed = []
788 packed.append(struct.pack("!H", self.type))
789 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
790 packed.append(struct.pack("!6B", *self.value))
791 length = sum([len(x) for x in packed])
792 packed[1] = struct.pack("!H", length)
793 return ''.join(packed)
794
795 @staticmethod
796 def unpack(reader):
797 obj = external_gateway_mac()
798 _type = reader.read("!H")[0]
799 assert(_type == 29)
800 _length = reader.read("!H")[0]
801 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]802 reader = orig_reader.slice(_length, 4)
Rich Lane18ec5352014-10-02 09:09:17 -0700[diff] [blame]803 obj.value = list(reader.read('!6B'))
804 return obj
805
806 def __eq__(self, other):
807 if type(self) != type(other): return False
808 if self.value != other.value: return False
809 return True
810
811 def pretty_print(self, q):
812 q.text("external_gateway_mac {")
813 with q.group():
814 with q.indent(2):
815 q.breakable()
816 q.text("value = ");
817 q.text(util.pretty_mac(self.value))
818 q.breakable()
819 q.text('}')
820
821bsn_tlv.subtypes[29] = external_gateway_mac
822
Rich Lanecc80d422014-09-24 14:54:09 -0700[diff] [blame]823class external_ip(bsn_tlv):
824 type = 23
825
826 def __init__(self, value=None):
827 if value != None:
828 self.value = value
829 else:
830 self.value = 0
831 return
832
833 def pack(self):
834 packed = []
835 packed.append(struct.pack("!H", self.type))
836 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
837 packed.append(struct.pack("!L", self.value))
838 length = sum([len(x) for x in packed])
839 packed[1] = struct.pack("!H", length)
840 return ''.join(packed)
841
842 @staticmethod
843 def unpack(reader):
844 obj = external_ip()
845 _type = reader.read("!H")[0]
846 assert(_type == 23)
847 _length = reader.read("!H")[0]
848 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]849 reader = orig_reader.slice(_length, 4)
Rich Lanecc80d422014-09-24 14:54:09 -0700[diff] [blame]850 obj.value = reader.read("!L")[0]
851 return obj
852
853 def __eq__(self, other):
854 if type(self) != type(other): return False
855 if self.value != other.value: return False
856 return True
857
858 def pretty_print(self, q):
859 q.text("external_ip {")
860 with q.group():
861 with q.indent(2):
862 q.breakable()
863 q.text("value = ");
864 q.text(util.pretty_ipv4(self.value))
865 q.breakable()
866 q.text('}')
867
868bsn_tlv.subtypes[23] = external_ip
869
870class external_mac(bsn_tlv):
871 type = 24
872
873 def __init__(self, value=None):
874 if value != None:
875 self.value = value
876 else:
877 self.value = [0,0,0,0,0,0]
878 return
879
880 def pack(self):
881 packed = []
882 packed.append(struct.pack("!H", self.type))
883 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
884 packed.append(struct.pack("!6B", *self.value))
885 length = sum([len(x) for x in packed])
886 packed[1] = struct.pack("!H", length)
887 return ''.join(packed)
888
889 @staticmethod
890 def unpack(reader):
891 obj = external_mac()
892 _type = reader.read("!H")[0]
893 assert(_type == 24)
894 _length = reader.read("!H")[0]
895 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]896 reader = orig_reader.slice(_length, 4)
Rich Lanecc80d422014-09-24 14:54:09 -0700[diff] [blame]897 obj.value = list(reader.read('!6B'))
898 return obj
899
900 def __eq__(self, other):
901 if type(self) != type(other): return False
902 if self.value != other.value: return False
903 return True
904
905 def pretty_print(self, q):
906 q.text("external_mac {")
907 with q.group():
908 with q.indent(2):
909 q.breakable()
910 q.text("value = ");
911 q.text(util.pretty_mac(self.value))
912 q.breakable()
913 q.text('}')
914
915bsn_tlv.subtypes[24] = external_mac
916
917class external_netmask(bsn_tlv):
918 type = 25
919
920 def __init__(self, value=None):
921 if value != None:
922 self.value = value
923 else:
924 self.value = 0
925 return
926
927 def pack(self):
928 packed = []
929 packed.append(struct.pack("!H", self.type))
930 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
931 packed.append(struct.pack("!L", self.value))
932 length = sum([len(x) for x in packed])
933 packed[1] = struct.pack("!H", length)
934 return ''.join(packed)
935
936 @staticmethod
937 def unpack(reader):
938 obj = external_netmask()
939 _type = reader.read("!H")[0]
940 assert(_type == 25)
941 _length = reader.read("!H")[0]
942 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]943 reader = orig_reader.slice(_length, 4)
Rich Lanecc80d422014-09-24 14:54:09 -0700[diff] [blame]944 obj.value = reader.read("!L")[0]
945 return obj
946
947 def __eq__(self, other):
948 if type(self) != type(other): return False
949 if self.value != other.value: return False
950 return True
951
952 def pretty_print(self, q):
953 q.text("external_netmask {")
954 with q.group():
955 with q.indent(2):
956 q.breakable()
957 q.text("value = ");
958 q.text(util.pretty_ipv4(self.value))
959 q.breakable()
960 q.text('}')
961
962bsn_tlv.subtypes[25] = external_netmask
963
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]964class header_size(bsn_tlv):
965 type = 31
966
967 def __init__(self, value=None):
968 if value != None:
969 self.value = value
970 else:
971 self.value = 0
972 return
973
974 def pack(self):
975 packed = []
976 packed.append(struct.pack("!H", self.type))
977 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
978 packed.append(struct.pack("!L", self.value))
979 length = sum([len(x) for x in packed])
980 packed[1] = struct.pack("!H", length)
981 return ''.join(packed)
982
983 @staticmethod
984 def unpack(reader):
985 obj = header_size()
986 _type = reader.read("!H")[0]
987 assert(_type == 31)
988 _length = reader.read("!H")[0]
989 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]990 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]991 obj.value = reader.read("!L")[0]
992 return obj
993
994 def __eq__(self, other):
995 if type(self) != type(other): return False
996 if self.value != other.value: return False
997 return True
998
999 def pretty_print(self, q):
1000 q.text("header_size {")
1001 with q.group():
1002 with q.indent(2):
1003 q.breakable()
1004 q.text("value = ");
1005 q.text("%#x" % self.value)
1006 q.breakable()
1007 q.text('}')
1008
1009bsn_tlv.subtypes[31] = header_size
1010
Rich Lane474324f2015-01-14 15:22:56 -0800[diff] [blame]1011class icmp_code(bsn_tlv):
1012 type = 69
1013
1014 def __init__(self, value=None):
1015 if value != None:
1016 self.value = value
1017 else:
1018 self.value = 0
1019 return
1020
1021 def pack(self):
1022 packed = []
1023 packed.append(struct.pack("!H", self.type))
1024 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1025 packed.append(struct.pack("!B", self.value))
1026 length = sum([len(x) for x in packed])
1027 packed[1] = struct.pack("!H", length)
1028 return ''.join(packed)
1029
1030 @staticmethod
1031 def unpack(reader):
1032 obj = icmp_code()
1033 _type = reader.read("!H")[0]
1034 assert(_type == 69)
1035 _length = reader.read("!H")[0]
1036 orig_reader = reader
1037 reader = orig_reader.slice(_length, 4)
1038 obj.value = reader.read("!B")[0]
1039 return obj
1040
1041 def __eq__(self, other):
1042 if type(self) != type(other): return False
1043 if self.value != other.value: return False
1044 return True
1045
1046 def pretty_print(self, q):
1047 q.text("icmp_code {")
1048 with q.group():
1049 with q.indent(2):
1050 q.breakable()
1051 q.text("value = ");
1052 q.text("%#x" % self.value)
1053 q.breakable()
1054 q.text('}')
1055
1056bsn_tlv.subtypes[69] = icmp_code
1057
1058class icmp_id(bsn_tlv):
1059 type = 70
1060
1061 def __init__(self, value=None):
1062 if value != None:
1063 self.value = value
1064 else:
1065 self.value = 0
1066 return
1067
1068 def pack(self):
1069 packed = []
1070 packed.append(struct.pack("!H", self.type))
1071 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1072 packed.append(struct.pack("!H", self.value))
1073 length = sum([len(x) for x in packed])
1074 packed[1] = struct.pack("!H", length)
1075 return ''.join(packed)
1076
1077 @staticmethod
1078 def unpack(reader):
1079 obj = icmp_id()
1080 _type = reader.read("!H")[0]
1081 assert(_type == 70)
1082 _length = reader.read("!H")[0]
1083 orig_reader = reader
1084 reader = orig_reader.slice(_length, 4)
1085 obj.value = reader.read("!H")[0]
1086 return obj
1087
1088 def __eq__(self, other):
1089 if type(self) != type(other): return False
1090 if self.value != other.value: return False
1091 return True
1092
1093 def pretty_print(self, q):
1094 q.text("icmp_id {")
1095 with q.group():
1096 with q.indent(2):
1097 q.breakable()
1098 q.text("value = ");
1099 q.text("%#x" % self.value)
1100 q.breakable()
1101 q.text('}')
1102
1103bsn_tlv.subtypes[70] = icmp_id
1104
1105class icmp_type(bsn_tlv):
1106 type = 68
1107
1108 def __init__(self, value=None):
1109 if value != None:
1110 self.value = value
1111 else:
1112 self.value = 0
1113 return
1114
1115 def pack(self):
1116 packed = []
1117 packed.append(struct.pack("!H", self.type))
1118 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1119 packed.append(struct.pack("!B", self.value))
1120 length = sum([len(x) for x in packed])
1121 packed[1] = struct.pack("!H", length)
1122 return ''.join(packed)
1123
1124 @staticmethod
1125 def unpack(reader):
1126 obj = icmp_type()
1127 _type = reader.read("!H")[0]
1128 assert(_type == 68)
1129 _length = reader.read("!H")[0]
1130 orig_reader = reader
1131 reader = orig_reader.slice(_length, 4)
1132 obj.value = reader.read("!B")[0]
1133 return obj
1134
1135 def __eq__(self, other):
1136 if type(self) != type(other): return False
1137 if self.value != other.value: return False
1138 return True
1139
1140 def pretty_print(self, q):
1141 q.text("icmp_type {")
1142 with q.group():
1143 with q.indent(2):
1144 q.breakable()
1145 q.text("value = ");
1146 q.text("%#x" % self.value)
1147 q.breakable()
1148 q.text('}')
1149
1150bsn_tlv.subtypes[68] = icmp_type
1151
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]1152class idle_notification(bsn_tlv):
1153 type = 7
1154
1155 def __init__(self):
1156 return
1157
1158 def pack(self):
1159 packed = []
1160 packed.append(struct.pack("!H", self.type))
1161 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1162 length = sum([len(x) for x in packed])
1163 packed[1] = struct.pack("!H", length)
1164 return ''.join(packed)
1165
1166 @staticmethod
1167 def unpack(reader):
1168 obj = idle_notification()
1169 _type = reader.read("!H")[0]
1170 assert(_type == 7)
1171 _length = reader.read("!H")[0]
1172 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1173 reader = orig_reader.slice(_length, 4)
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]1174 return obj
1175
1176 def __eq__(self, other):
1177 if type(self) != type(other): return False
1178 return True
1179
1180 def pretty_print(self, q):
1181 q.text("idle_notification {")
1182 with q.group():
1183 with q.indent(2):
1184 q.breakable()
1185 q.breakable()
1186 q.text('}')
1187
1188bsn_tlv.subtypes[7] = idle_notification
1189
1190class idle_time(bsn_tlv):
1191 type = 5
1192
1193 def __init__(self, value=None):
1194 if value != None:
1195 self.value = value
1196 else:
1197 self.value = 0
1198 return
1199
1200 def pack(self):
1201 packed = []
1202 packed.append(struct.pack("!H", self.type))
1203 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1204 packed.append(struct.pack("!Q", self.value))
1205 length = sum([len(x) for x in packed])
1206 packed[1] = struct.pack("!H", length)
1207 return ''.join(packed)
1208
1209 @staticmethod
1210 def unpack(reader):
1211 obj = idle_time()
1212 _type = reader.read("!H")[0]
1213 assert(_type == 5)
1214 _length = reader.read("!H")[0]
1215 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1216 reader = orig_reader.slice(_length, 4)
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]1217 obj.value = reader.read("!Q")[0]
1218 return obj
1219
1220 def __eq__(self, other):
1221 if type(self) != type(other): return False
1222 if self.value != other.value: return False
1223 return True
1224
1225 def pretty_print(self, q):
1226 q.text("idle_time {")
1227 with q.group():
1228 with q.indent(2):
1229 q.breakable()
1230 q.text("value = ");
1231 q.text("%#x" % self.value)
1232 q.breakable()
1233 q.text('}')
1234
1235bsn_tlv.subtypes[5] = idle_time
1236
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]1237class idle_timeout(bsn_tlv):
1238 type = 8
1239
1240 def __init__(self, value=None):
1241 if value != None:
1242 self.value = value
1243 else:
1244 self.value = 0
1245 return
1246
1247 def pack(self):
1248 packed = []
1249 packed.append(struct.pack("!H", self.type))
1250 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1251 packed.append(struct.pack("!L", self.value))
1252 length = sum([len(x) for x in packed])
1253 packed[1] = struct.pack("!H", length)
1254 return ''.join(packed)
1255
1256 @staticmethod
1257 def unpack(reader):
1258 obj = idle_timeout()
1259 _type = reader.read("!H")[0]
1260 assert(_type == 8)
1261 _length = reader.read("!H")[0]
1262 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1263 reader = orig_reader.slice(_length, 4)
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]1264 obj.value = reader.read("!L")[0]
1265 return obj
1266
1267 def __eq__(self, other):
1268 if type(self) != type(other): return False
1269 if self.value != other.value: return False
1270 return True
1271
1272 def pretty_print(self, q):
1273 q.text("idle_timeout {")
1274 with q.group():
1275 with q.indent(2):
1276 q.breakable()
1277 q.text("value = ");
1278 q.text("%#x" % self.value)
1279 q.breakable()
1280 q.text('}')
1281
1282bsn_tlv.subtypes[8] = idle_timeout
1283
Rich Lanecc80d422014-09-24 14:54:09 -0700[diff] [blame]1284class internal_gateway_mac(bsn_tlv):
1285 type = 28
1286
1287 def __init__(self, value=None):
1288 if value != None:
1289 self.value = value
1290 else:
1291 self.value = [0,0,0,0,0,0]
1292 return
1293
1294 def pack(self):
1295 packed = []
1296 packed.append(struct.pack("!H", self.type))
1297 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1298 packed.append(struct.pack("!6B", *self.value))
1299 length = sum([len(x) for x in packed])
1300 packed[1] = struct.pack("!H", length)
1301 return ''.join(packed)
1302
1303 @staticmethod
1304 def unpack(reader):
1305 obj = internal_gateway_mac()
1306 _type = reader.read("!H")[0]
1307 assert(_type == 28)
1308 _length = reader.read("!H")[0]
1309 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1310 reader = orig_reader.slice(_length, 4)
Rich Lanecc80d422014-09-24 14:54:09 -0700[diff] [blame]1311 obj.value = list(reader.read('!6B'))
1312 return obj
1313
1314 def __eq__(self, other):
1315 if type(self) != type(other): return False
1316 if self.value != other.value: return False
1317 return True
1318
1319 def pretty_print(self, q):
1320 q.text("internal_gateway_mac {")
1321 with q.group():
1322 with q.indent(2):
1323 q.breakable()
1324 q.text("value = ");
1325 q.text(util.pretty_mac(self.value))
1326 q.breakable()
1327 q.text('}')
1328
1329bsn_tlv.subtypes[28] = internal_gateway_mac
1330
1331class internal_mac(bsn_tlv):
1332 type = 27
1333
1334 def __init__(self, value=None):
1335 if value != None:
1336 self.value = value
1337 else:
1338 self.value = [0,0,0,0,0,0]
1339 return
1340
1341 def pack(self):
1342 packed = []
1343 packed.append(struct.pack("!H", self.type))
1344 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1345 packed.append(struct.pack("!6B", *self.value))
1346 length = sum([len(x) for x in packed])
1347 packed[1] = struct.pack("!H", length)
1348 return ''.join(packed)
1349
1350 @staticmethod
1351 def unpack(reader):
1352 obj = internal_mac()
1353 _type = reader.read("!H")[0]
1354 assert(_type == 27)
1355 _length = reader.read("!H")[0]
1356 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1357 reader = orig_reader.slice(_length, 4)
Rich Lanecc80d422014-09-24 14:54:09 -0700[diff] [blame]1358 obj.value = list(reader.read('!6B'))
1359 return obj
1360
1361 def __eq__(self, other):
1362 if type(self) != type(other): return False
1363 if self.value != other.value: return False
1364 return True
1365
1366 def pretty_print(self, q):
1367 q.text("internal_mac {")
1368 with q.group():
1369 with q.indent(2):
1370 q.breakable()
1371 q.text("value = ");
1372 q.text(util.pretty_mac(self.value))
1373 q.breakable()
1374 q.text('}')
1375
1376bsn_tlv.subtypes[27] = internal_mac
1377
Harshmeet Singh301f7172014-12-08 13:07:29 -0800[diff] [blame]1378class interval(bsn_tlv):
1379 type = 58
1380
1381 def __init__(self, value=None):
1382 if value != None:
1383 self.value = value
1384 else:
1385 self.value = 0
1386 return
1387
1388 def pack(self):
1389 packed = []
1390 packed.append(struct.pack("!H", self.type))
1391 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1392 packed.append(struct.pack("!L", self.value))
1393 length = sum([len(x) for x in packed])
1394 packed[1] = struct.pack("!H", length)
1395 return ''.join(packed)
1396
1397 @staticmethod
1398 def unpack(reader):
1399 obj = interval()
1400 _type = reader.read("!H")[0]
1401 assert(_type == 58)
1402 _length = reader.read("!H")[0]
1403 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1404 reader = orig_reader.slice(_length, 4)
Harshmeet Singh301f7172014-12-08 13:07:29 -0800[diff] [blame]1405 obj.value = reader.read("!L")[0]
1406 return obj
1407
1408 def __eq__(self, other):
1409 if type(self) != type(other): return False
1410 if self.value != other.value: return False
1411 return True
1412
1413 def pretty_print(self, q):
1414 q.text("interval {")
1415 with q.group():
1416 with q.indent(2):
1417 q.breakable()
1418 q.text("value = ");
1419 q.text("%#x" % self.value)
1420 q.breakable()
1421 q.text('}')
1422
1423bsn_tlv.subtypes[58] = interval
1424
Rich Lane474324f2015-01-14 15:22:56 -0800[diff] [blame]1425class ip_proto(bsn_tlv):
1426 type = 67
1427
1428 def __init__(self, value=None):
1429 if value != None:
1430 self.value = value
1431 else:
1432 self.value = 0
1433 return
1434
1435 def pack(self):
1436 packed = []
1437 packed.append(struct.pack("!H", self.type))
1438 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1439 packed.append(struct.pack("!B", self.value))
1440 length = sum([len(x) for x in packed])
1441 packed[1] = struct.pack("!H", length)
1442 return ''.join(packed)
1443
1444 @staticmethod
1445 def unpack(reader):
1446 obj = ip_proto()
1447 _type = reader.read("!H")[0]
1448 assert(_type == 67)
1449 _length = reader.read("!H")[0]
1450 orig_reader = reader
1451 reader = orig_reader.slice(_length, 4)
1452 obj.value = reader.read("!B")[0]
1453 return obj
1454
1455 def __eq__(self, other):
1456 if type(self) != type(other): return False
1457 if self.value != other.value: return False
1458 return True
1459
1460 def pretty_print(self, q):
1461 q.text("ip_proto {")
1462 with q.group():
1463 with q.indent(2):
1464 q.breakable()
1465 q.text("value = ");
1466 q.text("%#x" % self.value)
1467 q.breakable()
1468 q.text('}')
1469
1470bsn_tlv.subtypes[67] = ip_proto
1471
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]1472class ipv4(bsn_tlv):
1473 type = 4
1474
1475 def __init__(self, value=None):
1476 if value != None:
1477 self.value = value
1478 else:
1479 self.value = 0
1480 return
1481
1482 def pack(self):
1483 packed = []
1484 packed.append(struct.pack("!H", self.type))
1485 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1486 packed.append(struct.pack("!L", self.value))
1487 length = sum([len(x) for x in packed])
1488 packed[1] = struct.pack("!H", length)
1489 return ''.join(packed)
1490
1491 @staticmethod
1492 def unpack(reader):
1493 obj = ipv4()
1494 _type = reader.read("!H")[0]
1495 assert(_type == 4)
1496 _length = reader.read("!H")[0]
1497 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1498 reader = orig_reader.slice(_length, 4)
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]1499 obj.value = reader.read("!L")[0]
1500 return obj
1501
1502 def __eq__(self, other):
1503 if type(self) != type(other): return False
1504 if self.value != other.value: return False
1505 return True
1506
1507 def pretty_print(self, q):
1508 q.text("ipv4 {")
1509 with q.group():
1510 with q.indent(2):
1511 q.breakable()
1512 q.text("value = ");
1513 q.text(util.pretty_ipv4(self.value))
1514 q.breakable()
1515 q.text('}')
1516
1517bsn_tlv.subtypes[4] = ipv4
1518
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]1519class ipv4_dst(bsn_tlv):
1520 type = 35
1521
1522 def __init__(self, value=None):
1523 if value != None:
1524 self.value = value
1525 else:
1526 self.value = 0
1527 return
1528
1529 def pack(self):
1530 packed = []
1531 packed.append(struct.pack("!H", self.type))
1532 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1533 packed.append(struct.pack("!L", self.value))
1534 length = sum([len(x) for x in packed])
1535 packed[1] = struct.pack("!H", length)
1536 return ''.join(packed)
1537
1538 @staticmethod
1539 def unpack(reader):
1540 obj = ipv4_dst()
1541 _type = reader.read("!H")[0]
1542 assert(_type == 35)
1543 _length = reader.read("!H")[0]
1544 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1545 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]1546 obj.value = reader.read("!L")[0]
1547 return obj
1548
1549 def __eq__(self, other):
1550 if type(self) != type(other): return False
1551 if self.value != other.value: return False
1552 return True
1553
1554 def pretty_print(self, q):
1555 q.text("ipv4_dst {")
1556 with q.group():
1557 with q.indent(2):
1558 q.breakable()
1559 q.text("value = ");
1560 q.text(util.pretty_ipv4(self.value))
1561 q.breakable()
1562 q.text('}')
1563
1564bsn_tlv.subtypes[35] = ipv4_dst
1565
Harshmeet Singh301f7172014-12-08 13:07:29 -0800[diff] [blame]1566class ipv4_netmask(bsn_tlv):
1567 type = 60
1568
1569 def __init__(self, value=None):
1570 if value != None:
1571 self.value = value
1572 else:
1573 self.value = 0
1574 return
1575
1576 def pack(self):
1577 packed = []
1578 packed.append(struct.pack("!H", self.type))
1579 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1580 packed.append(struct.pack("!L", self.value))
1581 length = sum([len(x) for x in packed])
1582 packed[1] = struct.pack("!H", length)
1583 return ''.join(packed)
1584
1585 @staticmethod
1586 def unpack(reader):
1587 obj = ipv4_netmask()
1588 _type = reader.read("!H")[0]
1589 assert(_type == 60)
1590 _length = reader.read("!H")[0]
1591 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1592 reader = orig_reader.slice(_length, 4)
Harshmeet Singh301f7172014-12-08 13:07:29 -0800[diff] [blame]1593 obj.value = reader.read("!L")[0]
1594 return obj
1595
1596 def __eq__(self, other):
1597 if type(self) != type(other): return False
1598 if self.value != other.value: return False
1599 return True
1600
1601 def pretty_print(self, q):
1602 q.text("ipv4_netmask {")
1603 with q.group():
1604 with q.indent(2):
1605 q.breakable()
1606 q.text("value = ");
1607 q.text(util.pretty_ipv4(self.value))
1608 q.breakable()
1609 q.text('}')
1610
1611bsn_tlv.subtypes[60] = ipv4_netmask
1612
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]1613class ipv4_src(bsn_tlv):
1614 type = 34
1615
1616 def __init__(self, value=None):
1617 if value != None:
1618 self.value = value
1619 else:
1620 self.value = 0
1621 return
1622
1623 def pack(self):
1624 packed = []
1625 packed.append(struct.pack("!H", self.type))
1626 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1627 packed.append(struct.pack("!L", self.value))
1628 length = sum([len(x) for x in packed])
1629 packed[1] = struct.pack("!H", length)
1630 return ''.join(packed)
1631
1632 @staticmethod
1633 def unpack(reader):
1634 obj = ipv4_src()
1635 _type = reader.read("!H")[0]
1636 assert(_type == 34)
1637 _length = reader.read("!H")[0]
1638 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1639 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]1640 obj.value = reader.read("!L")[0]
1641 return obj
1642
1643 def __eq__(self, other):
1644 if type(self) != type(other): return False
1645 if self.value != other.value: return False
1646 return True
1647
1648 def pretty_print(self, q):
1649 q.text("ipv4_src {")
1650 with q.group():
1651 with q.indent(2):
1652 q.breakable()
1653 q.text("value = ");
1654 q.text(util.pretty_ipv4(self.value))
1655 q.breakable()
1656 q.text('}')
1657
1658bsn_tlv.subtypes[34] = ipv4_src
1659
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]1660class mac(bsn_tlv):
1661 type = 1
1662
1663 def __init__(self, value=None):
1664 if value != None:
1665 self.value = value
1666 else:
1667 self.value = [0,0,0,0,0,0]
1668 return
1669
1670 def pack(self):
1671 packed = []
1672 packed.append(struct.pack("!H", self.type))
1673 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1674 packed.append(struct.pack("!6B", *self.value))
1675 length = sum([len(x) for x in packed])
1676 packed[1] = struct.pack("!H", length)
1677 return ''.join(packed)
1678
1679 @staticmethod
1680 def unpack(reader):
1681 obj = mac()
1682 _type = reader.read("!H")[0]
1683 assert(_type == 1)
1684 _length = reader.read("!H")[0]
1685 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1686 reader = orig_reader.slice(_length, 4)
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]1687 obj.value = list(reader.read('!6B'))
1688 return obj
1689
1690 def __eq__(self, other):
1691 if type(self) != type(other): return False
1692 if self.value != other.value: return False
1693 return True
1694
1695 def pretty_print(self, q):
1696 q.text("mac {")
1697 with q.group():
1698 with q.indent(2):
1699 q.breakable()
1700 q.text("value = ");
1701 q.text(util.pretty_mac(self.value))
1702 q.breakable()
1703 q.text('}')
1704
1705bsn_tlv.subtypes[1] = mac
1706
Rich Laneccd32ed2014-11-10 17:48:24 -0800[diff] [blame]1707class mac_mask(bsn_tlv):
1708 type = 56
1709
1710 def __init__(self, value=None):
1711 if value != None:
1712 self.value = value
1713 else:
1714 self.value = [0,0,0,0,0,0]
1715 return
1716
1717 def pack(self):
1718 packed = []
1719 packed.append(struct.pack("!H", self.type))
1720 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1721 packed.append(struct.pack("!6B", *self.value))
1722 length = sum([len(x) for x in packed])
1723 packed[1] = struct.pack("!H", length)
1724 return ''.join(packed)
1725
1726 @staticmethod
1727 def unpack(reader):
1728 obj = mac_mask()
1729 _type = reader.read("!H")[0]
1730 assert(_type == 56)
1731 _length = reader.read("!H")[0]
1732 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1733 reader = orig_reader.slice(_length, 4)
Rich Laneccd32ed2014-11-10 17:48:24 -0800[diff] [blame]1734 obj.value = list(reader.read('!6B'))
1735 return obj
1736
1737 def __eq__(self, other):
1738 if type(self) != type(other): return False
1739 if self.value != other.value: return False
1740 return True
1741
1742 def pretty_print(self, q):
1743 q.text("mac_mask {")
1744 with q.group():
1745 with q.indent(2):
1746 q.breakable()
1747 q.text("value = ");
1748 q.text(util.pretty_mac(self.value))
1749 q.breakable()
1750 q.text('}')
1751
1752bsn_tlv.subtypes[56] = mac_mask
1753
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]1754class miss_packets(bsn_tlv):
1755 type = 13
1756
1757 def __init__(self, value=None):
1758 if value != None:
1759 self.value = value
1760 else:
1761 self.value = 0
1762 return
1763
1764 def pack(self):
1765 packed = []
1766 packed.append(struct.pack("!H", self.type))
1767 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1768 packed.append(struct.pack("!Q", self.value))
1769 length = sum([len(x) for x in packed])
1770 packed[1] = struct.pack("!H", length)
1771 return ''.join(packed)
1772
1773 @staticmethod
1774 def unpack(reader):
1775 obj = miss_packets()
1776 _type = reader.read("!H")[0]
1777 assert(_type == 13)
1778 _length = reader.read("!H")[0]
1779 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1780 reader = orig_reader.slice(_length, 4)
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]1781 obj.value = reader.read("!Q")[0]
1782 return obj
1783
1784 def __eq__(self, other):
1785 if type(self) != type(other): return False
1786 if self.value != other.value: return False
1787 return True
1788
1789 def pretty_print(self, q):
1790 q.text("miss_packets {")
1791 with q.group():
1792 with q.indent(2):
1793 q.breakable()
1794 q.text("value = ");
1795 q.text("%#x" % self.value)
1796 q.breakable()
1797 q.text('}')
1798
1799bsn_tlv.subtypes[13] = miss_packets
1800
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1801class mpls_control_word(bsn_tlv):
1802 type = 62
1803
1804 def __init__(self, value=None):
1805 if value != None:
1806 self.value = value
1807 else:
1808 self.value = 0
1809 return
1810
1811 def pack(self):
1812 packed = []
1813 packed.append(struct.pack("!H", self.type))
1814 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1815 packed.append(struct.pack("!B", self.value))
1816 length = sum([len(x) for x in packed])
1817 packed[1] = struct.pack("!H", length)
1818 return ''.join(packed)
1819
1820 @staticmethod
1821 def unpack(reader):
1822 obj = mpls_control_word()
1823 _type = reader.read("!H")[0]
1824 assert(_type == 62)
1825 _length = reader.read("!H")[0]
1826 orig_reader = reader
1827 reader = orig_reader.slice(_length, 4)
1828 obj.value = reader.read("!B")[0]
1829 return obj
1830
1831 def __eq__(self, other):
1832 if type(self) != type(other): return False
1833 if self.value != other.value: return False
1834 return True
1835
1836 def pretty_print(self, q):
1837 q.text("mpls_control_word {")
1838 with q.group():
1839 with q.indent(2):
1840 q.breakable()
1841 q.text("value = ");
1842 q.text("%#x" % self.value)
1843 q.breakable()
1844 q.text('}')
1845
1846bsn_tlv.subtypes[62] = mpls_control_word
1847
1848class mpls_label(bsn_tlv):
1849 type = 61
1850
1851 def __init__(self, value=None):
1852 if value != None:
1853 self.value = value
1854 else:
1855 self.value = 0
1856 return
1857
1858 def pack(self):
1859 packed = []
1860 packed.append(struct.pack("!H", self.type))
1861 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1862 packed.append(struct.pack("!L", self.value))
1863 length = sum([len(x) for x in packed])
1864 packed[1] = struct.pack("!H", length)
1865 return ''.join(packed)
1866
1867 @staticmethod
1868 def unpack(reader):
1869 obj = mpls_label()
1870 _type = reader.read("!H")[0]
1871 assert(_type == 61)
1872 _length = reader.read("!H")[0]
1873 orig_reader = reader
1874 reader = orig_reader.slice(_length, 4)
1875 obj.value = reader.read("!L")[0]
1876 return obj
1877
1878 def __eq__(self, other):
1879 if type(self) != type(other): return False
1880 if self.value != other.value: return False
1881 return True
1882
1883 def pretty_print(self, q):
1884 q.text("mpls_label {")
1885 with q.group():
1886 with q.indent(2):
1887 q.breakable()
1888 q.text("value = ");
1889 q.text("%#x" % self.value)
1890 q.breakable()
1891 q.text('}')
1892
1893bsn_tlv.subtypes[61] = mpls_label
1894
1895class mpls_sequenced(bsn_tlv):
1896 type = 63
1897
1898 def __init__(self, value=None):
1899 if value != None:
1900 self.value = value
1901 else:
1902 self.value = 0
1903 return
1904
1905 def pack(self):
1906 packed = []
1907 packed.append(struct.pack("!H", self.type))
1908 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1909 packed.append(struct.pack("!B", self.value))
1910 length = sum([len(x) for x in packed])
1911 packed[1] = struct.pack("!H", length)
1912 return ''.join(packed)
1913
1914 @staticmethod
1915 def unpack(reader):
1916 obj = mpls_sequenced()
1917 _type = reader.read("!H")[0]
1918 assert(_type == 63)
1919 _length = reader.read("!H")[0]
1920 orig_reader = reader
1921 reader = orig_reader.slice(_length, 4)
1922 obj.value = reader.read("!B")[0]
1923 return obj
1924
1925 def __eq__(self, other):
1926 if type(self) != type(other): return False
1927 if self.value != other.value: return False
1928 return True
1929
1930 def pretty_print(self, q):
1931 q.text("mpls_sequenced {")
1932 with q.group():
1933 with q.indent(2):
1934 q.breakable()
1935 q.text("value = ");
1936 q.text("%#x" % self.value)
1937 q.breakable()
1938 q.text('}')
1939
1940bsn_tlv.subtypes[63] = mpls_sequenced
1941
Rich Laned0be7552014-10-23 12:52:35 -0700[diff] [blame]1942class name(bsn_tlv):
1943 type = 52
1944
1945 def __init__(self, value=None):
1946 if value != None:
1947 self.value = value
1948 else:
1949 self.value = ''
1950 return
1951
1952 def pack(self):
1953 packed = []
1954 packed.append(struct.pack("!H", self.type))
1955 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
1956 packed.append(self.value)
1957 length = sum([len(x) for x in packed])
1958 packed[1] = struct.pack("!H", length)
1959 return ''.join(packed)
1960
1961 @staticmethod
1962 def unpack(reader):
1963 obj = name()
1964 _type = reader.read("!H")[0]
1965 assert(_type == 52)
1966 _length = reader.read("!H")[0]
1967 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]1968 reader = orig_reader.slice(_length, 4)
Rich Laned0be7552014-10-23 12:52:35 -0700[diff] [blame]1969 obj.value = str(reader.read_all())
1970 return obj
1971
1972 def __eq__(self, other):
1973 if type(self) != type(other): return False
1974 if self.value != other.value: return False
1975 return True
1976
1977 def pretty_print(self, q):
1978 q.text("name {")
1979 with q.group():
1980 with q.indent(2):
1981 q.breakable()
1982 q.text("value = ");
1983 q.pp(self.value)
1984 q.breakable()
1985 q.text('}')
1986
1987bsn_tlv.subtypes[52] = name
1988
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]1989class partner_key(bsn_tlv):
1990 type = 51
1991
1992 def __init__(self, value=None):
1993 if value != None:
1994 self.value = value
1995 else:
1996 self.value = 0
1997 return
1998
1999 def pack(self):
2000 packed = []
2001 packed.append(struct.pack("!H", self.type))
2002 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2003 packed.append(struct.pack("!H", self.value))
2004 length = sum([len(x) for x in packed])
2005 packed[1] = struct.pack("!H", length)
2006 return ''.join(packed)
2007
2008 @staticmethod
2009 def unpack(reader):
2010 obj = partner_key()
2011 _type = reader.read("!H")[0]
2012 assert(_type == 51)
2013 _length = reader.read("!H")[0]
2014 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2015 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]2016 obj.value = reader.read("!H")[0]
2017 return obj
2018
2019 def __eq__(self, other):
2020 if type(self) != type(other): return False
2021 if self.value != other.value: return False
2022 return True
2023
2024 def pretty_print(self, q):
2025 q.text("partner_key {")
2026 with q.group():
2027 with q.indent(2):
2028 q.breakable()
2029 q.text("value = ");
2030 q.text("%#x" % self.value)
2031 q.breakable()
2032 q.text('}')
2033
2034bsn_tlv.subtypes[51] = partner_key
2035
2036class partner_port_num(bsn_tlv):
2037 type = 50
2038
2039 def __init__(self, value=None):
2040 if value != None:
2041 self.value = value
2042 else:
2043 self.value = 0
2044 return
2045
2046 def pack(self):
2047 packed = []
2048 packed.append(struct.pack("!H", self.type))
2049 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2050 packed.append(struct.pack("!H", self.value))
2051 length = sum([len(x) for x in packed])
2052 packed[1] = struct.pack("!H", length)
2053 return ''.join(packed)
2054
2055 @staticmethod
2056 def unpack(reader):
2057 obj = partner_port_num()
2058 _type = reader.read("!H")[0]
2059 assert(_type == 50)
2060 _length = reader.read("!H")[0]
2061 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2062 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]2063 obj.value = reader.read("!H")[0]
2064 return obj
2065
2066 def __eq__(self, other):
2067 if type(self) != type(other): return False
2068 if self.value != other.value: return False
2069 return True
2070
2071 def pretty_print(self, q):
2072 q.text("partner_port_num {")
2073 with q.group():
2074 with q.indent(2):
2075 q.breakable()
2076 q.text("value = ");
2077 q.text("%#x" % self.value)
2078 q.breakable()
2079 q.text('}')
2080
2081bsn_tlv.subtypes[50] = partner_port_num
2082
2083class partner_port_priority(bsn_tlv):
2084 type = 49
2085
2086 def __init__(self, value=None):
2087 if value != None:
2088 self.value = value
2089 else:
2090 self.value = 0
2091 return
2092
2093 def pack(self):
2094 packed = []
2095 packed.append(struct.pack("!H", self.type))
2096 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2097 packed.append(struct.pack("!H", self.value))
2098 length = sum([len(x) for x in packed])
2099 packed[1] = struct.pack("!H", length)
2100 return ''.join(packed)
2101
2102 @staticmethod
2103 def unpack(reader):
2104 obj = partner_port_priority()
2105 _type = reader.read("!H")[0]
2106 assert(_type == 49)
2107 _length = reader.read("!H")[0]
2108 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2109 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]2110 obj.value = reader.read("!H")[0]
2111 return obj
2112
2113 def __eq__(self, other):
2114 if type(self) != type(other): return False
2115 if self.value != other.value: return False
2116 return True
2117
2118 def pretty_print(self, q):
2119 q.text("partner_port_priority {")
2120 with q.group():
2121 with q.indent(2):
2122 q.breakable()
2123 q.text("value = ");
2124 q.text("%#x" % self.value)
2125 q.breakable()
2126 q.text('}')
2127
2128bsn_tlv.subtypes[49] = partner_port_priority
2129
Rich Lane2e079da2014-10-29 15:30:24 -0700[diff] [blame]2130class partner_state(bsn_tlv):
2131 type = 54
2132
2133 def __init__(self, value=None):
2134 if value != None:
2135 self.value = value
2136 else:
2137 self.value = 0
2138 return
2139
2140 def pack(self):
2141 packed = []
2142 packed.append(struct.pack("!H", self.type))
2143 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2144 packed.append(struct.pack("!B", self.value))
2145 length = sum([len(x) for x in packed])
2146 packed[1] = struct.pack("!H", length)
2147 return ''.join(packed)
2148
2149 @staticmethod
2150 def unpack(reader):
2151 obj = partner_state()
2152 _type = reader.read("!H")[0]
2153 assert(_type == 54)
2154 _length = reader.read("!H")[0]
2155 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2156 reader = orig_reader.slice(_length, 4)
Rich Lane2e079da2014-10-29 15:30:24 -0700[diff] [blame]2157 obj.value = reader.read("!B")[0]
2158 return obj
2159
2160 def __eq__(self, other):
2161 if type(self) != type(other): return False
2162 if self.value != other.value: return False
2163 return True
2164
2165 def pretty_print(self, q):
2166 q.text("partner_state {")
2167 with q.group():
2168 with q.indent(2):
2169 q.breakable()
2170 q.text("value = ");
2171 q.text("%#x" % self.value)
2172 q.breakable()
2173 q.text('}')
2174
2175bsn_tlv.subtypes[54] = partner_state
2176
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]2177class partner_system_mac(bsn_tlv):
2178 type = 48
2179
2180 def __init__(self, value=None):
2181 if value != None:
2182 self.value = value
2183 else:
2184 self.value = [0,0,0,0,0,0]
2185 return
2186
2187 def pack(self):
2188 packed = []
2189 packed.append(struct.pack("!H", self.type))
2190 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2191 packed.append(struct.pack("!6B", *self.value))
2192 length = sum([len(x) for x in packed])
2193 packed[1] = struct.pack("!H", length)
2194 return ''.join(packed)
2195
2196 @staticmethod
2197 def unpack(reader):
2198 obj = partner_system_mac()
2199 _type = reader.read("!H")[0]
2200 assert(_type == 48)
2201 _length = reader.read("!H")[0]
2202 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2203 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]2204 obj.value = list(reader.read('!6B'))
2205 return obj
2206
2207 def __eq__(self, other):
2208 if type(self) != type(other): return False
2209 if self.value != other.value: return False
2210 return True
2211
2212 def pretty_print(self, q):
2213 q.text("partner_system_mac {")
2214 with q.group():
2215 with q.indent(2):
2216 q.breakable()
2217 q.text("value = ");
2218 q.text(util.pretty_mac(self.value))
2219 q.breakable()
2220 q.text('}')
2221
2222bsn_tlv.subtypes[48] = partner_system_mac
2223
2224class partner_system_priority(bsn_tlv):
2225 type = 47
2226
2227 def __init__(self, value=None):
2228 if value != None:
2229 self.value = value
2230 else:
2231 self.value = 0
2232 return
2233
2234 def pack(self):
2235 packed = []
2236 packed.append(struct.pack("!H", self.type))
2237 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2238 packed.append(struct.pack("!H", self.value))
2239 length = sum([len(x) for x in packed])
2240 packed[1] = struct.pack("!H", length)
2241 return ''.join(packed)
2242
2243 @staticmethod
2244 def unpack(reader):
2245 obj = partner_system_priority()
2246 _type = reader.read("!H")[0]
2247 assert(_type == 47)
2248 _length = reader.read("!H")[0]
2249 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2250 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]2251 obj.value = reader.read("!H")[0]
2252 return obj
2253
2254 def __eq__(self, other):
2255 if type(self) != type(other): return False
2256 if self.value != other.value: return False
2257 return True
2258
2259 def pretty_print(self, q):
2260 q.text("partner_system_priority {")
2261 with q.group():
2262 with q.indent(2):
2263 q.breakable()
2264 q.text("value = ");
2265 q.text("%#x" % self.value)
2266 q.breakable()
2267 q.text('}')
2268
2269bsn_tlv.subtypes[47] = partner_system_priority
2270
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]2271class port(bsn_tlv):
2272 type = 0
2273
2274 def __init__(self, value=None):
2275 if value != None:
2276 self.value = value
2277 else:
2278 self.value = 0
2279 return
2280
2281 def pack(self):
2282 packed = []
2283 packed.append(struct.pack("!H", self.type))
2284 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2285 packed.append(util.pack_port_no(self.value))
2286 length = sum([len(x) for x in packed])
2287 packed[1] = struct.pack("!H", length)
2288 return ''.join(packed)
2289
2290 @staticmethod
2291 def unpack(reader):
2292 obj = port()
2293 _type = reader.read("!H")[0]
2294 assert(_type == 0)
2295 _length = reader.read("!H")[0]
2296 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2297 reader = orig_reader.slice(_length, 4)
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]2298 obj.value = util.unpack_port_no(reader)
2299 return obj
2300
2301 def __eq__(self, other):
2302 if type(self) != type(other): return False
2303 if self.value != other.value: return False
2304 return True
2305
2306 def pretty_print(self, q):
2307 q.text("port {")
2308 with q.group():
2309 with q.indent(2):
2310 q.breakable()
2311 q.text("value = ");
2312 q.text(util.pretty_port(self.value))
2313 q.breakable()
2314 q.text('}')
2315
2316bsn_tlv.subtypes[0] = port
2317
Rich Laneccd32ed2014-11-10 17:48:24 -0800[diff] [blame]2318class priority(bsn_tlv):
2319 type = 57
2320
2321 def __init__(self, value=None):
2322 if value != None:
2323 self.value = value
2324 else:
2325 self.value = 0
2326 return
2327
2328 def pack(self):
2329 packed = []
2330 packed.append(struct.pack("!H", self.type))
2331 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2332 packed.append(struct.pack("!L", self.value))
2333 length = sum([len(x) for x in packed])
2334 packed[1] = struct.pack("!H", length)
2335 return ''.join(packed)
2336
2337 @staticmethod
2338 def unpack(reader):
2339 obj = priority()
2340 _type = reader.read("!H")[0]
2341 assert(_type == 57)
2342 _length = reader.read("!H")[0]
2343 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2344 reader = orig_reader.slice(_length, 4)
Rich Laneccd32ed2014-11-10 17:48:24 -0800[diff] [blame]2345 obj.value = reader.read("!L")[0]
2346 return obj
2347
2348 def __eq__(self, other):
2349 if type(self) != type(other): return False
2350 if self.value != other.value: return False
2351 return True
2352
2353 def pretty_print(self, q):
2354 q.text("priority {")
2355 with q.group():
2356 with q.indent(2):
2357 q.breakable()
2358 q.text("value = ");
2359 q.text("%#x" % self.value)
2360 q.breakable()
2361 q.text('}')
2362
2363bsn_tlv.subtypes[57] = priority
2364
Rich Lane78d9bcb2014-05-12 13:27:44 -0700[diff] [blame]2365class queue_id(bsn_tlv):
2366 type = 20
2367
2368 def __init__(self, value=None):
2369 if value != None:
2370 self.value = value
2371 else:
2372 self.value = 0
2373 return
2374
2375 def pack(self):
2376 packed = []
2377 packed.append(struct.pack("!H", self.type))
2378 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2379 packed.append(struct.pack("!L", self.value))
2380 length = sum([len(x) for x in packed])
2381 packed[1] = struct.pack("!H", length)
2382 return ''.join(packed)
2383
2384 @staticmethod
2385 def unpack(reader):
2386 obj = queue_id()
2387 _type = reader.read("!H")[0]
2388 assert(_type == 20)
2389 _length = reader.read("!H")[0]
2390 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2391 reader = orig_reader.slice(_length, 4)
Rich Lane78d9bcb2014-05-12 13:27:44 -0700[diff] [blame]2392 obj.value = reader.read("!L")[0]
2393 return obj
2394
2395 def __eq__(self, other):
2396 if type(self) != type(other): return False
2397 if self.value != other.value: return False
2398 return True
2399
2400 def pretty_print(self, q):
2401 q.text("queue_id {")
2402 with q.group():
2403 with q.indent(2):
2404 q.breakable()
2405 q.text("value = ");
2406 q.text("%#x" % self.value)
2407 q.breakable()
2408 q.text('}')
2409
2410bsn_tlv.subtypes[20] = queue_id
2411
2412class queue_weight(bsn_tlv):
2413 type = 21
2414
2415 def __init__(self, value=None):
2416 if value != None:
2417 self.value = value
2418 else:
2419 self.value = 0
2420 return
2421
2422 def pack(self):
2423 packed = []
2424 packed.append(struct.pack("!H", self.type))
2425 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2426 packed.append(struct.pack("!L", self.value))
2427 length = sum([len(x) for x in packed])
2428 packed[1] = struct.pack("!H", length)
2429 return ''.join(packed)
2430
2431 @staticmethod
2432 def unpack(reader):
2433 obj = queue_weight()
2434 _type = reader.read("!H")[0]
2435 assert(_type == 21)
2436 _length = reader.read("!H")[0]
2437 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2438 reader = orig_reader.slice(_length, 4)
Rich Lane78d9bcb2014-05-12 13:27:44 -0700[diff] [blame]2439 obj.value = reader.read("!L")[0]
2440 return obj
2441
2442 def __eq__(self, other):
2443 if type(self) != type(other): return False
2444 if self.value != other.value: return False
2445 return True
2446
2447 def pretty_print(self, q):
2448 q.text("queue_weight {")
2449 with q.group():
2450 with q.indent(2):
2451 q.breakable()
2452 q.text("value = ");
2453 q.text("%#x" % self.value)
2454 q.breakable()
2455 q.text('}')
2456
2457bsn_tlv.subtypes[21] = queue_weight
2458
Harshmeet Singh301f7172014-12-08 13:07:29 -0800[diff] [blame]2459class reference(bsn_tlv):
2460 type = 59
2461
2462 def __init__(self, table_id=None, key=None):
2463 if table_id != None:
2464 self.table_id = table_id
2465 else:
2466 self.table_id = 0
2467 if key != None:
2468 self.key = key
2469 else:
2470 self.key = []
2471 return
2472
2473 def pack(self):
2474 packed = []
2475 packed.append(struct.pack("!H", self.type))
2476 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2477 packed.append(struct.pack("!H", self.table_id))
2478 packed.append(loxi.generic_util.pack_list(self.key))
2479 length = sum([len(x) for x in packed])
2480 packed[1] = struct.pack("!H", length)
2481 return ''.join(packed)
2482
2483 @staticmethod
2484 def unpack(reader):
2485 obj = reference()
2486 _type = reader.read("!H")[0]
2487 assert(_type == 59)
2488 _length = reader.read("!H")[0]
2489 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2490 reader = orig_reader.slice(_length, 4)
Harshmeet Singh301f7172014-12-08 13:07:29 -0800[diff] [blame]2491 obj.table_id = reader.read("!H")[0]
2492 obj.key = loxi.generic_util.unpack_list(reader, bsn_tlv.bsn_tlv.unpack)
2493 return obj
2494
2495 def __eq__(self, other):
2496 if type(self) != type(other): return False
2497 if self.table_id != other.table_id: return False
2498 if self.key != other.key: return False
2499 return True
2500
2501 def pretty_print(self, q):
2502 q.text("reference {")
2503 with q.group():
2504 with q.indent(2):
2505 q.breakable()
2506 q.text("table_id = ");
2507 q.text("%#x" % self.table_id)
2508 q.text(","); q.breakable()
2509 q.text("key = ");
2510 q.pp(self.key)
2511 q.breakable()
2512 q.text('}')
2513
2514bsn_tlv.subtypes[59] = reference
2515
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]2516class reply_packets(bsn_tlv):
2517 type = 12
2518
2519 def __init__(self, value=None):
2520 if value != None:
2521 self.value = value
2522 else:
2523 self.value = 0
2524 return
2525
2526 def pack(self):
2527 packed = []
2528 packed.append(struct.pack("!H", self.type))
2529 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2530 packed.append(struct.pack("!Q", self.value))
2531 length = sum([len(x) for x in packed])
2532 packed[1] = struct.pack("!H", length)
2533 return ''.join(packed)
2534
2535 @staticmethod
2536 def unpack(reader):
2537 obj = reply_packets()
2538 _type = reader.read("!H")[0]
2539 assert(_type == 12)
2540 _length = reader.read("!H")[0]
2541 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2542 reader = orig_reader.slice(_length, 4)
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]2543 obj.value = reader.read("!Q")[0]
2544 return obj
2545
2546 def __eq__(self, other):
2547 if type(self) != type(other): return False
2548 if self.value != other.value: return False
2549 return True
2550
2551 def pretty_print(self, q):
2552 q.text("reply_packets {")
2553 with q.group():
2554 with q.indent(2):
2555 q.breakable()
2556 q.text("value = ");
2557 q.text("%#x" % self.value)
2558 q.breakable()
2559 q.text('}')
2560
2561bsn_tlv.subtypes[12] = reply_packets
2562
2563class request_packets(bsn_tlv):
2564 type = 11
2565
2566 def __init__(self, value=None):
2567 if value != None:
2568 self.value = value
2569 else:
2570 self.value = 0
2571 return
2572
2573 def pack(self):
2574 packed = []
2575 packed.append(struct.pack("!H", self.type))
2576 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2577 packed.append(struct.pack("!Q", self.value))
2578 length = sum([len(x) for x in packed])
2579 packed[1] = struct.pack("!H", length)
2580 return ''.join(packed)
2581
2582 @staticmethod
2583 def unpack(reader):
2584 obj = request_packets()
2585 _type = reader.read("!H")[0]
2586 assert(_type == 11)
2587 _length = reader.read("!H")[0]
2588 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2589 reader = orig_reader.slice(_length, 4)
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]2590 obj.value = reader.read("!Q")[0]
2591 return obj
2592
2593 def __eq__(self, other):
2594 if type(self) != type(other): return False
2595 if self.value != other.value: return False
2596 return True
2597
2598 def pretty_print(self, q):
2599 q.text("request_packets {")
2600 with q.group():
2601 with q.indent(2):
2602 q.breakable()
2603 q.text("value = ");
2604 q.text("%#x" % self.value)
2605 q.breakable()
2606 q.text('}')
2607
2608bsn_tlv.subtypes[11] = request_packets
2609
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]2610class rx_packets(bsn_tlv):
2611 type = 2
2612
2613 def __init__(self, value=None):
2614 if value != None:
2615 self.value = value
2616 else:
2617 self.value = 0
2618 return
2619
2620 def pack(self):
2621 packed = []
2622 packed.append(struct.pack("!H", self.type))
2623 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2624 packed.append(struct.pack("!Q", self.value))
2625 length = sum([len(x) for x in packed])
2626 packed[1] = struct.pack("!H", length)
2627 return ''.join(packed)
2628
2629 @staticmethod
2630 def unpack(reader):
2631 obj = rx_packets()
2632 _type = reader.read("!H")[0]
2633 assert(_type == 2)
2634 _length = reader.read("!H")[0]
2635 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2636 reader = orig_reader.slice(_length, 4)
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]2637 obj.value = reader.read("!Q")[0]
2638 return obj
2639
2640 def __eq__(self, other):
2641 if type(self) != type(other): return False
2642 if self.value != other.value: return False
2643 return True
2644
2645 def pretty_print(self, q):
2646 q.text("rx_packets {")
2647 with q.group():
2648 with q.indent(2):
2649 q.breakable()
2650 q.text("value = ");
2651 q.text("%#x" % self.value)
2652 q.breakable()
2653 q.text('}')
2654
2655bsn_tlv.subtypes[2] = rx_packets
2656
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]2657class sampling_rate(bsn_tlv):
2658 type = 30
2659
2660 def __init__(self, value=None):
2661 if value != None:
2662 self.value = value
2663 else:
2664 self.value = 0
2665 return
2666
2667 def pack(self):
2668 packed = []
2669 packed.append(struct.pack("!H", self.type))
2670 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2671 packed.append(struct.pack("!L", self.value))
2672 length = sum([len(x) for x in packed])
2673 packed[1] = struct.pack("!H", length)
2674 return ''.join(packed)
2675
2676 @staticmethod
2677 def unpack(reader):
2678 obj = sampling_rate()
2679 _type = reader.read("!H")[0]
2680 assert(_type == 30)
2681 _length = reader.read("!H")[0]
2682 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2683 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]2684 obj.value = reader.read("!L")[0]
2685 return obj
2686
2687 def __eq__(self, other):
2688 if type(self) != type(other): return False
2689 if self.value != other.value: return False
2690 return True
2691
2692 def pretty_print(self, q):
2693 q.text("sampling_rate {")
2694 with q.group():
2695 with q.indent(2):
2696 q.breakable()
2697 q.text("value = ");
2698 q.text("%#x" % self.value)
2699 q.breakable()
2700 q.text('}')
2701
2702bsn_tlv.subtypes[30] = sampling_rate
2703
2704class sub_agent_id(bsn_tlv):
2705 type = 38
2706
2707 def __init__(self, value=None):
2708 if value != None:
2709 self.value = value
2710 else:
2711 self.value = 0
2712 return
2713
2714 def pack(self):
2715 packed = []
2716 packed.append(struct.pack("!H", self.type))
2717 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2718 packed.append(struct.pack("!L", self.value))
2719 length = sum([len(x) for x in packed])
2720 packed[1] = struct.pack("!H", length)
2721 return ''.join(packed)
2722
2723 @staticmethod
2724 def unpack(reader):
2725 obj = sub_agent_id()
2726 _type = reader.read("!H")[0]
2727 assert(_type == 38)
2728 _length = reader.read("!H")[0]
2729 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2730 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]2731 obj.value = reader.read("!L")[0]
2732 return obj
2733
2734 def __eq__(self, other):
2735 if type(self) != type(other): return False
2736 if self.value != other.value: return False
2737 return True
2738
2739 def pretty_print(self, q):
2740 q.text("sub_agent_id {")
2741 with q.group():
2742 with q.indent(2):
2743 q.breakable()
2744 q.text("value = ");
2745 q.text("%#x" % self.value)
2746 q.breakable()
2747 q.text('}')
2748
2749bsn_tlv.subtypes[38] = sub_agent_id
2750
Rich Lane474324f2015-01-14 15:22:56 -0800[diff] [blame]2751class tcp_dst(bsn_tlv):
2752 type = 66
2753
2754 def __init__(self, value=None):
2755 if value != None:
2756 self.value = value
2757 else:
2758 self.value = 0
2759 return
2760
2761 def pack(self):
2762 packed = []
2763 packed.append(struct.pack("!H", self.type))
2764 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2765 packed.append(struct.pack("!H", self.value))
2766 length = sum([len(x) for x in packed])
2767 packed[1] = struct.pack("!H", length)
2768 return ''.join(packed)
2769
2770 @staticmethod
2771 def unpack(reader):
2772 obj = tcp_dst()
2773 _type = reader.read("!H")[0]
2774 assert(_type == 66)
2775 _length = reader.read("!H")[0]
2776 orig_reader = reader
2777 reader = orig_reader.slice(_length, 4)
2778 obj.value = reader.read("!H")[0]
2779 return obj
2780
2781 def __eq__(self, other):
2782 if type(self) != type(other): return False
2783 if self.value != other.value: return False
2784 return True
2785
2786 def pretty_print(self, q):
2787 q.text("tcp_dst {")
2788 with q.group():
2789 with q.indent(2):
2790 q.breakable()
2791 q.text("value = ");
2792 q.text("%#x" % self.value)
2793 q.breakable()
2794 q.text('}')
2795
2796bsn_tlv.subtypes[66] = tcp_dst
2797
2798class tcp_src(bsn_tlv):
2799 type = 65
2800
2801 def __init__(self, value=None):
2802 if value != None:
2803 self.value = value
2804 else:
2805 self.value = 0
2806 return
2807
2808 def pack(self):
2809 packed = []
2810 packed.append(struct.pack("!H", self.type))
2811 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2812 packed.append(struct.pack("!H", self.value))
2813 length = sum([len(x) for x in packed])
2814 packed[1] = struct.pack("!H", length)
2815 return ''.join(packed)
2816
2817 @staticmethod
2818 def unpack(reader):
2819 obj = tcp_src()
2820 _type = reader.read("!H")[0]
2821 assert(_type == 65)
2822 _length = reader.read("!H")[0]
2823 orig_reader = reader
2824 reader = orig_reader.slice(_length, 4)
2825 obj.value = reader.read("!H")[0]
2826 return obj
2827
2828 def __eq__(self, other):
2829 if type(self) != type(other): return False
2830 if self.value != other.value: return False
2831 return True
2832
2833 def pretty_print(self, q):
2834 q.text("tcp_src {")
2835 with q.group():
2836 with q.indent(2):
2837 q.breakable()
2838 q.text("value = ");
2839 q.text("%#x" % self.value)
2840 q.breakable()
2841 q.text('}')
2842
2843bsn_tlv.subtypes[65] = tcp_src
2844
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]2845class tx_bytes(bsn_tlv):
2846 type = 39
2847
2848 def __init__(self, value=None):
2849 if value != None:
2850 self.value = value
2851 else:
2852 self.value = 0
2853 return
2854
2855 def pack(self):
2856 packed = []
2857 packed.append(struct.pack("!H", self.type))
2858 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2859 packed.append(struct.pack("!Q", self.value))
2860 length = sum([len(x) for x in packed])
2861 packed[1] = struct.pack("!H", length)
2862 return ''.join(packed)
2863
2864 @staticmethod
2865 def unpack(reader):
2866 obj = tx_bytes()
2867 _type = reader.read("!H")[0]
2868 assert(_type == 39)
2869 _length = reader.read("!H")[0]
2870 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2871 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]2872 obj.value = reader.read("!Q")[0]
2873 return obj
2874
2875 def __eq__(self, other):
2876 if type(self) != type(other): return False
2877 if self.value != other.value: return False
2878 return True
2879
2880 def pretty_print(self, q):
2881 q.text("tx_bytes {")
2882 with q.group():
2883 with q.indent(2):
2884 q.breakable()
2885 q.text("value = ");
2886 q.text("%#x" % self.value)
2887 q.breakable()
2888 q.text('}')
2889
2890bsn_tlv.subtypes[39] = tx_bytes
2891
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]2892class tx_packets(bsn_tlv):
2893 type = 3
2894
2895 def __init__(self, value=None):
2896 if value != None:
2897 self.value = value
2898 else:
2899 self.value = 0
2900 return
2901
2902 def pack(self):
2903 packed = []
2904 packed.append(struct.pack("!H", self.type))
2905 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2906 packed.append(struct.pack("!Q", self.value))
2907 length = sum([len(x) for x in packed])
2908 packed[1] = struct.pack("!H", length)
2909 return ''.join(packed)
2910
2911 @staticmethod
2912 def unpack(reader):
2913 obj = tx_packets()
2914 _type = reader.read("!H")[0]
2915 assert(_type == 3)
2916 _length = reader.read("!H")[0]
2917 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2918 reader = orig_reader.slice(_length, 4)
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]2919 obj.value = reader.read("!Q")[0]
2920 return obj
2921
2922 def __eq__(self, other):
2923 if type(self) != type(other): return False
2924 if self.value != other.value: return False
2925 return True
2926
2927 def pretty_print(self, q):
2928 q.text("tx_packets {")
2929 with q.group():
2930 with q.indent(2):
2931 q.breakable()
2932 q.text("value = ");
2933 q.text("%#x" % self.value)
2934 q.breakable()
2935 q.text('}')
2936
2937bsn_tlv.subtypes[3] = tx_packets
2938
Rich Lane93b33132014-04-21 12:20:58 -0700[diff] [blame]2939class udf_anchor(bsn_tlv):
2940 type = 16
2941
2942 def __init__(self, value=None):
2943 if value != None:
2944 self.value = value
2945 else:
2946 self.value = 0
2947 return
2948
2949 def pack(self):
2950 packed = []
2951 packed.append(struct.pack("!H", self.type))
2952 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
2953 packed.append(struct.pack("!H", self.value))
2954 length = sum([len(x) for x in packed])
2955 packed[1] = struct.pack("!H", length)
2956 return ''.join(packed)
2957
2958 @staticmethod
2959 def unpack(reader):
2960 obj = udf_anchor()
2961 _type = reader.read("!H")[0]
2962 assert(_type == 16)
2963 _length = reader.read("!H")[0]
2964 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]2965 reader = orig_reader.slice(_length, 4)
Rich Lane93b33132014-04-21 12:20:58 -0700[diff] [blame]2966 obj.value = reader.read("!H")[0]
2967 return obj
2968
2969 def __eq__(self, other):
2970 if type(self) != type(other): return False
2971 if self.value != other.value: return False
2972 return True
2973
2974 def pretty_print(self, q):
2975 q.text("udf_anchor {")
2976 with q.group():
2977 with q.indent(2):
2978 q.breakable()
2979 q.text("value = ");
2980 q.text("%#x" % self.value)
2981 q.breakable()
2982 q.text('}')
2983
2984bsn_tlv.subtypes[16] = udf_anchor
2985
2986class udf_id(bsn_tlv):
2987 type = 15
2988
2989 def __init__(self, value=None):
2990 if value != None:
2991 self.value = value
2992 else:
2993 self.value = 0
2994 return
2995
2996 def pack(self):
2997 packed = []
2998 packed.append(struct.pack("!H", self.type))
2999 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
3000 packed.append(struct.pack("!H", self.value))
3001 length = sum([len(x) for x in packed])
3002 packed[1] = struct.pack("!H", length)
3003 return ''.join(packed)
3004
3005 @staticmethod
3006 def unpack(reader):
3007 obj = udf_id()
3008 _type = reader.read("!H")[0]
3009 assert(_type == 15)
3010 _length = reader.read("!H")[0]
3011 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]3012 reader = orig_reader.slice(_length, 4)
Rich Lane93b33132014-04-21 12:20:58 -0700[diff] [blame]3013 obj.value = reader.read("!H")[0]
3014 return obj
3015
3016 def __eq__(self, other):
3017 if type(self) != type(other): return False
3018 if self.value != other.value: return False
3019 return True
3020
3021 def pretty_print(self, q):
3022 q.text("udf_id {")
3023 with q.group():
3024 with q.indent(2):
3025 q.breakable()
3026 q.text("value = ");
3027 q.text("%#x" % self.value)
3028 q.breakable()
3029 q.text('}')
3030
3031bsn_tlv.subtypes[15] = udf_id
3032
3033class udf_length(bsn_tlv):
3034 type = 18
3035
3036 def __init__(self, value=None):
3037 if value != None:
3038 self.value = value
3039 else:
3040 self.value = 0
3041 return
3042
3043 def pack(self):
3044 packed = []
3045 packed.append(struct.pack("!H", self.type))
3046 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
3047 packed.append(struct.pack("!H", self.value))
3048 length = sum([len(x) for x in packed])
3049 packed[1] = struct.pack("!H", length)
3050 return ''.join(packed)
3051
3052 @staticmethod
3053 def unpack(reader):
3054 obj = udf_length()
3055 _type = reader.read("!H")[0]
3056 assert(_type == 18)
3057 _length = reader.read("!H")[0]
3058 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]3059 reader = orig_reader.slice(_length, 4)
Rich Lane93b33132014-04-21 12:20:58 -0700[diff] [blame]3060 obj.value = reader.read("!H")[0]
3061 return obj
3062
3063 def __eq__(self, other):
3064 if type(self) != type(other): return False
3065 if self.value != other.value: return False
3066 return True
3067
3068 def pretty_print(self, q):
3069 q.text("udf_length {")
3070 with q.group():
3071 with q.indent(2):
3072 q.breakable()
3073 q.text("value = ");
3074 q.text("%#x" % self.value)
3075 q.breakable()
3076 q.text('}')
3077
3078bsn_tlv.subtypes[18] = udf_length
3079
3080class udf_offset(bsn_tlv):
3081 type = 17
3082
3083 def __init__(self, value=None):
3084 if value != None:
3085 self.value = value
3086 else:
3087 self.value = 0
3088 return
3089
3090 def pack(self):
3091 packed = []
3092 packed.append(struct.pack("!H", self.type))
3093 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
3094 packed.append(struct.pack("!H", self.value))
3095 length = sum([len(x) for x in packed])
3096 packed[1] = struct.pack("!H", length)
3097 return ''.join(packed)
3098
3099 @staticmethod
3100 def unpack(reader):
3101 obj = udf_offset()
3102 _type = reader.read("!H")[0]
3103 assert(_type == 17)
3104 _length = reader.read("!H")[0]
3105 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]3106 reader = orig_reader.slice(_length, 4)
Rich Lane93b33132014-04-21 12:20:58 -0700[diff] [blame]3107 obj.value = reader.read("!H")[0]
3108 return obj
3109
3110 def __eq__(self, other):
3111 if type(self) != type(other): return False
3112 if self.value != other.value: return False
3113 return True
3114
3115 def pretty_print(self, q):
3116 q.text("udf_offset {")
3117 with q.group():
3118 with q.indent(2):
3119 q.breakable()
3120 q.text("value = ");
3121 q.text("%#x" % self.value)
3122 q.breakable()
3123 q.text('}')
3124
3125bsn_tlv.subtypes[17] = udf_offset
3126
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]3127class udp_dst(bsn_tlv):
3128 type = 37
3129
3130 def __init__(self, value=None):
3131 if value != None:
3132 self.value = value
3133 else:
3134 self.value = 0
3135 return
3136
3137 def pack(self):
3138 packed = []
3139 packed.append(struct.pack("!H", self.type))
3140 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
3141 packed.append(struct.pack("!H", self.value))
3142 length = sum([len(x) for x in packed])
3143 packed[1] = struct.pack("!H", length)
3144 return ''.join(packed)
3145
3146 @staticmethod
3147 def unpack(reader):
3148 obj = udp_dst()
3149 _type = reader.read("!H")[0]
3150 assert(_type == 37)
3151 _length = reader.read("!H")[0]
3152 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]3153 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]3154 obj.value = reader.read("!H")[0]
3155 return obj
3156
3157 def __eq__(self, other):
3158 if type(self) != type(other): return False
3159 if self.value != other.value: return False
3160 return True
3161
3162 def pretty_print(self, q):
3163 q.text("udp_dst {")
3164 with q.group():
3165 with q.indent(2):
3166 q.breakable()
3167 q.text("value = ");
3168 q.text("%#x" % self.value)
3169 q.breakable()
3170 q.text('}')
3171
3172bsn_tlv.subtypes[37] = udp_dst
3173
3174class udp_src(bsn_tlv):
3175 type = 36
3176
3177 def __init__(self, value=None):
3178 if value != None:
3179 self.value = value
3180 else:
3181 self.value = 0
3182 return
3183
3184 def pack(self):
3185 packed = []
3186 packed.append(struct.pack("!H", self.type))
3187 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
3188 packed.append(struct.pack("!H", self.value))
3189 length = sum([len(x) for x in packed])
3190 packed[1] = struct.pack("!H", length)
3191 return ''.join(packed)
3192
3193 @staticmethod
3194 def unpack(reader):
3195 obj = udp_src()
3196 _type = reader.read("!H")[0]
3197 assert(_type == 36)
3198 _length = reader.read("!H")[0]
3199 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]3200 reader = orig_reader.slice(_length, 4)
Harshmeet Singh1db46332014-10-14 16:29:13 -0700[diff] [blame]3201 obj.value = reader.read("!H")[0]
3202 return obj
3203
3204 def __eq__(self, other):
3205 if type(self) != type(other): return False
3206 if self.value != other.value: return False
3207 return True
3208
3209 def pretty_print(self, q):
3210 q.text("udp_src {")
3211 with q.group():
3212 with q.indent(2):
3213 q.breakable()
3214 q.text("value = ");
3215 q.text("%#x" % self.value)
3216 q.breakable()
3217 q.text('}')
3218
3219bsn_tlv.subtypes[36] = udp_src
3220
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]3221class unicast_query_timeout(bsn_tlv):
3222 type = 9
3223
3224 def __init__(self, value=None):
3225 if value != None:
3226 self.value = value
3227 else:
3228 self.value = 0
3229 return
3230
3231 def pack(self):
3232 packed = []
3233 packed.append(struct.pack("!H", self.type))
3234 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
3235 packed.append(struct.pack("!L", self.value))
3236 length = sum([len(x) for x in packed])
3237 packed[1] = struct.pack("!H", length)
3238 return ''.join(packed)
3239
3240 @staticmethod
3241 def unpack(reader):
3242 obj = unicast_query_timeout()
3243 _type = reader.read("!H")[0]
3244 assert(_type == 9)
3245 _length = reader.read("!H")[0]
3246 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]3247 reader = orig_reader.slice(_length, 4)
Rich Lane95f7fc92014-01-27 17:08:16 -0800[diff] [blame]3248 obj.value = reader.read("!L")[0]
3249 return obj
3250
3251 def __eq__(self, other):
3252 if type(self) != type(other): return False
3253 if self.value != other.value: return False
3254 return True
3255
3256 def pretty_print(self, q):
3257 q.text("unicast_query_timeout {")
3258 with q.group():
3259 with q.indent(2):
3260 q.breakable()
3261 q.text("value = ");
3262 q.text("%#x" % self.value)
3263 q.breakable()
3264 q.text('}')
3265
3266bsn_tlv.subtypes[9] = unicast_query_timeout
3267
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]3268class vlan_vid(bsn_tlv):
3269 type = 6
3270
3271 def __init__(self, value=None):
3272 if value != None:
3273 self.value = value
3274 else:
3275 self.value = 0
3276 return
3277
3278 def pack(self):
3279 packed = []
3280 packed.append(struct.pack("!H", self.type))
3281 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
3282 packed.append(struct.pack("!H", self.value))
3283 length = sum([len(x) for x in packed])
3284 packed[1] = struct.pack("!H", length)
3285 return ''.join(packed)
3286
3287 @staticmethod
3288 def unpack(reader):
3289 obj = vlan_vid()
3290 _type = reader.read("!H")[0]
3291 assert(_type == 6)
3292 _length = reader.read("!H")[0]
3293 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]3294 reader = orig_reader.slice(_length, 4)
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]3295 obj.value = reader.read("!H")[0]
3296 return obj
3297
3298 def __eq__(self, other):
3299 if type(self) != type(other): return False
3300 if self.value != other.value: return False
3301 return True
3302
3303 def pretty_print(self, q):
3304 q.text("vlan_vid {")
3305 with q.group():
3306 with q.indent(2):
3307 q.breakable()
3308 q.text("value = ");
3309 q.text("%#x" % self.value)
3310 q.breakable()
3311 q.text('}')
3312
3313bsn_tlv.subtypes[6] = vlan_vid
3314
Rich Lane93b33132014-04-21 12:20:58 -0700[diff] [blame]3315class vrf(bsn_tlv):
3316 type = 19
3317
3318 def __init__(self, value=None):
3319 if value != None:
3320 self.value = value
3321 else:
3322 self.value = 0
3323 return
3324
3325 def pack(self):
3326 packed = []
3327 packed.append(struct.pack("!H", self.type))
3328 packed.append(struct.pack("!H", 0)) # placeholder for length at index 1
3329 packed.append(struct.pack("!L", self.value))
3330 length = sum([len(x) for x in packed])
3331 packed[1] = struct.pack("!H", length)
3332 return ''.join(packed)
3333
3334 @staticmethod
3335 def unpack(reader):
3336 obj = vrf()
3337 _type = reader.read("!H")[0]
3338 assert(_type == 19)
3339 _length = reader.read("!H")[0]
3340 orig_reader = reader
Rich Lanecb18dbd2014-12-18 10:02:29 -0800[diff] [blame]3341 reader = orig_reader.slice(_length, 4)
Rich Lane93b33132014-04-21 12:20:58 -0700[diff] [blame]3342 obj.value = reader.read("!L")[0]
3343 return obj
3344
3345 def __eq__(self, other):
3346 if type(self) != type(other): return False
3347 if self.value != other.value: return False
3348 return True
3349
3350 def pretty_print(self, q):
3351 q.text("vrf {")
3352 with q.group():
3353 with q.indent(2):
3354 q.breakable()
3355 q.text("value = ");
3356 q.text("%#x" % self.value)
3357 q.breakable()
3358 q.text('}')
3359
3360bsn_tlv.subtypes[19] = vrf
3361
Rich Lane5454b682014-01-14 17:07:36 -0800[diff] [blame]3362