← Back to branch summary

~ubuntu-branches/debian/jessie/systemd/jessie

« back to all changes in this revision

Viewing changes to src/socket.c

  • Committer: Package Import Robot
  • Author(s): Tollef Fog Heen, Tollef Fog Heen, Michael Biebl
  • Date: 2012-04-03 19:59:17 UTC
  • mfrom: (1.1.10) (6.1.3 experimental)
  • Revision ID: package-import@ubuntu.com-20120403195917-l532urrbg4pkreas
Tags: 44-1
http://bugs.debian.org/664364
http://bugs.debian.org/663219
http://bugs.debian.org/663323
[ Tollef Fog Heen ]
* New upstream version.
  - Backport 3492207: journal: PAGE_SIZE is not known on ppc and other
    archs
  - Backport 5a2a2a1: journal: react with immediate rotation to a couple
    of more errors
  - Backport 693ce21: util: never follow symlinks in rm_rf_children()
    Fixes CVE-2012-1174, closes: #664364
* Drop output message from init-functions hook, it's pointless.
* Only rmdir /lib/init/rw if it exists.
* Explicitly order debian-fixup before sysinit.target to prevent a
  possible race condition with the creation of sockets.  Thanks to
  Michael Biebl for debugging this.
* Always restart the initctl socket on upgrades, to mask sysvinit
  removing it.

[ Michael Biebl ]
* Remove workaround for non-interactive sessions from pam config again.
* Create compat /dev/initctl symlink in case we are upgrading from a system
  running a newer version of sysvinit (using /run/initctl) and sysvinit is
  replaced with systemd-sysv during the upgrade. Closes: #663219
* Install new man pages.
* Build-Depend on valac (>= 0.12) instead of valac-0.12. Closes: #663323

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/socket.c
64
64
        Socket *s = SOCKET(u);
65
65
 
66
66
        assert(u);
67
 
        assert(u->meta.load_state == UNIT_STUB);
 
67
        assert(u->load_state == UNIT_STUB);
68
68
 
69
69
        s->backlog = SOMAXCONN;
70
70
        s->timeout_usec = DEFAULT_TIMEOUT_USEC;
79
79
        s->mark = -1;
80
80
 
81
81
        exec_context_init(&s->exec_context);
82
 
        s->exec_context.std_output = u->meta.manager->default_std_output;
83
 
        s->exec_context.std_error = u->meta.manager->default_std_error;
 
82
        s->exec_context.std_output = u->manager->default_std_output;
 
83
        s->exec_context.std_error = u->manager->default_std_error;
84
84
 
85
85
        s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
86
86
}
98
98
static void socket_done(Unit *u) {
99
99
        Socket *s = SOCKET(u);
100
100
        SocketPort *p;
101
 
        Meta *i;
102
101
 
103
102
        assert(s);
104
103
 
120
119
 
121
120
        socket_unwatch_control_pid(s);
122
121
 
123
 
        s->service = NULL;
 
122
        unit_ref_unset(&s->service);
124
123
 
125
124
        free(s->tcp_congestion);
126
125
        s->tcp_congestion = NULL;
129
128
        s->bind_to_device = NULL;
130
129
 
131
130
        unit_unwatch_timer(u, &s->timer_watch);
132
 
 
133
 
        /* Make sure no service instance refers to us anymore. */
134
 
        LIST_FOREACH(units_by_type, i, u->meta.manager->units_by_type[UNIT_SERVICE]) {
135
 
                Service *service = (Service *) i;
136
 
 
137
 
                if (service->accept_socket == s)
138
 
                        service->accept_socket = NULL;
139
 
 
140
 
                set_remove(service->configured_sockets, s);
141
 
        }
142
131
}
143
132
 
144
133
static int socket_instantiate_service(Socket *s) {
153
142
         * here. For Accept=no this is mostly a NOP since the service
154
143
         * is figured out at load time anyway. */
155
144
 
156
 
        if (s->service)
 
145
        if (UNIT_DEREF(s->service))
157
146
                return 0;
158
147
 
159
148
        assert(s->accept);
160
149
 
161
 
        if (!(prefix = unit_name_to_prefix(s->meta.id)))
 
150
        if (!(prefix = unit_name_to_prefix(UNIT(s)->id)))
162
151
                return -ENOMEM;
163
152
 
164
153
        r = asprintf(&name, "%s@%u.service", prefix, s->n_accepted);
167
156
        if (r < 0)
168
157
                return -ENOMEM;
169
158
 
170
 
        r = manager_load_unit(s->meta.manager, name, NULL, NULL, &u);
 
159
        r = manager_load_unit(UNIT(s)->manager, name, NULL, NULL, &u);
171
160
        free(name);
172
161
 
173
162
        if (r < 0)
180
169
        }
181
170
#endif
182
171
 
183
 
        u->meta.no_gc = true;
184
 
        s->service = SERVICE(u);
185
 
        return 0;
 
172
        u->no_gc = true;
 
173
        unit_ref_set(&s->service, u);
 
174
 
 
175
        return unit_add_two_dependencies(UNIT(s), UNIT_BEFORE, UNIT_TRIGGERS, u, false);
186
176
}
187
177
 
