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
169
170
171
172
173
174
175
176
177
178
179
180
|
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
* soup-message-client-io.c: client-side request/response
*
* Copyright (C) 2000-2003, Ximian, Inc.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <string.h>
#include "soup-message-private.h"
#include "soup-auth.h"
#include "soup-headers.h"
#include "soup-uri.h"
static guint
parse_response_headers (SoupMessage *req,
char *headers, guint headers_len,
SoupTransferEncoding *encoding,
guint *content_len,
gpointer user_data)
{
const char *length, *enc;
SoupHttpVersion version;
GHashTable *resp_hdrs;
SoupMethodId meth_id;
if (!soup_headers_parse_response (headers, headers_len,
req->response_headers,
&version,
&req->status_code,
(char **) &req->reason_phrase))
return SOUP_STATUS_MALFORMED;
if (version < req->priv->http_version)
req->priv->http_version = version;
meth_id = soup_method_get_id (req->method);
resp_hdrs = req->response_headers;
/*
* Special case zero body handling for:
* - HEAD requests (where content-length must be ignored)
* - CONNECT requests (no body expected)
* - No Content (204) responses (no message-body allowed)
* - Reset Content (205) responses (no entity allowed)
* - Not Modified (304) responses (no message-body allowed)
* - 1xx Informational responses (where no body is allowed)
*/
if (meth_id == SOUP_METHOD_ID_HEAD ||
meth_id == SOUP_METHOD_ID_CONNECT ||
req->status_code == SOUP_STATUS_NO_CONTENT ||
req->status_code == SOUP_STATUS_RESET_CONTENT ||
req->status_code == SOUP_STATUS_NOT_MODIFIED ||
SOUP_STATUS_IS_INFORMATIONAL (req->status_code)) {
*encoding = SOUP_TRANSFER_CONTENT_LENGTH;
*content_len = 0;
return SOUP_STATUS_OK;
}
/*
* Handle Chunked encoding. Prefer Chunked over a Content-Length to
* support broken Traffic-Server proxies that supply both.
*/
enc = soup_message_get_header (resp_hdrs, "Transfer-Encoding");
if (enc) {
if (g_strcasecmp (enc, "chunked") == 0) {
*encoding = SOUP_TRANSFER_CHUNKED;
return SOUP_STATUS_OK;
} else
return SOUP_STATUS_MALFORMED;
}
/*
* Handle Content-Length encoding
*/
length = soup_message_get_header (resp_hdrs, "Content-Length");
if (length) {
int len;
*encoding = SOUP_TRANSFER_CONTENT_LENGTH;
len = atoi (length);
if (len < 0)
return SOUP_STATUS_MALFORMED;
else
*content_len = len;
}
return SOUP_STATUS_OK;
}
static void
add_header (gpointer name, gpointer value, gpointer data)
{
GString *headers = data;
g_string_append_printf (headers, "%s: %s\r\n",
(char *)name, (char *)value);
}
static void
get_request_headers (SoupMessage *req, GString *header,
SoupTransferEncoding *encoding,
gpointer user_data)
{
gboolean proxy = GPOINTER_TO_UINT (user_data);
const SoupUri *uri = soup_message_get_uri (req);
const char *expect;
char *uri_string;
if (!strcmp (req->method, "CONNECT")) {
/* CONNECT URI is hostname:port for tunnel destination */
uri_string = g_strdup_printf ("%s:%d", uri->host, uri->port);
} else {
/* Proxy expects full URI to destination. Otherwise
* just the path.
*/
uri_string = soup_uri_to_string (uri, !proxy);
}
if (req->priv->http_version == SOUP_HTTP_1_0) {
g_string_append_printf (header, "%s %s HTTP/1.0\r\n",
req->method, uri_string);
} else {
g_string_append_printf (header, "%s %s HTTP/1.1\r\n",
req->method, uri_string);
if (soup_uri_uses_default_port (uri)) {
g_string_append_printf (header, "Host: %s\r\n",
uri->host);
} else {
g_string_append_printf (header, "Host: %s:%d\r\n",
uri->host, uri->port);
}
}
g_free (uri_string);
if (req->request.length > 0) {
if (!soup_message_get_header (req->request_headers,
"Content-Type")) {
g_string_append (header, "Content-Type: text/xml; "
"charset=utf-8\r\n");
}
g_string_append_printf (header, "Content-Length: %d\r\n",
req->request.length);
*encoding = SOUP_TRANSFER_CONTENT_LENGTH;
}
soup_message_foreach_header (req->request_headers, add_header, header);
g_string_append (header, "\r\n");
expect = soup_message_get_header (req->request_headers, "Expect");
if (expect && !strcmp (expect, "100-continue"))
req->priv->msg_flags |= SOUP_MESSAGE_EXPECT_CONTINUE;
}
/**
* soup_message_send_request:
* @req: a #SoupMessage
* @sock: the #SoupSocket to send @req on
* @is_via_proxy: %TRUE if @sock is a connection to a proxy server
* rather than a direct connection to the desired HTTP server
*
* Begins the process of sending @msg across @sock. (If @sock is
* synchronous, then soup_message_send_request() won't return until
* the response has been received.)
**/
void
soup_message_send_request (SoupMessage *req, SoupSocket *sock,
gboolean is_via_proxy)
{
soup_message_cleanup_response (req);
soup_message_io_client (req, sock,
get_request_headers,
parse_response_headers,
GUINT_TO_POINTER (is_via_proxy));
}
|
