403 lines
15 KiB
C
403 lines
15 KiB
C
/*
|
|
* ga-service-resolver.c - Source for GaServiceResolver
|
|
* Copyright (C) 2006-2007 Collabora Ltd.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "ga-service-resolver.h"
|
|
#include "signals-marshal.h"
|
|
|
|
#include "ga-error.h"
|
|
|
|
#include "ga-enums.h"
|
|
#include "ga-enums-enumtypes.h"
|
|
|
|
#include <avahi-client/lookup.h>
|
|
|
|
G_DEFINE_TYPE(GaServiceResolver, ga_service_resolver, G_TYPE_OBJECT)
|
|
|
|
/* signal enum */
|
|
enum {
|
|
FOUND,
|
|
FAILURE,
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
static guint signals[LAST_SIGNAL] = { 0 };
|
|
|
|
/* properties */
|
|
enum {
|
|
PROP_PROTOCOL = 1,
|
|
PROP_IFINDEX,
|
|
PROP_NAME,
|
|
PROP_TYPE,
|
|
PROP_DOMAIN,
|
|
PROP_FLAGS,
|
|
PROP_APROTOCOL
|
|
};
|
|
|
|
/* private structure */
|
|
typedef struct _GaServiceResolverPrivate GaServiceResolverPrivate;
|
|
|
|
struct _GaServiceResolverPrivate {
|
|
GaClient *client;
|
|
AvahiServiceResolver *resolver;
|
|
AvahiIfIndex interface;
|
|
AvahiProtocol protocol;
|
|
AvahiAddress address;
|
|
uint16_t port;
|
|
char *name;
|
|
char *type;
|
|
char *domain;
|
|
AvahiProtocol aprotocol;
|
|
AvahiLookupFlags flags;
|
|
gboolean dispose_has_run;
|
|
};
|
|
|
|
#define GA_SERVICE_RESOLVER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GA_TYPE_SERVICE_RESOLVER, GaServiceResolverPrivate))
|
|
|
|
static void ga_service_resolver_init(GaServiceResolver * obj) {
|
|
GaServiceResolverPrivate *priv = GA_SERVICE_RESOLVER_GET_PRIVATE(obj);
|
|
|
|
/* allocate any data required by the object here */
|
|
priv->client = NULL;
|
|
priv->resolver = NULL;
|
|
priv->name = NULL;
|
|
priv->type = NULL;
|
|
priv->domain = NULL;
|
|
priv->port = 0;
|
|
}
|
|
|
|
static void ga_service_resolver_dispose(GObject * object);
|
|
static void ga_service_resolver_finalize(GObject * object);
|
|
|
|
static void ga_service_resolver_set_property(GObject * object,
|
|
guint property_id,
|
|
const GValue * value, GParamSpec * pspec) {
|
|
GaServiceResolver *resolver = GA_SERVICE_RESOLVER(object);
|
|
GaServiceResolverPrivate *priv =
|
|
GA_SERVICE_RESOLVER_GET_PRIVATE(resolver);
|
|
|
|
g_assert(priv->resolver == NULL);
|
|
switch (property_id) {
|
|
case PROP_PROTOCOL:
|
|
priv->protocol = g_value_get_enum(value);
|
|
break;
|
|
case PROP_APROTOCOL:
|
|
priv->aprotocol = g_value_get_enum(value);
|
|
break;
|
|
case PROP_IFINDEX:
|
|
priv->interface = g_value_get_int(value);
|
|
break;
|
|
case PROP_NAME:
|
|
priv->name = g_strdup(g_value_get_string(value));
|
|
break;
|
|
case PROP_TYPE:
|
|
priv->type = g_strdup(g_value_get_string(value));
|
|
break;
|
|
case PROP_DOMAIN:
|
|
priv->domain = g_strdup(g_value_get_string(value));
|
|
break;
|
|
case PROP_FLAGS:
|
|
priv->flags = g_value_get_enum(value);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void ga_service_resolver_get_property(GObject * object,
|
|
guint property_id,
|
|
GValue * value, GParamSpec * pspec) {
|
|
GaServiceResolver *resolver = GA_SERVICE_RESOLVER(object);
|
|
GaServiceResolverPrivate *priv =
|
|
GA_SERVICE_RESOLVER_GET_PRIVATE(resolver);
|
|
|
|
switch (property_id) {
|
|
case PROP_APROTOCOL:
|
|
g_value_set_enum(value, priv->aprotocol);
|
|
break;
|
|
case PROP_PROTOCOL:
|
|
g_value_set_enum(value, priv->protocol);
|
|
break;
|
|
case PROP_IFINDEX:
|
|
g_value_set_int(value, priv->interface);
|
|
break;
|
|
case PROP_NAME:
|
|
g_value_set_string(value, priv->name);
|
|
break;
|
|
case PROP_TYPE:
|
|
g_value_set_string(value, priv->type);
|
|
break;
|
|
case PROP_DOMAIN:
|
|
g_value_set_string(value, priv->domain);
|
|
break;
|
|
case PROP_FLAGS:
|
|
g_value_set_enum(value, priv->flags);
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
static void ga_service_resolver_class_init(GaServiceResolverClass *
|
|
ga_service_resolver_class) {
|
|
GObjectClass *object_class = G_OBJECT_CLASS(ga_service_resolver_class);
|
|
GParamSpec *param_spec;
|
|
|
|
g_type_class_add_private(ga_service_resolver_class,
|
|
sizeof (GaServiceResolverPrivate));
|
|
|
|
object_class->set_property = ga_service_resolver_set_property;
|
|
object_class->get_property = ga_service_resolver_get_property;
|
|
|
|
object_class->dispose = ga_service_resolver_dispose;
|
|
object_class->finalize = ga_service_resolver_finalize;
|
|
|
|
signals[FOUND] =
|
|
g_signal_new("found",
|
|
G_OBJECT_CLASS_TYPE(ga_service_resolver_class),
|
|
G_SIGNAL_RUN_LAST,
|
|
0,
|
|
NULL, NULL,
|
|
_ga_signals_marshal_VOID__INT_ENUM_STRING_STRING_STRING_STRING_POINTER_INT_POINTER_INT,
|
|
G_TYPE_NONE, 10,
|
|
G_TYPE_INT,
|
|
GA_TYPE_PROTOCOL,
|
|
G_TYPE_STRING,
|
|
G_TYPE_STRING,
|
|
G_TYPE_STRING,
|
|
G_TYPE_STRING,
|
|
G_TYPE_POINTER,
|
|
G_TYPE_INT,
|
|
G_TYPE_POINTER, GA_TYPE_LOOKUP_RESULT_FLAGS);
|
|
|
|
signals[FAILURE] =
|
|
g_signal_new("failure",
|
|
G_OBJECT_CLASS_TYPE(ga_service_resolver_class),
|
|
G_SIGNAL_RUN_LAST,
|
|
0,
|
|
NULL, NULL,
|
|
g_cclosure_marshal_VOID__POINTER,
|
|
G_TYPE_NONE, 1, G_TYPE_POINTER);
|
|
|
|
param_spec = g_param_spec_enum("protocol", "Avahi protocol to resolve on",
|
|
"Avahi protocol to resolve on",
|
|
GA_TYPE_PROTOCOL,
|
|
GA_PROTOCOL_UNSPEC,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_NAME |
|
|
G_PARAM_STATIC_BLURB);
|
|
g_object_class_install_property(object_class, PROP_PROTOCOL, param_spec);
|
|
|
|
param_spec = g_param_spec_enum("aprotocol", "Address protocol",
|
|
"Avahi protocol of the address to be resolved",
|
|
GA_TYPE_PROTOCOL,
|
|
GA_PROTOCOL_UNSPEC,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_NAME |
|
|
G_PARAM_STATIC_BLURB);
|
|
g_object_class_install_property(object_class, PROP_APROTOCOL, param_spec);
|
|
|
|
param_spec = g_param_spec_int("interface", "interface index",
|
|
"Interface use for resolver",
|
|
AVAHI_IF_UNSPEC,
|
|
G_MAXINT,
|
|
AVAHI_IF_UNSPEC,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB);
|
|
g_object_class_install_property(object_class, PROP_IFINDEX, param_spec);
|
|
|
|
param_spec = g_param_spec_string("name", "service name",
|
|
"name to resolve",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_NAME |
|
|
G_PARAM_STATIC_BLURB);
|
|
g_object_class_install_property(object_class, PROP_NAME, param_spec);
|
|
|
|
param_spec = g_param_spec_string("type", "service type",
|
|
"Service type to browse for",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_NAME |
|
|
G_PARAM_STATIC_BLURB);
|
|
g_object_class_install_property(object_class, PROP_TYPE, param_spec);
|
|
|
|
param_spec = g_param_spec_string("domain", "service domain",
|
|
"Domain to browse in",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_NAME |
|
|
G_PARAM_STATIC_BLURB);
|
|
g_object_class_install_property(object_class, PROP_DOMAIN, param_spec);
|
|
|
|
param_spec = g_param_spec_enum("flags", "Lookup flags for the resolver",
|
|
"Resolver lookup flags",
|
|
GA_TYPE_LOOKUP_FLAGS,
|
|
GA_LOOKUP_NO_FLAGS,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_STATIC_NAME |
|
|
G_PARAM_STATIC_BLURB);
|
|
g_object_class_install_property(object_class, PROP_FLAGS, param_spec);
|
|
}
|
|
|
|
void ga_service_resolver_dispose(GObject * object) {
|
|
GaServiceResolver *self = GA_SERVICE_RESOLVER(object);
|
|
GaServiceResolverPrivate *priv = GA_SERVICE_RESOLVER_GET_PRIVATE(self);
|
|
|
|
if (priv->dispose_has_run)
|
|
return;
|
|
|
|
priv->dispose_has_run = TRUE;
|
|
|
|
if (priv->client)
|
|
g_object_unref(priv->client);
|
|
priv->client = NULL;
|
|
|
|
if (priv->resolver)
|
|
avahi_service_resolver_free(priv->resolver);
|
|
priv->resolver = NULL;
|
|
|
|
/* release any references held by the object here */
|
|
|
|
if (G_OBJECT_CLASS(ga_service_resolver_parent_class)->dispose)
|
|
G_OBJECT_CLASS(ga_service_resolver_parent_class)->dispose(object);
|
|
}
|
|
|
|
void ga_service_resolver_finalize(GObject * object) {
|
|
GaServiceResolver *self = GA_SERVICE_RESOLVER(object);
|
|
GaServiceResolverPrivate *priv = GA_SERVICE_RESOLVER_GET_PRIVATE(self);
|
|
|
|
/* free any data held directly by the object here */
|
|
g_free(priv->name);
|
|
priv->name = NULL;
|
|
|
|
g_free(priv->type);
|
|
priv->type = NULL;
|
|
|
|
g_free(priv->domain);
|
|
priv->domain = NULL;
|
|
|
|
G_OBJECT_CLASS(ga_service_resolver_parent_class)->finalize(object);
|
|
}
|
|
|
|
static void _avahi_service_resolver_cb(AVAHI_GCC_UNUSED AvahiServiceResolver * resolver,
|
|
AvahiIfIndex interface,
|
|
AvahiProtocol protocol,
|
|
AvahiResolverEvent event,
|
|
const char *name, const char *type,
|
|
const char *domain, const char *host_name,
|
|
const AvahiAddress * a,
|
|
uint16_t port,
|
|
AvahiStringList * txt,
|
|
AvahiLookupResultFlags flags, void *userdata) {
|
|
GaServiceResolver *self = GA_SERVICE_RESOLVER(userdata);
|
|
GaServiceResolverPrivate *priv = GA_SERVICE_RESOLVER_GET_PRIVATE(self);
|
|
|
|
switch (event) {
|
|
case AVAHI_RESOLVER_FOUND:{
|
|
/* FIXME: Double check if this address is always the same */
|
|
priv->address = *a;
|
|
priv->port = port;
|
|
g_signal_emit(self, signals[FOUND], 0,
|
|
interface, protocol,
|
|
name, type,
|
|
domain, host_name, a, port, txt, flags);
|
|
break;
|
|
}
|
|
case AVAHI_RESOLVER_FAILURE:{
|
|
GError *error;
|
|
int aerrno = avahi_client_errno(priv->client->avahi_client);
|
|
error = g_error_new(GA_ERROR, aerrno,
|
|
"Resolving failed: %s",
|
|
avahi_strerror(aerrno));
|
|
g_signal_emit(self, signals[FAILURE], 0, error);
|
|
g_error_free(error);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
GaServiceResolver *ga_service_resolver_new(AvahiIfIndex interface,
|
|
AvahiProtocol protocol,
|
|
const gchar * name,
|
|
const gchar * type,
|
|
const gchar * domain,
|
|
AvahiProtocol address_protocol,
|
|
GaLookupFlags flags) {
|
|
return g_object_new(GA_TYPE_SERVICE_RESOLVER, "interface", interface,
|
|
"protocol", protocol, "name", name, "type", type,
|
|
"domain", domain, "aprotocol", address_protocol,
|
|
"flags", flags, NULL);
|
|
}
|
|
|
|
gboolean ga_service_resolver_attach(GaServiceResolver * resolver,
|
|
GaClient * client, GError ** error) {
|
|
GaServiceResolverPrivate *priv =
|
|
GA_SERVICE_RESOLVER_GET_PRIVATE(resolver);
|
|
|
|
g_assert(client != NULL);
|
|
g_object_ref(client);
|
|
|
|
priv->client = client;
|
|
|
|
priv->resolver = avahi_service_resolver_new(client->avahi_client,
|
|
priv->interface,
|
|
priv->protocol,
|
|
priv->name,
|
|
priv->type, priv->domain,
|
|
priv->aprotocol,
|
|
priv->flags,
|
|
_avahi_service_resolver_cb,
|
|
resolver);
|
|
if (priv->resolver == NULL) {
|
|
if (error != NULL) {
|
|
int aerrno = avahi_client_errno(client->avahi_client);
|
|
*error = g_error_new(GA_ERROR, aerrno,
|
|
"Attaching group failed: %s",
|
|
avahi_strerror(aerrno));
|
|
}
|
|
/* printf("Failed to add resolver\n"); */
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean ga_service_resolver_get_address(GaServiceResolver * resolver,
|
|
AvahiAddress * address, uint16_t * port) {
|
|
GaServiceResolverPrivate *priv =
|
|
GA_SERVICE_RESOLVER_GET_PRIVATE(resolver);
|
|
if (priv->port == 0) {
|
|
/* printf("PORT == 0\n"); */
|
|
return FALSE;
|
|
}
|
|
|
|
*address = priv->address;
|
|
*port = priv->port;
|
|
return TRUE;
|
|
}
|