188
178
static bool have_non_accept_socket(Socket *s) {
208
198
static int socket_verify(Socket *s) {
209
199
        assert(s);
210
200
 
211
 
        if (s->meta.load_state != UNIT_LOADED)
 
201
        if (UNIT(s)->load_state != UNIT_LOADED)
212
202
                return 0;
213
203
 
214
204
        if (!s->ports) {
215
 
                log_error("%s lacks Listen setting. Refusing.", s->meta.id);
 
205
                log_error("%s lacks Listen setting. Refusing.", UNIT(s)->id);
216
206
                return -EINVAL;
217
207
        }
218
208
 
219
209
        if (s->accept && have_non_accept_socket(s)) {
220
 
                log_error("%s configured for accepting sockets, but sockets are non-accepting. Refusing.", s->meta.id);
 
210
                log_error("%s configured for accepting sockets, but sockets are non-accepting. Refusing.", UNIT(s)->id);
221
211
                return -EINVAL;
222
212
        }
223
213
 
224
214
        if (s->accept && s->max_connections <= 0) {
225
 
                log_error("%s's MaxConnection setting too small. Refusing.", s->meta.id);
 
215
                log_error("%s's MaxConnection setting too small. Refusing.", UNIT(s)->id);
226
216
                return -EINVAL;
227
217
        }
228
218
 
229
 
        if (s->accept && s->service) {
230
 
                log_error("Explicit service configuration for accepting sockets not supported on %s. Refusing.", s->meta.id);
 
219
        if (s->accept && UNIT_DEREF(s->service)) {
 
220
                log_error("Explicit service configuration for accepting sockets not supported on %s. Refusing.", UNIT(s)->id);
231
221
                return -EINVAL;
232
222
        }
233
223
 
234
224
        if (s->exec_context.pam_name && s->exec_context.kill_mode != KILL_CONTROL_GROUP) {
235
 
                log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", s->meta.id);
 
225
                log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(s)->id);
236
226
                return -EINVAL;
237
227
        }
238
228
 
264
254
        assert(s);
265
255
        assert(m);
266
256
 
267
 
        if (s->meta.load_state != UNIT_LOADED ||
268
 
            m->meta.load_state != UNIT_LOADED)
 
257
        if (UNIT(s)->load_state != UNIT_LOADED ||
 
258
            UNIT(m)->load_state != UNIT_LOADED)
269
259
                return 0;
270
260
 
271
261
        if (!socket_needs_mount(s, m->where))
278
268
}
279
269
 
280
270
static int socket_add_mount_links(Socket *s) {
281
 
        Meta *other;
 
271
        Unit *other;
282
272
        int r;
283
273
 
284
274
        assert(s);
285
275
 
286
 
        LIST_FOREACH(units_by_type, other, s->meta.manager->units_by_type[UNIT_MOUNT])
287
 
                if ((r = socket_add_one_mount_link(s, (Mount*) other)) < 0)
 
276
        LIST_FOREACH(units_by_type, other, UNIT(s)->manager->units_by_type[UNIT_MOUNT])
 
277
                if ((r = socket_add_one_mount_link(s, MOUNT(other))) < 0)
288
278
                        return r;
289
279
 
290
280
        return 0;
312
302
        int r;
313
303
        assert(s);
314
304
 
315
 
        if (s->meta.manager->running_as == MANAGER_SYSTEM) {
 
305
        if (UNIT(s)->manager->running_as == MANAGER_SYSTEM) {
316
306
                if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_BEFORE, SPECIAL_SOCKETS_TARGET, NULL, true)) < 0)
317
307
                        return r;
318
308
 
323
313
        return unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
324
314
}
325
315
 
 
316
static bool socket_has_exec(Socket *s) {
 
317
        unsigned i;
 
318
        assert(s);
 
319
 
 
320
        for (i = 0; i < _SOCKET_EXEC_COMMAND_MAX; i++)
 
321
                if (s->exec_command[i])
 
322
                        return true;
 
323
 
 
324
        return false;
 
325
}
 
326
 
326
327
static int socket_load(Unit *u) {
327
328
        Socket *s = SOCKET(u);
328
329
        int r;
329
330
 
330
331
        assert(u);
331
 
        assert(u->meta.load_state == UNIT_STUB);
 
332
        assert(u->load_state == UNIT_STUB);
332
333
 
333
334
        if ((r = unit_load_fragment_and_dropin(u)) < 0)
334
335
                return r;
335
336
 
336
337
        /* This is a new unit? Then let's add in some extras */
337
 
        if (u->meta.load_state == UNIT_LOADED) {
 
338
        if (u->load_state == UNIT_LOADED) {
338
339
 
339
340
                if (have_non_accept_socket(s)) {
340
341
 
341
 
                        if (!s->service)
342
 
                                if ((r = unit_load_related_unit(u, ".service", (Unit**) &s->service)) < 0)
 
342
                        if (!UNIT_DEREF(s->service)) {
 
343
                                Unit *x;
 
344
 
 
345
                                r = unit_load_related_unit(u, ".service", &x);
 
346
                                if (r < 0)
343
347
                                        return r;
344
348
 
345
 
                        if ((r = unit_add_dependency(u, UNIT_BEFORE, UNIT(s->service), true)) < 0)
 
349
                                unit_ref_set(&s->service, x);
 
350
                        }
 
351
 
 
352
                        r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(s->service), true);
 
353
                        if (r < 0)
346
354
                                return r;
347
355
                }
348
356
 
352
360
                if ((r = socket_add_device_link(s)) < 0)
353
361
                        return r;
354
362
 
355
 
                if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
356
 
                        return r;
 
363
                if (socket_has_exec(s))
 
364
                        if ((r = unit_add_exec_dependencies(u, &s->exec_context)) < 0)
 
365
                                return r;
357
366
 
358
367
                if ((r = unit_add_default_cgroups(u)) < 0)
359
368
                        return r;
360
369
 
361
 
                if (s->meta.default_dependencies)
 
370
                if (UNIT(s)->default_dependencies)
362
371
                        if ((r = socket_add_default_dependencies(s)) < 0)
363
372
                                return r;
364
373
        }
398
407
 
399
408
        fprintf(f,
400
409
                "%sSocket State: %s\n"
 
410
                "%sResult: %s\n"
401
411
                "%sBindIPv6Only: %s\n"
402
412
                "%sBacklog: %u\n"
403
413
                "%sSocketMode: %04o\n"
406
416
                "%sFreeBind: %s\n"
407
417
                "%sTransparent: %s\n"
408
418
                "%sBroadcast: %s\n"
 
419
                "%sPassCredentials: %s\n"
 
420
                "%sPassSecurity: %s\n"
409
421
                "%sTCPCongestion: %s\n",
410
422
                prefix, socket_state_to_string(s->state),
 
423
                prefix, socket_result_to_string(s->result),
411
424
                prefix, socket_address_bind_ipv6_only_to_string(s->bind_ipv6_only),
412
425
                prefix, s->backlog,
413
426
                prefix, s->socket_mode,
416
429
                prefix, yes_no(s->free_bind),
417
430
                prefix, yes_no(s->transparent),
418
431
                prefix, yes_no(s->broadcast),
 
432
                prefix, yes_no(s->pass_cred),
 
433
                prefix, yes_no(s->pass_sec),
419
434
                prefix, strna(s->tcp_congestion));
420
435
 
421
436
        if (s->control_pid > 0)
549
564
                        b = ntohl(remote.in.sin_addr.s_addr);
550
565
 
551
566
                if (asprintf(&r,
552
 
                             "%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 
567
                             "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 
568
                             nr,
553
569
                             a >> 24, (a >> 16) & 0xFF, (a >> 8) & 0xFF, a & 0xFF,
554
570
                             ntohs(local.in.sin_port),
555
571
                             b >> 24, (b >> 16) & 0xFF, (b >> 8) & 0xFF, b & 0xFF,
571
587
                                *b = remote.in6.sin6_addr.s6_addr+12;
572
588
 
573
589
                        if (asprintf(&r,
574
 
                                     "%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 
590
                                     "%u-%u.%u.%u.%u:%u-%u.%u.%u.%u:%u",
 
591
                                     nr,
575
592
                                     a[0], a[1], a[2], a[3],
576
593
                                     ntohs(local.in6.sin6_port),
577
594
                                     b[0], b[1], b[2], b[3],
581
598
                        char a[INET6_ADDRSTRLEN], b[INET6_ADDRSTRLEN];
582
599
 
583
600
                        if (asprintf(&r,
584
 
                                     "%s:%u-%s:%u",
 
601
                                     "%u-%s:%u-%s:%u",
 
602
                                     nr,
585
603
                                     inet_ntop(AF_INET6, &local.in6.sin6_addr, a, sizeof(a)),
586
604
                                     ntohs(local.in6.sin6_port),
587
605
                                     inet_ntop(AF_INET6, &remote.in6.sin6_addr, b, sizeof(b)),
657
675
                        log_warning("SO_BROADCAST failed: %m");
658
676
        }
659
677
 
 
678
        if (s->pass_cred) {
 
679
                int one = 1;
 
680
                if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &one, sizeof(one)) < 0)
 
681
                        log_warning("SO_PASSCRED failed: %m");
 
682
        }
 
683
 
 
684
        if (s->pass_sec) {
 
685
                int one = 1;
 
686
                if (setsockopt(fd, SOL_SOCKET, SO_PASSSEC, &one, sizeof(one)) < 0)
 
687
                        log_warning("SO_PASSSEC failed: %m");
 
688
        }
 
689
 
660
690
        if (s->priority >= 0)
661
691
                if (setsockopt(fd, SOL_SOCKET, SO_PRIORITY, &s->priority, sizeof(s->priority)) < 0)
662
692
                        log_warning("SO_PRIORITY failed: %m");
663
693
 
664
694
        if (s->receive_buffer > 0) {
665
695
                int value = (int) s->receive_buffer;
 
696
 
 
697
                /* We first try with SO_RCVBUFFORCE, in case we have the perms for that */
 
698
 
666
699
                if (setsockopt(fd, SOL_SOCKET, SO_RCVBUFFORCE, &value, sizeof(value)) < 0)
667
 
                        log_warning("SO_RCVBUFFORCE failed: %m");
 
700
                        if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &value, sizeof(value)) < 0)
 
701
                                log_warning("SO_RCVBUF failed: %m");
668
702
        }
669
703
 
670
704
        if (s->send_buffer > 0) {
671
705
                int value = (int) s->send_buffer;
672
706
                if (setsockopt(fd, SOL_SOCKET, SO_SNDBUFFORCE, &value, sizeof(value)) < 0)
673
 
                        log_warning("SO_SNDBUFFORCE failed: %m");
 
707
                        if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &value, sizeof(value)) < 0)
 
708
                                log_warning("SO_SNDBUF failed: %m");
674
709
        }
