← Back to branch summary

~ubuntu-branches/ubuntu/trusty/systemd/trusty

« back to all changes in this revision

Viewing changes to src/login/loginctl.c

Tags: upstream-202
Import upstream version 202

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/login/loginctl.c
72
72
}
73
73
 
74
74
static int list_sessions(DBusConnection *bus, char **args, unsigned n) {
75
 
        DBusMessage *reply = NULL;
 
75
        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
76
76
        int r;
77
77
        DBusMessageIter iter, sub, sub2;
78
78
        unsigned k = 0;
89
89
                        NULL,
90
90
                        DBUS_TYPE_INVALID);
91
91
        if (r)
92
 
                goto finish;
 
92
                return r;
93
93
 
94
94
        if (!dbus_message_iter_init(reply, &iter) ||
95
95
            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
96
96
            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
97
97
                log_error("Failed to parse reply.");
98
 
                r = -EIO;
99
 
                goto finish;
 
98
                return -EIO;
100
99
        }
101
100
 
102
101
        dbus_message_iter_recurse(&iter, &sub);
110
109
 
111
110
                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
112
111
                        log_error("Failed to parse reply.");
113
 
                        r = -EIO;
114
 
                        goto finish;
 
112
                        return -EIO;
115
113
                }
116
114
 
117
115
                dbus_message_iter_recurse(&sub, &sub2);
122
120
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 ||
123
121
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
124
122
                        log_error("Failed to parse reply.");
125
 
                        r = -EIO;
126
 
                        goto finish;
 
123
                        return -EIO;
127
124
                }
128
125
 
129
126
                printf("%10s %10u %-16s %-16s\n", id, (unsigned) uid, user, seat);
136
133
        if (on_tty())
137
134
                printf("\n%u sessions listed.\n", k);
138
135
 
139
 
        r = 0;
140
 
 
141
 
finish:
142
 
        if (reply)
143
 
                dbus_message_unref(reply);
144
 
 
145
 
        return r;
 
136
        return 0;
146
137
}
147
138
 
148
139
static int list_users(DBusConnection *bus, char **args, unsigned n) {
149
 
        DBusMessage *reply = NULL;
 
140
        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
150
141
        int r;
151
142
        DBusMessageIter iter, sub, sub2;
152
143
        unsigned k = 0;
163
154
                        NULL,
164
155
                        DBUS_TYPE_INVALID);
165
156
        if (r)
166
 
              goto finish;
 
157
                return r;
167
158
 
168
159
        if (!dbus_message_iter_init(reply, &iter) ||
169
160
            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
170
161
            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
171
162
                log_error("Failed to parse reply.");
172
 
                r = -EIO;
173
 
                goto finish;
 
163
                return -EIO;
174
164
        }
175
165
 
176
166
        dbus_message_iter_recurse(&iter, &sub);
184
174
 
185
175
                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
186
176
                        log_error("Failed to parse reply.");
187
 
                        r = -EIO;
188
 
                        goto finish;
 
177
                        return -EIO;
189
178
                }
190
179
 
191
180
                dbus_message_iter_recurse(&sub, &sub2);
194
183
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &user, true) < 0 ||
195
184
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
196
185
                        log_error("Failed to parse reply.");
197
 
                        r = -EIO;
198
 
                        goto finish;
 
186
                        return -EIO;
199
187
                }
200
188
 
201
189
                printf("%10u %-16s\n", (unsigned) uid, user);
208
196
        if (on_tty())
209
197
                printf("\n%u users listed.\n", k);
210
198
 
211
 
        r = 0;
212
 
 
213
 
finish:
214
 
        if (reply)
215
 
                dbus_message_unref(reply);
216
 
 
217
 
        return r;
 
199
        return 0;
218
200
}
219
201
 
