bolt-device.c 20.9 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
#include "bolt-str.h"
31

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

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

40

41
42
43
44
struct _BoltDevice
{
  BoltDBusDeviceSkeleton object;

45
46
  /* weak reference */
  BoltManager *mgr;
47

48
49
50
51
52
  char        *dbus_path;

  char        *uid;
  char        *name;
  char        *vendor;
53

54
55
  BoltStatus   status;

56
  /* when device is attached */
57
58
  char        *syspath;
  BoltSecurity security;
59
  char        *parent;
60
61

  /* when device is stored */
62
  BoltStore   *store;
63
64
  BoltPolicy   policy;
  BoltKeyState key;
65
66
67
68
69
70
};


enum {
  PROP_0,

71
  PROP_MANAGER,
72
73
74
75
76
  PROP_STORE,

  PROP_LAST,

  /* overridden */
77
  PROP_UID,
78
79
  PROP_NAME,
  PROP_VENDOR,
80
  PROP_STATUS,
81

82
  PROP_PARENT,
83
  PROP_SYSFS,
84
  PROP_SECURITY,
85

86
87
88
  PROP_STORED,
  PROP_POLICY,
  PROP_HAVE_KEY,
89
90
};

91
static GParamSpec *props[PROP_LAST] = {NULL, };
92

93
94
95
96
97
98
99
enum {
  SIGNAL_STATUS_CHANGED,
  SIGNAL_LAST
};

static guint signals[SIGNAL_LAST] = {0};

100
101
102
103
104
105
106
107
108
G_DEFINE_TYPE (BoltDevice,
               bolt_device,
               BOLT_DBUS_TYPE_DEVICE_SKELETON)

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

109
110
  g_clear_object (&dev->store);

111
112
  g_free (dev->dbus_path);

113
  g_free (dev->uid);
114
115
  g_free (dev->name);
  g_free (dev->vendor);
116
117

  g_free (dev->parent);
118
  g_free (dev->syspath);
119

120
121
122
123
124
125
126
  if (dev->mgr)
    {
      g_object_remove_weak_pointer (G_OBJECT (dev->mgr),
                                    (gpointer *) &dev->mgr);
      dev->mgr = NULL;
    }

127
128
129
130
  G_OBJECT_CLASS (bolt_device_parent_class)->finalize (object);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
    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)
    {
210

211
212
213
214
215
216
217
    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;

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

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

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

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

238
    case PROP_STATUS:
239
240
241
242
243
244
245
246
247
248
249
250
251
      {
        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;
      }
252

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

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

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

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

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

275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
    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;

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

298
299
300
301
302
303
304
305
306
307
308
  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);

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

  g_object_class_override_property (gobject_class,
                                    PROP_NAME,
                                    "name");

  g_object_class_override_property (gobject_class,
                                    PROP_VENDOR,
                                    "vendor");

321
322
323
324
  g_object_class_override_property (gobject_class,
                                    PROP_STATUS,
                                    "status");

325
326
327
328
  g_object_class_override_property (gobject_class,
                                    PROP_PARENT,
                                    "parent");

329
330
331
332
  g_object_class_override_property (gobject_class,
                                    PROP_SYSFS,
                                    "sysfs-path");

333
334
335
336
  g_object_class_override_property (gobject_class,
                                    PROP_SECURITY,
                                    "security");

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

  g_object_class_override_property (gobject_class,
                                    PROP_POLICY,
                                    "policy");

  g_object_class_override_property (gobject_class,
                                    PROP_HAVE_KEY,
                                    "key");

349
350
351
352
353
354
355
356
357
358
359

  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);

360
}
361
362
363

/* internal methods */

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

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

  if (v != NULL)
    return v;

  v = udev_device_get_sysattr_value (udev, attr);
377

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

  return v;
384
385
}

386
387
388
389
390
391
392
393
394
395
396
397
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;

398
  val = g_ascii_strtoll (str, &end, 0);
399
400
401
402
403
404

  if (str == end)
    return 0;

  if (val > G_MAXINT || val < G_MININT)
    {
405
      g_warning ("value read from sysfs outside of gint's range.");
406
407
408
409
410
411
412
413
414
415
416
417
      val = 0;
    }

  return (gint) val;
}

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

418
419
420
421
422
423
424
425
426
427
428
429
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;
}

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
458
459
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;
}

460
461

static struct udev_device *
462
bolt_sysfs_domain_for_device (struct udev_device *udev)
463
464
465
466
467
468
469
470
{
  struct udev_device *parent;
  gboolean found;

  found = FALSE;
  parent = udev;
  do
    {
471
      const char *devtype;
472
473
474
475
      parent = udev_device_get_parent (parent);
      if (!parent)
        break;

476
477
      devtype = udev_device_get_devtype (parent);
      found = bolt_streq (devtype, "thunderbolt_domain");
478
479
480
481
482
483
484
485

    }
  while (!found);

  return found ? parent : NULL;
}

static BoltSecurity
486
bolt_sysfs_security_for_device (struct udev_device *udev)
487
488
489
490
491
{
  struct udev_device *parent = NULL;
  const char *v;
  BoltSecurity s;

492
  parent = bolt_sysfs_domain_for_device (udev);
493
494
495
496
497
498
499
500
501
502
503
504
  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;
}

505
506
507
508
/*  device authorization */

typedef struct
{
509
  BoltAuth *auth;
510
511

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

} AuthData;

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

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

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

537
538
539
  key = bolt_auth_get_key (auth);
  level = bolt_auth_get_level (auth);

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

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

548
  if (key)
549
    {
550
551
552
553
554
555
556
      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;

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

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

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

  ok = authorize_device_internal (dev, auth, &error);
584
585

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

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

606
607
608
  auth_data = g_task_get_task_data (task);
  auth = auth_data->auth;

609
610
  ok = g_task_propagate_boolean (task, &error);

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

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

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

633
634
  g_object_set (auth, "device", dev, NULL);

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

641
642
      if (callback)
        callback (G_OBJECT (dev), G_ASYNC_RESULT (auth), user_data);
643

644
      return;
645
646
647
    }

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

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

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


/* dbus methods */

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

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

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

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

696
697
  level = dev->security;
  key = NULL;
698

699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
  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);
715
716
717
718

  return TRUE;
}

719
720
721
/* public methods */

BoltDevice *
722
bolt_device_new_for_udev (struct udev_device *udev,
723
724
                          GError            **error)
{
725
726
727
728
  const char *uid;
  const char *name;
  const char *vendor;
  const char *syspath;
729
  const char *parent;
730
  BoltDevice *dev;
731

732
733
734
735
736
737
738
  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;
    }
739

740
741
  syspath = udev_device_get_syspath (udev);
  g_return_val_if_fail (syspath != NULL, NULL);
742

743
  name = read_sysattr_name (udev, "device", error);
744
745
746
  if (name == NULL)
    return NULL;

747
  vendor = read_sysattr_name (udev, "vendor", error);
748
749
  if (vendor == NULL)
    return NULL;
750

751
  parent = bolt_sysfs_get_parent_uid (udev);
752
  dev = g_object_new (BOLT_TYPE_DEVICE,
753
754
755
756
                      "uid", uid,
                      "name", name,
                      "vendor", vendor,
                      "sysfs-path", syspath,
757
                      "parent", parent,
758
759
                      NULL);

760
  dev->status = bolt_status_from_udev (udev);
761
  dev->security = bolt_sysfs_security_for_device (udev);
762

763
764
765
  return dev;
}

766
const char *
767
768
769
770
bolt_device_export (BoltDevice      *device,
                    GDBusConnection *connection,
                    GError         **error)
{
771
  const char *path;
772
  gboolean ok;
773
774

  g_return_val_if_fail (BOLT_IS_DEVICE (device), FALSE);
775

776
  path = bolt_device_get_object_path (device);
777

778
779
780
781
782
  ok = g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (device),
                                         connection,
                                         path,
                                         error);
  return ok ? path : NULL;
783
784
785
786
787
788
789
}

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

791
792
793
794
795
796

BoltStatus
bolt_device_connected (BoltDevice         *dev,
                       struct udev_device *udev)
{
  const char *syspath;
797
  const char *parent;
798
799
800
801
802
  BoltSecurity security;
  BoltStatus status;

  syspath = udev_device_get_syspath (udev);
  status = bolt_status_from_udev (udev);
803
  security = bolt_sysfs_security_for_device (udev);
804
  parent = bolt_sysfs_get_parent_uid (udev);
805
806

  g_object_set (G_OBJECT (dev),
807
                "parent", parent,
808
809
810
811
812
                "sysfs-path", syspath,
                "security", security,
                "status", status,
                NULL);

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

815
816
817
818
819
820
821
  return status;
}

BoltStatus
bolt_device_disconnected (BoltDevice *dev)
{
  g_object_set (G_OBJECT (dev),
822
                "parent", NULL,
823
824
825
826
827
                "sysfs-path", NULL,
                "security", BOLT_SECURITY_NONE,
                "status", BOLT_STATUS_DISCONNECTED,
                NULL);

828
829
830
831
832
833
834
835
836
837
  /* check if we have a new key for the device, and
   * if so, change its state to KEY_HAVE, because
   * now it is not new anymore.
   */
  if (dev->key == BOLT_KEY_NEW)
    {
      dev->key = BOLT_KEY_HAVE;
      g_object_notify (G_OBJECT (dev), "key");
    }

838
839
840
841
842
843
  return dev->status;
}

gboolean
bolt_device_is_connected (BoltDevice *device)
{
844
  return bolt_status_is_connected (device->status);
845
846
}

847
848
849
850
851
852
853
854
855
856
857
858
859
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;
}

860
BoltKeyState
861
bolt_device_get_keystate (BoltDevice *dev)
862
863
864
865
{
  return dev->key;
}

866
867
868
869
870
871
const char *
bolt_device_get_name (BoltDevice *dev)
{
  return dev->name;
}

872
873
874
875
876
877
878
879
880
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;

881
      path = g_strdup_printf (BOLT_DBUS_PATH "/devices/%s", device->uid);
882
883
884
885
886
887
888
      g_strdelimit (path, "-", '_');

      device->dbus_path = path;
    }

  return device->dbus_path;
}
889

890
891
892
893
894
895
BoltPolicy
bolt_device_get_policy (BoltDevice *dev)
{
  return dev->policy;
}

896
897
898
899
900
901
const char *
bolt_device_get_uid (BoltDevice *dev)
{
  return dev->uid;
}

902
903
904
905
906
907
BoltSecurity
bolt_device_get_security (BoltDevice *dev)
{
  return dev->security;
}

Christian Kellner's avatar
Christian Kellner committed
908
909
910
911
912
913
BoltStatus
bolt_device_get_status (BoltDevice *dev)
{
  return dev->status;
}

914
915
gboolean
bolt_device_get_stored (BoltDevice *dev)
916
{
917
  return dev->store != NULL;
918
919
}

920
921
922
923
924
const char *
bolt_device_get_syspath (BoltDevice *dev)
{
  return dev->syspath;
}
925
926
927
928
929
930

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