bolt-device.c 22.4 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
    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);
207
  GParamSpec *parent;
208 209 210

  switch (prop_id)
    {
211

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

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

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

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

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

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

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

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

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

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

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

276 277 278
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312

  /* This is one gross hack to make the DBus property change
   * signal emission work.
   *   The heart "problem" is a combination of two things:
   *   1) the dbus object properties are override here,
   *      which means the property setter from the parent
   *      (the dbus skeleton) will not be called.
   *   2) The dbus skeleton will only emit the signal on the
   *      bus if it finds that the value has changed, which
   *      it can only detect if its property setter was called
   *   => We need to call the skeleton's set_property function
   *      from here, so it can detect property changes itself.
   */

  /* all properties below PROP_LAST are our own, non-dbus props */
  if (prop_id < PROP_LAST)
    return;

  /* we need to original GParamSpec, since the one we got is
   * the new, overridden one */
  parent = g_object_class_find_property (bolt_device_parent_class,
                                         pspec->name);
  if (parent == NULL)
    return;

  /* the prop_id is *our* prop_id, not the parent's prop_id, which
   * we need. For this to work our property list *after* PROP_LAST
   * need to be in sync with the parent */
  prop_id -= PROP_LAST;

  G_OBJECT_CLASS (bolt_device_parent_class)->set_property (object,
                                                           prop_id,
                                                           value,
                                                           parent);
313 314 315 316 317 318 319 320 321 322 323 324 325
}


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;

326 327 328 329 330 331 332
  props[PROP_MANAGER] =
    g_param_spec_object ("manager",
                         NULL, NULL,
                         BOLT_TYPE_MANAGER,
                         G_PARAM_READWRITE |
                         G_PARAM_STATIC_NICK);

333 334 335 336 337 338 339 340 341 342 343
  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);

344 345 346
  g_object_class_override_property (gobject_class,
                                    PROP_UID,
                                    "uid");
347 348 349 350 351 352 353 354 355

  g_object_class_override_property (gobject_class,
                                    PROP_NAME,
                                    "name");

  g_object_class_override_property (gobject_class,
                                    PROP_VENDOR,
                                    "vendor");

356 357 358 359
  g_object_class_override_property (gobject_class,
                                    PROP_STATUS,
                                    "status");

360 361 362 363
  g_object_class_override_property (gobject_class,
                                    PROP_PARENT,
                                    "parent");

364 365 366 367
  g_object_class_override_property (gobject_class,
                                    PROP_SYSFS,
                                    "sysfs-path");

368 369 370 371
  g_object_class_override_property (gobject_class,
                                    PROP_SECURITY,
                                    "security");

372 373
  g_object_class_override_property (gobject_class,
                                    PROP_STORED,
374
                                    "stored");
375 376 377 378 379 380 381 382 383

  g_object_class_override_property (gobject_class,
                                    PROP_POLICY,
                                    "policy");

  g_object_class_override_property (gobject_class,
                                    PROP_HAVE_KEY,
                                    "key");

384 385 386 387 388 389 390 391 392 393 394

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

395
}
396 397 398

/* internal methods */

399 400
static const char *
read_sysattr_name (struct udev_device *udev, const char *attr, GError **error)
401 402
{
  g_autofree char *s = NULL;
403
  const char *v;
404 405

  s = g_strdup_printf ("%s_name", attr);
406 407 408 409 410 411
  v = udev_device_get_sysattr_value (udev, s);

  if (v != NULL)
    return v;

  v = udev_device_get_sysattr_value (udev, attr);
412

413
  if (v == NULL)
414 415 416
    g_set_error (error,
                 BOLT_ERROR, BOLT_ERROR_UDEV,
                 "failed to get sysfs attr: %s", attr);
417 418

  return v;
419 420
}

421 422 423 424 425 426 427 428 429 430 431 432
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;

433
  val = g_ascii_strtoll (str, &end, 0);
