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 "openvswitch/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_batch *batch)
 622 {
 623     struct netdev_rxq_bsd *rxq = netdev_rxq_bsd_cast(rxq_);
 624     struct netdev *netdev = rxq->up.netdev;
 625     struct dp_packet *packet;
 626     ssize_t retval;
 627     int mtu;
 628
 629     if (netdev_bsd_get_mtu(netdev, &mtu)) {
 630         mtu = ETH_PAYLOAD_MAX;
 631     }
 632
 633     packet = dp_packet_new_with_headroom(VLAN_ETH_HEADER_LEN + mtu,
 634                                            DP_NETDEV_HEADROOM);
 635     retval = (rxq->pcap_handle
 636             ? netdev_rxq_bsd_recv_pcap(rxq, packet)
 637             : netdev_rxq_bsd_recv_tap(rxq, packet));
 638
 639     if (retval) {
 640         dp_packet_delete(packet);
 641     } else {
 642         dp_packet_pad(packet);
 643         batch->packets[0] = packet;
 644         batch->count = 1;
 645     }
 646     return retval;
 647 }
 648
 649 /*
 650  * Registers with the poll loop to wake up from the next call to poll_block()
 651  * when a packet is ready to be received with netdev_rxq_recv() on 'rxq'.
 652  */
 653 static void
 654 netdev_bsd_rxq_wait(struct netdev_rxq *rxq_)
 655 {
 656     struct netdev_rxq_bsd *rxq = netdev_rxq_bsd_cast(rxq_);
 657
 658     poll_fd_wait(rxq->fd, POLLIN);
 659 }
 660
 661 /* Discards all packets waiting to be received from 'rxq'. */
 662 static int
 663 netdev_bsd_rxq_drain(struct netdev_rxq *rxq_)
 664 {
 665     struct ifreq ifr;
 666     struct netdev_rxq_bsd *rxq = netdev_rxq_bsd_cast(rxq_);
 667
 668     strcpy(ifr.ifr_name, netdev_get_kernel_name(netdev_rxq_get_netdev(rxq_)));
 669     if (ioctl(rxq->fd, BIOCFLUSH, &ifr) == -1) {
 670         VLOG_DBG_RL(&rl, "%s: ioctl(BIOCFLUSH) failed: %s",
 671                     netdev_rxq_get_name(rxq_), ovs_strerror(errno));
 672         return errno;
 673     }
 674     return 0;
 675 }
 676
 677 /*
 678  * Send a packet on the specified network device. The device could be either a
 679  * system or a tap device.
 680  */
 681 static int
 682 netdev_bsd_send(struct netdev *netdev_, int qid OVS_UNUSED,
 683                 struct dp_packet_batch *batch, bool may_steal)
 684 {
 685     struct netdev_bsd *dev = netdev_bsd_cast(netdev_);
 686     const char *name = netdev_get_name(netdev_);
 687     int error;
 688     int i;
 689
 690     ovs_mutex_lock(&dev->mutex);
 691     if (dev->tap_fd < 0 && !dev->pcap) {
 692         error = netdev_bsd_open_pcap(name, &dev->pcap, &dev->fd);
 693     } else {
 694         error = 0;
 695     }
 696
 697     for (i = 0; i < batch->count; i++) {
 698         const void *data = dp_packet_data(batch->packets[i]);
 699         size_t size = dp_packet_size(batch->packets[i]);
 700
 701         /* Truncate the packet if it is configured. */
 702         size -= dp_packet_get_cutlen(batch->packets[i]);
 703
 704         while (!error) {
 705             ssize_t retval;
 706             if (dev->tap_fd >= 0) {
 707                 retval = write(dev->tap_fd, data, size);
 708             } else {
 709                 retval = pcap_inject(dev->pcap, data, size);
 710             }
 711             if (retval < 0) {
 712                 if (errno == EINTR) {
 713                     continue;
 714                 } else {
 715                     error = errno;
 716                     if (error != EAGAIN) {
 717                         VLOG_WARN_RL(&rl, "error sending Ethernet packet on"
 718                                      " %s: %s", name, ovs_strerror(error));
 719                     }
 720                 }
 721             } else if (retval != size) {
 722                 VLOG_WARN_RL(&rl, "sent partial Ethernet packet "
 723                                   "(%"PRIuSIZE" bytes of "
 724                                   "%"PRIuSIZE") on %s", retval, size, name);
 725                 error = EMSGSIZE;
 726             } else {
 727                 break;
 728             }
 729         }
 730     }
 731
 732     ovs_mutex_unlock(&dev->mutex);
 733     dp_packet_delete_batch(batch, may_steal);
 734
 735     return error;
 736 }
 737
 738 /*
 739  * Registers with the poll loop to wake up from the next call to poll_block()
 740  * when the packet transmission queue has sufficient room to transmit a packet
 741  * with netdev_send().
 742  */
 743 static void
 744 netdev_bsd_send_wait(struct netdev *netdev_, int qid OVS_UNUSED)
 745 {
 746     struct netdev_bsd *dev = netdev_bsd_cast(netdev_);
 747
 748     ovs_mutex_lock(&dev->mutex);
 749     if (dev->tap_fd >= 0) {
 750         /* TAP device always accepts packets. */
 751         poll_immediate_wake();
 752     } else if (dev->pcap) {
 753         poll_fd_wait(dev->fd, POLLOUT);
 754     } else {
 755         /* We haven't even tried to send a packet yet. */
 756         poll_immediate_wake();
 757     }
 758     ovs_mutex_unlock(&dev->mutex);
 759 }
 760
 761 /*
 762  * Attempts to set 'netdev''s MAC address to 'mac'.  Returns 0 if successful,
 763  * otherwise a positive errno value.
 764  */
 765 static int
 766 netdev_bsd_set_etheraddr(struct netdev *netdev_,
 767                          const struct eth_addr mac)
 768 {
 769     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 770     int error = 0;
 771
 772     ovs_mutex_lock(&netdev->mutex);
 773     if (!(netdev->cache_valid & VALID_ETHERADDR)
 774         || !eth_addr_equals(netdev->etheraddr, mac)) {
 775         error = set_etheraddr(netdev_get_kernel_name(netdev_), AF_LINK,
 776                               ETH_ADDR_LEN, mac);
 777         if (!error) {
 778             netdev->cache_valid |= VALID_ETHERADDR;
 779             netdev->etheraddr = mac;
 780             netdev_change_seq_changed(netdev_);
 781         }
 782     }
 783     ovs_mutex_unlock(&netdev->mutex);
 784
 785     return error;
 786 }
 787
 788 /*
 789  * Returns a pointer to 'netdev''s MAC address.  The caller must not modify or
 790  * free the returned buffer.
 791  */
 792 static int
 793 netdev_bsd_get_etheraddr(const struct netdev *netdev_, struct eth_addr *mac)
 794 {
 795     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 796     int error = 0;
 797
 798     ovs_mutex_lock(&netdev->mutex);
 799     if (!(netdev->cache_valid & VALID_ETHERADDR)) {
 800         error = get_etheraddr(netdev_get_kernel_name(netdev_),
 801                               &netdev->etheraddr);
 802         if (!error) {
 803             netdev->cache_valid |= VALID_ETHERADDR;
 804         }
 805     }
 806     if (!error) {
 807         *mac = netdev->etheraddr;
 808     }
 809     ovs_mutex_unlock(&netdev->mutex);
 810
 811     return error;
 812 }
 813
 814 /*
 815  * Returns the maximum size of transmitted (and received) packets on 'netdev',
 816  * in bytes, not including the hardware header; thus, this is typically 1500
 817  * bytes for Ethernet devices.
 818  */
 819 static int
 820 netdev_bsd_get_mtu(const struct netdev *netdev_, int *mtup)
 821 {
 822     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 823     int error = 0;
 824
 825     ovs_mutex_lock(&netdev->mutex);
 826     if (!(netdev->cache_valid & VALID_MTU)) {
 827         struct ifreq ifr;
 828
 829         error = af_inet_ifreq_ioctl(netdev_get_kernel_name(netdev_), &ifr,
 830                                     SIOCGIFMTU, "SIOCGIFMTU");
 831         if (!error) {
 832             netdev->mtu = ifr.ifr_mtu;
 833             netdev->cache_valid |= VALID_MTU;
 834         }
 835     }
 836     if (!error) {
 837         *mtup = netdev->mtu;
 838     }
 839     ovs_mutex_unlock(&netdev->mutex);
 840
 841     return error;
 842 }
 843
 844 static int
 845 netdev_bsd_get_ifindex(const struct netdev *netdev_)
 846 {
 847     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 848     int ifindex, error;
 849
 850     ovs_mutex_lock(&netdev->mutex);
 851     error = get_ifindex(netdev_, &ifindex);
 852     ovs_mutex_unlock(&netdev->mutex);
 853
 854     return error ? -error : ifindex;
 855 }
 856
 857 static int
 858 netdev_bsd_get_carrier(const struct netdev *netdev_, bool *carrier)
 859 {
 860     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 861     int error = 0;
 862
 863     ovs_mutex_lock(&netdev->mutex);
 864     if (!(netdev->cache_valid & VALID_CARRIER)) {
 865         struct ifmediareq ifmr;
 866
 867         memset(&ifmr, 0, sizeof(ifmr));
 868         ovs_strlcpy(ifmr.ifm_name, netdev_get_kernel_name(netdev_),
 869                     sizeof ifmr.ifm_name);
 870
 871         error = af_inet_ioctl(SIOCGIFMEDIA, &ifmr);
 872         if (!error) {
 873             netdev->carrier = (ifmr.ifm_status & IFM_ACTIVE) == IFM_ACTIVE;
 874             netdev->cache_valid |= VALID_CARRIER;
 875
 876             /* If the interface doesn't report whether the media is active,
 877              * just assume it is active. */
 878             if ((ifmr.ifm_status & IFM_AVALID) == 0) {
 879                 netdev->carrier = true;
 880             }
 881         } else {
 882             VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFMEDIA) failed: %s",
 883                         netdev_get_name(netdev_), ovs_strerror(error));
 884         }
 885     }
 886     if (!error) {
 887         *carrier = netdev->carrier;
 888     }
 889     ovs_mutex_unlock(&netdev->mutex);
 890
 891     return error;
 892 }
 893
 894 static void
 895 convert_stats_system(struct netdev_stats *stats, const struct if_data *ifd)
 896 {
 897     /*
 898      * note: UINT64_MAX means unsupported
 899      */
 900     stats->rx_packets = ifd->ifi_ipackets;
 901     stats->tx_packets = ifd->ifi_opackets;
 902     stats->rx_bytes = ifd->ifi_obytes;
 903     stats->tx_bytes = ifd->ifi_ibytes;
 904     stats->rx_errors = ifd->ifi_ierrors;
 905     stats->tx_errors = ifd->ifi_oerrors;
 906     stats->rx_dropped = ifd->ifi_iqdrops;
 907     stats->tx_dropped = UINT64_MAX;
 908     stats->multicast = ifd->ifi_imcasts;
 909     stats->collisions = ifd->ifi_collisions;
 910     stats->rx_length_errors = UINT64_MAX;
 911     stats->rx_over_errors = UINT64_MAX;
 912     stats->rx_crc_errors = UINT64_MAX;
 913     stats->rx_frame_errors = UINT64_MAX;
 914     stats->rx_fifo_errors = UINT64_MAX;
 915     stats->rx_missed_errors = UINT64_MAX;
 916     stats->tx_aborted_errors = UINT64_MAX;
 917     stats->tx_carrier_errors = UINT64_MAX;
 918     stats->tx_fifo_errors = UINT64_MAX;
 919     stats->tx_heartbeat_errors = UINT64_MAX;
 920     stats->tx_window_errors = UINT64_MAX;
 921 }
 922
 923 static void
 924 convert_stats_tap(struct netdev_stats *stats, const struct if_data *ifd)
 925 {
 926     /*
 927      * Similar to convert_stats_system but swapping rxq and tx
 928      * because 'ifd' is stats for the network interface side of the
 929      * tap device and what the caller wants is one for the character
 930      * device side.
 931      *
 932      * note: UINT64_MAX means unsupported
 933      */
 934     stats->rx_packets = ifd->ifi_opackets;
 935     stats->tx_packets = ifd->ifi_ipackets;
 936     stats->rx_bytes = ifd->ifi_ibytes;
 937     stats->tx_bytes = ifd->ifi_obytes;
 938     stats->rx_errors = ifd->ifi_oerrors;
 939     stats->tx_errors = ifd->ifi_ierrors;
 940     stats->rx_dropped = UINT64_MAX;
 941     stats->tx_dropped = ifd->ifi_iqdrops;
 942     stats->multicast = ifd->ifi_omcasts;
 943     stats->collisions = UINT64_MAX;
 944     stats->rx_length_errors = UINT64_MAX;
 945     stats->rx_over_errors = UINT64_MAX;
 946     stats->rx_crc_errors = UINT64_MAX;
 947     stats->rx_frame_errors = UINT64_MAX;
 948     stats->rx_fifo_errors = UINT64_MAX;
 949     stats->rx_missed_errors = UINT64_MAX;
 950     stats->tx_aborted_errors = UINT64_MAX;
 951     stats->tx_carrier_errors = UINT64_MAX;
 952     stats->tx_fifo_errors = UINT64_MAX;
 953     stats->tx_heartbeat_errors = UINT64_MAX;
 954     stats->tx_window_errors = UINT64_MAX;
 955 }
 956
 957 static void
 958 convert_stats(const struct netdev *netdev, struct netdev_stats *stats,
 959               const struct if_data *ifd)
 960 {
 961     if (netdev_bsd_cast(netdev)->tap_fd == -1) {
 962         convert_stats_system(stats, ifd);
 963     } else {
 964         convert_stats_tap(stats, ifd);
 965     }
 966 }
 967
 968 /* Retrieves current device stats for 'netdev'. */
 969 static int
 970 netdev_bsd_get_stats(const struct netdev *netdev_, struct netdev_stats *stats)
 971 {
 972 #if defined(__FreeBSD__)
 973     int if_count, i;
 974     int mib[6];
 975     size_t len;
 976     struct ifmibdata ifmd;
 977
 978
 979     mib[0] = CTL_NET;
 980     mib[1] = PF_LINK;
 981     mib[2] = NETLINK_GENERIC;
 982     mib[3] = IFMIB_SYSTEM;
 983     mib[4] = IFMIB_IFCOUNT;
 984
 985     len = sizeof(if_count);
 986
 987     if (sysctl(mib, 5, &if_count, &len, (void *)0, 0) == -1) {
 988         VLOG_DBG_RL(&rl, "%s: sysctl failed: %s",
 989                     netdev_get_name(netdev_), ovs_strerror(errno));
 990         return errno;
 991     }
 992
 993     mib[5] = IFDATA_GENERAL;
 994     mib[3] = IFMIB_IFDATA;
 995     len = sizeof(ifmd);
 996     for (i = 1; i <= if_count; i++) {
 997         mib[4] = i; //row
 998         if (sysctl(mib, 6, &ifmd, &len, (void *)0, 0) == -1) {
 999             VLOG_DBG_RL(&rl, "%s: sysctl failed: %s",
1000                         netdev_get_name(netdev_), ovs_strerror(errno));
1001             return errno;
1002         } else if (!strcmp(ifmd.ifmd_name, netdev_get_name(netdev_))) {
1003             convert_stats(netdev_, stats, &ifmd.ifmd_data);
1004             break;
1005         }
1006     }
1007
1008     return 0;
1009 #elif defined(__NetBSD__)
1010     struct ifdatareq ifdr;
1011     int error;
1012
1013     memset(&ifdr, 0, sizeof(ifdr));
1014     ovs_strlcpy(ifdr.ifdr_name, netdev_get_kernel_name(netdev_),
1015                 sizeof(ifdr.ifdr_name));
1016     error = af_link_ioctl(SIOCGIFDATA, &ifdr);
1017     if (!error) {
1018         convert_stats(netdev_, stats, &ifdr.ifdr_data);
1019     }
1020     return error;
1021 #else
1022 #error not implemented
1023 #endif
1024 }
1025
1026 static uint32_t
1027 netdev_bsd_parse_media(int media)
1028 {
1029     uint32_t supported = 0;
1030     bool half_duplex = media & IFM_HDX ? true : false;
1031
1032     switch (IFM_SUBTYPE(media)) {
1033     case IFM_10_2:
1034     case IFM_10_5:
1035     case IFM_10_STP:
1036     case IFM_10_T:
1037         supported |= half_duplex ? NETDEV_F_10MB_HD : NETDEV_F_10MB_FD;
1038         supported |= NETDEV_F_COPPER;
1039         break;
1040
1041     case IFM_10_FL:
1042         supported |= half_duplex ? NETDEV_F_10MB_HD : NETDEV_F_10MB_FD;
1043         supported |= NETDEV_F_FIBER;
1044         break;
1045
1046     case IFM_100_T2:
1047     case IFM_100_T4:
1048     case IFM_100_TX:
1049     case IFM_100_VG:
1050         supported |= half_duplex ? NETDEV_F_100MB_HD : NETDEV_F_100MB_FD;
1051         supported |= NETDEV_F_COPPER;
1052         break;
1053
1054     case IFM_100_FX:
1055         supported |= half_duplex ? NETDEV_F_100MB_HD : NETDEV_F_100MB_FD;
1056         supported |= NETDEV_F_FIBER;
1057         break;
1058
1059     case IFM_1000_CX:
1060     case IFM_1000_T:
1061         supported |= half_duplex ? NETDEV_F_1GB_HD : NETDEV_F_1GB_FD;
1062         supported |= NETDEV_F_COPPER;
1063         break;
1064
1065     case IFM_1000_LX:
1066     case IFM_1000_SX:
1067         supported |= half_duplex ? NETDEV_F_1GB_HD : NETDEV_F_1GB_FD;
1068         supported |= NETDEV_F_FIBER;
1069         break;
1070
1071     case IFM_10G_CX4:
1072         supported |= NETDEV_F_10GB_FD;
1073         supported |= NETDEV_F_COPPER;
1074         break;
1075
1076     case IFM_10G_LR:
1077     case IFM_10G_SR:
1078         supported |= NETDEV_F_10GB_FD;
1079         supported |= NETDEV_F_FIBER;
1080         break;
1081
1082     default:
1083         return 0;
1084     }
1085
1086     if (IFM_SUBTYPE(media) == IFM_AUTO) {
1087         supported |= NETDEV_F_AUTONEG;
1088     }
1089     /*
1090     if (media & IFM_ETH_FMASK) {
1091         supported |= NETDEV_F_PAUSE;
1092     }
1093     */
1094
1095     return supported;
1096 }
1097
1098 /*
1099  * Stores the features supported by 'netdev' into each of '*current',
1100  * '*advertised', '*supported', and '*peer' that are non-null.  Each value is a
1101  * bitmap of "enum ofp_port_features" bits, in host byte order.  Returns 0 if
1102  * successful, otherwise a positive errno value.  On failure, all of the
1103  * passed-in values are set to 0.
1104  */
1105 static int
1106 netdev_bsd_get_features(const struct netdev *netdev,
1107                         enum netdev_features *current, uint32_t *advertised,
1108                         enum netdev_features *supported, uint32_t *peer)
1109 {
1110     struct ifmediareq ifmr;
1111     int *media_list;
1112     int i;
1113     int error;
1114
1115
1116     /* XXX Look into SIOCGIFCAP instead of SIOCGIFMEDIA */
1117
1118     memset(&ifmr, 0, sizeof(ifmr));
1119     ovs_strlcpy(ifmr.ifm_name, netdev_get_name(netdev), sizeof ifmr.ifm_name);
1120
1121     /* We make two SIOCGIFMEDIA ioctl calls.  The first to determine the
1122      * number of supported modes, and a second with a buffer to retrieve
1123      * them. */
1124     error = af_inet_ioctl(SIOCGIFMEDIA, &ifmr);
1125     if (error) {
1126         VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFMEDIA) failed: %s",
1127                     netdev_get_name(netdev), ovs_strerror(error));
1128         return error;
1129     }
1130
1131     media_list = xcalloc(ifmr.ifm_count, sizeof(int));
1132     ifmr.ifm_ulist = media_list;
1133
1134     if (IFM_TYPE(ifmr.ifm_current) != IFM_ETHER) {
1135         VLOG_DBG_RL(&rl, "%s: doesn't appear to be ethernet",
1136                     netdev_get_name(netdev));
1137         error = EINVAL;
1138         goto cleanup;
1139     }
1140
1141     error = af_inet_ioctl(SIOCGIFMEDIA, &ifmr);
1142     if (error) {
1143         VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFMEDIA) failed: %s",
1144                     netdev_get_name(netdev), ovs_strerror(error));
1145         goto cleanup;
1146     }
1147
1148     /* Current settings. */
1149     *current = netdev_bsd_parse_media(ifmr.ifm_active);
1150
1151     /* Advertised features. */
1152     *advertised = netdev_bsd_parse_media(ifmr.ifm_current);
1153
1154     /* Supported features. */
1155     *supported = 0;
1156     for (i = 0; i < ifmr.ifm_count; i++) {
1157         *supported |= netdev_bsd_parse_media(ifmr.ifm_ulist[i]);
1158     }
1159
1160     /* Peer advertisements. */
1161     *peer = 0;                  /* XXX */
1162
1163     error = 0;
1164 cleanup:
1165     free(media_list);
1166     return error;
1167 }
1168
1169 /*
1170  * Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask.  If
1171  * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared.  Returns a
1172  * positive errno value.
1173  */
1174 static int
1175 netdev_bsd_set_in4(struct netdev *netdev_, struct in_addr addr,
1176                    struct in_addr mask)
1177 {
1178     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
1179     int error;
1180
1181     ovs_mutex_lock(&netdev->mutex);
1182     error = do_set_addr(netdev_, SIOCSIFADDR, "SIOCSIFADDR", addr);
1183     if (!error) {
1184         if (addr.s_addr != INADDR_ANY) {
1185             error = do_set_addr(netdev_, SIOCSIFNETMASK,
1186                                 "SIOCSIFNETMASK", mask);
1187         }
1188         netdev_change_seq_changed(netdev_);
1189     }
1190     ovs_mutex_unlock(&netdev->mutex);
1191
1192     return error;
1193 }
1194
1195 static int
1196 netdev_bsd_get_addr_list(const struct netdev *netdev_,
1197                          struct in6_addr **addr, struct in6_addr **mask, int *n_cnt)
1198 {
1199     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
1200     int error;
1201
1202     if (!(netdev->cache_valid & VALID_IN)) {
1203         netdev_get_addrs_list_flush();
1204     }
1205     error = netdev_get_addrs(netdev_get_name(netdev_), addr, mask, n_cnt);
1206     if (!error) {
1207         netdev->cache_valid |= VALID_IN;
1208     }
1209     return error;
1210 }
1211
1212 #if defined(__NetBSD__)
1213 static char *
1214 netdev_bsd_kernel_name_to_ovs_name(const char *kernel_name)
1215 {
1216     char *ovs_name = NULL;
1217     struct shash device_shash;
1218     struct shash_node *node;
1219
1220     shash_init(&device_shash);
1221     netdev_get_devices(&netdev_tap_class, &device_shash);
1222     SHASH_FOR_EACH(node, &device_shash) {
1223         struct netdev *netdev = node->data;
1224         struct netdev_bsd * const dev = netdev_bsd_cast(netdev);
1225
1226         if (!strcmp(dev->kernel_name, kernel_name)) {
1227             free(ovs_name);
1228             ovs_name = xstrdup(netdev_get_name(&dev->up));
1229         }
1230         netdev_close(netdev);
1231     }
1232     shash_destroy(&device_shash);
1233
1234     return ovs_name ? ovs_name : xstrdup(kernel_name);
1235 }
1236 #endif
1237
1238 static int
1239 netdev_bsd_get_next_hop(const struct in_addr *host OVS_UNUSED,
1240                         struct in_addr *next_hop OVS_UNUSED,
1241                         char **netdev_name OVS_UNUSED)
1242 {
1243 #if defined(__NetBSD__)
1244     static int seq = 0;
1245     struct sockaddr_in sin;
1246     struct sockaddr_dl sdl;
1247     int s;
1248     int i;
1249     struct {
1250         struct rt_msghdr h;
1251         char space[512];
1252     } buf;
1253     struct rt_msghdr *rtm = &buf.h;
1254     const pid_t pid = getpid();
1255     char *cp;
1256     ssize_t ssz;
1257     bool gateway = false;
1258     char *ifname = NULL;
1259     int saved_errno;
1260
1261     memset(next_hop, 0, sizeof(*next_hop));
1262     *netdev_name = NULL;
1263
1264     memset(&sin, 0, sizeof(sin));
1265     sin.sin_len = sizeof(sin);
1266     sin.sin_family = AF_INET;
1267     sin.sin_port = 0;
1268     sin.sin_addr = *host;
1269
1270     memset(&sdl, 0, sizeof(sdl));
1271     sdl.sdl_len = sizeof(sdl);
1272     sdl.sdl_family = AF_LINK;
1273
1274     s = socket(PF_ROUTE, SOCK_RAW, 0);
1275     memset(&buf, 0, sizeof(buf));
1276     rtm->rtm_flags = RTF_HOST|RTF_UP;
1277     rtm->rtm_version = RTM_VERSION;
1278     rtm->rtm_addrs = RTA_DST|RTA_IFP;
1279     cp = (void *)&buf.space;
1280     memcpy(cp, &sin, sizeof(sin));
1281     RT_ADVANCE(cp, (struct sockaddr *)(void *)&sin);
1282     memcpy(cp, &sdl, sizeof(sdl));
1283     RT_ADVANCE(cp, (struct sockaddr *)(void *)&sdl);
1284     rtm->rtm_msglen = cp - (char *)(void *)rtm;
1285     rtm->rtm_seq = ++seq;
1286     rtm->rtm_type = RTM_GET;
1287     rtm->rtm_pid = pid;
1288     write(s, rtm, rtm->rtm_msglen);
1289     memset(&buf, 0, sizeof(buf));
1290     do {
1291         ssz = read(s, &buf, sizeof(buf));
1292     } while (ssz > 0 && (rtm->rtm_seq != seq || rtm->rtm_pid != pid));
1293     saved_errno = errno;
1294     close(s);
1295     if (ssz <= 0) {
1296         if (ssz < 0) {
1297             return saved_errno;
1298         }
1299         return EPIPE; /* XXX */
1300     }
1301     cp = (void *)&buf.space;
1302     for (i = 1; i; i <<= 1) {
1303         if ((rtm->rtm_addrs & i) != 0) {
1304             const struct sockaddr *sa = (const void *)cp;
1305
1306             if ((i == RTA_GATEWAY) && sa->sa_family == AF_INET) {
1307                 const struct sockaddr_in * const sin =
1308                   ALIGNED_CAST(const struct sockaddr_in *, sa);
1309
1310                 *next_hop = sin->sin_addr;
1311                 gateway = true;
1312             }
1313             if ((i == RTA_IFP) && sa->sa_family == AF_LINK) {
1314                 const struct sockaddr_dl * const sdl =
1315                   ALIGNED_CAST(const struct sockaddr_dl *, sa);
1316                 char *kernel_name;
1317
1318                 kernel_name = xmemdup0(sdl->sdl_data, sdl->sdl_nlen);
1319                 ifname = netdev_bsd_kernel_name_to_ovs_name(kernel_name);
1320                 free(kernel_name);
1321             }
1322             RT_ADVANCE(cp, sa);
1323         }
1324     }
1325     if (ifname == NULL) {
1326         return ENXIO;
1327     }
1328     if (!gateway) {
1329         *next_hop = *host;
1330     }
1331     *netdev_name = ifname;
1332     VLOG_DBG("host " IP_FMT " next-hop " IP_FMT " if %s",
1333       IP_ARGS(host->s_addr), IP_ARGS(next_hop->s_addr), *netdev_name);
1334     return 0;
1335 #else
1336     return EOPNOTSUPP;
1337 #endif
1338 }
1339
1340 static int
1341 netdev_bsd_arp_lookup(const struct netdev *netdev OVS_UNUSED,
1342                       ovs_be32 ip OVS_UNUSED,
1343                       struct eth_addr *mac OVS_UNUSED)
1344 {
1345 #if defined(__NetBSD__)
1346     const struct rt_msghdr *rtm;
1347     size_t needed;
1348     char *buf;
1349     const char *cp;
1350     const char *ep;
1351     int mib[6];
1352     int error;
1353
1354     buf = NULL;
1355     mib[0] = CTL_NET;
1356     mib[1] = PF_ROUTE;
1357     mib[2] = 0;
1358     mib[3] = AF_INET;
1359     mib[4] = NET_RT_FLAGS;
1360     mib[5] = RTF_LLINFO;
1361     if (sysctl(mib, 6, NULL, &needed, NULL, 0) == -1) {
1362         error = errno;
1363         goto error;
1364     }
1365     buf = xmalloc(needed);
1366     if (sysctl(mib, 6, buf, &needed, NULL, 0) == -1) {
1367         error = errno;
1368         goto error;
1369     }
1370     ep = buf + needed;
1371     for (cp = buf; cp < ep; cp += rtm->rtm_msglen) {
1372         const struct sockaddr_inarp *sina;
1373         const struct sockaddr_dl *sdl;
1374
1375         rtm = (const void *)cp;
1376         sina = (const void *)(rtm + 1);
1377         if (ip != sina->sin_addr.s_addr) {
1378             continue;
1379         }
1380         sdl = (const void *)
1381            ((const char *)(const void *)sina + RT_ROUNDUP(sina->sin_len));
1382         if (sdl->sdl_alen == ETH_ADDR_LEN) {
1383             memcpy(mac, &sdl->sdl_data[sdl->sdl_nlen], ETH_ADDR_LEN);
1384             error = 0;
1385             goto error;
1386         }
1387     }
1388     error = ENXIO;
1389 error:
1390     free(buf);
1391     return error;
1392 #else
1393     return EOPNOTSUPP;
1394 #endif
1395 }
1396
1397 static void
1398 make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr)
1399 {
1400     struct sockaddr_in sin;
1401     memset(&sin, 0, sizeof sin);
1402     sin.sin_family = AF_INET;
1403     sin.sin_addr = addr;
1404     sin.sin_port = 0;
1405
1406     memset(sa, 0, sizeof *sa);
1407     memcpy(sa, &sin, sizeof sin);
1408 }
1409
1410 static int
1411 do_set_addr(struct netdev *netdev,
1412             unsigned long ioctl_nr, const char *ioctl_name,
1413             struct in_addr addr)
1414 {
1415     struct ifreq ifr;
1416     make_in4_sockaddr(&ifr.ifr_addr, addr);
1417     return af_inet_ifreq_ioctl(netdev_get_kernel_name(netdev), &ifr, ioctl_nr,
1418                                ioctl_name);
1419 }
1420
1421 static int
1422 nd_to_iff_flags(enum netdev_flags nd)
1423 {
1424     int iff = 0;
1425     if (nd & NETDEV_UP) {
1426         iff |= IFF_UP;
1427     }
1428     if (nd & NETDEV_PROMISC) {
1429         iff |= IFF_PROMISC;
1430 #if defined(IFF_PPROMISC)
1431         iff |= IFF_PPROMISC;
1432 #endif
1433     }
1434     if (nd & NETDEV_LOOPBACK) {
1435         iff |= IFF_LOOPBACK;
1436     }
1437     return iff;
1438 }
1439
1440 static int
1441 iff_to_nd_flags(int iff)
1442 {
1443     enum netdev_flags nd = 0;
1444     if (iff & IFF_UP) {
1445         nd |= NETDEV_UP;
1446     }
1447     if (iff & IFF_PROMISC) {
1448         nd |= NETDEV_PROMISC;
1449     }
1450     if (iff & IFF_LOOPBACK) {
1451         nd |= NETDEV_LOOPBACK;
1452     }
1453     return nd;
1454 }
1455
1456 static int
1457 netdev_bsd_update_flags(struct netdev *netdev_, enum netdev_flags off,
1458                         enum netdev_flags on, enum netdev_flags *old_flagsp)
1459 {
1460     int old_flags, new_flags;
1461     int error;
1462
1463     error = get_flags(netdev_, &old_flags);
1464     if (!error) {
1465         *old_flagsp = iff_to_nd_flags(old_flags);
1466         new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
1467         if (new_flags != old_flags) {
1468             error = set_flags(netdev_get_kernel_name(netdev_), new_flags);
1469             netdev_change_seq_changed(netdev_);
1470         }
1471     }
1472     return error;
1473 }
1474
1475 /* Linux has also different GET_STATS, SET_STATS,
1476  * GET_STATUS)
1477  */
1478 #define NETDEV_BSD_CLASS(NAME, CONSTRUCT,            \
1479                          GET_FEATURES)               \
1480 {                                                    \
1481     NAME,                                            \
1482     false, /* is_pmd */                              \
1483                                                      \
1484     NULL, /* init */                                 \
1485     netdev_bsd_run,                                  \
1486     netdev_bsd_wait,                                 \
1487     netdev_bsd_alloc,                                \
1488     CONSTRUCT,                                       \
1489     netdev_bsd_destruct,                             \
1490     netdev_bsd_dealloc,                              \
1491     NULL, /* get_config */                           \
1492     NULL, /* set_config */                           \
1493     NULL, /* get_tunnel_config */                    \
1494     NULL, /* build header */                         \
1495     NULL, /* push header */                          \
1496     NULL, /* pop header */                           \
1497     NULL, /* get_numa_id */                          \
1498     NULL, /* set_tx_multiq */                        \
1499                                                      \
1500     netdev_bsd_send,                                 \
1501     netdev_bsd_send_wait,                            \
1502                                                      \
1503     netdev_bsd_set_etheraddr,                        \
1504     netdev_bsd_get_etheraddr,                        \
1505     netdev_bsd_get_mtu,                              \
1506     NULL, /* set_mtu */                              \
1507     netdev_bsd_get_ifindex,                          \
1508     netdev_bsd_get_carrier,                          \
1509     NULL, /* get_carrier_resets */                   \
1510     NULL, /* set_miimon_interval */                  \
1511     netdev_bsd_get_stats,                            \
1512                                                      \
1513     GET_FEATURES,                                    \
1514     NULL, /* set_advertisement */                    \
1515     NULL, /* set_policing */                         \
1516     NULL, /* get_qos_type */                         \
1517     NULL, /* get_qos_capabilities */                 \
1518     NULL, /* get_qos */                              \
1519     NULL, /* set_qos */                              \
1520     NULL, /* get_queue */                            \
1521     NULL, /* set_queue */                            \
1522     NULL, /* delete_queue */                         \
1523     NULL, /* get_queue_stats */                      \
1524     NULL, /* queue_dump_start */                     \
1525     NULL, /* queue_dump_next */                      \
1526     NULL, /* queue_dump_done */                      \
1527     NULL, /* dump_queue_stats */                     \
1528                                                      \
1529     netdev_bsd_set_in4,                              \
1530     netdev_bsd_get_addr_list,                        \
1531     NULL, /* add_router */                           \
1532     netdev_bsd_get_next_hop,                         \
1533     NULL, /* get_status */                           \
1534     netdev_bsd_arp_lookup, /* arp_lookup */          \
1535                                                      \
1536     netdev_bsd_update_flags,                         \
1537     NULL, /* reconfigure */                          \
1538                                                      \
1539     netdev_bsd_rxq_alloc,                            \
1540     netdev_bsd_rxq_construct,                        \
1541     netdev_bsd_rxq_destruct,                         \
1542     netdev_bsd_rxq_dealloc,                          \
1543     netdev_bsd_rxq_recv,                             \
1544     netdev_bsd_rxq_wait,                             \
1545     netdev_bsd_rxq_drain,                            \
1546 }
1547
1548 const struct netdev_class netdev_bsd_class =
1549     NETDEV_BSD_CLASS(
1550         "system",
1551         netdev_bsd_construct_system,
1552         netdev_bsd_get_features);
1553
1554 const struct netdev_class netdev_tap_class =
1555     NETDEV_BSD_CLASS(
1556         "tap",
1557         netdev_bsd_construct_tap,
1558         netdev_bsd_get_features);
1559 \f
1560
1561 static void
1562 destroy_tap(int fd, const char *name)
1563 {
1564     struct ifreq ifr;
1565
1566     close(fd);
1567     strcpy(ifr.ifr_name, name);
1568     /* XXX What to do if this call fails? */
1569     af_inet_ioctl(SIOCIFDESTROY, &ifr);
1570 }
1571
1572 static int
1573 get_flags(const struct netdev *netdev, int *flags)
1574 {
1575     struct ifreq ifr;
1576     int error;
1577
1578     error = af_inet_ifreq_ioctl(netdev_get_kernel_name(netdev), &ifr,
1579                                 SIOCGIFFLAGS, "SIOCGIFFLAGS");
1580
1581     *flags = ifr_get_flags(&ifr);
1582
1583     return error;
1584 }
1585
1586 static int
1587 set_flags(const char *name, int flags)
1588 {
1589     struct ifreq ifr;
1590
1591     ifr_set_flags(&ifr, flags);
1592
1593     return af_inet_ifreq_ioctl(name, &ifr, SIOCSIFFLAGS, "SIOCSIFFLAGS");
1594 }
1595
1596 static int
1597 get_ifindex(const struct netdev *netdev_, int *ifindexp)
1598 {
1599     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
1600     *ifindexp = 0;
1601     if (!(netdev->cache_valid & VALID_IFINDEX)) {
1602         int ifindex = if_nametoindex(netdev_get_name(netdev_));
1603         if (ifindex <= 0) {
1604             return errno;
1605         }
1606         netdev->cache_valid |= VALID_IFINDEX;
1607         netdev->ifindex = ifindex;
1608     }
1609     *ifindexp = netdev->ifindex;
1610     return 0;
1611 }
1612
1613 static int
1614 get_etheraddr(const char *netdev_name, struct eth_addr *ea)
1615 {
1616     struct ifaddrs *head;
1617     struct ifaddrs *ifa;
1618     struct sockaddr_dl *sdl;
1619
1620     if (getifaddrs(&head) != 0) {
1621         VLOG_ERR("getifaddrs on %s device failed: %s", netdev_name,
1622                 ovs_strerror(errno));
1623         return errno;
1624     }
1625
1626     for (ifa = head; ifa; ifa = ifa->ifa_next) {
1627         if (ifa->ifa_addr->sa_family == AF_LINK) {
1628             if (!strcmp(ifa->ifa_name, netdev_name)) {
1629                 sdl = ALIGNED_CAST(struct sockaddr_dl *, ifa->ifa_addr);
1630                 if (sdl) {
1631                     memcpy(ea, LLADDR(sdl), sdl->sdl_alen);
1632                     freeifaddrs(head);
1633                     return 0;
1634                 }
1635             }
1636         }
1637     }
1638
1639     VLOG_ERR("could not find ethernet address for %s device", netdev_name);
1640     freeifaddrs(head);
1641     return ENODEV;
1642 }
1643
1644 static int
1645 set_etheraddr(const char *netdev_name OVS_UNUSED, int hwaddr_family OVS_UNUSED,
1646               int hwaddr_len OVS_UNUSED,
1647               const struct eth_addr mac OVS_UNUSED)
1648 {
1649 #if defined(__FreeBSD__)
1650     struct ifreq ifr;
1651     int error;
1652
1653     memset(&ifr, 0, sizeof ifr);
1654     ovs_strlcpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
1655     ifr.ifr_addr.sa_family = hwaddr_family;
1656     ifr.ifr_addr.sa_len = hwaddr_len;
1657     memcpy(ifr.ifr_addr.sa_data, &mac, hwaddr_len);
1658     error = af_inet_ioctl(SIOCSIFLLADDR, &ifr);
1659     if (error) {
1660         VLOG_ERR("ioctl(SIOCSIFLLADDR) on %s device failed: %s",
1661                  netdev_name, ovs_strerror(error));
1662         return error;
1663     }
1664     return 0;
1665 #elif defined(__NetBSD__)
1666     struct if_laddrreq req;
1667     struct sockaddr_dl *sdl;
1668     struct sockaddr_storage oldaddr;
1669     int error;
1670
1671     /*
1672      * get the old address, add new one, and then remove old one.
1673      */
1674
1675     if (hwaddr_len != ETH_ADDR_LEN) {
1676         /* just to be safe about sockaddr storage size */
1677         return EOPNOTSUPP;
1678     }
1679     memset(&req, 0, sizeof(req));
1680     ovs_strlcpy(req.iflr_name, netdev_name, sizeof(req.iflr_name));
1681     req.addr.ss_len = sizeof(req.addr);
1682     req.addr.ss_family = hwaddr_family;
1683     sdl = (struct sockaddr_dl *)&req.addr;
1684     sdl->sdl_alen = hwaddr_len;
1685
1686     error = af_link_ioctl(SIOCGLIFADDR, &req);
1687     if (error) {
1688         return error;
1689     }
1690     if (!memcmp(&sdl->sdl_data[sdl->sdl_nlen], &mac, hwaddr_len)) {
1691         return 0;
1692     }
1693     oldaddr = req.addr;
1694
1695     memset(&req, 0, sizeof(req));
1696     ovs_strlcpy(req.iflr_name, netdev_name, sizeof(req.iflr_name));
1697     req.flags = IFLR_ACTIVE;
1698     sdl = (struct sockaddr_dl *)&req.addr;
1699     sdl->sdl_len = offsetof(struct sockaddr_dl, sdl_data) + hwaddr_len;
1700     sdl->sdl_alen = hwaddr_len;
1701     sdl->sdl_family = hwaddr_family;
1702     memcpy(sdl->sdl_data, &mac, hwaddr_len);
1703     error = af_link_ioctl(SIOCALIFADDR, &req);
1704     if (error) {
1705         return error;
1706     }
1707
1708     memset(&req, 0, sizeof(req));
1709     ovs_strlcpy(req.iflr_name, netdev_name, sizeof(req.iflr_name));
1710     req.addr = oldaddr;
1711     return af_link_ioctl(SIOCDLIFADDR, &req);
1712 #else
1713 #error not implemented
1714 #endif
1715 }
1716
1717 static int
1718 ifr_get_flags(const struct ifreq *ifr)
1719 {
1720 #ifdef HAVE_STRUCT_IFREQ_IFR_FLAGSHIGH
1721     return (ifr->ifr_flagshigh << 16) | (ifr->ifr_flags & 0xffff);
1722 #else
1723     return ifr->ifr_flags;
1724 #endif
1725 }
1726
1727 static void
1728 ifr_set_flags(struct ifreq *ifr, int flags)
1729 {
1730 #ifdef HAVE_STRUCT_IFREQ_IFR_FLAGSHIGH
1731     ifr->ifr_flags = flags & 0xffff;
1732     ifr->ifr_flagshigh = flags >> 16;
1733 #else
1734     ifr->ifr_flags = flags;
1735 #endif
1736 }
1737
1738 #if defined(__NetBSD__)
1739 /* Calls ioctl() on an AF_LINK sock, passing the specified 'command' and
1740  * 'arg'.  Returns 0 if successful, otherwise a positive errno value. */
1741 int
1742 af_link_ioctl(unsigned long command, const void *arg)
1743 {
1744     static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
1745     static int sock;
1746
1747     if (ovsthread_once_start(&once)) {
1748         sock = socket(AF_LINK, SOCK_DGRAM, 0);
1749         if (sock < 0) {
1750             sock = -errno;
1751             VLOG_ERR("failed to create link socket: %s", ovs_strerror(errno));
1752         }
1753         ovsthread_once_done(&once);
1754     }
1755
1756     return (sock < 0 ? -sock
1757             : ioctl(sock, command, arg) == -1 ? errno
1758             : 0);
1759 }
1760 #endif
1761 #endif /* !defined(__MACH__) */