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