220
202
static int list_seats(DBusConnection *bus, char **args, unsigned n) {
221
 
        DBusMessage *reply = NULL;
 
203
        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
222
204
        int r;
223
205
        DBusMessageIter iter, sub, sub2;
224
206
        unsigned k = 0;
235
217
                        NULL,
236
218
                        DBUS_TYPE_INVALID);
237
219
        if (r)
238
 
                goto finish;
 
220
                return r;
239
221
 
240
222
        if (!dbus_message_iter_init(reply, &iter) ||
241
223
            dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
242
224
            dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
243
225
                log_error("Failed to parse reply.");
244
 
                r = -EIO;
245
 
                goto finish;
 
226
                return -EIO;
246
227
        }
247
228
 
248
229
        dbus_message_iter_recurse(&iter, &sub);
255
236
 
256
237
                if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
257
238
                        log_error("Failed to parse reply.");
258
 
                        r = -EIO;
259
 
                        goto finish;
 
239
                        return -EIO;
260
240
                }
261
241
 
262
242
                dbus_message_iter_recurse(&sub, &sub2);
264
244
                if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 ||
265
245
                    bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
266
246
                        log_error("Failed to parse reply.");
267
 
                        r = -EIO;
268
 
                        goto finish;
 
247
                        return -EIO;
269
248
                }
270
249
 
271
250
                printf("%-16s\n", seat);
278
257
        if (on_tty())
279
258
                printf("\n%u seats listed.\n", k);
280
259
 
281
 
        r = 0;
282
 
 
283
 
finish:
284
 
        if (reply)
285
 
                dbus_message_unref(reply);
286
 
 
287
 
        return r;
 
260
        return 0;
288
261
}
289
262
 
290
263
typedef struct SessionStatusInfo {
861
834
        const char *interface = "";
862
835
        int r;
863
836
        DBusMessageIter iter, sub, sub2, sub3;
864
 
        SessionStatusInfo session_info;
865
 
        UserStatusInfo user_info;
866
 
        SeatStatusInfo seat_info;
 
837
        SessionStatusInfo session_info = {};
 
838
        UserStatusInfo user_info = {};
 
839
        SeatStatusInfo seat_info = {};
867
840
 
868
841
        assert(path);
869
842
        assert(new_line);
870
843
 
871
 
        zero(session_info);
872
 
        zero(user_info);
873
 
        zero(seat_info);
874
 
 
875
844
        r = bus_method_call_with_reply(
876
845
                        bus,
877
846
                        "org.freedesktop.login1",
961
930
}
962
931
 
963
932
static int show(DBusConnection *bus, char **args, unsigned n) {
964
 
        DBusMessage *reply = NULL;
 
933
        _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
965
934
        int r, ret = 0;
966
935
        DBusError error;
967
936
        unsigned i;
1048
1017
                r = show_one(args[0], bus, path, show_properties, &new_line);
1049
1018
                if (r != 0)
1050
1019
                        ret = r;
1051
 
 
1052
 
                dbus_message_unref(reply);
1053
 
                reply = NULL;
1054
1020
        }
1055
1021
 
1056
1022
finish:
1057
 
        if (reply)
1058
 
                dbus_message_unref(reply);
1059
 
 
1060
1023
        dbus_error_free(&error);
1061
1024
 
1062
1025
        return ret;
1092
1055
}
1093
1056
 
