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