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