[thirdparty/systemd.git] / src / loginctl.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <dbus/dbus.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <getopt.h>

#include "log.h"
#include "util.h"
#include "macro.h"
#include "pager.h"
#include "dbus-common.h"
#include "build.h"

static bool arg_no_pager = false;
static enum transport {
        TRANSPORT_NORMAL,
        TRANSPORT_SSH,
        TRANSPORT_POLKIT
} arg_transport = TRANSPORT_NORMAL;
static const char *arg_host = NULL;

static bool on_tty(void) {
        static int t = -1;

        /* Note that this is invoked relatively early, before we start
         * the pager. That means the value we return reflects whether
         * we originally were started on a tty, not if we currently
         * are. But this is intended, since we want colour and so on
         * when run in our own pager. */

        if (_unlikely_(t < 0))
                t = isatty(STDOUT_FILENO) > 0;

        return t;
}

static void pager_open_if_enabled(void) {
        on_tty();

        if (!arg_no_pager)
                pager_open();
}

static int list_sessions(DBusConnection *bus, char **args, unsigned n) {
        DBusMessage *m = NULL, *reply = NULL;
        DBusError error;
        int r;
        DBusMessageIter iter, sub, sub2;
        unsigned k = 0;

        dbus_error_init(&error);

        assert(bus);

        pager_open_if_enabled();

        m = dbus_message_new_method_call(
                        "org.freedesktop.login1",
                        "/org/freedesktop/login1",
                        "org.freedesktop.login1.Manager",
                        "ListSessions");
        if (!m) {
                log_error("Could not allocate message.");
                return -ENOMEM;
        }

        reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
        if (!reply) {
                log_error("Failed to issue method call: %s", bus_error_message(&error));
                r = -EIO;
                goto finish;
        }

        if (!dbus_message_iter_init(reply, &iter) ||
            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
                log_error("Failed to parse reply.");
                r = -EIO;
                goto finish;
        }

        dbus_message_iter_recurse(&iter, &sub);

        if (on_tty())
                printf("%10s %10s %-16s %-16s\n", "SESSION", "UID", "USER", "SEAT");

        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
                const char *id, *user, *seat, *object;
                uint32_t uid;

                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
                        log_error("Failed to parse reply.");
                        r = -EIO;
                        goto finish;
                }

                dbus_message_iter_recurse(&sub, &sub2);

                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &user, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
                        log_error("Failed to parse reply.");
                        r = -EIO;
                        goto finish;
                }

                printf("%10s %10u %-16s %-16s\n", id, (unsigned) uid, user, seat);

                k++;

                dbus_message_iter_next(&sub);
        }

        if (on_tty())
                printf("\n%u sessions listed.\n", k);

        r = 0;

finish:
        if (m)
                dbus_message_unref(m);

        if (reply)
                dbus_message_unref(reply);

        dbus_error_free(&error);

        return r;
}

static int list_users(DBusConnection *bus, char **args, unsigned n) {
        DBusMessage *m = NULL, *reply = NULL;
        DBusError error;
        int r;
        DBusMessageIter iter, sub, sub2;
        unsigned k = 0;

        dbus_error_init(&error);

        assert(bus);

        pager_open_if_enabled();

        m = dbus_message_new_method_call(
                        "org.freedesktop.login1",
                        "/org/freedesktop/login1",
                        "org.freedesktop.login1.Manager",
                        "ListUsers");
        if (!m) {
                log_error("Could not allocate message.");
                return -ENOMEM;
        }

        reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
        if (!reply) {
                log_error("Failed to issue method call: %s", bus_error_message(&error));
                r = -EIO;
                goto finish;
        }

        if (!dbus_message_iter_init(reply, &iter) ||
            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
                log_error("Failed to parse reply.");
                r = -EIO;
                goto finish;
        }

        dbus_message_iter_recurse(&iter, &sub);

        if (on_tty())
                printf("%10s %-16s\n", "UID", "USER");

        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
                const char *user, *object;
                uint32_t uid;

                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
                        log_error("Failed to parse reply.");
                        r = -EIO;
                        goto finish;
                }

                dbus_message_iter_recurse(&sub, &sub2);

                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &user, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
                        log_error("Failed to parse reply.");
                        r = -EIO;
                        goto finish;
                }

                printf("%10u %-16s\n", (unsigned) uid, user);

                k++;

                dbus_message_iter_next(&sub);
        }

        if (on_tty())
                printf("\n%u users listed.\n", k);

        r = 0;

