ofproto-dpif: Factor out VLAN splinter flow adjustment into new function.
[openvswitch] / lib / netdev-vport.c
1 /*
2  * Copyright (c) 2010, 2011, 2012 Nicira, Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18
19 #include "netdev-vport.h"
20
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <sys/socket.h>
24 #include <linux/openvswitch.h>
25 #include <linux/rtnetlink.h>
26 #include <net/if.h>
27 #include <sys/ioctl.h>
28
29 #include "byte-order.h"
30 #include "daemon.h"
31 #include "dirs.h"
32 #include "dpif-linux.h"
33 #include "hash.h"
34 #include "hmap.h"
35 #include "list.h"
36 #include "netdev-linux.h"
37 #include "netdev-provider.h"
38 #include "netlink.h"
39 #include "netlink-notifier.h"
40 #include "netlink-socket.h"
41 #include "ofpbuf.h"
42 #include "openvswitch/tunnel.h"
43 #include "packets.h"
44 #include "route-table.h"
45 #include "shash.h"
46 #include "socket-util.h"
47 #include "unaligned.h"
48 #include "vlog.h"
49
50 VLOG_DEFINE_THIS_MODULE(netdev_vport);
51
52 struct netdev_dev_vport {
53     struct netdev_dev netdev_dev;
54     struct ofpbuf *options;
55     int dp_ifindex;             /* -1 if unknown. */
56     uint32_t port_no;           /* UINT32_MAX if unknown. */
57     unsigned int change_seq;
58 };
59
60 struct netdev_vport {
61     struct netdev netdev;
62 };
63
64 struct vport_class {
65     enum ovs_vport_type type;
66     struct netdev_class netdev_class;
67     int (*parse_config)(const char *name, const char *type,
68                         const struct shash *args, struct ofpbuf *options);
69     int (*unparse_config)(const char *name, const char *type,
70                           const struct nlattr *options, size_t options_len,
71                           struct shash *args);
72 };
73
74 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
75
76 static int netdev_vport_create(const struct netdev_class *, const char *,
77                                struct netdev_dev **);
78 static void netdev_vport_poll_notify(const struct netdev *);
79 static int tnl_port_config_from_nlattr(const struct nlattr *options,
80                                        size_t options_len,
81                                        struct nlattr *a[OVS_TUNNEL_ATTR_MAX + 1]);
82
83 static const char *netdev_vport_get_tnl_iface(const struct netdev *netdev);
84
85 static bool
86 is_vport_class(const struct netdev_class *class)
87 {
88     return class->create == netdev_vport_create;
89 }
90
91 static const struct vport_class *
92 vport_class_cast(const struct netdev_class *class)
93 {
94     assert(is_vport_class(class));
95     return CONTAINER_OF(class, struct vport_class, netdev_class);
96 }
97
98 static struct netdev_dev_vport *
99 netdev_dev_vport_cast(const struct netdev_dev *netdev_dev)
100 {
101     assert(is_vport_class(netdev_dev_get_class(netdev_dev)));
102     return CONTAINER_OF(netdev_dev, struct netdev_dev_vport, netdev_dev);
103 }
104
105 static struct netdev_vport *
106 netdev_vport_cast(const struct netdev *netdev)
107 {
108     struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
109     assert(is_vport_class(netdev_dev_get_class(netdev_dev)));
110     return CONTAINER_OF(netdev, struct netdev_vport, netdev);
111 }
112
113 /* If 'netdev' is a vport netdev, returns an ofpbuf that contains Netlink
114  * options to include in OVS_VPORT_ATTR_OPTIONS for configuring that vport.
115  * Otherwise returns NULL. */
116 const struct ofpbuf *
117 netdev_vport_get_options(const struct netdev *netdev)
118 {
119     const struct netdev_dev *dev = netdev_get_dev(netdev);
120
121     return (is_vport_class(netdev_dev_get_class(dev))
122             ? netdev_dev_vport_cast(dev)->options
123             : NULL);
124 }
125
126 enum ovs_vport_type
127 netdev_vport_get_vport_type(const struct netdev *netdev)
128 {
129     const struct netdev_dev *dev = netdev_get_dev(netdev);
130     const struct netdev_class *class = netdev_dev_get_class(dev);
131
132     return (is_vport_class(class) ? vport_class_cast(class)->type
133             : class == &netdev_internal_class ? OVS_VPORT_TYPE_INTERNAL
134             : (class == &netdev_linux_class ||
135                class == &netdev_tap_class) ? OVS_VPORT_TYPE_NETDEV
136             : OVS_VPORT_TYPE_UNSPEC);
137 }
138
139 const char *
140 netdev_vport_get_netdev_type(const struct dpif_linux_vport *vport)
141 {
142     struct nlattr *a[OVS_TUNNEL_ATTR_MAX + 1];
143
144     switch (vport->type) {
145     case OVS_VPORT_TYPE_UNSPEC:
146         break;
147
148     case OVS_VPORT_TYPE_NETDEV:
149         return "system";
150
151     case OVS_VPORT_TYPE_INTERNAL:
152         return "internal";
153
154     case OVS_VPORT_TYPE_PATCH:
155         return "patch";
156
157     case OVS_VPORT_TYPE_GRE:
158         if (tnl_port_config_from_nlattr(vport->options, vport->options_len,
159                                         a)) {
160             break;
161         }
162         return (nl_attr_get_u32(a[OVS_TUNNEL_ATTR_FLAGS]) & TNL_F_IPSEC
163                 ? "ipsec_gre" : "gre");
164
165     case OVS_VPORT_TYPE_CAPWAP:
166         return "capwap";
167
168     case __OVS_VPORT_TYPE_MAX:
169         break;
170     }
171
172     VLOG_WARN_RL(&rl, "dp%d: port `%s' has unsupported type %u",
173                  vport->dp_ifindex, vport->name, (unsigned int) vport->type);
174     return "unknown";
175 }
176
177 static int
178 netdev_vport_create(const struct netdev_class *netdev_class, const char *name,
179                     struct netdev_dev **netdev_devp)
180 {
181     struct netdev_dev_vport *dev;
182
183     dev = xmalloc(sizeof *dev);
184     netdev_dev_init(&dev->netdev_dev, name, netdev_class);
185     dev->options = NULL;
186     dev->dp_ifindex = -1;
187     dev->port_no = UINT32_MAX;
188     dev->change_seq = 1;
189
190     *netdev_devp = &dev->netdev_dev;
191     route_table_register();
192
193     return 0;
194 }
195
196 static void
197 netdev_vport_destroy(struct netdev_dev *netdev_dev_)
198 {
199     struct netdev_dev_vport *netdev_dev = netdev_dev_vport_cast(netdev_dev_);
200
201     ofpbuf_delete(netdev_dev->options);
202     route_table_unregister();
203     free(netdev_dev);
204 }
205
206 static int
207 netdev_vport_open(struct netdev_dev *netdev_dev_, struct netdev **netdevp)
208 {
209     struct netdev_vport *netdev;
210
211     netdev = xmalloc(sizeof *netdev);
212     netdev_init(&netdev->netdev, netdev_dev_);
213
214     *netdevp = &netdev->netdev;
215     return 0;
216 }
217
218 static void
219 netdev_vport_close(struct netdev *netdev_)
220 {
221     struct netdev_vport *netdev = netdev_vport_cast(netdev_);
222     free(netdev);
223 }
224
225 static int
226 netdev_vport_get_config(struct netdev_dev *dev_, struct shash *args)
227 {
228     const struct netdev_class *netdev_class = netdev_dev_get_class(dev_);
229     const struct vport_class *vport_class = vport_class_cast(netdev_class);
230     struct netdev_dev_vport *dev = netdev_dev_vport_cast(dev_);
231     const char *name = netdev_dev_get_name(dev_);
232     int error;
233
234     if (!dev->options) {
235         struct dpif_linux_vport reply;
236         struct ofpbuf *buf;
237
238         error = dpif_linux_vport_get(name, &reply, &buf);
239         if (error) {
240             VLOG_ERR_RL(&rl, "%s: vport query failed (%s)",
241                         name, strerror(error));
242             return error;
243         }
244
245         dev->options = ofpbuf_clone_data(reply.options, reply.options_len);
246         dev->dp_ifindex = reply.dp_ifindex;
247         dev->port_no = reply.port_no;
248         ofpbuf_delete(buf);
249     }
250
251     error = vport_class->unparse_config(name, netdev_class->type,
252                                         dev->options->data,
253                                         dev->options->size,
254                                         args);
255     if (error) {
256         VLOG_ERR_RL(&rl, "%s: failed to parse kernel config (%s)",
257                     name, strerror(error));
258     }
259     return error;
260 }
261
262 static int
263 netdev_vport_set_config(struct netdev_dev *dev_, const struct shash *args)
264 {
265     const struct netdev_class *netdev_class = netdev_dev_get_class(dev_);
266     const struct vport_class *vport_class = vport_class_cast(netdev_class);
267     struct netdev_dev_vport *dev = netdev_dev_vport_cast(dev_);
268     const char *name = netdev_dev_get_name(dev_);
269     struct ofpbuf *options;
270     int error;
271
272     options = ofpbuf_new(64);
273     error = vport_class->parse_config(name, netdev_dev_get_type(dev_),
274                                       args, options);
275     if (!error
276         && (!dev->options
277             || options->size != dev->options->size
278             || memcmp(options->data, dev->options->data, options->size))) {
279         struct dpif_linux_vport vport;
280
281         dpif_linux_vport_init(&vport);
282         vport.cmd = OVS_VPORT_CMD_SET;
283         vport.name = name;
284         vport.options = options->data;
285         vport.options_len = options->size;
286         error = dpif_linux_vport_transact(&vport, NULL, NULL);
287         if (!error || error == ENODEV) {
288             /* Either reconfiguration succeeded or this vport is not installed
289              * in the kernel (e.g. it hasn't been added to a dpif yet with
290              * dpif_port_add()). */
291             ofpbuf_delete(dev->options);
292             dev->options = options;
293             options = NULL;
294             error = 0;
295         }
296     }
297     ofpbuf_delete(options);
298
299     return error;
300 }
301
302 static int
303 netdev_vport_send(struct netdev *netdev, const void *data, size_t size)
304 {
305     struct netdev_dev *dev_ = netdev_get_dev(netdev);
306     struct netdev_dev_vport *dev = netdev_dev_vport_cast(dev_);
307
308     if (dev->dp_ifindex == -1) {
309         const char *name = netdev_get_name(netdev);
310         struct dpif_linux_vport reply;
311         struct ofpbuf *buf;
312         int error;
313
314         error = dpif_linux_vport_get(name, &reply, &buf);
315         if (error) {
316             VLOG_ERR_RL(&rl, "%s: failed to query vport for send (%s)",
317                         name, strerror(error));
318             return error;
319         }
320         dev->dp_ifindex = reply.dp_ifindex;
321         dev->port_no = reply.port_no;
322         ofpbuf_delete(buf);
323     }
324
325     return dpif_linux_vport_send(dev->dp_ifindex, dev->port_no, data, size);
326 }
327
328 static int
329 netdev_vport_set_etheraddr(struct netdev *netdev,
330                            const uint8_t mac[ETH_ADDR_LEN])
331 {
332     struct dpif_linux_vport vport;
333     int error;
334
335     dpif_linux_vport_init(&vport);
336     vport.cmd = OVS_VPORT_CMD_SET;
337     vport.name = netdev_get_name(netdev);
338     vport.address = mac;
339
340     error = dpif_linux_vport_transact(&vport, NULL, NULL);
341     if (!error) {
342         netdev_vport_poll_notify(netdev);
343     }
344     return error;
345 }
346
347 static int
348 netdev_vport_get_etheraddr(const struct netdev *netdev,
349                            uint8_t mac[ETH_ADDR_LEN])
350 {
351     struct dpif_linux_vport reply;
352     struct ofpbuf *buf;
353     int error;
354
355     error = dpif_linux_vport_get(netdev_get_name(netdev), &reply, &buf);
356     if (!error) {
357         if (reply.address) {
358             memcpy(mac, reply.address, ETH_ADDR_LEN);
359         } else {
360             error = EOPNOTSUPP;
361         }
362         ofpbuf_delete(buf);
363     }
364     return error;
365 }
366
367 /* Copies 'src' into 'dst', performing format conversion in the process.
368  *
369  * 'src' is allowed to be misaligned. */
370 static void
371 netdev_stats_from_ovs_vport_stats(struct netdev_stats *dst,
372                                   const struct ovs_vport_stats *src)
373 {
374     dst->rx_packets = get_unaligned_u64(&src->rx_packets);
375     dst->tx_packets = get_unaligned_u64(&src->tx_packets);
376     dst->rx_bytes = get_unaligned_u64(&src->rx_bytes);
377     dst->tx_bytes = get_unaligned_u64(&src->tx_bytes);
378     dst->rx_errors = get_unaligned_u64(&src->rx_errors);
379     dst->tx_errors = get_unaligned_u64(&src->tx_errors);
380     dst->rx_dropped = get_unaligned_u64(&src->rx_dropped);
381     dst->tx_dropped = get_unaligned_u64(&src->tx_dropped);
382     dst->multicast = 0;
383     dst->collisions = 0;
384     dst->rx_length_errors = 0;
385     dst->rx_over_errors = 0;
386     dst->rx_crc_errors = 0;
387     dst->rx_frame_errors = 0;
388     dst->rx_fifo_errors = 0;
389     dst->rx_missed_errors = 0;
390     dst->tx_aborted_errors = 0;
391     dst->tx_carrier_errors = 0;
392     dst->tx_fifo_errors = 0;
393     dst->tx_heartbeat_errors = 0;
394     dst->tx_window_errors = 0;
395 }
396
397 /* Copies 'src' into 'dst', performing format conversion in the process. */
398 static void
399 netdev_stats_to_ovs_vport_stats(struct ovs_vport_stats *dst,
400                                 const struct netdev_stats *src)
401 {
402     dst->rx_packets = src->rx_packets;
403     dst->tx_packets = src->tx_packets;
404     dst->rx_bytes = src->rx_bytes;
405     dst->tx_bytes = src->tx_bytes;
406     dst->rx_errors = src->rx_errors;
407     dst->tx_errors = src->tx_errors;
408     dst->rx_dropped = src->rx_dropped;
409     dst->tx_dropped = src->tx_dropped;
410 }
411
412 int
413 netdev_vport_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
414 {
415     struct dpif_linux_vport reply;
416     struct ofpbuf *buf;
417     int error;
418
419     error = dpif_linux_vport_get(netdev_get_name(netdev), &reply, &buf);
420     if (error) {
421         return error;
422     } else if (!reply.stats) {
423         ofpbuf_delete(buf);
424         return EOPNOTSUPP;
425     }
426
427     netdev_stats_from_ovs_vport_stats(stats, reply.stats);
428
429     ofpbuf_delete(buf);
430
431     return 0;
432 }
433
434 int
435 netdev_vport_set_stats(struct netdev *netdev, const struct netdev_stats *stats)
436 {
437     struct ovs_vport_stats rtnl_stats;
438     struct dpif_linux_vport vport;
439     int err;
440
441     netdev_stats_to_ovs_vport_stats(&rtnl_stats, stats);
442
443     dpif_linux_vport_init(&vport);
444     vport.cmd = OVS_VPORT_CMD_SET;
445     vport.name = netdev_get_name(netdev);
446     vport.stats = &rtnl_stats;
447
448     err = dpif_linux_vport_transact(&vport, NULL, NULL);
449
450     /* If the vport layer doesn't know about the device, that doesn't mean it
451      * doesn't exist (after all were able to open it when netdev_open() was
452      * called), it just means that it isn't attached and we'll be getting
453      * stats a different way. */
454     if (err == ENODEV) {
455         err = EOPNOTSUPP;
456     }
457
458     return err;
459 }
460
461 static int
462 netdev_vport_get_drv_info(const struct netdev *netdev, struct shash *sh)
463 {
464     const char *iface = netdev_vport_get_tnl_iface(netdev);
465
466     if (iface) {
467         struct netdev *egress_netdev;
468
469         shash_add(sh, "tunnel_egress_iface", xstrdup(iface));
470
471         if (!netdev_open(iface, "system", &egress_netdev)) {
472             shash_add(sh, "tunnel_egress_iface_carrier",
473                       xstrdup(netdev_get_carrier(egress_netdev)
474                               ? "up" : "down"));
475             netdev_close(egress_netdev);
476         }
477     }
478
479     return 0;
480 }
481
482 static int
483 netdev_vport_update_flags(struct netdev *netdev OVS_UNUSED,
484                         enum netdev_flags off, enum netdev_flags on OVS_UNUSED,
485                         enum netdev_flags *old_flagsp)
486 {
487     if (off & (NETDEV_UP | NETDEV_PROMISC)) {
488         return EOPNOTSUPP;
489     }
490
491     *old_flagsp = NETDEV_UP | NETDEV_PROMISC;
492     return 0;
493 }
494
495 static unsigned int
496 netdev_vport_change_seq(const struct netdev *netdev)
497 {
498     return netdev_dev_vport_cast(netdev_get_dev(netdev))->change_seq;
499 }
500
501 static void
502 netdev_vport_run(void)
503 {
504     route_table_run();
505 }
506
507 static void
508 netdev_vport_wait(void)
509 {
510     route_table_wait();
511 }
512 \f
513 /* get_tnl_iface() implementation. */
514 static const char *
515 netdev_vport_get_tnl_iface(const struct netdev *netdev)
516 {
517     struct nlattr *a[OVS_TUNNEL_ATTR_MAX + 1];
518     ovs_be32 route;
519     struct netdev_dev_vport *ndv;
520     static char name[IFNAMSIZ];
521
522     ndv = netdev_dev_vport_cast(netdev_get_dev(netdev));
523     if (tnl_port_config_from_nlattr(ndv->options->data, ndv->options->size,
524                                     a)) {
525         return NULL;
526     }
527     route = nl_attr_get_be32(a[OVS_TUNNEL_ATTR_DST_IPV4]);
528
529     if (route_table_get_name(route, name)) {
530         return name;
531     }
532
533     return NULL;
534 }
535 \f
536 /* Helper functions. */
537
538 static void
539 netdev_vport_poll_notify(const struct netdev *netdev)
540 {
541     struct netdev_dev_vport *ndv;
542
543     ndv = netdev_dev_vport_cast(netdev_get_dev(netdev));
544
545     ndv->change_seq++;
546     if (!ndv->change_seq) {
547         ndv->change_seq++;
548     }
549 }
550 \f
551 /* Code specific to individual vport types. */
552
553 static void
554 set_key(const struct shash *args, const char *name, uint16_t type,
555         struct ofpbuf *options)
556 {
557     const char *s;
558
559     s = shash_find_data(args, name);
560     if (!s) {
561         s = shash_find_data(args, "key");
562         if (!s) {
563             s = "0";
564         }
565     }
566
567     if (!strcmp(s, "flow")) {
568         /* This is the default if no attribute is present. */
569     } else {
570         nl_msg_put_be64(options, type, htonll(strtoull(s, NULL, 0)));
571     }
572 }
573
574 static int
575 parse_tunnel_config(const char *name, const char *type,
576                     const struct shash *args, struct ofpbuf *options)
577 {
578     bool is_gre = false;
579     bool is_ipsec = false;
580     struct shash_node *node;
581     bool ipsec_mech_set = false;
582     ovs_be32 daddr = htonl(0);
583     ovs_be32 saddr = htonl(0);
584     uint32_t flags;
585
586     flags = TNL_F_DF_DEFAULT | TNL_F_PMTUD | TNL_F_HDR_CACHE;
587     if (!strcmp(type, "gre")) {
588         is_gre = true;
589     } else if (!strcmp(type, "ipsec_gre")) {
590         is_gre = true;
591         is_ipsec = true;
592         flags |= TNL_F_IPSEC;
593         flags &= ~TNL_F_HDR_CACHE;
594     }
595
596     SHASH_FOR_EACH (node, args) {
597         if (!strcmp(node->name, "remote_ip")) {
598             struct in_addr in_addr;
599             if (lookup_ip(node->data, &in_addr)) {
600                 VLOG_WARN("%s: bad %s 'remote_ip'", name, type);
601             } else {
602                 daddr = in_addr.s_addr;
603             }
604         } else if (!strcmp(node->name, "local_ip")) {
605             struct in_addr in_addr;
606             if (lookup_ip(node->data, &in_addr)) {
607                 VLOG_WARN("%s: bad %s 'local_ip'", name, type);
608             } else {
609                 saddr = in_addr.s_addr;
610             }
611         } else if (!strcmp(node->name, "tos")) {
612             if (!strcmp(node->data, "inherit")) {
613                 flags |= TNL_F_TOS_INHERIT;
614             } else {
615                 nl_msg_put_u8(options, OVS_TUNNEL_ATTR_TOS, atoi(node->data));
616             }
617         } else if (!strcmp(node->name, "ttl")) {
618             if (!strcmp(node->data, "inherit")) {
619                 flags |= TNL_F_TTL_INHERIT;
620             } else {
621                 nl_msg_put_u8(options, OVS_TUNNEL_ATTR_TTL, atoi(node->data));
622             }
623         } else if (!strcmp(node->name, "csum") && is_gre) {
624             if (!strcmp(node->data, "true")) {
625                 flags |= TNL_F_CSUM;
626             }
627         } else if (!strcmp(node->name, "df_inherit")) {
628             if (!strcmp(node->data, "true")) {
629                 flags |= TNL_F_DF_INHERIT;
630             }
631         } else if (!strcmp(node->name, "df_default")) {
632             if (!strcmp(node->data, "false")) {
633                 flags &= ~TNL_F_DF_DEFAULT;
634             }
635         } else if (!strcmp(node->name, "pmtud")) {
636             if (!strcmp(node->data, "false")) {
637                 flags &= ~TNL_F_PMTUD;
638             }
639         } else if (!strcmp(node->name, "header_cache")) {
640             if (!strcmp(node->data, "false")) {
641                 flags &= ~TNL_F_HDR_CACHE;
642             }
643         } else if (!strcmp(node->name, "peer_cert") && is_ipsec) {
644             if (shash_find(args, "certificate")) {
645                 ipsec_mech_set = true;
646             } else {
647                 const char *use_ssl_cert;
648
649                 /* If the "use_ssl_cert" is true, then "certificate" and
650                  * "private_key" will be pulled from the SSL table.  The
651                  * use of this option is strongly discouraged, since it
652                  * will like be removed when multiple SSL configurations
653                  * are supported by OVS.
654                  */
655                 use_ssl_cert = shash_find_data(args, "use_ssl_cert");
656                 if (!use_ssl_cert || strcmp(use_ssl_cert, "true")) {
657                     VLOG_ERR("%s: 'peer_cert' requires 'certificate' argument",
658                              name);
659                     return EINVAL;
660                 }
661                 ipsec_mech_set = true;
662             }
663         } else if (!strcmp(node->name, "psk") && is_ipsec) {
664             ipsec_mech_set = true;
665         } else if (is_ipsec
666                 && (!strcmp(node->name, "certificate")
667                     || !strcmp(node->name, "private_key")
668                     || !strcmp(node->name, "use_ssl_cert"))) {
669             /* Ignore options not used by the netdev. */
670         } else if (!strcmp(node->name, "key") ||
671                    !strcmp(node->name, "in_key") ||
672                    !strcmp(node->name, "out_key")) {
673             /* Handled separately below. */
674         } else {
675             VLOG_WARN("%s: unknown %s argument '%s'", name, type, node->name);
676         }
677     }
678
679     if (is_ipsec) {
680         char *file_name = xasprintf("%s/%s", ovs_rundir(),
681                 "ovs-monitor-ipsec.pid");
682         pid_t pid = read_pidfile(file_name);
683         free(file_name);
684         if (pid < 0) {
685             VLOG_ERR("%s: IPsec requires the ovs-monitor-ipsec daemon",
686                      name);
687             return EINVAL;
688         }
689
690         if (shash_find(args, "peer_cert") && shash_find(args, "psk")) {
691             VLOG_ERR("%s: cannot define both 'peer_cert' and 'psk'", name);
692             return EINVAL;
693         }
694
695         if (!ipsec_mech_set) {
696             VLOG_ERR("%s: IPsec requires an 'peer_cert' or psk' argument",
697                      name);
698             return EINVAL;
699         }
700     }
701
702     set_key(args, "in_key", OVS_TUNNEL_ATTR_IN_KEY, options);
703     set_key(args, "out_key", OVS_TUNNEL_ATTR_OUT_KEY, options);
704
705     if (!daddr) {
706         VLOG_ERR("%s: %s type requires valid 'remote_ip' argument",
707                  name, type);
708         return EINVAL;
709     }
710     nl_msg_put_be32(options, OVS_TUNNEL_ATTR_DST_IPV4, daddr);
711
712     if (saddr) {
713         if (ip_is_multicast(daddr)) {
714             VLOG_WARN("%s: remote_ip is multicast, ignoring local_ip", name);
715         } else {
716             nl_msg_put_be32(options, OVS_TUNNEL_ATTR_SRC_IPV4, saddr);
717         }
718     }
719
720     nl_msg_put_u32(options, OVS_TUNNEL_ATTR_FLAGS, flags);
721
722     return 0;
723 }
724
725 static int
726 tnl_port_config_from_nlattr(const struct nlattr *options, size_t options_len,
727                             struct nlattr *a[OVS_TUNNEL_ATTR_MAX + 1])
728 {
729     static const struct nl_policy ovs_tunnel_policy[] = {
730         [OVS_TUNNEL_ATTR_FLAGS] = { .type = NL_A_U32 },
731         [OVS_TUNNEL_ATTR_DST_IPV4] = { .type = NL_A_BE32 },
732         [OVS_TUNNEL_ATTR_SRC_IPV4] = { .type = NL_A_BE32, .optional = true },
733         [OVS_TUNNEL_ATTR_IN_KEY] = { .type = NL_A_BE64, .optional = true },
734         [OVS_TUNNEL_ATTR_OUT_KEY] = { .type = NL_A_BE64, .optional = true },
735         [OVS_TUNNEL_ATTR_TOS] = { .type = NL_A_U8, .optional = true },
736         [OVS_TUNNEL_ATTR_TTL] = { .type = NL_A_U8, .optional = true },
737     };
738     struct ofpbuf buf;
739
740     ofpbuf_use_const(&buf, options, options_len);
741     if (!nl_policy_parse(&buf, 0, ovs_tunnel_policy,
742                          a, ARRAY_SIZE(ovs_tunnel_policy))) {
743         return EINVAL;
744     }
745     return 0;
746 }
747
748 static uint64_t
749 get_be64_or_zero(const struct nlattr *a)
750 {
751     return a ? ntohll(nl_attr_get_be64(a)) : 0;
752 }
753
754 static int
755 unparse_tunnel_config(const char *name OVS_UNUSED, const char *type OVS_UNUSED,
756                       const struct nlattr *options, size_t options_len,
757                       struct shash *args)
758 {
759     struct nlattr *a[OVS_TUNNEL_ATTR_MAX + 1];
760     ovs_be32 daddr;
761     uint32_t flags;
762     int error;
763
764     error = tnl_port_config_from_nlattr(options, options_len, a);
765     if (error) {
766         return error;
767     }
768
769     flags = nl_attr_get_u32(a[OVS_TUNNEL_ATTR_FLAGS]);
770     if (!(flags & TNL_F_HDR_CACHE) == !(flags & TNL_F_IPSEC)) {
771         smap_add(args, "header_cache",
772                  flags & TNL_F_HDR_CACHE ? "true" : "false");
773     }
774
775     daddr = nl_attr_get_be32(a[OVS_TUNNEL_ATTR_DST_IPV4]);
776     shash_add(args, "remote_ip", xasprintf(IP_FMT, IP_ARGS(&daddr)));
777
778     if (a[OVS_TUNNEL_ATTR_SRC_IPV4]) {
779         ovs_be32 saddr = nl_attr_get_be32(a[OVS_TUNNEL_ATTR_SRC_IPV4]);
780         shash_add(args, "local_ip", xasprintf(IP_FMT, IP_ARGS(&saddr)));
781     }
782
783     if (!a[OVS_TUNNEL_ATTR_IN_KEY] && !a[OVS_TUNNEL_ATTR_OUT_KEY]) {
784         smap_add(args, "key", "flow");
785     } else {
786         uint64_t in_key = get_be64_or_zero(a[OVS_TUNNEL_ATTR_IN_KEY]);
787         uint64_t out_key = get_be64_or_zero(a[OVS_TUNNEL_ATTR_OUT_KEY]);
788
789         if (in_key && in_key == out_key) {
790             shash_add(args, "key", xasprintf("%"PRIu64, in_key));
791         } else {
792             if (!a[OVS_TUNNEL_ATTR_IN_KEY]) {
793                 smap_add(args, "in_key", "flow");
794             } else if (in_key) {
795                 shash_add(args, "in_key", xasprintf("%"PRIu64, in_key));
796             }
797
798             if (!a[OVS_TUNNEL_ATTR_OUT_KEY]) {
799                 smap_add(args, "out_key", "flow");
800             } else if (out_key) {
801                 shash_add(args, "out_key", xasprintf("%"PRIu64, out_key));
802             }
803         }
804     }
805
806     if (flags & TNL_F_TTL_INHERIT) {
807         smap_add(args, "tos", "inherit");
808     } else if (a[OVS_TUNNEL_ATTR_TTL]) {
809         int ttl = nl_attr_get_u8(a[OVS_TUNNEL_ATTR_TTL]);
810         shash_add(args, "tos", xasprintf("%d", ttl));
811     }
812
813     if (flags & TNL_F_TOS_INHERIT) {
814         smap_add(args, "tos", "inherit");
815     } else if (a[OVS_TUNNEL_ATTR_TOS]) {
816         int tos = nl_attr_get_u8(a[OVS_TUNNEL_ATTR_TOS]);
817         shash_add(args, "tos", xasprintf("%d", tos));
818     }
819
820     if (flags & TNL_F_CSUM) {
821         smap_add(args, "csum", "true");
822     }
823     if (flags & TNL_F_DF_INHERIT) {
824         smap_add(args, "df_inherit", "true");
825     }
826     if (!(flags & TNL_F_DF_DEFAULT)) {
827         smap_add(args, "df_default", "false");
828     }
829     if (!(flags & TNL_F_PMTUD)) {
830         smap_add(args, "pmtud", "false");
831     }
832
833     return 0;
834 }
835
836 static int
837 parse_patch_config(const char *name, const char *type OVS_UNUSED,
838                    const struct shash *args, struct ofpbuf *options)
839 {
840     const char *peer;
841
842     peer = shash_find_data(args, "peer");
843     if (!peer) {
844         VLOG_ERR("%s: patch type requires valid 'peer' argument", name);
845         return EINVAL;
846     }
847
848     if (shash_count(args) > 1) {
849         VLOG_ERR("%s: patch type takes only a 'peer' argument", name);
850         return EINVAL;
851     }
852
853     if (strlen(peer) >= IFNAMSIZ) {
854         VLOG_ERR("%s: patch 'peer' arg too long", name);
855         return EINVAL;
856     }
857
858     if (!strcmp(name, peer)) {
859         VLOG_ERR("%s: patch peer must not be self", name);
860         return EINVAL;
861     }
862
863     nl_msg_put_string(options, OVS_PATCH_ATTR_PEER, peer);
864
865     return 0;
866 }
867
868 static int
869 unparse_patch_config(const char *name OVS_UNUSED, const char *type OVS_UNUSED,
870                      const struct nlattr *options, size_t options_len,
871                      struct shash *args)
872 {
873     static const struct nl_policy ovs_patch_policy[] = {
874         [OVS_PATCH_ATTR_PEER] = { .type = NL_A_STRING,
875                                .max_len = IFNAMSIZ,
876                                .optional = false }
877     };
878
879     struct nlattr *a[ARRAY_SIZE(ovs_patch_policy)];
880     struct ofpbuf buf;
881
882     ofpbuf_use_const(&buf, options, options_len);
883     if (!nl_policy_parse(&buf, 0, ovs_patch_policy,
884                          a, ARRAY_SIZE(ovs_patch_policy))) {
885         return EINVAL;
886     }
887
888     smap_add(args, "peer", nl_attr_get_string(a[OVS_PATCH_ATTR_PEER]));
889     return 0;
890 }
891 \f
892 #define VPORT_FUNCTIONS(GET_STATUS)                         \
893     NULL,                                                   \
894     netdev_vport_run,                                       \
895     netdev_vport_wait,                                      \
896                                                             \
897     netdev_vport_create,                                    \
898     netdev_vport_destroy,                                   \
899     netdev_vport_get_config,                                \
900     netdev_vport_set_config,                                \
901                                                             \
902     netdev_vport_open,                                      \
903     netdev_vport_close,                                     \
904                                                             \
905     NULL,                       /* listen */                \
906     NULL,                       /* recv */                  \
907     NULL,                       /* recv_wait */             \
908     NULL,                       /* drain */                 \
909                                                             \
910     netdev_vport_send,          /* send */                  \
911     NULL,                       /* send_wait */             \
912                                                             \
913     netdev_vport_set_etheraddr,                             \
914     netdev_vport_get_etheraddr,                             \
915     NULL,                       /* get_mtu */               \
916     NULL,                       /* set_mtu */               \
917     NULL,                       /* get_ifindex */           \
918     NULL,                       /* get_carrier */           \
919     NULL,                       /* get_carrier_resets */    \
920     NULL,                       /* get_miimon */            \
921     netdev_vport_get_stats,                                 \
922     netdev_vport_set_stats,                                 \
923                                                             \
924     NULL,                       /* get_features */          \
925     NULL,                       /* set_advertisements */    \
926                                                             \
927     NULL,                       /* set_policing */          \
928     NULL,                       /* get_qos_types */         \
929     NULL,                       /* get_qos_capabilities */  \
930     NULL,                       /* get_qos */               \
931     NULL,                       /* set_qos */               \
932     NULL,                       /* get_queue */             \
933     NULL,                       /* set_queue */             \
934     NULL,                       /* delete_queue */          \
935     NULL,                       /* get_queue_stats */       \
936     NULL,                       /* dump_queues */           \
937     NULL,                       /* dump_queue_stats */      \
938                                                             \
939     NULL,                       /* get_in4 */               \
940     NULL,                       /* set_in4 */               \
941     NULL,                       /* get_in6 */               \
942     NULL,                       /* add_router */            \
943     NULL,                       /* get_next_hop */          \
944     GET_STATUS,                                             \
945     NULL,                       /* arp_lookup */            \
946                                                             \
947     netdev_vport_update_flags,                              \
948                                                             \
949     netdev_vport_change_seq
950
951 void
952 netdev_vport_register(void)
953 {
954     static const struct vport_class vport_classes[] = {
955         { OVS_VPORT_TYPE_GRE,
956           { "gre", VPORT_FUNCTIONS(netdev_vport_get_drv_info) },
957           parse_tunnel_config, unparse_tunnel_config },
958
959         { OVS_VPORT_TYPE_GRE,
960           { "ipsec_gre", VPORT_FUNCTIONS(netdev_vport_get_drv_info) },
961           parse_tunnel_config, unparse_tunnel_config },
962
963         { OVS_VPORT_TYPE_CAPWAP,
964           { "capwap", VPORT_FUNCTIONS(netdev_vport_get_drv_info) },
965           parse_tunnel_config, unparse_tunnel_config },
966
967         { OVS_VPORT_TYPE_PATCH,
968           { "patch", VPORT_FUNCTIONS(NULL) },
969           parse_patch_config, unparse_patch_config }
970     };
971
972     int i;
973
974     for (i = 0; i < ARRAY_SIZE(vport_classes); i++) {
975         netdev_register_provider(&vport_classes[i].netdev_class);
976     }
977 }