bolt-device.c 21.5 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
 * Copyright © 2017 Red Hat, Inc
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 *
 * Authors:
 *       Christian J. Kellner <christian@kellner.me>
 */

#include "config.h"

23
#include "bolt-dbus.h"
24
#include "bolt-device.h"
25
#include "bolt-enums.h"
26
#include "bolt-error.h"
27
#include "bolt-io.h"
28
#include "bolt-manager.h"
29
#include "bolt-store.h"
30

31
#include <dirent.h>
32
33
#include <libudev.h>

34
35
36
37
38
/* dbus method calls */
static gboolean    handle_authorize (BoltDBusDevice        *object,
                                     GDBusMethodInvocation *invocation,
                                     gpointer               user_data);

39
40
41
42
43

static gboolean    handle_forget (BoltDBusDevice        *object,
                                  GDBusMethodInvocation *invocation,
                                  gpointer               user_data);

44
45
46
47
struct _BoltDevice
{
  BoltDBusDeviceSkeleton object;

48
49
  /* weak reference */
  BoltManager *mgr;
50

51
52
53
54
55
  char        *dbus_path;

  char        *uid;
  char        *name;
  char        *vendor;
56

57
58
  BoltStatus   status;

59
  /* when device is attached */
60
61
  char        *syspath;
  BoltSecurity security;
62
  char        *parent;
63
64

  /* when device is stored */
65
  BoltStore   *store;
66
67
  BoltPolicy   policy;
  BoltKeyState key;
68
69
70
71
72
73
};


enum {
  PROP_0,

74
  PROP_MANAGER,
75
76
77
78
79
  PROP_STORE,

  PROP_LAST,

  /* overridden */
80
  PROP_UID,
81
82
  PROP_NAME,
  PROP_VENDOR,
83
  PROP_STATUS,
84

85
  PROP_PARENT,
86
  PROP_SYSFS,
87
  PROP_SECURITY,
88

89
90
91
  PROP_STORED,
  PROP_POLICY,
  PROP_HAVE_KEY,
92
93
};

94
static GParamSpec *props[PROP_LAST] = {NULL, };
95

96
97
98
99
100
101
102
enum {
  SIGNAL_STATUS_CHANGED,
  SIGNAL_LAST
};

static guint signals[SIGNAL_LAST] = {0};

103
104
105
106
107
108
109
110
111
G_DEFINE_TYPE (BoltDevice,
               bolt_device,
               BOLT_DBUS_TYPE_DEVICE_SKELETON)

static void
bolt_device_finalize (GObject *object)
{
  BoltDevice *dev = BOLT_DEVICE (object);

112
113
  g_clear_object (&dev->store);

114
115
  g_free (dev->dbus_path);

116
  g_free (dev->uid);
117
118
  g_free (dev->name);
  g_free (dev->vendor);
119
120

  g_free (dev->parent);
121
  g_free (dev->syspath);
122
123
124
125
126

  G_OBJECT_CLASS (bolt_device_parent_class)->finalize (object);
}

static void
127
bolt_device_init (BoltDevice *dev)
128
{
129
130
  g_signal_connect (dev, "handle-authorize",
                    G_CALLBACK (handle_authorize), NULL);
131
132
  g_signal_connect (dev, "handle-forget",
                    G_CALLBACK (handle_forget), NULL);
133
134
135
136
137
138
139
140
141
142
143
144
}

