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

   1 /*
   2  * ga-client.c - Source for GaClient
   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-client.h"
  28
  29 #include "ga-client-enumtypes.h"
  30 #include "ga-error.h"
  31
  32 /* FIXME what to do about glib-malloc ? */
  33 #include <avahi-glib/glib-watch.h>
  34 #include <avahi-glib/glib-malloc.h>
  35 #include <avahi-common/error.h>
  36 #include <avahi-common/timeval.h>
  37
  38 G_DEFINE_TYPE(GaClient, ga_client, G_TYPE_OBJECT)
  39
  40 /* signal enum */
  41 enum {
  42     STATE_CHANGED,
  43     LAST_SIGNAL
  44 };
  45
  46 static guint signals[LAST_SIGNAL] = { 0 };
  47
  48 /* properties */
  49 enum {
  50     PROP_STATE = 1,
  51     PROP_FLAGS
  52 };
  53
  54 /* private structure */
  55 typedef struct _GaClientPrivate GaClientPrivate;
  56
  57 struct _GaClientPrivate {
  58     AvahiGLibPoll *poll;
  59     GaClientFlags flags;
  60     GaClientState state;
  61     gboolean dispose_has_run;
  62 };
  63
  64 #define GA_CLIENT_GET_PRIVATE(o)     (G_TYPE_INSTANCE_GET_PRIVATE ((o), GA_TYPE_CLIENT, GaClientPrivate))
  65
  66 static void ga_client_init(GaClient * self) {
  67     GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(self);
  68     /* allocate any data required by the object here */
  69     self->avahi_client = NULL;
  70     priv->state = GA_CLIENT_STATE_NOT_STARTED;
  71     priv->flags = GA_CLIENT_FLAG_NO_FLAGS;
  72 }
  73
  74 static void ga_client_dispose(GObject * object);
  75 static void ga_client_finalize(GObject * object);
  76
  77 static void ga_client_set_property(GObject * object,
  78                        guint property_id,
  79                        const GValue * value, GParamSpec * pspec) {
  80     GaClient *client = GA_CLIENT(object);
  81     GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(client);
  82
  83     switch (property_id) {
  84         case PROP_FLAGS:
  85             g_assert(client->avahi_client == NULL);
  86             priv->flags = g_value_get_enum(value);
  87             break;
  88         default:
  89             G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
  90             break;
  91     }
  92 }
  93
  94 static void ga_client_get_property(GObject * object,
  95                        guint property_id,
  96                        GValue * value, GParamSpec * pspec) {
  97     GaClient *client = GA_CLIENT(object);
  98     GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(client);
  99
 100     switch (property_id) {
 101         case PROP_STATE:
 102             g_value_set_enum(value, priv->state);
 103             break;
 104         case PROP_FLAGS:
 105             g_value_set_enum(value, priv->flags);
 106         default:
 107             G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 108             break;
 109     }
 110 }
 111
 112 static void ga_client_class_init(GaClientClass * ga_client_class) {
 113     GObjectClass *object_class = G_OBJECT_CLASS(ga_client_class);
 114     GParamSpec *param_spec;
 115
 116     g_type_class_add_private(ga_client_class, sizeof (GaClientPrivate));
 117
 118
 119     object_class->dispose = ga_client_dispose;
 120     object_class->finalize = ga_client_finalize;
 121
 122     object_class->set_property = ga_client_set_property;
 123     object_class->get_property = ga_client_get_property;
 124
 125     param_spec = g_param_spec_enum("state", "Client state",
 126                                    "The state of the Avahi client",
 127                                    GA_TYPE_CLIENT_STATE,
 128                                    GA_CLIENT_STATE_NOT_STARTED,
 129                                    G_PARAM_READABLE |
 130                                    G_PARAM_STATIC_NAME |
 131                                    G_PARAM_STATIC_BLURB);
 132     g_object_class_install_property(object_class, PROP_STATE, param_spec);
 133
 134     param_spec = g_param_spec_enum("flags", "Client flags",
 135                                    "The flags the Avahi client is started with",
 136                                    GA_TYPE_CLIENT_FLAGS,
 137                                    GA_CLIENT_FLAG_NO_FLAGS,
 138                                    G_PARAM_READWRITE |
 139                                    G_PARAM_CONSTRUCT_ONLY |
 140                                    G_PARAM_STATIC_NAME |
 141                                    G_PARAM_STATIC_BLURB);
 142     g_object_class_install_property(object_class, PROP_FLAGS, param_spec);
 143
 144     signals[STATE_CHANGED] =
 145             g_signal_new("state-changed",
 146                          G_OBJECT_CLASS_TYPE(ga_client_class),
 147                          G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
 148                          0,
 149                          NULL, NULL,
 150                          g_cclosure_marshal_VOID__ENUM,
 151                          G_TYPE_NONE, 1, GA_TYPE_CLIENT_STATE);
 152
 153 }
 154
 155 void ga_client_dispose(GObject * object) {
 156     GaClient *self = GA_CLIENT(object);
 157     GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(self);
 158
 159     if (priv->dispose_has_run)
 160         return;
 161
 162     priv->dispose_has_run = TRUE;
 163
 164     if (self->avahi_client) {
 165         avahi_client_free(self->avahi_client);
 166         self->avahi_client = NULL;
 167     }
 168     if (priv->poll) {
 169         avahi_glib_poll_free(priv->poll);
 170         priv->poll = NULL;
 171     }
 172
 173     /* release any references held by the object here */
 174     if (G_OBJECT_CLASS(ga_client_parent_class)->dispose)
 175         G_OBJECT_CLASS(ga_client_parent_class)->dispose(object);
 176 }
 177
 178 void ga_client_finalize(GObject * object) {
 179
 180     /* free any data held directly by the object here */
 181     G_OBJECT_CLASS(ga_client_parent_class)->finalize(object);
 182 }
 183
 184 GaClient *ga_client_new(GaClientFlags flags) {
 185     return g_object_new(GA_TYPE_CLIENT, "flags", flags, NULL);
 186 }
 187
 188 static GQuark detail_for_state(AvahiClientState state) {
 189     static struct {
 190         AvahiClientState state;
 191         const gchar *name;
 192         GQuark quark;
 193     } states[] = {
 194         { AVAHI_CLIENT_S_REGISTERING, "registering", 0},
 195         { AVAHI_CLIENT_S_RUNNING, "running", 0},
 196         { AVAHI_CLIENT_S_COLLISION, "collistion", 0},
 197         { AVAHI_CLIENT_FAILURE, "failure", 0},
 198         { AVAHI_CLIENT_CONNECTING, "connecting", 0},
 199         { 0, NULL, 0}
 200     };
 201     int i;
 202
 203     for (i = 0; states[i].name != NULL; i++) {
 204         if (state != states[i].state)
 205             continue;
 206
 207         if (!states[i].quark)
 208             states[i].quark = g_quark_from_static_string(states[i].name);
 209 /*         printf("Detail: %s\n", states[i].name); */
 210         return states[i].quark;
 211     }
 212     g_assert_not_reached();
 213 }
 214
 215 static void _avahi_client_cb(AvahiClient * c, AvahiClientState state, void *data) {
 216     GaClient *self = GA_CLIENT(data);
 217     GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(self);
 218
 219 /*     printf("CLIENT CB: %d\n", state); */
 220
 221     /* Avahi can call the callback before return from _client_new */
 222     if (self->avahi_client == NULL)
 223         self->avahi_client = c;
 224
 225     g_assert(c == self->avahi_client);
 226     priv->state = state;
 227     g_signal_emit(self, signals[STATE_CHANGED],
 228                   detail_for_state(state), state);
 229 }
 230
 231 gboolean ga_client_start(GaClient * client, GError ** error) {
 232     GaClientPrivate *priv = GA_CLIENT_GET_PRIVATE(client);
 233     AvahiClient *aclient;
 234     int aerror;
 235
 236     g_assert(client->avahi_client == NULL);
 237     g_assert(priv->poll == NULL);
 238
 239     avahi_set_allocator(avahi_glib_allocator());
 240
 241     priv->poll = avahi_glib_poll_new(NULL, G_PRIORITY_DEFAULT);
 242
 243     aclient = avahi_client_new(avahi_glib_poll_get(priv->poll),
 244                                priv->flags,
 245                                _avahi_client_cb, client, &aerror);
 246     if (aclient == NULL) {
 247         if (error != NULL) {
 248             *error = g_error_new(GA_ERROR, aerror,
 249                                  "Failed to create avahi client: %s",
 250                                  avahi_strerror(aerror));
 251         }
 252         return FALSE;
 253     }
 254     client->avahi_client = aclient;
 255     return TRUE;
 256 }