44e09d5c8ecc610a05a39dcf9c9806ec6a4a84b4
[connman] / src / udev.c
1 /*
2  *
3  *  Connection Manager
4  *
5  *  Copyright (C) 2007-2009  Intel Corporation. All rights reserved.
6  *
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License version 2 as
9  *  published by the Free Software Foundation.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  */
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <sys/types.h>
27
28 #define LIBUDEV_I_KNOW_THE_API_IS_SUBJECT_TO_CHANGE
29 #include <libudev.h>
30
31 #include <glib.h>
32
33 #include "connman.h"
34
35 #ifdef NEED_UDEV_ENUMERATE_ADD_MATCH_PROPERTY
36 static int udev_enumerate_add_match_property(struct udev_enumerate *enumerate,
37                                         const char *property, const char *value)
38 {
39         return -EINVAL;
40 }
41 #endif
42
43 #ifdef NEED_UDEV_DEVICE_GET_PARENT_WITH_SUBSYSTEM_DEVTYPE
44 static struct udev_device *udev_device_get_parent_with_subsystem_devtype(struct udev_device *device,
45                                                 const char *subsystem, const char *devtype)
46 {
47         return NULL;
48 }
49 #endif
50
51 static GSList *device_list = NULL;
52
53 static struct connman_device *find_device(const char *interface)
54 {
55         GSList *list;
56
57         if (interface == NULL)
58                 return NULL;
59
60         for (list = device_list; list; list = list->next) {
61                 struct connman_device *device = list->data;
62                 const char *device_interface;
63
64                 device_interface = connman_device_get_interface(device);
65                 if (device_interface == NULL)
66                         continue;
67
68                 if (g_str_equal(device_interface, interface) == TRUE)
69                         return device;
70         }
71
72         return NULL;
73 }
74
75 static void add_device(struct udev_device *udev_device)
76 {
77         enum connman_device_type devtype = CONNMAN_DEVICE_TYPE_UNKNOWN;
78         struct connman_device *device;
79         struct udev_list_entry *entry;
80         const char *type = NULL, *interface = NULL;
81
82         DBG("");
83
84         entry = udev_device_get_properties_list_entry(udev_device);
85         while (entry) {
86                 const char *name = udev_list_entry_get_name(entry);
87
88                 if (g_str_has_prefix(name, "CONNMAN_TYPE") == TRUE)
89                         type = udev_list_entry_get_value(entry);
90                 else if (g_str_has_prefix(name, "CONNMAN_INTERFACE") == TRUE)
91                         interface = udev_list_entry_get_value(entry);
92
93                 entry = udev_list_entry_get_next(entry);
94         }
95
96         device = find_device(interface);
97         if (device != NULL)
98                 return;
99
100         if (type == NULL || interface == NULL)
101                 return;
102
103         if (g_str_equal(interface, "ttyUSB0") == FALSE &&
104                                 g_str_equal(interface, "noz0") == FALSE)
105                 return;
106
107         if (g_str_equal(type, "nozomi") == TRUE)
108                 devtype = CONNMAN_DEVICE_TYPE_NOZOMI;
109         else if (g_str_equal(type, "huawei") == TRUE)
110                 devtype = CONNMAN_DEVICE_TYPE_HUAWEI;
111         else if (g_str_equal(type, "novatel") == TRUE)
112                 devtype = CONNMAN_DEVICE_TYPE_NOVATEL;
113         else
114                 return;
115
116         device = connman_device_create(interface, devtype);
117         if (device == NULL)
118                 return;
119
120         connman_device_set_mode(device, CONNMAN_DEVICE_MODE_NETWORK_SINGLE);
121         connman_device_set_policy(device, CONNMAN_DEVICE_POLICY_MANUAL);
122
123         connman_device_set_interface(device, interface);
124
125         if (connman_device_register(device) < 0) {
126                 connman_device_unref(device);
127                 return;
128         }
129
130         device_list = g_slist_append(device_list, device);
131 }
132
133 static void remove_device(struct udev_device *udev_device)
134 {
135         struct connman_device *device;
136         struct udev_list_entry *entry;
137         const char *interface = NULL;
138
139         DBG("");
140
141         entry = udev_device_get_properties_list_entry(udev_device);
142         while (entry) {
143                 const char *name = udev_list_entry_get_name(entry);
144
145                 if (g_str_has_prefix(name, "CONNMAN_INTERFACE") == TRUE)
146                         interface = udev_list_entry_get_value(entry);
147
148                 entry = udev_list_entry_get_next(entry);
149         }
150
151         device = find_device(interface);
152         if (device == NULL)
153                 return;
154
155         device_list = g_slist_remove(device_list, device);
156
157         connman_device_unregister(device);
158         connman_device_unref(device);
159 }
160
161 static void print_properties(struct udev_device *device, const char *prefix)
162 {
163         struct udev_list_entry *entry;
164
165         entry = udev_device_get_properties_list_entry(device);
166         while (entry) {
167                 const char *name = udev_list_entry_get_name(entry);
168                 const char *value = udev_list_entry_get_value(entry);
169
170                 if (g_str_has_prefix(name, "CONNMAN") == TRUE ||
171                                 g_str_has_prefix(name, "RFKILL") == TRUE ||
172                                 g_str_has_prefix(name, "ID_MODEM") == TRUE ||
173                                 g_str_equal(name, "ID_VENDOR") == TRUE ||
174                                 g_str_equal(name, "ID_MODEL") == TRUE ||
175                                 g_str_equal(name, "DEVNAME") == TRUE ||
176                                 g_str_equal(name, "DEVPATH") == TRUE)
177                         connman_debug("%s%s = %s", prefix, name, value);
178
179                 entry = udev_list_entry_get_next(entry);
180         }
181 }
182
183 static void print_device(struct udev_device *device, const char *action)
184 {
185         const char *subsystem, *devtype = NULL;
186         struct udev_device *parent;
187
188         connman_debug("=== %s ===", action);
189         print_properties(device, "");
190
191         parent = udev_device_get_parent(device);
192         if (parent == NULL)
193                 return;
194
195         subsystem = udev_device_get_subsystem(parent);
196
197         if (subsystem != NULL &&
198                         g_str_equal(subsystem, "usb-serial") == TRUE) {
199                 subsystem = "usb";
200                 devtype = "usb_device";
201         }
202
203         parent = udev_device_get_parent_with_subsystem_devtype(device,
204                                                         subsystem, devtype);
205         print_properties(parent, "    ");
206 }
207
208 static void enumerate_devices(struct udev *context)
209 {
210         struct udev_enumerate *enumerate;
211         struct udev_list_entry *entry;
212
213         enumerate = udev_enumerate_new(context);
214         if (enumerate == NULL)
215                 return;
216
217         udev_enumerate_add_match_property(enumerate, "CONNMAN_TYPE", "?*");
218
219         udev_enumerate_scan_devices(enumerate);
220
221         entry = udev_enumerate_get_list_entry(enumerate);
222         while (entry) {
223                 const char *syspath = udev_list_entry_get_name(entry);
224                 struct udev_device *device;
225
226                 device = udev_device_new_from_syspath(context, syspath);
227
228                 print_device(device, "coldplug");
229
230                 add_device(device);
231
232                 udev_device_unref(device);
233
234                 entry = udev_list_entry_get_next(entry);
235         }
236
237         udev_enumerate_unref(enumerate);
238 }
239
240 static gboolean udev_event(GIOChannel *channel,
241                                 GIOCondition condition, gpointer user_data)
242 {
243         struct udev_monitor *monitor = user_data;
244         struct udev_device *device;
245         const char *action;
246
247         device = udev_monitor_receive_device(monitor);
248         if (device == NULL)
249                 return TRUE;
250
251         action = udev_device_get_action(device);
252         if (action == NULL)
253                 goto done;
254
255         print_device(device, action);
256
257         if (g_str_equal(action, "add") == TRUE)
258                 add_device(device);
259         else if (g_str_equal(action, "remove") == TRUE)
260                 remove_device(device);
261
262 done:
263         udev_device_unref(device);
264
265         return TRUE;
266 }
267
268 static struct udev *udev_ctx;
269 static struct udev_monitor *udev_mon;
270 static guint udev_watch = 0;
271
272 int __connman_udev_init(void)
273 {
274         GIOChannel *channel;
275         int fd;
276
277         DBG("");
278
279         udev_ctx = udev_new();
280         if (udev_ctx == NULL) {
281                 connman_error("Failed to create udev context");
282                 return -1;
283         }
284
285         udev_mon = udev_monitor_new_from_socket(udev_ctx,
286                                                 "@/org/moblin/connman/udev");
287         if (udev_mon == NULL) {
288                 connman_error("Failed to create udev monitor");
289                 udev_unref(udev_ctx);
290                 udev_ctx = NULL;
291                 return -1;
292         }
293
294         if (udev_monitor_enable_receiving(udev_mon) < 0) {
295                 connman_error("Failed to enable udev monitor");
296                 udev_unref(udev_ctx);
297                 udev_ctx = NULL;
298                 udev_monitor_unref(udev_mon);
299                 return -1;
300         }
301
302         enumerate_devices(udev_ctx);
303
304         fd = udev_monitor_get_fd(udev_mon);
305
306         channel = g_io_channel_unix_new(fd);
307         if (channel == NULL)
308                 return 0;
309
310         udev_watch = g_io_add_watch(channel, G_IO_IN, udev_event, udev_mon);
311
312         g_io_channel_unref(channel);
313
314         return 0;
315 }
316
317 void __connman_udev_cleanup(void)
318 {
319         GSList *list;
320
321         DBG("");
322
323         if (udev_watch > 0)
324                 g_source_remove(udev_watch);
325
326         for (list = device_list; list; list = list->next) {
327                 struct connman_device *device = list->data;
328
329                 connman_device_unregister(device);
330                 connman_device_unref(device);
331         }
332
333         g_slist_free(device_list);
334         device_list = NULL;
335
336         if (udev_ctx == NULL)
337                 return;
338
339         udev_monitor_unref(udev_mon);
340         udev_unref(udev_ctx);
341 }