1094
1057
static int kill_session(DBusConnection *bus, char **args, unsigned n) {
1095
 
        int ret = 0;
1096
1058
        unsigned i;
1097
1059
 
1098
1060
        assert(args);
1101
1063
                arg_kill_who = "all";
1102
1064
 
1103
1065
        for (i = 1; i < n; i++) {
1104
 
                ret = bus_method_call_with_reply (
1105
 
                                bus,
1106
 
                                "org.freedesktop.login1",
1107
 
                                "/org/freedesktop/login1",
1108
 
                                "org.freedesktop.login1.Manager",
1109
 
                                "KillSession",
1110
 
                                NULL,
1111
 
                                NULL,
1112
 
                                DBUS_TYPE_STRING, &args[i],
1113
 
                                DBUS_TYPE_STRING, &arg_kill_who,
1114
 
                                DBUS_TYPE_INT32, &arg_signal,
1115
 
                                DBUS_TYPE_INVALID);
1116
 
                if (ret)
1117
 
                        goto finish;
 
1066
                int r;
 
1067
 
 
1068
                r = bus_method_call_with_reply (
 
1069
                        bus,
 
1070
                        "org.freedesktop.login1",
 
1071
                        "/org/freedesktop/login1",
 
1072
                        "org.freedesktop.login1.Manager",
 
1073
                        "KillSession",
 
1074
                        NULL,
 
1075
                        NULL,
 
1076
                        DBUS_TYPE_STRING, &args[i],
 
1077
                        DBUS_TYPE_STRING, &arg_kill_who,
 
1078
                        DBUS_TYPE_INT32, &arg_signal,
 
1079
                        DBUS_TYPE_INVALID);
 
1080
                if (r)
 
1081
                        return r;
1118
1082
        }
1119
1083
 
1120
 
finish:
1121
 
        return ret;
 
1084
        return 0;
1122
1085
}
1123
1086
 
