bolt-device.c 21 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
  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);

502 503 504 505 506 507
  if (!bolt_security_validate (s))
    {
      g_warning ("invalid security: %s", v);
      s = BOLT_SECURITY_NONE;
    }

508 509 510
  return s;
}

511 512 513 514
/*  device authorization */

typedef struct
{
515
  BoltAuth *auth;
516 517

  /* the outer callback  */
518 519
  GAsyncReadyCallback callback;
  gpointer            user_data;
520 521 522 523 524 525 526 527 528

} AuthData;

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

  g_debug ("freeing auth data");
529
  g_clear_object (&auth->auth);
530 531 532
  g_slice_free (AuthData, auth);
}

533 534
static gboolean
authorize_device_internal (BoltDevice *dev,
535
                           BoltAuth   *auth,
536
                           GError    **error)
537 538
{
  g_autoptr(DIR) devdir = NULL;
539 540
  BoltKey *key;
  BoltSecurity level;
541 542
  gboolean ok;

543 544 545
  key = bolt_auth_get_key (auth);
  level = bolt_auth_get_level (auth);

546
  devdir = bolt_opendir (dev->syspath, error);
547
  if (devdir == NULL)
548
    return FALSE;
549

550
  ok = bolt_verify_uid (dirfd (devdir), dev->uid, error);
551
  if (!ok)
552 553
    return FALSE;

554
  if (key)
555
    {
556 557 558 559 560 561 562
      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;

563
      ok = bolt_key_write_to (key, keyfd, &level, error);
564 565 566
      close (keyfd);
      if (!ok)
        return FALSE;
567 568
    }

569
  g_debug ("[%s] writing authorization", dev->uid);
570 571
  ok = bolt_write_char_at (dirfd (devdir),
                           "authorized",
572
                           level,
573 574 575 576 577 578 579 580 581 582 583 584
                           error);
  return ok;
}

static void
authorize_in_thread (GTask        *task,
                     gpointer      source,
                     gpointer      context,
                     GCancellable *cancellable)
{
  g_autoptr(GError) error = NULL;
  BoltDevice *dev = source;
585 586
  AuthData *auth_data = context;
  BoltAuth *auth = auth_data->auth;
587 588 589
  gboolean ok;

  ok = authorize_device_internal (dev, auth, &error);
590 591

  if (!ok)
592 593 594
    g_task_return_new_error (task, BOLT_ERROR, BOLT_ERROR_FAILED,
                             "failed to authorize device: %s",
                             error->message);
595
  else
596
    g_task_return_boolean (task, TRUE);
597 598 599 600 601 602 603
}

static void
authorize_thread_done (GObject      *object,
                       GAsyncResult *res,
                       gpointer      user_data)
{
604
  g_autoptr(GError) error = NULL;
605 606
  BoltDevice *dev = BOLT_DEVICE (object);
  GTask *task = G_TASK (res);
607
  BoltStatus status;
608 609
  AuthData *auth_data;
  BoltAuth *auth;
610 611
  gboolean ok;

612 613 614
  auth_data = g_task_get_task_data (task);
  auth = auth_data->auth;

615 616
  ok = g_task_propagate_boolean (task, &error);

617
  if (!ok)
618
    {
619
      status = BOLT_STATUS_AUTH_ERROR;
620 621
      g_object_set (dev, "status", status, NULL);
      bolt_auth_return_error (auth, &error);
622 623
    }

624 625 626 627
  if (auth_data->callback)
    auth_data->callback (G_OBJECT (dev),
                         G_ASYNC_RESULT (auth),
                         auth_data->user_data);
628 629
}

630 631 632 633 634
void
bolt_device_authorize (BoltDevice         *dev,
                       BoltAuth           *auth,
                       GAsyncReadyCallback callback,
                       gpointer            user_data)
635 636 637 638
{
  AuthData *auth_data;
  GTask *task;

639 640
  g_object_set (auth, "device", dev, NULL);

641 642 643
  if (dev->status != BOLT_STATUS_CONNECTED &&
      dev->status != BOLT_STATUS_AUTH_ERROR)
    {
644 645
      bolt_auth_return_new_error (auth, BOLT_ERROR, BOLT_ERROR_FAILED,
                                  "wrong device state: %u", dev->status);
646

647 648
      if (callback)
        callback (G_OBJECT (dev), G_ASYNC_RESULT (auth), user_data);
649

650
      return;
651 652 653
    }

  task = g_task_new (dev, NULL, authorize_thread_done, NULL);
654 655 656
  auth_data = g_slice_new (AuthData);
  auth_data->callback = callback;
  auth_data->user_data = user_data;
657
  auth_data->auth = g_object_ref (auth);
658 659
  g_task_set_task_data (task, auth_data, auth_data_free);

660
  g_object_set (dev, "status", BOLT_STATUS_AUTHORIZING, NULL);
661 662 663 664 665 666 667 668 669

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


/* dbus methods */

static void
670 671 672
handle_authorize_done (GObject      *device,
                       GAsyncResult *res,
                       gpointer      user_data)
673
{
674 675 676 677 678 679 680 681 682
  GDBusMethodInvocation *inv;
  GError *error = NULL;
  BoltAuth *auth;
  BoltDevice *dev;
  gboolean ok;

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

684
  ok = bolt_auth_check (auth, &error);
685
  if (ok)
686
    bolt_dbus_device_complete_authorize (BOLT_DBUS_DEVICE (dev), inv);
687
  else
688
    g_dbus_method_invocation_take_error (inv, error);
689 690 691 692
}

static gboolean
handle_authorize (BoltDBusDevice        *object,
693
                  GDBusMethodInvocation *inv,
694 695 696 697
                  gpointer               user_data)
{
  BoltDevice *dev = BOLT_DEVICE (object);
  GError *error = NULL;
698 699 700
  BoltAuth *auth;
  BoltSecurity level;
  BoltKey *key;
701

702 703
  level = dev->security;
  key = NULL;
704

705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720
  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);
721 722 723 724

  return TRUE;
}

