Import from old repository commit 61ef2b42a9c4ba8e1600f15bb0236765edc2ad45.
[openvswitch] / lib / netdev.c
1 /*
2  * Copyright (c) 2008, 2009 Nicira Networks.
3  *
4  * Permission to use, copy, modify, and/or distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16
17 #include <config.h>
18 #include "netdev.h"
19
20 #include <assert.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <arpa/inet.h>
24 #include <inttypes.h>
25 #include <linux/if_tun.h>
26 #include <linux/types.h>
27 #include <linux/ethtool.h>
28 #include <linux/rtnetlink.h>
29 #include <linux/sockios.h>
30 #include <linux/version.h>
31 #include <sys/types.h>
32 #include <sys/ioctl.h>
33 #include <sys/socket.h>
34 #include <netpacket/packet.h>
35 #include <net/ethernet.h>
36 #include <net/if.h>
37 #include <net/if_arp.h>
38 #include <net/if_packet.h>
39 #include <net/route.h>
40 #include <netinet/in.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <unistd.h>
44
45 #include "coverage.h"
46 #include "dynamic-string.h"
47 #include "fatal-signal.h"
48 #include "list.h"
49 #include "netlink.h"
50 #include "ofpbuf.h"
51 #include "openflow/openflow.h"
52 #include "packets.h"
53 #include "poll-loop.h"
54 #include "socket-util.h"
55 #include "svec.h"
56
57 /* linux/if.h defines IFF_LOWER_UP, net/if.h doesn't.
58  * net/if.h defines if_nameindex(), linux/if.h doesn't.
59  * We can't include both headers, so define IFF_LOWER_UP ourselves. */
60 #ifndef IFF_LOWER_UP
61 #define IFF_LOWER_UP 0x10000
62 #endif
63
64 /* These were introduced in Linux 2.6.14, so they might be missing if we have
65  * old headers. */
66 #ifndef ADVERTISED_Pause
67 #define ADVERTISED_Pause                (1 << 13)
68 #endif
69 #ifndef ADVERTISED_Asym_Pause
70 #define ADVERTISED_Asym_Pause           (1 << 14)
71 #endif
72
73 #define THIS_MODULE VLM_netdev
74 #include "vlog.h"
75
76 struct netdev {
77     struct list node;
78     char *name;
79
80     /* File descriptors.  For ordinary network devices, the two fds below are
81      * the same; for tap devices, they differ. */
82     int netdev_fd;              /* Network device. */
83     int tap_fd;                 /* TAP character device, if any, otherwise the
84                                  * network device. */
85
86     /* Cached network device information. */
87     int ifindex;                /* -1 if not known. */
88     uint8_t etheraddr[ETH_ADDR_LEN];
89     struct in6_addr in6;
90     int speed;
91     int mtu;
92     int txqlen;
93     int hwaddr_family;
94
95     int save_flags;             /* Initial device flags. */
96     int changed_flags;          /* Flags that we changed. */
97 };
98
99 /* Policy for RTNLGRP_LINK messages.
100  *
101  * There are *many* more fields in these messages, but currently we only care
102  * about interface names. */
103 static const struct nl_policy rtnlgrp_link_policy[] = {
104     [IFLA_IFNAME] = { .type = NL_A_STRING, .optional = false },
105     [IFLA_STATS] = { .type = NL_A_UNSPEC, .optional = true,
106                      .min_len = sizeof(struct rtnl_link_stats) },
107 };
108
109 /* All open network devices. */
110 static struct list netdev_list = LIST_INITIALIZER(&netdev_list);
111
112 /* An AF_INET socket (used for ioctl operations). */
113 static int af_inet_sock = -1;
114
115 /* NETLINK_ROUTE socket. */
116 static struct nl_sock *rtnl_sock;
117
118 /* Can we use RTM_GETLINK to get network device statistics?  (In pre-2.6.19
119  * kernels, this was only available if wireless extensions were enabled.) */
120 static bool use_netlink_stats;
121
122 /* This is set pretty low because we probably won't learn anything from the
123  * additional log messages. */
124 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
125
126 static void init_netdev(void);
127 static int do_open_netdev(const char *name, int ethertype, int tap_fd,
128                           struct netdev **netdev_);
129 static int restore_flags(struct netdev *netdev);
130 static int get_flags(const char *netdev_name, int *flagsp);
131 static int set_flags(const char *netdev_name, int flags);
132 static int do_get_ifindex(const char *netdev_name);
133 static int get_ifindex(const struct netdev *, int *ifindexp);
134 static int get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN],
135                          int *hwaddr_familyp);
136 static int set_etheraddr(const char *netdev_name, int hwaddr_family,
137                          const uint8_t[ETH_ADDR_LEN]);
138
139 /* Obtains the IPv6 address for 'name' into 'in6'. */
140 static void
141 get_ipv6_address(const char *name, struct in6_addr *in6)
142 {
143     FILE *file;
144     char line[128];
145
146     file = fopen("/proc/net/if_inet6", "r");
147     if (file == NULL) {
148         /* This most likely indicates that the host doesn't have IPv6 support,
149          * so it's not really a failure condition.*/
150         *in6 = in6addr_any;
151         return;
152     }
153
154     while (fgets(line, sizeof line, file)) {
155         uint8_t *s6 = in6->s6_addr;
156         char ifname[16 + 1];
157
158 #define X8 "%2"SCNx8
159         if (sscanf(line, " "X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8 X8
160                    "%*x %*x %*x %*x %16s\n",
161                    &s6[0], &s6[1], &s6[2], &s6[3],
162                    &s6[4], &s6[5], &s6[6], &s6[7],
163                    &s6[8], &s6[9], &s6[10], &s6[11],
164                    &s6[12], &s6[13], &s6[14], &s6[15],
165                    ifname) == 17
166             && !strcmp(name, ifname))
167         {
168             fclose(file);
169             return;
170         }
171     }
172     *in6 = in6addr_any;
173
174     fclose(file);
175 }
176
177 static int
178 do_ethtool(struct netdev *netdev, struct ethtool_cmd *ecmd,
179            int cmd, const char *cmd_name)
180 {
181     struct ifreq ifr;
182
183     memset(&ifr, 0, sizeof ifr);
184     strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name);
185     ifr.ifr_data = (caddr_t) ecmd;
186
187     ecmd->cmd = cmd;
188     COVERAGE_INC(netdev_ethtool);
189     if (ioctl(netdev->netdev_fd, SIOCETHTOOL, &ifr) == 0) {
190         return 0;
191     } else {
192         if (errno != EOPNOTSUPP) {
193             VLOG_WARN_RL(&rl, "ethtool command %s on network device %s "
194                          "failed: %s", cmd_name, netdev->name,
195                          strerror(errno));
196         } else {
197             /* The device doesn't support this operation.  That's pretty
198              * common, so there's no point in logging anything. */
199         }
200         return errno;
201     }
202 }
203
204 static int
205 do_get_features(struct netdev *netdev,
206                 uint32_t *current, uint32_t *advertised,
207                 uint32_t *supported, uint32_t *peer)
208 {
209     struct ethtool_cmd ecmd;
210     int error;
211
212     *current = 0;
213     *supported = 0;
214     *advertised = 0;
215     *peer = 0;
216
217     memset(&ecmd, 0, sizeof ecmd);
218     error = do_ethtool(netdev, &ecmd, ETHTOOL_GSET, "ETHTOOL_GSET");
219     if (error) {
220         return error;
221     }
222
223     if (ecmd.supported & SUPPORTED_10baseT_Half) {
224         *supported |= OFPPF_10MB_HD;
225     }
226     if (ecmd.supported & SUPPORTED_10baseT_Full) {
227         *supported |= OFPPF_10MB_FD;
228     }
229     if (ecmd.supported & SUPPORTED_100baseT_Half)  {
230         *supported |= OFPPF_100MB_HD;
231     }
232     if (ecmd.supported & SUPPORTED_100baseT_Full) {
233         *supported |= OFPPF_100MB_FD;
234     }
235     if (ecmd.supported & SUPPORTED_1000baseT_Half) {
236         *supported |= OFPPF_1GB_HD;
237     }
238     if (ecmd.supported & SUPPORTED_1000baseT_Full) {
239         *supported |= OFPPF_1GB_FD;
240     }
241     if (ecmd.supported & SUPPORTED_10000baseT_Full) {
242         *supported |= OFPPF_10GB_FD;
243     }
244     if (ecmd.supported & SUPPORTED_TP) {
245         *supported |= OFPPF_COPPER;
246     }
247     if (ecmd.supported & SUPPORTED_FIBRE) {
248         *supported |= OFPPF_FIBER;
249     }
250     if (ecmd.supported & SUPPORTED_Autoneg) {
251         *supported |= OFPPF_AUTONEG;
252     }
253     if (ecmd.supported & SUPPORTED_Pause) {
254         *supported |= OFPPF_PAUSE;
255     }
256     if (ecmd.supported & SUPPORTED_Asym_Pause) {
257         *supported |= OFPPF_PAUSE_ASYM;
258     }
259
260     /* Set the advertised features */
261     if (ecmd.advertising & ADVERTISED_10baseT_Half) {
262         *advertised |= OFPPF_10MB_HD;
263     }
264     if (ecmd.advertising & ADVERTISED_10baseT_Full) {
265         *advertised |= OFPPF_10MB_FD;
266     }
267     if (ecmd.advertising & ADVERTISED_100baseT_Half) {
268         *advertised |= OFPPF_100MB_HD;
269     }
270     if (ecmd.advertising & ADVERTISED_100baseT_Full) {
271         *advertised |= OFPPF_100MB_FD;
272     }
273     if (ecmd.advertising & ADVERTISED_1000baseT_Half) {
274         *advertised |= OFPPF_1GB_HD;
275     }
276     if (ecmd.advertising & ADVERTISED_1000baseT_Full) {
277         *advertised |= OFPPF_1GB_FD;
278     }
279     if (ecmd.advertising & ADVERTISED_10000baseT_Full) {
280         *advertised |= OFPPF_10GB_FD;
281     }
282     if (ecmd.advertising & ADVERTISED_TP) {
283         *advertised |= OFPPF_COPPER;
284     }
285     if (ecmd.advertising & ADVERTISED_FIBRE) {
286         *advertised |= OFPPF_FIBER;
287     }
288     if (ecmd.advertising & ADVERTISED_Autoneg) {
289         *advertised |= OFPPF_AUTONEG;
290     }
291     if (ecmd.advertising & ADVERTISED_Pause) {
292         *advertised |= OFPPF_PAUSE;
293     }
294     if (ecmd.advertising & ADVERTISED_Asym_Pause) {
295         *advertised |= OFPPF_PAUSE_ASYM;
296     }
297
298     /* Set the current features */
299     if (ecmd.speed == SPEED_10) {
300         *current = (ecmd.duplex) ? OFPPF_10MB_FD : OFPPF_10MB_HD;
301     }
302     else if (ecmd.speed == SPEED_100) {
303         *current = (ecmd.duplex) ? OFPPF_100MB_FD : OFPPF_100MB_HD;
304     }
305     else if (ecmd.speed == SPEED_1000) {
306         *current = (ecmd.duplex) ? OFPPF_1GB_FD : OFPPF_1GB_HD;
307     }
308     else if (ecmd.speed == SPEED_10000) {
309         *current = OFPPF_10GB_FD;
310     }
311
312     if (ecmd.port == PORT_TP) {
313         *current |= OFPPF_COPPER;
314     }
315     else if (ecmd.port == PORT_FIBRE) {
316         *current |= OFPPF_FIBER;
317     }
318
319     if (ecmd.autoneg) {
320         *current |= OFPPF_AUTONEG;
321     }
322     return 0;
323 }
324
325 /* Opens the network device named 'name' (e.g. "eth0") and returns zero if
326  * successful, otherwise a positive errno value.  On success, sets '*netdevp'
327  * to the new network device, otherwise to null.
328  *
329  * 'ethertype' may be a 16-bit Ethernet protocol value in host byte order to
330  * capture frames of that type received on the device.  It may also be one of
331  * the 'enum netdev_pseudo_ethertype' values to receive frames in one of those
332  * categories. */
333 int
334 netdev_open(const char *name, int ethertype, struct netdev **netdevp) 
335 {
336     if (!strncmp(name, "tap:", 4)) {
337         return netdev_open_tap(name + 4, netdevp);
338     } else {
339         return do_open_netdev(name, ethertype, -1, netdevp); 
340     }
341 }
342
343 /* Opens a TAP virtual network device.  If 'name' is a nonnull, non-empty
344  * string, attempts to assign that name to the TAP device (failing if the name
345  * is already in use); otherwise, a name is automatically assigned.  Returns
346  * zero if successful, otherwise a positive errno value.  On success, sets
347  * '*netdevp' to the new network device, otherwise to null.  */
348 int
349 netdev_open_tap(const char *name, struct netdev **netdevp)
350 {
351     static const char tap_dev[] = "/dev/net/tun";
352     struct ifreq ifr;
353     int error;
354     int tap_fd;
355
356     tap_fd = open(tap_dev, O_RDWR);
357     if (tap_fd < 0) {
358         ovs_error(errno, "opening \"%s\" failed", tap_dev);
359         return errno;
360     }
361
362     memset(&ifr, 0, sizeof ifr);
363     ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
364     if (name) {
365         strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
366     }
367     if (ioctl(tap_fd, TUNSETIFF, &ifr) < 0) {
368         int error = errno;
369         ovs_error(error, "ioctl(TUNSETIFF) on \"%s\" failed", tap_dev);
370         close(tap_fd);
371         return error;
372     }
373
374     error = set_nonblocking(tap_fd);
375     if (error) {
376         ovs_error(error, "set_nonblocking on \"%s\" failed", tap_dev);
377         close(tap_fd);
378         return error;
379     }
380
381     error = do_open_netdev(ifr.ifr_name, NETDEV_ETH_TYPE_NONE, tap_fd,
382                            netdevp);
383     if (error) {
384         close(tap_fd);
385     }
386     return error;
387 }
388
389 static int
390 do_open_netdev(const char *name, int ethertype, int tap_fd,
391                struct netdev **netdev_)
392 {
393     int netdev_fd;
394     struct sockaddr_ll sll;
395     struct ifreq ifr;
396     int ifindex = -1;
397     uint8_t etheraddr[ETH_ADDR_LEN];
398     struct in6_addr in6;
399     int mtu;
400     int txqlen;
401     int hwaddr_family;
402     int error;
403     struct netdev *netdev;
404
405     init_netdev();
406     *netdev_ = NULL;
407     COVERAGE_INC(netdev_open);
408
409     /* Create raw socket. */
410     netdev_fd = socket(PF_PACKET, SOCK_RAW,
411                        htons(ethertype == NETDEV_ETH_TYPE_NONE ? 0
412                              : ethertype == NETDEV_ETH_TYPE_ANY ? ETH_P_ALL
413                              : ethertype == NETDEV_ETH_TYPE_802_2 ? ETH_P_802_2
414                              : ethertype));
415     if (netdev_fd < 0) {
416         return errno;
417     }
418
419     if (ethertype != NETDEV_ETH_TYPE_NONE) {
420         /* Set non-blocking mode. */
421         error = set_nonblocking(netdev_fd);
422         if (error) {
423             goto error_already_set;
424         }
425
426         /* Get ethernet device index. */
427         ifindex = do_get_ifindex(name);
428         if (ifindex < 0) {
429             return -ifindex;
430         }
431
432         /* Bind to specific ethernet device. */
433         memset(&sll, 0, sizeof sll);
434         sll.sll_family = AF_PACKET;
435         sll.sll_ifindex = ifindex;
436         if (bind(netdev_fd, (struct sockaddr *) &sll, sizeof sll) < 0) {
437             VLOG_ERR("bind to %s failed: %s", name, strerror(errno));
438             goto error;
439         }
440
441         /* Between the socket() and bind() calls above, the socket receives all
442          * packets of the requested type on all system interfaces.  We do not
443          * want to receive that data, but there is no way to avoid it.  So we
444          * must now drain out the receive queue. */
445         error = drain_rcvbuf(netdev_fd);
446         if (error) {
447             goto error_already_set;
448         }
449     }
450
451     /* Get MAC address. */
452     error = get_etheraddr(name, etheraddr, &hwaddr_family);
453     if (error) {
454         goto error_already_set;
455     }
456
457     /* Get MTU. */
458     strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
459     if (ioctl(netdev_fd, SIOCGIFMTU, &ifr) < 0) {
460         VLOG_ERR("ioctl(SIOCGIFMTU) on %s device failed: %s",
461                  name, strerror(errno));
462         goto error;
463     }
464     mtu = ifr.ifr_mtu;
465
466     /* Get TX queue length. */
467     if (ioctl(netdev_fd, SIOCGIFTXQLEN, &ifr) < 0) {
468         VLOG_ERR("ioctl(SIOCGIFTXQLEN) on %s device failed: %s",
469                  name, strerror(errno));
470         goto error;
471     }
472     txqlen = ifr.ifr_qlen;
473
474     get_ipv6_address(name, &in6);
475
476     /* Allocate network device. */
477     netdev = xmalloc(sizeof *netdev);
478     netdev->name = xstrdup(name);
479     netdev->ifindex = ifindex;
480     netdev->txqlen = txqlen;
481     netdev->hwaddr_family = hwaddr_family;
482     netdev->netdev_fd = netdev_fd;
483     netdev->tap_fd = tap_fd < 0 ? netdev_fd : tap_fd;
484     memcpy(netdev->etheraddr, etheraddr, sizeof etheraddr);
485     netdev->mtu = mtu;
486     netdev->in6 = in6;
487
488     /* Save flags to restore at close or exit. */
489     error = get_flags(netdev->name, &netdev->save_flags);
490     if (error) {
491         goto error_already_set;
492     }
493     netdev->changed_flags = 0;
494     fatal_signal_block();
495     list_push_back(&netdev_list, &netdev->node);
496     fatal_signal_unblock();
497
498     /* Success! */
499     *netdev_ = netdev;
500     return 0;
501
502 error:
503     error = errno;
504 error_already_set:
505     close(netdev_fd);
506     if (tap_fd >= 0) {
507         close(tap_fd);
508     }
509     return error;
510 }
511
512 /* Closes and destroys 'netdev'. */
513 void
514 netdev_close(struct netdev *netdev)
515 {
516     if (netdev) {
517         /* Bring down interface and drop promiscuous mode, if we brought up
518          * the interface or enabled promiscuous mode. */
519         int error;
520         fatal_signal_block();
521         error = restore_flags(netdev);
522         list_remove(&netdev->node);
523         fatal_signal_unblock();
524         if (error) {
525             VLOG_WARN("failed to restore network device flags on %s: %s",
526                       netdev->name, strerror(error));
527         }
528
529         /* Free. */
530         free(netdev->name);
531         close(netdev->netdev_fd);
532         if (netdev->netdev_fd != netdev->tap_fd) {
533             close(netdev->tap_fd);
534         }
535         free(netdev);
536     }
537 }
538
539 /* Pads 'buffer' out with zero-bytes to the minimum valid length of an
540  * Ethernet packet, if necessary.  */
541 static void
542 pad_to_minimum_length(struct ofpbuf *buffer)
543 {
544     if (buffer->size < ETH_TOTAL_MIN) {
545         ofpbuf_put_zeros(buffer, ETH_TOTAL_MIN - buffer->size);
546     }
547 }
548
549 /* Attempts to receive a packet from 'netdev' into 'buffer', which the caller
550  * must have initialized with sufficient room for the packet.  The space
551  * required to receive any packet is ETH_HEADER_LEN bytes, plus VLAN_HEADER_LEN
552  * bytes, plus the device's MTU (which may be retrieved via netdev_get_mtu()).
553  * (Some devices do not allow for a VLAN header, in which case VLAN_HEADER_LEN
554  * need not be included.)
555  *
556  * If a packet is successfully retrieved, returns 0.  In this case 'buffer' is
557  * guaranteed to contain at least ETH_TOTAL_MIN bytes.  Otherwise, returns a
558  * positive errno value.  Returns EAGAIN immediately if no packet is ready to
559  * be returned.
560  */
561 int
562 netdev_recv(struct netdev *netdev, struct ofpbuf *buffer)
563 {
564     ssize_t n_bytes;
565
566     assert(buffer->size == 0);
567     assert(ofpbuf_tailroom(buffer) >= ETH_TOTAL_MIN);
568     do {
569         n_bytes = read(netdev->tap_fd,
570                        ofpbuf_tail(buffer), ofpbuf_tailroom(buffer));
571     } while (n_bytes < 0 && errno == EINTR);
572     if (n_bytes < 0) {
573         if (errno != EAGAIN) {
574             VLOG_WARN_RL(&rl, "error receiving Ethernet packet on %s: %s",
575                          strerror(errno), netdev->name);
576         }
577         return errno;
578     } else {
579         COVERAGE_INC(netdev_received);
580         buffer->size += n_bytes;
581
582         /* When the kernel internally sends out an Ethernet frame on an
583          * interface, it gives us a copy *before* padding the frame to the
584          * minimum length.  Thus, when it sends out something like an ARP
585          * request, we see a too-short frame.  So pad it out to the minimum
586          * length. */
587         pad_to_minimum_length(buffer);
588         return 0;
589     }
590 }
591
592 /* Registers with the poll loop to wake up from the next call to poll_block()
593  * when a packet is ready to be received with netdev_recv() on 'netdev'. */
594 void
595 netdev_recv_wait(struct netdev *netdev)
596 {
597     poll_fd_wait(netdev->tap_fd, POLLIN);
598 }
599
600 /* Discards all packets waiting to be received from 'netdev'. */
601 int
602 netdev_drain(struct netdev *netdev)
603 {
604     if (netdev->tap_fd != netdev->netdev_fd) {
605         drain_fd(netdev->tap_fd, netdev->txqlen);
606         return 0;
607     } else {
608         return drain_rcvbuf(netdev->netdev_fd);
609     }
610 }
611
612 /* Sends 'buffer' on 'netdev'.  Returns 0 if successful, otherwise a positive
613  * errno value.  Returns EAGAIN without blocking if the packet cannot be queued
614  * immediately.  Returns EMSGSIZE if a partial packet was transmitted or if
615  * the packet is too big or too small to transmit on the device.
616  *
617  * The caller retains ownership of 'buffer' in all cases.
618  *
619  * The kernel maintains a packet transmission queue, so the caller is not
620  * expected to do additional queuing of packets. */
621 int
622 netdev_send(struct netdev *netdev, const struct ofpbuf *buffer)
623 {
624     ssize_t n_bytes;
625
626     do {
627         n_bytes = write(netdev->tap_fd, buffer->data, buffer->size);
628     } while (n_bytes < 0 && errno == EINTR);
629
630     if (n_bytes < 0) {
631         /* The Linux AF_PACKET implementation never blocks waiting for room
632          * for packets, instead returning ENOBUFS.  Translate this into EAGAIN
633          * for the caller. */
634         if (errno == ENOBUFS) {
635             return EAGAIN;
636         } else if (errno != EAGAIN) {
637             VLOG_WARN_RL(&rl, "error sending Ethernet packet on %s: %s",
638                          netdev->name, strerror(errno));
639         }
640         return errno;
641     } else if (n_bytes != buffer->size) {
642         VLOG_WARN_RL(&rl,
643                      "send partial Ethernet packet (%d bytes of %zu) on %s",
644                      (int) n_bytes, buffer->size, netdev->name);
645         return EMSGSIZE;
646     } else {
647         COVERAGE_INC(netdev_sent);
648         return 0;
649     }
650 }
651
652 /* Registers with the poll loop to wake up from the next call to poll_block()
653  * when the packet transmission queue has sufficient room to transmit a packet
654  * with netdev_send().
655  *
656  * The kernel maintains a packet transmission queue, so the client is not
657  * expected to do additional queuing of packets.  Thus, this function is
658  * unlikely to ever be used.  It is included for completeness. */
659 void
660 netdev_send_wait(struct netdev *netdev)
661 {
662     if (netdev->tap_fd == netdev->netdev_fd) {
663         poll_fd_wait(netdev->tap_fd, POLLOUT);
664     } else {
665         /* TAP device always accepts packets.*/
666         poll_immediate_wake();
667     }
668 }
669
670 /* Attempts to set 'netdev''s MAC address to 'mac'.  Returns 0 if successful,
671  * otherwise a positive errno value. */
672 int
673 netdev_set_etheraddr(struct netdev *netdev, const uint8_t mac[ETH_ADDR_LEN])
674 {
675     int error = set_etheraddr(netdev->name, netdev->hwaddr_family, mac);
676     if (!error) {
677         memcpy(netdev->etheraddr, mac, ETH_ADDR_LEN);
678     }
679     return error;
680 }
681
682 int
683 netdev_nodev_set_etheraddr(const char *name, const uint8_t mac[ETH_ADDR_LEN])
684 {
685     init_netdev();
686     return set_etheraddr(name, ARPHRD_ETHER, mac);
687 }
688
689 /* Returns a pointer to 'netdev''s MAC address.  The caller must not modify or
690  * free the returned buffer. */
691 const uint8_t *
692 netdev_get_etheraddr(const struct netdev *netdev)
693 {
694     return netdev->etheraddr;
695 }
696
697 /* Returns the name of the network device that 'netdev' represents,
698  * e.g. "eth0".  The caller must not modify or free the returned string. */
699 const char *
700 netdev_get_name(const struct netdev *netdev)
701 {
702     return netdev->name;
703 }
704
705 /* Returns the maximum size of transmitted (and received) packets on 'netdev',
706  * in bytes, not including the hardware header; thus, this is typically 1500
707  * bytes for Ethernet devices. */
708 int
709 netdev_get_mtu(const struct netdev *netdev) 
710 {
711     return netdev->mtu;
712 }
713
714 /* Stores the features supported by 'netdev' into each of '*current',
715  * '*advertised', '*supported', and '*peer' that are non-null.  Each value is a
716  * bitmap of "enum ofp_port_features" bits, in host byte order.  Returns 0 if
717  * successful, otherwise a positive errno value.  On failure, all of the
718  * passed-in values are set to 0. */
719 int
720 netdev_get_features(struct netdev *netdev,
721                     uint32_t *current, uint32_t *advertised,
722                     uint32_t *supported, uint32_t *peer)
723 {
724     uint32_t dummy[4];
725     return do_get_features(netdev,
726                            current ? current : &dummy[0],
727                            advertised ? advertised : &dummy[1],
728                            supported ? supported : &dummy[2],
729                            peer ? peer : &dummy[3]);
730 }
731
732 int
733 netdev_set_advertisements(struct netdev *netdev, uint32_t advertise)
734 {
735     struct ethtool_cmd ecmd;
736     int error;
737
738     memset(&ecmd, 0, sizeof ecmd);
739     error = do_ethtool(netdev, &ecmd, ETHTOOL_GSET, "ETHTOOL_GSET");
740     if (error) {
741         return error;
742     }
743
744     ecmd.advertising = 0;
745     if (advertise & OFPPF_10MB_HD) {
746         ecmd.advertising |= ADVERTISED_10baseT_Half;
747     }
748     if (advertise & OFPPF_10MB_FD) {
749         ecmd.advertising |= ADVERTISED_10baseT_Full;
750     }
751     if (advertise & OFPPF_100MB_HD) {
752         ecmd.advertising |= ADVERTISED_100baseT_Half;
753     }
754     if (advertise & OFPPF_100MB_FD) {
755         ecmd.advertising |= ADVERTISED_100baseT_Full;
756     }
757     if (advertise & OFPPF_1GB_HD) {
758         ecmd.advertising |= ADVERTISED_1000baseT_Half;
759     }
760     if (advertise & OFPPF_1GB_FD) {
761         ecmd.advertising |= ADVERTISED_1000baseT_Full;
762     }
763     if (advertise & OFPPF_10GB_FD) {
764         ecmd.advertising |= ADVERTISED_10000baseT_Full;
765     }
766     if (advertise & OFPPF_COPPER) {
767         ecmd.advertising |= ADVERTISED_TP;
768     }
769     if (advertise & OFPPF_FIBER) {
770         ecmd.advertising |= ADVERTISED_FIBRE;
771     }
772     if (advertise & OFPPF_AUTONEG) {
773         ecmd.advertising |= ADVERTISED_Autoneg;
774     }
775     if (advertise & OFPPF_PAUSE) {
776         ecmd.advertising |= ADVERTISED_Pause;
777     }
778     if (advertise & OFPPF_PAUSE_ASYM) {
779         ecmd.advertising |= ADVERTISED_Asym_Pause;
780     }
781     return do_ethtool(netdev, &ecmd, ETHTOOL_SSET, "ETHTOOL_SSET");
782 }
783
784 /* If 'netdev' has an assigned IPv4 address, sets '*in4' to that address (if
785  * 'in4' is non-null) and returns true.  Otherwise, returns false. */
786 bool
787 netdev_get_in4(const struct netdev *netdev, struct in_addr *in4)
788 {
789     struct ifreq ifr;
790     struct in_addr ip = { INADDR_ANY };
791
792     strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name);
793     ifr.ifr_addr.sa_family = AF_INET;
794     COVERAGE_INC(netdev_get_in4);
795     if (ioctl(af_inet_sock, SIOCGIFADDR, &ifr) == 0) {
796         struct sockaddr_in *sin = (struct sockaddr_in *) &ifr.ifr_addr;
797         ip = sin->sin_addr;
798     } else {
799         VLOG_DBG_RL(&rl, "%s: ioctl(SIOCGIFADDR) failed: %s",
800                     netdev->name, strerror(errno));
801     }
802     if (in4) {
803         *in4 = ip;
804     }
805     return ip.s_addr != INADDR_ANY;
806 }
807
808 static void
809 make_in4_sockaddr(struct sockaddr *sa, struct in_addr addr)
810 {
811     struct sockaddr_in sin;
812     memset(&sin, 0, sizeof sin);
813     sin.sin_family = AF_INET;
814     sin.sin_addr = addr;
815     sin.sin_port = 0;
816
817     memset(sa, 0, sizeof *sa);
818     memcpy(sa, &sin, sizeof sin);
819 }
820
821 static int
822 do_set_addr(struct netdev *netdev, int sock,
823             int ioctl_nr, const char *ioctl_name, struct in_addr addr)
824 {
825     struct ifreq ifr;
826     int error;
827
828     strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name);
829     make_in4_sockaddr(&ifr.ifr_addr, addr);
830     COVERAGE_INC(netdev_set_in4);
831     error = ioctl(sock, ioctl_nr, &ifr) < 0 ? errno : 0;
832     if (error) {
833         VLOG_WARN("ioctl(%s): %s", ioctl_name, strerror(error));
834     }
835     return error;
836 }
837
838 /* Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask.  If
839  * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared.  Returns a
840  * positive errno value. */
841 int
842 netdev_set_in4(struct netdev *netdev, struct in_addr addr, struct in_addr mask)
843 {
844     int error;
845
846     error = do_set_addr(netdev, af_inet_sock,
847                         SIOCSIFADDR, "SIOCSIFADDR", addr);
848     if (!error && addr.s_addr != INADDR_ANY) {
849         error = do_set_addr(netdev, af_inet_sock,
850                             SIOCSIFNETMASK, "SIOCSIFNETMASK", mask);
851     }
852     return error;
853 }
854
855 /* Adds 'router' as a default IP gateway. */
856 int
857 netdev_add_router(struct in_addr router)
858 {
859     struct in_addr any = { INADDR_ANY };
860     struct rtentry rt;
861     int error;
862
863     memset(&rt, 0, sizeof rt);
864     make_in4_sockaddr(&rt.rt_dst, any);
865     make_in4_sockaddr(&rt.rt_gateway, router);
866     make_in4_sockaddr(&rt.rt_genmask, any);
867     rt.rt_flags = RTF_UP | RTF_GATEWAY;
868     COVERAGE_INC(netdev_add_router);
869     error = ioctl(af_inet_sock, SIOCADDRT, &rt) < 0 ? errno : 0;
870     if (error) {
871         VLOG_WARN("ioctl(SIOCADDRT): %s", strerror(error));
872     }
873     return error;
874 }
875
876 /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address (if
877  * 'in6' is non-null) and returns true.  Otherwise, returns false. */
878 bool
879 netdev_get_in6(const struct netdev *netdev, struct in6_addr *in6)
880 {
881     if (in6) {
882         *in6 = netdev->in6;
883     }
884     return memcmp(&netdev->in6, &in6addr_any, sizeof netdev->in6) != 0;
885 }
886
887 /* Obtains the current flags for 'netdev' and stores them into '*flagsp'.
888  * Returns 0 if successful, otherwise a positive errno value.  On failure,
889  * stores 0 into '*flagsp'. */
890 int
891 netdev_get_flags(const struct netdev *netdev, enum netdev_flags *flagsp)
892 {
893     return netdev_nodev_get_flags(netdev->name, flagsp);
894 }
895
896 static int
897 nd_to_iff_flags(enum netdev_flags nd)
898 {
899     int iff = 0;
900     if (nd & NETDEV_UP) {
901         iff |= IFF_UP;
902     }
903     if (nd & NETDEV_PROMISC) {
904         iff |= IFF_PROMISC;
905     }
906     return iff;
907 }
908
909 /* On 'netdev', turns off the flags in 'off' and then turns on the flags in
910  * 'on'.  If 'permanent' is true, the changes will persist; otherwise, they
911  * will be reverted when 'netdev' is closed or the program exits.  Returns 0 if
912  * successful, otherwise a positive errno value. */
913 static int
914 do_update_flags(struct netdev *netdev, enum netdev_flags off,
915                 enum netdev_flags on, bool permanent)
916 {
917     int old_flags, new_flags;
918     int error;
919
920     error = get_flags(netdev->name, &old_flags);
921     if (error) {
922         return error;
923     }
924
925     new_flags = (old_flags & ~nd_to_iff_flags(off)) | nd_to_iff_flags(on);
926     if (!permanent) {
927         netdev->changed_flags |= new_flags ^ old_flags; 
928     }
929     if (new_flags != old_flags) {
930         error = set_flags(netdev->name, new_flags);
931     }
932     return error;
933 }
934
935 /* Sets the flags for 'netdev' to 'flags'.
936  * If 'permanent' is true, the changes will persist; otherwise, they
937  * will be reverted when 'netdev' is closed or the program exits.
938  * Returns 0 if successful, otherwise a positive errno value. */
939 int
940 netdev_set_flags(struct netdev *netdev, enum netdev_flags flags,
941                  bool permanent)
942 {
943     return do_update_flags(netdev, -1, flags, permanent);
944 }
945
946 /* Turns on the specified 'flags' on 'netdev'.
947  * If 'permanent' is true, the changes will persist; otherwise, they
948  * will be reverted when 'netdev' is closed or the program exits.
949  * Returns 0 if successful, otherwise a positive errno value. */
950 int
951 netdev_turn_flags_on(struct netdev *netdev, enum netdev_flags flags,
952                      bool permanent)
953 {
954     return do_update_flags(netdev, 0, flags, permanent);
955 }
956
957 /* Turns off the specified 'flags' on 'netdev'.
958  * If 'permanent' is true, the changes will persist; otherwise, they
959  * will be reverted when 'netdev' is closed or the program exits.
960  * Returns 0 if successful, otherwise a positive errno value. */
961 int
962 netdev_turn_flags_off(struct netdev *netdev, enum netdev_flags flags,
963                       bool permanent)
964 {
965     return do_update_flags(netdev, flags, 0, permanent);
966 }
967
968 /* Looks up the ARP table entry for 'ip' on 'netdev'.  If one exists and can be
969  * successfully retrieved, it stores the corresponding MAC address in 'mac' and
970  * returns 0.  Otherwise, it returns a positive errno value; in particular,
971  * ENXIO indicates that there is not ARP table entry for 'ip' on 'netdev'. */
972 int
973 netdev_arp_lookup(const struct netdev *netdev,
974                   uint32_t ip, uint8_t mac[ETH_ADDR_LEN]) 
975 {
976     struct arpreq r;
977     struct sockaddr_in *pa;
978     int retval;
979
980     memset(&r, 0, sizeof r);
981     pa = (struct sockaddr_in *) &r.arp_pa;
982     pa->sin_family = AF_INET;
983     pa->sin_addr.s_addr = ip;
984     pa->sin_port = 0;
985     r.arp_ha.sa_family = ARPHRD_ETHER;
986     r.arp_flags = 0;
987     strncpy(r.arp_dev, netdev->name, sizeof r.arp_dev);
988     COVERAGE_INC(netdev_arp_lookup);
989     retval = ioctl(af_inet_sock, SIOCGARP, &r) < 0 ? errno : 0;
990     if (!retval) {
991         memcpy(mac, r.arp_ha.sa_data, ETH_ADDR_LEN);
992     } else if (retval != ENXIO) {
993         VLOG_WARN_RL(&rl, "%s: could not look up ARP entry for "IP_FMT": %s",
994                      netdev->name, IP_ARGS(&ip), strerror(retval));
995     }
996     return retval;
997 }
998
999 static int
1000 get_stats_via_netlink(int ifindex, struct netdev_stats *stats)
1001 {
1002     struct ofpbuf request;
1003     struct ofpbuf *reply;
1004     struct ifinfomsg *ifi;
1005     const struct rtnl_link_stats *rtnl_stats;
1006     struct nlattr *attrs[ARRAY_SIZE(rtnlgrp_link_policy)];
1007     int error;
1008
1009     ofpbuf_init(&request, 0);
1010     nl_msg_put_nlmsghdr(&request, rtnl_sock, sizeof *ifi,
1011                         RTM_GETLINK, NLM_F_REQUEST);
1012     ifi = ofpbuf_put_zeros(&request, sizeof *ifi);
1013     ifi->ifi_family = PF_UNSPEC;
1014     ifi->ifi_index = ifindex;
1015     error = nl_sock_transact(rtnl_sock, &request, &reply);
1016     ofpbuf_uninit(&request);
1017     if (error) {
1018         return error;
1019     }
1020
1021     if (!nl_policy_parse(reply, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
1022                          rtnlgrp_link_policy,
1023                          attrs, ARRAY_SIZE(rtnlgrp_link_policy))) {
1024         ofpbuf_delete(reply);
1025         return EPROTO;
1026     }
1027
1028     if (!attrs[IFLA_STATS]) {
1029         VLOG_WARN_RL(&rl, "RTM_GETLINK reply lacks stats");
1030         return EPROTO;
1031     }
1032
1033     rtnl_stats = nl_attr_get(attrs[IFLA_STATS]);
1034     stats->rx_packets = rtnl_stats->rx_packets;
1035     stats->tx_packets = rtnl_stats->tx_packets;
1036     stats->rx_bytes = rtnl_stats->rx_bytes;
1037     stats->tx_bytes = rtnl_stats->tx_bytes;
1038     stats->rx_errors = rtnl_stats->rx_errors;
1039     stats->tx_errors = rtnl_stats->tx_errors;
1040     stats->rx_dropped = rtnl_stats->rx_dropped;
1041     stats->tx_dropped = rtnl_stats->tx_dropped;
1042     stats->multicast = rtnl_stats->multicast;
1043     stats->collisions = rtnl_stats->collisions;
1044     stats->rx_length_errors = rtnl_stats->rx_length_errors;
1045     stats->rx_over_errors = rtnl_stats->rx_over_errors;
1046     stats->rx_crc_errors = rtnl_stats->rx_crc_errors;
1047     stats->rx_frame_errors = rtnl_stats->rx_frame_errors;
1048     stats->rx_fifo_errors = rtnl_stats->rx_fifo_errors;
1049     stats->rx_missed_errors = rtnl_stats->rx_missed_errors;
1050     stats->tx_aborted_errors = rtnl_stats->tx_aborted_errors;
1051     stats->tx_carrier_errors = rtnl_stats->tx_carrier_errors;
1052     stats->tx_fifo_errors = rtnl_stats->tx_fifo_errors;
1053     stats->tx_heartbeat_errors = rtnl_stats->tx_heartbeat_errors;
1054     stats->tx_window_errors = rtnl_stats->tx_window_errors;
1055
1056     return 0;
1057 }
1058
1059 static int
1060 get_stats_via_proc(const char *netdev_name, struct netdev_stats *stats)
1061 {
1062     static const char fn[] = "/proc/net/dev";
1063     char line[1024];
1064     FILE *stream;
1065     int ln;
1066
1067     stream = fopen(fn, "r");
1068     if (!stream) {
1069         VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(errno));
1070         return errno;
1071     }
1072
1073     ln = 0;
1074     while (fgets(line, sizeof line, stream)) {
1075         if (++ln >= 3) {
1076             char devname[16];
1077 #define X64 "%"SCNu64
1078             if (sscanf(line,
1079                        " %15[^:]:"
1080                        X64 X64 X64 X64 X64 X64 X64 "%*u"
1081                        X64 X64 X64 X64 X64 X64 X64 "%*u",
1082                        devname,
1083                        &stats->rx_bytes,
1084                        &stats->rx_packets,
1085                        &stats->rx_errors,
1086                        &stats->rx_dropped,
1087                        &stats->rx_fifo_errors,
1088                        &stats->rx_frame_errors,
1089                        &stats->multicast,
1090                        &stats->tx_bytes,
1091                        &stats->tx_packets,
1092                        &stats->tx_errors,
1093                        &stats->tx_dropped,
1094                        &stats->tx_fifo_errors,
1095                        &stats->collisions,
1096                        &stats->tx_carrier_errors) != 15) {
1097                 VLOG_WARN_RL(&rl, "%s:%d: parse error", fn, ln);
1098             } else if (!strcmp(devname, netdev_name)) {
1099                 stats->rx_length_errors = UINT64_MAX;
1100                 stats->rx_over_errors = UINT64_MAX;
1101                 stats->rx_crc_errors = UINT64_MAX;
1102                 stats->rx_missed_errors = UINT64_MAX;
1103                 stats->tx_aborted_errors = UINT64_MAX;
1104                 stats->tx_heartbeat_errors = UINT64_MAX;
1105                 stats->tx_window_errors = UINT64_MAX;
1106                 fclose(stream);
1107                 return 0;
1108             }
1109         }
1110     }
1111     VLOG_WARN_RL(&rl, "%s: no stats for %s", fn, netdev_name);
1112     fclose(stream);
1113     return ENODEV;
1114 }
1115
1116 int
1117 netdev_get_carrier(const struct netdev *netdev, bool *carrier)
1118 {
1119     char line[8];
1120     int retval;
1121     int error;
1122     char *fn;
1123     int fd;
1124
1125     *carrier = false;
1126
1127     fn = xasprintf("/sys/class/net/%s/carrier", netdev->name);
1128     fd = open(fn, O_RDONLY);
1129     if (fd < 0) {
1130         error = errno;
1131         VLOG_WARN_RL(&rl, "%s: open failed: %s", fn, strerror(error));
1132         goto exit;
1133     }
1134
1135     retval = read(fd, line, sizeof line);
1136     if (retval < 0) {
1137         error = errno;
1138         if (error == EINVAL) {
1139             /* This is the normal return value when we try to check carrier if
1140              * the network device is not up. */
1141         } else {
1142             VLOG_WARN_RL(&rl, "%s: read failed: %s", fn, strerror(error));
1143         }
1144         goto exit_close;
1145     } else if (retval == 0) {
1146         error = EPROTO;
1147         VLOG_WARN_RL(&rl, "%s: unexpected end of file", fn);
1148         goto exit_close;
1149     }
1150
1151     if (line[0] != '0' && line[0] != '1') {
1152         error = EPROTO;
1153         VLOG_WARN_RL(&rl, "%s: value is %c (expected 0 or 1)", fn, line[0]);
1154         goto exit_close;
1155     }
1156     *carrier = line[0] != '0';
1157     error = 0;
1158
1159 exit_close:
1160     close(fd);
1161 exit:
1162     free(fn);
1163     return error;
1164 }
1165
1166 int
1167 netdev_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
1168 {
1169     int error;
1170
1171     COVERAGE_INC(netdev_get_stats);
1172     if (use_netlink_stats) {
1173         int ifindex;
1174
1175         error = get_ifindex(netdev, &ifindex);
1176         if (!error) {
1177             error = get_stats_via_netlink(ifindex, stats);
1178         }
1179     } else {
1180         error = get_stats_via_proc(netdev->name, stats);
1181     }
1182
1183     if (error) {
1184         memset(stats, 0xff, sizeof *stats);
1185     }
1186     return error;
1187 }
1188
1189 #define POLICE_ADD_CMD "/sbin/tc qdisc add dev %s handle ffff: ingress"
1190 #define POLICE_CONFIG_CMD "/sbin/tc filter add dev %s parent ffff: protocol ip prio 50 u32 match ip src 0.0.0.0/0 police rate %dkbit burst %dk mtu 65535 drop flowid :1"
1191 /* We redirect stderr to /dev/null because we often want to remove all
1192  * traffic control configuration on a port so its in a known state.  If
1193  * this done when there is no such configuration, tc complains, so we just
1194  * always ignore it.
1195  */
1196 #define POLICE_DEL_CMD "/sbin/tc qdisc del dev %s handle ffff: ingress 2>/dev/null"
1197
1198 /* Attempts to set input rate limiting (policing) policy. */
1199 int
1200 netdev_nodev_set_policing(const char *netdev_name, uint32_t kbits_rate,
1201                           uint32_t kbits_burst)
1202 {
1203     char command[1024];
1204
1205     init_netdev();
1206
1207     COVERAGE_INC(netdev_set_policing);
1208     if (kbits_rate) {
1209         if (!kbits_burst) {
1210             /* Default to 10 kilobits if not specified. */
1211             kbits_burst = 10;
1212         }
1213
1214         /* xxx This should be more careful about only adding if it
1215          * xxx actually exists, as opposed to always deleting it. */
1216         snprintf(command, sizeof(command), POLICE_DEL_CMD, netdev_name);
1217         if (system(command) == -1) {
1218             VLOG_WARN_RL(&rl, "%s: problem removing policing", netdev_name);
1219         }
1220
1221         snprintf(command, sizeof(command), POLICE_ADD_CMD, netdev_name);
1222         if (system(command) != 0) {
1223             VLOG_WARN_RL(&rl, "%s: problem adding policing", netdev_name);
1224             return -1;
1225         }
1226
1227         snprintf(command, sizeof(command), POLICE_CONFIG_CMD, netdev_name,
1228                 kbits_rate, kbits_burst);
1229         if (system(command) != 0) {
1230             VLOG_WARN_RL(&rl, "%s: problem configuring policing", 
1231                     netdev_name);
1232             return -1;
1233         }
1234     } else {
1235         snprintf(command, sizeof(command), POLICE_DEL_CMD, netdev_name);
1236         if (system(command) == -1) {
1237             VLOG_WARN_RL(&rl, "%s: problem removing policing", netdev_name);
1238         }
1239     }
1240
1241     return 0;
1242 }
1243
1244 int
1245 netdev_set_policing(struct netdev *netdev, uint32_t kbits_rate,
1246                     uint32_t kbits_burst)
1247 {
1248     return netdev_nodev_set_policing(netdev->name, kbits_rate, kbits_burst);
1249 }
1250
1251 /* Initializes 'svec' with a list of the names of all known network devices. */
1252 void
1253 netdev_enumerate(struct svec *svec)
1254 {
1255     struct if_nameindex *names;
1256
1257     svec_init(svec);
1258     names = if_nameindex();
1259     if (names) {
1260         size_t i;
1261
1262         for (i = 0; names[i].if_name != NULL; i++) {
1263             svec_add(svec, names[i].if_name);
1264         }
1265         if_freenameindex(names);
1266     } else {
1267         VLOG_WARN("could not obtain list of network device names: %s",
1268                   strerror(errno));
1269     }
1270 }
1271
1272 /* Obtains the current flags for the network device named 'netdev_name' and
1273  * stores them into '*flagsp'.  Returns 0 if successful, otherwise a positive
1274  * errno value.  On error, stores 0 into '*flagsp'.
1275  *
1276  * If only device flags are needed, this is more efficient than calling
1277  * netdev_open(), netdev_get_flags(), netdev_close(). */
1278 int
1279 netdev_nodev_get_flags(const char *netdev_name, enum netdev_flags *flagsp)
1280 {
1281     int error, flags;
1282
1283     init_netdev();
1284
1285     *flagsp = 0;
1286     error = get_flags(netdev_name, &flags);
1287     if (error) {
1288         return error;
1289     }
1290
1291     if (flags & IFF_UP) {
1292         *flagsp |= NETDEV_UP;
1293     }
1294     if (flags & IFF_PROMISC) {
1295         *flagsp |= NETDEV_PROMISC;
1296     }
1297     return 0;
1298 }
1299
1300 int
1301 netdev_nodev_get_etheraddr(const char *netdev_name, uint8_t mac[6])
1302 {
1303     init_netdev();
1304
1305     return get_etheraddr(netdev_name, mac, NULL);
1306 }
1307
1308 /* If 'netdev_name' is the name of a VLAN network device (e.g. one created with
1309  * vconfig(8)), sets '*vlan_vid' to the VLAN VID associated with that device
1310  * and returns 0.  Otherwise returns a errno value (specifically ENOENT if
1311  * 'netdev_name' is the name of a network device that is not a VLAN device) and
1312  * sets '*vlan_vid' to -1. */
1313 int
1314 netdev_get_vlan_vid(const char *netdev_name, int *vlan_vid)
1315 {
1316     struct ds line = DS_EMPTY_INITIALIZER;
1317     FILE *stream = NULL;
1318     int error;
1319     char *fn;
1320
1321     COVERAGE_INC(netdev_get_vlan_vid);
1322     fn = xasprintf("/proc/net/vlan/%s", netdev_name);
1323     stream = fopen(fn, "r");
1324     if (!stream) {
1325         error = errno;
1326         goto done;
1327     }
1328
1329     if (ds_get_line(&line, stream)) {
1330         if (ferror(stream)) {
1331             error = errno;
1332             VLOG_ERR_RL(&rl, "error reading \"%s\": %s", fn, strerror(errno));
1333         } else {
1334             error = EPROTO;
1335             VLOG_ERR_RL(&rl, "unexpected end of file reading \"%s\"", fn);
1336         }
1337         goto done;
1338     }
1339
1340     if (!sscanf(ds_cstr(&line), "%*s VID: %d", vlan_vid)) {
1341         error = EPROTO;
1342         VLOG_ERR_RL(&rl, "parse error reading \"%s\" line 1: \"%s\"",
1343                     fn, ds_cstr(&line));
1344         goto done;
1345     }
1346
1347     error = 0;
1348
1349 done:
1350     free(fn);
1351     if (stream) {
1352         fclose(stream);
1353     }
1354     ds_destroy(&line);
1355     if (error) {
1356         *vlan_vid = -1;
1357     }
1358     return error;
1359 }
1360 \f
1361 static void restore_all_flags(void *aux);
1362
1363 /* Set up a signal hook to restore network device flags on program
1364  * termination.  */
1365 static void
1366 init_netdev(void)
1367 {
1368     static bool inited;
1369     if (!inited) {
1370         int ifindex;
1371         int error;
1372
1373         inited = true;
1374
1375         fatal_signal_add_hook(restore_all_flags, NULL, true);
1376
1377         af_inet_sock = socket(AF_INET, SOCK_DGRAM, 0);
1378         if (af_inet_sock < 0) {
1379             ovs_fatal(errno, "socket(AF_INET)");
1380         }
1381
1382         error = nl_sock_create(NETLINK_ROUTE, 0, 0, 0, &rtnl_sock);
1383         if (error) {
1384             ovs_fatal(error, "socket(AF_NETLINK, NETLINK_ROUTE)");
1385         }
1386
1387         /* Decide on the netdev_get_stats() implementation to use.  Netlink is
1388          * preferable, so if that works, we'll use it. */
1389         ifindex = do_get_ifindex("lo");
1390         if (ifindex < 0) {
1391             VLOG_WARN("failed to get ifindex for lo, "
1392                       "obtaining netdev stats from proc");
1393             use_netlink_stats = false;
1394         } else {
1395             struct netdev_stats stats;
1396             error = get_stats_via_netlink(ifindex, &stats);
1397             if (!error) {
1398                 VLOG_DBG("obtaining netdev stats via rtnetlink");
1399                 use_netlink_stats = true;
1400             } else {
1401                 VLOG_INFO("RTM_GETLINK failed (%s), obtaining netdev stats "
1402                           "via proc (you are probably running a pre-2.6.19 "
1403                           "kernel)", strerror(error));
1404                 use_netlink_stats = false;
1405             }
1406         }
1407     }
1408 }
1409
1410 /* Restore the network device flags on 'netdev' to those that were active
1411  * before we changed them.  Returns 0 if successful, otherwise a positive
1412  * errno value.
1413  *
1414  * To avoid reentry, the caller must ensure that fatal signals are blocked. */
1415 static int
1416 restore_flags(struct netdev *netdev)
1417 {
1418     struct ifreq ifr;
1419     int restore_flags;
1420
1421     /* Get current flags. */
1422     strncpy(ifr.ifr_name, netdev->name, sizeof ifr.ifr_name);
1423     COVERAGE_INC(netdev_get_flags);
1424     if (ioctl(netdev->netdev_fd, SIOCGIFFLAGS, &ifr) < 0) {
1425         return errno;
1426     }
1427
1428     /* Restore flags that we might have changed, if necessary. */
1429     restore_flags = netdev->changed_flags & (IFF_PROMISC | IFF_UP);
1430     if ((ifr.ifr_flags ^ netdev->save_flags) & restore_flags) {
1431         ifr.ifr_flags &= ~restore_flags;
1432         ifr.ifr_flags |= netdev->save_flags & restore_flags;
1433         COVERAGE_INC(netdev_set_flags);
1434         if (ioctl(netdev->netdev_fd, SIOCSIFFLAGS, &ifr) < 0) {
1435             return errno;
1436         }
1437     }
1438
1439     return 0;
1440 }
1441
1442 /* Retores all the flags on all network devices that we modified.  Called from
1443  * a signal handler, so it does not attempt to report error conditions. */
1444 static void
1445 restore_all_flags(void *aux UNUSED)
1446 {
1447     struct netdev *netdev;
1448     LIST_FOR_EACH (netdev, struct netdev, node, &netdev_list) {
1449         restore_flags(netdev);
1450     }
1451 }
1452
1453 static int
1454 get_flags(const char *netdev_name, int *flags)
1455 {
1456     struct ifreq ifr;
1457     strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
1458     COVERAGE_INC(netdev_get_flags);
1459     if (ioctl(af_inet_sock, SIOCGIFFLAGS, &ifr) < 0) {
1460         VLOG_ERR("ioctl(SIOCGIFFLAGS) on %s device failed: %s",
1461                  netdev_name, strerror(errno));
1462         return errno;
1463     }
1464     *flags = ifr.ifr_flags;
1465     return 0;
1466 }
1467
1468 static int
1469 set_flags(const char *netdev_name, int flags)
1470 {
1471     struct ifreq ifr;
1472     strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
1473     ifr.ifr_flags = flags;
1474     COVERAGE_INC(netdev_set_flags);
1475     if (ioctl(af_inet_sock, SIOCSIFFLAGS, &ifr) < 0) {
1476         VLOG_ERR("ioctl(SIOCSIFFLAGS) on %s device failed: %s",
1477                  netdev_name, strerror(errno));
1478         return errno;
1479     }
1480     return 0;
1481 }
1482
1483 static int
1484 do_get_ifindex(const char *netdev_name)
1485 {
1486     struct ifreq ifr;
1487
1488     strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
1489     COVERAGE_INC(netdev_get_ifindex);
1490     if (ioctl(af_inet_sock, SIOCGIFINDEX, &ifr) < 0) {
1491         VLOG_WARN_RL(&rl, "ioctl(SIOCGIFINDEX) on %s device failed: %s",
1492                      netdev_name, strerror(errno));
1493         return -errno;
1494     }
1495     return ifr.ifr_ifindex;
1496 }
1497
1498 static int
1499 get_ifindex(const struct netdev *netdev, int *ifindexp)
1500 {
1501     *ifindexp = 0;
1502     if (netdev->ifindex < 0) {
1503         int ifindex = do_get_ifindex(netdev->name);
1504         if (ifindex < 0) {
1505             return -ifindex;
1506         }
1507         ((struct netdev *) netdev)->ifindex = ifindex;
1508     }
1509     *ifindexp = netdev->ifindex;
1510     return 0;
1511 }
1512
1513 static int
1514 get_etheraddr(const char *netdev_name, uint8_t ea[ETH_ADDR_LEN],
1515               int *hwaddr_familyp)
1516 {
1517     struct ifreq ifr;
1518
1519     memset(&ifr, 0, sizeof ifr);
1520     strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
1521     COVERAGE_INC(netdev_get_hwaddr);
1522     if (ioctl(af_inet_sock, SIOCGIFHWADDR, &ifr) < 0) {
1523         VLOG_ERR("ioctl(SIOCGIFHWADDR) on %s device failed: %s",
1524                  netdev_name, strerror(errno));
1525         return errno;
1526     }
1527     if (hwaddr_familyp) {
1528         int hwaddr_family = ifr.ifr_hwaddr.sa_family;
1529         *hwaddr_familyp = hwaddr_family;
1530         if (hwaddr_family != AF_UNSPEC && hwaddr_family != ARPHRD_ETHER) {
1531             VLOG_WARN("%s device has unknown hardware address family %d",
1532                       netdev_name, hwaddr_family);
1533         }
1534     }
1535     memcpy(ea, ifr.ifr_hwaddr.sa_data, ETH_ADDR_LEN);
1536     return 0;
1537 }
1538
1539 static int
1540 set_etheraddr(const char *netdev_name, int hwaddr_family,
1541               const uint8_t mac[ETH_ADDR_LEN])
1542 {
1543     struct ifreq ifr;
1544
1545     memset(&ifr, 0, sizeof ifr);
1546     strncpy(ifr.ifr_name, netdev_name, sizeof ifr.ifr_name);
1547     ifr.ifr_hwaddr.sa_family = hwaddr_family;
1548     memcpy(ifr.ifr_hwaddr.sa_data, mac, ETH_ADDR_LEN);
1549     COVERAGE_INC(netdev_set_hwaddr);
1550     if (ioctl(af_inet_sock, SIOCSIFHWADDR, &ifr) < 0) {
1551         VLOG_ERR("ioctl(SIOCSIFHWADDR) on %s device failed: %s",
1552                  netdev_name, strerror(errno));
1553         return errno;
1554     }
1555     return 0;
1556 }