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

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