Gitiles
Code Review Sign In
gerrit.opencord.org / fabric-oftest / 58ea4c57f8fb758b672c8147064c39db3d3a375e / . / src / python / loxi / of10 / message.py
blob: 9b12a07932a30fa99de288062572a3643c3565b7 [file] [log] [blame]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[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.
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4# See the file LICENSE.pyloxi which should have been included in the source distribution
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5
6# Automatically generated by LOXI from template message.py
7# Do not modify
8
9import struct
10import loxi
11import const
12import common
13import action # for unpack_list
14import util
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]15import loxi.generic_util
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]16
17class Message(object):
18 version = const.OFP_VERSION
19 type = None # override in subclass
20 xid = None
21
22class aggregate_stats_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]23 version = 1
24 type = 17
25 stats_type = 2
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]26
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]27 def __init__(self, xid=None, flags=None, packet_count=None, byte_count=None, flow_count=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]28 self.xid = xid
29 if flags != None:
30 self.flags = flags
31 else:
32 self.flags = 0
33 if packet_count != None:
34 self.packet_count = packet_count
35 else:
36 self.packet_count = 0
37 if byte_count != None:
38 self.byte_count = byte_count
39 else:
40 self.byte_count = 0
41 if flow_count != None:
42 self.flow_count = flow_count
43 else:
44 self.flow_count = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]45
46 def pack(self):
47 packed = []
48 packed.append(struct.pack("!B", self.version))
49 packed.append(struct.pack("!B", self.type))
50 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
51 packed.append(struct.pack("!L", self.xid))
52 packed.append(struct.pack("!H", self.stats_type))
53 packed.append(struct.pack("!H", self.flags))
54 packed.append(struct.pack("!Q", self.packet_count))
55 packed.append(struct.pack("!Q", self.byte_count))
56 packed.append(struct.pack("!L", self.flow_count))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]57 packed.append('\x00' * 4)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]58 length = sum([len(x) for x in packed])
59 packed[2] = struct.pack("!H", length)
60 return ''.join(packed)
61
62 @staticmethod
63 def unpack(buf):
64 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
65 obj = aggregate_stats_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]66 if type(buf) == loxi.generic_util.OFReader:
67 reader = buf
68 else:
69 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]70 _version = reader.read("!B")[0]
71 assert(_version == 1)
72 _type = reader.read("!B")[0]
73 assert(_type == 17)
74 _length = reader.read("!H")[0]
75 obj.xid = reader.read("!L")[0]
76 _stats_type = reader.read("!H")[0]
77 assert(_stats_type == 2)
78 obj.flags = reader.read("!H")[0]
79 obj.packet_count = reader.read("!Q")[0]
80 obj.byte_count = reader.read("!Q")[0]
81 obj.flow_count = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]82 reader.skip(4)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]83 return obj
84
85 def __eq__(self, other):
86 if type(self) != type(other): return False
87 if self.version != other.version: return False
88 if self.type != other.type: return False
89 if self.xid != other.xid: return False
90 if self.flags != other.flags: return False
91 if self.packet_count != other.packet_count: return False
92 if self.byte_count != other.byte_count: return False
93 if self.flow_count != other.flow_count: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]94 return True
95
96 def __ne__(self, other):
97 return not self.__eq__(other)
98
99 def __str__(self):
100 return self.show()
101
102 def show(self):
103 import loxi.pp
104 return loxi.pp.pp(self)
105
106 def pretty_print(self, q):
107 q.text("aggregate_stats_reply {")
108 with q.group():
109 with q.indent(2):
110 q.breakable()
111 q.text("xid = ");
112 if self.xid != None:
113 q.text("%#x" % self.xid)
114 else:
115 q.text('None')
116 q.text(","); q.breakable()
117 q.text("flags = ");
118 q.text("%#x" % self.flags)
119 q.text(","); q.breakable()
120 q.text("packet_count = ");
121 q.text("%#x" % self.packet_count)
122 q.text(","); q.breakable()
123 q.text("byte_count = ");
124 q.text("%#x" % self.byte_count)
125 q.text(","); q.breakable()
126 q.text("flow_count = ");
127 q.text("%#x" % self.flow_count)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]128 q.breakable()
129 q.text('}')
130
131class aggregate_stats_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]132 version = 1
133 type = 16
134 stats_type = 2
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]135
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]136 def __init__(self, xid=None, flags=None, match=None, table_id=None, out_port=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]137 self.xid = xid
138 if flags != None:
139 self.flags = flags
140 else:
141 self.flags = 0
142 if match != None:
143 self.match = match
144 else:
145 self.match = common.match()
146 if table_id != None:
147 self.table_id = table_id
148 else:
149 self.table_id = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]150 if out_port != None:
151 self.out_port = out_port
152 else:
153 self.out_port = 0
154
155 def pack(self):
156 packed = []
157 packed.append(struct.pack("!B", self.version))
158 packed.append(struct.pack("!B", self.type))
159 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
160 packed.append(struct.pack("!L", self.xid))
161 packed.append(struct.pack("!H", self.stats_type))
162 packed.append(struct.pack("!H", self.flags))
163 packed.append(self.match.pack())
164 packed.append(struct.pack("!B", self.table_id))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]165 packed.append('\x00' * 1)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]166 packed.append(util.pack_port_no(self.out_port))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]167 length = sum([len(x) for x in packed])
168 packed[2] = struct.pack("!H", length)
169 return ''.join(packed)
170
171 @staticmethod
172 def unpack(buf):
173 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
174 obj = aggregate_stats_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]175 if type(buf) == loxi.generic_util.OFReader:
176 reader = buf
177 else:
178 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]179 _version = reader.read("!B")[0]
180 assert(_version == 1)
181 _type = reader.read("!B")[0]
182 assert(_type == 16)
183 _length = reader.read("!H")[0]
184 obj.xid = reader.read("!L")[0]
185 _stats_type = reader.read("!H")[0]
186 assert(_stats_type == 2)
187 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]188 obj.match = common.match.unpack(reader)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]189 obj.table_id = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]190 reader.skip(1)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]191 obj.out_port = util.unpack_port_no(reader)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]192 return obj
193
194 def __eq__(self, other):
195 if type(self) != type(other): return False
196 if self.version != other.version: return False
197 if self.type != other.type: return False
198 if self.xid != other.xid: return False
199 if self.flags != other.flags: return False
200 if self.match != other.match: return False
201 if self.table_id != other.table_id: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]202 if self.out_port != other.out_port: return False
203 return True
204
205 def __ne__(self, other):
206 return not self.__eq__(other)
207
208 def __str__(self):
209 return self.show()
210
211 def show(self):
212 import loxi.pp
213 return loxi.pp.pp(self)
214
215 def pretty_print(self, q):
216 q.text("aggregate_stats_request {")
217 with q.group():
218 with q.indent(2):
219 q.breakable()
220 q.text("xid = ");
221 if self.xid != None:
222 q.text("%#x" % self.xid)
223 else:
224 q.text('None')
225 q.text(","); q.breakable()
226 q.text("flags = ");
227 q.text("%#x" % self.flags)
228 q.text(","); q.breakable()
229 q.text("match = ");
230 q.pp(self.match)
231 q.text(","); q.breakable()
232 q.text("table_id = ");
233 q.text("%#x" % self.table_id)
234 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]235 q.text("out_port = ");
236 q.text(util.pretty_port(self.out_port))
237 q.breakable()
238 q.text('}')
239
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]240class bad_action_error_msg(Message):
241 version = 1
242 type = 1
243 err_type = 2
244
245 def __init__(self, xid=None, code=None, data=None):
246 self.xid = xid
247 if code != None:
248 self.code = code
249 else:
250 self.code = 0
251 if data != None:
252 self.data = data
253 else:
254 self.data = ''
255
256 def pack(self):
257 packed = []
258 packed.append(struct.pack("!B", self.version))
259 packed.append(struct.pack("!B", self.type))
260 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
261 packed.append(struct.pack("!L", self.xid))
262 packed.append(struct.pack("!H", self.err_type))
263 packed.append(struct.pack("!H", self.code))
264 packed.append(self.data)
265 length = sum([len(x) for x in packed])
266 packed[2] = struct.pack("!H", length)
267 return ''.join(packed)
268
269 @staticmethod
270 def unpack(buf):
271 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
272 obj = bad_action_error_msg()
273 if type(buf) == loxi.generic_util.OFReader:
274 reader = buf
275 else:
276 reader = loxi.generic_util.OFReader(buf)
277 _version = reader.read("!B")[0]
278 assert(_version == 1)
279 _type = reader.read("!B")[0]
280 assert(_type == 1)
281 _length = reader.read("!H")[0]
282 obj.xid = reader.read("!L")[0]
283 _err_type = reader.read("!H")[0]
284 assert(_err_type == 2)
285 obj.code = reader.read("!H")[0]
286 obj.data = str(reader.read_all())
287 return obj
288
289 def __eq__(self, other):
290 if type(self) != type(other): return False
291 if self.version != other.version: return False
292 if self.type != other.type: return False
293 if self.xid != other.xid: return False
294 if self.code != other.code: return False
295 if self.data != other.data: return False
296 return True
297
298 def __ne__(self, other):
299 return not self.__eq__(other)
300
301 def __str__(self):
302 return self.show()
303
304 def show(self):
305 import loxi.pp
306 return loxi.pp.pp(self)
307
308 def pretty_print(self, q):
309 q.text("bad_action_error_msg {")
310 with q.group():
311 with q.indent(2):
312 q.breakable()
313 q.text("xid = ");
314 if self.xid != None:
315 q.text("%#x" % self.xid)
316 else:
317 q.text('None')
318 q.text(","); q.breakable()
319 q.text("code = ");
320 q.text("%#x" % self.code)
321 q.text(","); q.breakable()
322 q.text("data = ");
323 q.pp(self.data)
324 q.breakable()
325 q.text('}')
326
327class bad_request_error_msg(Message):
328 version = 1
329 type = 1
330 err_type = 1
331
332 def __init__(self, xid=None, code=None, data=None):
333 self.xid = xid
334 if code != None:
335 self.code = code
336 else:
337 self.code = 0
338 if data != None:
339 self.data = data
340 else:
341 self.data = ''
342
343 def pack(self):
344 packed = []
345 packed.append(struct.pack("!B", self.version))
346 packed.append(struct.pack("!B", self.type))
347 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
348 packed.append(struct.pack("!L", self.xid))
349 packed.append(struct.pack("!H", self.err_type))
350 packed.append(struct.pack("!H", self.code))
351 packed.append(self.data)
352 length = sum([len(x) for x in packed])
353 packed[2] = struct.pack("!H", length)
354 return ''.join(packed)
355
356 @staticmethod
357 def unpack(buf):
358 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
359 obj = bad_request_error_msg()
360 if type(buf) == loxi.generic_util.OFReader:
361 reader = buf
362 else:
363 reader = loxi.generic_util.OFReader(buf)
364 _version = reader.read("!B")[0]
365 assert(_version == 1)
366 _type = reader.read("!B")[0]
367 assert(_type == 1)
368 _length = reader.read("!H")[0]
369 obj.xid = reader.read("!L")[0]
370 _err_type = reader.read("!H")[0]
371 assert(_err_type == 1)
372 obj.code = reader.read("!H")[0]
373 obj.data = str(reader.read_all())
374 return obj
375
376 def __eq__(self, other):
377 if type(self) != type(other): return False
378 if self.version != other.version: return False
379 if self.type != other.type: return False
380 if self.xid != other.xid: return False
381 if self.code != other.code: return False
382 if self.data != other.data: return False
383 return True
384
385 def __ne__(self, other):
386 return not self.__eq__(other)
387
388 def __str__(self):
389 return self.show()
390
391 def show(self):
392 import loxi.pp
393 return loxi.pp.pp(self)
394
395 def pretty_print(self, q):
396 q.text("bad_request_error_msg {")
397 with q.group():
398 with q.indent(2):
399 q.breakable()
400 q.text("xid = ");
401 if self.xid != None:
402 q.text("%#x" % self.xid)
403 else:
404 q.text('None')
405 q.text(","); q.breakable()
406 q.text("code = ");
407 q.text("%#x" % self.code)
408 q.text(","); q.breakable()
409 q.text("data = ");
410 q.pp(self.data)
411 q.breakable()
412 q.text('}')
413
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]414class barrier_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]415 version = 1
416 type = 19
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]417
418 def __init__(self, xid=None):
419 self.xid = xid
420
421 def pack(self):
422 packed = []
423 packed.append(struct.pack("!B", self.version))
424 packed.append(struct.pack("!B", self.type))
425 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
426 packed.append(struct.pack("!L", self.xid))
427 length = sum([len(x) for x in packed])
428 packed[2] = struct.pack("!H", length)
429 return ''.join(packed)
430
431 @staticmethod
432 def unpack(buf):
433 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
434 obj = barrier_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]435 if type(buf) == loxi.generic_util.OFReader:
436 reader = buf
437 else:
438 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]439 _version = reader.read("!B")[0]
440 assert(_version == 1)
441 _type = reader.read("!B")[0]
442 assert(_type == 19)
443 _length = reader.read("!H")[0]
444 obj.xid = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]445 return obj
446
447 def __eq__(self, other):
448 if type(self) != type(other): return False
449 if self.version != other.version: return False
450 if self.type != other.type: return False
451 if self.xid != other.xid: return False
452 return True
453
454 def __ne__(self, other):
455 return not self.__eq__(other)
456
457 def __str__(self):
458 return self.show()
459
460 def show(self):
461 import loxi.pp
462 return loxi.pp.pp(self)
463
464 def pretty_print(self, q):
465 q.text("barrier_reply {")
466 with q.group():
467 with q.indent(2):
468 q.breakable()
469 q.text("xid = ");
470 if self.xid != None:
471 q.text("%#x" % self.xid)
472 else:
473 q.text('None')
474 q.breakable()
475 q.text('}')
476
477class barrier_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]478 version = 1
479 type = 18
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]480
481 def __init__(self, xid=None):
482 self.xid = xid
483
484 def pack(self):
485 packed = []
486 packed.append(struct.pack("!B", self.version))
487 packed.append(struct.pack("!B", self.type))
488 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
489 packed.append(struct.pack("!L", self.xid))
490 length = sum([len(x) for x in packed])
491 packed[2] = struct.pack("!H", length)
492 return ''.join(packed)
493
494 @staticmethod
495 def unpack(buf):
496 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
497 obj = barrier_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]498 if type(buf) == loxi.generic_util.OFReader:
499 reader = buf
500 else:
501 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]502 _version = reader.read("!B")[0]
503 assert(_version == 1)
504 _type = reader.read("!B")[0]
505 assert(_type == 18)
506 _length = reader.read("!H")[0]
507 obj.xid = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]508 return obj
509
510 def __eq__(self, other):
511 if type(self) != type(other): return False
512 if self.version != other.version: return False
513 if self.type != other.type: return False
514 if self.xid != other.xid: return False
515 return True
516
517 def __ne__(self, other):
518 return not self.__eq__(other)
519
520 def __str__(self):
521 return self.show()
522
523 def show(self):
524 import loxi.pp
525 return loxi.pp.pp(self)
526
527 def pretty_print(self, q):
528 q.text("barrier_request {")
529 with q.group():
530 with q.indent(2):
531 q.breakable()
532 q.text("xid = ");
533 if self.xid != None:
534 q.text("%#x" % self.xid)
535 else:
536 q.text('None')
537 q.breakable()
538 q.text('}')
539
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]540class bsn_bw_clear_data_reply(Message):
541 version = 1
542 type = 4
543 experimenter = 6035143
544 subtype = 22
545
546 def __init__(self, xid=None, status=None):
547 self.xid = xid
548 if status != None:
549 self.status = status
550 else:
551 self.status = 0
552
553 def pack(self):
554 packed = []
555 packed.append(struct.pack("!B", self.version))
556 packed.append(struct.pack("!B", self.type))
557 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
558 packed.append(struct.pack("!L", self.xid))
559 packed.append(struct.pack("!L", self.experimenter))
560 packed.append(struct.pack("!L", self.subtype))
561 packed.append(struct.pack("!L", self.status))
562 length = sum([len(x) for x in packed])
563 packed[2] = struct.pack("!H", length)
564 return ''.join(packed)
565
566 @staticmethod
567 def unpack(buf):
568 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
569 obj = bsn_bw_clear_data_reply()
570 if type(buf) == loxi.generic_util.OFReader:
571 reader = buf
572 else:
573 reader = loxi.generic_util.OFReader(buf)
574 _version = reader.read("!B")[0]
575 assert(_version == 1)
576 _type = reader.read("!B")[0]
577 assert(_type == 4)
578 _length = reader.read("!H")[0]
579 obj.xid = reader.read("!L")[0]
580 _experimenter = reader.read("!L")[0]
581 assert(_experimenter == 6035143)
582 _subtype = reader.read("!L")[0]
583 assert(_subtype == 22)
584 obj.status = reader.read("!L")[0]
585 return obj
586
587 def __eq__(self, other):
588 if type(self) != type(other): return False
589 if self.version != other.version: return False
590 if self.type != other.type: return False
591 if self.xid != other.xid: return False
592 if self.status != other.status: return False
593 return True
594
595 def __ne__(self, other):
596 return not self.__eq__(other)
597
598 def __str__(self):
599 return self.show()
600
601 def show(self):
602 import loxi.pp
603 return loxi.pp.pp(self)
604
605 def pretty_print(self, q):
606 q.text("bsn_bw_clear_data_reply {")
607 with q.group():
608 with q.indent(2):
609 q.breakable()
610 q.text("xid = ");
611 if self.xid != None:
612 q.text("%#x" % self.xid)
613 else:
614 q.text('None')
615 q.text(","); q.breakable()
616 q.text("status = ");
617 q.text("%#x" % self.status)
618 q.breakable()
619 q.text('}')
620
621class bsn_bw_clear_data_request(Message):
622 version = 1
623 type = 4
624 experimenter = 6035143
625 subtype = 21
626
627 def __init__(self, xid=None):
628 self.xid = xid
629
630 def pack(self):
631 packed = []
632 packed.append(struct.pack("!B", self.version))
633 packed.append(struct.pack("!B", self.type))
634 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
635 packed.append(struct.pack("!L", self.xid))
636 packed.append(struct.pack("!L", self.experimenter))
637 packed.append(struct.pack("!L", self.subtype))
638 length = sum([len(x) for x in packed])
639 packed[2] = struct.pack("!H", length)
640 return ''.join(packed)
641
642 @staticmethod
643 def unpack(buf):
644 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
645 obj = bsn_bw_clear_data_request()
646 if type(buf) == loxi.generic_util.OFReader:
647 reader = buf
648 else:
649 reader = loxi.generic_util.OFReader(buf)
650 _version = reader.read("!B")[0]
651 assert(_version == 1)
652 _type = reader.read("!B")[0]
653 assert(_type == 4)
654 _length = reader.read("!H")[0]
655 obj.xid = reader.read("!L")[0]
656 _experimenter = reader.read("!L")[0]
657 assert(_experimenter == 6035143)
658 _subtype = reader.read("!L")[0]
659 assert(_subtype == 21)
660 return obj
661
662 def __eq__(self, other):
663 if type(self) != type(other): return False
664 if self.version != other.version: return False
665 if self.type != other.type: return False
666 if self.xid != other.xid: return False
667 return True
668
669 def __ne__(self, other):
670 return not self.__eq__(other)
671
672 def __str__(self):
673 return self.show()
674
675 def show(self):
676 import loxi.pp
677 return loxi.pp.pp(self)
678
679 def pretty_print(self, q):
680 q.text("bsn_bw_clear_data_request {")
681 with q.group():
682 with q.indent(2):
683 q.breakable()
684 q.text("xid = ");
685 if self.xid != None:
686 q.text("%#x" % self.xid)
687 else:
688 q.text('None')
689 q.breakable()
690 q.text('}')
691
692class bsn_bw_enable_get_reply(Message):
693 version = 1
694 type = 4
695 experimenter = 6035143
696 subtype = 20
697
698 def __init__(self, xid=None, enabled=None):
699 self.xid = xid
700 if enabled != None:
701 self.enabled = enabled
702 else:
703 self.enabled = 0
704
705 def pack(self):
706 packed = []
707 packed.append(struct.pack("!B", self.version))
708 packed.append(struct.pack("!B", self.type))
709 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
710 packed.append(struct.pack("!L", self.xid))
711 packed.append(struct.pack("!L", self.experimenter))
712 packed.append(struct.pack("!L", self.subtype))
713 packed.append(struct.pack("!L", self.enabled))
714 length = sum([len(x) for x in packed])
715 packed[2] = struct.pack("!H", length)
716 return ''.join(packed)
717
718 @staticmethod
719 def unpack(buf):
720 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
721 obj = bsn_bw_enable_get_reply()
722 if type(buf) == loxi.generic_util.OFReader:
723 reader = buf
724 else:
725 reader = loxi.generic_util.OFReader(buf)
726 _version = reader.read("!B")[0]
727 assert(_version == 1)
728 _type = reader.read("!B")[0]
729 assert(_type == 4)
730 _length = reader.read("!H")[0]
731 obj.xid = reader.read("!L")[0]
732 _experimenter = reader.read("!L")[0]
733 assert(_experimenter == 6035143)
734 _subtype = reader.read("!L")[0]
735 assert(_subtype == 20)
736 obj.enabled = reader.read("!L")[0]
737 return obj
738
739 def __eq__(self, other):
740 if type(self) != type(other): return False
741 if self.version != other.version: return False
742 if self.type != other.type: return False
743 if self.xid != other.xid: return False
744 if self.enabled != other.enabled: return False
745 return True
746
747 def __ne__(self, other):
748 return not self.__eq__(other)
749
750 def __str__(self):
751 return self.show()
752
753 def show(self):
754 import loxi.pp
755 return loxi.pp.pp(self)
756
757 def pretty_print(self, q):
758 q.text("bsn_bw_enable_get_reply {")
759 with q.group():
760 with q.indent(2):
761 q.breakable()
762 q.text("xid = ");
763 if self.xid != None:
764 q.text("%#x" % self.xid)
765 else:
766 q.text('None')
767 q.text(","); q.breakable()
768 q.text("enabled = ");
769 q.text("%#x" % self.enabled)
770 q.breakable()
771 q.text('}')
772
773class bsn_bw_enable_get_request(Message):
774 version = 1
775 type = 4
776 experimenter = 6035143
777 subtype = 19
778
779 def __init__(self, xid=None):
780 self.xid = xid
781
782 def pack(self):
783 packed = []
784 packed.append(struct.pack("!B", self.version))
785 packed.append(struct.pack("!B", self.type))
786 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
787 packed.append(struct.pack("!L", self.xid))
788 packed.append(struct.pack("!L", self.experimenter))
789 packed.append(struct.pack("!L", self.subtype))
790 length = sum([len(x) for x in packed])
791 packed[2] = struct.pack("!H", length)
792 return ''.join(packed)
793
794 @staticmethod
795 def unpack(buf):
796 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
797 obj = bsn_bw_enable_get_request()
798 if type(buf) == loxi.generic_util.OFReader:
799 reader = buf
800 else:
801 reader = loxi.generic_util.OFReader(buf)
802 _version = reader.read("!B")[0]
803 assert(_version == 1)
804 _type = reader.read("!B")[0]
805 assert(_type == 4)
806 _length = reader.read("!H")[0]
807 obj.xid = reader.read("!L")[0]
808 _experimenter = reader.read("!L")[0]
809 assert(_experimenter == 6035143)
810 _subtype = reader.read("!L")[0]
811 assert(_subtype == 19)
812 return obj
813
814 def __eq__(self, other):
815 if type(self) != type(other): return False
816 if self.version != other.version: return False
817 if self.type != other.type: return False
818 if self.xid != other.xid: return False
819 return True
820
821 def __ne__(self, other):
822 return not self.__eq__(other)
823
824 def __str__(self):
825 return self.show()
826
827 def show(self):
828 import loxi.pp
829 return loxi.pp.pp(self)
830
831 def pretty_print(self, q):
832 q.text("bsn_bw_enable_get_request {")
833 with q.group():
834 with q.indent(2):
835 q.breakable()
836 q.text("xid = ");
837 if self.xid != None:
838 q.text("%#x" % self.xid)
839 else:
840 q.text('None')
841 q.breakable()
842 q.text('}')
843
844class bsn_bw_enable_set_reply(Message):
845 version = 1
846 type = 4
847 experimenter = 6035143
848 subtype = 23
849
850 def __init__(self, xid=None, enable=None, status=None):
851 self.xid = xid
852 if enable != None:
853 self.enable = enable
854 else:
855 self.enable = 0
856 if status != None:
857 self.status = status
858 else:
859 self.status = 0
860
861 def pack(self):
862 packed = []
863 packed.append(struct.pack("!B", self.version))
864 packed.append(struct.pack("!B", self.type))
865 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
866 packed.append(struct.pack("!L", self.xid))
867 packed.append(struct.pack("!L", self.experimenter))
868 packed.append(struct.pack("!L", self.subtype))
869 packed.append(struct.pack("!L", self.enable))
870 packed.append(struct.pack("!L", self.status))
871 length = sum([len(x) for x in packed])
872 packed[2] = struct.pack("!H", length)
873 return ''.join(packed)
874
875 @staticmethod
876 def unpack(buf):
877 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
878 obj = bsn_bw_enable_set_reply()
879 if type(buf) == loxi.generic_util.OFReader:
880 reader = buf
881 else:
882 reader = loxi.generic_util.OFReader(buf)
883 _version = reader.read("!B")[0]
884 assert(_version == 1)
885 _type = reader.read("!B")[0]
886 assert(_type == 4)
887 _length = reader.read("!H")[0]
888 obj.xid = reader.read("!L")[0]
889 _experimenter = reader.read("!L")[0]
890 assert(_experimenter == 6035143)
891 _subtype = reader.read("!L")[0]
892 assert(_subtype == 23)
893 obj.enable = reader.read("!L")[0]
894 obj.status = reader.read("!L")[0]
895 return obj
896
897 def __eq__(self, other):
898 if type(self) != type(other): return False
899 if self.version != other.version: return False
900 if self.type != other.type: return False
901 if self.xid != other.xid: return False
902 if self.enable != other.enable: return False
903 if self.status != other.status: return False
904 return True
905
906 def __ne__(self, other):
907 return not self.__eq__(other)
908
909 def __str__(self):
910 return self.show()
911
912 def show(self):
913 import loxi.pp
914 return loxi.pp.pp(self)
915
916 def pretty_print(self, q):
917 q.text("bsn_bw_enable_set_reply {")
918 with q.group():
919 with q.indent(2):
920 q.breakable()
921 q.text("xid = ");
922 if self.xid != None:
923 q.text("%#x" % self.xid)
924 else:
925 q.text('None')
926 q.text(","); q.breakable()
927 q.text("enable = ");
928 q.text("%#x" % self.enable)
929 q.text(","); q.breakable()
930 q.text("status = ");
931 q.text("%#x" % self.status)
932 q.breakable()
933 q.text('}')
934
935class bsn_bw_enable_set_request(Message):
936 version = 1
937 type = 4
938 experimenter = 6035143
939 subtype = 18
940
941 def __init__(self, xid=None, enable=None):
942 self.xid = xid
943 if enable != None:
944 self.enable = enable
945 else:
946 self.enable = 0
947
948 def pack(self):
949 packed = []
950 packed.append(struct.pack("!B", self.version))
951 packed.append(struct.pack("!B", self.type))
952 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
953 packed.append(struct.pack("!L", self.xid))
954 packed.append(struct.pack("!L", self.experimenter))
955 packed.append(struct.pack("!L", self.subtype))
956 packed.append(struct.pack("!L", self.enable))
957 length = sum([len(x) for x in packed])
958 packed[2] = struct.pack("!H", length)
959 return ''.join(packed)
960
961 @staticmethod
962 def unpack(buf):
963 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
964 obj = bsn_bw_enable_set_request()
965 if type(buf) == loxi.generic_util.OFReader:
966 reader = buf
967 else:
968 reader = loxi.generic_util.OFReader(buf)
969 _version = reader.read("!B")[0]
970 assert(_version == 1)
971 _type = reader.read("!B")[0]
972 assert(_type == 4)
973 _length = reader.read("!H")[0]
974 obj.xid = reader.read("!L")[0]
975 _experimenter = reader.read("!L")[0]
976 assert(_experimenter == 6035143)
977 _subtype = reader.read("!L")[0]
978 assert(_subtype == 18)
979 obj.enable = reader.read("!L")[0]
980 return obj
981
982 def __eq__(self, other):
983 if type(self) != type(other): return False
984 if self.version != other.version: return False
985 if self.type != other.type: return False
986 if self.xid != other.xid: return False
987 if self.enable != other.enable: return False
988 return True
989
990 def __ne__(self, other):
991 return not self.__eq__(other)
992
993 def __str__(self):
994 return self.show()
995
996 def show(self):
997 import loxi.pp
998 return loxi.pp.pp(self)
999
1000 def pretty_print(self, q):
1001 q.text("bsn_bw_enable_set_request {")
1002 with q.group():
1003 with q.indent(2):
1004 q.breakable()
1005 q.text("xid = ");
1006 if self.xid != None:
1007 q.text("%#x" % self.xid)
1008 else:
1009 q.text('None')
1010 q.text(","); q.breakable()
1011 q.text("enable = ");
1012 q.text("%#x" % self.enable)
1013 q.breakable()
1014 q.text('}')
1015
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1016class bsn_get_interfaces_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1017 version = 1
1018 type = 4
1019 experimenter = 6035143
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1020 subtype = 10
1021
1022 def __init__(self, xid=None, interfaces=None):
1023 self.xid = xid
1024 if interfaces != None:
1025 self.interfaces = interfaces
1026 else:
1027 self.interfaces = []
1028
1029 def pack(self):
1030 packed = []
1031 packed.append(struct.pack("!B", self.version))
1032 packed.append(struct.pack("!B", self.type))
1033 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1034 packed.append(struct.pack("!L", self.xid))
1035 packed.append(struct.pack("!L", self.experimenter))
1036 packed.append(struct.pack("!L", self.subtype))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1037 packed.append(util.pack_list(self.interfaces))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1038 length = sum([len(x) for x in packed])
1039 packed[2] = struct.pack("!H", length)
1040 return ''.join(packed)
1041
1042 @staticmethod
1043 def unpack(buf):
1044 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1045 obj = bsn_get_interfaces_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1046 if type(buf) == loxi.generic_util.OFReader:
1047 reader = buf
1048 else:
1049 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1050 _version = reader.read("!B")[0]
1051 assert(_version == 1)
1052 _type = reader.read("!B")[0]
1053 assert(_type == 4)
1054 _length = reader.read("!H")[0]
1055 obj.xid = reader.read("!L")[0]
1056 _experimenter = reader.read("!L")[0]
1057 assert(_experimenter == 6035143)
1058 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1059 assert(_subtype == 10)
1060 obj.interfaces = loxi.generic_util.unpack_list(reader, common.bsn_interface.unpack)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1061 return obj
1062
1063 def __eq__(self, other):
1064 if type(self) != type(other): return False
1065 if self.version != other.version: return False
1066 if self.type != other.type: return False
1067 if self.xid != other.xid: return False
1068 if self.interfaces != other.interfaces: return False
1069 return True
1070
1071 def __ne__(self, other):
1072 return not self.__eq__(other)
1073
1074 def __str__(self):
1075 return self.show()
1076
1077 def show(self):
1078 import loxi.pp
1079 return loxi.pp.pp(self)
1080
1081 def pretty_print(self, q):
1082 q.text("bsn_get_interfaces_reply {")
1083 with q.group():
1084 with q.indent(2):
1085 q.breakable()
1086 q.text("xid = ");
1087 if self.xid != None:
1088 q.text("%#x" % self.xid)
1089 else:
1090 q.text('None')
1091 q.text(","); q.breakable()
1092 q.text("interfaces = ");
1093 q.pp(self.interfaces)
1094 q.breakable()
1095 q.text('}')
1096
1097class bsn_get_interfaces_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1098 version = 1
1099 type = 4
1100 experimenter = 6035143
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1101 subtype = 9
1102
1103 def __init__(self, xid=None):
1104 self.xid = xid
1105
1106 def pack(self):
1107 packed = []
1108 packed.append(struct.pack("!B", self.version))
1109 packed.append(struct.pack("!B", self.type))
1110 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1111 packed.append(struct.pack("!L", self.xid))
1112 packed.append(struct.pack("!L", self.experimenter))
1113 packed.append(struct.pack("!L", self.subtype))
1114 length = sum([len(x) for x in packed])
1115 packed[2] = struct.pack("!H", length)
1116 return ''.join(packed)
1117
1118 @staticmethod
1119 def unpack(buf):
1120 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1121 obj = bsn_get_interfaces_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1122 if type(buf) == loxi.generic_util.OFReader:
1123 reader = buf
1124 else:
1125 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1126 _version = reader.read("!B")[0]
1127 assert(_version == 1)
1128 _type = reader.read("!B")[0]
1129 assert(_type == 4)
1130 _length = reader.read("!H")[0]
1131 obj.xid = reader.read("!L")[0]
1132 _experimenter = reader.read("!L")[0]
1133 assert(_experimenter == 6035143)
1134 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1135 assert(_subtype == 9)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1136 return obj
1137
1138 def __eq__(self, other):
1139 if type(self) != type(other): return False
1140 if self.version != other.version: return False
1141 if self.type != other.type: return False
1142 if self.xid != other.xid: return False
1143 return True
1144
1145 def __ne__(self, other):
1146 return not self.__eq__(other)
1147
1148 def __str__(self):
1149 return self.show()
1150
1151 def show(self):
1152 import loxi.pp
1153 return loxi.pp.pp(self)
1154
1155 def pretty_print(self, q):
1156 q.text("bsn_get_interfaces_request {")
1157 with q.group():
1158 with q.indent(2):
1159 q.breakable()
1160 q.text("xid = ");
1161 if self.xid != None:
1162 q.text("%#x" % self.xid)
1163 else:
1164 q.text('None')
1165 q.breakable()
1166 q.text('}')
1167
1168class bsn_get_ip_mask_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1169 version = 1
1170 type = 4
1171 experimenter = 6035143
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1172 subtype = 2
1173
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1174 def __init__(self, xid=None, index=None, mask=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1175 self.xid = xid
1176 if index != None:
1177 self.index = index
1178 else:
1179 self.index = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1180 if mask != None:
1181 self.mask = mask
1182 else:
1183 self.mask = 0
1184
1185 def pack(self):
1186 packed = []
1187 packed.append(struct.pack("!B", self.version))
1188 packed.append(struct.pack("!B", self.type))
1189 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1190 packed.append(struct.pack("!L", self.xid))
1191 packed.append(struct.pack("!L", self.experimenter))
1192 packed.append(struct.pack("!L", self.subtype))
1193 packed.append(struct.pack("!B", self.index))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1194 packed.append('\x00' * 3)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1195 packed.append(struct.pack("!L", self.mask))
1196 length = sum([len(x) for x in packed])
1197 packed[2] = struct.pack("!H", length)
1198 return ''.join(packed)
1199
1200 @staticmethod
1201 def unpack(buf):
1202 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1203 obj = bsn_get_ip_mask_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1204 if type(buf) == loxi.generic_util.OFReader:
1205 reader = buf
1206 else:
1207 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1208 _version = reader.read("!B")[0]
1209 assert(_version == 1)
1210 _type = reader.read("!B")[0]
1211 assert(_type == 4)
1212 _length = reader.read("!H")[0]
1213 obj.xid = reader.read("!L")[0]
1214 _experimenter = reader.read("!L")[0]
1215 assert(_experimenter == 6035143)
1216 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1217 assert(_subtype == 2)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1218 obj.index = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1219 reader.skip(3)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1220 obj.mask = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1221 return obj
1222
1223 def __eq__(self, other):
1224 if type(self) != type(other): return False
1225 if self.version != other.version: return False
1226 if self.type != other.type: return False
1227 if self.xid != other.xid: return False
1228 if self.index != other.index: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1229 if self.mask != other.mask: return False
1230 return True
1231
1232 def __ne__(self, other):
1233 return not self.__eq__(other)
1234
1235 def __str__(self):
1236 return self.show()
1237
1238 def show(self):
1239 import loxi.pp
1240 return loxi.pp.pp(self)
1241
1242 def pretty_print(self, q):
1243 q.text("bsn_get_ip_mask_reply {")
1244 with q.group():
1245 with q.indent(2):
1246 q.breakable()
1247 q.text("xid = ");
1248 if self.xid != None:
1249 q.text("%#x" % self.xid)
1250 else:
1251 q.text('None')
1252 q.text(","); q.breakable()
1253 q.text("index = ");
1254 q.text("%#x" % self.index)
1255 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1256 q.text("mask = ");
1257 q.text("%#x" % self.mask)
1258 q.breakable()
1259 q.text('}')
1260
1261class bsn_get_ip_mask_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1262 version = 1
1263 type = 4
1264 experimenter = 6035143
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1265 subtype = 1
1266
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1267 def __init__(self, xid=None, index=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1268 self.xid = xid
1269 if index != None:
1270 self.index = index
1271 else:
1272 self.index = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1273
1274 def pack(self):
1275 packed = []
1276 packed.append(struct.pack("!B", self.version))
1277 packed.append(struct.pack("!B", self.type))
1278 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1279 packed.append(struct.pack("!L", self.xid))
1280 packed.append(struct.pack("!L", self.experimenter))
1281 packed.append(struct.pack("!L", self.subtype))
1282 packed.append(struct.pack("!B", self.index))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1283 packed.append('\x00' * 7)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1284 length = sum([len(x) for x in packed])
1285 packed[2] = struct.pack("!H", length)
1286 return ''.join(packed)
1287
1288 @staticmethod
1289 def unpack(buf):
1290 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1291 obj = bsn_get_ip_mask_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1292 if type(buf) == loxi.generic_util.OFReader:
1293 reader = buf
1294 else:
1295 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1296 _version = reader.read("!B")[0]
1297 assert(_version == 1)
1298 _type = reader.read("!B")[0]
1299 assert(_type == 4)
1300 _length = reader.read("!H")[0]
1301 obj.xid = reader.read("!L")[0]
1302 _experimenter = reader.read("!L")[0]
1303 assert(_experimenter == 6035143)
1304 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1305 assert(_subtype == 1)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1306 obj.index = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1307 reader.skip(7)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1308 return obj
1309
1310 def __eq__(self, other):
1311 if type(self) != type(other): return False
1312 if self.version != other.version: return False
1313 if self.type != other.type: return False
1314 if self.xid != other.xid: return False
1315 if self.index != other.index: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1316 return True
1317
1318 def __ne__(self, other):
1319 return not self.__eq__(other)
1320
1321 def __str__(self):
1322 return self.show()
1323
1324 def show(self):
1325 import loxi.pp
1326 return loxi.pp.pp(self)
1327
1328 def pretty_print(self, q):
1329 q.text("bsn_get_ip_mask_request {")
1330 with q.group():
1331 with q.indent(2):
1332 q.breakable()
1333 q.text("xid = ");
1334 if self.xid != None:
1335 q.text("%#x" % self.xid)
1336 else:
1337 q.text('None')
1338 q.text(","); q.breakable()
1339 q.text("index = ");
1340 q.text("%#x" % self.index)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1341 q.breakable()
1342 q.text('}')
1343
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]1344class bsn_get_l2_table_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1345 version = 1
1346 type = 4
1347 experimenter = 6035143
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]1348 subtype = 14
1349
1350 def __init__(self, xid=None, l2_table_enable=None, l2_table_priority=None):
1351 self.xid = xid
1352 if l2_table_enable != None:
1353 self.l2_table_enable = l2_table_enable
1354 else:
1355 self.l2_table_enable = 0
1356 if l2_table_priority != None:
1357 self.l2_table_priority = l2_table_priority
1358 else:
1359 self.l2_table_priority = 0
1360
1361 def pack(self):
1362 packed = []
1363 packed.append(struct.pack("!B", self.version))
1364 packed.append(struct.pack("!B", self.type))
1365 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1366 packed.append(struct.pack("!L", self.xid))
1367 packed.append(struct.pack("!L", self.experimenter))
1368 packed.append(struct.pack("!L", self.subtype))
1369 packed.append(struct.pack("!B", self.l2_table_enable))
1370 packed.append('\x00' * 1)
1371 packed.append(struct.pack("!H", self.l2_table_priority))
1372 packed.append('\x00' * 4)
1373 length = sum([len(x) for x in packed])
1374 packed[2] = struct.pack("!H", length)
1375 return ''.join(packed)
1376
1377 @staticmethod
1378 def unpack(buf):
1379 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1380 obj = bsn_get_l2_table_reply()
1381 if type(buf) == loxi.generic_util.OFReader:
1382 reader = buf
1383 else:
1384 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1385 _version = reader.read("!B")[0]
1386 assert(_version == 1)
1387 _type = reader.read("!B")[0]
1388 assert(_type == 4)
1389 _length = reader.read("!H")[0]
1390 obj.xid = reader.read("!L")[0]
1391 _experimenter = reader.read("!L")[0]
1392 assert(_experimenter == 6035143)
1393 _subtype = reader.read("!L")[0]
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]1394 assert(_subtype == 14)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1395 obj.l2_table_enable = reader.read("!B")[0]
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]1396 reader.skip(1)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1397 obj.l2_table_priority = reader.read("!H")[0]
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]1398 reader.skip(4)
1399 return obj
1400
1401 def __eq__(self, other):
1402 if type(self) != type(other): return False
1403 if self.version != other.version: return False
1404 if self.type != other.type: return False
1405 if self.xid != other.xid: return False
1406 if self.l2_table_enable != other.l2_table_enable: return False
1407 if self.l2_table_priority != other.l2_table_priority: return False
1408 return True
1409
1410 def __ne__(self, other):
1411 return not self.__eq__(other)
1412
1413 def __str__(self):
1414 return self.show()
1415
1416 def show(self):
1417 import loxi.pp
1418 return loxi.pp.pp(self)
1419
1420 def pretty_print(self, q):
1421 q.text("bsn_get_l2_table_reply {")
1422 with q.group():
1423 with q.indent(2):
1424 q.breakable()
1425 q.text("xid = ");
1426 if self.xid != None:
1427 q.text("%#x" % self.xid)
1428 else:
1429 q.text('None')
1430 q.text(","); q.breakable()
1431 q.text("l2_table_enable = ");
1432 q.text("%#x" % self.l2_table_enable)
1433 q.text(","); q.breakable()
1434 q.text("l2_table_priority = ");
1435 q.text("%#x" % self.l2_table_priority)
1436 q.breakable()
1437 q.text('}')
1438
1439class bsn_get_l2_table_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1440 version = 1
1441 type = 4
1442 experimenter = 6035143
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]1443 subtype = 13
1444
1445 def __init__(self, xid=None):
1446 self.xid = xid
1447
1448 def pack(self):
1449 packed = []
1450 packed.append(struct.pack("!B", self.version))
1451 packed.append(struct.pack("!B", self.type))
1452 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1453 packed.append(struct.pack("!L", self.xid))
1454 packed.append(struct.pack("!L", self.experimenter))
1455 packed.append(struct.pack("!L", self.subtype))
1456 length = sum([len(x) for x in packed])
1457 packed[2] = struct.pack("!H", length)
1458 return ''.join(packed)
1459
1460 @staticmethod
1461 def unpack(buf):
1462 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1463 obj = bsn_get_l2_table_request()
1464 if type(buf) == loxi.generic_util.OFReader:
1465 reader = buf
1466 else:
1467 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1468 _version = reader.read("!B")[0]
1469 assert(_version == 1)
1470 _type = reader.read("!B")[0]
1471 assert(_type == 4)
1472 _length = reader.read("!H")[0]
1473 obj.xid = reader.read("!L")[0]
1474 _experimenter = reader.read("!L")[0]
1475 assert(_experimenter == 6035143)
1476 _subtype = reader.read("!L")[0]
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]1477 assert(_subtype == 13)
1478 return obj
1479
1480 def __eq__(self, other):
1481 if type(self) != type(other): return False
1482 if self.version != other.version: return False
1483 if self.type != other.type: return False
1484 if self.xid != other.xid: return False
1485 return True
1486
1487 def __ne__(self, other):
1488 return not self.__eq__(other)
1489
1490 def __str__(self):
1491 return self.show()
1492
1493 def show(self):
1494 import loxi.pp
1495 return loxi.pp.pp(self)
1496
1497 def pretty_print(self, q):
1498 q.text("bsn_get_l2_table_request {")
1499 with q.group():
1500 with q.indent(2):
1501 q.breakable()
1502 q.text("xid = ");
1503 if self.xid != None:
1504 q.text("%#x" % self.xid)
1505 else:
1506 q.text('None')
1507 q.breakable()
1508 q.text('}')
1509
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1510class bsn_get_mirroring_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1511 version = 1
1512 type = 4
1513 experimenter = 6035143
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1514 subtype = 5
1515
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1516 def __init__(self, xid=None, report_mirror_ports=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1517 self.xid = xid
1518 if report_mirror_ports != None:
1519 self.report_mirror_ports = report_mirror_ports
1520 else:
1521 self.report_mirror_ports = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1522
1523 def pack(self):
1524 packed = []
1525 packed.append(struct.pack("!B", self.version))
1526 packed.append(struct.pack("!B", self.type))
1527 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1528 packed.append(struct.pack("!L", self.xid))
1529 packed.append(struct.pack("!L", self.experimenter))
1530 packed.append(struct.pack("!L", self.subtype))
1531 packed.append(struct.pack("!B", self.report_mirror_ports))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1532 packed.append('\x00' * 3)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1533 length = sum([len(x) for x in packed])
1534 packed[2] = struct.pack("!H", length)
1535 return ''.join(packed)
1536
1537 @staticmethod
1538 def unpack(buf):
1539 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1540 obj = bsn_get_mirroring_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1541 if type(buf) == loxi.generic_util.OFReader:
1542 reader = buf
1543 else:
1544 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1545 _version = reader.read("!B")[0]
1546 assert(_version == 1)
1547 _type = reader.read("!B")[0]
1548 assert(_type == 4)
1549 _length = reader.read("!H")[0]
1550 obj.xid = reader.read("!L")[0]
1551 _experimenter = reader.read("!L")[0]
1552 assert(_experimenter == 6035143)
1553 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1554 assert(_subtype == 5)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1555 obj.report_mirror_ports = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1556 reader.skip(3)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1557 return obj
1558
1559 def __eq__(self, other):
1560 if type(self) != type(other): return False
1561 if self.version != other.version: return False
1562 if self.type != other.type: return False
1563 if self.xid != other.xid: return False
1564 if self.report_mirror_ports != other.report_mirror_ports: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1565 return True
1566
1567 def __ne__(self, other):
1568 return not self.__eq__(other)
1569
1570 def __str__(self):
1571 return self.show()
1572
1573 def show(self):
1574 import loxi.pp
1575 return loxi.pp.pp(self)
1576
1577 def pretty_print(self, q):
1578 q.text("bsn_get_mirroring_reply {")
1579 with q.group():
1580 with q.indent(2):
1581 q.breakable()
1582 q.text("xid = ");
1583 if self.xid != None:
1584 q.text("%#x" % self.xid)
1585 else:
1586 q.text('None')
1587 q.text(","); q.breakable()
1588 q.text("report_mirror_ports = ");
1589 q.text("%#x" % self.report_mirror_ports)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1590 q.breakable()
1591 q.text('}')
1592
1593class bsn_get_mirroring_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1594 version = 1
1595 type = 4
1596 experimenter = 6035143
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1597 subtype = 4
1598
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1599 def __init__(self, xid=None, report_mirror_ports=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1600 self.xid = xid
1601 if report_mirror_ports != None:
1602 self.report_mirror_ports = report_mirror_ports
1603 else:
1604 self.report_mirror_ports = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1605
1606 def pack(self):
1607 packed = []
1608 packed.append(struct.pack("!B", self.version))
1609 packed.append(struct.pack("!B", self.type))
1610 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1611 packed.append(struct.pack("!L", self.xid))
1612 packed.append(struct.pack("!L", self.experimenter))
1613 packed.append(struct.pack("!L", self.subtype))
1614 packed.append(struct.pack("!B", self.report_mirror_ports))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1615 packed.append('\x00' * 3)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1616 length = sum([len(x) for x in packed])
1617 packed[2] = struct.pack("!H", length)
1618 return ''.join(packed)
1619
1620 @staticmethod
1621 def unpack(buf):
1622 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1623 obj = bsn_get_mirroring_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1624 if type(buf) == loxi.generic_util.OFReader:
1625 reader = buf
1626 else:
1627 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1628 _version = reader.read("!B")[0]
1629 assert(_version == 1)
1630 _type = reader.read("!B")[0]
1631 assert(_type == 4)
1632 _length = reader.read("!H")[0]
1633 obj.xid = reader.read("!L")[0]
1634 _experimenter = reader.read("!L")[0]
1635 assert(_experimenter == 6035143)
1636 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1637 assert(_subtype == 4)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]1638 obj.report_mirror_ports = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]1639 reader.skip(3)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1640 return obj
1641
1642 def __eq__(self, other):
1643 if type(self) != type(other): return False
1644 if self.version != other.version: return False
1645 if self.type != other.type: return False
1646 if self.xid != other.xid: return False
1647 if self.report_mirror_ports != other.report_mirror_ports: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1648 return True
1649
1650 def __ne__(self, other):
1651 return not self.__eq__(other)
1652
1653 def __str__(self):
1654 return self.show()
1655
1656 def show(self):
1657 import loxi.pp
1658 return loxi.pp.pp(self)
1659
1660 def pretty_print(self, q):
1661 q.text("bsn_get_mirroring_request {")
1662 with q.group():
1663 with q.indent(2):
1664 q.breakable()
1665 q.text("xid = ");
1666 if self.xid != None:
1667 q.text("%#x" % self.xid)
1668 else:
1669 q.text('None')
1670 q.text(","); q.breakable()
1671 q.text("report_mirror_ports = ");
1672 q.text("%#x" % self.report_mirror_ports)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]1673 q.breakable()
1674 q.text('}')
1675
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]1676class bsn_hybrid_get_reply(Message):
1677 version = 1
1678 type = 4
1679 experimenter = 6035143
1680 subtype = 28
1681
1682 def __init__(self, xid=None, hybrid_enable=None, hybrid_version=None):
1683 self.xid = xid
1684 if hybrid_enable != None:
1685 self.hybrid_enable = hybrid_enable
1686 else:
1687 self.hybrid_enable = 0
1688 if hybrid_version != None:
1689 self.hybrid_version = hybrid_version
1690 else:
1691 self.hybrid_version = 0
1692
1693 def pack(self):
1694 packed = []
1695 packed.append(struct.pack("!B", self.version))
1696 packed.append(struct.pack("!B", self.type))
1697 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1698 packed.append(struct.pack("!L", self.xid))
1699 packed.append(struct.pack("!L", self.experimenter))
1700 packed.append(struct.pack("!L", self.subtype))
1701 packed.append(struct.pack("!B", self.hybrid_enable))
1702 packed.append('\x00' * 1)
1703 packed.append(struct.pack("!H", self.hybrid_version))
1704 packed.append('\x00' * 4)
1705 length = sum([len(x) for x in packed])
1706 packed[2] = struct.pack("!H", length)
1707 return ''.join(packed)
1708
1709 @staticmethod
1710 def unpack(buf):
1711 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1712 obj = bsn_hybrid_get_reply()
1713 if type(buf) == loxi.generic_util.OFReader:
1714 reader = buf
1715 else:
1716 reader = loxi.generic_util.OFReader(buf)
1717 _version = reader.read("!B")[0]
1718 assert(_version == 1)
1719 _type = reader.read("!B")[0]
1720 assert(_type == 4)
1721 _length = reader.read("!H")[0]
1722 obj.xid = reader.read("!L")[0]
1723 _experimenter = reader.read("!L")[0]
1724 assert(_experimenter == 6035143)
1725 _subtype = reader.read("!L")[0]
1726 assert(_subtype == 28)
1727 obj.hybrid_enable = reader.read("!B")[0]
1728 reader.skip(1)
1729 obj.hybrid_version = reader.read("!H")[0]
1730 reader.skip(4)
1731 return obj
1732
1733 def __eq__(self, other):
1734 if type(self) != type(other): return False
1735 if self.version != other.version: return False
1736 if self.type != other.type: return False
1737 if self.xid != other.xid: return False
1738 if self.hybrid_enable != other.hybrid_enable: return False
1739 if self.hybrid_version != other.hybrid_version: return False
1740 return True
1741
1742 def __ne__(self, other):
1743 return not self.__eq__(other)
1744
1745 def __str__(self):
1746 return self.show()
1747
1748 def show(self):
1749 import loxi.pp
1750 return loxi.pp.pp(self)
1751
1752 def pretty_print(self, q):
1753 q.text("bsn_hybrid_get_reply {")
1754 with q.group():
1755 with q.indent(2):
1756 q.breakable()
1757 q.text("xid = ");
1758 if self.xid != None:
1759 q.text("%#x" % self.xid)
1760 else:
1761 q.text('None')
1762 q.text(","); q.breakable()
1763 q.text("hybrid_enable = ");
1764 q.text("%#x" % self.hybrid_enable)
1765 q.text(","); q.breakable()
1766 q.text("hybrid_version = ");
1767 q.text("%#x" % self.hybrid_version)
1768 q.breakable()
1769 q.text('}')
1770
1771class bsn_hybrid_get_request(Message):
1772 version = 1
1773 type = 4
1774 experimenter = 6035143
1775 subtype = 27
1776
1777 def __init__(self, xid=None):
1778 self.xid = xid
1779
1780 def pack(self):
1781 packed = []
1782 packed.append(struct.pack("!B", self.version))
1783 packed.append(struct.pack("!B", self.type))
1784 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1785 packed.append(struct.pack("!L", self.xid))
1786 packed.append(struct.pack("!L", self.experimenter))
1787 packed.append(struct.pack("!L", self.subtype))
1788 length = sum([len(x) for x in packed])
1789 packed[2] = struct.pack("!H", length)
1790 return ''.join(packed)
1791
1792 @staticmethod
1793 def unpack(buf):
1794 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1795 obj = bsn_hybrid_get_request()
1796 if type(buf) == loxi.generic_util.OFReader:
1797 reader = buf
1798 else:
1799 reader = loxi.generic_util.OFReader(buf)
1800 _version = reader.read("!B")[0]
1801 assert(_version == 1)
1802 _type = reader.read("!B")[0]
1803 assert(_type == 4)
1804 _length = reader.read("!H")[0]
1805 obj.xid = reader.read("!L")[0]
1806 _experimenter = reader.read("!L")[0]
1807 assert(_experimenter == 6035143)
1808 _subtype = reader.read("!L")[0]
1809 assert(_subtype == 27)
1810 return obj
1811
1812 def __eq__(self, other):
1813 if type(self) != type(other): return False
1814 if self.version != other.version: return False
1815 if self.type != other.type: return False
1816 if self.xid != other.xid: return False
1817 return True
1818
1819 def __ne__(self, other):
1820 return not self.__eq__(other)
1821
1822 def __str__(self):
1823 return self.show()
1824
1825 def show(self):
1826 import loxi.pp
1827 return loxi.pp.pp(self)
1828
1829 def pretty_print(self, q):
1830 q.text("bsn_hybrid_get_request {")
1831 with q.group():
1832 with q.indent(2):
1833 q.breakable()
1834 q.text("xid = ");
1835 if self.xid != None:
1836 q.text("%#x" % self.xid)
1837 else:
1838 q.text('None')
1839 q.breakable()
1840 q.text('}')
1841
1842class bsn_pdu_rx_reply(Message):
1843 version = 1
1844 type = 4
1845 experimenter = 6035143
1846 subtype = 34
1847
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]1848 def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]1849 self.xid = xid
1850 if status != None:
1851 self.status = status
1852 else:
1853 self.status = 0
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]1854 if port_no != None:
1855 self.port_no = port_no
1856 else:
1857 self.port_no = 0
1858 if slot_num != None:
1859 self.slot_num = slot_num
1860 else:
1861 self.slot_num = 0
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]1862
1863 def pack(self):
1864 packed = []
1865 packed.append(struct.pack("!B", self.version))
1866 packed.append(struct.pack("!B", self.type))
1867 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1868 packed.append(struct.pack("!L", self.xid))
1869 packed.append(struct.pack("!L", self.experimenter))
1870 packed.append(struct.pack("!L", self.subtype))
1871 packed.append(struct.pack("!L", self.status))
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]1872 packed.append(util.pack_port_no(self.port_no))
1873 packed.append(struct.pack("!B", self.slot_num))
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]1874 length = sum([len(x) for x in packed])
1875 packed[2] = struct.pack("!H", length)
1876 return ''.join(packed)
1877
1878 @staticmethod
1879 def unpack(buf):
1880 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1881 obj = bsn_pdu_rx_reply()
1882 if type(buf) == loxi.generic_util.OFReader:
1883 reader = buf
1884 else:
1885 reader = loxi.generic_util.OFReader(buf)
1886 _version = reader.read("!B")[0]
1887 assert(_version == 1)
1888 _type = reader.read("!B")[0]
1889 assert(_type == 4)
1890 _length = reader.read("!H")[0]
1891 obj.xid = reader.read("!L")[0]
1892 _experimenter = reader.read("!L")[0]
1893 assert(_experimenter == 6035143)
1894 _subtype = reader.read("!L")[0]
1895 assert(_subtype == 34)
1896 obj.status = reader.read("!L")[0]
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]1897 obj.port_no = util.unpack_port_no(reader)
1898 obj.slot_num = reader.read("!B")[0]
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]1899 return obj
1900
1901 def __eq__(self, other):
1902 if type(self) != type(other): return False
1903 if self.version != other.version: return False
1904 if self.type != other.type: return False
1905 if self.xid != other.xid: return False
1906 if self.status != other.status: return False
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]1907 if self.port_no != other.port_no: return False
1908 if self.slot_num != other.slot_num: return False
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]1909 return True
1910
1911 def __ne__(self, other):
1912 return not self.__eq__(other)
1913
1914 def __str__(self):
1915 return self.show()
1916
1917 def show(self):
1918 import loxi.pp
1919 return loxi.pp.pp(self)
1920
1921 def pretty_print(self, q):
1922 q.text("bsn_pdu_rx_reply {")
1923 with q.group():
1924 with q.indent(2):
1925 q.breakable()
1926 q.text("xid = ");
1927 if self.xid != None:
1928 q.text("%#x" % self.xid)
1929 else:
1930 q.text('None')
1931 q.text(","); q.breakable()
1932 q.text("status = ");
1933 q.text("%#x" % self.status)
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]1934 q.text(","); q.breakable()
1935 q.text("port_no = ");
1936 q.text(util.pretty_port(self.port_no))
1937 q.text(","); q.breakable()
1938 q.text("slot_num = ");
1939 q.text("%#x" % self.slot_num)
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]1940 q.breakable()
1941 q.text('}')
1942
1943class bsn_pdu_rx_request(Message):
1944 version = 1
1945 type = 4
1946 experimenter = 6035143
1947 subtype = 33
1948
1949 def __init__(self, xid=None, timeout_ms=None, port_no=None, slot_num=None, data=None):
1950 self.xid = xid
1951 if timeout_ms != None:
1952 self.timeout_ms = timeout_ms
1953 else:
1954 self.timeout_ms = 0
1955 if port_no != None:
1956 self.port_no = port_no
1957 else:
1958 self.port_no = 0
1959 if slot_num != None:
1960 self.slot_num = slot_num
1961 else:
1962 self.slot_num = 0
1963 if data != None:
1964 self.data = data
1965 else:
1966 self.data = ''
1967
1968 def pack(self):
1969 packed = []
1970 packed.append(struct.pack("!B", self.version))
1971 packed.append(struct.pack("!B", self.type))
1972 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
1973 packed.append(struct.pack("!L", self.xid))
1974 packed.append(struct.pack("!L", self.experimenter))
1975 packed.append(struct.pack("!L", self.subtype))
1976 packed.append(struct.pack("!L", self.timeout_ms))
1977 packed.append(util.pack_port_no(self.port_no))
1978 packed.append(struct.pack("!B", self.slot_num))
1979 packed.append('\x00' * 3)
1980 packed.append(self.data)
1981 length = sum([len(x) for x in packed])
1982 packed[2] = struct.pack("!H", length)
1983 return ''.join(packed)
1984
1985 @staticmethod
1986 def unpack(buf):
1987 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
1988 obj = bsn_pdu_rx_request()
1989 if type(buf) == loxi.generic_util.OFReader:
1990 reader = buf
1991 else:
1992 reader = loxi.generic_util.OFReader(buf)
1993 _version = reader.read("!B")[0]
1994 assert(_version == 1)
1995 _type = reader.read("!B")[0]
1996 assert(_type == 4)
1997 _length = reader.read("!H")[0]
1998 obj.xid = reader.read("!L")[0]
1999 _experimenter = reader.read("!L")[0]
2000 assert(_experimenter == 6035143)
2001 _subtype = reader.read("!L")[0]
2002 assert(_subtype == 33)
2003 obj.timeout_ms = reader.read("!L")[0]
2004 obj.port_no = util.unpack_port_no(reader)
2005 obj.slot_num = reader.read("!B")[0]
2006 reader.skip(3)
2007 obj.data = str(reader.read_all())
2008 return obj
2009
2010 def __eq__(self, other):
2011 if type(self) != type(other): return False
2012 if self.version != other.version: return False
2013 if self.type != other.type: return False
2014 if self.xid != other.xid: return False
2015 if self.timeout_ms != other.timeout_ms: return False
2016 if self.port_no != other.port_no: return False
2017 if self.slot_num != other.slot_num: return False
2018 if self.data != other.data: return False
2019 return True
2020
2021 def __ne__(self, other):
2022 return not self.__eq__(other)
2023
2024 def __str__(self):
2025 return self.show()
2026
2027 def show(self):
2028 import loxi.pp
2029 return loxi.pp.pp(self)
2030
2031 def pretty_print(self, q):
2032 q.text("bsn_pdu_rx_request {")
2033 with q.group():
2034 with q.indent(2):
2035 q.breakable()
2036 q.text("xid = ");
2037 if self.xid != None:
2038 q.text("%#x" % self.xid)
2039 else:
2040 q.text('None')
2041 q.text(","); q.breakable()
2042 q.text("timeout_ms = ");
2043 q.text("%#x" % self.timeout_ms)
2044 q.text(","); q.breakable()
2045 q.text("port_no = ");
2046 q.text(util.pretty_port(self.port_no))
2047 q.text(","); q.breakable()
2048 q.text("slot_num = ");
2049 q.text("%#x" % self.slot_num)
2050 q.text(","); q.breakable()
2051 q.text("data = ");
2052 q.pp(self.data)
2053 q.breakable()
2054 q.text('}')
2055
2056class bsn_pdu_rx_timeout(Message):
2057 version = 1
2058 type = 4
2059 experimenter = 6035143
2060 subtype = 35
2061
2062 def __init__(self, xid=None, port_no=None, slot_num=None):
2063 self.xid = xid
2064 if port_no != None:
2065 self.port_no = port_no
2066 else:
2067 self.port_no = 0
2068 if slot_num != None:
2069 self.slot_num = slot_num
2070 else:
2071 self.slot_num = 0
2072
2073 def pack(self):
2074 packed = []
2075 packed.append(struct.pack("!B", self.version))
2076 packed.append(struct.pack("!B", self.type))
2077 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2078 packed.append(struct.pack("!L", self.xid))
2079 packed.append(struct.pack("!L", self.experimenter))
2080 packed.append(struct.pack("!L", self.subtype))
2081 packed.append(util.pack_port_no(self.port_no))
2082 packed.append(struct.pack("!B", self.slot_num))
2083 length = sum([len(x) for x in packed])
2084 packed[2] = struct.pack("!H", length)
2085 return ''.join(packed)
2086
2087 @staticmethod
2088 def unpack(buf):
2089 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
2090 obj = bsn_pdu_rx_timeout()
2091 if type(buf) == loxi.generic_util.OFReader:
2092 reader = buf
2093 else:
2094 reader = loxi.generic_util.OFReader(buf)
2095 _version = reader.read("!B")[0]
2096 assert(_version == 1)
2097 _type = reader.read("!B")[0]
2098 assert(_type == 4)
2099 _length = reader.read("!H")[0]
2100 obj.xid = reader.read("!L")[0]
2101 _experimenter = reader.read("!L")[0]
2102 assert(_experimenter == 6035143)
2103 _subtype = reader.read("!L")[0]
2104 assert(_subtype == 35)
2105 obj.port_no = util.unpack_port_no(reader)
2106 obj.slot_num = reader.read("!B")[0]
2107 return obj
2108
2109 def __eq__(self, other):
2110 if type(self) != type(other): return False
2111 if self.version != other.version: return False
2112 if self.type != other.type: return False
2113 if self.xid != other.xid: return False
2114 if self.port_no != other.port_no: return False
2115 if self.slot_num != other.slot_num: return False
2116 return True
2117
2118 def __ne__(self, other):
2119 return not self.__eq__(other)
2120
2121 def __str__(self):
2122 return self.show()
2123
2124 def show(self):
2125 import loxi.pp
2126 return loxi.pp.pp(self)
2127
2128 def pretty_print(self, q):
2129 q.text("bsn_pdu_rx_timeout {")
2130 with q.group():
2131 with q.indent(2):
2132 q.breakable()
2133 q.text("xid = ");
2134 if self.xid != None:
2135 q.text("%#x" % self.xid)
2136 else:
2137 q.text('None')
2138 q.text(","); q.breakable()
2139 q.text("port_no = ");
2140 q.text(util.pretty_port(self.port_no))
2141 q.text(","); q.breakable()
2142 q.text("slot_num = ");
2143 q.text("%#x" % self.slot_num)
2144 q.breakable()
2145 q.text('}')
2146
2147class bsn_pdu_tx_reply(Message):
2148 version = 1
2149 type = 4
2150 experimenter = 6035143
2151 subtype = 32
2152
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]2153 def __init__(self, xid=None, status=None, port_no=None, slot_num=None):
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]2154 self.xid = xid
2155 if status != None:
2156 self.status = status
2157 else:
2158 self.status = 0
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]2159 if port_no != None:
2160 self.port_no = port_no
2161 else:
2162 self.port_no = 0
2163 if slot_num != None:
2164 self.slot_num = slot_num
2165 else:
2166 self.slot_num = 0
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]2167
2168 def pack(self):
2169 packed = []
2170 packed.append(struct.pack("!B", self.version))
2171 packed.append(struct.pack("!B", self.type))
2172 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2173 packed.append(struct.pack("!L", self.xid))
2174 packed.append(struct.pack("!L", self.experimenter))
2175 packed.append(struct.pack("!L", self.subtype))
2176 packed.append(struct.pack("!L", self.status))
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]2177 packed.append(util.pack_port_no(self.port_no))
2178 packed.append(struct.pack("!B", self.slot_num))
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]2179 length = sum([len(x) for x in packed])
2180 packed[2] = struct.pack("!H", length)
2181 return ''.join(packed)
2182
2183 @staticmethod
2184 def unpack(buf):
2185 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
2186 obj = bsn_pdu_tx_reply()
2187 if type(buf) == loxi.generic_util.OFReader:
2188 reader = buf
2189 else:
2190 reader = loxi.generic_util.OFReader(buf)
2191 _version = reader.read("!B")[0]
2192 assert(_version == 1)
2193 _type = reader.read("!B")[0]
2194 assert(_type == 4)
2195 _length = reader.read("!H")[0]
2196 obj.xid = reader.read("!L")[0]
2197 _experimenter = reader.read("!L")[0]
2198 assert(_experimenter == 6035143)
2199 _subtype = reader.read("!L")[0]
2200 assert(_subtype == 32)
2201 obj.status = reader.read("!L")[0]
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]2202 obj.port_no = util.unpack_port_no(reader)
2203 obj.slot_num = reader.read("!B")[0]
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]2204 return obj
2205
2206 def __eq__(self, other):
2207 if type(self) != type(other): return False
2208 if self.version != other.version: return False
2209 if self.type != other.type: return False
2210 if self.xid != other.xid: return False
2211 if self.status != other.status: return False
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]2212 if self.port_no != other.port_no: return False
2213 if self.slot_num != other.slot_num: return False
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]2214 return True
2215
2216 def __ne__(self, other):
2217 return not self.__eq__(other)
2218
2219 def __str__(self):
2220 return self.show()
2221
2222 def show(self):
2223 import loxi.pp
2224 return loxi.pp.pp(self)
2225
2226 def pretty_print(self, q):
2227 q.text("bsn_pdu_tx_reply {")
2228 with q.group():
2229 with q.indent(2):
2230 q.breakable()
2231 q.text("xid = ");
2232 if self.xid != None:
2233 q.text("%#x" % self.xid)
2234 else:
2235 q.text('None')
2236 q.text(","); q.breakable()
2237 q.text("status = ");
2238 q.text("%#x" % self.status)
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]2239 q.text(","); q.breakable()
2240 q.text("port_no = ");
2241 q.text(util.pretty_port(self.port_no))
2242 q.text(","); q.breakable()
2243 q.text("slot_num = ");
2244 q.text("%#x" % self.slot_num)
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]2245 q.breakable()
2246 q.text('}')
2247
2248class bsn_pdu_tx_request(Message):
2249 version = 1
2250 type = 4
2251 experimenter = 6035143
2252 subtype = 31
2253
2254 def __init__(self, xid=None, tx_interval_ms=None, port_no=None, slot_num=None, data=None):
2255 self.xid = xid
2256 if tx_interval_ms != None:
2257 self.tx_interval_ms = tx_interval_ms
2258 else:
2259 self.tx_interval_ms = 0
2260 if port_no != None:
2261 self.port_no = port_no
2262 else:
2263 self.port_no = 0
2264 if slot_num != None:
2265 self.slot_num = slot_num
2266 else:
2267 self.slot_num = 0
2268 if data != None:
2269 self.data = data
2270 else:
2271 self.data = ''
2272
2273 def pack(self):
2274 packed = []
2275 packed.append(struct.pack("!B", self.version))
2276 packed.append(struct.pack("!B", self.type))
2277 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2278 packed.append(struct.pack("!L", self.xid))
2279 packed.append(struct.pack("!L", self.experimenter))
2280 packed.append(struct.pack("!L", self.subtype))
2281 packed.append(struct.pack("!L", self.tx_interval_ms))
2282 packed.append(util.pack_port_no(self.port_no))
2283 packed.append(struct.pack("!B", self.slot_num))
2284 packed.append('\x00' * 3)
2285 packed.append(self.data)
2286 length = sum([len(x) for x in packed])
2287 packed[2] = struct.pack("!H", length)
2288 return ''.join(packed)
2289
2290 @staticmethod
2291 def unpack(buf):
2292 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
2293 obj = bsn_pdu_tx_request()
2294 if type(buf) == loxi.generic_util.OFReader:
2295 reader = buf
2296 else:
2297 reader = loxi.generic_util.OFReader(buf)
2298 _version = reader.read("!B")[0]
2299 assert(_version == 1)
2300 _type = reader.read("!B")[0]
2301 assert(_type == 4)
2302 _length = reader.read("!H")[0]
2303 obj.xid = reader.read("!L")[0]
2304 _experimenter = reader.read("!L")[0]
2305 assert(_experimenter == 6035143)
2306 _subtype = reader.read("!L")[0]
2307 assert(_subtype == 31)
2308 obj.tx_interval_ms = reader.read("!L")[0]
2309 obj.port_no = util.unpack_port_no(reader)
2310 obj.slot_num = reader.read("!B")[0]
2311 reader.skip(3)
2312 obj.data = str(reader.read_all())
2313 return obj
2314
2315 def __eq__(self, other):
2316 if type(self) != type(other): return False
2317 if self.version != other.version: return False
2318 if self.type != other.type: return False
2319 if self.xid != other.xid: return False
2320 if self.tx_interval_ms != other.tx_interval_ms: return False
2321 if self.port_no != other.port_no: return False
2322 if self.slot_num != other.slot_num: return False
2323 if self.data != other.data: return False
2324 return True
2325
2326 def __ne__(self, other):
2327 return not self.__eq__(other)
2328
2329 def __str__(self):
2330 return self.show()
2331
2332 def show(self):
2333 import loxi.pp
2334 return loxi.pp.pp(self)
2335
2336 def pretty_print(self, q):
2337 q.text("bsn_pdu_tx_request {")
2338 with q.group():
2339 with q.indent(2):
2340 q.breakable()
2341 q.text("xid = ");
2342 if self.xid != None:
2343 q.text("%#x" % self.xid)
2344 else:
2345 q.text('None')
2346 q.text(","); q.breakable()
2347 q.text("tx_interval_ms = ");
2348 q.text("%#x" % self.tx_interval_ms)
2349 q.text(","); q.breakable()
2350 q.text("port_no = ");
2351 q.text(util.pretty_port(self.port_no))
2352 q.text(","); q.breakable()
2353 q.text("slot_num = ");
2354 q.text("%#x" % self.slot_num)
2355 q.text(","); q.breakable()
2356 q.text("data = ");
2357 q.pp(self.data)
2358 q.breakable()
2359 q.text('}')
2360
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2361class bsn_set_ip_mask(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2362 version = 1
2363 type = 4
2364 experimenter = 6035143
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2365 subtype = 0
2366
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2367 def __init__(self, xid=None, index=None, mask=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2368 self.xid = xid
2369 if index != None:
2370 self.index = index
2371 else:
2372 self.index = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2373 if mask != None:
2374 self.mask = mask
2375 else:
2376 self.mask = 0
2377
2378 def pack(self):
2379 packed = []
2380 packed.append(struct.pack("!B", self.version))
2381 packed.append(struct.pack("!B", self.type))
2382 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2383 packed.append(struct.pack("!L", self.xid))
2384 packed.append(struct.pack("!L", self.experimenter))
2385 packed.append(struct.pack("!L", self.subtype))
2386 packed.append(struct.pack("!B", self.index))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2387 packed.append('\x00' * 3)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2388 packed.append(struct.pack("!L", self.mask))
2389 length = sum([len(x) for x in packed])
2390 packed[2] = struct.pack("!H", length)
2391 return ''.join(packed)
2392
2393 @staticmethod
2394 def unpack(buf):
2395 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
2396 obj = bsn_set_ip_mask()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2397 if type(buf) == loxi.generic_util.OFReader:
2398 reader = buf
2399 else:
2400 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2401 _version = reader.read("!B")[0]
2402 assert(_version == 1)
2403 _type = reader.read("!B")[0]
2404 assert(_type == 4)
2405 _length = reader.read("!H")[0]
2406 obj.xid = reader.read("!L")[0]
2407 _experimenter = reader.read("!L")[0]
2408 assert(_experimenter == 6035143)
2409 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2410 assert(_subtype == 0)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2411 obj.index = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2412 reader.skip(3)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2413 obj.mask = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2414 return obj
2415
2416 def __eq__(self, other):
2417 if type(self) != type(other): return False
2418 if self.version != other.version: return False
2419 if self.type != other.type: return False
2420 if self.xid != other.xid: return False
2421 if self.index != other.index: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2422 if self.mask != other.mask: return False
2423 return True
2424
2425 def __ne__(self, other):
2426 return not self.__eq__(other)
2427
2428 def __str__(self):
2429 return self.show()
2430
2431 def show(self):
2432 import loxi.pp
2433 return loxi.pp.pp(self)
2434
2435 def pretty_print(self, q):
2436 q.text("bsn_set_ip_mask {")
2437 with q.group():
2438 with q.indent(2):
2439 q.breakable()
2440 q.text("xid = ");
2441 if self.xid != None:
2442 q.text("%#x" % self.xid)
2443 else:
2444 q.text('None')
2445 q.text(","); q.breakable()
2446 q.text("index = ");
2447 q.text("%#x" % self.index)
2448 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2449 q.text("mask = ");
2450 q.text("%#x" % self.mask)
2451 q.breakable()
2452 q.text('}')
2453
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2454class bsn_set_l2_table_reply(Message):
2455 version = 1
2456 type = 4
2457 experimenter = 6035143
2458 subtype = 24
2459
2460 def __init__(self, xid=None, l2_table_enable=None, l2_table_priority=None, status=None):
2461 self.xid = xid
2462 if l2_table_enable != None:
2463 self.l2_table_enable = l2_table_enable
2464 else:
2465 self.l2_table_enable = 0
2466 if l2_table_priority != None:
2467 self.l2_table_priority = l2_table_priority
2468 else:
2469 self.l2_table_priority = 0
2470 if status != None:
2471 self.status = status
2472 else:
2473 self.status = 0
2474
2475 def pack(self):
2476 packed = []
2477 packed.append(struct.pack("!B", self.version))
2478 packed.append(struct.pack("!B", self.type))
2479 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2480 packed.append(struct.pack("!L", self.xid))
2481 packed.append(struct.pack("!L", self.experimenter))
2482 packed.append(struct.pack("!L", self.subtype))
2483 packed.append(struct.pack("!B", self.l2_table_enable))
2484 packed.append('\x00' * 1)
2485 packed.append(struct.pack("!H", self.l2_table_priority))
2486 packed.append(struct.pack("!L", self.status))
2487 length = sum([len(x) for x in packed])
2488 packed[2] = struct.pack("!H", length)
2489 return ''.join(packed)
2490
2491 @staticmethod
2492 def unpack(buf):
2493 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
2494 obj = bsn_set_l2_table_reply()
2495 if type(buf) == loxi.generic_util.OFReader:
2496 reader = buf
2497 else:
2498 reader = loxi.generic_util.OFReader(buf)
2499 _version = reader.read("!B")[0]
2500 assert(_version == 1)
2501 _type = reader.read("!B")[0]
2502 assert(_type == 4)
2503 _length = reader.read("!H")[0]
2504 obj.xid = reader.read("!L")[0]
2505 _experimenter = reader.read("!L")[0]
2506 assert(_experimenter == 6035143)
2507 _subtype = reader.read("!L")[0]
2508 assert(_subtype == 24)
2509 obj.l2_table_enable = reader.read("!B")[0]
2510 reader.skip(1)
2511 obj.l2_table_priority = reader.read("!H")[0]
2512 obj.status = reader.read("!L")[0]
2513 return obj
2514
2515 def __eq__(self, other):
2516 if type(self) != type(other): return False
2517 if self.version != other.version: return False
2518 if self.type != other.type: return False
2519 if self.xid != other.xid: return False
2520 if self.l2_table_enable != other.l2_table_enable: return False
2521 if self.l2_table_priority != other.l2_table_priority: return False
2522 if self.status != other.status: return False
2523 return True
2524
2525 def __ne__(self, other):
2526 return not self.__eq__(other)
2527
2528 def __str__(self):
2529 return self.show()
2530
2531 def show(self):
2532 import loxi.pp
2533 return loxi.pp.pp(self)
2534
2535 def pretty_print(self, q):
2536 q.text("bsn_set_l2_table_reply {")
2537 with q.group():
2538 with q.indent(2):
2539 q.breakable()
2540 q.text("xid = ");
2541 if self.xid != None:
2542 q.text("%#x" % self.xid)
2543 else:
2544 q.text('None')
2545 q.text(","); q.breakable()
2546 q.text("l2_table_enable = ");
2547 q.text("%#x" % self.l2_table_enable)
2548 q.text(","); q.breakable()
2549 q.text("l2_table_priority = ");
2550 q.text("%#x" % self.l2_table_priority)
2551 q.text(","); q.breakable()
2552 q.text("status = ");
2553 q.text("%#x" % self.status)
2554 q.breakable()
2555 q.text('}')
2556
2557class bsn_set_l2_table_request(Message):
2558 version = 1
2559 type = 4
2560 experimenter = 6035143
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]2561 subtype = 12
2562
2563 def __init__(self, xid=None, l2_table_enable=None, l2_table_priority=None):
2564 self.xid = xid
2565 if l2_table_enable != None:
2566 self.l2_table_enable = l2_table_enable
2567 else:
2568 self.l2_table_enable = 0
2569 if l2_table_priority != None:
2570 self.l2_table_priority = l2_table_priority
2571 else:
2572 self.l2_table_priority = 0
2573
2574 def pack(self):
2575 packed = []
2576 packed.append(struct.pack("!B", self.version))
2577 packed.append(struct.pack("!B", self.type))
2578 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2579 packed.append(struct.pack("!L", self.xid))
2580 packed.append(struct.pack("!L", self.experimenter))
2581 packed.append(struct.pack("!L", self.subtype))
2582 packed.append(struct.pack("!B", self.l2_table_enable))
2583 packed.append('\x00' * 1)
2584 packed.append(struct.pack("!H", self.l2_table_priority))
2585 packed.append('\x00' * 4)
2586 length = sum([len(x) for x in packed])
2587 packed[2] = struct.pack("!H", length)
2588 return ''.join(packed)
2589
2590 @staticmethod
2591 def unpack(buf):
2592 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2593 obj = bsn_set_l2_table_request()
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]2594 if type(buf) == loxi.generic_util.OFReader:
2595 reader = buf
2596 else:
2597 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2598 _version = reader.read("!B")[0]
2599 assert(_version == 1)
2600 _type = reader.read("!B")[0]
2601 assert(_type == 4)
2602 _length = reader.read("!H")[0]
2603 obj.xid = reader.read("!L")[0]
2604 _experimenter = reader.read("!L")[0]
2605 assert(_experimenter == 6035143)
2606 _subtype = reader.read("!L")[0]
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]2607 assert(_subtype == 12)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2608 obj.l2_table_enable = reader.read("!B")[0]
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]2609 reader.skip(1)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2610 obj.l2_table_priority = reader.read("!H")[0]
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]2611 reader.skip(4)
2612 return obj
2613
2614 def __eq__(self, other):
2615 if type(self) != type(other): return False
2616 if self.version != other.version: return False
2617 if self.type != other.type: return False
2618 if self.xid != other.xid: return False
2619 if self.l2_table_enable != other.l2_table_enable: return False
2620 if self.l2_table_priority != other.l2_table_priority: return False
2621 return True
2622
2623 def __ne__(self, other):
2624 return not self.__eq__(other)
2625
2626 def __str__(self):
2627 return self.show()
2628
2629 def show(self):
2630 import loxi.pp
2631 return loxi.pp.pp(self)
2632
2633 def pretty_print(self, q):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2634 q.text("bsn_set_l2_table_request {")
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]2635 with q.group():
2636 with q.indent(2):
2637 q.breakable()
2638 q.text("xid = ");
2639 if self.xid != None:
2640 q.text("%#x" % self.xid)
2641 else:
2642 q.text('None')
2643 q.text(","); q.breakable()
2644 q.text("l2_table_enable = ");
2645 q.text("%#x" % self.l2_table_enable)
2646 q.text(","); q.breakable()
2647 q.text("l2_table_priority = ");
2648 q.text("%#x" % self.l2_table_priority)
2649 q.breakable()
2650 q.text('}')
2651
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2652class bsn_set_mirroring(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2653 version = 1
2654 type = 4
2655 experimenter = 6035143
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2656 subtype = 3
2657
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2658 def __init__(self, xid=None, report_mirror_ports=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2659 self.xid = xid
2660 if report_mirror_ports != None:
2661 self.report_mirror_ports = report_mirror_ports
2662 else:
2663 self.report_mirror_ports = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2664
2665 def pack(self):
2666 packed = []
2667 packed.append(struct.pack("!B", self.version))
2668 packed.append(struct.pack("!B", self.type))
2669 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2670 packed.append(struct.pack("!L", self.xid))
2671 packed.append(struct.pack("!L", self.experimenter))
2672 packed.append(struct.pack("!L", self.subtype))
2673 packed.append(struct.pack("!B", self.report_mirror_ports))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2674 packed.append('\x00' * 3)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2675 length = sum([len(x) for x in packed])
2676 packed[2] = struct.pack("!H", length)
2677 return ''.join(packed)
2678
2679 @staticmethod
2680 def unpack(buf):
2681 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
2682 obj = bsn_set_mirroring()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2683 if type(buf) == loxi.generic_util.OFReader:
2684 reader = buf
2685 else:
2686 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2687 _version = reader.read("!B")[0]
2688 assert(_version == 1)
2689 _type = reader.read("!B")[0]
2690 assert(_type == 4)
2691 _length = reader.read("!H")[0]
2692 obj.xid = reader.read("!L")[0]
2693 _experimenter = reader.read("!L")[0]
2694 assert(_experimenter == 6035143)
2695 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2696 assert(_subtype == 3)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2697 obj.report_mirror_ports = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2698 reader.skip(3)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2699 return obj
2700
2701 def __eq__(self, other):
2702 if type(self) != type(other): return False
2703 if self.version != other.version: return False
2704 if self.type != other.type: return False
2705 if self.xid != other.xid: return False
2706 if self.report_mirror_ports != other.report_mirror_ports: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2707 return True
2708
2709 def __ne__(self, other):
2710 return not self.__eq__(other)
2711
2712 def __str__(self):
2713 return self.show()
2714
2715 def show(self):
2716 import loxi.pp
2717 return loxi.pp.pp(self)
2718
2719 def pretty_print(self, q):
2720 q.text("bsn_set_mirroring {")
2721 with q.group():
2722 with q.indent(2):
2723 q.breakable()
2724 q.text("xid = ");
2725 if self.xid != None:
2726 q.text("%#x" % self.xid)
2727 else:
2728 q.text('None')
2729 q.text(","); q.breakable()
2730 q.text("report_mirror_ports = ");
2731 q.text("%#x" % self.report_mirror_ports)
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2732 q.breakable()
2733 q.text('}')
2734
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2735class bsn_set_pktin_suppression_reply(Message):
2736 version = 1
2737 type = 4
2738 experimenter = 6035143
2739 subtype = 25
2740
2741 def __init__(self, xid=None, status=None):
2742 self.xid = xid
2743 if status != None:
2744 self.status = status
2745 else:
2746 self.status = 0
2747
2748 def pack(self):
2749 packed = []
2750 packed.append(struct.pack("!B", self.version))
2751 packed.append(struct.pack("!B", self.type))
2752 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2753 packed.append(struct.pack("!L", self.xid))
2754 packed.append(struct.pack("!L", self.experimenter))
2755 packed.append(struct.pack("!L", self.subtype))
2756 packed.append(struct.pack("!L", self.status))
2757 length = sum([len(x) for x in packed])
2758 packed[2] = struct.pack("!H", length)
2759 return ''.join(packed)
2760
2761 @staticmethod
2762 def unpack(buf):
2763 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
2764 obj = bsn_set_pktin_suppression_reply()
2765 if type(buf) == loxi.generic_util.OFReader:
2766 reader = buf
2767 else:
2768 reader = loxi.generic_util.OFReader(buf)
2769 _version = reader.read("!B")[0]
2770 assert(_version == 1)
2771 _type = reader.read("!B")[0]
2772 assert(_type == 4)
2773 _length = reader.read("!H")[0]
2774 obj.xid = reader.read("!L")[0]
2775 _experimenter = reader.read("!L")[0]
2776 assert(_experimenter == 6035143)
2777 _subtype = reader.read("!L")[0]
2778 assert(_subtype == 25)
2779 obj.status = reader.read("!L")[0]
2780 return obj
2781
2782 def __eq__(self, other):
2783 if type(self) != type(other): return False
2784 if self.version != other.version: return False
2785 if self.type != other.type: return False
2786 if self.xid != other.xid: return False
2787 if self.status != other.status: return False
2788 return True
2789
2790 def __ne__(self, other):
2791 return not self.__eq__(other)
2792
2793 def __str__(self):
2794 return self.show()
2795
2796 def show(self):
2797 import loxi.pp
2798 return loxi.pp.pp(self)
2799
2800 def pretty_print(self, q):
2801 q.text("bsn_set_pktin_suppression_reply {")
2802 with q.group():
2803 with q.indent(2):
2804 q.breakable()
2805 q.text("xid = ");
2806 if self.xid != None:
2807 q.text("%#x" % self.xid)
2808 else:
2809 q.text('None')
2810 q.text(","); q.breakable()
2811 q.text("status = ");
2812 q.text("%#x" % self.status)
2813 q.breakable()
2814 q.text('}')
2815
2816class bsn_set_pktin_suppression_request(Message):
2817 version = 1
2818 type = 4
2819 experimenter = 6035143
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2820 subtype = 11
2821
2822 def __init__(self, xid=None, enabled=None, idle_timeout=None, hard_timeout=None, priority=None, cookie=None):
2823 self.xid = xid
2824 if enabled != None:
2825 self.enabled = enabled
2826 else:
2827 self.enabled = 0
2828 if idle_timeout != None:
2829 self.idle_timeout = idle_timeout
2830 else:
2831 self.idle_timeout = 0
2832 if hard_timeout != None:
2833 self.hard_timeout = hard_timeout
2834 else:
2835 self.hard_timeout = 0
2836 if priority != None:
2837 self.priority = priority
2838 else:
2839 self.priority = 0
2840 if cookie != None:
2841 self.cookie = cookie
2842 else:
2843 self.cookie = 0
2844
2845 def pack(self):
2846 packed = []
2847 packed.append(struct.pack("!B", self.version))
2848 packed.append(struct.pack("!B", self.type))
2849 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2850 packed.append(struct.pack("!L", self.xid))
2851 packed.append(struct.pack("!L", self.experimenter))
2852 packed.append(struct.pack("!L", self.subtype))
2853 packed.append(struct.pack("!B", self.enabled))
2854 packed.append('\x00' * 1)
2855 packed.append(struct.pack("!H", self.idle_timeout))
2856 packed.append(struct.pack("!H", self.hard_timeout))
2857 packed.append(struct.pack("!H", self.priority))
2858 packed.append(struct.pack("!Q", self.cookie))
2859 length = sum([len(x) for x in packed])
2860 packed[2] = struct.pack("!H", length)
2861 return ''.join(packed)
2862
2863 @staticmethod
2864 def unpack(buf):
2865 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2866 obj = bsn_set_pktin_suppression_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2867 if type(buf) == loxi.generic_util.OFReader:
2868 reader = buf
2869 else:
2870 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2871 _version = reader.read("!B")[0]
2872 assert(_version == 1)
2873 _type = reader.read("!B")[0]
2874 assert(_type == 4)
2875 _length = reader.read("!H")[0]
2876 obj.xid = reader.read("!L")[0]
2877 _experimenter = reader.read("!L")[0]
2878 assert(_experimenter == 6035143)
2879 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2880 assert(_subtype == 11)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2881 obj.enabled = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2882 reader.skip(1)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2883 obj.idle_timeout = reader.read("!H")[0]
2884 obj.hard_timeout = reader.read("!H")[0]
2885 obj.priority = reader.read("!H")[0]
2886 obj.cookie = reader.read("!Q")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2887 return obj
2888
2889 def __eq__(self, other):
2890 if type(self) != type(other): return False
2891 if self.version != other.version: return False
2892 if self.type != other.type: return False
2893 if self.xid != other.xid: return False
2894 if self.enabled != other.enabled: return False
2895 if self.idle_timeout != other.idle_timeout: return False
2896 if self.hard_timeout != other.hard_timeout: return False
2897 if self.priority != other.priority: return False
2898 if self.cookie != other.cookie: return False
2899 return True
2900
2901 def __ne__(self, other):
2902 return not self.__eq__(other)
2903
2904 def __str__(self):
2905 return self.show()
2906
2907 def show(self):
2908 import loxi.pp
2909 return loxi.pp.pp(self)
2910
2911 def pretty_print(self, q):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2912 q.text("bsn_set_pktin_suppression_request {")
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2913 with q.group():
2914 with q.indent(2):
2915 q.breakable()
2916 q.text("xid = ");
2917 if self.xid != None:
2918 q.text("%#x" % self.xid)
2919 else:
2920 q.text('None')
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2921 q.text(","); q.breakable()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2922 q.text("enabled = ");
2923 q.text("%#x" % self.enabled)
2924 q.text(","); q.breakable()
2925 q.text("idle_timeout = ");
2926 q.text("%#x" % self.idle_timeout)
2927 q.text(","); q.breakable()
2928 q.text("hard_timeout = ");
2929 q.text("%#x" % self.hard_timeout)
2930 q.text(","); q.breakable()
2931 q.text("priority = ");
2932 q.text("%#x" % self.priority)
2933 q.text(","); q.breakable()
2934 q.text("cookie = ");
2935 q.text("%#x" % self.cookie)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2936 q.breakable()
2937 q.text('}')
2938
2939class bsn_shell_command(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2940 version = 1
2941 type = 4
2942 experimenter = 6035143
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2943 subtype = 6
2944
2945 def __init__(self, xid=None, service=None, data=None):
2946 self.xid = xid
2947 if service != None:
2948 self.service = service
2949 else:
2950 self.service = 0
2951 if data != None:
2952 self.data = data
2953 else:
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2954 self.data = ''
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2955
2956 def pack(self):
2957 packed = []
2958 packed.append(struct.pack("!B", self.version))
2959 packed.append(struct.pack("!B", self.type))
2960 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
2961 packed.append(struct.pack("!L", self.xid))
2962 packed.append(struct.pack("!L", self.experimenter))
2963 packed.append(struct.pack("!L", self.subtype))
2964 packed.append(struct.pack("!L", self.service))
2965 packed.append(self.data)
2966 length = sum([len(x) for x in packed])
2967 packed[2] = struct.pack("!H", length)
2968 return ''.join(packed)
2969
2970 @staticmethod
2971 def unpack(buf):
2972 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
2973 obj = bsn_shell_command()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2974 if type(buf) == loxi.generic_util.OFReader:
2975 reader = buf
2976 else:
2977 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2978 _version = reader.read("!B")[0]
2979 assert(_version == 1)
2980 _type = reader.read("!B")[0]
2981 assert(_type == 4)
2982 _length = reader.read("!H")[0]
2983 obj.xid = reader.read("!L")[0]
2984 _experimenter = reader.read("!L")[0]
2985 assert(_experimenter == 6035143)
2986 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2987 assert(_subtype == 6)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]2988 obj.service = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]2989 obj.data = str(reader.read_all())
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]2990 return obj
2991
2992 def __eq__(self, other):
2993 if type(self) != type(other): return False
2994 if self.version != other.version: return False
2995 if self.type != other.type: return False
2996 if self.xid != other.xid: return False
2997 if self.service != other.service: return False
2998 if self.data != other.data: return False
2999 return True
3000
3001 def __ne__(self, other):
3002 return not self.__eq__(other)
3003
3004 def __str__(self):
3005 return self.show()
3006
3007 def show(self):
3008 import loxi.pp
3009 return loxi.pp.pp(self)
3010
3011 def pretty_print(self, q):
3012 q.text("bsn_shell_command {")
3013 with q.group():
3014 with q.indent(2):
3015 q.breakable()
3016 q.text("xid = ");
3017 if self.xid != None:
3018 q.text("%#x" % self.xid)
3019 else:
3020 q.text('None')
3021 q.text(","); q.breakable()
3022 q.text("service = ");
3023 q.text("%#x" % self.service)
3024 q.text(","); q.breakable()
3025 q.text("data = ");
3026 q.pp(self.data)
3027 q.breakable()
3028 q.text('}')
3029
3030class bsn_shell_output(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3031 version = 1
3032 type = 4
3033 experimenter = 6035143
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3034 subtype = 7
3035
3036 def __init__(self, xid=None, data=None):
3037 self.xid = xid
3038 if data != None:
3039 self.data = data
3040 else:
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3041 self.data = ''
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3042
3043 def pack(self):
3044 packed = []
3045 packed.append(struct.pack("!B", self.version))
3046 packed.append(struct.pack("!B", self.type))
3047 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3048 packed.append(struct.pack("!L", self.xid))
3049 packed.append(struct.pack("!L", self.experimenter))
3050 packed.append(struct.pack("!L", self.subtype))
3051 packed.append(self.data)
3052 length = sum([len(x) for x in packed])
3053 packed[2] = struct.pack("!H", length)
3054 return ''.join(packed)
3055
3056 @staticmethod
3057 def unpack(buf):
3058 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
3059 obj = bsn_shell_output()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3060 if type(buf) == loxi.generic_util.OFReader:
3061 reader = buf
3062 else:
3063 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3064 _version = reader.read("!B")[0]
3065 assert(_version == 1)
3066 _type = reader.read("!B")[0]
3067 assert(_type == 4)
3068 _length = reader.read("!H")[0]
3069 obj.xid = reader.read("!L")[0]
3070 _experimenter = reader.read("!L")[0]
3071 assert(_experimenter == 6035143)
3072 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3073 assert(_subtype == 7)
3074 obj.data = str(reader.read_all())
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3075 return obj
3076
3077 def __eq__(self, other):
3078 if type(self) != type(other): return False
3079 if self.version != other.version: return False
3080 if self.type != other.type: return False
3081 if self.xid != other.xid: return False
3082 if self.data != other.data: return False
3083 return True
3084
3085 def __ne__(self, other):
3086 return not self.__eq__(other)
3087
3088 def __str__(self):
3089 return self.show()
3090
3091 def show(self):
3092 import loxi.pp
3093 return loxi.pp.pp(self)
3094
3095 def pretty_print(self, q):
3096 q.text("bsn_shell_output {")
3097 with q.group():
3098 with q.indent(2):
3099 q.breakable()
3100 q.text("xid = ");
3101 if self.xid != None:
3102 q.text("%#x" % self.xid)
3103 else:
3104 q.text('None')
3105 q.text(","); q.breakable()
3106 q.text("data = ");
3107 q.pp(self.data)
3108 q.breakable()
3109 q.text('}')
3110
3111class bsn_shell_status(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3112 version = 1
3113 type = 4
3114 experimenter = 6035143
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3115 subtype = 8
3116
3117 def __init__(self, xid=None, status=None):
3118 self.xid = xid
3119 if status != None:
3120 self.status = status
3121 else:
3122 self.status = 0
3123
3124 def pack(self):
3125 packed = []
3126 packed.append(struct.pack("!B", self.version))
3127 packed.append(struct.pack("!B", self.type))
3128 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3129 packed.append(struct.pack("!L", self.xid))
3130 packed.append(struct.pack("!L", self.experimenter))
3131 packed.append(struct.pack("!L", self.subtype))
3132 packed.append(struct.pack("!L", self.status))
3133 length = sum([len(x) for x in packed])
3134 packed[2] = struct.pack("!H", length)
3135 return ''.join(packed)
3136
3137 @staticmethod
3138 def unpack(buf):
3139 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
3140 obj = bsn_shell_status()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3141 if type(buf) == loxi.generic_util.OFReader:
3142 reader = buf
3143 else:
3144 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3145 _version = reader.read("!B")[0]
3146 assert(_version == 1)
3147 _type = reader.read("!B")[0]
3148 assert(_type == 4)
3149 _length = reader.read("!H")[0]
3150 obj.xid = reader.read("!L")[0]
3151 _experimenter = reader.read("!L")[0]
3152 assert(_experimenter == 6035143)
3153 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3154 assert(_subtype == 8)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3155 obj.status = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3156 return obj
3157
3158 def __eq__(self, other):
3159 if type(self) != type(other): return False
3160 if self.version != other.version: return False
3161 if self.type != other.type: return False
3162 if self.xid != other.xid: return False
3163 if self.status != other.status: return False
3164 return True
3165
3166 def __ne__(self, other):
3167 return not self.__eq__(other)
3168
3169 def __str__(self):
3170 return self.show()
3171
3172 def show(self):
3173 import loxi.pp
3174 return loxi.pp.pp(self)
3175
3176 def pretty_print(self, q):
3177 q.text("bsn_shell_status {")
3178 with q.group():
3179 with q.indent(2):
3180 q.breakable()
3181 q.text("xid = ");
3182 if self.xid != None:
3183 q.text("%#x" % self.xid)
3184 else:
3185 q.text('None')
3186 q.text(","); q.breakable()
3187 q.text("status = ");
3188 q.text("%#x" % self.status)
3189 q.breakable()
3190 q.text('}')
3191
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3192class bsn_virtual_port_create_reply(Message):
3193 version = 1
3194 type = 4
3195 experimenter = 6035143
3196 subtype = 16
3197
3198 def __init__(self, xid=None, status=None, vport_no=None):
3199 self.xid = xid
3200 if status != None:
3201 self.status = status
3202 else:
3203 self.status = 0
3204 if vport_no != None:
3205 self.vport_no = vport_no
3206 else:
3207 self.vport_no = 0
3208
3209 def pack(self):
3210 packed = []
3211 packed.append(struct.pack("!B", self.version))
3212 packed.append(struct.pack("!B", self.type))
3213 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3214 packed.append(struct.pack("!L", self.xid))
3215 packed.append(struct.pack("!L", self.experimenter))
3216 packed.append(struct.pack("!L", self.subtype))
3217 packed.append(struct.pack("!L", self.status))
3218 packed.append(struct.pack("!L", self.vport_no))
3219 length = sum([len(x) for x in packed])
3220 packed[2] = struct.pack("!H", length)
3221 return ''.join(packed)
3222
3223 @staticmethod
3224 def unpack(buf):
3225 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
3226 obj = bsn_virtual_port_create_reply()
3227 if type(buf) == loxi.generic_util.OFReader:
3228 reader = buf
3229 else:
3230 reader = loxi.generic_util.OFReader(buf)
3231 _version = reader.read("!B")[0]
3232 assert(_version == 1)
3233 _type = reader.read("!B")[0]
3234 assert(_type == 4)
3235 _length = reader.read("!H")[0]
3236 obj.xid = reader.read("!L")[0]
3237 _experimenter = reader.read("!L")[0]
3238 assert(_experimenter == 6035143)
3239 _subtype = reader.read("!L")[0]
3240 assert(_subtype == 16)
3241 obj.status = reader.read("!L")[0]
3242 obj.vport_no = reader.read("!L")[0]
3243 return obj
3244
3245 def __eq__(self, other):
3246 if type(self) != type(other): return False
3247 if self.version != other.version: return False
3248 if self.type != other.type: return False
3249 if self.xid != other.xid: return False
3250 if self.status != other.status: return False
3251 if self.vport_no != other.vport_no: return False
3252 return True
3253
3254 def __ne__(self, other):
3255 return not self.__eq__(other)
3256
3257 def __str__(self):
3258 return self.show()
3259
3260 def show(self):
3261 import loxi.pp
3262 return loxi.pp.pp(self)
3263
3264 def pretty_print(self, q):
3265 q.text("bsn_virtual_port_create_reply {")
3266 with q.group():
3267 with q.indent(2):
3268 q.breakable()
3269 q.text("xid = ");
3270 if self.xid != None:
3271 q.text("%#x" % self.xid)
3272 else:
3273 q.text('None')
3274 q.text(","); q.breakable()
3275 q.text("status = ");
3276 q.text("%#x" % self.status)
3277 q.text(","); q.breakable()
3278 q.text("vport_no = ");
3279 q.text("%#x" % self.vport_no)
3280 q.breakable()
3281 q.text('}')
3282
3283class bsn_virtual_port_create_request(Message):
3284 version = 1
3285 type = 4
3286 experimenter = 6035143
3287 subtype = 15
3288
3289 def __init__(self, xid=None, vport=None):
3290 self.xid = xid
3291 if vport != None:
3292 self.vport = vport
3293 else:
3294 self.vport = common.bsn_vport_q_in_q()
3295
3296 def pack(self):
3297 packed = []
3298 packed.append(struct.pack("!B", self.version))
3299 packed.append(struct.pack("!B", self.type))
3300 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3301 packed.append(struct.pack("!L", self.xid))
3302 packed.append(struct.pack("!L", self.experimenter))
3303 packed.append(struct.pack("!L", self.subtype))
3304 packed.append(self.vport.pack())
3305 length = sum([len(x) for x in packed])
3306 packed[2] = struct.pack("!H", length)
3307 return ''.join(packed)
3308
3309 @staticmethod
3310 def unpack(buf):
3311 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
3312 obj = bsn_virtual_port_create_request()
3313 if type(buf) == loxi.generic_util.OFReader:
3314 reader = buf
3315 else:
3316 reader = loxi.generic_util.OFReader(buf)
3317 _version = reader.read("!B")[0]
3318 assert(_version == 1)
3319 _type = reader.read("!B")[0]
3320 assert(_type == 4)
3321 _length = reader.read("!H")[0]
3322 obj.xid = reader.read("!L")[0]
3323 _experimenter = reader.read("!L")[0]
3324 assert(_experimenter == 6035143)
3325 _subtype = reader.read("!L")[0]
3326 assert(_subtype == 15)
3327 obj.vport = common.bsn_vport_q_in_q.unpack(reader)
3328 return obj
3329
3330 def __eq__(self, other):
3331 if type(self) != type(other): return False
3332 if self.version != other.version: return False
3333 if self.type != other.type: return False
3334 if self.xid != other.xid: return False
3335 if self.vport != other.vport: return False
3336 return True
3337
3338 def __ne__(self, other):
3339 return not self.__eq__(other)
3340
3341 def __str__(self):
3342 return self.show()
3343
3344 def show(self):
3345 import loxi.pp
3346 return loxi.pp.pp(self)
3347
3348 def pretty_print(self, q):
3349 q.text("bsn_virtual_port_create_request {")
3350 with q.group():
3351 with q.indent(2):
3352 q.breakable()
3353 q.text("xid = ");
3354 if self.xid != None:
3355 q.text("%#x" % self.xid)
3356 else:
3357 q.text('None')
3358 q.text(","); q.breakable()
3359 q.text("vport = ");
3360 q.pp(self.vport)
3361 q.breakable()
3362 q.text('}')
3363
3364class bsn_virtual_port_remove_reply(Message):
3365 version = 1
3366 type = 4
3367 experimenter = 6035143
3368 subtype = 26
3369
3370 def __init__(self, xid=None, status=None):
3371 self.xid = xid
3372 if status != None:
3373 self.status = status
3374 else:
3375 self.status = 0
3376
3377 def pack(self):
3378 packed = []
3379 packed.append(struct.pack("!B", self.version))
3380 packed.append(struct.pack("!B", self.type))
3381 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3382 packed.append(struct.pack("!L", self.xid))
3383 packed.append(struct.pack("!L", self.experimenter))
3384 packed.append(struct.pack("!L", self.subtype))
3385 packed.append(struct.pack("!L", self.status))
3386 length = sum([len(x) for x in packed])
3387 packed[2] = struct.pack("!H", length)
3388 return ''.join(packed)
3389
3390 @staticmethod
3391 def unpack(buf):
3392 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
3393 obj = bsn_virtual_port_remove_reply()
3394 if type(buf) == loxi.generic_util.OFReader:
3395 reader = buf
3396 else:
3397 reader = loxi.generic_util.OFReader(buf)
3398 _version = reader.read("!B")[0]
3399 assert(_version == 1)
3400 _type = reader.read("!B")[0]
3401 assert(_type == 4)
3402 _length = reader.read("!H")[0]
3403 obj.xid = reader.read("!L")[0]
3404 _experimenter = reader.read("!L")[0]
3405 assert(_experimenter == 6035143)
3406 _subtype = reader.read("!L")[0]
3407 assert(_subtype == 26)
3408 obj.status = reader.read("!L")[0]
3409 return obj
3410
3411 def __eq__(self, other):
3412 if type(self) != type(other): return False
3413 if self.version != other.version: return False
3414 if self.type != other.type: return False
3415 if self.xid != other.xid: return False
3416 if self.status != other.status: return False
3417 return True
3418
3419 def __ne__(self, other):
3420 return not self.__eq__(other)
3421
3422 def __str__(self):
3423 return self.show()
3424
3425 def show(self):
3426 import loxi.pp
3427 return loxi.pp.pp(self)
3428
3429 def pretty_print(self, q):
3430 q.text("bsn_virtual_port_remove_reply {")
3431 with q.group():
3432 with q.indent(2):
3433 q.breakable()
3434 q.text("xid = ");
3435 if self.xid != None:
3436 q.text("%#x" % self.xid)
3437 else:
3438 q.text('None')
3439 q.text(","); q.breakable()
3440 q.text("status = ");
3441 q.text("%#x" % self.status)
3442 q.breakable()
3443 q.text('}')
3444
3445class bsn_virtual_port_remove_request(Message):
3446 version = 1
3447 type = 4
3448 experimenter = 6035143
3449 subtype = 17
3450
3451 def __init__(self, xid=None, vport_no=None):
3452 self.xid = xid
3453 if vport_no != None:
3454 self.vport_no = vport_no
3455 else:
3456 self.vport_no = 0
3457
3458 def pack(self):
3459 packed = []
3460 packed.append(struct.pack("!B", self.version))
3461 packed.append(struct.pack("!B", self.type))
3462 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3463 packed.append(struct.pack("!L", self.xid))
3464 packed.append(struct.pack("!L", self.experimenter))
3465 packed.append(struct.pack("!L", self.subtype))
3466 packed.append(struct.pack("!L", self.vport_no))
3467 length = sum([len(x) for x in packed])
3468 packed[2] = struct.pack("!H", length)
3469 return ''.join(packed)
3470
3471 @staticmethod
3472 def unpack(buf):
3473 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
3474 obj = bsn_virtual_port_remove_request()
3475 if type(buf) == loxi.generic_util.OFReader:
3476 reader = buf
3477 else:
3478 reader = loxi.generic_util.OFReader(buf)
3479 _version = reader.read("!B")[0]
3480 assert(_version == 1)
3481 _type = reader.read("!B")[0]
3482 assert(_type == 4)
3483 _length = reader.read("!H")[0]
3484 obj.xid = reader.read("!L")[0]
3485 _experimenter = reader.read("!L")[0]
3486 assert(_experimenter == 6035143)
3487 _subtype = reader.read("!L")[0]
3488 assert(_subtype == 17)
3489 obj.vport_no = reader.read("!L")[0]
3490 return obj
3491
3492 def __eq__(self, other):
3493 if type(self) != type(other): return False
3494 if self.version != other.version: return False
3495 if self.type != other.type: return False
3496 if self.xid != other.xid: return False
3497 if self.vport_no != other.vport_no: return False
3498 return True
3499
3500 def __ne__(self, other):
3501 return not self.__eq__(other)
3502
3503 def __str__(self):
3504 return self.show()
3505
3506 def show(self):
3507 import loxi.pp
3508 return loxi.pp.pp(self)
3509
3510 def pretty_print(self, q):
3511 q.text("bsn_virtual_port_remove_request {")
3512 with q.group():
3513 with q.indent(2):
3514 q.breakable()
3515 q.text("xid = ");
3516 if self.xid != None:
3517 q.text("%#x" % self.xid)
3518 else:
3519 q.text('None')
3520 q.text(","); q.breakable()
3521 q.text("vport_no = ");
3522 q.text("%#x" % self.vport_no)
3523 q.breakable()
3524 q.text('}')
3525
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3526class desc_stats_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3527 version = 1
3528 type = 17
3529 stats_type = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3530
3531 def __init__(self, xid=None, flags=None, mfr_desc=None, hw_desc=None, sw_desc=None, serial_num=None, dp_desc=None):
3532 self.xid = xid
3533 if flags != None:
3534 self.flags = flags
3535 else:
3536 self.flags = 0
3537 if mfr_desc != None:
3538 self.mfr_desc = mfr_desc
3539 else:
3540 self.mfr_desc = ""
3541 if hw_desc != None:
3542 self.hw_desc = hw_desc
3543 else:
3544 self.hw_desc = ""
3545 if sw_desc != None:
3546 self.sw_desc = sw_desc
3547 else:
3548 self.sw_desc = ""
3549 if serial_num != None:
3550 self.serial_num = serial_num
3551 else:
3552 self.serial_num = ""
3553 if dp_desc != None:
3554 self.dp_desc = dp_desc
3555 else:
3556 self.dp_desc = ""
3557
3558 def pack(self):
3559 packed = []
3560 packed.append(struct.pack("!B", self.version))
3561 packed.append(struct.pack("!B", self.type))
3562 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3563 packed.append(struct.pack("!L", self.xid))
3564 packed.append(struct.pack("!H", self.stats_type))
3565 packed.append(struct.pack("!H", self.flags))
3566 packed.append(struct.pack("!256s", self.mfr_desc))
3567 packed.append(struct.pack("!256s", self.hw_desc))
3568 packed.append(struct.pack("!256s", self.sw_desc))
3569 packed.append(struct.pack("!32s", self.serial_num))
3570 packed.append(struct.pack("!256s", self.dp_desc))
3571 length = sum([len(x) for x in packed])
3572 packed[2] = struct.pack("!H", length)
3573 return ''.join(packed)
3574
3575 @staticmethod
3576 def unpack(buf):
3577 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
3578 obj = desc_stats_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3579 if type(buf) == loxi.generic_util.OFReader:
3580 reader = buf
3581 else:
3582 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3583 _version = reader.read("!B")[0]
3584 assert(_version == 1)
3585 _type = reader.read("!B")[0]
3586 assert(_type == 17)
3587 _length = reader.read("!H")[0]
3588 obj.xid = reader.read("!L")[0]
3589 _stats_type = reader.read("!H")[0]
3590 assert(_stats_type == 0)
3591 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3592 obj.mfr_desc = reader.read("!256s")[0].rstrip("\x00")
3593 obj.hw_desc = reader.read("!256s")[0].rstrip("\x00")
3594 obj.sw_desc = reader.read("!256s")[0].rstrip("\x00")
3595 obj.serial_num = reader.read("!32s")[0].rstrip("\x00")
3596 obj.dp_desc = reader.read("!256s")[0].rstrip("\x00")
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3597 return obj
3598
3599 def __eq__(self, other):
3600 if type(self) != type(other): return False
3601 if self.version != other.version: return False
3602 if self.type != other.type: return False
3603 if self.xid != other.xid: return False
3604 if self.flags != other.flags: return False
3605 if self.mfr_desc != other.mfr_desc: return False
3606 if self.hw_desc != other.hw_desc: return False
3607 if self.sw_desc != other.sw_desc: return False
3608 if self.serial_num != other.serial_num: return False
3609 if self.dp_desc != other.dp_desc: return False
3610 return True
3611
3612 def __ne__(self, other):
3613 return not self.__eq__(other)
3614
3615 def __str__(self):
3616 return self.show()
3617
3618 def show(self):
3619 import loxi.pp
3620 return loxi.pp.pp(self)
3621
3622 def pretty_print(self, q):
3623 q.text("desc_stats_reply {")
3624 with q.group():
3625 with q.indent(2):
3626 q.breakable()
3627 q.text("xid = ");
3628 if self.xid != None:
3629 q.text("%#x" % self.xid)
3630 else:
3631 q.text('None')
3632 q.text(","); q.breakable()
3633 q.text("flags = ");
3634 q.text("%#x" % self.flags)
3635 q.text(","); q.breakable()
3636 q.text("mfr_desc = ");
3637 q.pp(self.mfr_desc)
3638 q.text(","); q.breakable()
3639 q.text("hw_desc = ");
3640 q.pp(self.hw_desc)
3641 q.text(","); q.breakable()
3642 q.text("sw_desc = ");
3643 q.pp(self.sw_desc)
3644 q.text(","); q.breakable()
3645 q.text("serial_num = ");
3646 q.pp(self.serial_num)
3647 q.text(","); q.breakable()
3648 q.text("dp_desc = ");
3649 q.pp(self.dp_desc)
3650 q.breakable()
3651 q.text('}')
3652
3653class desc_stats_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3654 version = 1
3655 type = 16
3656 stats_type = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3657
3658 def __init__(self, xid=None, flags=None):
3659 self.xid = xid
3660 if flags != None:
3661 self.flags = flags
3662 else:
3663 self.flags = 0
3664
3665 def pack(self):
3666 packed = []
3667 packed.append(struct.pack("!B", self.version))
3668 packed.append(struct.pack("!B", self.type))
3669 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3670 packed.append(struct.pack("!L", self.xid))
3671 packed.append(struct.pack("!H", self.stats_type))
3672 packed.append(struct.pack("!H", self.flags))
3673 length = sum([len(x) for x in packed])
3674 packed[2] = struct.pack("!H", length)
3675 return ''.join(packed)
3676
3677 @staticmethod
3678 def unpack(buf):
3679 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
3680 obj = desc_stats_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3681 if type(buf) == loxi.generic_util.OFReader:
3682 reader = buf
3683 else:
3684 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3685 _version = reader.read("!B")[0]
3686 assert(_version == 1)
3687 _type = reader.read("!B")[0]
3688 assert(_type == 16)
3689 _length = reader.read("!H")[0]
3690 obj.xid = reader.read("!L")[0]
3691 _stats_type = reader.read("!H")[0]
3692 assert(_stats_type == 0)
3693 obj.flags = reader.read("!H")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3694 return obj
3695
3696 def __eq__(self, other):
3697 if type(self) != type(other): return False
3698 if self.version != other.version: return False
3699 if self.type != other.type: return False
3700 if self.xid != other.xid: return False
3701 if self.flags != other.flags: return False
3702 return True
3703
3704 def __ne__(self, other):
3705 return not self.__eq__(other)
3706
3707 def __str__(self):
3708 return self.show()
3709
3710 def show(self):
3711 import loxi.pp
3712 return loxi.pp.pp(self)
3713
3714 def pretty_print(self, q):
3715 q.text("desc_stats_request {")
3716 with q.group():
3717 with q.indent(2):
3718 q.breakable()
3719 q.text("xid = ");
3720 if self.xid != None:
3721 q.text("%#x" % self.xid)
3722 else:
3723 q.text('None')
3724 q.text(","); q.breakable()
3725 q.text("flags = ");
3726 q.text("%#x" % self.flags)
3727 q.breakable()
3728 q.text('}')
3729
3730class echo_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3731 version = 1
3732 type = 3
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3733
3734 def __init__(self, xid=None, data=None):
3735 self.xid = xid
3736 if data != None:
3737 self.data = data
3738 else:
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3739 self.data = ''
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3740
3741 def pack(self):
3742 packed = []
3743 packed.append(struct.pack("!B", self.version))
3744 packed.append(struct.pack("!B", self.type))
3745 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3746 packed.append(struct.pack("!L", self.xid))
3747 packed.append(self.data)
3748 length = sum([len(x) for x in packed])
3749 packed[2] = struct.pack("!H", length)
3750 return ''.join(packed)
3751
3752 @staticmethod
3753 def unpack(buf):
3754 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
3755 obj = echo_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3756 if type(buf) == loxi.generic_util.OFReader:
3757 reader = buf
3758 else:
3759 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3760 _version = reader.read("!B")[0]
3761 assert(_version == 1)
3762 _type = reader.read("!B")[0]
3763 assert(_type == 3)
3764 _length = reader.read("!H")[0]
3765 obj.xid = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3766 obj.data = str(reader.read_all())
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3767 return obj
3768
3769 def __eq__(self, other):
3770 if type(self) != type(other): return False
3771 if self.version != other.version: return False
3772 if self.type != other.type: return False
3773 if self.xid != other.xid: return False
3774 if self.data != other.data: return False
3775 return True
3776
3777 def __ne__(self, other):
3778 return not self.__eq__(other)
3779
3780 def __str__(self):
3781 return self.show()
3782
3783 def show(self):
3784 import loxi.pp
3785 return loxi.pp.pp(self)
3786
3787 def pretty_print(self, q):
3788 q.text("echo_reply {")
3789 with q.group():
3790 with q.indent(2):
3791 q.breakable()
3792 q.text("xid = ");
3793 if self.xid != None:
3794 q.text("%#x" % self.xid)
3795 else:
3796 q.text('None')
3797 q.text(","); q.breakable()
3798 q.text("data = ");
3799 q.pp(self.data)
3800 q.breakable()
3801 q.text('}')
3802
3803class echo_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3804 version = 1
3805 type = 2
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3806
3807 def __init__(self, xid=None, data=None):
3808 self.xid = xid
3809 if data != None:
3810 self.data = data
3811 else:
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3812 self.data = ''
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3813
3814 def pack(self):
3815 packed = []
3816 packed.append(struct.pack("!B", self.version))
3817 packed.append(struct.pack("!B", self.type))
3818 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3819 packed.append(struct.pack("!L", self.xid))
3820 packed.append(self.data)
3821 length = sum([len(x) for x in packed])
3822 packed[2] = struct.pack("!H", length)
3823 return ''.join(packed)
3824
3825 @staticmethod
3826 def unpack(buf):
3827 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
3828 obj = echo_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3829 if type(buf) == loxi.generic_util.OFReader:
3830 reader = buf
3831 else:
3832 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3833 _version = reader.read("!B")[0]
3834 assert(_version == 1)
3835 _type = reader.read("!B")[0]
3836 assert(_type == 2)
3837 _length = reader.read("!H")[0]
3838 obj.xid = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3839 obj.data = str(reader.read_all())
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3840 return obj
3841
3842 def __eq__(self, other):
3843 if type(self) != type(other): return False
3844 if self.version != other.version: return False
3845 if self.type != other.type: return False
3846 if self.xid != other.xid: return False
3847 if self.data != other.data: return False
3848 return True
3849
3850 def __ne__(self, other):
3851 return not self.__eq__(other)
3852
3853 def __str__(self):
3854 return self.show()
3855
3856 def show(self):
3857 import loxi.pp
3858 return loxi.pp.pp(self)
3859
3860 def pretty_print(self, q):
3861 q.text("echo_request {")
3862 with q.group():
3863 with q.indent(2):
3864 q.breakable()
3865 q.text("xid = ");
3866 if self.xid != None:
3867 q.text("%#x" % self.xid)
3868 else:
3869 q.text('None')
3870 q.text(","); q.breakable()
3871 q.text("data = ");
3872 q.pp(self.data)
3873 q.breakable()
3874 q.text('}')
3875
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3876class features_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3877 version = 1
3878 type = 6
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3879
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3880 def __init__(self, xid=None, datapath_id=None, n_buffers=None, n_tables=None, capabilities=None, actions=None, ports=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3881 self.xid = xid
3882 if datapath_id != None:
3883 self.datapath_id = datapath_id
3884 else:
3885 self.datapath_id = 0
3886 if n_buffers != None:
3887 self.n_buffers = n_buffers
3888 else:
3889 self.n_buffers = 0
3890 if n_tables != None:
3891 self.n_tables = n_tables
3892 else:
3893 self.n_tables = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3894 if capabilities != None:
3895 self.capabilities = capabilities
3896 else:
3897 self.capabilities = 0
3898 if actions != None:
3899 self.actions = actions
3900 else:
3901 self.actions = 0
3902 if ports != None:
3903 self.ports = ports
3904 else:
3905 self.ports = []
3906
3907 def pack(self):
3908 packed = []
3909 packed.append(struct.pack("!B", self.version))
3910 packed.append(struct.pack("!B", self.type))
3911 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
3912 packed.append(struct.pack("!L", self.xid))
3913 packed.append(struct.pack("!Q", self.datapath_id))
3914 packed.append(struct.pack("!L", self.n_buffers))
3915 packed.append(struct.pack("!B", self.n_tables))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3916 packed.append('\x00' * 3)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3917 packed.append(struct.pack("!L", self.capabilities))
3918 packed.append(struct.pack("!L", self.actions))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3919 packed.append(util.pack_list(self.ports))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3920 length = sum([len(x) for x in packed])
3921 packed[2] = struct.pack("!H", length)
3922 return ''.join(packed)
3923
3924 @staticmethod
3925 def unpack(buf):
3926 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
3927 obj = features_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3928 if type(buf) == loxi.generic_util.OFReader:
3929 reader = buf
3930 else:
3931 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3932 _version = reader.read("!B")[0]
3933 assert(_version == 1)
3934 _type = reader.read("!B")[0]
3935 assert(_type == 6)
3936 _length = reader.read("!H")[0]
3937 obj.xid = reader.read("!L")[0]
3938 obj.datapath_id = reader.read("!Q")[0]
3939 obj.n_buffers = reader.read("!L")[0]
3940 obj.n_tables = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3941 reader.skip(3)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]3942 obj.capabilities = reader.read("!L")[0]
3943 obj.actions = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]3944 obj.ports = loxi.generic_util.unpack_list(reader, common.port_desc.unpack)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3945 return obj
3946
3947 def __eq__(self, other):
3948 if type(self) != type(other): return False
3949 if self.version != other.version: return False
3950 if self.type != other.type: return False
3951 if self.xid != other.xid: return False
3952 if self.datapath_id != other.datapath_id: return False
3953 if self.n_buffers != other.n_buffers: return False
3954 if self.n_tables != other.n_tables: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3955 if self.capabilities != other.capabilities: return False
3956 if self.actions != other.actions: return False
3957 if self.ports != other.ports: return False
3958 return True
3959
3960 def __ne__(self, other):
3961 return not self.__eq__(other)
3962
3963 def __str__(self):
3964 return self.show()
3965
3966 def show(self):
3967 import loxi.pp
3968 return loxi.pp.pp(self)
3969
3970 def pretty_print(self, q):
3971 q.text("features_reply {")
3972 with q.group():
3973 with q.indent(2):
3974 q.breakable()
3975 q.text("xid = ");
3976 if self.xid != None:
3977 q.text("%#x" % self.xid)
3978 else:
3979 q.text('None')
3980 q.text(","); q.breakable()
3981 q.text("datapath_id = ");
3982 q.text("%#x" % self.datapath_id)
3983 q.text(","); q.breakable()
3984 q.text("n_buffers = ");
3985 q.text("%#x" % self.n_buffers)
3986 q.text(","); q.breakable()
3987 q.text("n_tables = ");
3988 q.text("%#x" % self.n_tables)
3989 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]3990 q.text("capabilities = ");
3991 q.text("%#x" % self.capabilities)
3992 q.text(","); q.breakable()
3993 q.text("actions = ");
3994 q.text("%#x" % self.actions)
3995 q.text(","); q.breakable()
3996 q.text("ports = ");
3997 q.pp(self.ports)
3998 q.breakable()
3999 q.text('}')
4000
4001class features_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4002 version = 1
4003 type = 5
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4004
4005 def __init__(self, xid=None):
4006 self.xid = xid
4007
4008 def pack(self):
4009 packed = []
4010 packed.append(struct.pack("!B", self.version))
4011 packed.append(struct.pack("!B", self.type))
4012 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4013 packed.append(struct.pack("!L", self.xid))
4014 length = sum([len(x) for x in packed])
4015 packed[2] = struct.pack("!H", length)
4016 return ''.join(packed)
4017
4018 @staticmethod
4019 def unpack(buf):
4020 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
4021 obj = features_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4022 if type(buf) == loxi.generic_util.OFReader:
4023 reader = buf
4024 else:
4025 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4026 _version = reader.read("!B")[0]
4027 assert(_version == 1)
4028 _type = reader.read("!B")[0]
4029 assert(_type == 5)
4030 _length = reader.read("!H")[0]
4031 obj.xid = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4032 return obj
4033
4034 def __eq__(self, other):
4035 if type(self) != type(other): return False
4036 if self.version != other.version: return False
4037 if self.type != other.type: return False
4038 if self.xid != other.xid: return False
4039 return True
4040
4041 def __ne__(self, other):
4042 return not self.__eq__(other)
4043
4044 def __str__(self):
4045 return self.show()
4046
4047 def show(self):
4048 import loxi.pp
4049 return loxi.pp.pp(self)
4050
4051 def pretty_print(self, q):
4052 q.text("features_request {")
4053 with q.group():
4054 with q.indent(2):
4055 q.breakable()
4056 q.text("xid = ");
4057 if self.xid != None:
4058 q.text("%#x" % self.xid)
4059 else:
4060 q.text('None')
4061 q.breakable()
4062 q.text('}')
4063
4064class flow_add(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4065 version = 1
4066 type = 14
4067 _command = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4068
4069 def __init__(self, xid=None, match=None, cookie=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None):
4070 self.xid = xid
4071 if match != None:
4072 self.match = match
4073 else:
4074 self.match = common.match()
4075 if cookie != None:
4076 self.cookie = cookie
4077 else:
4078 self.cookie = 0
4079 if idle_timeout != None:
4080 self.idle_timeout = idle_timeout
4081 else:
4082 self.idle_timeout = 0
4083 if hard_timeout != None:
4084 self.hard_timeout = hard_timeout
4085 else:
4086 self.hard_timeout = 0
4087 if priority != None:
4088 self.priority = priority
4089 else:
4090 self.priority = 0
4091 if buffer_id != None:
4092 self.buffer_id = buffer_id
4093 else:
4094 self.buffer_id = 0
4095 if out_port != None:
4096 self.out_port = out_port
4097 else:
4098 self.out_port = 0
4099 if flags != None:
4100 self.flags = flags
4101 else:
4102 self.flags = 0
4103 if actions != None:
4104 self.actions = actions
4105 else:
4106 self.actions = []
4107
4108 def pack(self):
4109 packed = []
4110 packed.append(struct.pack("!B", self.version))
4111 packed.append(struct.pack("!B", self.type))
4112 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4113 packed.append(struct.pack("!L", self.xid))
4114 packed.append(self.match.pack())
4115 packed.append(struct.pack("!Q", self.cookie))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4116 packed.append(util.pack_fm_cmd(self._command))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4117 packed.append(struct.pack("!H", self.idle_timeout))
4118 packed.append(struct.pack("!H", self.hard_timeout))
4119 packed.append(struct.pack("!H", self.priority))
4120 packed.append(struct.pack("!L", self.buffer_id))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4121 packed.append(util.pack_port_no(self.out_port))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4122 packed.append(struct.pack("!H", self.flags))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4123 packed.append(util.pack_list(self.actions))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4124 length = sum([len(x) for x in packed])
4125 packed[2] = struct.pack("!H", length)
4126 return ''.join(packed)
4127
4128 @staticmethod
4129 def unpack(buf):
4130 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
4131 obj = flow_add()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4132 if type(buf) == loxi.generic_util.OFReader:
4133 reader = buf
4134 else:
4135 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4136 _version = reader.read("!B")[0]
4137 assert(_version == 1)
4138 _type = reader.read("!B")[0]
4139 assert(_type == 14)
4140 _length = reader.read("!H")[0]
4141 obj.xid = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4142 obj.match = common.match.unpack(reader)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4143 obj.cookie = reader.read("!Q")[0]
4144 __command = util.unpack_fm_cmd(reader)
4145 assert(__command == 0)
4146 obj.idle_timeout = reader.read("!H")[0]
4147 obj.hard_timeout = reader.read("!H")[0]
4148 obj.priority = reader.read("!H")[0]
4149 obj.buffer_id = reader.read("!L")[0]
4150 obj.out_port = util.unpack_port_no(reader)
4151 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4152 obj.actions = action.unpack_list(reader)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4153 return obj
4154
4155 def __eq__(self, other):
4156 if type(self) != type(other): return False
4157 if self.version != other.version: return False
4158 if self.type != other.type: return False
4159 if self.xid != other.xid: return False
4160 if self.match != other.match: return False
4161 if self.cookie != other.cookie: return False
4162 if self.idle_timeout != other.idle_timeout: return False
4163 if self.hard_timeout != other.hard_timeout: return False
4164 if self.priority != other.priority: return False
4165 if self.buffer_id != other.buffer_id: return False
4166 if self.out_port != other.out_port: return False
4167 if self.flags != other.flags: return False
4168 if self.actions != other.actions: return False
4169 return True
4170
4171 def __ne__(self, other):
4172 return not self.__eq__(other)
4173
4174 def __str__(self):
4175 return self.show()
4176
4177 def show(self):
4178 import loxi.pp
4179 return loxi.pp.pp(self)
4180
4181 def pretty_print(self, q):
4182 q.text("flow_add {")
4183 with q.group():
4184 with q.indent(2):
4185 q.breakable()
4186 q.text("xid = ");
4187 if self.xid != None:
4188 q.text("%#x" % self.xid)
4189 else:
4190 q.text('None')
4191 q.text(","); q.breakable()
4192 q.text("match = ");
4193 q.pp(self.match)
4194 q.text(","); q.breakable()
4195 q.text("cookie = ");
4196 q.text("%#x" % self.cookie)
4197 q.text(","); q.breakable()
4198 q.text("idle_timeout = ");
4199 q.text("%#x" % self.idle_timeout)
4200 q.text(","); q.breakable()
4201 q.text("hard_timeout = ");
4202 q.text("%#x" % self.hard_timeout)
4203 q.text(","); q.breakable()
4204 q.text("priority = ");
4205 q.text("%#x" % self.priority)
4206 q.text(","); q.breakable()
4207 q.text("buffer_id = ");
4208 q.text("%#x" % self.buffer_id)
4209 q.text(","); q.breakable()
4210 q.text("out_port = ");
4211 q.text(util.pretty_port(self.out_port))
4212 q.text(","); q.breakable()
4213 q.text("flags = ");
4214 q.text("%#x" % self.flags)
4215 q.text(","); q.breakable()
4216 q.text("actions = ");
4217 q.pp(self.actions)
4218 q.breakable()
4219 q.text('}')
4220
4221class flow_delete(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4222 version = 1
4223 type = 14
4224 _command = 3
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4225
4226 def __init__(self, xid=None, match=None, cookie=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None):
4227 self.xid = xid
4228 if match != None:
4229 self.match = match
4230 else:
4231 self.match = common.match()
4232 if cookie != None:
4233 self.cookie = cookie
4234 else:
4235 self.cookie = 0
4236 if idle_timeout != None:
4237 self.idle_timeout = idle_timeout
4238 else:
4239 self.idle_timeout = 0
4240 if hard_timeout != None:
4241 self.hard_timeout = hard_timeout
4242 else:
4243 self.hard_timeout = 0
4244 if priority != None:
4245 self.priority = priority
4246 else:
4247 self.priority = 0
4248 if buffer_id != None:
4249 self.buffer_id = buffer_id
4250 else:
4251 self.buffer_id = 0
4252 if out_port != None:
4253 self.out_port = out_port
4254 else:
4255 self.out_port = 0
4256 if flags != None:
4257 self.flags = flags
4258 else:
4259 self.flags = 0
4260 if actions != None:
4261 self.actions = actions
4262 else:
4263 self.actions = []
4264
4265 def pack(self):
4266 packed = []
4267 packed.append(struct.pack("!B", self.version))
4268 packed.append(struct.pack("!B", self.type))
4269 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4270 packed.append(struct.pack("!L", self.xid))
4271 packed.append(self.match.pack())
4272 packed.append(struct.pack("!Q", self.cookie))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4273 packed.append(util.pack_fm_cmd(self._command))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4274 packed.append(struct.pack("!H", self.idle_timeout))
4275 packed.append(struct.pack("!H", self.hard_timeout))
4276 packed.append(struct.pack("!H", self.priority))
4277 packed.append(struct.pack("!L", self.buffer_id))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4278 packed.append(util.pack_port_no(self.out_port))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4279 packed.append(struct.pack("!H", self.flags))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4280 packed.append(util.pack_list(self.actions))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4281 length = sum([len(x) for x in packed])
4282 packed[2] = struct.pack("!H", length)
4283 return ''.join(packed)
4284
4285 @staticmethod
4286 def unpack(buf):
4287 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
4288 obj = flow_delete()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4289 if type(buf) == loxi.generic_util.OFReader:
4290 reader = buf
4291 else:
4292 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4293 _version = reader.read("!B")[0]
4294 assert(_version == 1)
4295 _type = reader.read("!B")[0]
4296 assert(_type == 14)
4297 _length = reader.read("!H")[0]
4298 obj.xid = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4299 obj.match = common.match.unpack(reader)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4300 obj.cookie = reader.read("!Q")[0]
4301 __command = util.unpack_fm_cmd(reader)
4302 assert(__command == 3)
4303 obj.idle_timeout = reader.read("!H")[0]
4304 obj.hard_timeout = reader.read("!H")[0]
4305 obj.priority = reader.read("!H")[0]
4306 obj.buffer_id = reader.read("!L")[0]
4307 obj.out_port = util.unpack_port_no(reader)
4308 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4309 obj.actions = action.unpack_list(reader)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4310 return obj
4311
4312 def __eq__(self, other):
4313 if type(self) != type(other): return False
4314 if self.version != other.version: return False
4315 if self.type != other.type: return False
4316 if self.xid != other.xid: return False
4317 if self.match != other.match: return False
4318 if self.cookie != other.cookie: return False
4319 if self.idle_timeout != other.idle_timeout: return False
4320 if self.hard_timeout != other.hard_timeout: return False
4321 if self.priority != other.priority: return False
4322 if self.buffer_id != other.buffer_id: return False
4323 if self.out_port != other.out_port: return False
4324 if self.flags != other.flags: return False
4325 if self.actions != other.actions: return False
4326 return True
4327
4328 def __ne__(self, other):
4329 return not self.__eq__(other)
4330
4331 def __str__(self):
4332 return self.show()
4333
4334 def show(self):
4335 import loxi.pp
4336 return loxi.pp.pp(self)
4337
4338 def pretty_print(self, q):
4339 q.text("flow_delete {")
4340 with q.group():
4341 with q.indent(2):
4342 q.breakable()
4343 q.text("xid = ");
4344 if self.xid != None:
4345 q.text("%#x" % self.xid)
4346 else:
4347 q.text('None')
4348 q.text(","); q.breakable()
4349 q.text("match = ");
4350 q.pp(self.match)
4351 q.text(","); q.breakable()
4352 q.text("cookie = ");
4353 q.text("%#x" % self.cookie)
4354 q.text(","); q.breakable()
4355 q.text("idle_timeout = ");
4356 q.text("%#x" % self.idle_timeout)
4357 q.text(","); q.breakable()
4358 q.text("hard_timeout = ");
4359 q.text("%#x" % self.hard_timeout)
4360 q.text(","); q.breakable()
4361 q.text("priority = ");
4362 q.text("%#x" % self.priority)
4363 q.text(","); q.breakable()
4364 q.text("buffer_id = ");
4365 q.text("%#x" % self.buffer_id)
4366 q.text(","); q.breakable()
4367 q.text("out_port = ");
4368 q.text(util.pretty_port(self.out_port))
4369 q.text(","); q.breakable()
4370 q.text("flags = ");
4371 q.text("%#x" % self.flags)
4372 q.text(","); q.breakable()
4373 q.text("actions = ");
4374 q.pp(self.actions)
4375 q.breakable()
4376 q.text('}')
4377
4378class flow_delete_strict(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4379 version = 1
4380 type = 14
4381 _command = 4
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4382
4383 def __init__(self, xid=None, match=None, cookie=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None):
4384 self.xid = xid
4385 if match != None:
4386 self.match = match
4387 else:
4388 self.match = common.match()
4389 if cookie != None:
4390 self.cookie = cookie
4391 else:
4392 self.cookie = 0
4393 if idle_timeout != None:
4394 self.idle_timeout = idle_timeout
4395 else:
4396 self.idle_timeout = 0
4397 if hard_timeout != None:
4398 self.hard_timeout = hard_timeout
4399 else:
4400 self.hard_timeout = 0
4401 if priority != None:
4402 self.priority = priority
4403 else:
4404 self.priority = 0
4405 if buffer_id != None:
4406 self.buffer_id = buffer_id
4407 else:
4408 self.buffer_id = 0
4409 if out_port != None:
4410 self.out_port = out_port
4411 else:
4412 self.out_port = 0
4413 if flags != None:
4414 self.flags = flags
4415 else:
4416 self.flags = 0
4417 if actions != None:
4418 self.actions = actions
4419 else:
4420 self.actions = []
4421
4422 def pack(self):
4423 packed = []
4424 packed.append(struct.pack("!B", self.version))
4425 packed.append(struct.pack("!B", self.type))
4426 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4427 packed.append(struct.pack("!L", self.xid))
4428 packed.append(self.match.pack())
4429 packed.append(struct.pack("!Q", self.cookie))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4430 packed.append(util.pack_fm_cmd(self._command))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4431 packed.append(struct.pack("!H", self.idle_timeout))
4432 packed.append(struct.pack("!H", self.hard_timeout))
4433 packed.append(struct.pack("!H", self.priority))
4434 packed.append(struct.pack("!L", self.buffer_id))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4435 packed.append(util.pack_port_no(self.out_port))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4436 packed.append(struct.pack("!H", self.flags))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4437 packed.append(util.pack_list(self.actions))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4438 length = sum([len(x) for x in packed])
4439 packed[2] = struct.pack("!H", length)
4440 return ''.join(packed)
4441
4442 @staticmethod
4443 def unpack(buf):
4444 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
4445 obj = flow_delete_strict()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4446 if type(buf) == loxi.generic_util.OFReader:
4447 reader = buf
4448 else:
4449 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4450 _version = reader.read("!B")[0]
4451 assert(_version == 1)
4452 _type = reader.read("!B")[0]
4453 assert(_type == 14)
4454 _length = reader.read("!H")[0]
4455 obj.xid = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4456 obj.match = common.match.unpack(reader)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4457 obj.cookie = reader.read("!Q")[0]
4458 __command = util.unpack_fm_cmd(reader)
4459 assert(__command == 4)
4460 obj.idle_timeout = reader.read("!H")[0]
4461 obj.hard_timeout = reader.read("!H")[0]
4462 obj.priority = reader.read("!H")[0]
4463 obj.buffer_id = reader.read("!L")[0]
4464 obj.out_port = util.unpack_port_no(reader)
4465 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4466 obj.actions = action.unpack_list(reader)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4467 return obj
4468
4469 def __eq__(self, other):
4470 if type(self) != type(other): return False
4471 if self.version != other.version: return False
4472 if self.type != other.type: return False
4473 if self.xid != other.xid: return False
4474 if self.match != other.match: return False
4475 if self.cookie != other.cookie: return False
4476 if self.idle_timeout != other.idle_timeout: return False
4477 if self.hard_timeout != other.hard_timeout: return False
4478 if self.priority != other.priority: return False
4479 if self.buffer_id != other.buffer_id: return False
4480 if self.out_port != other.out_port: return False
4481 if self.flags != other.flags: return False
4482 if self.actions != other.actions: return False
4483 return True
4484
4485 def __ne__(self, other):
4486 return not self.__eq__(other)
4487
4488 def __str__(self):
4489 return self.show()
4490
4491 def show(self):
4492 import loxi.pp
4493 return loxi.pp.pp(self)
4494
4495 def pretty_print(self, q):
4496 q.text("flow_delete_strict {")
4497 with q.group():
4498 with q.indent(2):
4499 q.breakable()
4500 q.text("xid = ");
4501 if self.xid != None:
4502 q.text("%#x" % self.xid)
4503 else:
4504 q.text('None')
4505 q.text(","); q.breakable()
4506 q.text("match = ");
4507 q.pp(self.match)
4508 q.text(","); q.breakable()
4509 q.text("cookie = ");
4510 q.text("%#x" % self.cookie)
4511 q.text(","); q.breakable()
4512 q.text("idle_timeout = ");
4513 q.text("%#x" % self.idle_timeout)
4514 q.text(","); q.breakable()
4515 q.text("hard_timeout = ");
4516 q.text("%#x" % self.hard_timeout)
4517 q.text(","); q.breakable()
4518 q.text("priority = ");
4519 q.text("%#x" % self.priority)
4520 q.text(","); q.breakable()
4521 q.text("buffer_id = ");
4522 q.text("%#x" % self.buffer_id)
4523 q.text(","); q.breakable()
4524 q.text("out_port = ");
4525 q.text(util.pretty_port(self.out_port))
4526 q.text(","); q.breakable()
4527 q.text("flags = ");
4528 q.text("%#x" % self.flags)
4529 q.text(","); q.breakable()
4530 q.text("actions = ");
4531 q.pp(self.actions)
4532 q.breakable()
4533 q.text('}')
4534
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]4535class flow_mod_failed_error_msg(Message):
4536 version = 1
4537 type = 1
4538 err_type = 3
4539
4540 def __init__(self, xid=None, code=None, data=None):
4541 self.xid = xid
4542 if code != None:
4543 self.code = code
4544 else:
4545 self.code = 0
4546 if data != None:
4547 self.data = data
4548 else:
4549 self.data = ''
4550
4551 def pack(self):
4552 packed = []
4553 packed.append(struct.pack("!B", self.version))
4554 packed.append(struct.pack("!B", self.type))
4555 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4556 packed.append(struct.pack("!L", self.xid))
4557 packed.append(struct.pack("!H", self.err_type))
4558 packed.append(struct.pack("!H", self.code))
4559 packed.append(self.data)
4560 length = sum([len(x) for x in packed])
4561 packed[2] = struct.pack("!H", length)
4562 return ''.join(packed)
4563
4564 @staticmethod
4565 def unpack(buf):
4566 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
4567 obj = flow_mod_failed_error_msg()
4568 if type(buf) == loxi.generic_util.OFReader:
4569 reader = buf
4570 else:
4571 reader = loxi.generic_util.OFReader(buf)
4572 _version = reader.read("!B")[0]
4573 assert(_version == 1)
4574 _type = reader.read("!B")[0]
4575 assert(_type == 1)
4576 _length = reader.read("!H")[0]
4577 obj.xid = reader.read("!L")[0]
4578 _err_type = reader.read("!H")[0]
4579 assert(_err_type == 3)
4580 obj.code = reader.read("!H")[0]
4581 obj.data = str(reader.read_all())
4582 return obj
4583
4584 def __eq__(self, other):
4585 if type(self) != type(other): return False
4586 if self.version != other.version: return False
4587 if self.type != other.type: return False
4588 if self.xid != other.xid: return False
4589 if self.code != other.code: return False
4590 if self.data != other.data: return False
4591 return True
4592
4593 def __ne__(self, other):
4594 return not self.__eq__(other)
4595
4596 def __str__(self):
4597 return self.show()
4598
4599 def show(self):
4600 import loxi.pp
4601 return loxi.pp.pp(self)
4602
4603 def pretty_print(self, q):
4604 q.text("flow_mod_failed_error_msg {")
4605 with q.group():
4606 with q.indent(2):
4607 q.breakable()
4608 q.text("xid = ");
4609 if self.xid != None:
4610 q.text("%#x" % self.xid)
4611 else:
4612 q.text('None')
4613 q.text(","); q.breakable()
4614 q.text("code = ");
4615 q.text("%#x" % self.code)
4616 q.text(","); q.breakable()
4617 q.text("data = ");
4618 q.pp(self.data)
4619 q.breakable()
4620 q.text('}')
4621
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4622class flow_modify(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4623 version = 1
4624 type = 14
4625 _command = 1
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4626
4627 def __init__(self, xid=None, match=None, cookie=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None):
4628 self.xid = xid
4629 if match != None:
4630 self.match = match
4631 else:
4632 self.match = common.match()
4633 if cookie != None:
4634 self.cookie = cookie
4635 else:
4636 self.cookie = 0
4637 if idle_timeout != None:
4638 self.idle_timeout = idle_timeout
4639 else:
4640 self.idle_timeout = 0
4641 if hard_timeout != None:
4642 self.hard_timeout = hard_timeout
4643 else:
4644 self.hard_timeout = 0
4645 if priority != None:
4646 self.priority = priority
4647 else:
4648 self.priority = 0
4649 if buffer_id != None:
4650 self.buffer_id = buffer_id
4651 else:
4652 self.buffer_id = 0
4653 if out_port != None:
4654 self.out_port = out_port
4655 else:
4656 self.out_port = 0
4657 if flags != None:
4658 self.flags = flags
4659 else:
4660 self.flags = 0
4661 if actions != None:
4662 self.actions = actions
4663 else:
4664 self.actions = []
4665
4666 def pack(self):
4667 packed = []
4668 packed.append(struct.pack("!B", self.version))
4669 packed.append(struct.pack("!B", self.type))
4670 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4671 packed.append(struct.pack("!L", self.xid))
4672 packed.append(self.match.pack())
4673 packed.append(struct.pack("!Q", self.cookie))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4674 packed.append(util.pack_fm_cmd(self._command))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4675 packed.append(struct.pack("!H", self.idle_timeout))
4676 packed.append(struct.pack("!H", self.hard_timeout))
4677 packed.append(struct.pack("!H", self.priority))
4678 packed.append(struct.pack("!L", self.buffer_id))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4679 packed.append(util.pack_port_no(self.out_port))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4680 packed.append(struct.pack("!H", self.flags))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4681 packed.append(util.pack_list(self.actions))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4682 length = sum([len(x) for x in packed])
4683 packed[2] = struct.pack("!H", length)
4684 return ''.join(packed)
4685
4686 @staticmethod
4687 def unpack(buf):
4688 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
4689 obj = flow_modify()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4690 if type(buf) == loxi.generic_util.OFReader:
4691 reader = buf
4692 else:
4693 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4694 _version = reader.read("!B")[0]
4695 assert(_version == 1)
4696 _type = reader.read("!B")[0]
4697 assert(_type == 14)
4698 _length = reader.read("!H")[0]
4699 obj.xid = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4700 obj.match = common.match.unpack(reader)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4701 obj.cookie = reader.read("!Q")[0]
4702 __command = util.unpack_fm_cmd(reader)
4703 assert(__command == 1)
4704 obj.idle_timeout = reader.read("!H")[0]
4705 obj.hard_timeout = reader.read("!H")[0]
4706 obj.priority = reader.read("!H")[0]
4707 obj.buffer_id = reader.read("!L")[0]
4708 obj.out_port = util.unpack_port_no(reader)
4709 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4710 obj.actions = action.unpack_list(reader)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4711 return obj
4712
4713 def __eq__(self, other):
4714 if type(self) != type(other): return False
4715 if self.version != other.version: return False
4716 if self.type != other.type: return False
4717 if self.xid != other.xid: return False
4718 if self.match != other.match: return False
4719 if self.cookie != other.cookie: return False
4720 if self.idle_timeout != other.idle_timeout: return False
4721 if self.hard_timeout != other.hard_timeout: return False
4722 if self.priority != other.priority: return False
4723 if self.buffer_id != other.buffer_id: return False
4724 if self.out_port != other.out_port: return False
4725 if self.flags != other.flags: return False
4726 if self.actions != other.actions: return False
4727 return True
4728
4729 def __ne__(self, other):
4730 return not self.__eq__(other)
4731
4732 def __str__(self):
4733 return self.show()
4734
4735 def show(self):
4736 import loxi.pp
4737 return loxi.pp.pp(self)
4738
4739 def pretty_print(self, q):
4740 q.text("flow_modify {")
4741 with q.group():
4742 with q.indent(2):
4743 q.breakable()
4744 q.text("xid = ");
4745 if self.xid != None:
4746 q.text("%#x" % self.xid)
4747 else:
4748 q.text('None')
4749 q.text(","); q.breakable()
4750 q.text("match = ");
4751 q.pp(self.match)
4752 q.text(","); q.breakable()
4753 q.text("cookie = ");
4754 q.text("%#x" % self.cookie)
4755 q.text(","); q.breakable()
4756 q.text("idle_timeout = ");
4757 q.text("%#x" % self.idle_timeout)
4758 q.text(","); q.breakable()
4759 q.text("hard_timeout = ");
4760 q.text("%#x" % self.hard_timeout)
4761 q.text(","); q.breakable()
4762 q.text("priority = ");
4763 q.text("%#x" % self.priority)
4764 q.text(","); q.breakable()
4765 q.text("buffer_id = ");
4766 q.text("%#x" % self.buffer_id)
4767 q.text(","); q.breakable()
4768 q.text("out_port = ");
4769 q.text(util.pretty_port(self.out_port))
4770 q.text(","); q.breakable()
4771 q.text("flags = ");
4772 q.text("%#x" % self.flags)
4773 q.text(","); q.breakable()
4774 q.text("actions = ");
4775 q.pp(self.actions)
4776 q.breakable()
4777 q.text('}')
4778
4779class flow_modify_strict(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4780 version = 1
4781 type = 14
4782 _command = 2
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4783
4784 def __init__(self, xid=None, match=None, cookie=None, idle_timeout=None, hard_timeout=None, priority=None, buffer_id=None, out_port=None, flags=None, actions=None):
4785 self.xid = xid
4786 if match != None:
4787 self.match = match
4788 else:
4789 self.match = common.match()
4790 if cookie != None:
4791 self.cookie = cookie
4792 else:
4793 self.cookie = 0
4794 if idle_timeout != None:
4795 self.idle_timeout = idle_timeout
4796 else:
4797 self.idle_timeout = 0
4798 if hard_timeout != None:
4799 self.hard_timeout = hard_timeout
4800 else:
4801 self.hard_timeout = 0
4802 if priority != None:
4803 self.priority = priority
4804 else:
4805 self.priority = 0
4806 if buffer_id != None:
4807 self.buffer_id = buffer_id
4808 else:
4809 self.buffer_id = 0
4810 if out_port != None:
4811 self.out_port = out_port
4812 else:
4813 self.out_port = 0
4814 if flags != None:
4815 self.flags = flags
4816 else:
4817 self.flags = 0
4818 if actions != None:
4819 self.actions = actions
4820 else:
4821 self.actions = []
4822
4823 def pack(self):
4824 packed = []
4825 packed.append(struct.pack("!B", self.version))
4826 packed.append(struct.pack("!B", self.type))
4827 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4828 packed.append(struct.pack("!L", self.xid))
4829 packed.append(self.match.pack())
4830 packed.append(struct.pack("!Q", self.cookie))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4831 packed.append(util.pack_fm_cmd(self._command))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4832 packed.append(struct.pack("!H", self.idle_timeout))
4833 packed.append(struct.pack("!H", self.hard_timeout))
4834 packed.append(struct.pack("!H", self.priority))
4835 packed.append(struct.pack("!L", self.buffer_id))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4836 packed.append(util.pack_port_no(self.out_port))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4837 packed.append(struct.pack("!H", self.flags))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4838 packed.append(util.pack_list(self.actions))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4839 length = sum([len(x) for x in packed])
4840 packed[2] = struct.pack("!H", length)
4841 return ''.join(packed)
4842
4843 @staticmethod
4844 def unpack(buf):
4845 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
4846 obj = flow_modify_strict()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4847 if type(buf) == loxi.generic_util.OFReader:
4848 reader = buf
4849 else:
4850 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4851 _version = reader.read("!B")[0]
4852 assert(_version == 1)
4853 _type = reader.read("!B")[0]
4854 assert(_type == 14)
4855 _length = reader.read("!H")[0]
4856 obj.xid = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4857 obj.match = common.match.unpack(reader)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4858 obj.cookie = reader.read("!Q")[0]
4859 __command = util.unpack_fm_cmd(reader)
4860 assert(__command == 2)
4861 obj.idle_timeout = reader.read("!H")[0]
4862 obj.hard_timeout = reader.read("!H")[0]
4863 obj.priority = reader.read("!H")[0]
4864 obj.buffer_id = reader.read("!L")[0]
4865 obj.out_port = util.unpack_port_no(reader)
4866 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4867 obj.actions = action.unpack_list(reader)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4868 return obj
4869
4870 def __eq__(self, other):
4871 if type(self) != type(other): return False
4872 if self.version != other.version: return False
4873 if self.type != other.type: return False
4874 if self.xid != other.xid: return False
4875 if self.match != other.match: return False
4876 if self.cookie != other.cookie: return False
4877 if self.idle_timeout != other.idle_timeout: return False
4878 if self.hard_timeout != other.hard_timeout: return False
4879 if self.priority != other.priority: return False
4880 if self.buffer_id != other.buffer_id: return False
4881 if self.out_port != other.out_port: return False
4882 if self.flags != other.flags: return False
4883 if self.actions != other.actions: return False
4884 return True
4885
4886 def __ne__(self, other):
4887 return not self.__eq__(other)
4888
4889 def __str__(self):
4890 return self.show()
4891
4892 def show(self):
4893 import loxi.pp
4894 return loxi.pp.pp(self)
4895
4896 def pretty_print(self, q):
4897 q.text("flow_modify_strict {")
4898 with q.group():
4899 with q.indent(2):
4900 q.breakable()
4901 q.text("xid = ");
4902 if self.xid != None:
4903 q.text("%#x" % self.xid)
4904 else:
4905 q.text('None')
4906 q.text(","); q.breakable()
4907 q.text("match = ");
4908 q.pp(self.match)
4909 q.text(","); q.breakable()
4910 q.text("cookie = ");
4911 q.text("%#x" % self.cookie)
4912 q.text(","); q.breakable()
4913 q.text("idle_timeout = ");
4914 q.text("%#x" % self.idle_timeout)
4915 q.text(","); q.breakable()
4916 q.text("hard_timeout = ");
4917 q.text("%#x" % self.hard_timeout)
4918 q.text(","); q.breakable()
4919 q.text("priority = ");
4920 q.text("%#x" % self.priority)
4921 q.text(","); q.breakable()
4922 q.text("buffer_id = ");
4923 q.text("%#x" % self.buffer_id)
4924 q.text(","); q.breakable()
4925 q.text("out_port = ");
4926 q.text(util.pretty_port(self.out_port))
4927 q.text(","); q.breakable()
4928 q.text("flags = ");
4929 q.text("%#x" % self.flags)
4930 q.text(","); q.breakable()
4931 q.text("actions = ");
4932 q.pp(self.actions)
4933 q.breakable()
4934 q.text('}')
4935
4936class flow_removed(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]4937 version = 1
4938 type = 11
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4939
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4940 def __init__(self, xid=None, match=None, cookie=None, priority=None, reason=None, duration_sec=None, duration_nsec=None, idle_timeout=None, packet_count=None, byte_count=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4941 self.xid = xid
4942 if match != None:
4943 self.match = match
4944 else:
4945 self.match = common.match()
4946 if cookie != None:
4947 self.cookie = cookie
4948 else:
4949 self.cookie = 0
4950 if priority != None:
4951 self.priority = priority
4952 else:
4953 self.priority = 0
4954 if reason != None:
4955 self.reason = reason
4956 else:
4957 self.reason = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4958 if duration_sec != None:
4959 self.duration_sec = duration_sec
4960 else:
4961 self.duration_sec = 0
4962 if duration_nsec != None:
4963 self.duration_nsec = duration_nsec
4964 else:
4965 self.duration_nsec = 0
4966 if idle_timeout != None:
4967 self.idle_timeout = idle_timeout
4968 else:
4969 self.idle_timeout = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4970 if packet_count != None:
4971 self.packet_count = packet_count
4972 else:
4973 self.packet_count = 0
4974 if byte_count != None:
4975 self.byte_count = byte_count
4976 else:
4977 self.byte_count = 0
4978
4979 def pack(self):
4980 packed = []
4981 packed.append(struct.pack("!B", self.version))
4982 packed.append(struct.pack("!B", self.type))
4983 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
4984 packed.append(struct.pack("!L", self.xid))
4985 packed.append(self.match.pack())
4986 packed.append(struct.pack("!Q", self.cookie))
4987 packed.append(struct.pack("!H", self.priority))
4988 packed.append(struct.pack("!B", self.reason))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4989 packed.append('\x00' * 1)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4990 packed.append(struct.pack("!L", self.duration_sec))
4991 packed.append(struct.pack("!L", self.duration_nsec))
4992 packed.append(struct.pack("!H", self.idle_timeout))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]4993 packed.append('\x00' * 2)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]4994 packed.append(struct.pack("!Q", self.packet_count))
4995 packed.append(struct.pack("!Q", self.byte_count))
4996 length = sum([len(x) for x in packed])
4997 packed[2] = struct.pack("!H", length)
4998 return ''.join(packed)
4999
5000 @staticmethod
5001 def unpack(buf):
5002 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
5003 obj = flow_removed()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5004 if type(buf) == loxi.generic_util.OFReader:
5005 reader = buf
5006 else:
5007 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5008 _version = reader.read("!B")[0]
5009 assert(_version == 1)
5010 _type = reader.read("!B")[0]
5011 assert(_type == 11)
5012 _length = reader.read("!H")[0]
5013 obj.xid = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5014 obj.match = common.match.unpack(reader)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5015 obj.cookie = reader.read("!Q")[0]
5016 obj.priority = reader.read("!H")[0]
5017 obj.reason = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5018 reader.skip(1)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5019 obj.duration_sec = reader.read("!L")[0]
5020 obj.duration_nsec = reader.read("!L")[0]
5021 obj.idle_timeout = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5022 reader.skip(2)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5023 obj.packet_count = reader.read("!Q")[0]
5024 obj.byte_count = reader.read("!Q")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5025 return obj
5026
5027 def __eq__(self, other):
5028 if type(self) != type(other): return False
5029 if self.version != other.version: return False
5030 if self.type != other.type: return False
5031 if self.xid != other.xid: return False
5032 if self.match != other.match: return False
5033 if self.cookie != other.cookie: return False
5034 if self.priority != other.priority: return False
5035 if self.reason != other.reason: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5036 if self.duration_sec != other.duration_sec: return False
5037 if self.duration_nsec != other.duration_nsec: return False
5038 if self.idle_timeout != other.idle_timeout: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5039 if self.packet_count != other.packet_count: return False
5040 if self.byte_count != other.byte_count: return False
5041 return True
5042
5043 def __ne__(self, other):
5044 return not self.__eq__(other)
5045
5046 def __str__(self):
5047 return self.show()
5048
5049 def show(self):
5050 import loxi.pp
5051 return loxi.pp.pp(self)
5052
5053 def pretty_print(self, q):
5054 q.text("flow_removed {")
5055 with q.group():
5056 with q.indent(2):
5057 q.breakable()
5058 q.text("xid = ");
5059 if self.xid != None:
5060 q.text("%#x" % self.xid)
5061 else:
5062 q.text('None')
5063 q.text(","); q.breakable()
5064 q.text("match = ");
5065 q.pp(self.match)
5066 q.text(","); q.breakable()
5067 q.text("cookie = ");
5068 q.text("%#x" % self.cookie)
5069 q.text(","); q.breakable()
5070 q.text("priority = ");
5071 q.text("%#x" % self.priority)
5072 q.text(","); q.breakable()
5073 q.text("reason = ");
5074 q.text("%#x" % self.reason)
5075 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5076 q.text("duration_sec = ");
5077 q.text("%#x" % self.duration_sec)
5078 q.text(","); q.breakable()
5079 q.text("duration_nsec = ");
5080 q.text("%#x" % self.duration_nsec)
5081 q.text(","); q.breakable()
5082 q.text("idle_timeout = ");
5083 q.text("%#x" % self.idle_timeout)
5084 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5085 q.text("packet_count = ");
5086 q.text("%#x" % self.packet_count)
5087 q.text(","); q.breakable()
5088 q.text("byte_count = ");
5089 q.text("%#x" % self.byte_count)
5090 q.breakable()
5091 q.text('}')
5092
5093class flow_stats_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5094 version = 1
5095 type = 17
5096 stats_type = 1
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5097
5098 def __init__(self, xid=None, flags=None, entries=None):
5099 self.xid = xid
5100 if flags != None:
5101 self.flags = flags
5102 else:
5103 self.flags = 0
5104 if entries != None:
5105 self.entries = entries
5106 else:
5107 self.entries = []
5108
5109 def pack(self):
5110 packed = []
5111 packed.append(struct.pack("!B", self.version))
5112 packed.append(struct.pack("!B", self.type))
5113 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5114 packed.append(struct.pack("!L", self.xid))
5115 packed.append(struct.pack("!H", self.stats_type))
5116 packed.append(struct.pack("!H", self.flags))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5117 packed.append(util.pack_list(self.entries))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5118 length = sum([len(x) for x in packed])
5119 packed[2] = struct.pack("!H", length)
5120 return ''.join(packed)
5121
5122 @staticmethod
5123 def unpack(buf):
5124 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
5125 obj = flow_stats_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5126 if type(buf) == loxi.generic_util.OFReader:
5127 reader = buf
5128 else:
5129 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5130 _version = reader.read("!B")[0]
5131 assert(_version == 1)
5132 _type = reader.read("!B")[0]
5133 assert(_type == 17)
5134 _length = reader.read("!H")[0]
5135 obj.xid = reader.read("!L")[0]
5136 _stats_type = reader.read("!H")[0]
5137 assert(_stats_type == 1)
5138 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5139 obj.entries = common.unpack_list_flow_stats_entry(reader)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5140 return obj
5141
5142 def __eq__(self, other):
5143 if type(self) != type(other): return False
5144 if self.version != other.version: return False
5145 if self.type != other.type: return False
5146 if self.xid != other.xid: return False
5147 if self.flags != other.flags: return False
5148 if self.entries != other.entries: return False
5149 return True
5150
5151 def __ne__(self, other):
5152 return not self.__eq__(other)
5153
5154 def __str__(self):
5155 return self.show()
5156
5157 def show(self):
5158 import loxi.pp
5159 return loxi.pp.pp(self)
5160
5161 def pretty_print(self, q):
5162 q.text("flow_stats_reply {")
5163 with q.group():
5164 with q.indent(2):
5165 q.breakable()
5166 q.text("xid = ");
5167 if self.xid != None:
5168 q.text("%#x" % self.xid)
5169 else:
5170 q.text('None')
5171 q.text(","); q.breakable()
5172 q.text("flags = ");
5173 q.text("%#x" % self.flags)
5174 q.text(","); q.breakable()
5175 q.text("entries = ");
5176 q.pp(self.entries)
5177 q.breakable()
5178 q.text('}')
5179
5180class flow_stats_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5181 version = 1
5182 type = 16
5183 stats_type = 1
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5184
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5185 def __init__(self, xid=None, flags=None, match=None, table_id=None, out_port=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5186 self.xid = xid
5187 if flags != None:
5188 self.flags = flags
5189 else:
5190 self.flags = 0
5191 if match != None:
5192 self.match = match
5193 else:
5194 self.match = common.match()
5195 if table_id != None:
5196 self.table_id = table_id
5197 else:
5198 self.table_id = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5199 if out_port != None:
5200 self.out_port = out_port
5201 else:
5202 self.out_port = 0
5203
5204 def pack(self):
5205 packed = []
5206 packed.append(struct.pack("!B", self.version))
5207 packed.append(struct.pack("!B", self.type))
5208 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5209 packed.append(struct.pack("!L", self.xid))
5210 packed.append(struct.pack("!H", self.stats_type))
5211 packed.append(struct.pack("!H", self.flags))
5212 packed.append(self.match.pack())
5213 packed.append(struct.pack("!B", self.table_id))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5214 packed.append('\x00' * 1)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5215 packed.append(util.pack_port_no(self.out_port))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5216 length = sum([len(x) for x in packed])
5217 packed[2] = struct.pack("!H", length)
5218 return ''.join(packed)
5219
5220 @staticmethod
5221 def unpack(buf):
5222 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
5223 obj = flow_stats_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5224 if type(buf) == loxi.generic_util.OFReader:
5225 reader = buf
5226 else:
5227 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5228 _version = reader.read("!B")[0]
5229 assert(_version == 1)
5230 _type = reader.read("!B")[0]
5231 assert(_type == 16)
5232 _length = reader.read("!H")[0]
5233 obj.xid = reader.read("!L")[0]
5234 _stats_type = reader.read("!H")[0]
5235 assert(_stats_type == 1)
5236 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5237 obj.match = common.match.unpack(reader)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5238 obj.table_id = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5239 reader.skip(1)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5240 obj.out_port = util.unpack_port_no(reader)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5241 return obj
5242
5243 def __eq__(self, other):
5244 if type(self) != type(other): return False
5245 if self.version != other.version: return False
5246 if self.type != other.type: return False
5247 if self.xid != other.xid: return False
5248 if self.flags != other.flags: return False
5249 if self.match != other.match: return False
5250 if self.table_id != other.table_id: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5251 if self.out_port != other.out_port: return False
5252 return True
5253
5254 def __ne__(self, other):
5255 return not self.__eq__(other)
5256
5257 def __str__(self):
5258 return self.show()
5259
5260 def show(self):
5261 import loxi.pp
5262 return loxi.pp.pp(self)
5263
5264 def pretty_print(self, q):
5265 q.text("flow_stats_request {")
5266 with q.group():
5267 with q.indent(2):
5268 q.breakable()
5269 q.text("xid = ");
5270 if self.xid != None:
5271 q.text("%#x" % self.xid)
5272 else:
5273 q.text('None')
5274 q.text(","); q.breakable()
5275 q.text("flags = ");
5276 q.text("%#x" % self.flags)
5277 q.text(","); q.breakable()
5278 q.text("match = ");
5279 q.pp(self.match)
5280 q.text(","); q.breakable()
5281 q.text("table_id = ");
5282 q.text("%#x" % self.table_id)
5283 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5284 q.text("out_port = ");
5285 q.text(util.pretty_port(self.out_port))
5286 q.breakable()
5287 q.text('}')
5288
5289class get_config_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5290 version = 1
5291 type = 8
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5292
5293 def __init__(self, xid=None, flags=None, miss_send_len=None):
5294 self.xid = xid
5295 if flags != None:
5296 self.flags = flags
5297 else:
5298 self.flags = 0
5299 if miss_send_len != None:
5300 self.miss_send_len = miss_send_len
5301 else:
5302 self.miss_send_len = 0
5303
5304 def pack(self):
5305 packed = []
5306 packed.append(struct.pack("!B", self.version))
5307 packed.append(struct.pack("!B", self.type))
5308 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5309 packed.append(struct.pack("!L", self.xid))
5310 packed.append(struct.pack("!H", self.flags))
5311 packed.append(struct.pack("!H", self.miss_send_len))
5312 length = sum([len(x) for x in packed])
5313 packed[2] = struct.pack("!H", length)
5314 return ''.join(packed)
5315
5316 @staticmethod
5317 def unpack(buf):
5318 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
5319 obj = get_config_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5320 if type(buf) == loxi.generic_util.OFReader:
5321 reader = buf
5322 else:
5323 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5324 _version = reader.read("!B")[0]
5325 assert(_version == 1)
5326 _type = reader.read("!B")[0]
5327 assert(_type == 8)
5328 _length = reader.read("!H")[0]
5329 obj.xid = reader.read("!L")[0]
5330 obj.flags = reader.read("!H")[0]
5331 obj.miss_send_len = reader.read("!H")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5332 return obj
5333
5334 def __eq__(self, other):
5335 if type(self) != type(other): return False
5336 if self.version != other.version: return False
5337 if self.type != other.type: return False
5338 if self.xid != other.xid: return False
5339 if self.flags != other.flags: return False
5340 if self.miss_send_len != other.miss_send_len: return False
5341 return True
5342
5343 def __ne__(self, other):
5344 return not self.__eq__(other)
5345
5346 def __str__(self):
5347 return self.show()
5348
5349 def show(self):
5350 import loxi.pp
5351 return loxi.pp.pp(self)
5352
5353 def pretty_print(self, q):
5354 q.text("get_config_reply {")
5355 with q.group():
5356 with q.indent(2):
5357 q.breakable()
5358 q.text("xid = ");
5359 if self.xid != None:
5360 q.text("%#x" % self.xid)
5361 else:
5362 q.text('None')
5363 q.text(","); q.breakable()
5364 q.text("flags = ");
5365 q.text("%#x" % self.flags)
5366 q.text(","); q.breakable()
5367 q.text("miss_send_len = ");
5368 q.text("%#x" % self.miss_send_len)
5369 q.breakable()
5370 q.text('}')
5371
5372class get_config_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5373 version = 1
5374 type = 7
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5375
5376 def __init__(self, xid=None):
5377 self.xid = xid
5378
5379 def pack(self):
5380 packed = []
5381 packed.append(struct.pack("!B", self.version))
5382 packed.append(struct.pack("!B", self.type))
5383 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5384 packed.append(struct.pack("!L", self.xid))
5385 length = sum([len(x) for x in packed])
5386 packed[2] = struct.pack("!H", length)
5387 return ''.join(packed)
5388
5389 @staticmethod
5390 def unpack(buf):
5391 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
5392 obj = get_config_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5393 if type(buf) == loxi.generic_util.OFReader:
5394 reader = buf
5395 else:
5396 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5397 _version = reader.read("!B")[0]
5398 assert(_version == 1)
5399 _type = reader.read("!B")[0]
5400 assert(_type == 7)
5401 _length = reader.read("!H")[0]
5402 obj.xid = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5403 return obj
5404
5405 def __eq__(self, other):
5406 if type(self) != type(other): return False
5407 if self.version != other.version: return False
5408 if self.type != other.type: return False
5409 if self.xid != other.xid: return False
5410 return True
5411
5412 def __ne__(self, other):
5413 return not self.__eq__(other)
5414
5415 def __str__(self):
5416 return self.show()
5417
5418 def show(self):
5419 import loxi.pp
5420 return loxi.pp.pp(self)
5421
5422 def pretty_print(self, q):
5423 q.text("get_config_request {")
5424 with q.group():
5425 with q.indent(2):
5426 q.breakable()
5427 q.text("xid = ");
5428 if self.xid != None:
5429 q.text("%#x" % self.xid)
5430 else:
5431 q.text('None')
5432 q.breakable()
5433 q.text('}')
5434
5435class hello(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5436 version = 1
5437 type = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5438
5439 def __init__(self, xid=None):
5440 self.xid = xid
5441
5442 def pack(self):
5443 packed = []
5444 packed.append(struct.pack("!B", self.version))
5445 packed.append(struct.pack("!B", self.type))
5446 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5447 packed.append(struct.pack("!L", self.xid))
5448 length = sum([len(x) for x in packed])
5449 packed[2] = struct.pack("!H", length)
5450 return ''.join(packed)
5451
5452 @staticmethod
5453 def unpack(buf):
5454 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
5455 obj = hello()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5456 if type(buf) == loxi.generic_util.OFReader:
5457 reader = buf
5458 else:
5459 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5460 _version = reader.read("!B")[0]
5461 assert(_version == 1)
5462 _type = reader.read("!B")[0]
5463 assert(_type == 0)
5464 _length = reader.read("!H")[0]
5465 obj.xid = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5466 return obj
5467
5468 def __eq__(self, other):
5469 if type(self) != type(other): return False
5470 if self.version != other.version: return False
5471 if self.type != other.type: return False
5472 if self.xid != other.xid: return False
5473 return True
5474
5475 def __ne__(self, other):
5476 return not self.__eq__(other)
5477
5478 def __str__(self):
5479 return self.show()
5480
5481 def show(self):
5482 import loxi.pp
5483 return loxi.pp.pp(self)
5484
5485 def pretty_print(self, q):
5486 q.text("hello {")
5487 with q.group():
5488 with q.indent(2):
5489 q.breakable()
5490 q.text("xid = ");
5491 if self.xid != None:
5492 q.text("%#x" % self.xid)
5493 else:
5494 q.text('None')
5495 q.breakable()
5496 q.text('}')
5497
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]5498class hello_failed_error_msg(Message):
5499 version = 1
5500 type = 1
5501 err_type = 0
5502
5503 def __init__(self, xid=None, code=None, data=None):
5504 self.xid = xid
5505 if code != None:
5506 self.code = code
5507 else:
5508 self.code = 0
5509 if data != None:
5510 self.data = data
5511 else:
5512 self.data = ''
5513
5514 def pack(self):
5515 packed = []
5516 packed.append(struct.pack("!B", self.version))
5517 packed.append(struct.pack("!B", self.type))
5518 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5519 packed.append(struct.pack("!L", self.xid))
5520 packed.append(struct.pack("!H", self.err_type))
5521 packed.append(struct.pack("!H", self.code))
5522 packed.append(self.data)
5523 length = sum([len(x) for x in packed])
5524 packed[2] = struct.pack("!H", length)
5525 return ''.join(packed)
5526
5527 @staticmethod
5528 def unpack(buf):
5529 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
5530 obj = hello_failed_error_msg()
5531 if type(buf) == loxi.generic_util.OFReader:
5532 reader = buf
5533 else:
5534 reader = loxi.generic_util.OFReader(buf)
5535 _version = reader.read("!B")[0]
5536 assert(_version == 1)
5537 _type = reader.read("!B")[0]
5538 assert(_type == 1)
5539 _length = reader.read("!H")[0]
5540 obj.xid = reader.read("!L")[0]
5541 _err_type = reader.read("!H")[0]
5542 assert(_err_type == 0)
5543 obj.code = reader.read("!H")[0]
5544 obj.data = str(reader.read_all())
5545 return obj
5546
5547 def __eq__(self, other):
5548 if type(self) != type(other): return False
5549 if self.version != other.version: return False
5550 if self.type != other.type: return False
5551 if self.xid != other.xid: return False
5552 if self.code != other.code: return False
5553 if self.data != other.data: return False
5554 return True
5555
5556 def __ne__(self, other):
5557 return not self.__eq__(other)
5558
5559 def __str__(self):
5560 return self.show()
5561
5562 def show(self):
5563 import loxi.pp
5564 return loxi.pp.pp(self)
5565
5566 def pretty_print(self, q):
5567 q.text("hello_failed_error_msg {")
5568 with q.group():
5569 with q.indent(2):
5570 q.breakable()
5571 q.text("xid = ");
5572 if self.xid != None:
5573 q.text("%#x" % self.xid)
5574 else:
5575 q.text('None')
5576 q.text(","); q.breakable()
5577 q.text("code = ");
5578 q.text("%#x" % self.code)
5579 q.text(","); q.breakable()
5580 q.text("data = ");
5581 q.pp(self.data)
5582 q.breakable()
5583 q.text('}')
5584
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5585class nicira_controller_role_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5586 version = 1
5587 type = 4
5588 experimenter = 8992
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5589 subtype = 11
5590
5591 def __init__(self, xid=None, role=None):
5592 self.xid = xid
5593 if role != None:
5594 self.role = role
5595 else:
5596 self.role = 0
5597
5598 def pack(self):
5599 packed = []
5600 packed.append(struct.pack("!B", self.version))
5601 packed.append(struct.pack("!B", self.type))
5602 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5603 packed.append(struct.pack("!L", self.xid))
5604 packed.append(struct.pack("!L", self.experimenter))
5605 packed.append(struct.pack("!L", self.subtype))
5606 packed.append(struct.pack("!L", self.role))
5607 length = sum([len(x) for x in packed])
5608 packed[2] = struct.pack("!H", length)
5609 return ''.join(packed)
5610
5611 @staticmethod
5612 def unpack(buf):
5613 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
5614 obj = nicira_controller_role_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5615 if type(buf) == loxi.generic_util.OFReader:
5616 reader = buf
5617 else:
5618 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5619 _version = reader.read("!B")[0]
5620 assert(_version == 1)
5621 _type = reader.read("!B")[0]
5622 assert(_type == 4)
5623 _length = reader.read("!H")[0]
5624 obj.xid = reader.read("!L")[0]
5625 _experimenter = reader.read("!L")[0]
5626 assert(_experimenter == 8992)
5627 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5628 assert(_subtype == 11)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5629 obj.role = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5630 return obj
5631
5632 def __eq__(self, other):
5633 if type(self) != type(other): return False
5634 if self.version != other.version: return False
5635 if self.type != other.type: return False
5636 if self.xid != other.xid: return False
5637 if self.role != other.role: return False
5638 return True
5639
5640 def __ne__(self, other):
5641 return not self.__eq__(other)
5642
5643 def __str__(self):
5644 return self.show()
5645
5646 def show(self):
5647 import loxi.pp
5648 return loxi.pp.pp(self)
5649
5650 def pretty_print(self, q):
5651 q.text("nicira_controller_role_reply {")
5652 with q.group():
5653 with q.indent(2):
5654 q.breakable()
5655 q.text("xid = ");
5656 if self.xid != None:
5657 q.text("%#x" % self.xid)
5658 else:
5659 q.text('None')
5660 q.text(","); q.breakable()
5661 q.text("role = ");
5662 q.text("%#x" % self.role)
5663 q.breakable()
5664 q.text('}')
5665
5666class nicira_controller_role_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5667 version = 1
5668 type = 4
5669 experimenter = 8992
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5670 subtype = 10
5671
5672 def __init__(self, xid=None, role=None):
5673 self.xid = xid
5674 if role != None:
5675 self.role = role
5676 else:
5677 self.role = 0
5678
5679 def pack(self):
5680 packed = []
5681 packed.append(struct.pack("!B", self.version))
5682 packed.append(struct.pack("!B", self.type))
5683 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5684 packed.append(struct.pack("!L", self.xid))
5685 packed.append(struct.pack("!L", self.experimenter))
5686 packed.append(struct.pack("!L", self.subtype))
5687 packed.append(struct.pack("!L", self.role))
5688 length = sum([len(x) for x in packed])
5689 packed[2] = struct.pack("!H", length)
5690 return ''.join(packed)
5691
5692 @staticmethod
5693 def unpack(buf):
5694 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
5695 obj = nicira_controller_role_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5696 if type(buf) == loxi.generic_util.OFReader:
5697 reader = buf
5698 else:
5699 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5700 _version = reader.read("!B")[0]
5701 assert(_version == 1)
5702 _type = reader.read("!B")[0]
5703 assert(_type == 4)
5704 _length = reader.read("!H")[0]
5705 obj.xid = reader.read("!L")[0]
5706 _experimenter = reader.read("!L")[0]
5707 assert(_experimenter == 8992)
5708 _subtype = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5709 assert(_subtype == 10)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5710 obj.role = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5711 return obj
5712
5713 def __eq__(self, other):
5714 if type(self) != type(other): return False
5715 if self.version != other.version: return False
5716 if self.type != other.type: return False
5717 if self.xid != other.xid: return False
5718 if self.role != other.role: return False
5719 return True
5720
5721 def __ne__(self, other):
5722 return not self.__eq__(other)
5723
5724 def __str__(self):
5725 return self.show()
5726
5727 def show(self):
5728 import loxi.pp
5729 return loxi.pp.pp(self)
5730
5731 def pretty_print(self, q):
5732 q.text("nicira_controller_role_request {")
5733 with q.group():
5734 with q.indent(2):
5735 q.breakable()
5736 q.text("xid = ");
5737 if self.xid != None:
5738 q.text("%#x" % self.xid)
5739 else:
5740 q.text('None')
5741 q.text(","); q.breakable()
5742 q.text("role = ");
5743 q.text("%#x" % self.role)
5744 q.breakable()
5745 q.text('}')
5746
5747class packet_in(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5748 version = 1
5749 type = 10
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5750
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5751 def __init__(self, xid=None, buffer_id=None, total_len=None, in_port=None, reason=None, data=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5752 self.xid = xid
5753 if buffer_id != None:
5754 self.buffer_id = buffer_id
5755 else:
5756 self.buffer_id = 0
5757 if total_len != None:
5758 self.total_len = total_len
5759 else:
5760 self.total_len = 0
5761 if in_port != None:
5762 self.in_port = in_port
5763 else:
5764 self.in_port = 0
5765 if reason != None:
5766 self.reason = reason
5767 else:
5768 self.reason = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5769 if data != None:
5770 self.data = data
5771 else:
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5772 self.data = ''
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5773
5774 def pack(self):
5775 packed = []
5776 packed.append(struct.pack("!B", self.version))
5777 packed.append(struct.pack("!B", self.type))
5778 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
5779 packed.append(struct.pack("!L", self.xid))
5780 packed.append(struct.pack("!L", self.buffer_id))
5781 packed.append(struct.pack("!H", self.total_len))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5782 packed.append(util.pack_port_no(self.in_port))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5783 packed.append(struct.pack("!B", self.reason))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5784 packed.append('\x00' * 1)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5785 packed.append(self.data)
5786 length = sum([len(x) for x in packed])
5787 packed[2] = struct.pack("!H", length)
5788 return ''.join(packed)
5789
5790 @staticmethod
5791 def unpack(buf):
5792 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
5793 obj = packet_in()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5794 if type(buf) == loxi.generic_util.OFReader:
5795 reader = buf
5796 else:
5797 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5798 _version = reader.read("!B")[0]
5799 assert(_version == 1)
5800 _type = reader.read("!B")[0]
5801 assert(_type == 10)
5802 _length = reader.read("!H")[0]
5803 obj.xid = reader.read("!L")[0]
5804 obj.buffer_id = reader.read("!L")[0]
5805 obj.total_len = reader.read("!H")[0]
5806 obj.in_port = util.unpack_port_no(reader)
5807 obj.reason = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5808 reader.skip(1)
5809 obj.data = str(reader.read_all())
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5810 return obj
5811
5812 def __eq__(self, other):
5813 if type(self) != type(other): return False
5814 if self.version != other.version: return False
5815 if self.type != other.type: return False
5816 if self.xid != other.xid: return False
5817 if self.buffer_id != other.buffer_id: return False
5818 if self.total_len != other.total_len: return False
5819 if self.in_port != other.in_port: return False
5820 if self.reason != other.reason: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5821 if self.data != other.data: return False
5822 return True
5823
5824 def __ne__(self, other):
5825 return not self.__eq__(other)
5826
5827 def __str__(self):
5828 return self.show()
5829
5830 def show(self):
5831 import loxi.pp
5832 return loxi.pp.pp(self)
5833
5834 def pretty_print(self, q):
5835 q.text("packet_in {")
5836 with q.group():
5837 with q.indent(2):
5838 q.breakable()
5839 q.text("xid = ");
5840 if self.xid != None:
5841 q.text("%#x" % self.xid)
5842 else:
5843 q.text('None')
5844 q.text(","); q.breakable()
5845 q.text("buffer_id = ");
5846 q.text("%#x" % self.buffer_id)
5847 q.text(","); q.breakable()
5848 q.text("total_len = ");
5849 q.text("%#x" % self.total_len)
5850 q.text(","); q.breakable()
5851 q.text("in_port = ");
5852 q.text(util.pretty_port(self.in_port))
5853 q.text(","); q.breakable()
5854 q.text("reason = ");
5855 q.text("%#x" % self.reason)
5856 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5857 q.text("data = ");
5858 q.pp(self.data)
5859 q.breakable()
5860 q.text('}')
5861
5862class packet_out(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5863 version = 1
5864 type = 13
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5865
5866 def __init__(self, xid=None, buffer_id=None, in_port=None, actions=None, data=None):
5867 self.xid = xid
5868 if buffer_id != None:
5869 self.buffer_id = buffer_id
5870 else:
Rich Laneff637c92013-04-04 13:57:09 -0700[diff] [blame]5871 self.buffer_id = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5872 if in_port != None:
5873 self.in_port = in_port
5874 else:
5875 self.in_port = 0
5876 if actions != None:
5877 self.actions = actions
5878 else:
5879 self.actions = []
5880 if data != None:
5881 self.data = data
5882 else:
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5883 self.data = ''
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5884
5885 def pack(self):
5886 packed = []
5887 packed.append(struct.pack("!B", self.version))
5888 packed.append(struct.pack("!B", self.type))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5889 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5890 packed.append(struct.pack("!L", self.xid))
5891 packed.append(struct.pack("!L", self.buffer_id))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5892 packed.append(util.pack_port_no(self.in_port))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5893 packed.append(struct.pack("!H", 0)) # placeholder for actions_len at index 6
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5894 packed.append(util.pack_list(self.actions))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5895 packed[6] = struct.pack("!H", len(packed[-1]))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5896 packed.append(self.data)
5897 length = sum([len(x) for x in packed])
5898 packed[2] = struct.pack("!H", length)
5899 return ''.join(packed)
5900
5901 @staticmethod
5902 def unpack(buf):
5903 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
5904 obj = packet_out()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5905 if type(buf) == loxi.generic_util.OFReader:
5906 reader = buf
5907 else:
5908 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5909 _version = reader.read("!B")[0]
5910 assert(_version == 1)
5911 _type = reader.read("!B")[0]
5912 assert(_type == 13)
5913 _length = reader.read("!H")[0]
5914 obj.xid = reader.read("!L")[0]
5915 obj.buffer_id = reader.read("!L")[0]
5916 obj.in_port = util.unpack_port_no(reader)
5917 _actions_len = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5918 obj.actions = action.unpack_list(reader.slice(_actions_len))
5919 obj.data = str(reader.read_all())
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5920 return obj
5921
5922 def __eq__(self, other):
5923 if type(self) != type(other): return False
5924 if self.version != other.version: return False
5925 if self.type != other.type: return False
5926 if self.xid != other.xid: return False
5927 if self.buffer_id != other.buffer_id: return False
5928 if self.in_port != other.in_port: return False
5929 if self.actions != other.actions: return False
5930 if self.data != other.data: return False
5931 return True
5932
5933 def __ne__(self, other):
5934 return not self.__eq__(other)
5935
5936 def __str__(self):
5937 return self.show()
5938
5939 def show(self):
5940 import loxi.pp
5941 return loxi.pp.pp(self)
5942
5943 def pretty_print(self, q):
5944 q.text("packet_out {")
5945 with q.group():
5946 with q.indent(2):
5947 q.breakable()
5948 q.text("xid = ");
5949 if self.xid != None:
5950 q.text("%#x" % self.xid)
5951 else:
5952 q.text('None')
5953 q.text(","); q.breakable()
5954 q.text("buffer_id = ");
5955 q.text("%#x" % self.buffer_id)
5956 q.text(","); q.breakable()
5957 q.text("in_port = ");
5958 q.text(util.pretty_port(self.in_port))
5959 q.text(","); q.breakable()
5960 q.text("actions = ");
5961 q.pp(self.actions)
5962 q.text(","); q.breakable()
5963 q.text("data = ");
5964 q.pp(self.data)
5965 q.breakable()
5966 q.text('}')
5967
5968class port_mod(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]5969 version = 1
5970 type = 15
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5971
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]5972 def __init__(self, xid=None, port_no=None, hw_addr=None, config=None, mask=None, advertise=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5973 self.xid = xid
5974 if port_no != None:
5975 self.port_no = port_no
5976 else:
5977 self.port_no = 0
5978 if hw_addr != None:
5979 self.hw_addr = hw_addr
5980 else:
5981 self.hw_addr = [0,0,0,0,0,0]
5982 if config != None:
5983 self.config = config
5984 else:
5985 self.config = 0
5986 if mask != None:
5987 self.mask = mask
5988 else:
5989 self.mask = 0
5990 if advertise != None:
5991 self.advertise = advertise
5992 else:
5993 self.advertise = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]5994
5995 def pack(self):
5996 packed = []
5997 packed.append(struct.pack("!B", self.version))
5998 packed.append(struct.pack("!B", self.type))
5999 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6000 packed.append(struct.pack("!L", self.xid))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6001 packed.append(util.pack_port_no(self.port_no))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6002 packed.append(struct.pack("!6B", *self.hw_addr))
6003 packed.append(struct.pack("!L", self.config))
6004 packed.append(struct.pack("!L", self.mask))
6005 packed.append(struct.pack("!L", self.advertise))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6006 packed.append('\x00' * 4)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6007 length = sum([len(x) for x in packed])
6008 packed[2] = struct.pack("!H", length)
6009 return ''.join(packed)
6010
6011 @staticmethod
6012 def unpack(buf):
6013 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6014 obj = port_mod()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6015 if type(buf) == loxi.generic_util.OFReader:
6016 reader = buf
6017 else:
6018 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6019 _version = reader.read("!B")[0]
6020 assert(_version == 1)
6021 _type = reader.read("!B")[0]
6022 assert(_type == 15)
6023 _length = reader.read("!H")[0]
6024 obj.xid = reader.read("!L")[0]
6025 obj.port_no = util.unpack_port_no(reader)
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6026 obj.hw_addr = list(reader.read('!6B'))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6027 obj.config = reader.read("!L")[0]
6028 obj.mask = reader.read("!L")[0]
6029 obj.advertise = reader.read("!L")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6030 reader.skip(4)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6031 return obj
6032
6033 def __eq__(self, other):
6034 if type(self) != type(other): return False
6035 if self.version != other.version: return False
6036 if self.type != other.type: return False
6037 if self.xid != other.xid: return False
6038 if self.port_no != other.port_no: return False
6039 if self.hw_addr != other.hw_addr: return False
6040 if self.config != other.config: return False
6041 if self.mask != other.mask: return False
6042 if self.advertise != other.advertise: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6043 return True
6044
6045 def __ne__(self, other):
6046 return not self.__eq__(other)
6047
6048 def __str__(self):
6049 return self.show()
6050
6051 def show(self):
6052 import loxi.pp
6053 return loxi.pp.pp(self)
6054
6055 def pretty_print(self, q):
6056 q.text("port_mod {")
6057 with q.group():
6058 with q.indent(2):
6059 q.breakable()
6060 q.text("xid = ");
6061 if self.xid != None:
6062 q.text("%#x" % self.xid)
6063 else:
6064 q.text('None')
6065 q.text(","); q.breakable()
6066 q.text("port_no = ");
6067 q.text(util.pretty_port(self.port_no))
6068 q.text(","); q.breakable()
6069 q.text("hw_addr = ");
6070 q.text(util.pretty_mac(self.hw_addr))
6071 q.text(","); q.breakable()
6072 q.text("config = ");
6073 q.text("%#x" % self.config)
6074 q.text(","); q.breakable()
6075 q.text("mask = ");
6076 q.text("%#x" % self.mask)
6077 q.text(","); q.breakable()
6078 q.text("advertise = ");
6079 q.text("%#x" % self.advertise)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6080 q.breakable()
6081 q.text('}')
6082
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]6083class port_mod_failed_error_msg(Message):
6084 version = 1
6085 type = 1
6086 err_type = 4
6087
6088 def __init__(self, xid=None, code=None, data=None):
6089 self.xid = xid
6090 if code != None:
6091 self.code = code
6092 else:
6093 self.code = 0
6094 if data != None:
6095 self.data = data
6096 else:
6097 self.data = ''
6098
6099 def pack(self):
6100 packed = []
6101 packed.append(struct.pack("!B", self.version))
6102 packed.append(struct.pack("!B", self.type))
6103 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6104 packed.append(struct.pack("!L", self.xid))
6105 packed.append(struct.pack("!H", self.err_type))
6106 packed.append(struct.pack("!H", self.code))
6107 packed.append(self.data)
6108 length = sum([len(x) for x in packed])
6109 packed[2] = struct.pack("!H", length)
6110 return ''.join(packed)
6111
6112 @staticmethod
6113 def unpack(buf):
6114 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6115 obj = port_mod_failed_error_msg()
6116 if type(buf) == loxi.generic_util.OFReader:
6117 reader = buf
6118 else:
6119 reader = loxi.generic_util.OFReader(buf)
6120 _version = reader.read("!B")[0]
6121 assert(_version == 1)
6122 _type = reader.read("!B")[0]
6123 assert(_type == 1)
6124 _length = reader.read("!H")[0]
6125 obj.xid = reader.read("!L")[0]
6126 _err_type = reader.read("!H")[0]
6127 assert(_err_type == 4)
6128 obj.code = reader.read("!H")[0]
6129 obj.data = str(reader.read_all())
6130 return obj
6131
6132 def __eq__(self, other):
6133 if type(self) != type(other): return False
6134 if self.version != other.version: return False
6135 if self.type != other.type: return False
6136 if self.xid != other.xid: return False
6137 if self.code != other.code: return False
6138 if self.data != other.data: return False
6139 return True
6140
6141 def __ne__(self, other):
6142 return not self.__eq__(other)
6143
6144 def __str__(self):
6145 return self.show()
6146
6147 def show(self):
6148 import loxi.pp
6149 return loxi.pp.pp(self)
6150
6151 def pretty_print(self, q):
6152 q.text("port_mod_failed_error_msg {")
6153 with q.group():
6154 with q.indent(2):
6155 q.breakable()
6156 q.text("xid = ");
6157 if self.xid != None:
6158 q.text("%#x" % self.xid)
6159 else:
6160 q.text('None')
6161 q.text(","); q.breakable()
6162 q.text("code = ");
6163 q.text("%#x" % self.code)
6164 q.text(","); q.breakable()
6165 q.text("data = ");
6166 q.pp(self.data)
6167 q.breakable()
6168 q.text('}')
6169
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6170class port_stats_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6171 version = 1
6172 type = 17
6173 stats_type = 4
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6174
6175 def __init__(self, xid=None, flags=None, entries=None):
6176 self.xid = xid
6177 if flags != None:
6178 self.flags = flags
6179 else:
6180 self.flags = 0
6181 if entries != None:
6182 self.entries = entries
6183 else:
6184 self.entries = []
6185
6186 def pack(self):
6187 packed = []
6188 packed.append(struct.pack("!B", self.version))
6189 packed.append(struct.pack("!B", self.type))
6190 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6191 packed.append(struct.pack("!L", self.xid))
6192 packed.append(struct.pack("!H", self.stats_type))
6193 packed.append(struct.pack("!H", self.flags))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6194 packed.append(util.pack_list(self.entries))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6195 length = sum([len(x) for x in packed])
6196 packed[2] = struct.pack("!H", length)
6197 return ''.join(packed)
6198
6199 @staticmethod
6200 def unpack(buf):
6201 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6202 obj = port_stats_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6203 if type(buf) == loxi.generic_util.OFReader:
6204 reader = buf
6205 else:
6206 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6207 _version = reader.read("!B")[0]
6208 assert(_version == 1)
6209 _type = reader.read("!B")[0]
6210 assert(_type == 17)
6211 _length = reader.read("!H")[0]
6212 obj.xid = reader.read("!L")[0]
6213 _stats_type = reader.read("!H")[0]
6214 assert(_stats_type == 4)
6215 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6216 obj.entries = loxi.generic_util.unpack_list(reader, common.port_stats_entry.unpack)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6217 return obj
6218
6219 def __eq__(self, other):
6220 if type(self) != type(other): return False
6221 if self.version != other.version: return False
6222 if self.type != other.type: return False
6223 if self.xid != other.xid: return False
6224 if self.flags != other.flags: return False
6225 if self.entries != other.entries: return False
6226 return True
6227
6228 def __ne__(self, other):
6229 return not self.__eq__(other)
6230
6231 def __str__(self):
6232 return self.show()
6233
6234 def show(self):
6235 import loxi.pp
6236 return loxi.pp.pp(self)
6237
6238 def pretty_print(self, q):
6239 q.text("port_stats_reply {")
6240 with q.group():
6241 with q.indent(2):
6242 q.breakable()
6243 q.text("xid = ");
6244 if self.xid != None:
6245 q.text("%#x" % self.xid)
6246 else:
6247 q.text('None')
6248 q.text(","); q.breakable()
6249 q.text("flags = ");
6250 q.text("%#x" % self.flags)
6251 q.text(","); q.breakable()
6252 q.text("entries = ");
6253 q.pp(self.entries)
6254 q.breakable()
6255 q.text('}')
6256
6257class port_stats_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6258 version = 1
6259 type = 16
6260 stats_type = 4
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6261
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6262 def __init__(self, xid=None, flags=None, port_no=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6263 self.xid = xid
6264 if flags != None:
6265 self.flags = flags
6266 else:
6267 self.flags = 0
6268 if port_no != None:
6269 self.port_no = port_no
6270 else:
6271 self.port_no = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6272
6273 def pack(self):
6274 packed = []
6275 packed.append(struct.pack("!B", self.version))
6276 packed.append(struct.pack("!B", self.type))
6277 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6278 packed.append(struct.pack("!L", self.xid))
6279 packed.append(struct.pack("!H", self.stats_type))
6280 packed.append(struct.pack("!H", self.flags))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6281 packed.append(util.pack_port_no(self.port_no))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6282 packed.append('\x00' * 6)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6283 length = sum([len(x) for x in packed])
6284 packed[2] = struct.pack("!H", length)
6285 return ''.join(packed)
6286
6287 @staticmethod
6288 def unpack(buf):
6289 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6290 obj = port_stats_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6291 if type(buf) == loxi.generic_util.OFReader:
6292 reader = buf
6293 else:
6294 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6295 _version = reader.read("!B")[0]
6296 assert(_version == 1)
6297 _type = reader.read("!B")[0]
6298 assert(_type == 16)
6299 _length = reader.read("!H")[0]
6300 obj.xid = reader.read("!L")[0]
6301 _stats_type = reader.read("!H")[0]
6302 assert(_stats_type == 4)
6303 obj.flags = reader.read("!H")[0]
6304 obj.port_no = util.unpack_port_no(reader)
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6305 reader.skip(6)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6306 return obj
6307
6308 def __eq__(self, other):
6309 if type(self) != type(other): return False
6310 if self.version != other.version: return False
6311 if self.type != other.type: return False
6312 if self.xid != other.xid: return False
6313 if self.flags != other.flags: return False
6314 if self.port_no != other.port_no: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6315 return True
6316
6317 def __ne__(self, other):
6318 return not self.__eq__(other)
6319
6320 def __str__(self):
6321 return self.show()
6322
6323 def show(self):
6324 import loxi.pp
6325 return loxi.pp.pp(self)
6326
6327 def pretty_print(self, q):
6328 q.text("port_stats_request {")
6329 with q.group():
6330 with q.indent(2):
6331 q.breakable()
6332 q.text("xid = ");
6333 if self.xid != None:
6334 q.text("%#x" % self.xid)
6335 else:
6336 q.text('None')
6337 q.text(","); q.breakable()
6338 q.text("flags = ");
6339 q.text("%#x" % self.flags)
6340 q.text(","); q.breakable()
6341 q.text("port_no = ");
6342 q.text(util.pretty_port(self.port_no))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6343 q.breakable()
6344 q.text('}')
6345
6346class port_status(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6347 version = 1
6348 type = 12
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6349
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6350 def __init__(self, xid=None, reason=None, desc=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6351 self.xid = xid
6352 if reason != None:
6353 self.reason = reason
6354 else:
6355 self.reason = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6356 if desc != None:
6357 self.desc = desc
6358 else:
6359 self.desc = common.port_desc()
6360
6361 def pack(self):
6362 packed = []
6363 packed.append(struct.pack("!B", self.version))
6364 packed.append(struct.pack("!B", self.type))
6365 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6366 packed.append(struct.pack("!L", self.xid))
6367 packed.append(struct.pack("!B", self.reason))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6368 packed.append('\x00' * 7)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6369 packed.append(self.desc.pack())
6370 length = sum([len(x) for x in packed])
6371 packed[2] = struct.pack("!H", length)
6372 return ''.join(packed)
6373
6374 @staticmethod
6375 def unpack(buf):
6376 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6377 obj = port_status()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6378 if type(buf) == loxi.generic_util.OFReader:
6379 reader = buf
6380 else:
6381 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6382 _version = reader.read("!B")[0]
6383 assert(_version == 1)
6384 _type = reader.read("!B")[0]
6385 assert(_type == 12)
6386 _length = reader.read("!H")[0]
6387 obj.xid = reader.read("!L")[0]
6388 obj.reason = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6389 reader.skip(7)
6390 obj.desc = common.port_desc.unpack(reader)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6391 return obj
6392
6393 def __eq__(self, other):
6394 if type(self) != type(other): return False
6395 if self.version != other.version: return False
6396 if self.type != other.type: return False
6397 if self.xid != other.xid: return False
6398 if self.reason != other.reason: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6399 if self.desc != other.desc: return False
6400 return True
6401
6402 def __ne__(self, other):
6403 return not self.__eq__(other)
6404
6405 def __str__(self):
6406 return self.show()
6407
6408 def show(self):
6409 import loxi.pp
6410 return loxi.pp.pp(self)
6411
6412 def pretty_print(self, q):
6413 q.text("port_status {")
6414 with q.group():
6415 with q.indent(2):
6416 q.breakable()
6417 q.text("xid = ");
6418 if self.xid != None:
6419 q.text("%#x" % self.xid)
6420 else:
6421 q.text('None')
6422 q.text(","); q.breakable()
6423 q.text("reason = ");
6424 q.text("%#x" % self.reason)
6425 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6426 q.text("desc = ");
6427 q.pp(self.desc)
6428 q.breakable()
6429 q.text('}')
6430
6431class queue_get_config_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6432 version = 1
6433 type = 21
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6434
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6435 def __init__(self, xid=None, port=None, queues=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6436 self.xid = xid
6437 if port != None:
6438 self.port = port
6439 else:
6440 self.port = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6441 if queues != None:
6442 self.queues = queues
6443 else:
6444 self.queues = []
6445
6446 def pack(self):
6447 packed = []
6448 packed.append(struct.pack("!B", self.version))
6449 packed.append(struct.pack("!B", self.type))
6450 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6451 packed.append(struct.pack("!L", self.xid))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6452 packed.append(util.pack_port_no(self.port))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6453 packed.append('\x00' * 6)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6454 packed.append(util.pack_list(self.queues))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6455 length = sum([len(x) for x in packed])
6456 packed[2] = struct.pack("!H", length)
6457 return ''.join(packed)
6458
6459 @staticmethod
6460 def unpack(buf):
6461 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6462 obj = queue_get_config_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6463 if type(buf) == loxi.generic_util.OFReader:
6464 reader = buf
6465 else:
6466 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6467 _version = reader.read("!B")[0]
6468 assert(_version == 1)
6469 _type = reader.read("!B")[0]
6470 assert(_type == 21)
6471 _length = reader.read("!H")[0]
6472 obj.xid = reader.read("!L")[0]
6473 obj.port = util.unpack_port_no(reader)
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6474 reader.skip(6)
6475 obj.queues = common.unpack_list_packet_queue(reader)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6476 return obj
6477
6478 def __eq__(self, other):
6479 if type(self) != type(other): return False
6480 if self.version != other.version: return False
6481 if self.type != other.type: return False
6482 if self.xid != other.xid: return False
6483 if self.port != other.port: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6484 if self.queues != other.queues: return False
6485 return True
6486
6487 def __ne__(self, other):
6488 return not self.__eq__(other)
6489
6490 def __str__(self):
6491 return self.show()
6492
6493 def show(self):
6494 import loxi.pp
6495 return loxi.pp.pp(self)
6496
6497 def pretty_print(self, q):
6498 q.text("queue_get_config_reply {")
6499 with q.group():
6500 with q.indent(2):
6501 q.breakable()
6502 q.text("xid = ");
6503 if self.xid != None:
6504 q.text("%#x" % self.xid)
6505 else:
6506 q.text('None')
6507 q.text(","); q.breakable()
6508 q.text("port = ");
6509 q.text(util.pretty_port(self.port))
6510 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6511 q.text("queues = ");
6512 q.pp(self.queues)
6513 q.breakable()
6514 q.text('}')
6515
6516class queue_get_config_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6517 version = 1
6518 type = 20
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6519
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6520 def __init__(self, xid=None, port=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6521 self.xid = xid
6522 if port != None:
6523 self.port = port
6524 else:
6525 self.port = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6526
6527 def pack(self):
6528 packed = []
6529 packed.append(struct.pack("!B", self.version))
6530 packed.append(struct.pack("!B", self.type))
6531 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6532 packed.append(struct.pack("!L", self.xid))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6533 packed.append(util.pack_port_no(self.port))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6534 packed.append('\x00' * 2)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6535 length = sum([len(x) for x in packed])
6536 packed[2] = struct.pack("!H", length)
6537 return ''.join(packed)
6538
6539 @staticmethod
6540 def unpack(buf):
6541 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6542 obj = queue_get_config_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6543 if type(buf) == loxi.generic_util.OFReader:
6544 reader = buf
6545 else:
6546 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6547 _version = reader.read("!B")[0]
6548 assert(_version == 1)
6549 _type = reader.read("!B")[0]
6550 assert(_type == 20)
6551 _length = reader.read("!H")[0]
6552 obj.xid = reader.read("!L")[0]
6553 obj.port = util.unpack_port_no(reader)
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6554 reader.skip(2)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6555 return obj
6556
6557 def __eq__(self, other):
6558 if type(self) != type(other): return False
6559 if self.version != other.version: return False
6560 if self.type != other.type: return False
6561 if self.xid != other.xid: return False
6562 if self.port != other.port: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6563 return True
6564
6565 def __ne__(self, other):
6566 return not self.__eq__(other)
6567
6568 def __str__(self):
6569 return self.show()
6570
6571 def show(self):
6572 import loxi.pp
6573 return loxi.pp.pp(self)
6574
6575 def pretty_print(self, q):
6576 q.text("queue_get_config_request {")
6577 with q.group():
6578 with q.indent(2):
6579 q.breakable()
6580 q.text("xid = ");
6581 if self.xid != None:
6582 q.text("%#x" % self.xid)
6583 else:
6584 q.text('None')
6585 q.text(","); q.breakable()
6586 q.text("port = ");
6587 q.text(util.pretty_port(self.port))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6588 q.breakable()
6589 q.text('}')
6590
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]6591class queue_op_failed_error_msg(Message):
6592 version = 1
6593 type = 1
6594 err_type = 5
6595
6596 def __init__(self, xid=None, code=None, data=None):
6597 self.xid = xid
6598 if code != None:
6599 self.code = code
6600 else:
6601 self.code = 0
6602 if data != None:
6603 self.data = data
6604 else:
6605 self.data = ''
6606
6607 def pack(self):
6608 packed = []
6609 packed.append(struct.pack("!B", self.version))
6610 packed.append(struct.pack("!B", self.type))
6611 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6612 packed.append(struct.pack("!L", self.xid))
6613 packed.append(struct.pack("!H", self.err_type))
6614 packed.append(struct.pack("!H", self.code))
6615 packed.append(self.data)
6616 length = sum([len(x) for x in packed])
6617 packed[2] = struct.pack("!H", length)
6618 return ''.join(packed)
6619
6620 @staticmethod
6621 def unpack(buf):
6622 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6623 obj = queue_op_failed_error_msg()
6624 if type(buf) == loxi.generic_util.OFReader:
6625 reader = buf
6626 else:
6627 reader = loxi.generic_util.OFReader(buf)
6628 _version = reader.read("!B")[0]
6629 assert(_version == 1)
6630 _type = reader.read("!B")[0]
6631 assert(_type == 1)
6632 _length = reader.read("!H")[0]
6633 obj.xid = reader.read("!L")[0]
6634 _err_type = reader.read("!H")[0]
6635 assert(_err_type == 5)
6636 obj.code = reader.read("!H")[0]
6637 obj.data = str(reader.read_all())
6638 return obj
6639
6640 def __eq__(self, other):
6641 if type(self) != type(other): return False
6642 if self.version != other.version: return False
6643 if self.type != other.type: return False
6644 if self.xid != other.xid: return False
6645 if self.code != other.code: return False
6646 if self.data != other.data: return False
6647 return True
6648
6649 def __ne__(self, other):
6650 return not self.__eq__(other)
6651
6652 def __str__(self):
6653 return self.show()
6654
6655 def show(self):
6656 import loxi.pp
6657 return loxi.pp.pp(self)
6658
6659 def pretty_print(self, q):
6660 q.text("queue_op_failed_error_msg {")
6661 with q.group():
6662 with q.indent(2):
6663 q.breakable()
6664 q.text("xid = ");
6665 if self.xid != None:
6666 q.text("%#x" % self.xid)
6667 else:
6668 q.text('None')
6669 q.text(","); q.breakable()
6670 q.text("code = ");
6671 q.text("%#x" % self.code)
6672 q.text(","); q.breakable()
6673 q.text("data = ");
6674 q.pp(self.data)
6675 q.breakable()
6676 q.text('}')
6677
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6678class queue_stats_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6679 version = 1
6680 type = 17
6681 stats_type = 5
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6682
6683 def __init__(self, xid=None, flags=None, entries=None):
6684 self.xid = xid
6685 if flags != None:
6686 self.flags = flags
6687 else:
6688 self.flags = 0
6689 if entries != None:
6690 self.entries = entries
6691 else:
6692 self.entries = []
6693
6694 def pack(self):
6695 packed = []
6696 packed.append(struct.pack("!B", self.version))
6697 packed.append(struct.pack("!B", self.type))
6698 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6699 packed.append(struct.pack("!L", self.xid))
6700 packed.append(struct.pack("!H", self.stats_type))
6701 packed.append(struct.pack("!H", self.flags))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6702 packed.append(util.pack_list(self.entries))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6703 length = sum([len(x) for x in packed])
6704 packed[2] = struct.pack("!H", length)
6705 return ''.join(packed)
6706
6707 @staticmethod
6708 def unpack(buf):
6709 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6710 obj = queue_stats_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6711 if type(buf) == loxi.generic_util.OFReader:
6712 reader = buf
6713 else:
6714 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6715 _version = reader.read("!B")[0]
6716 assert(_version == 1)
6717 _type = reader.read("!B")[0]
6718 assert(_type == 17)
6719 _length = reader.read("!H")[0]
6720 obj.xid = reader.read("!L")[0]
6721 _stats_type = reader.read("!H")[0]
6722 assert(_stats_type == 5)
6723 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6724 obj.entries = loxi.generic_util.unpack_list(reader, common.queue_stats_entry.unpack)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6725 return obj
6726
6727 def __eq__(self, other):
6728 if type(self) != type(other): return False
6729 if self.version != other.version: return False
6730 if self.type != other.type: return False
6731 if self.xid != other.xid: return False
6732 if self.flags != other.flags: return False
6733 if self.entries != other.entries: return False
6734 return True
6735
6736 def __ne__(self, other):
6737 return not self.__eq__(other)
6738
6739 def __str__(self):
6740 return self.show()
6741
6742 def show(self):
6743 import loxi.pp
6744 return loxi.pp.pp(self)
6745
6746 def pretty_print(self, q):
6747 q.text("queue_stats_reply {")
6748 with q.group():
6749 with q.indent(2):
6750 q.breakable()
6751 q.text("xid = ");
6752 if self.xid != None:
6753 q.text("%#x" % self.xid)
6754 else:
6755 q.text('None')
6756 q.text(","); q.breakable()
6757 q.text("flags = ");
6758 q.text("%#x" % self.flags)
6759 q.text(","); q.breakable()
6760 q.text("entries = ");
6761 q.pp(self.entries)
6762 q.breakable()
6763 q.text('}')
6764
6765class queue_stats_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6766 version = 1
6767 type = 16
6768 stats_type = 5
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6769
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6770 def __init__(self, xid=None, flags=None, port_no=None, queue_id=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6771 self.xid = xid
6772 if flags != None:
6773 self.flags = flags
6774 else:
6775 self.flags = 0
6776 if port_no != None:
6777 self.port_no = port_no
6778 else:
6779 self.port_no = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6780 if queue_id != None:
6781 self.queue_id = queue_id
6782 else:
6783 self.queue_id = 0
6784
6785 def pack(self):
6786 packed = []
6787 packed.append(struct.pack("!B", self.version))
6788 packed.append(struct.pack("!B", self.type))
6789 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6790 packed.append(struct.pack("!L", self.xid))
6791 packed.append(struct.pack("!H", self.stats_type))
6792 packed.append(struct.pack("!H", self.flags))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6793 packed.append(util.pack_port_no(self.port_no))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6794 packed.append('\x00' * 2)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6795 packed.append(struct.pack("!L", self.queue_id))
6796 length = sum([len(x) for x in packed])
6797 packed[2] = struct.pack("!H", length)
6798 return ''.join(packed)
6799
6800 @staticmethod
6801 def unpack(buf):
6802 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6803 obj = queue_stats_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6804 if type(buf) == loxi.generic_util.OFReader:
6805 reader = buf
6806 else:
6807 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6808 _version = reader.read("!B")[0]
6809 assert(_version == 1)
6810 _type = reader.read("!B")[0]
6811 assert(_type == 16)
6812 _length = reader.read("!H")[0]
6813 obj.xid = reader.read("!L")[0]
6814 _stats_type = reader.read("!H")[0]
6815 assert(_stats_type == 5)
6816 obj.flags = reader.read("!H")[0]
6817 obj.port_no = util.unpack_port_no(reader)
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6818 reader.skip(2)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6819 obj.queue_id = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6820 return obj
6821
6822 def __eq__(self, other):
6823 if type(self) != type(other): return False
6824 if self.version != other.version: return False
6825 if self.type != other.type: return False
6826 if self.xid != other.xid: return False
6827 if self.flags != other.flags: return False
6828 if self.port_no != other.port_no: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6829 if self.queue_id != other.queue_id: return False
6830 return True
6831
6832 def __ne__(self, other):
6833 return not self.__eq__(other)
6834
6835 def __str__(self):
6836 return self.show()
6837
6838 def show(self):
6839 import loxi.pp
6840 return loxi.pp.pp(self)
6841
6842 def pretty_print(self, q):
6843 q.text("queue_stats_request {")
6844 with q.group():
6845 with q.indent(2):
6846 q.breakable()
6847 q.text("xid = ");
6848 if self.xid != None:
6849 q.text("%#x" % self.xid)
6850 else:
6851 q.text('None')
6852 q.text(","); q.breakable()
6853 q.text("flags = ");
6854 q.text("%#x" % self.flags)
6855 q.text(","); q.breakable()
6856 q.text("port_no = ");
6857 q.text(util.pretty_port(self.port_no))
6858 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6859 q.text("queue_id = ");
6860 q.text("%#x" % self.queue_id)
6861 q.breakable()
6862 q.text('}')
6863
6864class set_config(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6865 version = 1
6866 type = 9
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6867
6868 def __init__(self, xid=None, flags=None, miss_send_len=None):
6869 self.xid = xid
6870 if flags != None:
6871 self.flags = flags
6872 else:
6873 self.flags = 0
6874 if miss_send_len != None:
6875 self.miss_send_len = miss_send_len
6876 else:
6877 self.miss_send_len = 0
6878
6879 def pack(self):
6880 packed = []
6881 packed.append(struct.pack("!B", self.version))
6882 packed.append(struct.pack("!B", self.type))
6883 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6884 packed.append(struct.pack("!L", self.xid))
6885 packed.append(struct.pack("!H", self.flags))
6886 packed.append(struct.pack("!H", self.miss_send_len))
6887 length = sum([len(x) for x in packed])
6888 packed[2] = struct.pack("!H", length)
6889 return ''.join(packed)
6890
6891 @staticmethod
6892 def unpack(buf):
6893 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6894 obj = set_config()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6895 if type(buf) == loxi.generic_util.OFReader:
6896 reader = buf
6897 else:
6898 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6899 _version = reader.read("!B")[0]
6900 assert(_version == 1)
6901 _type = reader.read("!B")[0]
6902 assert(_type == 9)
6903 _length = reader.read("!H")[0]
6904 obj.xid = reader.read("!L")[0]
6905 obj.flags = reader.read("!H")[0]
6906 obj.miss_send_len = reader.read("!H")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6907 return obj
6908
6909 def __eq__(self, other):
6910 if type(self) != type(other): return False
6911 if self.version != other.version: return False
6912 if self.type != other.type: return False
6913 if self.xid != other.xid: return False
6914 if self.flags != other.flags: return False
6915 if self.miss_send_len != other.miss_send_len: return False
6916 return True
6917
6918 def __ne__(self, other):
6919 return not self.__eq__(other)
6920
6921 def __str__(self):
6922 return self.show()
6923
6924 def show(self):
6925 import loxi.pp
6926 return loxi.pp.pp(self)
6927
6928 def pretty_print(self, q):
6929 q.text("set_config {")
6930 with q.group():
6931 with q.indent(2):
6932 q.breakable()
6933 q.text("xid = ");
6934 if self.xid != None:
6935 q.text("%#x" % self.xid)
6936 else:
6937 q.text('None')
6938 q.text(","); q.breakable()
6939 q.text("flags = ");
6940 q.text("%#x" % self.flags)
6941 q.text(","); q.breakable()
6942 q.text("miss_send_len = ");
6943 q.text("%#x" % self.miss_send_len)
6944 q.breakable()
6945 q.text('}')
6946
6947class table_mod(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6948 version = 1
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6949 type = 22
6950
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6951 def __init__(self, xid=None, table_id=None, config=None):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6952 self.xid = xid
6953 if table_id != None:
6954 self.table_id = table_id
6955 else:
6956 self.table_id = 0
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6957 if config != None:
6958 self.config = config
6959 else:
6960 self.config = 0
6961
6962 def pack(self):
6963 packed = []
6964 packed.append(struct.pack("!B", self.version))
6965 packed.append(struct.pack("!B", self.type))
6966 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
6967 packed.append(struct.pack("!L", self.xid))
6968 packed.append(struct.pack("!B", self.table_id))
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6969 packed.append('\x00' * 3)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6970 packed.append(struct.pack("!L", self.config))
6971 length = sum([len(x) for x in packed])
6972 packed[2] = struct.pack("!H", length)
6973 return ''.join(packed)
6974
6975 @staticmethod
6976 def unpack(buf):
6977 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
6978 obj = table_mod()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6979 if type(buf) == loxi.generic_util.OFReader:
6980 reader = buf
6981 else:
6982 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6983 _version = reader.read("!B")[0]
6984 assert(_version == 1)
6985 _type = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6986 assert(_type == 22)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6987 _length = reader.read("!H")[0]
6988 obj.xid = reader.read("!L")[0]
6989 obj.table_id = reader.read("!B")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]6990 reader.skip(3)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]6991 obj.config = reader.read("!L")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]6992 return obj
6993
6994 def __eq__(self, other):
6995 if type(self) != type(other): return False
6996 if self.version != other.version: return False
6997 if self.type != other.type: return False
6998 if self.xid != other.xid: return False
6999 if self.table_id != other.table_id: return False
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7000 if self.config != other.config: return False
7001 return True
7002
7003 def __ne__(self, other):
7004 return not self.__eq__(other)
7005
7006 def __str__(self):
7007 return self.show()
7008
7009 def show(self):
7010 import loxi.pp
7011 return loxi.pp.pp(self)
7012
7013 def pretty_print(self, q):
7014 q.text("table_mod {")
7015 with q.group():
7016 with q.indent(2):
7017 q.breakable()
7018 q.text("xid = ");
7019 if self.xid != None:
7020 q.text("%#x" % self.xid)
7021 else:
7022 q.text('None')
7023 q.text(","); q.breakable()
7024 q.text("table_id = ");
7025 q.text("%#x" % self.table_id)
7026 q.text(","); q.breakable()
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7027 q.text("config = ");
7028 q.text("%#x" % self.config)
7029 q.breakable()
7030 q.text('}')
7031
7032class table_stats_reply(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7033 version = 1
7034 type = 17
7035 stats_type = 3
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7036
7037 def __init__(self, xid=None, flags=None, entries=None):
7038 self.xid = xid
7039 if flags != None:
7040 self.flags = flags
7041 else:
7042 self.flags = 0
7043 if entries != None:
7044 self.entries = entries
7045 else:
7046 self.entries = []
7047
7048 def pack(self):
7049 packed = []
7050 packed.append(struct.pack("!B", self.version))
7051 packed.append(struct.pack("!B", self.type))
7052 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7053 packed.append(struct.pack("!L", self.xid))
7054 packed.append(struct.pack("!H", self.stats_type))
7055 packed.append(struct.pack("!H", self.flags))
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7056 packed.append(util.pack_list(self.entries))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7057 length = sum([len(x) for x in packed])
7058 packed[2] = struct.pack("!H", length)
7059 return ''.join(packed)
7060
7061 @staticmethod
7062 def unpack(buf):
7063 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
7064 obj = table_stats_reply()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]7065 if type(buf) == loxi.generic_util.OFReader:
7066 reader = buf
7067 else:
7068 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7069 _version = reader.read("!B")[0]
7070 assert(_version == 1)
7071 _type = reader.read("!B")[0]
7072 assert(_type == 17)
7073 _length = reader.read("!H")[0]
7074 obj.xid = reader.read("!L")[0]
7075 _stats_type = reader.read("!H")[0]
7076 assert(_stats_type == 3)
7077 obj.flags = reader.read("!H")[0]
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]7078 obj.entries = loxi.generic_util.unpack_list(reader, common.table_stats_entry.unpack)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7079 return obj
7080
7081 def __eq__(self, other):
7082 if type(self) != type(other): return False
7083 if self.version != other.version: return False
7084 if self.type != other.type: return False
7085 if self.xid != other.xid: return False
7086 if self.flags != other.flags: return False
7087 if self.entries != other.entries: return False
7088 return True
7089
7090 def __ne__(self, other):
7091 return not self.__eq__(other)
7092
7093 def __str__(self):
7094 return self.show()
7095
7096 def show(self):
7097 import loxi.pp
7098 return loxi.pp.pp(self)
7099
7100 def pretty_print(self, q):
7101 q.text("table_stats_reply {")
7102 with q.group():
7103 with q.indent(2):
7104 q.breakable()
7105 q.text("xid = ");
7106 if self.xid != None:
7107 q.text("%#x" % self.xid)
7108 else:
7109 q.text('None')
7110 q.text(","); q.breakable()
7111 q.text("flags = ");
7112 q.text("%#x" % self.flags)
7113 q.text(","); q.breakable()
7114 q.text("entries = ");
7115 q.pp(self.entries)
7116 q.breakable()
7117 q.text('}')
7118
7119class table_stats_request(Message):
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7120 version = 1
7121 type = 16
7122 stats_type = 3
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7123
7124 def __init__(self, xid=None, flags=None):
7125 self.xid = xid
7126 if flags != None:
7127 self.flags = flags
7128 else:
7129 self.flags = 0
7130
7131 def pack(self):
7132 packed = []
7133 packed.append(struct.pack("!B", self.version))
7134 packed.append(struct.pack("!B", self.type))
7135 packed.append(struct.pack("!H", 0)) # placeholder for length at index 2
7136 packed.append(struct.pack("!L", self.xid))
7137 packed.append(struct.pack("!H", self.stats_type))
7138 packed.append(struct.pack("!H", self.flags))
7139 length = sum([len(x) for x in packed])
7140 packed[2] = struct.pack("!H", length)
7141 return ''.join(packed)
7142
7143 @staticmethod
7144 def unpack(buf):
7145 if len(buf) < 8: raise loxi.ProtocolError("buffer too short to contain an OpenFlow message")
7146 obj = table_stats_request()
Rich Lanec2ee4b82013-04-24 17:12:38 -0700[diff] [blame]7147 if type(buf) == loxi.generic_util.OFReader:
7148 reader = buf
7149 else:
7150 reader = loxi.generic_util.OFReader(buf)
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7151 _version = reader.read("!B")[0]
7152 assert(_version == 1)
7153 _type = reader.read("!B")[0]
7154 assert(_type == 16)
7155 _length = reader.read("!H")[0]
7156 obj.xid = reader.read("!L")[0]
7157 _stats_type = reader.read("!H")[0]
7158 assert(_stats_type == 3)
7159 obj.flags = reader.read("!H")[0]
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7160 return obj
7161
7162 def __eq__(self, other):
7163 if type(self) != type(other): return False
7164 if self.version != other.version: return False
7165 if self.type != other.type: return False
7166 if self.xid != other.xid: return False
7167 if self.flags != other.flags: return False
7168 return True
7169
7170 def __ne__(self, other):
7171 return not self.__eq__(other)
7172
7173 def __str__(self):
7174 return self.show()
7175
7176 def show(self):
7177 import loxi.pp
7178 return loxi.pp.pp(self)
7179
7180 def pretty_print(self, q):
7181 q.text("table_stats_request {")
7182 with q.group():
7183 with q.indent(2):
7184 q.breakable()
7185 q.text("xid = ");
7186 if self.xid != None:
7187 q.text("%#x" % self.xid)
7188 else:
7189 q.text('None')
7190 q.text(","); q.breakable()
7191 q.text("flags = ");
7192 q.text("%#x" % self.flags)
7193 q.breakable()
7194 q.text('}')
7195
7196
7197def parse_header(buf):
7198 if len(buf) < 8:
7199 raise loxi.ProtocolError("too short to be an OpenFlow message")
7200 return struct.unpack_from("!BBHL", buf)
7201
7202def parse_message(buf):
7203 msg_ver, msg_type, msg_len, msg_xid = parse_header(buf)
Rich Lanefe600f52013-07-09 13:22:32 -0700[diff] [blame]7204 if msg_ver != const.OFP_VERSION and msg_type != const.OFPT_HELLO:
7205 raise loxi.ProtocolError("wrong OpenFlow version (expected %d, got %d)" % (const.OFP_VERSION, msg_ver))
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7206 if len(buf) != msg_len:
7207 raise loxi.ProtocolError("incorrect message size")
7208 if msg_type in parsers:
7209 return parsers[msg_type](buf)
7210 else:
7211 raise loxi.ProtocolError("unexpected message type")
7212
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]7213def parse_error(buf):
7214 if len(buf) < 8 + 2:
7215 raise loxi.ProtocolError("message too short")
7216 err_type, = struct.unpack_from("!H", buf, 8)
7217 if err_type in error_msg_parsers:
7218 return error_msg_parsers[err_type](buf)
7219 else:
7220 raise loxi.ProtocolError("unexpected error type %u" % err_type)
7221
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7222def parse_flow_mod(buf):
Rich Lanefe600f52013-07-09 13:22:32 -0700[diff] [blame]7223 if len(buf) < 57 + 1:
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7224 raise loxi.ProtocolError("message too short")
Rich Lanefe600f52013-07-09 13:22:32 -0700[diff] [blame]7225 # Technically uint16_t for OF 1.0
7226 cmd, = struct.unpack_from("!B", buf, 57)
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7227 if cmd in flow_mod_parsers:
7228 return flow_mod_parsers[cmd](buf)
7229 else:
7230 raise loxi.ProtocolError("unexpected flow mod cmd %u" % cmd)
7231
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]7232def parse_group_mod(buf):
7233 if len(buf) < 8 + 2:
7234 raise loxi.ProtocolError("message too short")
7235 cmd, = struct.unpack_from("!H", buf, 8)
7236 if cmd in flow_mod_parsers:
7237 return group_mod_parsers[cmd](buf)
7238 else:
7239 raise loxi.ProtocolError("unexpected group mod cmd %u" % cmd)
7240
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7241def parse_stats_reply(buf):
7242 if len(buf) < 8 + 2:
7243 raise loxi.ProtocolError("message too short")
7244 stats_type, = struct.unpack_from("!H", buf, 8)
7245 if stats_type in stats_reply_parsers:
7246 return stats_reply_parsers[stats_type](buf)
7247 else:
7248 raise loxi.ProtocolError("unexpected stats type %u" % stats_type)
7249
7250def parse_stats_request(buf):
7251 if len(buf) < 8 + 2:
7252 raise loxi.ProtocolError("message too short")
7253 stats_type, = struct.unpack_from("!H", buf, 8)
7254 if stats_type in stats_request_parsers:
7255 return stats_request_parsers[stats_type](buf)
7256 else:
7257 raise loxi.ProtocolError("unexpected stats type %u" % stats_type)
7258
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]7259def parse_experimenter_stats_request(buf):
7260 if len(buf) < 24:
7261 raise loxi.ProtocolError("experimenter stats request message too short")
7262
7263 experimenter, exp_type = struct.unpack_from("!LL", buf, 16)
7264
7265 if experimenter in experimenter_stats_request_parsers and \
7266 exp_type in experimenter_stats_request_parsers[experimenter]:
7267 return experimenter_stats_request_parsers[experimenter][exp_type](buf)
7268 else:
7269 raise loxi.ProtocolError("unexpected stats request experimenter %#x exp_type %#x" % (experimenter, exp_type))
7270
7271def parse_experimenter_stats_reply(buf):
7272 if len(buf) < 24:
7273 raise loxi.ProtocolError("experimenter stats reply message too short")
7274
7275 experimenter, exp_type = struct.unpack_from("!LL", buf, 16)
7276
7277 if experimenter in experimenter_stats_reply_parsers and \
7278 exp_type in experimenter_stats_reply_parsers[experimenter]:
7279 return experimenter_stats_reply_parsers[experimenter][exp_type](buf)
7280 else:
7281 raise loxi.ProtocolError("unexpected stats reply experimenter %#x exp_type %#x" % (experimenter, exp_type))
7282
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]7283def parse_experimenter(buf):
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7284 if len(buf) < 16:
7285 raise loxi.ProtocolError("experimenter message too short")
7286
7287 experimenter, = struct.unpack_from("!L", buf, 8)
7288 if experimenter == 0x005c16c7: # Big Switch Networks
7289 subtype, = struct.unpack_from("!L", buf, 12)
7290 elif experimenter == 0x00002320: # Nicira
7291 subtype, = struct.unpack_from("!L", buf, 12)
7292 else:
7293 raise loxi.ProtocolError("unexpected experimenter id %#x" % experimenter)
7294
7295 if subtype in experimenter_parsers[experimenter]:
7296 return experimenter_parsers[experimenter][subtype](buf)
7297 else:
7298 raise loxi.ProtocolError("unexpected experimenter %#x subtype %#x" % (experimenter, subtype))
7299
7300parsers = {
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7301 const.OFPT_HELLO : hello.unpack,
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]7302 const.OFPT_ERROR : parse_error,
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7303 const.OFPT_ECHO_REQUEST : echo_request.unpack,
7304 const.OFPT_ECHO_REPLY : echo_reply.unpack,
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]7305 const.OFPT_EXPERIMENTER : parse_experimenter,
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7306 const.OFPT_FEATURES_REQUEST : features_request.unpack,
7307 const.OFPT_FEATURES_REPLY : features_reply.unpack,
7308 const.OFPT_GET_CONFIG_REQUEST : get_config_request.unpack,
7309 const.OFPT_GET_CONFIG_REPLY : get_config_reply.unpack,
7310 const.OFPT_SET_CONFIG : set_config.unpack,
7311 const.OFPT_PACKET_IN : packet_in.unpack,
7312 const.OFPT_FLOW_REMOVED : flow_removed.unpack,
7313 const.OFPT_PORT_STATUS : port_status.unpack,
7314 const.OFPT_PACKET_OUT : packet_out.unpack,
7315 const.OFPT_FLOW_MOD : parse_flow_mod,
7316 const.OFPT_PORT_MOD : port_mod.unpack,
7317 const.OFPT_STATS_REQUEST : parse_stats_request,
7318 const.OFPT_STATS_REPLY : parse_stats_reply,
7319 const.OFPT_BARRIER_REQUEST : barrier_request.unpack,
7320 const.OFPT_BARRIER_REPLY : barrier_reply.unpack,
7321 const.OFPT_QUEUE_GET_CONFIG_REQUEST : queue_get_config_request.unpack,
7322 const.OFPT_QUEUE_GET_CONFIG_REPLY : queue_get_config_reply.unpack,
7323 22 : table_mod.unpack,
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7324}
7325
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]7326error_msg_parsers = {
7327 const.OFPET_HELLO_FAILED : hello_failed_error_msg.unpack,
7328 const.OFPET_BAD_REQUEST : bad_request_error_msg.unpack,
7329 const.OFPET_BAD_ACTION : bad_action_error_msg.unpack,
7330 const.OFPET_FLOW_MOD_FAILED : flow_mod_failed_error_msg.unpack,
7331 const.OFPET_PORT_MOD_FAILED : port_mod_failed_error_msg.unpack,
7332 const.OFPET_QUEUE_OP_FAILED : queue_op_failed_error_msg.unpack,
7333}
7334
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7335flow_mod_parsers = {
7336 const.OFPFC_ADD : flow_add.unpack,
7337 const.OFPFC_MODIFY : flow_modify.unpack,
7338 const.OFPFC_MODIFY_STRICT : flow_modify_strict.unpack,
7339 const.OFPFC_DELETE : flow_delete.unpack,
7340 const.OFPFC_DELETE_STRICT : flow_delete_strict.unpack,
7341}
7342
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]7343
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7344stats_reply_parsers = {
7345 const.OFPST_DESC : desc_stats_reply.unpack,
7346 const.OFPST_FLOW : flow_stats_reply.unpack,
7347 const.OFPST_AGGREGATE : aggregate_stats_reply.unpack,
7348 const.OFPST_TABLE : table_stats_reply.unpack,
7349 const.OFPST_PORT : port_stats_reply.unpack,
7350 const.OFPST_QUEUE : queue_stats_reply.unpack,
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]7351 const.OFPST_EXPERIMENTER : parse_experimenter_stats_reply,
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7352}
7353
7354stats_request_parsers = {
7355 const.OFPST_DESC : desc_stats_request.unpack,
7356 const.OFPST_FLOW : flow_stats_request.unpack,
7357 const.OFPST_AGGREGATE : aggregate_stats_request.unpack,
7358 const.OFPST_TABLE : table_stats_request.unpack,
7359 const.OFPST_PORT : port_stats_request.unpack,
7360 const.OFPST_QUEUE : queue_stats_request.unpack,
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]7361 const.OFPST_EXPERIMENTER : parse_experimenter_stats_request,
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7362}
7363
7364experimenter_parsers = {
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7365 8992 : {
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7366 11: nicira_controller_role_reply.unpack,
7367 10: nicira_controller_role_request.unpack,
7368 },
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7369 6035143 : {
7370 22: bsn_bw_clear_data_reply.unpack,
7371 21: bsn_bw_clear_data_request.unpack,
7372 20: bsn_bw_enable_get_reply.unpack,
7373 19: bsn_bw_enable_get_request.unpack,
7374 23: bsn_bw_enable_set_reply.unpack,
7375 18: bsn_bw_enable_set_request.unpack,
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7376 10: bsn_get_interfaces_reply.unpack,
7377 9: bsn_get_interfaces_request.unpack,
7378 2: bsn_get_ip_mask_reply.unpack,
7379 1: bsn_get_ip_mask_request.unpack,
Rich Lane90c961c2013-05-14 09:26:50 -0700[diff] [blame]7380 14: bsn_get_l2_table_reply.unpack,
7381 13: bsn_get_l2_table_request.unpack,
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7382 5: bsn_get_mirroring_reply.unpack,
7383 4: bsn_get_mirroring_request.unpack,
Rich Lane6f4978c2013-10-20 21:33:52 -0700[diff] [blame]7384 28: bsn_hybrid_get_reply.unpack,
7385 27: bsn_hybrid_get_request.unpack,
7386 34: bsn_pdu_rx_reply.unpack,
7387 33: bsn_pdu_rx_request.unpack,
7388 35: bsn_pdu_rx_timeout.unpack,
7389 32: bsn_pdu_tx_reply.unpack,
7390 31: bsn_pdu_tx_request.unpack,
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7391 0: bsn_set_ip_mask.unpack,
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7392 24: bsn_set_l2_table_reply.unpack,
7393 12: bsn_set_l2_table_request.unpack,
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7394 3: bsn_set_mirroring.unpack,
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7395 25: bsn_set_pktin_suppression_reply.unpack,
7396 11: bsn_set_pktin_suppression_request.unpack,
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7397 6: bsn_shell_command.unpack,
7398 7: bsn_shell_output.unpack,
7399 8: bsn_shell_status.unpack,
Dan Talaycof6202252013-07-02 01:00:29 -0700[diff] [blame]7400 16: bsn_virtual_port_create_reply.unpack,
7401 15: bsn_virtual_port_create_request.unpack,
7402 26: bsn_virtual_port_remove_reply.unpack,
7403 17: bsn_virtual_port_remove_request.unpack,
Rich Laneb658ddd2013-03-12 10:15:10 -0700[diff] [blame]7404 },
7405}
Rich Lane7b0f2012013-11-22 14:15:26 -0800[diff] [blame]7406
7407experimenter_stats_request_parsers = {
7408 0x005c16c7: {
7409 },
7410}
7411
7412experimenter_stats_reply_parsers = {
7413 0x005c16c7: {
7414 },
7415}