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                             CMSG_SPACE(sizeof(struct ucred)) +
 505                             CMSG_SPACE(NAME_MAX)]; /*selinux label */
 506         } control;
 507         struct cmsghdr *cmsg;
 508         bool handle_cmsg = false;
 509
 510         assert(b);
 511         assert(b->state == BUS_AUTHENTICATING);
 512
 513         r = bus_socket_auth_verify(b);
 514         if (r != 0)
 515                 return r;
 516
 517         n = MAX(256u, b->rbuffer_size * 2);
 518
 519         if (n > BUS_AUTH_SIZE_MAX)
 520                 n = BUS_AUTH_SIZE_MAX;
 521
 522         if (b->rbuffer_size >= n)
 523                 return -ENOBUFS;
 524
 525         p = realloc(b->rbuffer, n);
 526         if (!p)
 527                 return -ENOMEM;
 528
 529         b->rbuffer = p;
 530
 531         iov.iov_base = (uint8_t*) b->rbuffer + b->rbuffer_size;
 532         iov.iov_len = n - b->rbuffer_size;
 533
 534         if (b->prefer_readv)
 535                 k = readv(b->input_fd, &iov, 1);
 536         else {
 537                 zero(mh);
 538                 mh.msg_iov = &iov;
 539                 mh.msg_iovlen = 1;
 540                 mh.msg_control = &control;
 541                 mh.msg_controllen = sizeof(control);
 542
 543                 k = recvmsg(b->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
 544                 if (k < 0 && errno == ENOTSOCK) {
 545                         b->prefer_readv = true;
 546                         k = readv(b->input_fd, &iov, 1);
 547                 } else
 548                         handle_cmsg = true;
 549         }
 550         if (k < 0)
 551                 return errno == EAGAIN ? 0 : -errno;
 552         if (k == 0)
 553                 return -ECONNRESET;
 554
 555         b->rbuffer_size += k;
 556
 557         if (handle_cmsg) {
 558                 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
 559                         if (cmsg->cmsg_level == SOL_SOCKET &&
 560                             cmsg->cmsg_type == SCM_RIGHTS) {
 561                                 int j;
 562
 563                                 /* Whut? We received fds during the auth
 564                                  * protocol? Somebody is playing games with
 565                                  * us. Close them all, and fail */
 566                                 j = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
 567                                 close_many((int*) CMSG_DATA(cmsg), j);
 568                                 return -EIO;
 569
 570                         } else if (cmsg->cmsg_level == SOL_SOCKET &&
 571                                    cmsg->cmsg_type == SCM_CREDENTIALS &&
 572                                    cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
 573
 574                                 /* Ignore bogus data, which we might
 575                                  * get on socketpair() sockets */
 576                                 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
 577                                         memcpy(&b->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
 578                                         b->ucred_valid = true;
 579                                 }
 580
 581                         } else if (cmsg->cmsg_level == SOL_SOCKET &&
 582                                    cmsg->cmsg_type == SCM_SECURITY) {
 583
 584                                 size_t l;
 585
 586                                 l = cmsg->cmsg_len - CMSG_LEN(0);
 587                                 if (l > 0) {
 588                                         memcpy(&b->label, CMSG_DATA(cmsg), l);
 589                                         b->label[l] = 0;
 590                                 }
 591                         }
 592                 }
 593         }
 594
 595         r = bus_socket_auth_verify(b);
 596         if (r != 0)
 597                 return r;
 598
 599         return 1;
 600 }
 601
 602 void bus_socket_setup(sd_bus *b) {
 603         int enable;
 604
 605         assert(b);
 606
 607         /* Enable SO_PASSCRED + SO_PASSEC. We try this on any
 608          * socket, just in case. */
 609         enable = !b->bus_client;
 610         (void) setsockopt(b->input_fd, SOL_SOCKET, SO_PASSCRED, &enable, sizeof(enable));
 611
 612         enable = !b->bus_client && (b->attach_flags & KDBUS_ATTACH_SECLABEL);
 613         (void) setsockopt(b->input_fd, SOL_SOCKET, SO_PASSSEC, &enable, sizeof(enable));
 614
 615         /* Increase the buffers to 8 MB */
 616         fd_inc_rcvbuf(b->input_fd, SNDBUF_SIZE);
 617         fd_inc_sndbuf(b->output_fd, SNDBUF_SIZE);
 618
 619         b->is_kernel = false;
 620         b->message_version = 1;
 621         b->message_endian = 0;
 622 }
 623
 624 static void bus_get_peercred(sd_bus *b) {
 625         assert(b);
 626
 627         /* Get the peer for socketpair() sockets */
 628         b->ucred_valid = getpeercred(b->input_fd, &b->ucred) >= 0;
 629 }
 630
 631 static int bus_socket_start_auth_client(sd_bus *b) {
 632         size_t l;
 633         const char *auth_suffix, *auth_prefix;
 634
 635         assert(b);
 636
 637         if (b->anonymous_auth) {
 638                 auth_prefix = "\0AUTH ANONYMOUS ";
 639
 640                 /* For ANONYMOUS auth we send some arbitrary "trace" string */
 641                 l = 9;
 642                 b->auth_buffer = hexmem("anonymous", l);
 643         } else {
 644                 char text[DECIMAL_STR_MAX(uid_t) + 1];
 645
 646                 auth_prefix = "\0AUTH EXTERNAL ";
 647
 648                 xsprintf(text, UID_FMT, geteuid());
 649
 650                 l = strlen(text);
 651                 b->auth_buffer = hexmem(text, l);
 652         }
 653
 654         if (!b->auth_buffer)
 655                 return -ENOMEM;
 656
 657         if (b->hello_flags & KDBUS_HELLO_ACCEPT_FD)
 658                 auth_suffix = "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
 659         else
 660                 auth_suffix = "\r\nBEGIN\r\n";
 661
 662         b->auth_iovec[0].iov_base = (void*) auth_prefix;
 663         b->auth_iovec[0].iov_len = 1 + strlen(auth_prefix + 1);
 664         b->auth_iovec[1].iov_base = (void*) b->auth_buffer;
 665         b->auth_iovec[1].iov_len = l * 2;
 666         b->auth_iovec[2].iov_base = (void*) auth_suffix;
 667         b->auth_iovec[2].iov_len = strlen(auth_suffix);
 668
 669         return bus_socket_write_auth(b);
 670 }
 671
 672 int bus_socket_start_auth(sd_bus *b) {
 673         assert(b);
 674
 675         bus_get_peercred(b);
 676
 677         b->state = BUS_AUTHENTICATING;
 678         b->auth_timeout = now(CLOCK_MONOTONIC) + BUS_DEFAULT_TIMEOUT;
 679
 680         if (sd_is_socket(b->input_fd, AF_UNIX, 0, 0) <= 0)
 681                 b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
 682
 683         if (b->output_fd != b->input_fd)
 684                 if (sd_is_socket(b->output_fd, AF_UNIX, 0, 0) <= 0)
 685                         b->hello_flags &= ~KDBUS_HELLO_ACCEPT_FD;
 686
 687         if (b->is_server)
 688                 return bus_socket_read_auth(b);
 689         else
 690                 return bus_socket_start_auth_client(b);
 691 }
 692
 693 int bus_socket_connect(sd_bus *b) {
 694         int r;
 695
 696         assert(b);
 697         assert(b->input_fd < 0);
 698         assert(b->output_fd < 0);
 699         assert(b->sockaddr.sa.sa_family != AF_UNSPEC);
 700
 701         b->input_fd = socket(b->sockaddr.sa.sa_family, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 702         if (b->input_fd < 0)
 703                 return -errno;
 704
 705         b->output_fd = b->input_fd;
 706
 707         bus_socket_setup(b);
 708
 709         r = connect(b->input_fd, &b->sockaddr.sa, b->sockaddr_size);
 710         if (r < 0) {
 711                 if (errno == EINPROGRESS)
 712                         return 1;
 713
 714                 return -errno;
 715         }
 716
 717         return bus_socket_start_auth(b);
 718 }
 719
 720 int bus_socket_exec(sd_bus *b) {
 721         int s[2], r;
 722         pid_t pid;
 723
 724         assert(b);
 725         assert(b->input_fd < 0);
 726         assert(b->output_fd < 0);
 727         assert(b->exec_path);
 728
 729         r = socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, s);
 730         if (r < 0)
 731                 return -errno;
 732
 733         pid = fork();
 734         if (pid < 0) {
 735                 safe_close_pair(s);
 736                 return -errno;
 737         }
 738         if (pid == 0) {
 739                 /* Child */
 740
 741                 (void) reset_all_signal_handlers();
 742                 (void) reset_signal_mask();
 743
 744                 close_all_fds(s+1, 1);
 745
 746                 assert_se(dup3(s[1], STDIN_FILENO, 0) == STDIN_FILENO);
 747                 assert_se(dup3(s[1], STDOUT_FILENO, 0) == STDOUT_FILENO);
 748
 749                 if (s[1] != STDIN_FILENO && s[1] != STDOUT_FILENO)
 750                         safe_close(s[1]);
 751
 752                 fd_cloexec(STDIN_FILENO, false);
 753                 fd_cloexec(STDOUT_FILENO, false);
 754                 fd_nonblock(STDIN_FILENO, false);
 755                 fd_nonblock(STDOUT_FILENO, false);
 756
 757                 if (b->exec_argv)
 758                         execvp(b->exec_path, b->exec_argv);
 759                 else {
 760                         const char *argv[] = { b->exec_path, NULL };
 761                         execvp(b->exec_path, (char**) argv);
 762                 }
 763
 764                 _exit(EXIT_FAILURE);
 765         }
 766
 767         safe_close(s[1]);
 768         b->output_fd = b->input_fd = s[0];
 769
 770         bus_socket_setup(b);
 771
 772         return bus_socket_start_auth(b);
 773 }
 774
 775 int bus_socket_take_fd(sd_bus *b) {
 776         assert(b);
 777
 778         bus_socket_setup(b);
 779
 780         return bus_socket_start_auth(b);
 781 }
 782
 783 int bus_socket_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
 784         struct iovec *iov;
 785         ssize_t k;
 786         size_t n;
 787         unsigned j;
 788         int r;
 789
 790         assert(bus);
 791         assert(m);
 792         assert(idx);
 793         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
 794
 795         if (*idx >= BUS_MESSAGE_SIZE(m))
 796                 return 0;
 797
 798         r = bus_message_setup_iovec(m);
 799         if (r < 0)
 800                 return r;
 801
 802         n = m->n_iovec * sizeof(struct iovec);
 803         iov = alloca(n);
 804         memcpy(iov, m->iovec, n);
 805
 806         j = 0;
 807         iovec_advance(iov, &j, *idx);
 808
 809         if (bus->prefer_writev)
 810                 k = writev(bus->output_fd, iov, m->n_iovec);
 811         else {
 812                 struct msghdr mh = {
 813                         .msg_iov = iov,
 814                         .msg_iovlen = m->n_iovec,
 815                 };
 816
 817                 if (m->n_fds > 0) {
 818                         struct cmsghdr *control;
 819
 820                         mh.msg_control = control = alloca(CMSG_SPACE(sizeof(int) * m->n_fds));
 821                         mh.msg_controllen = control->cmsg_len = CMSG_LEN(sizeof(int) * m->n_fds);
 822                         control->cmsg_level = SOL_SOCKET;
 823                         control->cmsg_type = SCM_RIGHTS;
 824                         memcpy(CMSG_DATA(control), m->fds, sizeof(int) * m->n_fds);
 825                 }
 826
 827                 k = sendmsg(bus->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
 828                 if (k < 0 && errno == ENOTSOCK) {
 829                         bus->prefer_writev = true;
 830                         k = writev(bus->output_fd, iov, m->n_iovec);
 831                 }
 832         }
 833
 834         if (k < 0)
 835                 return errno == EAGAIN ? 0 : -errno;
 836
 837         *idx += (size_t) k;
 838         return 1;
 839 }
 840
 841 static int bus_socket_read_message_need(sd_bus *bus, size_t *need) {
 842         uint32_t a, b;
 843         uint8_t e;
 844         uint64_t sum;
 845
 846         assert(bus);
 847         assert(need);
 848         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
 849
 850         if (bus->rbuffer_size < sizeof(struct bus_header)) {
 851                 *need = sizeof(struct bus_header) + 8;
 852
 853                 /* Minimum message size:
 854                  *
 855                  * Header +
 856                  *
 857                  *  Method Call: +2 string headers
 858                  *       Signal: +3 string headers
 859                  * Method Error: +1 string headers
 860                  *               +1 uint32 headers
 861                  * Method Reply: +1 uint32 headers
 862                  *
 863                  * A string header is at least 9 bytes
 864                  * A uint32 header is at least 8 bytes
 865                  *
 866                  * Hence the minimum message size of a valid message
 867                  * is header + 8 bytes */
 868
 869                 return 0;
 870         }
 871
 872         a = ((const uint32_t*) bus->rbuffer)[1];
 873         b = ((const uint32_t*) bus->rbuffer)[3];
 874
 875         e = ((const uint8_t*) bus->rbuffer)[0];
 876         if (e == BUS_LITTLE_ENDIAN) {
 877                 a = le32toh(a);
 878                 b = le32toh(b);
 879         } else if (e == BUS_BIG_ENDIAN) {
 880                 a = be32toh(a);
 881                 b = be32toh(b);
 882         } else
 883                 return -EBADMSG;
 884
 885         sum = (uint64_t) sizeof(struct bus_header) + (uint64_t) ALIGN_TO(b, 8) + (uint64_t) a;
 886         if (sum >= BUS_MESSAGE_SIZE_MAX)
 887                 return -ENOBUFS;
 888
 889         *need = (size_t) sum;
 890         return 0;
 891 }
 892
 893 static int bus_socket_make_message(sd_bus *bus, size_t size) {
 894         sd_bus_message *t;
 895         void *b;
 896         int r;
 897
 898         assert(bus);
 899         assert(bus->rbuffer_size >= size);
 900         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
 901
 902         r = bus_rqueue_make_room(bus);
 903         if (r < 0)
 904                 return r;
 905
 906         if (bus->rbuffer_size > size) {
 907                 b = memdup((const uint8_t*) bus->rbuffer + size,
 908                            bus->rbuffer_size - size);
 909                 if (!b)
 910                         return -ENOMEM;
 911         } else
 912                 b = NULL;
 913
 914         r = bus_message_from_malloc(bus,
 915                                     bus->rbuffer, size,
 916                                     bus->fds, bus->n_fds,
 917                                     NULL,
 918                                     NULL,
 919                                     &t);
 920         if (r < 0) {
 921                 free(b);
 922                 return r;
 923         }
 924
 925         bus->rbuffer = b;
 926         bus->rbuffer_size -= size;
 927
 928         bus->fds = NULL;
 929         bus->n_fds = 0;
 930
 931         bus->rqueue[bus->rqueue_size++] = t;
 932
 933         return 1;
 934 }
 935
 936 int bus_socket_read_message(sd_bus *bus) {
 937         struct msghdr mh;
 938         struct iovec iov = {};
 939         ssize_t k;
 940         size_t need;
 941         int r;
 942         void *b;
 943         union {
 944                 struct cmsghdr cmsghdr;
 945                 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX) +
 946                             CMSG_SPACE(sizeof(struct ucred)) +
 947                             CMSG_SPACE(NAME_MAX)]; /*selinux label */
 948         } control;
 949         struct cmsghdr *cmsg;
 950         bool handle_cmsg = false;
 951
 952         assert(bus);
 953         assert(bus->state == BUS_RUNNING || bus->state == BUS_HELLO);
 954
 955         r = bus_socket_read_message_need(bus, &need);
 956         if (r < 0)
 957                 return r;
 958
 959         if (bus->rbuffer_size >= need)
 960                 return bus_socket_make_message(bus, need);
 961
 962         b = realloc(bus->rbuffer, need);
 963         if (!b)
 964                 return -ENOMEM;
 965
 966         bus->rbuffer = b;
 967
 968         iov.iov_base = (uint8_t*) bus->rbuffer + bus->rbuffer_size;
 969         iov.iov_len = need - bus->rbuffer_size;
 970
 971         if (bus->prefer_readv)
 972                 k = readv(bus->input_fd, &iov, 1);
 973         else {
 974                 zero(mh);
 975                 mh.msg_iov = &iov;
 976                 mh.msg_iovlen = 1;
 977                 mh.msg_control = &control;
 978                 mh.msg_controllen = sizeof(control);
 979
 980                 k = recvmsg(bus->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
 981                 if (k < 0 && errno == ENOTSOCK) {
 982                         bus->prefer_readv = true;
 983                         k = readv(bus->input_fd, &iov, 1);
 984                 } else
 985                         handle_cmsg = true;
 986         }
 987         if (k < 0)
 988                 return errno == EAGAIN ? 0 : -errno;
 989         if (k == 0)
 990                 return -ECONNRESET;
 991
 992         bus->rbuffer_size += k;
 993
 994         if (handle_cmsg) {
 995                 for (cmsg = CMSG_FIRSTHDR(&mh); cmsg; cmsg = CMSG_NXTHDR(&mh, cmsg)) {
 996                         if (cmsg->cmsg_level == SOL_SOCKET &&
 997                             cmsg->cmsg_type == SCM_RIGHTS) {
 998                                 int n, *f;
 999
1000                                 n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1001
1002                                 if (!bus->can_fds) {
1003                                         /* Whut? We received fds but this
1004                                          * isn't actually enabled? Close them,
1005                                          * and fail */
1006
1007                                         close_many((int*) CMSG_DATA(cmsg), n);
1008                                         return -EIO;
1009                                 }
1010
1011                                 f = realloc(bus->fds, sizeof(int) + (bus->n_fds + n));
1012                                 if (!f) {
1013                                         close_many((int*) CMSG_DATA(cmsg), n);
1014                                         return -ENOMEM;
1015                                 }
1016
1017                                 memcpy(f + bus->n_fds, CMSG_DATA(cmsg), n * sizeof(int));
1018                                 bus->fds = f;
1019                                 bus->n_fds += n;
1020                         } else if (cmsg->cmsg_level == SOL_SOCKET &&
1021                                    cmsg->cmsg_type == SCM_CREDENTIALS &&
1022                                    cmsg->cmsg_len == CMSG_LEN(sizeof(struct ucred))) {
1023
1024                                 /* Ignore bogus data, which we might
1025                                  * get on socketpair() sockets */
1026                                 if (((struct ucred*) CMSG_DATA(cmsg))->pid != 0) {
1027                                         memcpy(&bus->ucred, CMSG_DATA(cmsg), sizeof(struct ucred));
1028                                         bus->ucred_valid = true;
1029                                 }
1030
1031                         } else if (cmsg->cmsg_level == SOL_SOCKET &&
1032                                    cmsg->cmsg_type == SCM_SECURITY) {
1033
1034                                 size_t l;
1035                                 l = cmsg->cmsg_len - CMSG_LEN(0);
1036                                 if (l > 0) {
1037                                         memcpy(&bus->label, CMSG_DATA(cmsg), l);
1038                                         bus->label[l] = 0;
1039                                 }
1040                         }
1041                 }
1042         }
1043
1044         r = bus_socket_read_message_need(bus, &need);
1045         if (r < 0)
1046                 return r;
1047
1048         if (bus->rbuffer_size >= need)
1049                 return bus_socket_make_message(bus, need);
1050
1051         return 1;
1052 }
1053
1054 int bus_socket_process_opening(sd_bus *b) {
1055         int error = 0;
1056         socklen_t slen = sizeof(error);
1057         struct pollfd p = {
1058                 .fd = b->output_fd,
1059                 .events = POLLOUT,
1060         };
1061         int r;
1062
1063         assert(b->state == BUS_OPENING);
1064
1065         r = poll(&p, 1, 0);
1066         if (r < 0)
1067                 return -errno;
1068
1069         if (!(p.revents & (POLLOUT|POLLERR|POLLHUP)))
1070                 return 0;
1071
1072         r = getsockopt(b->output_fd, SOL_SOCKET, SO_ERROR, &error, &slen);
1073         if (r < 0)
1074                 b->last_connect_error = errno;
1075         else if (error != 0)
1076                 b->last_connect_error = error;
1077         else if (p.revents & (POLLERR|POLLHUP))
1078                 b->last_connect_error = ECONNREFUSED;
1079         else
1080                 return bus_socket_start_auth(b);
1081
1082         return bus_next_address(b);
1083 }
1084
1085 int bus_socket_process_authenticating(sd_bus *b) {
1086         int r;
1087
1088         assert(b);
1089         assert(b->state == BUS_AUTHENTICATING);
1090
1091         if (now(CLOCK_MONOTONIC) >= b->auth_timeout)
1092                 return -ETIMEDOUT;
1093
1094         r = bus_socket_write_auth(b);
1095         if (r != 0)
1096                 return r;
1097
1098         return bus_socket_read_auth(b);
1099 }