sysdeps/unix/sysv/linux/if_index.c

   1 /* Copyright (C) 1997-2014 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <http://www.gnu.org/licenses/>.  */
  17
  18 #include <alloca.h>
  19 #include <errno.h>
  20 #include <string.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24 #include <net/if.h>
  25 #include <sys/socket.h>
  26 #include <sys/ioctl.h>
  27 #include <bits/libc-lock.h>
  28 #include <not-cancel.h>
  29 #include <kernel-features.h>
  30
  31 #include "netlinkaccess.h"
  32
  33
  34 unsigned int
  35 if_nametoindex (const char *ifname)
  36 {
  37 #ifndef SIOCGIFINDEX
  38   __set_errno (ENOSYS);
  39   return 0;
  40 #else
  41   struct ifreq ifr;
  42   int fd = __opensock ();
  43
  44   if (fd < 0)
  45     return 0;
  46
  47   strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
  48   if (__ioctl (fd, SIOCGIFINDEX, &ifr) < 0)
  49     {
  50       int saved_errno = errno;
  51       close_not_cancel_no_status (fd);
  52       if (saved_errno == EINVAL)
  53         __set_errno (ENOSYS);
  54       return 0;
  55     }
  56   close_not_cancel_no_status (fd);
  57   return ifr.ifr_ifindex;
  58 #endif
  59 }
  60 libc_hidden_def (if_nametoindex)
  61
  62
  63 void
  64 if_freenameindex (struct if_nameindex *ifn)
  65 {
  66   struct if_nameindex *ptr = ifn;
  67   while (ptr->if_name || ptr->if_index)
  68     {
  69       free (ptr->if_name);
  70       ++ptr;
  71     }
  72   free (ifn);
  73 }
  74 libc_hidden_def (if_freenameindex)
  75
  76
  77 static struct if_nameindex *
  78 if_nameindex_netlink (void)
  79 {
  80   struct netlink_handle nh = { 0, 0, 0, NULL, NULL };
  81   struct if_nameindex *idx = NULL;
  82
  83   if (__netlink_open (&nh) < 0)
  84     return NULL;
  85
  86
  87   /* Tell the kernel that we wish to get a list of all
  88      active interfaces.  Collect all data for every interface.  */
  89   if (__netlink_request (&nh, RTM_GETLINK) < 0)
  90     goto exit_free;
  91
  92   /* Count the interfaces.  */
  93   unsigned int nifs = 0;
  94   for (struct netlink_res *nlp = nh.nlm_list; nlp; nlp = nlp->next)
  95     {
  96       struct nlmsghdr *nlh;
  97       size_t size = nlp->size;
  98
  99       if (nlp->nlh == NULL)
 100         continue;
 101
 102       /* Walk through all entries we got from the kernel and look, which
 103          message type they contain.  */
 104       for (nlh = nlp->nlh; NLMSG_OK (nlh, size); nlh = NLMSG_NEXT (nlh, size))
 105         {
 106           /* Check if the message is what we want.  */
 107           if ((pid_t) nlh->nlmsg_pid != nh.pid || nlh->nlmsg_seq != nlp->seq)
 108             continue;
 109
 110           if (nlh->nlmsg_type == NLMSG_DONE)
 111             break;              /* ok */
 112
 113           if (nlh->nlmsg_type == RTM_NEWLINK)
 114             ++nifs;
 115         }
 116     }
 117
 118   idx = malloc ((nifs + 1) * sizeof (struct if_nameindex));
 119   if (idx == NULL)
 120     {
 121     nomem:
 122       __set_errno (ENOBUFS);
 123       goto exit_free;
 124     }
 125
 126   /* Add the interfaces.  */
 127   nifs = 0;
 128   for (struct netlink_res *nlp = nh.nlm_list; nlp; nlp = nlp->next)
 129     {
 130       struct nlmsghdr *nlh;
 131       size_t size = nlp->size;
 132
 133       if (nlp->nlh == NULL)
 134         continue;
 135
 136       /* Walk through all entries we got from the kernel and look, which
 137          message type they contain.  */
 138       for (nlh = nlp->nlh; NLMSG_OK (nlh, size); nlh = NLMSG_NEXT (nlh, size))
 139         {
 140           /* Check if the message is what we want.  */
 141           if ((pid_t) nlh->nlmsg_pid != nh.pid || nlh->nlmsg_seq != nlp->seq)
 142             continue;
 143
 144           if (nlh->nlmsg_type == NLMSG_DONE)
 145             break;              /* ok */
 146
 147           if (nlh->nlmsg_type == RTM_NEWLINK)
 148             {
 149               struct ifinfomsg *ifim = (struct ifinfomsg *) NLMSG_DATA (nlh);
 150               struct rtattr *rta = IFLA_RTA (ifim);
 151               size_t rtasize = IFLA_PAYLOAD (nlh);
 152
 153               idx[nifs].if_index = ifim->ifi_index;
 154
 155               while (RTA_OK (rta, rtasize))
 156                 {
 157                   char *rta_data = RTA_DATA (rta);
 158                   size_t rta_payload = RTA_PAYLOAD (rta);
 159
 160                   if (rta->rta_type == IFLA_IFNAME)
 161                     {
 162                       idx[nifs].if_name = __strndup (rta_data, rta_payload);
 163                       if (idx[nifs].if_name == NULL)
 164                         {
 165                           idx[nifs].if_index = 0;
 166                           if_freenameindex (idx);
 167                           idx = NULL;
 168                           goto nomem;
 169                         }
 170                       break;
 171                     }
 172
 173                   rta = RTA_NEXT (rta, rtasize);
 174                 }
 175
 176               ++nifs;
 177             }
 178         }
 179     }
 180
 181   idx[nifs].if_index = 0;
 182   idx[nifs].if_name = NULL;
 183
 184  exit_free:
 185   __netlink_free_handle (&nh);
 186   __netlink_close (&nh);
 187
 188   return idx;
 189 }
 190
 191
 192 struct if_nameindex *
 193 if_nameindex (void)
 194 {
 195 #ifndef SIOCGIFINDEX
 196   __set_errno (ENOSYS);
 197   return NULL;
 198 #else
 199   struct if_nameindex *result = if_nameindex_netlink ();
 200   return result;
 201 #endif
 202 }
 203 libc_hidden_def (if_nameindex)
 204
 205
 206 char *
 207 if_indextoname (unsigned int ifindex, char *ifname)
 208 {
 209   /* We may be able to do the conversion directly, rather than searching a
 210      list.  This ioctl is not present in kernels before version 2.1.50.  */
 211   struct ifreq ifr;
 212   int fd;
 213   int status;
 214
 215   fd = __opensock ();
 216
 217   if (fd < 0)
 218     return NULL;
 219
 220   ifr.ifr_ifindex = ifindex;
 221   status = __ioctl (fd, SIOCGIFNAME, &ifr);
 222
 223   close_not_cancel_no_status (fd);
 224
 225   if (status  < 0)
 226     {
 227       if (errno == ENODEV)
 228         /* POSIX requires ENXIO.  */
 229         __set_errno (ENXIO);
 230
 231       return NULL;
 232     }
 233   else
 234     return strncpy (ifname, ifr.ifr_name, IFNAMSIZ);
 235 }
 236 libc_hidden_def (if_indextoname)