sysdeps/unix/sysv/linux/if_index.c

   1 /* Copyright (C) 1997,98,99,2000,2002,2003,2004 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, write to the Free
  16    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  17    02111-1307 USA.  */
  18
  19 #include <alloca.h>
  20 #include <errno.h>
  21 #include <string.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25 #include <net/if.h>
  26 #include <sys/socket.h>
  27 #include <sys/ioctl.h>
  28 #include <bits/libc-lock.h>
  29 #include <not-cancel.h>
  30
  31 #include "netlinkaccess.h"
  32
  33
  34 /* Variable to signal whether SIOCGIFCONF is not available.  */
  35 # if __ASSUME_SIOCGIFNAME == 0
  36 static int old_siocgifconf;
  37 #else
  38 # define old_siocgifconf 0
  39 #endif
  40
  41
  42 unsigned int
  43 if_nametoindex (const char *ifname)
  44 {
  45 #ifndef SIOCGIFINDEX
  46   __set_errno (ENOSYS);
  47   return 0;
  48 #else
  49   struct ifreq ifr;
  50   int fd = __opensock ();
  51
  52   if (fd < 0)
  53     return 0;
  54
  55   strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
  56   if (__ioctl (fd, SIOCGIFINDEX, &ifr) < 0)
  57     {
  58       int saved_errno = errno;
  59       close_not_cancel_no_status (fd);
  60       if (saved_errno == EINVAL)
  61         __set_errno (ENOSYS);
  62       return 0;
  63     }
  64   close_not_cancel_no_status (fd);
  65   return ifr.ifr_ifindex;
  66 #endif
  67 }
  68 libc_hidden_def (if_nametoindex)
  69
  70
  71 void
  72 if_freenameindex (struct if_nameindex *ifn)
  73 {
  74   struct if_nameindex *ptr = ifn;
  75   while (ptr->if_name || ptr->if_index)
  76     {
  77       free (ptr->if_name);
  78       ++ptr;
  79     }
  80   free (ifn);
  81 }
  82 libc_hidden_def (if_freenameindex)
  83
  84
  85 #if __ASSUME_NETLINK_SUPPORT == 0
  86 static struct if_nameindex *
  87 if_nameindex_ioctl (void)
  88 {
  89   int fd = __opensock ();
  90   struct ifconf ifc;
  91   unsigned int nifs, i;
  92   int rq_len;
  93   struct if_nameindex *idx = NULL;
  94 # define RQ_IFS 4
  95
  96   if (fd < 0)
  97     return NULL;
  98
  99   ifc.ifc_buf = NULL;
 100
 101   /* We may be able to get the needed buffer size directly, rather than
 102      guessing.  */
 103   if (! old_siocgifconf)
 104     {
 105       ifc.ifc_buf = NULL;
 106       ifc.ifc_len = 0;
 107       if (__ioctl (fd, SIOCGIFCONF, &ifc) < 0 || ifc.ifc_len == 0)
 108         {
 109 # if __ASSUME_SIOCGIFNAME == 0
 110           old_siocgifconf = 1;
 111 # endif
 112           rq_len = RQ_IFS * sizeof (struct ifreq);
 113         }
 114       else
 115         rq_len = ifc.ifc_len;
 116     }
 117   else
 118     rq_len = RQ_IFS * sizeof (struct ifreq);
 119
 120   /* Read all the interfaces out of the kernel.  */
 121   ifc.ifc_buf = alloca (rq_len);
 122   ifc.ifc_len = rq_len;
 123   while (1)
 124     {
 125         if (__ioctl (fd, SIOCGIFCONF, &ifc) < 0)
 126         {
 127           close_not_cancel_no_status (fd);
 128           return NULL;
 129         }
 130       if (ifc.ifc_len < rq_len || ! old_siocgifconf)
 131         break;
 132
 133       ifc.ifc_buf = extend_alloca (ifc.ifc_buf, rq_len, 2 * rq_len);
 134       ifc.ifc_len = rq_len;
 135     }
 136
 137   nifs = ifc.ifc_len / sizeof (struct ifreq);
 138
 139   idx = malloc ((nifs + 1) * sizeof (struct if_nameindex));
 140   if (idx == NULL)
 141     {
 142       close_not_cancel_no_status (fd);
 143       __set_errno (ENOBUFS);
 144       return NULL;
 145     }
 146
 147   for (i = 0; i < nifs; ++i)
 148     {
 149       struct ifreq *ifr = &ifc.ifc_req[i];
 150       idx[i].if_name = __strdup (ifr->ifr_name);
 151       if (idx[i].if_name == NULL
 152           || __ioctl (fd, SIOCGIFINDEX, ifr) < 0)
 153         {
 154           int saved_errno = errno;
 155           unsigned int j;
 156
 157           for (j =  0; j < i; ++j)
 158             free (idx[j].if_name);
 159           free (idx);
 160           close_not_cancel_no_status (fd);
 161           if (saved_errno == EINVAL)
 162             saved_errno = ENOSYS;
 163           else if (saved_errno == ENOMEM)
 164             saved_errno = ENOBUFS;
 165           __set_errno (saved_errno);
 166           return NULL;
 167         }
 168       idx[i].if_index = ifr->ifr_ifindex;
 169     }
 170
 171   idx[i].if_index = 0;
 172   idx[i].if_name = NULL;
 173
 174   close_not_cancel_no_status (fd);
 175   return idx;
 176 }
 177 #endif
 178
 179
 180 static struct if_nameindex *
 181 if_nameindex_netlink (void)
 182 {
 183   struct netlink_handle nh = { 0, 0, 0, NULL, NULL };
 184   struct if_nameindex *idx = NULL;
 185
 186   if (__no_netlink_support || __netlink_open (&nh) < 0)
 187     return NULL;
 188
 189
 190   /* Tell the kernel that we wish to get a list of all
 191      active interfaces.  */
 192   if (__netlink_sendreq (&nh, RTM_GETLINK) < 0)
 193     goto exit_close;
 194
 195   /* Collect all data for every interface.  */
 196   if (__netlink_receive (&nh) < 0)
 197     goto exit_free;
 198
 199   /* Count the interfaces.  */
 200   unsigned int nifs = 0;
 201   for (struct netlink_res *nlp = nh.nlm_list; nlp; nlp = nlp->next)
 202     {
 203       struct nlmsghdr *nlh;
 204       size_t size = nlp->size;
 205
 206       if (nlp->nlh == NULL)
 207         continue;
 208
 209       /* Walk through all entries we got from the kernel and look, which
 210          message type they contain.  */
 211       for (nlh = nlp->nlh; NLMSG_OK (nlh, size); nlh = NLMSG_NEXT (nlh, size))
 212         {
 213           /* Check if the message is what we want.  */
 214           if ((pid_t) nlh->nlmsg_pid != nh.pid || nlh->nlmsg_seq != nlp->seq)
 215             continue;
 216
 217           if (nlh->nlmsg_type == NLMSG_DONE)
 218             break;              /* ok */
 219
 220           if (nlh->nlmsg_type == RTM_NEWLINK)
 221             ++nifs;
 222         }
 223     }
 224
 225   idx = malloc ((nifs + 1) * sizeof (struct if_nameindex));
 226   if (idx == NULL)
 227     {
 228     nomem:
 229       __set_errno (ENOBUFS);
 230       goto exit_free;
 231     }
 232
 233   /* Add the interfaces.  */
 234   nifs = 0;
 235   for (struct netlink_res *nlp = nh.nlm_list; nlp; nlp = nlp->next)
 236     {
 237       struct nlmsghdr *nlh;
 238       size_t size = nlp->size;
 239
 240       if (nlp->nlh == NULL)
 241         continue;
 242
 243       /* Walk through all entries we got from the kernel and look, which
 244          message type they contain.  */
 245       for (nlh = nlp->nlh; NLMSG_OK (nlh, size); nlh = NLMSG_NEXT (nlh, size))
 246         {
 247           /* Check if the message is what we want.  */
 248           if ((pid_t) nlh->nlmsg_pid != nh.pid || nlh->nlmsg_seq != nlp->seq)
 249             continue;
 250
 251           if (nlh->nlmsg_type == NLMSG_DONE)
 252             break;              /* ok */
 253
 254           if (nlh->nlmsg_type == RTM_NEWLINK)
 255             {
 256               struct ifinfomsg *ifim = (struct ifinfomsg *) NLMSG_DATA (nlh);
 257               struct rtattr *rta = IFLA_RTA (ifim);
 258               size_t rtasize = IFLA_PAYLOAD (nlh);
 259
 260               idx[nifs].if_index = ifim->ifi_index;
 261
 262               while (RTA_OK (rta, rtasize))
 263                 {
 264                   char *rta_data = RTA_DATA (rta);
 265                   size_t rta_payload = RTA_PAYLOAD (rta);
 266
 267                   if (rta->rta_type == IFLA_IFNAME)
 268                     {
 269                       idx[nifs].if_name = __strndup (rta_data, rta_payload);
 270                       if (idx[nifs].if_name == NULL)
 271                         {
 272                           idx[nifs].if_index = 0;
 273                           if_freenameindex (idx);
 274                           idx = NULL;
 275                           goto nomem;
 276                         }
 277                       break;
 278                     }
 279
 280                   rta = RTA_NEXT (rta, rtasize);
 281                 }
 282
 283               ++nifs;
 284             }
 285         }
 286     }
 287
 288   idx[nifs].if_index = 0;
 289   idx[nifs].if_name = NULL;
 290
 291  exit_free:
 292   __netlink_free_handle (&nh);
 293  exit_close:
 294   __netlink_close (&nh);
 295
 296   return idx;
 297 }
 298
 299
 300 struct if_nameindex *
 301 if_nameindex (void)
 302 {
 303 #ifndef SIOCGIFINDEX
 304   __set_errno (ENOSYS);
 305   return NULL;
 306 #else
 307   struct if_nameindex *result = if_nameindex_netlink ();
 308 # if __ASSUME_NETLINK_SUPPORT == 0
 309   if (__no_netlink_support)
 310     result = if_nameindex_ioctl ();
 311 # endif
 312   return result;
 313 #endif
 314 }
 315 libc_hidden_def (if_nameindex)
 316
 317
 318 char *
 319 if_indextoname (unsigned int ifindex, char *ifname)
 320 {
 321 #if !defined SIOCGIFINDEX && __ASSUME_SIOCGIFNAME == 0
 322   __set_errno (ENOSYS);
 323   return NULL;
 324 #else
 325 # if __ASSUME_SIOCGIFNAME == 0
 326   struct if_nameindex *idx;
 327   struct if_nameindex *p;
 328   char *result = NULL;
 329 # endif
 330
 331 # if defined SIOCGIFNAME || __ASSUME_SIOCGIFNAME > 0
 332   /* We may be able to do the conversion directly, rather than searching a
 333      list.  This ioctl is not present in kernels before version 2.1.50.  */
 334   struct ifreq ifr;
 335   int fd;
 336 #  if __ASSUME_SIOCGIFNAME == 0
 337   static int siocgifname_works_not;
 338
 339   if (!siocgifname_works_not)
 340 #  endif
 341     {
 342 #  if __ASSUME_SIOCGIFNAME == 0
 343       int serrno = errno;
 344 #  endif
 345       int status;
 346
 347       fd = __opensock ();
 348
 349       if (fd < 0)
 350         return NULL;
 351
 352       ifr.ifr_ifindex = ifindex;
 353       status = __ioctl (fd, SIOCGIFNAME, &ifr);
 354
 355       close_not_cancel_no_status (fd);
 356
 357       if (status  < 0)
 358         {
 359 #  if __ASSUME_SIOCGIFNAME == 0
 360           if (errno == EINVAL)
 361             siocgifname_works_not = 1; /* Don't make the same mistake twice. */
 362           else
 363 #  endif
 364             {
 365               if (errno == ENODEV)
 366                 /* POSIX requires ENXIO.  */
 367                 __set_errno (ENXIO);
 368
 369               return NULL;
 370             }
 371         }
 372       else
 373         return strncpy (ifname, ifr.ifr_name, IFNAMSIZ);
 374
 375 #  if __ASSUME_SIOCGIFNAME == 0
 376       __set_errno (serrno);
 377 #  endif
 378     }
 379 # endif
 380
 381 # if __ASSUME_SIOCGIFNAME == 0
 382   idx = if_nameindex ();
 383
 384   if (idx != NULL)
 385     {
 386       for (p = idx; p->if_index || p->if_name; ++p)
 387         if (p->if_index == ifindex)
 388           {
 389             result = strncpy (ifname, p->if_name, IFNAMSIZ);
 390             break;
 391           }
 392
 393       if_freenameindex (idx);
 394
 395       if (result == NULL)
 396         __set_errno (ENXIO);
 397     }
 398   return result;
 399 # endif
 400 #endif
 401 }
 402 libc_hidden_def (if_indextoname)
 403
 404
 405 #if 0
 406 void
 407 internal_function
 408 __protocol_available (int *have_inet, int *have_inet6)
 409 {
 410   int fd = __opensock ();
 411   unsigned int nifs;
 412   int rq_len;
 413   struct ifconf ifc;
 414 # define RQ_IFS 4
 415
 416   /* Wirst case assumption.  */
 417   *have_inet = 0;
 418   *have_inet6 = 0;
 419
 420   if (fd < 0)
 421     /* We cannot open the socket.  No networking at all?  */
 422     return;
 423
 424   /* We may be able to get the needed buffer size directly, rather than
 425      guessing.  */
 426   if (! old_siocgifconf)
 427     {
 428       ifc.ifc_buf = NULL;
 429       ifc.ifc_len = 0;
 430       if (__ioctl (fd, SIOCGIFCONF, &ifc) < 0 || ifc.ifc_len == 0)
 431         {
 432 # if __ASSUME_SIOCGIFNAME == 0
 433           old_siocgifconf = 1;
 434 # endif
 435           rq_len = RQ_IFS * sizeof (struct ifreq);
 436         }
 437       else
 438         rq_len = ifc.ifc_len;
 439     }
 440   else
 441     rq_len = RQ_IFS * sizeof (struct ifreq);
 442
 443   /* Read all the interfaces out of the kernel.  */
 444   do
 445     {
 446       ifc.ifc_buf = alloca (ifc.ifc_len = rq_len);
 447       if (__ioctl (fd, SIOCGIFCONF, &ifc) < 0)
 448         {
 449           close_not_cancel_no_status (fd);
 450           return;
 451         }
 452       rq_len *= 2;
 453     }
 454   while (ifc.ifc_len == rq_len && old_siocgifconf);
 455
 456   nifs = ifc.ifc_len / sizeof (struct ifreq);
 457
 458   /* Go through all the interfaces and get the address.  */
 459   while (nifs-- > 0)
 460     if (__ioctl (fd, SIOCGIFADDR, &ifc.ifc_req[nifs]) >= 0)
 461       {
 462         /* We successfully got information about this interface.  Now
 463            test whether it is an IPv4 or IPv6 address.  */
 464         if (ifc.ifc_req[nifs].ifr_addr.sa_family == AF_INET)
 465           *have_inet = 1;
 466         else if (ifc.ifc_req[nifs].ifr_addr.sa_family == AF_INET6)
 467           *have_inet6 = 1;
 468
 469         /* Note, this is & not &&.  It works since the values are always
 470            0 or 1.  */
 471         if (*have_inet & *have_inet6)
 472           /* We can stop early.  */
 473           break;
 474       }
 475
 476   close_not_cancel_no_status (fd);
 477 }
 478 #endif