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

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2013 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <endian.h>
  22 #include <poll.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25
  26 #include "sd-bus.h"
  27 #include "sd-daemon.h"
  28
  29 #include "alloc-util.h"
  30 #include "bus-internal.h"
  31 #include "bus-message.h"
  32 #include "bus-socket.h"
  33 #include "fd-util.h"
  34 #include "format-util.h"
  35 #include "fs-util.h"
  36 #include "hexdecoct.h"
  37 #include "io-util.h"
  38 #include "macro.h"
  39 #include "missing.h"
  40 #include "path-util.h"
  41 #include "process-util.h"
  42 #include "selinux-util.h"
  43 #include "signal-util.h"
  44 #include "stdio-util.h"
  45 #include "string-util.h"
  46 #include "user-util.h"
  47 #include "utf8.h"
  48 #include "util.h"
  49
  50 #define SNDBUF_SIZE (8*1024*1024)
  51
  52 static void iovec_advance(struct iovec iov[], unsigned *idx, size_t size) {
  53
  54         while (size > 0) {
  55                 struct iovec *i = iov + *idx;
  56
  57                 if (i->iov_len > size) {
  58                         i->iov_base = (uint8_t*) i->iov_base + size;
  59                         i->iov_len -= size;
  60                         return;
  61                 }
  62
  63                 size -= i->iov_len;
  64
  65                 i->iov_base = NULL;
  66                 i->iov_len = 0;
  67
  68                 (*idx)++;
  69         }
  70 }
  71
  72 static int append_iovec(sd_bus_message *m, const void *p, size_t sz) {
  73         assert(m);
  74         assert(p);
  75         assert(sz > 0);
  76
  77         m->iovec[m->n_iovec].iov_base = (void*) p;
  78         m->iovec[m->n_iovec].iov_len = sz;
  79         m->n_iovec++;
  80
  81         return 0;
  82 }
  83
  84 static int bus_message_setup_iovec(sd_bus_message *m) {
  85         struct bus_body_part *part;
  86         unsigned n, i;
  87         int r;
  88
  89         assert(m);
  90         assert(m->sealed);
  91
  92         if (m->n_iovec > 0)
  93                 return 0;
  94
  95         assert(!m->iovec);
  96
  97         n = 1 + m->n_body_parts;
  98         if (n < ELEMENTSOF(m->iovec_fixed))
  99                 m->iovec = m->iovec_fixed;
 100         else {
 101                 m->iovec = new(struct iovec, n);
 102                 if (!m->iovec) {
 103                         r = -ENOMEM;
 104                         goto fail;
 105                 }
 106         }
 107
 108         r = append_iovec(m, m->header, BUS_MESSAGE_BODY_BEGIN(m));
 109         if (r < 0)
 110                 goto fail;
 111
 112         MESSAGE_FOREACH_PART(part, i, m)  {
 113                 r = bus_body_part_map(part);
 114                 if (r < 0)
 115                         goto fail;
 116
 117                 r = append_iovec(m, part->data, part->size);
 118                 if (r < 0)
 119                         goto fail;
 120         }
 121
 122         assert(n == m->n_iovec);
 123
 124         return 0;
 125
 126 fail:
 127         m->poisoned = true;
 128         return r;
 129 }
 130
 131 bool bus_socket_auth_needs_write(sd_bus *b) {
 132
 133         unsigned i;
 134
 135         if (b->auth_index >= ELEMENTSOF(b->auth_iovec))
 136                 return false;
 137
 138         for (i = b->auth_index; i < ELEMENTSOF(b->auth_iovec); i++) {
 139                 struct iovec *j = b->auth_iovec + i;
 140
 141                 if (j->iov_len > 0)
 142                         return true;
 143         }
 144
 145         return false;
 146 }
 147
 148 static int bus_socket_write_auth(sd_bus *b) {
 149         ssize_t k;
 150
 151         assert(b);
 152         assert(b->state == BUS_AUTHENTICATING);
 153
 154         if (!bus_socket_auth_needs_write(b))
 155                 return 0;
 156
 157         if (b->prefer_writev)
 158                 k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
 159         else {
 160                 struct msghdr mh;
 161                 zero(mh);
 162
 163                 mh.msg_iov = b->auth_iovec + b->auth_index;
 164                 mh.msg_iovlen = ELEMENTSOF(b->auth_iovec) - b->auth_index;
 165
 166                 k = sendmsg(b->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
 167                 if (k < 0 && errno == ENOTSOCK) {
 168                         b->prefer_writev = true;
 169                         k = writev(b->output_fd, b->auth_iovec + b->auth_index, ELEMENTSOF(b->auth_iovec) - b->auth_index);
 170                 }
 171         }
 172
 173         if (k < 0)
 174                 return errno == EAGAIN ? 0 : -errno;
 175
 176         iovec_advance(b->auth_iovec, &b->auth_index, (size_t) k);
 177         return 1;
 178 }
 179
 180 static int bus_socket_auth_verify_client(sd_bus *b) {
 181         char *e, *f, *start;
 182         sd_id128_t peer;
 183         unsigned i;
 184         int r;
 185
 186         assert(b);
 187
 188         /* We expect two response lines: "OK" and possibly
 189          * "AGREE_UNIX_FD" */
 190
 191         e = memmem_safe(b->rbuffer, b->rbuffer_size, "\r\n", 2);
 192         if (!e)
 193                 return 0;
 194
 195         if (b->accept_fd) {
 196                 f = memmem(e + 2, b->rbuffer_size - (e - (char*) b->rbuffer) - 2, "\r\n", 2);
 197                 if (!f)
 198                         return 0;
 199
 200                 start = f + 2;
 201         } else {
 202                 f = NULL;
 203                 start = e + 2;
 204         }
 205
 206         /* Nice! We got all the lines we need. First check the OK
 207          * line */
 208
 209         if (e - (char*) b->rbuffer != 3 + 32)
 210                 return -EPERM;
 211
 212         if (memcmp(b->rbuffer, "OK ", 3))
 213                 return -EPERM;
 214
 215         b->auth = b->anonymous_auth ? BUS_AUTH_ANONYMOUS : BUS_AUTH_EXTERNAL;
 216
 217         for (i = 0; i < 32; i += 2) {
 218                 int x, y;
 219
 220                 x = unhexchar(((char*) b->rbuffer)[3 + i]);
 221                 y = unhexchar(((char*) b->rbuffer)[3 + i + 1]);
 222
 223                 if (x < 0 || y < 0)
 224                         return -EINVAL;
 225
 226                 peer.bytes[i/2] = ((uint8_t) x << 4 | (uint8_t) y);
 227         }
 228
 229         if (!sd_id128_is_null(b->server_id) &&
 230             !sd_id128_equal(b->server_id, peer))
 231                 return -EPERM;
 232
 233         b->server_id = peer;
 234
 235         /* And possibly check the second line, too */
 236
 237         if (f)
 238                 b->can_fds =
 239                         (f - e == STRLEN("\r\nAGREE_UNIX_FD")) &&
 240                         memcmp(e + 2, "AGREE_UNIX_FD",
 241                                STRLEN("AGREE_UNIX_FD")) == 0;
 242
 243         b->rbuffer_size -= (start - (char*) b->rbuffer);
 244         memmove(b->rbuffer, start, b->rbuffer_size);
 245
 246         r = bus_start_running(b);
 247         if (r < 0)
 248                 return r;
 249
 250         return 1;
 251 }
 252
 253 static bool line_equals(const char *s, size_t m, const char *line) {
 254         size_t l;
 255
 256         l = strlen(line);
 257         if (l != m)
 258                 return false;
 259
 260         return memcmp(s, line, l) == 0;
 261 }
 262
 263 static bool line_begins(const char *s, size_t m, const char *word) {
 264         size_t l;
 265
 266         l = strlen(word);
 267         if (m < l)
 268                 return false;
 269
 270         if (memcmp(s, word, l) != 0)
 271                 return false;
 272
 273         return m == l || (m > l && s[l] == ' ');
 274 }
 275
 276 static int verify_anonymous_token(sd_bus *b, const char *p, size_t l) {
 277         _cleanup_free_ char *token = NULL;
 278         size_t len;
 279         int r;
 280
 281         if (!b->anonymous_auth)
 282                 return 0;
 283
 284         if (l <= 0)
 285                 return 1;
 286
 287         assert(p[0] == ' ');
 288         p++; l--;
 289
 290         if (l % 2 != 0)
 291                 return 0;
 292
 293         r = unhexmem(p, l, (void **) &token, &len);
 294         if (r < 0)
 295                 return 0;
 296
 297         if (memchr(token, 0, len))
 298                 return 0;
 299
 300         return !!utf8_is_valid(token);
 301 }
 302
 303 static int verify_external_token(sd_bus *b, const char *p, size_t l) {
 304         _cleanup_free_ char *token = NULL;
 305         size_t len;
 306         uid_t u;
 307         int r;
 308
 309         /* We don't do any real authentication here. Instead, we if
 310          * the owner of this bus wanted authentication he should have
 311          * checked SO_PEERCRED before even creating the bus object. */
 312
 313         if (!b->anonymous_auth && !b->ucred_valid)
 314                 return 0;
 315
 316         if (l <= 0)
 317                 return 1;
 318
 319         assert(p[0] == ' ');
 320         p++; l--;
 321
 322         if (l % 2 != 0)
 323                 return 0;
 324
 325         r = unhexmem(p, l, (void**) &token, &len);
 326         if (r < 0)
 327                 return 0;
 328
 329         if (memchr(token, 0, len))
 330                 return 0;
 331
 332         r = parse_uid(token, &u);
 333         if (r < 0)
 334                 return 0;
 335
 336         /* We ignore the passed value if anonymous authentication is
 337          * on anyway. */
 338         if (!b->anonymous_auth && u != b->ucred.uid)
 339                 return 0;
 340
 341         return 1;
 342 }
 343
 344 static int bus_socket_auth_write(sd_bus *b, const char *t) {
 345         char *p;
 346         size_t l;
 347
 348         assert(b);
 349         assert(t);
 350
 351         /* We only make use of the first iovec */
 352         assert(IN_SET(b->auth_index, 0, 1));
 353
 354         l = strlen(t);
 355         p = malloc(b->auth_iovec[0].iov_len + l);
 356         if (!p)
 357                 return -ENOMEM;
 358
 359         memcpy_safe(p, b->auth_iovec[0].iov_base, b->auth_iovec[0].iov_len);
 360         memcpy(p + b->auth_iovec[0].iov_len, t, l);
 361
 362         b->auth_iovec[0].iov_base = p;
 363         b->auth_iovec[0].iov_len += l;
 364
 365         free(b->auth_buffer);
 366         b->auth_buffer = p;
 367         b->auth_index = 0;
 368         return 0;
 369 }
 370
 371 static int bus_socket_auth_write_ok(sd_bus *b) {
 372         char t[3 + 32 + 2 + 1];
 373
 374         assert(b);
 375
 376         xsprintf(t, "OK " SD_ID128_FORMAT_STR "\r\n", SD_ID128_FORMAT_VAL(b->server_id));
 377
 378         return bus_socket_auth_write(b, t);
 379 }
 380
 381 static int bus_socket_auth_verify_server(sd_bus *b) {
 382         char *e;
 383         const char *line;
 384         size_t l;
 385         bool processed = false;
 386         int r;
 387
 388         assert(b);
 389
 390         if (b->rbuffer_size < 1)
 391                 return 0;
 392
 393         /* First char must be a NUL byte */
 394         if (*(char*) b->rbuffer != 0)
 395                 return -EIO;
 396
 397         if (b->rbuffer_size < 3)
 398                 return 0;
 399
 400         /* Begin with the first line */
 401         if (b->auth_rbegin <= 0)
 402                 b->auth_rbegin = 1;
 403
 404         for (;;) {
 405                 /* Check if line is complete */
 406                 line = (char*) b->rbuffer + b->auth_rbegin;
 407                 e = memmem(line, b->rbuffer_size - b->auth_rbegin, "\r\n", 2);
 408                 if (!e)
 409                         return processed;
 410
 411                 l = e - line;
 412
 413                 if (line_begins(line, l, "AUTH ANONYMOUS")) {
 414
 415                         r = verify_anonymous_token(b, line + 14, l - 14);
 416                         if (r < 0)
 417                                 return r;
 418                         if (r == 0)
 419                                 r = bus_socket_auth_write(b, "REJECTED\r\n");
 420                         else {
 421                                 b->auth = BUS_AUTH_ANONYMOUS;
 422                                 r = bus_socket_auth_write_ok(b);
 423                         }
 424
 425                 } else if (line_begins(line, l, "AUTH EXTERNAL")) {
 426
 427                         r = verify_external_token(b, line + 13, l - 13);
 428                         if (r < 0)
 429                                 return r;
 430                         if (r == 0)
 431                                 r = bus_socket_auth_write(b, "REJECTED\r\n");
 432                         else {
 433                                 b->auth = BUS_AUTH_EXTERNAL;
 434                                 r = bus_socket_auth_write_ok(b);
 435                         }
 436
 437                 } else if (line_begins(line, l, "AUTH"))
 438                         r = bus_socket_auth_write(b, "REJECTED EXTERNAL ANONYMOUS\r\n");
 439                 else if (line_equals(line, l, "CANCEL") ||
 440                          line_begins(line, l, "ERROR")) {
 441
 442                         b->auth = _BUS_AUTH_INVALID;
 443                         r = bus_socket_auth_write(b, "REJECTED\r\n");
 444
 445                 } else if (line_equals(line, l, "BEGIN")) {
 446
 447                         if (b->auth == _BUS_AUTH_INVALID)
 448                                 r = bus_socket_auth_write(b, "ERROR\r\n");
 449                         else {
 450                                 /* We can't leave from the auth phase
 451                                  * before we haven't written
 452                                  * everything queued, so let's check
 453                                  * that */
 454
 455                                 if (bus_socket_auth_needs_write(b))
 456                                         return 1;
 457
 458                                 b->rbuffer_size -= (e + 2 - (char*) b->rbuffer);
 459                                 memmove(b->rbuffer, e + 2, b->rbuffer_size);
 460                                 return bus_start_running(b);
 461                         }
 462
 463                 } else if (line_begins(line, l, "DATA")) {
 464
 465                         if (b->auth == _BUS_AUTH_INVALID)
 466                                 r = bus_socket_auth_write(b, "ERROR\r\n");
 467                         else {
 468                                 if (b->auth == BUS_AUTH_ANONYMOUS)
 469                                         r = verify_anonymous_token(b, line + 4, l - 4);
 470                                 else
 471                                         r = verify_external_token(b, line + 4, l - 4);
 472
 473                                 if (r < 0)
 474                                         return r;
 475                                 if (r == 0) {
 476                                         b->auth = _BUS_AUTH_INVALID;
 477                                         r = bus_socket_auth_write(b, "REJECTED\r\n");
 478                                 } else
 479                                         r = bus_socket_auth_write_ok(b);
 480                         }
 481                 } else if (line_equals(line, l, "NEGOTIATE_UNIX_FD")) {
 482                         if (b->auth == _BUS_AUTH_INVALID || !b->accept_fd)
 483                                 r = bus_socket_auth_write(b, "ERROR\r\n");
 484                         else {
 485                                 b->can_fds = true;
 486                                 r = bus_socket_auth_write(b, "AGREE_UNIX_FD\r\n");
 487                         }
 488                 } else
 489                         r = bus_socket_auth_write(b, "ERROR\r\n");
 490
 491                 if (r < 0)
 492                         return r;
 493
 494                 b->auth_rbegin = e + 2 - (char*) b->rbuffer;
 495
 496                 processed = true;
 497         }
 498 }
 499
 500 static int bus_socket_auth_verify(sd_bus *b) {
 501         assert(b);
 502
 503         if (b->is_server)
 504                 return bus_socket_auth_verify_server(b);
 505         else
 506                 return bus_socket_auth_verify_client(b);
 507 }
 508
 509 static int bus_socket_read_auth(sd_bus *b) {
 510         struct msghdr mh;
 511         struct iovec iov = {};
 512         size_t n;
 513         ssize_t k;
 514         int r;
 515         void *p;
 516         union {
 517                 struct cmsghdr cmsghdr;
 518                 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX)];
 519         } control;
 520         bool handle_cmsg = false;
 521
 522         assert(b);
 523         assert(b->state == BUS_AUTHENTICATING);
 524
 525         r = bus_socket_auth_verify(b);
 526         if (r != 0)
 527                 return r;
 528
 529         n = MAX(256u, b->rbuffer_size * 2);
 530
 531         if (n > BUS_AUTH_SIZE_MAX)
 532                 n = BUS_AUTH_SIZE_MAX;
 533
 534         if (b->rbuffer_size >= n)
 535                 return -ENOBUFS;
 536
 537         p = realloc(b->rbuffer, n);
 538         if (!p)
 539                 return -ENOMEM;
 540
 541         b->rbuffer = p;
 542
 543         iov.iov_base = (uint8_t*) b->rbuffer + b->rbuffer_size;
 544         iov.iov_len = n - b->rbuffer_size;
 545
 546         if (b->prefer_readv)
 547                 k = readv(b->input_fd, &iov, 1);
 548         else {
 549                 zero(mh);
 550                 mh.msg_iov = &iov;
 551                 mh.msg_iovlen = 1;
 552                 mh.msg_control = &control;
 553                 mh.msg_controllen = sizeof(control);
 554
 555                 k = recvmsg(b->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
 556                 if (k < 0 && errno == ENOTSOCK) {
 557                         b->prefer_readv = true;
 558                         k = readv(b->input_fd, &iov, 1);
 559                 } else
 560                         handle_cmsg = true;
 561         }
 562         if (k < 0)
 563                 return errno == EAGAIN ? 0 : -errno;
 564         if (k == 0)
 565                 return -ECONNRESET;
 566
 567         b->rbuffer_size += k;
 568
 569         if (handle_cmsg) {
 570                 struct cmsghdr *cmsg;
 571
 572                 CMSG_FOREACH(cmsg, &mh)
 573                         if (cmsg->cmsg_level == SOL_SOCKET &&
 574                             cmsg->cmsg_type == SCM_RIGHTS) {
 575                                 int j;
 576
 577                                 /* Whut? We received fds during the auth
 578                                  * protocol? Somebody is playing games with
 579                                  * us. Close them all, and fail */
 580                                 j = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
 581                                 close_many((int*) CMSG_DATA(cmsg), j);
 582                                 return -EIO;
 583                         } else
 584                                 log_debug("Got unexpected auxiliary data with level=%d and type=%d",
 585                                           cmsg->cmsg_level, cmsg->cmsg_type);
 586         }
 587
 588         r = bus_socket_auth_verify(b);
 589         if (r != 0)
 590                 return r;
 591
 592         return 1;
 593 }
 594
 595 void bus_socket_setup(sd_bus *b) {
 596         assert(b);
 597
 598         /* Increase the buffers to 8 MB */
 599         (void) fd_inc_rcvbuf(b->input_fd, SNDBUF_SIZE);
 600         (void) fd_inc_sndbuf(b->output_fd, SNDBUF_SIZE);
 601
 602         b->message_version = 1;
 603         b->message_endian = 0;
 604 }
 605
 606 static void bus_get_peercred(sd_bus *b) {
 607         int r;
 608
 609         assert(b);
 610         assert(!b->ucred_valid);
 611         assert(!b->label);
 612         assert(b->n_groups == (size_t) -1);
 613
 614         /* Get the peer for socketpair() sockets */
 615         b->ucred_valid = getpeercred(b->input_fd, &b->ucred) >= 0;
 616
 617         /* Get the SELinux context of the peer */
 618         r = getpeersec(b->input_fd, &b->label);
 619         if (r < 0 && !IN_SET(r, -EOPNOTSUPP, -ENOPROTOOPT))
 620                 log_debug_errno(r, "Failed to determine peer security context: %m");
 621
 622         /* Get the list of auxiliary groups of the peer */
 623         r = getpeergroups(b->input_fd, &b->groups);
 624         if (r < 0) {
 625                 if (!IN_SET(r, -EOPNOTSUPP, -ENOPROTOOPT))
 626                         log_debug_errno(r, "Failed to determine peer groups list: %m");
 627
 628                 b->n_groups = (size_t) -1;
 629         } else
 630                 b->n_groups = (size_t) r;
 631 }
 632
 633 static int bus_socket_start_auth_client(sd_bus *b) {
 634         size_t l;
 635         const char *auth_suffix, *auth_prefix;
 636
 637         assert(b);
 638
 639         if (b->anonymous_auth) {
 640                 auth_prefix = "\0AUTH ANONYMOUS ";
 641
 642                 /* For ANONYMOUS auth we send some arbitrary "trace" string */
 643                 l = 9;
 644                 b->auth_buffer = hexmem("anonymous", l);
 645         } else {
 646                 char text[DECIMAL_STR_MAX(uid_t) + 1];
 647
 648                 auth_prefix = "\0AUTH EXTERNAL ";
 649
 650                 xsprintf(text, UID_FMT, geteuid());
 651
 652                 l = strlen(text);
 653                 b->auth_buffer = hexmem(text, l);
 654         }
 655
 656         if (!b->auth_buffer)
 657                 return -ENOMEM;
 658
 659         if (b->accept_fd)
 660                 auth_suffix = "\r\nNEGOTIATE_UNIX_FD\r\nBEGIN\r\n";
 661         else
 662                 auth_suffix = "\r\nBEGIN\r\n";
 663
 664         b->auth_iovec[0].iov_base = (void*) auth_prefix;
 665         b->auth_iovec[0].iov_len = 1 + strlen(auth_prefix + 1);
 666         b->auth_iovec[1].iov_base = (void*) b->auth_buffer;
 667         b->auth_iovec[1].iov_len = l * 2;
 668         b->auth_iovec[2].iov_base = (void*) auth_suffix;
 669         b->auth_iovec[2].iov_len = strlen(auth_suffix);
 670
 671         return bus_socket_write_auth(b);
 672 }
 673
 674 int bus_socket_start_auth(sd_bus *b) {
 675         assert(b);
 676
 677         bus_get_peercred(b);
 678
 679         bus_set_state(b, BUS_AUTHENTICATING);
 680         b->auth_timeout = now(CLOCK_MONOTONIC) + BUS_AUTH_TIMEOUT;
 681
 682         if (sd_is_socket(b->input_fd, AF_UNIX, 0, 0) <= 0)
 683                 b->accept_fd = false;
 684
 685         if (b->output_fd != b->input_fd)
 686                 if (sd_is_socket(b->output_fd, AF_UNIX, 0, 0) <= 0)
 687                         b->accept_fd = false;
 688
 689         if (b->is_server)
 690                 return bus_socket_read_auth(b);
 691         else
 692                 return bus_socket_start_auth_client(b);
 693 }
 694
 695 static int bus_socket_inotify_setup(sd_bus *b) {
 696         _cleanup_free_ int *new_watches = NULL;
 697         _cleanup_free_ char *absolute = NULL;
 698         size_t n_allocated = 0, n = 0, done = 0, i;
 699         unsigned max_follow = 32;
 700         const char *p;
 701         int wd, r;
 702
 703         assert(b);
 704         assert(b->watch_bind);
 705         assert(b->sockaddr.sa.sa_family == AF_UNIX);
 706         assert(b->sockaddr.un.sun_path[0] != 0);
 707
 708         /* Sets up an inotify fd in case watch_bind is enabled: wait until the configured AF_UNIX file system socket
 709          * appears before connecting to it. The implemented is pretty simplistic: we just subscribe to relevant changes
 710          * to all prefix components of the path, and every time we get an event for that we try to reconnect again,
 711          * without actually caring what precisely the event we got told us. If we still can't connect we re-subscribe
 712          * to all relevant changes of anything in the path, so that our watches include any possibly newly created path
 713          * components. */
 714
 715         if (b->inotify_fd < 0) {
 716                 b->inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
 717                 if (b->inotify_fd < 0)
 718                         return -errno;
 719         }
 720
 721         /* Make sure the path is NUL terminated */
 722         p = strndupa(b->sockaddr.un.sun_path, sizeof(b->sockaddr.un.sun_path));
 723
 724         /* Make sure the path is absolute */
 725         r = path_make_absolute_cwd(p, &absolute);
 726         if (r < 0)
 727                 goto fail;
 728
 729         /* Watch all parent directories, and don't mind any prefix that doesn't exist yet. For the innermost directory
 730          * that exists we want to know when files are created or moved into it. For all parents of it we just care if
 731          * they are removed or renamed. */
 732
 733         if (!GREEDY_REALLOC(new_watches, n_allocated, n + 1)) {
 734                 r = -ENOMEM;
 735                 goto fail;
 736         }
 737
 738         /* Start with the top-level directory, which is a bit simpler than the rest, since it can't be a symlink, and
 739          * always exists */
 740         wd = inotify_add_watch(b->inotify_fd, "/", IN_CREATE|IN_MOVED_TO);
 741         if (wd < 0) {
 742                 r = log_debug_errno(errno, "Failed to add inotify watch on /: %m");
 743                 goto fail;
 744         } else
 745                 new_watches[n++] = wd;
 746
 747         for (;;) {
 748                 _cleanup_free_ char *component = NULL, *prefix = NULL, *destination = NULL;
 749                 size_t n_slashes, n_component;
 750                 char *c = NULL;
 751
 752                 n_slashes = strspn(absolute + done, "/");
 753                 n_component = n_slashes + strcspn(absolute + done + n_slashes, "/");
 754
 755                 if (n_component == 0) /* The end */
 756                         break;
 757
 758                 component = strndup(absolute + done, n_component);
 759                 if (!component) {
 760                         r = -ENOMEM;
 761                         goto fail;
 762                 }
 763
 764                 /* A trailing slash? That's a directory, and not a socket then */
 765                 if (path_equal(component, "/")) {
 766                         r = -EISDIR;
 767                         goto fail;
 768                 }
 769
 770                 /* A single dot? Let's eat this up */
 771                 if (path_equal(component, "/.")) {
 772                         done += n_component;
 773                         continue;
 774                 }
 775
 776                 prefix = strndup(absolute, done + n_component);
 777                 if (!prefix) {
 778                         r = -ENOMEM;
 779                         goto fail;
 780                 }
 781
 782                 if (!GREEDY_REALLOC(new_watches, n_allocated, n + 1)) {
 783                         r = -ENOMEM;
 784                         goto fail;
 785                 }
 786
 787                 wd = inotify_add_watch(b->inotify_fd, prefix, IN_DELETE_SELF|IN_MOVE_SELF|IN_ATTRIB|IN_CREATE|IN_MOVED_TO|IN_DONT_FOLLOW);
 788                 log_debug("Added inotify watch for %s on bus %s: %i", prefix, strna(b->description), wd);
 789
 790                 if (wd < 0) {
 791                         if (IN_SET(errno, ENOENT, ELOOP))
 792                                 break; /* This component doesn't exist yet, or the path contains a cyclic symlink right now */
 793
 794                         r = log_debug_errno(errno, "Failed to add inotify watch on %s: %m", isempty(prefix) ? "/" : prefix);
 795                         goto fail;
 796                 } else
 797                         new_watches[n++] = wd;
 798
 799                 /* Check if this is possibly a symlink. If so, let's follow it and watch it too. */
 800                 r = readlink_malloc(prefix, &destination);
 801                 if (r == -EINVAL) { /* not a symlink */
 802                         done += n_component;
 803                         continue;
 804                 }
 805                 if (r < 0)
 806                         goto fail;
 807
 808                 if (isempty(destination)) { /* Empty symlink target? Yuck! */
 809                         r = -EINVAL;
 810                         goto fail;
 811                 }
 812
 813                 if (max_follow <= 0) { /* Let's make sure we don't follow symlinks forever */
 814                         r = -ELOOP;
 815                         goto fail;
 816                 }
 817
 818                 if (path_is_absolute(destination)) {
 819                         /* For absolute symlinks we build the new path and start anew */
 820                         c = strjoin(destination, absolute + done + n_component);
 821                         done = 0;
 822                 } else {
 823                         _cleanup_free_ char *t = NULL;
 824
 825                         /* For relative symlinks we replace the last component, and try again */
 826                         t = strndup(absolute, done);
 827                         if (!t)
 828                                 return -ENOMEM;
 829
 830                         c = strjoin(t, "/", destination, absolute + done + n_component);
 831                 }
 832                 if (!c) {
 833                         r = -ENOMEM;
 834                         goto fail;
 835                 }
 836
 837                 free(absolute);
 838                 absolute = c;
 839
 840                 max_follow--;
 841         }
 842
 843         /* And now, let's remove all watches from the previous iteration we don't need anymore */
 844         for (i = 0; i < b->n_inotify_watches; i++) {
 845                 bool found = false;
 846                 size_t j;
 847
 848                 for (j = 0; j < n; j++)
 849                         if (new_watches[j] == b->inotify_watches[i]) {
 850                                 found = true;
 851                                 break;
 852                         }
 853
 854                 if (found)
 855                         continue;
 856
 857                 (void) inotify_rm_watch(b->inotify_fd, b->inotify_watches[i]);
 858         }
 859
 860         free_and_replace(b->inotify_watches, new_watches);
 861         b->n_inotify_watches = n;
 862
 863         return 0;
 864
 865 fail:
 866         bus_close_inotify_fd(b);
 867         return r;
 868 }
 869
 870 int bus_socket_connect(sd_bus *b) {
 871         bool inotify_done = false;
 872         int r;
 873
 874         assert(b);
 875
 876         for (;;) {
 877                 assert(b->input_fd < 0);
 878                 assert(b->output_fd < 0);
 879                 assert(b->sockaddr.sa.sa_family != AF_UNSPEC);
 880
 881                 b->input_fd = socket(b->sockaddr.sa.sa_family, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
 882                 if (b->input_fd < 0)
 883                         return -errno;
 884
 885                 b->output_fd = b->input_fd;
 886                 bus_socket_setup(b);
 887
 888                 if (connect(b->input_fd, &b->sockaddr.sa, b->sockaddr_size) < 0) {
 889                         if (errno == EINPROGRESS) {
 890
 891                                 /* If we have any inotify watches open, close them now, we don't need them anymore, as
 892                                  * we have successfully initiated a connection */
 893                                 bus_close_inotify_fd(b);
 894
 895                                 /* Note that very likely we are already in BUS_OPENING state here, as we enter it when
 896                                  * we start parsing the address string. The only reason we set the state explicitly
 897                                  * here, is to undo BUS_WATCH_BIND, in case we did the inotify magic. */
 898                                 bus_set_state(b, BUS_OPENING);
 899                                 return 1;
 900                         }
 901
 902                         if (IN_SET(errno, ENOENT, ECONNREFUSED) &&  /* ENOENT → unix socket doesn't exist at all; ECONNREFUSED → unix socket stale */
 903                             b->watch_bind &&
 904                             b->sockaddr.sa.sa_family == AF_UNIX &&
 905                             b->sockaddr.un.sun_path[0] != 0) {
 906
 907                                 /* This connection attempt failed, let's release the socket for now, and start with a
 908                                  * fresh one when reconnecting. */
 909                                 bus_close_io_fds(b);
 910
 911                                 if (inotify_done) {
 912                                         /* inotify set up already, don't do it again, just return now, and remember
 913                                          * that we are waiting for inotify events now. */
 914                                         bus_set_state(b, BUS_WATCH_BIND);
 915                                         return 1;
 916                                 }
 917
 918                                 /* This is a file system socket, and the inotify logic is enabled. Let's create the necessary inotify fd. */
 919                                 r = bus_socket_inotify_setup(b);
 920                                 if (r < 0)
 921                                         return r;
 922
 923                                 /* Let's now try to connect a second time, because in theory there's otherwise a race
 924                                  * here: the socket might have been created in the time between our first connect() and
 925                                  * the time we set up the inotify logic. But let's remember that we set up inotify now,
 926                                  * so that we don't do the connect() more than twice. */
 927                                 inotify_done = true;
 928
 929                         } else
 930                                 return -errno;
 931                 } else
 932                         break;
 933         }
 934
 935         /* Yay, established, we don't need no inotify anymore! */
 936         bus_close_inotify_fd(b);
 937
 938         return bus_socket_start_auth(b);
 939 }
 940
 941 int bus_socket_exec(sd_bus *b) {
 942         int s[2], r;
 943         pid_t pid;
 944
 945         assert(b);
 946         assert(b->input_fd < 0);
 947         assert(b->output_fd < 0);
 948         assert(b->exec_path);
 949
 950         r = socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, s);
 951         if (r < 0)
 952                 return -errno;
 953
 954         r = safe_fork_full("(sd-busexec)", s+1, 1, FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS, &pid);
 955         if (r < 0) {
 956                 safe_close_pair(s);
 957                 return r;
 958         }
 959         if (r == 0) {
 960                 /* Child */
 961
 962                 assert_se(dup3(s[1], STDIN_FILENO, 0) == STDIN_FILENO);
 963                 assert_se(dup3(s[1], STDOUT_FILENO, 0) == STDOUT_FILENO);
 964
 965                 if (!IN_SET(s[1], STDIN_FILENO, STDOUT_FILENO))
 966                         safe_close(s[1]);
 967
 968                 (void) fd_cloexec(STDIN_FILENO, false);
 969                 (void) fd_cloexec(STDOUT_FILENO, false);
 970                 (void) fd_nonblock(STDIN_FILENO, false);
 971                 (void) fd_nonblock(STDOUT_FILENO, false);
 972
 973                 if (b->exec_argv)
 974                         execvp(b->exec_path, b->exec_argv);
 975                 else {
 976                         const char *argv[] = { b->exec_path, NULL };
 977                         execvp(b->exec_path, (char**) argv);
 978                 }
 979
 980                 _exit(EXIT_FAILURE);
 981         }
 982
 983         safe_close(s[1]);
 984         b->output_fd = b->input_fd = s[0];
 985
 986         bus_socket_setup(b);
 987
 988         return bus_socket_start_auth(b);
 989 }
 990
 991 int bus_socket_take_fd(sd_bus *b) {
 992         assert(b);
 993
 994         bus_socket_setup(b);
 995
 996         return bus_socket_start_auth(b);
 997 }
 998
 999 int bus_socket_write_message(sd_bus *bus, sd_bus_message *m, size_t *idx) {
1000         struct iovec *iov;
1001         ssize_t k;
1002         size_t n;
1003         unsigned j;
1004         int r;
1005
1006         assert(bus);
1007         assert(m);
1008         assert(idx);
1009         assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1010
1011         if (*idx >= BUS_MESSAGE_SIZE(m))
1012                 return 0;
1013
1014         r = bus_message_setup_iovec(m);
1015         if (r < 0)
1016                 return r;
1017
1018         n = m->n_iovec * sizeof(struct iovec);
1019         iov = alloca(n);
1020         memcpy_safe(iov, m->iovec, n);
1021
1022         j = 0;
1023         iovec_advance(iov, &j, *idx);
1024
1025         if (bus->prefer_writev)
1026                 k = writev(bus->output_fd, iov, m->n_iovec);
1027         else {
1028                 struct msghdr mh = {
1029                         .msg_iov = iov,
1030                         .msg_iovlen = m->n_iovec,
1031                 };
1032
1033                 if (m->n_fds > 0 && *idx == 0) {
1034                         struct cmsghdr *control;
1035
1036                         mh.msg_control = control = alloca(CMSG_SPACE(sizeof(int) * m->n_fds));
1037                         mh.msg_controllen = control->cmsg_len = CMSG_LEN(sizeof(int) * m->n_fds);
1038                         control->cmsg_level = SOL_SOCKET;
1039                         control->cmsg_type = SCM_RIGHTS;
1040                         memcpy(CMSG_DATA(control), m->fds, sizeof(int) * m->n_fds);
1041                 }
1042
1043                 k = sendmsg(bus->output_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL);
1044                 if (k < 0 && errno == ENOTSOCK) {
1045                         bus->prefer_writev = true;
1046                         k = writev(bus->output_fd, iov, m->n_iovec);
1047                 }
1048         }
1049
1050         if (k < 0)
1051                 return errno == EAGAIN ? 0 : -errno;
1052
1053         *idx += (size_t) k;
1054         return 1;
1055 }
1056
1057 static int bus_socket_read_message_need(sd_bus *bus, size_t *need) {
1058         uint32_t a, b;
1059         uint8_t e;
1060         uint64_t sum;
1061
1062         assert(bus);
1063         assert(need);
1064         assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1065
1066         if (bus->rbuffer_size < sizeof(struct bus_header)) {
1067                 *need = sizeof(struct bus_header) + 8;
1068
1069                 /* Minimum message size:
1070                  *
1071                  * Header +
1072                  *
1073                  *  Method Call: +2 string headers
1074                  *       Signal: +3 string headers
1075                  * Method Error: +1 string headers
1076                  *               +1 uint32 headers
1077                  * Method Reply: +1 uint32 headers
1078                  *
1079                  * A string header is at least 9 bytes
1080                  * A uint32 header is at least 8 bytes
1081                  *
1082                  * Hence the minimum message size of a valid message
1083                  * is header + 8 bytes */
1084
1085                 return 0;
1086         }
1087
1088         a = ((const uint32_t*) bus->rbuffer)[1];
1089         b = ((const uint32_t*) bus->rbuffer)[3];
1090
1091         e = ((const uint8_t*) bus->rbuffer)[0];
1092         if (e == BUS_LITTLE_ENDIAN) {
1093                 a = le32toh(a);
1094                 b = le32toh(b);
1095         } else if (e == BUS_BIG_ENDIAN) {
1096                 a = be32toh(a);
1097                 b = be32toh(b);
1098         } else
1099                 return -EBADMSG;
1100
1101         sum = (uint64_t) sizeof(struct bus_header) + (uint64_t) ALIGN_TO(b, 8) + (uint64_t) a;
1102         if (sum >= BUS_MESSAGE_SIZE_MAX)
1103                 return -ENOBUFS;
1104
1105         *need = (size_t) sum;
1106         return 0;
1107 }
1108
1109 static int bus_socket_make_message(sd_bus *bus, size_t size) {
1110         sd_bus_message *t;
1111         void *b;
1112         int r;
1113
1114         assert(bus);
1115         assert(bus->rbuffer_size >= size);
1116         assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1117
1118         r = bus_rqueue_make_room(bus);
1119         if (r < 0)
1120                 return r;
1121
1122         if (bus->rbuffer_size > size) {
1123                 b = memdup((const uint8_t*) bus->rbuffer + size,
1124                            bus->rbuffer_size - size);
1125                 if (!b)
1126                         return -ENOMEM;
1127         } else
1128                 b = NULL;
1129
1130         r = bus_message_from_malloc(bus,
1131                                     bus->rbuffer, size,
1132                                     bus->fds, bus->n_fds,
1133                                     NULL,
1134                                     &t);
1135         if (r < 0) {
1136                 free(b);
1137                 return r;
1138         }
1139
1140         bus->rbuffer = b;
1141         bus->rbuffer_size -= size;
1142
1143         bus->fds = NULL;
1144         bus->n_fds = 0;
1145
1146         bus->rqueue[bus->rqueue_size++] = t;
1147
1148         return 1;
1149 }
1150
1151 int bus_socket_read_message(sd_bus *bus) {
1152         struct msghdr mh;
1153         struct iovec iov = {};
1154         ssize_t k;
1155         size_t need;
1156         int r;
1157         void *b;
1158         union {
1159                 struct cmsghdr cmsghdr;
1160                 uint8_t buf[CMSG_SPACE(sizeof(int) * BUS_FDS_MAX)];
1161         } control;
1162         bool handle_cmsg = false;
1163
1164         assert(bus);
1165         assert(IN_SET(bus->state, BUS_RUNNING, BUS_HELLO));
1166
1167         r = bus_socket_read_message_need(bus, &need);
1168         if (r < 0)
1169                 return r;
1170
1171         if (bus->rbuffer_size >= need)
1172                 return bus_socket_make_message(bus, need);
1173
1174         b = realloc(bus->rbuffer, need);
1175         if (!b)
1176                 return -ENOMEM;
1177
1178         bus->rbuffer = b;
1179
1180         iov.iov_base = (uint8_t*) bus->rbuffer + bus->rbuffer_size;
1181         iov.iov_len = need - bus->rbuffer_size;
1182
1183         if (bus->prefer_readv)
1184                 k = readv(bus->input_fd, &iov, 1);
1185         else {
1186                 zero(mh);
1187                 mh.msg_iov = &iov;
1188                 mh.msg_iovlen = 1;
1189                 mh.msg_control = &control;
1190                 mh.msg_controllen = sizeof(control);
1191
1192                 k = recvmsg(bus->input_fd, &mh, MSG_DONTWAIT|MSG_NOSIGNAL|MSG_CMSG_CLOEXEC);
1193                 if (k < 0 && errno == ENOTSOCK) {
1194                         bus->prefer_readv = true;
1195                         k = readv(bus->input_fd, &iov, 1);
1196                 } else
1197                         handle_cmsg = true;
1198         }
1199         if (k < 0)
1200                 return errno == EAGAIN ? 0 : -errno;
1201         if (k == 0)
1202                 return -ECONNRESET;
1203
1204         bus->rbuffer_size += k;
1205
1206         if (handle_cmsg) {
1207                 struct cmsghdr *cmsg;
1208
1209                 CMSG_FOREACH(cmsg, &mh)
1210                         if (cmsg->cmsg_level == SOL_SOCKET &&
1211                             cmsg->cmsg_type == SCM_RIGHTS) {
1212                                 int n, *f;
1213
1214                                 n = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
1215
1216                                 if (!bus->can_fds) {
1217                                         /* Whut? We received fds but this
1218                                          * isn't actually enabled? Close them,
1219                                          * and fail */
1220
1221                                         close_many((int*) CMSG_DATA(cmsg), n);
1222                                         return -EIO;
1223                                 }
1224
1225                                 f = realloc(bus->fds, sizeof(int) * (bus->n_fds + n));
1226                                 if (!f) {
1227                                         close_many((int*) CMSG_DATA(cmsg), n);
1228                                         return -ENOMEM;
1229                                 }
1230
1231                                 memcpy_safe(f + bus->n_fds, CMSG_DATA(cmsg), n * sizeof(int));
1232                                 bus->fds = f;
1233                                 bus->n_fds += n;
1234                         } else
1235                                 log_debug("Got unexpected auxiliary data with level=%d and type=%d",
1236                                           cmsg->cmsg_level, cmsg->cmsg_type);
1237         }
1238
1239         r = bus_socket_read_message_need(bus, &need);
1240         if (r < 0)
1241                 return r;
1242
1243         if (bus->rbuffer_size >= need)
1244                 return bus_socket_make_message(bus, need);
1245
1246         return 1;
1247 }
1248
1249 int bus_socket_process_opening(sd_bus *b) {
1250         int error = 0;
1251         socklen_t slen = sizeof(error);
1252         struct pollfd p = {
1253                 .fd = b->output_fd,
1254                 .events = POLLOUT,
1255         };
1256         int r;
1257
1258         assert(b->state == BUS_OPENING);
1259
1260         r = poll(&p, 1, 0);
1261         if (r < 0)
1262                 return -errno;
1263
1264         if (!(p.revents & (POLLOUT|POLLERR|POLLHUP)))
1265                 return 0;
1266
1267         r = getsockopt(b->output_fd, SOL_SOCKET, SO_ERROR, &error, &slen);
1268         if (r < 0)
1269                 b->last_connect_error = errno;
1270         else if (error != 0)
1271                 b->last_connect_error = error;
1272         else if (p.revents & (POLLERR|POLLHUP))
1273                 b->last_connect_error = ECONNREFUSED;
1274         else
1275                 return bus_socket_start_auth(b);
1276
1277         return bus_next_address(b);
1278 }
1279
1280 int bus_socket_process_authenticating(sd_bus *b) {
1281         int r;
1282
1283         assert(b);
1284         assert(b->state == BUS_AUTHENTICATING);
1285
1286         if (now(CLOCK_MONOTONIC) >= b->auth_timeout)
1287                 return -ETIMEDOUT;
1288
1289         r = bus_socket_write_auth(b);
1290         if (r != 0)
1291                 return r;
1292
1293         return bus_socket_read_auth(b);
1294 }
1295
1296 int bus_socket_process_watch_bind(sd_bus *b) {
1297         int r, q;
1298
1299         assert(b);
1300         assert(b->state == BUS_WATCH_BIND);
1301         assert(b->inotify_fd >= 0);
1302
1303         r = flush_fd(b->inotify_fd);
1304         if (r <= 0)
1305                 return r;
1306
1307         log_debug("Got inotify event on bus %s.", strna(b->description));
1308
1309         /* We flushed events out of the inotify fd. In that case, maybe the socket is valid now? Let's try to connect
1310          * to it again */
1311
1312         r = bus_socket_connect(b);
1313         if (r < 0)
1314                 return r;
1315
1316         q = bus_attach_io_events(b);
1317         if (q < 0)
1318                 return q;
1319
1320         q = bus_attach_inotify_event(b);
1321         if (q < 0)
1322                 return q;
1323
1324         return r;
1325 }