device/udev_linux/udev0_loader.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "device/udev_linux/udev0_loader.h"
   6
   7 #include "library_loaders/libudev0.h"
   8
   9 namespace device {
  10
  11 Udev0Loader::Udev0Loader() {
  12 }
  13
  14 Udev0Loader::~Udev0Loader() {
  15 }
  16
  17 bool Udev0Loader::Init() {
  18   if (lib_loader_)
  19     return lib_loader_->loaded();
  20   lib_loader_.reset(new LibUdev0Loader);
  21   return lib_loader_->Load("libudev.so.0");
  22 }
  23
  24 const char* Udev0Loader::udev_device_get_action(udev_device* udev_device) {
  25   return lib_loader_->udev_device_get_action(udev_device);
  26 }
  27
  28 const char* Udev0Loader::udev_device_get_devnode(udev_device* udev_device) {
  29   return lib_loader_->udev_device_get_devnode(udev_device);
  30 }
  31
  32 udev_device* Udev0Loader::udev_device_get_parent(udev_device* udev_device) {
  33   return lib_loader_->udev_device_get_parent(udev_device);
  34 }
  35
  36 udev_device* Udev0Loader::udev_device_get_parent_with_subsystem_devtype(
  37     udev_device* udev_device,
  38     const char* subsystem,
  39     const char* devtype) {
  40   return lib_loader_->udev_device_get_parent_with_subsystem_devtype(
  41       udev_device, subsystem, devtype);
  42 }
  43
  44 const char* Udev0Loader::udev_device_get_property_value(
  45     udev_device* udev_device,
  46     const char* key) {
  47   return lib_loader_->udev_device_get_property_value(udev_device, key);
  48 }
  49
  50 const char* Udev0Loader::udev_device_get_subsystem(udev_device* udev_device) {
  51   return lib_loader_->udev_device_get_subsystem(udev_device);
  52 }
  53
  54 const char* Udev0Loader::udev_device_get_sysattr_value(udev_device* udev_device,
  55                                                        const char* sysattr) {
  56   return lib_loader_->udev_device_get_sysattr_value(udev_device, sysattr);
  57 }
  58
  59 const char* Udev0Loader::udev_device_get_sysname(udev_device* udev_device) {
  60   return lib_loader_->udev_device_get_sysname(udev_device);
  61 }
  62
  63 const char* Udev0Loader::udev_device_get_syspath(udev_device* udev_device) {
  64   return lib_loader_->udev_device_get_syspath(udev_device);
  65 }
  66
  67 udev_device* Udev0Loader::udev_device_new_from_devnum(udev* udev,
  68                                                       char type,
  69                                                       dev_t devnum) {
  70   return lib_loader_->udev_device_new_from_devnum(udev, type, devnum);
  71 }
  72
  73 udev_device* Udev0Loader::udev_device_new_from_subsystem_sysname(
  74     udev* udev,
  75     const char* subsystem,
  76     const char* sysname) {
  77   return lib_loader_->udev_device_new_from_subsystem_sysname(
  78       udev, subsystem, sysname);
  79 }
  80
  81 udev_device* Udev0Loader::udev_device_new_from_syspath(udev* udev,
  82                                                        const char* syspath) {
  83   return lib_loader_->udev_device_new_from_syspath(udev, syspath);
  84 }
  85
  86 void Udev0Loader::udev_device_unref(udev_device* udev_device) {
  87   lib_loader_->udev_device_unref(udev_device);
  88 }
  89
  90 int Udev0Loader::udev_enumerate_add_match_subsystem(
  91     udev_enumerate* udev_enumerate,
  92     const char* subsystem) {
  93   return lib_loader_->udev_enumerate_add_match_subsystem(udev_enumerate,
  94                                                          subsystem);
  95 }
  96
  97 udev_list_entry* Udev0Loader::udev_enumerate_get_list_entry(
  98     udev_enumerate* udev_enumerate) {
  99   return lib_loader_->udev_enumerate_get_list_entry(udev_enumerate);
 100 }
 101
 102 udev_enumerate* Udev0Loader::udev_enumerate_new(udev* udev) {
 103   return lib_loader_->udev_enumerate_new(udev);
 104 }
 105
 106 int Udev0Loader::udev_enumerate_scan_devices(udev_enumerate* udev_enumerate) {
 107   return lib_loader_->udev_enumerate_scan_devices(udev_enumerate);
 108 }
 109
 110 void Udev0Loader::udev_enumerate_unref(udev_enumerate* udev_enumerate) {
 111   lib_loader_->udev_enumerate_unref(udev_enumerate);
 112 }
 113
 114 udev_list_entry* Udev0Loader::udev_list_entry_get_next(
 115     udev_list_entry* list_entry) {
 116   return lib_loader_->udev_list_entry_get_next(list_entry);
 117 }
 118
 119 const char* Udev0Loader::udev_list_entry_get_name(udev_list_entry* list_entry) {
 120   return lib_loader_->udev_list_entry_get_name(list_entry);
 121 }
 122
 123 int Udev0Loader::udev_monitor_enable_receiving(udev_monitor* udev_monitor) {
 124   return lib_loader_->udev_monitor_enable_receiving(udev_monitor);
 125 }
 126
 127 int Udev0Loader::udev_monitor_filter_add_match_subsystem_devtype(
 128     udev_monitor* udev_monitor,
 129     const char* subsystem,
 130     const char* devtype) {
 131   return lib_loader_->udev_monitor_filter_add_match_subsystem_devtype(
 132       udev_monitor, subsystem, devtype);
 133 }
 134
 135 int Udev0Loader::udev_monitor_get_fd(udev_monitor* udev_monitor) {
 136   return lib_loader_->udev_monitor_get_fd(udev_monitor);
 137 }
 138
 139 udev_monitor* Udev0Loader::udev_monitor_new_from_netlink(udev* udev,
 140                                                          const char* name) {
 141   return lib_loader_->udev_monitor_new_from_netlink(udev, name);
 142 }
 143
 144 udev_device* Udev0Loader::udev_monitor_receive_device(
 145     udev_monitor* udev_monitor) {
 146   return lib_loader_->udev_monitor_receive_device(udev_monitor);
 147 }
 148
 149 void Udev0Loader::udev_monitor_unref(udev_monitor* udev_monitor) {
 150   lib_loader_->udev_monitor_unref(udev_monitor);
 151 }
 152
 153 udev* Udev0Loader::udev_new() {
 154   return lib_loader_->udev_new();
 155 }
 156
 157 void Udev0Loader::udev_set_log_fn(
 158       struct udev* udev,
 159       void (*log_fn)(struct udev* udev, int priority,
 160                      const char* file, int line,
 161                      const char* fn, const char* format, va_list args)) {
 162   return lib_loader_->udev_set_log_fn(udev, log_fn);
 163 }
 164
 165 void Udev0Loader::udev_set_log_priority(struct udev* udev, int priority) {
 166   return lib_loader_->udev_set_log_priority(udev, priority);
 167 }
 168
 169 void Udev0Loader::udev_unref(udev* udev) {
 170   lib_loader_->udev_unref(udev);
 171 }
 172
 173 }  // namespace device