434 435 436 437 438 439

  if (str == end)
    return 0;

  if (val > G_MAXINT || val < G_MININT)
    {
440
      g_warning ("value read from sysfs outside of gint's range.");
441 442 443 444 445 446 447 448 449 450 451 452
      val = 0;
    }

  return (gint) val;
}

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

453 454 455 456 457 458 459 460 461 462 463 464
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;
}

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

495 496

static struct udev_device *
497
bolt_sysfs_domain_for_device (struct udev_device *udev)
498 499 500 501 502 503 504 505
{
  struct udev_device *parent;
  gboolean found;

  found = FALSE;
  parent = udev;
  do
    {
506
      const char *devtype;
507 508 509 510
      parent = udev_device_get_parent (parent);
      if (!parent)
        break;

511 512
      devtype = udev_device_get_devtype (parent);
      found = bolt_streq (devtype, "thunderbolt_domain");
513 514 515 516 517 518 519 520

    }
  while (!found);

  return found ? parent : NULL;
}

static BoltSecurity
521
bolt_sysfs_security_for_device (struct udev_device *udev)
522 523 524 525 526
{
  struct udev_device *parent = NULL;
  const char *v;
  BoltSecurity s;

527
  parent = bolt_sysfs_domain_for_device (udev);
528 529 530 531 532 533 534 535 536
  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);

537 538 539 540 541 542
  if (!bolt_security_validate (s))
    {
      g_warning ("invalid security: %s", v);
      s = BOLT_SECURITY_NONE;
    }

543 544 545
  return s;
}

546 547 548 549
/*  device authorization */

typedef struct
{
550
  BoltAuth *auth;
551 552

  /* the outer callback  */
553 554
  GAsyncReadyCallback callback;
  gpointer            user_data;
555 556 557 558 559 560 561 562 563

} AuthData;

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

  g_debug ("freeing auth data");
564
  g_clear_object (&auth->auth);
565 566 567
  g_slice_free (AuthData, auth);
}

568 569
static gboolean
authorize_device_internal (BoltDevice *dev,
570
                           BoltAuth   *auth,
571
                           GError    **error)
572 573
{
  g_autoptr(DIR) devdir = NULL;
574 575
  BoltKey *key;
  BoltSecurity level;
576 577
  gboolean ok;

578 579 580
  key = bolt_auth_get_key (auth);
  level = bolt_auth_get_level (auth);

581
  devdir = bolt_opendir (dev->syspath, error);
582
  if (devdir == NULL)
583
    return FALSE;
584

585
  ok = bolt_verify_uid (dirfd (devdir), dev->uid, error);
586
  if (!ok)
587 588
    return FALSE;

589
  if (key)
590
    {
591 592 593 594 595 596 597
      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;

598
      ok = bolt_key_write_to (key, keyfd, &level, error);
599 600 601
      close (keyfd);
      if (!ok)
        return FALSE;
602 603
    }

604
  g_debug ("[%s] writing authorization", dev->uid);
605 606
  ok = bolt_write_char_at (dirfd (devdir),
                           "authorized",
607
                           level,
608 609 610 611 612 613 614 615 616 617 618 619
                           error);
  return ok;
}

static void
authorize_in_thread (GTask        *task,
                     gpointer      source,
                     gpointer      context,
                     GCancellable *cancellable)
{
  g_autoptr(GError) error = NULL;
  BoltDevice *dev = source;
620 621
  AuthData *auth_data = context;
  BoltAuth *auth = auth_data->auth;
622 623 624
  gboolean ok;

  ok = authorize_device_internal (dev, auth, &error);
625 626

  if (!ok)
627 628 629
    g_task_return_new_error (task, BOLT_ERROR, BOLT_ERROR_FAILED,
                             "failed to authorize device: %s",
                             error->message);
630
  else
631
    g_task_return_boolean (task, TRUE);
632 633 634 635 636 637 638
}

