lib/netdev-bsd.c

   1 /*
   2  * Copyright (c) 2011 Gaetano Catalli.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18
  19 #include <stdlib.h>
  20 #include <config.h>
  21 #include <assert.h>
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <sys/types.h>
  25 #include <sys/time.h>
  26 #include <sys/ioctl.h>
  27 #include <sys/socket.h>
  28 #include <sys/sockio.h>
  29 #include <ifaddrs.h>
  30 #include <pcap/pcap.h>
  31 #include <net/if.h>
  32 #include <net/if_dl.h>
  33 #include <net/if_media.h>
  34 #include <net/if_tap.h>
  35 #include <netinet/in.h>
  36 #include <net/if_mib.h>
  37 #include <poll.h>
  38 #include <string.h>
  39 #include <unistd.h>
  40 #include <sys/sysctl.h>
  41
  42 #include "rtbsd.h"
  43 #include "coverage.h"
  44 #include "dynamic-string.h"
  45 #include "fatal-signal.h"
  46 #include "netdev-provider.h"
  47 #include "ofpbuf.h"
  48 #include "openflow/openflow.h"
  49 #include "packets.h"
  50 #include "poll-loop.h"
  51 #include "socket-util.h"
  52 #include "shash.h"
  53 #include "svec.h"
  54 #include "vlog.h"
  55
  56 VLOG_DEFINE_THIS_MODULE(netdev_bsd);
  57
  58 \f
  59 /*
  60  * This file implements objects to access interfaces.
  61  * Externally, interfaces are represented by two structures:
  62  *   + struct netdev_dev, representing a network device,
  63  *     containing e.g. name and a refcount;
  64  *     We can have private variables by embedding the
  65  *     struct netdev_dev into our own structure
  66  *     (e.g. netdev_dev_bsd)
  67  *
  68  *   + struct netdev, representing an instance of an open netdev_dev.
  69  *     The structure contains a pointer to the 'struct netdev'
  70  *     representing the device. Again, private information
  71  *     such as file descriptor etc. are stored in our
  72  *     own struct netdev_bsd which includes a struct netdev.
  73  *
  74  * Both 'struct netdev' and 'struct netdev_dev' are referenced
  75  * in containers which hold pointers to the data structures.
  76  * We can reach our own struct netdev_XXX_bsd by putting a
  77  * struct netdev_XXX within our own struct, and using CONTAINER_OF
  78  * to access the parent structure.
  79  */
  80 struct netdev_bsd {
  81     struct netdev netdev;
  82
  83     int netdev_fd;   /* Selectable file descriptor for the network device.
  84                         This descriptor will be used for polling operations */
  85
  86     pcap_t *pcap_handle;  /* Packet capture descriptor for a system network
  87                              device */
  88 };
  89
  90 struct netdev_dev_bsd {
  91     struct netdev_dev netdev_dev;
  92     unsigned int cache_valid;
  93     unsigned int change_seq;
  94
  95     int ifindex;
  96     uint8_t etheraddr[ETH_ADDR_LEN];
  97     struct in_addr in4;
  98     struct in6_addr in6;
  99     int mtu;
 100     int carrier;
 101
 102     bool tap_opened;
 103     int tap_fd;         /* TAP character device, if any */
 104 };
 105
 106
 107 enum {
 108     VALID_IFINDEX = 1 << 0,
 109     VALID_ETHERADDR = 1 << 1,
 110     VALID_IN4 = 1 << 2,
 111     VALID_IN6 = 1 << 3,
 112     VALID_MTU = 1 << 4,
 113     VALID_CARRIER = 1 << 5
 114 };
 115
 116 /* An AF_INET socket (used for ioctl operations). */
 117 static int af_inet_sock = -1;
 118
 119 #define PCAP_SNAPLEN 2048
 120
 121
 122 /*
 123  * Notifier used to invalidate device informations in case of status change.
 124  *
 125  * It will be registered with a 'rtbsd_notifier_register()' when the first
 126  * device will be created with the call of either 'netdev_bsd_tap_create()' or
 127  * 'netdev_bsd_system_create()'.
 128  *
 129  * The callback associated with this notifier ('netdev_bsd_cache_cb()') will
 130  * invalidate cached information about the device.
 131  */
 132 static struct rtbsd_notifier netdev_bsd_cache_notifier;
 133 static int cache_notifier_refcount;
 134
 135 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
 136
 137 static int netdev_bsd_do_ioctl(const struct netdev *, struct ifreq *,
 138                                  unsigned long cmd, const char *cmd_name);
 139 static void destroy_tap(int fd, const char *name);
 140 static int get_flags(const struct netdev *, int *flagsp);
 141 static int set_flags(struct netdev *, int flags);
 142 static int do_set_addr(struct netdev *netdev,
 143                        int ioctl_nr, const char *ioctl_name,
 144                        struct in_addr addr);
 145 static int get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN]);
 146 static int set_etheraddr(const char *netdev_name, int hwaddr_family,
 147                          int hwaddr_len, const uint8_t[ETH_ADDR_LEN]);
 148 static int get_ifindex(const struct netdev *, int *ifindexp);
 149
 150 static int netdev_bsd_init(void);
 151
 152 static bool
 153 is_netdev_bsd_class(const struct netdev_class *netdev_class)
 154 {
 155     return netdev_class->init == netdev_bsd_init;
 156 }
 157
 158 static struct netdev_bsd *
 159 netdev_bsd_cast(const struct netdev *netdev)
 160 {
 161     assert(is_netdev_bsd_class(netdev_dev_get_class(netdev_get_dev(netdev))));
 162     return CONTAINER_OF(netdev, struct netdev_bsd, netdev);
 163 }
 164
 165 static struct netdev_dev_bsd *
 166 netdev_dev_bsd_cast(const struct netdev_dev *netdev_dev)
 167 {
 168     assert(is_netdev_bsd_class(netdev_dev_get_class(netdev_dev)));
 169     return CONTAINER_OF(netdev_dev, struct netdev_dev_bsd, netdev_dev);
 170 }
 171
 172 /* Initialize the AF_INET socket used for ioctl operations */
 173 static int
 174 netdev_bsd_init(void)
 175 {
 176     static int status = -1;
 177
 178     if (status >= 0) {  /* already initialized */
 179         return status;
 180     }
 181
 182     af_inet_sock = socket(AF_INET, SOCK_DGRAM, 0);
 183     status = af_inet_sock >= 0 ? 0 : errno;
 184
 185     if (status) {
 186         VLOG_ERR("failed to create inet socket: %s", strerror(status));
 187     }
 188
 189     return status;
 190 }
 191
 192 /*
 193  * Perform periodic work needed by netdev. In BSD netdevs it checks for any
 194  * interface status changes, and eventually calls all the user callbacks.
 195  */
 196 static void
 197 netdev_bsd_run(void)
 198 {
 199     rtbsd_notifier_run();
 200 }
 201
 202 /*
 203  * Arranges for poll_block() to wake up if the "run" member function needs to
 204  * be called.
 205  */
 206 static void
 207 netdev_bsd_wait(void)
 208 {
 209     rtbsd_notifier_wait();
 210 }
 211
 212 static void
 213 netdev_dev_bsd_changed(struct netdev_dev_bsd *dev)
 214 {
 215     dev->change_seq++;
 216     if (!dev->change_seq) {
 217         dev->change_seq++;
 218     }
 219 }
 220
 221 /* Invalidate cache in case of interface status change. */
 222 static void
 223 netdev_bsd_cache_cb(const struct rtbsd_change *change,
 224                       void *aux OVS_UNUSED)
 225 {
 226     struct netdev_dev_bsd *dev;
 227
 228     if (change) {
 229         struct netdev_dev *base_dev = netdev_dev_from_name(change->if_name);
 230
 231         if (base_dev) {
 232             const struct netdev_class *netdev_class =
 233                                                 netdev_dev_get_class(base_dev);
 234
 235             if (is_netdev_bsd_class(netdev_class)) {
 236                 dev = netdev_dev_bsd_cast(base_dev);
 237                 dev->cache_valid = 0;
 238                 netdev_dev_bsd_changed(dev);
 239             }
 240         }
 241     } else {
 242         /*
 243          * XXX the API is lacking, we should be able to iterate on the list of
 244          * netdevs without having to store the info in a temp shash.
 245          */
 246         struct shash device_shash;
 247         struct shash_node *node;
 248
 249         shash_init(&device_shash);
 250         netdev_dev_get_devices(&netdev_bsd_class, &device_shash);
 251         SHASH_FOR_EACH (node, &device_shash) {
 252             dev = node->data;
 253             dev->cache_valid = 0;
 254             netdev_dev_bsd_changed(dev);
 255         }
 256         shash_destroy(&device_shash);
 257     }
 258 }
 259
 260 static int
 261 cache_notifier_ref(void)
 262 {
 263     int ret = 0;
 264
 265     if (!cache_notifier_refcount) {
 266         ret = rtbsd_notifier_register(&netdev_bsd_cache_notifier,
 267                                                 netdev_bsd_cache_cb, NULL);
 268         if (ret) {
 269             return ret;
 270         }
 271     }
 272     cache_notifier_refcount++;
 273     return 0;
 274 }
 275
 276 static int
 277 cache_notifier_unref(void)
 278 {
 279     cache_notifier_refcount--;
 280     if (cache_notifier_refcount == 0) {
 281         rtbsd_notifier_unregister(&netdev_bsd_cache_notifier);
 282     }
 283     return 0;
 284 }
 285
 286 /* Allocate a netdev_dev_bsd structure */
 287 static int
 288 netdev_bsd_create_system(const struct netdev_class *class, const char *name,
 289                   struct netdev_dev **netdev_devp)
 290 {
 291     struct netdev_dev_bsd *netdev_dev;
 292     int error;
 293
 294     error = cache_notifier_ref();
 295     if (error) {
 296         return error;
 297     }
 298
 299     netdev_dev = xzalloc(sizeof *netdev_dev);
 300     netdev_dev->change_seq = 1;
 301     netdev_dev_init(&netdev_dev->netdev_dev, name, class);
 302     *netdev_devp = &netdev_dev->netdev_dev;
 303
 304     return 0;
 305 }
 306
 307 /*
 308  * Allocate a netdev_dev_bsd structure with 'tap' class.
 309  */
 310 static int
 311 netdev_bsd_create_tap(const struct netdev_class *class, const char *name,
 312                   struct netdev_dev **netdev_devp)
 313 {
 314     struct netdev_dev_bsd *netdev_dev = NULL;
 315     int error = 0;
 316     struct ifreq ifr;
 317
 318     error = cache_notifier_ref();
 319     if (error) {
 320         goto error;
 321     }
 322
 323     /* allocate the device structure and set the internal flag */
 324     netdev_dev = xzalloc(sizeof *netdev_dev);
 325
 326     memset(&ifr, 0, sizeof(ifr));
 327
 328     /* Create a tap device by opening /dev/tap.  The TAPGIFNAME ioctl is used
 329      * to retrieve the name of the tap device. */
 330     netdev_dev->tap_fd = open("/dev/tap", O_RDWR);
 331     netdev_dev->change_seq = 1;
 332     if (netdev_dev->tap_fd < 0) {
 333         error = errno;
 334         VLOG_WARN("opening \"/dev/tap\" failed: %s", strerror(error));
 335         goto error_undef_notifier;
 336     }
 337
 338     /* Retrieve tap name (e.g. tap0) */
 339     if (ioctl(netdev_dev->tap_fd, TAPGIFNAME, &ifr) == -1) {
 340         /* XXX Need to destroy the device? */
 341         error = errno;
 342         goto error_undef_notifier;
 343     }
 344
 345     /* Change the name of the tap device */
 346     ifr.ifr_data = (void *)name;
 347     if (ioctl(af_inet_sock, SIOCSIFNAME, &ifr) == -1) {
 348         error = errno;
 349         destroy_tap(netdev_dev->tap_fd, ifr.ifr_name);
 350         goto error_undef_notifier;
 351     }
 352
 353     /* set non-blocking. */
 354     error = set_nonblocking(netdev_dev->tap_fd);
 355     if (error) {
 356         destroy_tap(netdev_dev->tap_fd, name);
 357         goto error_undef_notifier;
 358     }
 359
 360     /* Turn device UP */
 361     ifr.ifr_flags = (uint16_t)IFF_UP;
 362     ifr.ifr_flagshigh = 0;
 363     strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
 364     if (ioctl(af_inet_sock, SIOCSIFFLAGS, &ifr) == -1) {
 365         error = errno;
 366         destroy_tap(netdev_dev->tap_fd, name);
 367         goto error_undef_notifier;
 368     }
 369
 370     /* initialize the device structure and
 371      * link the structure to its netdev */
 372     netdev_dev_init(&netdev_dev->netdev_dev, name, class);
 373     *netdev_devp = &netdev_dev->netdev_dev;
 374
 375     return 0;
 376
 377 error_undef_notifier:
 378     cache_notifier_unref();
 379 error:
 380     free(netdev_dev);
 381     return error;
 382 }
 383
 384 static void
 385 netdev_bsd_destroy(struct netdev_dev *netdev_dev_)
 386 {
 387     struct netdev_dev_bsd *netdev_dev = netdev_dev_bsd_cast(netdev_dev_);
 388
 389     cache_notifier_unref();
 390
 391     if (netdev_dev->tap_fd >= 0 &&
 392             !strcmp(netdev_dev_get_type(netdev_dev_), "tap")) {
 393         destroy_tap(netdev_dev->tap_fd, netdev_dev_get_name(netdev_dev_));
 394     }
 395     free(netdev_dev);
 396 }
 397
 398
 399 static int
 400 netdev_bsd_open_system(struct netdev_dev *netdev_dev_, struct netdev **netdevp)
 401 {
 402     struct netdev_dev_bsd *netdev_dev = netdev_dev_bsd_cast(netdev_dev_);
 403     struct netdev_bsd *netdev;
 404     int error;
 405     enum netdev_flags flags;
 406
 407     /* Allocate network device. */
 408     netdev = xcalloc(1, sizeof *netdev);
 409     netdev->netdev_fd = -1;
 410     netdev_init(&netdev->netdev, netdev_dev_);
 411
 412     /* Verify that the netdev really exists by attempting to read its flags */
 413     error = netdev_get_flags(&netdev->netdev, &flags);
 414     if (error == ENXIO) {
 415         goto error;
 416     }
 417
 418     /* The first user that opens a tap port(from dpif_create_and_open()) will
 419      * receive the file descriptor associated with the tap device. Instead, the
 420      * following users will open the tap device as a normal 'system' device. */
 421     if (!strcmp(netdev_dev_get_type(netdev_dev_), "tap") &&
 422             !netdev_dev->tap_opened) {
 423         netdev_dev->tap_opened = true;
 424         netdev->netdev_fd = netdev_dev->tap_fd;
 425     }
 426
 427     *netdevp = &netdev->netdev;
 428     return 0;
 429
 430 error:
 431     netdev_uninit(&netdev->netdev, true);
 432     return error;
 433 }
 434
 435
 436
 437 /* Close a 'netdev'. */
 438 static void
 439 netdev_bsd_close(struct netdev *netdev_)
 440 {
 441     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 442
 443     if (netdev->netdev_fd >= 0 && strcmp(netdev_get_type(netdev_), "tap")) {
 444         pcap_close(netdev->pcap_handle);
 445     }
 446
 447     free(netdev);
 448 }
 449
 450 static int
 451 netdev_bsd_listen(struct netdev *netdev_)
 452 {
 453     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 454     char errbuf[PCAP_ERRBUF_SIZE];
 455     int error;
 456     int fd;
 457     int one = 1;
 458
 459     if (netdev->netdev_fd >= 0) {
 460         return 0;
 461     }
 462
 463     /* open the pcap device. The device is opened in non-promiscuous mode
 464      * because the interface flags are manually set by the caller. */
 465     errbuf[0] = '\0';
 466     netdev->pcap_handle = pcap_open_live(netdev_get_name(netdev_), PCAP_SNAPLEN,
 467                                      0, 1000, errbuf);
 468     if (netdev->pcap_handle == NULL) {
 469         VLOG_ERR("%s: pcap_open_live failed: %s",
 470                 netdev_get_name(netdev_), errbuf);
 471         error = EIO;
 472         goto error;
 473     } else if (errbuf[0] !=  '\0') {
 474         VLOG_WARN("%s: pcap_open_live: %s",
 475                 netdev_get_name(netdev_), errbuf);
 476     }
 477
 478     netdev_dev_bsd_changed(netdev_dev_bsd_cast(netdev_get_dev(netdev_)));
 479
 480     /* initialize netdev->netdev_fd */
 481     fd = pcap_get_selectable_fd(netdev->pcap_handle);
 482     if (fd == -1) {
 483         error = errno;
 484         goto error;
 485     }
 486
 487     /* Set non-blocking mode. Also the BIOCIMMEDIATE ioctl must be called
 488      * on the file descriptor returned by pcap_get_selectable_fd to achieve
 489      * a real non-blocking behaviour.*/
 490     error = pcap_setnonblock(netdev->pcap_handle, 1, errbuf);
 491     if (error == -1) {
 492         error = errno;
 493         goto error;
 494     }
 495
 496     /* This call assure that reads return immediately upon packet reception.
 497      * Otherwise, a read will block until either the kernel buffer becomes
 498      * full or a timeout occurs. */
 499     if(ioctl(fd, BIOCIMMEDIATE, &one) < 0 ) {
 500         VLOG_ERR("ioctl(BIOCIMMEDIATE) on %s device failed: %s",
 501                 netdev_get_name(netdev_), strerror(errno));
 502         error = errno;
 503         goto error;
 504     }
 505
 506     /* Capture only incoming packets */
 507     error = pcap_setdirection(netdev->pcap_handle, PCAP_D_IN);
 508     if (error == -1) {
 509         error = errno;
 510         goto error;
 511     }
 512
 513     netdev->netdev_fd = fd;
 514     return 0;
 515
 516 error:
 517     if (fd >= 0) {
 518         close(netdev->netdev_fd);
 519     }
 520     return error;
 521 }
 522
 523
 524 /* The recv callback of the netdev class returns the number of bytes of the
 525  * received packet.
 526  *
 527  * This can be done by the pcap_next() function. Unfortunately pcap_next() does
 528  * not make difference between a missing packet on the capture interface and
 529  * an error during the file capture.  We can use the pcap_dispatch() function
 530  * instead, which is able to distinguish between errors and null packet.
 531  *
 532  * To make pcap_dispatch() returns the number of bytes read from the interface
 533  * we need to define the following callback and argument.
 534  */
 535 struct pcap_arg {
 536     void *data;
 537     int size;
 538     int retval;
 539 };
 540
 541 /*
 542  * This callback will be executed on every captured packet.
 543  *
 544  * If the packet captured by pcap_dispatch() does not fit the pcap buffer,
 545  * pcap returns a truncated packet and we follow this behavior.
 546  *
 547  * The argument args->retval is the packet size in bytes.
 548  */
 549 static void
 550 proc_pkt(u_char *args_, const struct pcap_pkthdr *hdr, const u_char *packet)
 551 {
 552     struct pcap_arg *args = (struct pcap_arg *)args_;
 553
 554     if (args->size < hdr->len) {
 555         VLOG_WARN_RL(&rl, "packet truncated");
 556         args->retval = args->size;
 557     } else {
 558         args->retval = hdr->len;
 559     }
 560
 561     /* copy the packet to our buffer */
 562     memcpy(args->data, packet, args->retval);
 563 }
 564
 565 /*
 566  * This function attempts to receive a packet from the specified network
 567  * device. It is assumed that the network device is a system device or a tap
 568  * device opened as a system one. In this case the read operation is performed
 569  * on the 'netdev' pcap descriptor.
 570  */
 571 static int
 572 netdev_bsd_recv_system(struct netdev_bsd *netdev, void *data, size_t size)
 573 {
 574     struct pcap_arg arg;
 575     int ret;
 576
 577     if (netdev->netdev_fd < 0) {
 578         return -EAGAIN;
 579     }
 580
 581     /* prepare the pcap argument to store the packet */
 582     arg.size = size;
 583     arg.data = data;
 584
 585     for (;;) {
 586         ret = pcap_dispatch(netdev->pcap_handle, 1, proc_pkt, (u_char *)&arg);
 587
 588         if (ret > 0) {
 589             return arg.retval;  /* arg.retval < 0 is handled in the caller */
 590         }
 591         if (ret == -1) {
 592             if (errno == EINTR) {
 593                  continue;
 594             }
 595         }
 596
 597         return -EAGAIN;
 598     }
 599 }
 600
 601 /*
 602  * This function attempts to receive a packet from the specified network
 603  * device. It is assumed that the network device is a tap device and the
 604  * 'netdev_fd' member of the 'netdev' structure is initialized with the tap
 605  * file descriptor.
 606  */
 607 static int
 608 netdev_bsd_recv_tap(struct netdev_bsd *netdev, void *data, size_t size)
 609 {
 610     if (netdev->netdev_fd < 0) {
 611         return -EAGAIN;
 612     }
 613
 614     for (;;) {
 615         ssize_t retval = read(netdev->netdev_fd, data, size);
 616         if (retval >= 0) {
 617             return retval;
 618         } else if (errno != EINTR) {
 619             if (errno != EAGAIN) {
 620                 VLOG_WARN_RL(&rl, "error receiving Ethernet packet on %s: %s",
 621                              strerror(errno), netdev->netdev.netdev_dev->name);
 622             }
 623             return -errno;
 624         }
 625     }
 626 }
 627
 628
 629 /*
 630  * According with the nature of the device a different function must be called.
 631  * If the device is the bridge local port the 'netdev_bsd_recv_tap' function
 632  * must be called, otherwise the 'netdev_bsd_recv_system' function is called.
 633  *
 634  * type!="tap"                                        --->  system device.
 635  * type=="tap" && netdev_fd == tap_fd                 --->  internal tap device
 636  * type=="tap" && netdev_fd != tap_fd                 --->  internal tap device
 637  *                                                          opened as a system
 638  *                                                          device.
 639  */
 640 static int
 641 netdev_bsd_recv(struct netdev *netdev_, void* data, size_t size)
 642 {
 643     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 644     struct netdev_dev_bsd * netdev_dev =
 645         netdev_dev_bsd_cast(netdev_get_dev(netdev_));
 646
 647     if (!strcmp(netdev_get_type(netdev_), "tap") &&
 648             netdev->netdev_fd == netdev_dev->tap_fd) {
 649         return netdev_bsd_recv_tap(netdev, data, size);
 650     } else {
 651         return netdev_bsd_recv_system(netdev, data, size);
 652     }
 653 }
 654
 655
 656 /*
 657  * Registers with the poll loop to wake up from the next call to poll_block()
 658  * when a packet is ready to be received with netdev_recv() on 'netdev'.
 659  */
 660 static void
 661 netdev_bsd_recv_wait(struct netdev *netdev_)
 662 {
 663     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 664
 665     if (netdev->netdev_fd >= 0) {
 666         poll_fd_wait(netdev->netdev_fd, POLLIN);
 667     }
 668 }
 669
 670 /* Discards all packets waiting to be received from 'netdev'. */
 671 static int
 672 netdev_bsd_drain(struct netdev *netdev_)
 673 {
 674     struct ifreq ifr;
 675     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 676
 677     strcpy(ifr.ifr_name, netdev_get_name(netdev_));
 678     if (ioctl(netdev->netdev_fd, BIOCFLUSH, &ifr) == -1) {
 679         VLOG_DBG_RL(&rl, "%s: ioctl(BIOCFLUSH) failed: %s",
 680                     netdev_get_name(netdev_), strerror(errno));
 681         return errno;
 682     }
 683     return 0;
 684 }
 685
 686 /*
 687  * Send a packet on the specified network device. The device could be either a
 688  * system or a tap device.
 689  */
 690 static int
 691 netdev_bsd_send(struct netdev *netdev_, const void *data, size_t size)
 692 {
 693     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 694     struct netdev_dev_bsd * netdev_dev =
 695         netdev_dev_bsd_cast(netdev_get_dev(netdev_));
 696
 697     if (netdev->netdev_fd < 0) {
 698         return EPIPE;
 699     }
 700
 701     for (;;) {
 702         ssize_t retval;
 703         if (!strcmp(netdev_get_type(netdev_), "tap") &&
 704                 netdev_dev->tap_fd == netdev->netdev_fd) {
 705             retval = write(netdev->netdev_fd, data, size);
 706         } else {
 707             retval = pcap_inject(netdev->pcap_handle, data, size);
 708         }
 709         if (retval < 0) {
 710             if (errno == EINTR) {
 711                 continue;
 712             } else if (errno != EAGAIN) {
 713                 VLOG_WARN_RL(&rl, "error sending Ethernet packet on %s: %s",
 714                              netdev_get_name(netdev_), strerror(errno));
 715             }
 716             return errno;
 717         } else if (retval != size) {
 718             VLOG_WARN_RL(&rl, "sent partial Ethernet packet (%zd bytes of "
 719                          "%zu) on %s", retval, size,
 720                          netdev_get_name(netdev_));
 721            return EMSGSIZE;
 722         } else {
 723             return 0;
 724         }
 725     }
 726 }
 727
 728 /*
 729  * Registers with the poll loop to wake up from the next call to poll_block()
 730  * when the packet transmission queue has sufficient room to transmit a packet
 731  * with netdev_send().
 732  */
 733 static void
 734 netdev_bsd_send_wait(struct netdev *netdev_)
 735 {
 736     struct netdev_bsd *netdev = netdev_bsd_cast(netdev_);
 737
 738     if (netdev->netdev_fd < 0) { /* Nothing to do. */
 739         return;
 740     }
 741
 742     if (strcmp(netdev_get_type(netdev_), "tap")) {
 743         poll_fd_wait(netdev->netdev_fd, POLLOUT);
 744     } else {
 745         /* TAP device always accepts packets. */
 746         poll_immediate_wake();
 747     }
 748 }
 749
 750 /*
 751  * Attempts to set 'netdev''s MAC address to 'mac'.  Returns 0 if successful,
 752  * otherwise a positive errno value.
 753  */
 754 static int
 755 netdev_bsd_set_etheraddr(struct netdev *netdev_,
 756                            const uint8_t mac[ETH_ADDR_LEN])
 757 {
 758     struct netdev_dev_bsd *netdev_dev =
 759                                 netdev_dev_bsd_cast(netdev_get_dev(netdev_));
 760     int error;
 761
 762     if (!(netdev_dev->cache_valid & VALID_ETHERADDR)
 763         || !eth_addr_equals(netdev_dev->etheraddr, mac)) {
 764         error = set_etheraddr(netdev_get_name(netdev_), AF_LINK, ETH_ADDR_LEN,
 765                               mac);
 766         if (!error) {
 767             netdev_dev->cache_valid |= VALID_ETHERADDR;
 768             memcpy(netdev_dev->etheraddr, mac, ETH_ADDR_LEN);
 769             netdev_dev_bsd_changed(netdev_dev);
 770         }
 771     } else {
 772         error = 0;
 773     }
 774     return error;
 775 }
 776
 777 /*
 778  * Returns a pointer to 'netdev''s MAC address.  The caller must not modify or
 779  * free the returned buffer.
 780  */
 781 static int
 782 netdev_bsd_get_etheraddr(const struct netdev *netdev_,
 783                            uint8_t mac[ETH_ADDR_LEN])
 784 {
 785     struct netdev_dev_bsd *netdev_dev =
 786         netdev_dev_bsd_cast(netdev_get_dev(netdev_));
 787
 788     if (!(netdev_dev->cache_valid & VALID_ETHERADDR)) {
 789         int error = get_etheraddr(netdev_get_name(netdev_),
 790                                   netdev_dev->etheraddr);
 791         if (error) {
 792             return error;
 793         }
 794         netdev_dev->cache_valid |= VALID_ETHERADDR;
 795     }
 796     memcpy(mac, netdev_dev->etheraddr, ETH_ADDR_LEN);
 797
 798     return 0;
 799 }
 800
 801 /*
 802  * Returns the maximum size of transmitted (and received) packets on 'netdev',
 803  * in bytes, not including the hardware header; thus, this is typically 1500
 804  * bytes for Ethernet devices.
 805  */
 806 static int
 807 netdev_bsd_get_mtu(const struct netdev *netdev_, int *mtup)
 808 {
 809     struct netdev_dev_bsd *netdev_dev =
 810         netdev_dev_bsd_cast(netdev_get_dev(netdev_));
 811
 812     if (!(netdev_dev->cache_valid & VALID_MTU)) {
 813         struct ifreq ifr;
 814         int error;
 815
 816         error = netdev_bsd_do_ioctl(netdev_, &ifr, SIOCGIFMTU, "SIOCGIFMTU");
 817         if (error) {
 818             return error;
 819         }
 820         netdev_dev->mtu = ifr.ifr_mtu;
 821         netdev_dev->cache_valid |= VALID_MTU;
 822     }
 823
 824     *mtup = netdev_dev->mtu;
 825     return 0;
 826 }
 827
 828 static int
 829 netdev_bsd_get_ifindex(const struct netdev *netdev)
 830 {
 831     int ifindex, error;
 832
 833     error = get_ifindex(netdev, &ifindex);
 834     return error ? -error : ifindex;
 835 }
 836
 837 static int
 838 netdev_bsd_get_carrier(const struct netdev *netdev_, bool *carrier)
 839 {
 840     struct netdev_dev_bsd *netdev_dev =
 841         netdev_dev_bsd_cast(netdev_get_dev(netdev_));
 842
 843     if (!(netdev_dev->cache_valid & VALID_CARRIER)) {
 844         struct ifmediareq ifmr;
 845
 846         memset(&ifmr, 0, sizeof(ifmr));
 847         strncpy(ifmr.ifm_name, netdev_get_name(netdev_), sizeof ifmr.ifm_name);
 848
 849         if (ioctl(af_inet_sock, SIOCGIFMEDIA, &ifmr) == -1) {
 850             VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFMEDIA) failed: %s",
 851                         netdev_get_name(netdev_), strerror(errno));
 852             return errno;
 853         }
 854
 855         netdev_dev->carrier = (ifmr.ifm_status & IFM_ACTIVE) == IFM_ACTIVE;
 856         netdev_dev->cache_valid |= VALID_CARRIER;
 857
 858         /* If the interface doesn't report whether the media is active,
 859          * just assume it is active. */
 860         if ((ifmr.ifm_status & IFM_AVALID) == 0) {
 861             netdev_dev->carrier = true;
 862         }
 863     }
 864     *carrier = netdev_dev->carrier;
 865
 866     return 0;
 867 }
 868
 869 /* Retrieves current device stats for 'netdev'. */
 870 static int
 871 netdev_bsd_get_stats(const struct netdev *netdev_, struct netdev_stats *stats)
 872 {
 873     int if_count, i;
 874     int mib[6];
 875     size_t len;
 876     struct ifmibdata ifmd;
 877
 878
 879     mib[0] = CTL_NET;
 880     mib[1] = PF_LINK;
 881     mib[2] = NETLINK_GENERIC;
 882     mib[3] = IFMIB_SYSTEM;
 883     mib[4] = IFMIB_IFCOUNT;
 884
 885     len = sizeof(if_count);
 886
 887     if (sysctl(mib, 5, &if_count, &len, (void *)0, 0) == -1) {
 888         VLOG_DBG_RL(&rl, "%s: sysctl failed: %s",
 889                     netdev_get_name(netdev_), strerror(errno));
 890         return errno;
 891     }
 892
 893     mib[5] = IFDATA_GENERAL;
 894     mib[3] = IFMIB_IFDATA;
 895     len = sizeof(ifmd);
 896     for (i = 1; i <= if_count; i++) {
 897         mib[4] = i; //row
 898         if (sysctl(mib, 6, &ifmd, &len, (void *)0, 0) == -1) {
 899             VLOG_DBG_RL(&rl, "%s: sysctl failed: %s",
 900                         netdev_get_name(netdev_), strerror(errno));
 901             return errno;
 902         } else if (!strcmp(ifmd.ifmd_name, netdev_get_name(netdev_))) {
 903             stats->rx_packets = ifmd.ifmd_data.ifi_ipackets;
 904             stats->tx_packets = ifmd.ifmd_data.ifi_opackets;
 905             stats->rx_bytes = ifmd.ifmd_data.ifi_ibytes;
 906             stats->tx_bytes = ifmd.ifmd_data.ifi_obytes;
 907             stats->rx_errors = ifmd.ifmd_data.ifi_ierrors;
 908             stats->tx_errors = ifmd.ifmd_data.ifi_oerrors;
 909             stats->rx_dropped = ifmd.ifmd_data.ifi_iqdrops;
 910             stats->tx_dropped = 0;
 911             stats->multicast = ifmd.ifmd_data.ifi_imcasts;
 912             stats->collisions = ifmd.ifmd_data.ifi_collisions;
 913
 914             stats->rx_length_errors = 0;
 915             stats->rx_over_errors = 0;
 916             stats->rx_crc_errors = 0;
 917             stats->rx_frame_errors = 0;
 918             stats->rx_fifo_errors = 0;
 919             stats->rx_missed_errors = 0;
 920
 921             stats->tx_aborted_errors = 0;
 922             stats->tx_carrier_errors = 0;
 923             stats->tx_fifo_errors = 0;
 924             stats->tx_heartbeat_errors = 0;
 925             stats->tx_window_errors = 0;
 926             break;
 927         }
 928     }
 929
 930     return 0;
 931 }
 932
 933 static uint32_t
 934 netdev_bsd_parse_media(int media)
 935 {
 936     uint32_t supported = 0;
 937     bool half_duplex = media & IFM_HDX ? true : false;
 938
 939     switch (IFM_SUBTYPE(media)) {
 940     case IFM_10_2:
 941     case IFM_10_5:
 942     case IFM_10_STP:
 943     case IFM_10_T:
 944         supported |= half_duplex ? NETDEV_F_10MB_HD : NETDEV_F_10MB_FD;
 945         supported |= NETDEV_F_COPPER;
 946         break;
 947
 948     case IFM_10_FL:
 949         supported |= half_duplex ? NETDEV_F_10MB_HD : NETDEV_F_10MB_FD;
 950         supported |= NETDEV_F_FIBER;
 951         break;
 952
 953     case IFM_100_T2:
 954     case IFM_100_T4:
 955     case IFM_100_TX:
 956     case IFM_100_VG:
 957         supported |= half_duplex ? NETDEV_F_100MB_HD : NETDEV_F_100MB_FD;
 958         supported |= NETDEV_F_COPPER;
 959         break;
 960
 961     case IFM_100_FX:
 962         supported |= half_duplex ? NETDEV_F_100MB_HD : NETDEV_F_100MB_FD;
 963         supported |= NETDEV_F_FIBER;
 964         break;
 965
 966     case IFM_1000_CX:
 967     case IFM_1000_T:
 968         supported |= half_duplex ? NETDEV_F_1GB_HD : NETDEV_F_1GB_FD;
 969         supported |= NETDEV_F_COPPER;
 970         break;
 971
 972     case IFM_1000_LX:
 973     case IFM_1000_SX:
 974         supported |= half_duplex ? NETDEV_F_1GB_HD : NETDEV_F_1GB_FD;
 975         supported |= NETDEV_F_FIBER;
 976         break;
 977
 978     case IFM_10G_CX4:
 979         supported |= NETDEV_F_10GB_FD;
 980         supported |= NETDEV_F_COPPER;
 981         break;
 982
 983     case IFM_10G_LR:
 984     case IFM_10G_SR:
 985         supported |= NETDEV_F_10GB_FD;
 986         supported |= NETDEV_F_FIBER;
 987         break;
 988
 989     default:
 990         return 0;
 991     }
 992
 993     if (IFM_SUBTYPE(media) == IFM_AUTO) {
 994         supported |= NETDEV_F_AUTONEG;
 995     }
 996     /*
 997     if (media & IFM_ETH_FMASK) {
 998         supported |= NETDEV_F_PAUSE;
 999     }
1000     */
1001
1002     return supported;
1003 }
1004
1005 /*
1006  * Stores the features supported by 'netdev' into each of '*current',
1007  * '*advertised', '*supported', and '*peer' that are non-null.  Each value is a
1008  * bitmap of "enum ofp_port_features" bits, in host byte order.  Returns 0 if
1009  * successful, otherwise a positive errno value.  On failure, all of the
1010  * passed-in values are set to 0.
1011  */
1012 static int
1013 netdev_bsd_get_features(const struct netdev *netdev,
1014                           enum netdev_features *current, uint32_t *advertised,
1015                           enum netdev_features *supported, uint32_t *peer)
1016 {
1017     struct ifmediareq ifmr;
1018     int *media_list;
1019     int i;
1020     int error;
1021
1022
1023     /* XXX Look into SIOCGIFCAP instead of SIOCGIFMEDIA */
1024
1025     memset(&ifmr, 0, sizeof(ifmr));
1026     strncpy(ifmr.ifm_name, netdev_get_name(netdev), sizeof ifmr.ifm_name);
1027
1028     /* We make two SIOCGIFMEDIA ioctl calls.  The first to determine the
1029      * number of supported modes, and a second with a buffer to retrieve
1030      * them. */
1031     if (ioctl(af_inet_sock, SIOCGIFMEDIA, &ifmr) == -1) {
1032         VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFMEDIA) failed: %s",
1033                     netdev_get_name(netdev), strerror(errno));
1034         return errno;
1035     }
1036
1037     media_list = xcalloc(ifmr.ifm_count, sizeof(int));
1038     ifmr.ifm_ulist = media_list;
1039
1040     if (!IFM_TYPE(ifmr.ifm_current) & IFM_ETHER) {
1041         VLOG_DBG_RL(&rl, "%s: doesn't appear to be ethernet",
1042                     netdev_get_name(netdev));
1043         error = EINVAL;
1044         goto cleanup;
1045     }
1046
1047     if (ioctl(af_inet_sock, SIOCGIFMEDIA, &ifmr) == -1) {
1048         VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFMEDIA) failed: %s",
1049                     netdev_get_name(netdev), strerror(errno));
1050         error = errno;
1051         goto cleanup;
1052     }
1053
1054     /* Current settings. */
1055     *current = netdev_bsd_parse_media(ifmr.ifm_active);
1056
1057     /* Advertised features. */
1058     *advertised = netdev_bsd_parse_media(ifmr.ifm_current);
1059
1060     /* Supported features. */
1061     *supported = 0;
1062     for (i = 0; i < ifmr.ifm_count; i++) {
1063         *supported |= netdev_bsd_parse_media(ifmr.ifm_ulist[i]);
1064     }
1065
1066     /* Peer advertisements. */
1067     *peer = 0;                  /* XXX */
1068
1069     error = 0;
1070 cleanup:
1071     free(media_list);
1072     return error;
1073 }
1074
1075 /*
1076  * If 'netdev' has an assigned IPv4 address, sets '*in4' to that address (if
1077  * 'in4' is non-null) and returns true.  Otherwise, returns false.
1078  */
1079 static int
1080 netdev_bsd_get_in4(const struct netdev *netdev_, struct in_addr *in4,
1081                    struct in_addr *netmask)
1082 {
1083     struct netdev_dev_bsd *netdev_dev =
1084         netdev_dev_bsd_cast(netdev_get_dev(netdev_));
1085
1086     if (!(netdev_dev->cache_valid & VALID_IN4)) {
1087         const struct sockaddr_in *sin;
1088         struct ifreq ifr;
1089         int error;
1090
1091         ifr.ifr_addr.sa_family = AF_INET;
1092         error = netdev_bsd_do_ioctl(netdev_, &ifr,
1093                                       SIOCGIFADDR, "SIOCGIFADDR");
1094         if (error) {
1095             return error;
1096         }
1097
1098         sin = (struct sockaddr_in *) &ifr.ifr_addr;
1099         netdev_dev->in4 = sin->sin_addr;
1100         netdev_dev->cache_valid |= VALID_IN4;
1101         error = netdev_bsd_do_ioctl(netdev_, &ifr,
1102                                       SIOCGIFNETMASK, "SIOCGIFNETMASK");
1103         if (error) {
1104             return error;
1105         }
1106         *netmask = ((struct sockaddr_in*)&ifr.ifr_addr)->sin_addr;
1107     }
1108     *in4 = netdev_dev->in4;
1109
1110     return in4->s_addr == INADDR_ANY ? EADDRNOTAVAIL : 0;
1111 }
1112
1113 /*
1114  * Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask.  If
1115  * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared.  Returns a
1116  * positive errno value.
1117  */
1118 static int
1119 netdev_bsd_set_in4(struct netdev *netdev_, struct in_addr addr,
1120                      struct in_addr mask)
1121 {
1122     struct netdev_dev_bsd *netdev_dev =
1123         netdev_dev_bsd_cast(netdev_get_dev(netdev_));
1124     int error;
1125
1126     error = do_set_addr(netdev_, SIOCSIFADDR, "SIOCSIFADDR", addr);
1127     if (!error) {
1128         netdev_dev->cache_valid |= VALID_IN4;
1129         netdev_dev->in4 = addr;
1130         if (addr.s_addr != INADDR_ANY) {
1131             error = do_set_addr(netdev_, SIOCSIFNETMASK,
1132                                 "SIOCSIFNETMASK", mask);
1133         }
1134         netdev_dev_bsd_changed(netdev_dev);
1135     }
1136     return error;
1137 }
1138
1139 static int
1140 netdev_bsd_get_in6(const struct netdev *netdev_, struct in6_addr *in6)
1141 {
1142     struct netdev_dev_bsd *netdev_dev =
1143                                 netdev_dev_bsd_cast(netdev_get_dev(netdev_));
1144     if (!(netdev_dev->cache_valid & VALID_IN6)) {
1145         struct ifaddrs *ifa, *head;
1146         struct sockaddr_in6 *sin6;
1147         const char *netdev_name = netdev_get_name(netdev_);
1148
1149         if (getifaddrs(&head) != 0) {
1150             VLOG_ERR("getifaddrs on %s device failed: %s", netdev_name,
1151                     strerror(errno));
1152             return errno;
1153         }
1154
1155         for (ifa = head; ifa; ifa = ifa->ifa_next) {
1156             if (ifa->ifa_addr->sa_family == AF_INET6 &&
1157                     !strcmp(ifa->ifa_name, netdev_name)) {
1158                 sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
1159                 if (sin6) {
1160                     memcpy(&netdev_dev->in6, &sin6->sin6_addr, sin6->sin6_len);
1161                     netdev_dev->cache_valid |= VALID_IN6;
1162                     *in6 = netdev_dev->in6;
1163                     freeifaddrs(head);
1164                     return 0;
1165                 }
1166             }
1167         }
1168         return EADDRNOTAVAIL;
1169     }
1170     *in6 = netdev_dev->in6;
1171     return 0;
1172 }
1173
1174 static void
1175 make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr)
1176 {
1177     struct sockaddr_in sin;
1178     memset(&sin, 0, sizeof sin);
1179     sin.sin_family = AF_INET;
1180     sin.sin_addr = addr;
1181     sin.sin_port = 0;
1182
1183     memset(sa, 0, sizeof *sa);
1184     memcpy(sa, &sin, sizeof sin);
1185 }
1186
1187 static int
1188 do_set_addr(struct netdev *netdev,
1189             int ioctl_nr, const char *ioctl_name, struct in_addr addr)
1190 {
1191     struct ifreq ifr;
1192     make_in4_sockaddr(&ifr.ifr_addr, addr);
1193     return netdev_bsd_do_ioctl(netdev, &ifr, ioctl_nr, ioctl_name);
1194 }
1195
1196 static int
1197 nd_to_iff_flags(enum netdev_flags nd)
1198 {
1199     int iff = 0;
1200     if (nd & NETDEV_UP) {
1201         iff |= IFF_UP;
1202     }
1203     if (nd & NETDEV_PROMISC) {
1204         iff |= IFF_PROMISC;
1205         iff |= IFF_PPROMISC;
1206     }
1207     return iff;
1208 }
1209
1210 static int
1211 iff_to_nd_flags(int iff)
1212 {
1213     enum netdev_flags nd = 0;
1214     if (iff & IFF_UP) {
1215         nd |= NETDEV_UP;
1216     }
1217     if (iff & IFF_PROMISC) {
1218         nd |= NETDEV_PROMISC;
1219     }
1220     return nd;
1221 }
1222
1223 static int
1224 netdev_bsd_update_flags(struct netdev *netdev, enum netdev_flags off,
1225                           enum netdev_flags on, enum netdev_flags *old_flagsp)
1226 {
1227     int old_flags, new_flags;
1228     int error;
1229
1230     error = get_flags(netdev, &old_flags);
1231     if (!error) {
1232         *old_flagsp = iff_to_nd_flags(old_flags);
1233         new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
1234         if (new_flags != old_flags) {
1235             error = set_flags(netdev, new_flags);
1236             netdev_dev_bsd_changed(netdev_dev_bsd_cast(netdev_get_dev(netdev)));
1237         }
1238     }
1239     return error;
1240 }
1241
1242 static unsigned int
1243 netdev_bsd_change_seq(const struct netdev *netdev)
1244 {
1245     return netdev_dev_bsd_cast(netdev_get_dev(netdev))->change_seq;
1246 }
1247
1248
1249 const struct netdev_class netdev_bsd_class = {
1250     "system",
1251
1252     netdev_bsd_init,
1253     netdev_bsd_run,
1254     netdev_bsd_wait,
1255     netdev_bsd_create_system,
1256     netdev_bsd_destroy,
1257     NULL, /* get_config */
1258     NULL, /* set_config */
1259     netdev_bsd_open_system,
1260     netdev_bsd_close,
1261
1262     netdev_bsd_listen,
1263
1264     netdev_bsd_recv,
1265     netdev_bsd_recv_wait,
1266     netdev_bsd_drain,
1267
1268     netdev_bsd_send,
1269     netdev_bsd_send_wait,
1270
1271     netdev_bsd_set_etheraddr,
1272     netdev_bsd_get_etheraddr,
1273     netdev_bsd_get_mtu,
1274     NULL, /* set_mtu */
1275     netdev_bsd_get_ifindex,
1276     netdev_bsd_get_carrier,
1277     NULL, /* get_carrier_resets */
1278     NULL, /* set_miimon_interval */
1279     netdev_bsd_get_stats,
1280     NULL, /* set_stats */
1281
1282     netdev_bsd_get_features,
1283     NULL, /* set_advertisement */
1284     NULL, /* set_policing */
1285     NULL, /* get_qos_type */
1286     NULL, /* get_qos_capabilities */
1287     NULL, /* get_qos */
1288     NULL, /* set_qos */
1289     NULL, /* get_queue */
1290     NULL, /* set_queue */
1291     NULL, /* delete_queue */
1292     NULL, /* get_queue_stats */
1293     NULL, /* dump_queue */
1294     NULL, /* dump_queue_stats */
1295
1296     netdev_bsd_get_in4,
1297     netdev_bsd_set_in4,
1298     netdev_bsd_get_in6,
1299     NULL, /* add_router */
1300     NULL, /* get_next_hop */
1301     NULL, /* get_drv_info */
1302     NULL, /* arp_lookup */
1303
1304     netdev_bsd_update_flags,
1305
1306     netdev_bsd_change_seq
1307 };
1308
1309 const struct netdev_class netdev_tap_class = {
1310     "tap",
1311
1312     netdev_bsd_init,
1313     netdev_bsd_run,
1314     netdev_bsd_wait,
1315     netdev_bsd_create_tap,
1316     netdev_bsd_destroy,
1317     NULL, /* get_config */
1318     NULL, /* set_config */
1319     netdev_bsd_open_system,
1320     netdev_bsd_close,
1321
1322     netdev_bsd_listen,
1323
1324     netdev_bsd_recv,
1325     netdev_bsd_recv_wait,
1326     netdev_bsd_drain,
1327
1328     netdev_bsd_send,
1329     netdev_bsd_send_wait,
1330
1331     netdev_bsd_set_etheraddr,
1332     netdev_bsd_get_etheraddr,
1333     netdev_bsd_get_mtu,
1334     NULL, /* set_mtu */
1335     netdev_bsd_get_ifindex,
1336     netdev_bsd_get_carrier,
1337     NULL, /* get_carrier_resets */
1338     NULL, /* set_miimon_interval */
1339     netdev_bsd_get_stats,
1340     NULL, /* set_stats */
1341
1342     netdev_bsd_get_features,
1343     NULL, /* set_advertisement */
1344     NULL, /* set_policing */
1345     NULL, /* get_qos_type */
1346     NULL, /* get_qos_capabilities */
1347     NULL, /* get_qos */
1348     NULL, /* set_qos */
1349     NULL, /* get_queue */
1350     NULL, /* set_queue */
1351     NULL, /* delete_queue */
1352     NULL, /* get_queue_stats */
1353     NULL, /* dump_queue */
1354     NULL, /* dump_queue_stats */
1355
1356     netdev_bsd_get_in4,
1357     netdev_bsd_set_in4,
1358     netdev_bsd_get_in6,
1359     NULL, /* add_router */
1360     NULL, /* get_next_hop */
1361     NULL, /* get_drv_info */
1362     NULL, /* arp_lookup */
1363
1364     netdev_bsd_update_flags,
1365
1366     netdev_bsd_change_seq
1367 };
1368 \f
1369
1370 static void
1371 destroy_tap(int fd, const char *name)
1372 {
1373     struct ifreq ifr;
1374
1375     close(fd);
1376     strcpy(ifr.ifr_name, name);
1377     /* XXX What to do if this call fails? */
1378     ioctl(af_inet_sock, SIOCIFDESTROY, &ifr);
1379 }
1380
1381 static int
1382 get_flags(const struct netdev *netdev, int *flags)
1383 {
1384     struct ifreq ifr;
1385     int error;
1386
1387     error = netdev_bsd_do_ioctl(netdev, &ifr, SIOCGIFFLAGS, "SIOCGIFFLAGS");
1388
1389     *flags = 0xFFFF0000 & (ifr.ifr_flagshigh << 16);
1390     *flags |= 0x0000FFFF & ifr.ifr_flags;
1391
1392     return error;
1393 }
1394
1395 static int
1396 set_flags(struct netdev *netdev, int flags)
1397 {
1398     struct ifreq ifr;
1399
1400     ifr.ifr_flags = 0x0000FFFF & flags;
1401     ifr.ifr_flagshigh = (0xFFFF0000 & flags) >> 16;
1402
1403     return netdev_bsd_do_ioctl(netdev, &ifr, SIOCSIFFLAGS, "SIOCSIFFLAGS");
1404 }
1405
1406 static int
1407 get_ifindex(const struct netdev *netdev_, int *ifindexp)
1408 {
1409     struct netdev_dev_bsd *netdev_dev =
1410                                 netdev_dev_bsd_cast(netdev_get_dev(netdev_));
1411     *ifindexp = 0;
1412     if (!(netdev_dev->cache_valid & VALID_IFINDEX)) {
1413         int ifindex = if_nametoindex(netdev_get_name(netdev_));
1414         if (ifindex <= 0) {
1415             return errno;
1416         }
1417         netdev_dev->cache_valid |= VALID_IFINDEX;
1418         netdev_dev->ifindex = ifindex;
1419     }
1420     *ifindexp = netdev_dev->ifindex;
1421     return 0;
1422 }
1423
1424 static int
1425 get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN])
1426 {
1427     struct ifaddrs *head;
1428     struct ifaddrs *ifa;
1429     struct sockaddr_dl *sdl;
1430
1431     if (getifaddrs(&head) != 0) {
1432         VLOG_ERR("getifaddrs on %s device failed: %s", netdev_name,
1433                 strerror(errno));
1434         return errno;
1435     }
1436
1437     for (ifa = head; ifa; ifa = ifa->ifa_next) {
1438         if (ifa->ifa_addr->sa_family == AF_LINK) {
1439             if (!strcmp(ifa->ifa_name, netdev_name)) {
1440                 sdl = (struct sockaddr_dl *)ifa->ifa_addr;
1441                 if (sdl) {
1442                     memcpy(ea, LLADDR(sdl), sdl->sdl_alen);
1443                     freeifaddrs(head);
1444                     return 0;
1445                 }
1446             }
1447         }
1448     }
1449
1450     VLOG_ERR("could not find ethernet address for %s device", netdev_name);
1451     freeifaddrs(head);
1452     return ENODEV;
1453 }
1454
1455 static int
1456 set_etheraddr(const char *netdev_name, int hwaddr_family,
1457               int hwaddr_len, const uint8_t mac[ETH_ADDR_LEN])
1458 {
1459     struct ifreq ifr;
1460
1461     memset(&ifr, 0, sizeof ifr);
1462     strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
1463     ifr.ifr_addr.sa_family = hwaddr_family;
1464     ifr.ifr_addr.sa_len = hwaddr_len;
1465     memcpy(ifr.ifr_addr.sa_data, mac, hwaddr_len);
1466     if (ioctl(af_inet_sock, SIOCSIFLLADDR, &ifr) < 0) {
1467         VLOG_ERR("ioctl(SIOCSIFLLADDR) on %s device failed: %s",
1468                  netdev_name, strerror(errno));
1469         return errno;
1470     }
1471     return 0;
1472 }
1473
1474 static int
1475 netdev_bsd_do_ioctl(const struct netdev *netdev, struct ifreq *ifr,
1476                     unsigned long cmd, const char *cmd_name)
1477 {
1478     strncpy(ifr->ifr_name, netdev_get_name(netdev), sizeof ifr->ifr_name);
1479     if (ioctl(af_inet_sock, cmd, ifr) == -1) {
1480         VLOG_DBG_RL(&rl, "%s: ioctl(%s) failed: %s",
1481                     netdev_get_name(netdev), cmd_name, strerror(errno));
1482         return errno;
1483     }
1484     return 0;
1485 }