1124
1087
static int enable_linger(DBusConnection *bus, char **args, unsigned n) {
1125
 
        int ret = 0;
1126
1088
        unsigned i;
1127
1089
        dbus_bool_t b, interactive = true;
1128
1090
 
1135
1097
        for (i = 1; i < n; i++) {
1136
1098
                uint32_t u;
1137
1099
                uid_t uid;
 
1100
                int r;
1138
1101
 
1139
 
                ret = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
1140
 
                if (ret < 0) {
1141
 
                        log_error("Failed to resolve user %s: %s", args[i], strerror(-ret));
1142
 
                        goto finish;
 
1102
                r = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
 
1103
                if (r < 0) {
 
1104
                        log_error("Failed to resolve user %s: %s", args[i], strerror(-r));
 
1105
                        return r;
1143
1106
                }
1144
1107
 
1145
1108
                u = (uint32_t) uid;
1146
 
                ret = bus_method_call_with_reply (
1147
 
                                bus,
1148
 
                                "org.freedesktop.login1",
1149
 
                                "/org/freedesktop/login1",
1150
 
                                "org.freedesktop.login1.Manager",
1151
 
                                "SetUserLinger",
1152
 
                                NULL,
1153
 
                                NULL,
1154
 
                                DBUS_TYPE_UINT32, &u,
1155
 
                                DBUS_TYPE_BOOLEAN, &b,
1156
 
                                DBUS_TYPE_BOOLEAN, &interactive,
1157
 
                                DBUS_TYPE_INVALID);
1158
 
                if (ret)
1159
 
                        goto finish;
 
1109
                r = bus_method_call_with_reply (
 
1110
                        bus,
 
1111
                        "org.freedesktop.login1",
 
1112
                        "/org/freedesktop/login1",
 
1113
                        "org.freedesktop.login1.Manager",
 
1114
                        "SetUserLinger",
 
1115
                        NULL,
 
1116
                        NULL,
 
1117
                        DBUS_TYPE_UINT32, &u,
 
1118
                        DBUS_TYPE_BOOLEAN, &b,
 
1119
                        DBUS_TYPE_BOOLEAN, &interactive,
 
1120
                        DBUS_TYPE_INVALID);
 
1121
                if (r)
 
1122
                        return r;
1160
1123
        }
1161
1124
 
1162
 
finish:
1163
 
        return ret;
 
1125
        return 0;
1164
1126
}
1165
1127
 
1166
1128
static int terminate_user(DBusConnection *bus, char **args, unsigned n) {
1167
 
        int ret = 0;
1168
1129
        unsigned i;
1169
1130
 
1170
1131
        assert(args);
1172
1133
        for (i = 1; i < n; i++) {
1173
1134
                uint32_t u;
1174
1135
                uid_t uid;
 
1136
                int r;
1175
1137
 
1176
 
                ret = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
1177
 
                if (ret < 0) {
1178
 
                        log_error("Failed to look up user %s: %s", args[i], strerror(-ret));
1179
 
                        goto finish;
 
1138
                r = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
 
1139
                if (r < 0) {
 
1140
                        log_error("Failed to look up user %s: %s", args[i], strerror(-r));
 
1141
                        return r;
1180
1142
                }
1181
1143
 
1182
1144
                u = (uint32_t) uid;
1183
 
                ret = bus_method_call_with_reply (
1184
 
                                bus,
1185
 
                                "org.freedesktop.login1",
1186
 
                                "/org/freedesktop/login1",
1187
 
                                "org.freedesktop.login1.Manager",
1188
 
                                "TerminateUser",
1189
 
                                NULL,
1190
 
                                NULL,
1191
 
                                DBUS_TYPE_UINT32, &u,
1192
 
                                DBUS_TYPE_INVALID);
1193
 
                if (ret)
1194
 
                        goto finish;
 
1145
                r = bus_method_call_with_reply (
 
1146
                        bus,
 
1147
                        "org.freedesktop.login1",
 
1148
                        "/org/freedesktop/login1",
 
1149
                        "org.freedesktop.login1.Manager",
 
1150
                        "TerminateUser",
 
1151
                        NULL,
 
1152
                        NULL,
 
1153
                        DBUS_TYPE_UINT32, &u,
 
1154
                        DBUS_TYPE_INVALID);
 
1155
                if (r)
 
1156
                        return r;
1195
1157
        }
1196
1158
 
1197
 
finish:
1198
 
        return ret;
 
1159
        return 0;
1199
1160
}
1200
1161
 
1201
1162
static int kill_user(DBusConnection *bus, char **args, unsigned n) {
1202
 
        int ret = 0;
1203
1163
        unsigned i;
1204
1164
 
1205
1165
        assert(args);
1210
1170
        for (i = 1; i < n; i++) {
1211
1171
                uid_t uid;
1212
1172
                uint32_t u;
 
1173
                int r;
1213
1174
 
1214
 
                ret = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
1215
 
                if (ret < 0) {
1216
 
                        log_error("Failed to look up user %s: %s", args[i], strerror(-ret));
1217
 
                        goto finish;
 
1175
                r = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
 
1176
                if (r < 0) {
 
1177
                        log_error("Failed to look up user %s: %s", args[i], strerror(-r));
 
1178
                        return r;
1218
1179
                }
1219
1180
 
1220
1181
                u = (uint32_t) uid;
1221
 
                ret = bus_method_call_with_reply (
1222
 
                                bus,
1223
 
                                "org.freedesktop.login1",
1224
 
                                "/org/freedesktop/login1",
1225
 
                                "org.freedesktop.login1.Manager",
1226
 
                                "KillUser",
1227
 
                                NULL,
1228
 
                                NULL,
1229
 
                                DBUS_TYPE_UINT32, &u,
1230
 
                                DBUS_TYPE_INT32, &arg_signal,
1231
 
                                DBUS_TYPE_INVALID);
1232
 
                if (ret)
1233
 
                        goto finish;
 
1182
                r = bus_method_call_with_reply (
 
1183
                        bus,
 
1184
                        "org.freedesktop.login1",
 
1185
                        "/org/freedesktop/login1",
 
1186
                        "org.freedesktop.login1.Manager",
 
1187
                        "KillUser",
 
1188
                        NULL,
 
1189
                        NULL,
 
1190
                        DBUS_TYPE_UINT32, &u,
 
1191
                        DBUS_TYPE_INT32, &arg_signal,
 
1192
                        DBUS_TYPE_INVALID);
 
1193
                if (r)
 
1194
                        return r;
1234
1195
        }
1235
1196
 
1236
 
finish:
1237
 
        return ret;
 
1197
        return 0;
1238
1198
}
1239
1199
 
1240
1200
static int attach(DBusConnection *bus, char **args, unsigned n) {
1241
 
        int ret = 0;
1242
1201
        unsigned i;
1243
1202
        dbus_bool_t interactive = true;
1244
1203
 
1247
1206
        polkit_agent_open_if_enabled();
1248
1207
 
1249
1208
        for (i = 2; i < n; i++) {
1250
 
                ret = bus_method_call_with_reply (
1251
 
                                bus,
1252
 
                                "org.freedesktop.login1",
1253
 
                                "/org/freedesktop/login1",
1254
 
                                "org.freedesktop.login1.Manager",
1255
 
                                "AttachDevice",
1256
 
                                NULL,
1257
 
                                NULL,
1258
 
                                DBUS_TYPE_STRING, &args[1],
1259
 
                                DBUS_TYPE_STRING, &args[i],
1260
 
                                DBUS_TYPE_BOOLEAN, &interactive,
1261
 
                                DBUS_TYPE_INVALID);
1262
 
                if (ret)
1263
 
                        goto finish;
 
1209
                int r;
 
1210
 
 
1211
                r = bus_method_call_with_reply (
 
1212
                        bus,
 
1213
                        "org.freedesktop.login1",
 
1214
                        "/org/freedesktop/login1",
 
1215
                        "org.freedesktop.login1.Manager",
 
1216
                        "AttachDevice",
 
1217
                        NULL,
 
1218
                        NULL,
 
1219
                        DBUS_TYPE_STRING, &args[1],
 
1220
                        DBUS_TYPE_STRING, &args[i],
 
1221
                        DBUS_TYPE_BOOLEAN, &interactive,
 
1222
                        DBUS_TYPE_INVALID);
 
1223
                if (r)
 
1224
                        return r;
1264
1225
        }
1265
1226
 
1266
 
finish:
1267
 
        return ret;
 
1227
        return 0;
1268
1228
}
1269
1229
 
1270
1230
static int flush_devices(DBusConnection *bus, char **args, unsigned n) {
1303
1263
}
1304
1264
 
1305
1265
static int terminate_seat(DBusConnection *bus, char **args, unsigned n) {
1306
 
        int ret = 0;
1307
1266
        unsigned i;
1308
1267
 
1309
1268
        assert(args);
1310
1269
 
1311
1270
        for (i = 1; i < n; i++) {
1312
 
                ret = bus_method_call_with_reply (
1313
 
                                bus,
1314
 
                                "org.freedesktop.login1",
1315
 
                                "/org/freedesktop/login1",
1316
 
                                "org.freedesktop.login1.Manager",
1317
 
                                "TerminateSeat",
1318
 
                                NULL,
1319
 
                                NULL,
1320
 
                                DBUS_TYPE_STRING, &args[i],
1321
 
                                DBUS_TYPE_INVALID);
1322
 
                if (ret)
1323
 
                        goto finish;
 
1271
                int r;
 
1272
 
 
1273
                r = bus_method_call_with_reply (
 
1274
                        bus,
 
1275
                        "org.freedesktop.login1",
 
1276
                        "/org/freedesktop/login1",
 
1277
                        "org.freedesktop.login1.Manager",
 
1278
                        "TerminateSeat",
 
1279
                        NULL,
 
1280
                        NULL,
 
1281
                        DBUS_TYPE_STRING, &args[i],
 
1282
                        DBUS_TYPE_INVALID);
 
1283
                if (r)
 
1284
                        return r;
1324
1285
        }
1325
1286
 
1326
 
finish:
1327
 
        return ret;
 
1287
        return 0;
1328
1288
}
1329
1289
 
1330
1290
static int help(void) {