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