mono/utils/networking-posix.c

   1 /*
   2  * networking-posix.c: Modern posix networking code
   3  *
   4  * Author:
   5  *      Rodrigo Kumpera (kumpera@gmail.com)
   6  *
   7  * (C) 2015 Xamarin
   8  */
   9
  10 #include <mono/utils/networking.h>
  11 #include <glib.h>
  12
  13 #ifdef HAVE_NETDB_H
  14 #include <netdb.h>
  15 #endif
  16 #ifdef HAVE_SYS_IOCTL_H
  17 #include <sys/ioctl.h>
  18 #endif
  19 #ifdef HAVE_NET_IF_H
  20 #include <net/if.h>
  21 #endif
  22 #ifdef HAVE_UNISTD_H
  23 #include <unistd.h>
  24 #endif
  25 #ifdef HAVE_GETIFADDRS
  26 #include <ifaddrs.h>
  27 #endif
  28
  29 static void*
  30 get_address_from_sockaddr (struct sockaddr *sa)
  31 {
  32         switch (sa->sa_family) {
  33         case AF_INET:
  34                 return &((struct sockaddr_in*)sa)->sin_addr;
  35         case AF_INET6:
  36                 return &((struct sockaddr_in6*)sa)->sin6_addr;
  37         }
  38         return NULL;
  39 }
  40
  41 #ifdef HAVE_GETADDRINFO
  42
  43 int
  44 mono_get_address_info (const char *hostname, int port, int flags, MonoAddressInfo **result)
  45 {
  46         char service_name [16];
  47         struct addrinfo hints, *res = NULL, *info;
  48         MonoAddressEntry *cur = NULL, *prev = NULL;
  49         MonoAddressInfo *addr_info;
  50
  51         memset (&hints, 0, sizeof (struct addrinfo));
  52         *result = NULL;
  53
  54         hints.ai_family = PF_UNSPEC;
  55         if (flags & MONO_HINT_IPV4)
  56                 hints.ai_family = PF_INET;
  57         else if (flags & MONO_HINT_IPV6)
  58                 hints.ai_family = PF_INET6;
  59
  60         hints.ai_socktype = SOCK_STREAM;
  61
  62         if (flags & MONO_HINT_CANONICAL_NAME)
  63                 hints.ai_flags = AI_CANONNAME;
  64
  65 /* Some ancient libc don't define AI_ADDRCONFIG */
  66 #ifdef AI_ADDRCONFIG
  67         if (flags & MONO_HINT_CONFIGURED_ONLY)
  68                 hints.ai_flags = AI_ADDRCONFIG;
  69 #endif
  70         sprintf (service_name, "%d", port);
  71     if (getaddrinfo (hostname, service_name, &hints, &info))
  72                 return 1; /* FIXME propagate the error */
  73
  74         res = info;
  75         *result = addr_info = g_new0 (MonoAddressInfo, 1);
  76
  77         while (res) {
  78                 cur = g_new0 (MonoAddressEntry, 1);
  79                 cur->family = res->ai_family;
  80                 cur->socktype = res->ai_socktype;
  81                 cur->protocol = res->ai_protocol;
  82                 if (cur->family == PF_INET) {
  83                         cur->address_len = sizeof (struct in_addr);
  84                         cur->address.v4 = ((struct sockaddr_in*)res->ai_addr)->sin_addr;
  85                 } else if (cur->family == PF_INET6) {
  86                         cur->address_len = sizeof (struct in6_addr);
  87                         cur->address.v6 = ((struct sockaddr_in6*)res->ai_addr)->sin6_addr;
  88                 } else {
  89                         g_warning ("Cannot handle address family %d", cur->family);
  90                         res = res->ai_next;
  91                         g_free (cur);
  92                         continue;
  93                 }
  94
  95                 if (res->ai_canonname)
  96                         cur->canonical_name = g_strdup (res->ai_canonname);
  97
  98                 if (prev)
  99                         prev->next = cur;
 100                 else
 101                         addr_info->entries = cur;
 102
 103                 prev = cur;
 104                 res = res->ai_next;
 105         }
 106
 107         freeaddrinfo (info);
 108         return 0;
 109 }
 110
 111 #endif
 112
 113 #ifdef HAVE_GETPROTOBYNAME
 114
 115 static int
 116 fetch_protocol (const char *proto_name, int *cache, int *proto, int default_val)
 117 {
 118         if (!*cache) {
 119                 struct protoent *pent;
 120
 121                 pent = getprotobyname (proto_name);
 122                 *proto = pent ? pent->p_proto : default_val;
 123                 *cache = 1;
 124         }
 125         return *proto;
 126 }
 127
 128 int
 129 mono_networking_get_tcp_protocol (void)
 130 {
 131         static int cache, proto;
 132         return fetch_protocol ("tcp", &cache, &proto, 6); //6 is SOL_TCP on linux
 133 }
 134
 135 int
 136 mono_networking_get_ip_protocol (void)
 137 {
 138         static int cache, proto;
 139         return fetch_protocol ("ip", &cache, &proto, 0); //0 is SOL_IP on linux
 140 }
 141
 142 int
 143 mono_networking_get_ipv6_protocol (void)
 144 {
 145         static int cache, proto;
 146         return fetch_protocol ("ipv6", &cache, &proto, 41); //41 is SOL_IPV6 on linux
 147 }
 148
 149 #endif
 150
 151 #if defined (HAVE_SIOCGIFCONF)
 152
 153 #define IFCONF_BUFF_SIZE 1024
 154 #ifndef _SIZEOF_ADDR_IFREQ
 155 #define _SIZEOF_ADDR_IFREQ(ifr) (sizeof (struct ifreq))
 156 #endif
 157
 158 #define FOREACH_IFR(IFR, IFC) \
 159         for (IFR = (IFC).ifc_req;       \
 160         ifr < (struct ifreq*)((char*)(IFC).ifc_req + (IFC).ifc_len); \
 161         ifr = (struct ifreq*)((char*)(IFR) + _SIZEOF_ADDR_IFREQ (*(IFR))))
 162
 163 void *
 164 mono_get_local_interfaces (int family, int *interface_count)
 165 {
 166         int fd;
 167         struct ifconf ifc;
 168         struct ifreq *ifr;
 169         int if_count = 0;
 170         gboolean ignore_loopback = FALSE;
 171         void *result = NULL;
 172         char *result_ptr;
 173
 174         *interface_count = 0;
 175
 176         if (!mono_address_size_for_family (family))
 177                 return NULL;
 178
 179         fd = socket (family, SOCK_STREAM, 0);
 180         if (fd == -1)
 181                 return NULL;
 182
 183         memset (&ifc, 0, sizeof (ifc));
 184         ifc.ifc_len = IFCONF_BUFF_SIZE;
 185         ifc.ifc_buf = g_malloc (IFCONF_BUFF_SIZE); /* We can't have such huge buffers on the stack. */
 186         if (ioctl (fd, SIOCGIFCONF, &ifc) < 0)
 187                 goto done;
 188
 189         FOREACH_IFR (ifr, ifc) {
 190                 struct ifreq iflags;
 191
 192                 //only return addresses of the same type as @family
 193                 if (ifr->ifr_addr.sa_family != family) {
 194                         ifr->ifr_name [0] = '\0';
 195                         continue;
 196                 }
 197
 198                 strcpy (iflags.ifr_name, ifr->ifr_name);
 199
 200                 //ignore interfaces we can't get props for
 201                 if (ioctl (fd, SIOCGIFFLAGS, &iflags) < 0) {
 202                         ifr->ifr_name [0] = '\0';
 203                         continue;
 204                 }
 205
 206                 //ignore interfaces that are down
 207                 if ((iflags.ifr_flags & IFF_UP) == 0) {
 208                         ifr->ifr_name [0] = '\0';
 209                         continue;
 210                 }
 211
 212                 //If we have a non-loopback iface, don't return any loopback
 213                 if ((iflags.ifr_flags & IFF_LOOPBACK) == 0) {
 214                         ignore_loopback = TRUE;
 215                         ifr->ifr_name [0] = 1;//1 means non-loopback
 216                 } else {
 217                         ifr->ifr_name [0] = 2; //2 means loopback
 218                 }
 219                 ++if_count;
 220         }
 221
 222         result_ptr = result = g_malloc (if_count * mono_address_size_for_family (family));
 223         FOREACH_IFR (ifr, ifc) {
 224                 if (ifr->ifr_name [0] == '\0')
 225                         continue;
 226
 227                 if (ignore_loopback && ifr->ifr_name [0] == 2) {
 228                         --if_count;
 229                         continue;
 230                 }
 231
 232                 memcpy (result_ptr, get_address_from_sockaddr (&ifr->ifr_addr), mono_address_size_for_family (family));
 233                 result_ptr += mono_address_size_for_family (family);
 234         }
 235         g_assert (result_ptr <= (char*)result + if_count * mono_address_size_for_family (family));
 236
 237 done:
 238         *interface_count = if_count;
 239         g_free (ifc.ifc_buf);
 240         close (fd);
 241         return result;
 242 }
 243
 244 #elif defined(HAVE_GETIFADDRS)
 245
 246 void *
 247 mono_get_local_interfaces (int family, int *interface_count)
 248 {
 249         struct ifaddrs *ifap = NULL, *cur;
 250         int if_count = 0;
 251         gboolean ignore_loopback = FALSE;
 252         void *result;
 253         char *result_ptr;
 254
 255         *interface_count = 0;
 256
 257         if (!mono_address_size_for_family (family))
 258                 return NULL;
 259
 260         if (getifaddrs (&ifap))
 261                 return NULL;
 262
 263         for (cur = ifap; cur; cur = cur->ifa_next) {
 264                 //ignore interfaces with no address assigned
 265                 if (!cur->ifa_addr)
 266                         continue;
 267
 268                 //ignore interfaces that don't belong to @family
 269                 if (cur->ifa_addr->sa_family != family)
 270                         continue;
 271
 272                 //ignore interfaces that are down
 273                 if ((cur->ifa_flags & IFF_UP) == 0)
 274                         continue;
 275
 276                 //If we have a non-loopback iface, don't return any loopback
 277                 if ((cur->ifa_flags & IFF_LOOPBACK) == 0)
 278                         ignore_loopback = TRUE;
 279
 280                 if_count++;
 281         }
 282
 283         result_ptr = result = g_malloc (if_count * mono_address_size_for_family (family));
 284         for (cur = ifap; cur; cur = cur->ifa_next) {
 285                 if (!cur->ifa_addr)
 286                         continue;
 287                 if (cur->ifa_addr->sa_family != family)
 288                         continue;
 289                 if ((cur->ifa_flags & IFF_UP) == 0)
 290                         continue;
 291
 292                 //we decrement if_count because it did not on the previous loop.
 293                 if (ignore_loopback && (cur->ifa_flags & IFF_LOOPBACK)) {
 294                         --if_count;
 295                         continue;
 296                 }
 297
 298                 memcpy (result_ptr, get_address_from_sockaddr (cur->ifa_addr), mono_address_size_for_family (family));
 299                 result_ptr += mono_address_size_for_family (family);
 300         }
 301         g_assert (result_ptr <= (char*)result + if_count * mono_address_size_for_family (family));
 302
 303         freeifaddrs (ifap);
 304         *interface_count = if_count;
 305         return result;
 306 }
 307
 308 #endif
 309
 310 #ifdef HAVE_GETNAMEINFO
 311
 312 gboolean
 313 mono_networking_addr_to_str (MonoAddress *address, char *buffer, socklen_t buflen)
 314 {
 315         MonoSocketAddress saddr;
 316         socklen_t len;
 317         mono_socket_address_init (&saddr, &len, address->family, &address->addr, 0);
 318
 319         return getnameinfo (&saddr.addr, len, buffer, buflen, NULL, 0, NI_NUMERICHOST) == 0;
 320 }
 321
 322 #elif HAVE_INET_NTOP
 323
 324 gboolean
 325 mono_networking_addr_to_str (MonoAddress *address, char *buffer, socklen_t buflen)
 326 {
 327         return inet_ntop (address->family, &address->addr, buffer, buflen) != NULL;
 328 }
 329
 330 #endif
 331
 332 #ifndef _WIN32
 333 // These are already defined in networking-windows.c for Windows
 334 void
 335 mono_networking_init (void)
 336 {
 337         //nothing really
 338 }
 339
 340 void
 341 mono_networking_shutdown (void)
 342 {
 343         //nothing really
 344 }
 345 #endif