dev.c

   1 #include <string.h>
   2 #include <errno.h>
   3 #include <sys/ioctl.h>
   4 #include <sys/types.h>
   5 #include <sys/socket.h>
   6 #include <linux/if_arp.h>
   7 #include <ifaddrs.h>
   8
   9 #include "dev.h"
  10 #include "str.h"
  11 #include "sock.h"
  12 #include "die.h"
  13 #include "link.h"
  14 #include "built_in.h"
  15
  16 int device_ifindex(const char *ifname)
  17 {
  18         int ret, sock, index;
  19         struct ifreq ifr;
  20
  21         if (!strncmp("any", ifname, strlen("any")))
  22                 return 0;
  23
  24         sock = af_socket(AF_INET);
  25
  26         memset(&ifr, 0, sizeof(ifr));
  27         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
  28
  29         ret = ioctl(sock, SIOCGIFINDEX, &ifr);
  30         if (unlikely(ret))
  31                 panic("Cannot get ifindex from device!\n");
  32
  33         index = ifr.ifr_ifindex;
  34         close(sock);
  35
  36         return index;
  37 }
  38
  39 int device_type(const char *ifname)
  40 {
  41         int ret, sock, type;
  42         struct ifreq ifr;
  43
  44         if (!strncmp("any", ifname, strlen("any")))
  45                 return ARPHRD_ETHER;
  46
  47         sock = af_socket(AF_INET);
  48
  49         memset(&ifr, 0, sizeof(ifr));
  50         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
  51
  52         ret = ioctl(sock, SIOCGIFHWADDR, &ifr);
  53         if (unlikely(ret))
  54                 panic("Cannot get iftype from device!\n");
  55
  56         /* dev->type */
  57         type = ifr.ifr_hwaddr.sa_family;
  58         close(sock);
  59
  60         return type;
  61 }
  62
  63 static int __device_address6(const char *ifname, struct sockaddr_storage *ss)
  64 {
  65         int ret, family, found = -EINVAL;
  66         struct ifaddrs *ifaddr, *ifa;
  67
  68         ret = getifaddrs(&ifaddr);
  69         if (unlikely(ret < 0))
  70                 panic("Cannot get device addresses for IPv6!\n");
  71
  72         for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
  73                 family = ifa->ifa_addr->sa_family;
  74                 if (family != AF_INET6)
  75                         continue;
  76                 if (strcmp(ifa->ifa_name, ifname))
  77                         continue;
  78
  79                 memcpy(ss, ifa->ifa_addr, sizeof(*ss));
  80                 found = 0;
  81                 break;
  82         }
  83
  84         freeifaddrs(ifaddr);
  85         return found;
  86 }
  87
  88 int device_address(const char *ifname, int af, struct sockaddr_storage *ss)
  89 {
  90         int ret, sock;
  91         struct ifreq ifr;
  92
  93         if (unlikely(!ss))
  94                 return -EINVAL;
  95         if (!strncmp("any", ifname, strlen("any")))
  96                 return -EINVAL;
  97         if (af == AF_INET6)
  98                 return __device_address6(ifname, ss);
  99
 100         sock = af_socket(af);
 101
 102         memset(&ifr, 0, sizeof(ifr));
 103         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 104
 105         ifr.ifr_addr.sa_family = af;
 106
 107         ret = ioctl(sock, SIOCGIFADDR, &ifr);
 108         if (likely(!ret))
 109                 memcpy(ss, &ifr.ifr_addr, sizeof(ifr.ifr_addr));
 110
 111         close(sock);
 112         return ret;
 113 }
 114
 115 int device_mtu(const char *ifname)
 116 {
 117         int ret, sock, mtu = 0;
 118         struct ifreq ifr;
 119
 120         sock = af_socket(AF_INET);
 121
 122         memset(&ifr, 0, sizeof(ifr));
 123         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 124
 125         ret = ioctl(sock, SIOCGIFMTU, &ifr);
 126         if (likely(!ret))
 127                 mtu = ifr.ifr_mtu;
 128
 129         close(sock);
 130         return mtu;
 131 }
 132
 133 short device_get_flags(const char *ifname)
 134 {
 135         short flags = 0;
 136         int ret, sock;
 137         struct ifreq ifr;
 138
 139         sock = af_socket(AF_INET);
 140
 141         memset(&ifr, 0, sizeof(ifr));
 142         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 143
 144         ret = ioctl(sock, SIOCGIFFLAGS, &ifr);
 145         if (likely(!ret))
 146                 flags = ifr.ifr_flags;
 147
 148         close(sock);
 149         return flags;
 150 }
 151
 152 void device_set_flags(const char *ifname, const short flags)
 153 {
 154         int ret, sock;
 155         struct ifreq ifr;
 156
 157         sock = af_socket(AF_INET);
 158
 159         memset(&ifr, 0, sizeof(ifr));
 160         strlcpy(ifr.ifr_name, ifname, IFNAMSIZ);
 161         ifr.ifr_flags = flags;
 162
 163         ret = ioctl(sock, SIOCSIFFLAGS, &ifr);
 164         if (unlikely(ret < 0))
 165                 panic("Cannot set NIC flags!\n");
 166
 167         close(sock);
 168 }
 169
 170 int device_up_and_running(char *ifname)
 171 {
 172         if (!ifname)
 173                 return -EINVAL;
 174         if (!strncmp("any", ifname, strlen("any")))
 175                 return 1;
 176
 177         return (device_get_flags(ifname) &
 178                 (IFF_UP | IFF_RUNNING)) ==
 179                 (IFF_UP | IFF_RUNNING);
 180 }
 181
 182 u32 device_bitrate(const char *ifname)
 183 {
 184         u32 scopper, swireless;
 185
 186         scopper   = ethtool_bitrate(ifname);
 187         swireless = wireless_bitrate(ifname);
 188
 189         return scopper ? : swireless;
 190 }