chiark / gitweb /
bus: make sd_bus_request_name() and sd_bus_release_name() behave more like other...
[elogind.git] / src / machine / machined-dbus.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2011 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 <errno.h>
23 #include <string.h>
24 #include <unistd.h>
25 #include <pwd.h>
26
27 #include "sd-id128.h"
28 #include "sd-messages.h"
29
30 #include "strv.h"
31 #include "mkdir.h"
32 #include "path-util.h"
33 #include "special.h"
34 #include "fileio-label.h"
35 #include "label.h"
36 #include "utf8.h"
37 #include "unit-name.h"
38 #include "bus-util.h"
39 #include "bus-errors.h"
40 #include "time-util.h"
41 #include "cgroup-util.h"
42 #include "machined.h"
43
44 static bool valid_machine_name(const char *p) {
45         size_t l;
46
47         if (!filename_is_safe(p))
48                 return false;
49
50         if (!ascii_is_valid(p))
51                 return false;
52
53         l = strlen(p);
54
55         if (l < 1 || l> 64)
56                 return false;
57
58         return true;
59 }
60
61 static int method_get_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
62         _cleanup_free_ char *p = NULL;
63         Manager *m = userdata;
64         Machine *machine;
65         const char *name;
66         int r;
67
68         assert(bus);
69         assert(message);
70         assert(m);
71
72         r = sd_bus_message_read(message, "s", &name);
73         if (r < 0)
74                 return r;
75
76         machine = hashmap_get(m->machines, name);
77         if (!machine)
78                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
79
80         p = machine_bus_path(machine);
81         if (!p)
82                 return -ENOMEM;
83
84         return sd_bus_reply_method_return(message, "o", p);
85 }
86
87 static int method_get_machine_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
88         _cleanup_free_ char *p = NULL;
89         Manager *m = userdata;
90         Machine *machine = NULL;
91         pid_t pid;
92         int r;
93
94         assert(bus);
95         assert(message);
96         assert(m);
97
98         assert_cc(sizeof(pid_t) == sizeof(uint32_t));
99
100         r = sd_bus_message_read(message, "u", &pid);
101         if (r < 0)
102                 return r;
103
104         if (pid == 0) {
105                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
106
107                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
108                 if (r < 0)
109                         return r;
110
111                 r = sd_bus_creds_get_pid(creds, &pid);
112                 if (r < 0)
113                         return r;
114         }
115
116         r = manager_get_machine_by_pid(m, pid, &machine);
117         if (r < 0)
118                 return r;
119         if (!machine)
120                 return sd_bus_error_setf(error, BUS_ERROR_NO_MACHINE_FOR_PID, "PID %lu does not belong to any known machine", (unsigned long) pid);
121
122         p = machine_bus_path(machine);
123         if (!p)
124                 return -ENOMEM;
125
126         return sd_bus_reply_method_return(message, "o", p);
127 }
128
129 static int method_list_machines(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
130         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
131         Manager *m = userdata;
132         Machine *machine;
133         Iterator i;
134         int r;
135
136         assert(bus);
137         assert(message);
138         assert(m);
139
140         r = sd_bus_message_new_method_return(message, &reply);
141         if (r < 0)
142                 return sd_bus_error_set_errno(error, r);
143
144         r = sd_bus_message_open_container(reply, 'a', "(ssso)");
145         if (r < 0)
146                 return sd_bus_error_set_errno(error, r);
147
148         HASHMAP_FOREACH(machine, m->machines, i) {
149                 _cleanup_free_ char *p = NULL;
150
151                 p = machine_bus_path(machine);
152                 if (!p)
153                         return -ENOMEM;
154
155                 r = sd_bus_message_append(reply, "(ssso)",
156                                           machine->name,
157                                           strempty(machine_class_to_string(machine->class)),
158                                           machine->service,
159                                           p);
160                 if (r < 0)
161                         return sd_bus_error_set_errno(error, r);
162         }
163
164         r = sd_bus_message_close_container(reply);
165         if (r < 0)
166                 return sd_bus_error_set_errno(error, r);
167
168         return sd_bus_send(bus, reply, NULL);
169 }
170
171 static int method_create_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
172         const char *name, *service, *class, *root_directory;
173         Manager *manager = userdata;
174         MachineClass c;
175         uint32_t leader;
176         sd_id128_t id;
177         const void *v;
178         Machine *m;
179         size_t n;
180         int r;
181
182         assert(bus);
183         assert(message);
184         assert(manager);
185
186         r = sd_bus_message_read(message, "s", &name);
187         if (r < 0)
188                 return r;
189         if (!valid_machine_name(name))
190                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine name");
191
192         r = sd_bus_message_read_array(message, 'y', &v, &n);
193         if (r < 0)
194                 return r;
195         if (n == 0)
196                 id = SD_ID128_NULL;
197         else if (n == 16)
198                 memcpy(&id, v, n);
199         else
200                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine ID parameter");
201
202         r = sd_bus_message_read(message, "ssus", &service, &class, &leader, &root_directory);
203         if (r < 0)
204                 return r;
205
206         if (isempty(class))
207                 c = _MACHINE_CLASS_INVALID;
208         else {
209                 c = machine_class_from_string(class);
210                 if (c < 0)
211                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid machine class parameter");
212         }
213
214         if (leader == 1)
215                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid leader PID");
216
217         if (!isempty(root_directory) && !path_is_absolute(root_directory))
218                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Root directory must be empty or an absolute path");
219
220         r = sd_bus_message_enter_container(message, 'a', "(sv)");
221         if (r < 0)
222                 return r;
223
224         if (leader == 0) {
225                 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
226
227                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
228                 if (r < 0)
229                         return r;
230
231                 assert_cc(sizeof(uint32_t) == sizeof(pid_t));
232
233                 r = sd_bus_creds_get_pid(creds, (pid_t*) &leader);
234                 if (r < 0)
235                         return r;
236         }
237
238         if (hashmap_get(manager->machines, name))
239                 return sd_bus_error_setf(error, BUS_ERROR_MACHINE_EXISTS, "Machine '%s' already exists", name);
240
241         r = manager_add_machine(manager, name, &m);
242         if (r < 0)
243                 return r;
244
245         m->leader = leader;
246         m->class = c;
247         m->id = id;
248
249         if (!isempty(service)) {
250                 m->service = strdup(service);
251                 if (!m->service) {
252                         r = -ENOMEM;
253                         goto fail;
254                 }
255         }
256
257         if (!isempty(root_directory)) {
258                 m->root_directory = strdup(root_directory);
259                 if (!m->root_directory) {
260                         r = -ENOMEM;
261                         goto fail;
262                 }
263         }
264
265         r = machine_start(m, message, error);
266         if (r < 0)
267                 goto fail;
268
269         m->create_message = sd_bus_message_ref(message);
270
271         return 1;
272
273 fail:
274         machine_add_to_gc_queue(m);
275
276         return r;
277 }
278
279 static int method_terminate_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
280         Manager *m = userdata;
281         Machine *machine;
282         const char *name;
283         int r;
284
285         assert(bus);
286         assert(message);
287         assert(m);
288
289         r = sd_bus_message_read(message, "s", &name);
290         if (r < 0)
291                 return sd_bus_error_set_errno(error, r);
292
293         machine = hashmap_get(m->machines, name);
294         if (!machine)
295                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
296
297         r = machine_stop(machine);
298         if (r < 0)
299                 return sd_bus_error_set_errno(error, r);
300
301         return sd_bus_reply_method_return(message, NULL);
302 }
303
304 static int method_kill_machine(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
305         Manager *m = userdata;
306         Machine *machine;
307         const char *name;
308         const char *swho;
309         int32_t signo;
310         KillWho who;
311         int r;
312
313         assert(bus);
314         assert(message);
315         assert(m);
316
317         r = sd_bus_message_read(message, "ssi", &name, &swho, &signo);
318         if (r < 0)
319                 return sd_bus_error_set_errno(error, r);
320
321         if (isempty(swho))
322                 who = KILL_ALL;
323         else {
324                 who = kill_who_from_string(swho);
325                 if (who < 0)
326                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid kill parameter '%s'", swho);
327         }
328
329         if (signo <= 0 || signo >= _NSIG)
330                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid signal %i", signo);
331
332         machine = hashmap_get(m->machines, name);
333         if (!machine)
334                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_MACHINE, "No machine '%s' known", name);
335
336         r = machine_kill(machine, who, signo);
337         if (r < 0)
338                 return sd_bus_error_set_errno(error, r);
339
340         return sd_bus_reply_method_return(message, NULL);
341 }
342
343 const sd_bus_vtable manager_vtable[] = {
344         SD_BUS_VTABLE_START(0),
345         SD_BUS_METHOD("GetMachine", "s", "o", method_get_machine, 0),
346         SD_BUS_METHOD("GetMachineByPID", "u", "o", method_get_machine_by_pid, 0),
347         SD_BUS_METHOD("ListMachines", NULL, "a(ssso)", method_list_machines, 0),
348         SD_BUS_METHOD("CreateMachine", "sayssusa(sv)", "o", method_create_machine, 0),
349         SD_BUS_METHOD("KillMachine", "ssi", NULL, method_kill_machine, 0),
350         SD_BUS_METHOD("TerminateMachine", "s", NULL, method_terminate_machine, 0),
351         SD_BUS_SIGNAL("MachineNew", "so", 0),
352         SD_BUS_SIGNAL("MachineRemoved", "so", 0),
353         SD_BUS_VTABLE_END
354 };
355
356 int match_job_removed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
357         const char *path, *result, *unit;
358         Manager *m = userdata;
359         Machine *machine;
360         uint32_t id;
361         int r;
362
363         assert(bus);
364         assert(message);
365         assert(m);
366
367         r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
368         if (r < 0) {
369                 bus_log_parse_error(r);
370                 return r;
371         }
372
373         machine = hashmap_get(m->machine_units, unit);
374         if (!machine)
375                 return 0;
376
377         if (streq_ptr(path, machine->scope_job)) {
378                 free(machine->scope_job);
379                 machine->scope_job = NULL;
380
381                 if (machine->started) {
382                         if (streq(result, "done"))
383                                 machine_send_create_reply(machine, NULL);
384                         else {
385                                 _cleanup_bus_error_free_ sd_bus_error e = SD_BUS_ERROR_NULL;
386
387                                 sd_bus_error_setf(&e, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
388
389                                 machine_send_create_reply(machine, &e);
390                         }
391                 } else
392                         machine_save(machine);
393         }
394
395         machine_add_to_gc_queue(machine);
396         return 0;
397 }
398
399 int match_properties_changed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
400         _cleanup_free_ char *unit = NULL;
401         Manager *m = userdata;
402         Machine *machine;
403         const char *path;
404         int r;
405
406         assert(bus);
407         assert(message);
408         assert(m);
409
410         path = sd_bus_message_get_path(message);
411         if (!path)
412                 return 0;
413
414         r = unit_name_from_dbus_path(path, &unit);
415         if (r < 0)
416                 return r;
417
418         machine = hashmap_get(m->machine_units, unit);
419         if (machine)
420                 machine_add_to_gc_queue(machine);
421
422         return 0;
423 }
424
425 int match_unit_removed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
426         const char *path, *unit;
427         Manager *m = userdata;
428         Machine *machine;
429         int r;
430
431         assert(bus);
432         assert(message);
433         assert(m);
434
435         r = sd_bus_message_read(message, "so", &unit, &path);
436         if (r < 0) {
437                 bus_log_parse_error(r);
438                 return r;
439         }
440
441         machine = hashmap_get(m->machine_units, unit);
442         if (machine)
443                 machine_add_to_gc_queue(machine);
444
445         return 0;
446 }
447
448 int match_reloading(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
449         Manager *m = userdata;
450         Machine *machine;
451         Iterator i;
452         int b, r;
453
454         assert(bus);
455
456         r = sd_bus_message_read(message, "b", &b);
457         if (r < 0) {
458                 bus_log_parse_error(r);
459                 return r;
460         }
461         if (b)
462                 return 0;
463
464         /* systemd finished reloading, let's recheck all our machines */
465         log_debug("System manager has been reloaded, rechecking machines...");
466
467         HASHMAP_FOREACH(machine, m->machines, i)
468                 machine_add_to_gc_queue(machine);
469
470         return 0;
471 }
472
473 int manager_start_scope(
474                 Manager *manager,
475                 const char *scope,
476                 pid_t pid,
477                 const char *slice,
478                 const char *description,
479                 sd_bus_message *more_properties,
480                 sd_bus_error *error,
481                 char **job) {
482
483         _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
484         int r;
485
486         assert(manager);
487         assert(scope);
488         assert(pid > 1);
489
490         r = sd_bus_message_new_method_call(
491                         manager->bus,
492                         "org.freedesktop.systemd1",
493                         "/org/freedesktop/systemd1",
494                         "org.freedesktop.systemd1.Manager",
495                         "StartTransientUnit",
496                         &m);
497         if (r < 0)
498                 return r;
499
500         r = sd_bus_message_append(m, "ss", strempty(scope), "fail");
501         if (r < 0)
502                 return r;
503
504         r = sd_bus_message_open_container(m, 'a', "(sv)");
505         if (r < 0)
506                 return r;
507
508         if (!isempty(slice)) {
509                 r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
510                 if (r < 0)
511                         return r;
512         }
513
514         if (!isempty(description)) {
515                 r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
516                 if (r < 0)
517                         return r;
518         }
519
520         /* cgroup empty notification is not available in containers
521          * currently. To make this less problematic, let's shorten the
522          * stop timeout for machines, so that we don't wait
523          * forever. */
524         r = sd_bus_message_append(m, "(sv)", "TimeoutStopUSec", "t", 500 * USEC_PER_MSEC);
525         if (r < 0)
526                 return r;
527
528         r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, pid);
529         if (r < 0)
530                 return r;
531
532         if (more_properties) {
533                 r = sd_bus_message_copy(m, more_properties, true);
534                 if (r < 0)
535                         return r;
536         }
537
538         r = sd_bus_message_close_container(m);
539         if (r < 0)
540                 return r;
541
542         r = sd_bus_message_append(m, "a(sa(sv))", 0);
543         if (r < 0)
544                 return r;
545
546         r = sd_bus_call(manager->bus, m, 0, error, &reply);
547         if (r < 0)
548                 return r;
549
550         if (job) {
551                 const char *j;
552                 char *copy;
553
554                 r = sd_bus_message_read(reply, "o", &j);
555                 if (r < 0)
556                         return r;
557
558                 copy = strdup(j);
559                 if (!copy)
560                         return -ENOMEM;
561
562                 *job = copy;
563         }
564
565         return 1;
566 }
567
568 int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
569         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
570         int r;
571
572         assert(manager);
573         assert(unit);
574
575         r = sd_bus_call_method(
576                         manager->bus,
577                         "org.freedesktop.systemd1",
578                         "/org/freedesktop/systemd1",
579                         "org.freedesktop.systemd1.Manager",
580                         "StopUnit",
581                         error,
582                         &reply,
583                         "ss", unit, "fail");
584         if (r < 0) {
585                 if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
586                     sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
587
588                         if (job)
589                                 *job = NULL;
590
591                         sd_bus_error_free(error);
592                         return 0;
593                 }
594
595                 return r;
596         }
597
598         if (job) {
599                 const char *j;
600                 char *copy;
601
602                 r = sd_bus_message_read(reply, "o", &j);
603                 if (r < 0)
604                         return r;
605
606                 copy = strdup(j);
607                 if (!copy)
608                         return -ENOMEM;
609
610                 *job = copy;
611         }
612
613         return 1;
614 }
615
616 int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error) {
617         assert(manager);
618         assert(unit);
619
620         return sd_bus_call_method(
621                         manager->bus,
622                         "org.freedesktop.systemd1",
623                         "/org/freedesktop/systemd1",
624                         "org.freedesktop.systemd1.Manager",
625                         "KillUnit",
626                         error,
627                         NULL,
628                         "ssi", unit, who == KILL_LEADER ? "main" : "all", signo);
629 }
630
631 int manager_unit_is_active(Manager *manager, const char *unit) {
632         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
633         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
634         _cleanup_free_ char *path = NULL;
635         const char *state;
636         int r;
637
638         assert(manager);
639         assert(unit);
640
641         path = unit_dbus_path_from_name(unit);
642         if (!path)
643                 return -ENOMEM;
644
645         r = sd_bus_get_property(
646                         manager->bus,
647                         "org.freedesktop.systemd1",
648                         path,
649                         "org.freedesktop.systemd1.Unit",
650                         "ActiveState",
651                         &error,
652                         &reply,
653                         "s");
654         if (r < 0) {
655                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
656                     sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
657                         return true;
658
659                 if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
660                     sd_bus_error_has_name(&error, BUS_ERROR_LOAD_FAILED))
661                         return false;
662
663                 return r;
664         }
665
666         r = sd_bus_message_read(reply, "s", &state);
667         if (r < 0)
668                 return -EINVAL;
669
670         return !streq(state, "inactive") && !streq(state, "failed");
671 }
672
673 int manager_job_is_active(Manager *manager, const char *path) {
674         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
675         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
676         int r;
677
678         assert(manager);
679         assert(path);
680
681         r = sd_bus_get_property(
682                         manager->bus,
683                         "org.freedesktop.systemd1",
684                         path,
685                         "org.freedesktop.systemd1.Job",
686                         "State",
687                         &error,
688                         &reply,
689                         "s");
690         if (r < 0) {
691                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
692                     sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
693                         return true;
694
695                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT))
696                         return false;
697
698                 return r;
699         }
700
701         /* We don't actually care about the state really. The fact
702          * that we could read the job state is enough for us */
703
704         return true;
705 }
706
707 int manager_get_machine_by_pid(Manager *m, pid_t pid, Machine **machine) {
708         _cleanup_free_ char *unit = NULL;
709         Machine *mm;
710         int r;
711
712         assert(m);
713         assert(pid >= 1);
714         assert(machine);
715
716         r = cg_pid_get_unit(pid, &unit);
717         if (r < 0)
718                 mm = hashmap_get(m->machine_leaders, UINT_TO_PTR(pid));
719         else
720                 mm = hashmap_get(m->machine_units, unit);
721
722         if (!mm)
723                 return 0;
724
725         *machine = mm;
726         return 1;
727 }
728
729 int manager_add_machine(Manager *m, const char *name, Machine **_machine) {
730         Machine *machine;
731
732         assert(m);
733         assert(name);
734
735         machine = hashmap_get(m->machines, name);
736         if (!machine) {
737                 machine = machine_new(m, name);
738                 if (!machine)
739                         return -ENOMEM;
740         }
741
742         if (_machine)
743                 *_machine = machine;
744
745         return 0;
746 }