loudmouth/lm-resolver.c
changeset 725 05fa3e01e5b1
parent 712 ba47719252ad
child 728 35639729e565
equal deleted inserted replaced
724:3cd39dfd5ff7 725:05fa3e01e5b1
    34 #include "lm-debug.h"
    34 #include "lm-debug.h"
    35 #include "lm-internals.h"
    35 #include "lm-internals.h"
    36 #include "lm-marshal.h"
    36 #include "lm-marshal.h"
    37 #include "lm-resolver.h"
    37 #include "lm-resolver.h"
    38 
    38 
    39 #define GET_PRIV(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), LM_TYPE_RESOLVER, LmResolverPriv))
    39 #define GET_PRIV(obj) (lm_resolver_get_instance_private (LM_RESOLVER(obj)))
    40 
    40 
    41 typedef struct LmResolverPriv LmResolverPriv;
    41 typedef struct LmResolverPrivate LmResolverPrivate;
    42 struct LmResolverPriv {
    42 struct LmResolverPrivate {
    43     GMainContext       *context;
    43     GMainContext       *context;
    44 
    44 
    45     LmResolverCallback  callback;
    45     LmResolverCallback  callback;
    46     gpointer            user_data;
    46     gpointer            user_data;
    47 
    47 
    70 static void     resolver_set_property        (GObject           *object,
    70 static void     resolver_set_property        (GObject           *object,
    71                                               guint              param_id,
    71                                               guint              param_id,
    72                                               const GValue      *value,
    72                                               const GValue      *value,
    73                                               GParamSpec        *pspec);
    73                                               GParamSpec        *pspec);
    74 
    74 
    75 G_DEFINE_TYPE (LmResolver, lm_resolver, G_TYPE_OBJECT)
    75 G_DEFINE_TYPE_WITH_PRIVATE (LmResolver, lm_resolver, G_TYPE_OBJECT)
    76 
    76 
    77 enum {
    77 enum {
    78     PROP_0,
    78     PROP_0,
    79     PROP_CONTEXT,
    79     PROP_CONTEXT,
    80     PROP_TYPE,
    80     PROP_TYPE,
   151                                      g_param_spec_string ("protocol",
   151                                      g_param_spec_string ("protocol",
   152                                                           "Protocol",
   152                                                           "Protocol",
   153                                                           "Protocol for SRV lookup",
   153                                                           "Protocol for SRV lookup",
   154                                                           NULL,
   154                                                           NULL,
   155                                                           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
   155                                                           G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
   156 
       
   157     g_type_class_add_private (object_class, sizeof (LmResolverPriv));
       
   158 }
   156 }
   159 
   157 
   160 static void
   158 static void
   161 lm_resolver_init (LmResolver *resolver)
   159 lm_resolver_init (LmResolver *resolver)
   162 {
   160 {
   163 }
   161 }
   164 
   162 
   165 static void
   163 static void
   166 resolver_dispose (GObject *object)
   164 resolver_dispose (GObject *object)
   167 {
   165 {
   168     LmResolverPriv *priv = GET_PRIV (object);
   166     LmResolverPrivate *priv = GET_PRIV (object);
   169 
   167 
   170     if (priv->context) {
   168     if (priv->context) {
   171         g_main_context_unref (priv->context);
   169         g_main_context_unref (priv->context);
   172         priv->context = NULL;
   170         priv->context = NULL;
   173     }
   171     }
   176 }
   174 }
   177 
   175 
   178 static void
   176 static void
   179 resolver_finalize (GObject *object)
   177 resolver_finalize (GObject *object)
   180 {
   178 {
   181     LmResolverPriv *priv;
   179     LmResolverPrivate *priv;
   182 
   180 
   183     priv = GET_PRIV (object);
   181     priv = GET_PRIV (object);
   184 
   182 
   185     g_free (priv->host);
   183     g_free (priv->host);
   186     g_free (priv->domain);
   184     g_free (priv->domain);
   198 resolver_get_property (GObject    *object,
   196 resolver_get_property (GObject    *object,
   199                        guint       param_id,
   197                        guint       param_id,
   200                        GValue     *value,
   198                        GValue     *value,
   201                        GParamSpec *pspec)
   199                        GParamSpec *pspec)
   202 {
   200 {
   203     LmResolverPriv *priv;
   201     LmResolverPrivate *priv;
   204 
   202 
   205     priv = GET_PRIV (object);
   203     priv = GET_PRIV (object);
   206 
   204 
   207     switch (param_id) {
   205     switch (param_id) {
   208     case PROP_CONTEXT:
   206     case PROP_CONTEXT:
   236 resolver_set_property (GObject      *object,
   234 resolver_set_property (GObject      *object,
   237                        guint         param_id,
   235                        guint         param_id,
   238                        const GValue *value,
   236                        const GValue *value,
   239                        GParamSpec   *pspec)
   237                        GParamSpec   *pspec)
   240 {
   238 {
   241     LmResolverPriv *priv;
   239     LmResolverPrivate *priv;
   242 
   240 
   243     priv = GET_PRIV (object);
   241     priv = GET_PRIV (object);
   244 
   242 
   245     switch (param_id) {
   243     switch (param_id) {
   246     case PROP_CONTEXT:
   244     case PROP_CONTEXT:
   309 lm_resolver_new_for_host (const gchar        *host,
   307 lm_resolver_new_for_host (const gchar        *host,
   310                           LmResolverCallback  callback,
   308                           LmResolverCallback  callback,
   311                           gpointer            user_data)
   309                           gpointer            user_data)
   312 {
   310 {
   313     LmResolver     *resolver;
   311     LmResolver     *resolver;
   314     LmResolverPriv *priv;
   312     LmResolverPrivate *priv;
   315 
   313 
   316     g_return_val_if_fail (host != NULL, NULL);
   314     g_return_val_if_fail (host != NULL, NULL);
   317     g_return_val_if_fail (callback != NULL, NULL);
   315     g_return_val_if_fail (callback != NULL, NULL);
   318 
   316 
   319     resolver =  g_object_new (resolver_get_gtype (),
   317     resolver =  g_object_new (resolver_get_gtype (),
   335                              const gchar        *protocol,
   333                              const gchar        *protocol,
   336                              LmResolverCallback  callback,
   334                              LmResolverCallback  callback,
   337                              gpointer            user_data)
   335                              gpointer            user_data)
   338 {
   336 {
   339     LmResolver     *resolver;
   337     LmResolver     *resolver;
   340     LmResolverPriv *priv;
   338     LmResolverPrivate *priv;
   341 
   339 
   342     g_return_val_if_fail (domain != NULL, NULL);
   340     g_return_val_if_fail (domain != NULL, NULL);
   343     g_return_val_if_fail (service != NULL, NULL);
   341     g_return_val_if_fail (service != NULL, NULL);
   344     g_return_val_if_fail (protocol != NULL, NULL);
   342     g_return_val_if_fail (protocol != NULL, NULL);
   345     g_return_val_if_fail (callback != NULL, NULL);
   343     g_return_val_if_fail (callback != NULL, NULL);
   381 
   379 
   382 /* To iterate through the results */
   380 /* To iterate through the results */
   383 struct addrinfo *
   381 struct addrinfo *
   384 lm_resolver_results_get_next (LmResolver *resolver)
   382 lm_resolver_results_get_next (LmResolver *resolver)
   385 {
   383 {
   386     LmResolverPriv  *priv;
   384     LmResolverPrivate  *priv;
   387     struct addrinfo *ret_val;
   385     struct addrinfo *ret_val;
   388 
   386 
   389     g_return_val_if_fail (LM_IS_RESOLVER (resolver), NULL);
   387     g_return_val_if_fail (LM_IS_RESOLVER (resolver), NULL);
   390 
   388 
   391     priv = GET_PRIV (resolver);
   389     priv = GET_PRIV (resolver);
   409 }
   407 }
   410 
   408 
   411 void
   409 void
   412 lm_resolver_results_reset (LmResolver *resolver)
   410 lm_resolver_results_reset (LmResolver *resolver)
   413 {
   411 {
   414     LmResolverPriv *priv;
   412     LmResolverPrivate *priv;
   415 
   413 
   416     g_return_if_fail (LM_IS_RESOLVER (resolver));
   414     g_return_if_fail (LM_IS_RESOLVER (resolver));
   417 
   415 
   418     priv = GET_PRIV (resolver);
   416     priv = GET_PRIV (resolver);
   419 
   417 
   435 void
   433 void
   436 _lm_resolver_set_result (LmResolver       *resolver,
   434 _lm_resolver_set_result (LmResolver       *resolver,
   437                          LmResolverResult  result,
   435                          LmResolverResult  result,
   438                          struct addrinfo  *results)
   436                          struct addrinfo  *results)
   439 {
   437 {
   440     LmResolverPriv *priv;
   438     LmResolverPrivate *priv;
   441 
   439 
   442     g_return_if_fail (LM_IS_RESOLVER (resolver));
   440     g_return_if_fail (LM_IS_RESOLVER (resolver));
   443 
   441 
   444     priv = GET_PRIV (resolver);
   442     priv = GET_PRIV (resolver);
   445 
   443