static void
bolt_device_get_property (GObject    *object,
                          guint       prop_id,
                          GValue     *value,
                          GParamSpec *pspec)
{
  BoltDevice *dev = BOLT_DEVICE (object);

  switch (prop_id)
    {
145
146
147
148
    case PROP_MANAGER:
      g_value_set_object (value, dev->mgr);
      break;

149
150
151
152
    case PROP_STORE:
      g_value_set_object (value, dev->store);
      break;

153
154
155
156
    case PROP_UID:
      g_value_set_string (value, dev->uid);
      break;

157
158
159
160
161
162
163
164
    case PROP_NAME:
      g_value_set_string (value, dev->name);
      break;

    case PROP_VENDOR:
      g_value_set_string (value, dev->vendor);
      break;

165
166
167
168
    case PROP_STATUS:
      g_value_set_uint (value, dev->status);
      break;

169
170
171
172
    case PROP_PARENT:
      g_value_set_string (value, dev->parent);
      break;

173
174
175
176
    case PROP_SYSFS:
      g_value_set_string (value, dev->syspath);
      break;

177
178
179
180
    case PROP_SECURITY:
      g_value_set_uint (value, dev->security);
      break;

181
    case PROP_STORED:
182
      g_value_set_boolean (value, dev->store != NULL);
183
184
185
186
187
188
189
190
191
192
      break;

    case PROP_POLICY:
      g_value_set_uint (value, dev->policy);
      break;

    case PROP_HAVE_KEY:
      g_value_set_uint (value, dev->key);
      break;

193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
bolt_device_set_property (GObject      *object,
                          guint         prop_id,
                          const GValue *value,
                          GParamSpec   *pspec)
{
  BoltDevice *dev = BOLT_DEVICE (object);

  switch (prop_id)
    {
208

209
210
211
212
213
214
215
    case PROP_MANAGER:
      g_return_if_fail (dev->mgr == NULL);
      dev->mgr = g_value_get_object (value);
      g_object_add_weak_pointer (G_OBJECT (dev->mgr),
                                 (gpointer *) &dev->mgr);
      break;

216
217
218
219
220
    case PROP_STORE:
      dev->store = g_value_dup_object (value);
      g_object_notify (object, "stored");
      break;

221
    case PROP_UID:
222
      g_return_if_fail (dev->uid == NULL);
223
224
225
      dev->uid = g_value_dup_string (value);
      break;

226
    case PROP_NAME:
227
      g_clear_pointer (&dev->name, g_free);
228
      dev->name = g_value_dup_string (value);
229
230
231
      break;

    case PROP_VENDOR:
232
      g_clear_pointer (&dev->vendor, g_free);
233
      dev->vendor = g_value_dup_string (value);
234
235
      break;

236
    case PROP_STATUS:
237
238
239
240
241
242
243
244
245
246
247
248
249
      {
        BoltStatus old = dev->status;
        BoltStatus now = g_value_get_uint (value);
        if (old == now)
          break;

        dev->status = now;
        g_signal_emit (dev,
                       signals[SIGNAL_STATUS_CHANGED],
                       0,
                       old);
        break;
      }
250

251
252
253
254
255
    case PROP_PARENT:
      g_clear_pointer (&dev->parent, g_free);
      dev->parent = g_value_dup_string (value);
      break;

256
    case PROP_SYSFS:
257
      g_clear_pointer (&dev->syspath, g_free);
258
259
      dev->syspath = g_value_dup_string (value);
      break;
260
261
262
263

    case PROP_SECURITY:
      dev->security = g_value_get_uint (value);
      break;
264

265
266
267
268
269
270
271
272
    case PROP_POLICY:
      dev->policy = g_value_get_uint (value);
      break;

    case PROP_HAVE_KEY:
      dev->key = g_value_get_uint (value);
      break;

273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}


static void
bolt_device_class_init (BoltDeviceClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->finalize = bolt_device_finalize;

  gobject_class->get_property = bolt_device_get_property;
  gobject_class->set_property = bolt_device_set_property;

289
290
291
292
293
294
295
  props[PROP_MANAGER] =
    g_param_spec_object ("manager",
                         NULL, NULL,
                         BOLT_TYPE_MANAGER,
                         G_PARAM_READWRITE |
                         G_PARAM_STATIC_NICK);

296
297
298
299
300
301
302
303
304
305
306
  props[PROP_STORE] =
    g_param_spec_object ("store",
                         NULL, NULL,
                         BOLT_TYPE_STORE,
                         G_PARAM_READWRITE |
                         G_PARAM_STATIC_NICK);

  g_object_class_install_properties (gobject_class,
                                     PROP_LAST,
                                     props);

307
308
309
  g_object_class_override_property (gobject_class,
                                    PROP_UID,
                                    "uid");
310
311
312
313
314
315
316
317
318

  g_object_class_override_property (gobject_class,
                                    PROP_NAME,
                                    "name");

  g_object_class_override_property (gobject_class,
                                    PROP_VENDOR,
                                    "vendor");

319
320
321
322
  g_object_class_override_property (gobject_class,
                                    PROP_STATUS,
                                    "status");

323
324
325
326
  g_object_class_override_property (gobject_class,
                                    PROP_PARENT,
                                    "parent");

327
328
329
330
  g_object_class_override_property (gobject_class,
                                    PROP_SYSFS,
                                    "sysfs-path");

331
332
333
334
  g_object_class_override_property (gobject_class,
                                    PROP_SECURITY,
                                    "security");

335
336
  g_object_class_override_property (gobject_class,
                                    PROP_STORED,
337
                                    "stored");
338
339
340
341
342
343
344
345
346

  g_object_class_override_property (gobject_class,
                                    PROP_POLICY,
                                    "policy");

  g_object_class_override_property (gobject_class,
                                    PROP_HAVE_KEY,
                                    "key");

347
348
349
350
351
352
353
354
355
356
357

  signals[SIGNAL_STATUS_CHANGED] =
    g_signal_new ("status-changed",
                  G_TYPE_FROM_CLASS (gobject_class),
                  G_SIGNAL_RUN_LAST,
                  0,
                  NULL, NULL,
                  NULL,
                  G_TYPE_NONE,
                  1, BOLT_TYPE_STATUS);

358
}
359
360
361

/* internal methods */

362
363
static const char *
read_sysattr_name (struct udev_device *udev, const char *attr, GError **error)
364
365
{
  g_autofree char *s = NULL;
366
  const char *v;
367
368

  s = g_strdup_printf ("%s_name", attr);
369
370
371
372
373
374
  v = udev_device_get_sysattr_value (udev, s);

  if (v != NULL)
    return v;

  v = udev_device_get_sysattr_value (udev, attr);
375

376
  if (v == NULL)
377
378
379
    g_set_error (error,
                 BOLT_ERROR, BOLT_ERROR_UDEV,
                 "failed to get sysfs attr: %s", attr);
380
381

  return v;
382
383
}

384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
static gint
read_sysfs_attr_int (struct udev_device *device, const char *attr)
{
  const char *str;
  char *end;
  gint64 val;

  str = udev_device_get_sysattr_value (device, attr);

  if (str == NULL)
    return 0;

  val = g_ascii_strtoull (str, &end, 0);

  if (str == end)
    return 0;

  if (val > G_MAXINT || val < G_MININT)
    {
      g_warning ("value read from sysfs outside of guint's range.");
      val = 0;
    }

  return (gint) val;
}

static gboolean
string_nonzero (const char *str)
{
  return str != NULL && str[0] != '\0';
}

416
417
418
419
420
421
422
423
424
425
426
427
static const char *
bolt_sysfs_get_parent_uid (struct udev_device *udev)
{
  struct udev_device *parent;
  const char *uid = NULL;

  parent = udev_device_get_parent (udev);
  if (parent)
    uid = udev_device_get_sysattr_value (parent, "unique_id");
  return uid;
}

428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
static BoltStatus
bolt_status_from_udev (struct udev_device *udev)
{
  gint authorized;
  const char *key;
  gboolean have_key;

  authorized = read_sysfs_attr_int (udev, "authorized");

  if (authorized == 2)
    return BOLT_STATUS_AUTHORIZED_SECURE;

  key = udev_device_get_sysattr_value (udev, "key");
  have_key = string_nonzero (key);

  if (authorized == 1)
    {
      if (have_key)
        return BOLT_STATUS_AUTHORIZED_NEWKEY;
      else
        return BOLT_STATUS_AUTHORIZED;
    }
  else if (authorized == 0 && have_key)
    {
      return BOLT_STATUS_AUTH_ERROR;
    }

  return BOLT_STATUS_CONNECTED;
}

458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502

static struct udev_device *
domain_for_device (struct udev_device *udev)
{
  struct udev_device *parent;
  gboolean found;

  found = FALSE;
  parent = udev;
  do
    {
      const char *name;
      parent = udev_device_get_parent (parent);
      if (!parent)
        break;

      name = udev_device_get_sysname (parent);
      found = g_str_has_prefix (name, "domain");

    }
  while (!found);

  return found ? parent : NULL;
}

static BoltSecurity
security_for_udev (struct udev_device *udev)
{
  struct udev_device *parent = NULL;
  const char *v;
  BoltSecurity s;

  parent = domain_for_device (udev);
  if (parent == NULL)
    {
      g_warning ("Failed to determine domain device");
      return BOLT_SECURITY_NONE;
    }

  v = udev_device_get_sysattr_value (parent, "security");
  s = bolt_security_from_string (v);

  return s;
}

503
504
505
506
/*  device authorization */

typedef struct
{
507
  BoltAuth *auth;
508
509

  /* the outer callback  */
510
511
  GAsyncReadyCallback callback;
  gpointer            user_data;
512
513
514
515
516
517
518
519
520

} AuthData;

static void
auth_data_free (gpointer data)
{
  AuthData *auth = data;

  g_debug ("freeing auth data");
521
  g_clear_object (&auth->auth);
522
523
524
  g_slice_free (AuthData, auth);
}

525
526
static gboolean
authorize_device_internal (BoltDevice *dev,
527
                           BoltAuth   *auth,
528
                           GError    **error)
529
530
{
  g_autoptr(DIR) devdir = NULL;
531
532
  BoltKey *key;
  BoltSecurity level;
533
534
  gboolean ok;

535
536
537
  key = bolt_auth_get_key (auth);
  level = bolt_auth_get_level (auth);

538
  devdir = bolt_opendir (dev->syspath, error);
539
  if (devdir == NULL)
540
    return FALSE;
541

542
  ok = bolt_verify_uid (dirfd (devdir), dev->uid, error);
543
  if (!ok)
544
545
    return FALSE;

546
  if (key)
547
    {
548
549
550
551
552
553
554
      int keyfd;

      g_debug ("[%s] writing key", dev->uid);
      keyfd = bolt_openat (dirfd (devdir), "key", O_WRONLY | O_CLOEXEC, error);
      if (keyfd < 0)
        return FALSE;

555
      ok = bolt_key_write_to (key, keyfd, &level, error);
556
557
558
      close (keyfd);
      if (!ok)
        return FALSE;
559
560
    }

561
  g_debug ("[%s] writing authorization", dev->uid);
562
563
  ok = bolt_write_char_at (dirfd (devdir),
                           "authorized",
564
                           level,
565
566
567
568
569
570
571
572
573
574
575
576
                           error);
  return ok;
}

static void
authorize_in_thread (GTask        *task,
                     gpointer      source,
                     gpointer      context,
                     GCancellable *cancellable)
{
  g_autoptr(GError) error = NULL;
  BoltDevice *dev = source;
577
578
  AuthData *auth_data = context;
  BoltAuth *auth = auth_data->auth;
579
580
581
  gboolean ok;

  ok = authorize_device_internal (dev, auth, &error);
582
583

  if (!ok)
584
585
586
    g_task_return_new_error (task, BOLT_ERROR, BOLT_ERROR_FAILED,
                             "failed to authorize device: %s",
                             error->message);
587
  else
588
    g_task_return_boolean (task, TRUE);
589
590
591
592
593
594
595
}

static void
authorize_thread_done (GObject      *object,
                       GAsyncResult *res,
                       gpointer      user_data)
{
596
  g_autoptr(GError) error = NULL;
597
598
  BoltDevice *dev = BOLT_DEVICE (object);
  GTask *task = G_TASK (res);
599
  BoltStatus status;
600
601
  AuthData *auth_data;
  BoltAuth *auth;
602
603
  gboolean ok;

604
605
606
  auth_data = g_task_get_task_data (task);
  auth = auth_data->auth;

607
608
  ok = g_task_propagate_boolean (task, &error);

609
  if (!ok)
610
    {
611
      status = BOLT_STATUS_AUTH_ERROR;
612
613
      g_object_set (dev, "status", status, NULL);
      bolt_auth_return_error (auth, &error);
614
615
    }

616
617
618
619
  if (auth_data->callback)
    auth_data->callback (G_OBJECT (dev),
                         G_ASYNC_RESULT (auth),
                         auth_data->user_data);
620
621
}

622
623
624
625
626
void
bolt_device_authorize (BoltDevice         *dev,
                       BoltAuth           *auth,
                       GAsyncReadyCallback callback,
                       gpointer            user_data)
627
628
629
630
{
  AuthData *auth_data;
  GTask *task;

631
632
  g_object_set (auth, "device", dev, NULL);

633
634
635
  if (dev->status != BOLT_STATUS_CONNECTED &&
      dev->status != BOLT_STATUS_AUTH_ERROR)
    {
636
637
      bolt_auth_return_new_error (auth, BOLT_ERROR, BOLT_ERROR_FAILED,
                                  "wrong device state: %u", dev->status);
638

639
640
      if (callback)
        callback (G_OBJECT (dev), G_ASYNC_RESULT (auth), user_data);
641

642
      return;
643
644
645
    }

  task = g_task_new (dev, NULL, authorize_thread_done, NULL);
646
647
648
  auth_data = g_slice_new (AuthData);
  auth_data->callback = callback;
  auth_data->user_data = user_data;
649
  auth_data->auth = g_object_ref (auth);
650
651
  g_task_set_task_data (task, auth_data, auth_data_free);

652
  g_object_set (dev, "status", BOLT_STATUS_AUTHORIZING, NULL);
653
654
655
656
657
658
659
660
661

  g_task_run_in_thread (task, authorize_in_thread);
  g_object_unref (task);
}


/* dbus methods */

static void
662
663
664
handle_authorize_done (GObject      *device,
                       GAsyncResult *res,
                       gpointer      user_data)
665
{
666
667
668
669
670
671
672
673
674
  GDBusMethodInvocation *inv;
  GError *error = NULL;
  BoltAuth *auth;
  BoltDevice *dev;
  gboolean ok;

  dev = BOLT_DEVICE (device);
  inv  = user_data;
  auth = BOLT_AUTH (res);
675

676
  ok = bolt_auth_check (auth, &error);
677
  if (ok)
678
    bolt_dbus_device_complete_authorize (BOLT_DBUS_DEVICE (dev), inv);
679
  else
680
    g_dbus_method_invocation_take_error (inv, error);
681
682
683
684
}

static gboolean
handle_authorize (BoltDBusDevice        *object,
685
                  GDBusMethodInvocation *inv,
686
687
688
689
                  gpointer               user_data)
{
  BoltDevice *dev = BOLT_DEVICE (object);
  GError *error = NULL;
690
691
692
  BoltAuth *auth;
  BoltSecurity level;
  BoltKey *key;
693

694
695
  level = dev->security;
  key = NULL;
696

697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
  if (level == BOLT_SECURITY_SECURE)
    {
      if (dev->key)
        key = bolt_store_get_key (dev->store, dev->uid, &error);
      else
        level = BOLT_SECURITY_USER;
    }

  if (level == BOLT_SECURITY_SECURE && key == NULL)
    {
      g_dbus_method_invocation_take_error (inv, error);
      return TRUE;
    }

  auth = bolt_auth_new (dev, level, key);
  bolt_device_authorize (dev, auth, handle_authorize_done, inv);
713
714
715
716

  return TRUE;
}

717
718
719
720
721
722
723
724
725
726
727
728
static gboolean
handle_forget (BoltDBusDevice        *object,
               GDBusMethodInvocation *inv,
               gpointer               user_data)
{
  g_autoptr(GError) key_err = NULL;
  g_autoptr(GError) dev_err = NULL;
  BoltDevice *dev;
  gboolean key_ok, dev_ok;

  dev = BOLT_DEVICE (object);

729
  key_ok = bolt_store_del_key (dev->store, dev->uid, &key_err);
730
731
732
  if (!key_ok && bolt_err_notfound (key_err))
    key_ok = TRUE;

733
  dev_ok = bolt_store_del_device (dev->store, dev->uid, &dev_err);
734
735
736
737
738
739
740
741
742
743
744
745
746

  g_debug ("[%s] forgetting: key: %d, dev: %d", dev->uid, key_ok, dev_ok);

  if (!dev_ok)
    g_dbus_method_invocation_take_error (inv, g_steal_pointer (&dev_err));
  else if (!key_ok)
    g_dbus_method_invocation_take_error (inv, g_steal_pointer (&key_err));
  else
    bolt_dbus_device_complete_forget (BOLT_DBUS_DEVICE (dev), inv);

  return TRUE;
}

747
748
749
/* public methods */

BoltDevice *
750
bolt_device_new_for_udev (struct udev_device *udev,
751
752
                          GError            **error)
{
753
754
755
756
  const char *uid;
  const char *name;
  const char *vendor;
  const char *syspath;
757
  const char *parent;
758
  BoltDevice *dev;
759

760
761
762
763
764
765
766
  uid = udev_device_get_sysattr_value (udev, "unique_id");
  if (udev == NULL)
    {
      g_set_error (error, BOLT_ERROR, BOLT_ERROR_UDEV,
                   "could not get unique_id for udev");
      return NULL;
    }
767

768
769
  syspath = udev_device_get_syspath (udev);
  g_return_val_if_fail (syspath != NULL, NULL);
770

771
  name = read_sysattr_name (udev, "device", error);
772
773
774
  if (name == NULL)
    return NULL;

775
  vendor = read_sysattr_name (udev, "vendor", error);
776
777
  if (vendor == NULL)
    return NULL;
778

779
  parent = bolt_sysfs_get_parent_uid (udev);
780
  dev = g_object_new (BOLT_TYPE_DEVICE,
781
782
783
784
                      "uid", uid,
                      "name", name,
                      "vendor", vendor,
                      "sysfs-path", syspath,
785
                      "parent", parent,
786
787
                      NULL);

788
  dev->status = bolt_status_from_udev (udev);
789
  dev->security = security_for_udev (udev);
790

791
792
793
  return dev;
}

794
const char *
795
796
797
798
bolt_device_export (BoltDevice      *device,
                    GDBusConnection *connection,
                    GError         **error)
{
799
  const char *path;
800
  gboolean ok;
801
802

  g_return_val_if_fail (BOLT_IS_DEVICE (device), FALSE);
803

804
  path = bolt_device_get_object_path (device);
805

806
807
808
809
810
  ok = g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (device),
                                         connection,
                                         path,
                                         error);
  return ok ? path : NULL;
811
812
813
814
815
816
817
}

void
bolt_device_unexport (BoltDevice *device)
{
  g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (device));
}
818

819
820
821
822
823
824

BoltStatus
bolt_device_connected (BoltDevice         *dev,
                       struct udev_device *udev)
{
  const char *syspath;
825
  const char *parent;
826
827
828
829
830
831
  BoltSecurity security;
  BoltStatus status;

  syspath = udev_device_get_syspath (udev);
  status = bolt_status_from_udev (udev);
  security = security_for_udev (udev);
832
  parent = bolt_sysfs_get_parent_uid (udev);
833
834

  g_object_set (G_OBJECT (dev),
835
                "parent", parent,
836
837
838
839
840
                "sysfs-path", syspath,
                "security", security,
                "status", status,
                NULL);

841
842
  g_debug ("[%s] parent is %s", dev->uid, dev->parent);

843
844
845
846
847
848
849
  return status;
}

BoltStatus
bolt_device_disconnected (BoltDevice *dev)
{
  g_object_set (G_OBJECT (dev),
850
                "parent", NULL,
851
852
853
854
855
856
857
858
859
860
861
                "sysfs-path", NULL,
                "security", BOLT_SECURITY_NONE,
                "status", BOLT_STATUS_DISCONNECTED,
                NULL);

  return dev->status;
}

gboolean
bolt_device_is_connected (BoltDevice *device)
{
862
  return bolt_status_is_connected (device->status);
863
864
}

865
866
867
868
869
870
871
872
873
874
875
876
877
BoltStatus
bolt_device_update_from_udev (BoltDevice         *dev,
                              struct udev_device *udev)
{
  BoltStatus status = bolt_status_from_udev (udev);

  g_object_set (G_OBJECT (dev),
                "status", status,
                NULL);

  return status;
}

878
BoltKeyState
879
880
881
882
883
bolt_device_get_key (BoltDevice *dev)
{
  return dev->key;
}

884
885
886
887
888
889
const char *
bolt_device_get_name (BoltDevice *dev)
{
  return dev->name;
}

890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
const char *
bolt_device_get_object_path (BoltDevice *device)
{
  g_return_val_if_fail (BOLT_IS_DEVICE (device), FALSE);

  if (device->dbus_path == NULL)
    {
      char *path = NULL;

      path = g_strdup_printf ("/org/freedesktop/Bolt/devices/%s", device->uid);
      g_strdelimit (path, "-", '_');

      device->dbus_path = path;
    }

  return device->dbus_path;
}
907

908
909
910
911
912
913
BoltPolicy
bolt_device_get_policy (BoltDevice *dev)
{
  return dev->policy;
}

914
915
916
917
918
919
const char *
bolt_device_get_uid (BoltDevice *dev)
{
  return dev->uid;
}

920
921
922
923
924
925
BoltSecurity
bolt_device_get_security (BoltDevice *dev)
{
  return dev->security;
}

Christian Kellner's avatar
Christian Kellner committed
926
927
928
929
930
931
BoltStatus
bolt_device_get_status (BoltDevice *dev)
{
  return dev->status;
}

932
933
gboolean
bolt_device_get_stored (BoltDevice *dev)
934
{
935
  return dev->store != NULL;
936
937
}

938
939
940
941
942
const char *
bolt_device_get_syspath (BoltDevice *dev)
{
  return dev->syspath;
}
943
944
945
946
947
948

const char *
bolt_device_get_vendor (BoltDevice *dev)
{
  return dev->vendor;
}