finish:
        if (m)
                dbus_message_unref(m);

        if (reply)
                dbus_message_unref(reply);

        dbus_error_free(&error);

        return r;
}

static int list_seats(DBusConnection *bus, char **args, unsigned n) {
        DBusMessage *m = NULL, *reply = NULL;
        DBusError error;
        int r;
        DBusMessageIter iter, sub, sub2;
        unsigned k = 0;

        dbus_error_init(&error);

        assert(bus);

        pager_open_if_enabled();

        m = dbus_message_new_method_call(
                        "org.freedesktop.login1",
                        "/org/freedesktop/login1",
                        "org.freedesktop.login1.Manager",
                        "ListSeats");
        if (!m) {
                log_error("Could not allocate message.");
                return -ENOMEM;
        }

        reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
        if (!reply) {
                log_error("Failed to issue method call: %s", bus_error_message(&error));
                r = -EIO;
                goto finish;
        }

        if (!dbus_message_iter_init(reply, &iter) ||
            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
                log_error("Failed to parse reply.");
                r = -EIO;
                goto finish;
        }

        dbus_message_iter_recurse(&iter, &sub);

        if (on_tty())
                printf("%-16s\n", "SEAT");

        while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
                const char *seat, *object;

                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
                        log_error("Failed to parse reply.");
                        r = -EIO;
                        goto finish;
                }

                dbus_message_iter_recurse(&sub, &sub2);

                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 ||
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
                        log_error("Failed to parse reply.");
                        r = -EIO;
                        goto finish;
                }

                printf("%-16s\n", seat);

                k++;

                dbus_message_iter_next(&sub);
        }

        if (on_tty())
                printf("\n%u seats listed.\n", k);

        r = 0;

finish:
        if (m)
                dbus_message_unref(m);

        if (reply)
                dbus_message_unref(reply);

        dbus_error_free(&error);

        return r;
}

static int help(void) {

        printf("%s [OPTIONS...] {COMMAND} ...\n\n"
               "Send control commands to or query the login manager.\n\n"
               "  -h --help           Show this help\n"
               "     --version        Show package version\n"
               "  -H --host=[user@]host\n"
               "                      Show information for remote host\n"
               "  -P --privileged     Acquire privileges before execution\n"
               "     --no-pager       Do not pipe output into a pager.\n"
               "Commands:\n"
               "  list-sessions                   List sessions\n"
               "  list-users                      List users\n"
               "  list-seats                      List seats\n",
               program_invocation_short_name);

        return 0;
}

static int parse_argv(int argc, char *argv[]) {

        enum {
                ARG_VERSION = 0x100,
                ARG_NO_PAGER
        };

        static const struct option options[] = {
                { "help",      no_argument,       NULL, 'h'           },
                { "version",   no_argument,       NULL, ARG_VERSION   },
                { "no-pager",  no_argument,       NULL, ARG_NO_PAGER  },
                { "host",      required_argument, NULL, 'H'           },
                { "privileged",no_argument,       NULL, 'P'           },
                { NULL,        0,                 NULL, 0             }
        };

        int c;

        assert(argc >= 0);
        assert(argv);

        while ((c = getopt_long(argc, argv, "hH:P", options, NULL)) >= 0) {

                switch (c) {

                case 'h':
                        help();
                        return 0;

                case ARG_VERSION:
                        puts(PACKAGE_STRING);
                        puts(DISTRIBUTION);
                        puts(SYSTEMD_FEATURES);
                        return 0;

                case ARG_NO_PAGER:
                        arg_no_pager = true;
                        break;

                case 'P':
                        arg_transport = TRANSPORT_POLKIT;
                        break;

                case 'H':
                        arg_transport = TRANSPORT_SSH;
                        arg_host = optarg;
                        break;

                case '?':
                        return -EINVAL;

                default:
                        log_error("Unknown option code %c", c);
                        return -EINVAL;
                }
        }

        return 1;
}

