src/libsystemd/sd-resolve/sd-resolve.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2005-2008 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <errno.h>
  21 #include <poll.h>
  22 #include <pthread.h>
  23 #include <resolv.h>
  24 #include <signal.h>
  25 #include <stdint.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <sys/prctl.h>
  30 #include <unistd.h>
  31
  32 #include "sd-resolve.h"
  33
  34 #include "alloc-util.h"
  35 #include "fd-util.h"
  36 #include "io-util.h"
  37 #include "list.h"
  38 #include "missing.h"
  39 #include "socket-util.h"
  40 #include "util.h"
  41
  42 #define WORKERS_MIN 1U
  43 #define WORKERS_MAX 16U
  44 #define QUERIES_MAX 256U
  45 #define BUFSIZE 10240U
  46
  47 typedef enum {
  48         REQUEST_ADDRINFO,
  49         RESPONSE_ADDRINFO,
  50         REQUEST_NAMEINFO,
  51         RESPONSE_NAMEINFO,
  52         REQUEST_TERMINATE,
  53         RESPONSE_DIED
  54 } QueryType;
  55
  56 enum {
  57         REQUEST_RECV_FD,
  58         REQUEST_SEND_FD,
  59         RESPONSE_RECV_FD,
  60         RESPONSE_SEND_FD,
  61         _FD_MAX
  62 };
  63
  64 struct sd_resolve {
  65         unsigned n_ref;
  66
  67         bool dead:1;
  68         pid_t original_pid;
  69
  70         int fds[_FD_MAX];
  71
  72         pthread_t workers[WORKERS_MAX];
  73         unsigned n_valid_workers;
  74
  75         unsigned current_id;
  76         sd_resolve_query* query_array[QUERIES_MAX];
  77         unsigned n_queries, n_done, n_outstanding;
  78
  79         sd_event_source *event_source;
  80         sd_event *event;
  81
  82         sd_resolve_query *current;
  83
  84         sd_resolve **default_resolve_ptr;
  85         pid_t tid;
  86
  87         LIST_HEAD(sd_resolve_query, queries);
  88 };
  89
  90 struct sd_resolve_query {
  91         unsigned n_ref;
  92
  93         sd_resolve *resolve;
  94
  95         QueryType type:4;
  96         bool done:1;
  97         bool floating:1;
  98         unsigned id;
  99
 100         int ret;
 101         int _errno;
 102         int _h_errno;
 103         struct addrinfo *addrinfo;
 104         char *serv, *host;
 105
 106         union {
 107                 sd_resolve_getaddrinfo_handler_t getaddrinfo_handler;
 108                 sd_resolve_getnameinfo_handler_t getnameinfo_handler;
 109         };
 110
 111         void *userdata;
 112
 113         LIST_FIELDS(sd_resolve_query, queries);
 114 };
 115
 116 typedef struct RHeader {
 117         QueryType type;
 118         unsigned id;
 119         size_t length;
 120 } RHeader;
 121
 122 typedef struct AddrInfoRequest {
 123         struct RHeader header;
 124         bool hints_valid;
 125         int ai_flags;
 126         int ai_family;
 127         int ai_socktype;
 128         int ai_protocol;
 129         size_t node_len, service_len;
 130 } AddrInfoRequest;
 131
 132 typedef struct AddrInfoResponse {
 133         struct RHeader header;
 134         int ret;
 135         int _errno;
 136         int _h_errno;
 137         /* followed by addrinfo_serialization[] */
 138 } AddrInfoResponse;
 139
 140 typedef struct AddrInfoSerialization {
 141         int ai_flags;
 142         int ai_family;
 143         int ai_socktype;
 144         int ai_protocol;
 145         size_t ai_addrlen;
 146         size_t canonname_len;
 147         /* Followed by ai_addr amd ai_canonname with variable lengths */
 148 } AddrInfoSerialization;
 149
 150 typedef struct NameInfoRequest {
 151         struct RHeader header;
 152         int flags;
 153         socklen_t sockaddr_len;
 154         bool gethost:1, getserv:1;
 155 } NameInfoRequest;
 156
 157 typedef struct NameInfoResponse {
 158         struct RHeader header;
 159         size_t hostlen, servlen;
 160         int ret;
 161         int _errno;
 162         int _h_errno;
 163 } NameInfoResponse;
 164
 165 typedef union Packet {
 166         RHeader rheader;
 167         AddrInfoRequest addrinfo_request;
 168         AddrInfoResponse addrinfo_response;
 169         NameInfoRequest nameinfo_request;
 170         NameInfoResponse nameinfo_response;
 171 } Packet;
 172
 173 static int getaddrinfo_done(sd_resolve_query* q);
 174 static int getnameinfo_done(sd_resolve_query *q);
 175
 176 static void resolve_query_disconnect(sd_resolve_query *q);
 177
 178 #define RESOLVE_DONT_DESTROY(resolve) \
 179         _cleanup_(sd_resolve_unrefp) _unused_ sd_resolve *_dont_destroy_##resolve = sd_resolve_ref(resolve)
 180
 181 static int send_died(int out_fd) {
 182
 183         RHeader rh = {
 184                 .type = RESPONSE_DIED,
 185                 .length = sizeof(RHeader),
 186         };
 187
 188         assert(out_fd >= 0);
 189
 190         if (send(out_fd, &rh, rh.length, MSG_NOSIGNAL) < 0)
 191                 return -errno;
 192
 193         return 0;
 194 }
 195
 196 static void *serialize_addrinfo(void *p, const struct addrinfo *ai, size_t *length, size_t maxlength) {
 197         AddrInfoSerialization s;
 198         size_t cnl, l;
 199
 200         assert(p);
 201         assert(ai);
 202         assert(length);
 203         assert(*length <= maxlength);
 204
 205         cnl = ai->ai_canonname ? strlen(ai->ai_canonname)+1 : 0;
 206         l = sizeof(AddrInfoSerialization) + ai->ai_addrlen + cnl;
 207
 208         if (*length + l > maxlength)
 209                 return NULL;
 210
 211         s.ai_flags = ai->ai_flags;
 212         s.ai_family = ai->ai_family;
 213         s.ai_socktype = ai->ai_socktype;
 214         s.ai_protocol = ai->ai_protocol;
 215         s.ai_addrlen = ai->ai_addrlen;
 216         s.canonname_len = cnl;
 217
 218         memcpy((uint8_t*) p, &s, sizeof(AddrInfoSerialization));
 219         memcpy((uint8_t*) p + sizeof(AddrInfoSerialization), ai->ai_addr, ai->ai_addrlen);
 220
 221         if (ai->ai_canonname)
 222                 memcpy((char*) p + sizeof(AddrInfoSerialization) + ai->ai_addrlen, ai->ai_canonname, cnl);
 223
 224         *length += l;
 225         return (uint8_t*) p + l;
 226 }
 227
 228 static int send_addrinfo_reply(
 229                 int out_fd,
 230                 unsigned id,
 231                 int ret,
 232                 struct addrinfo *ai,
 233                 int _errno,
 234                 int _h_errno) {
 235
 236         AddrInfoResponse resp = {
 237                 .header.type = RESPONSE_ADDRINFO,
 238                 .header.id = id,
 239                 .header.length = sizeof(AddrInfoResponse),
 240                 .ret = ret,
 241                 ._errno = _errno,
 242                 ._h_errno = _h_errno,
 243         };
 244
 245         struct msghdr mh = {};
 246         struct iovec iov[2];
 247         union {
 248                 AddrInfoSerialization ais;
 249                 uint8_t space[BUFSIZE];
 250         } buffer;
 251
 252         assert(out_fd >= 0);
 253
 254         if (ret == 0 && ai) {
 255                 void *p = &buffer;
 256                 struct addrinfo *k;
 257
 258                 for (k = ai; k; k = k->ai_next) {
 259                         p = serialize_addrinfo(p, k, &resp.header.length, (uint8_t*) &buffer + BUFSIZE - (uint8_t*) p);
 260                         if (!p) {
 261                                 freeaddrinfo(ai);
 262                                 return -ENOBUFS;
 263                         }
 264                 }
 265         }
 266
 267         if (ai)
 268                 freeaddrinfo(ai);
 269
 270         iov[0] = (struct iovec) { .iov_base = &resp, .iov_len = sizeof(AddrInfoResponse) };
 271         iov[1] = (struct iovec) { .iov_base = &buffer, .iov_len = resp.header.length - sizeof(AddrInfoResponse) };
 272
 273         mh.msg_iov = iov;
 274         mh.msg_iovlen = ELEMENTSOF(iov);
 275
 276         if (sendmsg(out_fd, &mh, MSG_NOSIGNAL) < 0)
 277                 return -errno;
 278
 279         return 0;
 280 }
 281
 282 static int send_nameinfo_reply(
 283                 int out_fd,
 284                 unsigned id,
 285                 int ret,
 286                 const char *host,
 287                 const char *serv,
 288                 int _errno,
 289                 int _h_errno) {
 290
 291         NameInfoResponse resp = {
 292                 .header.type = RESPONSE_NAMEINFO,
 293                 .header.id = id,
 294                 .ret = ret,
 295                 ._errno = _errno,
 296                 ._h_errno = _h_errno,
 297         };
 298
 299         struct msghdr mh = {};
 300         struct iovec iov[3];
 301         size_t hl, sl;
 302
 303         assert(out_fd >= 0);
 304
 305         sl = serv ? strlen(serv)+1 : 0;
 306         hl = host ? strlen(host)+1 : 0;
 307
 308         resp.header.length = sizeof(NameInfoResponse) + hl + sl;
 309         resp.hostlen = hl;
 310         resp.servlen = sl;
 311
 312         iov[0] = (struct iovec) { .iov_base = &resp, .iov_len = sizeof(NameInfoResponse) };
 313         iov[1] = (struct iovec) { .iov_base = (void*) host, .iov_len = hl };
 314         iov[2] = (struct iovec) { .iov_base = (void*) serv, .iov_len = sl };
 315
 316         mh.msg_iov = iov;
 317         mh.msg_iovlen = ELEMENTSOF(iov);
 318
 319         if (sendmsg(out_fd, &mh, MSG_NOSIGNAL) < 0)
 320                 return -errno;
 321
 322         return 0;
 323 }
 324
 325 static int handle_request(int out_fd, const Packet *packet, size_t length) {
 326         const RHeader *req;
 327
 328         assert(out_fd >= 0);
 329         assert(packet);
 330
 331         req = &packet->rheader;
 332
 333         assert(length >= sizeof(RHeader));
 334         assert(length == req->length);
 335
 336         switch (req->type) {
 337
 338         case REQUEST_ADDRINFO: {
 339                const AddrInfoRequest *ai_req = &packet->addrinfo_request;
 340                struct addrinfo hints = {}, *result = NULL;
 341                const char *node, *service;
 342                int ret;
 343
 344                assert(length >= sizeof(AddrInfoRequest));
 345                assert(length == sizeof(AddrInfoRequest) + ai_req->node_len + ai_req->service_len);
 346
 347                hints.ai_flags = ai_req->ai_flags;
 348                hints.ai_family = ai_req->ai_family;
 349                hints.ai_socktype = ai_req->ai_socktype;
 350                hints.ai_protocol = ai_req->ai_protocol;
 351
 352                node = ai_req->node_len ? (const char*) ai_req + sizeof(AddrInfoRequest) : NULL;
 353                service = ai_req->service_len ? (const char*) ai_req + sizeof(AddrInfoRequest) + ai_req->node_len : NULL;
 354
 355                ret = getaddrinfo(
 356                                node, service,
 357                                ai_req->hints_valid ? &hints : NULL,
 358                                &result);
 359
 360                /* send_addrinfo_reply() frees result */
 361                return send_addrinfo_reply(out_fd, req->id, ret, result, errno, h_errno);
 362         }
 363
 364         case REQUEST_NAMEINFO: {
 365                const NameInfoRequest *ni_req = &packet->nameinfo_request;
 366                char hostbuf[NI_MAXHOST], servbuf[NI_MAXSERV];
 367                union sockaddr_union sa;
 368                int ret;
 369
 370                assert(length >= sizeof(NameInfoRequest));
 371                assert(length == sizeof(NameInfoRequest) + ni_req->sockaddr_len);
 372                assert(sizeof(sa) >= ni_req->sockaddr_len);
 373
 374                memcpy(&sa, (const uint8_t *) ni_req + sizeof(NameInfoRequest), ni_req->sockaddr_len);
 375
 376                ret = getnameinfo(&sa.sa, ni_req->sockaddr_len,
 377                                ni_req->gethost ? hostbuf : NULL, ni_req->gethost ? sizeof(hostbuf) : 0,
 378                                ni_req->getserv ? servbuf : NULL, ni_req->getserv ? sizeof(servbuf) : 0,
 379                                ni_req->flags);
 380
 381                return send_nameinfo_reply(out_fd, req->id, ret,
 382                                ret == 0 && ni_req->gethost ? hostbuf : NULL,
 383                                ret == 0 && ni_req->getserv ? servbuf : NULL,
 384                                errno, h_errno);
 385         }
 386
 387         case REQUEST_TERMINATE:
 388                  /* Quit */
 389                  return -ECONNRESET;
 390
 391         default:
 392                 assert_not_reached("Unknown request");
 393         }
 394
 395         return 0;
 396 }
 397
 398 static void* thread_worker(void *p) {
 399         sd_resolve *resolve = p;
 400         sigset_t fullset;
 401
 402         /* No signals in this thread please */
 403         assert_se(sigfillset(&fullset) == 0);
 404         assert_se(pthread_sigmask(SIG_BLOCK, &fullset, NULL) == 0);
 405
 406         /* Assign a pretty name to this thread */
 407         prctl(PR_SET_NAME, (unsigned long) "sd-resolve");
 408
 409         while (!resolve->dead) {
 410                 union {
 411                         Packet packet;
 412                         uint8_t space[BUFSIZE];
 413                 } buf;
 414                 ssize_t length;
 415
 416                 length = recv(resolve->fds[REQUEST_RECV_FD], &buf, sizeof(buf), 0);
 417                 if (length < 0) {
 418                         if (errno == EINTR)
 419                                 continue;
 420
 421                         break;
 422                 }
 423                 if (length == 0)
 424                         break;
 425
 426                 if (resolve->dead)
 427                         break;
 428
 429                 if (handle_request(resolve->fds[RESPONSE_SEND_FD], &buf.packet, (size_t) length) < 0)
 430                         break;
 431         }
 432
 433         send_died(resolve->fds[RESPONSE_SEND_FD]);
 434
 435         return NULL;
 436 }
 437
 438 static int start_threads(sd_resolve *resolve, unsigned extra) {
 439         unsigned n;
 440         int r;
 441
 442         n = resolve->n_outstanding + extra;
 443         n = CLAMP(n, WORKERS_MIN, WORKERS_MAX);
 444
 445         while (resolve->n_valid_workers < n) {
 446
 447                 r = pthread_create(&resolve->workers[resolve->n_valid_workers], NULL, thread_worker, resolve);
 448                 if (r != 0)
 449                         return -r;
 450
 451                 resolve->n_valid_workers ++;
 452         }
 453
 454         return 0;
 455 }
 456
 457 static bool resolve_pid_changed(sd_resolve *r) {
 458         assert(r);
 459
 460         /* We don't support people creating a resolver and keeping it
 461          * around after fork(). Let's complain. */
 462
 463         return r->original_pid != getpid();
 464 }
 465
 466 _public_ int sd_resolve_new(sd_resolve **ret) {
 467         sd_resolve *resolve = NULL;
 468         int i, r;
 469
 470         assert_return(ret, -EINVAL);
 471
 472         resolve = new0(sd_resolve, 1);
 473         if (!resolve)
 474                 return -ENOMEM;
 475
 476         resolve->n_ref = 1;
 477         resolve->original_pid = getpid();
 478
 479         for (i = 0; i < _FD_MAX; i++)
 480                 resolve->fds[i] = -1;
 481
 482         r = socketpair(PF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, resolve->fds + REQUEST_RECV_FD);
 483         if (r < 0) {
 484                 r = -errno;
 485                 goto fail;
 486         }
 487
 488         r = socketpair(PF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0, resolve->fds + RESPONSE_RECV_FD);
 489         if (r < 0) {
 490                 r = -errno;
 491                 goto fail;
 492         }
 493
 494         fd_inc_sndbuf(resolve->fds[REQUEST_SEND_FD], QUERIES_MAX * BUFSIZE);
 495         fd_inc_rcvbuf(resolve->fds[REQUEST_RECV_FD], QUERIES_MAX * BUFSIZE);
 496         fd_inc_sndbuf(resolve->fds[RESPONSE_SEND_FD], QUERIES_MAX * BUFSIZE);
 497         fd_inc_rcvbuf(resolve->fds[RESPONSE_RECV_FD], QUERIES_MAX * BUFSIZE);
 498
 499         fd_nonblock(resolve->fds[RESPONSE_RECV_FD], true);
 500
 501         *ret = resolve;
 502         return 0;
 503
 504 fail:
 505         sd_resolve_unref(resolve);
 506         return r;
 507 }
 508
 509 _public_ int sd_resolve_default(sd_resolve **ret) {
 510
 511         static thread_local sd_resolve *default_resolve = NULL;
 512         sd_resolve *e = NULL;
 513         int r;
 514
 515         if (!ret)
 516                 return !!default_resolve;
 517
 518         if (default_resolve) {
 519                 *ret = sd_resolve_ref(default_resolve);
 520                 return 0;
 521         }
 522
 523         r = sd_resolve_new(&e);
 524         if (r < 0)
 525                 return r;
 526
 527         e->default_resolve_ptr = &default_resolve;
 528         e->tid = gettid();
 529         default_resolve = e;
 530
 531         *ret = e;
 532         return 1;
 533 }
 534
 535 _public_ int sd_resolve_get_tid(sd_resolve *resolve, pid_t *tid) {
 536         assert_return(resolve, -EINVAL);
 537         assert_return(tid, -EINVAL);
 538         assert_return(!resolve_pid_changed(resolve), -ECHILD);
 539
 540         if (resolve->tid != 0) {
 541                 *tid = resolve->tid;
 542                 return 0;
 543         }
 544
 545         if (resolve->event)
 546                 return sd_event_get_tid(resolve->event, tid);
 547
 548         return -ENXIO;
 549 }
 550
 551 static void resolve_free(sd_resolve *resolve) {
 552         PROTECT_ERRNO;
 553         sd_resolve_query *q;
 554         unsigned i;
 555
 556         assert(resolve);
 557
 558         while ((q = resolve->queries)) {
 559                 assert(q->floating);
 560                 resolve_query_disconnect(q);
 561                 sd_resolve_query_unref(q);
 562         }
 563
 564         if (resolve->default_resolve_ptr)
 565                 *(resolve->default_resolve_ptr) = NULL;
 566
 567         resolve->dead = true;
 568
 569         sd_resolve_detach_event(resolve);
 570
 571         if (resolve->fds[REQUEST_SEND_FD] >= 0) {
 572
 573                 RHeader req = {
 574                         .type = REQUEST_TERMINATE,
 575                         .length = sizeof(req)
 576                 };
 577
 578                 /* Send one termination packet for each worker */
 579                 for (i = 0; i < resolve->n_valid_workers; i++)
 580                         (void) send(resolve->fds[REQUEST_SEND_FD], &req, req.length, MSG_NOSIGNAL);
 581         }
 582
 583         /* Now terminate them and wait until they are gone. */
 584         for (i = 0; i < resolve->n_valid_workers; i++)
 585                 pthread_join(resolve->workers[i], NULL);
 586
 587         /* Close all communication channels */
 588         for (i = 0; i < _FD_MAX; i++)
 589                 safe_close(resolve->fds[i]);
 590
 591         free(resolve);
 592 }
 593
 594 _public_ sd_resolve* sd_resolve_ref(sd_resolve *resolve) {
 595         assert_return(resolve, NULL);
 596
 597         assert(resolve->n_ref >= 1);
 598         resolve->n_ref++;
 599
 600         return resolve;
 601 }
 602
 603 _public_ sd_resolve* sd_resolve_unref(sd_resolve *resolve) {
 604
 605         if (!resolve)
 606                 return NULL;
 607
 608         assert(resolve->n_ref >= 1);
 609         resolve->n_ref--;
 610
 611         if (resolve->n_ref <= 0)
 612                 resolve_free(resolve);
 613
 614         return NULL;
 615 }
 616
 617 _public_ int sd_resolve_get_fd(sd_resolve *resolve) {
 618         assert_return(resolve, -EINVAL);
 619         assert_return(!resolve_pid_changed(resolve), -ECHILD);
 620
 621         return resolve->fds[RESPONSE_RECV_FD];
 622 }
 623
 624 _public_ int sd_resolve_get_events(sd_resolve *resolve) {
 625         assert_return(resolve, -EINVAL);
 626         assert_return(!resolve_pid_changed(resolve), -ECHILD);
 627
 628         return resolve->n_queries > resolve->n_done ? POLLIN : 0;
 629 }
 630
 631 _public_ int sd_resolve_get_timeout(sd_resolve *resolve, uint64_t *usec) {
 632         assert_return(resolve, -EINVAL);
 633         assert_return(usec, -EINVAL);
 634         assert_return(!resolve_pid_changed(resolve), -ECHILD);
 635
 636         *usec = (uint64_t) -1;
 637         return 0;
 638 }
 639
 640 static sd_resolve_query *lookup_query(sd_resolve *resolve, unsigned id) {
 641         sd_resolve_query *q;
 642
 643         assert(resolve);
 644
 645         q = resolve->query_array[id % QUERIES_MAX];
 646         if (q)
 647                 if (q->id == id)
 648                         return q;
 649
 650         return NULL;
 651 }
 652
 653 static int complete_query(sd_resolve *resolve, sd_resolve_query *q) {
 654         int r;
 655
 656         assert(q);
 657         assert(!q->done);
 658         assert(q->resolve == resolve);
 659
 660         q->done = true;
 661         resolve->n_done ++;
 662
 663         resolve->current = sd_resolve_query_ref(q);
 664
 665         switch (q->type) {
 666
 667         case REQUEST_ADDRINFO:
 668                 r = getaddrinfo_done(q);
 669                 break;
 670
 671         case REQUEST_NAMEINFO:
 672                 r = getnameinfo_done(q);
 673                 break;
 674
 675         default:
 676                 assert_not_reached("Cannot complete unknown query type");
 677         }
 678
 679         resolve->current = NULL;
 680
 681         if (q->floating) {
 682                 resolve_query_disconnect(q);
 683                 sd_resolve_query_unref(q);
 684         }
 685
 686         sd_resolve_query_unref(q);
 687
 688         return r;
 689 }
 690
 691 static int unserialize_addrinfo(const void **p, size_t *length, struct addrinfo **ret_ai) {
 692         AddrInfoSerialization s;
 693         size_t l;
 694         struct addrinfo *ai;
 695
 696         assert(p);
 697         assert(*p);
 698         assert(ret_ai);
 699         assert(length);
 700
 701         if (*length < sizeof(AddrInfoSerialization))
 702                 return -EBADMSG;
 703
 704         memcpy(&s, *p, sizeof(s));
 705
 706         l = sizeof(AddrInfoSerialization) + s.ai_addrlen + s.canonname_len;
 707         if (*length < l)
 708                 return -EBADMSG;
 709
 710         ai = new0(struct addrinfo, 1);
 711         if (!ai)
 712                 return -ENOMEM;
 713
 714         ai->ai_flags = s.ai_flags;
 715         ai->ai_family = s.ai_family;
 716         ai->ai_socktype = s.ai_socktype;
 717         ai->ai_protocol = s.ai_protocol;
 718         ai->ai_addrlen = s.ai_addrlen;
 719
 720         if (s.ai_addrlen > 0) {
 721                 ai->ai_addr = memdup((const uint8_t*) *p + sizeof(AddrInfoSerialization), s.ai_addrlen);
 722                 if (!ai->ai_addr) {
 723                         free(ai);
 724                         return -ENOMEM;
 725                 }
 726         }
 727
 728         if (s.canonname_len > 0) {
 729                 ai->ai_canonname = memdup((const uint8_t*) *p + sizeof(AddrInfoSerialization) + s.ai_addrlen, s.canonname_len);
 730                 if (!ai->ai_canonname) {
 731                         free(ai->ai_addr);
 732                         free(ai);
 733                         return -ENOMEM;
 734                 }
 735         }
 736
 737         *length -= l;
 738         *ret_ai = ai;
 739         *p = ((const uint8_t*) *p) + l;
 740
 741         return 0;
 742 }
 743
 744 static int handle_response(sd_resolve *resolve, const Packet *packet, size_t length) {
 745         const RHeader *resp;
 746         sd_resolve_query *q;
 747         int r;
 748
 749         assert(resolve);
 750
 751         resp = &packet->rheader;
 752         assert(resp);
 753         assert(length >= sizeof(RHeader));
 754         assert(length == resp->length);
 755
 756         if (resp->type == RESPONSE_DIED) {
 757                 resolve->dead = true;
 758                 return 0;
 759         }
 760
 761         assert(resolve->n_outstanding > 0);
 762         resolve->n_outstanding--;
 763
 764         q = lookup_query(resolve, resp->id);
 765         if (!q)
 766                 return 0;
 767
 768         switch (resp->type) {
 769
 770         case RESPONSE_ADDRINFO: {
 771                 const AddrInfoResponse *ai_resp = &packet->addrinfo_response;
 772                 const void *p;
 773                 size_t l;
 774                 struct addrinfo *prev = NULL;
 775
 776                 assert(length >= sizeof(AddrInfoResponse));
 777                 assert(q->type == REQUEST_ADDRINFO);
 778
 779                 q->ret = ai_resp->ret;
 780                 q->_errno = ai_resp->_errno;
 781                 q->_h_errno = ai_resp->_h_errno;
 782
 783                 l = length - sizeof(AddrInfoResponse);
 784                 p = (const uint8_t*) resp + sizeof(AddrInfoResponse);
 785
 786                 while (l > 0 && p) {
 787                         struct addrinfo *ai = NULL;
 788
 789                         r = unserialize_addrinfo(&p, &l, &ai);
 790                         if (r < 0) {
 791                                 q->ret = EAI_SYSTEM;
 792                                 q->_errno = -r;
 793                                 q->_h_errno = 0;
 794                                 freeaddrinfo(q->addrinfo);
 795                                 q->addrinfo = NULL;
 796                                 break;
 797                         }
 798
 799                         if (prev)
 800                                 prev->ai_next = ai;
 801                         else
 802                                 q->addrinfo = ai;
 803
 804                         prev = ai;
 805                 }
 806
 807                 return complete_query(resolve, q);
 808         }
 809
 810         case RESPONSE_NAMEINFO: {
 811                 const NameInfoResponse *ni_resp = &packet->nameinfo_response;
 812
 813                 assert(length >= sizeof(NameInfoResponse));
 814                 assert(q->type == REQUEST_NAMEINFO);
 815
 816                 q->ret = ni_resp->ret;
 817                 q->_errno = ni_resp->_errno;
 818                 q->_h_errno = ni_resp->_h_errno;
 819
 820                 if (ni_resp->hostlen > 0) {
 821                         q->host = strndup((const char*) ni_resp + sizeof(NameInfoResponse), ni_resp->hostlen-1);
 822                         if (!q->host) {
 823                                 q->ret = EAI_MEMORY;
 824                                 q->_errno = ENOMEM;
 825                                 q->_h_errno = 0;
 826                         }
 827                 }
 828
 829                 if (ni_resp->servlen > 0) {
 830                         q->serv = strndup((const char*) ni_resp + sizeof(NameInfoResponse) + ni_resp->hostlen, ni_resp->servlen-1);
 831                         if (!q->serv) {
 832                                 q->ret = EAI_MEMORY;
 833                                 q->_errno = ENOMEM;
 834                                 q->_h_errno = 0;
 835                         }
 836                 }
 837
 838                 return complete_query(resolve, q);
 839         }
 840
 841         default:
 842                 return 0;
 843         }
 844 }
 845
 846 _public_ int sd_resolve_process(sd_resolve *resolve) {
 847         RESOLVE_DONT_DESTROY(resolve);
 848
 849         union {
 850                 Packet packet;
 851                 uint8_t space[BUFSIZE];
 852         } buf;
 853         ssize_t l;
 854         int r;
 855
 856         assert_return(resolve, -EINVAL);
 857         assert_return(!resolve_pid_changed(resolve), -ECHILD);
 858
 859         /* We don't allow recursively invoking sd_resolve_process(). */
 860         assert_return(!resolve->current, -EBUSY);
 861
 862         l = recv(resolve->fds[RESPONSE_RECV_FD], &buf, sizeof(buf), 0);
 863         if (l < 0) {
 864                 if (errno == EAGAIN)
 865                         return 0;
 866
 867                 return -errno;
 868         }
 869         if (l == 0)
 870                 return -ECONNREFUSED;
 871
 872         r = handle_response(resolve, &buf.packet, (size_t) l);
 873         if (r < 0)
 874                 return r;
 875
 876         return 1;
 877 }
 878
 879 _public_ int sd_resolve_wait(sd_resolve *resolve, uint64_t timeout_usec) {
 880         int r;
 881
 882         assert_return(resolve, -EINVAL);
 883         assert_return(!resolve_pid_changed(resolve), -ECHILD);
 884
 885         if (resolve->n_done >= resolve->n_queries)
 886                 return 0;
 887
 888         do {
 889                 r = fd_wait_for_event(resolve->fds[RESPONSE_RECV_FD], POLLIN, timeout_usec);
 890         } while (r == -EINTR);
 891
 892         if (r < 0)
 893                 return r;
 894
 895         return sd_resolve_process(resolve);
 896 }
 897
 898 static int alloc_query(sd_resolve *resolve, bool floating, sd_resolve_query **_q) {
 899         sd_resolve_query *q;
 900         int r;
 901
 902         assert(resolve);
 903         assert(_q);
 904
 905         if (resolve->n_queries >= QUERIES_MAX)
 906                 return -ENOBUFS;
 907
 908         r = start_threads(resolve, 1);
 909         if (r < 0)
 910                 return r;
 911
 912         while (resolve->query_array[resolve->current_id % QUERIES_MAX])
 913                 resolve->current_id++;
 914
 915         q = resolve->query_array[resolve->current_id % QUERIES_MAX] = new0(sd_resolve_query, 1);
 916         if (!q)
 917                 return -ENOMEM;
 918
 919         q->n_ref = 1;
 920         q->resolve = resolve;
 921         q->floating = floating;
 922         q->id = resolve->current_id++;
 923
 924         if (!floating)
 925                 sd_resolve_ref(resolve);
 926
 927         LIST_PREPEND(queries, resolve->queries, q);
 928         resolve->n_queries++;
 929
 930         *_q = q;
 931         return 0;
 932 }
 933
 934 _public_ int sd_resolve_getaddrinfo(
 935                 sd_resolve *resolve,
 936                 sd_resolve_query **_q,
 937                 const char *node, const char *service,
 938                 const struct addrinfo *hints,
 939                 sd_resolve_getaddrinfo_handler_t callback, void *userdata) {
 940
 941         AddrInfoRequest req = {};
 942         struct msghdr mh = {};
 943         struct iovec iov[3];
 944         sd_resolve_query *q;
 945         int r;
 946
 947         assert_return(resolve, -EINVAL);
 948         assert_return(node || service, -EINVAL);
 949         assert_return(callback, -EINVAL);
 950         assert_return(!resolve_pid_changed(resolve), -ECHILD);
 951
 952         r = alloc_query(resolve, !_q, &q);
 953         if (r < 0)
 954                 return r;
 955
 956         q->type = REQUEST_ADDRINFO;
 957         q->getaddrinfo_handler = callback;
 958         q->userdata = userdata;
 959
 960         req.node_len = node ? strlen(node)+1 : 0;
 961         req.service_len = service ? strlen(service)+1 : 0;
 962
 963         req.header.id = q->id;
 964         req.header.type = REQUEST_ADDRINFO;
 965         req.header.length = sizeof(AddrInfoRequest) + req.node_len + req.service_len;
 966
 967         if (hints) {
 968                 req.hints_valid = true;
 969                 req.ai_flags = hints->ai_flags;
 970                 req.ai_family = hints->ai_family;
 971                 req.ai_socktype = hints->ai_socktype;
 972                 req.ai_protocol = hints->ai_protocol;
 973         }
 974
 975         iov[mh.msg_iovlen++] = (struct iovec) { .iov_base = &req, .iov_len = sizeof(AddrInfoRequest) };
 976         if (node)
 977                 iov[mh.msg_iovlen++] = (struct iovec) { .iov_base = (void*) node, .iov_len = req.node_len };
 978         if (service)
 979                 iov[mh.msg_iovlen++] = (struct iovec) { .iov_base = (void*) service, .iov_len = req.service_len };
 980         mh.msg_iov = iov;
 981
 982         if (sendmsg(resolve->fds[REQUEST_SEND_FD], &mh, MSG_NOSIGNAL) < 0) {
 983                 sd_resolve_query_unref(q);
 984                 return -errno;
 985         }
 986
 987         resolve->n_outstanding++;
 988
 989         if (_q)
 990                 *_q = q;
 991
 992         return 0;
 993 }
 994
 995 static int getaddrinfo_done(sd_resolve_query* q) {
 996         assert(q);
 997         assert(q->done);
 998         assert(q->getaddrinfo_handler);
 999
1000         errno = q->_errno;
1001         h_errno = q->_h_errno;
1002
1003         return q->getaddrinfo_handler(q, q->ret, q->addrinfo, q->userdata);
1004 }
1005
1006 _public_ int sd_resolve_getnameinfo(
1007                 sd_resolve *resolve,
1008                 sd_resolve_query**_q,
1009                 const struct sockaddr *sa, socklen_t salen,
1010                 int flags,
1011                 uint64_t get,
1012                 sd_resolve_getnameinfo_handler_t callback,
1013                 void *userdata) {
1014
1015         NameInfoRequest req = {};
1016         struct msghdr mh = {};
1017         struct iovec iov[2];
1018         sd_resolve_query *q;
1019         int r;
1020
1021         assert_return(resolve, -EINVAL);
1022         assert_return(sa, -EINVAL);
1023         assert_return(salen >= sizeof(struct sockaddr), -EINVAL);
1024         assert_return(salen <= sizeof(union sockaddr_union), -EINVAL);
1025         assert_return((get & ~SD_RESOLVE_GET_BOTH) == 0, -EINVAL);
1026         assert_return(callback, -EINVAL);
1027         assert_return(!resolve_pid_changed(resolve), -ECHILD);
1028
1029         r = alloc_query(resolve, !_q, &q);
1030         if (r < 0)
1031                 return r;
1032
1033         q->type = REQUEST_NAMEINFO;
1034         q->getnameinfo_handler = callback;
1035         q->userdata = userdata;
1036
1037         req.header.id = q->id;
1038         req.header.type = REQUEST_NAMEINFO;
1039         req.header.length = sizeof(NameInfoRequest) + salen;
1040
1041         req.flags = flags;
1042         req.sockaddr_len = salen;
1043         req.gethost = !!(get & SD_RESOLVE_GET_HOST);
1044         req.getserv = !!(get & SD_RESOLVE_GET_SERVICE);
1045
1046         iov[0] = (struct iovec) { .iov_base = &req, .iov_len = sizeof(NameInfoRequest) };
1047         iov[1] = (struct iovec) { .iov_base = (void*) sa, .iov_len = salen };
1048
1049         mh.msg_iov = iov;
1050         mh.msg_iovlen = 2;
1051
1052         if (sendmsg(resolve->fds[REQUEST_SEND_FD], &mh, MSG_NOSIGNAL) < 0) {
1053                 sd_resolve_query_unref(q);
1054                 return -errno;
1055         }
1056
1057         resolve->n_outstanding++;
1058
1059         if (_q)
1060                 *_q = q;
1061
1062         return 0;
1063 }
1064
1065 static int getnameinfo_done(sd_resolve_query *q) {
1066
1067         assert(q);
1068         assert(q->done);
1069         assert(q->getnameinfo_handler);
1070
1071         errno = q->_errno;
1072         h_errno= q->_h_errno;
1073
1074         return q->getnameinfo_handler(q, q->ret, q->host, q->serv, q->userdata);
1075 }
1076
1077 _public_ sd_resolve_query* sd_resolve_query_ref(sd_resolve_query *q) {
1078         assert_return(q, NULL);
1079
1080         assert(q->n_ref >= 1);
1081         q->n_ref++;
1082
1083         return q;
1084 }
1085
1086 static void resolve_freeaddrinfo(struct addrinfo *ai) {
1087         while (ai) {
1088                 struct addrinfo *next = ai->ai_next;
1089
1090                 free(ai->ai_addr);
1091                 free(ai->ai_canonname);
1092                 free(ai);
1093                 ai = next;
1094         }
1095 }
1096
1097 static void resolve_query_disconnect(sd_resolve_query *q) {
1098         sd_resolve *resolve;
1099         unsigned i;
1100
1101         assert(q);
1102
1103         if (!q->resolve)
1104                 return;
1105
1106         resolve = q->resolve;
1107         assert(resolve->n_queries > 0);
1108
1109         if (q->done) {
1110                 assert(resolve->n_done > 0);
1111                 resolve->n_done--;
1112         }
1113
1114         i = q->id % QUERIES_MAX;
1115         assert(resolve->query_array[i] == q);
1116         resolve->query_array[i] = NULL;
1117         LIST_REMOVE(queries, resolve->queries, q);
1118         resolve->n_queries--;
1119
1120         q->resolve = NULL;
1121         if (!q->floating)
1122                 sd_resolve_unref(resolve);
1123 }
1124
1125 static void resolve_query_free(sd_resolve_query *q) {
1126         assert(q);
1127
1128         resolve_query_disconnect(q);
1129
1130         resolve_freeaddrinfo(q->addrinfo);
1131         free(q->host);
1132         free(q->serv);
1133         free(q);
1134 }
1135
1136 _public_ sd_resolve_query* sd_resolve_query_unref(sd_resolve_query* q) {
1137         if (!q)
1138                 return NULL;
1139
1140         assert(q->n_ref >= 1);
1141         q->n_ref--;
1142
1143         if (q->n_ref <= 0)
1144                 resolve_query_free(q);
1145
1146         return NULL;
1147 }
1148
1149 _public_ int sd_resolve_query_is_done(sd_resolve_query *q) {
1150         assert_return(q, -EINVAL);
1151         assert_return(!resolve_pid_changed(q->resolve), -ECHILD);
1152
1153         return q->done;
1154 }
1155
1156 _public_ void* sd_resolve_query_set_userdata(sd_resolve_query *q, void *userdata) {
1157         void *ret;
1158
1159         assert_return(q, NULL);
1160         assert_return(!resolve_pid_changed(q->resolve), NULL);
1161
1162         ret = q->userdata;
1163         q->userdata = userdata;
1164
1165         return ret;
1166 }
1167
1168 _public_ void* sd_resolve_query_get_userdata(sd_resolve_query *q) {
1169         assert_return(q, NULL);
1170         assert_return(!resolve_pid_changed(q->resolve), NULL);
1171
1172         return q->userdata;
1173 }
1174
1175 _public_ sd_resolve *sd_resolve_query_get_resolve(sd_resolve_query *q) {
1176         assert_return(q, NULL);
1177         assert_return(!resolve_pid_changed(q->resolve), NULL);
1178
1179         return q->resolve;
1180 }
1181
1182 static int io_callback(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1183         sd_resolve *resolve = userdata;
1184         int r;
1185
1186         assert(resolve);
1187
1188         r = sd_resolve_process(resolve);
1189         if (r < 0)
1190                 return r;
1191
1192         return 1;
1193 }
1194
1195 _public_ int sd_resolve_attach_event(sd_resolve *resolve, sd_event *event, int priority) {
1196         int r;
1197
1198         assert_return(resolve, -EINVAL);
1199         assert_return(!resolve->event, -EBUSY);
1200
1201         assert(!resolve->event_source);
1202
1203         if (event)
1204                 resolve->event = sd_event_ref(event);
1205         else {
1206                 r = sd_event_default(&resolve->event);
1207                 if (r < 0)
1208                         return r;
1209         }
1210
1211         r = sd_event_add_io(resolve->event, &resolve->event_source, resolve->fds[RESPONSE_RECV_FD], POLLIN, io_callback, resolve);
1212         if (r < 0)
1213                 goto fail;
1214
1215         r = sd_event_source_set_priority(resolve->event_source, priority);
1216         if (r < 0)
1217                 goto fail;
1218
1219         return 0;
1220
1221 fail:
1222         sd_resolve_detach_event(resolve);
1223         return r;
1224 }
1225
1226 _public_  int sd_resolve_detach_event(sd_resolve *resolve) {
1227         assert_return(resolve, -EINVAL);
1228
1229         if (!resolve->event)
1230                 return 0;
1231
1232         if (resolve->event_source) {
1233                 sd_event_source_set_enabled(resolve->event_source, SD_EVENT_OFF);
1234                 resolve->event_source = sd_event_source_unref(resolve->event_source);
1235         }
1236
1237         resolve->event = sd_event_unref(resolve->event);
1238         return 1;
1239 }
1240
1241 _public_ sd_event *sd_resolve_get_event(sd_resolve *resolve) {
1242         assert_return(resolve, NULL);
1243
1244         return resolve->event;
1245 }