lib/netdev-bsd.c

   1 /*
   2  * Copyright (c) 2011, 2013, 2014 Gaetano Catalli.
   3  * Copyright (c) 2013, 2014 YAMAMOTO Takashi.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #if !defined(__MACH__)
  19 #include <config.h>
  20
  21 #include "netdev-provider.h"
  22 #include <stdlib.h>
  23 #include <errno.h>
  24 #include <fcntl.h>
  25 #include <sys/types.h>
  26 #include <sys/time.h>
  27 #include <sys/ioctl.h>
  28 #include <sys/socket.h>
  29 #include <sys/sockio.h>
  30 #include <net/bpf.h>
  31 #include <ifaddrs.h>
  32 #include <pcap/pcap.h>
  33 #include <net/if.h>
  34 #include <net/if_dl.h>
  35 #include <net/if_media.h>
  36 #include <net/if_tap.h>
  37 #include <netinet/in.h>
  38 #ifdef HAVE_NET_IF_MIB_H
  39 #include <net/if_mib.h>
  40 #endif
  41 #include <poll.h>
  42 #include <string.h>
  43 #include <unistd.h>
  44 #include <sys/sysctl.h>
  45 #if defined(__NetBSD__)
  46 #include <net/route.h>
  47 #include <netinet/if_inarp.h>
  48 #endif
  49
  50 #include "rtbsd.h"
  51 #include "coverage.h"
  52 #include "dp-packet.h"
  53 #include "dpif-netdev.h"
  54 #include "openvswitch/dynamic-string.h"
  55 #include "fatal-signal.h"
  56 #include "openflow/openflow.h"
  57 #include "ovs-thread.h"
  58 #include "packets.h"
  59 #include "poll-loop.h"
  60 #include "shash.h"
  61 #include "socket-util.h"
  62 #include "svec.h"
  63 #include "util.h"
  64 #include "openvswitch/vlog.h"
  65
  66 VLOG_DEFINE_THIS_MODULE(netdev_bsd);
  67
  68 \f
  69 struct netdev_rxq_bsd {
  70     struct netdev_rxq up;
  71
  72     /* Packet capture descriptor for a system network device.
  73      * For a tap device this is NULL. */
  74     pcap_t *pcap_handle;
  75
  76     /* Selectable file descriptor for the network device.
  77      * This descriptor will be used for polling operations. */
  78     int fd;
  79 };
  80
  81 struct netdev_bsd {
  82     struct netdev up;
  83
  84     /* Never changes after initialization. */
  85     char *kernel_name;
  86
  87     /* Protects all members below. */
  88     struct ovs_mutex mutex;
  89
  90     unsigned int cache_valid;
  91
  92     int ifindex;
  93     struct eth_addr etheraddr;
  94     int mtu;
  95     int carrier;
  96
  97     int tap_fd;         /* TAP character device, if any, otherwise -1. */
  98
  99     /* Used for sending packets on non-tap devices. */
 100     pcap_t *pcap;
 101     int fd;
 102 };
 103
 104
 105 enum {
 106     VALID_IFINDEX   = 1 << 0,
 107     VALID_ETHERADDR = 1 << 1,
 108     VALID_IN        = 1 << 2,
 109     VALID_MTU       = 1 << 3,
 110     VALID_CARRIER   = 1 << 4
 111 };
 112
 113 #define PCAP_SNAPLEN 2048
 114
 115
 116 /*
 117  * Notifier used to invalidate device informations in case of status change.
 118  *
 119  * It will be registered with a 'rtbsd_notifier_register()' when the first
 120  * device will be created with the call of either 'netdev_bsd_tap_create()' or
 121  * 'netdev_bsd_system_create()'.
 122  *
 123  * The callback associated with this notifier ('netdev_bsd_cache_cb()') will
 124  * invalidate cached information about the device.
 125  */
 126 static struct rtbsd_notifier netdev_bsd_cache_notifier;
 127 static int cache_notifier_refcount;
 128
 129 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
 130
 131 static void destroy_tap(int fd, const char *name);
 132 static int get_flags(const struct netdev *, int *flagsp);
 133 static int set_flags(const char *, int flags);
 134 static int do_set_addr(struct netdev *netdev,
 135                        unsigned long ioctl_nr, const char *ioctl_name,
 136                        struct in_addr addr);
 137 static int get_etheraddr(const char *netdev_name, struct eth_addr *ea);
 138 static int set_etheraddr(const char *netdev_name, int hwaddr_family,
 139                          int hwaddr_len, const struct eth_addr);
 140 static int get_ifindex(const struct netdev *, int *ifindexp);
 141
 142 static int ifr_get_flags(const struct ifreq *);
 143 static void ifr_set_flags(struct ifreq *, int flags);
 144
 145 #ifdef __NetBSD__
 146 static int af_link_ioctl(unsigned long command, const void *arg);
 147 #endif
 148
 149 static void netdev_bsd_run(void);
 150 static int netdev_bsd_get_mtu(const struct netdev *netdev_, int *mtup);
 151
 152 static bool
 153 is_netdev_bsd_class(const struct netdev_class *netdev_class)
 154 {
 155     return netdev_class->run == netdev_bsd_run;
 156 }
 157
 158 static struct netdev_bsd *
 159 netdev_bsd_cast(const struct netdev *netdev)
 160 {
 161     ovs_assert(is_netdev_bsd_class(netdev_get_class(netdev)));
 162     return CONTAINER_OF(netdev, struct netdev_bsd, up);
 163 }
 164
 165 static struct netdev_rxq_bsd *
 166 netdev_rxq_bsd_cast(const struct netdev_rxq *rxq)
 167 {
 168     ovs_assert(is_netdev_bsd_class(netdev_get_class(rxq->netdev)));
 169     return CONTAINER_OF(rxq, struct netdev_rxq_bsd, up);
 170 }
 171
 172 static const char *
 173 netdev_get_kernel_name(const struct netdev *netdev)
 174 {
 175     return netdev_bsd_cast(netdev)->kernel_name;
 176 }
 177
 178 /*
 179  * Perform periodic work needed by netdev. In BSD netdevs it checks for any
 180  * interface status changes, and eventually calls all the user callbacks.
 181  */
 182 static void
 183 netdev_bsd_run(void)
 184 {
 185     rtbsd_notifier_run();
 186 }
 187
 188 /*
 189  * Arranges for poll_block() to wake up if the "run" member function needs to
 190  * be called.
 191  */
 192 static void
 193 netdev_bsd_wait(void)
 194 {
 195     rtbsd_notifier_wait();
 196 }
 197
 198 /* Invalidate cache in case of interface status change. */
 199 static void
 200 netdev_bsd_cache_cb(const struct rtbsd_change *change,
 201                     void *aux OVS_UNUSED)
 202 {
 203     struct netdev_bsd *dev;
 204
 205     if (change) {
 206         struct netdev *base_dev = netdev_from_name(change->if_name);
 207
 208         if (base_dev) {
 209             const struct netdev_class *netdev_class =
 210                                                 netdev_get_class(base_dev);
 211
 212             if (is_netdev_bsd_class(netdev_class)) {
 213                 dev = netdev_bsd_cast(base_dev);
 214                 dev->cache_valid = 0;
 215                 netdev_change_seq_changed(base_dev);
 216             }
 217             netdev_close(base_dev);
 218         }
 219     } else {
 220         /*
 221          * XXX the API is lacking, we should be able to iterate on the list of
 222          * netdevs without having to store the info in a temp shash.
 223          */
 224         struct shash device_shash;
 225         struct shash_node *node;
 226
 227         shash_init(&device_shash);
 228         netdev_get_devices(&netdev_bsd_class, &device_shash);
 229         SHASH_FOR_EACH (node, &device_shash) {
 230             struct netdev *netdev = node->data;
 231             dev = netdev_bsd_cast(netdev);
 232             dev->cache_valid = 0;
 233             netdev_change_seq_changed(netdev);
 234             netdev_close(netdev);
 235         }
 236         shash_destroy(&device_shash);
 237     }
 238 }
 239
 240 static int
 241 cache_notifier_ref(void)
 242 {
 243     int ret = 0;
 244
 245     if (!cache_notifier_refcount) {
 246         ret = rtbsd_notifier_register(&netdev_bsd_cache_notifier,
 247                                       netdev_bsd_cache_cb, NULL);
 248         if (ret) {
 249             return ret;
 250         }
 251     }
 252     cache_notifier_refcount++;
 253     return 0;
 254 }
 255
 256 static int
 257 cache_notifier_unref(void)
 258 {
 259     cache_notifier_refcount--;
 260     if (cache_notifier_refcount == 0) {
 261         rtbsd_notifier_unregister(&netdev_bsd_cache_notifier);
 262     }
 263     return 0;
 264 }
 265
 266 static struct netdev *
 267 netdev_bsd_alloc(void)
 268 {
 269     struct netdev_bsd *netdev = xzalloc(sizeof *netdev);
 270     return &netdev->up;
 271 }
 272
 273 static int
 274 netdev_bsd_construct_system(struct netdev *netdev_)
 275 {
 276     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 277     enum netdev_flags flags;
 278     int error;
 279
 280     error = cache_notifier_ref();
 281     if (error) {
 282         return error;
 283     }
 284
 285     ovs_mutex_init(&netdev->mutex);
 286     netdev->tap_fd = -1;
 287     netdev->kernel_name = xstrdup(netdev_->name);
 288
 289     /* Verify that the netdev really exists by attempting to read its flags */
 290     error = netdev_get_flags(netdev_, &flags);
 291     if (error == ENXIO) {
 292         free(netdev->kernel_name);
 293         cache_notifier_unref();
 294         ovs_mutex_destroy(&netdev->mutex);
 295         return error;
 296     }
 297
 298     return 0;
 299 }
 300
 301 static int
 302 netdev_bsd_construct_tap(struct netdev *netdev_)
 303 {
 304     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 305     const char *name = netdev_->name;
 306     int error = 0;
 307     struct ifreq ifr;
 308     char *kernel_name = NULL;
 309
 310     error = cache_notifier_ref();
 311     if (error) {
 312         goto error;
 313     }
 314
 315     memset(&ifr, 0, sizeof(ifr));
 316
 317     /* Create a tap device by opening /dev/tap.  The TAPGIFNAME ioctl is used
 318      * to retrieve the name of the tap device. */
 319     ovs_mutex_init(&netdev->mutex);
 320     netdev->tap_fd = open("/dev/tap", O_RDWR);
 321     if (netdev->tap_fd < 0) {
 322         error = errno;
 323         VLOG_WARN("opening \"/dev/tap\" failed: %s", ovs_strerror(error));
 324         goto error_unref_notifier;
 325     }
 326
 327     /* Retrieve tap name (e.g. tap0) */
 328     if (ioctl(netdev->tap_fd, TAPGIFNAME, &ifr) == -1) {
 329         /* XXX Need to destroy the device? */
 330         error = errno;
 331         close(netdev->tap_fd);
 332         goto error_unref_notifier;
 333     }
 334
 335     /* Change the name of the tap device */
 336 #if defined(SIOCSIFNAME)
 337     ifr.ifr_data = (void *)name;
 338     error = af_inet_ioctl(SIOCSIFNAME, &ifr);
 339     if (error) {
 340         destroy_tap(netdev->tap_fd, ifr.ifr_name);
 341         goto error_unref_notifier;
 342     }
 343     kernel_name = xstrdup(name);
 344 #else
 345     /*
 346      * NetBSD doesn't support inteface renaming.
 347      */
 348     VLOG_INFO("tap %s is created for bridge %s", ifr.ifr_name, name);
 349     kernel_name = xstrdup(ifr.ifr_name);
 350 #endif
 351
 352     /* set non-blocking. */
 353     error = set_nonblocking(netdev->tap_fd);
 354     if (error) {
 355         destroy_tap(netdev->tap_fd, kernel_name);
 356         goto error_unref_notifier;
 357     }
 358
 359     /* Turn device UP */
 360     ifr_set_flags(&ifr, IFF_UP);
 361     ovs_strlcpy(ifr.ifr_name, kernel_name, sizeof ifr.ifr_name);
 362     error = af_inet_ioctl(SIOCSIFFLAGS, &ifr);
 363     if (error) {
 364         destroy_tap(netdev->tap_fd, kernel_name);
 365         goto error_unref_notifier;
 366     }
 367
 368     netdev->kernel_name = kernel_name;
 369
 370     return 0;
 371
 372 error_unref_notifier:
 373     ovs_mutex_destroy(&netdev->mutex);
 374     cache_notifier_unref();
 375 error:
 376     free(kernel_name);
 377     return error;
 378 }
 379
 380 static void
 381 netdev_bsd_destruct(struct netdev *netdev_)
 382 {
 383     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 384
 385     cache_notifier_unref();
 386
 387     if (netdev->tap_fd >= 0) {
 388         destroy_tap(netdev->tap_fd, netdev_get_kernel_name(netdev_));
 389     }
 390     if (netdev->pcap) {
 391         pcap_close(netdev->pcap);
 392     }
 393     free(netdev->kernel_name);
 394     ovs_mutex_destroy(&netdev->mutex);
 395 }
 396
 397 static void
 398 netdev_bsd_dealloc(struct netdev *netdev_)
 399 {
 400     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 401
 402     free(netdev);
 403 }
 404
 405 static int
 406 netdev_bsd_open_pcap(const char *name, pcap_t **pcapp, int *fdp)
 407 {
 408     char errbuf[PCAP_ERRBUF_SIZE];
 409     pcap_t *pcap = NULL;
 410     int one = 1;
 411     int error;
 412     int fd;
 413
 414     /* Open the pcap device.  The device is opened in non-promiscuous mode
 415      * because the interface flags are manually set by the caller. */
 416     errbuf[0] = '\0';
 417     pcap = pcap_open_live(name, PCAP_SNAPLEN, 0, 1000, errbuf);
 418     if (!pcap) {
 419         VLOG_ERR_RL(&rl, "%s: pcap_open_live failed: %s", name, errbuf);
 420         error = EIO;
 421         goto error;
 422     }
 423     if (errbuf[0] != '\0') {
 424         VLOG_WARN_RL(&rl, "%s: pcap_open_live: %s", name, errbuf);
 425     }
 426
 427     /* Get the underlying fd. */
 428     fd = pcap_get_selectable_fd(pcap);
 429     if (fd == -1) {
 430         VLOG_WARN_RL(&rl, "%s: no selectable file descriptor", name);
 431         error = errno;
 432         goto error;
 433     }
 434
 435     /* Set non-blocking mode. Also the BIOCIMMEDIATE ioctl must be called
 436      * on the file descriptor returned by pcap_get_selectable_fd to achieve
 437      * a real non-blocking behaviour.*/
 438     error = pcap_setnonblock(pcap, 1, errbuf);
 439     if (error == -1) {
 440         error = errno;
 441         goto error;
 442     }
 443
 444     /* This call assure that reads return immediately upon packet
 445      * reception.  Otherwise, a read will block until either the kernel
 446      * buffer becomes full or a timeout occurs. */
 447     if (ioctl(fd, BIOCIMMEDIATE, &one) < 0 ) {
 448         VLOG_ERR_RL(&rl, "ioctl(BIOCIMMEDIATE) on %s device failed: %s",
 449                     name, ovs_strerror(errno));
 450         error = errno;
 451         goto error;
 452     }
 453
 454     /* Capture only incoming packets. */
 455     error = pcap_setdirection(pcap, PCAP_D_IN);
 456     if (error == -1) {
 457         error = errno;
 458         goto error;
 459     }
 460
 461     *pcapp = pcap;
 462     *fdp = fd;
 463     return 0;
 464
 465 error:
 466     if (pcap) {
 467         pcap_close(pcap);
 468     }
 469     *pcapp = NULL;
 470     *fdp = -1;
 471     return error;
 472 }
 473
 474 static struct netdev_rxq *
 475 netdev_bsd_rxq_alloc(void)
 476 {
 477     struct netdev_rxq_bsd *rxq = xzalloc(sizeof *rxq);
 478     return &rxq->up;
 479 }
 480
 481 static int
 482 netdev_bsd_rxq_construct(struct netdev_rxq *rxq_)
 483 {
 484     struct netdev_rxq_bsd *rxq = netdev_rxq_bsd_cast(rxq_);
 485     struct netdev *netdev_ = rxq->up.netdev;
 486     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 487     int error;
 488
 489     if (!strcmp(netdev_get_type(netdev_), "tap")) {
 490         rxq->pcap_handle = NULL;
 491         rxq->fd = netdev->tap_fd;
 492         error = 0;
 493     } else {
 494         ovs_mutex_lock(&netdev->mutex);
 495         error = netdev_bsd_open_pcap(netdev_get_kernel_name(netdev_),
 496                                      &rxq->pcap_handle, &rxq->fd);
 497         ovs_mutex_unlock(&netdev->mutex);
 498     }
 499
 500     return error;
 501 }
 502
 503 static void
 504 netdev_bsd_rxq_destruct(struct netdev_rxq *rxq_)
 505 {
 506     struct netdev_rxq_bsd *rxq = netdev_rxq_bsd_cast(rxq_);
 507
 508     if (rxq->pcap_handle) {
 509         pcap_close(rxq->pcap_handle);
 510     }
 511 }
 512
 513 static void
 514 netdev_bsd_rxq_dealloc(struct netdev_rxq *rxq_)
 515 {
 516     struct netdev_rxq_bsd *rxq = netdev_rxq_bsd_cast(rxq_);
 517
 518     free(rxq);
 519 }
 520
 521 /* The recv callback of the netdev class returns the number of bytes of the
 522  * received packet.
 523  *
 524  * This can be done by the pcap_next() function. Unfortunately pcap_next() does
 525  * not make difference between a missing packet on the capture interface and
 526  * an error during the file capture.  We can use the pcap_dispatch() function
 527  * instead, which is able to distinguish between errors and null packet.
 528  *
 529  * To make pcap_dispatch() returns the number of bytes read from the interface
 530  * we need to define the following callback and argument.
 531  */
 532 struct pcap_arg {
 533     void *data;
 534     int size;
 535     int retval;
 536 };
 537
 538 /*
 539  * This callback will be executed on every captured packet.
 540  *
 541  * If the packet captured by pcap_dispatch() does not fit the pcap buffer,
 542  * pcap returns a truncated packet and we follow this behavior.
 543  *
 544  * The argument args->retval is the packet size in bytes.
 545  */
 546 static void
 547 proc_pkt(u_char *args_, const struct pcap_pkthdr *hdr, const u_char *packet)
 548 {
 549     struct pcap_arg *args = ALIGNED_CAST(struct pcap_arg *, args_);
 550
 551     if (args->size < hdr->len) {
 552         VLOG_WARN_RL(&rl, "packet truncated");
 553         args->retval = args->size;
 554     } else {
 555         args->retval = hdr->len;
 556     }
 557
 558     /* copy the packet to our buffer */
 559     memcpy(args->data, packet, args->retval);
 560 }
 561
 562 /*
 563  * This function attempts to receive a packet from the specified network
 564  * device. It is assumed that the network device is a system device or a tap
 565  * device opened as a system one. In this case the read operation is performed
 566  * from rxq->pcap.
 567  */
 568 static int
 569 netdev_rxq_bsd_recv_pcap(struct netdev_rxq_bsd *rxq, struct dp_packet *buffer)
 570 {
 571     struct pcap_arg arg;
 572     int ret;
 573
 574     /* prepare the pcap argument to store the packet */
 575     arg.size = dp_packet_tailroom(buffer);
 576     arg.data = dp_packet_data(buffer);
 577
 578     for (;;) {
 579         ret = pcap_dispatch(rxq->pcap_handle, 1, proc_pkt, (u_char *) &arg);
 580
 581         if (ret > 0) {
 582             dp_packet_set_size(buffer, dp_packet_size(buffer) + arg.retval);
 583             return 0;
 584         }
 585         if (ret == -1) {
 586             if (errno == EINTR) {
 587                  continue;
 588             }
 589         }
 590
 591         return EAGAIN;
 592     }
 593 }
 594
 595 /*
 596  * This function attempts to receive a packet from the specified network
 597  * device. It is assumed that the network device is a tap device and
 598  * 'rxq->fd' is initialized with the tap file descriptor.
 599  */
 600 static int
 601 netdev_rxq_bsd_recv_tap(struct netdev_rxq_bsd *rxq, struct dp_packet *buffer)
 602 {
 603     size_t size = dp_packet_tailroom(buffer);
 604
 605     for (;;) {
 606         ssize_t retval = read(rxq->fd, dp_packet_data(buffer), size);
 607         if (retval >= 0) {
 608             dp_packet_set_size(buffer, dp_packet_size(buffer) + retval);
 609             return 0;
 610         } else if (errno != EINTR) {
 611             if (errno != EAGAIN) {
 612                 VLOG_WARN_RL(&rl, "error receiving Ethernet packet on %s: %s",
 613                              ovs_strerror(errno), netdev_rxq_get_name(&rxq->up));
 614             }
 615             return errno;
 616         }
 617     }
 618 }
 619
 620 static int
 621 netdev_bsd_rxq_recv(struct netdev_rxq *rxq_, struct dp_packet **packets,
 622                     int *c)
 623 {
 624     struct netdev_rxq_bsd *rxq = netdev_rxq_bsd_cast(rxq_);
 625     struct netdev *netdev = rxq->up.netdev;
 626     struct dp_packet *packet;
 627     ssize_t retval;
 628     int mtu;
 629
 630     if (netdev_bsd_get_mtu(netdev, &mtu)) {
 631         mtu = ETH_PAYLOAD_MAX;
 632     }
 633
 634     packet = dp_packet_new_with_headroom(VLAN_ETH_HEADER_LEN + mtu,
 635                                            DP_NETDEV_HEADROOM);
 636     retval = (rxq->pcap_handle
 637             ? netdev_rxq_bsd_recv_pcap(rxq, packet)
 638             : netdev_rxq_bsd_recv_tap(rxq, packet));
 639
 640     if (retval) {
 641         dp_packet_delete(packet);
 642     } else {
 643         dp_packet_pad(packet);
 644         packets[0] = packet;
 645         *c = 1;
 646     }
 647     return retval;
 648 }
 649
 650 /*
 651  * Registers with the poll loop to wake up from the next call to poll_block()
 652  * when a packet is ready to be received with netdev_rxq_recv() on 'rxq'.
 653  */
 654 static void
 655 netdev_bsd_rxq_wait(struct netdev_rxq *rxq_)
 656 {
 657     struct netdev_rxq_bsd *rxq = netdev_rxq_bsd_cast(rxq_);
 658
 659     poll_fd_wait(rxq->fd, POLLIN);
 660 }
 661
 662 /* Discards all packets waiting to be received from 'rxq'. */
 663 static int
 664 netdev_bsd_rxq_drain(struct netdev_rxq *rxq_)
 665 {
 666     struct ifreq ifr;
 667     struct netdev_rxq_bsd *rxq = netdev_rxq_bsd_cast(rxq_);
 668
 669     strcpy(ifr.ifr_name, netdev_get_kernel_name(netdev_rxq_get_netdev(rxq_)));
 670     if (ioctl(rxq->fd, BIOCFLUSH, &ifr) == -1) {
 671         VLOG_DBG_RL(&rl, "%s: ioctl(BIOCFLUSH) failed: %s",
 672                     netdev_rxq_get_name(rxq_), ovs_strerror(errno));
 673         return errno;
 674     }
 675     return 0;
 676 }
 677
 678 /*
 679  * Send a packet on the specified network device. The device could be either a
 680  * system or a tap device.
 681  */
 682 static int
 683 netdev_bsd_send(struct netdev *netdev_, int qid OVS_UNUSED,
 684                 struct dp_packet **pkts, int cnt, bool may_steal)
 685 {
 686     struct netdev_bsd *dev = netdev_bsd_cast(netdev_);
 687     const char *name = netdev_get_name(netdev_);
 688     int error;
 689     int i;
 690
 691     ovs_mutex_lock(&dev->mutex);
 692     if (dev->tap_fd < 0 && !dev->pcap) {
 693         error = netdev_bsd_open_pcap(name, &dev->pcap, &dev->fd);
 694     } else {
 695         error = 0;
 696     }
 697
 698     for (i = 0; i < cnt; i++) {
 699         const void *data = dp_packet_data(pkts[i]);
 700         size_t size = dp_packet_size(pkts[i]);
 701
 702         while (!error) {
 703             ssize_t retval;
 704             if (dev->tap_fd >= 0) {
 705                 retval = write(dev->tap_fd, data, size);
 706             } else {
 707                 retval = pcap_inject(dev->pcap, data, size);
 708             }
 709             if (retval < 0) {
 710                 if (errno == EINTR) {
 711                     continue;
 712                 } else {
 713                     error = errno;
 714                     if (error != EAGAIN) {
 715                         VLOG_WARN_RL(&rl, "error sending Ethernet packet on"
 716                                      " %s: %s", name, ovs_strerror(error));
 717                     }
 718                 }
 719             } else if (retval != size) {
 720                 VLOG_WARN_RL(&rl, "sent partial Ethernet packet "
 721                                   "(%"PRIuSIZE" bytes of "
 722                                   "%"PRIuSIZE") on %s", retval, size, name);
 723                 error = EMSGSIZE;
 724             } else {
 725                 break;
 726             }
 727         }
 728     }
 729
 730     ovs_mutex_unlock(&dev->mutex);
 731     if (may_steal) {
 732         for (i = 0; i < cnt; i++) {
 733             dp_packet_delete(pkts[i]);
 734         }
 735     }
 736
 737     return error;
 738 }
 739
 740 /*
 741  * Registers with the poll loop to wake up from the next call to poll_block()
 742  * when the packet transmission queue has sufficient room to transmit a packet
 743  * with netdev_send().
 744  */
 745 static void
 746 netdev_bsd_send_wait(struct netdev *netdev_, int qid OVS_UNUSED)
 747 {
 748     struct netdev_bsd *dev = netdev_bsd_cast(netdev_);
 749
 750     ovs_mutex_lock(&dev->mutex);
 751     if (dev->tap_fd >= 0) {
 752         /* TAP device always accepts packets. */
 753         poll_immediate_wake();
 754     } else if (dev->pcap) {
 755         poll_fd_wait(dev->fd, POLLOUT);
 756     } else {
 757         /* We haven't even tried to send a packet yet. */
 758         poll_immediate_wake();
 759     }
 760     ovs_mutex_unlock(&dev->mutex);
 761 }
 762
 763 /*
 764  * Attempts to set 'netdev''s MAC address to 'mac'.  Returns 0 if successful,
 765  * otherwise a positive errno value.
 766  */
 767 static int
 768 netdev_bsd_set_etheraddr(struct netdev *netdev_,
 769                          const struct eth_addr mac)
 770 {
 771     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 772     int error = 0;
 773
 774     ovs_mutex_lock(&netdev->mutex);
 775     if (!(netdev->cache_valid & VALID_ETHERADDR)
 776         || !eth_addr_equals(netdev->etheraddr, mac)) {
 777         error = set_etheraddr(netdev_get_kernel_name(netdev_), AF_LINK,
 778                               ETH_ADDR_LEN, mac);
 779         if (!error) {
 780             netdev->cache_valid |= VALID_ETHERADDR;
 781             netdev->etheraddr = mac;
 782             netdev_change_seq_changed(netdev_);
 783         }
 784     }
 785     ovs_mutex_unlock(&netdev->mutex);
 786
 787     return error;
 788 }
 789
 790 /*
 791  * Returns a pointer to 'netdev''s MAC address.  The caller must not modify or
 792  * free the returned buffer.
 793  */
 794 static int
 795 netdev_bsd_get_etheraddr(const struct netdev *netdev_, struct eth_addr *mac)
 796 {
 797     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 798     int error = 0;
 799
 800     ovs_mutex_lock(&netdev->mutex);
 801     if (!(netdev->cache_valid & VALID_ETHERADDR)) {
 802         error = get_etheraddr(netdev_get_kernel_name(netdev_),
 803                               &netdev->etheraddr);
 804         if (!error) {
 805             netdev->cache_valid |= VALID_ETHERADDR;
 806         }
 807     }
 808     if (!error) {
 809         *mac = netdev->etheraddr;
 810     }
 811     ovs_mutex_unlock(&netdev->mutex);
 812
 813     return error;
 814 }
 815
 816 /*
 817  * Returns the maximum size of transmitted (and received) packets on 'netdev',
 818  * in bytes, not including the hardware header; thus, this is typically 1500
 819  * bytes for Ethernet devices.
 820  */
 821 static int
 822 netdev_bsd_get_mtu(const struct netdev *netdev_, int *mtup)
 823 {
 824     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 825     int error = 0;
 826
 827     ovs_mutex_lock(&netdev->mutex);
 828     if (!(netdev->cache_valid & VALID_MTU)) {
 829         struct ifreq ifr;
 830
 831         error = af_inet_ifreq_ioctl(netdev_get_kernel_name(netdev_), &ifr,
 832                                     SIOCGIFMTU, "SIOCGIFMTU");
 833         if (!error) {
 834             netdev->mtu = ifr.ifr_mtu;
 835             netdev->cache_valid |= VALID_MTU;
 836         }
 837     }
 838     if (!error) {
 839         *mtup = netdev->mtu;
 840     }
 841     ovs_mutex_unlock(&netdev->mutex);
 842
 843     return error;
 844 }
 845
 846 static int
 847 netdev_bsd_get_ifindex(const struct netdev *netdev_)
 848 {
 849     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 850     int ifindex, error;
 851
 852     ovs_mutex_lock(&netdev->mutex);
 853     error = get_ifindex(netdev_, &ifindex);
 854     ovs_mutex_unlock(&netdev->mutex);
 855
 856     return error ? -error : ifindex;
 857 }
 858
 859 static int
 860 netdev_bsd_get_carrier(const struct netdev *netdev_, bool *carrier)
 861 {
 862     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 863     int error = 0;
 864
 865     ovs_mutex_lock(&netdev->mutex);
 866     if (!(netdev->cache_valid & VALID_CARRIER)) {
 867         struct ifmediareq ifmr;
 868
 869         memset(&ifmr, 0, sizeof(ifmr));
 870         ovs_strlcpy(ifmr.ifm_name, netdev_get_kernel_name(netdev_),
 871                     sizeof ifmr.ifm_name);
 872
 873         error = af_inet_ioctl(SIOCGIFMEDIA, &ifmr);
 874         if (!error) {
 875             netdev->carrier = (ifmr.ifm_status & IFM_ACTIVE) == IFM_ACTIVE;
 876             netdev->cache_valid |= VALID_CARRIER;
 877
 878             /* If the interface doesn't report whether the media is active,
 879              * just assume it is active. */
 880             if ((ifmr.ifm_status & IFM_AVALID) == 0) {
 881                 netdev->carrier = true;
 882             }
 883         } else {
 884             VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFMEDIA) failed: %s",
 885                         netdev_get_name(netdev_), ovs_strerror(error));
 886         }
 887     }
 888     if (!error) {
 889         *carrier = netdev->carrier;
 890     }
 891     ovs_mutex_unlock(&netdev->mutex);
 892
 893     return error;
 894 }
 895
 896 static void
 897 convert_stats_system(struct netdev_stats *stats, const struct if_data *ifd)
 898 {
 899     /*
 900      * note: UINT64_MAX means unsupported
 901      */
 902     stats->rx_packets = ifd->ifi_ipackets;
 903     stats->tx_packets = ifd->ifi_opackets;
 904     stats->rx_bytes = ifd->ifi_obytes;
 905     stats->tx_bytes = ifd->ifi_ibytes;
 906     stats->rx_errors = ifd->ifi_ierrors;
 907     stats->tx_errors = ifd->ifi_oerrors;
 908     stats->rx_dropped = ifd->ifi_iqdrops;
 909     stats->tx_dropped = UINT64_MAX;
 910     stats->multicast = ifd->ifi_imcasts;
 911     stats->collisions = ifd->ifi_collisions;
 912     stats->rx_length_errors = UINT64_MAX;
 913     stats->rx_over_errors = UINT64_MAX;
 914     stats->rx_crc_errors = UINT64_MAX;
 915     stats->rx_frame_errors = UINT64_MAX;
 916     stats->rx_fifo_errors = UINT64_MAX;
 917     stats->rx_missed_errors = UINT64_MAX;
 918     stats->tx_aborted_errors = UINT64_MAX;
 919     stats->tx_carrier_errors = UINT64_MAX;
 920     stats->tx_fifo_errors = UINT64_MAX;
 921     stats->tx_heartbeat_errors = UINT64_MAX;
 922     stats->tx_window_errors = UINT64_MAX;
 923 }
 924
 925 static void
 926 convert_stats_tap(struct netdev_stats *stats, const struct if_data *ifd)
 927 {
 928     /*
 929      * Similar to convert_stats_system but swapping rxq and tx
 930      * because 'ifd' is stats for the network interface side of the
 931      * tap device and what the caller wants is one for the character
 932      * device side.
 933      *
 934      * note: UINT64_MAX means unsupported
 935      */
 936     stats->rx_packets = ifd->ifi_opackets;
 937     stats->tx_packets = ifd->ifi_ipackets;
 938     stats->rx_bytes = ifd->ifi_ibytes;
 939     stats->tx_bytes = ifd->ifi_obytes;
 940     stats->rx_errors = ifd->ifi_oerrors;
 941     stats->tx_errors = ifd->ifi_ierrors;
 942     stats->rx_dropped = UINT64_MAX;
 943     stats->tx_dropped = ifd->ifi_iqdrops;
 944     stats->multicast = ifd->ifi_omcasts;
 945     stats->collisions = UINT64_MAX;
 946     stats->rx_length_errors = UINT64_MAX;
 947     stats->rx_over_errors = UINT64_MAX;
 948     stats->rx_crc_errors = UINT64_MAX;
 949     stats->rx_frame_errors = UINT64_MAX;
 950     stats->rx_fifo_errors = UINT64_MAX;
 951     stats->rx_missed_errors = UINT64_MAX;
 952     stats->tx_aborted_errors = UINT64_MAX;
 953     stats->tx_carrier_errors = UINT64_MAX;
 954     stats->tx_fifo_errors = UINT64_MAX;
 955     stats->tx_heartbeat_errors = UINT64_MAX;
 956     stats->tx_window_errors = UINT64_MAX;
 957 }
 958
 959 static void
 960 convert_stats(const struct netdev *netdev, struct netdev_stats *stats,
 961               const struct if_data *ifd)
 962 {
 963     if (netdev_bsd_cast(netdev)->tap_fd == -1) {
 964         convert_stats_system(stats, ifd);
 965     } else {
 966         convert_stats_tap(stats, ifd);
 967     }
 968 }
 969
 970 /* Retrieves current device stats for 'netdev'. */
 971 static int
 972 netdev_bsd_get_stats(const struct netdev *netdev_, struct netdev_stats *stats)
 973 {
 974 #if defined(__FreeBSD__)
 975     int if_count, i;
 976     int mib[6];
 977     size_t len;
 978     struct ifmibdata ifmd;
 979
 980
 981     mib[0] = CTL_NET;
 982     mib[1] = PF_LINK;
 983     mib[2] = NETLINK_GENERIC;
 984     mib[3] = IFMIB_SYSTEM;
 985     mib[4] = IFMIB_IFCOUNT;
 986
 987     len = sizeof(if_count);
 988
 989     if (sysctl(mib, 5, &if_count, &len, (void *)0, 0) == -1) {
 990         VLOG_DBG_RL(&rl, "%s: sysctl failed: %s",
 991                     netdev_get_name(netdev_), ovs_strerror(errno));
 992         return errno;
 993     }
 994
 995     mib[5] = IFDATA_GENERAL;
 996     mib[3] = IFMIB_IFDATA;
 997     len = sizeof(ifmd);
 998     for (i = 1; i <= if_count; i++) {
 999         mib[4] = i; //row
1000         if (sysctl(mib, 6, &ifmd, &len, (void *)0, 0) == -1) {
1001             VLOG_DBG_RL(&rl, "%s: sysctl failed: %s",
1002                         netdev_get_name(netdev_), ovs_strerror(errno));
1003             return errno;
1004         } else if (!strcmp(ifmd.ifmd_name, netdev_get_name(netdev_))) {
1005             convert_stats(netdev_, stats, &ifmd.ifmd_data);
1006             break;
1007         }
1008     }
1009
1010     return 0;
1011 #elif defined(__NetBSD__)
1012     struct ifdatareq ifdr;
1013     int error;
1014
1015     memset(&ifdr, 0, sizeof(ifdr));
1016     ovs_strlcpy(ifdr.ifdr_name, netdev_get_kernel_name(netdev_),
1017                 sizeof(ifdr.ifdr_name));
1018     error = af_link_ioctl(SIOCGIFDATA, &ifdr);
1019     if (!error) {
1020         convert_stats(netdev_, stats, &ifdr.ifdr_data);
1021     }
1022     return error;
1023 #else
1024 #error not implemented
1025 #endif
1026 }
1027
1028 static uint32_t
1029 netdev_bsd_parse_media(int media)
1030 {
1031     uint32_t supported = 0;
1032     bool half_duplex = media & IFM_HDX ? true : false;
1033
1034     switch (IFM_SUBTYPE(media)) {
1035     case IFM_10_2:
1036     case IFM_10_5:
1037     case IFM_10_STP:
1038     case IFM_10_T:
1039         supported |= half_duplex ? NETDEV_F_10MB_HD : NETDEV_F_10MB_FD;
1040         supported |= NETDEV_F_COPPER;
1041         break;
1042
1043     case IFM_10_FL:
1044         supported |= half_duplex ? NETDEV_F_10MB_HD : NETDEV_F_10MB_FD;
1045         supported |= NETDEV_F_FIBER;
1046         break;
1047
1048     case IFM_100_T2:
1049     case IFM_100_T4:
1050     case IFM_100_TX:
1051     case IFM_100_VG:
1052         supported |= half_duplex ? NETDEV_F_100MB_HD : NETDEV_F_100MB_FD;
1053         supported |= NETDEV_F_COPPER;
1054         break;
1055
1056     case IFM_100_FX:
1057         supported |= half_duplex ? NETDEV_F_100MB_HD : NETDEV_F_100MB_FD;
1058         supported |= NETDEV_F_FIBER;
1059         break;
1060
1061     case IFM_1000_CX:
1062     case IFM_1000_T:
1063         supported |= half_duplex ? NETDEV_F_1GB_HD : NETDEV_F_1GB_FD;
1064         supported |= NETDEV_F_COPPER;
1065         break;
1066
1067     case IFM_1000_LX:
1068     case IFM_1000_SX:
1069         supported |= half_duplex ? NETDEV_F_1GB_HD : NETDEV_F_1GB_FD;
1070         supported |= NETDEV_F_FIBER;
1071         break;
1072
1073     case IFM_10G_CX4:
1074         supported |= NETDEV_F_10GB_FD;
1075         supported |= NETDEV_F_COPPER;
1076         break;
1077
1078     case IFM_10G_LR:
1079     case IFM_10G_SR:
1080         supported |= NETDEV_F_10GB_FD;
1081         supported |= NETDEV_F_FIBER;
1082         break;
1083
1084     default:
1085         return 0;
1086     }
1087
1088     if (IFM_SUBTYPE(media) == IFM_AUTO) {
1089         supported |= NETDEV_F_AUTONEG;
1090     }
1091     /*
1092     if (media & IFM_ETH_FMASK) {
1093         supported |= NETDEV_F_PAUSE;
1094     }
1095     */
1096
1097     return supported;
1098 }
1099
1100 /*
1101  * Stores the features supported by 'netdev' into each of '*current',
1102  * '*advertised', '*supported', and '*peer' that are non-null.  Each value is a
1103  * bitmap of "enum ofp_port_features" bits, in host byte order.  Returns 0 if
1104  * successful, otherwise a positive errno value.  On failure, all of the
1105  * passed-in values are set to 0.
1106  */
1107 static int
1108 netdev_bsd_get_features(const struct netdev *netdev,
1109                         enum netdev_features *current, uint32_t *advertised,
1110                         enum netdev_features *supported, uint32_t *peer)
1111 {
1112     struct ifmediareq ifmr;
1113     int *media_list;
1114     int i;
1115     int error;
1116
1117
1118     /* XXX Look into SIOCGIFCAP instead of SIOCGIFMEDIA */
1119
1120     memset(&ifmr, 0, sizeof(ifmr));
1121     ovs_strlcpy(ifmr.ifm_name, netdev_get_name(netdev), sizeof ifmr.ifm_name);
1122
1123     /* We make two SIOCGIFMEDIA ioctl calls.  The first to determine the
1124      * number of supported modes, and a second with a buffer to retrieve
1125      * them. */
1126     error = af_inet_ioctl(SIOCGIFMEDIA, &ifmr);
1127     if (error) {
1128         VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFMEDIA) failed: %s",
1129                     netdev_get_name(netdev), ovs_strerror(error));
1130         return error;
1131     }
1132
1133     media_list = xcalloc(ifmr.ifm_count, sizeof(int));
1134     ifmr.ifm_ulist = media_list;
1135
1136     if (IFM_TYPE(ifmr.ifm_current) != IFM_ETHER) {
1137         VLOG_DBG_RL(&rl, "%s: doesn't appear to be ethernet",
1138                     netdev_get_name(netdev));
1139         error = EINVAL;
1140         goto cleanup;
1141     }
1142
1143     error = af_inet_ioctl(SIOCGIFMEDIA, &ifmr);
1144     if (error) {
1145         VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFMEDIA) failed: %s",
1146                     netdev_get_name(netdev), ovs_strerror(error));
1147         goto cleanup;
1148     }
1149
1150     /* Current settings. */
1151     *current = netdev_bsd_parse_media(ifmr.ifm_active);
1152
1153     /* Advertised features. */
1154     *advertised = netdev_bsd_parse_media(ifmr.ifm_current);
1155
1156     /* Supported features. */
1157     *supported = 0;
1158     for (i = 0; i < ifmr.ifm_count; i++) {
1159         *supported |= netdev_bsd_parse_media(ifmr.ifm_ulist[i]);
1160     }
1161
1162     /* Peer advertisements. */
1163     *peer = 0;                  /* XXX */
1164
1165     error = 0;
1166 cleanup:
1167     free(media_list);
1168     return error;
1169 }
1170
1171 /*
1172  * Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask.  If
1173  * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared.  Returns a
1174  * positive errno value.
1175  */
1176 static int
1177 netdev_bsd_set_in4(struct netdev *netdev_, struct in_addr addr,
1178                    struct in_addr mask)
1179 {
1180     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
1181     int error;
1182
1183     ovs_mutex_lock(&netdev->mutex);
1184     error = do_set_addr(netdev_, SIOCSIFADDR, "SIOCSIFADDR", addr);
1185     if (!error) {
1186         if (addr.s_addr != INADDR_ANY) {
1187             error = do_set_addr(netdev_, SIOCSIFNETMASK,
1188                                 "SIOCSIFNETMASK", mask);
1189         }
1190         netdev_change_seq_changed(netdev_);
1191     }
1192     ovs_mutex_unlock(&netdev->mutex);
1193
1194     return error;
1195 }
1196
1197 static int
1198 netdev_bsd_get_addr_list(const struct netdev *netdev_,
1199                          struct in6_addr **addr, struct in6_addr **mask, int *n_cnt)
1200 {
1201     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
1202     int error;
1203
1204     if (!(netdev->cache_valid & VALID_IN)) {
1205         netdev_get_addrs_list_flush();
1206     }
1207     error = netdev_get_addrs(netdev_get_name(netdev_), addr, mask, n_cnt);
1208     if (!error) {
1209         netdev->cache_valid |= VALID_IN;
1210     }
1211     return error;
1212 }
1213
1214 #if defined(__NetBSD__)
1215 static char *
1216 netdev_bsd_kernel_name_to_ovs_name(const char *kernel_name)
1217 {
1218     char *ovs_name = NULL;
1219     struct shash device_shash;
1220     struct shash_node *node;
1221
1222     shash_init(&device_shash);
1223     netdev_get_devices(&netdev_tap_class, &device_shash);
1224     SHASH_FOR_EACH(node, &device_shash) {
1225         struct netdev *netdev = node->data;
1226         struct netdev_bsd * const dev = netdev_bsd_cast(netdev);
1227
1228         if (!strcmp(dev->kernel_name, kernel_name)) {
1229             free(ovs_name);
1230             ovs_name = xstrdup(netdev_get_name(&dev->up));
1231         }
1232         netdev_close(netdev);
1233     }
1234     shash_destroy(&device_shash);
1235
1236     return ovs_name ? ovs_name : xstrdup(kernel_name);
1237 }
1238 #endif
1239
1240 static int
1241 netdev_bsd_get_next_hop(const struct in_addr *host OVS_UNUSED,
1242                         struct in_addr *next_hop OVS_UNUSED,
1243                         char **netdev_name OVS_UNUSED)
1244 {
1245 #if defined(__NetBSD__)
1246     static int seq = 0;
1247     struct sockaddr_in sin;
1248     struct sockaddr_dl sdl;
1249     int s;
1250     int i;
1251     struct {
1252         struct rt_msghdr h;
1253         char space[512];
1254     } buf;
1255     struct rt_msghdr *rtm = &buf.h;
1256     const pid_t pid = getpid();
1257     char *cp;
1258     ssize_t ssz;
1259     bool gateway = false;
1260     char *ifname = NULL;
1261     int saved_errno;
1262
1263     memset(next_hop, 0, sizeof(*next_hop));
1264     *netdev_name = NULL;
1265
1266     memset(&sin, 0, sizeof(sin));
1267     sin.sin_len = sizeof(sin);
1268     sin.sin_family = AF_INET;
1269     sin.sin_port = 0;
1270     sin.sin_addr = *host;
1271
1272     memset(&sdl, 0, sizeof(sdl));
1273     sdl.sdl_len = sizeof(sdl);
1274     sdl.sdl_family = AF_LINK;
1275
1276     s = socket(PF_ROUTE, SOCK_RAW, 0);
1277     memset(&buf, 0, sizeof(buf));
1278     rtm->rtm_flags = RTF_HOST|RTF_UP;
1279     rtm->rtm_version = RTM_VERSION;
1280     rtm->rtm_addrs = RTA_DST|RTA_IFP;
1281     cp = (void *)&buf.space;
1282     memcpy(cp, &sin, sizeof(sin));
1283     RT_ADVANCE(cp, (struct sockaddr *)(void *)&sin);
1284     memcpy(cp, &sdl, sizeof(sdl));
1285     RT_ADVANCE(cp, (struct sockaddr *)(void *)&sdl);
1286     rtm->rtm_msglen = cp - (char *)(void *)rtm;
1287     rtm->rtm_seq = ++seq;
1288     rtm->rtm_type = RTM_GET;
1289     rtm->rtm_pid = pid;
1290     write(s, rtm, rtm->rtm_msglen);
1291     memset(&buf, 0, sizeof(buf));
1292     do {
1293         ssz = read(s, &buf, sizeof(buf));
1294     } while (ssz > 0 && (rtm->rtm_seq != seq || rtm->rtm_pid != pid));
1295     saved_errno = errno;
1296     close(s);
1297     if (ssz <= 0) {
1298         if (ssz < 0) {
1299             return saved_errno;
1300         }
1301         return EPIPE; /* XXX */
1302     }
1303     cp = (void *)&buf.space;
1304     for (i = 1; i; i <<= 1) {
1305         if ((rtm->rtm_addrs & i) != 0) {
1306             const struct sockaddr *sa = (const void *)cp;
1307
1308             if ((i == RTA_GATEWAY) && sa->sa_family == AF_INET) {
1309                 const struct sockaddr_in * const sin =
1310                   ALIGNED_CAST(const struct sockaddr_in *, sa);
1311
1312                 *next_hop = sin->sin_addr;
1313                 gateway = true;
1314             }
1315             if ((i == RTA_IFP) && sa->sa_family == AF_LINK) {
1316                 const struct sockaddr_dl * const sdl =
1317                   ALIGNED_CAST(const struct sockaddr_dl *, sa);
1318                 char *kernel_name;
1319
1320                 kernel_name = xmemdup0(sdl->sdl_data, sdl->sdl_nlen);
1321                 ifname = netdev_bsd_kernel_name_to_ovs_name(kernel_name);
1322                 free(kernel_name);
1323             }
1324             RT_ADVANCE(cp, sa);
1325         }
1326     }
1327     if (ifname == NULL) {
1328         return ENXIO;
1329     }
1330     if (!gateway) {
1331         *next_hop = *host;
1332     }
1333     *netdev_name = ifname;
1334     VLOG_DBG("host " IP_FMT " next-hop " IP_FMT " if %s",
1335       IP_ARGS(host->s_addr), IP_ARGS(next_hop->s_addr), *netdev_name);
1336     return 0;
1337 #else
1338     return EOPNOTSUPP;
1339 #endif
1340 }
1341
1342 static int
1343 netdev_bsd_arp_lookup(const struct netdev *netdev OVS_UNUSED,
1344                       ovs_be32 ip OVS_UNUSED,
1345                       struct eth_addr *mac OVS_UNUSED)
1346 {
1347 #if defined(__NetBSD__)
1348     const struct rt_msghdr *rtm;
1349     size_t needed;
1350     char *buf;
1351     const char *cp;
1352     const char *ep;
1353     int mib[6];
1354     int error;
1355
1356     buf = NULL;
1357     mib[0] = CTL_NET;
1358     mib[1] = PF_ROUTE;
1359     mib[2] = 0;
1360     mib[3] = AF_INET;
1361     mib[4] = NET_RT_FLAGS;
1362     mib[5] = RTF_LLINFO;
1363     if (sysctl(mib, 6, NULL, &needed, NULL, 0) == -1) {
1364         error = errno;
1365         goto error;
1366     }
1367     buf = xmalloc(needed);
1368     if (sysctl(mib, 6, buf, &needed, NULL, 0) == -1) {
1369         error = errno;
1370         goto error;
1371     }
1372     ep = buf + needed;
1373     for (cp = buf; cp < ep; cp += rtm->rtm_msglen) {
1374         const struct sockaddr_inarp *sina;
1375         const struct sockaddr_dl *sdl;
1376
1377         rtm = (const void *)cp;
1378         sina = (const void *)(rtm + 1);
1379         if (ip != sina->sin_addr.s_addr) {
1380             continue;
1381         }
1382         sdl = (const void *)
1383            ((const char *)(const void *)sina + RT_ROUNDUP(sina->sin_len));
1384         if (sdl->sdl_alen == ETH_ADDR_LEN) {
1385             memcpy(mac, &sdl->sdl_data[sdl->sdl_nlen], ETH_ADDR_LEN);
1386             error = 0;
1387             goto error;
1388         }
1389     }
1390     error = ENXIO;
1391 error:
1392     free(buf);
1393     return error;
1394 #else
1395     return EOPNOTSUPP;
1396 #endif
1397 }
1398
1399 static void
1400 make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr)
1401 {
1402     struct sockaddr_in sin;
1403     memset(&sin, 0, sizeof sin);
1404     sin.sin_family = AF_INET;
1405     sin.sin_addr = addr;
1406     sin.sin_port = 0;
1407
1408     memset(sa, 0, sizeof *sa);
1409     memcpy(sa, &sin, sizeof sin);
1410 }
1411
1412 static int
1413 do_set_addr(struct netdev *netdev,
1414             unsigned long ioctl_nr, const char *ioctl_name,
1415             struct in_addr addr)
1416 {
1417     struct ifreq ifr;
1418     make_in4_sockaddr(&ifr.ifr_addr, addr);
1419     return af_inet_ifreq_ioctl(netdev_get_kernel_name(netdev), &ifr, ioctl_nr,
1420                                ioctl_name);
1421 }
1422
1423 static int
1424 nd_to_iff_flags(enum netdev_flags nd)
1425 {
1426     int iff = 0;
1427     if (nd & NETDEV_UP) {
1428         iff |= IFF_UP;
1429     }
1430     if (nd & NETDEV_PROMISC) {
1431         iff |= IFF_PROMISC;
1432 #if defined(IFF_PPROMISC)
1433         iff |= IFF_PPROMISC;
1434 #endif
1435     }
1436     if (nd & NETDEV_LOOPBACK) {
1437         iff |= IFF_LOOPBACK;
1438     }
1439     return iff;
1440 }
1441
1442 static int
1443 iff_to_nd_flags(int iff)
1444 {
1445     enum netdev_flags nd = 0;
1446     if (iff & IFF_UP) {
1447         nd |= NETDEV_UP;
1448     }
1449     if (iff & IFF_PROMISC) {
1450         nd |= NETDEV_PROMISC;
1451     }
1452     if (iff & IFF_LOOPBACK) {
1453         nd |= NETDEV_LOOPBACK;
1454     }
1455     return nd;
1456 }
1457
1458 static int
1459 netdev_bsd_update_flags(struct netdev *netdev_, enum netdev_flags off,
1460                         enum netdev_flags on, enum netdev_flags *old_flagsp)
1461 {
1462     int old_flags, new_flags;
1463     int error;
1464
1465     error = get_flags(netdev_, &old_flags);
1466     if (!error) {
1467         *old_flagsp = iff_to_nd_flags(old_flags);
1468         new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
1469         if (new_flags != old_flags) {
1470             error = set_flags(netdev_get_kernel_name(netdev_), new_flags);
1471             netdev_change_seq_changed(netdev_);
1472         }
1473     }
1474     return error;
1475 }
1476
1477 /* Linux has also different GET_STATS, SET_STATS,
1478  * GET_STATUS)
1479  */
1480 #define NETDEV_BSD_CLASS(NAME, CONSTRUCT,            \
1481                          GET_FEATURES)               \
1482 {                                                    \
1483     NAME,                                            \
1484     false, /* is_pmd */                              \
1485                                                      \
1486     NULL, /* init */                                 \
1487     netdev_bsd_run,                                  \
1488     netdev_bsd_wait,                                 \
1489     netdev_bsd_alloc,                                \
1490     CONSTRUCT,                                       \
1491     netdev_bsd_destruct,                             \
1492     netdev_bsd_dealloc,                              \
1493     NULL, /* get_config */                           \
1494     NULL, /* set_config */                           \
1495     NULL, /* get_tunnel_config */                    \
1496     NULL, /* build header */                         \
1497     NULL, /* push header */                          \
1498     NULL, /* pop header */                           \
1499     NULL, /* get_numa_id */                          \
1500     NULL, /* set_tx_multiq */                        \
1501                                                      \
1502     netdev_bsd_send,                                 \
1503     netdev_bsd_send_wait,                            \
1504                                                      \
1505     netdev_bsd_set_etheraddr,                        \
1506     netdev_bsd_get_etheraddr,                        \
1507     netdev_bsd_get_mtu,                              \
1508     NULL, /* set_mtu */                              \
1509     netdev_bsd_get_ifindex,                          \
1510     netdev_bsd_get_carrier,                          \
1511     NULL, /* get_carrier_resets */                   \
1512     NULL, /* set_miimon_interval */                  \
1513     netdev_bsd_get_stats,                            \
1514                                                      \
1515     GET_FEATURES,                                    \
1516     NULL, /* set_advertisement */                    \
1517     NULL, /* set_policing */                         \
1518     NULL, /* get_qos_type */                         \
1519     NULL, /* get_qos_capabilities */                 \
1520     NULL, /* get_qos */                              \
1521     NULL, /* set_qos */                              \
1522     NULL, /* get_queue */                            \
1523     NULL, /* set_queue */                            \
1524     NULL, /* delete_queue */                         \
1525     NULL, /* get_queue_stats */                      \
1526     NULL, /* queue_dump_start */                     \
1527     NULL, /* queue_dump_next */                      \
1528     NULL, /* queue_dump_done */                      \
1529     NULL, /* dump_queue_stats */                     \
1530                                                      \
1531     netdev_bsd_set_in4,                              \
1532     netdev_bsd_get_addr_list,                        \
1533     NULL, /* add_router */                           \
1534     netdev_bsd_get_next_hop,                         \
1535     NULL, /* get_status */                           \
1536     netdev_bsd_arp_lookup, /* arp_lookup */          \
1537                                                      \
1538     netdev_bsd_update_flags,                         \
1539     NULL, /* reconfigure */                          \
1540                                                      \
1541     netdev_bsd_rxq_alloc,                            \
1542     netdev_bsd_rxq_construct,                        \
1543     netdev_bsd_rxq_destruct,                         \
1544     netdev_bsd_rxq_dealloc,                          \
1545     netdev_bsd_rxq_recv,                             \
1546     netdev_bsd_rxq_wait,                             \
1547     netdev_bsd_rxq_drain,                            \
1548 }
1549
1550 const struct netdev_class netdev_bsd_class =
1551     NETDEV_BSD_CLASS(
1552         "system",
1553         netdev_bsd_construct_system,
1554         netdev_bsd_get_features);
1555
1556 const struct netdev_class netdev_tap_class =
1557     NETDEV_BSD_CLASS(
1558         "tap",
1559         netdev_bsd_construct_tap,
1560         netdev_bsd_get_features);
1561 \f
1562
1563 static void
1564 destroy_tap(int fd, const char *name)
1565 {
1566     struct ifreq ifr;
1567
1568     close(fd);
1569     strcpy(ifr.ifr_name, name);
1570     /* XXX What to do if this call fails? */
1571     af_inet_ioctl(SIOCIFDESTROY, &ifr);
1572 }
1573
1574 static int
1575 get_flags(const struct netdev *netdev, int *flags)
1576 {
1577     struct ifreq ifr;
1578     int error;
1579
1580     error = af_inet_ifreq_ioctl(netdev_get_kernel_name(netdev), &ifr,
1581                                 SIOCGIFFLAGS, "SIOCGIFFLAGS");
1582
1583     *flags = ifr_get_flags(&ifr);
1584
1585     return error;
1586 }
1587
1588 static int
1589 set_flags(const char *name, int flags)
1590 {
1591     struct ifreq ifr;
1592
1593     ifr_set_flags(&ifr, flags);
1594
1595     return af_inet_ifreq_ioctl(name, &ifr, SIOCSIFFLAGS, "SIOCSIFFLAGS");
1596 }
1597
1598 static int
1599 get_ifindex(const struct netdev *netdev_, int *ifindexp)
1600 {
1601     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
1602     *ifindexp = 0;
1603     if (!(netdev->cache_valid & VALID_IFINDEX)) {
1604         int ifindex = if_nametoindex(netdev_get_name(netdev_));
1605         if (ifindex <= 0) {
1606             return errno;
1607         }
1608         netdev->cache_valid |= VALID_IFINDEX;
1609         netdev->ifindex = ifindex;
1610     }
1611     *ifindexp = netdev->ifindex;
1612     return 0;
1613 }
1614
1615 static int
1616 get_etheraddr(const char *netdev_name, struct eth_addr *ea)
1617 {
1618     struct ifaddrs *head;
1619     struct ifaddrs *ifa;
1620     struct sockaddr_dl *sdl;
1621
1622     if (getifaddrs(&head) != 0) {
1623         VLOG_ERR("getifaddrs on %s device failed: %s", netdev_name,
1624                 ovs_strerror(errno));
1625         return errno;
1626     }
1627
1628     for (ifa = head; ifa; ifa = ifa->ifa_next) {
1629         if (ifa->ifa_addr->sa_family == AF_LINK) {
1630             if (!strcmp(ifa->ifa_name, netdev_name)) {
1631                 sdl = ALIGNED_CAST(struct sockaddr_dl *, ifa->ifa_addr);
1632                 if (sdl) {
1633                     memcpy(ea, LLADDR(sdl), sdl->sdl_alen);
1634                     freeifaddrs(head);
1635                     return 0;
1636                 }
1637             }
1638         }
1639     }
1640
1641     VLOG_ERR("could not find ethernet address for %s device", netdev_name);
1642     freeifaddrs(head);
1643     return ENODEV;
1644 }
1645
1646 static int
1647 set_etheraddr(const char *netdev_name OVS_UNUSED, int hwaddr_family OVS_UNUSED,
1648               int hwaddr_len OVS_UNUSED,
1649               const struct eth_addr mac OVS_UNUSED)
1650 {
1651 #if defined(__FreeBSD__)
1652     struct ifreq ifr;
1653     int error;
1654
1655     memset(&ifr, 0, sizeof ifr);
1656     ovs_strlcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
1657     ifr.ifr_addr.sa_family = hwaddr_family;
1658     ifr.ifr_addr.sa_len = hwaddr_len;
1659     memcpy(ifr.ifr_addr.sa_data, &mac, hwaddr_len);
1660     error = af_inet_ioctl(SIOCSIFLLADDR, &ifr);
1661     if (error) {
1662         VLOG_ERR("ioctl(SIOCSIFLLADDR) on %s device failed: %s",
1663                  netdev_name, ovs_strerror(error));
1664         return error;
1665     }
1666     return 0;
1667 #elif defined(__NetBSD__)
1668     struct if_laddrreq req;
1669     struct sockaddr_dl *sdl;
1670     struct sockaddr_storage oldaddr;
1671     int error;
1672
1673     /*
1674      * get the old address, add new one, and then remove old one.
1675      */
1676
1677     if (hwaddr_len != ETH_ADDR_LEN) {
1678         /* just to be safe about sockaddr storage size */
1679         return EOPNOTSUPP;
1680     }
1681     memset(&req, 0, sizeof(req));
1682     ovs_strlcpy(req.iflr_name, netdev_name, sizeof(req.iflr_name));
1683     req.addr.ss_len = sizeof(req.addr);
1684     req.addr.ss_family = hwaddr_family;
1685     sdl = (struct sockaddr_dl *)&req.addr;
1686     sdl->sdl_alen = hwaddr_len;
1687
1688     error = af_link_ioctl(SIOCGLIFADDR, &req);
1689     if (error) {
1690         return error;
1691     }
1692     if (!memcmp(&sdl->sdl_data[sdl->sdl_nlen], &mac, hwaddr_len)) {
1693         return 0;
1694     }
1695     oldaddr = req.addr;
1696
1697     memset(&req, 0, sizeof(req));
1698     ovs_strlcpy(req.iflr_name, netdev_name, sizeof(req.iflr_name));
1699     req.flags = IFLR_ACTIVE;
1700     sdl = (struct sockaddr_dl *)&req.addr;
1701     sdl->sdl_len = offsetof(struct sockaddr_dl, sdl_data) + hwaddr_len;
1702     sdl->sdl_alen = hwaddr_len;
1703     sdl->sdl_family = hwaddr_family;
1704     memcpy(sdl->sdl_data, &mac, hwaddr_len);
1705     error = af_link_ioctl(SIOCALIFADDR, &req);
1706     if (error) {
1707         return error;
1708     }
1709
1710     memset(&req, 0, sizeof(req));
1711     ovs_strlcpy(req.iflr_name, netdev_name, sizeof(req.iflr_name));
1712     req.addr = oldaddr;
1713     return af_link_ioctl(SIOCDLIFADDR, &req);
1714 #else
1715 #error not implemented
1716 #endif
1717 }
1718
1719 static int
1720 ifr_get_flags(const struct ifreq *ifr)
1721 {
1722 #ifdef HAVE_STRUCT_IFREQ_IFR_FLAGSHIGH
1723     return (ifr->ifr_flagshigh << 16) | (ifr->ifr_flags & 0xffff);
1724 #else
1725     return ifr->ifr_flags;
1726 #endif
1727 }
1728
1729 static void
1730 ifr_set_flags(struct ifreq *ifr, int flags)
1731 {
1732 #ifdef HAVE_STRUCT_IFREQ_IFR_FLAGSHIGH
1733     ifr->ifr_flags = flags & 0xffff;
1734     ifr->ifr_flagshigh = flags >> 16;
1735 #else
1736     ifr->ifr_flags = flags;
1737 #endif
1738 }
1739
1740 #if defined(__NetBSD__)
1741 /* Calls ioctl() on an AF_LINK sock, passing the specified 'command' and
1742  * 'arg'.  Returns 0 if successful, otherwise a positive errno value. */
1743 int
1744 af_link_ioctl(unsigned long command, const void *arg)
1745 {
1746     static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
1747     static int sock;
1748
1749     if (ovsthread_once_start(&once)) {
1750         sock = socket(AF_LINK, SOCK_DGRAM, 0);
1751         if (sock < 0) {
1752             sock = -errno;
1753             VLOG_ERR("failed to create link socket: %s", ovs_strerror(errno));
1754         }
1755         ovsthread_once_done(&once);
1756     }
1757
1758     return (sock < 0 ? -sock
1759             : ioctl(sock, command, arg) == -1 ? errno
1760             : 0);
1761 }
1762 #endif
1763 #endif /* !defined(__MACH__) */