loudmouth/lm-resolver.c
changeset 728 35639729e565
parent 726 ea6aaf57f344
parent 725 05fa3e01e5b1
child 733 3a3f9df8b9fd
equal deleted inserted replaced
727:4d5bce4b7832 728:35639729e565
    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);
   403 }
   401 }
   404 
   402 
   405 void
   403 void
   406 lm_resolver_results_reset (LmResolver *resolver)
   404 lm_resolver_results_reset (LmResolver *resolver)
   407 {
   405 {
   408     LmResolverPriv *priv;
   406     LmResolverPrivate *priv;
   409 
   407 
   410     g_return_if_fail (LM_IS_RESOLVER (resolver));
   408     g_return_if_fail (LM_IS_RESOLVER (resolver));
   411 
   409 
   412     priv = GET_PRIV (resolver);
   410     priv = GET_PRIV (resolver);
   413 
   411 
   429 void
   427 void
   430 _lm_resolver_set_result (LmResolver       *resolver,
   428 _lm_resolver_set_result (LmResolver       *resolver,
   431                          LmResolverResult  result,
   429                          LmResolverResult  result,
   432                          struct addrinfo  *results)
   430                          struct addrinfo  *results)
   433 {
   431 {
   434     LmResolverPriv *priv;
   432     LmResolverPrivate *priv;
   435 
   433 
   436     g_return_if_fail (LM_IS_RESOLVER (resolver));
   434     g_return_if_fail (LM_IS_RESOLVER (resolver));
   437 
   435 
   438     priv = GET_PRIV (resolver);
   436     priv = GET_PRIV (resolver);
   439 
   437