libsoup/soup-content-decoder.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * soup-content-decoder.c
   4  *
   5  * Copyright (C) 2009 Red Hat, Inc.
   6  */
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include <config.h>
  10 #endif
  11
  12 #include <string.h>
  13 #include <gio/gio.h>
  14
  15 #include "soup-content-decoder.h"
  16 #include "soup-enum-types.h"
  17 #include "soup-message.h"
  18 #include "soup-message-private.h"
  19 #include "soup-session-feature.h"
  20 #include "soup-uri.h"
  21
  22 /**
  23  * SECTION:soup-content-decoder
  24  * @short_description: Content-Encoding handler
  25  *
  26  * #SoupContentDecoder handles the "Accept-Encoding" header on
  27  * outgoing messages, and the "Content-Encoding" header on incoming
  28  * ones. If you add it to a session with soup_session_add_feature() or
  29  * soup_session_add_feature_by_type(), the session will automatically
  30  * use Content-Encoding as appropriate.
  31  *
  32  * (Note that currently there is no way to (automatically) use
  33  * Content-Encoding when sending a request body, or to pick specific
  34  * encoding types to support.)
  35  *
  36  * If #SoupContentDecoder successfully decodes the Content-Encoding,
  37  * it will set the %SOUP_MESSAGE_CONTENT_DECODED flag on the message,
  38  * and the message body and the chunks in the #SoupMessage::got_chunk
  39  * signals will contain the decoded data; however, the message headers
  40  * will be unchanged (and so "Content-Encoding" will still be present,
  41  * "Content-Length" will describe the original encoded length, etc).
  42  *
  43  * If "Content-Encoding" contains any encoding types that
  44  * #SoupContentDecoder doesn't recognize, then none of the encodings
  45  * will be decoded (and the %SOUP_MESSAGE_CONTENT_DECODED flag will
  46  * not be set).
  47  *
  48  * Since: 2.28.2
  49  **/
  50
  51 struct _SoupContentDecoderPrivate {
  52         GHashTable *decoders;
  53 };
  54
  55 typedef GConverter * (*SoupContentDecoderCreator) (void);
  56
  57 static void soup_content_decoder_session_feature_init (SoupSessionFeatureInterface *feature_interface, gpointer interface_data);
  58
  59 static void request_queued (SoupSessionFeature *feature, SoupSession *session, SoupMessage *msg);
  60 static void request_unqueued (SoupSessionFeature *feature, SoupSession *session, SoupMessage *msg);
  61
  62 static void finalize (GObject *object);
  63
  64 G_DEFINE_TYPE_WITH_CODE (SoupContentDecoder, soup_content_decoder, G_TYPE_OBJECT,
  65                          G_IMPLEMENT_INTERFACE (SOUP_TYPE_SESSION_FEATURE,
  66                                                 soup_content_decoder_session_feature_init))
  67
  68 /* This is constant for now */
  69 #define ACCEPT_ENCODING_HEADER "gzip, deflate"
  70
  71 static GConverter *
  72 gzip_decoder_creator (void)
  73 {
  74         return (GConverter *)g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP);
  75 }
  76
  77 static GConverter *
  78 zlib_decoder_creator (void)
  79 {
  80         return (GConverter *)g_zlib_decompressor_new (G_ZLIB_COMPRESSOR_FORMAT_ZLIB);
  81 }
  82
  83 static void
  84 soup_content_decoder_init (SoupContentDecoder *decoder)
  85 {
  86         decoder->priv = G_TYPE_INSTANCE_GET_PRIVATE (decoder,
  87                                                      SOUP_TYPE_CONTENT_DECODER,
  88                                                      SoupContentDecoderPrivate);
  89
  90         decoder->priv->decoders = g_hash_table_new (g_str_hash, g_str_equal);
  91         /* Hardcoded for now */
  92         g_hash_table_insert (decoder->priv->decoders, "gzip",
  93                              gzip_decoder_creator);
  94         g_hash_table_insert (decoder->priv->decoders, "x-gzip",
  95                              gzip_decoder_creator);
  96         g_hash_table_insert (decoder->priv->decoders, "deflate",
  97                              zlib_decoder_creator);
  98 }
  99
 100 static void
 101 soup_content_decoder_class_init (SoupContentDecoderClass *decoder_class)
 102 {
 103         GObjectClass *object_class = G_OBJECT_CLASS (decoder_class);
 104
 105         g_type_class_add_private (decoder_class, sizeof (SoupContentDecoderPrivate));
 106
 107         object_class->finalize = finalize;
 108 }
 109
 110 static void
 111 soup_content_decoder_session_feature_init (SoupSessionFeatureInterface *feature_interface,
 112                                            gpointer interface_data)
 113 {
 114         feature_interface->request_queued = request_queued;
 115         feature_interface->request_unqueued = request_unqueued;
 116 }
 117
 118 static void
 119 finalize (GObject *object)
 120 {
 121         SoupContentDecoder *decoder = SOUP_CONTENT_DECODER (object);
 122
 123         g_hash_table_destroy (decoder->priv->decoders);
 124
 125         G_OBJECT_CLASS (soup_content_decoder_parent_class)->finalize (object);
 126 }
 127
 128 static void
 129 soup_content_decoder_got_headers_cb (SoupMessage *msg, SoupContentDecoder *decoder)
 130 {
 131         SoupMessagePrivate *msgpriv = SOUP_MESSAGE_GET_PRIVATE (msg);
 132         const char *header;
 133         GSList *encodings, *e;
 134         SoupContentDecoderCreator converter_creator;
 135         GConverter *converter;
 136
 137         header = soup_message_headers_get_list (msg->response_headers,
 138                                                 "Content-Encoding");
 139         if (!header)
 140                 return;
 141
 142         /* Workaround for an apache bug (bgo 613361) */
 143         if (!g_ascii_strcasecmp (header, "gzip") ||
 144             !g_ascii_strcasecmp (header, "x-gzip")) {
 145                 const char *content_type = soup_message_headers_get_content_type (msg->response_headers, NULL);
 146
 147                 if (content_type &&
 148                     (!g_ascii_strcasecmp (content_type, "application/gzip") ||
 149                      !g_ascii_strcasecmp (content_type, "application/x-gzip")))
 150                         return;
 151         }
 152
 153         /* OK, really, no one is ever going to use more than one
 154          * encoding, but we'll be robust.
 155          */
 156         encodings = soup_header_parse_list (header);
 157         if (!encodings)
 158                 return;
 159
 160         for (e = encodings; e; e = e->next) {
 161                 if (!g_hash_table_lookup (decoder->priv->decoders, e->data)) {
 162                         soup_header_free_list (encodings);
 163                         return;
 164                 }
 165         }
 166
 167         /* msgpriv->decoders should be empty at this point anyway, but
 168          * clean it up if it's not.
 169          */
 170         while (msgpriv->decoders) {
 171                 g_object_unref (msgpriv->decoders->data);
 172                 msgpriv->decoders = g_slist_delete_link (msgpriv->decoders, msgpriv->decoders);
 173         }
 174
 175         for (e = encodings; e; e = e->next) {
 176                 converter_creator = g_hash_table_lookup (decoder->priv->decoders, e->data);
 177                 converter = converter_creator ();
 178
 179                 /* Content-Encoding lists the codings in the order
 180                  * they were applied in, so we put decoders in reverse
 181                  * order so the last-applied will be the first
 182                  * decoded.
 183                  */
 184                 msgpriv->decoders = g_slist_prepend (msgpriv->decoders, converter);
 185         }
 186         soup_header_free_list (encodings);
 187 }
 188
 189 static void
 190 request_queued (SoupSessionFeature *feature, SoupSession *session,
 191                 SoupMessage *msg)
 192 {
 193         SoupContentDecoder *decoder = SOUP_CONTENT_DECODER (feature);
 194
 195         if (!soup_message_headers_get_one (msg->request_headers,
 196                                            "Accept-Encoding")) {
 197                 soup_message_headers_append (msg->request_headers,
 198                                              "Accept-Encoding",
 199                                              ACCEPT_ENCODING_HEADER);
 200         }
 201
 202         g_signal_connect (msg, "got-headers",
 203                           G_CALLBACK (soup_content_decoder_got_headers_cb),
 204                           decoder);
 205 }
 206
 207 static void
 208 request_unqueued (SoupSessionFeature *feature, SoupSession *session,
 209                   SoupMessage *msg)
 210 {
 211         g_signal_handlers_disconnect_by_func (msg, soup_content_decoder_got_headers_cb, feature);
 212 }