gdbus: Update copyright information
[framework/connectivity/connman.git] / gdbus / watch.c
1 /*
2  *
3  *  D-Bus helper library
4  *
5  *  Copyright (C) 2004-2011  Marcel Holtmann <marcel@holtmann.org>
6  *
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or
11  *  (at your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *  GNU General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License
19  *  along with this program; if not, write to the Free Software
20  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
21  *
22  */
23
24 #ifdef HAVE_CONFIG_H
25 #include <config.h>
26 #endif
27
28 #include <stdio.h>
29 #include <string.h>
30
31 #include <glib.h>
32 #include <dbus/dbus.h>
33
34 #include "gdbus.h"
35
36 #define info(fmt...)
37 #define error(fmt...)
38 #define debug(fmt...)
39
40 static DBusHandlerResult message_filter(DBusConnection *connection,
41                                         DBusMessage *message, void *user_data);
42
43 static guint listener_id = 0;
44 static GSList *listeners = NULL;
45
46 struct service_data {
47         DBusConnection *conn;
48         DBusPendingCall *call;
49         char *name;
50         const char *owner;
51         guint id;
52         struct filter_callback *callback;
53 };
54
55 struct filter_callback {
56         GDBusWatchFunction conn_func;
57         GDBusWatchFunction disc_func;
58         GDBusSignalFunction signal_func;
59         GDBusDestroyFunction destroy_func;
60         struct service_data *data;
61         void *user_data;
62         guint id;
63 };
64
65 struct filter_data {
66         DBusConnection *connection;
67         DBusHandleMessageFunction handle_func;
68         char *name;
69         char *owner;
70         char *path;
71         char *interface;
72         char *member;
73         char *argument;
74         GSList *callbacks;
75         GSList *processed;
76         guint name_watch;
77         gboolean lock;
78         gboolean registered;
79 };
80
81 static struct filter_data *filter_data_find(DBusConnection *connection,
82                                                         const char *name,
83                                                         const char *owner,
84                                                         const char *path,
85                                                         const char *interface,
86                                                         const char *member,
87                                                         const char *argument)
88 {
89         GSList *current;
90
91         for (current = listeners;
92                         current != NULL; current = current->next) {
93                 struct filter_data *data = current->data;
94
95                 if (connection != data->connection)
96                         continue;
97
98                 if (name && data->name &&
99                                 g_str_equal(name, data->name) == FALSE)
100                         continue;
101
102                 if (owner && data->owner &&
103                                 g_str_equal(owner, data->owner) == FALSE)
104                         continue;
105
106                 if (path && data->path &&
107                                 g_str_equal(path, data->path) == FALSE)
108                         continue;
109
110                 if (interface && data->interface &&
111                                 g_str_equal(interface, data->interface) == FALSE)
112                         continue;
113
114                 if (member && data->member &&
115                                 g_str_equal(member, data->member) == FALSE)
116                         continue;
117
118                 if (argument && data->argument &&
119                                 g_str_equal(argument, data->argument) == FALSE)
120                         continue;
121
122                 return data;
123         }
124
125         return NULL;
126 }
127
128 static void format_rule(struct filter_data *data, char *rule, size_t size)
129 {
130         const char *sender;
131         int offset;
132
133         offset = snprintf(rule, size, "type='signal'");
134         sender = data->name ? : data->owner;
135
136         if (sender)
137                 offset += snprintf(rule + offset, size - offset,
138                                 ",sender='%s'", sender);
139         if (data->path)
140                 offset += snprintf(rule + offset, size - offset,
141                                 ",path='%s'", data->path);
142         if (data->interface)
143                 offset += snprintf(rule + offset, size - offset,
144                                 ",interface='%s'", data->interface);
145         if (data->member)
146                 offset += snprintf(rule + offset, size - offset,
147                                 ",member='%s'", data->member);
148         if (data->argument)
149                 snprintf(rule + offset, size - offset,
150                                 ",arg0='%s'", data->argument);
151 }
152
153 static gboolean add_match(struct filter_data *data,
154                                 DBusHandleMessageFunction filter)
155 {
156         DBusError err;
157         char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
158
159         format_rule(data, rule, sizeof(rule));
160         dbus_error_init(&err);
161
162         dbus_bus_add_match(data->connection, rule, &err);
163         if (dbus_error_is_set(&err)) {
164                 error("Adding match rule \"%s\" failed: %s", rule,
165                                 err.message);
166                 dbus_error_free(&err);
167                 return FALSE;
168         }
169
170         data->handle_func = filter;
171         data->registered = TRUE;
172
173         return TRUE;
174 }
175
176 static gboolean remove_match(struct filter_data *data)
177 {
178         DBusError err;
179         char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
180
181         format_rule(data, rule, sizeof(rule));
182
183         dbus_error_init(&err);
184
185         dbus_bus_remove_match(data->connection, rule, &err);
186         if (dbus_error_is_set(&err)) {
187                 error("Removing owner match rule for %s failed: %s",
188                                 rule, err.message);
189                 dbus_error_free(&err);
190                 return FALSE;
191         }
192
193         return TRUE;
194 }
195
196 static struct filter_data *filter_data_get(DBusConnection *connection,
197                                         DBusHandleMessageFunction filter,
198                                         const char *sender,
199                                         const char *path,
200                                         const char *interface,
201                                         const char *member,
202                                         const char *argument)
203 {
204         struct filter_data *data;
205         const char *name = NULL, *owner = NULL;
206
207         if (filter_data_find(connection, NULL, NULL, NULL, NULL, NULL, NULL) == NULL) {
208                 if (!dbus_connection_add_filter(connection,
209                                         message_filter, NULL, NULL)) {
210                         error("dbus_connection_add_filter() failed");
211                         return NULL;
212                 }
213         }
214
215         if (sender == NULL)
216                 goto proceed;
217
218         if (sender[0] == ':')
219                 owner = sender;
220         else
221                 name = sender;
222
223 proceed:
224         data = filter_data_find(connection, name, owner, path, interface,
225                                         member, argument);
226         if (data)
227                 return data;
228
229         data = g_new0(struct filter_data, 1);
230
231         data->connection = dbus_connection_ref(connection);
232         data->name = name ? g_strdup(name) : NULL;
233         data->owner = owner ? g_strdup(owner) : NULL;
234         data->path = g_strdup(path);
235         data->interface = g_strdup(interface);
236         data->member = g_strdup(member);
237         data->argument = g_strdup(argument);
238
239         if (!add_match(data, filter)) {
240                 g_free(data);
241                 return NULL;
242         }
243
244         listeners = g_slist_append(listeners, data);
245
246         return data;
247 }
248
249 static struct filter_callback *filter_data_find_callback(
250                                                 struct filter_data *data,
251                                                 guint id)
252 {
253         GSList *l;
254
255         for (l = data->callbacks; l; l = l->next) {
256                 struct filter_callback *cb = l->data;
257                 if (cb->id == id)
258                         return cb;
259         }
260         for (l = data->processed; l; l = l->next) {
261                 struct filter_callback *cb = l->data;
262                 if (cb->id == id)
263                         return cb;
264         }
265
266         return NULL;
267 }
268
269 static void filter_data_free(struct filter_data *data)
270 {
271         GSList *l;
272
273         for (l = data->callbacks; l != NULL; l = l->next)
274                 g_free(l->data);
275
276         g_slist_free(data->callbacks);
277         g_dbus_remove_watch(data->connection, data->name_watch);
278         g_free(data->name);
279         g_free(data->owner);
280         g_free(data->path);
281         g_free(data->interface);
282         g_free(data->member);
283         g_free(data->argument);
284         dbus_connection_unref(data->connection);
285         g_free(data);
286 }
287
288 static void filter_data_call_and_free(struct filter_data *data)
289 {
290         GSList *l;
291
292         for (l = data->callbacks; l != NULL; l = l->next) {
293                 struct filter_callback *cb = l->data;
294                 if (cb->disc_func)
295                         cb->disc_func(data->connection, cb->user_data);
296                 if (cb->destroy_func)
297                         cb->destroy_func(cb->user_data);
298                 g_free(cb);
299         }
300
301         filter_data_free(data);
302 }
303
304 static struct filter_callback *filter_data_add_callback(
305                                                 struct filter_data *data,
306                                                 GDBusWatchFunction connect,
307                                                 GDBusWatchFunction disconnect,
308                                                 GDBusSignalFunction signal,
309                                                 GDBusDestroyFunction destroy,
310                                                 void *user_data)
311 {
312         struct filter_callback *cb = NULL;
313
314         cb = g_new0(struct filter_callback, 1);
315
316         cb->conn_func = connect;
317         cb->disc_func = disconnect;
318         cb->signal_func = signal;
319         cb->destroy_func = destroy;
320         cb->user_data = user_data;
321         cb->id = ++listener_id;
322
323         if (data->lock)
324                 data->processed = g_slist_append(data->processed, cb);
325         else
326                 data->callbacks = g_slist_append(data->callbacks, cb);
327
328         return cb;
329 }
330
331 static void service_data_free(struct service_data *data)
332 {
333         struct filter_callback *callback = data->callback;
334
335         dbus_connection_unref(data->conn);
336
337         if (data->call)
338                 dbus_pending_call_unref(data->call);
339
340         if (data->id)
341                 g_source_remove(data->id);
342
343         g_free(data->name);
344         g_free(data);
345
346         callback->data = NULL;
347 }
348
349 static gboolean filter_data_remove_callback(struct filter_data *data,
350                                                 struct filter_callback *cb)
351 {
352         DBusConnection *connection;
353
354         data->callbacks = g_slist_remove(data->callbacks, cb);
355         data->processed = g_slist_remove(data->processed, cb);
356
357         /* Cancel pending operations */
358         if (cb->data) {
359                 if (cb->data->call)
360                         dbus_pending_call_cancel(cb->data->call);
361                 service_data_free(cb->data);
362         }
363
364         if (cb->destroy_func)
365                 cb->destroy_func(cb->user_data);
366
367         g_free(cb);
368
369         /* Don't remove the filter if other callbacks exist or data is lock
370          * processing callbacks */
371         if (data->callbacks || data->lock)
372                 return TRUE;
373
374         if (data->registered && !remove_match(data))
375                 return FALSE;
376
377         connection = dbus_connection_ref(data->connection);
378         listeners = g_slist_remove(listeners, data);
379         filter_data_free(data);
380
381         /* Remove filter if there are no listeners left for the connection */
382         data = filter_data_find(connection, NULL, NULL, NULL, NULL, NULL,
383                                         NULL);
384         if (data == NULL)
385                 dbus_connection_remove_filter(connection, message_filter,
386                                                 NULL);
387
388         dbus_connection_unref(connection);
389
390         return TRUE;
391 }
392
393 static DBusHandlerResult signal_filter(DBusConnection *connection,
394                                         DBusMessage *message, void *user_data)
395 {
396         struct filter_data *data = user_data;
397         struct filter_callback *cb;
398
399         while (data->callbacks) {
400                 cb = data->callbacks->data;
401
402                 if (cb->signal_func && !cb->signal_func(connection, message,
403                                                         cb->user_data)) {
404                         filter_data_remove_callback(data, cb);
405                         continue;
406                 }
407
408                 /* Check if the watch was removed/freed by the callback
409                  * function */
410                 if (!g_slist_find(data->callbacks, cb))
411                         continue;
412
413                 data->callbacks = g_slist_remove(data->callbacks, cb);
414                 data->processed = g_slist_append(data->processed, cb);
415         }
416
417         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
418 }
419
420 static void update_name_cache(const char *name, const char *owner)
421 {
422         GSList *l;
423
424         for (l = listeners; l != NULL; l = l->next) {
425                 struct filter_data *data = l->data;
426
427                 if (g_strcmp0(data->name, name) != 0)
428                         continue;
429
430                 g_free(data->owner);
431                 data->owner = g_strdup(owner);
432         }
433 }
434
435 static const char *check_name_cache(const char *name)
436 {
437         GSList *l;
438
439         for (l = listeners; l != NULL; l = l->next) {
440                 struct filter_data *data = l->data;
441
442                 if (g_strcmp0(data->name, name) != 0)
443                         continue;
444
445                 return data->owner;
446         }
447
448         return NULL;
449 }
450
451 static DBusHandlerResult service_filter(DBusConnection *connection,
452                                         DBusMessage *message, void *user_data)
453 {
454         struct filter_data *data = user_data;
455         struct filter_callback *cb;
456         char *name, *old, *new;
457
458         if (!dbus_message_get_args(message, NULL,
459                                 DBUS_TYPE_STRING, &name,
460                                 DBUS_TYPE_STRING, &old,
461                                 DBUS_TYPE_STRING, &new,
462                                 DBUS_TYPE_INVALID)) {
463                 error("Invalid arguments for NameOwnerChanged signal");
464                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
465         }
466
467         update_name_cache(name, new);
468
469         while (data->callbacks) {
470                 cb = data->callbacks->data;
471
472                 if (*new == '\0') {
473                         if (cb->disc_func)
474                                 cb->disc_func(connection, cb->user_data);
475                 } else {
476                         if (cb->conn_func)
477                                 cb->conn_func(connection, cb->user_data);
478                 }
479
480                 /* Check if the watch was removed/freed by the callback
481                  * function */
482                 if (!g_slist_find(data->callbacks, cb))
483                         continue;
484
485                 /* Only auto remove if it is a bus name watch */
486                 if (data->argument[0] == ':' &&
487                                 (cb->conn_func == NULL || cb->disc_func == NULL)) {
488                         filter_data_remove_callback(data, cb);
489                         continue;
490                 }
491
492                 data->callbacks = g_slist_remove(data->callbacks, cb);
493                 data->processed = g_slist_append(data->processed, cb);
494         }
495
496         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
497 }
498
499
500 static DBusHandlerResult message_filter(DBusConnection *connection,
501                                         DBusMessage *message, void *user_data)
502 {
503         struct filter_data *data;
504         const char *sender, *path, *iface, *member, *arg = NULL;
505
506         /* Only filter signals */
507         if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
508                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
509
510         sender = dbus_message_get_sender(message);
511         path = dbus_message_get_path(message);
512         iface = dbus_message_get_interface(message);
513         member = dbus_message_get_member(message);
514         dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID);
515
516         /* Sender is always bus name */
517         data = filter_data_find(connection, NULL, sender, path, iface, member,
518                                         arg);
519         if (data == NULL) {
520                 error("Got %s.%s signal which has no listeners", iface, member);
521                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
522         }
523
524         if (data->handle_func) {
525                 data->lock = TRUE;
526
527                 data->handle_func(connection, message, data);
528
529                 data->callbacks = data->processed;
530                 data->processed = NULL;
531                 data->lock = FALSE;
532         }
533
534         if (data->callbacks)
535                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
536
537         remove_match(data);
538
539         listeners = g_slist_remove(listeners, data);
540         filter_data_free(data);
541
542         /* Remove filter if there no listener left for the connection */
543         data = filter_data_find(connection, NULL, NULL, NULL, NULL, NULL,
544                                         NULL);
545         if (data == NULL)
546                 dbus_connection_remove_filter(connection, message_filter,
547                                                 NULL);
548
549         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
550 }
551
552 static gboolean update_service(void *user_data)
553 {
554         struct service_data *data = user_data;
555         struct filter_callback *cb = data->callback;
556
557         update_name_cache(data->name, data->owner);
558         if (cb->conn_func)
559                 cb->conn_func(data->conn, cb->user_data);
560
561         service_data_free(data);
562
563         return FALSE;
564 }
565
566 static void service_reply(DBusPendingCall *call, void *user_data)
567 {
568         struct service_data *data = user_data;
569         DBusMessage *reply;
570         DBusError err;
571
572         reply = dbus_pending_call_steal_reply(call);
573         if (reply == NULL)
574                 return;
575
576         dbus_error_init(&err);
577
578         if (dbus_set_error_from_message(&err, reply))
579                 goto fail;
580
581         if (dbus_message_get_args(reply, &err,
582                                         DBUS_TYPE_STRING, &data->owner,
583                                                 DBUS_TYPE_INVALID) == FALSE)
584                 goto fail;
585
586         update_service(data);
587
588         goto done;
589
590 fail:
591         error("%s", err.message);
592         dbus_error_free(&err);
593         service_data_free(data);
594 done:
595         dbus_message_unref(reply);
596 }
597
598 static void check_service(DBusConnection *connection,
599                                         const char *name,
600                                         struct filter_callback *callback)
601 {
602         DBusMessage *message;
603         struct service_data *data;
604
605         data = g_try_malloc0(sizeof(*data));
606         if (data == NULL) {
607                 error("Can't allocate data structure");
608                 return;
609         }
610
611         data->conn = dbus_connection_ref(connection);
612         data->name = g_strdup(name);
613         data->callback = callback;
614         callback->data = data;
615
616         data->owner = check_name_cache(name);
617         if (data->owner != NULL) {
618                 data->id = g_idle_add(update_service, data);
619                 return;
620         }
621
622         message = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
623                         DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetNameOwner");
624         if (message == NULL) {
625                 error("Can't allocate new message");
626                 g_free(data);
627                 return;
628         }
629
630         dbus_message_append_args(message, DBUS_TYPE_STRING, &name,
631                                                         DBUS_TYPE_INVALID);
632
633         if (dbus_connection_send_with_reply(connection, message,
634                                                         &data->call, -1) == FALSE) {
635                 error("Failed to execute method call");
636                 g_free(data);
637                 goto done;
638         }
639
640         if (data->call == NULL) {
641                 error("D-Bus connection not available");
642                 g_free(data);
643                 goto done;
644         }
645
646         dbus_pending_call_set_notify(data->call, service_reply, data, NULL);
647
648 done:
649         dbus_message_unref(message);
650 }
651
652 guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
653                                 GDBusWatchFunction connect,
654                                 GDBusWatchFunction disconnect,
655                                 void *user_data, GDBusDestroyFunction destroy)
656 {
657         struct filter_data *data;
658         struct filter_callback *cb;
659
660         if (name == NULL)
661                 return 0;
662
663         data = filter_data_get(connection, service_filter, NULL, NULL,
664                                 DBUS_INTERFACE_DBUS, "NameOwnerChanged",
665                                 name);
666         if (data == NULL)
667                 return 0;
668
669         cb = filter_data_add_callback(data, connect, disconnect, NULL, NULL,
670                                         user_data);
671         if (cb == NULL)
672                 return 0;
673
674         if (connect)
675                 check_service(connection, name, cb);
676
677         return cb->id;
678 }
679
680 guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
681                                 GDBusWatchFunction func,
682                                 void *user_data, GDBusDestroyFunction destroy)
683 {
684         return g_dbus_add_service_watch(connection, name, NULL, func,
685                                                         user_data, destroy);
686 }
687
688 guint g_dbus_add_signal_watch(DBusConnection *connection,
689                                 const char *sender, const char *path,
690                                 const char *interface, const char *member,
691                                 GDBusSignalFunction function, void *user_data,
692                                 GDBusDestroyFunction destroy)
693 {
694         struct filter_data *data;
695         struct filter_callback *cb;
696
697         data = filter_data_get(connection, signal_filter, sender, path,
698                                 interface, member, NULL);
699         if (data == NULL)
700                 return 0;
701
702         cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
703                                         user_data);
704         if (cb == NULL)
705                 return 0;
706
707         if (data->name != NULL && data->name_watch == 0)
708                 data->name_watch = g_dbus_add_service_watch(connection,
709                                                         data->name, NULL,
710                                                         NULL, NULL, NULL);
711
712         return cb->id;
713 }
714
715 gboolean g_dbus_remove_watch(DBusConnection *connection, guint id)
716 {
717         struct filter_data *data;
718         struct filter_callback *cb;
719         GSList *ldata;
720
721         if (id == 0)
722                 return FALSE;
723
724         for (ldata = listeners; ldata; ldata = ldata->next) {
725                 data = ldata->data;
726
727                 cb = filter_data_find_callback(data, id);
728                 if (cb) {
729                         filter_data_remove_callback(data, cb);
730                         return TRUE;
731                 }
732         }
733
734         return FALSE;
735 }
736
737 void g_dbus_remove_all_watches(DBusConnection *connection)
738 {
739         struct filter_data *data;
740
741         while ((data = filter_data_find(connection, NULL, NULL, NULL, NULL,
742                                         NULL, NULL))) {
743                 listeners = g_slist_remove(listeners, data);
744                 filter_data_call_and_free(data);
745         }
746
747         dbus_connection_remove_filter(connection, message_filter, NULL);
748 }