udev.cc 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208
  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. #include "device/udev_linux/udev.h"
  5. #include <stddef.h>
  6. #include "base/strings/string_util.h"
  7. #include "device/udev_linux/udev_loader.h"
  8. namespace device {
  9. namespace {
  10. std::string StringOrEmptyIfNull(const char* value) {
  11. return value ? value : std::string();
  12. }
  13. } // namespace
  14. const char* udev_device_get_action(udev_device* udev_device) {
  15. return UdevLoader::Get()->udev_device_get_action(udev_device);
  16. }
  17. const char* udev_device_get_devnode(udev_device* udev_device) {
  18. return UdevLoader::Get()->udev_device_get_devnode(udev_device);
  19. }
  20. const char* udev_device_get_devtype(udev_device* udev_device) {
  21. return UdevLoader::Get()->udev_device_get_devtype(udev_device);
  22. }
  23. udev_device* udev_device_get_parent(udev_device* udev_device) {
  24. return UdevLoader::Get()->udev_device_get_parent(udev_device);
  25. }
  26. udev_device* udev_device_get_parent_with_subsystem_devtype(
  27. udev_device* udev_device,
  28. const char* subsystem,
  29. const char* devtype) {
  30. return UdevLoader::Get()->udev_device_get_parent_with_subsystem_devtype(
  31. udev_device, subsystem, devtype);
  32. }
  33. udev_list_entry* udev_device_get_properties_list_entry(
  34. struct udev_device* udev_device) {
  35. return UdevLoader::Get()->udev_device_get_properties_list_entry(udev_device);
  36. }
  37. const char* udev_device_get_property_value(udev_device* udev_device,
  38. const char* key) {
  39. return UdevLoader::Get()->udev_device_get_property_value(udev_device, key);
  40. }
  41. const char* udev_device_get_subsystem(udev_device* udev_device) {
  42. return UdevLoader::Get()->udev_device_get_subsystem(udev_device);
  43. }
  44. const char* udev_device_get_sysattr_value(udev_device* udev_device,
  45. const char* sysattr) {
  46. return UdevLoader::Get()->udev_device_get_sysattr_value(udev_device, sysattr);
  47. }
  48. const char* udev_device_get_sysname(udev_device* udev_device) {
  49. return UdevLoader::Get()->udev_device_get_sysname(udev_device);
  50. }
  51. const char* udev_device_get_syspath(udev_device* udev_device) {
  52. return UdevLoader::Get()->udev_device_get_syspath(udev_device);
  53. }
  54. udev_device* udev_device_new_from_devnum(udev* udev, char type, dev_t devnum) {
  55. return UdevLoader::Get()->udev_device_new_from_devnum(udev, type, devnum);
  56. }
  57. udev_device* udev_device_new_from_subsystem_sysname(
  58. udev* udev,
  59. const char* subsystem,
  60. const char* sysname) {
  61. return UdevLoader::Get()->udev_device_new_from_subsystem_sysname(
  62. udev, subsystem, sysname);
  63. }
  64. udev_device* udev_device_new_from_syspath(udev* udev, const char* syspath) {
  65. return UdevLoader::Get()->udev_device_new_from_syspath(udev, syspath);
  66. }
  67. void udev_device_unref(udev_device* udev_device) {
  68. UdevLoader::Get()->udev_device_unref(udev_device);
  69. }
  70. int udev_enumerate_add_match_subsystem(udev_enumerate* udev_enumerate,
  71. const char* subsystem) {
  72. return UdevLoader::Get()->udev_enumerate_add_match_subsystem(udev_enumerate,
  73. subsystem);
  74. }
  75. udev_list_entry* udev_enumerate_get_list_entry(udev_enumerate* udev_enumerate) {
  76. return UdevLoader::Get()->udev_enumerate_get_list_entry(udev_enumerate);
  77. }
  78. udev_enumerate* udev_enumerate_new(udev* udev) {
  79. return UdevLoader::Get()->udev_enumerate_new(udev);
  80. }
  81. int udev_enumerate_scan_devices(udev_enumerate* udev_enumerate) {
  82. return UdevLoader::Get()->udev_enumerate_scan_devices(udev_enumerate);
  83. }
  84. void udev_enumerate_unref(udev_enumerate* udev_enumerate) {
  85. UdevLoader::Get()->udev_enumerate_unref(udev_enumerate);
  86. }
  87. udev_list_entry* udev_list_entry_get_next(udev_list_entry* list_entry) {
  88. return UdevLoader::Get()->udev_list_entry_get_next(list_entry);
  89. }
  90. const char* udev_list_entry_get_name(udev_list_entry* list_entry) {
  91. return UdevLoader::Get()->udev_list_entry_get_name(list_entry);
  92. }
  93. int udev_monitor_enable_receiving(udev_monitor* udev_monitor) {
  94. return UdevLoader::Get()->udev_monitor_enable_receiving(udev_monitor);
  95. }
  96. int udev_monitor_filter_add_match_subsystem_devtype(udev_monitor* udev_monitor,
  97. const char* subsystem,
  98. const char* devtype) {
  99. return UdevLoader::Get()->udev_monitor_filter_add_match_subsystem_devtype(
  100. udev_monitor, subsystem, devtype);
  101. }
  102. int udev_monitor_get_fd(udev_monitor* udev_monitor) {
  103. return UdevLoader::Get()->udev_monitor_get_fd(udev_monitor);
  104. }
  105. udev_monitor* udev_monitor_new_from_netlink(udev* udev, const char* name) {
  106. return UdevLoader::Get()->udev_monitor_new_from_netlink(udev, name);
  107. }
  108. udev_device* udev_monitor_receive_device(udev_monitor* udev_monitor) {
  109. return UdevLoader::Get()->udev_monitor_receive_device(udev_monitor);
  110. }
  111. void udev_monitor_unref(udev_monitor* udev_monitor) {
  112. UdevLoader::Get()->udev_monitor_unref(udev_monitor);
  113. }
  114. udev* udev_new() {
  115. return UdevLoader::Get()->udev_new();
  116. }
  117. void udev_set_log_fn(
  118. struct udev* udev,
  119. void (*log_fn)(struct udev* udev, int priority, const char* file, int line,
  120. const char* fn, const char* format, va_list args)) {
  121. return UdevLoader::Get()->udev_set_log_fn(udev, log_fn);
  122. }
  123. void udev_set_log_priority(struct udev* udev, int priority) {
  124. return UdevLoader::Get()->udev_set_log_priority(udev, priority);
  125. }
  126. void udev_unref(udev* udev) {
  127. UdevLoader::Get()->udev_unref(udev);
  128. }
  129. std::string UdevDeviceGetPropertyValue(udev_device* udev_device,
  130. const char* key) {
  131. return StringOrEmptyIfNull(udev_device_get_property_value(udev_device, key));
  132. }
  133. std::string UdevDeviceGetSysattrValue(udev_device* udev_device,
  134. const char* key) {
  135. return StringOrEmptyIfNull(udev_device_get_sysattr_value(udev_device, key));
  136. }
  137. std::string UdevDeviceRecursiveGetSysattrValue(udev_device* udev_device,
  138. const char* key) {
  139. while (udev_device) {
  140. const char* result = udev_device_get_sysattr_value(udev_device, key);
  141. if (result) {
  142. return result;
  143. }
  144. udev_device = udev_device_get_parent(udev_device);
  145. }
  146. return "";
  147. }
  148. std::string UdevDecodeString(const std::string& encoded) {
  149. std::string decoded;
  150. const size_t size = encoded.size();
  151. for (size_t i = 0; i < size; ++i) {
  152. char c = encoded[i];
  153. if ((i + 3 < size) && c == '\\' && encoded[i + 1] == 'x') {
  154. c = (base::HexDigitToInt(encoded[i + 2]) << 4) +
  155. base::HexDigitToInt(encoded[i + 3]);
  156. i += 3;
  157. }
  158. decoded.push_back(c);
  159. }
  160. return decoded;
  161. }
  162. } // namespace device