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