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