libsoup/soup-message.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * soup-message.c: HTTP request/response
   4  *
   5  * Copyright (C) 2000-2003, Ximian, Inc.
   6  */
   7
   8 #include <string.h>
   9
  10 #include "soup-auth.h"
  11 #include "soup-marshal.h"
  12 #include "soup-message.h"
  13 #include "soup-message-private.h"
  14 #include "soup-misc.h"
  15 #include "soup-uri.h"
  16
  17 #define PARENT_TYPE G_TYPE_OBJECT
  18 static GObjectClass *parent_class;
  19
  20 enum {
  21         WROTE_INFORMATIONAL,
  22         WROTE_HEADERS,
  23         WROTE_CHUNK,
  24         WROTE_BODY,
  25
  26         GOT_INFORMATIONAL,
  27         GOT_HEADERS,
  28         GOT_CHUNK,
  29         GOT_BODY,
  30
  31         RESTARTED,
  32         FINISHED,
  33
  34         LAST_SIGNAL
  35 };
  36
  37 static guint signals[LAST_SIGNAL] = { 0 };
  38
  39 static void wrote_body (SoupMessage *req);
  40 static void got_headers (SoupMessage *req);
  41 static void got_chunk (SoupMessage *req);
  42 static void got_body (SoupMessage *req);
  43 static void restarted (SoupMessage *req);
  44 static void finished (SoupMessage *req);
  45 static void free_chunks (SoupMessage *msg);
  46
  47 static void
  48 init (GObject *object)
  49 {
  50         SoupMessage *msg = SOUP_MESSAGE (object);
  51
  52         msg->priv = g_new0 (SoupMessagePrivate, 1);
  53
  54         msg->status  = SOUP_MESSAGE_STATUS_IDLE;
  55
  56         msg->request_headers = g_hash_table_new (soup_str_case_hash,
  57                                                  soup_str_case_equal);
  58
  59         msg->response_headers = g_hash_table_new (soup_str_case_hash,
  60                                                   soup_str_case_equal);
  61
  62         msg->priv->http_version = SOUP_HTTP_1_1;
  63 }
  64
  65 static void
  66 finalize (GObject *object)
  67 {
  68         SoupMessage *msg = SOUP_MESSAGE (object);
  69
  70         soup_message_io_cancel (msg);
  71
  72         if (msg->priv->uri)
  73                 soup_uri_free (msg->priv->uri);
  74
  75         if (msg->request.owner == SOUP_BUFFER_SYSTEM_OWNED)
  76                 g_free (msg->request.body);
  77         if (msg->response.owner == SOUP_BUFFER_SYSTEM_OWNED)
  78                 g_free (msg->response.body);
  79         free_chunks (msg);
  80
  81         soup_message_clear_headers (msg->request_headers);
  82         g_hash_table_destroy (msg->request_headers);
  83
  84         soup_message_clear_headers (msg->response_headers);
  85         g_hash_table_destroy (msg->response_headers);
  86
  87         g_slist_foreach (msg->priv->content_handlers, (GFunc) g_free, NULL);
  88         g_slist_free (msg->priv->content_handlers);
  89
  90         g_free ((char *) msg->reason_phrase);
  91
  92         g_free (msg->priv);
  93
  94         G_OBJECT_CLASS (parent_class)->finalize (object);
  95 }
  96
  97 static void
  98 class_init (GObjectClass *object_class)
  99 {
 100         SoupMessageClass *message_class = SOUP_MESSAGE_CLASS (object_class);
 101
 102         parent_class = g_type_class_ref (PARENT_TYPE);
 103
 104         /* virtual method definition */
 105         message_class->wrote_body   = wrote_body;
 106         message_class->got_headers  = got_headers;
 107         message_class->got_chunk    = got_chunk;
 108         message_class->got_body     = got_body;
 109         message_class->restarted    = restarted;
 110         message_class->finished     = finished;
 111
 112         /* virtual method override */
 113         object_class->finalize = finalize;
 114
 115         /* signals */
 116         signals[WROTE_INFORMATIONAL] =
 117                 g_signal_new ("wrote_informational",
 118                               G_OBJECT_CLASS_TYPE (object_class),
 119                               G_SIGNAL_RUN_FIRST,
 120                               G_STRUCT_OFFSET (SoupMessageClass, wrote_informational),
 121                               NULL, NULL,
 122                               soup_marshal_NONE__NONE,
 123                               G_TYPE_NONE, 0);
 124         signals[WROTE_HEADERS] =
 125                 g_signal_new ("wrote_headers",
 126                               G_OBJECT_CLASS_TYPE (object_class),
 127                               G_SIGNAL_RUN_FIRST,
 128                               G_STRUCT_OFFSET (SoupMessageClass, wrote_headers),
 129                               NULL, NULL,
 130                               soup_marshal_NONE__NONE,
 131                               G_TYPE_NONE, 0);
 132         signals[WROTE_CHUNK] =
 133                 g_signal_new ("wrote_chunk",
 134                               G_OBJECT_CLASS_TYPE (object_class),
 135                               G_SIGNAL_RUN_FIRST,
 136                               G_STRUCT_OFFSET (SoupMessageClass, wrote_chunk),
 137                               NULL, NULL,
 138                               soup_marshal_NONE__NONE,
 139                               G_TYPE_NONE, 0);
 140         signals[WROTE_BODY] =
 141                 g_signal_new ("wrote_body",
 142                               G_OBJECT_CLASS_TYPE (object_class),
 143                               G_SIGNAL_RUN_FIRST,
 144                               G_STRUCT_OFFSET (SoupMessageClass, wrote_body),
 145                               NULL, NULL,
 146                               soup_marshal_NONE__NONE,
 147                               G_TYPE_NONE, 0);
 148
 149         signals[GOT_INFORMATIONAL] =
 150                 g_signal_new ("got_informational",
 151                               G_OBJECT_CLASS_TYPE (object_class),
 152                               G_SIGNAL_RUN_FIRST,
 153                               G_STRUCT_OFFSET (SoupMessageClass, got_informational),
 154                               NULL, NULL,
 155                               soup_marshal_NONE__NONE,
 156                               G_TYPE_NONE, 0);
 157         signals[GOT_HEADERS] =
 158                 g_signal_new ("got_headers",
 159                               G_OBJECT_CLASS_TYPE (object_class),
 160                               G_SIGNAL_RUN_FIRST,
 161                               G_STRUCT_OFFSET (SoupMessageClass, got_headers),
 162                               NULL, NULL,
 163                               soup_marshal_NONE__NONE,
 164                               G_TYPE_NONE, 0);
 165         signals[GOT_CHUNK] =
 166                 g_signal_new ("got_chunk",
 167                               G_OBJECT_CLASS_TYPE (object_class),
 168                               G_SIGNAL_RUN_FIRST,
 169                               G_STRUCT_OFFSET (SoupMessageClass, got_chunk),
 170                               NULL, NULL,
 171                               soup_marshal_NONE__NONE,
 172                               G_TYPE_NONE, 0);
 173         signals[GOT_BODY] =
 174                 g_signal_new ("got_body",
 175                               G_OBJECT_CLASS_TYPE (object_class),
 176                               G_SIGNAL_RUN_FIRST,
 177                               G_STRUCT_OFFSET (SoupMessageClass, got_body),
 178                               NULL, NULL,
 179                               soup_marshal_NONE__NONE,
 180                               G_TYPE_NONE, 0);
 181
 182         signals[RESTARTED] =
 183                 g_signal_new ("restarted",
 184                               G_OBJECT_CLASS_TYPE (object_class),
 185                               G_SIGNAL_RUN_FIRST,
 186                               G_STRUCT_OFFSET (SoupMessageClass, restarted),
 187                               NULL, NULL,
 188                               soup_marshal_NONE__NONE,
 189                               G_TYPE_NONE, 0);
 190         signals[FINISHED] =
 191                 g_signal_new ("finished",
 192                               G_OBJECT_CLASS_TYPE (object_class),
 193                               G_SIGNAL_RUN_FIRST,
 194                               G_STRUCT_OFFSET (SoupMessageClass, finished),
 195                               NULL, NULL,
 196                               soup_marshal_NONE__NONE,
 197                               G_TYPE_NONE, 0);
 198 }
 199
 200 SOUP_MAKE_TYPE (soup_message, SoupMessage, class_init, init, PARENT_TYPE)
 201
 202
 203 /**
 204  * soup_message_new:
 205  * @method: the HTTP method for the created request
 206  * @uri_string: the destination endpoint (as a string)
 207  *
 208  * Creates a new empty #SoupMessage, which will connect to @uri
 209  *
 210  * Return value: the new #SoupMessage (or %NULL if @uri could not
 211  * be parsed).
 212  */
 213 SoupMessage *
 214 soup_message_new (const char *method, const char *uri_string)
 215 {
 216         SoupMessage *msg;
 217         SoupUri *uri;
 218
 219         uri = soup_uri_new (uri_string);
 220         if (!uri)
 221                 return NULL;
 222
 223         msg = g_object_new (SOUP_TYPE_MESSAGE, NULL);
 224         msg->method = method ? method : SOUP_METHOD_GET;
 225         msg->priv->uri = uri;
 226
 227         return msg;
 228 }
 229
 230 /**
 231  * soup_message_new_from_uri:
 232  * @method: the HTTP method for the created request
 233  * @uri: the destination endpoint (as a #SoupUri)
 234  *
 235  * Creates a new empty #SoupMessage, which will connect to @uri
 236  *
 237  * Return value: the new #SoupMessage
 238  */
 239 SoupMessage *
 240 soup_message_new_from_uri (const char *method, const SoupUri *uri)
 241 {
 242         SoupMessage *msg;
 243
 244         msg = g_object_new (SOUP_TYPE_MESSAGE, NULL);
 245         msg->method = method ? method : SOUP_METHOD_GET;
 246         msg->priv->uri = soup_uri_copy (uri);
 247
 248         return msg;
 249 }
 250
 251 /**
 252  * soup_message_set_request:
 253  * @msg: the message
 254  * @content_type: MIME Content-Type of the body
 255  * @req_owner: the #SoupOwnership of the passed data buffer.
 256  * @req_body: a data buffer containing the body of the message request.
 257  * @req_length: the byte length of @req_body.
 258  *
 259  * Convenience function to set the request body of a #SoupMessage
 260  */
 261 void
 262 soup_message_set_request (SoupMessage   *msg,
 263                           const char    *content_type,
 264                           SoupOwnership  req_owner,
 265                           char          *req_body,
 266                           gulong         req_length)
 267 {
 268         g_return_if_fail (SOUP_IS_MESSAGE (msg));
 269         g_return_if_fail (content_type != NULL);
 270         g_return_if_fail (req_body != NULL || req_length == 0);
 271
 272         soup_message_add_header (msg->request_headers,
 273                                  "Content-Type", content_type);
 274         msg->request.owner = req_owner;
 275         msg->request.body = req_body;
 276         msg->request.length = req_length;
 277 }
 278
 279 /**
 280  * soup_message_set_response:
 281  * @msg: the message
 282  * @content_type: MIME Content-Type of the body
 283  * @resp_owner: the #SoupOwnership of the passed data buffer.
 284  * @resp_body: a data buffer containing the body of the message response.
 285  * @resp_length: the byte length of @resp_body.
 286  *
 287  * Convenience function to set the response body of a #SoupMessage
 288  */
 289 void
 290 soup_message_set_response (SoupMessage   *msg,
 291                            const char    *content_type,
 292                            SoupOwnership  resp_owner,
 293                            char          *resp_body,
 294                            gulong         resp_length)
 295 {
 296         g_return_if_fail (SOUP_IS_MESSAGE (msg));
 297         g_return_if_fail (content_type != NULL);
 298         g_return_if_fail (resp_body != NULL || resp_length == 0);
 299
 300         soup_message_add_header (msg->response_headers,
 301                                  "Content-Type", content_type);
 302         msg->response.owner = resp_owner;
 303         msg->response.body = resp_body;
 304         msg->response.length = resp_length;
 305 }
 306
 307 void
 308 soup_message_wrote_informational (SoupMessage *msg)
 309 {
 310         g_signal_emit (msg, signals[WROTE_INFORMATIONAL], 0);
 311 }
 312
 313 void
 314 soup_message_wrote_headers (SoupMessage *msg)
 315 {
 316         g_signal_emit (msg, signals[WROTE_HEADERS], 0);
 317 }
 318
 319 void
 320 soup_message_wrote_chunk (SoupMessage *msg)
 321 {
 322         g_signal_emit (msg, signals[WROTE_CHUNK], 0);
 323 }
 324
 325 static void
 326 wrote_body (SoupMessage *req)
 327 {
 328         g_object_ref (req);
 329         soup_message_run_handlers (req, SOUP_HANDLER_POST_REQUEST);
 330         g_object_unref (req);
 331 }
 332
 333 void
 334 soup_message_wrote_body (SoupMessage *msg)
 335 {
 336         g_signal_emit (msg, signals[WROTE_BODY], 0);
 337 }
 338
 339 void
 340 soup_message_got_informational (SoupMessage *msg)
 341 {
 342         g_signal_emit (msg, signals[GOT_INFORMATIONAL], 0);
 343 }
 344
 345 static void
 346 got_headers (SoupMessage *req)
 347 {
 348         g_object_ref (req);
 349         soup_message_run_handlers (req, SOUP_HANDLER_PRE_BODY);
 350         if (SOUP_MESSAGE_IS_STARTING (req))
 351                 g_signal_stop_emission (req, signals[GOT_HEADERS], 0);
 352         g_object_unref (req);
 353 }
 354
 355 void
 356 soup_message_got_headers (SoupMessage *msg)
 357 {
 358         g_signal_emit (msg, signals[GOT_HEADERS], 0);
 359 }
 360
 361 static void
 362 got_chunk (SoupMessage *req)
 363 {
 364         g_object_ref (req);
 365         soup_message_run_handlers (req, SOUP_HANDLER_BODY_CHUNK);
 366         if (SOUP_MESSAGE_IS_STARTING (req))
 367                 g_signal_stop_emission (req, signals[GOT_CHUNK], 0);
 368         g_object_unref (req);
 369 }
 370
 371 void
 372 soup_message_got_chunk (SoupMessage *msg)
 373 {
 374         g_signal_emit (msg, signals[GOT_CHUNK], 0);
 375 }
 376
 377 static void
 378 got_body (SoupMessage *req)
 379 {
 380         g_object_ref (req);
 381         soup_message_run_handlers (req, SOUP_HANDLER_POST_BODY);
 382         if (SOUP_MESSAGE_IS_STARTING (req))
 383                 g_signal_stop_emission (req, signals[GOT_BODY], 0);
 384         g_object_unref (req);
 385 }
 386
 387 void
 388 soup_message_got_body (SoupMessage *msg)
 389 {
 390         g_signal_emit (msg, signals[GOT_BODY], 0);
 391 }
 392
 393 static void
 394 restarted (SoupMessage *req)
 395 {
 396         soup_message_io_cancel (req);
 397 }
 398
 399 void
 400 soup_message_restarted (SoupMessage *msg)
 401 {
 402         g_signal_emit (msg, signals[RESTARTED], 0);
 403 }
 404
 405 static void
 406 finished (SoupMessage *req)
 407 {
 408         soup_message_io_cancel (req);
 409         req->status = SOUP_MESSAGE_STATUS_FINISHED;
 410 }
 411
 412 void
 413 soup_message_finished (SoupMessage *msg)
 414 {
 415         g_signal_emit (msg, signals[FINISHED], 0);
 416 }
 417
 418 static gboolean
 419 free_header_list (gpointer name, gpointer vals, gpointer user_data)
 420 {
 421         g_free (name);
 422         g_slist_foreach (vals, (GFunc) g_free, NULL);
 423         g_slist_free (vals);
 424
 425         return TRUE;
 426 }
 427
 428 void
 429 soup_message_clear_headers (GHashTable *hash)
 430 {
 431         g_return_if_fail (hash != NULL);
 432
 433         g_hash_table_foreach_remove (hash, free_header_list, NULL);
 434 }
 435
 436 void
 437 soup_message_remove_header (GHashTable *hash, const char *name)
 438 {
 439         gpointer old_key, old_vals;
 440
 441         g_return_if_fail (hash != NULL);
 442         g_return_if_fail (name != NULL || name[0] != '\0');
 443
 444         if (g_hash_table_lookup_extended (hash, name, &old_key, &old_vals)) {
 445                 g_hash_table_remove (hash, name);
 446                 free_header_list (old_key, old_vals, NULL);
 447         }
 448 }
 449
 450 void
 451 soup_message_add_header (GHashTable *hash, const char *name, const char *value)
 452 {
 453         GSList *old_value;
 454
 455         g_return_if_fail (hash != NULL);
 456         g_return_if_fail (name != NULL || name [0] != '\0');
 457         g_return_if_fail (value != NULL);
 458
 459         old_value = g_hash_table_lookup (hash, name);
 460
 461         if (old_value)
 462                 g_slist_append (old_value, g_strdup (value));
 463         else {
 464                 g_hash_table_insert (hash, g_strdup (name),
 465                                      g_slist_append (NULL, g_strdup (value)));
 466         }
 467 }
 468
 469 /**
 470  * soup_message_get_header:
 471  * @hash: a header hash table
 472  * @name: header name.
 473  *
 474  * Lookup the first transport header in @hash with a key equal to
 475  * @name.
 476  *
 477  * Return value: the header's value or %NULL if not found.
 478  */
 479 const char *
 480 soup_message_get_header (GHashTable *hash, const char *name)
 481 {
 482         GSList *vals;
 483
 484         g_return_val_if_fail (hash != NULL, NULL);
 485         g_return_val_if_fail (name != NULL || name [0] != '\0', NULL);
 486
 487         vals = g_hash_table_lookup (hash, name);
 488         if (vals)
 489                 return vals->data;
 490
 491         return NULL;
 492 }
 493
 494 /**
 495  * soup_message_get_header_list:
 496  * @hash: a header hash table
 497  * @name: header name.
 498  *
 499  * Lookup the all transport request headers in @hash with a key equal
 500  * to @name.
 501  *
 502  * Return value: a const pointer to a #GSList of header values or
 503  * %NULL if not found.
 504  */
 505 const GSList *
 506 soup_message_get_header_list (GHashTable *hash, const char *name)
 507 {
 508         g_return_val_if_fail (hash != NULL, NULL);
 509         g_return_val_if_fail (name != NULL || name [0] != '\0', NULL);
 510
 511         return g_hash_table_lookup (hash, name);
 512 }
 513
 514 typedef struct {
 515         GHFunc   func;
 516         gpointer user_data;
 517 } SoupMessageForeachHeaderData;
 518
 519 static void
 520 foreach_value_in_list (gpointer name, gpointer value, gpointer user_data)
 521 {
 522         GSList *vals = value;
 523         SoupMessageForeachHeaderData *data = user_data;
 524
 525         while (vals) {
 526                 (*data->func) (name, vals->data, data->user_data);
 527                 vals = vals->next;
 528         }
 529 }
 530
 531 void
 532 soup_message_foreach_header (GHashTable *hash, GHFunc func, gpointer user_data)
 533 {
 534         SoupMessageForeachHeaderData data;
 535
 536         g_return_if_fail (hash != NULL);
 537         g_return_if_fail (func != NULL);
 538
 539         data.func = func;
 540         data.user_data = user_data;
 541         g_hash_table_foreach (hash, foreach_value_in_list, &data);
 542 }
 543
 544 void
 545 soup_message_cleanup_response (SoupMessage *req)
 546 {
 547         if (req->response.owner == SOUP_BUFFER_SYSTEM_OWNED)
 548                 g_free (req->response.body);
 549
 550         req->response.owner = 0;
 551         req->response.body = NULL;
 552         req->response.length = 0;
 553
 554         free_chunks (req);
 555
 556         soup_message_clear_headers (req->response_headers);
 557
 558         req->status_code = 0;
 559         if (req->reason_phrase) {
 560                 g_free ((char *) req->reason_phrase);
 561                 req->reason_phrase = NULL;
 562         }
 563 }
 564
 565 void
 566 soup_message_set_flags (SoupMessage *msg, guint flags)
 567 {
 568         g_return_if_fail (SOUP_IS_MESSAGE (msg));
 569
 570         msg->priv->msg_flags = flags;
 571 }
 572
 573 guint
 574 soup_message_get_flags (SoupMessage *msg)
 575 {
 576         g_return_val_if_fail (SOUP_IS_MESSAGE (msg), 0);
 577
 578         return msg->priv->msg_flags;
 579 }
 580
 581 void
 582 soup_message_set_http_version (SoupMessage *msg, SoupHttpVersion version)
 583 {
 584         g_return_if_fail (SOUP_IS_MESSAGE (msg));
 585
 586         msg->priv->http_version = version;
 587 }
 588
 589 SoupHttpVersion
 590 soup_message_get_http_version (SoupMessage *msg)
 591 {
 592         g_return_val_if_fail (SOUP_IS_MESSAGE (msg), SOUP_HTTP_1_0);
 593
 594         return msg->priv->http_version;
 595 }
 596
 597 gboolean
 598 soup_message_is_keepalive (SoupMessage *msg)
 599 {
 600         const char *c_conn, *s_conn;
 601
 602         c_conn = soup_message_get_header (msg->request_headers, "Connection");
 603         s_conn = soup_message_get_header (msg->response_headers, "Connection");
 604
 605         if (msg->priv->http_version == SOUP_HTTP_1_0) {
 606                 /* Only persistent if the client requested keepalive
 607                  * and the server agreed.
 608                  */
 609
 610                 if (!c_conn || !s_conn)
 611                         return FALSE;
 612                 if (g_strcasecmp (c_conn, "Keep-Alive") != 0 ||
 613                     g_strcasecmp (s_conn, "Keep-Alive") != 0)
 614                         return FALSE;
 615
 616                 return TRUE;
 617         } else {
 618                 /* Persistent unless either side requested otherwise */
 619
 620                 if (c_conn && g_strcasecmp (c_conn, "close") == 0)
 621                         return FALSE;
 622                 if (s_conn && g_strcasecmp (s_conn, "close") == 0)
 623                         return FALSE;
 624
 625                 return TRUE;
 626         }
 627 }
 628
 629 void
 630 soup_message_set_uri (SoupMessage *msg, const SoupUri *new_uri)
 631 {
 632         g_return_if_fail (SOUP_IS_MESSAGE (msg));
 633
 634         if (msg->priv->uri && new_uri) {
 635                 if (strcmp (msg->priv->uri->host, new_uri->host) != 0)
 636                         soup_message_io_cancel (msg);
 637         } else if (!new_uri)
 638                 soup_message_io_cancel (msg);
 639
 640         if (msg->priv->uri)
 641                 soup_uri_free (msg->priv->uri);
 642         msg->priv->uri = soup_uri_copy (new_uri);
 643 }
 644
 645 const SoupUri *
 646 soup_message_get_uri (SoupMessage *msg)
 647 {
 648         g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);
 649
 650         return msg->priv->uri;
 651 }
 652
 653 void
 654 soup_message_set_status (SoupMessage *msg, guint status_code)
 655 {
 656         g_return_if_fail (SOUP_IS_MESSAGE (msg));
 657         g_return_if_fail (status_code != 0);
 658
 659         g_free ((char *) msg->reason_phrase);
 660
 661         msg->status_code = status_code;
 662         msg->reason_phrase = g_strdup (soup_status_get_phrase (status_code));
 663 }
 664
 665 void
 666 soup_message_set_status_full (SoupMessage *msg,
 667                               guint        status_code,
 668                               const char  *reason_phrase)
 669 {
 670         g_return_if_fail (SOUP_IS_MESSAGE (msg));
 671         g_return_if_fail (status_code != 0);
 672         g_return_if_fail (reason_phrase != NULL);
 673
 674         g_free ((char *) msg->reason_phrase);
 675
 676         msg->status_code = status_code;
 677         msg->reason_phrase = g_strdup (reason_phrase);
 678 }
 679
 680
 681 void
 682 soup_message_add_chunk (SoupMessage   *msg,
 683                         SoupOwnership  owner,
 684                         const char    *body,
 685                         guint          length)
 686 {
 687         SoupDataBuffer *chunk;
 688
 689         g_return_if_fail (SOUP_IS_MESSAGE (msg));
 690         g_return_if_fail (body != NULL || length == 0);
 691
 692         chunk = g_new0 (SoupDataBuffer, 1);
 693         if (owner == SOUP_BUFFER_USER_OWNED) {
 694                 chunk->owner = SOUP_BUFFER_SYSTEM_OWNED;
 695                 chunk->body = g_memdup (body, length);
 696         } else {
 697                 chunk->owner = owner;
 698                 chunk->body = (char *)body;
 699         }
 700         chunk->length = length;
 701
 702         if (msg->priv->chunks) {
 703                 g_slist_append (msg->priv->last_chunk, chunk);
 704                 msg->priv->last_chunk = msg->priv->last_chunk->next;
 705         } else {
 706                 msg->priv->chunks = msg->priv->last_chunk =
 707                         g_slist_append (NULL, chunk);
 708         }
 709 }
 710
 711 void
 712 soup_message_add_final_chunk (SoupMessage *msg)
 713 {
 714         soup_message_add_chunk (msg, SOUP_BUFFER_STATIC, NULL, 0);
 715 }
 716
 717 SoupDataBuffer *
 718 soup_message_pop_chunk (SoupMessage *msg)
 719 {
 720         SoupDataBuffer *chunk;
 721
 722         g_return_val_if_fail (SOUP_IS_MESSAGE (msg), NULL);
 723
 724         if (!msg->priv->chunks)
 725                 return NULL;
 726
 727         chunk = msg->priv->chunks->data;
 728         msg->priv->chunks = g_slist_remove (msg->priv->chunks, chunk);
 729         if (!msg->priv->chunks)
 730                 msg->priv->last_chunk = NULL;
 731
 732         return chunk;
 733 }
 734
 735 static void
 736 free_chunks (SoupMessage *msg)
 737 {
 738         SoupDataBuffer *chunk;
 739         GSList *ch;
 740
 741         for (ch = msg->priv->chunks; ch; ch = ch->next) {
 742                 chunk = ch->data;
 743
 744                 if (chunk->owner == SOUP_BUFFER_SYSTEM_OWNED)
 745                         g_free (chunk->body);
 746                 g_free (chunk);
 747         }
 748
 749         g_slist_free (msg->priv->chunks);
 750         msg->priv->chunks = msg->priv->last_chunk = NULL;
 751 }