1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* soup-proxy-resolver.c: HTTP proxy resolver interface
*
* Copyright (C) 2008 Red Hat, Inc.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "soup-proxy-resolver.h"
#include "soup.h"
static void soup_proxy_resolver_default_init (SoupProxyResolverInterface *iface);
static void soup_proxy_resolver_uri_resolver_interface_init (SoupProxyURIResolverInterface *uri_resolver_interface);
G_DEFINE_INTERFACE_WITH_CODE (SoupProxyResolver, soup_proxy_resolver, G_TYPE_OBJECT,
g_type_interface_add_prerequisite (g_define_type_id, SOUP_TYPE_SESSION_FEATURE);
)
static void
proxy_resolver_interface_check (gpointer func_data, gpointer g_iface)
{
GTypeInterface *iface = g_iface;
if (iface->g_type != SOUP_TYPE_PROXY_RESOLVER)
return;
/* If the class hasn't already declared that it implements
* SoupProxyURIResolver, add our own compat implementation.
*/
if (!g_type_is_a (iface->g_instance_type, SOUP_TYPE_PROXY_URI_RESOLVER)) {
const GInterfaceInfo uri_resolver_interface_info = {
(GInterfaceInitFunc) soup_proxy_resolver_uri_resolver_interface_init, NULL, NULL
};
g_type_add_interface_static (iface->g_instance_type,
SOUP_TYPE_PROXY_URI_RESOLVER,
&uri_resolver_interface_info);
}
}
static void
soup_proxy_resolver_default_init (SoupProxyResolverInterface *iface)
{
/* Add an interface_check where we can kludgily add the
* SoupProxyURIResolver interface to all SoupProxyResolvers.
* (SoupProxyResolver can't just implement
* SoupProxyURIResolver itself because interface types can't
* implement other interfaces.) This is an ugly hack, but it
* only gets used if someone actually creates a
* SoupProxyResolver...
*/
g_type_add_interface_check (NULL, proxy_resolver_interface_check);
}
void
soup_proxy_resolver_get_proxy_async (SoupProxyResolver *proxy_resolver,
SoupMessage *msg,
GMainContext *async_context,
GCancellable *cancellable,
SoupProxyResolverCallback callback,
gpointer user_data)
{
SOUP_PROXY_RESOLVER_GET_CLASS (proxy_resolver)->
get_proxy_async (proxy_resolver, msg,
async_context, cancellable,
callback, user_data);
}
guint
soup_proxy_resolver_get_proxy_sync (SoupProxyResolver *proxy_resolver,
SoupMessage *msg,
GCancellable *cancellable,
SoupAddress **addr)
{
return SOUP_PROXY_RESOLVER_GET_CLASS (proxy_resolver)->
get_proxy_sync (proxy_resolver, msg, cancellable, addr);
}
/* SoupProxyURIResolver implementation */
static SoupURI *
uri_from_address (SoupAddress *addr)
{
SoupURI *proxy_uri;
proxy_uri = soup_uri_new (NULL);
soup_uri_set_scheme (proxy_uri, SOUP_URI_SCHEME_HTTP);
soup_uri_set_host (proxy_uri, soup_address_get_name (addr));
soup_uri_set_port (proxy_uri, soup_address_get_port (addr));
soup_uri_set_path (proxy_uri, "");
return proxy_uri;
}
typedef struct {
SoupProxyURIResolverCallback callback;
gpointer user_data;
} ProxyURIResolverAsyncData;
static void
compat_got_proxy (SoupProxyResolver *proxy_resolver,
SoupMessage *msg, guint status, SoupAddress *proxy_addr,
gpointer user_data)
{
ProxyURIResolverAsyncData *purad = user_data;
SoupURI *proxy_uri;
proxy_uri = proxy_addr ? uri_from_address (proxy_addr) : NULL;
purad->callback (SOUP_PROXY_URI_RESOLVER (proxy_resolver),
status, proxy_uri, purad->user_data);
g_object_unref (msg);
if (proxy_uri)
soup_uri_free (proxy_uri);
g_slice_free (ProxyURIResolverAsyncData, purad);
}
static void
compat_get_proxy_uri_async (SoupProxyURIResolver *proxy_uri_resolver,
SoupURI *uri, GMainContext *async_context,
GCancellable *cancellable,
SoupProxyURIResolverCallback callback,
gpointer user_data)
{
SoupMessage *dummy_msg;
ProxyURIResolverAsyncData *purad;
dummy_msg = soup_message_new_from_uri (SOUP_METHOD_GET, uri);
purad = g_slice_new (ProxyURIResolverAsyncData);
purad->callback = callback;
purad->user_data = user_data;
soup_proxy_resolver_get_proxy_async (
SOUP_PROXY_RESOLVER (proxy_uri_resolver), dummy_msg,
async_context, cancellable,
compat_got_proxy, purad);
}
static guint
compat_get_proxy_uri_sync (SoupProxyURIResolver *proxy_uri_resolver,
SoupURI *uri, GCancellable *cancellable,
SoupURI **proxy_uri)
{
SoupMessage *dummy_msg;
SoupAddress *proxy_addr = NULL;
guint status;
dummy_msg = soup_message_new_from_uri (SOUP_METHOD_GET, uri);
status = soup_proxy_resolver_get_proxy_sync (
SOUP_PROXY_RESOLVER (proxy_uri_resolver), dummy_msg,
cancellable, &proxy_addr);
g_object_unref (dummy_msg);
if (!proxy_addr)
return status;
*proxy_uri = uri_from_address (proxy_addr);
g_object_unref (proxy_addr);
return status;
}
static void
soup_proxy_resolver_uri_resolver_interface_init (SoupProxyURIResolverInterface *uri_resolver_interface)
{
uri_resolver_interface->get_proxy_uri_async = compat_get_proxy_uri_async;
uri_resolver_interface->get_proxy_uri_sync = compat_get_proxy_uri_sync;
}
|
