src/core/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 2010 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 <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <unistd.h>
  25 #include <errno.h>
  26 #include <fcntl.h>
  27 #include <sys/epoll.h>
  28 #include <signal.h>
  29 #include <arpa/inet.h>
  30 #include <mqueue.h>
  31 #ifdef HAVE_XATTR
  32 #include <attr/xattr.h>
  33 #endif
  34
  35 #include "unit.h"
  36 #include "socket.h"
  37 #include "netinet/tcp.h"
  38 #include "log.h"
  39 #include "load-dropin.h"
  40 #include "load-fragment.h"
  41 #include "strv.h"
  42 #include "mkdir.h"
  43 #include "path-util.h"
  44 #include "unit-name.h"
  45 #include "unit-printf.h"
  46 #include "dbus-socket.h"
  47 #include "missing.h"
  48 #include "special.h"
  49 #include "dbus-common.h"
  50 #include "label.h"
  51 #include "exit-status.h"
  52 #include "def.h"
  53
  54 static const UnitActiveState state_translation_table[_SOCKET_STATE_MAX] = {
  55         [SOCKET_DEAD] = UNIT_INACTIVE,
  56         [SOCKET_START_PRE] = UNIT_ACTIVATING,
  57         [SOCKET_START_POST] = UNIT_ACTIVATING,
  58         [SOCKET_LISTENING] = UNIT_ACTIVE,
  59         [SOCKET_RUNNING] = UNIT_ACTIVE,
  60         [SOCKET_STOP_PRE] = UNIT_DEACTIVATING,
  61         [SOCKET_STOP_PRE_SIGTERM] = UNIT_DEACTIVATING,
  62         [SOCKET_STOP_PRE_SIGKILL] = UNIT_DEACTIVATING,
  63         [SOCKET_STOP_POST] = UNIT_DEACTIVATING,
  64         [SOCKET_FINAL_SIGTERM] = UNIT_DEACTIVATING,
  65         [SOCKET_FINAL_SIGKILL] = UNIT_DEACTIVATING,
  66         [SOCKET_FAILED] = UNIT_FAILED
  67 };
  68
  69 static void socket_init(Unit *u) {
  70         Socket *s = SOCKET(u);
  71
  72         assert(u);
  73         assert(u->load_state == UNIT_STUB);
  74
  75         s->backlog = SOMAXCONN;
  76         s->timeout_usec = DEFAULT_TIMEOUT_USEC;
  77         s->directory_mode = 0755;
  78         s->socket_mode = 0666;
  79
  80         s->max_connections = 64;
  81
  82         s->priority = -1;
  83         s->ip_tos = -1;
  84         s->ip_ttl = -1;
  85         s->mark = -1;
  86
  87         exec_context_init(&s->exec_context);
  88         s->exec_context.std_output = u->manager->default_std_output;
  89         s->exec_context.std_error = u->manager->default_std_error;
  90         kill_context_init(&s->kill_context);
  91         cgroup_context_init(&s->cgroup_context);
  92
  93         s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
  94 }
  95
  96 static void socket_unwatch_control_pid(Socket *s) {
  97         assert(s);
  98
  99         if (s->control_pid <= 0)
 100                 return;
 101
 102         unit_unwatch_pid(UNIT(s), s->control_pid);
 103         s->control_pid = 0;
 104 }
 105
 106 void socket_free_ports(Socket *s) {
 107         SocketPort *p;
 108
 109         assert(s);
 110
 111         while ((p = s->ports)) {
 112                 LIST_REMOVE(SocketPort, port, s->ports, p);
 113
 114                 if (p->fd >= 0) {
 115                         unit_unwatch_fd(UNIT(s), &p->fd_watch);
 116                         close_nointr_nofail(p->fd);
 117                 }
 118
 119                 free(p->path);
 120                 free(p);
 121         }
 122 }
 123
 124 static void socket_done(Unit *u) {
 125         Socket *s = SOCKET(u);
 126
 127         assert(s);
 128
 129         socket_free_ports(s);
 130
 131         exec_context_done(&s->exec_context, manager_is_reloading_or_reexecuting(u->manager));
 132         cgroup_context_init(&s->cgroup_context);
 133
 134         exec_command_free_array(s->exec_command, _SOCKET_EXEC_COMMAND_MAX);
 135         s->control_command = NULL;
 136
 137         socket_unwatch_control_pid(s);
 138
 139         unit_ref_unset(&s->service);
 140
 141         free(s->tcp_congestion);
 142         s->tcp_congestion = NULL;
 143
 144         free(s->bind_to_device);
 145         s->bind_to_device = NULL;
 146
 147         free(s->smack);
 148         free(s->smack_ip_in);
 149         free(s->smack_ip_out);
 150
 151         unit_unwatch_timer(u, &s->timer_watch);
 152 }
 153
 154 static int socket_instantiate_service(Socket *s) {
 155         char *prefix, *name;
 156         int r;
 157         Unit *u;
 158
 159         assert(s);
 160
 161         /* This fills in s->service if it isn't filled in yet. For
 162          * Accept=yes sockets we create the next connection service
 163          * here. For Accept=no this is mostly a NOP since the service
 164          * is figured out at load time anyway. */
 165
 166         if (UNIT_DEREF(s->service))
 167                 return 0;
 168
 169         assert(s->accept);
 170
 171         if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
 172                 return -ENOMEM;
 173
 174         r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
 175         free(prefix);
 176
 177         if (r < 0)
 178                 return -ENOMEM;
 179
 180         r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
 181         free(name);
 182
 183         if (r < 0)
 184                 return r;
 185
 186 #ifdef HAVE_SYSV_COMPAT
 187         if (SERVICE(u)->is_sysv) {
 188                 log_error("Using SysV services for socket activation is not supported. Refusing.");
 189                 return -ENOENT;
 190         }
 191 #endif
 192
 193         u->no_gc = true;
 194         unit_ref_set(&s->service, u);
 195
 196         return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
 197 }
 198
 199 static bool have_non_accept_socket(Socket *s) {
 200         SocketPort *p;
 201
 202         assert(s);
 203
 204         if (!s->accept)
 205                 return true;
 206
 207         LIST_FOREACH(port, p, s->ports) {
 208
 209                 if (p->type != SOCKET_SOCKET)
 210                         return true;
 211
 212                 if (!socket_address_can_accept(&p->address))
 213                         return true;
 214         }
 215
 216         return false;
 217 }
 218
 219 static int socket_verify(Socket *s) {
 220         assert(s);
 221
 222         if (UNIT(s)->load_state != UNIT_LOADED)
 223                 return 0;
 224
 225         if (!s->ports) {
 226                 log_error_unit(UNIT(s)->id,
 227                                "%s lacks Listen setting. Refusing.", UNIT(s)->id);
 228                 return -EINVAL;
 229         }
 230
 231         if (s->accept && have_non_accept_socket(s)) {
 232                 log_error_unit(UNIT(s)->id,
 233                                "%s configured for accepting sockets, but sockets are non-accepting. Refusing.",
 234                                UNIT(s)->id);
 235                 return -EINVAL;
 236         }
 237
 238         if (s->accept && s->max_connections <= 0) {
 239                 log_error_unit(UNIT(s)->id,
 240                                "%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
 241                 return -EINVAL;
 242         }
 243
 244         if (s->accept && UNIT_DEREF(s->service)) {
 245                 log_error_unit(UNIT(s)->id,
 246                                "Explicit service configuration for accepting sockets not supported on %s. Refusing.",
 247                                UNIT(s)->id);
 248                 return -EINVAL;
 249         }
 250
 251         if (s->exec_context.pam_name && s->kill_context.kill_mode != KILL_CONTROL_GROUP) {
 252                 log_error_unit(UNIT(s)->id,
 253                                "%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.",
 254                                UNIT(s)->id);
 255                 return -EINVAL;
 256         }
 257
 258         return 0;
 259 }
 260
 261 static bool socket_needs_mount(Socket *s, const char *prefix) {
 262         SocketPort *p;
 263
 264         assert(s);
 265
 266         LIST_FOREACH(port, p, s->ports) {
 267
 268                 if (p->type == SOCKET_SOCKET) {
 269                         if (socket_address_needs_mount(&p->address, prefix))
 270                                 return true;
 271                 } else if (p->type == SOCKET_FIFO || p->type == SOCKET_SPECIAL) {
 272                         if (path_startswith(p->path, prefix))
 273                                 return true;
 274                 }
 275         }
 276
 277         return false;
 278 }
 279
 280 int socket_add_one_mount_link(Socket *s, Mount *m) {
 281         int r;
 282
 283         assert(s);
 284         assert(m);
 285
 286         if (UNIT(s)->load_state != UNIT_LOADED ||
 287             UNIT(m)->load_state != UNIT_LOADED)
 288                 return 0;
 289
 290         if (!socket_needs_mount(s, m->where))
 291                 return 0;
 292
 293         r = unit_add_two_dependencies(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
 294         if (r < 0)
 295                 return r;
 296
 297         return 0;
 298 }
 299
 300 static int socket_add_mount_links(Socket *s) {
 301         Unit *other;
 302         int r;
 303
 304         assert(s);
 305
 306         LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT]) {
 307                 r = socket_add_one_mount_link(s, MOUNT(other));
 308                 if (r < 0)
 309                         return r;
 310         }
 311
 312         return 0;
 313 }
 314
 315 static int socket_add_device_link(Socket *s) {
 316         char *t;
 317         int r;
 318
 319         assert(s);
 320
 321         if (!s->bind_to_device || streq(s->bind_to_device, "lo"))
 322                 return 0;
 323
 324         if (asprintf(&t, "/sys/subsystem/net/devices/%s", s->bind_to_device) < 0)
 325                 return -ENOMEM;
 326
 327         r = unit_add_node_link(UNIT(s), t, false);
 328         free(t);
 329
 330         return r;
 331 }
 332
 333 static int socket_add_default_dependencies(Socket *s) {
 334         int r;
 335         assert(s);
 336
 337         r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true);
 338         if (r < 0)
 339                 return r;
 340
 341         if (UNIT(s)->manager->running_as == SYSTEMD_SYSTEM) {
 342                 r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
 343                 if (r < 0)
 344                         return r;
 345         }
 346
 347         return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
 348 }
 349
 350 _pure_ static bool socket_has_exec(Socket *s) {
 351         unsigned i;
 352         assert(s);
 353
 354         for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
 355                 if (s->exec_command[i])
 356                         return true;
 357
 358         return false;
 359 }
 360
 361 static int socket_load(Unit *u) {
 362         Socket *s = SOCKET(u);
 363         int r;
 364
 365         assert(u);
 366         assert(u->load_state == UNIT_STUB);
 367
 368         if ((r = unit_load_fragment_and_dropin(u)) < 0)
 369                 return r;
 370
 371         /* This is a new unit? Then let's add in some extras */
 372         if (u->load_state == UNIT_LOADED) {
 373
 374                 if (have_non_accept_socket(s)) {
 375
 376                         if (!UNIT_DEREF(s->service)) {
 377                                 Unit *x;
 378
 379                                 r = unit_load_related_unit(u, ".service", &x);
 380                                 if (r < 0)
 381                                         return r;
 382
 383                                 unit_ref_set(&s->service, x);
 384                         }
 385
 386                         r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
 387                         if (r < 0)
 388                                 return r;
 389                 }
 390
 391                 if ((r = socket_add_mount_links(s)) < 0)
 392                         return r;
 393
 394                 if ((r = socket_add_device_link(s)) < 0)
 395                         return r;
 396
 397                 if (socket_has_exec(s))
 398                         if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
 399                                 return r;
 400
 401                 r = unit_add_default_slice(u);
 402                 if (r < 0)
 403                         return r;
 404
 405                 if (UNIT(s)->default_dependencies)
 406                         if ((r = socket_add_default_dependencies(s)) < 0)
 407                                 return r;
 408
 409                 r = unit_exec_context_defaults(u, &s->exec_context);
 410                 if (r < 0)
 411                         return r;
 412         }
 413
 414         return socket_verify(s);
 415 }
 416
 417 _const_ static const char* listen_lookup(int family, int type) {
 418
 419         if (family == AF_NETLINK)
 420                 return "ListenNetlink";
 421
 422         if (type == SOCK_STREAM)
 423                 return "ListenStream";
 424         else if (type == SOCK_DGRAM)
 425                 return "ListenDatagram";
 426         else if (type == SOCK_SEQPACKET)
 427                 return "ListenSequentialPacket";
 428
 429         assert_not_reached("Unknown socket type");
 430         return NULL;
 431 }
 432
 433 static void socket_dump(Unit *u, FILE *f, const char *prefix) {
 434
 435         SocketExecCommand c;
 436         Socket *s = SOCKET(u);
 437         SocketPort *p;
 438         const char *prefix2;
 439         char *p2;
 440
 441         assert(s);
 442         assert(f);
 443
 444         p2 = strappend(prefix, "\t");
 445         prefix2 = p2 ? p2 : prefix;
 446
 447         fprintf(f,
 448                 "%sSocket State: %s\n"
 449                 "%sResult: %s\n"
 450                 "%sBindIPv6Only: %s\n"
 451                 "%sBacklog: %u\n"
 452                 "%sSocketMode: %04o\n"
 453                 "%sDirectoryMode: %04o\n"
 454                 "%sKeepAlive: %s\n"
 455                 "%sFreeBind: %s\n"
 456                 "%sTransparent: %s\n"
 457                 "%sBroadcast: %s\n"
 458                 "%sPassCredentials: %s\n"
 459                 "%sPassSecurity: %s\n"
 460                 "%sTCPCongestion: %s\n",
 461                 prefix, socket_state_to_string(s->state),
 462                 prefix, socket_result_to_string(s->result),
 463                 prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
 464                 prefix, s->backlog,
 465                 prefix, s->socket_mode,
 466                 prefix, s->directory_mode,
 467                 prefix, yes_no(s->keep_alive),
 468                 prefix, yes_no(s->free_bind),
 469                 prefix, yes_no(s->transparent),
 470                 prefix, yes_no(s->broadcast),
 471                 prefix, yes_no(s->pass_cred),
 472                 prefix, yes_no(s->pass_sec),
 473                 prefix, strna(s->tcp_congestion));
 474
 475         if (s->control_pid > 0)
 476                 fprintf(f,
 477                         "%sControl PID: %lu\n",
 478                         prefix, (unsigned long) s->control_pid);
 479
 480         if (s->bind_to_device)
 481                 fprintf(f,
 482                         "%sBindToDevice: %s\n",
 483                         prefix, s->bind_to_device);
 484
 485         if (s->accept)
 486                 fprintf(f,
 487                         "%sAccepted: %u\n"
 488                         "%sNConnections: %u\n"
 489                         "%sMaxConnections: %u\n",
 490                         prefix, s->n_accepted,
 491                         prefix, s->n_connections,
 492                         prefix, s->max_connections);
 493
 494         if (s->priority >= 0)
 495                 fprintf(f,
 496                         "%sPriority: %i\n",
 497                         prefix, s->priority);
 498
 499         if (s->receive_buffer > 0)
 500                 fprintf(f,
 501                         "%sReceiveBuffer: %zu\n",
 502                         prefix, s->receive_buffer);
 503
 504         if (s->send_buffer > 0)
 505                 fprintf(f,
 506                         "%sSendBuffer: %zu\n",
 507                         prefix, s->send_buffer);
 508
 509         if (s->ip_tos >= 0)
 510                 fprintf(f,
 511                         "%sIPTOS: %i\n",
 512                         prefix, s->ip_tos);
 513
 514         if (s->ip_ttl >= 0)
 515                 fprintf(f,
 516                         "%sIPTTL: %i\n",
 517                         prefix, s->ip_ttl);
 518
 519         if (s->pipe_size > 0)
 520                 fprintf(f,
 521                         "%sPipeSize: %zu\n",
 522                         prefix, s->pipe_size);
 523
 524         if (s->mark >= 0)
 525                 fprintf(f,
 526                         "%sMark: %i\n",
 527                         prefix, s->mark);
 528
 529         if (s->mq_maxmsg > 0)
 530                 fprintf(f,
 531                         "%sMessageQueueMaxMessages: %li\n",
 532                         prefix, s->mq_maxmsg);
 533
 534         if (s->mq_msgsize > 0)
 535                 fprintf(f,
 536                         "%sMessageQueueMessageSize: %li\n",
 537                         prefix, s->mq_msgsize);
 538
 539         if (s->reuseport)
 540                 fprintf(f,
 541                         "%sReusePort: %s\n",
 542                          prefix, yes_no(s->reuseport));
 543
 544         if (s->smack)
 545                 fprintf(f,
 546                         "%sSmackLabel: %s\n",
 547                         prefix, s->smack);
 548
 549         if (s->smack_ip_in)
 550                 fprintf(f,
 551                         "%sSmackLabelIPIn: %s\n",
 552                         prefix, s->smack_ip_in);
 553
 554         if (s->smack_ip_out)
 555                 fprintf(f,
 556                         "%sSmackLabelIPOut: %s\n",
 557                         prefix, s->smack_ip_out);
 558
 559         LIST_FOREACH(port, p, s->ports) {
 560
 561                 if (p->type == SOCKET_SOCKET) {
 562                         const char *t;
 563                         int r;
 564                         char *k = NULL;
 565
 566                         if ((r = socket_address_print(&p->address, &k)) < 0)
 567                                 t = strerror(-r);
 568                         else
 569                                 t = k;
 570
 571                         fprintf(f, "%s%s: %s\n", prefix, listen_lookup(socket_address_family(&p->address), p->address.type), t);
 572                         free(k);
 573                 } else if (p->type == SOCKET_SPECIAL)
 574                         fprintf(f, "%sListenSpecial: %s\n", prefix, p->path);
 575                 else if (p->type == SOCKET_MQUEUE)
 576                         fprintf(f, "%sListenMessageQueue: %s\n", prefix, p->path);
 577                 else
 578                         fprintf(f, "%sListenFIFO: %s\n", prefix, p->path);
 579         }
 580
 581         exec_context_dump(&s->exec_context, f, prefix);
 582         kill_context_dump(&s->kill_context, f, prefix);
 583
 584         for (c = 0; c < _SOCKET_EXEC_COMMAND_MAX; c++) {
 585                 if (!s->exec_command[c])
 586                         continue;
 587
 588                 fprintf(f, "%s-> %s:\n",
 589                         prefix, socket_exec_command_to_string(c));
 590
 591                 exec_command_dump_list(s->exec_command[c], f, prefix2);
 592         }
 593
 594         free(p2);
 595 }
 596
 597 static int instance_from_socket(int fd, unsigned nr, char **instance) {
 598         socklen_t l;
 599         char *r;
 600         union {
 601                 struct sockaddr sa;
 602                 struct sockaddr_un un;
 603                 struct sockaddr_in in;
 604                 struct sockaddr_in6 in6;
 605                 struct sockaddr_storage storage;
 606         } local, remote;
 607
 608         assert(fd >= 0);
 609         assert(instance);
 610
 611         l = sizeof(local);
 612         if (getsockname(fd, &local.sa, &l) < 0)
 613                 return -errno;
 614
 615         l = sizeof(remote);
 616         if (getpeername(fd, &remote.sa, &l) < 0)
 617                 return -errno;
 618
 619         switch (local.sa.sa_family) {
 620
 621         case AF_INET: {
 622                 uint32_t
 623                         a = ntohl(local.in.sin_addr.s_addr),
 624                         b = ntohl(remote.in.sin_addr.s_addr);
 625
 626                 if (asprintf(&r,
 627                              "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 628                              nr,
 629                              a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
 630                              ntohs(local.in.sin_port),
 631                              b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
 632                              ntohs(remote.in.sin_port)) < 0)
 633                         return -ENOMEM;
 634
 635                 break;
 636         }
 637
 638         case AF_INET6: {
 639                 static const unsigned char ipv4_prefix[] = {
 640                         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF
 641                 };
 642
 643                 if (memcmp(&local.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0 &&
 644                     memcmp(&remote.in6.sin6_addr, ipv4_prefix, sizeof(ipv4_prefix)) == 0) {
 645                         const uint8_t
 646                                 *a = local.in6.sin6_addr.s6_addr+12,
 647                                 *b = remote.in6.sin6_addr.s6_addr+12;
 648
 649                         if (asprintf(&r,
 650                                      "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 651                                      nr,
 652                                      a[0], a[1], a[2], a[3],
 653                                      ntohs(local.in6.sin6_port),
 654                                      b[0], b[1], b[2], b[3],
 655                                      ntohs(remote.in6.sin6_port)) < 0)
 656                                 return -ENOMEM;
 657                 } else {
 658                         char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
 659
 660                         if (asprintf(&r,
 661                                      "%u-%s:%u-%s:%u",
 662                                      nr,
 663                                      inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
 664                                      ntohs(local.in6.sin6_port),
 665                                      inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
 666                                      ntohs(remote.in6.sin6_port)) < 0)
 667                                 return -ENOMEM;
 668                 }
 669
 670                 break;
 671         }
 672
 673         case AF_UNIX: {
 674                 struct ucred ucred;
 675
 676                 l = sizeof(ucred);
 677                 if (getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &ucred, &l) < 0)
 678                         return -errno;
 679
 680                 if (asprintf(&r,
 681                              "%u-%lu-%lu",
 682                              nr,
 683                              (unsigned long) ucred.pid,
 684                              (unsigned long) ucred.uid) < 0)
 685                         return -ENOMEM;
 686
 687                 break;
 688         }
 689
 690         default:
 691                 assert_not_reached("Unhandled socket type.");
 692         }
 693
 694         *instance = r;
 695         return 0;
 696 }
 697
 698 static void socket_close_fds(Socket *s) {
 699         SocketPort *p;
 700
 701         assert(s);
 702
 703         LIST_FOREACH(port, p, s->ports) {
 704                 if (p->fd < 0)
 705                         continue;
 706
 707                 unit_unwatch_fd(UNIT(s), &p->fd_watch);
 708                 close_nointr_nofail(p->fd);
 709
 710                 /* One little note: we should never delete any sockets
 711                  * in the file system here! After all some other
 712                  * process we spawned might still have a reference of
 713                  * this fd and wants to continue to use it. Therefore
 714                  * we delete sockets in the file system before we
 715                  * create a new one, not after we stopped using
 716                  * one! */
 717
 718                 p->fd = -1;
 719         }
 720 }
 721
 722 static void socket_apply_socket_options(Socket *s, int fd) {
 723         assert(s);
 724         assert(fd >= 0);
 725
 726         if (s->keep_alive) {
 727                 int b = s->keep_alive;
 728                 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &b, sizeof(b)) < 0)
 729                         log_warning_unit(UNIT(s)->id, "SO_KEEPALIVE failed: %m");
 730         }
 731
 732         if (s->broadcast) {
 733                 int one = 1;
 734                 if (setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &one, sizeof(one)) < 0)
 735                         log_warning_unit(UNIT(s)->id, "SO_BROADCAST failed: %m");
 736         }
 737
 738         if (s->pass_cred) {
 739                 int one = 1;
 740                 if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
 741                         log_warning_unit(UNIT(s)->id, "SO_PASSCRED failed: %m");
 742         }
 743
 744         if (s->pass_sec) {
 745                 int one = 1;
 746                 if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
 747                         log_warning_unit(UNIT(s)->id, "SO_PASSSEC failed: %m");
 748         }
 749
 750         if (s->priority >= 0)
 751                 if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
 752                         log_warning_unit(UNIT(s)->id, "SO_PRIORITY failed: %m");
 753
 754         if (s->receive_buffer > 0) {
 755                 int value = (int) s->receive_buffer;
 756
 757                 /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
 758
 759                 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
 760                         if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
 761                                 log_warning_unit(UNIT(s)->id, "SO_RCVBUF failed: %m");
 762         }
 763
 764         if (s->send_buffer > 0) {
 765                 int value = (int) s->send_buffer;
 766                 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
 767                         if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
 768                                 log_warning_unit(UNIT(s)->id, "SO_SNDBUF failed: %m");
 769         }
 770
 771         if (s->mark >= 0)
 772                 if (setsockopt(fd, SOL_SOCKET, SO_MARK, &s->mark, sizeof(s->mark)) < 0)
 773                         log_warning_unit(UNIT(s)->id, "SO_MARK failed: %m");
 774
 775         if (s->ip_tos >= 0)
 776                 if (setsockopt(fd, IPPROTO_IP, IP_TOS, &s->ip_tos, sizeof(s->ip_tos)) < 0)
 777                         log_warning_unit(UNIT(s)->id, "IP_TOS failed: %m");
 778
 779         if (s->ip_ttl >= 0) {
 780                 int r, x;
 781
 782                 r = setsockopt(fd, IPPROTO_IP, IP_TTL, &s->ip_ttl, sizeof(s->ip_ttl));
 783
 784                 if (socket_ipv6_is_supported())
 785                         x = setsockopt(fd, IPPROTO_IPV6, IPV6_UNICAST_HOPS, &s->ip_ttl, sizeof(s->ip_ttl));
 786                 else {
 787                         x = -1;
 788                         errno = EAFNOSUPPORT;
 789                 }
 790
 791                 if (r < 0 && x < 0)
 792                         log_warning_unit(UNIT(s)->id,
 793                                          "IP_TTL/IPV6_UNICAST_HOPS failed: %m");
 794         }
 795
 796         if (s->tcp_congestion)
 797                 if (setsockopt(fd, SOL_TCP, TCP_CONGESTION, s->tcp_congestion, strlen(s->tcp_congestion)+1) < 0)
 798                         log_warning_unit(UNIT(s)->id, "TCP_CONGESTION failed: %m");
 799
 800         if (s->reuseport) {
 801                 int b = s->reuseport;
 802                 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &b, sizeof(b)))
 803                         log_warning_unit(UNIT(s)->id, "SO_REUSEPORT failed: %m");
 804         }
 805
 806 #ifdef HAVE_SMACK
 807         if (s->smack_ip_in)
 808                 if (fsetxattr(fd, "security.SMACK64IPIN", s->smack_ip_in, strlen(s->smack_ip_in), 0) < 0)
 809                         log_error_unit(UNIT(s)->id,
 810                                        "fsetxattr(\"security.SMACK64IPIN\"): %m");
 811
 812         if (s->smack_ip_out)
 813                 if (fsetxattr(fd, "security.SMACK64IPOUT", s->smack_ip_out, strlen(s->smack_ip_out), 0) < 0)
 814                         log_error_unit(UNIT(s)->id,
 815                                        "fsetxattr(\"security.SMACK64IPOUT\"): %m");
 816 #endif
 817 }
 818
 819 static void socket_apply_fifo_options(Socket *s, int fd) {
 820         assert(s);
 821         assert(fd >= 0);
 822
 823         if (s->pipe_size > 0)
 824                 if (fcntl(fd, F_SETPIPE_SZ, s->pipe_size) < 0)
 825                         log_warning_unit(UNIT(s)->id,
 826                                          "F_SETPIPE_SZ: %m");
 827
 828 #ifdef HAVE_SMACK
 829         if (s->smack)
 830                 if (fsetxattr(fd, "security.SMACK64", s->smack, strlen(s->smack), 0) < 0)
 831                         log_error_unit(UNIT(s)->id,
 832                                        "fsetxattr(\"security.SMACK64\"): %m");
 833 #endif
 834 }
 835
 836 static int fifo_address_create(
 837                 const char *path,
 838                 mode_t directory_mode,
 839                 mode_t socket_mode,
 840                 int *_fd) {
 841
 842         int fd = -1, r = 0;
 843         struct stat st;
 844         mode_t old_mask;
 845
 846         assert(path);
 847         assert(_fd);
 848
 849         mkdir_parents_label(path, directory_mode);
 850
 851         r = label_context_set(path, S_IFIFO);
 852         if (r < 0)
 853                 goto fail;
 854
 855         /* Enforce the right access mode for the fifo */
 856         old_mask = umask(~ socket_mode);
 857
 858         /* Include the original umask in our mask */
 859         umask(~socket_mode | old_mask);
 860
 861         r = mkfifo(path, socket_mode);
 862         umask(old_mask);
 863
 864         if (r < 0 && errno != EEXIST) {
 865                 r = -errno;
 866                 goto fail;
 867         }
 868
 869         if ((fd = open(path, O_RDWR|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 870                 r = -errno;
 871                 goto fail;
 872         }
 873
 874         label_context_clear();
 875
 876         if (fstat(fd, &st) < 0) {
 877                 r = -errno;
 878                 goto fail;
 879         }
 880
 881         if (!S_ISFIFO(st.st_mode) ||
 882             (st.st_mode & 0777) != (socket_mode & ~old_mask) ||
 883             st.st_uid != getuid() ||
 884             st.st_gid != getgid()) {
 885
 886                 r = -EEXIST;
 887                 goto fail;
 888         }
 889
 890         *_fd = fd;
 891         return 0;
 892
 893 fail:
 894         label_context_clear();
 895
 896         if (fd >= 0)
 897                 close_nointr_nofail(fd);
 898
 899         return r;
 900 }
 901
 902 static int special_address_create(
 903                 const char *path,
 904                 int *_fd) {
 905
 906         int fd = -1, r = 0;
 907         struct stat st;
 908
 909         assert(path);
 910         assert(_fd);
 911
 912         if ((fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY|O_NONBLOCK|O_NOFOLLOW)) < 0) {
 913                 r = -errno;
 914                 goto fail;
 915         }
 916
 917         if (fstat(fd, &st) < 0) {
 918                 r = -errno;
 919                 goto fail;
 920         }
 921
 922         /* Check whether this is a /proc, /sys or /dev file or char device */
 923         if (!S_ISREG(st.st_mode) && !S_ISCHR(st.st_mode)) {
 924                 r = -EEXIST;
 925                 goto fail;
 926         }
 927
 928         *_fd = fd;
 929         return 0;
 930
 931 fail:
 932         if (fd >= 0)
 933                 close_nointr_nofail(fd);
 934
 935         return r;
 936 }
 937
 938 static int mq_address_create(
 939                 const char *path,
 940                 mode_t mq_mode,
 941                 long maxmsg,
 942                 long msgsize,
 943                 int *_fd) {
 944
 945         int fd = -1, r = 0;
 946         struct stat st;
 947         mode_t old_mask;
 948         struct mq_attr _attr, *attr = NULL;
 949
 950         assert(path);
 951         assert(_fd);
 952
 953         if (maxmsg > 0 && msgsize > 0) {
 954                 zero(_attr);
 955                 _attr.mq_flags = O_NONBLOCK;
 956                 _attr.mq_maxmsg = maxmsg;
 957                 _attr.mq_msgsize = msgsize;
 958                 attr = &_attr;
 959         }
 960
 961         /* Enforce the right access mode for the mq */
 962         old_mask = umask(~ mq_mode);
 963
 964         /* Include the original umask in our mask */
 965         umask(~mq_mode | old_mask);
 966
 967         fd = mq_open(path, O_RDONLY|O_CLOEXEC|O_NONBLOCK|O_CREAT, mq_mode, attr);
 968         umask(old_mask);
 969
 970         if (fd < 0) {
 971                 r = -errno;
 972                 goto fail;
 973         }
 974
 975         if (fstat(fd, &st) < 0) {
 976                 r = -errno;
 977                 goto fail;
 978         }
 979
 980         if ((st.st_mode & 0777) != (mq_mode & ~old_mask) ||
 981             st.st_uid != getuid() ||
 982             st.st_gid != getgid()) {
 983
 984                 r = -EEXIST;
 985                 goto fail;
 986         }
 987
 988         *_fd = fd;
 989         return 0;
 990
 991 fail:
 992         if (fd >= 0)
 993                 close_nointr_nofail(fd);
 994
 995         return r;
 996 }
 997
 998 static int socket_open_fds(Socket *s) {
 999         SocketPort *p;
1000         int r;
1001         char *label = NULL;
1002         bool know_label = false;
1003
1004         assert(s);
1005
1006         LIST_FOREACH(port, p, s->ports) {
1007
1008                 if (p->fd >= 0)
1009                         continue;
1010
1011                 if (p->type == SOCKET_SOCKET) {
1012
1013                         if (!know_label) {
1014
1015                                 if ((r = socket_instantiate_service(s)) < 0)
1016                                         return r;
1017
1018                                 if (UNIT_ISSET(s->service) &&
1019                                     SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
1020                                         r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
1021
1022                                         if (r < 0) {
1023                                                 if (r != -EPERM)
1024                                                         return r;
1025                                         }
1026                                 }
1027
1028                                 know_label = true;
1029                         }
1030
1031                         if ((r = socket_address_listen(
1032                                              &p->address,
1033                                              s->backlog,
1034                                              s->bind_ipv6_only,
1035                                              s->bind_to_device,
1036                                              s->free_bind,
1037                                              s->transparent,
1038                                              s->directory_mode,
1039                                              s->socket_mode,
1040                                              label,
1041                                              &p->fd)) < 0)
1042                                 goto rollback;
1043
1044                         socket_apply_socket_options(s, p->fd);
1045
1046                 } else  if (p->type == SOCKET_SPECIAL) {
1047
1048                         if ((r = special_address_create(
1049                                              p->path,
1050                                              &p->fd)) < 0)
1051                                 goto rollback;
1052
1053                 } else  if (p->type == SOCKET_FIFO) {
1054
1055                         if ((r = fifo_address_create(
1056                                              p->path,
1057                                              s->directory_mode,
1058                                              s->socket_mode,
1059                                              &p->fd)) < 0)
1060                                 goto rollback;
1061
1062                         socket_apply_fifo_options(s, p->fd);
1063                 } else if (p->type == SOCKET_MQUEUE) {
1064
1065                         if ((r = mq_address_create(
1066                                              p->path,
1067                                              s->socket_mode,
1068                                              s->mq_maxmsg,
1069                                              s->mq_msgsize,
1070                                              &p->fd)) < 0)
1071                                 goto rollback;
1072                 } else
1073                         assert_not_reached("Unknown port type");
1074         }
1075
1076         label_free(label);
1077         return 0;
1078
1079 rollback:
1080         socket_close_fds(s);
1081         label_free(label);
1082         return r;
1083 }
1084
1085 static void socket_unwatch_fds(Socket *s) {
1086         SocketPort *p;
1087
1088         assert(s);
1089
1090         LIST_FOREACH(port, p, s->ports) {
1091                 if (p->fd < 0)
1092                         continue;
1093
1094                 unit_unwatch_fd(UNIT(s), &p->fd_watch);
1095         }
1096 }
1097
1098 static int socket_watch_fds(Socket *s) {
1099         SocketPort *p;
1100         int r;
1101
1102         assert(s);
1103
1104         LIST_FOREACH(port, p, s->ports) {
1105                 if (p->fd < 0)
1106                         continue;
1107
1108                 p->fd_watch.socket_accept =
1109                         s->accept &&
1110                         p->type == SOCKET_SOCKET &&
1111                         socket_address_can_accept(&p->address);
1112
1113                 if ((r = unit_watch_fd(UNIT(s), p->fd, EPOLLIN, &p->fd_watch)) < 0)
1114                         goto fail;
1115         }
1116
1117         return 0;
1118
1119 fail:
1120         socket_unwatch_fds(s);
1121         return r;
1122 }
1123
1124 static void socket_set_state(Socket *s, SocketState state) {
1125         SocketState old_state;
1126         assert(s);
1127
1128         old_state = s->state;
1129         s->state = state;
1130
1131         if (state != SOCKET_START_PRE &&
1132             state != SOCKET_START_POST &&
1133             state != SOCKET_STOP_PRE &&
1134             state != SOCKET_STOP_PRE_SIGTERM &&
1135             state != SOCKET_STOP_PRE_SIGKILL &&
1136             state != SOCKET_STOP_POST &&
1137             state != SOCKET_FINAL_SIGTERM &&
1138             state != SOCKET_FINAL_SIGKILL) {
1139                 unit_unwatch_timer(UNIT(s), &s->timer_watch);
1140                 socket_unwatch_control_pid(s);
1141                 s->control_command = NULL;
1142                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1143         }
1144
1145         if (state != SOCKET_LISTENING)
1146                 socket_unwatch_fds(s);
1147
1148         if (state != SOCKET_START_POST &&
1149             state != SOCKET_LISTENING &&
1150             state != SOCKET_RUNNING &&
1151             state != SOCKET_STOP_PRE &&
1152             state != SOCKET_STOP_PRE_SIGTERM &&
1153             state != SOCKET_STOP_PRE_SIGKILL)
1154                 socket_close_fds(s);
1155
1156         if (state != old_state)
1157                 log_debug_unit(UNIT(s)->id,
1158                                "%s changed %s -> %s", UNIT(s)->id,
1159                                socket_state_to_string(old_state),
1160                                socket_state_to_string(state));
1161
1162         unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
1163 }
1164
1165 static int socket_coldplug(Unit *u) {
1166         Socket *s = SOCKET(u);
1167         int r;
1168
1169         assert(s);
1170         assert(s->state == SOCKET_DEAD);
1171
1172         if (s->deserialized_state != s->state) {
1173
1174                 if (s->deserialized_state == SOCKET_START_PRE ||
1175                     s->deserialized_state == SOCKET_START_POST ||
1176                     s->deserialized_state == SOCKET_STOP_PRE ||
1177                     s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1178                     s->deserialized_state == SOCKET_STOP_PRE_SIGKILL ||
1179                     s->deserialized_state == SOCKET_STOP_POST ||
1180                     s->deserialized_state == SOCKET_FINAL_SIGTERM ||
1181                     s->deserialized_state == SOCKET_FINAL_SIGKILL) {
1182
1183                         if (s->control_pid <= 0)
1184                                 return -EBADMSG;
1185
1186                         r = unit_watch_pid(UNIT(s), s->control_pid);
1187                         if (r < 0)
1188                                 return r;
1189
1190                         r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1191                         if (r < 0)
1192                                 return r;
1193                 }
1194
1195                 if (s->deserialized_state == SOCKET_START_POST ||
1196                     s->deserialized_state == SOCKET_LISTENING ||
1197                     s->deserialized_state == SOCKET_RUNNING ||
1198                     s->deserialized_state == SOCKET_STOP_PRE ||
1199                     s->deserialized_state == SOCKET_STOP_PRE_SIGTERM ||
1200                     s->deserialized_state == SOCKET_STOP_PRE_SIGKILL)
1201                         if ((r = socket_open_fds(s)) < 0)
1202                                 return r;
1203
1204                 if (s->deserialized_state == SOCKET_LISTENING)
1205                         if ((r = socket_watch_fds(s)) < 0)
1206                                 return r;
1207
1208                 socket_set_state(s, s->deserialized_state);
1209         }
1210
1211         return 0;
1212 }
1213
1214 static int socket_spawn(Socket *s, ExecCommand *c, pid_t *_pid) {
1215         pid_t pid;
1216         int r;
1217         char **argv;
1218
1219         assert(s);
1220         assert(c);
1221         assert(_pid);
1222
1223         unit_realize_cgroup(UNIT(s));
1224
1225         r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1226         if (r < 0)
1227                 goto fail;
1228
1229         argv = unit_full_printf_strv(UNIT(s), c->argv);
1230         if (!argv) {
1231                 r = -ENOMEM;
1232                 goto fail;
1233         }
1234
1235         r = exec_spawn(c,
1236                        argv,
1237                        &s->exec_context,
1238                        NULL, 0,
1239                        UNIT(s)->manager->environment,
1240                        true,
1241                        true,
1242                        true,
1243                        UNIT(s)->manager->confirm_spawn,
1244                        UNIT(s)->cgroup_mask,
1245                        UNIT(s)->cgroup_path,
1246                        UNIT(s)->id,
1247                        NULL,
1248                        &pid);
1249
1250         strv_free(argv);
1251         if (r < 0)
1252                 goto fail;
1253
1254         if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
1255                 /* FIXME: we need to do something here */
1256                 goto fail;
1257
1258         *_pid = pid;
1259
1260         return 0;
1261
1262 fail:
1263         unit_unwatch_timer(UNIT(s), &s->timer_watch);
1264
1265         return r;
1266 }
1267
1268 static void socket_enter_dead(Socket *s, SocketResult f) {
1269         assert(s);
1270
1271         if (f != SOCKET_SUCCESS)
1272                 s->result = f;
1273
1274         exec_context_tmp_dirs_done(&s->exec_context);
1275         socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1276 }
1277
1278 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1279
1280 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1281         int r;
1282         assert(s);
1283
1284         if (f != SOCKET_SUCCESS)
1285                 s->result = f;
1286
1287         socket_unwatch_control_pid(s);
1288
1289         s->control_command_id = SOCKET_EXEC_STOP_POST;
1290
1291         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST])) {
1292                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1293                         goto fail;
1294
1295                 socket_set_state(s, SOCKET_STOP_POST);
1296         } else
1297                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1298
1299         return;
1300
1301 fail:
1302         log_warning_unit(UNIT(s)->id,
1303                          "%s failed to run 'stop-post' task: %s",
1304                          UNIT(s)->id, strerror(-r));
1305         socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1306 }
1307
1308 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1309         int r;
1310
1311         assert(s);
1312
1313         if (f != SOCKET_SUCCESS)
1314                 s->result = f;
1315
1316         r = unit_kill_context(
1317                         UNIT(s),
1318                         &s->kill_context,
1319                         state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1320                         -1,
1321                         s->control_pid,
1322                         false);
1323         if (r < 0)
1324                 goto fail;
1325
1326         if (r > 0) {
1327                 r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_usec, &s->timer_watch);
1328                 if (r < 0)
1329                         goto fail;
1330
1331                 socket_set_state(s, state);
1332         } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1333                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1334         else
1335                 socket_enter_dead(s, SOCKET_SUCCESS);
1336
1337         return;
1338
1339 fail:
1340         log_warning_unit(UNIT(s)->id,
1341                          "%s failed to kill processes: %s",
1342                          UNIT(s)->id, strerror(-r));
1343
1344         if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1345                 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1346         else
1347                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1348 }
1349
1350 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1351         int r;
1352         assert(s);
1353
1354         if (f != SOCKET_SUCCESS)
1355                 s->result = f;
1356
1357         socket_unwatch_control_pid(s);
1358
1359         s->control_command_id = SOCKET_EXEC_STOP_PRE;
1360
1361         if ((s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE])) {
1362                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1363                         goto fail;
1364
1365                 socket_set_state(s, SOCKET_STOP_PRE);
1366         } else
1367                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1368
1369         return;
1370
1371 fail:
1372         log_warning_unit(UNIT(s)->id,
1373                          "%s failed to run 'stop-pre' task: %s",
1374                          UNIT(s)->id, strerror(-r));
1375         socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1376 }
1377
1378 static void socket_enter_listening(Socket *s) {
1379         int r;
1380         assert(s);
1381
1382         r = socket_watch_fds(s);
1383         if (r < 0) {
1384                 log_warning_unit(UNIT(s)->id,
1385                                  "%s failed to watch sockets: %s",
1386                                  UNIT(s)->id, strerror(-r));
1387                 goto fail;
1388         }
1389
1390         socket_set_state(s, SOCKET_LISTENING);
1391         return;
1392
1393 fail:
1394         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1395 }
1396
1397 static void socket_enter_start_post(Socket *s) {
1398         int r;
1399         assert(s);
1400
1401         r = socket_open_fds(s);
1402         if (r < 0) {
1403                 log_warning_unit(UNIT(s)->id,
1404                                  "%s failed to listen on sockets: %s",
1405                                  UNIT(s)->id, strerror(-r));
1406                 goto fail;
1407         }
1408
1409         socket_unwatch_control_pid(s);
1410
1411         s->control_command_id = SOCKET_EXEC_START_POST;
1412
1413         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1414                 r = socket_spawn(s, s->control_command, &s->control_pid);
1415                 if (r < 0) {
1416                         log_warning_unit(UNIT(s)->id,
1417                                          "%s failed to run 'start-post' task: %s",
1418                                          UNIT(s)->id, strerror(-r));
1419                         goto fail;
1420                 }
1421
1422                 socket_set_state(s, SOCKET_START_POST);
1423         } else
1424                 socket_enter_listening(s);
1425
1426         return;
1427
1428 fail:
1429         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1430 }
1431
1432 static void socket_enter_start_pre(Socket *s) {
1433         int r;
1434         assert(s);
1435
1436         socket_unwatch_control_pid(s);
1437
1438         s->control_command_id = SOCKET_EXEC_START_PRE;
1439
1440         if ((s->control_command = s->exec_command[SOCKET_EXEC_START_PRE])) {
1441                 if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1442                         goto fail;
1443
1444                 socket_set_state(s, SOCKET_START_PRE);
1445         } else
1446                 socket_enter_start_post(s);
1447
1448         return;
1449
1450 fail:
1451         log_warning_unit(UNIT(s)->id,
1452                          "%s failed to run 'start-pre' task: %s",
1453                          UNIT(s)->id, strerror(-r));
1454         socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1455 }
1456
1457 static void socket_enter_running(Socket *s, int cfd) {
1458         int r;
1459         DBusError error;
1460
1461         assert(s);
1462         dbus_error_init(&error);
1463
1464         /* We don't take connections anymore if we are supposed to
1465          * shut down anyway */
1466         if (unit_stop_pending(UNIT(s))) {
1467                 log_debug_unit(UNIT(s)->id,
1468                                "Suppressing connection request on %s since unit stop is scheduled.",
1469                                UNIT(s)->id);
1470
1471                 if (cfd >= 0)
1472                         close_nointr_nofail(cfd);
1473                 else  {
1474                         /* Flush all sockets by closing and reopening them */
1475                         socket_close_fds(s);
1476
1477                         r = socket_watch_fds(s);
1478                         if (r < 0) {
1479                                 log_warning_unit(UNIT(s)->id,
1480                                                  "%s failed to watch sockets: %s",
1481                                                  UNIT(s)->id, strerror(-r));
1482                                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1483                         }
1484                 }
1485
1486                 return;
1487         }
1488
1489         if (cfd < 0) {
1490                 Iterator i;
1491                 Unit *u;
1492                 bool pending = false;
1493
1494                 /* If there's already a start pending don't bother to
1495                  * do anything */
1496                 SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1497                         if (unit_active_or_pending(u)) {
1498                                 pending = true;
1499                                 break;
1500                         }
1501
1502                 if (!pending) {
1503                         r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1504                         if (r < 0)
1505                                 goto fail;
1506                 }
1507
1508                 socket_set_state(s, SOCKET_RUNNING);
1509         } else {
1510                 char *prefix, *instance = NULL, *name;
1511                 Service *service;
1512
1513                 if (s->n_connections >= s->max_connections) {
1514                         log_warning_unit(UNIT(s)->id,
1515                                          "%s: Too many incoming connections (%u)",
1516                                          UNIT(s)->id, s->n_connections);
1517                         close_nointr_nofail(cfd);
1518                         return;
1519                 }
1520
1521                 r = socket_instantiate_service(s);
1522                 if (r < 0)
1523                         goto fail;
1524
1525                 r = instance_from_socket(cfd, s->n_accepted, &instance);
1526                 if (r < 0) {
1527                         if (r != -ENOTCONN)
1528                                 goto fail;
1529
1530                         /* ENOTCONN is legitimate if TCP RST was received.
1531                          * This connection is over, but the socket unit lives on. */
1532                         close_nointr_nofail(cfd);
1533                         return;
1534                 }
1535
1536                 prefix = unit_name_to_prefix(UNIT(s)->id);
1537                 if (!prefix) {
1538                         free(instance);
1539                         r = -ENOMEM;
1540                         goto fail;
1541                 }
1542
1543                 name = unit_name_build(prefix, instance, ".service");
1544                 free(prefix);
1545                 free(instance);
1546
1547                 if (!name) {
1548                         r = -ENOMEM;
1549                         goto fail;
1550                 }
1551
1552                 r = unit_add_name(UNIT_DEREF(s->service), name);
1553                 if (r < 0) {
1554                         free(name);
1555                         goto fail;
1556                 }
1557
1558                 service = SERVICE(UNIT_DEREF(s->service));
1559                 unit_ref_unset(&s->service);
1560                 s->n_accepted ++;
1561
1562                 UNIT(service)->no_gc = false;
1563
1564                 unit_choose_id(UNIT(service), name);
1565                 free(name);
1566
1567                 r = service_set_socket_fd(service, cfd, s);
1568                 if (r < 0)
1569                         goto fail;
1570
1571                 cfd = -1;
1572                 s->n_connections ++;
1573
1574                 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1575                 if (r < 0)
1576                         goto fail;
1577
1578                 /* Notify clients about changed counters */
1579                 unit_add_to_dbus_queue(UNIT(s));
1580         }
1581
1582         return;
1583
1584 fail:
1585         log_warning_unit(UNIT(s)->id,
1586                          "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1587                          UNIT(s)->id,
1588                          cfd >= 0 ? "template" : "non-template",
1589                          bus_error(&error, r));
1590         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1591
1592         if (cfd >= 0)
1593                 close_nointr_nofail(cfd);
1594
1595         dbus_error_free(&error);
1596 }
1597
1598 static void socket_run_next(Socket *s) {
1599         int r;
1600
1601         assert(s);
1602         assert(s->control_command);
1603         assert(s->control_command->command_next);
1604
1605         socket_unwatch_control_pid(s);
1606
1607         s->control_command = s->control_command->command_next;
1608
1609         if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1610                 goto fail;
1611
1612         return;
1613
1614 fail:
1615         log_warning_unit(UNIT(s)->id,
1616                          "%s failed to run next task: %s",
1617                          UNIT(s)->id, strerror(-r));
1618
1619         if (s->state == SOCKET_START_POST)
1620                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1621         else if (s->state == SOCKET_STOP_POST)
1622                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1623         else
1624                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1625 }
1626
1627 static int socket_start(Unit *u) {
1628         Socket *s = SOCKET(u);
1629
1630         assert(s);
1631
1632         /* We cannot fulfill this request right now, try again later
1633          * please! */
1634         if (s->state == SOCKET_STOP_PRE ||
1635             s->state == SOCKET_STOP_PRE_SIGKILL ||
1636             s->state == SOCKET_STOP_PRE_SIGTERM ||
1637             s->state == SOCKET_STOP_POST ||
1638             s->state == SOCKET_FINAL_SIGTERM ||
1639             s->state == SOCKET_FINAL_SIGKILL)
1640                 return -EAGAIN;
1641
1642         if (s->state == SOCKET_START_PRE ||
1643             s->state == SOCKET_START_POST)
1644                 return 0;
1645
1646         /* Cannot run this without the service being around */
1647         if (UNIT_ISSET(s->service)) {
1648                 Service *service;
1649
1650                 service = SERVICE(UNIT_DEREF(s->service));
1651
1652                 if (UNIT(service)->load_state != UNIT_LOADED) {
1653                         log_error_unit(u->id,
1654                                        "Socket service %s not loaded, refusing.",
1655                                        UNIT(service)->id);
1656                         return -ENOENT;
1657                 }
1658
1659                 /* If the service is already active we cannot start the
1660                  * socket */
1661                 if (service->state != SERVICE_DEAD &&
1662                     service->state != SERVICE_FAILED &&
1663                     service->state != SERVICE_AUTO_RESTART) {
1664                         log_error_unit(u->id,
1665                                        "Socket service %s already active, refusing.",
1666                                        UNIT(service)->id);
1667                         return -EBUSY;
1668                 }
1669
1670 #ifdef HAVE_SYSV_COMPAT
1671                 if (service->is_sysv) {
1672                         log_error_unit(u->id,
1673                                        "Using SysV services for socket activation is not supported. Refusing.");
1674                         return -ENOENT;
1675                 }
1676 #endif
1677         }
1678
1679         assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1680
1681         s->result = SOCKET_SUCCESS;
1682         socket_enter_start_pre(s);
1683         return 0;
1684 }
1685
1686 static int socket_stop(Unit *u) {
1687         Socket *s = SOCKET(u);
1688
1689         assert(s);
1690
1691         /* Already on it */
1692         if (s->state == SOCKET_STOP_PRE ||
1693             s->state == SOCKET_STOP_PRE_SIGTERM ||
1694             s->state == SOCKET_STOP_PRE_SIGKILL ||
1695             s->state == SOCKET_STOP_POST ||
1696             s->state == SOCKET_FINAL_SIGTERM ||
1697             s->state == SOCKET_FINAL_SIGKILL)
1698                 return 0;
1699
1700         /* If there's already something running we go directly into
1701          * kill mode. */
1702         if (s->state == SOCKET_START_PRE ||
1703             s->state == SOCKET_START_POST) {
1704                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1705                 return -EAGAIN;
1706         }
1707
1708         assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1709
1710         socket_enter_stop_pre(s, SOCKET_SUCCESS);
1711         return 0;
1712 }
1713
1714 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1715         Socket *s = SOCKET(u);
1716         SocketPort *p;
1717         int r;
1718
1719         assert(u);
1720         assert(f);
1721         assert(fds);
1722
1723         unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1724         unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1725         unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1726
1727         if (s->control_pid > 0)
1728                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1729
1730         if (s->control_command_id >= 0)
1731                 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1732
1733         LIST_FOREACH(port, p, s->ports) {
1734                 int copy;
1735
1736                 if (p->fd < 0)
1737                         continue;
1738
1739                 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1740                         return copy;
1741
1742                 if (p->type == SOCKET_SOCKET) {
1743                         char *t;
1744
1745                         r = socket_address_print(&p->address, &t);
1746                         if (r < 0)
1747                                 return r;
1748
1749                         if (socket_address_family(&p->address) == AF_NETLINK)
1750                                 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1751                         else
1752                                 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1753                         free(t);
1754                 } else if (p->type == SOCKET_SPECIAL)
1755                         unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1756                 else if (p->type == SOCKET_MQUEUE)
1757                         unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1758                 else {
1759                         assert(p->type == SOCKET_FIFO);
1760                         unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1761                 }
1762         }
1763
1764         exec_context_serialize(&s->exec_context, UNIT(s), f);
1765
1766         return 0;
1767 }
1768
1769 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1770         Socket *s = SOCKET(u);
1771
1772         assert(u);
1773         assert(key);
1774         assert(value);
1775         assert(fds);
1776
1777         if (streq(key, "state")) {
1778                 SocketState state;
1779
1780                 state = socket_state_from_string(value);
1781                 if (state < 0)
1782                         log_debug_unit(u->id,
1783                                        "Failed to parse state value %s", value);
1784                 else
1785                         s->deserialized_state = state;
1786         } else if (streq(key, "result")) {
1787                 SocketResult f;
1788
1789                 f = socket_result_from_string(value);
1790                 if (f < 0)
1791                         log_debug_unit(u->id,
1792                                        "Failed to parse result value %s", value);
1793                 else if (f != SOCKET_SUCCESS)
1794                         s->result = f;
1795
1796         } else if (streq(key, "n-accepted")) {
1797                 unsigned k;
1798
1799                 if (safe_atou(value, &k) < 0)
1800                         log_debug_unit(u->id,
1801                                        "Failed to parse n-accepted value %s", value);
1802                 else
1803                         s->n_accepted += k;
1804         } else if (streq(key, "control-pid")) {
1805                 pid_t pid;
1806
1807                 if (parse_pid(value, &pid) < 0)
1808                         log_debug_unit(u->id,
1809                                        "Failed to parse control-pid value %s", value);
1810                 else
1811                         s->control_pid = pid;
1812         } else if (streq(key, "control-command")) {
1813                 SocketExecCommand id;
1814
1815                 id = socket_exec_command_from_string(value);
1816                 if (id < 0)
1817                         log_debug_unit(u->id,
1818                                        "Failed to parse exec-command value %s", value);
1819                 else {
1820                         s->control_command_id = id;
1821                         s->control_command = s->exec_command[id];
1822                 }
1823         } else if (streq(key, "fifo")) {
1824                 int fd, skip = 0;
1825                 SocketPort *p;
1826
1827                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1828                         log_debug_unit(u->id,
1829                                        "Failed to parse fifo value %s", value);
1830                 else {
1831
1832                         LIST_FOREACH(port, p, s->ports)
1833                                 if (p->type == SOCKET_FIFO &&
1834                                     streq_ptr(p->path, value+skip))
1835                                         break;
1836
1837                         if (p) {
1838                                 if (p->fd >= 0)
1839                                         close_nointr_nofail(p->fd);
1840                                 p->fd = fdset_remove(fds, fd);
1841                         }
1842                 }
1843
1844         } else if (streq(key, "special")) {
1845                 int fd, skip = 0;
1846                 SocketPort *p;
1847
1848                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1849                         log_debug_unit(u->id,
1850                                        "Failed to parse special value %s", value);
1851                 else {
1852
1853                         LIST_FOREACH(port, p, s->ports)
1854                                 if (p->type == SOCKET_SPECIAL &&
1855                                     streq_ptr(p->path, value+skip))
1856                                         break;
1857
1858                         if (p) {
1859                                 if (p->fd >= 0)
1860                                         close_nointr_nofail(p->fd);
1861                                 p->fd = fdset_remove(fds, fd);
1862                         }
1863                 }
1864
1865         } else if (streq(key, "mqueue")) {
1866                 int fd, skip = 0;
1867                 SocketPort *p;
1868
1869                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1870                         log_debug_unit(u->id,
1871                                        "Failed to parse mqueue value %s", value);
1872                 else {
1873
1874                         LIST_FOREACH(port, p, s->ports)
1875                                 if (p->type == SOCKET_MQUEUE &&
1876                                     streq_ptr(p->path, value+skip))
1877                                         break;
1878
1879                         if (p) {
1880                                 if (p->fd >= 0)
1881                                         close_nointr_nofail(p->fd);
1882                                 p->fd = fdset_remove(fds, fd);
1883                         }
1884                 }
1885
1886         } else if (streq(key, "socket")) {
1887                 int fd, type, skip = 0;
1888                 SocketPort *p;
1889
1890                 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1891                         log_debug_unit(u->id,
1892                                        "Failed to parse socket value %s", value);
1893                 else {
1894
1895                         LIST_FOREACH(port, p, s->ports)
1896                                 if (socket_address_is(&p->address, value+skip, type))
1897                                         break;
1898
1899                         if (p) {
1900                                 if (p->fd >= 0)
1901                                         close_nointr_nofail(p->fd);
1902                                 p->fd = fdset_remove(fds, fd);
1903                         }
1904                 }
1905
1906         } else if (streq(key, "netlink")) {
1907                 int fd, skip = 0;
1908                 SocketPort *p;
1909
1910                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1911                         log_debug_unit(u->id,
1912                                        "Failed to parse socket value %s", value);
1913                 else {
1914
1915                         LIST_FOREACH(port, p, s->ports)
1916                                 if (socket_address_is_netlink(&p->address, value+skip))
1917                                         break;
1918
1919                         if (p) {
1920                                 if (p->fd >= 0)
1921                                         close_nointr_nofail(p->fd);
1922                                 p->fd = fdset_remove(fds, fd);
1923                         }
1924                 }
1925         } else if (streq(key, "tmp-dir")) {
1926                 char *t;
1927
1928                 t = strdup(value);
1929                 if (!t)
1930                         return log_oom();
1931
1932                 s->exec_context.tmp_dir = t;
1933         } else if (streq(key, "var-tmp-dir")) {
1934                 char *t;
1935
1936                 t = strdup(value);
1937                 if (!t)
1938                         return log_oom();
1939
1940                 s->exec_context.var_tmp_dir = t;
1941         } else
1942                 log_debug_unit(UNIT(s)->id,
1943                                "Unknown serialization key '%s'", key);
1944
1945         return 0;
1946 }
1947
1948 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1949         Socket *s = SOCKET(u);
1950         SocketPort *p;
1951
1952         assert(u);
1953
1954         LIST_FOREACH(port, p, s->ports) {
1955                 Iterator i;
1956                 int fd;
1957
1958                 if (p->type != SOCKET_SOCKET)
1959                         continue;
1960
1961                 if (p->fd >= 0)
1962                         continue;
1963
1964                 FDSET_FOREACH(fd, fds, i) {
1965                         if (socket_address_matches_fd(&p->address, fd)) {
1966                                 p->fd = fdset_remove(fds, fd);
1967                                 s->deserialized_state = SOCKET_LISTENING;
1968                                 break;
1969                         }
1970                 }
1971         }
1972
1973         return 0;
1974 }
1975
1976 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1977         assert(u);
1978
1979         return state_translation_table[SOCKET(u)->state];
1980 }
1981
1982 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1983         assert(u);
1984
1985         return socket_state_to_string(SOCKET(u)->state);
1986 }
1987
1988 const char* socket_port_type_to_string(SocketPort *p) {
1989
1990         assert(p);
1991
1992         switch (p->type) {
1993                 case SOCKET_SOCKET:
1994                         switch (p->address.type) {
1995                                 case SOCK_STREAM: return "Stream";
1996                                 case SOCK_DGRAM: return "Datagram";
1997                                 case SOCK_SEQPACKET: return "SequentialPacket";
1998                                 case SOCK_RAW:
1999                                         if (socket_address_family(&p->address) == AF_NETLINK)
2000                                                 return "Netlink";
2001                                 default: return "Invalid";
2002                         }
2003                 case SOCKET_SPECIAL: return "Special";
2004                 case SOCKET_MQUEUE: return "MessageQueue";
2005                 case SOCKET_FIFO: return "FIFO";
2006                 default: return NULL;
2007         }
2008 }
2009
2010 _pure_ static bool socket_check_gc(Unit *u) {
2011         Socket *s = SOCKET(u);
2012
2013         assert(u);
2014
2015         return s->n_connections > 0;
2016 }
2017
2018 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
2019         Socket *s = SOCKET(u);
2020         int cfd = -1;
2021
2022         assert(s);
2023         assert(fd >= 0);
2024
2025         if (s->state != SOCKET_LISTENING)
2026                 return;
2027
2028         log_debug_unit(u->id, "Incoming traffic on %s", u->id);
2029
2030         if (events != EPOLLIN) {
2031
2032                 if (events & EPOLLHUP)
2033                         log_error_unit(u->id,
2034                                        "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
2035                                        u->id);
2036                 else
2037                         log_error_unit(u->id,
2038                                        "%s: Got unexpected poll event (0x%x) on socket.",
2039                                        u->id, events);
2040
2041                 goto fail;
2042         }
2043
2044         if (w->socket_accept) {
2045                 for (;;) {
2046
2047                         cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2048                         if (cfd < 0) {
2049
2050                                 if (errno == EINTR)
2051                                         continue;
2052
2053                                 log_error_unit(u->id,
2054                                                "Failed to accept socket: %m");
2055                                 goto fail;
2056                         }
2057
2058                         break;
2059                 }
2060
2061                 socket_apply_socket_options(s, cfd);
2062         }
2063
2064         socket_enter_running(s, cfd);
2065         return;
2066
2067 fail:
2068         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2069 }
2070
2071 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2072         Socket *s = SOCKET(u);
2073         SocketResult f;
2074
2075         assert(s);
2076         assert(pid >= 0);
2077
2078         if (pid != s->control_pid)
2079                 return;
2080
2081         s->control_pid = 0;
2082
2083         if (is_clean_exit(code, status, NULL))
2084                 f = SOCKET_SUCCESS;
2085         else if (code == CLD_EXITED)
2086                 f = SOCKET_FAILURE_EXIT_CODE;
2087         else if (code == CLD_KILLED)
2088                 f = SOCKET_FAILURE_SIGNAL;
2089         else if (code == CLD_DUMPED)
2090                 f = SOCKET_FAILURE_CORE_DUMP;
2091         else
2092                 assert_not_reached("Unknown code");
2093
2094         if (s->control_command) {
2095                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2096
2097                 if (s->control_command->ignore)
2098                         f = SOCKET_SUCCESS;
2099         }
2100
2101         log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2102                       u->id,
2103                       "%s control process exited, code=%s status=%i",
2104                       u->id, sigchld_code_to_string(code), status);
2105
2106         if (f != SOCKET_SUCCESS)
2107                 s->result = f;
2108
2109         if (s->control_command &&
2110             s->control_command->command_next &&
2111             f == SOCKET_SUCCESS) {
2112
2113                 log_debug_unit(u->id,
2114                                "%s running next command for state %s",
2115                                u->id, socket_state_to_string(s->state));
2116                 socket_run_next(s);
2117         } else {
2118                 s->control_command = NULL;
2119                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2120
2121                 /* No further commands for this step, so let's figure
2122                  * out what to do next */
2123
2124                 log_debug_unit(u->id,
2125                                "%s got final SIGCHLD for state %s",
2126                                u->id, socket_state_to_string(s->state));
2127
2128                 switch (s->state) {
2129
2130                 case SOCKET_START_PRE:
2131                         if (f == SOCKET_SUCCESS)
2132                                 socket_enter_start_post(s);
2133                         else
2134                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2135                         break;
2136
2137                 case SOCKET_START_POST:
2138                         if (f == SOCKET_SUCCESS)
2139                                 socket_enter_listening(s);
2140                         else
2141                                 socket_enter_stop_pre(s, f);
2142                         break;
2143
2144                 case SOCKET_STOP_PRE:
2145                 case SOCKET_STOP_PRE_SIGTERM:
2146                 case SOCKET_STOP_PRE_SIGKILL:
2147                         socket_enter_stop_post(s, f);
2148                         break;
2149
2150                 case SOCKET_STOP_POST:
2151                 case SOCKET_FINAL_SIGTERM:
2152                 case SOCKET_FINAL_SIGKILL:
2153                         socket_enter_dead(s, f);
2154                         break;
2155
2156                 default:
2157                         assert_not_reached("Uh, control process died at wrong time.");
2158                 }
2159         }
2160
2161         /* Notify clients about changed exit status */
2162         unit_add_to_dbus_queue(u);
2163 }
2164
2165 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2166         Socket *s = SOCKET(u);
2167
2168         assert(s);
2169         assert(elapsed == 1);
2170         assert(w == &s->timer_watch);
2171
2172         switch (s->state) {
2173
2174         case SOCKET_START_PRE:
2175                 log_warning_unit(u->id,
2176                                  "%s starting timed out. Terminating.", u->id);
2177                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2178                 break;
2179
2180         case SOCKET_START_POST:
2181                 log_warning_unit(u->id,
2182                                  "%s starting timed out. Stopping.", u->id);
2183                 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2184                 break;
2185
2186         case SOCKET_STOP_PRE:
2187                 log_warning_unit(u->id,
2188                                  "%s stopping timed out. Terminating.", u->id);
2189                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2190                 break;
2191
2192         case SOCKET_STOP_PRE_SIGTERM:
2193                 if (s->kill_context.send_sigkill) {
2194                         log_warning_unit(u->id,
2195                                          "%s stopping timed out. Killing.", u->id);
2196                         socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2197                 } else {
2198                         log_warning_unit(u->id,
2199                                          "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2200                                          u->id);
2201                         socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2202                 }
2203                 break;
2204
2205         case SOCKET_STOP_PRE_SIGKILL:
2206                 log_warning_unit(u->id,
2207                                  "%s still around after SIGKILL. Ignoring.", u->id);
2208                 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2209                 break;
2210
2211         case SOCKET_STOP_POST:
2212                 log_warning_unit(u->id,
2213                                  "%s stopping timed out (2). Terminating.", u->id);
2214                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2215                 break;
2216
2217         case SOCKET_FINAL_SIGTERM:
2218                 if (s->kill_context.send_sigkill) {
2219                         log_warning_unit(u->id,
2220                                          "%s stopping timed out (2). Killing.", u->id);
2221                         socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2222                 } else {
2223                         log_warning_unit(u->id,
2224                                          "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2225                                          u->id);
2226                         socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2227                 }
2228                 break;
2229
2230         case SOCKET_FINAL_SIGKILL:
2231                 log_warning_unit(u->id,
2232                                  "%s still around after SIGKILL (2). Entering failed mode.",
2233                                  u->id);
2234                 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2235                 break;
2236
2237         default:
2238                 assert_not_reached("Timeout at wrong time.");
2239         }
2240 }
2241
2242 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2243         int *rfds;
2244         unsigned rn_fds, k;
2245         SocketPort *p;
2246
2247         assert(s);
2248         assert(fds);
2249         assert(n_fds);
2250
2251         /* Called from the service code for requesting our fds */
2252
2253         rn_fds = 0;
2254         LIST_FOREACH(port, p, s->ports)
2255                 if (p->fd >= 0)
2256                         rn_fds++;
2257
2258         if (rn_fds <= 0) {
2259                 *fds = NULL;
2260                 *n_fds = 0;
2261                 return 0;
2262         }
2263
2264         if (!(rfds = new(int, rn_fds)))
2265                 return -ENOMEM;
2266
2267         k = 0;
2268         LIST_FOREACH(port, p, s->ports)
2269                 if (p->fd >= 0)
2270                         rfds[k++] = p->fd;
2271
2272         assert(k == rn_fds);
2273
2274         *fds = rfds;
2275         *n_fds = rn_fds;
2276
2277         return 0;
2278 }
2279
2280 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2281         assert(s);
2282
2283         /* The service is dead. Dang!
2284          *
2285          * This is strictly for one-instance-for-all-connections
2286          * services. */
2287
2288         if (s->state == SOCKET_RUNNING) {
2289                 log_debug_unit(UNIT(s)->id,
2290                                "%s got notified about service death (failed permanently: %s)",
2291                                UNIT(s)->id, yes_no(failed_permanent));
2292                 if (failed_permanent)
2293                         socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2294                 else
2295                         socket_enter_listening(s);
2296         }
2297 }
2298
2299 void socket_connection_unref(Socket *s) {
2300         assert(s);
2301
2302         /* The service is dead. Yay!
2303          *
2304          * This is strictly for one-instance-per-connection
2305          * services. */
2306
2307         assert(s->n_connections > 0);
2308         s->n_connections--;
2309
2310         log_debug_unit(UNIT(s)->id,
2311                        "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2312 }
2313
2314 static void socket_reset_failed(Unit *u) {
2315         Socket *s = SOCKET(u);
2316
2317         assert(s);
2318
2319         if (s->state == SOCKET_FAILED)
2320                 socket_set_state(s, SOCKET_DEAD);
2321
2322         s->result = SOCKET_SUCCESS;
2323 }
2324
2325 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2326         return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2327 }
2328
2329 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2330         [SOCKET_DEAD] = "dead",
2331         [SOCKET_START_PRE] = "start-pre",
2332         [SOCKET_START_POST] = "start-post",
2333         [SOCKET_LISTENING] = "listening",
2334         [SOCKET_RUNNING] = "running",
2335         [SOCKET_STOP_PRE] = "stop-pre",
2336         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2337         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2338         [SOCKET_STOP_POST] = "stop-post",
2339         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2340         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2341         [SOCKET_FAILED] = "failed"
2342 };
2343
2344 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2345
2346 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2347         [SOCKET_EXEC_START_PRE] = "StartPre",
2348         [SOCKET_EXEC_START_POST] = "StartPost",
2349         [SOCKET_EXEC_STOP_PRE] = "StopPre",
2350         [SOCKET_EXEC_STOP_POST] = "StopPost"
2351 };
2352
2353 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2354
2355 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2356         [SOCKET_SUCCESS] = "success",
2357         [SOCKET_FAILURE_RESOURCES] = "resources",
2358         [SOCKET_FAILURE_TIMEOUT] = "timeout",
2359         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2360         [SOCKET_FAILURE_SIGNAL] = "signal",
2361         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2362         [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2363 };
2364
2365 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2366
2367 const UnitVTable socket_vtable = {
2368         .object_size = sizeof(Socket),
2369
2370         .sections =
2371                 "Unit\0"
2372                 "Socket\0"
2373                 "Install\0",
2374
2375         .private_section = "Socket",
2376         .exec_context_offset = offsetof(Socket, exec_context),
2377         .cgroup_context_offset = offsetof(Socket, cgroup_context),
2378
2379         .init = socket_init,
2380         .done = socket_done,
2381         .load = socket_load,
2382
2383         .kill = socket_kill,
2384
2385         .coldplug = socket_coldplug,
2386
2387         .dump = socket_dump,
2388
2389         .start = socket_start,
2390         .stop = socket_stop,
2391
2392         .serialize = socket_serialize,
2393         .deserialize_item = socket_deserialize_item,
2394         .distribute_fds = socket_distribute_fds,
2395
2396         .active_state = socket_active_state,
2397         .sub_state_to_string = socket_sub_state_to_string,
2398
2399         .check_gc = socket_check_gc,
2400
2401         .fd_event = socket_fd_event,
2402         .sigchld_event = socket_sigchld_event,
2403         .timer_event = socket_timer_event,
2404
2405         .reset_failed = socket_reset_failed,
2406
2407         .bus_interface = "org.freedesktop.systemd1.Socket",
2408         .bus_message_handler = bus_socket_message_handler,
2409         .bus_invalidating_properties =  bus_socket_invalidating_properties,
2410         .bus_set_property = bus_socket_set_property,
2411         .bus_commit_properties = bus_socket_commit_properties,
2412
2413         .status_message_formats = {
2414                 /*.starting_stopping = {
2415                         [0] = "Starting socket %s...",
2416                         [1] = "Stopping socket %s...",
2417                 },*/
2418                 .finished_start_job = {
2419                         [JOB_DONE]       = "Listening on %s.",
2420                         [JOB_FAILED]     = "Failed to listen on %s.",
2421                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
2422                         [JOB_TIMEOUT]    = "Timed out starting %s.",
2423                 },
2424                 .finished_stop_job = {
2425                         [JOB_DONE]       = "Closed %s.",
2426                         [JOB_FAILED]     = "Failed stopping %s.",
2427                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
2428                 },
2429         },
2430 };