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