lib/libcr/net/getifaddrs.c

   1 /*      $FreeBSD: src/lib/libc/net/getifaddrs.c,v 1.1.2.4 2002/08/01 19:31:06 ume Exp $ */
   2 /*      $DragonFly: src/lib/libcr/net/Attic/getifaddrs.c,v 1.3 2003/07/13 05:45:05 dillon Exp $ */
   3 /*      $KAME: getifaddrs.c,v 1.9 2001/08/20 02:31:20 itojun Exp $      */
   4
   5 /*
   6  * Copyright (c) 1995, 1999
   7  *      Berkeley Software Design, Inc.  All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY Berkeley Software Design, Inc. ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL Berkeley Software Design, Inc. BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  *
  27  *      BSDI getifaddrs.c,v 2.12 2000/02/23 14:51:59 dab Exp
  28  */
  29 /*
  30  * NOTE: SIOCGIFCONF case is not LP64 friendly.  it also does not perform
  31  * try-and-error for region size.
  32  */
  33 #include <sys/param.h>
  34 #include <sys/types.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/socket.h>
  37 #include <net/if.h>
  38 #ifdef  NET_RT_IFLIST
  39 #include <net/route.h>
  40 #include <sys/sysctl.h>
  41 #include <net/if_dl.h>
  42 #endif
  43
  44 #include <errno.h>
  45 #include <ifaddrs.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48
  49 #if !defined(AF_LINK)
  50 #define SA_LEN(sa)      sizeof(struct sockaddr)
  51 #endif
  52
  53 #if !defined(SA_LEN)
  54 #define SA_LEN(sa)      (sa)->sa_len
  55 #endif
  56
  57 #define SALIGN  (sizeof(long) - 1)
  58 #define SA_RLEN(sa)     ((sa)->sa_len ? (((sa)->sa_len + SALIGN) & ~SALIGN) : (SALIGN + 1))
  59
  60 #ifndef ALIGNBYTES
  61 /*
  62  * On systems with a routing socket, ALIGNBYTES should match the value
  63  * that the kernel uses when building the messages.
  64  */
  65 #define ALIGNBYTES      XXX
  66 #endif
  67 #ifndef ALIGN
  68 #define ALIGN(p)        (((u_long)(p) + ALIGNBYTES) &~ ALIGNBYTES)
  69 #endif
  70
  71 #if     _BSDI_VERSION >= 199701
  72 #define HAVE_IFM_DATA
  73 #endif
  74
  75 #if     _BSDI_VERSION >= 199802
  76 /* ifam_data is very specific to recent versions of bsdi */
  77 #define HAVE_IFAM_DATA
  78 #endif
  79
  80 #if defined(__NetBSD__) || defined(__OpenBSD__) || defined(__FreeBSD__)
  81 #define HAVE_IFM_DATA
  82 #endif
  83
  84 #define MAX_SYSCTL_TRY 5
  85
  86 int
  87 getifaddrs(struct ifaddrs **pif)
  88 {
  89         int icnt = 1;
  90         int dcnt = 0;
  91         int ncnt = 0;
  92 #ifdef  NET_RT_IFLIST
  93         int ntry = 0;
  94         int mib[6];
  95         size_t needed;
  96         char *buf;
  97         char *next;
  98         struct ifaddrs *cif = 0;
  99         char *p, *p0;
 100         struct rt_msghdr *rtm;
 101         struct if_msghdr *ifm;
 102         struct ifa_msghdr *ifam;
 103         struct sockaddr_dl *dl;
 104         struct sockaddr *sa;
 105         struct ifaddrs *ifa, *ift;
 106         u_short idx = 0;
 107 #else   /* NET_RT_IFLIST */
 108         char buf[1024];
 109         int m, sock;
 110         struct ifconf ifc;
 111         struct ifreq *ifr;
 112         struct ifreq *lifr;
 113 #endif  /* NET_RT_IFLIST */
 114         int i;
 115         size_t len, alen;
 116         char *data;
 117         char *names;
 118
 119 #ifdef  NET_RT_IFLIST
 120         mib[0] = CTL_NET;
 121         mib[1] = PF_ROUTE;
 122         mib[2] = 0;             /* protocol */
 123         mib[3] = 0;             /* wildcard address family */
 124         mib[4] = NET_RT_IFLIST;
 125         mib[5] = 0;             /* no flags */
 126         do {
 127                 /*
 128                  * We'll try to get addresses several times in case that
 129                  * the number of addresses is unexpectedly increased during
 130                  * the two sysctl calls.  This should rarely happen, but we'll
 131                  * try to do our best for applications that assume success of
 132                  * this library (which should usually be the case).
 133                  * Portability note: since FreeBSD does not add margin of
 134                  * memory at the first sysctl, the possibility of failure on
 135                  * the second sysctl call is a bit higher.
 136                  */
 137
 138                 if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
 139                         return (-1);
 140                 if ((buf = malloc(needed)) == NULL)
 141                         return (-1);
 142                 if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0) {
 143                         if (errno != ENOMEM || ++ntry >= MAX_SYSCTL_TRY) {
 144                                 free(buf);
 145                                 return (-1);
 146                         }
 147                         free(buf);
 148                         buf = NULL;
 149                 }
 150         } while (buf == NULL);
 151
 152         for (next = buf; next < buf + needed; next += rtm->rtm_msglen) {
 153                 rtm = (struct rt_msghdr *)(void *)next;
 154                 if (rtm->rtm_version != RTM_VERSION)
 155                         continue;
 156                 switch (rtm->rtm_type) {
 157                 case RTM_IFINFO:
 158                         ifm = (struct if_msghdr *)(void *)rtm;
 159                         if (ifm->ifm_addrs & RTA_IFP) {
 160                                 idx = ifm->ifm_index;
 161                                 ++icnt;
 162                                 dl = (struct sockaddr_dl *)(void *)(ifm + 1);
 163                                 dcnt += SA_RLEN((struct sockaddr *)(void*)dl) +
 164                                     ALIGNBYTES;
 165 #ifdef  HAVE_IFM_DATA
 166                                 dcnt += sizeof(ifm->ifm_data);
 167 #endif  /* HAVE_IFM_DATA */
 168                                 ncnt += dl->sdl_nlen + 1;
 169                         } else
 170                                 idx = 0;
 171                         break;
 172
 173                 case RTM_NEWADDR:
 174                         ifam = (struct ifa_msghdr *)(void *)rtm;
 175                         if (idx && ifam->ifam_index != idx)
 176                                 abort();        /* this cannot happen */
 177
 178 #define RTA_MASKS       (RTA_NETMASK | RTA_IFA | RTA_BRD)
 179                         if (idx == 0 || (ifam->ifam_addrs & RTA_MASKS) == 0)
 180                                 break;
 181                         p = (char *)(void *)(ifam + 1);
 182                         ++icnt;
 183 #ifdef  HAVE_IFAM_DATA
 184                         dcnt += sizeof(ifam->ifam_data) + ALIGNBYTES;
 185 #endif  /* HAVE_IFAM_DATA */
 186                         /* Scan to look for length of address */
 187                         alen = 0;
 188                         for (p0 = p, i = 0; i < RTAX_MAX; i++) {
 189                                 if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
 190                                     == 0)
 191                                         continue;
 192                                 sa = (struct sockaddr *)(void *)p;
 193                                 len = SA_RLEN(sa);
 194                                 if (i == RTAX_IFA) {
 195                                         alen = len;
 196                                         break;
 197                                 }
 198                                 p += len;
 199                         }
 200                         for (p = p0, i = 0; i < RTAX_MAX; i++) {
 201                                 if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
 202                                     == 0)
 203                                         continue;
 204                                 sa = (struct sockaddr *)(void *)p;
 205                                 len = SA_RLEN(sa);
 206                                 if (i == RTAX_NETMASK && SA_LEN(sa) == 0)
 207                                         dcnt += alen;
 208                                 else
 209                                         dcnt += len;
 210                                 p += len;
 211                         }
 212                         break;
 213                 }
 214         }
 215 #else   /* NET_RT_IFLIST */
 216         ifc.ifc_buf = buf;
 217         ifc.ifc_len = sizeof(buf);
 218
 219         if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
 220                 return (-1);
 221         i =  ioctl(sock, SIOCGIFCONF, (char *)&ifc);
 222         close(sock);
 223         if (i < 0)
 224                 return (-1);
 225
 226         ifr = ifc.ifc_req;
 227         lifr = (struct ifreq *)&ifc.ifc_buf[ifc.ifc_len];
 228
 229         while (ifr < lifr) {
 230                 struct sockaddr *sa;
 231
 232                 sa = &ifr->ifr_addr;
 233                 ++icnt;
 234                 dcnt += SA_RLEN(sa);
 235                 ncnt += sizeof(ifr->ifr_name) + 1;
 236
 237                 if (SA_LEN(sa) < sizeof(*sa))
 238                         ifr = (struct ifreq *)(((char *)sa) + sizeof(*sa));
 239                 else
 240                         ifr = (struct ifreq *)(((char *)sa) + SA_LEN(sa));
 241         }
 242 #endif  /* NET_RT_IFLIST */
 243
 244         if (icnt + dcnt + ncnt == 1) {
 245                 *pif = NULL;
 246                 free(buf);
 247                 return (0);
 248         }
 249         data = malloc(sizeof(struct ifaddrs) * icnt + dcnt + ncnt);
 250         if (data == NULL) {
 251                 free(buf);
 252                 return(-1);
 253         }
 254
 255         ifa = (struct ifaddrs *)(void *)data;
 256         data += sizeof(struct ifaddrs) * icnt;
 257         names = data + dcnt;
 258
 259         memset(ifa, 0, sizeof(struct ifaddrs) * icnt);
 260         ift = ifa;
 261
 262 #ifdef  NET_RT_IFLIST
 263         idx = 0;
 264         for (next = buf; next < buf + needed; next += rtm->rtm_msglen) {
 265                 rtm = (struct rt_msghdr *)(void *)next;
 266                 if (rtm->rtm_version != RTM_VERSION)
 267                         continue;
 268                 switch (rtm->rtm_type) {
 269                 case RTM_IFINFO:
 270                         ifm = (struct if_msghdr *)(void *)rtm;
 271                         if (ifm->ifm_addrs & RTA_IFP) {
 272                                 idx = ifm->ifm_index;
 273                                 dl = (struct sockaddr_dl *)(void *)(ifm + 1);
 274
 275                                 cif = ift;
 276                                 ift->ifa_name = names;
 277                                 ift->ifa_flags = (int)ifm->ifm_flags;
 278                                 memcpy(names, dl->sdl_data,
 279                                     (size_t)dl->sdl_nlen);
 280                                 names[dl->sdl_nlen] = 0;
 281                                 names += dl->sdl_nlen + 1;
 282
 283                                 ift->ifa_addr = (struct sockaddr *)(void *)data;
 284                                 memcpy(data, dl,
 285                                     (size_t)SA_LEN((struct sockaddr *)
 286                                     (void *)dl));
 287                                 data += SA_RLEN((struct sockaddr *)(void *)dl);
 288
 289 #ifdef  HAVE_IFM_DATA
 290                                 /* ifm_data needs to be aligned */
 291                                 ift->ifa_data = data = (void *)ALIGN(data);
 292                                 memcpy(data, &ifm->ifm_data, sizeof(ifm->ifm_data));
 293                                 data += sizeof(ifm->ifm_data);
 294 #else   /* HAVE_IFM_DATA */
 295                                 ift->ifa_data = NULL;
 296 #endif  /* HAVE_IFM_DATA */
 297
 298                                 ift = (ift->ifa_next = ift + 1);
 299                         } else
 300                                 idx = 0;
 301                         break;
 302
 303                 case RTM_NEWADDR:
 304                         ifam = (struct ifa_msghdr *)(void *)rtm;
 305                         if (idx && ifam->ifam_index != idx)
 306                                 abort();        /* this cannot happen */
 307
 308                         if (idx == 0 || (ifam->ifam_addrs & RTA_MASKS) == 0)
 309                                 break;
 310                         ift->ifa_name = cif->ifa_name;
 311                         ift->ifa_flags = cif->ifa_flags;
 312                         ift->ifa_data = NULL;
 313                         p = (char *)(void *)(ifam + 1);
 314                         /* Scan to look for length of address */
 315                         alen = 0;
 316                         for (p0 = p, i = 0; i < RTAX_MAX; i++) {
 317                                 if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
 318                                     == 0)
 319                                         continue;
 320                                 sa = (struct sockaddr *)(void *)p;
 321                                 len = SA_RLEN(sa);
 322                                 if (i == RTAX_IFA) {
 323                                         alen = len;
 324                                         break;
 325                                 }
 326                                 p += len;
 327                         }
 328                         for (p = p0, i = 0; i < RTAX_MAX; i++) {
 329                                 if ((RTA_MASKS & ifam->ifam_addrs & (1 << i))
 330                                     == 0)
 331                                         continue;
 332                                 sa = (struct sockaddr *)(void *)p;
 333                                 len = SA_RLEN(sa);
 334                                 switch (i) {
 335                                 case RTAX_IFA:
 336                                         ift->ifa_addr =
 337                                             (struct sockaddr *)(void *)data;
 338                                         memcpy(data, p, len);
 339                                         data += len;
 340                                         break;
 341
 342                                 case RTAX_NETMASK:
 343                                         ift->ifa_netmask =
 344                                             (struct sockaddr *)(void *)data;
 345                                         if (SA_LEN(sa) == 0) {
 346                                                 memset(data, 0, alen);
 347                                                 data += alen;
 348                                                 break;
 349                                         }
 350                                         memcpy(data, p, len);
 351                                         data += len;
 352                                         break;
 353
 354                                 case RTAX_BRD:
 355                                         ift->ifa_broadaddr =
 356                                             (struct sockaddr *)(void *)data;
 357                                         memcpy(data, p, len);
 358                                         data += len;
 359                                         break;
 360                                 }
 361                                 p += len;
 362                         }
 363
 364 #ifdef  HAVE_IFAM_DATA
 365                         /* ifam_data needs to be aligned */
 366                         ift->ifa_data = data = (void *)ALIGN(data);
 367                         memcpy(data, &ifam->ifam_data, sizeof(ifam->ifam_data));
 368                         data += sizeof(ifam->ifam_data);
 369 #endif  /* HAVE_IFAM_DATA */
 370
 371                         ift = (ift->ifa_next = ift + 1);
 372                         break;
 373                 }
 374         }
 375
 376         free(buf);
 377 #else   /* NET_RT_IFLIST */
 378         ifr = ifc.ifc_req;
 379         lifr = (struct ifreq *)&ifc.ifc_buf[ifc.ifc_len];
 380
 381         while (ifr < lifr) {
 382                 struct sockaddr *sa;
 383
 384                 ift->ifa_name = names;
 385                 names[sizeof(ifr->ifr_name)] = 0;
 386                 strncpy(names, ifr->ifr_name, sizeof(ifr->ifr_name));
 387                 while (*names++)
 388                         ;
 389
 390                 ift->ifa_addr = (struct sockaddr *)data;
 391                 sa = &ifr->ifr_addr;
 392                 memcpy(data, sa, SA_LEN(sa));
 393                 data += SA_RLEN(sa);
 394
 395                 ifr = (struct ifreq *)(((char *)sa) + SA_LEN(sa));
 396                 ift = (ift->ifa_next = ift + 1);
 397         }
 398 #endif  /* NET_RT_IFLIST */
 399         if (--ift >= ifa) {
 400                 ift->ifa_next = NULL;
 401                 *pif = ifa;
 402         } else {
 403                 *pif = NULL;
 404                 free(ifa);
 405         }
 406         return (0);
 407 }
 408
 409 void
 410 freeifaddrs(struct ifaddrs *ifp)
 411 {
 412
 413         free(ifp);
 414 }