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