chiark / gitweb /
Docs: udev.xml: Clean up description of LABEL assignment key
[elogind.git] / extras / gudev / gudevclient.c
1 /* -*- Mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*-
2  *
3  * Copyright (C) 2008-2010 David Zeuthen <davidz@redhat.com>
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the
17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18  * Boston, MA 02111-1307, USA.
19  *
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #  include "config.h"
24 #endif
25
26 #include <stdlib.h>
27 #include <string.h>
28
29 #include "gudevclient.h"
30 #include "gudevdevice.h"
31 #include "gudevmarshal.h"
32 #include "gudevprivate.h"
33
34 /**
35  * SECTION:gudevclient
36  * @short_description: Query devices and listen to uevents
37  *
38  * #GUdevClient is used to query information about devices on a Linux
39  * system from the Linux kernel and the udev device
40  * manager.
41  *
42  * Device information is retrieved from the kernel (through the
43  * <literal>sysfs</literal> filesystem) and the udev daemon (through a
44  * <literal>tmpfs</literal> filesystem) and presented through
45  * #GUdevDevice objects. This means that no blocking IO ever happens
46  * (in both cases, we are essentially just reading data from kernel
47  * memory) and as such there are no asynchronous versions of the
48  * provided methods.
49  *
50  * To get #GUdevDevice objects, use
51  * g_udev_client_query_by_subsystem(),
52  * g_udev_client_query_by_device_number(),
53  * g_udev_client_query_by_device_file(),
54  * g_udev_client_query_by_sysfs_path(),
55  * g_udev_client_query_by_subsystem_and_name()
56  * or the #GUdevEnumerator type.
57  *
58  * To listen to uevents, connect to the #GUdevClient::uevent signal.
59  */
60
61 struct _GUdevClientPrivate
62 {
63   GSource *watch_source;
64   struct udev *udev;
65   struct udev_monitor *monitor;
66
67   gchar **subsystems;
68 };
69
70 enum
71 {
72   PROP_0,
73   PROP_SUBSYSTEMS,
74 };
75
76 enum
77 {
78   UEVENT_SIGNAL,
79   LAST_SIGNAL,
80 };
81
82 static guint signals[LAST_SIGNAL] = { 0 };
83
84 G_DEFINE_TYPE (GUdevClient, g_udev_client, G_TYPE_OBJECT)
85
86 /* ---------------------------------------------------------------------------------------------------- */
87
88 static gboolean
89 monitor_event (GIOChannel *source,
90                GIOCondition condition,
91                gpointer data)
92 {
93   GUdevClient *client = (GUdevClient *) data;
94   GUdevDevice *device;
95   struct udev_device *udevice;
96
97   if (client->priv->monitor == NULL)
98     goto out;
99   udevice = udev_monitor_receive_device (client->priv->monitor);
100   if (udevice == NULL)
101     goto out;
102
103   device = _g_udev_device_new (udevice);
104   udev_device_unref (udevice);
105   g_signal_emit (client,
106                  signals[UEVENT_SIGNAL],
107                  0,
108                  g_udev_device_get_action (device),
109                  device);
110   g_object_unref (device);
111
112  out:
113   return TRUE;
114 }
115
116 static void
117 g_udev_client_finalize (GObject *object)
118 {
119   GUdevClient *client = G_UDEV_CLIENT (object);
120
121   if (client->priv->watch_source != NULL)
122     {
123       g_source_destroy (client->priv->watch_source);
124       client->priv->watch_source = NULL;
125     }
126
127   if (client->priv->monitor != NULL)
128     {
129       udev_monitor_unref (client->priv->monitor);
130       client->priv->monitor = NULL;
131     }
132
133   if (client->priv->udev != NULL)
134     {
135       udev_unref (client->priv->udev);
136       client->priv->udev = NULL;
137     }
138
139   g_strfreev (client->priv->subsystems);
140
141   if (G_OBJECT_CLASS (g_udev_client_parent_class)->finalize != NULL)
142     G_OBJECT_CLASS (g_udev_client_parent_class)->finalize (object);
143 }
144
145 static void
146 g_udev_client_set_property (GObject      *object,
147                             guint         prop_id,
148                             const GValue *value,
149                             GParamSpec   *pspec)
150 {
151   GUdevClient *client = G_UDEV_CLIENT (object);
152
153   switch (prop_id)
154     {
155     case PROP_SUBSYSTEMS:
156       if (client->priv->subsystems != NULL)
157         g_strfreev (client->priv->subsystems);
158       client->priv->subsystems = g_strdupv (g_value_get_boxed (value));
159       break;
160
161     default:
162       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
163       break;
164     }
165 }
166
167 static void
168 g_udev_client_get_property (GObject     *object,
169                             guint        prop_id,
170                             GValue      *value,
171                             GParamSpec  *pspec)
172 {
173   GUdevClient *client = G_UDEV_CLIENT (object);
174
175   switch (prop_id)
176     {
177     case PROP_SUBSYSTEMS:
178       g_value_set_boxed (value, client->priv->subsystems);
179       break;
180
181     default:
182       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
183       break;
184     }
185 }
186
187 static void
188 g_udev_client_constructed (GObject *object)
189 {
190   GUdevClient *client = G_UDEV_CLIENT (object);
191   GIOChannel *channel;
192   guint n;
193
194   client->priv->udev = udev_new ();
195
196   /* connect to event source */
197   client->priv->monitor = udev_monitor_new_from_netlink (client->priv->udev, "udev");
198
199   //g_debug ("ss = %p", client->priv->subsystems);
200
201   if (client->priv->subsystems != NULL)
202     {
203       /* install subsystem filters to only wake up for certain events */
204       for (n = 0; client->priv->subsystems[n] != NULL; n++)
205         {
206           gchar *subsystem;
207           gchar *devtype;
208           gchar *s;
209
210           subsystem = g_strdup (client->priv->subsystems[n]);
211           devtype = NULL;
212
213           //g_debug ("s = '%s'", subsystem);
214
215           s = strstr (subsystem, "/");
216           if (s != NULL)
217             {
218               devtype = s + 1;
219               *s = '\0';
220             }
221
222           if (client->priv->monitor != NULL)
223               udev_monitor_filter_add_match_subsystem_devtype (client->priv->monitor, subsystem, devtype);
224
225           g_free (subsystem);
226         }
227
228       /* listen to events, and buffer them */
229       if (client->priv->monitor != NULL)
230         {
231           udev_monitor_enable_receiving (client->priv->monitor);
232           channel = g_io_channel_unix_new (udev_monitor_get_fd (client->priv->monitor));
233           client->priv->watch_source = g_io_create_watch (channel, G_IO_IN);
234           g_io_channel_unref (channel);
235           g_source_set_callback (client->priv->watch_source, (GSourceFunc) monitor_event, client, NULL);
236           g_source_attach (client->priv->watch_source, g_main_context_get_thread_default ());
237           g_source_unref (client->priv->watch_source);
238         }
239       else
240         {
241           client->priv->watch_source = NULL;
242         }
243     }
244
245   if (G_OBJECT_CLASS (g_udev_client_parent_class)->constructed != NULL)
246     G_OBJECT_CLASS (g_udev_client_parent_class)->constructed (object);
247 }
248
249
250 static void
251 g_udev_client_class_init (GUdevClientClass *klass)
252 {
253   GObjectClass *gobject_class = (GObjectClass *) klass;
254
255   gobject_class->constructed  = g_udev_client_constructed;
256   gobject_class->set_property = g_udev_client_set_property;
257   gobject_class->get_property = g_udev_client_get_property;
258   gobject_class->finalize     = g_udev_client_finalize;
259
260   /**
261    * GUdevClient:subsystems:
262    *
263    * The subsystems to listen for uevents on.
264    *
265    * To listen for only a specific DEVTYPE for a given SUBSYSTEM, use
266    * "subsystem/devtype". For example, to only listen for uevents
267    * where SUBSYSTEM is usb and DEVTYPE is usb_interface, use
268    * "usb/usb_interface".
269    *
270    * If this property is %NULL, then no events will be reported. If
271    * it's the empty array, events from all subsystems will be
272    * reported.
273    */
274   g_object_class_install_property (gobject_class,
275                                    PROP_SUBSYSTEMS,
276                                    g_param_spec_boxed ("subsystems",
277                                                        "The subsystems to listen for changes on",
278                                                        "The subsystems to listen for changes on",
279                                                        G_TYPE_STRV,
280                                                        G_PARAM_CONSTRUCT_ONLY |
281                                                        G_PARAM_READWRITE));
282
283   /**
284    * GUdevClient::uevent:
285    * @client: The #GUdevClient receiving the event.
286    * @action: The action for the uevent e.g. "add", "remove", "change", "move", etc.
287    * @device: Details about the #GUdevDevice the event is for.
288    *
289    * Emitted when @client receives an uevent.
290    *
291    * This signal is emitted in the
292    * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
293    * of the thread that @client was created in.
294    */
295   signals[UEVENT_SIGNAL] = g_signal_new ("uevent",
296                                          G_TYPE_FROM_CLASS (klass),
297                                          G_SIGNAL_RUN_LAST,
298                                          G_STRUCT_OFFSET (GUdevClientClass, uevent),
299                                          NULL,
300                                          NULL,
301                                          g_udev_marshal_VOID__STRING_OBJECT,
302                                          G_TYPE_NONE,
303                                          2,
304                                          G_TYPE_STRING,
305                                          G_UDEV_TYPE_DEVICE);
306
307   g_type_class_add_private (klass, sizeof (GUdevClientPrivate));
308 }
309
310 static void
311 g_udev_client_init (GUdevClient *client)
312 {
313   client->priv = G_TYPE_INSTANCE_GET_PRIVATE (client,
314                                               G_UDEV_TYPE_CLIENT,
315                                               GUdevClientPrivate);
316 }
317
318 /**
319  * g_udev_client_new:
320  * @subsystems: (array zero-terminated=1) (element-type utf8) (transfer none) (allow-none): A %NULL terminated string array of subsystems to listen for uevents on, %NULL to not listen on uevents at all, or an empty array to listen to uevents on all subsystems. See the documentation for the #GUdevClient:subsystems property for details on this parameter.
321  *
322  * Constructs a #GUdevClient object that can be used to query
323  * information about devices. Connect to the #GUdevClient::uevent
324  * signal to listen for uevents. Note that signals are emitted in the
325  * <link linkend="g-main-context-push-thread-default">thread-default main loop</link>
326  * of the thread that you call this constructor from.
327  *
328  * Returns: A new #GUdevClient object. Free with g_object_unref().
329  */
330 GUdevClient *
331 g_udev_client_new (const gchar * const *subsystems)
332 {
333   return G_UDEV_CLIENT (g_object_new (G_UDEV_TYPE_CLIENT, "subsystems", subsystems, NULL));
334 }
335
336 /**
337  * g_udev_client_query_by_subsystem:
338  * @client: A #GUdevClient.
339  * @subsystem: (allow-none): The subsystem to get devices for or %NULL to get all devices.
340  *
341  * Gets all devices belonging to @subsystem.
342  *
343  * Returns: (element-type GUdevDevice) (transfer full): A list of #GUdevDevice objects. The caller should free the result by using g_object_unref() on each element in the list and then g_list_free() on the list.
344  */
345 GList *
346 g_udev_client_query_by_subsystem (GUdevClient  *client,
347                                   const gchar  *subsystem)
348 {
349   struct udev_enumerate *enumerate;
350   struct udev_list_entry *l, *devices;
351   GList *ret;
352
353   g_return_val_if_fail (G_UDEV_IS_CLIENT (client), NULL);
354
355   ret = NULL;
356
357   /* prepare a device scan */
358   enumerate = udev_enumerate_new (client->priv->udev);
359
360   /* filter for subsystem */
361   if (subsystem != NULL)
362     udev_enumerate_add_match_subsystem (enumerate, subsystem);
363   /* retrieve the list */
364   udev_enumerate_scan_devices (enumerate);
365
366   /* add devices to the list */
367   devices = udev_enumerate_get_list_entry (enumerate);
368   for (l = devices; l != NULL; l = udev_list_entry_get_next (l))
369     {
370       struct udev_device *udevice;
371       GUdevDevice *device;
372
373       udevice = udev_device_new_from_syspath (udev_enumerate_get_udev (enumerate),
374                                               udev_list_entry_get_name (l));
375       if (udevice == NULL)
376         continue;
377       device = _g_udev_device_new (udevice);
378       udev_device_unref (udevice);
379       ret = g_list_prepend (ret, device);
380     }
381   udev_enumerate_unref (enumerate);
382
383   ret = g_list_reverse (ret);
384
385   return ret;
386 }
387
388 /**
389  * g_udev_client_query_by_device_number:
390  * @client: A #GUdevClient.
391  * @type: A value from the #GUdevDeviceType enumeration.
392  * @number: A device number.
393  *
394  * Looks up a device for a type and device number.
395  *
396  * Returns: (transfer full): A #GUdevDevice object or %NULL if the device was not found. Free with g_object_unref().
397  */
398 GUdevDevice *
399 g_udev_client_query_by_device_number (GUdevClient      *client,
400                                       GUdevDeviceType   type,
401                                       GUdevDeviceNumber number)
402 {
403   struct udev_device *udevice;
404   GUdevDevice *device;
405
406   g_return_val_if_fail (G_UDEV_IS_CLIENT (client), NULL);
407
408   device = NULL;
409   udevice = udev_device_new_from_devnum (client->priv->udev, type, number);
410
411   if (udevice == NULL)
412     goto out;
413
414   device = _g_udev_device_new (udevice);
415   udev_device_unref (udevice);
416
417  out:
418   return device;
419 }
420
421 /**
422  * g_udev_client_query_by_device_file:
423  * @client: A #GUdevClient.
424  * @device_file: A device file.
425  *
426  * Looks up a device for a device file.
427  *
428  * Returns: (transfer full): A #GUdevDevice object or %NULL if the device was not found. Free with g_object_unref().
429  */
430 GUdevDevice *
431 g_udev_client_query_by_device_file (GUdevClient  *client,
432                                     const gchar  *device_file)
433 {
434   struct stat stat_buf;
435   GUdevDevice *device;
436
437   g_return_val_if_fail (G_UDEV_IS_CLIENT (client), NULL);
438   g_return_val_if_fail (device_file != NULL, NULL);
439
440   device = NULL;
441
442   if (stat (device_file, &stat_buf) != 0)
443     goto out;
444
445   if (stat_buf.st_rdev == 0)
446     goto out;
447
448   if (S_ISBLK (stat_buf.st_mode))
449     device = g_udev_client_query_by_device_number (client, G_UDEV_DEVICE_TYPE_BLOCK, stat_buf.st_rdev);
450   else if (S_ISCHR (stat_buf.st_mode))
451     device = g_udev_client_query_by_device_number (client, G_UDEV_DEVICE_TYPE_CHAR, stat_buf.st_rdev);
452
453  out:
454   return device;
455 }
456
457 /**
458  * g_udev_client_query_by_sysfs_path:
459  * @client: A #GUdevClient.
460  * @sysfs_path: A sysfs path.
461  *
462  * Looks up a device for a sysfs path.
463  */
464 GUdevDevice *
465 g_udev_client_query_by_sysfs_path (GUdevClient  *client,
466                                    const gchar  *sysfs_path)
467 {
468   struct udev_device *udevice;
469   GUdevDevice *device;
470
471   g_return_val_if_fail (G_UDEV_IS_CLIENT (client), NULL);
472   g_return_val_if_fail (sysfs_path != NULL, NULL);
473
474   device = NULL;
475   udevice = udev_device_new_from_syspath (client->priv->udev, sysfs_path);
476   if (udevice == NULL)
477     goto out;
478
479   device = _g_udev_device_new (udevice);
480   udev_device_unref (udevice);
481
482  out:
483   return device;
484 }
485
486 /**
487  * g_udev_client_query_by_subsystem_and_name:
488  * @client: A #GUdevClient.
489  * @subsystem: A subsystem name.
490  * @name: The name of the device.
491  *
492  * Looks up a device for a subsystem and name.
493  *
494  * Returns: (transfer full): A #GUdevDevice object or %NULL if the device was not found. Free with g_object_unref().
495  */
496 GUdevDevice *
497 g_udev_client_query_by_subsystem_and_name (GUdevClient  *client,
498                                            const gchar  *subsystem,
499                                            const gchar  *name)
500 {
501   struct udev_device *udevice;
502   GUdevDevice *device;
503
504   g_return_val_if_fail (G_UDEV_IS_CLIENT (client), NULL);
505   g_return_val_if_fail (subsystem != NULL, NULL);
506   g_return_val_if_fail (name != NULL, NULL);
507
508   device = NULL;
509   udevice = udev_device_new_from_subsystem_sysname (client->priv->udev, subsystem, name);
510   if (udevice == NULL)
511     goto out;
512
513   device = _g_udev_device_new (udevice);
514   udev_device_unref (udevice);
515
516  out:
517   return device;
518 }
519
520 struct udev *
521 _g_udev_client_get_udev (GUdevClient *client)
522 {
523   g_return_val_if_fail (G_UDEV_IS_CLIENT (client), NULL);
524   return client->priv->udev;
525 }
526