git.meshlink.io Git - meshlink/blob - src/netutl.c

   1 /*
   2     netutl.c -- some supporting network utility code
   3     Copyright (C) 2014-2017 Guus Sliepen <guus@meshlink.io>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "system.h"
  21
  22 #include "meshlink_internal.h"
  23 #include "net.h"
  24 #include "netutl.h"
  25 #include "logger.h"
  26 #include "utils.h"
  27 #include "xalloc.h"
  28
  29 /*
  30   Turn a string into a struct addrinfo.
  31   Return NULL on failure.
  32 */
  33 struct addrinfo *str2addrinfo(const char *address, const char *service, int socktype) {
  34         struct addrinfo *ai;
  35         int err;
  36
  37         struct addrinfo hint = {
  38                 .ai_family = AF_UNSPEC,
  39                 .ai_socktype = socktype,
  40         };
  41
  42         err = getaddrinfo(address, service, &hint, &ai);
  43
  44         if(err) {
  45                 logger(NULL, MESHLINK_WARNING, "Error looking up %s port %s: %s", address, service, err == EAI_SYSTEM ? strerror(errno) : gai_strerror(err));
  46                 return NULL;
  47         }
  48
  49         return ai;
  50 }
  51
  52 sockaddr_t str2sockaddr(const char *address, const char *port) {
  53         struct addrinfo *ai;
  54         sockaddr_t result;
  55         int err;
  56
  57         memset(&result, 0, sizeof(result));
  58
  59         struct addrinfo hint = {
  60                 .ai_family = AF_UNSPEC,
  61                 .ai_flags = AI_NUMERICHOST | AI_NUMERICSERV,
  62                 .ai_socktype = SOCK_STREAM,
  63         };
  64
  65         err = getaddrinfo(address, port, &hint, &ai);
  66
  67         if(err || !ai) {
  68                 logger(NULL, MESHLINK_DEBUG, "Unknown type address %s port %s", address, port);
  69                 result.sa.sa_family = AF_UNKNOWN;
  70                 result.unknown.address = xstrdup(address);
  71                 result.unknown.port = xstrdup(port);
  72                 return result;
  73         }
  74
  75         memcpy(&result, ai->ai_addr, ai->ai_addrlen);
  76         freeaddrinfo(ai);
  77
  78         return result;
  79 }
  80
  81 sockaddr_t str2sockaddr_random(struct meshlink_handle *mesh, const char *address, const char *port) {
  82         struct addrinfo *ai;
  83         sockaddr_t result;
  84         int err;
  85
  86         memset(&result, 0, sizeof(result));
  87
  88         struct addrinfo hint = {
  89                 .ai_family = AF_UNSPEC,
  90                 .ai_flags = AI_NUMERICHOST | AI_NUMERICSERV,
  91                 .ai_socktype = SOCK_STREAM,
  92         };
  93
  94         err = getaddrinfo(address, port, &hint, &ai);
  95
  96         if(err || !ai) {
  97                 logger(NULL, MESHLINK_DEBUG, "Unknown type address %s port %s", address, port);
  98                 result.sa.sa_family = AF_UNKNOWN;
  99                 result.unknown.address = xstrdup(address);
 100                 result.unknown.port = xstrdup(port);
 101                 return result;
 102         }
 103
 104         int count = 0;
 105
 106         for(struct addrinfo *aip = ai; aip; aip = aip->ai_next) {
 107                 count++;
 108         }
 109
 110         struct addrinfo *aip = ai;
 111
 112         for(count = prng(mesh, count); count--; aip = aip->ai_next);
 113
 114         memcpy(&result, aip->ai_addr, aip->ai_addrlen);
 115         freeaddrinfo(ai);
 116
 117         return result;
 118 }
 119
 120 void sockaddr2str(const sockaddr_t *sa, char **addrstr, char **portstr) {
 121         char address[NI_MAXHOST];
 122         char port[NI_MAXSERV];
 123         char *scopeid;
 124         int err;
 125
 126         if(sa->sa.sa_family == AF_UNKNOWN) {
 127                 if(addrstr) {
 128                         *addrstr = xstrdup(sa->unknown.address);
 129                 }
 130
 131                 if(portstr) {
 132                         *portstr = xstrdup(sa->unknown.port);
 133                 }
 134
 135                 return;
 136         }
 137
 138         err = getnameinfo(&sa->sa, SALEN(sa->sa), address, sizeof(address), port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV);
 139
 140         if(err) {
 141                 logger(NULL, MESHLINK_ERROR, "Error while translating addresses: %s", err == EAI_SYSTEM ? strerror(errno) : gai_strerror(err));
 142                 abort();
 143         }
 144
 145         scopeid = strchr(address, '%');
 146
 147         if(scopeid) {
 148                 *scopeid = '\0';        /* Descope. */
 149         }
 150
 151         if(addrstr) {
 152                 *addrstr = xstrdup(address);
 153         }
 154
 155         if(portstr) {
 156                 *portstr = xstrdup(port);
 157         }
 158 }
 159
 160 char *sockaddr2hostname(const sockaddr_t *sa) {
 161         char *str;
 162         char address[NI_MAXHOST] = "unknown";
 163         char port[NI_MAXSERV] = "unknown";
 164         int err;
 165
 166         if(sa->sa.sa_family == AF_UNKNOWN) {
 167                 xasprintf(&str, "%s port %s", sa->unknown.address, sa->unknown.port);
 168                 return str;
 169         }
 170
 171         err = getnameinfo(&sa->sa, SALEN(sa->sa), address, sizeof(address), port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV);
 172
 173         if(err) {
 174                 logger(NULL, MESHLINK_ERROR, "Error while looking up hostname: %s", err == EAI_SYSTEM ? strerror(errno) : gai_strerror(err));
 175                 abort();
 176         }
 177
 178         xasprintf(&str, "%s port %s", address, port);
 179
 180         return str;
 181 }
 182
 183 int sockaddrcmp_noport(const sockaddr_t *a, const sockaddr_t *b) {
 184         int result;
 185
 186         result = a->sa.sa_family - b->sa.sa_family;
 187
 188         if(result) {
 189                 return result;
 190         }
 191
 192         switch(a->sa.sa_family) {
 193         case AF_UNSPEC:
 194                 return 0;
 195
 196         case AF_UNKNOWN:
 197                 return strcmp(a->unknown.address, b->unknown.address);
 198
 199         case AF_INET:
 200                 return memcmp(&a->in.sin_addr, &b->in.sin_addr, sizeof(a->in.sin_addr));
 201
 202         case AF_INET6:
 203                 return memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a->in6.sin6_addr));
 204
 205         default:
 206                 logger(NULL, MESHLINK_ERROR, "sockaddrcmp() was called with unknown address family %d, exitting!",
 207                        a->sa.sa_family);
 208                 abort();
 209         }
 210 }
 211
 212 int sockaddrcmp(const sockaddr_t *a, const sockaddr_t *b) {
 213         int result;
 214
 215         result = a->sa.sa_family - b->sa.sa_family;
 216
 217         if(result) {
 218                 return result;
 219         }
 220
 221         switch(a->sa.sa_family) {
 222         case AF_UNSPEC:
 223                 return 0;
 224
 225         case AF_UNKNOWN:
 226                 result = strcmp(a->unknown.address, b->unknown.address);
 227
 228                 if(result) {
 229                         return result;
 230                 }
 231
 232                 return strcmp(a->unknown.port, b->unknown.port);
 233
 234         case AF_INET:
 235                 result = memcmp(&a->in.sin_addr, &b->in.sin_addr, sizeof(a)->in.sin_addr);
 236
 237                 if(result) {
 238                         return result;
 239                 }
 240
 241                 return memcmp(&a->in.sin_port, &b->in.sin_port, sizeof(a)->in.sin_port);
 242
 243         case AF_INET6:
 244                 result = memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a)->in6.sin6_addr);
 245
 246                 if(result) {
 247                         return result;
 248                 }
 249
 250                 return memcmp(&a->in6.sin6_port, &b->in6.sin6_port, sizeof(a)->in6.sin6_port);
 251
 252         default:
 253                 logger(NULL, MESHLINK_ERROR, "sockaddrcmp() was called with unknown address family %d, exitting!",
 254                        a->sa.sa_family);
 255                 abort();
 256         }
 257 }
 258
 259 void sockaddrcpy(sockaddr_t *a, const sockaddr_t *b) {
 260         if(b->sa.sa_family != AF_UNKNOWN) {
 261                 *a = *b;
 262         } else {
 263                 a->unknown.family = AF_UNKNOWN;
 264                 a->unknown.address = xstrdup(b->unknown.address);
 265                 a->unknown.port = xstrdup(b->unknown.port);
 266         }
 267 }
 268
 269 void sockaddrcpy_setport(sockaddr_t *a, const sockaddr_t *b, uint16_t port) {
 270         sockaddrcpy(a, b);
 271
 272         switch(b->sa.sa_family) {
 273         case AF_INET:
 274                 a->in.sin_port = htons(port);
 275                 break;
 276
 277         case AF_INET6:
 278                 a->in6.sin6_port = htons(port);
 279                 break;
 280
 281         default:
 282                 break;
 283         }
 284 }
 285
 286 void sockaddrfree(sockaddr_t *a) {
 287         if(a->sa.sa_family == AF_UNKNOWN) {
 288                 free(a->unknown.address);
 289                 free(a->unknown.port);
 290         }
 291 }
 292
 293 void sockaddrunmap(sockaddr_t *sa) {
 294         if(sa->sa.sa_family == AF_INET6 && IN6_IS_ADDR_V4MAPPED(&sa->in6.sin6_addr)) {
 295                 sa->in.sin_addr.s_addr = ((uint32_t *) & sa->in6.sin6_addr)[3];
 296                 sa->in.sin_family = AF_INET;
 297         }
 298 }
 299
 300 void packmsg_add_sockaddr(packmsg_output_t *out, const sockaddr_t *sa) {
 301         switch(sa->sa.sa_family) {
 302         case AF_INET: {
 303                 uint8_t buf[6];
 304                 memcpy(buf + 0, &sa->in.sin_port, 2);
 305                 memcpy(buf + 2, &sa->in.sin_addr, 4);
 306                 packmsg_add_ext(out, 4, buf, sizeof(buf));
 307                 break;
 308         }
 309
 310         case AF_INET6: {
 311                 uint8_t buf[18];
 312                 memcpy(buf + 0, &sa->in6.sin6_port, 2);
 313                 memcpy(buf + 2, &sa->in6.sin6_addr, 16);
 314                 packmsg_add_ext(out, 6, buf, sizeof(buf));
 315                 break;
 316         }
 317
 318         default:
 319                 packmsg_output_invalidate(out);
 320                 break;
 321         }
 322 }
 323
 324 sockaddr_t packmsg_get_sockaddr(packmsg_input_t *in) {
 325         sockaddr_t sa;
 326         memset(&sa, 0, sizeof sa);
 327
 328         int8_t type;
 329         const void *data;
 330         uint32_t len = packmsg_get_ext_raw(in, &type, &data);
 331
 332         switch(type) {
 333         case 4:
 334                 if(len != 6) {
 335                         packmsg_input_invalidate(in);
 336                         return sa;
 337                 }
 338
 339                 sa.sa.sa_family = AF_INET;
 340                 memcpy(&sa.in.sin_port, (uint8_t *)data + 0, 2);
 341                 memcpy(&sa.in.sin_addr, (uint8_t *)data + 2, 4);
 342                 break;
 343
 344         case 6:
 345                 if(len != 18) {
 346                         packmsg_input_invalidate(in);
 347                         return sa;
 348                 }
 349
 350                 sa.sa.sa_family = AF_INET6;
 351                 memcpy(&sa.in6.sin6_port, (uint8_t *)data + 0, 2);
 352                 memcpy(&sa.in6.sin6_addr, (uint8_t *)data + 2, 16);
 353                 break;
 354
 355         default:
 356                 packmsg_input_invalidate(in);
 357                 return sa;
 358         }
 359
 360         return sa;
 361 }