Branch data Line data Source code
1 : : /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
2 : : *
3 : : * Copyright © 2019 Endless Mobile, Inc.
4 : : *
5 : : * SPDX-License-Identifier: LGPL-2.1-or-later
6 : : *
7 : : * This library is free software; you can redistribute it and/or
8 : : * modify it under the terms of the GNU Lesser General Public
9 : : * License as published by the Free Software Foundation; either
10 : : * version 2.1 of the License, or (at your option) any later version.
11 : : *
12 : : * This library is distributed in the hope that it will be useful,
13 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : : * Lesser General Public License for more details.
16 : : *
17 : : * You should have received a copy of the GNU Lesser General Public
18 : : * License along with this library; if not, write to the Free Software
19 : : * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 : : *
21 : : * Authors:
22 : : * - Philip Withnall <withnall@endlessm.com>
23 : : */
24 : :
25 : : #include "config.h"
26 : :
27 : : #include <glib.h>
28 : : #include <glib-object.h>
29 : : #include <glib/gi18n-lib.h>
30 : : #include <gio/gio.h>
31 : : #include <libmalcontent/app-filter.h>
32 : : #include <libmalcontent/manager.h>
33 : : #include <libmalcontent/session-limits.h>
34 : :
35 : : #include "libmalcontent/app-filter-private.h"
36 : : #include "libmalcontent/session-limits-private.h"
37 : :
38 : :
39 [ + + ]: 60 : G_DEFINE_QUARK (MctManagerError, mct_manager_error)
40 : :
41 : : /**
42 : : * MctManager:
43 : : *
44 : : * #MctManager is a top-level management object which is used to query and
45 : : * monitor #MctAppFilters for different users.
46 : : *
47 : : * Since: 0.3.0
48 : : */
49 : : struct _MctManager
50 : : {
51 : : GObject parent_instance;
52 : :
53 : : GDBusConnection *connection; /* (owned) */
54 : : guint user_changed_id;
55 : : };
56 : :
57 [ + + + - : 233 : G_DEFINE_TYPE (MctManager, mct_manager, G_TYPE_OBJECT)
+ + ]
58 : :
59 : : typedef enum
60 : : {
61 : : PROP_CONNECTION = 1,
62 : : } MctManagerProperty;
63 : :
64 : : static GParamSpec *props[PROP_CONNECTION + 1] = { NULL, };
65 : :
66 : : static void
67 : 35 : mct_manager_init (MctManager *self)
68 : : {
69 : : /* Nothing to do here. */
70 : 35 : }
71 : :
72 : : static void
73 : 0 : mct_manager_get_property (GObject *object,
74 : : guint property_id,
75 : : GValue *value,
76 : : GParamSpec *spec)
77 : : {
78 : 0 : MctManager *self = MCT_MANAGER (object);
79 : :
80 [ # # ]: 0 : switch ((MctManagerProperty) property_id)
81 : : {
82 : 0 : case PROP_CONNECTION:
83 : 0 : g_value_set_object (value, self->connection);
84 : 0 : break;
85 : :
86 : 0 : default:
87 : 0 : G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, spec);
88 : 0 : break;
89 : : }
90 : 0 : }
91 : :
92 : : static void
93 : 35 : mct_manager_set_property (GObject *object,
94 : : guint property_id,
95 : : const GValue *value,
96 : : GParamSpec *spec)
97 : : {
98 : 35 : MctManager *self = MCT_MANAGER (object);
99 : :
100 [ + - ]: 35 : switch ((MctManagerProperty) property_id)
101 : : {
102 : 35 : case PROP_CONNECTION:
103 : : /* Construct-only. May not be %NULL. */
104 : 35 : g_assert (self->connection == NULL);
105 : 35 : self->connection = g_value_dup_object (value);
106 : 35 : g_assert (self->connection != NULL);
107 : 35 : break;
108 : :
109 : 0 : default:
110 : 0 : G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, spec);
111 : 0 : break;
112 : : }
113 : 35 : }
114 : :
115 : : static void _mct_manager_user_changed_cb (GDBusConnection *connection,
116 : : const gchar *sender_name,
117 : : const gchar *object_path,
118 : : const gchar *interface_name,
119 : : const gchar *signal_name,
120 : : GVariant *parameters,
121 : : gpointer user_data);
122 : :
123 : : static void
124 : 35 : mct_manager_constructed (GObject *object)
125 : : {
126 : 35 : MctManager *self = MCT_MANAGER (object);
127 : :
128 : : /* Chain up. */
129 : 35 : G_OBJECT_CLASS (mct_manager_parent_class)->constructed (object);
130 : :
131 : : /* Connect to notifications from AccountsService. */
132 : 35 : g_assert (self->connection != NULL);
133 : 35 : self->user_changed_id =
134 : 35 : g_dbus_connection_signal_subscribe (self->connection,
135 : : "org.freedesktop.Accounts", /* sender */
136 : : "org.freedesktop.Accounts.User", /* interface name */
137 : : "Changed", /* signal name */
138 : : NULL, /* object path */
139 : : NULL, /* arg0 */
140 : : G_DBUS_SIGNAL_FLAGS_NONE,
141 : : _mct_manager_user_changed_cb,
142 : : self, NULL);
143 : 35 : }
144 : :
145 : : static void
146 : 34 : mct_manager_dispose (GObject *object)
147 : : {
148 : 34 : MctManager *self = MCT_MANAGER (object);
149 : :
150 [ + - + - ]: 34 : if (self->user_changed_id != 0 && self->connection != NULL)
151 : : {
152 : 34 : g_dbus_connection_signal_unsubscribe (self->connection,
153 : : self->user_changed_id);
154 : 34 : self->user_changed_id = 0;
155 : : }
156 [ + - ]: 34 : g_clear_object (&self->connection);
157 : :
158 : 34 : G_OBJECT_CLASS (mct_manager_parent_class)->dispose (object);
159 : 34 : }
160 : :
161 : : static void
162 : 4 : mct_manager_class_init (MctManagerClass *klass)
163 : : {
164 : 4 : GObjectClass *object_class = G_OBJECT_CLASS (klass);
165 : :
166 : 4 : object_class->constructed = mct_manager_constructed;
167 : 4 : object_class->dispose = mct_manager_dispose;
168 : 4 : object_class->get_property = mct_manager_get_property;
169 : 4 : object_class->set_property = mct_manager_set_property;
170 : :
171 : : /**
172 : : * MctManager:connection: (not nullable)
173 : : *
174 : : * A connection to the system bus, where accounts-service runs. It’s provided
175 : : * mostly for testing purposes, or to allow an existing connection to be
176 : : * re-used.
177 : : *
178 : : * Since: 0.3.0
179 : : */
180 : 4 : props[PROP_CONNECTION] = g_param_spec_object ("connection",
181 : : "D-Bus Connection",
182 : : "A connection to the system bus.",
183 : : G_TYPE_DBUS_CONNECTION,
184 : : G_PARAM_READWRITE |
185 : : G_PARAM_CONSTRUCT_ONLY |
186 : : G_PARAM_STATIC_STRINGS);
187 : :
188 : 4 : g_object_class_install_properties (object_class,
189 : : G_N_ELEMENTS (props),
190 : : props);
191 : :
192 : : /**
193 : : * MctManager::app-filter-changed:
194 : : * @self: a #MctManager
195 : : * @user_id: UID of the user whose app filter has changed
196 : : *
197 : : * Emitted when the app filter stored for a user changes.
198 : : * The new app filter for the user should be requested again from
199 : : * the #MctManager instance.
200 : : *
201 : : * Since: 0.3.0
202 : : */
203 : 4 : g_signal_new ("app-filter-changed", G_TYPE_FROM_CLASS (klass),
204 : : G_SIGNAL_RUN_LAST,
205 : : 0, NULL, NULL, NULL,
206 : : G_TYPE_NONE, 1,
207 : : G_TYPE_UINT64);
208 : 4 : }
209 : :
210 : : /**
211 : : * mct_manager_new:
212 : : * @connection: (transfer none): a #GDBusConnection to use
213 : : *
214 : : * Create a new #MctManager.
215 : : *
216 : : * Returns: (transfer full): a new #MctManager
217 : : * Since: 0.3.0
218 : : */
219 : : MctManager *
220 : 35 : mct_manager_new (GDBusConnection *connection)
221 : : {
222 : 35 : g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL);
223 : :
224 : 35 : return g_object_new (MCT_TYPE_MANAGER,
225 : : "connection", connection,
226 : : NULL);
227 : : }
228 : :
229 : : static void
230 : 0 : _mct_manager_user_changed_cb (GDBusConnection *connection,
231 : : const gchar *sender_name,
232 : : const gchar *object_path,
233 : : const gchar *interface_name,
234 : : const gchar *signal_name,
235 : : GVariant *parameters,
236 : : gpointer user_data)
237 : : {
238 : 0 : MctManager *manager = MCT_MANAGER (user_data);
239 [ # # ]: 0 : g_autoptr(GError) local_error = NULL;
240 : : const gchar *uid_str;
241 : : guint64 uid;
242 : :
243 : 0 : g_assert (g_str_equal (interface_name, "org.freedesktop.Accounts.User"));
244 : 0 : g_assert (g_str_equal (signal_name, "Changed"));
245 : :
246 : : /* Extract the UID from the object path. This is a bit hacky, but probably
247 : : * better than depending on libaccountsservice just for this. */
248 [ # # # # : 0 : if (!g_str_has_prefix (object_path, "/org/freedesktop/Accounts/User"))
# # # # ]
249 : 0 : return;
250 : :
251 : 0 : uid_str = object_path + strlen ("/org/freedesktop/Accounts/User");
252 [ # # ]: 0 : if (!g_ascii_string_to_unsigned (uid_str, 10, 0, G_MAXUINT64, &uid, &local_error))
253 : : {
254 : 0 : g_warning ("Error converting object path ‘%s’ to user ID: %s",
255 : : object_path, local_error->message);
256 : 0 : g_clear_error (&local_error);
257 : : }
258 : :
259 : 0 : g_signal_emit_by_name (manager, "app-filter-changed", uid);
260 : : }
261 : :
262 : : /* Check if @error is a D-Bus remote error matching @expected_error_name. */
263 : : static gboolean
264 : 32 : bus_remote_error_matches (const GError *error,
265 : : const gchar *expected_error_name)
266 : : {
267 : 32 : g_autofree gchar *error_name = NULL;
268 : :
269 [ - + ]: 32 : if (!g_dbus_error_is_remote_error (error))
270 : 0 : return FALSE;
271 : :
272 : 32 : error_name = g_dbus_error_get_remote_error (error);
273 : :
274 : 32 : return g_str_equal (error_name, expected_error_name);
275 : : }
276 : :
277 : : /* Convert a #GDBusError into a #MctManagerError. */
278 : : static GError *
279 : 18 : bus_error_to_manager_error (const GError *bus_error,
280 : : uid_t user_id)
281 : : {
282 [ + - + + ]: 36 : if (g_error_matches (bus_error, G_DBUS_ERROR, G_DBUS_ERROR_ACCESS_DENIED) ||
283 : 18 : bus_remote_error_matches (bus_error, "org.freedesktop.Accounts.Error.PermissionDenied"))
284 : 4 : return g_error_new (MCT_MANAGER_ERROR, MCT_MANAGER_ERROR_PERMISSION_DENIED,
285 : : _("Not allowed to query parental controls data for user %u"),
286 : : (guint) user_id);
287 [ + - + + ]: 28 : else if (g_error_matches (bus_error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD) ||
288 : 14 : bus_remote_error_matches (bus_error, "org.freedesktop.Accounts.Error.Failed"))
289 : 4 : return g_error_new (MCT_MANAGER_ERROR, MCT_MANAGER_ERROR_INVALID_USER,
290 : : _("User %u does not exist"), (guint) user_id);
291 [ + - - + ]: 20 : else if (g_error_matches (bus_error, G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN) ||
292 : 10 : g_error_matches (bus_error, G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER))
293 : : /* If accountsservice is not available on the system bus, then the
294 : : * com.endlessm.ParentalControls.AppFilter extension interface
295 : : * certainly can't be available. */
296 : 0 : return g_error_new_literal (MCT_MANAGER_ERROR,
297 : : MCT_MANAGER_ERROR_DISABLED,
298 : : _("System accounts service not available"));
299 : : else
300 : 10 : return g_error_copy (bus_error);
301 : : }
302 : :
303 : : /* Find the object path for the given @user_id on the accountsservice D-Bus
304 : : * interface, by calling its FindUserById() method. This is a synchronous,
305 : : * blocking function. */
306 : : static gchar *
307 : 34 : accounts_find_user_by_id (GDBusConnection *connection,
308 : : uid_t user_id,
309 : : gboolean allow_interactive_authorization,
310 : : GCancellable *cancellable,
311 : : GError **error)
312 : : {
313 : 34 : g_autofree gchar *object_path = NULL;
314 : 34 : g_autoptr(GVariant) result_variant = NULL;
315 : 34 : g_autoptr(GError) local_error = NULL;
316 : :
317 : 34 : result_variant =
318 [ - + ]: 34 : g_dbus_connection_call_sync (connection,
319 : : "org.freedesktop.Accounts",
320 : : "/org/freedesktop/Accounts",
321 : : "org.freedesktop.Accounts",
322 : : "FindUserById",
323 : : g_variant_new ("(x)", (gint64) user_id),
324 : : G_VARIANT_TYPE ("(o)"),
325 : : allow_interactive_authorization
326 : : ? G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION
327 : : : G_DBUS_CALL_FLAGS_NONE,
328 : : -1, /* timeout, ms */
329 : : cancellable,
330 : : &local_error);
331 [ + + ]: 34 : if (local_error != NULL)
332 : : {
333 : 6 : g_autoptr(GError) app_filter_error = bus_error_to_manager_error (local_error,
334 : : user_id);
335 : 6 : g_propagate_error (error, g_steal_pointer (&app_filter_error));
336 : 6 : return NULL;
337 : : }
338 : :
339 : 28 : g_variant_get (result_variant, "(o)", &object_path);
340 : :
341 : 28 : return g_steal_pointer (&object_path);
342 : : }
343 : :
344 : : /**
345 : : * mct_manager_get_app_filter:
346 : : * @self: a #MctManager
347 : : * @user_id: ID of the user to query, typically coming from getuid()
348 : : * @flags: flags to affect the behaviour of the call
349 : : * @cancellable: (nullable): a #GCancellable, or %NULL
350 : : * @error: return location for a #GError, or %NULL
351 : : *
352 : : * Synchronous version of mct_manager_get_app_filter_async().
353 : : *
354 : : * Returns: (transfer full): app filter for the queried user
355 : : * Since: 0.3.0
356 : : */
357 : : MctAppFilter *
358 : 10 : mct_manager_get_app_filter (MctManager *self,
359 : : uid_t user_id,
360 : : MctManagerGetValueFlags flags,
361 : : GCancellable *cancellable,
362 : : GError **error)
363 : : {
364 : 10 : g_autofree gchar *object_path = NULL;
365 : 10 : g_autoptr(GVariant) result_variant = NULL;
366 : 10 : g_autoptr(GVariant) properties = NULL;
367 : 10 : g_autoptr(GError) local_error = NULL;
368 : :
369 : 10 : g_return_val_if_fail (MCT_IS_MANAGER (self), NULL);
370 : 10 : g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
371 : 10 : g_return_val_if_fail (error == NULL || *error == NULL, NULL);
372 : :
373 : 20 : object_path = accounts_find_user_by_id (self->connection, user_id,
374 : 10 : (flags & MCT_MANAGER_GET_VALUE_FLAGS_INTERACTIVE),
375 : : cancellable, error);
376 [ + + ]: 10 : if (object_path == NULL)
377 : 2 : return NULL;
378 : :
379 : 8 : result_variant =
380 : 8 : g_dbus_connection_call_sync (self->connection,
381 : : "org.freedesktop.Accounts",
382 : : object_path,
383 : : "org.freedesktop.DBus.Properties",
384 : : "GetAll",
385 : : g_variant_new ("(s)", "com.endlessm.ParentalControls.AppFilter"),
386 : : G_VARIANT_TYPE ("(a{sv})"),
387 : : (flags & MCT_MANAGER_GET_VALUE_FLAGS_INTERACTIVE)
388 : : ? G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION
389 : 8 : : G_DBUS_CALL_FLAGS_NONE,
390 : : -1, /* timeout, ms */
391 : : cancellable,
392 : : &local_error);
393 [ + + ]: 8 : if (local_error != NULL)
394 : : {
395 : 4 : g_autoptr(GError) manager_error = NULL;
396 : :
397 [ + + ]: 2 : if (g_error_matches (local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS))
398 : : {
399 : : /* o.fd.D.GetAll() will return InvalidArgs errors if
400 : : * accountsservice doesn’t have the com.endlessm.ParentalControls.AppFilter
401 : : * extension interface installed. */
402 : 1 : manager_error = g_error_new_literal (MCT_MANAGER_ERROR,
403 : : MCT_MANAGER_ERROR_DISABLED,
404 : : _("App filtering is globally disabled"));
405 : : }
406 : : else
407 : : {
408 : 1 : manager_error = bus_error_to_manager_error (local_error, user_id);
409 : : }
410 : :
411 : 2 : g_propagate_error (error, g_steal_pointer (&manager_error));
412 : 2 : return NULL;
413 : : }
414 : :
415 : : /* Extract the properties we care about. They may be silently omitted from the
416 : : * results if we don’t have permission to access them. */
417 : 6 : properties = g_variant_get_child_value (result_variant, 0);
418 [ + + ]: 6 : if (!g_variant_lookup (properties, "AppFilter", "(b^as)", NULL, NULL))
419 : : {
420 : 1 : g_set_error (error, MCT_MANAGER_ERROR,
421 : : MCT_MANAGER_ERROR_PERMISSION_DENIED,
422 : : _("Not allowed to query parental controls data for user %u"),
423 : : (guint) user_id);
424 : 1 : return NULL;
425 : : }
426 : :
427 : 5 : return mct_app_filter_deserialize (properties, user_id, error);
428 : : }
429 : :
430 : : static void get_app_filter_thread_cb (GTask *task,
431 : : gpointer source_object,
432 : : gpointer task_data,
433 : : GCancellable *cancellable);
434 : :
435 : : typedef struct
436 : : {
437 : : uid_t user_id;
438 : : MctManagerGetValueFlags flags;
439 : : } GetAppFilterData;
440 : :
441 : : static void
442 : 6 : get_app_filter_data_free (GetAppFilterData *data)
443 : : {
444 : 6 : g_free (data);
445 : 6 : }
446 : :
447 [ - + ]: 12 : G_DEFINE_AUTOPTR_CLEANUP_FUNC (GetAppFilterData, get_app_filter_data_free)
448 : :
449 : : /**
450 : : * mct_manager_get_app_filter_async:
451 : : * @self: a #MctManager
452 : : * @user_id: ID of the user to query, typically coming from getuid()
453 : : * @flags: flags to affect the behaviour of the call
454 : : * @cancellable: (nullable): a #GCancellable, or %NULL
455 : : * @callback: a #GAsyncReadyCallback
456 : : * @user_data: user data to pass to @callback
457 : : *
458 : : * Asynchronously get a snapshot of the app filter settings for the given
459 : : * @user_id.
460 : : *
461 : : * On failure, an #MctManagerError, a #GDBusError or a #GIOError will be
462 : : * returned.
463 : : *
464 : : * Since: 0.3.0
465 : : */
466 : : void
467 : 6 : mct_manager_get_app_filter_async (MctManager *self,
468 : : uid_t user_id,
469 : : MctManagerGetValueFlags flags,
470 : : GCancellable *cancellable,
471 : : GAsyncReadyCallback callback,
472 : : gpointer user_data)
473 : : {
474 [ + - ]: 6 : g_autoptr(GTask) task = NULL;
475 [ + - ]: 6 : g_autoptr(GetAppFilterData) data = NULL;
476 : :
477 : 6 : g_return_if_fail (MCT_IS_MANAGER (self));
478 : 6 : g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
479 : :
480 : 6 : task = g_task_new (self, cancellable, callback, user_data);
481 [ + - ]: 6 : g_task_set_source_tag (task, mct_manager_get_app_filter_async);
482 : :
483 : 6 : data = g_new0 (GetAppFilterData, 1);
484 : 6 : data->user_id = user_id;
485 : 6 : data->flags = flags;
486 : 6 : g_task_set_task_data (task, g_steal_pointer (&data),
487 : : (GDestroyNotify) get_app_filter_data_free);
488 : :
489 : 6 : g_task_run_in_thread (task, get_app_filter_thread_cb);
490 : : }
491 : :
492 : : static void
493 : 6 : get_app_filter_thread_cb (GTask *task,
494 : : gpointer source_object,
495 : : gpointer task_data,
496 : : GCancellable *cancellable)
497 : : {
498 : 6 : g_autoptr(MctAppFilter) filter = NULL;
499 : 6 : MctManager *manager = MCT_MANAGER (source_object);
500 : 6 : GetAppFilterData *data = task_data;
501 : 6 : g_autoptr(GError) local_error = NULL;
502 : :
503 : 6 : filter = mct_manager_get_app_filter (manager, data->user_id,
504 : : data->flags,
505 : : cancellable, &local_error);
506 : :
507 [ + + ]: 6 : if (local_error != NULL)
508 : 5 : g_task_return_error (task, g_steal_pointer (&local_error));
509 : : else
510 : 1 : g_task_return_pointer (task, g_steal_pointer (&filter),
511 : : (GDestroyNotify) mct_app_filter_unref);
512 : 6 : }
513 : :
514 : : /**
515 : : * mct_manager_get_app_filter_finish:
516 : : * @self: a #MctManager
517 : : * @result: a #GAsyncResult
518 : : * @error: return location for a #GError, or %NULL
519 : : *
520 : : * Finish an asynchronous operation to get the app filter for a user, started
521 : : * with mct_manager_get_app_filter_async().
522 : : *
523 : : * Returns: (transfer full): app filter for the queried user
524 : : * Since: 0.3.0
525 : : */
526 : : MctAppFilter *
527 : 6 : mct_manager_get_app_filter_finish (MctManager *self,
528 : : GAsyncResult *result,
529 : : GError **error)
530 : : {
531 : 6 : g_return_val_if_fail (MCT_IS_MANAGER (self), NULL);
532 : 6 : g_return_val_if_fail (g_task_is_valid (result, self), NULL);
533 : 6 : g_return_val_if_fail (error == NULL || *error == NULL, NULL);
534 : :
535 : 6 : return g_task_propagate_pointer (G_TASK (result), error);
536 : : }
537 : :
538 : : /**
539 : : * mct_manager_set_app_filter:
540 : : * @self: a #MctManager
541 : : * @user_id: ID of the user to set the filter for, typically coming from getuid()
542 : : * @app_filter: (transfer none): the app filter to set for the user
543 : : * @flags: flags to affect the behaviour of the call
544 : : * @cancellable: (nullable): a #GCancellable, or %NULL
545 : : * @error: return location for a #GError, or %NULL
546 : : *
547 : : * Synchronous version of mct_manager_set_app_filter_async().
548 : : *
549 : : * Returns: %TRUE on success, %FALSE otherwise
550 : : * Since: 0.3.0
551 : : */
552 : : gboolean
553 : 9 : mct_manager_set_app_filter (MctManager *self,
554 : : uid_t user_id,
555 : : MctAppFilter *app_filter,
556 : : MctManagerSetValueFlags flags,
557 : : GCancellable *cancellable,
558 : : GError **error)
559 : : {
560 : 9 : g_autofree gchar *object_path = NULL;
561 : 9 : g_autoptr(GVariant) properties_variant = NULL;
562 : 9 : g_autoptr(GVariant) properties_value = NULL;
563 : 9 : const gchar *properties_key = NULL;
564 : : GVariantIter iter;
565 : 9 : g_autoptr(GError) local_error = NULL;
566 : :
567 : 9 : g_return_val_if_fail (MCT_IS_MANAGER (self), FALSE);
568 : 9 : g_return_val_if_fail (app_filter != NULL, FALSE);
569 : 9 : g_return_val_if_fail (app_filter->ref_count >= 1, FALSE);
570 : 9 : g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
571 : 9 : g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
572 : :
573 : 18 : object_path = accounts_find_user_by_id (self->connection, user_id,
574 : 9 : (flags & MCT_MANAGER_SET_VALUE_FLAGS_INTERACTIVE),
575 : : cancellable, error);
576 [ + + ]: 9 : if (object_path == NULL)
577 : 1 : return FALSE;
578 : :
579 : 8 : properties_variant = mct_app_filter_serialize (app_filter);
580 : :
581 : 8 : g_variant_iter_init (&iter, properties_variant);
582 [ + + ]: 22 : while (g_variant_iter_loop (&iter, "{&sv}", &properties_key, &properties_value))
583 : : {
584 [ + + ]: 20 : g_autoptr(GVariant) result_variant = NULL;
585 : :
586 : 20 : result_variant =
587 : 20 : g_dbus_connection_call_sync (self->connection,
588 : : "org.freedesktop.Accounts",
589 : : object_path,
590 : : "org.freedesktop.DBus.Properties",
591 : : "Set",
592 : : g_variant_new ("(ssv)",
593 : : "com.endlessm.ParentalControls.AppFilter",
594 : : properties_key,
595 : : properties_value),
596 : : G_VARIANT_TYPE ("()"),
597 : : (flags & MCT_MANAGER_SET_VALUE_FLAGS_INTERACTIVE)
598 : : ? G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION
599 : 20 : : G_DBUS_CALL_FLAGS_NONE,
600 : : -1, /* timeout, ms */
601 : : cancellable,
602 : : &local_error);
603 [ + + ]: 20 : if (local_error != NULL)
604 : : {
605 : 6 : g_propagate_error (error, bus_error_to_manager_error (local_error, user_id));
606 : 6 : return FALSE;
607 : : }
608 : : }
609 : :
610 : 2 : return TRUE;
611 : : }
612 : :
613 : : static void set_app_filter_thread_cb (GTask *task,
614 : : gpointer source_object,
615 : : gpointer task_data,
616 : : GCancellable *cancellable);
617 : :
618 : : typedef struct
619 : : {
620 : : uid_t user_id;
621 : : MctAppFilter *app_filter; /* (owned) */
622 : : MctManagerSetValueFlags flags;
623 : : } SetAppFilterData;
624 : :
625 : : static void
626 : 2 : set_app_filter_data_free (SetAppFilterData *data)
627 : : {
628 : 2 : mct_app_filter_unref (data->app_filter);
629 : 2 : g_free (data);
630 : 2 : }
631 : :
632 [ - + ]: 4 : G_DEFINE_AUTOPTR_CLEANUP_FUNC (SetAppFilterData, set_app_filter_data_free)
633 : :
634 : : /**
635 : : * mct_manager_set_app_filter_async:
636 : : * @self: a #MctManager
637 : : * @user_id: ID of the user to set the filter for, typically coming from getuid()
638 : : * @app_filter: (transfer none): the app filter to set for the user
639 : : * @flags: flags to affect the behaviour of the call
640 : : * @cancellable: (nullable): a #GCancellable, or %NULL
641 : : * @callback: a #GAsyncReadyCallback
642 : : * @user_data: user data to pass to @callback
643 : : *
644 : : * Asynchronously set the app filter settings for the given @user_id to the
645 : : * given @app_filter instance. This will set all fields of the app filter.
646 : : *
647 : : * On failure, an #MctManagerError, a #GDBusError or a #GIOError will be
648 : : * returned. The user’s app filter settings will be left in an undefined state.
649 : : *
650 : : * Since: 0.3.0
651 : : */
652 : : void
653 : 2 : mct_manager_set_app_filter_async (MctManager *self,
654 : : uid_t user_id,
655 : : MctAppFilter *app_filter,
656 : : MctManagerSetValueFlags flags,
657 : : GCancellable *cancellable,
658 : : GAsyncReadyCallback callback,
659 : : gpointer user_data)
660 : : {
661 [ + - ]: 2 : g_autoptr(GTask) task = NULL;
662 [ + - ]: 2 : g_autoptr(SetAppFilterData) data = NULL;
663 : :
664 : 2 : g_return_if_fail (MCT_IS_MANAGER (self));
665 : 2 : g_return_if_fail (app_filter != NULL);
666 : 2 : g_return_if_fail (app_filter->ref_count >= 1);
667 : 2 : g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
668 : :
669 : 2 : task = g_task_new (self, cancellable, callback, user_data);
670 [ + - ]: 2 : g_task_set_source_tag (task, mct_manager_set_app_filter_async);
671 : :
672 : 2 : data = g_new0 (SetAppFilterData, 1);
673 : 2 : data->user_id = user_id;
674 : 2 : data->app_filter = mct_app_filter_ref (app_filter);
675 : 2 : data->flags = flags;
676 : 2 : g_task_set_task_data (task, g_steal_pointer (&data),
677 : : (GDestroyNotify) set_app_filter_data_free);
678 : :
679 : 2 : g_task_run_in_thread (task, set_app_filter_thread_cb);
680 : : }
681 : :
682 : : static void
683 : 2 : set_app_filter_thread_cb (GTask *task,
684 : : gpointer source_object,
685 : : gpointer task_data,
686 : : GCancellable *cancellable)
687 : : {
688 : : gboolean success;
689 : 2 : MctManager *manager = MCT_MANAGER (source_object);
690 : 2 : SetAppFilterData *data = task_data;
691 : 2 : g_autoptr(GError) local_error = NULL;
692 : :
693 : 2 : success = mct_manager_set_app_filter (manager, data->user_id,
694 : : data->app_filter, data->flags,
695 : : cancellable, &local_error);
696 : :
697 [ + + ]: 2 : if (local_error != NULL)
698 : 1 : g_task_return_error (task, g_steal_pointer (&local_error));
699 : : else
700 : 1 : g_task_return_boolean (task, success);
701 : 2 : }
702 : :
703 : : /**
704 : : * mct_manager_set_app_filter_finish:
705 : : * @self: a #MctManager
706 : : * @result: a #GAsyncResult
707 : : * @error: return location for a #GError, or %NULL
708 : : *
709 : : * Finish an asynchronous operation to set the app filter for a user, started
710 : : * with mct_manager_set_app_filter_async().
711 : : *
712 : : * Returns: %TRUE on success, %FALSE otherwise
713 : : * Since: 0.3.0
714 : : */
715 : : gboolean
716 : 2 : mct_manager_set_app_filter_finish (MctManager *self,
717 : : GAsyncResult *result,
718 : : GError **error)
719 : : {
720 : 2 : g_return_val_if_fail (MCT_IS_MANAGER (self), FALSE);
721 : 2 : g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
722 : 2 : g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
723 : :
724 : 2 : return g_task_propagate_boolean (G_TASK (result), error);
725 : : }
726 : :
727 : : /**
728 : : * mct_manager_get_session_limits:
729 : : * @self: a #MctManager
730 : : * @user_id: ID of the user to query, typically coming from getuid()
731 : : * @flags: flags to affect the behaviour of the call
732 : : * @cancellable: (nullable): a #GCancellable, or %NULL
733 : : * @error: return location for a #GError, or %NULL
734 : : *
735 : : * Synchronous version of mct_manager_get_session_limits_async().
736 : : *
737 : : * Returns: (transfer full): session limits for the queried user
738 : : * Since: 0.5.0
739 : : */
740 : : MctSessionLimits *
741 : 8 : mct_manager_get_session_limits (MctManager *self,
742 : : uid_t user_id,
743 : : MctManagerGetValueFlags flags,
744 : : GCancellable *cancellable,
745 : : GError **error)
746 : : {
747 : 8 : g_autofree gchar *object_path = NULL;
748 : 8 : g_autoptr(GVariant) result_variant = NULL;
749 : 8 : g_autoptr(GVariant) properties = NULL;
750 : 8 : g_autoptr(GError) local_error = NULL;
751 : :
752 : 8 : g_return_val_if_fail (MCT_IS_MANAGER (self), NULL);
753 : 8 : g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), NULL);
754 : 8 : g_return_val_if_fail (error == NULL || *error == NULL, NULL);
755 : :
756 : 16 : object_path = accounts_find_user_by_id (self->connection, user_id,
757 : 8 : (flags & MCT_MANAGER_GET_VALUE_FLAGS_INTERACTIVE),
758 : : cancellable, error);
759 [ + + ]: 8 : if (object_path == NULL)
760 : 2 : return NULL;
761 : :
762 : 6 : result_variant =
763 : 6 : g_dbus_connection_call_sync (self->connection,
764 : : "org.freedesktop.Accounts",
765 : : object_path,
766 : : "org.freedesktop.DBus.Properties",
767 : : "GetAll",
768 : : g_variant_new ("(s)", "com.endlessm.ParentalControls.SessionLimits"),
769 : : G_VARIANT_TYPE ("(a{sv})"),
770 : : (flags & MCT_MANAGER_GET_VALUE_FLAGS_INTERACTIVE)
771 : : ? G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION
772 : 6 : : G_DBUS_CALL_FLAGS_NONE,
773 : : -1, /* timeout, ms */
774 : : cancellable,
775 : : &local_error);
776 [ + + ]: 6 : if (local_error != NULL)
777 : : {
778 : 4 : g_autoptr(GError) manager_error = NULL;
779 : :
780 [ + + ]: 2 : if (g_error_matches (local_error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS))
781 : : {
782 : : /* o.fd.D.GetAll() will return InvalidArgs errors if
783 : : * accountsservice doesn’t have the com.endlessm.ParentalControls.SessionLimits
784 : : * extension interface installed. */
785 : 1 : manager_error = g_error_new_literal (MCT_MANAGER_ERROR,
786 : : MCT_MANAGER_ERROR_DISABLED,
787 : : _("Session limits are globally disabled"));
788 : : }
789 : : else
790 : : {
791 : 1 : manager_error = bus_error_to_manager_error (local_error, user_id);
792 : : }
793 : :
794 : 2 : g_propagate_error (error, g_steal_pointer (&manager_error));
795 : 2 : return NULL;
796 : : }
797 : :
798 : : /* Extract the properties we care about. They may be silently omitted from the
799 : : * results if we don’t have permission to access them. */
800 : 4 : properties = g_variant_get_child_value (result_variant, 0);
801 [ + + ]: 4 : if (!g_variant_lookup (properties, "LimitType", "u", NULL))
802 : : {
803 : 1 : g_set_error (error, MCT_MANAGER_ERROR,
804 : : MCT_MANAGER_ERROR_PERMISSION_DENIED,
805 : : _("Not allowed to query parental controls data for user %u"),
806 : : (guint) user_id);
807 : 1 : return NULL;
808 : : }
809 : :
810 : 3 : return mct_session_limits_deserialize (properties, user_id, error);
811 : : }
812 : :
813 : : static void get_session_limits_thread_cb (GTask *task,
814 : : gpointer source_object,
815 : : gpointer task_data,
816 : : GCancellable *cancellable);
817 : :
818 : : typedef struct
819 : : {
820 : : uid_t user_id;
821 : : MctManagerGetValueFlags flags;
822 : : } GetSessionLimitsData;
823 : :
824 : : static void
825 : 6 : get_session_limits_data_free (GetSessionLimitsData *data)
826 : : {
827 : 6 : g_free (data);
828 : 6 : }
829 : :
830 [ - + ]: 12 : G_DEFINE_AUTOPTR_CLEANUP_FUNC (GetSessionLimitsData, get_session_limits_data_free)
831 : :
832 : : /**
833 : : * mct_manager_get_session_limits_async:
834 : : * @self: a #MctManager
835 : : * @user_id: ID of the user to query, typically coming from getuid()
836 : : * @flags: flags to affect the behaviour of the call
837 : : * @cancellable: (nullable): a #GCancellable, or %NULL
838 : : * @callback: a #GAsyncReadyCallback
839 : : * @user_data: user data to pass to @callback
840 : : *
841 : : * Asynchronously get a snapshot of the session limit settings for the given
842 : : * @user_id.
843 : : *
844 : : * On failure, an #MctManagerError, a #GDBusError or a #GIOError will be
845 : : * returned via mct_manager_get_session_limits_finish().
846 : : *
847 : : * Since: 0.5.0
848 : : */
849 : : void
850 : 6 : mct_manager_get_session_limits_async (MctManager *self,
851 : : uid_t user_id,
852 : : MctManagerGetValueFlags flags,
853 : : GCancellable *cancellable,
854 : : GAsyncReadyCallback callback,
855 : : gpointer user_data)
856 : : {
857 [ + - ]: 6 : g_autoptr(GTask) task = NULL;
858 [ + - ]: 6 : g_autoptr(GetSessionLimitsData) data = NULL;
859 : :
860 : 6 : g_return_if_fail (MCT_IS_MANAGER (self));
861 : 6 : g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
862 : :
863 : 6 : task = g_task_new (self, cancellable, callback, user_data);
864 [ + - ]: 6 : g_task_set_source_tag (task, mct_manager_get_session_limits_async);
865 : :
866 : 6 : data = g_new0 (GetSessionLimitsData, 1);
867 : 6 : data->user_id = user_id;
868 : 6 : data->flags = flags;
869 : 6 : g_task_set_task_data (task, g_steal_pointer (&data),
870 : : (GDestroyNotify) get_session_limits_data_free);
871 : :
872 : 6 : g_task_run_in_thread (task, get_session_limits_thread_cb);
873 : : }
874 : :
875 : : static void
876 : 6 : get_session_limits_thread_cb (GTask *task,
877 : : gpointer source_object,
878 : : gpointer task_data,
879 : : GCancellable *cancellable)
880 : : {
881 : 6 : g_autoptr(MctSessionLimits) limits = NULL;
882 : 6 : MctManager *manager = MCT_MANAGER (source_object);
883 : 6 : GetSessionLimitsData *data = task_data;
884 : 6 : g_autoptr(GError) local_error = NULL;
885 : :
886 : 6 : limits = mct_manager_get_session_limits (manager, data->user_id,
887 : : data->flags,
888 : : cancellable, &local_error);
889 : :
890 [ + + ]: 6 : if (local_error != NULL)
891 : 5 : g_task_return_error (task, g_steal_pointer (&local_error));
892 : : else
893 : 1 : g_task_return_pointer (task, g_steal_pointer (&limits),
894 : : (GDestroyNotify) mct_session_limits_unref);
895 : 6 : }
896 : :
897 : : /**
898 : : * mct_manager_get_session_limits_finish:
899 : : * @self: a #MctManager
900 : : * @result: a #GAsyncResult
901 : : * @error: return location for a #GError, or %NULL
902 : : *
903 : : * Finish an asynchronous operation to get the session limits for a user,
904 : : * started with mct_manager_get_session_limits_async().
905 : : *
906 : : * Returns: (transfer full): session limits for the queried user
907 : : * Since: 0.5.0
908 : : */
909 : : MctSessionLimits *
910 : 6 : mct_manager_get_session_limits_finish (MctManager *self,
911 : : GAsyncResult *result,
912 : : GError **error)
913 : : {
914 : 6 : g_return_val_if_fail (MCT_IS_MANAGER (self), NULL);
915 : 6 : g_return_val_if_fail (g_task_is_valid (result, self), NULL);
916 : 6 : g_return_val_if_fail (error == NULL || *error == NULL, NULL);
917 : :
918 : 6 : return g_task_propagate_pointer (G_TASK (result), error);
919 : : }
920 : :
921 : : /**
922 : : * mct_manager_set_session_limits:
923 : : * @self: a #MctManager
924 : : * @user_id: ID of the user to set the limits for, typically coming from getuid()
925 : : * @session_limits: (transfer none): the session limits to set for the user
926 : : * @flags: flags to affect the behaviour of the call
927 : : * @cancellable: (nullable): a #GCancellable, or %NULL
928 : : * @error: return location for a #GError, or %NULL
929 : : *
930 : : * Synchronous version of mct_manager_set_session_limits_async().
931 : : *
932 : : * Returns: %TRUE on success, %FALSE otherwise
933 : : * Since: 0.5.0
934 : : */
935 : : gboolean
936 : 7 : mct_manager_set_session_limits (MctManager *self,
937 : : uid_t user_id,
938 : : MctSessionLimits *session_limits,
939 : : MctManagerSetValueFlags flags,
940 : : GCancellable *cancellable,
941 : : GError **error)
942 : : {
943 : 7 : g_autofree gchar *object_path = NULL;
944 : 7 : g_autoptr(GVariant) limit_type_variant = NULL;
945 : 7 : g_autoptr(GVariant) limit_type_result_variant = NULL;
946 : 7 : g_autoptr(GVariant) properties_variant = NULL;
947 : 7 : g_autoptr(GVariant) properties_value = NULL;
948 : 7 : const gchar *properties_key = NULL;
949 : : GVariantIter iter;
950 : 7 : g_autoptr(GError) local_error = NULL;
951 : :
952 : 7 : g_return_val_if_fail (MCT_IS_MANAGER (self), FALSE);
953 : 7 : g_return_val_if_fail (session_limits != NULL, FALSE);
954 : 7 : g_return_val_if_fail (session_limits->ref_count >= 1, FALSE);
955 : 7 : g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE);
956 : 7 : g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
957 : :
958 : 14 : object_path = accounts_find_user_by_id (self->connection, user_id,
959 : 7 : (flags & MCT_MANAGER_SET_VALUE_FLAGS_INTERACTIVE),
960 : : cancellable, error);
961 [ + + ]: 7 : if (object_path == NULL)
962 : 1 : return FALSE;
963 : :
964 : 6 : properties_variant = mct_session_limits_serialize (session_limits);
965 : :
966 : 6 : g_variant_iter_init (&iter, properties_variant);
967 [ + + ]: 14 : while (g_variant_iter_loop (&iter, "{&sv}", &properties_key, &properties_value))
968 : : {
969 [ + + + ]: 9 : g_autoptr(GVariant) result_variant = NULL;
970 : :
971 : : /* Change the limit type last, so all the details of the new limit are
972 : : * correct by the time it’s changed over. */
973 [ + + ]: 9 : if (g_str_equal (properties_key, "LimitType"))
974 : : {
975 : 5 : limit_type_variant = g_steal_pointer (&properties_value);
976 : 5 : continue;
977 : : }
978 : :
979 : 4 : result_variant =
980 : 4 : g_dbus_connection_call_sync (self->connection,
981 : : "org.freedesktop.Accounts",
982 : : object_path,
983 : : "org.freedesktop.DBus.Properties",
984 : : "Set",
985 : : g_variant_new ("(ssv)",
986 : : "com.endlessm.ParentalControls.SessionLimits",
987 : : properties_key,
988 : : properties_value),
989 : : G_VARIANT_TYPE ("()"),
990 : : (flags & MCT_MANAGER_SET_VALUE_FLAGS_INTERACTIVE)
991 : : ? G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION
992 : 4 : : G_DBUS_CALL_FLAGS_NONE,
993 : : -1, /* timeout, ms */
994 : : cancellable,
995 : : &local_error);
996 [ + + ]: 4 : if (local_error != NULL)
997 : : {
998 : 1 : g_propagate_error (error, bus_error_to_manager_error (local_error, user_id));
999 : 1 : return FALSE;
1000 : : }
1001 : : }
1002 : :
1003 : 5 : limit_type_result_variant =
1004 : 5 : g_dbus_connection_call_sync (self->connection,
1005 : : "org.freedesktop.Accounts",
1006 : : object_path,
1007 : : "org.freedesktop.DBus.Properties",
1008 : : "Set",
1009 : : g_variant_new ("(ssv)",
1010 : : "com.endlessm.ParentalControls.SessionLimits",
1011 : : "LimitType",
1012 : : limit_type_variant),
1013 : : G_VARIANT_TYPE ("()"),
1014 : : (flags & MCT_MANAGER_SET_VALUE_FLAGS_INTERACTIVE)
1015 : : ? G_DBUS_CALL_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION
1016 : 5 : : G_DBUS_CALL_FLAGS_NONE,
1017 : : -1, /* timeout, ms */
1018 : : cancellable,
1019 : : &local_error);
1020 [ + + ]: 5 : if (local_error != NULL)
1021 : : {
1022 : 3 : g_propagate_error (error, bus_error_to_manager_error (local_error, user_id));
1023 : 3 : return FALSE;
1024 : : }
1025 : :
1026 : 2 : return TRUE;
1027 : : }
1028 : :
1029 : : static void set_session_limits_thread_cb (GTask *task,
1030 : : gpointer source_object,
1031 : : gpointer task_data,
1032 : : GCancellable *cancellable);
1033 : :
1034 : : typedef struct
1035 : : {
1036 : : uid_t user_id;
1037 : : MctSessionLimits *session_limits; /* (owned) */
1038 : : MctManagerSetValueFlags flags;
1039 : : } SetSessionLimitsData;
1040 : :
1041 : : static void
1042 : 2 : set_session_limits_data_free (SetSessionLimitsData *data)
1043 : : {
1044 : 2 : mct_session_limits_unref (data->session_limits);
1045 : 2 : g_free (data);
1046 : 2 : }
1047 : :
1048 [ - + ]: 4 : G_DEFINE_AUTOPTR_CLEANUP_FUNC (SetSessionLimitsData, set_session_limits_data_free)
1049 : :
1050 : : /**
1051 : : * mct_manager_set_session_limits_async:
1052 : : * @self: a #MctManager
1053 : : * @user_id: ID of the user to set the limits for, typically coming from getuid()
1054 : : * @session_limits: (transfer none): the session limits to set for the user
1055 : : * @flags: flags to affect the behaviour of the call
1056 : : * @cancellable: (nullable): a #GCancellable, or %NULL
1057 : : * @callback: a #GAsyncReadyCallback
1058 : : * @user_data: user data to pass to @callback
1059 : : *
1060 : : * Asynchronously set the session limits settings for the given @user_id to the
1061 : : * given @session_limits instance.
1062 : : *
1063 : : * On failure, an #MctManagerError, a #GDBusError or a #GIOError will be
1064 : : * returned via mct_manager_set_session_limits_finish(). The user’s session
1065 : : * limits settings will be left in an undefined state.
1066 : : *
1067 : : * Since: 0.5.0
1068 : : */
1069 : : void
1070 : 2 : mct_manager_set_session_limits_async (MctManager *self,
1071 : : uid_t user_id,
1072 : : MctSessionLimits *session_limits,
1073 : : MctManagerSetValueFlags flags,
1074 : : GCancellable *cancellable,
1075 : : GAsyncReadyCallback callback,
1076 : : gpointer user_data)
1077 : : {
1078 [ + - ]: 2 : g_autoptr(GTask) task = NULL;
1079 [ + - ]: 2 : g_autoptr(SetSessionLimitsData) data = NULL;
1080 : :
1081 : 2 : g_return_if_fail (MCT_IS_MANAGER (self));
1082 : 2 : g_return_if_fail (session_limits != NULL);
1083 : 2 : g_return_if_fail (session_limits->ref_count >= 1);
1084 : 2 : g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
1085 : :
1086 : 2 : task = g_task_new (self, cancellable, callback, user_data);
1087 [ + - ]: 2 : g_task_set_source_tag (task, mct_manager_set_session_limits_async);
1088 : :
1089 : 2 : data = g_new0 (SetSessionLimitsData, 1);
1090 : 2 : data->user_id = user_id;
1091 : 2 : data->session_limits = mct_session_limits_ref (session_limits);
1092 : 2 : data->flags = flags;
1093 : 2 : g_task_set_task_data (task, g_steal_pointer (&data),
1094 : : (GDestroyNotify) set_session_limits_data_free);
1095 : :
1096 : 2 : g_task_run_in_thread (task, set_session_limits_thread_cb);
1097 : : }
1098 : :
1099 : : static void
1100 : 2 : set_session_limits_thread_cb (GTask *task,
1101 : : gpointer source_object,
1102 : : gpointer task_data,
1103 : : GCancellable *cancellable)
1104 : : {
1105 : : gboolean success;
1106 : 2 : MctManager *manager = MCT_MANAGER (source_object);
1107 : 2 : SetSessionLimitsData *data = task_data;
1108 : 2 : g_autoptr(GError) local_error = NULL;
1109 : :
1110 : 2 : success = mct_manager_set_session_limits (manager, data->user_id,
1111 : : data->session_limits, data->flags,
1112 : : cancellable, &local_error);
1113 : :
1114 [ + + ]: 2 : if (local_error != NULL)
1115 : 1 : g_task_return_error (task, g_steal_pointer (&local_error));
1116 : : else
1117 : 1 : g_task_return_boolean (task, success);
1118 : 2 : }
1119 : :
1120 : : /**
1121 : : * mct_manager_set_session_limits_finish:
1122 : : * @self: a #MctManager
1123 : : * @result: a #GAsyncResult
1124 : : * @error: return location for a #GError, or %NULL
1125 : : *
1126 : : * Finish an asynchronous operation to set the session limits for a user,
1127 : : * started with mct_manager_set_session_limits_async().
1128 : : *
1129 : : * Returns: %TRUE on success, %FALSE otherwise
1130 : : * Since: 0.5.0
1131 : : */
1132 : : gboolean
1133 : 2 : mct_manager_set_session_limits_finish (MctManager *self,
1134 : : GAsyncResult *result,
1135 : : GError **error)
1136 : : {
1137 : 2 : g_return_val_if_fail (MCT_IS_MANAGER (self), FALSE);
1138 : 2 : g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
1139 : 2 : g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
1140 : :
1141 : 2 : return g_task_propagate_boolean (G_TASK (result), error);
1142 : : }
|
