lib/if2ip.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel@haxx.se>, et al.
   9  *
  10  * This software is licensed as described in the file COPYING, which
  11  * you should have received as part of this distribution. The terms
  12  * are also available at https://curl.haxx.se/docs/copyright.html.
  13  *
  14  * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15  * copies of the Software, and permit persons to whom the Software is
  16  * furnished to do so, under the terms of the COPYING file.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ***************************************************************************/
  22
  23 #include "curl_setup.h"
  24
  25 #ifdef HAVE_NETINET_IN_H
  26 #  include <netinet/in.h>
  27 #endif
  28 #ifdef HAVE_ARPA_INET_H
  29 #  include <arpa/inet.h>
  30 #endif
  31 #ifdef HAVE_NET_IF_H
  32 #  include <net/if.h>
  33 #endif
  34 #ifdef HAVE_SYS_IOCTL_H
  35 #  include <sys/ioctl.h>
  36 #endif
  37 #ifdef HAVE_NETDB_H
  38 #  include <netdb.h>
  39 #endif
  40 #ifdef HAVE_SYS_SOCKIO_H
  41 #  include <sys/sockio.h>
  42 #endif
  43 #ifdef HAVE_IFADDRS_H
  44 #  include <ifaddrs.h>
  45 #endif
  46 #ifdef HAVE_STROPTS_H
  47 #  include <stropts.h>
  48 #endif
  49 #ifdef __VMS
  50 #  include <inet.h>
  51 #endif
  52
  53 #include "inet_ntop.h"
  54 #include "strequal.h"
  55 #include "if2ip.h"
  56 #include "curl_printf.h"
  57
  58 #include "curl_memory.h"
  59 /* The last #include file should be: */
  60 #include "memdebug.h"
  61
  62 /* ------------------------------------------------------------------ */
  63
  64 /* Return the scope of the given address. */
  65 unsigned int Curl_ipv6_scope(const struct sockaddr *sa)
  66 {
  67 #ifndef ENABLE_IPV6
  68   (void) sa;
  69 #else
  70   if(sa->sa_family == AF_INET6) {
  71     const struct sockaddr_in6 * sa6 = (const struct sockaddr_in6 *)(void *) sa;
  72     const unsigned char * b = sa6->sin6_addr.s6_addr;
  73     unsigned short w = (unsigned short) ((b[0] << 8) | b[1]);
  74
  75     switch(w & 0xFFC0) {
  76     case 0xFE80:
  77       return IPV6_SCOPE_LINKLOCAL;
  78     case 0xFEC0:
  79       return IPV6_SCOPE_SITELOCAL;
  80     case 0x0000:
  81       w = b[1] | b[2] | b[3] | b[4] | b[5] | b[6] | b[7] | b[8] | b[9] |
  82           b[10] | b[11] | b[12] | b[13] | b[14];
  83       if(w || b[15] != 0x01)
  84         break;
  85       return IPV6_SCOPE_NODELOCAL;
  86     default:
  87       break;
  88     }
  89   }
  90 #endif
  91
  92   return IPV6_SCOPE_GLOBAL;
  93 }
  94
  95
  96 #if defined(HAVE_GETIFADDRS)
  97
  98 bool Curl_if_is_interface_name(const char *interf)
  99 {
 100   bool result = FALSE;
 101
 102   struct ifaddrs *iface, *head;
 103
 104   if(getifaddrs(&head) >= 0) {
 105     for(iface=head; iface != NULL; iface=iface->ifa_next) {
 106       if(curl_strequal(iface->ifa_name, interf)) {
 107         result = TRUE;
 108         break;
 109       }
 110     }
 111     freeifaddrs(head);
 112   }
 113   return result;
 114 }
 115
 116 if2ip_result_t Curl_if2ip(int af, unsigned int remote_scope,
 117                           unsigned int remote_scope_id, const char *interf,
 118                           char *buf, int buf_size)
 119 {
 120   struct ifaddrs *iface, *head;
 121   if2ip_result_t res = IF2IP_NOT_FOUND;
 122
 123 #ifndef ENABLE_IPV6
 124   (void) remote_scope;
 125
 126 #ifndef HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID
 127   (void) remote_scope_id;
 128 #endif
 129
 130 #endif
 131
 132   if(getifaddrs(&head) >= 0) {
 133     for(iface = head; iface != NULL; iface=iface->ifa_next) {
 134       if(iface->ifa_addr != NULL) {
 135         if(iface->ifa_addr->sa_family == af) {
 136           if(curl_strequal(iface->ifa_name, interf)) {
 137             void *addr;
 138             char *ip;
 139             char scope[12] = "";
 140             char ipstr[64];
 141 #ifdef ENABLE_IPV6
 142             if(af == AF_INET6) {
 143               unsigned int scopeid = 0;
 144               unsigned int ifscope = Curl_ipv6_scope(iface->ifa_addr);
 145
 146               if(ifscope != remote_scope) {
 147                 /* We are interested only in interface addresses whose
 148                    scope matches the remote address we want to
 149                    connect to: global for global, link-local for
 150                    link-local, etc... */
 151                 if(res == IF2IP_NOT_FOUND) res = IF2IP_AF_NOT_SUPPORTED;
 152                 continue;
 153               }
 154
 155               addr =
 156                 &((struct sockaddr_in6 *)(void *)iface->ifa_addr)->sin6_addr;
 157 #ifdef HAVE_SOCKADDR_IN6_SIN6_SCOPE_ID
 158               /* Include the scope of this interface as part of the address */
 159               scopeid = ((struct sockaddr_in6 *)(void *)iface->ifa_addr)
 160                             ->sin6_scope_id;
 161
 162               /* If given, scope id should match. */
 163               if(remote_scope_id && scopeid != remote_scope_id) {
 164                 if(res == IF2IP_NOT_FOUND)
 165                   res = IF2IP_AF_NOT_SUPPORTED;
 166
 167                 continue;
 168               }
 169 #endif
 170               if(scopeid)
 171                 snprintf(scope, sizeof(scope), "%%%u", scopeid);
 172             }
 173             else
 174 #endif
 175               addr =
 176                   &((struct sockaddr_in *)(void *)iface->ifa_addr)->sin_addr;
 177             res = IF2IP_FOUND;
 178             ip = (char *) Curl_inet_ntop(af, addr, ipstr, sizeof(ipstr));
 179             snprintf(buf, buf_size, "%s%s", ip, scope);
 180             break;
 181           }
 182         }
 183         else if((res == IF2IP_NOT_FOUND) &&
 184                 curl_strequal(iface->ifa_name, interf)) {
 185           res = IF2IP_AF_NOT_SUPPORTED;
 186         }
 187       }
 188     }
 189
 190     freeifaddrs(head);
 191   }
 192
 193   return res;
 194 }
 195
 196 #elif defined(HAVE_IOCTL_SIOCGIFADDR)
 197
 198 bool Curl_if_is_interface_name(const char *interf)
 199 {
 200   /* This is here just to support the old interfaces */
 201   char buf[256];
 202
 203   return (Curl_if2ip(AF_INET, 0 /* unused */, 0, interf, buf, sizeof(buf)) ==
 204           IF2IP_NOT_FOUND) ? FALSE : TRUE;
 205 }
 206
 207 if2ip_result_t Curl_if2ip(int af, unsigned int remote_scope,
 208                           unsigned int remote_scope_id, const char *interf,
 209                           char *buf, int buf_size)
 210 {
 211   struct ifreq req;
 212   struct in_addr in;
 213   struct sockaddr_in *s;
 214   curl_socket_t dummy;
 215   size_t len;
 216
 217   (void)remote_scope;
 218   (void)remote_scope_id;
 219
 220   if(!interf || (af != AF_INET))
 221     return IF2IP_NOT_FOUND;
 222
 223   len = strlen(interf);
 224   if(len >= sizeof(req.ifr_name))
 225     return IF2IP_NOT_FOUND;
 226
 227   dummy = socket(AF_INET, SOCK_STREAM, 0);
 228   if(CURL_SOCKET_BAD == dummy)
 229     return IF2IP_NOT_FOUND;
 230
 231   memset(&req, 0, sizeof(req));
 232   memcpy(req.ifr_name, interf, len+1);
 233   req.ifr_addr.sa_family = AF_INET;
 234
 235   if(ioctl(dummy, SIOCGIFADDR, &req) < 0) {
 236     sclose(dummy);
 237     /* With SIOCGIFADDR, we cannot tell the difference between an interface
 238        that does not exist and an interface that has no address of the
 239        correct family. Assume the interface does not exist */
 240     return IF2IP_NOT_FOUND;
 241   }
 242
 243   s = (struct sockaddr_in *)&req.ifr_addr;
 244   memcpy(&in, &s->sin_addr, sizeof(in));
 245   Curl_inet_ntop(s->sin_family, &in, buf, buf_size);
 246
 247   sclose(dummy);
 248   return IF2IP_FOUND;
 249 }
 250
 251 #else
 252
 253 bool Curl_if_is_interface_name(const char *interf)
 254 {
 255   (void) interf;
 256
 257   return FALSE;
 258 }
 259
 260 if2ip_result_t Curl_if2ip(int af, unsigned int remote_scope,
 261                           unsigned int remote_scope_id, const char *interf,
 262                           char *buf, int buf_size)
 263 {
 264     (void) af;
 265     (void) remote_scope;
 266     (void) remote_scope_id;
 267     (void) interf;
 268     (void) buf;
 269     (void) buf_size;
 270     return IF2IP_NOT_FOUND;
 271 }
 272
 273 #endif