libsoup/soup-proxy-resolver-static.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * soup-proxy-resolver-static.c: Static proxy "resolution"
   4  *
   5  * Copyright (C) 2008 Red Hat, Inc.
   6  */
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include <config.h>
  10 #endif
  11
  12 #include <string.h>
  13
  14 #include "soup-proxy-resolver-static.h"
  15 #include "soup-address.h"
  16 #include "soup-message.h"
  17 #include "soup-misc.h"
  18 #include "soup-session-feature.h"
  19
  20 typedef struct {
  21         SoupURI *proxy_uri;
  22
  23 } SoupProxyResolverStaticPrivate;
  24 #define SOUP_PROXY_RESOLVER_STATIC_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUP_TYPE_PROXY_RESOLVER_STATIC, SoupProxyResolverStaticPrivate))
  25
  26 static void soup_proxy_resolver_static_interface_init (SoupProxyURIResolverInterface *proxy_resolver_interface);
  27
  28 G_DEFINE_TYPE_EXTENDED (SoupProxyResolverStatic, soup_proxy_resolver_static, G_TYPE_OBJECT, 0,
  29                         G_IMPLEMENT_INTERFACE (SOUP_TYPE_SESSION_FEATURE, NULL)
  30                         G_IMPLEMENT_INTERFACE (SOUP_TYPE_PROXY_URI_RESOLVER, soup_proxy_resolver_static_interface_init))
  31
  32 enum {
  33         PROP_0,
  34
  35         PROP_PROXY_URI,
  36
  37         LAST_PROP
  38 };
  39
  40 static void set_property (GObject *object, guint prop_id,
  41                           const GValue *value, GParamSpec *pspec);
  42 static void get_property (GObject *object, guint prop_id,
  43                           GValue *value, GParamSpec *pspec);
  44
  45 static void get_proxy_uri_async (SoupProxyURIResolver  *proxy_resolver,
  46                                  SoupURI               *uri,
  47                                  GMainContext          *async_context,
  48                                  GCancellable          *cancellable,
  49                                  SoupProxyURIResolverCallback callback,
  50                                  gpointer               user_data);
  51 static guint get_proxy_uri_sync (SoupProxyURIResolver  *proxy_resolver,
  52                                  SoupURI               *uri,
  53                                  GCancellable          *cancellable,
  54                                  SoupURI              **proxy_uri);
  55
  56 static void
  57 soup_proxy_resolver_static_init (SoupProxyResolverStatic *resolver_static)
  58 {
  59 }
  60
  61 static void
  62 finalize (GObject *object)
  63 {
  64         SoupProxyResolverStaticPrivate *priv =
  65                 SOUP_PROXY_RESOLVER_STATIC_GET_PRIVATE (object);
  66
  67         if (priv->proxy_uri)
  68                 soup_uri_free (priv->proxy_uri);
  69
  70         G_OBJECT_CLASS (soup_proxy_resolver_static_parent_class)->finalize (object);
  71 }
  72
  73 static void
  74 soup_proxy_resolver_static_class_init (SoupProxyResolverStaticClass *static_class)
  75 {
  76         GObjectClass *object_class = G_OBJECT_CLASS (static_class);
  77
  78         g_type_class_add_private (static_class, sizeof (SoupProxyResolverStaticPrivate));
  79
  80         object_class->set_property = set_property;
  81         object_class->get_property = get_property;
  82         object_class->finalize = finalize;
  83
  84         g_object_class_install_property (
  85                 object_class, PROP_PROXY_URI,
  86                 g_param_spec_boxed (SOUP_PROXY_RESOLVER_STATIC_PROXY_URI,
  87                                     "Proxy URI",
  88                                     "The HTTP Proxy to use",
  89                                     SOUP_TYPE_URI,
  90                                     G_PARAM_READWRITE));
  91 }
  92
  93 static void
  94 set_property (GObject *object, guint prop_id,
  95               const GValue *value, GParamSpec *pspec)
  96 {
  97         SoupProxyResolverStaticPrivate *priv =
  98                 SOUP_PROXY_RESOLVER_STATIC_GET_PRIVATE (object);
  99         SoupURI *uri;
 100
 101         switch (prop_id) {
 102         case PROP_PROXY_URI:
 103                 uri = g_value_get_boxed (value);
 104                 if (priv->proxy_uri)
 105                         soup_uri_free (priv->proxy_uri);
 106
 107                 priv->proxy_uri = uri ? soup_uri_copy (uri) : NULL;
 108                 break;
 109         default:
 110                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 111                 break;
 112         }
 113 }
 114
 115 static void
 116 get_property (GObject *object, guint prop_id,
 117               GValue *value, GParamSpec *pspec)
 118 {
 119         SoupProxyResolverStaticPrivate *priv =
 120                 SOUP_PROXY_RESOLVER_STATIC_GET_PRIVATE (object);
 121
 122         switch (prop_id) {
 123         case PROP_PROXY_URI:
 124                 g_value_set_boxed (value, priv->proxy_uri);
 125                 break;
 126         default:
 127                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 128                 break;
 129         }
 130 }
 131
 132 static void
 133 soup_proxy_resolver_static_interface_init (SoupProxyURIResolverInterface *proxy_uri_resolver_interface)
 134 {
 135         proxy_uri_resolver_interface->get_proxy_uri_async = get_proxy_uri_async;
 136         proxy_uri_resolver_interface->get_proxy_uri_sync = get_proxy_uri_sync;
 137 }
 138
 139 SoupProxyURIResolver *
 140 soup_proxy_resolver_static_new (SoupURI *proxy_uri)
 141 {
 142         return g_object_new (SOUP_TYPE_PROXY_RESOLVER_STATIC,
 143                              SOUP_PROXY_RESOLVER_STATIC_PROXY_URI, proxy_uri,
 144                              NULL);
 145 }
 146
 147 typedef struct {
 148         SoupProxyURIResolver *proxy_resolver;
 149         SoupProxyURIResolverCallback callback;
 150         gpointer user_data;
 151 } SoupStaticAsyncData;
 152
 153 static gboolean
 154 idle_return_proxy_uri (gpointer data)
 155 {
 156         SoupStaticAsyncData *ssad = data;
 157         SoupProxyResolverStaticPrivate *priv =
 158                 SOUP_PROXY_RESOLVER_STATIC_GET_PRIVATE (ssad->proxy_resolver);
 159
 160         ssad->callback (ssad->proxy_resolver,
 161                         SOUP_STATUS_OK, priv->proxy_uri,
 162                         ssad->user_data);
 163         g_object_unref (ssad->proxy_resolver);
 164         g_slice_free (SoupStaticAsyncData, ssad);
 165
 166         return FALSE;
 167 }
 168
 169 static void
 170 get_proxy_uri_async (SoupProxyURIResolver  *proxy_resolver,
 171                      SoupURI               *uri,
 172                      GMainContext          *async_context,
 173                      GCancellable          *cancellable,
 174                      SoupProxyURIResolverCallback callback,
 175                      gpointer               user_data)
 176 {
 177         SoupStaticAsyncData *ssad;
 178
 179         ssad = g_slice_new0 (SoupStaticAsyncData);
 180         ssad->proxy_resolver = g_object_ref (proxy_resolver);
 181         ssad->callback = callback;
 182         ssad->user_data = user_data;
 183         soup_add_completion (async_context, idle_return_proxy_uri, ssad);
 184 }
 185
 186 static guint
 187 get_proxy_uri_sync (SoupProxyURIResolver  *proxy_resolver,
 188                     SoupURI               *uri,
 189                     GCancellable          *cancellable,
 190                     SoupURI              **proxy_uri)
 191 {
 192         SoupProxyResolverStaticPrivate *priv =
 193                 SOUP_PROXY_RESOLVER_STATIC_GET_PRIVATE (proxy_resolver);
 194
 195         *proxy_uri = soup_uri_copy (priv->proxy_uri);
 196         return SOUP_STATUS_OK;
 197 }