static int loginctl_main(DBusConnection *bus, int argc, char *argv[], DBusError *error) {

        static const struct {
                const char* verb;
                const enum {
                        MORE,
                        LESS,
                        EQUAL
                } argc_cmp;
                const int argc;
                int (* const dispatch)(DBusConnection *bus, char **args, unsigned n);
        } verbs[] = {
                { "list-sessions",         LESS,   1, list_sessions    },
                { "list-users",            EQUAL,  1, list_users       },
                { "list-seats",            EQUAL,  1, list_seats       },
        };

        int left;
        unsigned i;

        assert(argc >= 0);
        assert(argv);
        assert(error);

        left = argc - optind;

        if (left <= 0)
                /* Special rule: no arguments means "list-sessions" */
                i = 0;
        else {
                if (streq(argv[optind], "help")) {
                        help();
                        return 0;
                }

                for (i = 0; i < ELEMENTSOF(verbs); i++)
                        if (streq(argv[optind], verbs[i].verb))
                                break;

                if (i >= ELEMENTSOF(verbs)) {
                        log_error("Unknown operation %s", argv[optind]);
                        return -EINVAL;
                }
        }

        switch (verbs[i].argc_cmp) {

        case EQUAL:
                if (left != verbs[i].argc) {
                        log_error("Invalid number of arguments.");
                        return -EINVAL;
                }

                break;

        case MORE:
                if (left < verbs[i].argc) {
                        log_error("Too few arguments.");
                        return -EINVAL;
                }

                break;

        case LESS:
                if (left > verbs[i].argc) {
                        log_error("Too many arguments.");
                        return -EINVAL;
                }

                break;

        default:
                assert_not_reached("Unknown comparison operator.");
        }

        if (!bus) {
                log_error("Failed to get D-Bus connection: %s", error->message);
                return -EIO;
        }

        return verbs[i].dispatch(bus, argv + optind, left);
}

int main(int argc, char*argv[]) {
        int r, retval = EXIT_FAILURE;
        DBusConnection *bus = NULL;
        DBusError error;

        dbus_error_init(&error);

        log_parse_environment();
        log_open();

        r = parse_argv(argc, argv);
        if (r < 0)
                goto finish;
        else if (r == 0) {
                retval = EXIT_SUCCESS;
                goto finish;
        }

        if (arg_transport == TRANSPORT_NORMAL)
                bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
        else if (arg_transport == TRANSPORT_POLKIT)
                bus_connect_system_polkit(&bus, &error);
        else if (arg_transport == TRANSPORT_SSH)
                bus_connect_system_ssh(NULL, arg_host, &bus, &error);
        else
                assert_not_reached("Uh, invalid transport...");

        r = loginctl_main(bus, argc, argv, &error);
        retval = r < 0 ? EXIT_FAILURE : r;

finish:
        if (bus) {
                dbus_connection_flush(bus);
                dbus_connection_close(bus);
                dbus_connection_unref(bus);
        }

        dbus_error_free(&error);
        dbus_shutdown();

        pager_close();

        return retval;
}
Commit	Line	Data
abca4822 LP	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 General Public License as published by
	10	the Free Software Foundation; either version 2 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	General Public License for more details.
	17
	18	You should have received a copy of the GNU 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
	28	#include "log.h"
	29	#include "util.h"
	30	#include "macro.h"
	31	#include "pager.h"
	32	#include "dbus-common.h"
	33	#include "build.h"
	34
	35	static bool arg_no_pager = false;
	36	static enum transport {
	37	TRANSPORT_NORMAL,
	38	TRANSPORT_SSH,
	39	TRANSPORT_POLKIT
	40	} arg_transport = TRANSPORT_NORMAL;
	41	static const char *arg_host = NULL;
	42
	43	static bool on_tty(void) {
	44	static int t = -1;
	45
	46	/* Note that this is invoked relatively early, before we start
	47	* the pager. That means the value we return reflects whether
	48	* we originally were started on a tty, not if we currently
	49	* are. But this is intended, since we want colour and so on
	50	* when run in our own pager. */
	51
	52	if (_unlikely_(t < 0))
	53	t = isatty(STDOUT_FILENO) > 0;
	54
	55	return t;
	56	}
	57
	58	static void pager_open_if_enabled(void) {
	59	on_tty();
	60
	61	if (!arg_no_pager)
	62	pager_open();
	63	}
	64
