lib/replace/getifaddrs.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4    Copyright (C) Andrew Tridgell 1998
   5    Copyright (C) Jeremy Allison 2007
   6    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2007
   7
   8      ** NOTE! The following LGPL license applies to the replace
   9      ** library. This does NOT imply that all of Samba is released
  10      ** under the LGPL
  11
  12    This library is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU Lesser General Public
  14    License as published by the Free Software Foundation; either
  15    version 3 of the License, or (at your option) any later version.
  16
  17    This library is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20    Library General Public License for more details.
  21
  22    You should have received a copy of the GNU Lesser General Public
  23    License along with this library; if not, see <http://www.gnu.org/licenses/>.
  24 */
  25
  26 #include "replace.h"
  27 #include "system/network.h"
  28
  29 #include <unistd.h>
  30 #include <stdio.h>
  31 #include <sys/types.h>
  32
  33 #ifdef HAVE_SYS_TIME_H
  34 #include <sys/time.h>
  35 #endif
  36
  37 #ifndef SIOCGIFCONF
  38 #ifdef HAVE_SYS_SOCKIO_H
  39 #include <sys/sockio.h>
  40 #endif
  41 #endif
  42
  43 #ifdef HAVE_IFACE_GETIFADDRS
  44 #define _FOUND_IFACE_ANY
  45 #else
  46
  47 void rep_freeifaddrs(struct ifaddrs *ifp)
  48 {
  49         if (ifp != NULL) {
  50                 free(ifp->ifa_name);
  51                 free(ifp->ifa_addr);
  52                 free(ifp->ifa_netmask);
  53                 free(ifp->ifa_dstaddr);
  54                 freeifaddrs(ifp->ifa_next);
  55                 free(ifp);
  56         }
  57 }
  58
  59 static struct sockaddr *sockaddr_dup(struct sockaddr *sa)
  60 {
  61         struct sockaddr *ret;
  62         socklen_t socklen;
  63 #ifdef HAVE_SOCKADDR_SA_LEN
  64         socklen = sa->sa_len;
  65 #else
  66         socklen = sizeof(struct sockaddr_storage);
  67 #endif
  68         ret = calloc(1, socklen);
  69         if (ret == NULL)
  70                 return NULL;
  71         memcpy(ret, sa, socklen);
  72         return ret;
  73 }
  74 #endif
  75
  76 #if HAVE_IFACE_IFCONF
  77
  78 /* this works for Linux 2.2, Solaris 2.5, SunOS4, HPUX 10.20, OSF1
  79    V4.0, Ultrix 4.4, SCO Unix 3.2, IRIX 6.4 and FreeBSD 3.2.
  80
  81    It probably also works on any BSD style system.  */
  82
  83 int rep_getifaddrs(struct ifaddrs **ifap)
  84 {
  85         struct ifconf ifc;
  86         char buff[8192];
  87         int fd, i, n;
  88         struct ifreq *ifr=NULL;
  89         struct ifaddrs *curif;
  90         struct ifaddrs *lastif = NULL;
  91
  92         *ifap = NULL;
  93
  94         if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
  95                 return -1;
  96         }
  97
  98         ifc.ifc_len = sizeof(buff);
  99         ifc.ifc_buf = buff;
 100
 101         if (ioctl(fd, SIOCGIFCONF, &ifc) != 0) {
 102                 close(fd);
 103                 return -1;
 104         }
 105
 106         ifr = ifc.ifc_req;
 107
 108         n = ifc.ifc_len / sizeof(struct ifreq);
 109
 110         /* Loop through interfaces, looking for given IP address */
 111         for (i=n-1; i>=0; i--) {
 112                 if (ioctl(fd, SIOCGIFFLAGS, &ifr[i]) == -1) {
 113                         freeifaddrs(*ifap);
 114                         close(fd);
 115                         return -1;
 116                 }
 117
 118                 curif = calloc(1, sizeof(struct ifaddrs));
 119                 if (curif == NULL) {
 120                         freeifaddrs(*ifap);
 121                         close(fd);
 122                         return -1;
 123                 }
 124                 curif->ifa_name = strdup(ifr[i].ifr_name);
 125                 if (curif->ifa_name == NULL) {
 126                         free(curif);
 127                         freeifaddrs(*ifap);
 128                         close(fd);
 129                         return -1;
 130                 }
 131                 curif->ifa_flags = ifr[i].ifr_flags;
 132                 curif->ifa_dstaddr = NULL;
 133                 curif->ifa_data = NULL;
 134                 curif->ifa_next = NULL;
 135
 136                 curif->ifa_addr = NULL;
 137                 if (ioctl(fd, SIOCGIFADDR, &ifr[i]) != -1) {
 138                         curif->ifa_addr = sockaddr_dup(&ifr[i].ifr_addr);
 139                         if (curif->ifa_addr == NULL) {
 140                                 free(curif->ifa_name);
 141                                 free(curif);
 142                                 freeifaddrs(*ifap);
 143                                 close(fd);
 144                                 return -1;
 145                         }
 146                 }
 147
 148                 curif->ifa_netmask = NULL;
 149                 if (ioctl(fd, SIOCGIFNETMASK, &ifr[i]) != -1) {
 150                         curif->ifa_netmask = sockaddr_dup(&ifr[i].ifr_addr);
 151                         if (curif->ifa_netmask == NULL) {
 152                                 if (curif->ifa_addr != NULL) {
 153                                         free(curif->ifa_addr);
 154                                 }
 155                                 free(curif->ifa_name);
 156                                 free(curif);
 157                                 freeifaddrs(*ifap);
 158                                 close(fd);
 159                                 return -1;
 160                         }
 161                 }
 162
 163                 if (lastif == NULL) {
 164                         *ifap = curif;
 165                 } else {
 166                         lastif->ifa_next = curif;
 167                 }
 168                 lastif = curif;
 169         }
 170
 171         close(fd);
 172
 173         return 0;
 174 }
 175
 176 #define _FOUND_IFACE_ANY
 177 #endif /* HAVE_IFACE_IFCONF */
 178 #ifdef HAVE_IFACE_IFREQ
 179
 180 #ifndef I_STR
 181 #include <sys/stropts.h>
 182 #endif
 183
 184 /****************************************************************************
 185 this should cover most of the streams based systems
 186 Thanks to Andrej.Borsenkow@mow.siemens.ru for several ideas in this code
 187 ****************************************************************************/
 188 int rep_getifaddrs(struct ifaddrs **ifap)
 189 {
 190         struct ifreq ifreq;
 191         struct strioctl strioctl;
 192         char buff[8192];
 193         int fd, i, n;
 194         struct ifreq *ifr=NULL;
 195         struct ifaddrs *curif;
 196         struct ifaddrs *lastif = NULL;
 197
 198         *ifap = NULL;
 199
 200         if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
 201                 return -1;
 202         }
 203
 204         strioctl.ic_cmd = SIOCGIFCONF;
 205         strioctl.ic_dp  = buff;
 206         strioctl.ic_len = sizeof(buff);
 207         if (ioctl(fd, I_STR, &strioctl) < 0) {
 208                 close(fd);
 209                 return -1;
 210         }
 211
 212         /* we can ignore the possible sizeof(int) here as the resulting
 213            number of interface structures won't change */
 214         n = strioctl.ic_len / sizeof(struct ifreq);
 215
 216         /* we will assume that the kernel returns the length as an int
 217            at the start of the buffer if the offered size is a
 218            multiple of the structure size plus an int */
 219         if (n*sizeof(struct ifreq) + sizeof(int) == strioctl.ic_len) {
 220                 ifr = (struct ifreq *)(buff + sizeof(int));
 221         } else {
 222                 ifr = (struct ifreq *)buff;
 223         }
 224
 225         /* Loop through interfaces */
 226
 227         for (i = 0; i<n; i++) {
 228                 ifreq = ifr[i];
 229
 230                 curif = calloc(1, sizeof(struct ifaddrs));
 231                 if (lastif == NULL) {
 232                         *ifap = curif;
 233                 } else {
 234                         lastif->ifa_next = curif;
 235                 }
 236
 237                 strioctl.ic_cmd = SIOCGIFFLAGS;
 238                 strioctl.ic_dp  = (char *)&ifreq;
 239                 strioctl.ic_len = sizeof(struct ifreq);
 240                 if (ioctl(fd, I_STR, &strioctl) != 0) {
 241                         freeifaddrs(*ifap);
 242                         return -1;
 243                 }
 244
 245                 curif->ifa_flags = ifreq.ifr_flags;
 246
 247                 strioctl.ic_cmd = SIOCGIFADDR;
 248                 strioctl.ic_dp  = (char *)&ifreq;
 249                 strioctl.ic_len = sizeof(struct ifreq);
 250                 if (ioctl(fd, I_STR, &strioctl) != 0) {
 251                         freeifaddrs(*ifap);
 252                         return -1;
 253                 }
 254
 255                 curif->ifa_name = strdup(ifreq.ifr_name);
 256                 curif->ifa_addr = sockaddr_dup(&ifreq.ifr_addr);
 257                 curif->ifa_dstaddr = NULL;
 258                 curif->ifa_data = NULL;
 259                 curif->ifa_next = NULL;
 260                 curif->ifa_netmask = NULL;
 261
 262                 strioctl.ic_cmd = SIOCGIFNETMASK;
 263                 strioctl.ic_dp  = (char *)&ifreq;
 264                 strioctl.ic_len = sizeof(struct ifreq);
 265                 if (ioctl(fd, I_STR, &strioctl) != 0) {
 266                         freeifaddrs(*ifap);
 267                         return -1;
 268                 }
 269
 270                 curif->ifa_netmask = sockaddr_dup(&ifreq.ifr_addr);
 271
 272                 lastif = curif;
 273         }
 274
 275         close(fd);
 276
 277         return 0;
 278 }
 279
 280 #define _FOUND_IFACE_ANY
 281 #endif /* HAVE_IFACE_IFREQ */
 282 #ifdef HAVE_IFACE_AIX
 283
 284 /****************************************************************************
 285 this one is for AIX (tested on 4.2)
 286 ****************************************************************************/
 287 int rep_getifaddrs(struct ifaddrs **ifap)
 288 {
 289         char buff[8192];
 290         int fd, i;
 291         struct ifconf ifc;
 292         struct ifreq *ifr=NULL;
 293         struct ifaddrs *curif;
 294         struct ifaddrs *lastif = NULL;
 295
 296         *ifap = NULL;
 297
 298         if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
 299                 return -1;
 300         }
 301
 302         ifc.ifc_len = sizeof(buff);
 303         ifc.ifc_buf = buff;
 304
 305         if (ioctl(fd, SIOCGIFCONF, &ifc) != 0) {
 306                 close(fd);
 307                 return -1;
 308         }
 309
 310         ifr = ifc.ifc_req;
 311
 312         /* Loop through interfaces */
 313         i = ifc.ifc_len;
 314
 315         while (i > 0) {
 316                 unsigned int inc;
 317
 318                 inc = ifr->ifr_addr.sa_len;
 319
 320                 if (ioctl(fd, SIOCGIFADDR, ifr) != 0) {
 321                         freeaddrinfo(*ifap);
 322                         return -1;
 323                 }
 324
 325                 curif = calloc(1, sizeof(struct ifaddrs));
 326                 if (lastif == NULL) {
 327                         *ifap = curif;
 328                 } else {
 329                         lastif->ifa_next = curif;
 330                 }
 331
 332                 curif->ifa_name = strdup(ifr->ifr_name);
 333                 curif->ifa_addr = sockaddr_dup(&ifr->ifr_addr);
 334                 curif->ifa_dstaddr = NULL;
 335                 curif->ifa_data = NULL;
 336                 curif->ifa_netmask = NULL;
 337                 curif->ifa_next = NULL;
 338
 339                 if (ioctl(fd, SIOCGIFFLAGS, ifr) != 0) {
 340                         freeaddrinfo(*ifap);
 341                         return -1;
 342                 }
 343
 344                 curif->ifa_flags = ifr->ifr_flags;
 345
 346                 if (ioctl(fd, SIOCGIFNETMASK, ifr) != 0) {
 347                         freeaddrinfo(*ifap);
 348                         return -1;
 349                 }
 350
 351                 curif->ifa_netmask = sockaddr_dup(&ifr->ifr_addr);
 352
 353                 lastif = curif;
 354
 355         next:
 356                 /*
 357                  * Patch from Archie Cobbs (archie@whistle.com).  The
 358                  * addresses in the SIOCGIFCONF interface list have a
 359                  * minimum size. Usually this doesn't matter, but if
 360                  * your machine has tunnel interfaces, etc. that have
 361                  * a zero length "link address", this does matter.  */
 362
 363                 if (inc < sizeof(ifr->ifr_addr))
 364                         inc = sizeof(ifr->ifr_addr);
 365                 inc += IFNAMSIZ;
 366
 367                 ifr = (struct ifreq*) (((char*) ifr) + inc);
 368                 i -= inc;
 369         }
 370
 371         close(fd);
 372         return 0;
 373 }
 374
 375 #define _FOUND_IFACE_ANY
 376 #endif /* HAVE_IFACE_AIX */
 377 #ifndef _FOUND_IFACE_ANY
 378 int rep_getifaddrs(struct ifaddrs **ifap)
 379 {
 380         errno = ENOSYS;
 381         return -1;
 382 }
 383 #endif