static void
authorize_thread_done (GObject      *object,
                       GAsyncResult *res,
                       gpointer      user_data)
{
639
  g_autoptr(GError) error = NULL;
640 641
  BoltDevice *dev = BOLT_DEVICE (object);
  GTask *task = G_TASK (res);
642
  BoltStatus status;
643 644
  AuthData *auth_data;
  BoltAuth *auth;
645 646
  gboolean ok;

647 648 649
  auth_data = g_task_get_task_data (task);
  auth = auth_data->auth;

650 651
  ok = g_task_propagate_boolean (task, &error);

652
  if (!ok)
653
    {
654
      status = BOLT_STATUS_AUTH_ERROR;
655 656
      g_object_set (dev, "status", status, NULL);
      bolt_auth_return_error (auth, &error);
657 658
    }

659 660 661 662
  if (auth_data->callback)
    auth_data->callback (G_OBJECT (dev),
                         G_ASYNC_RESULT (auth),
                         auth_data->user_data);
663 664
}

665 666 667 668 669
void
bolt_device_authorize (BoltDevice         *dev,
                       BoltAuth           *auth,
                       GAsyncReadyCallback callback,
                       gpointer            user_data)
670 671 672 673
{
  AuthData *auth_data;
  GTask *task;

674 675
  g_object_set (auth, "device", dev, NULL);

676 677 678
  if (dev->status != BOLT_STATUS_CONNECTED &&
      dev->status != BOLT_STATUS_AUTH_ERROR)
    {
679 680
      bolt_auth_return_new_error (auth, BOLT_ERROR, BOLT_ERROR_FAILED,
                                  "wrong device state: %u", dev->status);
681

682 683
      if (callback)
        callback (G_OBJECT (dev), G_ASYNC_RESULT (auth), user_data);
684

685
      return;
686 687 688
    }

  task = g_task_new (dev, NULL, authorize_thread_done, NULL);
689 690 691
  auth_data = g_slice_new (AuthData);
  auth_data->callback = callback;
  auth_data->user_data = user_data;
692
  auth_data->auth = g_object_ref (auth);
693 694
  g_task_set_task_data (task, auth_data, auth_data_free);

695
  g_object_set (dev, "status", BOLT_STATUS_AUTHORIZING, NULL);
696 697 698 699 700 701 702 703 704

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


/* dbus methods */

static void
705 706 707
handle_authorize_done (GObject      *device,
                       GAsyncResult *res,
                       gpointer      user_data)
708
{
709 710 711 712 713 714 715 716 717
  GDBusMethodInvocation *inv;
  GError *error = NULL;
  BoltAuth *auth;
  BoltDevice *dev;
  gboolean ok;

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

719
  ok = bolt_auth_check (auth, &error);
720
  if (ok)
721
    bolt_dbus_device_complete_authorize (BOLT_DBUS_DEVICE (dev), inv);
722
  else
723
    g_dbus_method_invocation_take_error (inv, error);
724 725 726 727
}

static gboolean
handle_authorize (BoltDBusDevice        *object,
728
                  GDBusMethodInvocation *inv,
729 730 731 732
                  gpointer               user_data)
{
  BoltDevice *dev = BOLT_DEVICE (object);
  GError *error = NULL;
733 734 735
  BoltAuth *auth;
  BoltSecurity level;
  BoltKey *key;
736

737 738
  level = dev->security;
  key = NULL;
739

740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
  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);
756 757 758 759

  return TRUE;
}

760 761 762
/* public methods */

BoltDevice *
763
bolt_device_new_for_udev (struct udev_device *udev,
764 765
                          GError            **error)
{
766 767 768 769
  const char *uid;
  const char *name;
  const char *vendor;
  const char *syspath;
770
  const char *parent;
771
  BoltDevice *dev;
772

773 774 775 776 777 778 779
  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;
    }
780

781 782
  syspath = udev_device_get_syspath (udev);
  g_return_val_if_fail (syspath != NULL, NULL);
783

784
  name = read_sysattr_name (udev, "device", error);
785 786 787
  if (name == NULL)
    return NULL;

788
  vendor = read_sysattr_name (udev, "vendor", error);
789 790
  if (vendor == NULL)
    return NULL;
791

