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