mono/utils/networking-posix.c

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