]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/login/loginctl.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
machined: split out machine registration stuff from logind
[thirdparty/systemd.git] / src / login / loginctl.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 <dbus/dbus.h>
23 #include <unistd.h>
24 #include <errno.h>
25 #include <string.h>
26 #include <getopt.h>
27 #include <pwd.h>
28 #include <locale.h>
29
30 #include "log.h"
31 #include "util.h"
32 #include "macro.h"
33 #include "pager.h"
34 #include "dbus-common.h"
35 #include "build.h"
36 #include "strv.h"
37 #include "cgroup-show.h"
38 #include "sysfs-show.h"
39 #include "spawn-polkit-agent.h"
40
41 static char **arg_property = NULL;
42 static bool arg_all = false;
43 static bool arg_full = false;
44 static bool arg_no_pager = false;
45 static const char *arg_kill_who = NULL;
46 static int arg_signal = SIGTERM;
47 static enum transport {
48 TRANSPORT_NORMAL,
49 TRANSPORT_SSH,
50 TRANSPORT_POLKIT
51 } arg_transport = TRANSPORT_NORMAL;
52 static bool arg_ask_password = true;
53 static char *arg_host = NULL;
54 static char *arg_user = NULL;
55
56 static void pager_open_if_enabled(void) {
57
58 /* Cache result before we open the pager */
59 if (arg_no_pager)
60 return;
61
62 pager_open(false);
63 }
64
65 static void polkit_agent_open_if_enabled(void) {
66
67 /* Open the polkit agent as a child process if necessary */
68
69 if (!arg_ask_password)
70 return;
71
72 polkit_agent_open();
73 }
74
75 static int list_sessions(DBusConnection *bus, char **args, unsigned n) {
76 _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
77 int r;
78 DBusMessageIter iter, sub, sub2;
79 unsigned k = 0;
80
81 pager_open_if_enabled();
82
83 r = bus_method_call_with_reply (
84 bus,
85 "org.freedesktop.login1",
86 "/org/freedesktop/login1",
87 "org.freedesktop.login1.Manager",
88 "ListSessions",
89 &reply,
90 NULL,
91 DBUS_TYPE_INVALID);
92 if (r)
93 return r;
94
95 if (!dbus_message_iter_init(reply, &iter) ||
96 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
97 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
98 log_error("Failed to parse reply.");
99 return -EIO;
100 }
101
102 dbus_message_iter_recurse(&iter, &sub);
103
104 if (on_tty())
105 printf("%10s %10s %-16s %-16s\n", "SESSION", "UID", "USER", "SEAT");
106
107 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
108 const char *id, *user, *seat, *object;
109 uint32_t uid;
110
111 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
112 log_error("Failed to parse reply.");
113 return -EIO;
114 }
115
116 dbus_message_iter_recurse(&sub, &sub2);
117
118 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) < 0 ||
119 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
120 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &user, true) < 0 ||
121 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 ||
122 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
123 log_error("Failed to parse reply.");
124 return -EIO;
125 }
126
127 printf("%10s %10u %-16s %-16s\n", id, (unsigned) uid, user, seat);
128
129 k++;
130
131 dbus_message_iter_next(&sub);
132 }
133
134 if (on_tty())
135 printf("\n%u sessions listed.\n", k);
136
137 return 0;
138 }
139
140 static int list_users(DBusConnection *bus, char **args, unsigned n) {
141 _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
142 int r;
143 DBusMessageIter iter, sub, sub2;
144 unsigned k = 0;
145
146 pager_open_if_enabled();
147
148 r = bus_method_call_with_reply (
149 bus,
150 "org.freedesktop.login1",
151 "/org/freedesktop/login1",
152 "org.freedesktop.login1.Manager",
153 "ListUsers",
154 &reply,
155 NULL,
156 DBUS_TYPE_INVALID);
157 if (r)
158 return r;
159
160 if (!dbus_message_iter_init(reply, &iter) ||
161 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
162 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
163 log_error("Failed to parse reply.");
164 return -EIO;
165 }
166
167 dbus_message_iter_recurse(&iter, &sub);
168
169 if (on_tty())
170 printf("%10s %-16s\n", "UID", "USER");
171
172 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
173 const char *user, *object;
174 uint32_t uid;
175
176 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
177 log_error("Failed to parse reply.");
178 return -EIO;
179 }
180
181 dbus_message_iter_recurse(&sub, &sub2);
182
183 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
184 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &user, true) < 0 ||
185 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
186 log_error("Failed to parse reply.");
187 return -EIO;
188 }
189
190 printf("%10u %-16s\n", (unsigned) uid, user);
191
192 k++;
193
194 dbus_message_iter_next(&sub);
195 }
196
197 if (on_tty())
198 printf("\n%u users listed.\n", k);
199
200 return 0;
201 }
202
203 static int list_seats(DBusConnection *bus, char **args, unsigned n) {
204 _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
205 int r;
206 DBusMessageIter iter, sub, sub2;
207 unsigned k = 0;
208
209 pager_open_if_enabled();
210
211 r = bus_method_call_with_reply (
212 bus,
213 "org.freedesktop.login1",
214 "/org/freedesktop/login1",
215 "org.freedesktop.login1.Manager",
216 "ListSeats",
217 &reply,
218 NULL,
219 DBUS_TYPE_INVALID);
220 if (r)
221 return r;
222
223 if (!dbus_message_iter_init(reply, &iter) ||
224 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
225 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
226 log_error("Failed to parse reply.");
227 return -EIO;
228 }
229
230 dbus_message_iter_recurse(&iter, &sub);
231
232 if (on_tty())
233 printf("%-16s\n", "SEAT");
234
235 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
236 const char *seat, *object;
237
238 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
239 log_error("Failed to parse reply.");
240 return -EIO;
241 }
242
243 dbus_message_iter_recurse(&sub, &sub2);
244
245 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 ||
246 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
247 log_error("Failed to parse reply.");
248 return -EIO;
249 }
250
251 printf("%-16s\n", seat);
252
253 k++;
254
255 dbus_message_iter_next(&sub);
256 }
257
258 if (on_tty())
259 printf("\n%u seats listed.\n", k);
260
261 return 0;
262 }
263
264 typedef struct SessionStatusInfo {
265 const char *id;
266 uid_t uid;
267 const char *name;
268 usec_t timestamp;
269 const char *default_control_group;
270 int vtnr;
271 const char *seat;
272 const char *tty;
273 const char *display;
274 bool remote;
275 const char *remote_host;
276 const char *remote_user;
277 const char *service;
278 pid_t leader;
279 const char *type;
280 const char *class;
281 const char *state;
282 const char *slice;
283 } SessionStatusInfo;
284
285 typedef struct UserStatusInfo {
286 uid_t uid;
287 const char *name;
288 usec_t timestamp;
289 const char *default_control_group;
290 const char *state;
291 char **sessions;
292 const char *display;
293 const char *slice;
294 } UserStatusInfo;
295
296 typedef struct SeatStatusInfo {
297 const char *id;
298 const char *active_session;
299 char **sessions;
300 } SeatStatusInfo;
301
302 static void print_session_status_info(SessionStatusInfo *i) {
303 char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
304 char since2[FORMAT_TIMESTAMP_MAX], *s2;
305 assert(i);
306
307 printf("%s - ", strna(i->id));
308
309 if (i->name)
310 printf("%s (%u)\n", i->name, (unsigned) i->uid);
311 else
312 printf("%u\n", (unsigned) i->uid);
313
314 s1 = format_timestamp_relative(since1, sizeof(since1), i->timestamp);
315 s2 = format_timestamp(since2, sizeof(since2), i->timestamp);
316
317 if (s1)
318 printf("\t Since: %s; %s\n", s2, s1);
319 else if (s2)
320 printf("\t Since: %s\n", s2);
321
322 if (i->leader > 0) {
323 _cleanup_free_ char *t = NULL;
324
325 printf("\t Leader: %u", (unsigned) i->leader);
326
327 get_process_comm(i->leader, &t);
328 if (t)
329 printf(" (%s)", t);
330
331 printf("\n");
332 }
333
334 if (i->seat) {
335 printf("\t Seat: %s", i->seat);
336
337 if (i->vtnr > 0)
338 printf("; vc%i", i->vtnr);
339
340 printf("\n");
341 }
342
343 if (i->tty)
344 printf("\t TTY: %s\n", i->tty);
345 else if (i->display)
346 printf("\t Display: %s\n", i->display);
347
348 if (i->remote_host && i->remote_user)
349 printf("\t Remote: %s@%s\n", i->remote_user, i->remote_host);
350 else if (i->remote_host)
351 printf("\t Remote: %s\n", i->remote_host);
352 else if (i->remote_user)
353 printf("\t Remote: user %s\n", i->remote_user);
354 else if (i->remote)
355 printf("\t Remote: Yes\n");
356
357 if (i->service) {
358 printf("\t Service: %s", i->service);
359
360 if (i->type)
361 printf("; type %s", i->type);
362
363 if (i->class)
364 printf("; class %s", i->class);
365
366 printf("\n");
367 } else if (i->type) {
368 printf("\t Type: %s\n", i->type);
369
370 if (i->class)
371 printf("; class %s", i->class);
372 } else if (i->class)
373 printf("\t Class: %s\n", i->class);
374
375 if (i->state)
376 printf("\t State: %s\n", i->state);
377
378 if (i->slice)
379 printf("\t Slice: %s\n", i->slice);
380
381 if (i->default_control_group) {
382 unsigned c;
383 int output_flags =
384 arg_all * OUTPUT_SHOW_ALL |
385 arg_full * OUTPUT_FULL_WIDTH;
386
387 printf("\t CGroup: %s\n", i->default_control_group);
388
389 if (arg_transport != TRANSPORT_SSH) {
390 c = columns();
391 if (c > 18)
392 c -= 18;
393 else
394 c = 0;
395
396 show_cgroup_and_extra_by_spec(i->default_control_group,
397 "\t\t ", c, false, &i->leader,
398 i->leader > 0 ? 1 : 0,
399 output_flags);
400 }
401 }
402 }
403
404 static void print_user_status_info(UserStatusInfo *i) {
405 char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
406 char since2[FORMAT_TIMESTAMP_MAX], *s2;
407 assert(i);
408
409 if (i->name)
410 printf("%s (%u)\n", i->name, (unsigned) i->uid);
411 else
412 printf("%u\n", (unsigned) i->uid);
413
414 s1 = format_timestamp_relative(since1, sizeof(since1), i->timestamp);
415 s2 = format_timestamp(since2, sizeof(since2), i->timestamp);
416
417 if (s1)
418 printf("\t Since: %s; %s\n", s2, s1);
419 else if (s2)
420 printf("\t Since: %s\n", s2);
421
422 if (!isempty(i->state))
423 printf("\t State: %s\n", i->state);
424
425 if (i->slice)
426 printf("\t Slice: %s\n", i->slice);
427
428 if (!strv_isempty(i->sessions)) {
429 char **l;
430 printf("\tSessions:");
431
432 STRV_FOREACH(l, i->sessions) {
433 if (streq_ptr(*l, i->display))
434 printf(" *%s", *l);
435 else
436 printf(" %s", *l);
437 }
438
439 printf("\n");
440 }
441
442 if (i->default_control_group) {
443 unsigned c;
444 int output_flags =
445 arg_all * OUTPUT_SHOW_ALL |
446 arg_full * OUTPUT_FULL_WIDTH;
447
448 printf("\t CGroup: %s\n", i->default_control_group);
449
450 if (arg_transport != TRANSPORT_SSH) {
451 c = columns();
452 if (c > 18)
453 c -= 18;
454 else
455 c = 0;
456
457 show_cgroup_by_path(i->default_control_group, "\t\t ",
458 c, false, output_flags);
459 }
460 }
461 }
462
463 static void print_seat_status_info(SeatStatusInfo *i) {
464 assert(i);
465
466 printf("%s\n", strna(i->id));
467
468 if (!strv_isempty(i->sessions)) {
469 char **l;
470 printf("\tSessions:");
471
472 STRV_FOREACH(l, i->sessions) {
473 if (streq_ptr(*l, i->active_session))
474 printf(" *%s", *l);
475 else
476 printf(" %s", *l);
477 }
478
479 printf("\n");
480 }
481
482 if (arg_transport != TRANSPORT_SSH) {
483 unsigned c;
484
485 c = columns();
486 if (c > 21)
487 c -= 21;
488 else
489 c = 0;
490
491 printf("\t Devices:\n");
492
493 show_sysfs(i->id, "\t\t ", c);
494 }
495 }
496
497 static int status_property_session(const char *name, DBusMessageIter *iter, SessionStatusInfo *i) {
498 assert(name);
499 assert(iter);
500 assert(i);
501
502 switch (dbus_message_iter_get_arg_type(iter)) {
503
504 case DBUS_TYPE_STRING: {
505 const char *s;
506
507 dbus_message_iter_get_basic(iter, &s);
508
509 if (!isempty(s)) {
510 if (streq(name, "Id"))
511 i->id = s;
512 else if (streq(name, "Name"))
513 i->name = s;
514 else if (streq(name, "DefaultControlGroup"))
515 i->default_control_group = s;
516 else if (streq(name, "TTY"))
517 i->tty = s;
518 else if (streq(name, "Display"))
519 i->display = s;
520 else if (streq(name, "RemoteHost"))
521 i->remote_host = s;
522 else if (streq(name, "RemoteUser"))
523 i->remote_user = s;
524 else if (streq(name, "Service"))
525 i->service = s;
526 else if (streq(name, "Type"))
527 i->type = s;
528 else if (streq(name, "Class"))
529 i->class = s;
530 else if (streq(name, "Slice"))
531 i->slice = s;
532 else if (streq(name, "State"))
533 i->state = s;
534 }
535 break;
536 }
537
538 case DBUS_TYPE_UINT32: {
539 uint32_t u;
540
541 dbus_message_iter_get_basic(iter, &u);
542
543 if (streq(name, "VTNr"))
544 i->vtnr = (int) u;
545 else if (streq(name, "Leader"))
546 i->leader = (pid_t) u;
547
548 break;
549 }
550
551 case DBUS_TYPE_BOOLEAN: {
552 dbus_bool_t b;
553
554 dbus_message_iter_get_basic(iter, &b);
555
556 if (streq(name, "Remote"))
557 i->remote = b;
558
559 break;
560 }
561
562 case DBUS_TYPE_UINT64: {
563 uint64_t u;
564
565 dbus_message_iter_get_basic(iter, &u);
566
567 if (streq(name, "Timestamp"))
568 i->timestamp = (usec_t) u;
569
570 break;
571 }
572
573 case DBUS_TYPE_STRUCT: {
574 DBusMessageIter sub;
575
576 dbus_message_iter_recurse(iter, &sub);
577
578 if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32 && streq(name, "User")) {
579 uint32_t u;
580
581 dbus_message_iter_get_basic(&sub, &u);
582 i->uid = (uid_t) u;
583
584 } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Seat")) {
585 const char *s;
586
587 dbus_message_iter_get_basic(&sub, &s);
588
589 if (!isempty(s))
590 i->seat = s;
591 }
592
593 break;
594 }
595 }
596
597 return 0;
598 }
599
600 static int status_property_user(const char *name, DBusMessageIter *iter, UserStatusInfo *i) {
601 assert(name);
602 assert(iter);
603 assert(i);
604
605 switch (dbus_message_iter_get_arg_type(iter)) {
606
607 case DBUS_TYPE_STRING: {
608 const char *s;
609
610 dbus_message_iter_get_basic(iter, &s);
611
612 if (!isempty(s)) {
613 if (streq(name, "Name"))
614 i->name = s;
615 else if (streq(name, "DefaultControlGroup"))
616 i->default_control_group = s;
617 else if (streq(name, "Slice"))
618 i->slice = s;
619 else if (streq(name, "State"))
620 i->state = s;
621 }
622 break;
623 }
624
625 case DBUS_TYPE_UINT32: {
626 uint32_t u;
627
628 dbus_message_iter_get_basic(iter, &u);
629
630 if (streq(name, "UID"))
631 i->uid = (uid_t) u;
632
633 break;
634 }
635
636 case DBUS_TYPE_UINT64: {
637 uint64_t u;
638
639 dbus_message_iter_get_basic(iter, &u);
640
641 if (streq(name, "Timestamp"))
642 i->timestamp = (usec_t) u;
643
644 break;
645 }
646
647 case DBUS_TYPE_STRUCT: {
648 DBusMessageIter sub;
649
650 dbus_message_iter_recurse(iter, &sub);
651
652 if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Display")) {
653 const char *s;
654
655 dbus_message_iter_get_basic(&sub, &s);
656
657 if (!isempty(s))
658 i->display = s;
659 }
660
661 break;
662 }
663
664 case DBUS_TYPE_ARRAY: {
665
666 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Sessions")) {
667 DBusMessageIter sub, sub2;
668
669 dbus_message_iter_recurse(iter, &sub);
670 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
671 const char *id;
672 const char *path;
673
674 dbus_message_iter_recurse(&sub, &sub2);
675
676 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) >= 0 &&
677 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &path, false) >= 0) {
678 char **l;
679
680 l = strv_append(i->sessions, id);
681 if (!l)
682 return -ENOMEM;
683
684 strv_free(i->sessions);
685 i->sessions = l;
686 }
687
688 dbus_message_iter_next(&sub);
689 }
690
691 return 0;
692 }
693 }
694 }
695
696 return 0;
697 }
698
699 static int status_property_seat(const char *name, DBusMessageIter *iter, SeatStatusInfo *i) {
700 assert(name);
701 assert(iter);
702 assert(i);
703
704 switch (dbus_message_iter_get_arg_type(iter)) {
705
706 case DBUS_TYPE_STRING: {
707 const char *s;
708
709 dbus_message_iter_get_basic(iter, &s);
710
711 if (!isempty(s)) {
712 if (streq(name, "Id"))
713 i->id = s;
714 }
715 break;
716 }
717
718 case DBUS_TYPE_STRUCT: {
719 DBusMessageIter sub;
720
721 dbus_message_iter_recurse(iter, &sub);
722
723 if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "ActiveSession")) {
724 const char *s;
725
726 dbus_message_iter_get_basic(&sub, &s);
727
728 if (!isempty(s))
729 i->active_session = s;
730 }
731
732 break;
733 }
734
735 case DBUS_TYPE_ARRAY: {
736
737 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Sessions")) {
738 DBusMessageIter sub, sub2;
739
740 dbus_message_iter_recurse(iter, &sub);
741 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
742 const char *id;
743 const char *path;
744
745 dbus_message_iter_recurse(&sub, &sub2);
746
747 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) >= 0 &&
748 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &path, false) >= 0) {
749 char **l;
750
751 l = strv_append(i->sessions, id);
752 if (!l)
753 return -ENOMEM;
754
755 strv_free(i->sessions);
756 i->sessions = l;
757 }
758
759 dbus_message_iter_next(&sub);
760 }
761
762 return 0;
763 }
764 }
765 }
766
767 return 0;
768 }
769
770 static int print_property(const char *name, DBusMessageIter *iter) {
771 assert(name);
772 assert(iter);
773
774 if (arg_property && !strv_find(arg_property, name))
775 return 0;
776
777 switch (dbus_message_iter_get_arg_type(iter)) {
778
779 case DBUS_TYPE_STRUCT: {
780 DBusMessageIter sub;
781
782 dbus_message_iter_recurse(iter, &sub);
783
784 if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING &&
785 (streq(name, "Display") || streq(name, "ActiveSession"))) {
786 const char *s;
787
788 dbus_message_iter_get_basic(&sub, &s);
789
790 if (arg_all || !isempty(s))
791 printf("%s=%s\n", name, s);
792 return 0;
793 }
794 break;
795 }
796
797 case DBUS_TYPE_ARRAY:
798
799 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Sessions")) {
800 DBusMessageIter sub, sub2;
801 bool found = false;
802
803 dbus_message_iter_recurse(iter, &sub);
804 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
805 const char *id;
806 const char *path;
807
808 dbus_message_iter_recurse(&sub, &sub2);
809
810 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) >= 0 &&
811 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &path, false) >= 0) {
812 if (found)
813 printf(" %s", id);
814 else {
815 printf("%s=%s", name, id);
816 found = true;
817 }
818 }
819
820 dbus_message_iter_next(&sub);
821 }
822
823 if (!found && arg_all)
824 printf("%s=\n", name);
825 else if (found)
826 printf("\n");
827
828 return 0;
829 }
830
831 break;
832 }
833
834 if (generic_print_property(name, iter, arg_all) > 0)
835 return 0;
836
837 if (arg_all)
838 printf("%s=[unprintable]\n", name);
839
840 return 0;
841 }
842
843 static int show_one(const char *verb, DBusConnection *bus, const char *path, bool show_properties, bool *new_line) {
844 _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
845 const char *interface = "";
846 int r;
847 DBusMessageIter iter, sub, sub2, sub3;
848 SessionStatusInfo session_info = {};
849 UserStatusInfo user_info = {};
850 SeatStatusInfo seat_info = {};
851
852 assert(path);
853 assert(new_line);
854
855 r = bus_method_call_with_reply(
856 bus,
857 "org.freedesktop.login1",
858 path,
859 "org.freedesktop.DBus.Properties",
860 "GetAll",
861 &reply,
862 NULL,
863 DBUS_TYPE_STRING, &interface,
864 DBUS_TYPE_INVALID);
865 if (r < 0)
866 goto finish;
867
868 if (!dbus_message_iter_init(reply, &iter) ||
869 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
870 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY) {
871 log_error("Failed to parse reply.");
872 r = -EIO;
873 goto finish;
874 }
875
876 dbus_message_iter_recurse(&iter, &sub);
877
878 if (*new_line)
879 printf("\n");
880
881 *new_line = true;
882
883 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
884 const char *name;
885
886 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_DICT_ENTRY) {
887 log_error("Failed to parse reply.");
888 r = -EIO;
889 goto finish;
890 }
891
892 dbus_message_iter_recurse(&sub, &sub2);
893
894 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0) {
895 log_error("Failed to parse reply.");
896 r = -EIO;
897 goto finish;
898 }
899
900 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) {
901 log_error("Failed to parse reply.");
902 r = -EIO;
903 goto finish;
904 }
905
906 dbus_message_iter_recurse(&sub2, &sub3);
907
908 if (show_properties)
909 r = print_property(name, &sub3);
910 else if (strstr(verb, "session"))
911 r = status_property_session(name, &sub3, &session_info);
912 else if (strstr(verb, "user"))
913 r = status_property_user(name, &sub3, &user_info);
914 else
915 r = status_property_seat(name, &sub3, &seat_info);
916
917 if (r < 0) {
918 log_error("Failed to parse reply.");
919 goto finish;
920 }
921
922 dbus_message_iter_next(&sub);
923 }
924
925 if (!show_properties) {
926 if (strstr(verb, "session"))
927 print_session_status_info(&session_info);
928 else if (strstr(verb, "user"))
929 print_user_status_info(&user_info);
930 else
931 print_seat_status_info(&seat_info);
932 }
933
934 r = 0;
935
936 finish:
937 strv_free(seat_info.sessions);
938 strv_free(user_info.sessions);
939
940 return r;
941 }
942
943 static int show(DBusConnection *bus, char **args, unsigned n) {
944 _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
945 int r, ret = 0;
946 DBusError error;
947 unsigned i;
948 bool show_properties, new_line = false;
949
950 assert(bus);
951 assert(args);
952
953 dbus_error_init(&error);
954
955 show_properties = !strstr(args[0], "status");
956
957 pager_open_if_enabled();
958
959 if (show_properties && n <= 1) {
960 /* If not argument is specified inspect the manager
961 * itself */
962
963 ret = show_one(args[0], bus, "/org/freedesktop/login1", show_properties, &new_line);
964 goto finish;
965 }
966
967 for (i = 1; i < n; i++) {
968 const char *path = NULL;
969
970 if (strstr(args[0], "session")) {
971
972 ret = bus_method_call_with_reply (
973 bus,
974 "org.freedesktop.login1",
975 "/org/freedesktop/login1",
976 "org.freedesktop.login1.Manager",
977 "GetSession",
978 &reply,
979 NULL,
980 DBUS_TYPE_STRING, &args[i],
981 DBUS_TYPE_INVALID);
982
983 } else if (strstr(args[0], "user")) {
984 uid_t uid;
985 uint32_t u;
986
987 ret = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
988 if (ret < 0) {
989 log_error("User %s unknown.", args[i]);
990 goto finish;
991 }
992
993 u = (uint32_t) uid;
994 ret = bus_method_call_with_reply(
995 bus,
996 "org.freedesktop.login1",
997 "/org/freedesktop/login1",
998 "org.freedesktop.login1.Manager",
999 "GetUser",
1000 &reply,
1001 NULL,
1002 DBUS_TYPE_UINT32, &u,
1003 DBUS_TYPE_INVALID);
1004
1005 } else {
1006
1007 ret = bus_method_call_with_reply(
1008 bus,
1009 "org.freedesktop.login1",
1010 "/org/freedesktop/login1",
1011 "org.freedesktop.login1.Manager",
1012 "GetSeat",
1013 &reply,
1014 NULL,
1015 DBUS_TYPE_STRING, &args[i],
1016 DBUS_TYPE_INVALID);
1017
1018 }
1019
1020 if (ret < 0)
1021 goto finish;
1022
1023 if (!dbus_message_get_args(reply, &error,
1024 DBUS_TYPE_OBJECT_PATH, &path,
1025 DBUS_TYPE_INVALID)) {
1026 log_error("Failed to parse reply: %s", bus_error_message(&error));
1027 ret = -EIO;
1028 goto finish;
1029 }
1030
1031 r = show_one(args[0], bus, path, show_properties, &new_line);
1032 if (r != 0)
1033 ret = r;
1034 }
1035
1036 finish:
1037 dbus_error_free(&error);
1038
1039 return ret;
1040 }
1041
1042 static int activate(DBusConnection *bus, char **args, unsigned n) {
1043 int ret = 0;
1044 unsigned i;
1045
1046 assert(args);
1047
1048 for (i = 1; i < n; i++) {
1049
1050 ret = bus_method_call_with_reply (
1051 bus,
1052 "org.freedesktop.login1",
1053 "/org/freedesktop/login1",
1054 "org.freedesktop.login1.Manager",
1055 streq(args[0], "lock-session") ? "LockSession" :
1056 streq(args[0], "unlock-session") ? "UnlockSession" :
1057 streq(args[0], "terminate-session") ? "TerminateSession" :
1058 "ActivateSession",
1059 NULL,
1060 NULL,
1061 DBUS_TYPE_STRING, &args[i],
1062 DBUS_TYPE_INVALID);
1063 if (ret)
1064 goto finish;
1065 }
1066
1067 finish:
1068 return ret;
1069 }
1070
1071 static int kill_session(DBusConnection *bus, char **args, unsigned n) {
1072 unsigned i;
1073
1074 assert(args);
1075
1076 if (!arg_kill_who)
1077 arg_kill_who = "all";
1078
1079 for (i = 1; i < n; i++) {
1080 int r;
1081
1082 r = bus_method_call_with_reply (
1083 bus,
1084 "org.freedesktop.login1",
1085 "/org/freedesktop/login1",
1086 "org.freedesktop.login1.Manager",
1087 "KillSession",
1088 NULL,
1089 NULL,
1090 DBUS_TYPE_STRING, &args[i],
1091 DBUS_TYPE_STRING, &arg_kill_who,
1092 DBUS_TYPE_INT32, &arg_signal,
1093 DBUS_TYPE_INVALID);
1094 if (r)
1095 return r;
1096 }
1097
1098 return 0;
1099 }
1100
1101 static int enable_linger(DBusConnection *bus, char **args, unsigned n) {
1102 unsigned i;
1103 dbus_bool_t b, interactive = true;
1104
1105 assert(args);
1106
1107 polkit_agent_open_if_enabled();
1108
1109 b = streq(args[0], "enable-linger");
1110
1111 for (i = 1; i < n; i++) {
1112 uint32_t u;
1113 uid_t uid;
1114 int r;
1115
1116 r = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
1117 if (r < 0) {
1118 log_error("Failed to resolve user %s: %s", args[i], strerror(-r));
1119 return r;
1120 }
1121
1122 u = (uint32_t) uid;
1123 r = bus_method_call_with_reply (
1124 bus,
1125 "org.freedesktop.login1",
1126 "/org/freedesktop/login1",
1127 "org.freedesktop.login1.Manager",
1128 "SetUserLinger",
1129 NULL,
1130 NULL,
1131 DBUS_TYPE_UINT32, &u,
1132 DBUS_TYPE_BOOLEAN, &b,
1133 DBUS_TYPE_BOOLEAN, &interactive,
1134 DBUS_TYPE_INVALID);
1135 if (r)
1136 return r;
1137 }
1138
1139 return 0;
1140 }
1141
1142 static int terminate_user(DBusConnection *bus, char **args, unsigned n) {
1143 unsigned i;
1144
1145 assert(args);
1146
1147 for (i = 1; i < n; i++) {
1148 uint32_t u;
1149 uid_t uid;
1150 int r;
1151
1152 r = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
1153 if (r < 0) {
1154 log_error("Failed to look up user %s: %s", args[i], strerror(-r));
1155 return r;
1156 }
1157
1158 u = (uint32_t) uid;
1159 r = bus_method_call_with_reply (
1160 bus,
1161 "org.freedesktop.login1",
1162 "/org/freedesktop/login1",
1163 "org.freedesktop.login1.Manager",
1164 "TerminateUser",
1165 NULL,
1166 NULL,
1167 DBUS_TYPE_UINT32, &u,
1168 DBUS_TYPE_INVALID);
1169 if (r)
1170 return r;
1171 }
1172
1173 return 0;
1174 }
1175
1176 static int kill_user(DBusConnection *bus, char **args, unsigned n) {
1177 unsigned i;
1178
1179 assert(args);
1180
1181 if (!arg_kill_who)
1182 arg_kill_who = "all";
1183
1184 for (i = 1; i < n; i++) {
1185 uid_t uid;
1186 uint32_t u;
1187 int r;
1188
1189 r = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
1190 if (r < 0) {
1191 log_error("Failed to look up user %s: %s", args[i], strerror(-r));
1192 return r;
1193 }
1194
1195 u = (uint32_t) uid;
1196 r = bus_method_call_with_reply (
1197 bus,
1198 "org.freedesktop.login1",
1199 "/org/freedesktop/login1",
1200 "org.freedesktop.login1.Manager",
1201 "KillUser",
1202 NULL,
1203 NULL,
1204 DBUS_TYPE_UINT32, &u,
1205 DBUS_TYPE_INT32, &arg_signal,
1206 DBUS_TYPE_INVALID);
1207 if (r)
1208 return r;
1209 }
1210
1211 return 0;
1212 }
1213
1214 static int attach(DBusConnection *bus, char **args, unsigned n) {
1215 unsigned i;
1216 dbus_bool_t interactive = true;
1217
1218 assert(args);
1219
1220 polkit_agent_open_if_enabled();
1221
1222 for (i = 2; i < n; i++) {
1223 int r;
1224
1225 r = bus_method_call_with_reply (
1226 bus,
1227 "org.freedesktop.login1",
1228 "/org/freedesktop/login1",
1229 "org.freedesktop.login1.Manager",
1230 "AttachDevice",
1231 NULL,
1232 NULL,
1233 DBUS_TYPE_STRING, &args[1],
1234 DBUS_TYPE_STRING, &args[i],
1235 DBUS_TYPE_BOOLEAN, &interactive,
1236 DBUS_TYPE_INVALID);
1237 if (r)
1238 return r;
1239 }
1240
1241 return 0;
1242 }
1243
1244 static int flush_devices(DBusConnection *bus, char **args, unsigned n) {
1245 dbus_bool_t interactive = true;
1246
1247 assert(args);
1248
1249 polkit_agent_open_if_enabled();
1250
1251 return bus_method_call_with_reply (
1252 bus,
1253 "org.freedesktop.login1",
1254 "/org/freedesktop/login1",
1255 "org.freedesktop.login1.Manager",
1256 "FlushDevices",
1257 NULL,
1258 NULL,
1259 DBUS_TYPE_BOOLEAN, &interactive,
1260 DBUS_TYPE_INVALID);
1261 }
1262
1263 static int lock_sessions(DBusConnection *bus, char **args, unsigned n) {
1264 assert(args);
1265
1266 polkit_agent_open_if_enabled();
1267
1268 return bus_method_call_with_reply (
1269 bus,
1270 "org.freedesktop.login1",
1271 "/org/freedesktop/login1",
1272 "org.freedesktop.login1.Manager",
1273 streq(args[0], "lock-sessions") ? "LockSessions" : "UnlockSessions",
1274 NULL,
1275 NULL,
1276 DBUS_TYPE_INVALID);
1277 }
1278
1279 static int terminate_seat(DBusConnection *bus, char **args, unsigned n) {
1280 unsigned i;
1281
1282 assert(args);
1283
1284 for (i = 1; i < n; i++) {
1285 int r;
1286
1287 r = bus_method_call_with_reply (
1288 bus,
1289 "org.freedesktop.login1",
1290 "/org/freedesktop/login1",
1291 "org.freedesktop.login1.Manager",
1292 "TerminateSeat",
1293 NULL,
1294 NULL,
1295 DBUS_TYPE_STRING, &args[i],
1296 DBUS_TYPE_INVALID);
1297 if (r)
1298 return r;
1299 }
1300
1301 return 0;
1302 }
1303
1304 static int help(void) {
1305
1306 printf("%s [OPTIONS...] {COMMAND} ...\n\n"
1307 "Send control commands to or query the login manager.\n\n"
1308 " -h --help Show this help\n"
1309 " --version Show package version\n"
1310 " -p --property=NAME Show only properties by this name\n"
1311 " -a --all Show all properties, including empty ones\n"
1312 " --kill-who=WHO Who to send signal to\n"
1313 " -l --full Do not ellipsize output\n"
1314 " -s --signal=SIGNAL Which signal to send\n"
1315 " --no-ask-password Don't prompt for password\n"
1316 " -H --host=[USER@]HOST Show information for remote host\n"
1317 " -P --privileged Acquire privileges before execution\n"
1318 " --no-pager Do not pipe output into a pager\n\n"
1319 "Commands:\n"
1320 " list-sessions List sessions\n"
1321 " session-status [ID...] Show session status\n"
1322 " show-session [ID...] Show properties of one or more sessions\n"
1323 " activate [ID] Activate a session\n"
1324 " lock-session [ID...] Screen lock one or more sessions\n"
1325 " unlock-session [ID...] Screen unlock one or more sessions\n"
1326 " lock-sessions Screen lock all current sessions\n"
1327 " unlock-sessions Screen unlock all current sessions\n"
1328 " terminate-session [ID...] Terminate one or more sessions\n"
1329 " kill-session [ID...] Send signal to processes of a session\n"
1330 " list-users List users\n"
1331 " user-status [USER...] Show user status\n"
1332 " show-user [USER...] Show properties of one or more users\n"
1333 " enable-linger [USER...] Enable linger state of one or more users\n"
1334 " disable-linger [USER...] Disable linger state of one or more users\n"
1335 " terminate-user [USER...] Terminate all sessions of one or more users\n"
1336 " kill-user [USER...] Send signal to processes of a user\n"
1337 " list-seats List seats\n"
1338 " seat-status [NAME...] Show seat status\n"
1339 " show-seat [NAME...] Show properties of one or more seats\n"
1340 " attach [NAME] [DEVICE...] Attach one or more devices to a seat\n"
1341 " flush-devices Flush all device associations\n"
1342 " terminate-seat [NAME...] Terminate all sessions on one or more seats\n",
1343 program_invocation_short_name);
1344
1345 return 0;
1346 }
1347
1348 static int parse_argv(int argc, char *argv[]) {
1349
1350 enum {
1351 ARG_VERSION = 0x100,
1352 ARG_NO_PAGER,
1353 ARG_KILL_WHO,
1354 ARG_NO_ASK_PASSWORD,
1355 };
1356
1357 static const struct option options[] = {
1358 { "help", no_argument, NULL, 'h' },
1359 { "version", no_argument, NULL, ARG_VERSION },
1360 { "property", required_argument, NULL, 'p' },
1361 { "all", no_argument, NULL, 'a' },
1362 { "full", no_argument, NULL, 'l' },
1363 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
1364 { "kill-who", required_argument, NULL, ARG_KILL_WHO },
1365 { "signal", required_argument, NULL, 's' },
1366 { "host", required_argument, NULL, 'H' },
1367 { "privileged", no_argument, NULL, 'P' },
1368 { "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD },
1369 { NULL, 0, NULL, 0 }
1370 };
1371
1372 int c;
1373
1374 assert(argc >= 0);
1375 assert(argv);
1376
1377 while ((c = getopt_long(argc, argv, "hp:als:H:P", options, NULL)) >= 0) {
1378
1379 switch (c) {
1380
1381 case 'h':
1382 help();
1383 return 0;
1384
1385 case ARG_VERSION:
1386 puts(PACKAGE_STRING);
1387 puts(SYSTEMD_FEATURES);
1388 return 0;
1389
1390 case 'p': {
1391 char **l;
1392
1393 l = strv_append(arg_property, optarg);
1394 if (!l)
1395 return -ENOMEM;
1396
1397 strv_free(arg_property);
1398 arg_property = l;
1399
1400 /* If the user asked for a particular
1401 * property, show it to him, even if it is
1402 * empty. */
1403 arg_all = true;
1404 break;
1405 }
1406
1407 case 'a':
1408 arg_all = true;
1409 break;
1410
1411 case 'l':
1412 arg_full = true;
1413 break;
1414
1415 case ARG_NO_PAGER:
1416 arg_no_pager = true;
1417 break;
1418
1419 case ARG_NO_ASK_PASSWORD:
1420 arg_ask_password = false;
1421 break;
1422
1423 case ARG_KILL_WHO:
1424 arg_kill_who = optarg;
1425 break;
1426
1427 case 's':
1428 arg_signal = signal_from_string_try_harder(optarg);
1429 if (arg_signal < 0) {
1430 log_error("Failed to parse signal string %s.", optarg);
1431 return -EINVAL;
1432 }
1433 break;
1434
1435 case 'P':
1436 arg_transport = TRANSPORT_POLKIT;
1437 break;
1438
1439 case 'H':
1440 arg_transport = TRANSPORT_SSH;
1441 parse_user_at_host(optarg, &arg_user, &arg_host);
1442 break;
1443
1444 case '?':
1445 return -EINVAL;
1446
1447 default:
1448 log_error("Unknown option code %c", c);
1449 return -EINVAL;
1450 }
1451 }
1452
1453 return 1;
1454 }
1455
1456 static int loginctl_main(DBusConnection *bus, int argc, char *argv[], DBusError *error) {
1457
1458 static const struct {
1459 const char* verb;
1460 const enum {
1461 MORE,
1462 LESS,
1463 EQUAL
1464 } argc_cmp;
1465 const int argc;
1466 int (* const dispatch)(DBusConnection *bus, char **args, unsigned n);
1467 } verbs[] = {
1468 { "list-sessions", LESS, 1, list_sessions },
1469 { "session-status", MORE, 2, show },
1470 { "show-session", MORE, 1, show },
1471 { "activate", EQUAL, 2, activate },
1472 { "lock-session", MORE, 2, activate },
1473 { "unlock-session", MORE, 2, activate },
1474 { "lock-sessions", EQUAL, 1, lock_sessions },
1475 { "unlock-sessions", EQUAL, 1, lock_sessions },
1476 { "terminate-session", MORE, 2, activate },
1477 { "kill-session", MORE, 2, kill_session },
1478 { "list-users", EQUAL, 1, list_users },
1479 { "user-status", MORE, 2, show },
1480 { "show-user", MORE, 1, show },
1481 { "enable-linger", MORE, 2, enable_linger },
1482 { "disable-linger", MORE, 2, enable_linger },
1483 { "terminate-user", MORE, 2, terminate_user },
1484 { "kill-user", MORE, 2, kill_user },
1485 { "list-seats", EQUAL, 1, list_seats },
1486 { "seat-status", MORE, 2, show },
1487 { "show-seat", MORE, 1, show },
1488 { "attach", MORE, 3, attach },
1489 { "flush-devices", EQUAL, 1, flush_devices },
1490 { "terminate-seat", MORE, 2, terminate_seat },
1491 };
1492
1493 int left;
1494 unsigned i;
1495
1496 assert(argc >= 0);
1497 assert(argv);
1498 assert(error);
1499
1500 left = argc - optind;
1501
1502 if (left <= 0)
1503 /* Special rule: no arguments means "list-sessions" */
1504 i = 0;
1505 else {
1506 if (streq(argv[optind], "help")) {
1507 help();
1508 return 0;
1509 }
1510
1511 for (i = 0; i < ELEMENTSOF(verbs); i++)
1512 if (streq(argv[optind], verbs[i].verb))
1513 break;
1514
1515 if (i >= ELEMENTSOF(verbs)) {
1516 log_error("Unknown operation %s", argv[optind]);
1517 return -EINVAL;
1518 }
1519 }
1520
1521 switch (verbs[i].argc_cmp) {
1522
1523 case EQUAL:
1524 if (left != verbs[i].argc) {
1525 log_error("Invalid number of arguments.");
1526 return -EINVAL;
1527 }
1528
1529 break;
1530
1531 case MORE:
1532 if (left < verbs[i].argc) {
1533 log_error("Too few arguments.");
1534 return -EINVAL;
1535 }
1536
1537 break;
1538
1539 case LESS:
1540 if (left > verbs[i].argc) {
1541 log_error("Too many arguments.");
1542 return -EINVAL;
1543 }
1544
1545 break;
1546
1547 default:
1548 assert_not_reached("Unknown comparison operator.");
1549 }
1550
1551 if (!bus) {
1552 log_error("Failed to get D-Bus connection: %s", error->message);
1553 return -EIO;
1554 }
1555
1556 return verbs[i].dispatch(bus, argv + optind, left);
1557 }
1558
1559 int main(int argc, char*argv[]) {
1560 int r, retval = EXIT_FAILURE;
1561 DBusConnection *bus = NULL;
1562 DBusError error;
1563
1564 dbus_error_init(&error);
1565
1566 setlocale(LC_ALL, "");
1567 log_parse_environment();
1568 log_open();
1569
1570 r = parse_argv(argc, argv);
1571 if (r < 0)
1572 goto finish;
1573 else if (r == 0) {
1574 retval = EXIT_SUCCESS;
1575 goto finish;
1576 }
1577
1578 if (arg_transport == TRANSPORT_NORMAL)
1579 bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
1580 else if (arg_transport == TRANSPORT_POLKIT)
1581 bus_connect_system_polkit(&bus, &error);
1582 else if (arg_transport == TRANSPORT_SSH)
1583 bus_connect_system_ssh(NULL, arg_host, &bus, &error);
1584 else
1585 assert_not_reached("Uh, invalid transport...");
1586
1587 r = loginctl_main(bus, argc, argv, &error);
1588 retval = r < 0 ? EXIT_FAILURE : r;
1589
1590 finish:
1591 if (bus) {
1592 dbus_connection_flush(bus);
1593 dbus_connection_close(bus);
1594 dbus_connection_unref(bus);
1595 }
1596
1597 dbus_error_free(&error);
1598 dbus_shutdown();
1599
1600 strv_free(arg_property);
1601
1602 pager_close();
1603
1604 return retval;
1605 }
Unnamed repository; edit this file 'description' to name the repository.