GCC Code Coverage Report

Line	Branch	Exec	Source
1			/*
2			* Copyright © 2017 Red Hat, Inc
3			*
4			* This program is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU Lesser General Public
6			* License as published by the Free Software Foundation; either
7			* version 2.1 of the License, or (at your option) any later version.
8			*
9			* This library is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12			* Lesser General Public License for more details.
13			*
14			* You should have received a copy of the GNU Lesser General Public
15			* License along with this library. If not, see <http://www.gnu.org/licenses/>.
16			*
17			* Authors:
18			* Christian J. Kellner <christian@kellner.me>
19			*/
20
21			#include "config.h"
22
23			#include "bolt-device.h"
24
25			#include "bolt-enums.h"
26			#include "bolt-error.h"
27			#include "bolt-names.h"
28
29			#include <gio/gio.h>
30
31			struct _BoltDevice
32			{
33			BoltProxy parent;
34			};
35
36			enum {
37			PROP_0,
38
39			/* D-Bus Props */
40			PROP_UID,
41			PROP_NAME,
42			PROP_VENDOR,
43			PROP_TYPE,
44			PROP_STATUS,
45			PROP_AUTHFLAGS,
46			PROP_PARENT,
47			PROP_SYSPATH,
48			PROP_CONNTIME,
49			PROP_AUTHTIME,
50
51			PROP_STORED,
52			PROP_POLICY,
53			PROP_KEY,
54			PROP_STORETIME,
55			PROP_LABEL,
56
57			PROP_LAST
58			};
59
60			static GParamSpec *props[PROP_LAST] = {NULL, };
61
62		✗	G_DEFINE_TYPE (BoltDevice,
63			bolt_device,
64			BOLT_TYPE_PROXY);
65
66			static void
67		✗	bolt_device_get_property (GObject *object,
68			guint prop_id,
69			GValue *value,
70			GParamSpec *pspec)
71			{
72		✗	if (bolt_proxy_get_dbus_property (object, pspec, value))
73		✗	return;
74			}
75
76
77
78			static void
79		✗	bolt_device_class_init (BoltDeviceClass *klass)
80			{
81		✗	GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
82
83		✗	gobject_class->get_property = bolt_device_get_property;
84
85		✗	props[PROP_UID] =
86		✗	g_param_spec_string ("uid",
87			"Uid", NULL,
88			"unknown",
89			G_PARAM_READABLE |
90			G_PARAM_STATIC_NICK);
91
92		✗	props[PROP_NAME] =
93		✗	g_param_spec_string ("name",
94			"Name", NULL,
95			"unknown",
96			G_PARAM_READABLE |
97			G_PARAM_STATIC_NICK);
98
99		✗	props[PROP_VENDOR] =
100		✗	g_param_spec_string ("vendor",
101			"Vendor", NULL,
102			"unknown",
103			G_PARAM_READABLE |
104			G_PARAM_STATIC_NICK);
105
106		✗	props[PROP_TYPE] =
107		✗	g_param_spec_enum ("type",
108			"Type", NULL,
109			BOLT_TYPE_DEVICE_TYPE,
110			BOLT_DEVICE_PERIPHERAL,
111			G_PARAM_READABLE |
112			G_PARAM_STATIC_NICK);
113
114		✗	props[PROP_STATUS] =
115		✗	g_param_spec_enum ("status",
116			"Status", NULL,
117			BOLT_TYPE_STATUS,
118			BOLT_STATUS_DISCONNECTED,
119			G_PARAM_READABLE |
120			G_PARAM_STATIC_NICK);
121
122		✗	props[PROP_AUTHFLAGS] =
123		✗	g_param_spec_flags ("authflags",
124			"AuthFlags", NULL,
125			BOLT_TYPE_AUTH_FLAGS,
126			BOLT_AUTH_NONE,
127			G_PARAM_READABLE |
128			G_PARAM_STATIC_STRINGS);
129
130		✗	props[PROP_PARENT] =
131		✗	g_param_spec_string ("parent",
132			"Parent", NULL,
133			"unknown",
134			G_PARAM_READABLE |
135			G_PARAM_STATIC_NICK);
136
137		✗	props[PROP_SYSPATH] =
138		✗	g_param_spec_string ("syspath",
139			"SysfsPath", NULL,
140			"unknown",
141			G_PARAM_READABLE |
142			G_PARAM_STATIC_NICK);
143
144		✗	props[PROP_CONNTIME] =
145		✗	g_param_spec_uint64 ("conntime",
146			"ConnectTime", NULL,
147			0, G_MAXUINT64, 0,
148			G_PARAM_READABLE |
149			G_PARAM_STATIC_STRINGS);
150
151		✗	props[PROP_AUTHTIME] =
152		✗	g_param_spec_uint64 ("authtime",
153			"AuthorizeTime", NULL,
154			0, G_MAXUINT64, 0,
155			G_PARAM_READABLE |
156			G_PARAM_STATIC_STRINGS);
157
158		✗	props[PROP_STORED] =
159		✗	g_param_spec_boolean ("stored",
160			"Stored", NULL,
161			FALSE,
162			G_PARAM_READABLE |
163			G_PARAM_STATIC_NICK);
164
165		✗	props[PROP_POLICY] =
166		✗	g_param_spec_enum ("policy",
167			"Policy", NULL,
168			BOLT_TYPE_POLICY,
169			BOLT_POLICY_DEFAULT,
170			G_PARAM_READABLE |
171			G_PARAM_STATIC_NICK);
172
173		✗	props[PROP_KEY] =
174		✗	g_param_spec_enum ("key",
175			"Key", NULL,
176			BOLT_TYPE_KEY_STATE,
177			BOLT_KEY_MISSING,
178			G_PARAM_READABLE |
179			G_PARAM_STATIC_NICK);
180
181		✗	props[PROP_STORETIME] =
182		✗	g_param_spec_uint64 ("storetime",
183			"StoreTime", NULL,
184			0, G_MAXUINT64, 0,
185			G_PARAM_READABLE |
186			G_PARAM_STATIC_STRINGS);
187
188		✗	props[PROP_LABEL] =
189		✗	g_param_spec_string ("label",
190			"Label", NULL,
191			NULL,
192			G_PARAM_READABLE |
193			G_PARAM_STATIC_STRINGS);
194
195		✗	g_object_class_install_properties (gobject_class,
196			PROP_LAST,
197			props);
198
199		✗	}
200
201			static void
202		✗	bolt_device_init (BoltDevice *mgr)
203			{
204		✗	}
205
206			/* public methods */
207
208			BoltDevice *
209		✗	bolt_device_new_for_object_path (GDBusConnection *bus,
210			const char *path,
211			GCancellable *cancel,
212			GError **error)
213			{
214			BoltDevice *dev;
215
216		✗	dev = g_initable_new (BOLT_TYPE_DEVICE,
217			cancel, error,
218			"g-flags", G_DBUS_PROXY_FLAGS_NONE,
219			"g-connection", bus,
220			"g-name", BOLT_DBUS_NAME,
221			"g-object-path", path,
222			"g-interface-name", BOLT_DBUS_DEVICE_INTERFACE,
223			NULL);
224
225		✗	return dev;
226			}
227
228			gboolean
229		✗	bolt_device_authorize (BoltDevice *dev,
230			BoltAuthCtrl flags,
231			GCancellable *cancel,
232			GError **error)
233			{
234		✗	g_autoptr(GError) err = NULL;
235		✗	g_autofree char *fstr = NULL;
236
237		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), FALSE);
238
239		✗	fstr = bolt_flags_to_string (BOLT_TYPE_AUTH_CTRL, flags, error);
240		✗	if (fstr == NULL)
241		✗	return FALSE;
242
243		✗	g_dbus_proxy_call_sync (G_DBUS_PROXY (dev),
244			"Authorize",
245			g_variant_new ("(s)", fstr),
246			G_DBUS_CALL_FLAGS_NONE,
247			-1,
248			cancel,
249			&err);
250
251		✗	if (err != NULL)
252		✗	return bolt_error_propagate_stripped (error, &err);
253
254		✗	return TRUE;
255			}
256
257			void
258		✗	bolt_device_authorize_async (BoltDevice *dev,
259			BoltAuthCtrl flags,
260			GCancellable *cancellable,
261			GAsyncReadyCallback callback,
262			gpointer user_data)
263			{
264		✗	GError *err = NULL;
265		✗	g_autofree char *fstr = NULL;
266
267		✗	g_return_if_fail (BOLT_IS_DEVICE (dev));
268
269		✗	fstr = bolt_flags_to_string (BOLT_TYPE_AUTH_CTRL, flags, &err);
270		✗	if (fstr == NULL)
271			{
272		✗	g_task_report_error (dev, callback, user_data, NULL, err);
273		✗	return;
274			}
275
276		✗	g_dbus_proxy_call (G_DBUS_PROXY (dev),
277			"Authorize",
278			g_variant_new ("(s)", fstr),
279			G_DBUS_CALL_FLAGS_NONE,
280			-1,
281			cancellable,
282			callback,
283			user_data);
284			}
285
286			gboolean
287		✗	bolt_device_authorize_finish (BoltDevice *dev,
288			GAsyncResult *res,
289			GError **error)
290			{
291		✗	g_autoptr(GError) err = NULL;
292		✗	g_autoptr(GVariant) val = NULL;
293
294		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), FALSE);
295
296		✗	val = g_dbus_proxy_call_finish (G_DBUS_PROXY (dev), res, &err);
297		✗	if (val == NULL)
298			{
299		✗	bolt_error_propagate_stripped (error, &err);
300		✗	return FALSE;
301			}
302
303		✗	return TRUE;
304			}
305
306			const char *
307		✗	bolt_device_get_uid (BoltDevice *dev)
308			{
309			const char *key;
310			const char *str;
311
312		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), NULL);
313
314		✗	key = g_param_spec_get_name (props[PROP_UID]);
315		✗	str = bolt_proxy_get_property_string (BOLT_PROXY (dev), key);
316
317		✗	return str;
318			}
319
320			const char *
321		✗	bolt_device_get_name (BoltDevice *dev)
322			{
323			const char *key;
324			const char *str;
325
326		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), NULL);
327
328		✗	key = g_param_spec_get_name (props[PROP_NAME]);
329		✗	str = bolt_proxy_get_property_string (BOLT_PROXY (dev), key);
330
331		✗	return str;
332			}
333
334			const char *
335		✗	bolt_device_get_vendor (BoltDevice *dev)
336			{
337			const char *key;
338			const char *str;
339
340		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), NULL);
341
342		✗	key = g_param_spec_get_name (props[PROP_VENDOR]);
343		✗	str = bolt_proxy_get_property_string (BOLT_PROXY (dev), key);
344
345		✗	return str;
346			}
347
348			BoltDeviceType
349		✗	bolt_device_get_device_type (BoltDevice *dev)
350			{
351			const char *key;
352			gboolean ok;
353		✗	gint val = BOLT_DEVICE_PERIPHERAL;
354
355		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), val);
356
357		✗	key = g_param_spec_get_name (props[PROP_TYPE]);
358		✗	ok = bolt_proxy_get_property_enum (BOLT_PROXY (dev), key, &val);
359
360		✗	if (!ok)
361		✗	g_warning ("failed to get enum property '%s'", key);
362
363		✗	return val;
364			}
365
366			BoltStatus
367		✗	bolt_device_get_status (BoltDevice *dev)
368			{
369			const char *key;
370			gboolean ok;
371		✗	gint val = BOLT_STATUS_UNKNOWN;
372
373		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), val);
374
375		✗	key = g_param_spec_get_name (props[PROP_STATUS]);
376		✗	ok = bolt_proxy_get_property_enum (BOLT_PROXY (dev), key, &val);
377
378		✗	if (!ok)
379		✗	g_warning ("failed to get enum property '%s'", key);
380
381		✗	return val;
382			}
383
384			BoltAuthFlags
385		✗	bolt_device_get_authflags (BoltDevice *dev)
386			{
387			const char *key;
388			gboolean ok;
389		✗	guint val = BOLT_AUTH_NONE;
390
391		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), val);
392
393		✗	key = g_param_spec_get_name (props[PROP_AUTHFLAGS]);
394		✗	ok = bolt_proxy_get_property_flags (BOLT_PROXY (dev), key, &val);
395
396		✗	if (!ok)
397		✗	g_warning ("failed to get enum property '%s'", key);
398
399		✗	return val;
400			}
401
402			const char *
403		✗	bolt_device_get_parent (BoltDevice *dev)
404			{
405			const char *key;
406			const char *str;
407
408		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), NULL);
409
410		✗	key = g_param_spec_get_name (props[PROP_PARENT]);
411		✗	str = bolt_proxy_get_property_string (BOLT_PROXY (dev), key);
412
413		✗	return str;
414			}
415
416			const char *
417		✗	bolt_device_get_syspath (BoltDevice *dev)
418			{
419			const char *key;
420			const char *str;
421
422		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), NULL);
423
424		✗	key = g_param_spec_get_name (props[PROP_SYSPATH]);
425		✗	str = bolt_proxy_get_property_string (BOLT_PROXY (dev), key);
426
427		✗	return str;
428			}
429
430			guint64
431		✗	bolt_device_get_conntime (BoltDevice *dev)
432			{
433			const char *key;
434		✗	guint64 val = 0;
435			gboolean ok;
436
437		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), val);
438
439		✗	key = g_param_spec_get_name (props[PROP_CONNTIME]);
440		✗	ok = bolt_proxy_get_property_uint64 (BOLT_PROXY (dev), key, &val);
441
442		✗	if (!ok)
443		✗	g_warning ("failed to get enum property '%s'", key);
444
445		✗	return val;
446			}
447
448			guint64
449		✗	bolt_device_get_authtime (BoltDevice *dev)
450			{
451			const char *key;
452		✗	guint64 val = 0;
453			gboolean ok;
454
455		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), val);
456
457		✗	key = g_param_spec_get_name (props[PROP_AUTHTIME]);
458		✗	ok = bolt_proxy_get_property_uint64 (BOLT_PROXY (dev), key, &val);
459
460		✗	if (!ok)
461		✗	g_warning ("failed to get enum property '%s'", key);
462
463		✗	return val;
464			}
465
466			gboolean
467		✗	bolt_device_is_stored (BoltDevice *dev)
468			{
469			const char *key;
470		✗	gboolean val = FALSE;
471			gboolean ok;
472
473		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), val);
474
475		✗	key = g_param_spec_get_name (props[PROP_STORED]);
476		✗	ok = bolt_proxy_get_property_bool (BOLT_PROXY (dev), key, &val);
477
478		✗	if (!ok)
479		✗	g_warning ("failed to get enum property '%s'", key);
480
481		✗	return val;
482			}
483
484			BoltPolicy
485		✗	bolt_device_get_policy (BoltDevice *dev)
486			{
487			const char *key;
488			gboolean ok;
489		✗	gint val = BOLT_POLICY_DEFAULT;
490
491		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), val);
492
493		✗	key = g_param_spec_get_name (props[PROP_POLICY]);
494		✗	ok = bolt_proxy_get_property_enum (BOLT_PROXY (dev), key, &val);
495
496		✗	if (!ok)
497		✗	g_warning ("failed to get enum property '%s'", key);
498
499		✗	return val;
500			}
501
502			BoltKeyState
503		✗	bolt_device_get_keystate (BoltDevice *dev)
504			{
505			const char *key;
506			gboolean ok;
507		✗	gint val = BOLT_KEY_MISSING;
508
509		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), val);
510
511		✗	key = g_param_spec_get_name (props[PROP_KEY]);
512		✗	ok = bolt_proxy_get_property_enum (BOLT_PROXY (dev), key, &val);
513
514		✗	if (!ok)
515		✗	g_warning ("failed to get enum property '%s'", key);
516
517		✗	return val;
518			}
519
520			guint64
521		✗	bolt_device_get_storetime (BoltDevice *dev)
522			{
523			const char *key;
524		✗	guint64 val = 0;
525			gboolean ok;
526
527		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), val);
528
529		✗	key = g_param_spec_get_name (props[PROP_STORETIME]);
530		✗	ok = bolt_proxy_get_property_uint64 (BOLT_PROXY (dev), key, &val);
531
532		✗	if (!ok)
533		✗	g_warning ("failed to get enum property '%s'", key);
534
535		✗	return val;
536			}
537
538			const char *
539		✗	bolt_device_get_label (BoltDevice *dev)
540			{
541			const char *key;
542			const char *str;
543
544		✗	g_return_val_if_fail (BOLT_IS_DEVICE (dev), NULL);
545
546		✗	key = g_param_spec_get_name (props[PROP_LABEL]);
547		✗	str = bolt_proxy_get_property_string (BOLT_PROXY (dev), key);
548
549		✗	return str;
550			}
551
552			char *
553		✗	bolt_device_get_display_name (BoltDevice *dev)
554			{
555			const char *label;
556			const char *name;
557			const char *vendor;
558
559		✗	label = bolt_device_get_label (dev);
560		✗	if (label != NULL)
561		✗	return g_strdup (label);
562
563		✗	name = bolt_device_get_name (dev);
564		✗	vendor = bolt_device_get_vendor (dev);
565
566		✗	return g_strdup_printf ("%s %s", vendor, name);
567			}
568
569			guint64
570		✗	bolt_device_get_timestamp (BoltDevice *dev)
571			{
572			BoltStatus status;
573		✗	guint64 timestamp = 0;
574
575		✗	status = bolt_device_get_status (dev);
576
577		✗	switch (status)
578			{
579		✗	case BOLT_STATUS_AUTHORIZING:
580			case BOLT_STATUS_AUTH_ERROR:
581			case BOLT_STATUS_CONNECTING:
582			case BOLT_STATUS_CONNECTED:
583		✗	timestamp = bolt_device_get_conntime (dev);
584		✗	break;
585
586		✗	case BOLT_STATUS_DISCONNECTED:
587			/* implicit: device is stored */
588		✗	timestamp = bolt_device_get_storetime (dev);
589		✗	break;
590
591		✗	case BOLT_STATUS_AUTHORIZED:
592			case BOLT_STATUS_AUTHORIZED_DPONLY:
593			case BOLT_STATUS_AUTHORIZED_NEWKEY:
594			case BOLT_STATUS_AUTHORIZED_SECURE:
595		✗	timestamp = bolt_device_get_authtime (dev);
596		✗	break;
597
598		✗	case BOLT_STATUS_UNKNOWN:
599		✗	timestamp = 0;
600		✗	break;
601			}
602
603		✗	return timestamp;
604			}
605