tests/chunk-test.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Copyright (C) 2008 Red Hat, Inc.
   4  */
   5
   6 #include "config.h"
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11
  12 #include <glib.h>
  13 #include <libsoup/soup.h>
  14
  15 #include "test-utils.h"
  16
  17 typedef struct {
  18         SoupSession *session;
  19         SoupBuffer *chunks[3];
  20         int next, nwrote;
  21 } PutTestData;
  22
  23 static SoupBuffer *
  24 error_chunk_allocator (SoupMessage *msg, gsize max_len, gpointer user_data)
  25 {
  26         /* This should never be called, because there is no response body. */
  27         debug_printf (1, "  error_chunk_allocator called!\n");
  28         errors++;
  29         return soup_buffer_new (SOUP_MEMORY_TAKE, g_malloc (100), 100);
  30 }
  31
  32 static void
  33 write_next_chunk (SoupMessage *msg, gpointer user_data)
  34 {
  35         PutTestData *ptd = user_data;
  36
  37         debug_printf (2, "  writing chunk\n");
  38
  39         if (ptd->next > 0 && ptd->chunks[ptd->next - 1]) {
  40                 debug_printf (1, "  error: next chunk requested before last one freed!\n");
  41                 errors++;
  42         }
  43
  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]);
  48                 ptd->next++;
  49         } else
  50                 soup_message_body_complete (msg->request_body);
  51         soup_session_unpause_message (ptd->session, msg);
  52 }
  53
  54 static void
  55 wrote_body_data (SoupMessage *msg, SoupBuffer *chunk, gpointer user_data)
  56 {
  57         PutTestData *ptd = user_data;
  58
  59         debug_printf (2, "  wrote_body_data, %d bytes\n",
  60                       (int)chunk->length);
  61         ptd->nwrote += chunk->length;
  62 }
  63
  64 static void
  65 clear_buffer_ptr (gpointer data)
  66 {
  67         SoupBuffer **buffer_ptr = data;
  68
  69         debug_printf (2, "  clearing chunk\n");
  70         if (*buffer_ptr) {
  71                 (*buffer_ptr)->length = 0;
  72                 g_free ((char *)(*buffer_ptr)->data);
  73                 *buffer_ptr = NULL;
  74         } else {
  75                 debug_printf (2, "  chunk is already clear!\n");
  76                 errors++;
  77         }
  78 }
  79
  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.
  83  */
  84 static void
  85 make_put_chunk (SoupBuffer **buffer, const char *text)
  86 {
  87         *buffer = soup_buffer_new_with_owner (g_strdup (text), strlen (text),
  88                                               buffer, clear_buffer_ptr);
  89 }
  90
  91 static void
  92 do_request_test (SoupSession *session, SoupURI *base_uri)
  93 {
  94         PutTestData ptd;
  95         SoupMessage *msg;
  96         const char *client_md5, *server_md5;
  97         GChecksum *check;
  98         int i, length;
  99
 100         debug_printf (1, "PUT\n");
 101
 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;
 107
 108         check = g_checksum_new (G_CHECKSUM_MD5);
 109         length = 0;
 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;
 114         }
 115         client_md5 = g_checksum_get_string (check);
 116
 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);
 128
 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);
 132                 errors++;
 133         }
 134
 135         if (msg->request_body->data) {
 136                 debug_printf (1, "  msg->request_body set!\n");
 137                 errors++;
 138         }
 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);
 142                 errors++;
 143         }
 144
 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)");
 149                 errors++;
 150         }
 151
 152         g_object_unref (msg);
 153         g_checksum_free (check);
 154 }
 155
 156 typedef struct {
 157         SoupBuffer *current_chunk;
 158         GChecksum *check;
 159         int length;
 160 } GetTestData;
 161
 162 static SoupBuffer *
 163 chunk_allocator (SoupMessage *msg, gsize max_len, gpointer user_data)
 164 {
 165         GetTestData *gtd = user_data;
 166
 167         debug_printf (2, "  allocating chunk\n");
 168
 169         if (gtd->current_chunk) {
 170                 debug_printf (1, "  error: next chunk allocated before last one freed!\n");
 171                 errors++;
 172         }
 173         gtd->current_chunk = soup_buffer_new_with_owner (g_malloc (6), 6,
 174                                                          &gtd->current_chunk,
 175                                                          clear_buffer_ptr);
 176         return gtd->current_chunk;
 177 }
 178
 179 static void
 180 got_chunk (SoupMessage *msg, SoupBuffer *chunk, gpointer user_data)
 181 {
 182         GetTestData *gtd = user_data;
 183
 184         debug_printf (2, "  got chunk, %d bytes\n",
 185                       (int)chunk->length);
 186         if (chunk != gtd->current_chunk) {
 187                 debug_printf (1, "chunk mismatch! %p vs %p\n",
 188                               chunk, gtd->current_chunk);
 189         }
 190
 191         g_checksum_update (gtd->check, (guchar *)chunk->data, chunk->length);
 192         gtd->length += chunk->length;
 193 }
 194
 195 static void
 196 do_response_test (SoupSession *session, SoupURI *base_uri)
 197 {
 198         GetTestData gtd;
 199         SoupMessage *msg;
 200         const char *client_md5, *server_md5;
 201
 202         debug_printf (1, "GET\n");
 203
 204         gtd.current_chunk = NULL;
 205         gtd.length = 0;
 206         gtd.check = g_checksum_new (G_CHECKSUM_MD5);
 207
 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, &gtd, NULL);
 211         g_signal_connect (msg, "got_chunk",
 212                           G_CALLBACK (got_chunk), &gtd);
 213         soup_session_send_message (session, msg);
 214
 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);
 218                 errors++;
 219         }
 220
 221         if (msg->response_body->data) {
 222                 debug_printf (1, "  msg->response_body set!\n");
 223                 errors++;
 224         }
 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);
 228                 errors++;
 229         }
 230
 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)");
 236                 errors++;
 237         }
 238
 239         g_object_unref (msg);
 240         g_checksum_free (gtd.check);
 241 }
 242
 243 static void
 244 do_chunk_tests (SoupURI *base_uri)
 245 {
 246         SoupSession *session;
 247
 248         session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
 249         do_request_test (session, base_uri);
 250         debug_printf (2, "\n\n");
 251         do_response_test (session, base_uri);
 252         soup_test_session_abort_unref (session);
 253 }
 254
 255 static void
 256 server_callback (SoupServer *server, SoupMessage *msg,
 257                  const char *path, GHashTable *query,
 258                  SoupClientContext *context, gpointer data)
 259 {
 260         SoupMessageBody *md5_body;
 261         char *md5;
 262
 263         if (msg->method == SOUP_METHOD_GET) {
 264                 soup_message_set_response (msg, "text/plain",
 265                                            SOUP_MEMORY_STATIC,
 266                                            "three\r\ntwo\r\none\r\n",
 267                                            strlen ("three\r\ntwo\r\none\r\n"));
 268                 soup_buffer_free (soup_message_body_flatten (msg->response_body));
 269                 md5_body = msg->response_body;
 270                 soup_message_set_status (msg, SOUP_STATUS_OK);
 271         } else if (msg->method == SOUP_METHOD_PUT) {
 272                 soup_message_set_status (msg, SOUP_STATUS_CREATED);
 273                 md5_body = msg->request_body;
 274         } else {
 275                 soup_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED);
 276                 return;
 277         }
 278
 279         md5 = g_compute_checksum_for_data (G_CHECKSUM_MD5,
 280                                            (guchar *)md5_body->data,
 281                                            md5_body->length);
 282         soup_message_headers_append (msg->response_headers,
 283                                      "Content-MD5", md5);
 284         g_free (md5);
 285 }
 286
 287 int
 288 main (int argc, char **argv)
 289 {
 290         GMainLoop *loop;
 291         SoupServer *server;
 292         guint port;
 293         SoupURI *base_uri;
 294
 295         test_init (argc, argv, NULL);
 296
 297         server = soup_test_server_new (TRUE);
 298         soup_server_add_handler (server, NULL,
 299                                  server_callback, NULL, NULL);
 300         port =  soup_server_get_port (server);
 301
 302         loop = g_main_loop_new (NULL, TRUE);
 303
 304         base_uri = soup_uri_new ("http://localhost");
 305         soup_uri_set_port (base_uri, port);
 306         do_chunk_tests (base_uri);
 307         soup_uri_free (base_uri);
 308
 309         g_main_loop_unref (loop);
 310
 311         test_cleanup ();
 312         return errors != 0;
 313 }