Loading...
Note: File does not exist in v4.10.11.
1#!/usr/bin/env python3
2# SPDX-License-Identifier: GPL-2.0
3
4# Controls the openvswitch module. Part of the kselftest suite, but
5# can be used for some diagnostic purpose as well.
6
7import argparse
8import errno
9import ipaddress
10import logging
11import multiprocessing
12import re
13import struct
14import sys
15import time
16import types
17import uuid
18
19try:
20 from pyroute2 import NDB
21
22 from pyroute2.netlink import NLA_F_NESTED
23 from pyroute2.netlink import NLM_F_ACK
24 from pyroute2.netlink import NLM_F_DUMP
25 from pyroute2.netlink import NLM_F_REQUEST
26 from pyroute2.netlink import genlmsg
27 from pyroute2.netlink import nla
28 from pyroute2.netlink import nlmsg_atoms
29 from pyroute2.netlink.exceptions import NetlinkError
30 from pyroute2.netlink.generic import GenericNetlinkSocket
31 import pyroute2
32
33except ModuleNotFoundError:
34 print("Need to install the python pyroute2 package >= 0.6.")
35 sys.exit(0)
36
37
38OVS_DATAPATH_FAMILY = "ovs_datapath"
39OVS_VPORT_FAMILY = "ovs_vport"
40OVS_FLOW_FAMILY = "ovs_flow"
41OVS_PACKET_FAMILY = "ovs_packet"
42OVS_METER_FAMILY = "ovs_meter"
43OVS_CT_LIMIT_FAMILY = "ovs_ct_limit"
44
45OVS_DATAPATH_VERSION = 2
46OVS_DP_CMD_NEW = 1
47OVS_DP_CMD_DEL = 2
48OVS_DP_CMD_GET = 3
49OVS_DP_CMD_SET = 4
50
51OVS_VPORT_CMD_NEW = 1
52OVS_VPORT_CMD_DEL = 2
53OVS_VPORT_CMD_GET = 3
54OVS_VPORT_CMD_SET = 4
55
56OVS_FLOW_CMD_NEW = 1
57OVS_FLOW_CMD_DEL = 2
58OVS_FLOW_CMD_GET = 3
59OVS_FLOW_CMD_SET = 4
60
61
62def macstr(mac):
63 outstr = ":".join(["%02X" % i for i in mac])
64 return outstr
65
66
67def strcspn(str1, str2):
68 tot = 0
69 for char in str1:
70 if str2.find(char) != -1:
71 return tot
72 tot += 1
73 return tot
74
75
76def strspn(str1, str2):
77 tot = 0
78 for char in str1:
79 if str2.find(char) == -1:
80 return tot
81 tot += 1
82 return tot
83
84
85def intparse(statestr, defmask="0xffffffff"):
86 totalparse = strspn(statestr, "0123456789abcdefABCDEFx/")
87 # scan until "/"
88 count = strspn(statestr, "x0123456789abcdefABCDEF")
89
90 firstnum = statestr[:count]
91 if firstnum[-1] == "/":
92 firstnum = firstnum[:-1]
93 k = int(firstnum, 0)
94
95 m = None
96 if defmask is not None:
97 secondnum = defmask
98 if statestr[count] == "/":
99 secondnum = statestr[count + 1 :] # this is wrong...
100 m = int(secondnum, 0)
101
102 return statestr[totalparse + 1 :], k, m
103
104
105def parse_flags(flag_str, flag_vals):
106 bitResult = 0
107 maskResult = 0
108
109 if len(flag_str) == 0:
110 return flag_str, bitResult, maskResult
111
112 if flag_str[0].isdigit():
113 idx = 0
114 while flag_str[idx].isdigit() or flag_str[idx] == "x":
115 idx += 1
116 digits = flag_str[:idx]
117 flag_str = flag_str[idx:]
118
119 bitResult = int(digits, 0)
120 maskResult = int(digits, 0)
121
122 while len(flag_str) > 0 and (flag_str[0] == "+" or flag_str[0] == "-"):
123 if flag_str[0] == "+":
124 setFlag = True
125 elif flag_str[0] == "-":
126 setFlag = False
127
128 flag_str = flag_str[1:]
129
130 flag_len = 0
131 while (
132 flag_str[flag_len] != "+"
133 and flag_str[flag_len] != "-"
134 and flag_str[flag_len] != ","
135 and flag_str[flag_len] != ")"
136 ):
137 flag_len += 1
138
139 flag = flag_str[0:flag_len]
140
141 if flag in flag_vals:
142 if maskResult & flag_vals[flag]:
143 raise KeyError(
144 "Flag %s set once, cannot be set in multiples" % flag
145 )
146
147 if setFlag:
148 bitResult |= flag_vals[flag]
149
150 maskResult |= flag_vals[flag]
151 else:
152 raise KeyError("Missing flag value: %s" % flag)
153
154 flag_str = flag_str[flag_len:]
155
156 return flag_str, bitResult, maskResult
157
158
159def parse_ct_state(statestr):
160 ct_flags = {
161 "new": 1 << 0,
162 "est": 1 << 1,
163 "rel": 1 << 2,
164 "rpl": 1 << 3,
165 "inv": 1 << 4,
166 "trk": 1 << 5,
167 "snat": 1 << 6,
168 "dnat": 1 << 7,
169 }
170
171 return parse_flags(statestr, ct_flags)
172
173
174def convert_mac(data):
175 def to_bytes(mac):
176 mac_split = mac.split(":")
177 ret = bytearray([int(i, 16) for i in mac_split])
178 return bytes(ret)
179
180 mac_str, _, mask_str = data.partition('/')
181
182 if not mac_str:
183 mac_str = mask_str = "00:00:00:00:00:00"
184 elif not mask_str:
185 mask_str = "FF:FF:FF:FF:FF:FF"
186
187 return to_bytes(mac_str), to_bytes(mask_str)
188
189def convert_ipv4(data):
190 ip, _, mask = data.partition('/')
191
192 if not ip:
193 ip = mask = 0
194 elif not mask:
195 mask = 0xFFFFFFFF
196 elif mask.isdigit():
197 mask = (0xFFFFFFFF << (32 - int(mask))) & 0xFFFFFFFF
198
199 return int(ipaddress.IPv4Address(ip)), int(ipaddress.IPv4Address(mask))
200
201def convert_int(size):
202 def convert_int_sized(data):
203 value, _, mask = data.partition('/')
204
205 if not value:
206 return 0, 0
207 elif not mask:
208 return int(value, 0), pow(2, size) - 1
209 else:
210 return int(value, 0), int(mask, 0)
211
212 return convert_int_sized
213
214def parse_starts_block(block_str, scanstr, returnskipped, scanregex=False):
215 if scanregex:
216 m = re.search(scanstr, block_str)
217 if m is None:
218 if returnskipped:
219 return block_str
220 return False
221 if returnskipped:
222 block_str = block_str[len(m.group(0)) :]
223 return block_str
224 return True
225
226 if block_str.startswith(scanstr):
227 if returnskipped:
228 block_str = block_str[len(scanstr) :]
229 else:
230 return True
231
232 if returnskipped:
233 return block_str
234
235 return False
236
237
238def parse_extract_field(
239 block_str, fieldstr, scanfmt, convert, masked=False, defval=None
240):
241 if fieldstr and not block_str.startswith(fieldstr):
242 return block_str, defval
243
244 if fieldstr:
245 str_skiplen = len(fieldstr)
246 str_skipped = block_str[str_skiplen:]
247 if str_skiplen == 0:
248 return str_skipped, defval
249 else:
250 str_skiplen = 0
251 str_skipped = block_str
252
253 m = re.search(scanfmt, str_skipped)
254 if m is None:
255 raise ValueError("Bad fmt string")
256
257 data = m.group(0)
258 if convert:
259 data = convert(m.group(0))
260
261 str_skipped = str_skipped[len(m.group(0)) :]
262 if masked:
263 if str_skipped[0] == "/":
264 raise ValueError("Masking support TBD...")
265
266 str_skipped = str_skipped[strspn(str_skipped, ", ") :]
267 return str_skipped, data
268
269
270class ovs_dp_msg(genlmsg):
271 # include the OVS version
272 # We need a custom header rather than just being able to rely on
273 # genlmsg because fields ends up not expressing everything correctly
274 # if we use the canonical example of setting fields = (('customfield',),)
275 fields = genlmsg.fields + (("dpifindex", "I"),)
276
277
278class ovsactions(nla):
279 nla_flags = NLA_F_NESTED
280
281 nla_map = (
282 ("OVS_ACTION_ATTR_UNSPEC", "none"),
283 ("OVS_ACTION_ATTR_OUTPUT", "uint32"),
284 ("OVS_ACTION_ATTR_USERSPACE", "userspace"),
285 ("OVS_ACTION_ATTR_SET", "none"),
286 ("OVS_ACTION_ATTR_PUSH_VLAN", "none"),
287 ("OVS_ACTION_ATTR_POP_VLAN", "flag"),
288 ("OVS_ACTION_ATTR_SAMPLE", "none"),
289 ("OVS_ACTION_ATTR_RECIRC", "uint32"),
290 ("OVS_ACTION_ATTR_HASH", "none"),
291 ("OVS_ACTION_ATTR_PUSH_MPLS", "none"),
292 ("OVS_ACTION_ATTR_POP_MPLS", "flag"),
293 ("OVS_ACTION_ATTR_SET_MASKED", "none"),
294 ("OVS_ACTION_ATTR_CT", "ctact"),
295 ("OVS_ACTION_ATTR_TRUNC", "uint32"),
296 ("OVS_ACTION_ATTR_PUSH_ETH", "none"),
297 ("OVS_ACTION_ATTR_POP_ETH", "flag"),
298 ("OVS_ACTION_ATTR_CT_CLEAR", "flag"),
299 ("OVS_ACTION_ATTR_PUSH_NSH", "none"),
300 ("OVS_ACTION_ATTR_POP_NSH", "flag"),
301 ("OVS_ACTION_ATTR_METER", "none"),
302 ("OVS_ACTION_ATTR_CLONE", "recursive"),
303 ("OVS_ACTION_ATTR_CHECK_PKT_LEN", "none"),
304 ("OVS_ACTION_ATTR_ADD_MPLS", "none"),
305 ("OVS_ACTION_ATTR_DEC_TTL", "none"),
306 ("OVS_ACTION_ATTR_DROP", "uint32"),
307 )
308
309 class ctact(nla):
310 nla_flags = NLA_F_NESTED
311
312 nla_map = (
313 ("OVS_CT_ATTR_NONE", "none"),
314 ("OVS_CT_ATTR_COMMIT", "flag"),
315 ("OVS_CT_ATTR_ZONE", "uint16"),
316 ("OVS_CT_ATTR_MARK", "none"),
317 ("OVS_CT_ATTR_LABELS", "none"),
318 ("OVS_CT_ATTR_HELPER", "asciiz"),
319 ("OVS_CT_ATTR_NAT", "natattr"),
320 ("OVS_CT_ATTR_FORCE_COMMIT", "flag"),
321 ("OVS_CT_ATTR_EVENTMASK", "uint32"),
322 ("OVS_CT_ATTR_TIMEOUT", "asciiz"),
323 )
324
325 class natattr(nla):
326 nla_flags = NLA_F_NESTED
327
328 nla_map = (
329 ("OVS_NAT_ATTR_NONE", "none"),
330 ("OVS_NAT_ATTR_SRC", "flag"),
331 ("OVS_NAT_ATTR_DST", "flag"),
332 ("OVS_NAT_ATTR_IP_MIN", "ipaddr"),
333 ("OVS_NAT_ATTR_IP_MAX", "ipaddr"),
334 ("OVS_NAT_ATTR_PROTO_MIN", "uint16"),
335 ("OVS_NAT_ATTR_PROTO_MAX", "uint16"),
336 ("OVS_NAT_ATTR_PERSISTENT", "flag"),
337 ("OVS_NAT_ATTR_PROTO_HASH", "flag"),
338 ("OVS_NAT_ATTR_PROTO_RANDOM", "flag"),
339 )
340
341 def dpstr(self, more=False):
342 print_str = "nat("
343
344 if self.get_attr("OVS_NAT_ATTR_SRC"):
345 print_str += "src"
346 elif self.get_attr("OVS_NAT_ATTR_DST"):
347 print_str += "dst"
348 else:
349 print_str += "XXX-unknown-nat"
350
351 if self.get_attr("OVS_NAT_ATTR_IP_MIN") or self.get_attr(
352 "OVS_NAT_ATTR_IP_MAX"
353 ):
354 if self.get_attr("OVS_NAT_ATTR_IP_MIN"):
355 print_str += "=%s," % str(
356 self.get_attr("OVS_NAT_ATTR_IP_MIN")
357 )
358
359 if self.get_attr("OVS_NAT_ATTR_IP_MAX"):
360 print_str += "-%s," % str(
361 self.get_attr("OVS_NAT_ATTR_IP_MAX")
362 )
363 else:
364 print_str += ","
365
366 if self.get_attr("OVS_NAT_ATTR_PROTO_MIN"):
367 print_str += "proto_min=%d," % self.get_attr(
368 "OVS_NAT_ATTR_PROTO_MIN"
369 )
370
371 if self.get_attr("OVS_NAT_ATTR_PROTO_MAX"):
372 print_str += "proto_max=%d," % self.get_attr(
373 "OVS_NAT_ATTR_PROTO_MAX"
374 )
375
376 if self.get_attr("OVS_NAT_ATTR_PERSISTENT"):
377 print_str += "persistent,"
378 if self.get_attr("OVS_NAT_ATTR_HASH"):
379 print_str += "hash,"
380 if self.get_attr("OVS_NAT_ATTR_RANDOM"):
381 print_str += "random"
382 print_str += ")"
383 return print_str
384
385 def dpstr(self, more=False):
386 print_str = "ct("
387
388 if self.get_attr("OVS_CT_ATTR_COMMIT") is not None:
389 print_str += "commit,"
390 if self.get_attr("OVS_CT_ATTR_ZONE") is not None:
391 print_str += "zone=%d," % self.get_attr("OVS_CT_ATTR_ZONE")
392 if self.get_attr("OVS_CT_ATTR_HELPER") is not None:
393 print_str += "helper=%s," % self.get_attr("OVS_CT_ATTR_HELPER")
394 if self.get_attr("OVS_CT_ATTR_NAT") is not None:
395 print_str += self.get_attr("OVS_CT_ATTR_NAT").dpstr(more)
396 print_str += ","
397 if self.get_attr("OVS_CT_ATTR_FORCE_COMMIT") is not None:
398 print_str += "force,"
399 if self.get_attr("OVS_CT_ATTR_EVENTMASK") is not None:
400 print_str += "emask=0x%X," % self.get_attr(
401 "OVS_CT_ATTR_EVENTMASK"
402 )
403 if self.get_attr("OVS_CT_ATTR_TIMEOUT") is not None:
404 print_str += "timeout=%s" % self.get_attr(
405 "OVS_CT_ATTR_TIMEOUT"
406 )
407 print_str += ")"
408 return print_str
409
410 class userspace(nla):
411 nla_flags = NLA_F_NESTED
412
413 nla_map = (
414 ("OVS_USERSPACE_ATTR_UNUSED", "none"),
415 ("OVS_USERSPACE_ATTR_PID", "uint32"),
416 ("OVS_USERSPACE_ATTR_USERDATA", "array(uint8)"),
417 ("OVS_USERSPACE_ATTR_EGRESS_TUN_PORT", "uint32"),
418 )
419
420 def dpstr(self, more=False):
421 print_str = "userspace("
422 if self.get_attr("OVS_USERSPACE_ATTR_PID") is not None:
423 print_str += "pid=%d," % self.get_attr(
424 "OVS_USERSPACE_ATTR_PID"
425 )
426 if self.get_attr("OVS_USERSPACE_ATTR_USERDATA") is not None:
427 print_str += "userdata="
428 for f in self.get_attr("OVS_USERSPACE_ATTR_USERDATA"):
429 print_str += "%x." % f
430 if self.get_attr("OVS_USERSPACE_ATTR_TUN_PORT") is not None:
431 print_str += "egress_tun_port=%d" % self.get_attr(
432 "OVS_USERSPACE_ATTR_TUN_PORT"
433 )
434 print_str += ")"
435 return print_str
436
437 def dpstr(self, more=False):
438 print_str = ""
439
440 for field in self.nla_map:
441 if field[1] == "none" or self.get_attr(field[0]) is None:
442 continue
443 if print_str != "":
444 print_str += ","
445
446 if field[1] == "uint32":
447 if field[0] == "OVS_ACTION_ATTR_OUTPUT":
448 print_str += "%d" % int(self.get_attr(field[0]))
449 elif field[0] == "OVS_ACTION_ATTR_RECIRC":
450 print_str += "recirc(0x%x)" % int(self.get_attr(field[0]))
451 elif field[0] == "OVS_ACTION_ATTR_TRUNC":
452 print_str += "trunc(%d)" % int(self.get_attr(field[0]))
453 elif field[0] == "OVS_ACTION_ATTR_DROP":
454 print_str += "drop(%d)" % int(self.get_attr(field[0]))
455 elif field[1] == "flag":
456 if field[0] == "OVS_ACTION_ATTR_CT_CLEAR":
457 print_str += "ct_clear"
458 elif field[0] == "OVS_ACTION_ATTR_POP_VLAN":
459 print_str += "pop_vlan"
460 elif field[0] == "OVS_ACTION_ATTR_POP_ETH":
461 print_str += "pop_eth"
462 elif field[0] == "OVS_ACTION_ATTR_POP_NSH":
463 print_str += "pop_nsh"
464 elif field[0] == "OVS_ACTION_ATTR_POP_MPLS":
465 print_str += "pop_mpls"
466 else:
467 datum = self.get_attr(field[0])
468 if field[0] == "OVS_ACTION_ATTR_CLONE":
469 print_str += "clone("
470 print_str += datum.dpstr(more)
471 print_str += ")"
472 else:
473 print_str += datum.dpstr(more)
474
475 return print_str
476
477 def parse(self, actstr):
478 totallen = len(actstr)
479 while len(actstr) != 0:
480 parsed = False
481 parencount = 0
482 if actstr.startswith("drop"):
483 # If no reason is provided, the implicit drop is used (i.e no
484 # action). If some reason is given, an explicit action is used.
485 reason = None
486 if actstr.startswith("drop("):
487 parencount += 1
488
489 actstr, reason = parse_extract_field(
490 actstr,
491 "drop(",
492 "([0-9]+)",
493 lambda x: int(x, 0),
494 False,
495 None,
496 )
497
498 if reason is not None:
499 self["attrs"].append(["OVS_ACTION_ATTR_DROP", reason])
500 parsed = True
501 else:
502 actstr = actstr[len("drop"): ]
503 return (totallen - len(actstr))
504
505 elif parse_starts_block(actstr, "^(\d+)", False, True):
506 actstr, output = parse_extract_field(
507 actstr, None, "(\d+)", lambda x: int(x), False, "0"
508 )
509 self["attrs"].append(["OVS_ACTION_ATTR_OUTPUT", output])
510 parsed = True
511 elif parse_starts_block(actstr, "recirc(", False):
512 actstr, recircid = parse_extract_field(
513 actstr,
514 "recirc(",
515 "([0-9a-fA-Fx]+)",
516 lambda x: int(x, 0),
517 False,
518 0,
519 )
520 parencount += 1
521 self["attrs"].append(["OVS_ACTION_ATTR_RECIRC", recircid])
522 parsed = True
523
524 parse_flat_map = (
525 ("ct_clear", "OVS_ACTION_ATTR_CT_CLEAR"),
526 ("pop_vlan", "OVS_ACTION_ATTR_POP_VLAN"),
527 ("pop_eth", "OVS_ACTION_ATTR_POP_ETH"),
528 ("pop_nsh", "OVS_ACTION_ATTR_POP_NSH"),
529 )
530
531 for flat_act in parse_flat_map:
532 if parse_starts_block(actstr, flat_act[0], False):
533 actstr = actstr[len(flat_act[0]):]
534 self["attrs"].append([flat_act[1]])
535 actstr = actstr[strspn(actstr, ", ") :]
536 parsed = True
537
538 if parse_starts_block(actstr, "clone(", False):
539 parencount += 1
540 subacts = ovsactions()
541 actstr = actstr[len("clone("):]
542 parsedLen = subacts.parse(actstr)
543 lst = []
544 self["attrs"].append(("OVS_ACTION_ATTR_CLONE", subacts))
545 actstr = actstr[parsedLen:]
546 parsed = True
547 elif parse_starts_block(actstr, "ct(", False):
548 parencount += 1
549 actstr = actstr[len("ct(") :]
550 ctact = ovsactions.ctact()
551
552 for scan in (
553 ("commit", "OVS_CT_ATTR_COMMIT", None),
554 ("force_commit", "OVS_CT_ATTR_FORCE_COMMIT", None),
555 ("zone", "OVS_CT_ATTR_ZONE", int),
556 ("mark", "OVS_CT_ATTR_MARK", int),
557 ("helper", "OVS_CT_ATTR_HELPER", lambda x, y: str(x)),
558 ("timeout", "OVS_CT_ATTR_TIMEOUT", lambda x, y: str(x)),
559 ):
560 if actstr.startswith(scan[0]):
561 actstr = actstr[len(scan[0]) :]
562 if scan[2] is not None:
563 if actstr[0] != "=":
564 raise ValueError("Invalid ct attr")
565 actstr = actstr[1:]
566 pos = strcspn(actstr, ",)")
567 datum = scan[2](actstr[:pos], 0)
568 ctact["attrs"].append([scan[1], datum])
569 actstr = actstr[pos:]
570 else:
571 ctact["attrs"].append([scan[1], None])
572 actstr = actstr[strspn(actstr, ", ") :]
573 # it seems strange to put this here, but nat() is a complex
574 # sub-action and this lets it sit anywhere in the ct() action
575 if actstr.startswith("nat"):
576 actstr = actstr[3:]
577 natact = ovsactions.ctact.natattr()
578
579 if actstr.startswith("("):
580 parencount += 1
581 t = None
582 actstr = actstr[1:]
583 if actstr.startswith("src"):
584 t = "OVS_NAT_ATTR_SRC"
585 actstr = actstr[3:]
586 elif actstr.startswith("dst"):
587 t = "OVS_NAT_ATTR_DST"
588 actstr = actstr[3:]
589
590 actstr, ip_block_min = parse_extract_field(
591 actstr, "=", "([0-9a-fA-F\.]+)", str, False
592 )
593 actstr, ip_block_max = parse_extract_field(
594 actstr, "-", "([0-9a-fA-F\.]+)", str, False
595 )
596
597 actstr, proto_min = parse_extract_field(
598 actstr, ":", "(\d+)", int, False
599 )
600 actstr, proto_max = parse_extract_field(
601 actstr, "-", "(\d+)", int, False
602 )
603
604 if t is not None:
605 natact["attrs"].append([t, None])
606
607 if ip_block_min is not None:
608 natact["attrs"].append(
609 ["OVS_NAT_ATTR_IP_MIN", ip_block_min]
610 )
611 if ip_block_max is not None:
612 natact["attrs"].append(
613 ["OVS_NAT_ATTR_IP_MAX", ip_block_max]
614 )
615 if proto_min is not None:
616 natact["attrs"].append(
617 ["OVS_NAT_ATTR_PROTO_MIN", proto_min]
618 )
619 if proto_max is not None:
620 natact["attrs"].append(
621 ["OVS_NAT_ATTR_PROTO_MAX", proto_max]
622 )
623
624 for natscan in (
625 ("persistent", "OVS_NAT_ATTR_PERSISTENT"),
626 ("hash", "OVS_NAT_ATTR_PROTO_HASH"),
627 ("random", "OVS_NAT_ATTR_PROTO_RANDOM"),
628 ):
629 if actstr.startswith(natscan[0]):
630 actstr = actstr[len(natscan[0]) :]
631 natact["attrs"].append([natscan[1], None])
632 actstr = actstr[strspn(actstr, ", ") :]
633
634 ctact["attrs"].append(["OVS_CT_ATTR_NAT", natact])
635 actstr = actstr[strspn(actstr, ", ") :]
636
637 self["attrs"].append(["OVS_ACTION_ATTR_CT", ctact])
638 parsed = True
639
640 actstr = actstr[strspn(actstr, ", ") :]
641 while parencount > 0:
642 parencount -= 1
643 actstr = actstr[strspn(actstr, " "):]
644 if len(actstr) and actstr[0] != ")":
645 raise ValueError("Action str: '%s' unbalanced" % actstr)
646 actstr = actstr[1:]
647
648 if len(actstr) and actstr[0] == ")":
649 return (totallen - len(actstr))
650
651 actstr = actstr[strspn(actstr, ", ") :]
652
653 if not parsed:
654 raise ValueError("Action str: '%s' not supported" % actstr)
655
656 return (totallen - len(actstr))
657
658
659class ovskey(nla):
660 nla_flags = NLA_F_NESTED
661 nla_map = (
662 ("OVS_KEY_ATTR_UNSPEC", "none"),
663 ("OVS_KEY_ATTR_ENCAP", "none"),
664 ("OVS_KEY_ATTR_PRIORITY", "uint32"),
665 ("OVS_KEY_ATTR_IN_PORT", "uint32"),
666 ("OVS_KEY_ATTR_ETHERNET", "ethaddr"),
667 ("OVS_KEY_ATTR_VLAN", "uint16"),
668 ("OVS_KEY_ATTR_ETHERTYPE", "be16"),
669 ("OVS_KEY_ATTR_IPV4", "ovs_key_ipv4"),
670 ("OVS_KEY_ATTR_IPV6", "ovs_key_ipv6"),
671 ("OVS_KEY_ATTR_TCP", "ovs_key_tcp"),
672 ("OVS_KEY_ATTR_UDP", "ovs_key_udp"),
673 ("OVS_KEY_ATTR_ICMP", "ovs_key_icmp"),
674 ("OVS_KEY_ATTR_ICMPV6", "ovs_key_icmpv6"),
675 ("OVS_KEY_ATTR_ARP", "ovs_key_arp"),
676 ("OVS_KEY_ATTR_ND", "ovs_key_nd"),
677 ("OVS_KEY_ATTR_SKB_MARK", "uint32"),
678 ("OVS_KEY_ATTR_TUNNEL", "none"),
679 ("OVS_KEY_ATTR_SCTP", "ovs_key_sctp"),
680 ("OVS_KEY_ATTR_TCP_FLAGS", "be16"),
681 ("OVS_KEY_ATTR_DP_HASH", "uint32"),
682 ("OVS_KEY_ATTR_RECIRC_ID", "uint32"),
683 ("OVS_KEY_ATTR_MPLS", "array(ovs_key_mpls)"),
684 ("OVS_KEY_ATTR_CT_STATE", "uint32"),
685 ("OVS_KEY_ATTR_CT_ZONE", "uint16"),
686 ("OVS_KEY_ATTR_CT_MARK", "uint32"),
687 ("OVS_KEY_ATTR_CT_LABELS", "none"),
688 ("OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4", "ovs_key_ct_tuple_ipv4"),
689 ("OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6", "ovs_key_ct_tuple_ipv6"),
690 ("OVS_KEY_ATTR_NSH", "none"),
691 ("OVS_KEY_ATTR_PACKET_TYPE", "none"),
692 ("OVS_KEY_ATTR_ND_EXTENSIONS", "none"),
693 ("OVS_KEY_ATTR_TUNNEL_INFO", "none"),
694 ("OVS_KEY_ATTR_IPV6_EXTENSIONS", "none"),
695 )
696
697 class ovs_key_proto(nla):
698 fields = (
699 ("src", "!H"),
700 ("dst", "!H"),
701 )
702
703 fields_map = (
704 ("src", "src", "%d", lambda x: int(x) if x else 0,
705 convert_int(16)),
706 ("dst", "dst", "%d", lambda x: int(x) if x else 0,
707 convert_int(16)),
708 )
709
710 def __init__(
711 self,
712 protostr,
713 data=None,
714 offset=None,
715 parent=None,
716 length=None,
717 init=None,
718 ):
719 self.proto_str = protostr
720 nla.__init__(
721 self,
722 data=data,
723 offset=offset,
724 parent=parent,
725 length=length,
726 init=init,
727 )
728
729 def parse(self, flowstr, typeInst):
730 if not flowstr.startswith(self.proto_str):
731 return None, None
732
733 k = typeInst()
734 m = typeInst()
735
736 flowstr = flowstr[len(self.proto_str) :]
737 if flowstr.startswith("("):
738 flowstr = flowstr[1:]
739
740 keybits = b""
741 maskbits = b""
742 for f in self.fields_map:
743 if flowstr.startswith(f[1]):
744 # the following assumes that the field looks
745 # something like 'field.' where '.' is a
746 # character that we don't exactly care about.
747 flowstr = flowstr[len(f[1]) + 1 :]
748 splitchar = 0
749 for c in flowstr:
750 if c == "," or c == ")":
751 break
752 splitchar += 1
753 data = flowstr[:splitchar]
754 flowstr = flowstr[splitchar:]
755 else:
756 data = ""
757
758 if len(f) > 4:
759 k[f[0]], m[f[0]] = f[4](data)
760 else:
761 k[f[0]] = f[3](data)
762 m[f[0]] = f[3](data)
763
764 flowstr = flowstr[strspn(flowstr, ", ") :]
765 if len(flowstr) == 0:
766 return flowstr, k, m
767
768 flowstr = flowstr[strspn(flowstr, "), ") :]
769
770 return flowstr, k, m
771
772 def dpstr(self, masked=None, more=False):
773 outstr = self.proto_str + "("
774 first = False
775 for f in self.fields_map:
776 if first:
777 outstr += ","
778 if masked is None:
779 outstr += "%s=" % f[0]
780 if isinstance(f[2], str):
781 outstr += f[2] % self[f[1]]
782 else:
783 outstr += f[2](self[f[1]])
784 first = True
785 elif more or f[3](masked[f[1]]) != 0:
786 outstr += "%s=" % f[0]
787 if isinstance(f[2], str):
788 outstr += f[2] % self[f[1]]
789 else:
790 outstr += f[2](self[f[1]])
791 outstr += "/"
792 if isinstance(f[2], str):
793 outstr += f[2] % masked[f[1]]
794 else:
795 outstr += f[2](masked[f[1]])
796 first = True
797 outstr += ")"
798 return outstr
799
800 class ethaddr(ovs_key_proto):
801 fields = (
802 ("src", "!6s"),
803 ("dst", "!6s"),
804 )
805
806 fields_map = (
807 (
808 "src",
809 "src",
810 macstr,
811 lambda x: int.from_bytes(x, "big"),
812 convert_mac,
813 ),
814 (
815 "dst",
816 "dst",
817 macstr,
818 lambda x: int.from_bytes(x, "big"),
819 convert_mac,
820 ),
821 )
822
823 def __init__(
824 self,
825 data=None,
826 offset=None,
827 parent=None,
828 length=None,
829 init=None,
830 ):
831 ovskey.ovs_key_proto.__init__(
832 self,
833 "eth",
834 data=data,
835 offset=offset,
836 parent=parent,
837 length=length,
838 init=init,
839 )
840
841 class ovs_key_ipv4(ovs_key_proto):
842 fields = (
843 ("src", "!I"),
844 ("dst", "!I"),
845 ("proto", "B"),
846 ("tos", "B"),
847 ("ttl", "B"),
848 ("frag", "B"),
849 )
850
851 fields_map = (
852 (
853 "src",
854 "src",
855 lambda x: str(ipaddress.IPv4Address(x)),
856 int,
857 convert_ipv4,
858 ),
859 (
860 "dst",
861 "dst",
862 lambda x: str(ipaddress.IPv4Address(x)),
863 int,
864 convert_ipv4,
865 ),
866 ("proto", "proto", "%d", lambda x: int(x) if x else 0,
867 convert_int(8)),
868 ("tos", "tos", "%d", lambda x: int(x) if x else 0,
869 convert_int(8)),
870 ("ttl", "ttl", "%d", lambda x: int(x) if x else 0,
871 convert_int(8)),
872 ("frag", "frag", "%d", lambda x: int(x) if x else 0,
873 convert_int(8)),
874 )
875
876 def __init__(
877 self,
878 data=None,
879 offset=None,
880 parent=None,
881 length=None,
882 init=None,
883 ):
884 ovskey.ovs_key_proto.__init__(
885 self,
886 "ipv4",
887 data=data,
888 offset=offset,
889 parent=parent,
890 length=length,
891 init=init,
892 )
893
894 class ovs_key_ipv6(ovs_key_proto):
895 fields = (
896 ("src", "!16s"),
897 ("dst", "!16s"),
898 ("label", "!I"),
899 ("proto", "B"),
900 ("tclass", "B"),
901 ("hlimit", "B"),
902 ("frag", "B"),
903 )
904
905 fields_map = (
906 (
907 "src",
908 "src",
909 lambda x: str(ipaddress.IPv6Address(x)),
910 lambda x: int.from_bytes(x, "big"),
911 lambda x: ipaddress.IPv6Address(x),
912 ),
913 (
914 "dst",
915 "dst",
916 lambda x: str(ipaddress.IPv6Address(x)),
917 lambda x: int.from_bytes(x, "big"),
918 lambda x: ipaddress.IPv6Address(x),
919 ),
920 ("label", "label", "%d", int),
921 ("proto", "proto", "%d", int),
922 ("tclass", "tclass", "%d", int),
923 ("hlimit", "hlimit", "%d", int),
924 ("frag", "frag", "%d", int),
925 )
926
927 def __init__(
928 self,
929 data=None,
930 offset=None,
931 parent=None,
932 length=None,
933 init=None,
934 ):
935 ovskey.ovs_key_proto.__init__(
936 self,
937 "ipv6",
938 data=data,
939 offset=offset,
940 parent=parent,
941 length=length,
942 init=init,
943 )
944
945 class ovs_key_tcp(ovs_key_proto):
946 def __init__(
947 self,
948 data=None,
949 offset=None,
950 parent=None,
951 length=None,
952 init=None,
953 ):
954 ovskey.ovs_key_proto.__init__(
955 self,
956 "tcp",
957 data=data,
958 offset=offset,
959 parent=parent,
960 length=length,
961 init=init,
962 )
963
964 class ovs_key_udp(ovs_key_proto):
965 def __init__(
966 self,
967 data=None,
968 offset=None,
969 parent=None,
970 length=None,
971 init=None,
972 ):
973 ovskey.ovs_key_proto.__init__(
974 self,
975 "udp",
976 data=data,
977 offset=offset,
978 parent=parent,
979 length=length,
980 init=init,
981 )
982
983 class ovs_key_sctp(ovs_key_proto):
984 def __init__(
985 self,
986 data=None,
987 offset=None,
988 parent=None,
989 length=None,
990 init=None,
991 ):
992 ovskey.ovs_key_proto.__init__(
993 self,
994 "sctp",
995 data=data,
996 offset=offset,
997 parent=parent,
998 length=length,
999 init=init,
1000 )
1001
1002 class ovs_key_icmp(ovs_key_proto):
1003 fields = (
1004 ("type", "B"),
1005 ("code", "B"),
1006 )
1007
1008 fields_map = (
1009 ("type", "type", "%d", lambda x: int(x) if x else 0),
1010 ("code", "code", "%d", lambda x: int(x) if x else 0),
1011 )
1012
1013 def __init__(
1014 self,
1015 data=None,
1016 offset=None,
1017 parent=None,
1018 length=None,
1019 init=None,
1020 ):
1021 ovskey.ovs_key_proto.__init__(
1022 self,
1023 "icmp",
1024 data=data,
1025 offset=offset,
1026 parent=parent,
1027 length=length,
1028 init=init,
1029 )
1030
1031 class ovs_key_icmpv6(ovs_key_icmp):
1032 def __init__(
1033 self,
1034 data=None,
1035 offset=None,
1036 parent=None,
1037 length=None,
1038 init=None,
1039 ):
1040 ovskey.ovs_key_proto.__init__(
1041 self,
1042 "icmpv6",
1043 data=data,
1044 offset=offset,
1045 parent=parent,
1046 length=length,
1047 init=init,
1048 )
1049
1050 class ovs_key_arp(ovs_key_proto):
1051 fields = (
1052 ("sip", "!I"),
1053 ("tip", "!I"),
1054 ("op", "!H"),
1055 ("sha", "!6s"),
1056 ("tha", "!6s"),
1057 ("pad", "xx"),
1058 )
1059
1060 fields_map = (
1061 (
1062 "sip",
1063 "sip",
1064 lambda x: str(ipaddress.IPv4Address(x)),
1065 int,
1066 convert_ipv4,
1067 ),
1068 (
1069 "tip",
1070 "tip",
1071 lambda x: str(ipaddress.IPv4Address(x)),
1072 int,
1073 convert_ipv4,
1074 ),
1075 ("op", "op", "%d", lambda x: int(x) if x else 0),
1076 (
1077 "sha",
1078 "sha",
1079 macstr,
1080 lambda x: int.from_bytes(x, "big"),
1081 convert_mac,
1082 ),
1083 (
1084 "tha",
1085 "tha",
1086 macstr,
1087 lambda x: int.from_bytes(x, "big"),
1088 convert_mac,
1089 ),
1090 )
1091
1092 def __init__(
1093 self,
1094 data=None,
1095 offset=None,
1096 parent=None,
1097 length=None,
1098 init=None,
1099 ):
1100 ovskey.ovs_key_proto.__init__(
1101 self,
1102 "arp",
1103 data=data,
1104 offset=offset,
1105 parent=parent,
1106 length=length,
1107 init=init,
1108 )
1109
1110 class ovs_key_nd(ovs_key_proto):
1111 fields = (
1112 ("target", "!16s"),
1113 ("sll", "!6s"),
1114 ("tll", "!6s"),
1115 )
1116
1117 fields_map = (
1118 (
1119 "target",
1120 "target",
1121 lambda x: str(ipaddress.IPv6Address(x)),
1122 lambda x: int.from_bytes(x, "big"),
1123 ),
1124 ("sll", "sll", macstr, lambda x: int.from_bytes(x, "big")),
1125 ("tll", "tll", macstr, lambda x: int.from_bytes(x, "big")),
1126 )
1127
1128 def __init__(
1129 self,
1130 data=None,
1131 offset=None,
1132 parent=None,
1133 length=None,
1134 init=None,
1135 ):
1136 ovskey.ovs_key_proto.__init__(
1137 self,
1138 "nd",
1139 data=data,
1140 offset=offset,
1141 parent=parent,
1142 length=length,
1143 init=init,
1144 )
1145
1146 class ovs_key_ct_tuple_ipv4(ovs_key_proto):
1147 fields = (
1148 ("src", "!I"),
1149 ("dst", "!I"),
1150 ("tp_src", "!H"),
1151 ("tp_dst", "!H"),
1152 ("proto", "B"),
1153 )
1154
1155 fields_map = (
1156 (
1157 "src",
1158 "src",
1159 lambda x: str(ipaddress.IPv4Address(x)),
1160 int,
1161 convert_ipv4,
1162 ),
1163 (
1164 "dst",
1165 "dst",
1166 lambda x: str(ipaddress.IPv4Address(x)),
1167 int,
1168 convert_ipv4,
1169 ),
1170 ("tp_src", "tp_src", "%d", int),
1171 ("tp_dst", "tp_dst", "%d", int),
1172 ("proto", "proto", "%d", int),
1173 )
1174
1175 def __init__(
1176 self,
1177 data=None,
1178 offset=None,
1179 parent=None,
1180 length=None,
1181 init=None,
1182 ):
1183 ovskey.ovs_key_proto.__init__(
1184 self,
1185 "ct_tuple4",
1186 data=data,
1187 offset=offset,
1188 parent=parent,
1189 length=length,
1190 init=init,
1191 )
1192
1193 class ovs_key_ct_tuple_ipv6(nla):
1194 fields = (
1195 ("src", "!16s"),
1196 ("dst", "!16s"),
1197 ("tp_src", "!H"),
1198 ("tp_dst", "!H"),
1199 ("proto", "B"),
1200 )
1201
1202 fields_map = (
1203 (
1204 "src",
1205 "src",
1206 lambda x: str(ipaddress.IPv6Address(x)),
1207 lambda x: int.from_bytes(x, "big", convertmac),
1208 ),
1209 (
1210 "dst",
1211 "dst",
1212 lambda x: str(ipaddress.IPv6Address(x)),
1213 lambda x: int.from_bytes(x, "big"),
1214 ),
1215 ("tp_src", "tp_src", "%d", int),
1216 ("tp_dst", "tp_dst", "%d", int),
1217 ("proto", "proto", "%d", int),
1218 )
1219
1220 def __init__(
1221 self,
1222 data=None,
1223 offset=None,
1224 parent=None,
1225 length=None,
1226 init=None,
1227 ):
1228 ovskey.ovs_key_proto.__init__(
1229 self,
1230 "ct_tuple6",
1231 data=data,
1232 offset=offset,
1233 parent=parent,
1234 length=length,
1235 init=init,
1236 )
1237
1238 class ovs_key_mpls(nla):
1239 fields = (("lse", ">I"),)
1240
1241 def parse(self, flowstr, mask=None):
1242 for field in (
1243 ("OVS_KEY_ATTR_PRIORITY", "skb_priority", intparse),
1244 ("OVS_KEY_ATTR_SKB_MARK", "skb_mark", intparse),
1245 ("OVS_KEY_ATTR_RECIRC_ID", "recirc_id", intparse),
1246 ("OVS_KEY_ATTR_DP_HASH", "dp_hash", intparse),
1247 ("OVS_KEY_ATTR_CT_STATE", "ct_state", parse_ct_state),
1248 ("OVS_KEY_ATTR_CT_ZONE", "ct_zone", intparse),
1249 ("OVS_KEY_ATTR_CT_MARK", "ct_mark", intparse),
1250 ("OVS_KEY_ATTR_IN_PORT", "in_port", intparse),
1251 (
1252 "OVS_KEY_ATTR_ETHERNET",
1253 "eth",
1254 ovskey.ethaddr,
1255 ),
1256 (
1257 "OVS_KEY_ATTR_ETHERTYPE",
1258 "eth_type",
1259 lambda x: intparse(x, "0xffff"),
1260 ),
1261 (
1262 "OVS_KEY_ATTR_IPV4",
1263 "ipv4",
1264 ovskey.ovs_key_ipv4,
1265 ),
1266 (
1267 "OVS_KEY_ATTR_IPV6",
1268 "ipv6",
1269 ovskey.ovs_key_ipv6,
1270 ),
1271 (
1272 "OVS_KEY_ATTR_ARP",
1273 "arp",
1274 ovskey.ovs_key_arp,
1275 ),
1276 (
1277 "OVS_KEY_ATTR_TCP",
1278 "tcp",
1279 ovskey.ovs_key_tcp,
1280 ),
1281 (
1282 "OVS_KEY_ATTR_UDP",
1283 "udp",
1284 ovskey.ovs_key_udp,
1285 ),
1286 (
1287 "OVS_KEY_ATTR_ICMP",
1288 "icmp",
1289 ovskey.ovs_key_icmp,
1290 ),
1291 (
1292 "OVS_KEY_ATTR_TCP_FLAGS",
1293 "tcp_flags",
1294 lambda x: parse_flags(x, None),
1295 ),
1296 ):
1297 fld = field[1] + "("
1298 if not flowstr.startswith(fld):
1299 continue
1300
1301 if not isinstance(field[2], types.FunctionType):
1302 nk = field[2]()
1303 flowstr, k, m = nk.parse(flowstr, field[2])
1304 else:
1305 flowstr = flowstr[len(fld) :]
1306 flowstr, k, m = field[2](flowstr)
1307
1308 if m and mask is not None:
1309 mask["attrs"].append([field[0], m])
1310 self["attrs"].append([field[0], k])
1311
1312 flowstr = flowstr[strspn(flowstr, "),") :]
1313
1314 return flowstr
1315
1316 def dpstr(self, mask=None, more=False):
1317 print_str = ""
1318
1319 for field in (
1320 (
1321 "OVS_KEY_ATTR_PRIORITY",
1322 "skb_priority",
1323 "%d",
1324 lambda x: False,
1325 True,
1326 ),
1327 (
1328 "OVS_KEY_ATTR_SKB_MARK",
1329 "skb_mark",
1330 "%d",
1331 lambda x: False,
1332 True,
1333 ),
1334 (
1335 "OVS_KEY_ATTR_RECIRC_ID",
1336 "recirc_id",
1337 "0x%08X",
1338 lambda x: False,
1339 True,
1340 ),
1341 (
1342 "OVS_KEY_ATTR_DP_HASH",
1343 "dp_hash",
1344 "0x%08X",
1345 lambda x: False,
1346 True,
1347 ),
1348 (
1349 "OVS_KEY_ATTR_CT_STATE",
1350 "ct_state",
1351 "0x%04x",
1352 lambda x: False,
1353 True,
1354 ),
1355 (
1356 "OVS_KEY_ATTR_CT_ZONE",
1357 "ct_zone",
1358 "0x%04x",
1359 lambda x: False,
1360 True,
1361 ),
1362 (
1363 "OVS_KEY_ATTR_CT_MARK",
1364 "ct_mark",
1365 "0x%08x",
1366 lambda x: False,
1367 True,
1368 ),
1369 (
1370 "OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4",
1371 None,
1372 None,
1373 False,
1374 False,
1375 ),
1376 (
1377 "OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6",
1378 None,
1379 None,
1380 False,
1381 False,
1382 ),
1383 (
1384 "OVS_KEY_ATTR_IN_PORT",
1385 "in_port",
1386 "%d",
1387 lambda x: True,
1388 True,
1389 ),
1390 ("OVS_KEY_ATTR_ETHERNET", None, None, False, False),
1391 (
1392 "OVS_KEY_ATTR_ETHERTYPE",
1393 "eth_type",
1394 "0x%04x",
1395 lambda x: int(x) == 0xFFFF,
1396 True,
1397 ),
1398 ("OVS_KEY_ATTR_IPV4", None, None, False, False),
1399 ("OVS_KEY_ATTR_IPV6", None, None, False, False),
1400 ("OVS_KEY_ATTR_ARP", None, None, False, False),
1401 ("OVS_KEY_ATTR_TCP", None, None, False, False),
1402 (
1403 "OVS_KEY_ATTR_TCP_FLAGS",
1404 "tcp_flags",
1405 "0x%04x",
1406 lambda x: False,
1407 True,
1408 ),
1409 ("OVS_KEY_ATTR_UDP", None, None, False, False),
1410 ("OVS_KEY_ATTR_SCTP", None, None, False, False),
1411 ("OVS_KEY_ATTR_ICMP", None, None, False, False),
1412 ("OVS_KEY_ATTR_ICMPV6", None, None, False, False),
1413 ("OVS_KEY_ATTR_ND", None, None, False, False),
1414 ):
1415 v = self.get_attr(field[0])
1416 if v is not None:
1417 m = None if mask is None else mask.get_attr(field[0])
1418 if field[4] is False:
1419 print_str += v.dpstr(m, more)
1420 print_str += ","
1421 else:
1422 if m is None or field[3](m):
1423 print_str += field[1] + "("
1424 print_str += field[2] % v
1425 print_str += "),"
1426 elif more or m != 0:
1427 print_str += field[1] + "("
1428 print_str += (field[2] % v) + "/" + (field[2] % m)
1429 print_str += "),"
1430
1431 return print_str
1432
1433
1434class OvsPacket(GenericNetlinkSocket):
1435 OVS_PACKET_CMD_MISS = 1 # Flow table miss
1436 OVS_PACKET_CMD_ACTION = 2 # USERSPACE action
1437 OVS_PACKET_CMD_EXECUTE = 3 # Apply actions to packet
1438
1439 class ovs_packet_msg(ovs_dp_msg):
1440 nla_map = (
1441 ("OVS_PACKET_ATTR_UNSPEC", "none"),
1442 ("OVS_PACKET_ATTR_PACKET", "array(uint8)"),
1443 ("OVS_PACKET_ATTR_KEY", "ovskey"),
1444 ("OVS_PACKET_ATTR_ACTIONS", "ovsactions"),
1445 ("OVS_PACKET_ATTR_USERDATA", "none"),
1446 ("OVS_PACKET_ATTR_EGRESS_TUN_KEY", "none"),
1447 ("OVS_PACKET_ATTR_UNUSED1", "none"),
1448 ("OVS_PACKET_ATTR_UNUSED2", "none"),
1449 ("OVS_PACKET_ATTR_PROBE", "none"),
1450 ("OVS_PACKET_ATTR_MRU", "uint16"),
1451 ("OVS_PACKET_ATTR_LEN", "uint32"),
1452 ("OVS_PACKET_ATTR_HASH", "uint64"),
1453 )
1454
1455 def __init__(self):
1456 GenericNetlinkSocket.__init__(self)
1457 self.bind(OVS_PACKET_FAMILY, OvsPacket.ovs_packet_msg)
1458
1459 def upcall_handler(self, up=None):
1460 print("listening on upcall packet handler:", self.epid)
1461 while True:
1462 try:
1463 msgs = self.get()
1464 for msg in msgs:
1465 if not up:
1466 continue
1467 if msg["cmd"] == OvsPacket.OVS_PACKET_CMD_MISS:
1468 up.miss(msg)
1469 elif msg["cmd"] == OvsPacket.OVS_PACKET_CMD_ACTION:
1470 up.action(msg)
1471 elif msg["cmd"] == OvsPacket.OVS_PACKET_CMD_EXECUTE:
1472 up.execute(msg)
1473 else:
1474 print("Unkonwn cmd: %d" % msg["cmd"])
1475 except NetlinkError as ne:
1476 raise ne
1477
1478
1479class OvsDatapath(GenericNetlinkSocket):
1480 OVS_DP_F_VPORT_PIDS = 1 << 1
1481 OVS_DP_F_DISPATCH_UPCALL_PER_CPU = 1 << 3
1482
1483 class dp_cmd_msg(ovs_dp_msg):
1484 """
1485 Message class that will be used to communicate with the kernel module.
1486 """
1487
1488 nla_map = (
1489 ("OVS_DP_ATTR_UNSPEC", "none"),
1490 ("OVS_DP_ATTR_NAME", "asciiz"),
1491 ("OVS_DP_ATTR_UPCALL_PID", "array(uint32)"),
1492 ("OVS_DP_ATTR_STATS", "dpstats"),
1493 ("OVS_DP_ATTR_MEGAFLOW_STATS", "megaflowstats"),
1494 ("OVS_DP_ATTR_USER_FEATURES", "uint32"),
1495 ("OVS_DP_ATTR_PAD", "none"),
1496 ("OVS_DP_ATTR_MASKS_CACHE_SIZE", "uint32"),
1497 ("OVS_DP_ATTR_PER_CPU_PIDS", "array(uint32)"),
1498 )
1499
1500 class dpstats(nla):
1501 fields = (
1502 ("hit", "=Q"),
1503 ("missed", "=Q"),
1504 ("lost", "=Q"),
1505 ("flows", "=Q"),
1506 )
1507
1508 class megaflowstats(nla):
1509 fields = (
1510 ("mask_hit", "=Q"),
1511 ("masks", "=I"),
1512 ("padding", "=I"),
1513 ("cache_hits", "=Q"),
1514 ("pad1", "=Q"),
1515 )
1516
1517 def __init__(self):
1518 GenericNetlinkSocket.__init__(self)
1519 self.bind(OVS_DATAPATH_FAMILY, OvsDatapath.dp_cmd_msg)
1520
1521 def info(self, dpname, ifindex=0):
1522 msg = OvsDatapath.dp_cmd_msg()
1523 msg["cmd"] = OVS_DP_CMD_GET
1524 msg["version"] = OVS_DATAPATH_VERSION
1525 msg["reserved"] = 0
1526 msg["dpifindex"] = ifindex
1527 msg["attrs"].append(["OVS_DP_ATTR_NAME", dpname])
1528
1529 try:
1530 reply = self.nlm_request(
1531 msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST
1532 )
1533 reply = reply[0]
1534 except NetlinkError as ne:
1535 if ne.code == errno.ENODEV:
1536 reply = None
1537 else:
1538 raise ne
1539
1540 return reply
1541
1542 def create(
1543 self, dpname, shouldUpcall=False, versionStr=None, p=OvsPacket()
1544 ):
1545 msg = OvsDatapath.dp_cmd_msg()
1546 msg["cmd"] = OVS_DP_CMD_NEW
1547 if versionStr is None:
1548 msg["version"] = OVS_DATAPATH_VERSION
1549 else:
1550 msg["version"] = int(versionStr.split(":")[0], 0)
1551 msg["reserved"] = 0
1552 msg["dpifindex"] = 0
1553 msg["attrs"].append(["OVS_DP_ATTR_NAME", dpname])
1554
1555 dpfeatures = 0
1556 if versionStr is not None and versionStr.find(":") != -1:
1557 dpfeatures = int(versionStr.split(":")[1], 0)
1558 else:
1559 if versionStr is None or versionStr.find(":") == -1:
1560 dpfeatures |= OvsDatapath.OVS_DP_F_DISPATCH_UPCALL_PER_CPU
1561 dpfeatures &= ~OvsDatapath.OVS_DP_F_VPORT_PIDS
1562
1563 nproc = multiprocessing.cpu_count()
1564 procarray = []
1565 for i in range(1, nproc):
1566 procarray += [int(p.epid)]
1567 msg["attrs"].append(["OVS_DP_ATTR_UPCALL_PID", procarray])
1568 msg["attrs"].append(["OVS_DP_ATTR_USER_FEATURES", dpfeatures])
1569 if not shouldUpcall:
1570 msg["attrs"].append(["OVS_DP_ATTR_UPCALL_PID", [0]])
1571
1572 try:
1573 reply = self.nlm_request(
1574 msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST | NLM_F_ACK
1575 )
1576 reply = reply[0]
1577 except NetlinkError as ne:
1578 if ne.code == errno.EEXIST:
1579 reply = None
1580 else:
1581 raise ne
1582
1583 return reply
1584
1585 def destroy(self, dpname):
1586 msg = OvsDatapath.dp_cmd_msg()
1587 msg["cmd"] = OVS_DP_CMD_DEL
1588 msg["version"] = OVS_DATAPATH_VERSION
1589 msg["reserved"] = 0
1590 msg["dpifindex"] = 0
1591 msg["attrs"].append(["OVS_DP_ATTR_NAME", dpname])
1592
1593 try:
1594 reply = self.nlm_request(
1595 msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST | NLM_F_ACK
1596 )
1597 reply = reply[0]
1598 except NetlinkError as ne:
1599 if ne.code == errno.ENODEV:
1600 reply = None
1601 else:
1602 raise ne
1603
1604 return reply
1605
1606
1607class OvsVport(GenericNetlinkSocket):
1608 OVS_VPORT_TYPE_NETDEV = 1
1609 OVS_VPORT_TYPE_INTERNAL = 2
1610 OVS_VPORT_TYPE_GRE = 3
1611 OVS_VPORT_TYPE_VXLAN = 4
1612 OVS_VPORT_TYPE_GENEVE = 5
1613
1614 class ovs_vport_msg(ovs_dp_msg):
1615 nla_map = (
1616 ("OVS_VPORT_ATTR_UNSPEC", "none"),
1617 ("OVS_VPORT_ATTR_PORT_NO", "uint32"),
1618 ("OVS_VPORT_ATTR_TYPE", "uint32"),
1619 ("OVS_VPORT_ATTR_NAME", "asciiz"),
1620 ("OVS_VPORT_ATTR_OPTIONS", "none"),
1621 ("OVS_VPORT_ATTR_UPCALL_PID", "array(uint32)"),
1622 ("OVS_VPORT_ATTR_STATS", "vportstats"),
1623 ("OVS_VPORT_ATTR_PAD", "none"),
1624 ("OVS_VPORT_ATTR_IFINDEX", "uint32"),
1625 ("OVS_VPORT_ATTR_NETNSID", "uint32"),
1626 )
1627
1628 class vportstats(nla):
1629 fields = (
1630 ("rx_packets", "=Q"),
1631 ("tx_packets", "=Q"),
1632 ("rx_bytes", "=Q"),
1633 ("tx_bytes", "=Q"),
1634 ("rx_errors", "=Q"),
1635 ("tx_errors", "=Q"),
1636 ("rx_dropped", "=Q"),
1637 ("tx_dropped", "=Q"),
1638 )
1639
1640 def type_to_str(vport_type):
1641 if vport_type == OvsVport.OVS_VPORT_TYPE_NETDEV:
1642 return "netdev"
1643 elif vport_type == OvsVport.OVS_VPORT_TYPE_INTERNAL:
1644 return "internal"
1645 elif vport_type == OvsVport.OVS_VPORT_TYPE_GRE:
1646 return "gre"
1647 elif vport_type == OvsVport.OVS_VPORT_TYPE_VXLAN:
1648 return "vxlan"
1649 elif vport_type == OvsVport.OVS_VPORT_TYPE_GENEVE:
1650 return "geneve"
1651 raise ValueError("Unknown vport type:%d" % vport_type)
1652
1653 def str_to_type(vport_type):
1654 if vport_type == "netdev":
1655 return OvsVport.OVS_VPORT_TYPE_NETDEV
1656 elif vport_type == "internal":
1657 return OvsVport.OVS_VPORT_TYPE_INTERNAL
1658 elif vport_type == "gre":
1659 return OvsVport.OVS_VPORT_TYPE_INTERNAL
1660 elif vport_type == "vxlan":
1661 return OvsVport.OVS_VPORT_TYPE_VXLAN
1662 elif vport_type == "geneve":
1663 return OvsVport.OVS_VPORT_TYPE_GENEVE
1664 raise ValueError("Unknown vport type: '%s'" % vport_type)
1665
1666 def __init__(self, packet=OvsPacket()):
1667 GenericNetlinkSocket.__init__(self)
1668 self.bind(OVS_VPORT_FAMILY, OvsVport.ovs_vport_msg)
1669 self.upcall_packet = packet
1670
1671 def info(self, vport_name, dpifindex=0, portno=None):
1672 msg = OvsVport.ovs_vport_msg()
1673
1674 msg["cmd"] = OVS_VPORT_CMD_GET
1675 msg["version"] = OVS_DATAPATH_VERSION
1676 msg["reserved"] = 0
1677 msg["dpifindex"] = dpifindex
1678
1679 if portno is None:
1680 msg["attrs"].append(["OVS_VPORT_ATTR_NAME", vport_name])
1681 else:
1682 msg["attrs"].append(["OVS_VPORT_ATTR_PORT_NO", portno])
1683
1684 try:
1685 reply = self.nlm_request(
1686 msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST
1687 )
1688 reply = reply[0]
1689 except NetlinkError as ne:
1690 if ne.code == errno.ENODEV:
1691 reply = None
1692 else:
1693 raise ne
1694 return reply
1695
1696 def attach(self, dpindex, vport_ifname, ptype):
1697 msg = OvsVport.ovs_vport_msg()
1698
1699 msg["cmd"] = OVS_VPORT_CMD_NEW
1700 msg["version"] = OVS_DATAPATH_VERSION
1701 msg["reserved"] = 0
1702 msg["dpifindex"] = dpindex
1703 port_type = OvsVport.str_to_type(ptype)
1704
1705 msg["attrs"].append(["OVS_VPORT_ATTR_TYPE", port_type])
1706 msg["attrs"].append(["OVS_VPORT_ATTR_NAME", vport_ifname])
1707 msg["attrs"].append(
1708 ["OVS_VPORT_ATTR_UPCALL_PID", [self.upcall_packet.epid]]
1709 )
1710
1711 try:
1712 reply = self.nlm_request(
1713 msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST | NLM_F_ACK
1714 )
1715 reply = reply[0]
1716 except NetlinkError as ne:
1717 if ne.code == errno.EEXIST:
1718 reply = None
1719 else:
1720 raise ne
1721 return reply
1722
1723 def reset_upcall(self, dpindex, vport_ifname, p=None):
1724 msg = OvsVport.ovs_vport_msg()
1725
1726 msg["cmd"] = OVS_VPORT_CMD_SET
1727 msg["version"] = OVS_DATAPATH_VERSION
1728 msg["reserved"] = 0
1729 msg["dpifindex"] = dpindex
1730 msg["attrs"].append(["OVS_VPORT_ATTR_NAME", vport_ifname])
1731
1732 if p == None:
1733 p = self.upcall_packet
1734 else:
1735 self.upcall_packet = p
1736
1737 msg["attrs"].append(["OVS_VPORT_ATTR_UPCALL_PID", [p.epid]])
1738
1739 try:
1740 reply = self.nlm_request(
1741 msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST | NLM_F_ACK
1742 )
1743 reply = reply[0]
1744 except NetlinkError as ne:
1745 raise ne
1746 return reply
1747
1748 def detach(self, dpindex, vport_ifname):
1749 msg = OvsVport.ovs_vport_msg()
1750
1751 msg["cmd"] = OVS_VPORT_CMD_DEL
1752 msg["version"] = OVS_DATAPATH_VERSION
1753 msg["reserved"] = 0
1754 msg["dpifindex"] = dpindex
1755 msg["attrs"].append(["OVS_VPORT_ATTR_NAME", vport_ifname])
1756
1757 try:
1758 reply = self.nlm_request(
1759 msg, msg_type=self.prid, msg_flags=NLM_F_REQUEST | NLM_F_ACK
1760 )
1761 reply = reply[0]
1762 except NetlinkError as ne:
1763 if ne.code == errno.ENODEV:
1764 reply = None
1765 else:
1766 raise ne
1767 return reply
1768
1769 def upcall_handler(self, handler=None):
1770 self.upcall_packet.upcall_handler(handler)
1771
1772
1773class OvsFlow(GenericNetlinkSocket):
1774 class ovs_flow_msg(ovs_dp_msg):
1775 nla_map = (
1776 ("OVS_FLOW_ATTR_UNSPEC", "none"),
1777 ("OVS_FLOW_ATTR_KEY", "ovskey"),
1778 ("OVS_FLOW_ATTR_ACTIONS", "ovsactions"),
1779 ("OVS_FLOW_ATTR_STATS", "flowstats"),
1780 ("OVS_FLOW_ATTR_TCP_FLAGS", "uint8"),
1781 ("OVS_FLOW_ATTR_USED", "uint64"),
1782 ("OVS_FLOW_ATTR_CLEAR", "none"),
1783 ("OVS_FLOW_ATTR_MASK", "ovskey"),
1784 ("OVS_FLOW_ATTR_PROBE", "none"),
1785 ("OVS_FLOW_ATTR_UFID", "array(uint32)"),
1786 ("OVS_FLOW_ATTR_UFID_FLAGS", "uint32"),
1787 )
1788
1789 class flowstats(nla):
1790 fields = (
1791 ("packets", "=Q"),
1792 ("bytes", "=Q"),
1793 )
1794
1795 def dpstr(self, more=False):
1796 ufid = self.get_attr("OVS_FLOW_ATTR_UFID")
1797 ufid_str = ""
1798 if ufid is not None:
1799 ufid_str = (
1800 "ufid:{:08x}-{:04x}-{:04x}-{:04x}-{:04x}{:08x}".format(
1801 ufid[0],
1802 ufid[1] >> 16,
1803 ufid[1] & 0xFFFF,
1804 ufid[2] >> 16,
1805 ufid[2] & 0,
1806 ufid[3],
1807 )
1808 )
1809
1810 key_field = self.get_attr("OVS_FLOW_ATTR_KEY")
1811 keymsg = None
1812 if key_field is not None:
1813 keymsg = key_field
1814
1815 mask_field = self.get_attr("OVS_FLOW_ATTR_MASK")
1816 maskmsg = None
1817 if mask_field is not None:
1818 maskmsg = mask_field
1819
1820 acts_field = self.get_attr("OVS_FLOW_ATTR_ACTIONS")
1821 actsmsg = None
1822 if acts_field is not None:
1823 actsmsg = acts_field
1824
1825 print_str = ""
1826
1827 if more:
1828 print_str += ufid_str + ","
1829
1830 if keymsg is not None:
1831 print_str += keymsg.dpstr(maskmsg, more)
1832
1833 stats = self.get_attr("OVS_FLOW_ATTR_STATS")
1834 if stats is None:
1835 print_str += " packets:0, bytes:0,"
1836 else:
1837 print_str += " packets:%d, bytes:%d," % (
1838 stats["packets"],
1839 stats["bytes"],
1840 )
1841
1842 used = self.get_attr("OVS_FLOW_ATTR_USED")
1843 print_str += " used:"
1844 if used is None:
1845 print_str += "never,"
1846 else:
1847 used_time = int(used)
1848 cur_time_sec = time.clock_gettime(time.CLOCK_MONOTONIC)
1849 used_time = (cur_time_sec * 1000) - used_time
1850 print_str += "{}s,".format(used_time / 1000)
1851
1852 print_str += " actions:"
1853 if (
1854 actsmsg is None
1855 or "attrs" not in actsmsg
1856 or len(actsmsg["attrs"]) == 0
1857 ):
1858 print_str += "drop"
1859 else:
1860 print_str += actsmsg.dpstr(more)
1861
1862 return print_str
1863
1864 def parse(self, flowstr, actstr, dpidx=0):
1865 OVS_UFID_F_OMIT_KEY = 1 << 0
1866 OVS_UFID_F_OMIT_MASK = 1 << 1
1867 OVS_UFID_F_OMIT_ACTIONS = 1 << 2
1868
1869 self["cmd"] = 0
1870 self["version"] = 0
1871 self["reserved"] = 0
1872 self["dpifindex"] = 0
1873
1874 if flowstr.startswith("ufid:"):
1875 count = 5
1876 while flowstr[count] != ",":
1877 count += 1
1878 ufidstr = flowstr[5:count]
1879 flowstr = flowstr[count + 1 :]
1880 else:
1881 ufidstr = str(uuid.uuid4())
1882 uuidRawObj = uuid.UUID(ufidstr).fields
1883
1884 self["attrs"].append(
1885 [
1886 "OVS_FLOW_ATTR_UFID",
1887 [
1888 uuidRawObj[0],
1889 uuidRawObj[1] << 16 | uuidRawObj[2],
1890 uuidRawObj[3] << 24
1891 | uuidRawObj[4] << 16
1892 | uuidRawObj[5] & (0xFF << 32) >> 32,
1893 uuidRawObj[5] & (0xFFFFFFFF),
1894 ],
1895 ]
1896 )
1897 self["attrs"].append(
1898 [
1899 "OVS_FLOW_ATTR_UFID_FLAGS",
1900 int(
1901 OVS_UFID_F_OMIT_KEY
1902 | OVS_UFID_F_OMIT_MASK
1903 | OVS_UFID_F_OMIT_ACTIONS
1904 ),
1905 ]
1906 )
1907
1908 k = ovskey()
1909 m = ovskey()
1910 k.parse(flowstr, m)
1911 self["attrs"].append(["OVS_FLOW_ATTR_KEY", k])
1912 self["attrs"].append(["OVS_FLOW_ATTR_MASK", m])
1913
1914 a = ovsactions()
1915 a.parse(actstr)
1916 self["attrs"].append(["OVS_FLOW_ATTR_ACTIONS", a])
1917
1918 def __init__(self):
1919 GenericNetlinkSocket.__init__(self)
1920
1921 self.bind(OVS_FLOW_FAMILY, OvsFlow.ovs_flow_msg)
1922
1923 def add_flow(self, dpifindex, flowmsg):
1924 """
1925 Send a new flow message to the kernel.
1926
1927 dpifindex should be a valid datapath obtained by calling
1928 into the OvsDatapath lookup
1929
1930 flowmsg is a flow object obtained by calling a dpparse
1931 """
1932
1933 flowmsg["cmd"] = OVS_FLOW_CMD_NEW
1934 flowmsg["version"] = OVS_DATAPATH_VERSION
1935 flowmsg["reserved"] = 0
1936 flowmsg["dpifindex"] = dpifindex
1937
1938 try:
1939 reply = self.nlm_request(
1940 flowmsg,
1941 msg_type=self.prid,
1942 msg_flags=NLM_F_REQUEST | NLM_F_ACK,
1943 )
1944 reply = reply[0]
1945 except NetlinkError as ne:
1946 print(flowmsg)
1947 raise ne
1948 return reply
1949
1950 def del_flows(self, dpifindex):
1951 """
1952 Send a del message to the kernel that will drop all flows.
1953
1954 dpifindex should be a valid datapath obtained by calling
1955 into the OvsDatapath lookup
1956 """
1957
1958 flowmsg = OvsFlow.ovs_flow_msg()
1959 flowmsg["cmd"] = OVS_FLOW_CMD_DEL
1960 flowmsg["version"] = OVS_DATAPATH_VERSION
1961 flowmsg["reserved"] = 0
1962 flowmsg["dpifindex"] = dpifindex
1963
1964 try:
1965 reply = self.nlm_request(
1966 flowmsg,
1967 msg_type=self.prid,
1968 msg_flags=NLM_F_REQUEST | NLM_F_ACK,
1969 )
1970 reply = reply[0]
1971 except NetlinkError as ne:
1972 print(flowmsg)
1973 raise ne
1974 return reply
1975
1976 def dump(self, dpifindex, flowspec=None):
1977 """
1978 Returns a list of messages containing flows.
1979
1980 dpifindex should be a valid datapath obtained by calling
1981 into the OvsDatapath lookup
1982
1983 flowpsec is a string which represents a flow in the dpctl
1984 format.
1985 """
1986 msg = OvsFlow.ovs_flow_msg()
1987
1988 msg["cmd"] = OVS_FLOW_CMD_GET
1989 msg["version"] = OVS_DATAPATH_VERSION
1990 msg["reserved"] = 0
1991 msg["dpifindex"] = dpifindex
1992
1993 msg_flags = NLM_F_REQUEST | NLM_F_ACK
1994 if flowspec is None:
1995 msg_flags |= NLM_F_DUMP
1996 rep = None
1997
1998 try:
1999 rep = self.nlm_request(
2000 msg,
2001 msg_type=self.prid,
2002 msg_flags=msg_flags,
2003 )
2004 except NetlinkError as ne:
2005 raise ne
2006 return rep
2007
2008 def miss(self, packetmsg):
2009 seq = packetmsg["header"]["sequence_number"]
2010 keystr = "(none)"
2011 key_field = packetmsg.get_attr("OVS_PACKET_ATTR_KEY")
2012 if key_field is not None:
2013 keystr = key_field.dpstr(None, True)
2014
2015 pktdata = packetmsg.get_attr("OVS_PACKET_ATTR_PACKET")
2016 pktpres = "yes" if pktdata is not None else "no"
2017
2018 print("MISS upcall[%d/%s]: %s" % (seq, pktpres, keystr), flush=True)
2019
2020 def execute(self, packetmsg):
2021 print("userspace execute command")
2022
2023 def action(self, packetmsg):
2024 print("userspace action command")
2025
2026
2027def print_ovsdp_full(dp_lookup_rep, ifindex, ndb=NDB(), vpl=OvsVport()):
2028 dp_name = dp_lookup_rep.get_attr("OVS_DP_ATTR_NAME")
2029 base_stats = dp_lookup_rep.get_attr("OVS_DP_ATTR_STATS")
2030 megaflow_stats = dp_lookup_rep.get_attr("OVS_DP_ATTR_MEGAFLOW_STATS")
2031 user_features = dp_lookup_rep.get_attr("OVS_DP_ATTR_USER_FEATURES")
2032 masks_cache_size = dp_lookup_rep.get_attr("OVS_DP_ATTR_MASKS_CACHE_SIZE")
2033
2034 print("%s:" % dp_name)
2035 print(
2036 " lookups: hit:%d missed:%d lost:%d"
2037 % (base_stats["hit"], base_stats["missed"], base_stats["lost"])
2038 )
2039 print(" flows:%d" % base_stats["flows"])
2040 pkts = base_stats["hit"] + base_stats["missed"]
2041 avg = (megaflow_stats["mask_hit"] / pkts) if pkts != 0 else 0.0
2042 print(
2043 " masks: hit:%d total:%d hit/pkt:%f"
2044 % (megaflow_stats["mask_hit"], megaflow_stats["masks"], avg)
2045 )
2046 print(" caches:")
2047 print(" masks-cache: size:%d" % masks_cache_size)
2048
2049 if user_features is not None:
2050 print(" features: 0x%X" % user_features)
2051
2052 # port print out
2053 for iface in ndb.interfaces:
2054 rep = vpl.info(iface.ifname, ifindex)
2055 if rep is not None:
2056 print(
2057 " port %d: %s (%s)"
2058 % (
2059 rep.get_attr("OVS_VPORT_ATTR_PORT_NO"),
2060 rep.get_attr("OVS_VPORT_ATTR_NAME"),
2061 OvsVport.type_to_str(rep.get_attr("OVS_VPORT_ATTR_TYPE")),
2062 )
2063 )
2064
2065
2066def main(argv):
2067 nlmsg_atoms.ovskey = ovskey
2068 nlmsg_atoms.ovsactions = ovsactions
2069
2070 # version check for pyroute2
2071 prverscheck = pyroute2.__version__.split(".")
2072 if int(prverscheck[0]) == 0 and int(prverscheck[1]) < 6:
2073 print("Need to upgrade the python pyroute2 package to >= 0.6.")
2074 sys.exit(0)
2075
2076 parser = argparse.ArgumentParser()
2077 parser.add_argument(
2078 "-v",
2079 "--verbose",
2080 action="count",
2081 help="Increment 'verbose' output counter.",
2082 default=0,
2083 )
2084 subparsers = parser.add_subparsers()
2085
2086 showdpcmd = subparsers.add_parser("show")
2087 showdpcmd.add_argument(
2088 "showdp", metavar="N", type=str, nargs="?", help="Datapath Name"
2089 )
2090
2091 adddpcmd = subparsers.add_parser("add-dp")
2092 adddpcmd.add_argument("adddp", help="Datapath Name")
2093 adddpcmd.add_argument(
2094 "-u",
2095 "--upcall",
2096 action="store_true",
2097 help="Leave open a reader for upcalls",
2098 )
2099 adddpcmd.add_argument(
2100 "-V",
2101 "--versioning",
2102 required=False,
2103 help="Specify a custom version / feature string",
2104 )
2105
2106 deldpcmd = subparsers.add_parser("del-dp")
2107 deldpcmd.add_argument("deldp", help="Datapath Name")
2108
2109 addifcmd = subparsers.add_parser("add-if")
2110 addifcmd.add_argument("dpname", help="Datapath Name")
2111 addifcmd.add_argument("addif", help="Interface name for adding")
2112 addifcmd.add_argument(
2113 "-u",
2114 "--upcall",
2115 action="store_true",
2116 help="Leave open a reader for upcalls",
2117 )
2118 addifcmd.add_argument(
2119 "-t",
2120 "--ptype",
2121 type=str,
2122 default="netdev",
2123 choices=["netdev", "internal"],
2124 help="Interface type (default netdev)",
2125 )
2126 delifcmd = subparsers.add_parser("del-if")
2127 delifcmd.add_argument("dpname", help="Datapath Name")
2128 delifcmd.add_argument("delif", help="Interface name for adding")
2129
2130 dumpflcmd = subparsers.add_parser("dump-flows")
2131 dumpflcmd.add_argument("dumpdp", help="Datapath Name")
2132
2133 addflcmd = subparsers.add_parser("add-flow")
2134 addflcmd.add_argument("flbr", help="Datapath name")
2135 addflcmd.add_argument("flow", help="Flow specification")
2136 addflcmd.add_argument("acts", help="Flow actions")
2137
2138 delfscmd = subparsers.add_parser("del-flows")
2139 delfscmd.add_argument("flsbr", help="Datapath name")
2140
2141 args = parser.parse_args()
2142
2143 if args.verbose > 0:
2144 if args.verbose > 1:
2145 logging.basicConfig(level=logging.DEBUG)
2146
2147 ovspk = OvsPacket()
2148 ovsdp = OvsDatapath()
2149 ovsvp = OvsVport(ovspk)
2150 ovsflow = OvsFlow()
2151 ndb = NDB()
2152
2153 sys.setrecursionlimit(100000)
2154
2155 if hasattr(args, "showdp"):
2156 found = False
2157 for iface in ndb.interfaces:
2158 rep = None
2159 if args.showdp is None:
2160 rep = ovsdp.info(iface.ifname, 0)
2161 elif args.showdp == iface.ifname:
2162 rep = ovsdp.info(iface.ifname, 0)
2163
2164 if rep is not None:
2165 found = True
2166 print_ovsdp_full(rep, iface.index, ndb, ovsvp)
2167
2168 if not found:
2169 msg = "No DP found"
2170 if args.showdp is not None:
2171 msg += ":'%s'" % args.showdp
2172 print(msg)
2173 elif hasattr(args, "adddp"):
2174 rep = ovsdp.create(args.adddp, args.upcall, args.versioning, ovspk)
2175 if rep is None:
2176 print("DP '%s' already exists" % args.adddp)
2177 else:
2178 print("DP '%s' added" % args.adddp)
2179 if args.upcall:
2180 ovspk.upcall_handler(ovsflow)
2181 elif hasattr(args, "deldp"):
2182 ovsdp.destroy(args.deldp)
2183 elif hasattr(args, "addif"):
2184 rep = ovsdp.info(args.dpname, 0)
2185 if rep is None:
2186 print("DP '%s' not found." % args.dpname)
2187 return 1
2188 dpindex = rep["dpifindex"]
2189 rep = ovsvp.attach(rep["dpifindex"], args.addif, args.ptype)
2190 msg = "vport '%s'" % args.addif
2191 if rep and rep["header"]["error"] is None:
2192 msg += " added."
2193 else:
2194 msg += " failed to add."
2195 if args.upcall:
2196 if rep is None:
2197 rep = ovsvp.reset_upcall(dpindex, args.addif, ovspk)
2198 ovsvp.upcall_handler(ovsflow)
2199 elif hasattr(args, "delif"):
2200 rep = ovsdp.info(args.dpname, 0)
2201 if rep is None:
2202 print("DP '%s' not found." % args.dpname)
2203 return 1
2204 rep = ovsvp.detach(rep["dpifindex"], args.delif)
2205 msg = "vport '%s'" % args.delif
2206 if rep and rep["header"]["error"] is None:
2207 msg += " removed."
2208 else:
2209 msg += " failed to remove."
2210 elif hasattr(args, "dumpdp"):
2211 rep = ovsdp.info(args.dumpdp, 0)
2212 if rep is None:
2213 print("DP '%s' not found." % args.dumpdp)
2214 return 1
2215 rep = ovsflow.dump(rep["dpifindex"])
2216 for flow in rep:
2217 print(flow.dpstr(True if args.verbose > 0 else False))
2218 elif hasattr(args, "flbr"):
2219 rep = ovsdp.info(args.flbr, 0)
2220 if rep is None:
2221 print("DP '%s' not found." % args.flbr)
2222 return 1
2223 flow = OvsFlow.ovs_flow_msg()
2224 flow.parse(args.flow, args.acts, rep["dpifindex"])
2225 ovsflow.add_flow(rep["dpifindex"], flow)
2226 elif hasattr(args, "flsbr"):
2227 rep = ovsdp.info(args.flsbr, 0)
2228 if rep is None:
2229 print("DP '%s' not found." % args.flsbr)
2230 ovsflow.del_flows(rep["dpifindex"])
2231
2232 return 0
2233
2234
2235if __name__ == "__main__":
2236 sys.exit(main(sys.argv))