src/libsystemd/sd-bus/bus-socket.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <endian.h>
  23 #include <poll.h>
  24 #include <stdlib.h>
  25 #include <unistd.h>
  26
  27 #include "sd-bus.h"
  28 #include "sd-daemon.h"
  29
  30 #include "alloc-util.h"
  31 #include "bus-internal.h"
  32 #include "bus-message.h"
  33 #include "bus-socket.h"
  34 #include "fd-util.h"
  35 #include "formats-util.h"
  36 #include "hexdecoct.h"
  37 #include "macro.h"
  38 #include "missing.h"
  39 #include "signal-util.h"
  40 #include "stdio-util.h"
  41 #include "string-util.h"
  42 #include "user-util.h"
  43 #include "utf8.h"
  44 #include "util.h"
  45
  46 #define SNDBUF_SIZE (8*1024*1024)
  47
  48 static void iovec_advance(struct iovec iov[], unsigned *idx, size_t size) {
  49
  50         while (size > 0) {
  51                 struct iovec *i = iov + *idx;
  52
  53                 if (i->iov_len > size) {
  54                         i->iov_base = (uint8_t*) i->iov_base + size;
  55                         i->iov_len -= size;
  56                         return;
  57                 }
  58
  59                 size -= i->iov_len;
  60
  61                 i->iov_base = NULL;
  62                 i->iov_len = 0;
  63
  64                 (*idx) ++;
  65         }
  66 }
  67
  68 static int append_iovec(sd_bus_message *m, const void *p, size_t sz) {
  69         assert(m);
  70         assert(p);
  71         assert(sz > 0);
  72
  73         m->iovec[m->n_iovec].iov_base = (void*) p;
  74         m->iovec[m->n_iovec].iov_len = sz;
  75         m->n_iovec++;
  76
  77         return 0;
  78 }
  79
  80 static int bus_message_setup_iovec(sd_bus_message *m) {
  81         struct bus_body_part *part;
  82         unsigned n, i;
  83         int r;
  84
  85         assert(m);
  86         assert(m->sealed);
  87
  88         if (m->n_iovec > 0)
  89                 return 0;
  90
  91         assert(!m->iovec);
  92
  93         n = 1 + m->n_body_parts;
  94         if (n < ELEMENTSOF(m->iovec_fixed))
  95                 m->iovec = m->iovec_fixed;
  96         else {
  97                 m->iovec = new(struct iovec, n);
  98                 if (!m->iovec) {
  99                         r = -ENOMEM;
 100                         goto fail;
 101                 }
 102         }
 103
 104         r = append_iovec(m, m->header, BUS_MESSAGE_BODY_BEGIN(m));
 105         if (r < 0)
 106                 goto fail;
 107
 108         MESSAGE_FOREACH_PART(part, i, m)  {
 109                 r = bus_body_part_map(part);
 110                 if (r < 0)
 111                         goto fail;
 112
 113                 r = append_iovec(m, part->data, part->size);
 114                 if (r < 0)
 115                         goto fail;
 116         }
 117
 118         assert(n == m->n_iovec);
 119
 120         return 0;
 121
 122 fail:
 123         m->poisoned = true;
 124         return r;
 125 }
 126
 127 bool bus_socket_auth_needs_write(sd_bus *b) {
 128
 129         unsigned i;
 130
 131         if (b->auth_index >= ELEMENTSOF(b->auth_iovec))
 132                 return false;
 133
 134         for (i = b->auth_index; i < ELEMENTSOF(b->auth_iovec); i++) {
 135                 struct iovec *j = b->auth_iovec + i;
 136
 137                 if (j->iov_len > 0)
 138                         return true;
 139         }
 140
 141         return false;
 142 }
 143
 144 static int bus_socket_write_auth(sd_bus *b) {
 145         ssize_t k;
 146
 147         assert(b);
 148         assert(b->state == BUS_AUTHENTICATING);
 149
 150         if (!bus_socket_auth_needs_write(b))
 151                 return 0;
 152
 153         if (b->prefer_writev)
 154                 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
 155         else {
 156                 struct msghdr mh;
 157                 zero(mh);
 158
 159                 mh.msg_iov = b->auth_iovec + b->auth_index;
 160                 mh.msg_iovlen = ELEMENTSOF(b->auth_iovec) - b->auth_index;
 161
 162                 k = sendmsg(b->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
 163                 if (k < 0 && errno == ENOTSOCK) {
 164                         b->prefer_writev = true;
 165                         k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
 166                 }
 167         }
 168
 169         if (k < 0)
 170                 return errno == EAGAIN ? 0 : -errno;
 171
 172         iovec_advance(b->auth_iovec, &b->auth_index, (size_t) k);
 173         return 1;
 174 }
 175
 176 static int bus_socket_auth_verify_client(sd_bus *b) {
 177         char *e, *f, *start;
 178         sd_id128_t peer;
 179         unsigned i;
 180         int r;
 181
 182         assert(b);
 183
 184         /* We expect two response lines: "OK" and possibly
 185          * "AGREE_UNIX_FD" */
 186
 187         e = memmem_safe(b->rbuffer, b->rbuffer_size, "\r\n", 2);
 188         if (!e)
 189                 return 0;
 190
 191         if (b->hello_flags & KDBUS_HELLO_ACCEPT_FD) {
 192                 f = memmem(e + 2, b->rbuffer_size - (e - (char*) b->rbuffer) - 2, "\r\n", 2);
 193                 if (!f)
 194                         return 0;
 195
 196                 start = f + 2;
 197         } else {
 198                 f = NULL;
 199                 start = e + 2;
 200         }
 201
 202         /* Nice! We got all the lines we need. First check the OK
 203          * line */
 204
 205         if (e - (char*) b->rbuffer != 3 + 32)
 206                 return -EPERM;
 207
 208         if (memcmp(b->rbuffer, "OK ", 3))
 209                 return -EPERM;
 210
 211         b->auth = b->anonymous_auth ? BUS_AUTH_ANONYMOUS : BUS_AUTH_EXTERNAL;
 212
 213         for (i = 0; i < 32; i += 2) {
 214                 int x, y;
 215
 216                 x = unhexchar(((char*) b->rbuffer)[3 + i]);
 217                 y = unhexchar(((char*) b->rbuffer)[3 + i + 1]);
 218
 219                 if (x < 0 || y < 0)
 220                         return -EINVAL;
 221
 222                 peer.bytes[i/2] = ((uint8_t) x << 4 | (uint8_t) y);
 223         }
 224
 225         if (!sd_id128_equal(b->server_id, SD_ID128_NULL) &&
 226             !sd_id128_equal(b->server_id, peer))
 227                 return -EPERM;
 228
 229         b->server_id = peer;
 230
 231         /* And possibly check the second line, too */
 232
 233         if (f)
 234                 b->can_fds =
 235                         (f - e == strlen("\r\nAGREE_UNIX_FD")) &&
 236                         memcmp(e + 2, "AGREE_UNIX_FD", strlen("AGREE_UNIX_FD")) == 0;
 237
 238         b->rbuffer_size -= (start - (char*) b->rbuffer);
 239         memmove(b->rbuffer, start, b->rbuffer_size);
 240
 241         r = bus_start_running(b);
 242         if (r < 0)
 243                 return r;
 244
 245         return 1;
 246 }
 247
 248 static bool line_equals(const char *s, size_t m, const char *line) {
 249         size_t l;
 250
 251         l = strlen(line);
 252         if (l != m)
 253                 return false;
 254
 255         return memcmp(s, line, l) == 0;
 256 }
 257
 258 static bool line_begins(const char *s, size_t m, const char *word) {
 259         size_t l;
 260
 261         l = strlen(word);
 262         if (m < l)
 263                 return false;
 264
 265         if (memcmp(s, word, l) != 0)
 266                 return false;
 267
 268         return m == l || (m > l && s[l] == ' ');
 269 }
 270
 271 static int verify_anonymous_token(sd_bus *b, const char *p, size_t l) {
 272         _cleanup_free_ char *token = NULL;
 273         size_t len;
 274         int r;
 275
 276         if (!b->anonymous_auth)
 277                 return 0;
 278
 279         if (l <= 0)
 280                 return 1;
 281
 282         assert(p[0] == ' ');
 283         p++; l--;
 284
 285         if (l % 2 != 0)
 286                 return 0;
 287
 288         r = unhexmem(p, l, (void **) &token, &len);
 289         if (r < 0)
 290                 return 0;
 291
 292         if (memchr(token, 0, len))
 293                 return 0;
 294
 295         return !!utf8_is_valid(token);
 296 }
 297
 298 static int verify_external_token(sd_bus *b, const char *p, size_t l) {
 299         _cleanup_free_ char *token = NULL;
 300         size_t len;
 301         uid_t u;
 302         int r;
 303
 304         /* We don't do any real authentication here. Instead, we if
 305          * the owner of this bus wanted authentication he should have
 306          * checked SO_PEERCRED before even creating the bus object. */
 307
 308         if (!b->anonymous_auth && !b->ucred_valid)
 309                 return 0;
 310
 311         if (l <= 0)
 312                 return 1;
 313
 314         assert(p[0] == ' ');
 315         p++; l--;
 316
 317         if (l % 2 != 0)
 318                 return 0;
 319
 320         r = unhexmem(p, l, (void**) &token, &len);
 321         if (r < 0)
 322                 return 0;
 323
 324         if (memchr(token, 0, len))
 325                 return 0;
 326
 327         r = parse_uid(token, &u);
 328         if (r < 0)
 329                 return 0;
 330
 331         /* We ignore the passed value if anonymous authentication is
 332          * on anyway. */
 333         if (!b->anonymous_auth && u != b->ucred.uid)
 334                 return 0;
 335
 336         return 1;
 337 }
 338
 339 static int bus_socket_auth_write(sd_bus *b, const char *t) {
 340         char *p;
 341         size_t l;
 342
 343         assert(b);
 344         assert(t);
 345
 346         /* We only make use of the first iovec */
 347         assert(b->auth_index == 0 || b->auth_index == 1);
 348
 349         l = strlen(t);
 350         p = malloc(b->auth_iovec[0].iov_len + l);
 351         if (!p)
 352                 return -ENOMEM;
 353
 354         memcpy(p, b->auth_iovec[0].iov_base, b->auth_iovec[0].iov_len);
 355         memcpy(p + b->auth_iovec[0].iov_len, t, l);
 356
 357         b->auth_iovec[0].iov_base = p;
 358         b->auth_iovec[0].iov_len += l;
 359
 360         free(b->auth_buffer);
 361         b->auth_buffer = p;
 362         b->auth_index = 0;
 363         return 0;
 364 }
 365
 366 static int bus_socket_auth_write_ok(sd_bus *b) {
 367         char t[3 + 32 + 2 + 1];
 368
 369         assert(b);
 370
 371         xsprintf(t, "OK " SD_ID128_FORMAT_STR "\r\n", SD_ID128_FORMAT_VAL(b->server_id));
 372
 373         return bus_socket_auth_write(b, t);
 374 }
 375
 376 static int bus_socket_auth_verify_server(sd_bus *b) {
 377         char *e;
 378         const char *line;
 379         size_t l;
 380         bool processed = false;
 381         int r;
 382
 383         assert(b);
 384
 385         if (b->rbuffer_size < 1)
 386                 return 0;
 387
 388         /* First char must be a NUL byte */
 389         if (*(char*) b->rbuffer != 0)
 390                 return -EIO;
 391
 392         if (b->rbuffer_size < 3)
 393                 return 0;
 394
 395         /* Begin with the first line */
 396         if (b->auth_rbegin <= 0)
 397                 b->auth_rbegin = 1;
 398
 399         for (;;) {
 400                 /* Check if line is complete */
 401                 line = (char*) b->rbuffer + b->auth_rbegin;
 402                 e = memmem(line, b->rbuffer_size - b->auth_rbegin, "\r\n", 2);
 403                 if (!e)
 404                         return processed;
 405
 406                 l = e - line;
 407
 408                 if (line_begins(line, l, "AUTH ANONYMOUS")) {
 409
 410                         r = verify_anonymous_token(b, line + 14, l - 14);
 411                         if (r < 0)
 412                                 return r;
 413                         if (r == 0)
 414                                 r = bus_socket_auth_write(b, "REJECTED\r\n");
 415                         else {
 416                                 b->auth = BUS_AUTH_ANONYMOUS;
 417                                 r = bus_socket_auth_write_ok(b);
 418                         }
 419
 420                 } else if (line_begins(line, l, "AUTH EXTERNAL")) {
 421
 422                         r = verify_external_token(b, line + 13, l - 13);
 423                         if (r < 0)
 424                                 return r;
 425                         if (r == 0)
 426                                 r = bus_socket_auth_write(b, "REJECTED\r\n");
 427                         else {
 428                                 b->auth = BUS_AUTH_EXTERNAL;
 429                                 r = bus_socket_auth_write_ok(b);
 430                         }
 431
 432                 } else if (line_begins(line, l, "AUTH"))
 433                         r = bus_socket_auth_write(b, "REJECTED EXTERNAL ANONYMOUS\r\n");
 434                 else if (line_equals(line, l, "CANCEL") ||
 435                          line_begins(line, l, "ERROR")) {
 436
 437                         b->auth = _BUS_AUTH_INVALID;
 438                         r = bus_socket_auth_write(b, "REJECTED\r\n");
 439
 440                 } else if (line_equals(line, l, "BEGIN")) {
 441
 442                         if (b->auth == _BUS_AUTH_INVALID)
 443                                 r = bus_socket_auth_write(b, "ERROR\r\n");
 444                         else {
 445                                 /* We can't leave from the auth phase
 446                                  * before we haven't written
 447                                  * everything queued, so let's check
 448                                  * that */
 449
 450                                 if (bus_socket_auth_needs_write(b))
 451                                         return 1;
 452
 453                                 b->rbuffer_size -= (e + 2 - (char*) b->rbuffer);
 454                                 memmove(b->rbuffer, e + 2, b->rbuffer_size);
 455                                 return bus_start_running(b);
 456                         }
 457
 458                 } else if (line_begins(line, l, "DATA")) {
 459
 460                         if (b->auth == _BUS_AUTH_INVALID)
 461                                 r = bus_socket_auth_write(b, "ERROR\r\n");
 462                         else {
 463                                 if (b->auth == BUS_AUTH_ANONYMOUS)
 464                                         r = verify_anonymous_token(b, line + 4, l - 4);
 465                                 else
 466                                         r = verify_external_token(b, line + 4, l - 4);
 467
 468                                 if (r < 0)
 469                                         return r;
 470                                 if (r == 0) {
 471                                         b->auth = _BUS_AUTH_INVALID;
 472                                         r = bus_socket_auth_write(b, "REJECTED\r\n");
 473                                 } else
 474                                         r = bus_socket_auth_write_ok(b);
 475                         }
 476                 } else if (line_equals(line, l, "NEGOTIATE_UNIX_FD")) {
 477                         if (b->auth == _BUS_AUTH_INVALID || !(b->hello_flags & KDBUS_HELLO_ACCEPT_FD))
 478                                 r = bus_socket_auth_write(b, "ERROR\r\n");
 479                         else {
 480                                 b->can_fds = true;
 481                                 r = bus_socket_auth_write(b, "AGREE_UNIX_FD\r\n");
 482                         }
 483                 } else
 484                         r = bus_socket_auth_write(b, "ERROR\r\n");
 485
 486                 if (r < 0)
 487                         return r;
 488
 489                 b->auth_rbegin = e + 2 - (char*) b->rbuffer;
 490
 491                 processed = true;
 492         }
 493 }
 494
 495 static int bus_socket_auth_verify(sd_bus *b) {
 496         assert(b);
 497
 498         if (b->is_server)
 499                 return bus_socket_auth_verify_server(b);
 500         else
 501                 return bus_socket_auth_verify_client(b);
 502 }
 503
 504 static int bus_socket_read_auth(sd_bus *b) {
 505         struct msghdr mh;
 506         struct iovec iov = {};
 507         size_t n;
 508         ssize_t k;
 509         int r;
 510         void *p;
 511         union {
 512                 struct cmsghdr cmsghdr;
 513                 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX)];
 514         } control;
 515         bool handle_cmsg = false;
 516
 517         assert(b);
 518         assert(b->state == BUS_AUTHENTICATING);
 519
 520         r = bus_socket_auth_verify(b);
 521         if (r != 0)
 522                 return r;
 523
 524         n = MAX(256u, b->rbuffer_size * 2);
 525
 526         if (n > BUS_AUTH_SIZE_MAX)
 527                 n = BUS_AUTH_SIZE_MAX;
 528
 529         if (b->rbuffer_size >= n)
 530                 return -ENOBUFS;
 531
 532         p = realloc(b->rbuffer, n);
 533         if (!p)
 534                 return -ENOMEM;
 535
 536         b->rbuffer = p;
 537
 538         iov.iov_base = (uint8_t*) b->rbuffer + b->rbuffer_size;
 539         iov.iov_len = n - b->rbuffer_size;
 540
 541         if (b->prefer_readv)
 542                 k = readv(b->input_fd, &iov, 1);
 543         else {
 544                 zero(mh);
 545                 mh.msg_iov = &iov;
 546                 mh.msg_iovlen = 1;
 547                 mh.msg_control = &control;
 548                 mh.msg_controllen = sizeof(control);
 549
 550                 k = recvmsg(b->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
 551                 if (k < 0 && errno == ENOTSOCK) {
 552                         b->prefer_readv = true;
 553                         k = readv(b->input_fd, &iov, 1);
 554                 } else
 555                         handle_cmsg = true;
 556         }
 557         if (k < 0)
 558                 return errno == EAGAIN ? 0 : -errno;
 559         if (k == 0)
 560                 return -ECONNRESET;
 561
 562         b->rbuffer_size += k;
 563
 564         if (handle_cmsg) {
 565                 struct cmsghdr *cmsg;
 566
 567                 CMSG_FOREACH(cmsg, &mh)
 568                         if (cmsg->cmsg_level == SOL_SOCKET &&
 569                             cmsg->cmsg_type == SCM_RIGHTS) {
 570                                 int j;
 571
 572                                 /* Whut? We received fds during the auth
 573                                  * protocol? Somebody is playing games with
 574                                  * us. Close them all, and fail */
 575                                 j = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
 576                                 close_many((int*) CMSG_DATA(cmsg), j);
 577                                 return -EIO;
 578                         } else
 579                                 log_debug("Got unexpected auxiliary data with level=%d and type=%d",
 580                                           cmsg->cmsg_level, cmsg->cmsg_type);
 581         }
 582
 583         r = bus_socket_auth_verify(b);
 584         if (r != 0)
 585                 return r;
 586
 587         return 1;
 588 }
 589
 590 void bus_socket_setup(sd_bus *b) {
 591         assert(b);
 592
 593         /* Increase the buffers to 8 MB */
 594         fd_inc_rcvbuf(b->input_fd, SNDBUF_SIZE);
 595         fd_inc_sndbuf(b->output_fd, SNDBUF_SIZE);
 596
 597         b->is_kernel = false;
 598         b->message_version = 1;
 599         b->message_endian = 0;
 600 }
 601
 602 static void bus_get_peercred(sd_bus *b) {
 603         int r;
 604
 605         assert(b);
 606
 607         /* Get the peer for socketpair() sockets */
 608         b->ucred_valid = getpeercred(b->input_fd, &b->ucred) >= 0;
 609
 610         /* Get the SELinux context of the peer */
 611         r = getpeersec(b->input_fd, &b->label);
 612         if (r < 0 && r != -EOPNOTSUPP)
 613                 log_debug_errno(r, "Failed to determine peer security context: %m");
 614 }
 615
 616 static int bus_socket_start_auth_client(sd_bus *b) {
 617         size_t l;
 618         const char *auth_suffix, *auth_prefix;
 619
 620         assert(b);
 621
 622         if (b->anonymous_auth) {
 623                 auth_prefix = "\0AUTH ANONYMOUS ";
 624
 625                 /* For ANONYMOUS auth we send some arbitrary "trace" string */
 626                 l = 9;
 627                 b->auth_buffer = hexmem("anonymous", l);
 628         } else {
 629                 char text[DECIMAL_STR_MAX(uid_t) + 1];
 630
 631                 auth_prefix = "\0AUTH EXTERNAL ";
 632
 633                 xsprintf(text, UID_FMT, geteuid());
 634
 635                 l = strlen(text);
 636                 b->auth_buffer = hexmem(text, l);
 637         }
 638
 639         if (!b->auth_buffer)
 640                 return -ENOMEM;
 641
 642         if (b->hello_flags & KDBUS_HELLO_ACCEPT_FD)
 643                 auth_suffix = "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
 644         else
 645                 auth_suffix = "\r\nBEGIN\r\n";
 646
 647         b->auth_iovec[0].iov_base = (void*) auth_prefix;
 648         b->auth_iovec[0].iov_len = 1 + strlen(auth_prefix + 1);
 649         b->auth_iovec[1].iov_base = (void*) b->auth_buffer;
 650         b->auth_iovec[1].iov_len = l * 2;
 651         b->auth_iovec[2].iov_base = (void*) auth_suffix;
 652         b->auth_iovec[2].iov_len = strlen(auth_suffix);
 653
 654         return bus_socket_write_auth(b);
 655 }
 656
 657 int bus_socket_start_auth(sd_bus *b) {
 658         assert(b);
 659
 660         bus_get_peercred(b);
 661
 662         b->state = BUS_AUTHENTICATING;
 663         b->auth_timeout = now(CLOCK_MONOTONIC) + BUS_DEFAULT_TIMEOUT;
 664
 665         if (sd_is_socket(b->input_fd, AF_UNIX, 0, 0) <= 0)
 666                 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
 667
 668         if (b->output_fd != b->input_fd)
 669                 if (sd_is_socket(b->output_fd, AF_UNIX, 0, 0) <= 0)
 670                         b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
 671
 672         if (b->is_server)
 673                 return bus_socket_read_auth(b);
 674         else
 675                 return bus_socket_start_auth_client(b);
 676 }
 677
 678 int bus_socket_connect(sd_bus *b) {
 679         int r;
 680
 681         assert(b);
 682         assert(b->input_fd < 0);
 683         assert(b->output_fd < 0);
 684         assert(b->sockaddr.sa.sa_family != AF_UNSPEC);
 685
 686         b->input_fd = socket(b->sockaddr.sa.sa_family, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 687         if (b->input_fd < 0)
 688                 return -errno;
 689
 690         b->output_fd = b->input_fd;
 691
 692         bus_socket_setup(b);
 693
 694         r = connect(b->input_fd, &b->sockaddr.sa, b->sockaddr_size);
 695         if (r < 0) {
 696                 if (errno == EINPROGRESS)
 697                         return 1;
 698
 699                 return -errno;
 700         }
 701
 702         return bus_socket_start_auth(b);
 703 }
 704
 705 int bus_socket_exec(sd_bus *b) {
 706         int s[2], r;
 707         pid_t pid;
 708
 709         assert(b);
 710         assert(b->input_fd < 0);
 711         assert(b->output_fd < 0);
 712         assert(b->exec_path);
 713
 714         r = socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, s);
 715         if (r < 0)
 716                 return -errno;
 717
 718         pid = fork();
 719         if (pid < 0) {
 720                 safe_close_pair(s);
 721                 return -errno;
 722         }
 723         if (pid == 0) {
 724                 /* Child */
 725
 726                 (void) reset_all_signal_handlers();
 727                 (void) reset_signal_mask();
 728
 729                 close_all_fds(s+1, 1);
 730
 731                 assert_se(dup3(s[1], STDIN_FILENO, 0) == STDIN_FILENO);
 732                 assert_se(dup3(s[1], STDOUT_FILENO, 0) == STDOUT_FILENO);
 733
 734                 if (s[1] != STDIN_FILENO && s[1] != STDOUT_FILENO)
 735                         safe_close(s[1]);
 736
 737                 fd_cloexec(STDIN_FILENO, false);
 738                 fd_cloexec(STDOUT_FILENO, false);
 739                 fd_nonblock(STDIN_FILENO, false);
 740                 fd_nonblock(STDOUT_FILENO, false);
 741
 742                 if (b->exec_argv)
 743                         execvp(b->exec_path, b->exec_argv);
 744                 else {
 745                         const char *argv[] = { b->exec_path, NULL };
 746                         execvp(b->exec_path, (char**) argv);
 747                 }
 748
 749                 _exit(EXIT_FAILURE);
 750         }
 751
 752         safe_close(s[1]);
 753         b->output_fd = b->input_fd = s[0];
 754
 755         bus_socket_setup(b);
 756
 757         return bus_socket_start_auth(b);
 758 }
 759
 760 int bus_socket_take_fd(sd_bus *b) {
 761         assert(b);
 762
 763         bus_socket_setup(b);
 764
 765         return bus_socket_start_auth(b);
 766 }
 767
 768 int bus_socket_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
 769         struct iovec *iov;
 770         ssize_t k;
 771         size_t n;
 772         unsigned j;
 773         int r;
 774
 775         assert(bus);
 776         assert(m);
 777         assert(idx);
 778         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
 779
 780         if (*idx >= BUS_MESSAGE_SIZE(m))
 781                 return 0;
 782
 783         r = bus_message_setup_iovec(m);
 784         if (r < 0)
 785                 return r;
 786
 787         n = m->n_iovec * sizeof(struct iovec);
 788         iov = alloca(n);
 789         memcpy(iov, m->iovec, n);
 790
 791         j = 0;
 792         iovec_advance(iov, &j, *idx);
 793
 794         if (bus->prefer_writev)
 795                 k = writev(bus->output_fd, iov, m->n_iovec);
 796         else {
 797                 struct msghdr mh = {
 798                         .msg_iov = iov,
 799                         .msg_iovlen = m->n_iovec,
 800                 };
 801
 802                 if (m->n_fds > 0) {
 803                         struct cmsghdr *control;
 804
 805                         mh.msg_control = control = alloca(CMSG_SPACE(sizeof(int) * m->n_fds));
 806                         mh.msg_controllen = control->cmsg_len = CMSG_LEN(sizeof(int) * m->n_fds);
 807                         control->cmsg_level = SOL_SOCKET;
 808                         control->cmsg_type = SCM_RIGHTS;
 809                         memcpy(CMSG_DATA(control), m->fds, sizeof(int) * m->n_fds);
 810                 }
 811
 812                 k = sendmsg(bus->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
 813                 if (k < 0 && errno == ENOTSOCK) {
 814                         bus->prefer_writev = true;
 815                         k = writev(bus->output_fd, iov, m->n_iovec);
 816                 }
 817         }
 818
 819         if (k < 0)
 820                 return errno == EAGAIN ? 0 : -errno;
 821
 822         *idx += (size_t) k;
 823         return 1;
 824 }
 825
 826 static int bus_socket_read_message_need(sd_bus *bus, size_t *need) {
 827         uint32_t a, b;
 828         uint8_t e;
 829         uint64_t sum;
 830
 831         assert(bus);
 832         assert(need);
 833         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
 834
 835         if (bus->rbuffer_size < sizeof(struct bus_header)) {
 836                 *need = sizeof(struct bus_header) + 8;
 837
 838                 /* Minimum message size:
 839                  *
 840                  * Header +
 841                  *
 842                  *  Method Call: +2 string headers
 843                  *       Signal: +3 string headers
 844                  * Method Error: +1 string headers
 845                  *               +1 uint32 headers
 846                  * Method Reply: +1 uint32 headers
 847                  *
 848                  * A string header is at least 9 bytes
 849                  * A uint32 header is at least 8 bytes
 850                  *
 851                  * Hence the minimum message size of a valid message
 852                  * is header + 8 bytes */
 853
 854                 return 0;
 855         }
 856
 857         a = ((const uint32_t*) bus->rbuffer)[1];
 858         b = ((const uint32_t*) bus->rbuffer)[3];
 859
 860         e = ((const uint8_t*) bus->rbuffer)[0];
 861         if (e == BUS_LITTLE_ENDIAN) {
 862                 a = le32toh(a);
 863                 b = le32toh(b);
 864         } else if (e == BUS_BIG_ENDIAN) {
 865                 a = be32toh(a);
 866                 b = be32toh(b);
 867         } else
 868                 return -EBADMSG;
 869
 870         sum = (uint64_t) sizeof(struct bus_header) + (uint64_t) ALIGN_TO(b, 8) + (uint64_t) a;
 871         if (sum >= BUS_MESSAGE_SIZE_MAX)
 872                 return -ENOBUFS;
 873
 874         *need = (size_t) sum;
 875         return 0;
 876 }
 877
 878 static int bus_socket_make_message(sd_bus *bus, size_t size) {
 879         sd_bus_message *t;
 880         void *b;
 881         int r;
 882
 883         assert(bus);
 884         assert(bus->rbuffer_size >= size);
 885         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
 886
 887         r = bus_rqueue_make_room(bus);
 888         if (r < 0)
 889                 return r;
 890
 891         if (bus->rbuffer_size > size) {
 892                 b = memdup((const uint8_t*) bus->rbuffer + size,
 893                            bus->rbuffer_size - size);
 894                 if (!b)
 895                         return -ENOMEM;
 896         } else
 897                 b = NULL;
 898
 899         r = bus_message_from_malloc(bus,
 900                                     bus->rbuffer, size,
 901                                     bus->fds, bus->n_fds,
 902                                     NULL,
 903                                     &t);
 904         if (r < 0) {
 905                 free(b);
 906                 return r;
 907         }
 908
 909         bus->rbuffer = b;
 910         bus->rbuffer_size -= size;
 911
 912         bus->fds = NULL;
 913         bus->n_fds = 0;
 914
 915         bus->rqueue[bus->rqueue_size++] = t;
 916
 917         return 1;
 918 }
 919
 920 int bus_socket_read_message(sd_bus *bus) {
 921         struct msghdr mh;
 922         struct iovec iov = {};
 923         ssize_t k;
 924         size_t need;
 925         int r;
 926         void *b;
 927         union {
 928                 struct cmsghdr cmsghdr;
 929                 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX)];
 930         } control;
 931         bool handle_cmsg = false;
 932
 933         assert(bus);
 934         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
 935
 936         r = bus_socket_read_message_need(bus, &need);
 937         if (r < 0)
 938                 return r;
 939
 940         if (bus->rbuffer_size >= need)
 941                 return bus_socket_make_message(bus, need);
 942
 943         b = realloc(bus->rbuffer, need);
 944         if (!b)
 945                 return -ENOMEM;
 946
 947         bus->rbuffer = b;
 948
 949         iov.iov_base = (uint8_t*) bus->rbuffer + bus->rbuffer_size;
 950         iov.iov_len = need - bus->rbuffer_size;
 951
 952         if (bus->prefer_readv)
 953                 k = readv(bus->input_fd, &iov, 1);
 954         else {
 955                 zero(mh);
 956                 mh.msg_iov = &iov;
 957                 mh.msg_iovlen = 1;
 958                 mh.msg_control = &control;
 959                 mh.msg_controllen = sizeof(control);
 960
 961                 k = recvmsg(bus->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
 962                 if (k < 0 && errno == ENOTSOCK) {
 963                         bus->prefer_readv = true;
 964                         k = readv(bus->input_fd, &iov, 1);
 965                 } else
 966                         handle_cmsg = true;
 967         }
 968         if (k < 0)
 969                 return errno == EAGAIN ? 0 : -errno;
 970         if (k == 0)
 971                 return -ECONNRESET;
 972
 973         bus->rbuffer_size += k;
 974
 975         if (handle_cmsg) {
 976                 struct cmsghdr *cmsg;
 977
 978                 CMSG_FOREACH(cmsg, &mh)
 979                         if (cmsg->cmsg_level == SOL_SOCKET &&
 980                             cmsg->cmsg_type == SCM_RIGHTS) {
 981                                 int n, *f;
 982
 983                                 n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
 984
 985                                 if (!bus->can_fds) {
 986                                         /* Whut? We received fds but this
 987                                          * isn't actually enabled? Close them,
 988                                          * and fail */
 989
 990                                         close_many((int*) CMSG_DATA(cmsg), n);
 991                                         return -EIO;
 992                                 }
 993
 994                                 f = realloc(bus->fds, sizeof(int) * (bus->n_fds + n));
 995                                 if (!f) {
 996                                         close_many((int*) CMSG_DATA(cmsg), n);
 997                                         return -ENOMEM;
 998                                 }
 999
1000                                 memcpy(f + bus->n_fds, CMSG_DATA(cmsg), n * sizeof(int));
1001                                 bus->fds = f;
1002                                 bus->n_fds += n;
1003                         } else
1004                                 log_debug("Got unexpected auxiliary data with level=%d and type=%d",
1005                                           cmsg->cmsg_level, cmsg->cmsg_type);
1006         }
1007
1008         r = bus_socket_read_message_need(bus, &need);
1009         if (r < 0)
1010                 return r;
1011
1012         if (bus->rbuffer_size >= need)
1013                 return bus_socket_make_message(bus, need);
1014
1015         return 1;
1016 }
1017
1018 int bus_socket_process_opening(sd_bus *b) {
1019         int error = 0;
1020         socklen_t slen = sizeof(error);
1021         struct pollfd p = {
1022                 .fd = b->output_fd,
1023                 .events = POLLOUT,
1024         };
1025         int r;
1026
1027         assert(b->state == BUS_OPENING);
1028
1029         r = poll(&p, 1, 0);
1030         if (r < 0)
1031                 return -errno;
1032
1033         if (!(p.revents & (POLLOUT|POLLERR|POLLHUP)))
1034                 return 0;
1035
1036         r = getsockopt(b->output_fd, SOL_SOCKET, SO_ERROR, &error, &slen);
1037         if (r < 0)
1038                 b->last_connect_error = errno;
1039         else if (error != 0)
1040                 b->last_connect_error = error;
1041         else if (p.revents & (POLLERR|POLLHUP))
1042                 b->last_connect_error = ECONNREFUSED;
1043         else
1044                 return bus_socket_start_auth(b);
1045
1046         return bus_next_address(b);
1047 }
1048
1049 int bus_socket_process_authenticating(sd_bus *b) {
1050         int r;
1051
1052         assert(b);
1053         assert(b->state == BUS_AUTHENTICATING);
1054
1055         if (now(CLOCK_MONOTONIC) >= b->auth_timeout)
1056                 return -ETIMEDOUT;
1057
1058         r = bus_socket_write_auth(b);
1059         if (r != 0)
1060                 return r;
1061
1062         return bus_socket_read_auth(b);
1063 }