792
  parent = bolt_sysfs_get_parent_uid (udev);
793
  dev = g_object_new (BOLT_TYPE_DEVICE,
794 795 796 797
                      "uid", uid,
                      "name", name,
                      "vendor", vendor,
                      "sysfs-path", syspath,
798
                      "parent", parent,
799 800
                      NULL);

801
  dev->status = bolt_status_from_udev (udev);
802
  dev->security = bolt_sysfs_security_for_device (udev);
803

804 805 806
  return dev;
}

807
const char *
808 809 810 811
bolt_device_export (BoltDevice      *device,
                    GDBusConnection *connection,
                    GError         **error)
{
812
  const char *path;
813
  gboolean ok;
814 815

  g_return_val_if_fail (BOLT_IS_DEVICE (device), FALSE);
816

817
  path = bolt_device_get_object_path (device);
818

819 820 821 822 823
  ok = g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (device),
                                         connection,
                                         path,
                                         error);
  return ok ? path : NULL;
824 825 826 827 828 829 830
}

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

832 833 834 835 836 837

BoltStatus
bolt_device_connected (BoltDevice         *dev,
                       struct udev_device *udev)
{
  const char *syspath;
838
  const char *parent;
839 840 841 842 843
  BoltSecurity security;
  BoltStatus status;

  syspath = udev_device_get_syspath (udev);
  status = bolt_status_from_udev (udev);
844
  security = bolt_sysfs_security_for_device (udev);
845
  parent = bolt_sysfs_get_parent_uid (udev);
846 847

  g_object_set (G_OBJECT (dev),
848
                "parent", parent,
849 850 851 852 853
                "sysfs-path", syspath,
                "security", security,
                "status", status,
                NULL);

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

856 857 858 859 860 861 862
  return status;
}

BoltStatus
bolt_device_disconnected (BoltDevice *dev)
{
  g_object_set (G_OBJECT (dev),
863
                "parent", NULL,
864 865 866 867 868
                "sysfs-path", NULL,
                "security", BOLT_SECURITY_NONE,
                "status", BOLT_STATUS_DISCONNECTED,
                NULL);

869 870 871 872 873
  /* 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)
874
    g_object_set (G_OBJECT (dev), "key", BOLT_KEY_HAVE, NULL);
875

876 877 878 879 880 881
  return dev->status;
}

gboolean
bolt_device_is_connected (BoltDevice *device)
{
882
  return bolt_status_is_connected (device->status);
883 884
}

885 886 887 888 889 890 891 892 893 894 895 896 897
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;
}

898
BoltKeyState
899
bolt_device_get_keystate (BoltDevice *dev)
900 901 902 903
{
  return dev->key;
}

904 905 906 907 908 909
const char *
bolt_device_get_name (BoltDevice *dev)
{
  return dev->name;
}

910 911 912 913 914 915 916 917 918
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;

919
      path = g_strdup_printf (BOLT_DBUS_PATH "/devices/%s", device->uid);
920 921 922 923 924 925 926
      g_strdelimit (path, "-", '_');

      device->dbus_path = path;
    }

  return device->dbus_path;
}
927

928 929 930 931 932 933
BoltPolicy
bolt_device_get_policy (BoltDevice *dev)
{
  return dev->policy;
}

934 935 936 937 938 939
const char *
bolt_device_get_uid (BoltDevice *dev)
{
  return dev->uid;
}

940 941 942 943 944 945
BoltSecurity
bolt_device_get_security (BoltDevice *dev)
{
  return dev->security;
}

Christian Kellner's avatar
Christian Kellner committed
946 947 948 949 950 951
BoltStatus
bolt_device_get_status (BoltDevice *dev)
{
  return dev->status;
}

952 953
gboolean
bolt_device_get_stored (BoltDevice *dev)
954
{
955
  return dev->store != NULL;
956 957
}

958 959 960 961 962
const char *
bolt_device_get_syspath (BoltDevice *dev)
{
  return dev->syspath;
}
963 964 965 966 967 968

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