675
710
 
676
711
        if (s->mark >= 0)
892
927
                                if ((r = socket_instantiate_service(s)) < 0)
893
928
                                        return r;
894
929
 
895
 
                                if (s->service && s->service->exec_command[SERVICE_EXEC_START]) {
896
 
                                        r = label_get_create_label_from_exe(s->service->exec_command[SERVICE_EXEC_START]->path, &label);
 
930
                                if (UNIT_DEREF(s->service) &&
 
931
                                    SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]) {
 
932
                                        r = label_get_create_label_from_exe(SERVICE(UNIT_DEREF(s->service))->exec_command[SERVICE_EXEC_START]->path, &label);
897
933
 
898
934
                                        if (r < 0) {
899
935
                                                if (r != -EPERM)
1031
1067
 
1032
1068
        if (state != old_state)
1033
1069
                log_debug("%s changed %s -> %s",
1034
 
                          s->meta.id,
 
1070
                          UNIT(s)->id,
1035
1071
                          socket_state_to_string(old_state),
1036
1072
                          socket_state_to_string(state));
1037
1073
 
1106
1142
                       argv,
1107
1143
                       &s->exec_context,
1108
1144
                       NULL, 0,
1109
 
                       s->meta.manager->environment,
1110
 
                       true,
1111
 
                       true,
1112
 
                       true,
1113
 
                       s->meta.manager->confirm_spawn,
1114
 
                       s->meta.cgroup_bondings,
1115
 
                       s->meta.cgroup_attributes,
 
1145
                       UNIT(s)->manager->environment,
 
1146
                       true,
 
1147
                       true,
 
1148
                       true,
 
1149
                       UNIT(s)->manager->confirm_spawn,
 
1150
                       UNIT(s)->cgroup_bondings,
 
1151
                       UNIT(s)->cgroup_attributes,
1116
1152
                       &pid);
1117
1153
 
1118
1154
        strv_free(argv);
1133
1169
        return r;
1134
1170
}
1135
1171
 
1136
 
static void socket_enter_dead(Socket *s, bool success) {
 
1172
static void socket_enter_dead(Socket *s, SocketResult f) {
1137
1173
        assert(s);
1138
1174
 
1139
 
        if (!success)
1140
 
                s->failure = true;
 
1175
        if (f != SOCKET_SUCCESS)
 
1176
                s->result = f;
1141
1177
 
1142
 
        socket_set_state(s, s->failure ? SOCKET_FAILED : SOCKET_DEAD);
 
1178
        socket_set_state(s, s->result != SOCKET_SUCCESS ? SOCKET_FAILED : SOCKET_DEAD);
1143
1179
}
1144
1180
 
1145
 
static void socket_enter_signal(Socket *s, SocketState state, bool success);
 
1181
static void socket_enter_signal(Socket *s, SocketState state, SocketResult f);
1146
1182
 
1147
 
static void socket_enter_stop_post(Socket *s, bool success) {
 
1183
static void socket_enter_stop_post(Socket *s, SocketResult f) {
1148
1184
        int r;
1149
1185
        assert(s);
1150
1186
 
1151
 
        if (!success)
1152
 
                s->failure = true;
 
1187
        if (f != SOCKET_SUCCESS)
 
1188
                s->result = f;
1153
1189
 
1154
1190
        socket_unwatch_control_pid(s);
1155
1191
 
1161
1197
 
1162
1198
                socket_set_state(s, SOCKET_STOP_POST);
1163
1199
        } else
1164
 
                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, true);
 
1200
                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_SUCCESS);
