Print this page
8807 More recent glib updates break hald build
Reviewed by: Dan McDonald <danmcd@joyent.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/hal/hald/device_store.c
+++ new/usr/src/cmd/hal/hald/device_store.c
1 1 /***************************************************************************
2 2 * CVSID: $Id$
3 3 *
4 4 * device_store.c : HalDeviceStore methods
5 5 *
6 6 * Copyright (C) 2003 David Zeuthen, <david@fubar.dk>
7 7 * Copyright (C) 2004 Novell, Inc.
8 8 *
9 9 * Licensed under the Academic Free License version 2.1
10 10 *
11 11 * This program is free software; you can redistribute it and/or modify
12 12 * it under the terms of the GNU General Public License as published by
13 13 * the Free Software Foundation; either version 2 of the License, or
14 14 * (at your option) any later version.
15 15 *
16 16 * This program is distributed in the hope that it will be useful,
17 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 19 * GNU General Public License for more details.
20 20 *
21 21 * You should have received a copy of the GNU General Public License
22 22 * along with this program; if not, write to the Free Software
23 23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 24 *
25 25 **************************************************************************/
26 26
27 27 #ifdef HAVE_CONFIG_H
28 28 # include <config.h>
29 29 #endif
30 30
31 31 #include <stdio.h>
32 32 #include <string.h>
33 33
34 34 #include "device_store.h"
35 35 #include "hald_marshal.h"
36 36 #include "logger.h"
37 37
38 38 static GObjectClass *parent_class;
39 39
40 40 enum {
41 41 STORE_CHANGED,
42 42 DEVICE_PROPERTY_CHANGED,
43 43 DEVICE_CAPABILITY_ADDED,
44 44 LAST_SIGNAL
45 45 };
46 46
47 47 static guint signals[LAST_SIGNAL] = { 0 };
48 48
49 49 static void
50 50 hal_device_store_finalize (GObject *obj)
51 51 {
52 52 HalDeviceStore *store = HAL_DEVICE_STORE (obj);
53 53
54 54 g_slist_foreach (store->devices, (GFunc) g_object_unref, NULL);
55 55
56 56 if (parent_class->finalize)
57 57 parent_class->finalize (obj);
58 58 }
59 59
60 60 static void
61 61 hal_device_store_class_init (HalDeviceStoreClass *klass)
62 62 {
63 63 GObjectClass *obj_class = (GObjectClass *) klass;
64 64
65 65 parent_class = g_type_class_peek_parent (klass);
|
↓ open down ↓ |
65 lines elided |
↑ open up ↑ |
66 66
67 67 obj_class->finalize = hal_device_store_finalize;
68 68
69 69 signals[STORE_CHANGED] =
70 70 g_signal_new ("store_changed",
71 71 G_TYPE_FROM_CLASS (klass),
72 72 G_SIGNAL_RUN_LAST,
73 73 G_STRUCT_OFFSET (HalDeviceStoreClass,
74 74 store_changed),
75 75 NULL, NULL,
76 - hald_marshal_VOID__OBJECT_BOOL,
76 + hald_marshal_VOID__OBJECT_BOOLEAN,
77 77 G_TYPE_NONE, 2,
78 78 G_TYPE_OBJECT,
79 79 G_TYPE_BOOLEAN);
80 80
81 81 signals[DEVICE_PROPERTY_CHANGED] =
82 82 g_signal_new ("device_property_changed",
83 83 G_TYPE_FROM_CLASS (klass),
84 84 G_SIGNAL_RUN_LAST,
85 85 G_STRUCT_OFFSET (HalDeviceStoreClass,
86 86 device_property_changed),
87 87 NULL, NULL,
88 - hald_marshal_VOID__OBJECT_STRING_BOOL_BOOL,
88 + hald_marshal_VOID__OBJECT_STRING_BOOLEAN_BOOLEAN,
89 89 G_TYPE_NONE, 4,
90 90 G_TYPE_OBJECT,
91 91 G_TYPE_STRING,
92 92 G_TYPE_BOOLEAN,
93 93 G_TYPE_BOOLEAN);
94 94
95 95 signals[DEVICE_CAPABILITY_ADDED] =
96 96 g_signal_new ("device_capability_added",
97 97 G_TYPE_FROM_CLASS (klass),
98 98 G_SIGNAL_RUN_LAST,
99 99 G_STRUCT_OFFSET (HalDeviceStoreClass,
100 100 device_capability_added),
101 101 NULL, NULL,
102 102 hald_marshal_VOID__OBJECT_STRING,
103 103 G_TYPE_NONE, 2,
104 104 G_TYPE_OBJECT,
105 105 G_TYPE_STRING);
106 106 }
107 107
108 108 static void
109 109 hal_device_store_init (HalDeviceStore *device)
110 110 {
111 111 }
112 112
113 113 GType
114 114 hal_device_store_get_type (void)
115 115 {
116 116 static GType type = 0;
117 117
118 118 if (!type) {
119 119 static GTypeInfo type_info = {
120 120 sizeof (HalDeviceStoreClass),
121 121 NULL, NULL,
122 122 (GClassInitFunc) hal_device_store_class_init,
123 123 NULL, NULL,
124 124 sizeof (HalDeviceStore),
125 125 0,
126 126 (GInstanceInitFunc) hal_device_store_init
127 127 };
128 128
129 129 type = g_type_register_static (G_TYPE_OBJECT,
130 130 "HalDeviceStore",
131 131 &type_info,
132 132 0);
133 133 }
134 134
135 135 return type;
136 136 }
137 137
138 138 HalDeviceStore *
139 139 hal_device_store_new (void)
140 140 {
141 141 HalDeviceStore *store;
142 142
143 143 store = g_object_new (HAL_TYPE_DEVICE_STORE, NULL, NULL);
144 144
145 145 return store;
146 146 }
147 147
148 148 static void
149 149 emit_device_property_changed (HalDevice *device,
150 150 const char *key,
151 151 gboolean added,
152 152 gboolean removed,
153 153 gpointer data)
154 154 {
155 155 HalDeviceStore *store = HAL_DEVICE_STORE (data);
156 156
157 157 g_signal_emit (store, signals[DEVICE_PROPERTY_CHANGED], 0,
158 158 device, key, added, removed);
159 159 }
160 160
161 161 static void
162 162 emit_device_capability_added (HalDevice *device,
163 163 const char *capability,
164 164 gpointer data)
165 165 {
166 166 HalDeviceStore *store = HAL_DEVICE_STORE (data);
167 167
168 168 g_signal_emit (store, signals[DEVICE_CAPABILITY_ADDED], 0,
169 169 device, capability);
170 170 }
171 171
172 172 void
173 173 hal_device_store_add (HalDeviceStore *store, HalDevice *device)
174 174 {
175 175 const char buf[] = "/org/freedesktop/Hal/devices/";
176 176
177 177 if (strncmp(device->udi, buf, sizeof (buf) - 1) != 0) {
178 178
179 179 HAL_ERROR(("Can't add HalDevice with incorrect UDI. Valid "
180 180 "UDI must start with '/org/freedesktop/Hal/devices/'"));
181 181 goto out;
182 182 }
183 183 store->devices = g_slist_prepend (store->devices,
184 184 g_object_ref (device));
185 185
186 186 g_signal_connect (device, "property_changed",
187 187 G_CALLBACK (emit_device_property_changed), store);
188 188 g_signal_connect (device, "capability_added",
189 189 G_CALLBACK (emit_device_capability_added), store);
190 190
191 191 g_signal_emit (store, signals[STORE_CHANGED], 0, device, TRUE);
192 192
193 193 out:
194 194 ;
195 195 }
196 196
197 197 gboolean
198 198 hal_device_store_remove (HalDeviceStore *store, HalDevice *device)
199 199 {
200 200 if (!g_slist_find (store->devices, device))
201 201 return FALSE;
202 202
203 203 store->devices = g_slist_remove (store->devices, device);
204 204
205 205 g_signal_handlers_disconnect_by_func (device,
206 206 (gpointer)emit_device_property_changed,
207 207 store);
208 208 g_signal_handlers_disconnect_by_func (device,
209 209 (gpointer)emit_device_capability_added,
210 210 store);
211 211
212 212 g_signal_emit (store, signals[STORE_CHANGED], 0, device, FALSE);
213 213
214 214 g_object_unref (device);
215 215
216 216 return TRUE;
217 217 }
218 218
219 219 HalDevice *
220 220 hal_device_store_find (HalDeviceStore *store, const char *udi)
221 221 {
222 222 GSList *iter;
223 223
224 224 for (iter = store->devices; iter != NULL; iter = iter->next) {
225 225 HalDevice *d = iter->data;
226 226
227 227 if (strcmp (hal_device_get_udi (d), udi) == 0)
228 228 return d;
229 229 }
230 230
231 231 return NULL;
232 232 }
233 233
234 234 void
235 235 hal_device_store_foreach (HalDeviceStore *store,
236 236 HalDeviceStoreForeachFn callback,
237 237 gpointer user_data)
238 238 {
239 239 GSList *iter;
240 240
241 241 g_return_if_fail (store != NULL);
242 242 g_return_if_fail (callback != NULL);
243 243
244 244 for (iter = store->devices; iter != NULL; iter = iter->next) {
245 245 HalDevice *d = HAL_DEVICE (iter->data);
246 246 gboolean cont;
247 247
248 248 cont = callback (store, d, user_data);
249 249
250 250 if (cont == FALSE)
251 251 return;
252 252 }
253 253 }
254 254
255 255 static gboolean
256 256 hal_device_store_print_foreach_fn (HalDeviceStore *store,
257 257 HalDevice *device,
258 258 gpointer user_data)
259 259 {
260 260 fprintf (stderr, "----\n");
261 261 hal_device_print (device);
262 262 fprintf (stderr, "----\n");
263 263 return TRUE;
264 264 }
265 265
266 266 void
267 267 hal_device_store_print (HalDeviceStore *store)
268 268 {
269 269 fprintf (stderr, "===============================================\n");
270 270 fprintf (stderr, "Dumping %d devices\n",
271 271 g_slist_length (store->devices));
272 272 fprintf (stderr, "===============================================\n");
273 273 hal_device_store_foreach (store,
274 274 hal_device_store_print_foreach_fn,
275 275 NULL);
276 276 fprintf (stderr, "===============================================\n");
277 277 }
278 278
279 279 HalDevice *
280 280 hal_device_store_match_key_value_string (HalDeviceStore *store,
281 281 const char *key,
282 282 const char *value)
283 283 {
284 284 GSList *iter;
285 285
286 286 g_return_val_if_fail (store != NULL, NULL);
287 287 g_return_val_if_fail (key != NULL, NULL);
288 288 g_return_val_if_fail (value != NULL, NULL);
289 289
290 290 for (iter = store->devices; iter != NULL; iter = iter->next) {
291 291 HalDevice *d = HAL_DEVICE (iter->data);
292 292 int type;
293 293
294 294 if (!hal_device_has_property (d, key))
295 295 continue;
296 296
297 297 type = hal_device_property_get_type (d, key);
298 298 if (type != HAL_PROPERTY_TYPE_STRING)
299 299 continue;
300 300
301 301 if (strcmp (hal_device_property_get_string (d, key),
302 302 value) == 0)
303 303 return d;
304 304 }
305 305
306 306 return NULL;
307 307 }
308 308
309 309 HalDevice *
310 310 hal_device_store_match_key_value_int (HalDeviceStore *store,
311 311 const char *key,
312 312 int value)
313 313 {
314 314 GSList *iter;
315 315
316 316 g_return_val_if_fail (store != NULL, NULL);
317 317 g_return_val_if_fail (key != NULL, NULL);
318 318
319 319 for (iter = store->devices; iter != NULL; iter = iter->next) {
320 320 HalDevice *d = HAL_DEVICE (iter->data);
321 321 int type;
322 322
323 323 if (!hal_device_has_property (d, key))
324 324 continue;
325 325
326 326 type = hal_device_property_get_type (d, key);
327 327 if (type != HAL_PROPERTY_TYPE_INT32)
328 328 continue;
329 329
330 330 if (hal_device_property_get_int (d, key) == value)
331 331 return d;
332 332 }
333 333
334 334 return NULL;
335 335 }
336 336
337 337 GSList *
338 338 hal_device_store_match_multiple_key_value_string (HalDeviceStore *store,
339 339 const char *key,
340 340 const char *value)
341 341 {
342 342 GSList *iter;
343 343 GSList *matches = NULL;
344 344
345 345 g_return_val_if_fail (store != NULL, NULL);
346 346 g_return_val_if_fail (key != NULL, NULL);
347 347 g_return_val_if_fail (value != NULL, NULL);
348 348
349 349 for (iter = store->devices; iter != NULL; iter = iter->next) {
350 350 HalDevice *d = HAL_DEVICE (iter->data);
351 351 int type;
352 352
353 353 if (!hal_device_has_property (d, key))
354 354 continue;
355 355
356 356 type = hal_device_property_get_type (d, key);
357 357 if (type != HAL_PROPERTY_TYPE_STRING)
358 358 continue;
359 359
360 360 if (strcmp (hal_device_property_get_string (d, key),
361 361 value) == 0)
362 362 matches = g_slist_prepend (matches, d);
363 363 }
364 364
365 365 return matches;
366 366 }
367 367
368 368 typedef struct {
369 369 HalDeviceStore *store;
370 370 char *key;
371 371 char *value;
372 372 HalDeviceStoreAsyncCallback callback;
373 373 gpointer user_data;
374 374
375 375 guint prop_signal_id;
376 376 guint store_signal_id;
377 377 guint timeout_id;
378 378 } AsyncMatchInfo;
379 379
380 380 static void
381 381 destroy_async_match_info (AsyncMatchInfo *info)
382 382 {
383 383 g_object_unref (info->store);
384 384
385 385 g_free (info->key);
386 386 g_free (info->value);
387 387
388 388 g_signal_handler_disconnect (info->store, info->prop_signal_id);
389 389 g_signal_handler_disconnect (info->store, info->store_signal_id);
390 390 g_source_remove (info->timeout_id);
391 391
392 392 g_free (info);
393 393 }
394 394
395 395 static void
396 396 match_device_async (HalDeviceStore *store, HalDevice *device,
397 397 const char *key, gboolean removed, gboolean added,
398 398 gpointer user_data)
399 399 {
400 400 AsyncMatchInfo *info = (AsyncMatchInfo *) user_data;
401 401
402 402 /* Only want to do it for added or changed properties */
403 403 if (removed)
404 404 return;
405 405
406 406 /* Keys have to match */
407 407 if (strcmp (info->key, key) != 0)
408 408 return;
409 409
410 410 /* Values have to match */
411 411 if (strcmp (hal_device_property_get_string (device, key),
412 412 info->value) != 0)
413 413 return;
414 414
415 415 info->callback (store, device, info->user_data);
416 416
417 417 destroy_async_match_info (info);
418 418 }
419 419
420 420 static void
421 421 store_changed (HalDeviceStore *store, HalDevice *device,
422 422 gboolean added, gpointer user_data)
423 423 {
424 424 AsyncMatchInfo *info = (AsyncMatchInfo *) user_data;
425 425
426 426 if (!added)
427 427 return;
428 428
429 429 if (!hal_device_has_property (device, info->key))
430 430 return;
431 431
432 432 if (strcmp (hal_device_property_get_string (device, info->key),
433 433 info->value) != 0)
434 434 return;
435 435
436 436 info->callback (store, device, info->user_data);
437 437
438 438 destroy_async_match_info (info);
439 439 }
440 440
441 441 static gboolean
442 442 match_device_async_timeout (gpointer user_data)
443 443 {
444 444 AsyncMatchInfo *info = (AsyncMatchInfo *) user_data;
445 445
446 446 info->callback (info->store, NULL, info->user_data);
447 447
448 448 destroy_async_match_info (info);
449 449
450 450 return FALSE;
451 451 }
452 452
453 453 void
454 454 hal_device_store_match_key_value_string_async (HalDeviceStore *store,
455 455 const char *key,
456 456 const char *value,
457 457 HalDeviceStoreAsyncCallback callback,
458 458 gpointer user_data,
459 459 int timeout)
460 460 {
461 461 HalDevice *device;
462 462 AsyncMatchInfo *info;
463 463
464 464 /* First check to see if it's already there */
465 465 device = hal_device_store_match_key_value_string (store, key, value);
466 466
467 467 if (device != NULL || timeout == 0) {
468 468 callback (store, device, user_data);
469 469
470 470 return;
471 471 }
472 472
473 473 info = g_new0 (AsyncMatchInfo, 1);
474 474
475 475 info->store = g_object_ref (store);
476 476 info->key = g_strdup (key);
477 477 info->value = g_strdup (value);
478 478 info->callback = callback;
479 479 info->user_data = user_data;
480 480
481 481 info->prop_signal_id = g_signal_connect (store,
482 482 "device_property_changed",
483 483 G_CALLBACK (match_device_async),
484 484 info);
485 485 info->store_signal_id = g_signal_connect (store,
486 486 "store_changed",
487 487 G_CALLBACK (store_changed),
488 488 info);
489 489
490 490 info->timeout_id = g_timeout_add (timeout,
491 491 match_device_async_timeout,
492 492 info);
493 493 }
|
↓ open down ↓ |
395 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX