git.meshlink.io Git - catta/blob - avahi-gobject/ga-service-resolver.c

   1 /*
   2  * ga-service-resolver.c - Source for GaServiceResolver
   3  * Copyright (C) 2006-2007 Collabora Ltd.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26
  27 #include "ga-service-resolver.h"
  28 #include "signals-marshal.h"
  29
  30 #include "ga-error.h"
  31
  32 #include "ga-enums.h"
  33 #include "ga-enums-enumtypes.h"
  34
  35 #include <avahi-client/lookup.h>
  36
  37 G_DEFINE_TYPE(GaServiceResolver, ga_service_resolver, G_TYPE_OBJECT)
  38
  39 /* signal enum */
  40 enum {
  41     FOUND,
  42     FAILURE,
  43     LAST_SIGNAL
  44 };
  45
  46 static guint signals[LAST_SIGNAL] = { 0 };
  47
  48 /* properties */
  49 enum {
  50     PROP_PROTOCOL = 1,
  51     PROP_IFINDEX,
  52     PROP_NAME,
  53     PROP_TYPE,
  54     PROP_DOMAIN,
  55     PROP_FLAGS,
  56     PROP_APROTOCOL
  57 };
  58
  59 /* private structure */
  60 typedef struct _GaServiceResolverPrivate GaServiceResolverPrivate;
  61
  62 struct _GaServiceResolverPrivate {
  63     GaClient *client;
  64     AvahiServiceResolver *resolver;
  65     AvahiIfIndex interface;
  66     AvahiProtocol protocol;
  67     AvahiAddress address;
  68     uint16_t port;
  69     char *name;
  70     char *type;
  71     char *domain;
  72     AvahiProtocol aprotocol;
  73     AvahiLookupFlags flags;
  74     gboolean dispose_has_run;
  75 };
  76
  77 #define GA_SERVICE_RESOLVER_GET_PRIVATE(o)     (G_TYPE_INSTANCE_GET_PRIVATE ((o), GA_TYPE_SERVICE_RESOLVER, GaServiceResolverPrivate))
  78
  79 static void ga_service_resolver_init(GaServiceResolver * obj) {
  80     GaServiceResolverPrivate *priv = GA_SERVICE_RESOLVER_GET_PRIVATE(obj);
  81
  82     /* allocate any data required by the object here */
  83     priv->client = NULL;
  84     priv->resolver = NULL;
  85     priv->name = NULL;
  86     priv->type = NULL;
  87     priv->domain = NULL;
  88     priv->port = 0;
  89 }
  90
  91 static void ga_service_resolver_dispose(GObject * object);
  92 static void ga_service_resolver_finalize(GObject * object);
  93
  94 static void ga_service_resolver_set_property(GObject * object,
  95                                  guint property_id,
  96                                  const GValue * value, GParamSpec * pspec) {
  97     GaServiceResolver *resolver = GA_SERVICE_RESOLVER(object);
  98     GaServiceResolverPrivate *priv =
  99             GA_SERVICE_RESOLVER_GET_PRIVATE(resolver);
 100
 101     g_assert(priv->resolver == NULL);
 102     switch (property_id) {
 103         case PROP_PROTOCOL:
 104             priv->protocol = g_value_get_enum(value);
 105             break;
 106         case PROP_APROTOCOL:
 107             priv->aprotocol = g_value_get_enum(value);
 108             break;
 109         case PROP_IFINDEX:
 110             priv->interface = g_value_get_int(value);
 111             break;
 112         case PROP_NAME:
 113             priv->name = g_strdup(g_value_get_string(value));
 114             break;
 115         case PROP_TYPE:
 116             priv->type = g_strdup(g_value_get_string(value));
 117             break;
 118         case PROP_DOMAIN:
 119             priv->domain = g_strdup(g_value_get_string(value));
 120             break;
 121         case PROP_FLAGS:
 122             priv->flags = g_value_get_enum(value);
 123             break;
 124         default:
 125             G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 126             break;
 127     }
 128 }
 129
 130 static void ga_service_resolver_get_property(GObject * object,
 131                                  guint property_id,
 132                                  GValue * value, GParamSpec * pspec) {
 133     GaServiceResolver *resolver = GA_SERVICE_RESOLVER(object);
 134     GaServiceResolverPrivate *priv =
 135             GA_SERVICE_RESOLVER_GET_PRIVATE(resolver);
 136
 137     switch (property_id) {
 138         case PROP_APROTOCOL:
 139             g_value_set_enum(value, priv->aprotocol);
 140             break;
 141         case PROP_PROTOCOL:
 142             g_value_set_enum(value, priv->protocol);
 143             break;
 144         case PROP_IFINDEX:
 145             g_value_set_int(value, priv->interface);
 146             break;
 147         case PROP_NAME:
 148             g_value_set_string(value, priv->name);
 149             break;
 150         case PROP_TYPE:
 151             g_value_set_string(value, priv->type);
 152             break;
 153         case PROP_DOMAIN:
 154             g_value_set_string(value, priv->domain);
 155             break;
 156         case PROP_FLAGS:
 157             g_value_set_enum(value, priv->flags);
 158             break;
 159         default:
 160             G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 161             break;
 162     }
 163 }
 164
 165
 166 static void ga_service_resolver_class_init(GaServiceResolverClass *
 167                                ga_service_resolver_class) {
 168     GObjectClass *object_class = G_OBJECT_CLASS(ga_service_resolver_class);
 169     GParamSpec *param_spec;
 170
 171     g_type_class_add_private(ga_service_resolver_class,
 172                              sizeof (GaServiceResolverPrivate));
 173
 174     object_class->set_property = ga_service_resolver_set_property;
 175     object_class->get_property = ga_service_resolver_get_property;
 176
 177     object_class->dispose = ga_service_resolver_dispose;
 178     object_class->finalize = ga_service_resolver_finalize;
 179
 180     signals[FOUND] =
 181             g_signal_new("found",
 182                          G_OBJECT_CLASS_TYPE(ga_service_resolver_class),
 183                          G_SIGNAL_RUN_LAST,
 184                          0,
 185                          NULL, NULL,
 186                          _ga_signals_marshal_VOID__INT_ENUM_STRING_STRING_STRING_STRING_POINTER_INT_POINTER_INT,
 187                          G_TYPE_NONE, 10,
 188                          G_TYPE_INT,
 189                          GA_TYPE_PROTOCOL,
 190                          G_TYPE_STRING,
 191                          G_TYPE_STRING,
 192                          G_TYPE_STRING,
 193                          G_TYPE_STRING,
 194                          G_TYPE_POINTER,
 195                          G_TYPE_INT,
 196                          G_TYPE_POINTER, GA_TYPE_LOOKUP_RESULT_FLAGS);
 197
 198     signals[FAILURE] =
 199             g_signal_new("failure",
 200                          G_OBJECT_CLASS_TYPE(ga_service_resolver_class),
 201                          G_SIGNAL_RUN_LAST,
 202                          0,
 203                          NULL, NULL,
 204                          g_cclosure_marshal_VOID__POINTER,
 205                          G_TYPE_NONE, 1, G_TYPE_POINTER);
 206
 207     param_spec = g_param_spec_enum("protocol", "Avahi protocol to resolve on",
 208                                    "Avahi protocol to resolve on",
 209                                    GA_TYPE_PROTOCOL,
 210                                    GA_PROTOCOL_UNSPEC,
 211                                    G_PARAM_READWRITE |
 212                                    G_PARAM_STATIC_NAME |
 213                                    G_PARAM_STATIC_BLURB);
 214     g_object_class_install_property(object_class, PROP_PROTOCOL, param_spec);
 215
 216     param_spec = g_param_spec_enum("aprotocol", "Address protocol",
 217                                    "Avahi protocol of the address to be resolved",
 218                                    GA_TYPE_PROTOCOL,
 219                                    GA_PROTOCOL_UNSPEC,
 220                                    G_PARAM_READWRITE |
 221                                    G_PARAM_STATIC_NAME |
 222                                    G_PARAM_STATIC_BLURB);
 223     g_object_class_install_property(object_class, PROP_APROTOCOL, param_spec);
 224
 225     param_spec = g_param_spec_int("interface", "interface index",
 226                                   "Interface use for resolver",
 227                                   AVAHI_IF_UNSPEC,
 228                                   G_MAXINT,
 229                                   AVAHI_IF_UNSPEC,
 230                                   G_PARAM_READWRITE |
 231                                   G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB);
 232     g_object_class_install_property(object_class, PROP_IFINDEX, param_spec);
 233
 234     param_spec = g_param_spec_string("name", "service name",
 235                                      "name to resolve",
 236                                      NULL,
 237                                      G_PARAM_READWRITE |
 238                                      G_PARAM_STATIC_NAME |
 239                                      G_PARAM_STATIC_BLURB);
 240     g_object_class_install_property(object_class, PROP_NAME, param_spec);
 241
 242     param_spec = g_param_spec_string("type", "service type",
 243                                      "Service type to browse for",
 244                                      NULL,
 245                                      G_PARAM_READWRITE |
 246                                      G_PARAM_STATIC_NAME |
 247                                      G_PARAM_STATIC_BLURB);
 248     g_object_class_install_property(object_class, PROP_TYPE, param_spec);
 249
 250     param_spec = g_param_spec_string("domain", "service domain",
 251                                      "Domain to browse in",
 252                                      NULL,
 253                                      G_PARAM_READWRITE |
 254                                      G_PARAM_STATIC_NAME |
 255                                      G_PARAM_STATIC_BLURB);
 256     g_object_class_install_property(object_class, PROP_DOMAIN, param_spec);
 257
 258     param_spec = g_param_spec_enum("flags", "Lookup flags for the resolver",
 259                                    "Resolver lookup flags",
 260                                    GA_TYPE_LOOKUP_FLAGS,
 261                                    GA_LOOKUP_NO_FLAGS,
 262                                    G_PARAM_READWRITE |
 263                                    G_PARAM_STATIC_NAME |
 264                                    G_PARAM_STATIC_BLURB);
 265     g_object_class_install_property(object_class, PROP_FLAGS, param_spec);
 266 }
 267
 268 void ga_service_resolver_dispose(GObject * object) {
 269     GaServiceResolver *self = GA_SERVICE_RESOLVER(object);
 270     GaServiceResolverPrivate *priv = GA_SERVICE_RESOLVER_GET_PRIVATE(self);
 271
 272     if (priv->dispose_has_run)
 273         return;
 274
 275     priv->dispose_has_run = TRUE;
 276
 277     if (priv->client)
 278         g_object_unref(priv->client);
 279     priv->client = NULL;
 280
 281     if (priv->resolver)
 282         avahi_service_resolver_free(priv->resolver);
 283     priv->resolver = NULL;
 284
 285     /* release any references held by the object here */
 286
 287     if (G_OBJECT_CLASS(ga_service_resolver_parent_class)->dispose)
 288         G_OBJECT_CLASS(ga_service_resolver_parent_class)->dispose(object);
 289 }
 290
 291 void ga_service_resolver_finalize(GObject * object) {
 292     GaServiceResolver *self = GA_SERVICE_RESOLVER(object);
 293     GaServiceResolverPrivate *priv = GA_SERVICE_RESOLVER_GET_PRIVATE(self);
 294
 295     /* free any data held directly by the object here */
 296     g_free(priv->name);
 297     priv->name = NULL;
 298
 299     g_free(priv->type);
 300     priv->type = NULL;
 301
 302     g_free(priv->domain);
 303     priv->domain = NULL;
 304
 305     G_OBJECT_CLASS(ga_service_resolver_parent_class)->finalize(object);
 306 }
 307
 308 static void _avahi_service_resolver_cb(AVAHI_GCC_UNUSED AvahiServiceResolver * resolver,
 309                            AvahiIfIndex interface,
 310                            AvahiProtocol protocol,
 311                            AvahiResolverEvent event,
 312                            const char *name, const char *type,
 313                            const char *domain, const char *host_name,
 314                            const AvahiAddress * a,
 315                            uint16_t port,
 316                            AvahiStringList * txt,
 317                            AvahiLookupResultFlags flags, void *userdata) {
 318     GaServiceResolver *self = GA_SERVICE_RESOLVER(userdata);
 319     GaServiceResolverPrivate *priv = GA_SERVICE_RESOLVER_GET_PRIVATE(self);
 320
 321     switch (event) {
 322         case AVAHI_RESOLVER_FOUND:{
 323                 /* FIXME: Double check if this address is always the same */
 324                 priv->address = *a;
 325                 priv->port = port;
 326                 g_signal_emit(self, signals[FOUND], 0,
 327                               interface, protocol,
 328                               name, type,
 329                               domain, host_name, a, port, txt, flags);
 330                 break;
 331             }
 332         case AVAHI_RESOLVER_FAILURE:{
 333                 GError *error;
 334                 int aerrno = avahi_client_errno(priv->client->avahi_client);
 335                 error = g_error_new(GA_ERROR, aerrno,
 336                                     "Resolving failed: %s",
 337                                     avahi_strerror(aerrno));
 338                 g_signal_emit(self, signals[FAILURE], 0, error);
 339                 g_error_free(error);
 340                 break;
 341             }
 342     }
 343 }
 344
 345
 346 GaServiceResolver *ga_service_resolver_new(AvahiIfIndex interface,
 347                                            AvahiProtocol protocol,
 348                                            const gchar * name,
 349                                            const gchar * type,
 350                                            const gchar * domain,
 351                                            AvahiProtocol address_protocol,
 352                                            GaLookupFlags flags) {
 353     return g_object_new(GA_TYPE_SERVICE_RESOLVER, "interface", interface,
 354                         "protocol", protocol, "name", name, "type", type,
 355                         "domain", domain, "aprotocol", address_protocol,
 356                         "flags", flags, NULL);
 357 }
 358
 359 gboolean ga_service_resolver_attach(GaServiceResolver * resolver,
 360                            GaClient * client, GError ** error) {
 361     GaServiceResolverPrivate *priv =
 362             GA_SERVICE_RESOLVER_GET_PRIVATE(resolver);
 363
 364     g_assert(client != NULL);
 365     g_object_ref(client);
 366
 367     priv->client = client;
 368
 369     priv->resolver = avahi_service_resolver_new(client->avahi_client,
 370                                                 priv->interface,
 371                                                 priv->protocol,
 372                                                 priv->name,
 373                                                 priv->type, priv->domain,
 374                                                 priv->aprotocol,
 375                                                 priv->flags,
 376                                                 _avahi_service_resolver_cb,
 377                                                 resolver);
 378     if (priv->resolver == NULL) {
 379         if (error != NULL) {
 380             int aerrno = avahi_client_errno(client->avahi_client);
 381             *error = g_error_new(GA_ERROR, aerrno,
 382                                  "Attaching group failed: %s",
 383                                  avahi_strerror(aerrno));
 384         }
 385 /*         printf("Failed to add resolver\n"); */
 386         return FALSE;
 387     }
 388     return TRUE;
 389 }
 390
 391 gboolean ga_service_resolver_get_address(GaServiceResolver * resolver,
 392                                 AvahiAddress * address, uint16_t * port) {
 393     GaServiceResolverPrivate *priv =
 394             GA_SERVICE_RESOLVER_GET_PRIVATE(resolver);
 395     if (priv->port == 0) {
 396 /*         printf("PORT == 0\n"); */
 397         return FALSE;
 398     }
 399
 400     *address = priv->address;
 401     *port = priv->port;
 402     return TRUE;
 403 }