1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
3 * Copyright (C) 2008 Red Hat, Inc.
13 #include <libsoup/soup.h>
15 #include "test-utils.h"
19 SoupBuffer *chunks[3];
24 error_chunk_allocator (SoupMessage *msg, gsize max_len, gpointer user_data)
26 /* This should never be called, because there is no response body. */
27 debug_printf (1, " error_chunk_allocator called!\n");
29 return soup_buffer_new (SOUP_MEMORY_TAKE, g_malloc (100), 100);
33 write_next_chunk (SoupMessage *msg, gpointer user_data)
35 PutTestData *ptd = user_data;
37 debug_printf (2, " writing chunk\n");
39 if (ptd->next > 0 && ptd->chunks[ptd->next - 1]) {
40 debug_printf (1, " error: next chunk requested before last one freed!\n");
44 if (ptd->next < G_N_ELEMENTS (ptd->chunks)) {
45 soup_message_body_append_buffer (msg->request_body,
46 ptd->chunks[ptd->next]);
47 soup_buffer_free (ptd->chunks[ptd->next]);
50 soup_message_body_complete (msg->request_body);
51 soup_session_unpause_message (ptd->session, msg);
55 wrote_body_data (SoupMessage *msg, SoupBuffer *chunk, gpointer user_data)
57 PutTestData *ptd = user_data;
59 debug_printf (2, " wrote_body_data, %d bytes\n",
61 ptd->nwrote += chunk->length;
65 clear_buffer_ptr (gpointer data)
67 SoupBuffer **buffer_ptr = data;
69 debug_printf (2, " clearing chunk\n");
71 (*buffer_ptr)->length = 0;
72 g_free ((char *)(*buffer_ptr)->data);
75 debug_printf (2, " chunk is already clear!\n");
80 /* Put a chunk containing @text into *@buffer, set up so that it will
81 * clear out *@buffer when the chunk is freed, allowing us to make sure
82 * the set_accumulate(FALSE) is working.
85 make_put_chunk (SoupBuffer **buffer, const char *text)
87 *buffer = soup_buffer_new_with_owner (g_strdup (text), strlen (text),
88 buffer, clear_buffer_ptr);
92 do_request_test (SoupSession *session, SoupURI *base_uri)
96 const char *client_md5, *server_md5;
100 debug_printf (1, "PUT\n");
102 ptd.session = session;
103 make_put_chunk (&ptd.chunks[0], "one\r\n");
104 make_put_chunk (&ptd.chunks[1], "two\r\n");
105 make_put_chunk (&ptd.chunks[2], "three\r\n");
106 ptd.next = ptd.nwrote = 0;
108 check = g_checksum_new (G_CHECKSUM_MD5);
110 for (i = 0; i < 3; i++) {
111 g_checksum_update (check, (guchar *)ptd.chunks[i]->data,
112 ptd.chunks[i]->length);
113 length += ptd.chunks[i]->length;
115 client_md5 = g_checksum_get_string (check);
117 msg = soup_message_new_from_uri ("PUT", base_uri);
118 soup_message_headers_set_encoding (msg->request_headers, SOUP_ENCODING_CHUNKED);
119 soup_message_body_set_accumulate (msg->request_body, FALSE);
120 soup_message_set_chunk_allocator (msg, error_chunk_allocator, NULL, NULL);
121 g_signal_connect (msg, "wrote_headers",
122 G_CALLBACK (write_next_chunk), &ptd);
123 g_signal_connect (msg, "wrote_chunk",
124 G_CALLBACK (write_next_chunk), &ptd);
125 g_signal_connect (msg, "wrote_body_data",
126 G_CALLBACK (wrote_body_data), &ptd);
127 soup_session_send_message (session, msg);
129 if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
130 debug_printf (1, " message failed: %d %s\n",
131 msg->status_code, msg->reason_phrase);
135 if (msg->request_body->data) {
136 debug_printf (1, " msg->request_body set!\n");
139 if (msg->request_body->length != length || length != ptd.nwrote) {
140 debug_printf (1, " sent length mismatch: %d vs %d vs %d\n",
141 (int)msg->request_body->length, length, ptd.nwrote);
145 server_md5 = soup_message_headers_get (msg->response_headers, "Content-MD5");
146 if (!server_md5 || strcmp (client_md5, server_md5) != 0) {
147 debug_printf (1, " client/server data mismatch: %s vs %s\n",
148 client_md5, server_md5 ? server_md5 : "(null)");
152 g_object_unref (msg);
153 g_checksum_free (check);
157 SoupBuffer *current_chunk;
163 chunk_allocator (SoupMessage *msg, gsize max_len, gpointer user_data)
165 GetTestData *gtd = user_data;
167 debug_printf (2, " allocating chunk\n");
169 if (gtd->current_chunk) {
170 debug_printf (1, " error: next chunk allocated before last one freed!\n");
173 gtd->current_chunk = soup_buffer_new_with_owner (g_malloc (6), 6,
176 return gtd->current_chunk;
180 got_chunk (SoupMessage *msg, SoupBuffer *chunk, gpointer user_data)
182 GetTestData *gtd = user_data;
184 debug_printf (2, " got chunk, %d bytes\n",
186 if (chunk != gtd->current_chunk) {
187 debug_printf (1, "chunk mismatch! %p vs %p\n",
188 chunk, gtd->current_chunk);
191 g_checksum_update (gtd->check, (guchar *)chunk->data, chunk->length);
192 gtd->length += chunk->length;
196 do_response_test (SoupSession *session, SoupURI *base_uri)
200 const char *client_md5, *server_md5;
202 debug_printf (1, "GET\n");
204 gtd.current_chunk = NULL;
206 gtd.check = g_checksum_new (G_CHECKSUM_MD5);
208 msg = soup_message_new_from_uri ("GET", base_uri);
209 soup_message_body_set_accumulate (msg->response_body, FALSE);
210 soup_message_set_chunk_allocator (msg, chunk_allocator, >d, NULL);
211 g_signal_connect (msg, "got_chunk",
212 G_CALLBACK (got_chunk), >d);
213 soup_session_send_message (session, msg);
215 if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
216 debug_printf (1, " message failed: %d %s\n",
217 msg->status_code, msg->reason_phrase);
221 if (msg->response_body->data) {
222 debug_printf (1, " msg->response_body set!\n");
225 if (soup_message_headers_get_content_length (msg->response_headers) != gtd.length) {
226 debug_printf (1, " received length mismatch: %d vs %d\n",
227 (int)soup_message_headers_get_content_length (msg->response_headers), gtd.length);
231 client_md5 = g_checksum_get_string (gtd.check);
232 server_md5 = soup_message_headers_get (msg->response_headers, "Content-MD5");
233 if (!server_md5 || strcmp (client_md5, server_md5) != 0) {
234 debug_printf (1, " client/server data mismatch: %s vs %s\n",
235 client_md5, server_md5 ? server_md5 : "(null)");
239 g_object_unref (msg);
240 g_checksum_free (gtd.check);
243 /* Make sure TEMPORARY buffers are handled properly with non-accumulating
244 * message bodies. Part of https://bugs.webkit.org/show_bug.cgi?id=18343
248 temp_test_wrote_chunk (SoupMessage *msg, gpointer session)
250 /* When the bug is present, the second chunk will also be
251 * discarded after the first is written, which will cause
252 * the I/O to stall since soup-message-io will think it's
253 * done, but it hasn't written Content-Length bytes yet.
254 * So add in another chunk to keep it going.
256 if (!soup_message_body_get_chunk (msg->request_body,
258 debug_printf (1, " Lost second chunk!\n");
260 soup_session_abort (session);
263 g_signal_handlers_disconnect_by_func (msg, temp_test_wrote_chunk, session);
267 do_temporary_test (SoupSession *session, SoupURI *base_uri)
270 const char *client_md5, *server_md5;
272 debug_printf (1, "PUT w/ temporary buffers\n");
274 msg = soup_message_new_from_uri ("PUT", base_uri);
275 soup_message_body_append (msg->request_body, SOUP_MEMORY_TEMPORARY,
277 soup_message_body_append (msg->request_body, SOUP_MEMORY_STATIC,
279 soup_message_body_set_accumulate (msg->request_body, FALSE);
281 client_md5 = g_compute_checksum_for_string (G_CHECKSUM_MD5,
282 "one\r\ntwo\r\n", 10);
283 g_signal_connect (msg, "wrote_chunk",
284 G_CALLBACK (temp_test_wrote_chunk), session);
285 soup_session_send_message (session, msg);
287 if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
288 debug_printf (1, " message failed: %d %s\n",
289 msg->status_code, msg->reason_phrase);
293 server_md5 = soup_message_headers_get (msg->response_headers, "Content-MD5");
294 if (!server_md5 || strcmp (client_md5, server_md5) != 0) {
295 debug_printf (1, " client/server data mismatch: %s vs %s\n",
296 client_md5, server_md5 ? server_md5 : "(null)");
300 g_object_unref (msg);
304 do_chunk_tests (SoupURI *base_uri)
306 SoupSession *session;
308 session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
309 do_request_test (session, base_uri);
310 debug_printf (2, "\n\n");
311 do_response_test (session, base_uri);
312 debug_printf (2, "\n\n");
313 do_temporary_test (session, base_uri);
314 soup_test_session_abort_unref (session);
318 server_callback (SoupServer *server, SoupMessage *msg,
319 const char *path, GHashTable *query,
320 SoupClientContext *context, gpointer data)
322 SoupMessageBody *md5_body;
325 if (msg->method == SOUP_METHOD_GET) {
326 soup_message_set_response (msg, "text/plain",
328 "three\r\ntwo\r\none\r\n",
329 strlen ("three\r\ntwo\r\none\r\n"));
330 soup_buffer_free (soup_message_body_flatten (msg->response_body));
331 md5_body = msg->response_body;
332 soup_message_set_status (msg, SOUP_STATUS_OK);
333 } else if (msg->method == SOUP_METHOD_PUT) {
334 soup_message_set_status (msg, SOUP_STATUS_CREATED);
335 md5_body = msg->request_body;
337 soup_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED);
341 md5 = g_compute_checksum_for_data (G_CHECKSUM_MD5,
342 (guchar *)md5_body->data,
344 soup_message_headers_append (msg->response_headers,
350 main (int argc, char **argv)
357 test_init (argc, argv, NULL);
359 server = soup_test_server_new (TRUE);
360 soup_server_add_handler (server, NULL,
361 server_callback, NULL, NULL);
362 port = soup_server_get_port (server);
364 loop = g_main_loop_new (NULL, TRUE);
366 base_uri = soup_uri_new ("http://localhost");
367 soup_uri_set_port (base_uri, port);
368 do_chunk_tests (base_uri);
369 soup_uri_free (base_uri);
371 g_main_loop_unref (loop);