1 /***************************************************************************
2 * CVSID: $Id$
3 *
4 * device.c : HalDevice methods
5 *
6 * Copyright (C) 2003 David Zeuthen, <david@fubar.dk>
7 * Copyright (C) 2004 Novell, Inc.
8 *
9 * Licensed under the Academic Free License version 2.1
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 *
25 **************************************************************************/
26
27 #ifdef HAVE_CONFIG_H
28 # include <config.h>
29 #endif
30
31 #include <stdio.h>
32 #include <string.h>
33
34 #include "hald.h"
35 #include "device.h"
36 #include "hald_marshal.h"
37 #include "logger.h"
38 #include "hald_runner.h"
39
40 static GObjectClass *parent_class;
41
42 enum {
43 PROPERTY_CHANGED,
44 CAPABILITY_ADDED,
45 CALLOUTS_FINISHED,
46 CANCELLED,
47 LAST_SIGNAL
48 };
49
50 static guint signals[LAST_SIGNAL] = { 0 };
51
52 #ifdef HALD_MEMLEAK_DBG
53 int dbg_hal_device_object_delta = 0;
54 #endif
55
56 static void
57 hal_device_finalize (GObject *obj)
58 {
59 HalDevice *device = HAL_DEVICE (obj);
60
61 runner_device_finalized (device);
62
63 #ifdef HALD_MEMLEAK_DBG
64 dbg_hal_device_object_delta--;
65 printf ("************* in finalize for udi=%s\n", device->udi);
66 #endif
67
68
69 g_slist_foreach (device->properties, (GFunc) hal_property_free, NULL);
70
71 g_slist_free (device->properties);
72
73 g_free (device->udi);
74
75 if (parent_class->finalize)
76 parent_class->finalize (obj);
77
78 }
79
80 static void
81 hal_device_class_init (HalDeviceClass *klass)
82 {
83 GObjectClass *obj_class = (GObjectClass *) klass;
84
85 parent_class = g_type_class_peek_parent (klass);
86
87 obj_class->finalize = hal_device_finalize;
88
89 signals[PROPERTY_CHANGED] =
90 g_signal_new ("property_changed",
91 G_TYPE_FROM_CLASS (klass),
92 G_SIGNAL_RUN_LAST,
93 G_STRUCT_OFFSET (HalDeviceClass,
94 property_changed),
95 NULL, NULL,
96 hald_marshal_VOID__STRING_BOOLEAN_BOOLEAN,
97 G_TYPE_NONE, 3,
98 G_TYPE_STRING,
99 G_TYPE_BOOLEAN,
100 G_TYPE_BOOLEAN);
101
102 signals[CAPABILITY_ADDED] =
103 g_signal_new ("capability_added",
104 G_TYPE_FROM_CLASS (klass),
105 G_SIGNAL_RUN_LAST,
106 G_STRUCT_OFFSET (HalDeviceClass,
107 capability_added),
108 NULL, NULL,
109 hald_marshal_VOID__STRING,
110 G_TYPE_NONE, 1,
111 G_TYPE_STRING);
112
113 signals[CALLOUTS_FINISHED] =
114 g_signal_new ("callouts_finished",
115 G_TYPE_FROM_CLASS (klass),
116 G_SIGNAL_RUN_LAST,
117 G_STRUCT_OFFSET (HalDeviceClass,
118 callouts_finished),
119 NULL, NULL,
120 hald_marshal_VOID__VOID,
121 G_TYPE_NONE, 0);
122
123 signals[CANCELLED] =
124 g_signal_new ("cancelled",
125 G_TYPE_FROM_CLASS (klass),
126 G_SIGNAL_RUN_LAST,
127 G_STRUCT_OFFSET (HalDeviceClass,
128 cancelled),
129 NULL, NULL,
130 hald_marshal_VOID__VOID,
131 G_TYPE_NONE, 0);
132 }
133
134 static void
135 hal_device_init (HalDevice *device)
136 {
137 static int temp_device_counter = 0;
138
139 device->udi = g_strdup_printf ("/org/freedesktop/Hal/devices/temp/%d",
140 temp_device_counter++);
141 device->num_addons = 0;
142 device->num_addons_ready = 0;
143 }
144
145 GType
146 hal_device_get_type (void)
147 {
148 static GType type = 0;
149
150 if (!type) {
151 static GTypeInfo type_info = {
152 sizeof (HalDeviceClass),
153 NULL, NULL,
154 (GClassInitFunc) hal_device_class_init,
155 NULL, NULL,
156 sizeof (HalDevice),
157 0,
158 (GInstanceInitFunc) hal_device_init,
159 NULL
160 };
161
162 type = g_type_register_static (G_TYPE_OBJECT,
163 "HalDevice",
164 &type_info,
165 0);
166 }
167
168 return type;
169 }
170
171
172 HalDevice *
173 hal_device_new (void)
174 {
175 HalDevice *device;
176
177 device = g_object_new (HAL_TYPE_DEVICE, NULL, NULL);
178
179 #ifdef HALD_MEMLEAK_DBG
180 dbg_hal_device_object_delta++;
181 #endif
182 return device;
183 }
184
185 /** Merge all properties from source where the key starts with
186 * source_namespace and put them onto target replacing source_namespace
187 * with target_namespace
188 *
189 * @param target Device to put properties onto
190 * @param source Device to retrieve properties from
191 * @param target_namespace Replace source namespace with this namespace
192 * @param source_namespace Source namespace that property keys must match
193 */
194 void
195 hal_device_merge_with_rewrite (HalDevice *target,
196 HalDevice *source,
197 const char *target_namespace,
198 const char *source_namespace)
199 {
200 GSList *iter;
201 size_t source_ns_len;
202
203 source_ns_len = strlen (source_namespace);
204
205 /* doesn't handle info.capabilities */
206
207 /* device_property_atomic_update_begin (); */
208
209 for (iter = source->properties; iter != NULL; iter = iter->next) {
210 HalProperty *p = iter->data;
211 int type;
212 const char *key;
213 int target_type;
214 gchar *target_key;
215
216 key = hal_property_get_key (p);
217
218 /* only care about properties that match source namespace */
219 if (strncmp(key, source_namespace, source_ns_len) != 0)
220 continue;
221
222 target_key = g_strdup_printf("%s%s", target_namespace,
223 key+source_ns_len);
224
225 type = hal_property_get_type (p);
226
227 /* only remove target if it exists with a different type */
228 target_type = hal_device_property_get_type (target, key);
229 if (target_type != HAL_PROPERTY_TYPE_INVALID && target_type != type)
230 hal_device_property_remove (target, key);
231
232 switch (type) {
233
234 case HAL_PROPERTY_TYPE_STRING:
235 hal_device_property_set_string (
236 target, target_key,
237 hal_property_get_string (p));
238 break;
239
240 case HAL_PROPERTY_TYPE_INT32:
241 hal_device_property_set_int (
242 target, target_key,
243 hal_property_get_int (p));
244 break;
245
246 case HAL_PROPERTY_TYPE_UINT64:
247 hal_device_property_set_uint64 (
248 target, target_key,
249 hal_property_get_uint64 (p));
250 break;
251
252 case HAL_PROPERTY_TYPE_BOOLEAN:
253 hal_device_property_set_bool (
254 target, target_key,
255 hal_property_get_bool (p));
256 break;
257
258 case HAL_PROPERTY_TYPE_DOUBLE:
259 hal_device_property_set_double (
260 target, target_key,
261 hal_property_get_double (p));
262 break;
263
264 default:
265 HAL_WARNING (("Unknown property type %d", type));
266 break;
267 }
268
269 g_free (target_key);
270 }
271
272 /* device_property_atomic_update_end (); */
273
274 }
275
276 void
277 hal_device_merge (HalDevice *target, HalDevice *source)
278 {
279 GSList *iter;
280 GSList *caps;
281
282 /* device_property_atomic_update_begin (); */
283
284 for (iter = source->properties; iter != NULL; iter = iter->next) {
285 HalProperty *p = iter->data;
286 int type;
287 const char *key;
288 int target_type;
289
290 key = hal_property_get_key (p);
291 type = hal_property_get_type (p);
292
293 /* handle info.capabilities in a special way */
294 if (strcmp (key, "info.capabilities") == 0)
295 continue;
296
297 /* only remove target if it exists with a different type */
298 target_type = hal_device_property_get_type (target, key);
299 if (target_type != HAL_PROPERTY_TYPE_INVALID && target_type != type)
300 hal_device_property_remove (target, key);
301
302 switch (type) {
303
304 case HAL_PROPERTY_TYPE_STRING:
305 hal_device_property_set_string (
306 target, key,
307 hal_property_get_string (p));
308 break;
309
310 case HAL_PROPERTY_TYPE_INT32:
311 hal_device_property_set_int (
312 target, key,
313 hal_property_get_int (p));
314 break;
315
316 case HAL_PROPERTY_TYPE_UINT64:
317 hal_device_property_set_uint64 (
318 target, key,
319 hal_property_get_uint64 (p));
320 break;
321
322 case HAL_PROPERTY_TYPE_BOOLEAN:
323 hal_device_property_set_bool (
324 target, key,
325 hal_property_get_bool (p));
326 break;
327
328 case HAL_PROPERTY_TYPE_DOUBLE:
329 hal_device_property_set_double (
330 target, key,
331 hal_property_get_double (p));
332 break;
333
334 default:
335 HAL_WARNING (("Unknown property type %d", type));
336 break;
337 }
338 }
339
340 /* device_property_atomic_update_end (); */
341
342 caps = hal_device_property_get_strlist (source, "info.capabilities");
343 for (iter = caps; iter != NULL; iter = iter->next) {
344 if (!hal_device_has_capability (target, iter->data))
345 hal_device_add_capability (target, iter->data);
346 }
347 }
348
349 gboolean
350 hal_device_matches (HalDevice *device1, HalDevice *device2,
351 const char *namespace)
352 {
353 int len;
354 GSList *iter;
355
356 len = strlen (namespace);
357
358 for (iter = device1->properties; iter != NULL; iter = iter->next) {
359 HalProperty *p;
360 const char *key;
361 int type;
362
363 p = (HalProperty *) iter->data;
364 key = hal_property_get_key (p);
365 type = hal_property_get_type (p);
366
367 if (strncmp (key, namespace, len) != 0)
368 continue;
369
370 if (!hal_device_has_property (device2, key))
371 return FALSE;
372
373 switch (type) {
374
375 case HAL_PROPERTY_TYPE_STRING:
376 if (strcmp (hal_property_get_string (p),
377 hal_device_property_get_string (device2,
378 key)) != 0)
379 return FALSE;
380 break;
381
382 case HAL_PROPERTY_TYPE_INT32:
383 if (hal_property_get_int (p) !=
384 hal_device_property_get_int (device2, key))
385 return FALSE;
386 break;
387
388 case HAL_PROPERTY_TYPE_UINT64:
389 if (hal_property_get_uint64 (p) !=
390 hal_device_property_get_uint64 (device2, key))
391 return FALSE;
392 break;
393
394 case HAL_PROPERTY_TYPE_BOOLEAN:
395 if (hal_property_get_bool (p) !=
396 hal_device_property_get_bool (device2, key))
397 return FALSE;
398 break;
399
400 case HAL_PROPERTY_TYPE_DOUBLE:
401 if (hal_property_get_double (p) !=
402 hal_device_property_get_double (device2, key))
403 return FALSE;
404 break;
405
406 default:
407 HAL_WARNING (("Unknown property type %d", type));
408 break;
409 }
410 }
411
412 return TRUE;
413 }
414
415 const char *
416 hal_device_get_udi (HalDevice *device)
417 {
418 return device->udi;
419 }
420
421 void
422 hal_device_set_udi (HalDevice *device, const char *udi)
423 {
424 if (device->udi != NULL)
425 g_free (device->udi);
426 device->udi = g_strdup (udi);
427 }
428
429 void
430 hal_device_add_capability (HalDevice *device, const char *capability)
431 {
432 if (hal_device_property_strlist_add (device, "info.capabilities", capability))
433 g_signal_emit (device, signals[CAPABILITY_ADDED], 0, capability);
434 }
435
436 gboolean
437 hal_device_has_capability (HalDevice *device, const char *capability)
438 {
439 GSList *caps;
440 GSList *iter;
441 gboolean matched = FALSE;
442
443 caps = hal_device_property_get_strlist (device, "info.capabilities");
444
445 if (caps == NULL)
446 return FALSE;
447
448 for (iter = caps; iter != NULL; iter = iter->next) {
449 if (strcmp (iter->data, capability) == 0) {
450 matched = TRUE;
451 break;
452 }
453 }
454
455 return matched;
456 }
457
458 gboolean
459 hal_device_has_property (HalDevice *device, const char *key)
460 {
461 g_return_val_if_fail (device != NULL, FALSE);
462 g_return_val_if_fail (key != NULL, FALSE);
463
464 return hal_device_property_find (device, key) != NULL;
465 }
466
467 int
468 hal_device_num_properties (HalDevice *device)
469 {
470 g_return_val_if_fail (device != NULL, -1);
471
472 return g_slist_length (device->properties);
473 }
474
475 HalProperty *
476 hal_device_property_find (HalDevice *device, const char *key)
477 {
478 GSList *iter;
479
480 g_return_val_if_fail (device != NULL, NULL);
481 g_return_val_if_fail (key != NULL, NULL);
482
483 for (iter = device->properties; iter != NULL; iter = iter->next) {
484 HalProperty *p = iter->data;
485
486 if (strcmp (hal_property_get_key (p), key) == 0)
487 return p;
488 }
489
490 return NULL;
491 }
492
493 char *
494 hal_device_property_to_string (HalDevice *device, const char *key)
495 {
496 HalProperty *prop;
497
498 prop = hal_device_property_find (device, key);
499 if (!prop)
500 return NULL;
501
502 return hal_property_to_string (prop);
503 }
504
505 void
506 hal_device_property_foreach (HalDevice *device,
507 HalDevicePropertyForeachFn callback,
508 gpointer user_data)
509 {
510 GSList *iter;
511
512 g_return_if_fail (device != NULL);
513 g_return_if_fail (callback != NULL);
514
515 for (iter = device->properties; iter != NULL; iter = iter->next) {
516 HalProperty *p = iter->data;
517 gboolean cont;
518
519 cont = callback (device, p, user_data);
520
521 if (cont == FALSE)
522 return;
523 }
524 }
525
526 int
527 hal_device_property_get_type (HalDevice *device, const char *key)
528 {
529 HalProperty *prop;
530
531 g_return_val_if_fail (device != NULL, HAL_PROPERTY_TYPE_INVALID);
532 g_return_val_if_fail (key != NULL, HAL_PROPERTY_TYPE_INVALID);
533
534 prop = hal_device_property_find (device, key);
535
536 if (prop != NULL)
537 return hal_property_get_type (prop);
538 else
539 return HAL_PROPERTY_TYPE_INVALID;
540 }
541
542 const char *
543 hal_device_property_get_string (HalDevice *device, const char *key)
544 {
545 HalProperty *prop;
546
547 g_return_val_if_fail (device != NULL, NULL);
548 g_return_val_if_fail (key != NULL, NULL);
549
550 prop = hal_device_property_find (device, key);
551
552 if (prop != NULL)
553 return hal_property_get_string (prop);
554 else
555 return NULL;
556 }
557
558 const char *
559 hal_device_property_get_as_string (HalDevice *device, const char *key, char *buf, size_t bufsize)
560 {
561 HalProperty *prop;
562
563 g_return_val_if_fail (device != NULL, NULL);
564 g_return_val_if_fail (key != NULL, NULL);
565 g_return_val_if_fail (buf != NULL, NULL);
566
567 prop = hal_device_property_find (device, key);
568
569 if (prop != NULL) {
570 switch (hal_property_get_type (prop)) {
571 case HAL_PROPERTY_TYPE_STRING:
572 strncpy (buf, hal_property_get_string (prop), bufsize);
573 break;
574 case HAL_PROPERTY_TYPE_INT32:
575 snprintf (buf, bufsize, "%d", hal_property_get_int (prop));
576 break;
577 case HAL_PROPERTY_TYPE_UINT64:
578 snprintf (buf, bufsize, "%llu", (long long unsigned int) hal_property_get_uint64 (prop));
579 break;
580 case HAL_PROPERTY_TYPE_DOUBLE:
581 snprintf (buf, bufsize, "%f", hal_property_get_double (prop));
582 break;
583 case HAL_PROPERTY_TYPE_BOOLEAN:
584 strncpy (buf, hal_property_get_bool (prop) ? "true" : "false", bufsize);
585 break;
586
587 case HAL_PROPERTY_TYPE_STRLIST:
588 /* print out as "\tval1\tval2\val3\t" */
589 {
590 GSList *iter;
591 guint i;
592
593 if (bufsize > 0)
594 buf[0] = '\t';
595 i = 1;
596 for (iter = hal_property_get_strlist (prop);
597 iter != NULL && i < bufsize;
598 iter = g_slist_next (iter)) {
599 guint len;
600 const char *str;
601
602 str = (const char *) iter->data;
603 len = strlen (str);
604 strncpy (buf + i, str, bufsize - i);
605 i += len;
606
607 if (i < bufsize) {
608 buf[i] = '\t';
609 i++;
610 }
611 }
612 }
613 break;
614 }
615 return buf;
616 } else {
617 buf[0] = '\0';
618 return NULL;
619 }
620 }
621
622 dbus_int32_t
623 hal_device_property_get_int (HalDevice *device, const char *key)
624 {
625 HalProperty *prop;
626
627 g_return_val_if_fail (device != NULL, -1);
628 g_return_val_if_fail (key != NULL, -1);
629
630 prop = hal_device_property_find (device, key);
631
632 if (prop != NULL)
633 return hal_property_get_int (prop);
634 else
635 return -1;
636 }
637
638 dbus_uint64_t
639 hal_device_property_get_uint64 (HalDevice *device, const char *key)
640 {
641 HalProperty *prop;
642
643 g_return_val_if_fail (device != NULL, -1);
644 g_return_val_if_fail (key != NULL, -1);
645
646 prop = hal_device_property_find (device, key);
647
648 if (prop != NULL)
649 return hal_property_get_uint64 (prop);
650 else
651 return -1;
652 }
653
654 dbus_bool_t
655 hal_device_property_get_bool (HalDevice *device, const char *key)
656 {
657 HalProperty *prop;
658
659 g_return_val_if_fail (device != NULL, FALSE);
660 g_return_val_if_fail (key != NULL, FALSE);
661
662 prop = hal_device_property_find (device, key);
663
664 if (prop != NULL)
665 return hal_property_get_bool (prop);
666 else
667 return FALSE;
668 }
669
670 double
671 hal_device_property_get_double (HalDevice *device, const char *key)
672 {
673 HalProperty *prop;
674
675 g_return_val_if_fail (device != NULL, -1.0);
676 g_return_val_if_fail (key != NULL, -1.0);
677
678 prop = hal_device_property_find (device, key);
679
680 if (prop != NULL)
681 return hal_property_get_double (prop);
682 else
683 return -1.0;
684 }
685
686 gboolean
687 hal_device_property_set_string (HalDevice *device, const char *key,
688 const char *value)
689 {
690 HalProperty *prop;
691
692 /* check if property already exists */
693 prop = hal_device_property_find (device, key);
694
695 if (prop != NULL) {
696 if (hal_property_get_type (prop) != HAL_PROPERTY_TYPE_STRING)
697 return FALSE;
698
699 /* don't bother setting the same value */
700 if (value != NULL &&
701 strcmp (hal_property_get_string (prop), value) == 0)
702 return TRUE;
703
704 hal_property_set_string (prop, value);
705
706 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
707 key, FALSE, FALSE);
708
709 } else {
710
711 prop = hal_property_new_string (key, value);
712
713 device->properties = g_slist_prepend (device->properties, prop);
714
715 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
716 key, FALSE, TRUE);
717 }
718
719 return TRUE;
720 }
721
722 gboolean
723 hal_device_property_set_int (HalDevice *device, const char *key,
724 dbus_int32_t value)
725 {
726 HalProperty *prop;
727
728 /* check if property already exists */
729 prop = hal_device_property_find (device, key);
730
731 if (prop != NULL) {
732 if (hal_property_get_type (prop) != HAL_PROPERTY_TYPE_INT32)
733 return FALSE;
734
735 /* don't bother setting the same value */
736 if (hal_property_get_int (prop) == value)
737 return TRUE;
738
739 hal_property_set_int (prop, value);
740
741 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
742 key, FALSE, FALSE);
743
744 } else {
745 prop = hal_property_new_int (key, value);
746
747 device->properties = g_slist_prepend (device->properties, prop);
748
749 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
750 key, FALSE, TRUE);
751 }
752
753 return TRUE;
754 }
755
756 gboolean
757 hal_device_property_set_uint64 (HalDevice *device, const char *key,
758 dbus_uint64_t value)
759 {
760 HalProperty *prop;
761
762 /* check if property already exists */
763 prop = hal_device_property_find (device, key);
764
765 if (prop != NULL) {
766 if (hal_property_get_type (prop) != HAL_PROPERTY_TYPE_UINT64)
767 return FALSE;
768
769 /* don't bother setting the same value */
770 if (hal_property_get_uint64 (prop) == value)
771 return TRUE;
772
773 hal_property_set_uint64 (prop, value);
774
775 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
776 key, FALSE, FALSE);
777
778 } else {
779 prop = hal_property_new_uint64 (key, value);
780
781 device->properties = g_slist_prepend (device->properties, prop);
782
783 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
784 key, FALSE, TRUE);
785 }
786
787 return TRUE;
788 }
789
790 gboolean
791 hal_device_property_set_bool (HalDevice *device, const char *key,
792 dbus_bool_t value)
793 {
794 HalProperty *prop;
795
796 /* check if property already exists */
797 prop = hal_device_property_find (device, key);
798
799 if (prop != NULL) {
800 if (hal_property_get_type (prop) != HAL_PROPERTY_TYPE_BOOLEAN)
801 return FALSE;
802
803 /* don't bother setting the same value */
804 if (hal_property_get_bool (prop) == value)
805 return TRUE;
806
807 hal_property_set_bool (prop, value);
808
809 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
810 key, FALSE, FALSE);
811
812 } else {
813 prop = hal_property_new_bool (key, value);
814
815 device->properties = g_slist_prepend (device->properties, prop);
816
817 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
818 key, FALSE, TRUE);
819 }
820
821 return TRUE;
822 }
823
824 gboolean
825 hal_device_property_set_double (HalDevice *device, const char *key,
826 double value)
827 {
828 HalProperty *prop;
829
830 /* check if property already exists */
831 prop = hal_device_property_find (device, key);
832
833 if (prop != NULL) {
834 if (hal_property_get_type (prop) != HAL_PROPERTY_TYPE_DOUBLE)
835 return FALSE;
836
837 /* don't bother setting the same value */
838 if (hal_property_get_double (prop) == value)
839 return TRUE;
840
841 hal_property_set_double (prop, value);
842
843 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
844 key, FALSE, FALSE);
845
846 } else {
847 prop = hal_property_new_double (key, value);
848
849 device->properties = g_slist_prepend (device->properties, prop);
850
851 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
852 key, FALSE, TRUE);
853 }
854
855 return TRUE;
856 }
857
858 gboolean
859 hal_device_copy_property (HalDevice *from_device, const char *from, HalDevice *to_device, const char *to)
860 {
861 gboolean rc;
862
863 rc = FALSE;
864
865 if (hal_device_has_property (from_device, from)) {
866 switch (hal_device_property_get_type (from_device, from)) {
867 case HAL_PROPERTY_TYPE_STRING:
868 rc = hal_device_property_set_string (
869 to_device, to, hal_device_property_get_string (from_device, from));
870 break;
871 case HAL_PROPERTY_TYPE_INT32:
872 rc = hal_device_property_set_int (
873 to_device, to, hal_device_property_get_int (from_device, from));
874 break;
875 case HAL_PROPERTY_TYPE_UINT64:
876 rc = hal_device_property_set_uint64 (
877 to_device, to, hal_device_property_get_uint64 (from_device, from));
878 break;
879 case HAL_PROPERTY_TYPE_BOOLEAN:
880 rc = hal_device_property_set_bool (
881 to_device, to, hal_device_property_get_bool (from_device, from));
882 break;
883 case HAL_PROPERTY_TYPE_DOUBLE:
884 rc = hal_device_property_set_double (
885 to_device, to, hal_device_property_get_double (from_device, from));
886 break;
887 }
888 }
889
890 return rc;
891 }
892
893 gboolean
894 hal_device_property_remove (HalDevice *device, const char *key)
895 {
896 HalProperty *prop;
897
898 prop = hal_device_property_find (device, key);
899
900 if (prop == NULL)
901 return FALSE;
902
903 device->properties = g_slist_remove (device->properties, prop);
904
905 hal_property_free (prop);
906
907 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
908 key, TRUE, FALSE);
909
910 return TRUE;
911 }
912
913 gboolean
914 hal_device_property_set_attribute (HalDevice *device,
915 const char *key,
916 enum PropertyAttribute attr,
917 gboolean val)
918 {
919 HalProperty *prop;
920
921 prop = hal_device_property_find (device, key);
922
923 if (prop == NULL)
924 return FALSE;
925
926 return TRUE;
927 }
928
929 void
930 hal_device_print (HalDevice *device)
931 {
932 GSList *iter;
933
934 fprintf (stderr, "device udi = %s\n", hal_device_get_udi (device));
935
936 for (iter = device->properties; iter != NULL; iter = iter->next) {
937 HalProperty *p = iter->data;
938 int type;
939 const char *key;
940
941 key = hal_property_get_key (p);
942 type = hal_property_get_type (p);
943
944 switch (type) {
945 case HAL_PROPERTY_TYPE_STRING:
946 fprintf (stderr, " %s = '%s' (string)\n", key,
947 hal_property_get_string (p));
948 break;
949
950 case HAL_PROPERTY_TYPE_INT32:
951 fprintf (stderr, " %s = %d 0x%x (int)\n", key,
952 hal_property_get_int (p),
953 hal_property_get_int (p));
954 break;
955
956 case HAL_PROPERTY_TYPE_UINT64:
957 fprintf (stderr, " %s = %llu 0x%llx (uint64)\n", key,
958 (long long unsigned int) hal_property_get_uint64 (p),
959 (long long unsigned int) hal_property_get_uint64 (p));
960 break;
961
962 case HAL_PROPERTY_TYPE_DOUBLE:
963 fprintf (stderr, " %s = %g (double)\n", key,
964 hal_property_get_double (p));
965 break;
966
967 case HAL_PROPERTY_TYPE_BOOLEAN:
968 fprintf (stderr, " %s = %s (bool)\n", key,
969 (hal_property_get_bool (p) ? "true" :
970 "false"));
971 break;
972
973 default:
974 HAL_WARNING (("Unknown property type %d", type));
975 break;
976 }
977 }
978 fprintf (stderr, "\n");
979 }
980
981
982 typedef struct {
983 char *key;
984 HalDevice *device;
985 HalDeviceAsyncCallback callback;
986 gpointer user_data;
987
988 guint prop_signal_id;
989 guint timeout_id;
990 } AsyncMatchInfo;
991
992 static void
993 destroy_async_match_info (AsyncMatchInfo *ai)
994 {
995 g_free (ai->key);
996 g_signal_handler_disconnect (ai->device, ai->prop_signal_id);
997 g_source_remove (ai->timeout_id);
998 g_object_unref (ai->device);
999 g_free (ai);
1000 }
1001
1002 static void
1003 prop_changed_cb (HalDevice *device, const char *key,
1004 gboolean removed, gboolean added, gpointer user_data)
1005 {
1006 AsyncMatchInfo *ai = user_data;
1007
1008 if (strcmp (key, ai->key) != 0)
1009 return;
1010
1011 /* the property is no longer there */
1012 if (removed)
1013 goto cleanup;
1014
1015
1016 ai->callback (ai->device, ai->user_data, TRUE);
1017
1018 cleanup:
1019 destroy_async_match_info (ai);
1020 }
1021
1022
1023 static gboolean
1024 async_wait_timeout (gpointer user_data)
1025 {
1026 AsyncMatchInfo *ai = (AsyncMatchInfo *) user_data;
1027
1028 ai->callback (ai->device, ai->user_data, FALSE);
1029
1030 destroy_async_match_info (ai);
1031
1032 return FALSE;
1033 }
1034
1035 void
1036 hal_device_async_wait_property (HalDevice *device,
1037 const char *key,
1038 HalDeviceAsyncCallback callback,
1039 gpointer user_data,
1040 int timeout)
1041 {
1042 HalProperty *prop;
1043 AsyncMatchInfo *ai;
1044
1045 /* check if property already exists */
1046 prop = hal_device_property_find (device, key);
1047
1048 if (prop != NULL || timeout==0) {
1049 callback (device, user_data, prop != NULL);
1050 return;
1051 }
1052
1053 ai = g_new0 (AsyncMatchInfo, 1);
1054
1055 ai->device = g_object_ref (device);
1056 ai->key = g_strdup (key);
1057 ai->callback = callback;
1058 ai->user_data = user_data;
1059
1060 ai->prop_signal_id = g_signal_connect (device, "property_changed",
1061 G_CALLBACK (prop_changed_cb),
1062 ai);
1063
1064 ai->timeout_id = g_timeout_add (timeout, async_wait_timeout, ai);
1065 }
1066
1067 void
1068 hal_device_callouts_finished (HalDevice *device)
1069 {
1070 g_signal_emit (device, signals[CALLOUTS_FINISHED], 0);
1071 }
1072
1073 /** Used when giving up on a device, e.g. if no device file appeared
1074 */
1075 void
1076 hal_device_cancel (HalDevice *device)
1077 {
1078 HAL_INFO (("udi=%s", device->udi));
1079 g_signal_emit (device, signals[CANCELLED], 0);
1080 }
1081
1082
1083
1084
1085 GSList *
1086 hal_device_property_get_strlist (HalDevice *device,
1087 const char *key)
1088 {
1089 HalProperty *prop;
1090
1091 g_return_val_if_fail (device != NULL, NULL);
1092 g_return_val_if_fail (key != NULL, NULL);
1093
1094 prop = hal_device_property_find (device, key);
1095
1096 if (prop != NULL)
1097 return hal_property_get_strlist (prop);
1098 else
1099 return NULL;
1100 }
1101
1102 const char *
1103 hal_device_property_get_strlist_elem (HalDevice *device,
1104 const char *key,
1105 guint index)
1106 {
1107 GSList *strlist;
1108 GSList *i;
1109
1110 strlist = hal_device_property_get_strlist (device, key);
1111 if (strlist == NULL)
1112 return NULL;
1113
1114 i = g_slist_nth (strlist, index);
1115 if (i == NULL)
1116 return NULL;
1117
1118 return (const char *) i->data;
1119 }
1120
1121 gboolean
1122 hal_device_property_strlist_append (HalDevice *device,
1123 const char *key,
1124 const char *value)
1125 {
1126 HalProperty *prop;
1127
1128 /* check if property already exists */
1129 prop = hal_device_property_find (device, key);
1130
1131 if (prop != NULL) {
1132 if (hal_property_get_type (prop) != HAL_PROPERTY_TYPE_STRLIST)
1133 return FALSE;
1134
1135 hal_property_strlist_append (prop, value);
1136
1137 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
1138 key, FALSE, FALSE);
1139
1140 } else {
1141 prop = hal_property_new_strlist (key);
1142 hal_property_strlist_append (prop, value);
1143
1144 device->properties = g_slist_prepend (device->properties, prop);
1145
1146 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
1147 key, FALSE, TRUE);
1148 }
1149
1150 return TRUE;
1151 }
1152
1153 gboolean
1154 hal_device_property_strlist_prepend (HalDevice *device,
1155 const char *key,
1156 const char *value)
1157 {
1158 HalProperty *prop;
1159
1160 /* check if property already exists */
1161 prop = hal_device_property_find (device, key);
1162
1163 if (prop != NULL) {
1164 if (hal_property_get_type (prop) != HAL_PROPERTY_TYPE_STRLIST)
1165 return FALSE;
1166
1167 hal_property_strlist_prepend (prop, value);
1168
1169 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
1170 key, FALSE, FALSE);
1171
1172 } else {
1173 prop = hal_property_new_strlist (key);
1174 hal_property_strlist_prepend (prop, value);
1175
1176 device->properties = g_slist_prepend (device->properties, prop);
1177
1178 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
1179 key, FALSE, TRUE);
1180 }
1181
1182 return TRUE;
1183 }
1184
1185 gboolean
1186 hal_device_property_strlist_remove_elem (HalDevice *device,
1187 const char *key,
1188 guint index)
1189 {
1190 HalProperty *prop;
1191
1192 /* check if property already exists */
1193 prop = hal_device_property_find (device, key);
1194
1195 if (prop == NULL)
1196 return FALSE;
1197
1198 if (hal_property_get_type (prop) != HAL_PROPERTY_TYPE_STRLIST)
1199 return FALSE;
1200
1201 if (hal_property_strlist_remove_elem (prop, index)) {
1202 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
1203 key, FALSE, FALSE);
1204 return TRUE;
1205 }
1206
1207 return FALSE;
1208 }
1209
1210 gboolean
1211 hal_device_property_strlist_clear (HalDevice *device,
1212 const char *key)
1213 {
1214 HalProperty *prop;
1215
1216 /* check if property already exists */
1217 prop = hal_device_property_find (device, key);
1218
1219 if (prop == NULL) {
1220 prop = hal_property_new_strlist (key);
1221
1222 device->properties = g_slist_prepend (device->properties, prop);
1223
1224 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
1225 key, FALSE, TRUE);
1226
1227 return TRUE;
1228 }
1229
1230 if (hal_property_get_type (prop) != HAL_PROPERTY_TYPE_STRLIST)
1231 return FALSE;
1232
1233 if (hal_property_strlist_clear (prop)) {
1234 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
1235 key, FALSE, FALSE);
1236 return TRUE;
1237 }
1238
1239 return FALSE;
1240 }
1241
1242
1243 gboolean
1244 hal_device_property_strlist_add (HalDevice *device,
1245 const char *key,
1246 const char *value)
1247 {
1248 HalProperty *prop;
1249 gboolean res;
1250
1251 res = FALSE;
1252
1253 /* check if property already exists */
1254 prop = hal_device_property_find (device, key);
1255
1256 if (prop != NULL) {
1257 if (hal_property_get_type (prop) != HAL_PROPERTY_TYPE_STRLIST)
1258 goto out;
1259
1260 res = hal_property_strlist_add (prop, value);
1261 if (res) {
1262 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
1263 key, FALSE, FALSE);
1264 }
1265
1266 } else {
1267 prop = hal_property_new_strlist (key);
1268 hal_property_strlist_prepend (prop, value);
1269
1270 device->properties = g_slist_prepend (device->properties, prop);
1271
1272 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
1273 key, FALSE, TRUE);
1274
1275 res = TRUE;
1276 }
1277
1278 out:
1279 return res;
1280 }
1281
1282 gboolean
1283 hal_device_property_strlist_remove (HalDevice *device,
1284 const char *key,
1285 const char *value)
1286 {
1287 HalProperty *prop;
1288
1289 /* check if property already exists */
1290 prop = hal_device_property_find (device, key);
1291
1292 if (prop == NULL)
1293 return FALSE;
1294
1295 if (hal_property_get_type (prop) != HAL_PROPERTY_TYPE_STRLIST)
1296 return FALSE;
1297
1298 if (hal_property_strlist_remove (prop, value)) {
1299 g_signal_emit (device, signals[PROPERTY_CHANGED], 0,
1300 key, FALSE, FALSE);
1301 }
1302
1303 return TRUE;
1304 }
1305
1306 gboolean
1307 hal_device_property_strlist_is_empty (HalDevice *device,
1308 const char *key)
1309 {
1310 GSList *strlist;
1311
1312 if ( hal_device_has_property (device, key)) {
1313 strlist = hal_device_property_get_strlist (device, key);
1314 if (strlist == NULL )
1315 return TRUE;
1316
1317 if (g_slist_length (strlist) > 0)
1318 return FALSE;
1319 else
1320 return TRUE;
1321 }
1322 return FALSE;
1323 }
1324
1325 void
1326 hal_device_inc_num_addons (HalDevice *device)
1327 {
1328 device->num_addons++;
1329 }
1330
1331 gboolean
1332 hal_device_inc_num_ready_addons (HalDevice *device)
1333 {
1334 if (hal_device_are_all_addons_ready (device)) {
1335 HAL_ERROR (("In hal_device_inc_num_ready_addons for udi=%s but all addons are already ready!",
1336 device->udi));
1337 return FALSE;
1338 }
1339
1340 device->num_addons_ready++;
1341 return TRUE;
1342 }
1343
1344 gboolean
1345 hal_device_are_all_addons_ready (HalDevice *device)
1346 {
1347 if (device->num_addons_ready == device->num_addons) {
1348 return TRUE;
1349 } else {
1350 return FALSE;
1351 }
1352 }