725 726 727
/* public methods */

BoltDevice *
728
bolt_device_new_for_udev (struct udev_device *udev,
729 730
                          GError            **error)
{
731 732 733 734
  const char *uid;
  const char *name;
  const char *vendor;
  const char *syspath;
735
  const char *parent;
736
  BoltDevice *dev;
737

738 739 740 741 742 743 744
  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;
    }
745

746 747
  syspath = udev_device_get_syspath (udev);
  g_return_val_if_fail (syspath != NULL, NULL);
748

749
  name = read_sysattr_name (udev, "device", error);
750 751 752
  if (name == NULL)
    return NULL;

753
  vendor = read_sysattr_name (udev, "vendor", error);
754 755
  if (vendor == NULL)
    return NULL;
756

757
  parent = bolt_sysfs_get_parent_uid (udev);
758
  dev = g_object_new (BOLT_TYPE_DEVICE,
759 760 761 762
                      "uid", uid,
                      "name", name,
                      "vendor", vendor,
                      "sysfs-path", syspath,
763
                      "parent", parent,
764 765
                      NULL);

766
  dev->status = bolt_status_from_udev (udev);
767
  dev->security = bolt_sysfs_security_for_device (udev);
768

769 770 771
  return dev;
}

772
const char *
773 774 775 776
bolt_device_export (BoltDevice      *device,
                    GDBusConnection *connection,
                    GError         **error)
{
777
  const char *path;
778
  gboolean ok;
779 780

  g_return_val_if_fail (BOLT_IS_DEVICE (device), FALSE);
781

782
  path = bolt_device_get_object_path (device);
783

784 785 786 787 788
  ok = g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (device),
                                         connection,
                                         path,
                                         error);
  return ok ? path : NULL;
789 790 791 792 793 794 795
}

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

797 798 799 800 801 802

BoltStatus
bolt_device_connected (BoltDevice         *dev,
                       struct udev_device *udev)
{
  const char *syspath;
803
  const char *parent;
804 805 806 807 808
  BoltSecurity security;
  BoltStatus status;

  syspath = udev_device_get_syspath (udev);
  status = bolt_status_from_udev (udev);
809
  security = bolt_sysfs_security_for_device (udev);
810
  parent = bolt_sysfs_get_parent_uid (udev);
811 812

  g_object_set (G_OBJECT (dev),
813
                "parent", parent,
814 815 816 817 818
                "sysfs-path", syspath,
                "security", security,
                "status", status,
                NULL);

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

821 822 823 824 825 826 827
  return status;
}

BoltStatus
bolt_device_disconnected (BoltDevice *dev)
{
  g_object_set (G_OBJECT (dev),
828
                "parent", NULL,
829 830 831 832 833
                "sysfs-path", NULL,
                "security", BOLT_SECURITY_NONE,
                "status", BOLT_STATUS_DISCONNECTED,
                NULL);

834 835 836 837 838 839 840 841 842 843
  /* 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");
    }

844 845 846 847 848 849
  return dev->status;
}

gboolean
bolt_device_is_connected (BoltDevice *device)
{
850
  return bolt_status_is_connected (device->status);
851 852
}

853 854 855 856 857 858 859 860 861 862 863 864 865
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;
}

866
BoltKeyState
867
bolt_device_get_keystate (BoltDevice *dev)
868 869 870 871
{
  return dev->key;
}

872 873 874 875 876 877
const char *
bolt_device_get_name (BoltDevice *dev)
{
  return dev->name;
}

878 879 880 881 882 883 884 885 886
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;

887
      path = g_strdup_printf (BOLT_DBUS_PATH "/devices/%s", device->uid);
888 889 890 891 892 893 894
      g_strdelimit (path, "-", '_');

      device->dbus_path = path;
    }

  return device->dbus_path;
}
895

896 897 898 899 900 901
BoltPolicy
bolt_device_get_policy (BoltDevice *dev)
{
  return dev->policy;
}

902 903 904 905 906 907
const char *
bolt_device_get_uid (BoltDevice *dev)
{
  return dev->uid;
}

908 909 910 911 912 913
BoltSecurity
bolt_device_get_security (BoltDevice *dev)
{
  return dev->security;
}

Christian Kellner's avatar
Christian Kellner committed
914 915 916 917 918 919
BoltStatus
bolt_device_get_status (BoltDevice *dev)
{
  return dev->status;
}

920 921
gboolean
bolt_device_get_stored (BoltDevice *dev)
922
{
923
  return dev->store != NULL;
924 925
}

926 927 928 929 930
const char *
bolt_device_get_syspath (BoltDevice *dev)
{
  return dev->syspath;
}
931 932 933 934 935 936

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