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("Too many incoming connections (%u)", 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                         if ((r = socket_address_print(&p->address, &t)) < 0)
1706                                 return r;
1707
1708                         if (socket_address_family(&p->address) == AF_NETLINK)
1709                                 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1710                         else
1711                                 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1712                         free(t);
1713                 } else if (p->type == SOCKET_SPECIAL)
1714                         unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1715                 else {
1716                         assert(p->type == SOCKET_FIFO);
1717                         unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1718                 }
1719         }
1720
1721         return 0;
1722 }
1723
1724 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1725         Socket *s = SOCKET(u);
1726
1727         assert(u);
1728         assert(key);
1729         assert(value);
1730         assert(fds);
1731
1732         if (streq(key, "state")) {
1733                 SocketState state;
1734
1735                 if ((state = socket_state_from_string(value)) < 0)
1736                         log_debug("Failed to parse state value %s", value);
1737                 else
1738                         s->deserialized_state = state;
1739         } else if (streq(key, "result")) {
1740                 SocketResult f;
1741
1742                 f = socket_result_from_string(value);
1743                 if (f < 0)
1744                         log_debug("Failed to parse result value %s", value);
1745                 else if (f != SOCKET_SUCCESS)
1746                         s->result = f;
1747
1748         } else if (streq(key, "n-accepted")) {
1749                 unsigned k;
1750
1751                 if (safe_atou(value, &k) < 0)
1752                         log_debug("Failed to parse n-accepted value %s", value);
1753                 else
1754                         s->n_accepted += k;
1755         } else if (streq(key, "control-pid")) {
1756                 pid_t pid;
1757
1758                 if (parse_pid(value, &pid) < 0)
1759                         log_debug("Failed to parse control-pid value %s", value);
1760                 else
1761                         s->control_pid = pid;
1762         } else if (streq(key, "control-command")) {
1763                 SocketExecCommand id;
1764
1765                 if ((id = socket_exec_command_from_string(value)) < 0)
1766                         log_debug("Failed to parse exec-command value %s", value);
1767                 else {
1768                         s->control_command_id = id;
1769                         s->control_command = s->exec_command[id];
1770                 }
1771         } else if (streq(key, "fifo")) {
1772                 int fd, skip = 0;
1773                 SocketPort *p;
1774
1775                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1776                         log_debug("Failed to parse fifo value %s", value);
1777                 else {
1778
1779                         LIST_FOREACH(port, p, s->ports)
1780                                 if (p->type == SOCKET_FIFO &&
1781                                     streq_ptr(p->path, value+skip))
1782                                         break;
1783
1784                         if (p) {
1785                                 if (p->fd >= 0)
1786                                         close_nointr_nofail(p->fd);
1787                                 p->fd = fdset_remove(fds, fd);
1788                         }
1789                 }
1790
1791         } else if (streq(key, "special")) {
1792                 int fd, skip = 0;
1793                 SocketPort *p;
1794
1795                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1796                         log_debug("Failed to parse special value %s", value);
1797                 else {
1798
1799                         LIST_FOREACH(port, p, s->ports)
1800                                 if (p->type == SOCKET_SPECIAL &&
1801                                     streq_ptr(p->path, value+skip))
1802                                         break;
1803
1804                         if (p) {
1805                                 if (p->fd >= 0)
1806                                         close_nointr_nofail(p->fd);
1807                                 p->fd = fdset_remove(fds, fd);
1808                         }
1809                 }
1810
1811         } else if (streq(key, "socket")) {
1812                 int fd, type, skip = 0;
1813                 SocketPort *p;
1814
1815                 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
1816                         log_debug("Failed to parse socket value %s", value);
1817                 else {
1818
1819                         LIST_FOREACH(port, p, s->ports)
1820                                 if (socket_address_is(&p->address, value+skip, type))
1821                                         break;
1822
1823                         if (p) {
1824                                 if (p->fd >= 0)
1825                                         close_nointr_nofail(p->fd);
1826                                 p->fd = fdset_remove(fds, fd);
1827                         }
1828                 }
1829
1830         } else if (streq(key, "netlink")) {
1831                 int fd, skip = 0;
1832                 SocketPort *p;
1833
1834                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
1835                         log_debug("Failed to parse socket value %s", value);
1836                 else {
1837
1838                         LIST_FOREACH(port, p, s->ports)
1839                                 if (socket_address_is_netlink(&p->address, value+skip))
1840                                         break;
1841
1842                         if (p) {
1843                                 if (p->fd >= 0)
1844                                         close_nointr_nofail(p->fd);
1845                                 p->fd = fdset_remove(fds, fd);
1846                         }
1847                 }
1848
1849         } else
1850                 log_debug("Unknown serialization key '%s'", key);
1851
1852         return 0;
1853 }
1854
1855 static UnitActiveState socket_active_state(Unit *u) {
1856         assert(u);
1857
1858         return state_translation_table[SOCKET(u)->state];
1859 }
1860
1861 static const char *socket_sub_state_to_string(Unit *u) {
1862         assert(u);
1863
1864         return socket_state_to_string(SOCKET(u)->state);
1865 }
1866
1867 static bool socket_check_gc(Unit *u) {
1868         Socket *s = SOCKET(u);
1869
1870         assert(u);
1871
1872         return s->n_connections > 0;
1873 }
1874
1875 static void socket_fd_event(Unit *u, int fd, uint32_t events, Watch *w) {
1876         Socket *s = SOCKET(u);
1877         int cfd = -1;
1878
1879         assert(s);
1880         assert(fd >= 0);
1881
1882         if (s->state != SOCKET_LISTENING)
1883                 return;
1884
1885         log_debug("Incoming traffic on %s", u->id);
1886
1887         if (events != EPOLLIN) {
1888
1889                 if (events & EPOLLHUP)
1890                         log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1891                 else
1892                         log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1893
1894                 goto fail;
1895         }
1896
1897         if (w->socket_accept) {
1898                 for (;;) {
1899
1900                         cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
1901                         if (cfd < 0) {
1902
1903                                 if (errno == EINTR)
1904                                         continue;
1905
1906                                 log_error("Failed to accept socket: %m");
1907                                 goto fail;
1908                         }
1909
1910                         break;
1911                 }
1912
1913                 socket_apply_socket_options(s, cfd);
1914         }
1915
1916         socket_enter_running(s, cfd);
1917         return;
1918
1919 fail:
1920         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1921 }
1922
1923 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1924         Socket *s = SOCKET(u);
1925         SocketResult f;
1926
1927         assert(s);
1928         assert(pid >= 0);
1929
1930         if (pid != s->control_pid)
1931                 return;
1932
1933         s->control_pid = 0;
1934
1935         if (is_clean_exit(code, status, NULL))
1936                 f = SOCKET_SUCCESS;
1937         else if (code == CLD_EXITED)
1938                 f = SOCKET_FAILURE_EXIT_CODE;
1939         else if (code == CLD_KILLED)
1940                 f = SOCKET_FAILURE_SIGNAL;
1941         else if (code == CLD_DUMPED)
1942                 f = SOCKET_FAILURE_CORE_DUMP;
1943         else
1944                 assert_not_reached("Unknown code");
1945
1946         if (s->control_command) {
1947                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1948
1949                 if (s->control_command->ignore)
1950                         f = SOCKET_SUCCESS;
1951         }
1952
1953         log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1954                  "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1955
1956         if (f != SOCKET_SUCCESS)
1957                 s->result = f;
1958
1959         if (s->control_command &&
1960             s->control_command->command_next &&
1961             f == SOCKET_SUCCESS) {
1962
1963                 log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
1964                 socket_run_next(s);
1965         } else {
1966                 s->control_command = NULL;
1967                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1968
1969                 /* No further commands for this step, so let's figure
1970                  * out what to do next */
1971
1972                 log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1973
1974                 switch (s->state) {
1975
1976                 case SOCKET_START_PRE:
1977                         if (f == SOCKET_SUCCESS)
1978                                 socket_enter_start_post(s);
1979                         else
1980                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1981                         break;
1982
1983                 case SOCKET_START_POST:
1984                         if (f == SOCKET_SUCCESS)
1985                                 socket_enter_listening(s);
1986                         else
1987                                 socket_enter_stop_pre(s, f);
1988                         break;
1989
1990                 case SOCKET_STOP_PRE:
1991                 case SOCKET_STOP_PRE_SIGTERM:
1992                 case SOCKET_STOP_PRE_SIGKILL:
1993                         socket_enter_stop_post(s, f);
1994                         break;
1995
1996                 case SOCKET_STOP_POST:
1997                 case SOCKET_FINAL_SIGTERM:
1998                 case SOCKET_FINAL_SIGKILL:
1999                         socket_enter_dead(s, f);
2000                         break;
2001
2002                 default:
2003                         assert_not_reached("Uh, control process died at wrong time.");
2004                 }
2005         }
2006
2007         /* Notify clients about changed exit status */
2008         unit_add_to_dbus_queue(u);
2009 }
2010
2011 static void socket_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
2012         Socket *s = SOCKET(u);
2013
2014         assert(s);
2015         assert(elapsed == 1);
2016         assert(w == &s->timer_watch);
2017
2018         switch (s->state) {
2019
2020         case SOCKET_START_PRE:
2021                 log_warning("%s starting timed out. Terminating.", u->id);
2022                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2023                 break;
2024
2025         case SOCKET_START_POST:
2026                 log_warning("%s starting timed out. Stopping.", u->id);
2027                 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2028                 break;
2029
2030         case SOCKET_STOP_PRE:
2031                 log_warning("%s stopping timed out. Terminating.", u->id);
2032                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2033                 break;
2034
2035         case SOCKET_STOP_PRE_SIGTERM:
2036                 if (s->kill_context.send_sigkill) {
2037                         log_warning("%s stopping timed out. Killing.", u->id);
2038                         socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2039                 } else {
2040                         log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
2041                         socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2042                 }
2043                 break;
2044
2045         case SOCKET_STOP_PRE_SIGKILL:
2046                 log_warning("%s still around after SIGKILL. Ignoring.", u->id);
2047                 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2048                 break;
2049
2050         case SOCKET_STOP_POST:
2051                 log_warning("%s stopping timed out (2). Terminating.", u->id);
2052                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2053                 break;
2054
2055         case SOCKET_FINAL_SIGTERM:
2056                 if (s->kill_context.send_sigkill) {
2057                         log_warning("%s stopping timed out (2). Killing.", u->id);
2058                         socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2059                 } else {
2060                         log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
2061                         socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2062                 }
2063                 break;
2064
2065         case SOCKET_FINAL_SIGKILL:
2066                 log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
2067                 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2068                 break;
2069
2070         default:
2071                 assert_not_reached("Timeout at wrong time.");
2072         }
2073 }
2074
2075 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2076         int *rfds;
2077         unsigned rn_fds, k;
2078         SocketPort *p;
2079
2080         assert(s);
2081         assert(fds);
2082         assert(n_fds);
2083
2084         /* Called from the service code for requesting our fds */
2085
2086         rn_fds = 0;
2087         LIST_FOREACH(port, p, s->ports)
2088                 if (p->fd >= 0)
2089                         rn_fds++;
2090
2091         if (rn_fds <= 0) {
2092                 *fds = NULL;
2093                 *n_fds = 0;
2094                 return 0;
2095         }
2096
2097         if (!(rfds = new(int, rn_fds)))
2098                 return -ENOMEM;
2099
2100         k = 0;
2101         LIST_FOREACH(port, p, s->ports)
2102                 if (p->fd >= 0)
2103                         rfds[k++] = p->fd;
2104
2105         assert(k == rn_fds);
2106
2107         *fds = rfds;
2108         *n_fds = rn_fds;
2109
2110         return 0;
2111 }
2112
2113 void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2114         assert(s);
2115
2116         /* The service is dead. Dang!
2117          *
2118          * This is strictly for one-instance-for-all-connections
2119          * services. */
2120
2121         if (s->state == SOCKET_RUNNING) {
2122                 log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2123                 if (failed_permanent)
2124                         socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2125                 else
2126                         socket_enter_listening(s);
2127         }
2128 }
2129
2130 void socket_connection_unref(Socket *s) {
2131         assert(s);
2132
2133         /* The service is dead. Yay!
2134          *
2135          * This is strictly for one-instance-per-connection
2136          * services. */
2137
2138         assert(s->n_connections > 0);
2139         s->n_connections--;
2140
2141         log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2142 }
2143
2144 static void socket_reset_failed(Unit *u) {
2145         Socket *s = SOCKET(u);
2146
2147         assert(s);
2148
2149         if (s->state == SOCKET_FAILED)
2150                 socket_set_state(s, SOCKET_DEAD);
2151
2152         s->result = SOCKET_SUCCESS;
2153 }
2154
2155 static int socket_kill(Unit *u, KillWho who, int signo, DBusError *error) {
2156         Socket *s = SOCKET(u);
2157         int r = 0;
2158         Set *pid_set = NULL;
2159
2160         assert(s);
2161
2162         if (who == KILL_MAIN) {
2163                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Socket units have no main processes");
2164                 return -ESRCH;
2165         }
2166
2167         if (s->control_pid <= 0 && who == KILL_CONTROL) {
2168                 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2169                 return -ESRCH;
2170         }
2171
2172         if (who == KILL_CONTROL || who == KILL_ALL)
2173                 if (s->control_pid > 0)
2174                         if (kill(s->control_pid, signo) < 0)
2175                                 r = -errno;
2176
2177         if (who == KILL_ALL) {
2178                 int q;
2179
2180                 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2181                 if (!pid_set)
2182                         return -ENOMEM;
2183
2184                 /* Exclude the control pid from being killed via the cgroup */
2185                 if (s->control_pid > 0) {
2186                         q = set_put(pid_set, LONG_TO_PTR(s->control_pid));
2187                         if (q < 0) {
2188                                 r = q;
2189                                 goto finish;
2190                         }
2191                 }
2192
2193                 q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, false, pid_set, NULL);
2194                 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2195                         r = q;
2196         }
2197
2198 finish:
2199         if (pid_set)
2200                 set_free(pid_set);
2201
2202         return r;
2203 }
2204
2205 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2206         [SOCKET_DEAD] = "dead",
2207         [SOCKET_START_PRE] = "start-pre",
2208         [SOCKET_START_POST] = "start-post",
2209         [SOCKET_LISTENING] = "listening",
2210         [SOCKET_RUNNING] = "running",
2211         [SOCKET_STOP_PRE] = "stop-pre",
2212         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2213         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2214         [SOCKET_STOP_POST] = "stop-post",
2215         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2216         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2217         [SOCKET_FAILED] = "failed"
2218 };
2219
2220 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2221
2222 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2223         [SOCKET_EXEC_START_PRE] = "StartPre",
2224         [SOCKET_EXEC_START_POST] = "StartPost",
2225         [SOCKET_EXEC_STOP_PRE] = "StopPre",
2226         [SOCKET_EXEC_STOP_POST] = "StopPost"
2227 };
2228
2229 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2230
2231 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2232         [SOCKET_SUCCESS] = "success",
2233         [SOCKET_FAILURE_RESOURCES] = "resources",
2234         [SOCKET_FAILURE_TIMEOUT] = "timeout",
2235         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2236         [SOCKET_FAILURE_SIGNAL] = "signal",
2237         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2238         [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2239 };
2240
2241 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2242
2243 const UnitVTable socket_vtable = {
2244         .object_size = sizeof(Socket),
2245         .exec_context_offset = offsetof(Socket, exec_context),
2246
2247         .sections =
2248                 "Unit\0"
2249                 "Socket\0"
2250                 "Install\0",
2251
2252         .init = socket_init,
2253         .done = socket_done,
2254         .load = socket_load,
2255
2256         .kill = socket_kill,
2257
2258         .coldplug = socket_coldplug,
2259
2260         .dump = socket_dump,
2261
2262         .start = socket_start,
2263         .stop = socket_stop,
2264
2265         .serialize = socket_serialize,
2266         .deserialize_item = socket_deserialize_item,
2267
2268         .active_state = socket_active_state,
2269         .sub_state_to_string = socket_sub_state_to_string,
2270
2271         .check_gc = socket_check_gc,
2272
2273         .fd_event = socket_fd_event,
2274         .sigchld_event = socket_sigchld_event,
2275         .timer_event = socket_timer_event,
2276
2277         .reset_failed = socket_reset_failed,
2278
2279         .bus_interface = "org.freedesktop.systemd1.Socket",
2280         .bus_message_handler = bus_socket_message_handler,
2281         .bus_invalidating_properties =  bus_socket_invalidating_properties,
2282
2283         .status_message_formats = {
2284                 /*.starting_stopping = {
2285                         [0] = "Starting socket %s...",
2286                         [1] = "Stopping socket %s...",
2287                 },*/
2288                 .finished_start_job = {
2289                         [JOB_DONE]       = "Listening on %s.",
2290                         [JOB_FAILED]     = "Failed to listen on %s.",
2291                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
2292                         [JOB_TIMEOUT]    = "Timed out starting %s.",
2293                 },
2294                 .finished_stop_job = {
2295                         [JOB_DONE]       = "Closed %s.",
2296                         [JOB_FAILED]     = "Failed stopping %s.",
2297                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
2298                 },
2299         },
2300 };