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
1347         r = unit_watch_pid(UNIT(s), pid);
1348         if (r < 0)
1349                 /* FIXME: we need to do something here */
1350                 goto fail;
1351
1352         *_pid = pid;
1353         return 0;
1354
1355 fail:
1356         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1357         return r;
1358 }
1359
1360 static int socket_chown(Socket *s, pid_t *_pid) {
1361         pid_t pid;
1362         int r;
1363
1364         r = socket_arm_timer(s);
1365         if (r < 0)
1366                 goto fail;
1367
1368         /* We have to resolve the user names out-of-process, hence
1369          * let's fork here. It's messy, but well, what can we do? */
1370
1371         pid = fork();
1372         if (pid < 0)
1373                 return -errno;
1374
1375         if (pid == 0) {
1376                 SocketPort *p;
1377                 uid_t uid = (uid_t) -1;
1378                 gid_t gid = (gid_t) -1;
1379                 int ret;
1380
1381                 default_signals(SIGNALS_CRASH_HANDLER, SIGNALS_IGNORE, -1);
1382                 ignore_signals(SIGPIPE, -1);
1383                 log_forget_fds();
1384
1385                 if (!isempty(s->user)) {
1386                         const char *user = s->user;
1387
1388                         r = get_user_creds(&user, &uid, &gid, NULL, NULL);
1389                         if (r < 0) {
1390                                 ret = EXIT_USER;
1391                                 goto fail_child;
1392                         }
1393                 }
1394
1395                 if (!isempty(s->group)) {
1396                         const char *group = s->group;
1397
1398                         r = get_group_creds(&group, &gid);
1399                         if (r < 0) {
1400                                 ret = EXIT_GROUP;
1401                                 goto fail_child;
1402                         }
1403                 }
1404
1405                 LIST_FOREACH(port, p, s->ports) {
1406                         const char *path = NULL;
1407
1408                         if (p->type == SOCKET_SOCKET)
1409                                 path = socket_address_get_path(&p->address);
1410                         else if (p->type == SOCKET_FIFO)
1411                                 path = p->path;
1412
1413                         if (!path)
1414                                 continue;
1415
1416                         if (chown(path, uid, gid) < 0) {
1417                                 r = -errno;
1418                                 ret = EXIT_CHOWN;
1419                                 goto fail_child;
1420                         }
1421                 }
1422
1423                 _exit(0);
1424
1425         fail_child:
1426                 log_open();
1427                 log_error("Failed to chown socket at step %s: %s", exit_status_to_string(ret, EXIT_STATUS_SYSTEMD), strerror(-r));
1428
1429                 _exit(ret);
1430         }
1431
1432         r = unit_watch_pid(UNIT(s), pid);
1433         if (r < 0)
1434                 goto fail;
1435
1436         *_pid = pid;
1437         return 0;
1438
1439 fail:
1440         s->timer_event_source = sd_event_source_unref(s->timer_event_source);
1441         return r;
1442 }
1443
1444 static void socket_enter_dead(Socket *s, SocketResult f) {
1445         assert(s);
1446
1447         if (f != SOCKET_SUCCESS)
1448                 s->result = f;
1449
1450         exec_runtime_destroy(s->exec_runtime);
1451         s->exec_runtime = exec_runtime_unref(s->exec_runtime);
1452
1453         exec_context_destroy_runtime_directory(&s->exec_context, manager_get_runtime_prefix(UNIT(s)->manager));
1454
1455         socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1456 }
1457
1458 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1459
1460 static void socket_enter_stop_post(Socket *s, SocketResult f) {
1461         int r;
1462         assert(s);
1463
1464         if (f != SOCKET_SUCCESS)
1465                 s->result = f;
1466
1467         socket_unwatch_control_pid(s);
1468         s->control_command_id = SOCKET_EXEC_STOP_POST;
1469         s->control_command = s->exec_command[SOCKET_EXEC_STOP_POST];
1470
1471         if (s->control_command) {
1472                 r = socket_spawn(s, s->control_command, &s->control_pid);
1473                 if (r < 0)
1474                         goto fail;
1475
1476                 socket_set_state(s, SOCKET_STOP_POST);
1477         } else
1478                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1479
1480         return;
1481
1482 fail:
1483         log_warning_unit(UNIT(s)->id,
1484                          "%s failed to run 'stop-post' task: %s",
1485                          UNIT(s)->id, strerror(-r));
1486         socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1487 }
1488
1489 static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1490         int r;
1491
1492         assert(s);
1493
1494         if (f != SOCKET_SUCCESS)
1495                 s->result = f;
1496
1497         r = unit_kill_context(
1498                         UNIT(s),
1499                         &s->kill_context,
1500                         state != SOCKET_STOP_PRE_SIGTERM && state != SOCKET_FINAL_SIGTERM,
1501                         -1,
1502                         s->control_pid,
1503                         false);
1504         if (r < 0)
1505                 goto fail;
1506
1507         if (r > 0) {
1508                 r = socket_arm_timer(s);
1509                 if (r < 0)
1510                         goto fail;
1511
1512                 socket_set_state(s, state);
1513         } else if (state == SOCKET_STOP_PRE_SIGTERM)
1514                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_SUCCESS);
1515         else if (state == SOCKET_STOP_PRE_SIGKILL)
1516                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1517         else if (state == SOCKET_FINAL_SIGTERM)
1518                 socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_SUCCESS);
1519         else
1520                 socket_enter_dead(s, SOCKET_SUCCESS);
1521
1522         return;
1523
1524 fail:
1525         log_warning_unit(UNIT(s)->id, "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1526
1527         if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1528                 socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1529         else
1530                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1531 }
1532
1533 static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1534         int r;
1535         assert(s);
1536
1537         if (f != SOCKET_SUCCESS)
1538                 s->result = f;
1539
1540         socket_unwatch_control_pid(s);
1541         s->control_command_id = SOCKET_EXEC_STOP_PRE;
1542         s->control_command = s->exec_command[SOCKET_EXEC_STOP_PRE];
1543
1544         if (s->control_command) {
1545                 r = socket_spawn(s, s->control_command, &s->control_pid);
1546                 if (r < 0)
1547                         goto fail;
1548
1549                 socket_set_state(s, SOCKET_STOP_PRE);
1550         } else
1551                 socket_enter_stop_post(s, SOCKET_SUCCESS);
1552
1553         return;
1554
1555 fail:
1556         log_warning_unit(UNIT(s)->id, "%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
1557         socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1558 }
1559
1560 static void socket_enter_listening(Socket *s) {
1561         int r;
1562         assert(s);
1563
1564         r = socket_watch_fds(s);
1565         if (r < 0) {
1566                 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1567                 goto fail;
1568         }
1569
1570         socket_set_state(s, SOCKET_LISTENING);
1571         return;
1572
1573 fail:
1574         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1575 }
1576
1577 static void socket_enter_start_post(Socket *s) {
1578         int r;
1579         assert(s);
1580
1581         socket_unwatch_control_pid(s);
1582         s->control_command_id = SOCKET_EXEC_START_POST;
1583         s->control_command = s->exec_command[SOCKET_EXEC_START_POST];
1584
1585         if (s->control_command) {
1586                 r = socket_spawn(s, s->control_command, &s->control_pid);
1587                 if (r < 0) {
1588                         log_warning_unit(UNIT(s)->id, "%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1589                         goto fail;
1590                 }
1591
1592                 socket_set_state(s, SOCKET_START_POST);
1593         } else
1594                 socket_enter_listening(s);
1595
1596         return;
1597
1598 fail:
1599         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1600 }
1601
1602 static void socket_enter_start_chown(Socket *s) {
1603         int r;
1604
1605         assert(s);
1606
1607         r = socket_open_fds(s);
1608         if (r < 0) {
1609                 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1610                 goto fail;
1611         }
1612
1613         if (!isempty(s->user) || !isempty(s->group)) {
1614
1615                 socket_unwatch_control_pid(s);
1616                 s->control_command_id = SOCKET_EXEC_START_CHOWN;
1617                 s->control_command = NULL;
1618
1619                 r = socket_chown(s, &s->control_pid);
1620                 if (r < 0) {
1621                         log_warning_unit(UNIT(s)->id, "%s failed to fork 'start-chown' task: %s", UNIT(s)->id, strerror(-r));
1622                         goto fail;
1623                 }
1624
1625                 socket_set_state(s, SOCKET_START_CHOWN);
1626         } else
1627                 socket_enter_start_post(s);
1628
1629         return;
1630
1631 fail:
1632         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1633 }
1634
1635 static void socket_enter_start_pre(Socket *s) {
1636         int r;
1637         assert(s);
1638
1639         socket_unwatch_control_pid(s);
1640         s->control_command_id = SOCKET_EXEC_START_PRE;
1641         s->control_command = s->exec_command[SOCKET_EXEC_START_PRE];
1642
1643         if (s->control_command) {
1644                 r = socket_spawn(s, s->control_command, &s->control_pid);
1645                 if (r < 0) {
1646                         log_warning_unit(UNIT(s)->id, "%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
1647                         goto fail;
1648                 }
1649
1650                 socket_set_state(s, SOCKET_START_PRE);
1651         } else
1652                 socket_enter_start_chown(s);
1653
1654         return;
1655
1656 fail:
1657         socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1658 }
1659
1660 static void socket_enter_running(Socket *s, int cfd) {
1661         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1662         int r;
1663
1664         assert(s);
1665
1666         /* We don't take connections anymore if we are supposed to
1667          * shut down anyway */
1668         if (unit_stop_pending(UNIT(s))) {
1669
1670                 log_debug_unit(UNIT(s)->id, "Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1671
1672                 if (cfd >= 0)
1673                         safe_close(cfd);
1674                 else  {
1675                         /* Flush all sockets by closing and reopening them */
1676                         socket_close_fds(s);
1677
1678                         r = socket_open_fds(s);
1679                         if (r < 0) {
1680                                 log_warning_unit(UNIT(s)->id, "%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1681                                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1682                                 return;
1683                         }
1684
1685                         r = socket_watch_fds(s);
1686                         if (r < 0) {
1687                                 log_warning_unit(UNIT(s)->id, "%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1688                                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1689                         }
1690                 }
1691
1692                 return;
1693         }
1694
1695         if (cfd < 0) {
1696                 Iterator i;
1697                 Unit *other;
1698                 bool pending = false;
1699
1700                 /* If there's already a start pending don't bother to
1701                  * do anything */
1702                 SET_FOREACH(other, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
1703                         if (unit_active_or_pending(other)) {
1704                                 pending = true;
1705                                 break;
1706                         }
1707
1708                 if (!pending) {
1709                         if (!UNIT_ISSET(s->service)) {
1710                                 log_error_unit(UNIT(s)->id, "%s: service to activate vanished, refusing activation.", UNIT(s)->id);
1711                                 r = -ENOENT;
1712                                 goto fail;
1713                         }
1714
1715                         r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
1716                         if (r < 0)
1717                                 goto fail;
1718                 }
1719
1720                 socket_set_state(s, SOCKET_RUNNING);
1721         } else {
1722                 _cleanup_free_ char *prefix = NULL, *instance = NULL, *name = NULL;
1723                 Service *service;
1724
1725                 if (s->n_connections >= s->max_connections) {
1726                         log_warning_unit(UNIT(s)->id, "%s: Too many incoming connections (%u)", UNIT(s)->id, s->n_connections);
1727                         safe_close(cfd);
1728                         return;
1729                 }
1730
1731                 r = socket_instantiate_service(s);
1732                 if (r < 0)
1733                         goto fail;
1734
1735                 r = instance_from_socket(cfd, s->n_accepted, &instance);
1736                 if (r < 0) {
1737                         if (r != -ENOTCONN)
1738                                 goto fail;
1739
1740                         /* ENOTCONN is legitimate if TCP RST was received.
1741                          * This connection is over, but the socket unit lives on. */
1742                         safe_close(cfd);
1743                         return;
1744                 }
1745
1746                 prefix = unit_name_to_prefix(UNIT(s)->id);
1747                 if (!prefix) {
1748                         r = -ENOMEM;
1749                         goto fail;
1750                 }
1751
1752                 name = unit_name_build(prefix, instance, ".service");
1753                 if (!name) {
1754                         r = -ENOMEM;
1755                         goto fail;
1756                 }
1757
1758                 r = unit_add_name(UNIT_DEREF(s->service), name);
1759                 if (r < 0)
1760                         goto fail;
1761
1762                 service = SERVICE(UNIT_DEREF(s->service));
1763                 unit_ref_unset(&s->service);
1764                 s->n_accepted ++;
1765
1766                 UNIT(service)->no_gc = false;
1767
1768                 unit_choose_id(UNIT(service), name);
1769
1770                 r = service_set_socket_fd(service, cfd, s);
1771                 if (r < 0)
1772                         goto fail;
1773
1774                 cfd = -1;
1775                 s->n_connections ++;
1776
1777                 r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
1778                 if (r < 0)
1779                         goto fail;
1780
1781                 /* Notify clients about changed counters */
1782                 unit_add_to_dbus_queue(UNIT(s));
1783         }
1784
1785         return;
1786
1787 fail:
1788         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",
1789                          UNIT(s)->id, cfd >= 0 ? "template" : "non-template",
1790                          bus_error_message(&error, r));
1791
1792         socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1793         safe_close(cfd);
1794 }
1795
1796 static void socket_run_next(Socket *s) {
1797         int r;
1798
1799         assert(s);
1800         assert(s->control_command);
1801         assert(s->control_command->command_next);
1802
1803         socket_unwatch_control_pid(s);
1804
1805         s->control_command = s->control_command->command_next;
1806
1807         r = socket_spawn(s, s->control_command, &s->control_pid);
1808         if (r < 0)
1809                 goto fail;
1810
1811         return;
1812
1813 fail:
1814         log_warning_unit(UNIT(s)->id, "%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1815
1816         if (s->state == SOCKET_START_POST)
1817                 socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1818         else if (s->state == SOCKET_STOP_POST)
1819                 socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1820         else
1821                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1822 }
1823
1824 static int socket_start(Unit *u) {
1825         Socket *s = SOCKET(u);
1826
1827         assert(s);
1828
1829         /* We cannot fulfill this request right now, try again later
1830          * please! */
1831         if (IN_SET(s->state,
1832                    SOCKET_STOP_PRE,
1833                    SOCKET_STOP_PRE_SIGKILL,
1834                    SOCKET_STOP_PRE_SIGTERM,
1835                    SOCKET_STOP_POST,
1836                    SOCKET_FINAL_SIGTERM,
1837                    SOCKET_FINAL_SIGKILL))
1838                 return -EAGAIN;
1839
1840         /* Already on it! */
1841         if (IN_SET(s->state,
1842                    SOCKET_START_PRE,
1843                    SOCKET_START_CHOWN,
1844                    SOCKET_START_POST))
1845                 return 0;
1846
1847         /* Cannot run this without the service being around */
1848         if (UNIT_ISSET(s->service)) {
1849                 Service *service;
1850
1851                 service = SERVICE(UNIT_DEREF(s->service));
1852
1853                 if (UNIT(service)->load_state != UNIT_LOADED) {
1854                         log_error_unit(u->id, "Socket service %s not loaded, refusing.", UNIT(service)->id);
1855                         return -ENOENT;
1856                 }
1857
1858                 /* If the service is already active we cannot start the
1859                  * socket */
1860                 if (service->state != SERVICE_DEAD &&
1861                     service->state != SERVICE_FAILED &&
1862                     service->state != SERVICE_AUTO_RESTART) {
1863                         log_error_unit(u->id, "Socket service %s already active, refusing.", UNIT(service)->id);
1864                         return -EBUSY;
1865                 }
1866         }
1867
1868         assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1869
1870         s->result = SOCKET_SUCCESS;
1871         socket_enter_start_pre(s);
1872
1873         return 0;
1874 }
1875
1876 static int socket_stop(Unit *u) {
1877         Socket *s = SOCKET(u);
1878
1879         assert(s);
1880
1881         /* Already on it */
1882         if (IN_SET(s->state,
1883                    SOCKET_STOP_PRE,
1884                    SOCKET_STOP_PRE_SIGTERM,
1885                    SOCKET_STOP_PRE_SIGKILL,
1886                    SOCKET_STOP_POST,
1887                    SOCKET_FINAL_SIGTERM,
1888                    SOCKET_FINAL_SIGKILL))
1889                 return 0;
1890
1891         /* If there's already something running we go directly into
1892          * kill mode. */
1893         if (IN_SET(s->state,
1894                    SOCKET_START_PRE,
1895                    SOCKET_START_CHOWN,
1896                    SOCKET_START_POST)) {
1897                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1898                 return -EAGAIN;
1899         }
1900
1901         assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1902
1903         socket_enter_stop_pre(s, SOCKET_SUCCESS);
1904         return 0;
1905 }
1906
1907 static int socket_serialize(Unit *u, FILE *f, FDSet *fds) {
1908         Socket *s = SOCKET(u);
1909         SocketPort *p;
1910         int r;
1911
1912         assert(u);
1913         assert(f);
1914         assert(fds);
1915
1916         unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1917         unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1918         unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1919
1920         if (s->control_pid > 0)
1921                 unit_serialize_item_format(u, f, "control-pid", PID_FMT, s->control_pid);
1922
1923         if (s->control_command_id >= 0)
1924                 unit_serialize_item(u, f, "control-command", socket_exec_command_to_string(s->control_command_id));
1925
1926         LIST_FOREACH(port, p, s->ports) {
1927                 int copy;
1928
1929                 if (p->fd < 0)
1930                         continue;
1931
1932                 copy = fdset_put_dup(fds, p->fd);
1933                 if (copy < 0)
1934                         return copy;
1935
1936                 if (p->type == SOCKET_SOCKET) {
1937                         _cleanup_free_ char *t = NULL;
1938
1939                         r = socket_address_print(&p->address, &t);
1940                         if (r < 0)
1941                                 return r;
1942
1943                         if (socket_address_family(&p->address) == AF_NETLINK)
1944                                 unit_serialize_item_format(u, f, "netlink", "%i %s", copy, t);
1945                         else
1946                                 unit_serialize_item_format(u, f, "socket", "%i %i %s", copy, p->address.type, t);
1947
1948                 } else if (p->type == SOCKET_SPECIAL)
1949                         unit_serialize_item_format(u, f, "special", "%i %s", copy, p->path);
1950                 else if (p->type == SOCKET_MQUEUE)
1951                         unit_serialize_item_format(u, f, "mqueue", "%i %s", copy, p->path);
1952                 else {
1953                         assert(p->type == SOCKET_FIFO);
1954                         unit_serialize_item_format(u, f, "fifo", "%i %s", copy, p->path);
1955                 }
1956         }
1957
1958         return 0;
1959 }
1960
1961 static int socket_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1962         Socket *s = SOCKET(u);
1963
1964         assert(u);
1965         assert(key);
1966         assert(value);
1967
1968         if (streq(key, "state")) {
1969                 SocketState state;
1970
1971                 state = socket_state_from_string(value);
1972                 if (state < 0)
1973                         log_debug_unit(u->id, "Failed to parse state value %s", value);
1974                 else
1975                         s->deserialized_state = state;
1976         } else if (streq(key, "result")) {
1977                 SocketResult f;
1978
1979                 f = socket_result_from_string(value);
1980                 if (f < 0)
1981                         log_debug_unit(u->id, "Failed to parse result value %s", value);
1982                 else if (f != SOCKET_SUCCESS)
1983                         s->result = f;
1984
1985         } else if (streq(key, "n-accepted")) {
1986                 unsigned k;
1987
1988                 if (safe_atou(value, &k) < 0)
1989                         log_debug_unit(u->id, "Failed to parse n-accepted value %s", value);
1990                 else
1991                         s->n_accepted += k;
1992         } else if (streq(key, "control-pid")) {
1993                 pid_t pid;
1994
1995                 if (parse_pid(value, &pid) < 0)
1996                         log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
1997                 else
1998                         s->control_pid = pid;
1999         } else if (streq(key, "control-command")) {
2000                 SocketExecCommand id;
2001
2002                 id = socket_exec_command_from_string(value);
2003                 if (id < 0)
2004                         log_debug_unit(u->id, "Failed to parse exec-command value %s", value);
2005                 else {
2006                         s->control_command_id = id;
2007                         s->control_command = s->exec_command[id];
2008                 }
2009         } else if (streq(key, "fifo")) {
2010                 int fd, skip = 0;
2011                 SocketPort *p;
2012
2013                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2014                         log_debug_unit(u->id, "Failed to parse fifo value %s", value);
2015                 else {
2016
2017                         LIST_FOREACH(port, p, s->ports)
2018                                 if (p->type == SOCKET_FIFO &&
2019                                     streq_ptr(p->path, value+skip))
2020                                         break;
2021
2022                         if (p) {
2023                                 safe_close(p->fd);
2024                                 p->fd = fdset_remove(fds, fd);
2025                         }
2026                 }
2027
2028         } else if (streq(key, "special")) {
2029                 int fd, skip = 0;
2030                 SocketPort *p;
2031
2032                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2033                         log_debug_unit(u->id, "Failed to parse special value %s", value);
2034                 else {
2035
2036                         LIST_FOREACH(port, p, s->ports)
2037                                 if (p->type == SOCKET_SPECIAL &&
2038                                     streq_ptr(p->path, value+skip))
2039                                         break;
2040
2041                         if (p) {
2042                                 safe_close(p->fd);
2043                                 p->fd = fdset_remove(fds, fd);
2044                         }
2045                 }
2046
2047         } else if (streq(key, "mqueue")) {
2048                 int fd, skip = 0;
2049                 SocketPort *p;
2050
2051                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2052                         log_debug_unit(u->id, "Failed to parse mqueue value %s", value);
2053                 else {
2054
2055                         LIST_FOREACH(port, p, s->ports)
2056                                 if (p->type == SOCKET_MQUEUE &&
2057                                     streq_ptr(p->path, value+skip))
2058                                         break;
2059
2060                         if (p) {
2061                                 safe_close(p->fd);
2062                                 p->fd = fdset_remove(fds, fd);
2063                         }
2064                 }
2065
2066         } else if (streq(key, "socket")) {
2067                 int fd, type, skip = 0;
2068                 SocketPort *p;
2069
2070                 if (sscanf(value, "%i %i %n", &fd, &type, &skip) < 2 || fd < 0 || type < 0 || !fdset_contains(fds, fd))
2071                         log_debug_unit(u->id, "Failed to parse socket value %s", value);
2072                 else {
2073
2074                         LIST_FOREACH(port, p, s->ports)
2075                                 if (socket_address_is(&p->address, value+skip, type))
2076                                         break;
2077
2078                         if (p) {
2079                                 safe_close(p->fd);
2080                                 p->fd = fdset_remove(fds, fd);
2081                         }
2082                 }
2083
2084         } else if (streq(key, "netlink")) {
2085                 int fd, skip = 0;
2086                 SocketPort *p;
2087
2088                 if (sscanf(value, "%i %n", &fd, &skip) < 1 || fd < 0 || !fdset_contains(fds, fd))
2089                         log_debug_unit(u->id, "Failed to parse socket value %s", value);
2090                 else {
2091
2092                         LIST_FOREACH(port, p, s->ports)
2093                                 if (socket_address_is_netlink(&p->address, value+skip))
2094                                         break;
2095
2096                         if (p) {
2097                                 safe_close(p->fd);
2098                                 p->fd = fdset_remove(fds, fd);
2099                         }
2100                 }
2101         } else
2102                 log_debug_unit(UNIT(s)->id, "Unknown serialization key '%s'", key);
2103
2104         return 0;
2105 }
2106
2107 static int socket_distribute_fds(Unit *u, FDSet *fds) {
2108         Socket *s = SOCKET(u);
2109         SocketPort *p;
2110
2111         assert(u);
2112
2113         LIST_FOREACH(port, p, s->ports) {
2114                 Iterator i;
2115                 int fd;
2116
2117                 if (p->type != SOCKET_SOCKET)
2118                         continue;
2119
2120                 if (p->fd >= 0)
2121                         continue;
2122
2123                 FDSET_FOREACH(fd, fds, i) {
2124                         if (socket_address_matches_fd(&p->address, fd)) {
2125                                 p->fd = fdset_remove(fds, fd);
2126                                 s->deserialized_state = SOCKET_LISTENING;
2127                                 break;
2128                         }
2129                 }
2130         }
2131
2132         return 0;
2133 }
2134
2135 _pure_ static UnitActiveState socket_active_state(Unit *u) {
2136         assert(u);
2137
2138         return state_translation_table[SOCKET(u)->state];
2139 }
2140
2141 _pure_ static const char *socket_sub_state_to_string(Unit *u) {
2142         assert(u);
2143
2144         return socket_state_to_string(SOCKET(u)->state);
2145 }
2146
2147 const char* socket_port_type_to_string(SocketPort *p) {
2148
2149         assert(p);
2150
2151         switch (p->type) {
2152
2153         case SOCKET_SOCKET:
2154
2155                 switch (p->address.type) {
2156
2157                 case SOCK_STREAM:
2158                         return "Stream";
2159
2160                 case SOCK_DGRAM:
2161                         return "Datagram";
2162
2163                 case SOCK_SEQPACKET:
2164                         return "SequentialPacket";
2165
2166                 case SOCK_RAW:
2167                         if (socket_address_family(&p->address) == AF_NETLINK)
2168                                 return "Netlink";
2169
2170                 default:
2171                         return NULL;
2172                 }
2173
2174         case SOCKET_SPECIAL:
2175                 return "Special";
2176
2177         case SOCKET_MQUEUE:
2178                 return "MessageQueue";
2179
2180         case SOCKET_FIFO:
2181                 return "FIFO";
2182
2183         default:
2184                 return NULL;
2185         }
2186 }
2187
2188 _pure_ static bool socket_check_gc(Unit *u) {
2189         Socket *s = SOCKET(u);
2190
2191         assert(u);
2192
2193         return s->n_connections > 0;
2194 }
2195
2196 static int socket_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
2197         SocketPort *p = userdata;
2198         int cfd = -1;
2199
2200         assert(p);
2201         assert(fd >= 0);
2202
2203         if (p->socket->state != SOCKET_LISTENING)
2204                 return 0;
2205
2206         log_debug_unit(UNIT(p->socket)->id, "Incoming traffic on %s", UNIT(p->socket)->id);
2207
2208         if (revents != EPOLLIN) {
2209
2210                 if (revents & EPOLLHUP)
2211                         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.",
2212                                        UNIT(p->socket)->id);
2213                 else
2214                         log_error_unit(UNIT(p->socket)->id, "%s: Got unexpected poll event (0x%x) on socket.",
2215                                        UNIT(p->socket)->id, revents);
2216
2217                 goto fail;
2218         }
2219
2220         if (p->socket->accept &&
2221             p->type == SOCKET_SOCKET &&
2222             socket_address_can_accept(&p->address)) {
2223
2224                 for (;;) {
2225
2226                         cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK);
2227                         if (cfd < 0) {
2228
2229                                 if (errno == EINTR)
2230                                         continue;
2231
2232                                 log_error_unit(UNIT(p->socket)->id,
2233                                                "Failed to accept socket: %m");
2234                                 goto fail;
2235                         }
2236
2237                         break;
2238                 }
2239
2240                 socket_apply_socket_options(p->socket, cfd);
2241         }
2242
2243         socket_enter_running(p->socket, cfd);
2244         return 0;
2245
2246 fail:
2247         socket_enter_stop_pre(p->socket, SOCKET_FAILURE_RESOURCES);
2248         return 0;
2249 }
2250
2251 static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
2252         Socket *s = SOCKET(u);
2253         SocketResult f;
2254
2255         assert(s);
2256         assert(pid >= 0);
2257
2258         if (pid != s->control_pid)
2259                 return;
2260
2261         s->control_pid = 0;
2262
2263         if (is_clean_exit(code, status, NULL))
2264                 f = SOCKET_SUCCESS;
2265         else if (code == CLD_EXITED)
2266                 f = SOCKET_FAILURE_EXIT_CODE;
2267         else if (code == CLD_KILLED)
2268                 f = SOCKET_FAILURE_SIGNAL;
2269         else if (code == CLD_DUMPED)
2270                 f = SOCKET_FAILURE_CORE_DUMP;
2271         else
2272                 assert_not_reached("Unknown sigchld code");
2273
2274         if (s->control_command) {
2275                 exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
2276
2277                 if (s->control_command->ignore)
2278                         f = SOCKET_SUCCESS;
2279         }
2280
2281         log_full_unit(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
2282                       u->id,
2283                       "%s control process exited, code=%s status=%i",
2284                       u->id, sigchld_code_to_string(code), status);
2285
2286         if (f != SOCKET_SUCCESS)
2287                 s->result = f;
2288
2289         if (s->control_command &&
2290             s->control_command->command_next &&
2291             f == SOCKET_SUCCESS) {
2292
2293                 log_debug_unit(u->id,
2294                                "%s running next command for state %s",
2295                                u->id, socket_state_to_string(s->state));
2296                 socket_run_next(s);
2297         } else {
2298                 s->control_command = NULL;
2299                 s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
2300
2301                 /* No further commands for this step, so let's figure
2302                  * out what to do next */
2303
2304                 log_debug_unit(u->id,
2305                                "%s got final SIGCHLD for state %s",
2306                                u->id, socket_state_to_string(s->state));
2307
2308                 switch (s->state) {
2309
2310                 case SOCKET_START_PRE:
2311                         if (f == SOCKET_SUCCESS)
2312                                 socket_enter_start_chown(s);
2313                         else
2314                                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
2315                         break;
2316
2317                 case SOCKET_START_CHOWN:
2318                         if (f == SOCKET_SUCCESS)
2319                                 socket_enter_start_post(s);
2320                         else
2321                                 socket_enter_stop_pre(s, f);
2322                         break;
2323
2324                 case SOCKET_START_POST:
2325                         if (f == SOCKET_SUCCESS)
2326                                 socket_enter_listening(s);
2327                         else
2328                                 socket_enter_stop_pre(s, f);
2329                         break;
2330
2331                 case SOCKET_STOP_PRE:
2332                 case SOCKET_STOP_PRE_SIGTERM:
2333                 case SOCKET_STOP_PRE_SIGKILL:
2334                         socket_enter_stop_post(s, f);
2335                         break;
2336
2337                 case SOCKET_STOP_POST:
2338                 case SOCKET_FINAL_SIGTERM:
2339                 case SOCKET_FINAL_SIGKILL:
2340                         socket_enter_dead(s, f);
2341                         break;
2342
2343                 default:
2344                         assert_not_reached("Uh, control process died at wrong time.");
2345                 }
2346         }
2347
2348         /* Notify clients about changed exit status */
2349         unit_add_to_dbus_queue(u);
2350 }
2351
2352 static int socket_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
2353         Socket *s = SOCKET(userdata);
2354
2355         assert(s);
2356         assert(s->timer_event_source == source);
2357
2358         switch (s->state) {
2359
2360         case SOCKET_START_PRE:
2361                 log_warning_unit(UNIT(s)->id, "%s starting timed out. Terminating.", UNIT(s)->id);
2362                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2363                 break;
2364
2365         case SOCKET_START_CHOWN:
2366         case SOCKET_START_POST:
2367                 log_warning_unit(UNIT(s)->id, "%s starting timed out. Stopping.", UNIT(s)->id);
2368                 socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
2369                 break;
2370
2371         case SOCKET_STOP_PRE:
2372                 log_warning_unit(UNIT(s)->id, "%s stopping timed out. Terminating.", UNIT(s)->id);
2373                 socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2374                 break;
2375
2376         case SOCKET_STOP_PRE_SIGTERM:
2377                 if (s->kill_context.send_sigkill) {
2378                         log_warning_unit(UNIT(s)->id, "%s stopping timed out. Killing.", UNIT(s)->id);
2379                         socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2380                 } else {
2381                         log_warning_unit(UNIT(s)->id, "%s stopping timed out. Skipping SIGKILL. Ignoring.", UNIT(s)->id);
2382                         socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2383                 }
2384                 break;
2385
2386         case SOCKET_STOP_PRE_SIGKILL:
2387                 log_warning_unit(UNIT(s)->id, "%s still around after SIGKILL. Ignoring.", UNIT(s)->id);
2388                 socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
2389                 break;
2390
2391         case SOCKET_STOP_POST:
2392                 log_warning_unit(UNIT(s)->id, "%s stopping timed out (2). Terminating.", UNIT(s)->id);
2393                 socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
2394                 break;
2395
2396         case SOCKET_FINAL_SIGTERM:
2397                 if (s->kill_context.send_sigkill) {
2398                         log_warning_unit(UNIT(s)->id, "%s stopping timed out (2). Killing.", UNIT(s)->id);
2399                         socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
2400                 } else {
2401                         log_warning_unit(UNIT(s)->id, "%s stopping timed out (2). Skipping SIGKILL. Ignoring.", UNIT(s)->id);
2402                         socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2403                 }
2404                 break;
2405
2406         case SOCKET_FINAL_SIGKILL:
2407                 log_warning_unit(UNIT(s)->id, "%s still around after SIGKILL (2). Entering failed mode.", UNIT(s)->id);
2408                 socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
2409                 break;
2410
2411         default:
2412                 assert_not_reached("Timeout at wrong time.");
2413         }
2414
2415         return 0;
2416 }
2417
2418 int socket_collect_fds(Socket *s, int **fds, unsigned *n_fds) {
2419         int *rfds;
2420         unsigned rn_fds, k;
2421         SocketPort *p;
2422
2423         assert(s);
2424         assert(fds);
2425         assert(n_fds);
2426
2427         /* Called from the service code for requesting our fds */
2428
2429         rn_fds = 0;
2430         LIST_FOREACH(port, p, s->ports)
2431                 if (p->fd >= 0)
2432                         rn_fds++;
2433
2434         if (rn_fds <= 0) {
2435                 *fds = NULL;
2436                 *n_fds = 0;
2437                 return 0;
2438         }
2439
2440         if (!(rfds = new(int, rn_fds)))
2441                 return -ENOMEM;
2442
2443         k = 0;
2444         LIST_FOREACH(port, p, s->ports)
2445                 if (p->fd >= 0)
2446                         rfds[k++] = p->fd;
2447
2448         assert(k == rn_fds);
2449
2450         *fds = rfds;
2451         *n_fds = rn_fds;
2452
2453         return 0;
2454 }
2455
2456 static void socket_reset_failed(Unit *u) {
2457         Socket *s = SOCKET(u);
2458
2459         assert(s);
2460
2461         if (s->state == SOCKET_FAILED)
2462                 socket_set_state(s, SOCKET_DEAD);
2463
2464         s->result = SOCKET_SUCCESS;
2465 }
2466
2467 static void socket_notify_service_dead(Socket *s, bool failed_permanent) {
2468         assert(s);
2469
2470         /* The service is dead. Dang!
2471          *
2472          * This is strictly for one-instance-for-all-connections
2473          * services. */
2474
2475         if (s->state == SOCKET_RUNNING) {
2476                 log_debug_unit(UNIT(s)->id, "%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
2477                 if (failed_permanent)
2478                         socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
2479                 else
2480                         socket_enter_listening(s);
2481         }
2482 }
2483
2484 void socket_connection_unref(Socket *s) {
2485         assert(s);
2486
2487         /* The service is dead. Yay!
2488          *
2489          * This is strictly for one-instance-per-connection
2490          * services. */
2491
2492         assert(s->n_connections > 0);
2493         s->n_connections--;
2494
2495         log_debug_unit(UNIT(s)->id, "%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2496 }
2497
2498 static void socket_trigger_notify(Unit *u, Unit *other) {
2499         Socket *s = SOCKET(u);
2500         Service *se;
2501
2502         assert(u);
2503         assert(other);
2504
2505         /* Don't propagate state changes from the service if we are
2506            already down or accepting connections */
2507         if ((s->state !=  SOCKET_RUNNING &&
2508             s->state != SOCKET_LISTENING) ||
2509             s->accept)
2510                 return;
2511
2512         if (other->load_state != UNIT_LOADED ||
2513             other->type != UNIT_SERVICE)
2514                 return;
2515
2516         se = SERVICE(other);
2517
2518         if (se->state == SERVICE_FAILED)
2519                 socket_notify_service_dead(s, se->result == SERVICE_FAILURE_START_LIMIT);
2520
2521         if (se->state == SERVICE_DEAD ||
2522             se->state == SERVICE_STOP ||
2523             se->state == SERVICE_STOP_SIGTERM ||
2524             se->state == SERVICE_STOP_SIGKILL ||
2525             se->state == SERVICE_STOP_POST ||
2526             se->state == SERVICE_FINAL_SIGTERM ||
2527             se->state == SERVICE_FINAL_SIGKILL ||
2528             se->state == SERVICE_AUTO_RESTART)
2529                 socket_notify_service_dead(s, false);
2530
2531         if (se->state == SERVICE_RUNNING)
2532                 socket_set_state(s, SOCKET_RUNNING);
2533 }
2534
2535 static int socket_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
2536         return unit_kill_common(u, who, signo, -1, SOCKET(u)->control_pid, error);
2537 }
2538
2539 static int socket_get_timeout(Unit *u, uint64_t *timeout) {
2540         Socket *s = SOCKET(u);
2541         int r;
2542
2543         if (!s->timer_event_source)
2544                 return 0;
2545
2546         r = sd_event_source_get_time(s->timer_event_source, timeout);
2547         if (r < 0)
2548                 return r;
2549
2550         return 1;
2551 }
2552
2553 static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
2554         [SOCKET_DEAD] = "dead",
2555         [SOCKET_START_PRE] = "start-pre",
2556         [SOCKET_START_CHOWN] = "start-chown",
2557         [SOCKET_START_POST] = "start-post",
2558         [SOCKET_LISTENING] = "listening",
2559         [SOCKET_RUNNING] = "running",
2560         [SOCKET_STOP_PRE] = "stop-pre",
2561         [SOCKET_STOP_PRE_SIGTERM] = "stop-pre-sigterm",
2562         [SOCKET_STOP_PRE_SIGKILL] = "stop-pre-sigkill",
2563         [SOCKET_STOP_POST] = "stop-post",
2564         [SOCKET_FINAL_SIGTERM] = "final-sigterm",
2565         [SOCKET_FINAL_SIGKILL] = "final-sigkill",
2566         [SOCKET_FAILED] = "failed"
2567 };
2568
2569 DEFINE_STRING_TABLE_LOOKUP(socket_state, SocketState);
2570
2571 static const char* const socket_exec_command_table[_SOCKET_EXEC_COMMAND_MAX] = {
2572         [SOCKET_EXEC_START_PRE] = "StartPre",
2573         [SOCKET_EXEC_START_CHOWN] = "StartChown",
2574         [SOCKET_EXEC_START_POST] = "StartPost",
2575         [SOCKET_EXEC_STOP_PRE] = "StopPre",
2576         [SOCKET_EXEC_STOP_POST] = "StopPost"
2577 };
2578
2579 DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2580
2581 static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
2582         [SOCKET_SUCCESS] = "success",
2583         [SOCKET_FAILURE_RESOURCES] = "resources",
2584         [SOCKET_FAILURE_TIMEOUT] = "timeout",
2585         [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
2586         [SOCKET_FAILURE_SIGNAL] = "signal",
2587         [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
2588         [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
2589 };
2590
2591 DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
2592
2593 const UnitVTable socket_vtable = {
2594         .object_size = sizeof(Socket),
2595         .exec_context_offset = offsetof(Socket, exec_context),
2596         .cgroup_context_offset = offsetof(Socket, cgroup_context),
2597         .kill_context_offset = offsetof(Socket, kill_context),
2598         .exec_runtime_offset = offsetof(Socket, exec_runtime),
2599
2600         .sections =
2601                 "Unit\0"
2602                 "Socket\0"
2603                 "Install\0",
2604         .private_section = "Socket",
2605
2606         .init = socket_init,
2607         .done = socket_done,
2608         .load = socket_load,
2609
2610         .coldplug = socket_coldplug,
2611
2612         .dump = socket_dump,
2613
2614         .start = socket_start,
2615         .stop = socket_stop,
2616
2617         .kill = socket_kill,
2618
2619         .get_timeout = socket_get_timeout,
2620
2621         .serialize = socket_serialize,
2622         .deserialize_item = socket_deserialize_item,
2623         .distribute_fds = socket_distribute_fds,
2624
2625         .active_state = socket_active_state,
2626         .sub_state_to_string = socket_sub_state_to_string,
2627
2628         .check_gc = socket_check_gc,
2629
2630         .sigchld_event = socket_sigchld_event,
2631
2632         .trigger_notify = socket_trigger_notify,
2633
2634         .reset_failed = socket_reset_failed,
2635
2636         .bus_interface = "org.freedesktop.systemd1.Socket",
2637         .bus_vtable = bus_socket_vtable,
2638         .bus_set_property = bus_socket_set_property,
2639         .bus_commit_properties = bus_socket_commit_properties,
2640
2641         .status_message_formats = {
2642                 /*.starting_stopping = {
2643                         [0] = "Starting socket %s...",
2644                         [1] = "Stopping socket %s...",
2645                 },*/
2646                 .finished_start_job = {
2647                         [JOB_DONE]       = "Listening on %s.",
2648                         [JOB_FAILED]     = "Failed to listen on %s.",
2649                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
2650                         [JOB_TIMEOUT]    = "Timed out starting %s.",
2651                 },
2652                 .finished_stop_job = {
2653                         [JOB_DONE]       = "Closed %s.",
2654                         [JOB_FAILED]     = "Failed stopping %s.",
2655                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
2656                 },
2657         },
2658 };