65	static int list_sessions(DBusConnection bus, char *args, unsigned n) {
66	DBusMessage m = NULL, reply = NULL;
67	DBusError error;
68	int r;
69	DBusMessageIter iter, sub, sub2;
70	unsigned k = 0;
71
72	dbus_error_init(&error);
73
74	assert(bus);
75
76	pager_open_if_enabled();
77
78	m = dbus_message_new_method_call(
79	"org.freedesktop.login1",
80	"/org/freedesktop/login1",
81	"org.freedesktop.login1.Manager",
82	"ListSessions");
83	if (!m) {
84	log_error("Could not allocate message.");
85	return -ENOMEM;
86	}
87
88	reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
89	if (!reply) {
90	log_error("Failed to issue method call: %s", bus_error_message(&error));
91	r = -EIO;
92	goto finish;
93	}
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	r = -EIO;
100	goto finish;
101	}
102
103	dbus_message_iter_recurse(&iter, &sub);
104
105	if (on_tty())
106	printf("%10s %10s %-16s %-16s\n", "SESSION", "UID", "USER", "SEAT");
107
108	while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
109	const char id, user, seat, object;
110	uint32_t uid;
111
112	if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
113	log_error("Failed to parse reply.");
114	r = -EIO;
115	goto finish;
116	}
117
118	dbus_message_iter_recurse(&sub, &sub2);
119
120	if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) < 0 \|\|
121	bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 \|\|
122	bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &user, true) < 0 \|\|
123	bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 \|\|
124	bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
125	log_error("Failed to parse reply.");
126	r = -EIO;
127	goto finish;
128	}
129
130	printf("%10s %10u %-16s %-16s\n", id, (unsigned) uid, user, seat);
131
132	k++;
133
134	dbus_message_iter_next(&sub);
135	}
136
137	if (on_tty())
138	printf("\n%u sessions listed.\n", k);
139
140	r = 0;
141
142	finish:
143	if (m)
144	dbus_message_unref(m);
145
146	if (reply)
147	dbus_message_unref(reply);
148
149	dbus_error_free(&error);
150
151	return r;
152	}
153
154	static int list_users(DBusConnection bus, char *args, unsigned n) {
155	DBusMessage m = NULL, reply = NULL;
156	DBusError error;
157	int r;
158	DBusMessageIter iter, sub, sub2;
159	unsigned k = 0;
160
161	dbus_error_init(&error);
162
163	assert(bus);
164
165	pager_open_if_enabled();
166
167	m = dbus_message_new_method_call(
168	"org.freedesktop.login1",
169	"/org/freedesktop/login1",
170	"org.freedesktop.login1.Manager",
171	"ListUsers");
172	if (!m) {
173	log_error("Could not allocate message.");
174	return -ENOMEM;
175	}
176
177	reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
178	if (!reply) {
179	log_error("Failed to issue method call: %s", bus_error_message(&error));
180	r = -EIO;
181	goto finish;
182	}
183
184	if (!dbus_message_iter_init(reply, &iter) \|\|
185	dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY \|\|
186	dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
187	log_error("Failed to parse reply.");
188	r = -EIO;
189	goto finish;
190	}
191
192	dbus_message_iter_recurse(&iter, &sub);
193
194	if (on_tty())
195	printf("%10s %-16s\n", "UID", "USER");
196
197	while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
198	const char user, object;
199	uint32_t uid;
200
201	if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
202	log_error("Failed to parse reply.");
203	r = -EIO;
204	goto finish;
205	}
206
207	dbus_message_iter_recurse(&sub, &sub2);
208
209	if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 \|\|
210	bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &user, true) < 0 \|\|
211	bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
212	log_error("Failed to parse reply.");
213	r = -EIO;
214	goto finish;
215	}
216
217	printf("%10u %-16s\n", (unsigned) uid, user);
218
219	k++;
220
221	dbus_message_iter_next(&sub);
222	}
223
224	if (on_tty())
225	printf("\n%u users listed.\n", k);
226
227	r = 0;
228
229	finish:
230	if (m)
231	dbus_message_unref(m);
232
233	if (reply)
234	dbus_message_unref(reply);
235
236	dbus_error_free(&error);
237
238	return r;
239	}
240
241	static int list_seats(DBusConnection bus, char *args, unsigned n) {
242	DBusMessage m = NULL, reply = NULL;
243	DBusError error;
244	int r;
245	DBusMessageIter iter, sub, sub2;
246	unsigned k = 0;
247
248	dbus_error_init(&error);
249
250	assert(bus);
251
252	pager_open_if_enabled();
253
254	m = dbus_message_new_method_call(
255	"org.freedesktop.login1",
256	"/org/freedesktop/login1",
257	"org.freedesktop.login1.Manager",
258	"ListSeats");
259	if (!m) {
260	log_error("Could not allocate message.");
261	return -ENOMEM;
262	}
263
264	reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
265	if (!reply) {
266	log_error("Failed to issue method call: %s", bus_error_message(&error));
267	r = -EIO;
268	goto finish;
269	}
270
271	if (!dbus_message_iter_init(reply, &iter) \|\|
272	dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY \|\|
273	dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
274	log_error("Failed to parse reply.");
275	r = -EIO;
276	goto finish;
277	}
278
279	dbus_message_iter_recurse(&iter, &sub);
280
281	if (on_tty())
282	printf("%-16s\n", "SEAT");
283
284	while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
285	const char seat, object;
286
287	if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
288	log_error("Failed to parse reply.");
289	r = -EIO;
290	goto finish;
291	}
292
293	dbus_message_iter_recurse(&sub, &sub2);
294
295	if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 \|\|
296	bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
297	log_error("Failed to parse reply.");
298	r = -EIO;
299	goto finish;
300	}
301
302	printf("%-16s\n", seat);
303
304	k++;
305
306	dbus_message_iter_next(&sub);
307	}
308
309	if (on_tty())
310	printf("\n%u seats listed.\n", k);
311
312	r = 0;
313
314	finish:
315	if (m)
316	dbus_message_unref(m);
317
318	if (reply)
319	dbus_message_unref(reply);
320
321	dbus_error_free(&error);
322
323	return r;
324	}
325
326	static int help(void) {
327
328	printf("%s [OPTIONS...] {COMMAND} ...\n\n"
329	"Send control commands to or query the login manager.\n\n"
330	" -h --help Show this help\n"
331	" --version Show package version\n"
332	" -H --host=[user@]host\n"
333	" Show information for remote host\n"
334	" -P --privileged Acquire privileges before execution\n"
335	" --no-pager Do not pipe output into a pager.\n"
336	"Commands:\n"
337	" list-sessions List sessions\n"
338	" list-users List users\n"
339	" list-seats List seats\n",
340	program_invocation_short_name);
341
342	return 0;
343	}
344
345	static int parse_argv(int argc, char *argv[]) {
346
347	enum {
348	ARG_VERSION = 0x100,
349	ARG_NO_PAGER
350	};
351
352	static const struct option options[] = {
353	{ "help", no_argument, NULL, 'h' },
354	{ "version", no_argument, NULL, ARG_VERSION },
355	{ "no-pager", no_argument, NULL, ARG_NO_PAGER },
356	{ "host", required_argument, NULL, 'H' },
357	{ "privileged",no_argument, NULL, 'P' },
358	{ NULL, 0, NULL, 0 }
359	};
360
361	int c;
362
363	assert(argc >= 0);
364	assert(argv);
365
366	while ((c = getopt_long(argc, argv, "hH:P", options, NULL)) >= 0) {
367
368	switch (c) {
369
370	case 'h':
371	help();
372	return 0;
373
374	case ARG_VERSION:
375	puts(PACKAGE_STRING);
376	puts(DISTRIBUTION);
377	puts(SYSTEMD_FEATURES);
378	return 0;
379
380	case ARG_NO_PAGER:
381	arg_no_pager = true;
382	break;
383
384	case 'P':
385	arg_transport = TRANSPORT_POLKIT;
386	break;
387
388	case 'H':
389	arg_transport = TRANSPORT_SSH;
390	arg_host = optarg;
391	break;
392
393	case '?':
394	return -EINVAL;
395
396	default:
397	log_error("Unknown option code %c", c);
398	return -EINVAL;
399	}
400	}
401
402	return 1;
403	}
404
405	static int loginctl_main(DBusConnection bus, int argc, char argv[], DBusError *error) {
406
407	static const struct {
408	const char* verb;
409	const enum {
410	MORE,
411	LESS,
412	EQUAL
413	} argc_cmp;
414	const int argc;
415	int (* const dispatch)(DBusConnection bus, char *args, unsigned n);
416	} verbs[] = {
417	{ "list-sessions", LESS, 1, list_sessions },
418	{ "list-users", EQUAL, 1, list_users },
419	{ "list-seats", EQUAL, 1, list_seats },
420	};
421
422	int left;
423	unsigned i;
424
425	assert(argc >= 0);
426	assert(argv);
427	assert(error);
428
429	left = argc - optind;
430
431	if (left <= 0)
432	/* Special rule: no arguments means "list-sessions" */
433	i = 0;
434	else {
435	if (streq(argv[optind], "help")) {
436	help();
437	return 0;
438	}
439
440	for (i = 0; i < ELEMENTSOF(verbs); i++)
441	if (streq(argv[optind], verbs[i].verb))
442	break;
443
444	if (i >= ELEMENTSOF(verbs)) {
445	log_error("Unknown operation %s", argv[optind]);
446	return -EINVAL;
447	}
448	}
449
450	switch (verbs[i].argc_cmp) {
451
452	case EQUAL:
453	if (left != verbs[i].argc) {
454	log_error("Invalid number of arguments.");
455	return -EINVAL;
456	}
457
458	break;
459
460	case MORE:
461	if (left < verbs[i].argc) {
462	log_error("Too few arguments.");
463	return -EINVAL;
464	}
465
466	break;
467
468	case LESS:
469	if (left > verbs[i].argc) {
470	log_error("Too many arguments.");
471	return -EINVAL;
472	}
473
474	break;
475
476	default:
477	assert_not_reached("Unknown comparison operator.");
478	}
479
480	if (!bus) {
481	log_error("Failed to get D-Bus connection: %s", error->message);
482	return -EIO;
483	}
484
485	return verbs[i].dispatch(bus, argv + optind, left);
486	}
487
488	int main(int argc, char*argv[]) {
489	int r, retval = EXIT_FAILURE;
490	DBusConnection *bus = NULL;
491	DBusError error;
492
493	dbus_error_init(&error);
494
495	log_parse_environment();
496	log_open();
497
498	r = parse_argv(argc, argv);
499	if (r < 0)
500	goto finish;
501	else if (r == 0) {
502	retval = EXIT_SUCCESS;
503	goto finish;
504	}
505
506	if (arg_transport == TRANSPORT_NORMAL)
507	bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
508	else if (arg_transport == TRANSPORT_POLKIT)
509	bus_connect_system_polkit(&bus, &error);
510	else if (arg_transport == TRANSPORT_SSH)
511	bus_connect_system_ssh(NULL, arg_host, &bus, &error);
512	else
513	assert_not_reached("Uh, invalid transport...");
514
515	r = loginctl_main(bus, argc, argv, &error);
516	retval = r < 0 ? EXIT_FAILURE : r;
517
518	finish:
519	if (bus) {
520	dbus_connection_flush(bus);
521	dbus_connection_close(bus);
522	dbus_connection_unref(bus);
523	}
524
525	dbus_error_free(&error);
526	dbus_shutdown();
527
528	pager_close();
529
530	return retval;
531	}