1165
1201
 
1166
1202
        return;
1167
1203
 
1168
1204
fail:
1169
 
        log_warning("%s failed to run 'stop-post' task: %s", s->meta.id, strerror(-r));
1170
 
        socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
 
1205
        log_warning("%s failed to run 'stop-post' task: %s", UNIT(s)->id, strerror(-r));
 
1206
        socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1171
1207
}
1172
1208
 
1173
 
static void socket_enter_signal(Socket *s, SocketState state, bool success) {
 
1209
static void socket_enter_signal(Socket *s, SocketState state, SocketResult f) {
1174
1210
        int r;
1175
1211
        Set *pid_set = NULL;
1176
1212
        bool wait_for_exit = false;
1177
1213
 
1178
1214
        assert(s);
1179
1215
 
1180
 
        if (!success)
1181
 
                s->failure = true;
 
1216
        if (f != SOCKET_SUCCESS)
 
1217
                s->result = f;
1182
1218
 
1183
1219
        if (s->exec_context.kill_mode != KILL_NONE) {
1184
1220
                int sig = (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_FINAL_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
1203
1239
                                if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
1204
1240
                                        goto fail;
1205
1241
 
1206
 
                        if ((r = cgroup_bonding_kill_list(s->meta.cgroup_bondings, sig, true, pid_set)) < 0) {
 
1242
                        if ((r = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, sig, true, pid_set)) < 0) {
1207
1243
                                if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
1208
1244
                                        log_warning("Failed to kill control group: %s", strerror(-r));
1209
1245
                        } else if (r > 0)
1220
1256
 
1221
1257
                socket_set_state(s, state);
1222
1258
        } else if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1223
 
                socket_enter_stop_post(s, true);
 
1259
                socket_enter_stop_post(s, SOCKET_SUCCESS);
1224
1260
        else
1225
 
                socket_enter_dead(s, true);
 
1261
                socket_enter_dead(s, SOCKET_SUCCESS);
1226
1262
 
1227
1263
        return;
1228
1264
 
1229
1265
fail:
1230
 
        log_warning("%s failed to kill processes: %s", s->meta.id, strerror(-r));
 
1266
        log_warning("%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
1231
1267
 
1232
1268
        if (state == SOCKET_STOP_PRE_SIGTERM || state == SOCKET_STOP_PRE_SIGKILL)
1233
 
                socket_enter_stop_post(s, false);
 
1269
                socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1234
1270
        else
1235
 
                socket_enter_dead(s, false);
 
1271
                socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1236
1272
 
1237
1273
        if (pid_set)
1238
1274
                set_free(pid_set);
1239
1275
}
1240
1276
 
1241
 
static void socket_enter_stop_pre(Socket *s, bool success) {
 
1277
static void socket_enter_stop_pre(Socket *s, SocketResult f) {
1242
1278
        int r;
1243
1279
        assert(s);
1244
1280
 
1245
 
        if (!success)
1246
 
                s->failure = true;
 
1281
        if (f != SOCKET_SUCCESS)
 
1282
                s->result = f;
1247
1283
 
1248
1284
        socket_unwatch_control_pid(s);
1249
1285
 
1255
1291
 
1256
1292
                socket_set_state(s, SOCKET_STOP_PRE);
1257
1293
        } else
1258
 
                socket_enter_stop_post(s, true);
 
1294
                socket_enter_stop_post(s, SOCKET_SUCCESS);
1259
1295
 
1260
1296
        return;
1261
1297
 
1262
1298
fail:
1263
 
        log_warning("%s failed to run 'stop-pre' task: %s", s->meta.id, strerror(-r));
1264
 
        socket_enter_stop_post(s, false);
 
1299
        log_warning("%s failed to run 'stop-pre' task: %s", UNIT(s)->id, strerror(-r));
 
1300
        socket_enter_stop_post(s, SOCKET_FAILURE_RESOURCES);
1265
1301
}
1266
1302
 
1267
1303
static void socket_enter_listening(Socket *s) {
1268
1304
        int r;
1269
1305
        assert(s);
1270
1306
 
1271
 
        if ((r = socket_watch_fds(s)) < 0) {
1272
 
                log_warning("%s failed to watch sockets: %s", s->meta.id, strerror(-r));
 
1307
        r = socket_watch_fds(s);
 
1308
        if (r < 0) {
 
1309
                log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
1273
1310
                goto fail;
1274
1311
        }
1275
1312
 
1277
1314
        return;
1278
1315
 
1279
1316
fail:
1280
 
        socket_enter_stop_pre(s, false);
 
1317
        socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1281
1318
}
1282
1319
 
1283
1320
static void socket_enter_start_post(Socket *s) {
1284
1321
        int r;
1285
1322
        assert(s);
1286
1323
 
1287
 
        if ((r = socket_open_fds(s)) < 0) {
1288
 
                log_warning("%s failed to listen on sockets: %s", s->meta.id, strerror(-r));
 
1324
        r = socket_open_fds(s);
 
1325
        if (r < 0) {
 
1326
                log_warning("%s failed to listen on sockets: %s", UNIT(s)->id, strerror(-r));
1289
1327
                goto fail;
1290
1328
        }
1291
1329
 
1294
1332
        s->control_command_id = SOCKET_EXEC_START_POST;
1295
1333
 
1296
1334
        if ((s->control_command = s->exec_command[SOCKET_EXEC_START_POST])) {
1297
 
                if ((r = socket_spawn(s, s->control_command, &s->control_pid)) < 0) {
1298
 
                        log_warning("%s failed to run 'start-post' task: %s", s->meta.id, strerror(-r));
 
1335
                r = socket_spawn(s, s->control_command, &s->control_pid);
 
1336
                if (r < 0) {
 
1337
                        log_warning("%s failed to run 'start-post' task: %s", UNIT(s)->id, strerror(-r));
1299
1338
                        goto fail;
1300
1339
                }
1301
1340
 
1306
1345
        return;
1307
1346
 
1308
1347
fail:
1309
 
        socket_enter_stop_pre(s, false);
 
1348
        socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1310
1349
}
1311
1350
 
1312
1351
static void socket_enter_start_pre(Socket *s) {
1328
1367
        return;
1329
1368
 
1330
1369
fail:
1331
 
        log_warning("%s failed to run 'start-pre' task: %s", s->meta.id, strerror(-r));
1332
 
        socket_enter_dead(s, false);
 
1370
        log_warning("%s failed to run 'start-pre' task: %s", UNIT(s)->id, strerror(-r));
 
1371
        socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1333
1372
}
1334
1373
 
1335
1374
static void socket_enter_running(Socket *s, int cfd) {
1342
1381
        /* We don't take connections anymore if we are supposed to
1343
1382
         * shut down anyway */
1344
1383
        if (unit_pending_inactive(UNIT(s))) {
1345
 
                log_debug("Suppressing connection request on %s since unit stop is scheduled.", s->meta.id);
 
1384
                log_debug("Suppressing connection request on %s since unit stop is scheduled.", UNIT(s)->id);
1346
1385
 
1347
1386
                if (cfd >= 0)
1348
1387
                        close_nointr_nofail(cfd);
1350
1389
                        /* Flush all sockets by closing and reopening them */
1351
1390
                        socket_close_fds(s);
1352
1391
 
1353
 
                        if ((r = socket_watch_fds(s)) < 0) {
1354
 
                                log_warning("%s failed to watch sockets: %s", s->meta.id, strerror(-r));
1355
 
                                socket_enter_stop_pre(s, false);
 
1392
                        r = socket_watch_fds(s);
 
1393
                        if (r < 0) {
 
1394
                                log_warning("%s failed to watch sockets: %s", UNIT(s)->id, strerror(-r));
 
1395
                                socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1356
1396
                        }
1357
1397
                }
1358
1398
 
1360
1400
        }
1361
1401
 
1362
1402
        if (cfd < 0) {
 
1403
                Iterator i;
 
1404
                Unit *u;
1363
1405
                bool pending = false;
1364
 
                Meta *i;
1365
1406
 
1366
1407
                /* If there's already a start pending don't bother to
1367
1408
                 * do anything */
1368
 
                LIST_FOREACH(units_by_type, i, s->meta.manager->units_by_type[UNIT_SERVICE]) {
1369
 
                        Service *service = (Service *) i;
1370
 
 
1371
 
                        if (!set_get(service->configured_sockets, s))
1372
 
                                continue;
1373
 
 
1374
 
                        if (!unit_pending_active(UNIT(service)))
1375
 
                                continue;
1376
 
 
1377
 
                        pending = true;
1378
 
                        break;
 
1409
                SET_FOREACH(u, UNIT(s)->dependencies[UNIT_TRIGGERS], i)
 
1410
                        if (unit_pending_active(u)) {
 
1411
                                pending = true;
 
1412
                                break;
 
1413
                        }
 
1414
 
 
1415
                if (!pending) {
 
1416
                        r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT_DEREF(s->service), JOB_REPLACE, true, &error, NULL);
 
1417
                        if (r < 0)
 
1418
                                goto fail;
1379
1419
                }
1380
1420
 
1381
 
                if (!pending)
1382
 
                        if ((r = manager_add_job(s->meta.manager, JOB_START, UNIT(s->service), JOB_REPLACE, true, &error, NULL)) < 0)
1383
 
                                goto fail;
1384
 
 
1385
1421
                socket_set_state(s, SOCKET_RUNNING);
1386
1422
        } else {
1387
1423
                char *prefix, *instance = NULL, *name;
1393
1429
                        return;
1394
1430
                }
1395
1431
 
1396
 
                if ((r = socket_instantiate_service(s)) < 0)
1397
 
                        goto fail;
1398
 
 
1399
 
                if ((r = instance_from_socket(cfd, s->n_accepted, &instance)) < 0)
1400
 
                        goto fail;
1401
 
 
1402
 
                if (!(prefix = unit_name_to_prefix(s->meta.id))) {
 
1432
                r = socket_instantiate_service(s);
 
1433
                if (r < 0)
 
1434
                        goto fail;
 
1435
 
 
1436
                r = instance_from_socket(cfd, s->n_accepted, &instance);
 
1437
                if (r < 0) {
 
1438
                        if (r != -ENOTCONN)
 
1439
                                goto fail;
 
1440
 
 
1441
                        /* ENOTCONN is legitimate if TCP RST was received.
 
1442
                         * This connection is over, but the socket unit lives on. */
 
1443
                        close_nointr_nofail(cfd);
 
1444
                        return;
 
1445
                }
 
1446
 
 
1447
                prefix = unit_name_to_prefix(UNIT(s)->id);
 
1448
                if (!prefix) {
1403
1449
                        free(instance);
1404
1450
                        r = -ENOMEM;
1405
1451
                        goto fail;
1414
1460
                        goto fail;
1415
1461
                }
1416
1462
 
1417
 
                if ((r = unit_add_name(UNIT(s->service), name)) < 0) {
 
1463
                r = unit_add_name(UNIT_DEREF(s->service), name);
 
1464
                if (r < 0) {
1418
1465
                        free(name);
1419
1466
                        goto fail;
1420
1467
                }
1421
1468
 
1422
 
                service = s->service;
1423
 
                s->service = NULL;
 
1469
                service = SERVICE(UNIT_DEREF(s->service));
 
1470
                unit_ref_unset(&s->service);
1424
1471
                s->n_accepted ++;
1425
1472
 
1426
 
                service->meta.no_gc = false;
 
1473
                UNIT(service)->no_gc = false;
1427
1474
 
1428
1475
                unit_choose_id(UNIT(service), name);
1429
1476
                free(name);
1430
1477
 
1431
 
                if ((r = service_set_socket_fd(service, cfd, s)) < 0)
 
1478
                r = service_set_socket_fd(service, cfd, s);
 
1479
                if (r < 0)
1432
1480
                        goto fail;
1433
1481
 
1434
1482
                cfd = -1;
1435
1483
                s->n_connections ++;
1436
1484
 
1437
 
                if ((r = manager_add_job(s->meta.manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL)) < 0)
 
1485
                r = manager_add_job(UNIT(s)->manager, JOB_START, UNIT(service), JOB_REPLACE, true, &error, NULL);
 
1486
                if (r < 0)
1438
1487
                        goto fail;
1439
1488
 
1440
1489
                /* Notify clients about changed counters */
1444
1493
        return;
1445
1494
 
1446
1495
fail:
1447
 
        log_warning("%s failed to queue socket startup job: %s", s->meta.id, bus_error(&error, r));
1448
 
        socket_enter_stop_pre(s, false);
 
1496
        log_warning("%s failed to queue socket startup job: %s", UNIT(s)->id, bus_error(&error, r));
1449
1497
 
1450
1498
        if (cfd >= 0)
1451
1499
                close_nointr_nofail(cfd);
1453
1501
        dbus_error_free(&error);
1454
1502
}
1455
1503
 
1456
 
static void socket_run_next(Socket *s, bool success) {
 
1504
static void socket_run_next(Socket *s) {
1457
1505
        int r;
1458
1506
 
1459
1507
        assert(s);
1460
1508
        assert(s->control_command);
1461
1509
        assert(s->control_command->command_next);
1462
1510
 
1463
 
        if (!success)
1464
 
                s->failure = true;
1465
 
 
1466
1511
        socket_unwatch_control_pid(s);
1467
1512
 
1468
1513
        s->control_command = s->control_command->command_next;
1473
1518
        return;
1474
1519
 
1475
1520
fail:
1476
 
        log_warning("%s failed to run next task: %s", s->meta.id, strerror(-r));
 
1521
        log_warning("%s failed to run next task: %s", UNIT(s)->id, strerror(-r));
1477
1522
 
1478
1523
        if (s->state == SOCKET_START_POST)
1479
 
                socket_enter_stop_pre(s, false);
 
1524
                socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1480
1525
        else if (s->state == SOCKET_STOP_POST)
1481
 
                socket_enter_dead(s, false);
 
1526
                socket_enter_dead(s, SOCKET_FAILURE_RESOURCES);
1482
1527
        else
1483
 
                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
 
1528
                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_RESOURCES);
1484
1529
}
1485
1530
 
1486
1531
static int socket_start(Unit *u) {
1503
1548
                return 0;
1504
1549
 
1505
1550
        /* Cannot run this without the service being around */
1506
 
        if (s->service) {
1507
 
                if (s->service->meta.load_state != UNIT_LOADED) {
1508
 
                        log_error("Socket service %s not loaded, refusing.", s->service->meta.id);
 
1551
        if (UNIT_DEREF(s->service)) {
 
1552
                Service *service;
 
1553
 
 
1554
                service = SERVICE(UNIT_DEREF(s->service));
 
1555
 
 
1556
                if (UNIT(service)->load_state != UNIT_LOADED) {
 
1557
                        log_error("Socket service %s not loaded, refusing.", UNIT(service)->id);
1509
1558
                        return -ENOENT;
1510
1559
                }
1511
1560
 
1512
1561
                /* If the service is already active we cannot start the
1513
1562
                 * socket */
1514
 
                if (s->service->state != SERVICE_DEAD &&
1515
 
                    s->service->state != SERVICE_FAILED &&
1516
 
                    s->service->state != SERVICE_AUTO_RESTART) {
1517
 
                        log_error("Socket service %s already active, refusing.", s->service->meta.id);
 
1563
                if (service->state != SERVICE_DEAD &&
 
1564
                    service->state != SERVICE_FAILED &&
 
1565
                    service->state != SERVICE_AUTO_RESTART) {
 
1566
                        log_error("Socket service %s already active, refusing.", UNIT(service)->id);
1518
1567
                        return -EBUSY;
1519
1568
                }
1520
1569
 
1521
1570
#ifdef HAVE_SYSV_COMPAT
1522
 
                if (s->service->sysv_path) {
 
1571
                if (service->sysv_path) {
1523
1572
                        log_error("Using SysV services for socket activation is not supported. Refusing.");
1524
1573
                        return -ENOENT;
1525
1574
                }
1528
1577
 
1529
1578
        assert(s->state == SOCKET_DEAD || s->state == SOCKET_FAILED);
1530
1579
 
1531
 
        s->failure = false;
 
1580
        s->result = SOCKET_SUCCESS;
1532
1581
        socket_enter_start_pre(s);
1533
1582
        return 0;
1534
1583
}
1551
1600
         * kill mode. */
1552
1601
        if (s->state == SOCKET_START_PRE ||
1553
1602
            s->state == SOCKET_START_POST) {
1554
 
                socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, true);
 
1603
                socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_SUCCESS);
1555
1604
                return -EAGAIN;
1556
1605
        }
1557
1606
 
1558
1607
        assert(s->state == SOCKET_LISTENING || s->state == SOCKET_RUNNING);
1559
1608
 
1560
 
        socket_enter_stop_pre(s, true);
 
1609
        socket_enter_stop_pre(s, SOCKET_SUCCESS);
1561
1610
        return 0;
1562
1611
}
1563
1612
 
1571
1620
        assert(fds);
1572
1621
 
1573
1622
        unit_serialize_item(u, f, "state", socket_state_to_string(s->state));
1574
 
        unit_serialize_item(u, f, "failure", yes_no(s->failure));
 
1623
        unit_serialize_item(u, f, "result", socket_result_to_string(s->result));
1575
1624
        unit_serialize_item_format(u, f, "n-accepted", "%u", s->n_accepted);
1576
1625
 
1577
1626
        if (s->control_pid > 0)
1626
1675
                        log_debug("Failed to parse state value %s", value);
1627
1676
                else
1628
1677
                        s->deserialized_state = state;
1629
 
        } else if (streq(key, "failure")) {
1630
 
                int b;
 
1678
        } else if (streq(key, "result")) {
 
1679
                SocketResult f;
1631
1680
 
1632
 
                if ((b = parse_boolean(value)) < 0)
1633
 
                        log_debug("Failed to parse failure value %s", value);
1634
 
                else
1635
 
                        s->failure = b || s->failure;
 
1681
                f = socket_result_from_string(value);
 
1682
                if (f < 0)
 
1683
                        log_debug("Failed to parse result value %s", value);
 
1684
                else if (f != SOCKET_SUCCESS)
 
1685
                        s->result = f;
1636
1686
 
1637
1687
        } else if (streq(key, "n-accepted")) {
1638
1688
                unsigned k;
1771
1821
        if (s->state != SOCKET_LISTENING)
1772
1822
                return;
1773
1823
 
1774
 
        log_debug("Incoming traffic on %s", u->meta.id);
 
1824
        log_debug("Incoming traffic on %s", u->id);
1775
1825
 
1776
1826
        if (events != EPOLLIN) {
1777
1827
 
1778
1828
                if (events & EPOLLHUP)
1779
 
                        log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->meta.id);
 
1829
                        log_error("%s: Got POLLHUP on a listening socket. The service probably invoked shutdown() on it, and should better not do that.", u->id);
1780
1830
                else
1781
 
                        log_error("%s: Got unexpected poll event (0x%x) on socket.", u->meta.id, events);
 
1831
                        log_error("%s: Got unexpected poll event (0x%x) on socket.", u->id, events);
1782
1832
 
1783
1833
                goto fail;
1784
1834
        }
1805
1855
        return;
1806
1856
 
1807
1857
fail:
1808
 
        socket_enter_stop_pre(s, false);
 
1858
        socket_enter_stop_pre(s, SOCKET_FAILURE_RESOURCES);
1809
1859
}
1810
1860
 
1811
1861
static void socket_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1812
1862
        Socket *s = SOCKET(u);
1813
 
        bool success;
 
1863
        SocketResult f;
1814
1864
 
1815
1865
        assert(s);
1816
1866
        assert(pid >= 0);
1820
1870
 
1821
1871
        s->control_pid = 0;
1822
1872
 
1823
 
        success = is_clean_exit(code, status);
 
1873
        if (is_clean_exit(code, status))
 
1874
                f = SOCKET_SUCCESS;
 
1875
        else if (code == CLD_EXITED)
 
1876
                f = SOCKET_FAILURE_EXIT_CODE;
 
1877
        else if (code == CLD_KILLED)
 
1878
                f = SOCKET_FAILURE_SIGNAL;
 
1879
        else if (code == CLD_DUMPED)
 
1880
                f = SOCKET_FAILURE_CORE_DUMP;
 
1881
        else
 
1882
                assert_not_reached("Unknown code");
1824
1883
 
1825
1884
        if (s->control_command) {
1826
1885
                exec_status_exit(&s->control_command->exec_status, &s->exec_context, pid, code, status);
1827
1886
 
1828
1887
                if (s->control_command->ignore)
1829
 
                        success = true;
 
1888
                        f = SOCKET_SUCCESS;
1830
1889
        }
1831
1890
 
1832
 
        log_full(success ? LOG_DEBUG : LOG_NOTICE,
1833
 
                 "%s control process exited, code=%s status=%i", u->meta.id, sigchld_code_to_string(code), status);
1834
 
        s->failure = s->failure || !success;
1835
 
 
1836
 
        if (s->control_command && s->control_command->command_next && success) {
1837
 
                log_debug("%s running next command for state %s", u->meta.id, socket_state_to_string(s->state));
1838
 
                socket_run_next(s, success);
 
1891
        log_full(f == SOCKET_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
 
1892
                 "%s control process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
 
1893
 
 
1894
        if (f != SOCKET_SUCCESS)
 
1895
                s->result = f;
 
1896
 
 
1897
        if (s->control_command &&
 
1898
            s->control_command->command_next &&
 
1899
            f == SOCKET_SUCCESS) {
 
1900
 
 
1901
                log_debug("%s running next command for state %s", u->id, socket_state_to_string(s->state));
 
1902
                socket_run_next(s);
1839
1903
        } else {
1840
1904
                s->control_command = NULL;
1841
1905
                s->control_command_id = _SOCKET_EXEC_COMMAND_INVALID;
1843
1907
                /* No further commands for this step, so let's figure
1844
1908
                 * out what to do next */
1845
1909
 
1846
 
                log_debug("%s got final SIGCHLD for state %s", u->meta.id, socket_state_to_string(s->state));
 
1910
                log_debug("%s got final SIGCHLD for state %s", u->id, socket_state_to_string(s->state));
1847
1911
 
1848
1912
                switch (s->state) {
1849
1913
 
1850
1914
                case SOCKET_START_PRE:
1851
 
                        if (success)
 
1915
                        if (f == SOCKET_SUCCESS)
1852
1916
                                socket_enter_start_post(s);
1853
1917
                        else
1854
 
                                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
 
1918
                                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, f);
1855
1919
                        break;
1856
1920
 
1857
1921
                case SOCKET_START_POST:
1858
 
                        if (success)
 
1922
                        if (f == SOCKET_SUCCESS)
1859
1923
                                socket_enter_listening(s);
1860
1924
                        else
1861
 
                                socket_enter_stop_pre(s, false);
 
1925
                                socket_enter_stop_pre(s, f);
1862
1926
                        break;
1863
1927
 
1864
1928
                case SOCKET_STOP_PRE:
1865
1929
                case SOCKET_STOP_PRE_SIGTERM:
1866
1930
                case SOCKET_STOP_PRE_SIGKILL:
1867
 
                        socket_enter_stop_post(s, success);
 
1931
                        socket_enter_stop_post(s, f);
1868
1932
                        break;
1869
1933
 
1870
1934
                case SOCKET_STOP_POST:
1871
1935
                case SOCKET_FINAL_SIGTERM:
1872
1936
                case SOCKET_FINAL_SIGKILL:
1873
 
                        socket_enter_dead(s, success);
 
1937
                        socket_enter_dead(s, f);
1874
1938
                        break;
1875
1939
 
1876
1940
                default:
1892
1956
        switch (s->state) {
1893
1957
 
1894
1958
        case SOCKET_START_PRE:
1895
 
                log_warning("%s starting timed out. Terminating.", u->meta.id);
1896
 
                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
 
1959
                log_warning("%s starting timed out. Terminating.", u->id);
 
1960
                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1897
1961
                break;
1898
1962
 
1899
1963
        case SOCKET_START_POST:
1900
 
                log_warning("%s starting timed out. Stopping.", u->meta.id);
1901
 
                socket_enter_stop_pre(s, false);
 
1964
                log_warning("%s starting timed out. Stopping.", u->id);
 
1965
                socket_enter_stop_pre(s, SOCKET_FAILURE_TIMEOUT);
1902
1966
                break;
1903
1967
 
1904
1968
        case SOCKET_STOP_PRE:
1905
 
                log_warning("%s stopping timed out. Terminating.", u->meta.id);
1906
 
                socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, false);
 
1969
                log_warning("%s stopping timed out. Terminating.", u->id);
 
1970
                socket_enter_signal(s, SOCKET_STOP_PRE_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1907
1971
                break;
1908
1972
 
1909
1973
        case SOCKET_STOP_PRE_SIGTERM:
1910
1974
                if (s->exec_context.send_sigkill) {
1911
 
                        log_warning("%s stopping timed out. Killing.", u->meta.id);
1912
 
                        socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, false);
 
1975
                        log_warning("%s stopping timed out. Killing.", u->id);
 
1976
                        socket_enter_signal(s, SOCKET_STOP_PRE_SIGKILL, SOCKET_FAILURE_TIMEOUT);
1913
1977
                } else {
1914
 
                        log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->meta.id);
1915
 
                        socket_enter_stop_post(s, false);
 
1978
                        log_warning("%s stopping timed out. Skipping SIGKILL. Ignoring.", u->id);
 
1979
                        socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1916
1980
                }
1917
1981
                break;
1918
1982
 
1919
1983
        case SOCKET_STOP_PRE_SIGKILL:
1920
 
                log_warning("%s still around after SIGKILL. Ignoring.", u->meta.id);
1921
 
                socket_enter_stop_post(s, false);
 
1984
                log_warning("%s still around after SIGKILL. Ignoring.", u->id);
 
1985
                socket_enter_stop_post(s, SOCKET_FAILURE_TIMEOUT);
1922
1986
                break;
1923
1987
 
1924
1988
        case SOCKET_STOP_POST:
1925
 
                log_warning("%s stopping timed out (2). Terminating.", u->meta.id);
1926
 
                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, false);
 
1989
                log_warning("%s stopping timed out (2). Terminating.", u->id);
 
1990
                socket_enter_signal(s, SOCKET_FINAL_SIGTERM, SOCKET_FAILURE_TIMEOUT);
1927
1991
                break;
1928
1992
 
1929
1993
        case SOCKET_FINAL_SIGTERM:
1930
1994
                if (s->exec_context.send_sigkill) {
1931
 
                        log_warning("%s stopping timed out (2). Killing.", u->meta.id);
1932
 
                        socket_enter_signal(s, SOCKET_FINAL_SIGKILL, false);
 
1995
                        log_warning("%s stopping timed out (2). Killing.", u->id);
 
1996
                        socket_enter_signal(s, SOCKET_FINAL_SIGKILL, SOCKET_FAILURE_TIMEOUT);
1933
1997
                } else {
1934
 
                        log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->meta.id);
1935
 
                        socket_enter_dead(s, false);
 
1998
                        log_warning("%s stopping timed out (2). Skipping SIGKILL. Ignoring.", u->id);
 
1999
                        socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
1936
2000
                }
1937
2001
                break;
1938
2002
 
1939
2003
        case SOCKET_FINAL_SIGKILL:
1940
 
                log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->meta.id);
1941
 
                socket_enter_dead(s, false);
 
2004
                log_warning("%s still around after SIGKILL (2). Entering failed mode.", u->id);
 
2005
                socket_enter_dead(s, SOCKET_FAILURE_TIMEOUT);
1942
2006
                break;
1943
2007
 
1944
2008
        default:
1984
2048
        return 0;
1985
2049
}
1986
2050
 
1987
 
void socket_notify_service_dead(Socket *s) {
 
2051
void socket_notify_service_dead(Socket *s, bool failed_permanent) {
1988
2052
        assert(s);
1989
2053
 
1990
2054
        /* The service is dead. Dang!
1993
2057
         * services. */
1994
2058
 
1995
2059
        if (s->state == SOCKET_RUNNING) {
1996
 
                log_debug("%s got notified about service death.", s->meta.id);
1997
 
                socket_enter_listening(s);
 
2060
                log_debug("%s got notified about service death (failed permanently: %s)", UNIT(s)->id, yes_no(failed_permanent));
 
2061
                if (failed_permanent)
 
2062
                        socket_enter_stop_pre(s, SOCKET_FAILURE_SERVICE_FAILED_PERMANENT);
 
2063
                else
 
2064
                        socket_enter_listening(s);
1998
2065
        }
1999
2066
}
2000
2067
 
2009
2076
        assert(s->n_connections > 0);
2010
2077
        s->n_connections--;
2011
2078
 
2012
 
        log_debug("%s: One connection closed, %u left.", s->meta.id, s->n_connections);
 
2079
        log_debug("%s: One connection closed, %u left.", UNIT(s)->id, s->n_connections);
2013
2080
}
2014
2081
 
2015
2082
static void socket_reset_failed(Unit *u) {
2020
2087
        if (s->state == SOCKET_FAILED)
2021
2088
                socket_set_state(s, SOCKET_DEAD);
2022
2089
 
2023
 
        s->failure = false;
 
2090
        s->result = SOCKET_SUCCESS;
2024
2091
}
2025
2092
 
2026
2093
static int socket_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
2058
2125
                                goto finish;
2059
2126
                        }
2060
2127
 
2061
 
                if ((q = cgroup_bonding_kill_list(s->meta.cgroup_bondings, signo, false, pid_set)) < 0)
 
2128
                if ((q = cgroup_bonding_kill_list(UNIT(s)->cgroup_bondings, signo, false, pid_set)) < 0)
2062
2129
                        if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2063
2130
                                r = q;
2064
2131
        }
2096
2163
 
2097
2164
DEFINE_STRING_TABLE_LOOKUP(socket_exec_command, SocketExecCommand);
2098
2165
 
 
2166
static const char* const socket_result_table[_SOCKET_RESULT_MAX] = {
 
2167
        [SOCKET_SUCCESS] = "success",
 
2168
        [SOCKET_FAILURE_RESOURCES] = "resources",
 
2169
        [SOCKET_FAILURE_TIMEOUT] = "timeout",
 
2170
        [SOCKET_FAILURE_EXIT_CODE] = "exit-code",
 
2171
        [SOCKET_FAILURE_SIGNAL] = "signal",
 
2172
        [SOCKET_FAILURE_CORE_DUMP] = "core-dump",
 
2173
        [SOCKET_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent"
 
2174
};
 
2175
 
 
2176
DEFINE_STRING_TABLE_LOOKUP(socket_result, SocketResult);
 
2177
 
2099
2178
const UnitVTable socket_vtable = {
2100
2179
        .suffix = ".socket",
 
2180
        .object_size = sizeof(Socket),
2101
2181
        .sections =
2102
2182
                "Unit\0"
2103
2183
                "Socket\0"