Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.

main.c 4.6KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287
  1. #include "json.h"
  2. #include <libudev.h>
  3. #include <stdio.h>
  4. #include <sys/select.h>
  5. #include <unistd.h>
  6. #include <errno.h>
  7. #include <string.h>
  8. #include <fcntl.h>
  9. #include <stdlib.h>
  10. struct udev *udev;
  11. FILE *out;
  12. struct listener
  13. {
  14. struct udev_monitor *mon;
  15. int fd;
  16. };
  17. struct listener listeners[32];
  18. int listenerc = 0;
  19. struct udev_monitor *mons[32];
  20. static void devinfo_print_json(
  21. FILE *f,
  22. struct udev *udev,
  23. struct udev_device *dev)
  24. {
  25. struct udev_list_entry *entry, *sysattrs;
  26. int first;
  27. const char *key, *val;
  28. json_obj_start(f);
  29. sysattrs = udev_device_get_properties_list_entry(dev);
  30. first = 1;
  31. udev_list_entry_foreach(entry, sysattrs)
  32. {
  33. key = udev_list_entry_get_name(entry);
  34. val = udev_list_entry_get_value(entry);
  35. if (!first)
  36. json_sep(f);
  37. json_obj_key(f, key);
  38. json_str(f, val);
  39. first = 0;
  40. }
  41. json_obj_end(f);
  42. udev_device_unref(dev);
  43. }
  44. static void enumerate(FILE *f, const char *subsystem)
  45. {
  46. struct udev_enumerate *en;
  47. struct udev_list_entry *device, *devices;
  48. struct udev_device *dev;
  49. int first;
  50. const char *name;
  51. // Create enumerator
  52. en = udev_enumerate_new(udev);
  53. if (subsystem != NULL)
  54. udev_enumerate_add_match_subsystem(en, subsystem);
  55. json_arr_start(f);
  56. // Enumerate
  57. udev_enumerate_scan_devices(en);
  58. devices = udev_enumerate_get_list_entry(en);
  59. first = 1;
  60. udev_list_entry_foreach(device, devices)
  61. {
  62. if (!first)
  63. json_sep(f);
  64. name = udev_list_entry_get_name(device);
  65. dev = udev_device_new_from_syspath(udev, name);
  66. devinfo_print_json(f, udev, dev);
  67. first = 0;
  68. }
  69. json_arr_end(f);
  70. printf("\n");
  71. fflush(f);
  72. udev_enumerate_unref(en);
  73. }
  74. int monitor(const char *subsystem)
  75. {
  76. struct udev_monitor *mon;
  77. struct listener *l;
  78. mon = udev_monitor_new_from_netlink(udev, "udev");
  79. if (!mon)
  80. return -1;
  81. if (subsystem != NULL)
  82. {
  83. udev_monitor_filter_add_match_subsystem_devtype(
  84. mon, subsystem, NULL);
  85. }
  86. udev_monitor_enable_receiving(mon);
  87. l = &listeners[listenerc++];
  88. l->mon = mon;
  89. l->fd = udev_monitor_get_fd(mon);
  90. return 0;
  91. }
  92. void oncommand(struct listener *l)
  93. {
  94. char buf[1024];
  95. char *cmd, *arg;
  96. int cnt, i;
  97. char c;
  98. memset(buf, 0, sizeof(buf));
  99. cnt = read(l->fd, buf, sizeof(buf));
  100. if (cnt == -1)
  101. {
  102. perror("stdin");
  103. return;
  104. }
  105. else if (cnt == 0)
  106. {
  107. // don't try to read from stdin anymore if it's closed
  108. l->fd = -1;
  109. return;
  110. }
  111. else if (cnt == sizeof(buf))
  112. {
  113. fprintf(stderr, "input buffer too big\n");
  114. // drain, so we don't end up reading stale data next time
  115. do {
  116. cnt = read(l->fd, buf, sizeof(buf));
  117. if (cnt == -1)
  118. {
  119. perror("stdin");
  120. return;
  121. }
  122. } while (cnt == sizeof(buf));
  123. return;
  124. }
  125. // parse input into command and argument
  126. cmd = buf;
  127. arg = NULL;
  128. i = 0;
  129. while (1)
  130. {
  131. c = buf[i];
  132. // colon: replace with \0 to terminate cmd,
  133. // update arg to point to the charcater after :
  134. if (c == ':')
  135. {
  136. buf[i] = '\0';
  137. arg = buf + i + 1;
  138. }
  139. // newline: replace with \0 to terminate arg,
  140. // respond to request, then update cmd and
  141. // continue reading the buffer until we reach a \0
  142. else if (c == '\n' || c == '\0')
  143. {
  144. buf[i] = '\0';
  145. if (*cmd == '\0')
  146. break;
  147. // respond to request
  148. if (strcmp(cmd, "list") == 0)
  149. {
  150. if (strcmp(arg, "*") == 0)
  151. enumerate(out, NULL);
  152. else
  153. enumerate(out, arg);
  154. }
  155. else if (strcmp(cmd, "monitor") == 0)
  156. {
  157. if (strcmp(arg, "*") == 0)
  158. monitor(NULL);
  159. else
  160. monitor(arg);
  161. }
  162. else
  163. {
  164. fprintf(stderr, "Unknown command: %s\n", cmd);
  165. }
  166. if (c == '\0')
  167. break;
  168. cmd = buf + i + 1;
  169. }
  170. i += 1;
  171. }
  172. }
  173. void onevent(struct listener *l)
  174. {
  175. struct udev_device *dev = udev_monitor_receive_device(l->mon);
  176. if (!dev)
  177. {
  178. fprintf(stderr, "No device even though an event occurred.\n");
  179. return;
  180. }
  181. devinfo_print_json(out, udev, dev);
  182. printf("\n");
  183. fflush(out);
  184. }
  185. void readinput()
  186. {
  187. fd_set set;
  188. FD_ZERO(&set);
  189. int max = -1;
  190. for (int i = 0; i < listenerc; ++i)
  191. {
  192. int fd = listeners[i].fd;
  193. if (fd == -1)
  194. continue;
  195. FD_SET(fd, &set);
  196. if (fd > max)
  197. max = fd;
  198. }
  199. int activity;
  200. activity = select(max + 1, &set, NULL, NULL, NULL);
  201. if (activity < 0)
  202. {
  203. if (errno != EINTR)
  204. perror("select");
  205. return;
  206. }
  207. for (int i = 0; i < listenerc; ++i)
  208. {
  209. struct listener *l = &listeners[i];
  210. int fd = l->fd;
  211. if (!FD_ISSET(fd, &set))
  212. continue;
  213. if (fd == STDIN_FILENO)
  214. oncommand(l);
  215. else
  216. onevent(l);
  217. }
  218. }
  219. int main()
  220. {
  221. out = stdout;
  222. memset(listeners, 0, sizeof(listeners));
  223. // read stdin
  224. listeners[listenerc++].fd = STDIN_FILENO;
  225. // create udev
  226. udev = udev_new();
  227. if (!udev)
  228. {
  229. fprintf(stderr, "Failed to craete udev\n");
  230. return 1;
  231. }
  232. // main loop
  233. while (1) {
  234. readinput();
  235. }
  236. udev_unref(udev);
  237. }