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)) < 0)
 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                 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
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                         r = -ENOMEM;
1507                         goto fail;
1508                 }
1509
1510                 name = unit_name_build(prefix, instance, ".service");
1511
1512                 if (!name) {
1513                         r = -ENOMEM;
1514                         goto fail;
1515                 }
1516
1517                 r = unit_add_name(UNIT_DEREF(s->service), name);
1518                 if (r < 0)
1519                         goto fail;
1520
1521                 service = SERVICE(UNIT_DEREF(s->service));
1522                 unit_ref_unset(&s->service);
1523                 s->n_accepted ++;
1524
1525                 UNIT(service)->no_gc = false;
1526
1527                 unit_choose_id(UNIT(service), name);
1528
1529                 r = service_set_socket_fd(service, cfd, s);
1530                 if (r < 0)
1531                         goto fail;
1532
1533                 cfd = -1;
1534                 s->n_connections ++;
1535
1536                 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1537                 if (r < 0)
1538                         goto fail;
1539
1540                 /* Notify clients about changed counters */
1541                 unit_add_to_dbus_queue(UNIT(s));
1542         }
1543
1544         return;
1545
1546 fail:
1547         log_warning_unit(UNIT(s)->id,
1548                          "%s failed to queue service startup job (Maybe the service file is missing or not a %s unit?): %s",
1549                          UNIT(s)->id,
1550                          cfd >= 0 ? "template" : "non-template",
1551                          bus_error(&error, r));
1552         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1553
1554         if (cfd >= 0)
1555                 close_nointr_nofail(cfd);
1556
1557         dbus_error_free(&error);
1558 }
1559
1560 static void socket_run_next(Socket *s) {
1561         int r;
1562
1563         assert(s);
1564         assert(s->control_command);
1565         assert(s->control_command->command_next);
1566
1567         socket_unwatch_control_pid(s);
1568
1569         s->control_command = s->control_command->command_next;
1570
1571         if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0)
1572                 goto fail;
1573
1574         return;
1575
1576 fail:
1577         log_warning_unit(UNIT(s)->id,
1578                          "%s failed to run next task: %s",
1579                          UNIT(s)->id, strerror(-r));
1580
1581         if (s->state == SOCKET_START_POST)
1582                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1583         else if (s->state == SOCKET_STOP_POST)
1584                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1585         else
1586                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1587 }
1588
1589 static int socket_start(Unit *u) {
1590         Socket *s = SOCKET(u);
1591
1592         assert(s);
1593
1594         /* We cannot fulfill this request right now, try again later
1595          * please! */
1596         if (s->state == SOCKET_STOP_PRE ||
1597             s->state == SOCKET_STOP_PRE_SIGKILL ||
1598             s->state == SOCKET_STOP_PRE_SIGTERM ||
1599             s->state == SOCKET_STOP_POST ||
1600             s->state == SOCKET_FINAL_SIGTERM ||
1601             s->state == SOCKET_FINAL_SIGKILL)
1602                 return -EAGAIN;
1603
1604         if (s->state == SOCKET_START_PRE ||
1605             s->state == SOCKET_START_POST)
1606                 return 0;
1607
1608         /* Cannot run this without the service being around */
1609         if (UNIT_ISSET(s->service)) {
1610                 Service *service;
1611
1612                 service = SERVICE(UNIT_DEREF(s->service));
1613
1614                 if (UNIT(service)->load_state != UNIT_LOADED) {
1615                         log_error_unit(u->id,
1616                                        "Socket service %s not loaded, refusing.",
1617                                        UNIT(service)->id);
1618                         return -ENOENT;
1619                 }
1620
1621                 /* If the service is already active we cannot start the
1622                  * socket */
1623                 if (service->state != SERVICE_DEAD &&
1624                     service->state != SERVICE_FAILED &&
1625                     service->state != SERVICE_AUTO_RESTART) {
1626                         log_error_unit(u->id,
1627                                        "Socket service %s already active, refusing.",
1628                                        UNIT(service)->id);
1629                         return -EBUSY;
1630                 }
1631
1632 #ifdef HAVE_SYSV_COMPAT
1633                 if (service->is_sysv) {
1634                         log_error_unit(u->id,
1635                                        "Using SysV services for socket activation is not supported. Refusing.");
1636                         return -ENOENT;
1637                 }
1638 #endif
1639         }
1640
1641         assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1642
1643         s->result = SOCKET_SUCCESS;
1644         socket_enter_start_pre(s);
1645         return 0;
1646 }
1647
1648 static int socket_stop(Unit *u) {
1649         Socket *s = SOCKET(u);
1650
1651         assert(s);
1652
1653         /* Already on it */
1654         if (s->state == SOCKET_STOP_PRE ||
1655             s->state == SOCKET_STOP_PRE_SIGTERM ||
1656             s->state == SOCKET_STOP_PRE_SIGKILL ||
1657             s->state == SOCKET_STOP_POST ||
1658             s->state == SOCKET_FINAL_SIGTERM ||
1659             s->state == SOCKET_FINAL_SIGKILL)
1660                 return 0;
1661
1662         /* If there's already something running we go directly into
1663          * kill mode. */
1664         if (s->state == SOCKET_START_PRE ||
1665             s->state == SOCKET_START_POST) {
1666                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1667                 return -EAGAIN;
1668         }
1669
1670         assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1671
1672         socket_enter_stop_pre(s, SOCKET_SUCCESS);
1673         return 0;
1674 }
1675
1676 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1677         Socket *s = SOCKET(u);
1678         SocketPort *p;
1679         int r;
1680
1681         assert(u);
1682         assert(f);
1683         assert(fds);
1684
1685         unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1686         unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1687         unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1688
1689         if (s->control_pid > 0)
1690                 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
1691
1692         if (s->control_command_id >= 0)
1693                 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1694
1695         LIST_FOREACH(port, p, s->ports) {
1696                 int copy;
1697
1698                 if (p->fd < 0)
1699                         continue;
1700
1701                 if ((copy = fdset_put_dup(fds, p->fd)) < 0)
1702                         return copy;
1703
1704                 if (p->type == SOCKET_SOCKET) {
1705                         char *t;
1706
1707                         r = socket_address_print(&p->address, &t);
1708                         if (r < 0)
1709                                 return r;
1710
1711                         if (socket_address_family(&p->address) == AF_NETLINK)
1712                                 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1713                         else
1714                                 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1715                         free(t);
1716                 } else if (p->type == SOCKET_SPECIAL)
1717                         unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1718                 else if (p->type == SOCKET_MQUEUE)
1719                         unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1720                 else {
1721                         assert(p->type == SOCKET_FIFO);
1722                         unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1723                 }
1724         }
1725
1726         exec_context_serialize(&s->exec_context, UNIT(s), f);
1727
1728         return 0;
1729 }
1730
1731 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1732         Socket *s = SOCKET(u);
1733
1734         assert(u);
1735         assert(key);
1736         assert(value);
1737         assert(fds);
1738
1739         if (streq(key, "state")) {
1740                 SocketState state;
1741
1742                 state = socket_state_from_string(value);
1743                 if (state < 0)
1744                         log_debug_unit(u->id,
1745                                        "Failed to parse state value %s", value);
1746                 else
1747                         s->deserialized_state = state;
1748         } else if (streq(key, "result")) {
1749                 SocketResult f;
1750
1751                 f = socket_result_from_string(value);
1752                 if (f < 0)
1753                         log_debug_unit(u->id,
1754                                        "Failed to parse result value %s", value);
1755                 else if (f != SOCKET_SUCCESS)
1756                         s->result = f;
1757
1758         } else if (streq(key, "n-accepted")) {
1759                 unsigned k;
1760
1761                 if (safe_atou(value, &k) < 0)
1762                         log_debug_unit(u->id,
1763                                        "Failed to parse n-accepted value %s", value);
1764                 else
1765                         s->n_accepted += k;
1766         } else if (streq(key, "control-pid")) {
1767                 pid_t pid;
1768
1769                 if (parse_pid(value, &pid) < 0)
1770                         log_debug_unit(u->id,
1771                                        "Failed to parse control-pid value %s", value);
1772                 else
1773                         s->control_pid = pid;
1774         } else if (streq(key, "control-command")) {
1775                 SocketExecCommand id;
1776
1777                 id = socket_exec_command_from_string(value);
1778                 if (id < 0)
1779                         log_debug_unit(u->id,
1780                                        "Failed to parse exec-command value %s", value);
1781                 else {
1782                         s->control_command_id = id;
1783                         s->control_command = s->exec_command[id];
1784                 }
1785         } else if (streq(key, "fifo")) {
1786                 int fd, skip = 0;
1787                 SocketPort *p;
1788
1789                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1790                         log_debug_unit(u->id,
1791                                        "Failed to parse fifo value %s", value);
1792                 else {
1793
1794                         LIST_FOREACH(port, p, s->ports)
1795                                 if (p->type == SOCKET_FIFO &&
1796                                     streq_ptr(p->path, value+skip))
1797                                         break;
1798
1799                         if (p) {
1800                                 if (p->fd >= 0)
1801                                         close_nointr_nofail(p->fd);
1802                                 p->fd = fdset_remove(fds, fd);
1803                         }
1804                 }
1805
1806         } else if (streq(key, "special")) {
1807                 int fd, skip = 0;
1808                 SocketPort *p;
1809
1810                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1811                         log_debug_unit(u->id,
1812                                        "Failed to parse special value %s", value);
1813                 else {
1814
1815                         LIST_FOREACH(port, p, s->ports)
1816                                 if (p->type == SOCKET_SPECIAL &&
1817                                     streq_ptr(p->path, value+skip))
1818                                         break;
1819
1820                         if (p) {
1821                                 if (p->fd >= 0)
1822                                         close_nointr_nofail(p->fd);
1823                                 p->fd = fdset_remove(fds, fd);
1824                         }
1825                 }
1826
1827         } else if (streq(key, "mqueue")) {
1828                 int fd, skip = 0;
1829                 SocketPort *p;
1830
1831                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1832                         log_debug_unit(u->id,
1833                                        "Failed to parse mqueue value %s", value);
1834                 else {
1835
1836                         LIST_FOREACH(port, p, s->ports)
1837                                 if (p->type == SOCKET_MQUEUE &&
1838                                     streq_ptr(p->path, value+skip))
1839                                         break;
1840
1841                         if (p) {
1842                                 if (p->fd >= 0)
1843                                         close_nointr_nofail(p->fd);
1844                                 p->fd = fdset_remove(fds, fd);
1845                         }
1846                 }
1847
1848         } else if (streq(key, "socket")) {
1849                 int fd, type, skip = 0;
1850                 SocketPort *p;
1851
1852                 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1853                         log_debug_unit(u->id,
1854                                        "Failed to parse socket value %s", value);
1855                 else {
1856
1857                         LIST_FOREACH(port, p, s->ports)
1858                                 if (socket_address_is(&p->address, value+skip, type))
1859                                         break;
1860
1861                         if (p) {
1862                                 if (p->fd >= 0)
1863                                         close_nointr_nofail(p->fd);
1864                                 p->fd = fdset_remove(fds, fd);
1865                         }
1866                 }
1867
1868         } else if (streq(key, "netlink")) {
1869                 int fd, skip = 0;
1870                 SocketPort *p;
1871
1872                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1873                         log_debug_unit(u->id,
1874                                        "Failed to parse socket value %s", value);
1875                 else {
1876
1877                         LIST_FOREACH(port, p, s->ports)
1878                                 if (socket_address_is_netlink(&p->address, value+skip))
1879                                         break;
1880
1881                         if (p) {
1882                                 if (p->fd >= 0)
1883                                         close_nointr_nofail(p->fd);
1884                                 p->fd = fdset_remove(fds, fd);
1885                         }
1886                 }
1887         } else if (streq(key, "tmp-dir")) {
1888                 char *t;
1889
1890                 t = strdup(value);
1891                 if (!t)
1892                         return log_oom();
1893
1894                 s->exec_context.tmp_dir = t;
1895         } else if (streq(key, "var-tmp-dir")) {
1896                 char *t;
1897
1898                 t = strdup(value);
1899                 if (!t)
1900                         return log_oom();
1901
1902                 s->exec_context.var_tmp_dir = t;
1903         } else
1904                 log_debug_unit(UNIT(s)->id,
1905                                "Unknown serialization key '%s'", key);
1906
1907         return 0;
1908 }
1909
1910 static int socket_distribute_fds(Unit *u, FDSet *fds) {
1911         Socket *s = SOCKET(u);
1912         SocketPort *p;
1913
1914         assert(u);
1915
1916         LIST_FOREACH(port, p, s->ports) {
1917                 Iterator i;
1918                 int fd;
1919
1920                 if (p->type != SOCKET_SOCKET)
1921                         continue;
1922
1923                 if (p->fd >= 0)
1924                         continue;
1925
1926                 FDSET_FOREACH(fd, fds, i) {
1927                         if (socket_address_matches_fd(&p->address, fd)) {
1928                                 p->fd = fdset_remove(fds, fd);
1929                                 s->deserialized_state = SOCKET_LISTENING;
1930                                 break;
1931                         }
1932                 }
1933         }
1934
1935         return 0;
1936 }
1937
1938 _pure_ static UnitActiveState socket_active_state(Unit *u) {
1939         assert(u);
1940
1941         return state_translation_table[SOCKET(u)->state];
1942 }
1943
1944 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
1945         assert(u);
1946
1947         return socket_state_to_string(SOCKET(u)->state);
1948 }
1949
1950 const char* socket_port_type_to_string(SocketPort *p) {
1951
1952         assert(p);
1953
1954         switch (p->type) {
1955                 case SOCKET_SOCKET:
1956                         switch (p->address.type) {
1957                                 case SOCK_STREAM: return "Stream";
1958                                 case SOCK_DGRAM: return "Datagram";
1959                                 case SOCK_SEQPACKET: return "SequentialPacket";
1960                                 case SOCK_RAW:
1961                                         if (socket_address_family(&p->address) == AF_NETLINK)
1962                                                 return "Netlink";
1963                                 default: return "Invalid";
1964                         }
1965                 case SOCKET_SPECIAL: return "Special";
1966                 case SOCKET_MQUEUE: return "MessageQueue";
1967                 case SOCKET_FIFO: return "FIFO";
1968                 default: return NULL;
1969         }
1970 }
1971
1972 _pure_ static bool socket_check_gc(Unit *u) {
1973         Socket *s = SOCKET(u);
1974
1975         assert(u);
1976
1977         return s->n_connections > 0;
1978 }
1979
1980 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1981         Socket *s = SOCKET(u);
1982         int cfd = -1;
1983
1984         assert(s);
1985         assert(fd >= 0);
1986
1987         if (s->state != SOCKET_LISTENING)
1988                 return;
1989
1990         log_debug_unit(u->id, "Incoming traffic on %s", u->id);
1991
1992         if (events != EPOLLIN) {
1993
1994                 if (events & EPOLLHUP)
1995                         log_error_unit(u->id,
1996                                        "%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.",
1997                                        u->id);
1998                 else
1999                         log_error_unit(u->id,
2000                                        "%s: Got unexpected poll event (0x%x) on socket.",
2001                                        u->id, events);
2002
2003                 goto fail;
2004         }
2005
2006         if (w->socket_accept) {
2007                 for (;;) {
2008
2009                         cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2010                         if (cfd < 0) {
2011
2012                                 if (errno == EINTR)
2013                                         continue;
2014
2015                                 log_error_unit(u->id,
2016                                                "Failed to accept socket: %m");
2017                                 goto fail;
2018                         }
2019
2020                         break;
2021                 }
2022
2023                 socket_apply_socket_options(s, cfd);
2024         }
2025
2026         socket_enter_running(s, cfd);
2027         return;
2028
2029 fail:
2030         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
2031 }
2032
2033 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2034         Socket *s = SOCKET(u);
2035         SocketResult f;
2036
2037         assert(s);
2038         assert(pid >= 0);
2039
2040         if (pid != s->control_pid)
2041                 return;
2042
2043         s->control_pid = 0;
2044
2045         if (is_clean_exit(code, status, NULL))
2046                 f = SOCKET_SUCCESS;
2047         else if (code == CLD_EXITED)
2048                 f = SOCKET_FAILURE_EXIT_CODE;
2049         else if (code == CLD_KILLED)
2050                 f = SOCKET_FAILURE_SIGNAL;
2051         else if (code == CLD_DUMPED)
2052                 f = SOCKET_FAILURE_CORE_DUMP;
2053         else
2054                 assert_not_reached("Unknown code");
2055
2056         if (s->control_command) {
2057                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2058
2059                 if (s->control_command->ignore)
2060                         f = SOCKET_SUCCESS;
2061         }
2062
2063         log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2064                       u->id,
2065                       "%s control process exited, code=%s status=%i",
2066                       u->id, sigchld_code_to_string(code), status);
2067
2068         if (f != SOCKET_SUCCESS)
2069                 s->result = f;
2070
2071         if (s->control_command &&
2072             s->control_command->command_next &&
2073             f == SOCKET_SUCCESS) {
2074
2075                 log_debug_unit(u->id,
2076                                "%s running next command for state %s",
2077                                u->id, socket_state_to_string(s->state));
2078                 socket_run_next(s);
2079         } else {
2080                 s->control_command = NULL;
2081                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2082
2083                 /* No further commands for this step, so let's figure
2084                  * out what to do next */
2085
2086                 log_debug_unit(u->id,
2087                                "%s got final SIGCHLD for state %s",
2088                                u->id, socket_state_to_string(s->state));
2089
2090                 switch (s->state) {
2091
2092                 case SOCKET_START_PRE:
2093                         if (f == SOCKET_SUCCESS)
2094                                 socket_enter_start_post(s);
2095                         else
2096                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2097                         break;
2098
2099                 case SOCKET_START_POST:
2100                         if (f == SOCKET_SUCCESS)
2101                                 socket_enter_listening(s);
2102                         else
2103                                 socket_enter_stop_pre(s, f);
2104                         break;
2105
2106                 case SOCKET_STOP_PRE:
2107                 case SOCKET_STOP_PRE_SIGTERM:
2108                 case SOCKET_STOP_PRE_SIGKILL:
2109                         socket_enter_stop_post(s, f);
2110                         break;
2111
2112                 case SOCKET_STOP_POST:
2113                 case SOCKET_FINAL_SIGTERM:
2114                 case SOCKET_FINAL_SIGKILL:
2115                         socket_enter_dead(s, f);
2116                         break;
2117
2118                 default:
2119                         assert_not_reached("Uh, control process died at wrong time.");
2120                 }
2121         }
2122
2123         /* Notify clients about changed exit status */
2124         unit_add_to_dbus_queue(u);
2125 }
2126
2127 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2128         Socket *s = SOCKET(u);
2129
2130         assert(s);
2131         assert(elapsed == 1);
2132         assert(w == &s->timer_watch);
2133
2134         switch (s->state) {
2135
2136         case SOCKET_START_PRE:
2137                 log_warning_unit(u->id,
2138                                  "%s starting timed out. Terminating.", u->id);
2139                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2140                 break;
2141
2142         case SOCKET_START_POST:
2143                 log_warning_unit(u->id,
2144                                  "%s starting timed out. Stopping.", u->id);
2145                 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2146                 break;
2147
2148         case SOCKET_STOP_PRE:
2149                 log_warning_unit(u->id,
2150                                  "%s stopping timed out. Terminating.", u->id);
2151                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2152                 break;
2153
2154         case SOCKET_STOP_PRE_SIGTERM:
2155                 if (s->kill_context.send_sigkill) {
2156                         log_warning_unit(u->id,
2157                                          "%s stopping timed out. Killing.", u->id);
2158                         socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2159                 } else {
2160                         log_warning_unit(u->id,
2161                                          "%s stopping timed out. Skipping SIGKILL. Ignoring.",
2162                                          u->id);
2163                         socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2164                 }
2165                 break;
2166
2167         case SOCKET_STOP_PRE_SIGKILL:
2168                 log_warning_unit(u->id,
2169                                  "%s still around after SIGKILL. Ignoring.", u->id);
2170                 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2171                 break;
2172
2173         case SOCKET_STOP_POST:
2174                 log_warning_unit(u->id,
2175                                  "%s stopping timed out (2). Terminating.", u->id);
2176                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2177                 break;
2178
2179         case SOCKET_FINAL_SIGTERM:
2180                 if (s->kill_context.send_sigkill) {
2181                         log_warning_unit(u->id,
2182                                          "%s stopping timed out (2). Killing.", u->id);
2183                         socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2184                 } else {
2185                         log_warning_unit(u->id,
2186                                          "%s stopping timed out (2). Skipping SIGKILL. Ignoring.",
2187                                          u->id);
2188                         socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2189                 }
2190                 break;
2191
2192         case SOCKET_FINAL_SIGKILL:
2193                 log_warning_unit(u->id,
2194                                  "%s still around after SIGKILL (2). Entering failed mode.",
2195                                  u->id);
2196                 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2197                 break;
2198
2199         default:
2200                 assert_not_reached("Timeout at wrong time.");
2201         }
2202 }
2203
2204 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2205         int *rfds;
2206         unsigned rn_fds, k;
2207         SocketPort *p;
2208
2209         assert(s);
2210         assert(fds);
2211         assert(n_fds);
2212
2213         /* Called from the service code for requesting our fds */
2214
2215         rn_fds = 0;
2216         LIST_FOREACH(port, p, s->ports)
2217                 if (p->fd >= 0)
2218                         rn_fds++;
2219
2220         if (rn_fds <= 0) {
2221                 *fds = NULL;
2222                 *n_fds = 0;
2223                 return 0;
2224         }
2225
2226         if (!(rfds = new(int, rn_fds)))
2227                 return -ENOMEM;
2228
2229         k = 0;
2230         LIST_FOREACH(port, p, s->ports)
2231                 if (p->fd >= 0)
2232                         rfds[k++] = p->fd;
2233
2234         assert(k == rn_fds);
2235
2236         *fds = rfds;
2237         *n_fds = rn_fds;
2238
2239         return 0;
2240 }
2241
2242 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2243         assert(s);
2244
2245         /* The service is dead. Dang!
2246          *
2247          * This is strictly for one-instance-for-all-connections
2248          * services. */
2249
2250         if (s->state == SOCKET_RUNNING) {
2251                 log_debug_unit(UNIT(s)->id,
2252                                "%s got notified about service death (failed permanently: %s)",
2253                                UNIT(s)->id, yes_no(failed_permanent));
2254                 if (failed_permanent)
2255                         socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2256                 else
2257                         socket_enter_listening(s);
2258         }
2259 }
2260
2261 void socket_connection_unref(Socket *s) {
2262         assert(s);
2263
2264         /* The service is dead. Yay!
2265          *
2266          * This is strictly for one-instance-per-connection
2267          * services. */
2268
2269         assert(s->n_connections > 0);
2270         s->n_connections--;
2271
2272         log_debug_unit(UNIT(s)->id,
2273                        "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2274 }
2275
2276 static void socket_reset_failed(Unit *u) {
2277         Socket *s = SOCKET(u);
2278
2279         assert(s);
2280
2281         if (s->state == SOCKET_FAILED)
2282                 socket_set_state(s, SOCKET_DEAD);
2283
2284         s->result = SOCKET_SUCCESS;
2285 }
2286
2287 static void socket_trigger_notify(Unit *u, Unit *other) {
2288         Socket *s = SOCKET(u);
2289         Service *se = SERVICE(other);
2290
2291         assert(u);
2292         assert(other);
2293
2294         /* Don't propagate state changes from the service if we are
2295            already down or accepting connections */
2296         if ((s->state !=  SOCKET_RUNNING &&
2297             s->state != SOCKET_LISTENING) ||
2298             s->accept)
2299                 return;
2300
2301         if (other->load_state != UNIT_LOADED ||
2302             other->type != UNIT_SERVICE)
2303                 return;
2304
2305         if (se->state == SERVICE_FAILED)
2306                 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2307
2308         if (se->state == SERVICE_DEAD ||
2309             se->state == SERVICE_STOP ||
2310             se->state == SERVICE_STOP_SIGTERM ||
2311             se->state == SERVICE_STOP_SIGKILL ||
2312             se->state == SERVICE_STOP_POST ||
2313             se->state == SERVICE_FINAL_SIGTERM ||
2314             se->state == SERVICE_FINAL_SIGKILL ||
2315             se->state == SERVICE_AUTO_RESTART)
2316                 socket_notify_service_dead(s, false);
2317
2318         if (se->state == SERVICE_RUNNING)
2319                 socket_set_state(s, SOCKET_RUNNING);
2320 }
2321
2322 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2323         return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2324 }
2325
2326 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2327         [SOCKET_DEAD] = "dead",
2328         [SOCKET_START_PRE] = "start-pre",
2329         [SOCKET_START_POST] = "start-post",
2330         [SOCKET_LISTENING] = "listening",
2331         [SOCKET_RUNNING] = "running",
2332         [SOCKET_STOP_PRE] = "stop-pre",
2333         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2334         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2335         [SOCKET_STOP_POST] = "stop-post",
2336         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2337         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2338         [SOCKET_FAILED] = "failed"
2339 };
2340
2341 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2342
2343 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2344         [SOCKET_EXEC_START_PRE] = "StartPre",
2345         [SOCKET_EXEC_START_POST] = "StartPost",
2346         [SOCKET_EXEC_STOP_PRE] = "StopPre",
2347         [SOCKET_EXEC_STOP_POST] = "StopPost"
2348 };
2349
2350 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2351
2352 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2353         [SOCKET_SUCCESS] = "success",
2354         [SOCKET_FAILURE_RESOURCES] = "resources",
2355         [SOCKET_FAILURE_TIMEOUT] = "timeout",
2356         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2357         [SOCKET_FAILURE_SIGNAL] = "signal",
2358         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2359         [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2360 };
2361
2362 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2363
2364 const UnitVTable socket_vtable = {
2365         .object_size = sizeof(Socket),
2366
2367         .sections =
2368                 "Unit\0"
2369                 "Socket\0"
2370                 "Install\0",
2371
2372         .private_section = "Socket",
2373         .exec_context_offset = offsetof(Socket, exec_context),
2374         .cgroup_context_offset = offsetof(Socket, cgroup_context),
2375
2376         .init = socket_init,
2377         .done = socket_done,
2378         .load = socket_load,
2379
2380         .kill = socket_kill,
2381
2382         .coldplug = socket_coldplug,
2383
2384         .dump = socket_dump,
2385
2386         .start = socket_start,
2387         .stop = socket_stop,
2388
2389         .serialize = socket_serialize,
2390         .deserialize_item = socket_deserialize_item,
2391         .distribute_fds = socket_distribute_fds,
2392
2393         .active_state = socket_active_state,
2394         .sub_state_to_string = socket_sub_state_to_string,
2395
2396         .check_gc = socket_check_gc,
2397
2398         .fd_event = socket_fd_event,
2399         .sigchld_event = socket_sigchld_event,
2400         .timer_event = socket_timer_event,
2401
2402         .trigger_notify = socket_trigger_notify,
2403
2404         .reset_failed = socket_reset_failed,
2405
2406         .bus_interface = "org.freedesktop.systemd1.Socket",
2407         .bus_message_handler = bus_socket_message_handler,
2408         .bus_invalidating_properties =  bus_socket_invalidating_properties,
2409         .bus_set_property = bus_socket_set_property,
2410         .bus_commit_properties = bus_socket_commit_properties,
2411
2412         .status_message_formats = {
2413                 /*.starting_stopping = {
2414                         [0] = "Starting socket %s...",
2415                         [1] = "Stopping socket %s...",
2416                 },*/
2417                 .finished_start_job = {
2418                         [JOB_DONE]       = "Listening on %s.",
2419                         [JOB_FAILED]     = "Failed to listen on %s.",
2420                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
2421                         [JOB_TIMEOUT]    = "Timed out starting %s.",
2422                 },
2423                 .finished_stop_job = {
2424                         [JOB_DONE]       = "Closed %s.",
2425                         [JOB_FAILED]     = "Failed stopping %s.",
2426                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
2427                 },
2428         },
2429 };