common/common.c

   1 /**********************************************************
   2  SixXS - Automatic IPv6 Connectivity Configuration Utility
   3 ***********************************************************
   4  Copyright 2003-2005 SixXS - http://www.sixxs.net
   5 ***********************************************************
   6  common/common.c - Common Functions
   7 ***********************************************************
   8  $Author: jeroen $
   9  $Id: common.c,v 1.14 2006-12-21 14:08:50 jeroen Exp $
  10  $Date: 2006-12-21 14:08:50 $
  11 **********************************************************/
  12
  13 /* Dirty dependency for Windows:GUI version */
  14 #ifdef _WIN32
  15 #ifndef AICCU_CONSOLE
  16 #include "../windows-gui/stdafx.h"
  17 #include "../windows-gui/AICCUApp.h"
  18 extern CAICCUApp theApp;
  19 #endif
  20 #endif
  21
  22 #include "aiccu.h"
  23 #include "common.h"
  24
  25 /* getline debugging? */
  26 /*
  27 #define E(x) x
  28  */
  29 #define E(x) {}
  30
  31 void dologA(int level, const char *fmt, va_list ap)
  32 {
  33 #ifdef _WIN32
  34         char buf[1024];
  35 #endif
  36         /* Don't show noise */
  37         if (g_aiccu && !g_aiccu->verbose && level == LOG_DEBUG) return;
  38
  39 #ifndef _WIN32
  40         if (g_aiccu && g_aiccu->daemonize > 0) vsyslog(LOG_LOCAL7|level, fmt, ap);
  41         else
  42         {
  43                 vfprintf(stderr, fmt, ap);
  44                 fflush(stderr);
  45         }
  46 #else
  47         vsnprintf(buf, sizeof(buf), fmt, ap);
  48
  49 #ifndef AICCU_CONSOLE
  50         /* Use the debug facility */
  51         OutputDebugString(buf);
  52
  53         /* Store it in a log file if we are running in verbose mode */
  54         if (g_aiccu && g_aiccu->verbose)
  55         {
  56                 char    logfile[1024];
  57                 FILE    *f;
  58
  59                 /* Figure out the "C:\Windows" location */
  60                 /* as that is where we store our configuration */
  61                 GetWindowsDirectory(logfile, sizeof(logfile));
  62                 strncat(logfile, "\\aiccu.log", sizeof(logfile));
  63                 f = fopen(logfile, "w+");
  64                 if (f)
  65                 {
  66                         fwrite(buf, strlen(buf), 1, f);
  67                         fclose(f);
  68                 }
  69         }
  70
  71         /*
  72          * Always store the last message
  73          * which can be displayed as errors etc.
  74          */
  75
  76         /* strip the \n */
  77         if (strlen(buf) > 0) buf[strlen(buf)-1] = '\0';
  78         theApp.m_sMessage = buf;
  79 #else
  80         OutputDebugString("dolog() - ");
  81         OutputDebugString(buf);
  82         fprintf(stderr, "%s", buf);
  83 #endif /* AICCU_CONSOLE */
  84 #endif /* !_WIN32 */
  85 }
  86
  87 void dolog(int level, const char *fmt, ...)
  88 {
  89         va_list ap;
  90         va_start(ap, fmt);
  91         dologA(level, fmt, ap);
  92         va_end(ap);
  93 }
  94
  95 /*
  96  * Check if an address is RFC1918 based
  97  * This allows us to warn the user that they are behind a NAT
  98  */
  99 bool is_rfc1918(char *ipv4)
 100 {
 101         unsigned int    addr = inet_addr(ipv4);
 102         bool            ret = false;
 103
 104
 105
 106         ret = ( /* 10.0.0.0/8 */
 107                 ((addr & htonl(0xff000000)) == htonl(0x0a000000)) ||
 108                 /* 172.16.0.0/12 */
 109                 ((addr & htonl(0xfff00000)) == htonl(0xac100000)) ||
 110                 /* 192.168.0.0/16 */
 111                 ((addr & htonl(0xffff0000)) == htonl(0xc0a80000))) ? true : false;
 112
 113         dolog(LOG_DEBUG, "is_rfc1918(%s) = %s\n", ipv4, ret ? "yes" : "false");
 114
 115         return ret;
 116 }
 117
 118 void sock_printf(TLSSOCKET sock, const char *fmt, ...)
 119 {
 120         char            buf[2048];
 121         unsigned int    len = 0, done = 0;
 122         int             ret;
 123
 124         va_list ap;
 125         va_start(ap, fmt);
 126         /* When not a socket send it to the logs */
 127         if (sock == NULL || sock->socket == -1) dologA(LOG_INFO, fmt, ap);
 128         else
 129         {
 130                 /* Format the string */
 131                 len = vsnprintf(buf, sizeof(buf), fmt, ap);
 132
 133                 /* Send the line(s) over the network */
 134
 135                 while (done < len)
 136                 {
 137 #ifdef AICCU_GNUTLS
 138                         if (sock->tls_active) ret = gnutls_record_send(sock->session, &buf[done], len-done);
 139                         else
 140 #endif
 141                         ret = send(sock->socket, &buf[done], len-done, 0);
 142
 143                         if (ret > 0) done+=ret;
 144                         else break;
 145                 }
 146
 147                 /* Show this as debug output */
 148                 if (g_aiccu->verbose)
 149                 {
 150                         /* Strip the last \n */
 151                         len = (int)strlen(buf);
 152                         if (len > 0) buf[len-1] = '\0';
 153                         /* dump the information */
 154                         dolog(LOG_DEBUG, "sock_printf()  : \"%s\"\n", buf);
 155                 }
 156         }
 157         va_end(ap);
 158 }
 159
 160 extern char tic_buf[2048];
 161
 162 /*
 163  * Read a line from a socket and store it in ubuf
 164  * Note: uses internal caching, this should be the only function
 165  * used to read from the sock! The internal cache is rbuf.
 166  */
 167 int sock_getline(TLSSOCKET sock, char *rbuf, unsigned int rbuflen, unsigned int *filled, char *ubuf, unsigned int ubuflen)
 168 {
 169         unsigned int i;
 170
 171         if (!sock) return -1;
 172
 173         /* A closed socket? -> clear the buffer */
 174         if (sock->socket == -1)
 175         {
 176                 memset(rbuf, 0, rbuflen);
 177                 *filled = 0;
 178                 return -1;
 179         }
 180
 181         /* Clear the caller supplied buffer, just in case */
 182         memset(ubuf, 0, ubuflen);
 183
 184         for (;;)
 185         {
 186                 E(dolog(LOG_DEBUG, "gl() - Filled %d\n", *filled);)
 187
 188                 /* Did we still have something in the buffer? */
 189                 if (*filled > 0)
 190                 {
 191                         E(dolog(LOG_DEBUG, "gl() - Seeking newline\n");)
 192
 193                         /* Walk to the end or until we reach a \n */
 194                         for (i=0; (i < (*filled-1)) && (rbuf[i] != '\n'); i++);
 195
 196                         E(dolog(LOG_DEBUG, "gl() - Seeking newline - end\n");)
 197
 198                         /* Did we find a newline? */
 199                         if (rbuf[i] == '\n')
 200                         {
 201                                 E(dolog(LOG_DEBUG, "gl() - Found newline at %i\n", i+1);)
 202
 203                                 /* Newline with a Linefeed in front of it ? -> remove it */
 204                                 if (rbuf[i] == '\n' && rbuf[i-1] == '\r')
 205                                 {
 206                                         E(dolog(LOG_DEBUG, "gl() - Removing LF\n");)
 207                                         i--;
 208                                 }
 209                                 E(else dolog(LOG_DEBUG, "gl() - No LF\n");)
 210
 211                                 /* Copy this over to the caller */
 212                                 memcpy(ubuf, rbuf, i);
 213
 214                                 E(dolog(LOG_DEBUG, "gl() - Copied %d bytes from %x to %x\n", i, rbuf, ubuf);)
 215
 216                                 /* Count the \r if it is there */
 217                                 if (rbuf[i] == '\r') i++;
 218                                 /* Count the \n */
 219                                 i++;
 220
 221                                 /* filled = what is left in the buffer */
 222                                 *filled -= i;
 223
 224                                 E(dolog(LOG_DEBUG, "gl() - %d bytes left in the buffer\n", *filled);)
 225
 226                                 /* Now move the rest of the buffer to the front */
 227                                 if (*filled > 0) memmove(rbuf, &rbuf[i], *filled);
 228                                 else *filled = 0;
 229
 230                                 /* Show this as debug output */
 231                                 if (g_aiccu->verbose) dolog(LOG_DEBUG, "sock_getline() : \"%s\"\n", ubuf);
 232
 233                                 /* We got ourselves a line in 'buf' thus return to the caller */
 234                                 return i;
 235                         }
 236                 }
 237
 238                 E(dolog(LOG_DEBUG, "gl() - Trying to receive (max=%d)...\n", rbuflen-*filled-10);)
 239
 240                 /* Fill the rest of the buffer */
 241 #ifdef AICCU_GNUTLS
 242                 if (sock->tls_active) i = gnutls_record_recv(sock->session, &rbuf[*filled], rbuflen-*filled-10);
 243                 else
 244 #endif
 245                 i = recv(sock->socket, &rbuf[*filled], rbuflen-*filled-10, 0);
 246
 247                 E(dolog(LOG_DEBUG, "gl() - Received %d\n", i);)
 248
 249                 /* Fail on errors */
 250                 if (i <= 0) return -1;
 251
 252                 /* We got more filled space! */
 253                 *filled+=i;
 254
 255                 /* Buffer overflow? */
 256                 if (    *filled >= (rbuflen-10) ||
 257                         *filled >= (ubuflen-10) )
 258                 {
 259                         dolog(LOG_ERR, "Buffer almost flowed over without receiving a newline\n");
 260                         return -1;
 261                 }
 262
 263                 /* And try again in this loop ;) */
 264         }
 265
 266         /* Never reached */
 267         return -1;
 268 }
 269
 270 TLSSOCKET sock_alloc(void);
 271 TLSSOCKET sock_alloc(void)
 272 {
 273 #ifdef AICCU_GNUTLS
 274         /* Allow connections to servers that have OpenPGP keys as well */
 275         const int       cert_type_priority[3] = { GNUTLS_CRT_X509, GNUTLS_CRT_OPENPGP, 0 };
 276         int             ret;
 277 #endif /* AICCU_GNUTLS*/
 278
 279         TLSSOCKET       sock;
 280
 281         sock = (TLSSOCKET)malloc(sizeof(*sock));
 282         if (!sock) return NULL;
 283
 284         sock->socket = -1;
 285
 286 #ifdef AICCU_GNUTLS
 287         /* TLS is not active yet (use sock_gotls() for that) */
 288         sock->tls_active = false;
 289
 290         /* Initialize TLS session */
 291         ret = gnutls_init(&sock->session, GNUTLS_CLIENT);
 292         if (ret != 0)
 293         {
 294                 dolog(LOG_ERR, "TLS Init failed: %s (%d)\n", gnutls_strerror(ret), ret);
 295                 free(sock);
 296                 return NULL;
 297         }
 298
 299         /* Use default priorities */
 300         gnutls_set_default_priority(sock->session);
 301         /* XXX: Return value is not documented in GNUTLS documentation! */
 302
 303         gnutls_certificate_type_set_priority(sock->session, cert_type_priority);
 304         /* XXX: Return value is not documented in GNUTLS documentation! */
 305
 306         /* Configure the x509 credentials for the current session */
 307         gnutls_credentials_set(sock->session, GNUTLS_CRD_CERTIFICATE, g_aiccu->tls_cred);
 308         /* XXX: Return value is not documented in GNUTLS documentation! */
 309
 310 #endif /* AICCU_GNUTLS*/
 311
 312         return sock;
 313 }
 314
 315 void sock_free(TLSSOCKET sock)
 316 {
 317         if (!sock) return;
 318
 319 #ifdef AICCU_GNUTLS
 320         if (sock->tls_active)
 321         {
 322                 sock->tls_active = false;
 323                 gnutls_bye(sock->session, GNUTLS_SHUT_RDWR);
 324         }
 325 #endif /* AICCU_GNUTLS*/
 326
 327         if (sock->socket >= 0)
 328         {
 329                 /* Stop communications */
 330                 shutdown(sock->socket, SHUT_RDWR);
 331                 closesocket(sock->socket);
 332                 sock->socket = -1;
 333         }
 334
 335 #ifdef AICCU_GNUTLS
 336         gnutls_deinit(sock->session);
 337 #endif /* AICCU_GNUTLS*/
 338
 339         free(sock);
 340 }
 341
 342 /* Connect this client to a server */
 343 TLSSOCKET connect_client(const char *hostname, const char *service, int family, int socktype)
 344 {
 345         TLSSOCKET       sock;
 346         struct addrinfo hints, *res, *ressave;
 347
 348         sock = sock_alloc();
 349         if (!sock) return NULL;
 350
 351         memset(&hints, 0, sizeof(struct addrinfo));
 352         hints.ai_family = family;
 353         hints.ai_socktype = socktype;
 354
 355         if (getaddrinfo(hostname, service, &hints, &res) != 0)
 356         {
 357                 dolog(LOG_ERR, "Couldn't resolve host %s, service %s\n", hostname, service);
 358                 sock_free(sock);
 359                 return NULL;
 360         }
 361
 362         ressave = res;
 363
 364         while (res)
 365         {
 366                 sock->socket = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
 367                 if (sock->socket == -1) continue;
 368                 if (connect(sock->socket, res->ai_addr, (unsigned int)res->ai_addrlen) == 0) break;
 369                 closesocket(sock->socket);
 370                 sock->socket = -1;
 371                 res = res->ai_next;
 372         }
 373
 374         freeaddrinfo(ressave);
 375
 376         if (sock->socket == -1)
 377         {
 378                 sock_free(sock);
 379                 sock = NULL;
 380         }
 381
 382         return sock;
 383 }
 384
 385 TLSSOCKET listen_server(const char *description, const char *hostname, const char *service, int family, int socktype)
 386 {
 387         struct addrinfo hints, *res, *ressave;
 388         int             n;
 389         TLSSOCKET       sock;
 390         socklen_t       on = 1;
 391 /*
 392         D(dolog(LOG_DEBUG, "[%s] Trying to get socket for [%s]:%s over %s (%d) using %s (%d)\n",
 393                 description, hostname, service,
 394                 family == AF_INET ? "IPv4" : (family == AF_INET6 ? "IPv6" : "??"),
 395                 family,
 396                 socktype == IPPROTO_UDP ? "UDP" : (socktype == IPPROTO_TCP ? "TCP" : "??"),
 397                 socktype);)
 398 */
 399         sock = sock_alloc();
 400         if (!sock) return NULL;
 401
 402         memset(&hints, 0, sizeof(struct addrinfo));
 403
 404         /* AI_PASSIVE flag: the resulting address is used to bind
 405            to a socket for accepting incoming connections.
 406            So, when the hostname==NULL, getaddrinfo function will
 407            return one entry per allowed protocol family containing
 408            the unspecified address for that family. */
 409
 410         hints.ai_flags    = AI_PASSIVE;
 411         hints.ai_family   = family;
 412         hints.ai_socktype = socktype;
 413
 414         n = getaddrinfo(hostname, service, &hints, &res);
 415         if (n < 0)
 416         {
 417                 dolog(LOG_ERR, "[%s] listen_server setup: getaddrinfo error: %s\n", description, gai_strerror(n));
 418                 sock_free(sock);
 419                 return NULL;
 420         }
 421
 422         ressave=res;
 423
 424         /* Try to open socket with each address getaddrinfo returned,
 425            until we get one valid listening socket. */
 426         while (res)
 427         {
 428                 sock->socket = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
 429                 if (!(sock->socket < 0))
 430                 {
 431                         setsockopt(sock->socket, SOL_SOCKET, SO_REUSEADDR, (const char *)&on, sizeof(on));
 432                         if (bind(sock->socket, res->ai_addr, (unsigned int)res->ai_addrlen) == 0) break;
 433                         closesocket(sock->socket);
 434                         sock->socket = -1;
 435                 }
 436                 res = res->ai_next;
 437         }
 438
 439         freeaddrinfo(ressave);
 440
 441         if (sock->socket < 0)
 442         {
 443                 dolog(LOG_ERR, "[%s] listen setup: socket error: could not open socket\n", description);
 444                 sock_free(sock);
 445                 return NULL;
 446         }
 447
 448         if (listen(sock->socket, LISTEN_QUEUE) == -1)
 449         {
 450                 dolog(LOG_ERR, "[%s] listen setup: socket error: could not listen on socket\n", description);
 451                 sock_free(sock);
 452                 return NULL;
 453         }
 454
 455         dolog(LOG_INFO, "[%s] Listening on [%s]:%s\n", description, hostname, service);
 456
 457         return sock;
 458 }
 459
 460 /*
 461  * Put a socket into TLS mode
 462  */
 463 #ifdef AICCU_GNUTLS
 464 bool sock_gotls(TLSSOCKET sock)
 465 {
 466         int ret = 0;
 467
 468         if (!sock) return false;
 469
 470         if (sock->tls_active)
 471         {
 472                 dolog(LOG_ERR, "Can't go into TLS mode twice!?\n");
 473                 return false;
 474         }
 475
 476         /* Set the transport */
 477         gnutls_transport_set_ptr(sock->session, (gnutls_transport_ptr)sock->socket);
 478
 479         /* Perform the TLS handshake */
 480         ret = gnutls_handshake(sock->session);
 481         if (ret < 0)
 482         {
 483                 dolog(LOG_ERR, "TLS Handshake failed: %s (%d)\n", gnutls_strerror(ret), ret);
 484                 return false;
 485         }
 486
 487         dolog(LOG_DEBUG, "TLS Handshake completed succesfully\n");
 488
 489         sock->tls_active = true;
 490         return true;
 491 }
 492 #endif
 493
 494 /* Count the number of fields in <s> */
 495 unsigned int countfields(char *s)
 496 {
 497         int n = 1, i;
 498         if (s == NULL) return 0;
 499         for (i=0; s[i] != '\0'; i++) if (s[i] == ' ') n++;
 500         return n;
 501 }
 502
 503 /*
 504  * Copy field <n> of string <s> into <buf> with a maximum of buflen
 505  * First field is 1
 506  */
 507 bool copyfield(char *s, unsigned int n, char *buf, unsigned int buflen)
 508 {
 509         unsigned int begin = 0, i=0;
 510
 511         /* Clear the buffer */
 512         memset(buf, 0, buflen);
 513
 514         while (s[i] != '\0')
 515         {
 516                 n--;
 517                 begin = i;
 518
 519                 /* Find next delimiter */
 520                 for (; s[i] != '\0' && s[i] != ' '; i++);
 521
 522                 if (n == 0)
 523                 {
 524                         i-=begin;
 525                         strncpy(buf, s+begin, i > buflen ? buflen : i);
 526                         /* dolog(LOG_DEBUG, "copyfield() : '%s', begin = %d, len = %d\n", buf, begin, i); */
 527                         return true;
 528                 }
 529
 530                 i++;
 531         }
 532         dolog(LOG_WARNING, "copyfield() - Field %u didn't exist in '%s'\n", n, s);
 533         return false;
 534 }
 535
 536 bool parseline(char *line, const char *split, struct pl_rule *rules, void *data)
 537 {
 538         unsigned int    r, len;
 539         char            *end = NULL, *val = NULL, *p = NULL;
 540         void            *store;
 541
 542         /* Chop off \n and \r and white space */
 543         p = &line[strlen(line)-1];
 544         while ( p >= line && (
 545                 *p == '\n' ||
 546                 *p == '\r' ||
 547                 *p == '\t' ||
 548                 *p == ' ')) *p-- = '\0';
 549
 550         /* Ignore comments and emtpy lines */
 551         if (    strlen(line) == 0 ||
 552                 line[0] == '#' ||
 553                 line[0] == ';' ||
 554                 (line[0] == '/' && line[1] == '/'))
 555         {
 556                 return true;
 557         }
 558
 559         /* Get the end of the first argument */
 560         p = line;
 561         end = &line[strlen(line)-1];
 562         /* Skip until whitespace */
 563         while ( p < end &&
 564                 strncmp(p, split, strlen(split)) != 0) p++;
 565         /* Terminate this argument */
 566         *p = '\0';
 567         p++;
 568
 569         /* Skip whitespace */
 570         while ( p < end &&
 571                 *p == ' ' &&
 572                 *p == '\t') p++;
 573
 574         /* Start of the value */
 575         val = p+(strlen(split)-1);
 576
 577         /* If starting with quotes, skip until next quote */
 578         if (*p == '"' || *p == '\'')
 579         {
 580                 p++;
 581                 /* Find next quote */
 582                 while (p <= end &&
 583                         *p != *val &&
 584                         *p != '\0') p++;
 585                 /* Terminate */
 586                 *p = '\0';
 587                 /* Skip the first quote */
 588                 val++;
 589         }
 590         /* Otherwise it is already terminated above */
 591
 592         /* Walk through all the rules */
 593         for (r = 0; rules[r].type != PLRT_END; r++)
 594         {
 595                 len = (int)strlen(rules[r].title);
 596                 if (strncmp(line, rules[r].title, len) != 0) continue;
 597
 598                 store = (void *)((char *)data + rules[r].offset);
 599
 600                 switch (rules[r].type)
 601                 {
 602                 case PLRT_STRING:
 603                         if (*((char **)store)) free(*((char **)store));
 604                         *((char **)store) = strdup(val);
 605                         break;
 606
 607                 case PLRT_INTEGER:
 608                         *((uint32_t *)store) = atoi(val);
 609                         break;
 610
 611                 case PLRT_BOOL:
 612                         if (    strcmp(val, "yes") == 0 ||
 613                                 strcmp(val, "true") == 0)
 614                         {
 615                                 *((bool *)store) = true;
 616                         }
 617                         else if (strcmp(val, "no") == 0 ||
 618                                 strcmp(val, "false") == 0)
 619                         {
 620                                 *((bool *)store) = false;
 621                         }
 622                         else
 623                         {
 624                                 dolog(LOG_WARNING, "Unknown boolean value \"%s\" for option \"%s\"\n", val, rules[r].title);
 625                         }
 626                         break;
 627
 628                 case PLRT_IPV4:
 629                         inet_pton(AF_INET, val, store);
 630                         break;
 631
 632                 case PLRT_IPV6:
 633                         inet_pton(AF_INET6, val, store);
 634                         break;
 635
 636                 case PLRT_END:
 637                         return false;
 638                 }
 639                 return true;
 640         }
 641         return false;
 642 }
 643
 644 /*
 645  * MD5 a string
 646  * sSignature's size MUST be 32 bytes!
 647  */
 648 void MD5String(const char *sString, char *sSignature, unsigned int siglen)
 649 {
 650         struct MD5Context       md5c;
 651         unsigned char           signature[16];
 652         unsigned int            i;
 653
 654         if (siglen < 32) return;
 655
 656         /* Initialize MD5 structure */
 657         MD5Init(&md5c);
 658         /* Calculate MD5 of the string */
 659         MD5Update(&md5c, (unsigned char *)sString, (unsigned int)strlen(sString));
 660         MD5Final(signature, &md5c);
 661
 662         memset(sSignature, 0, siglen);
 663
 664         for (i=0; i < sizeof(signature); i++)
 665         {
 666                 snprintf(&sSignature[i*2], 3, "%02x", signature[i]);
 667         }
 668 }
 669
 670 #ifdef _AIX
 671 /* AIX doesn't have vsyslog() thus we implement it here */
 672 void vsyslog(int priority, const char *format, va_list ap)
 673 {
 674         char buf[1024];
 675         vsnprintf(buf, sizeof(buf), format, ap);
 676         syslog(priority, buf);
 677 }
 678 #endif
 679
 680 #ifdef _WIN32
 681 const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt)
 682 {
 683         if (af == AF_INET)
 684         {
 685                 struct sockaddr_in in;
 686                 memset(&in, 0, sizeof(in));
 687                 in.sin_family = AF_INET;
 688                 memcpy(&in.sin_addr, src, sizeof(struct in_addr));
 689                 getnameinfo((struct sockaddr *)&in, sizeof(struct sockaddr_in), dst, cnt, NULL, 0, NI_NUMERICHOST);
 690                 return dst;
 691         }
 692         else if (af == AF_INET6)
 693         {
 694                 struct sockaddr_in6 in;
 695                 memset(&in, 0, sizeof(in));
 696                 in.sin6_family = AF_INET6;
 697                 memcpy(&in.sin6_addr, src, sizeof(struct in_addr6));
 698                 getnameinfo((struct sockaddr *)&in, sizeof(struct sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST);
 699                 return dst;
 700         }
 701         return NULL;
 702 }
 703
 704 int inet_pton(int af, const char *src, void *dst)
 705 {
 706         struct addrinfo hints, *res, *ressave;
 707
 708         memset(&hints, 0, sizeof(struct addrinfo));
 709         hints.ai_family = af;
 710
 711         if (getaddrinfo(src, NULL, &hints, &res) != 0)
 712         {
 713                 dolog(LOG_ERR, "Couldn't resolve host %s\n", src);
 714                 return -1;
 715         }
 716
 717         ressave = res;
 718
 719         while (res)
 720         {
 721                 /* Check if AF is correct */
 722                 if (res->ai_family != af)
 723                 {
 724                         res = res->ai_next;
 725                         continue;
 726                 }
 727
 728                 /* This is the one we want */
 729                 memcpy(dst, res->ai_addr, af == AF_INET6 ? sizeof(struct in_addr6) : sizeof(struct in_addr));
 730
 731                 /* We only need one */
 732                 break;
 733         }
 734
 735         freeaddrinfo(ressave);
 736         return 0;
 737 }
 738
 739 #endif