git.meshlink.io Git - catta/blob - avahi-client/browser.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of avahi.
   5
   6   avahi is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   avahi is distributed in the hope that it will be useful, but WITHOUT
  12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  14   Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with avahi; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <avahi-client/client.h>
  27 #include <avahi-common/dbus.h>
  28 #include <avahi-common/llist.h>
  29 #include <avahi-common/error.h>
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33
  34 #define DBUS_API_SUBJECT_TO_CHANGE
  35 #include <dbus/dbus.h>
  36 #include <dbus/dbus-glib-lowlevel.h>
  37
  38 #include <stdlib.h>
  39
  40 #include "client.h"
  41 #include "internal.h"
  42
  43 /* AvahiDomainBrowser */
  44
  45 AvahiDomainBrowser* avahi_domain_browser_new (AvahiClient *client, AvahiIfIndex interface, AvahiProtocol protocol, char *domain, AvahiDomainBrowserType btype, AvahiDomainBrowserCallback callback, void *user_data)
  46 {
  47     AvahiDomainBrowser *tmp = NULL;
  48     DBusMessage *message = NULL, *reply;
  49     DBusError error;
  50     char *path;
  51
  52     if (client == NULL)
  53         return NULL;
  54
  55     dbus_error_init (&error);
  56
  57     message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER,
  58             AVAHI_DBUS_INTERFACE_SERVER, "DomainBrowserNew");
  59
  60     if (!dbus_message_append_args (message, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INT32, &btype, DBUS_TYPE_INVALID))
  61         goto dbus_error;
  62
  63     reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
  64
  65     if (dbus_error_is_set (&error) || reply == NULL)
  66         goto dbus_error;
  67
  68     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID))
  69         goto dbus_error;
  70
  71     if (dbus_error_is_set (&error) || path == NULL)
  72         goto dbus_error;
  73
  74     tmp = malloc (sizeof (AvahiDomainBrowser));
  75     tmp->client = client;
  76     tmp->callback = callback;
  77     tmp->user_data = user_data;
  78     tmp->path = strdup (path);
  79
  80     AVAHI_LLIST_PREPEND(AvahiDomainBrowser, domain_browsers, client->domain_browsers, tmp);
  81
  82     return tmp;
  83
  84 dbus_error:
  85     dbus_error_free (&error);
  86     avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
  87
  88     return NULL;
  89 }
  90
  91 int
  92 avahi_domain_browser_free (AvahiDomainBrowser *b)
  93 {
  94     AvahiClient *client = b->client;
  95     DBusMessage *message = NULL;
  96
  97     if (b == NULL || b->path == NULL)
  98         return avahi_client_set_errno (client, AVAHI_ERR_INVALID_OBJECT);
  99
 100     message = dbus_message_new_method_call (AVAHI_DBUS_NAME,
 101             b->path,
 102             AVAHI_DBUS_INTERFACE_DOMAIN_BROWSER, "Free");
 103
 104     if (message == NULL)
 105         return avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
 106
 107     dbus_connection_send (client->bus, message, NULL);
 108
 109     AVAHI_LLIST_REMOVE(AvahiDomainBrowser, domain_browsers, client->domain_browsers, b);
 110
 111     free (b);
 112
 113     return avahi_client_set_errno (client, AVAHI_OK);
 114 }
 115
 116 char*
 117 avahi_domain_browser_path (AvahiDomainBrowser *b)
 118 {
 119     return b->path;
 120 }
 121
 122 DBusHandlerResult
 123 avahi_domain_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message)
 124 {
 125     AvahiDomainBrowser *n, *db = NULL;
 126     DBusError error;
 127     const char *path;
 128     char *domain;
 129     int interface, protocol;
 130
 131     dbus_error_init (&error);
 132
 133     path = dbus_message_get_path (message);
 134
 135     if (path == NULL)
 136         goto out;
 137
 138     for (n = client->domain_browsers; n != NULL; n = n->domain_browsers_next)
 139     {
 140         printf ("cmp: %s, %s\n", n->path, path);
 141         if (strcmp (n->path, path) == 0) {
 142             db = n;
 143             break;
 144         }
 145     }
 146
 147     if (db == NULL)
 148         goto out;
 149
 150     dbus_message_get_args (message, &error, DBUS_TYPE_INT32, &interface,
 151             DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INVALID);
 152
 153     if (dbus_error_is_set (&error))
 154         goto out;
 155
 156     db->callback (db, interface, protocol, event, domain, db->user_data);
 157
 158     return DBUS_HANDLER_RESULT_HANDLED;
 159
 160 out:
 161     dbus_error_free (&error);
 162     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 163 }
 164
 165 /* AvahiServiceTypeBrowser */
 166 AvahiServiceTypeBrowser* avahi_service_type_browser_new (AvahiClient *client, AvahiIfIndex interface, AvahiProtocol protocol, char *domain, AvahiServiceTypeBrowserCallback callback, void *user_data)
 167 {
 168     AvahiServiceTypeBrowser *tmp = NULL;
 169     DBusMessage *message = NULL, *reply;
 170     DBusError error;
 171     char *path;
 172
 173     if (client == NULL)
 174         return NULL;
 175
 176     dbus_error_init (&error);
 177
 178     message = dbus_message_new_method_call (AVAHI_DBUS_NAME,
 179             AVAHI_DBUS_PATH_SERVER,
 180             AVAHI_DBUS_INTERFACE_SERVER,
 181             "ServiceTypeBrowserNew");
 182
 183     if (!dbus_message_append_args (message, DBUS_TYPE_INT32, &interface, DBUS_TYPE_INT32, &protocol, DBUS_TYPE_STRING, &domain, DBUS_TYPE_INVALID))
 184         goto dbus_error;
 185
 186     reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
 187
 188     if (dbus_error_is_set (&error) || reply == NULL)
 189         goto dbus_error;
 190
 191     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID))
 192         goto dbus_error;
 193
 194     if (dbus_error_is_set (&error) || path == NULL)
 195         goto dbus_error;
 196
 197     tmp = malloc (sizeof (AvahiServiceTypeBrowser));
 198     tmp->client = client;
 199     tmp->callback = callback;
 200     tmp->user_data = user_data;
 201     tmp->path = strdup (path);
 202
 203     AVAHI_LLIST_PREPEND(AvahiServiceTypeBrowser, service_type_browsers, client->service_type_browsers, tmp);
 204
 205     return tmp;
 206
 207 dbus_error:
 208     dbus_error_free (&error);
 209     avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
 210
 211     return NULL;
 212 }
 213
 214 int
 215 avahi_service_type_browser_free (AvahiServiceTypeBrowser *b)
 216 {
 217     AvahiClient *client = b->client;
 218     DBusMessage *message = NULL;
 219
 220     if (b == NULL || b->path == NULL)
 221         return avahi_client_set_errno (client, AVAHI_ERR_INVALID_OBJECT);
 222
 223     message = dbus_message_new_method_call (AVAHI_DBUS_NAME,
 224             b->path,
 225             AVAHI_DBUS_INTERFACE_SERVICE_TYPE_BROWSER, "Free");
 226
 227     if (message == NULL)
 228         return avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
 229
 230     dbus_connection_send (b->client->bus, message, NULL);
 231
 232     AVAHI_LLIST_REMOVE(AvahiServiceTypeBrowser, service_type_browsers, b->client->service_type_browsers, b);
 233
 234     free (b);
 235
 236     return avahi_client_set_errno (client, AVAHI_OK);
 237 }
 238
 239 char*
 240 avahi_service_type_browser_path (AvahiServiceTypeBrowser *b)
 241 {
 242     return b->path;
 243 }
 244
 245 DBusHandlerResult
 246 avahi_service_type_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message)
 247 {
 248     AvahiServiceTypeBrowser *n, *db = NULL;
 249     DBusError error;
 250     const char *path;
 251     char *domain, *type;
 252     int interface, protocol;
 253
 254     dbus_error_init (&error);
 255
 256     path = dbus_message_get_path (message);
 257
 258     if (path == NULL)
 259         goto out;
 260
 261     for (n = client->service_type_browsers; n != NULL; n = n->service_type_browsers_next)
 262     {
 263         printf ("cmp: %s, %s\n", n->path, path);
 264         if (strcmp (n->path, path) == 0) {
 265             db = n;
 266             break;
 267         }
 268     }
 269
 270     if (db == NULL)
 271         goto out;
 272
 273     dbus_message_get_args (message, &error,
 274             DBUS_TYPE_INT32, &interface,
 275             DBUS_TYPE_INT32, &protocol,
 276             DBUS_TYPE_STRING, &type,
 277             DBUS_TYPE_STRING, &domain,
 278             DBUS_TYPE_INVALID);
 279
 280     if (dbus_error_is_set (&error))
 281         goto out;
 282
 283     db->callback (db, interface, protocol, event, type, domain, db->user_data);
 284
 285     return DBUS_HANDLER_RESULT_HANDLED;
 286
 287 out:
 288     dbus_error_free (&error);
 289     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 290 }
 291
 292 /* AvahiServiceBrowser */
 293
 294 AvahiServiceBrowser* avahi_service_browser_new (AvahiClient *client, AvahiIfIndex interface, AvahiProtocol protocol, char *type, char *domain, AvahiServiceBrowserCallback callback, void *user_data)
 295 {
 296     AvahiServiceBrowser *tmp = NULL;
 297     DBusMessage *message = NULL, *reply;
 298     DBusError error;
 299     char *path;
 300
 301     if (client == NULL)
 302         return NULL;
 303
 304     dbus_error_init (&error);
 305
 306     message = dbus_message_new_method_call (AVAHI_DBUS_NAME, AVAHI_DBUS_PATH_SERVER,
 307             AVAHI_DBUS_INTERFACE_SERVER, "ServiceBrowserNew");
 308
 309     if (!dbus_message_append_args (message,
 310                 DBUS_TYPE_INT32, &interface,
 311                 DBUS_TYPE_INT32, &protocol,
 312                 DBUS_TYPE_STRING, &type,
 313                 DBUS_TYPE_STRING, &domain,
 314                 DBUS_TYPE_INVALID))
 315         goto dbus_error;
 316
 317     reply = dbus_connection_send_with_reply_and_block (client->bus, message, -1, &error);
 318
 319     if (dbus_error_is_set (&error) || reply == NULL)
 320         goto dbus_error;
 321
 322     if (!dbus_message_get_args (reply, &error, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID))
 323         goto dbus_error;
 324
 325     if (dbus_error_is_set (&error) || path == NULL)
 326         goto dbus_error;
 327
 328     tmp = malloc (sizeof (AvahiServiceBrowser));
 329     tmp->client = client;
 330     tmp->callback = callback;
 331     tmp->user_data = user_data;
 332     tmp->path = strdup (path);
 333
 334     AVAHI_LLIST_PREPEND(AvahiServiceBrowser, service_browsers, client->service_browsers, tmp);
 335
 336     return tmp;
 337
 338 dbus_error:
 339     dbus_error_free (&error);
 340     avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
 341
 342     return NULL;
 343 }
 344
 345 int
 346 avahi_service_browser_free (AvahiServiceBrowser *b)
 347 {
 348     AvahiClient *client = b->client;
 349     DBusMessage *message = NULL;
 350
 351     if (b == NULL || b->path == NULL)
 352         return avahi_client_set_errno (client, AVAHI_ERR_INVALID_OBJECT);
 353
 354     message = dbus_message_new_method_call (AVAHI_DBUS_NAME,
 355             b->path,
 356             AVAHI_DBUS_INTERFACE_SERVICE_BROWSER, "Free");
 357
 358     if (message == NULL)
 359         return avahi_client_set_errno (client, AVAHI_ERR_DBUS_ERROR);
 360
 361     dbus_connection_send (b->client->bus, message, NULL);
 362
 363     AVAHI_LLIST_REMOVE(AvahiServiceBrowser, service_browsers, b->client->service_browsers, b);
 364
 365     free (b);
 366
 367     return avahi_client_set_errno (client, AVAHI_OK);
 368 }
 369
 370 char*
 371 avahi_service_browser_path (AvahiServiceBrowser *b)
 372 {
 373     return b->path;
 374 }
 375
 376 DBusHandlerResult
 377 avahi_service_browser_event (AvahiClient *client, AvahiBrowserEvent event, DBusMessage *message)
 378 {
 379     AvahiServiceBrowser *n, *db = NULL;
 380     DBusError error;
 381     const char *path;
 382     char *name, *type, *domain;
 383     int interface, protocol;
 384
 385     dbus_error_init (&error);
 386
 387     path = dbus_message_get_path (message);
 388
 389     if (path == NULL)
 390         goto out;
 391
 392     for (n = client->service_browsers; n != NULL; n = n->service_browsers_next)
 393     {
 394         printf ("cmp: %s, %s\n", n->path, path);
 395         if (strcmp (n->path, path) == 0) {
 396             db = n;
 397             break;
 398         }
 399     }
 400
 401     if (db == NULL)
 402         goto out;
 403
 404     dbus_message_get_args (message, &error,
 405             DBUS_TYPE_INT32, &interface,
 406             DBUS_TYPE_INT32, &protocol,
 407             DBUS_TYPE_STRING, &name,
 408             DBUS_TYPE_STRING, &type,
 409             DBUS_TYPE_STRING, &domain,
 410             DBUS_TYPE_INVALID);
 411
 412     if (dbus_error_is_set (&error))
 413         goto out;
 414
 415     db->callback (db, interface, protocol, event, name, type, domain, db->user_data);
 416
 417     return DBUS_HANDLER_RESULT_HANDLED;
 418
 419 out:
 420     dbus_error_free (&error);
 421     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 422 }
 423
 424