← Back to branch summary

~midori/midori/trunk

« back to all changes in this revision

Viewing changes to extensions/web-cache.c

  • Committer: Tarmac
  • Author(s): Christian Dywan
  • Date: 2013-06-19 21:00:46 UTC
  • mfrom: (6216.1.10 midori.butcher)
  • Revision ID: tarmac-20130619210046-i3yv8cnkyjuafubb
Bump WebKit requirement to 1.8.3 and drop support for earlier versions

Show diffs side-by-side

added added

removed removed

Lines of Context:
extensions/web-cache.c
1
 
/*
2
 
 Copyright (C) 2009 Christian Dywan <christian@twotoasts.de>
3
 
 Copyright (C) 2009 Alexander Butenko <a.butenka@gmail.com>
4
 
 
5
 
 This library is free software; you can redistribute it and/or
6
 
 modify it under the terms of the GNU Lesser General Public
7
 
 License as published by the Free Software Foundation; either
8
 
 version 2.1 of the License, or (at your option) any later version.
9
 
 
10
 
 See the file COPYING for the full license text.
11
 
*/
12
 
 
13
 
#include <midori/midori.h>
14
 
#include <glib/gstdio.h>
15
 
#include <stdlib.h>
16
 
 
17
 
#include "config.h"
18
 
#if HAVE_UNISTD_H
19
 
    #include <unistd.h>
20
 
#endif
21
 
 
22
 
#if !WEBKIT_CHECK_VERSION (1, 3, 11)
23
 
 
24
 
#define MAXLENGTH 1024 * 1024
25
 
 
26
 
static gchar*
27
 
web_cache_get_cache_dir (void)
28
 
{
29
 
    static gchar* cache_dir = NULL;
30
 
    if (!cache_dir)
31
 
        cache_dir = g_build_filename (midori_paths_get_cache_dir (), "web", NULL);
32
 
    return cache_dir;
33
 
}
34
 
 
35
 
static gchar*
36
 
web_cache_get_cached_path (MidoriExtension* extension,
37
 
                           const gchar*     uri)
38
 
{
39
 
    gchar* checksum;
40
 
    gchar* folder;
41
 
    gchar* sub_path;
42
 
    gchar* encoded;
43
 
    gchar* ext;
44
 
    gchar* cached_filename;
45
 
    gchar* cached_path;
46
 
 
47
 
    checksum = g_compute_checksum_for_string (G_CHECKSUM_MD5, uri, -1);
48
 
    folder = g_strdup_printf ("%c%c", checksum[0], checksum[1]);
49
 
    sub_path = g_build_path (G_DIR_SEPARATOR_S,
50
 
                             web_cache_get_cache_dir (), folder, NULL);
51
 
    katze_mkdir_with_parents (sub_path, 0700);
52
 
    g_free (folder);
53
 
 
54
 
    encoded = soup_uri_encode (uri, "/");
55
 
    ext = g_strdup (g_strrstr (encoded, "."));
56
 
    /* Make sure ext isn't becoming too long */
57
 
    if (ext && ext[0] && ext[1] && ext[2] && ext[3] && ext[4])
58
 
        ext[4] = '\0';
59
 
    cached_filename = g_strdup_printf ("%s%s", checksum, ext ? ext : "");
60
 
    g_free (ext);
61
 
    g_free (encoded);
62
 
    g_free (checksum);
63
 
    cached_path = g_build_filename (sub_path, cached_filename, NULL);
64
 
    g_free (cached_filename);
65
 
    return cached_path;
66
 
}
67
 
 
68
 
static gboolean
69
 
web_cache_save_headers (SoupMessage* msg,
70
 
                        gchar*       filename)
71
 
{
72
 
      gchar* dsc_filename = g_strdup_printf ("%s.dsc.tmp", filename);
73
 
      SoupMessageHeaders* hdrs = msg->response_headers;
74
 
      SoupMessageHeadersIter iter;
75
 
      const gchar* name, *value;
76
 
      FILE* dscfd;
77
 
 
78
 
      soup_message_headers_iter_init (&iter, hdrs);
79
 
      dscfd = g_fopen (dsc_filename, "w");
80
 
      g_free (dsc_filename);
81
 
      if (!dscfd)
82
 
          return FALSE;
83
 
 
84
 
      while (soup_message_headers_iter_next (&iter, &name, &value))
85
 
          g_fprintf (dscfd, "%s: %s\n", name, value);
86
 
      fclose (dscfd);
87
 
 
88
 
      return TRUE;
89
 
}
90
 
 
91
 
static GHashTable*
92
 
web_cache_get_headers (gchar* filename)
93
 
{
94
 
    GHashTable* headers;
95
 
    FILE* file;
96
 
    gchar* dsc_filename;
97
 
    gchar line[128];
98
 
 
99
 
    if (!filename)
100
 
        return NULL;
101
 
 
102
 
    /* use g_access() instead of g_file_test for better performance */
103
 
    if (g_access (filename, F_OK) != 0)
104
 
        return NULL;
105
 
 
106
 
    dsc_filename = g_strdup_printf ("%s.dsc", filename);
107
 
    headers = g_hash_table_new_full (g_str_hash, g_str_equal,
108
 
                               (GDestroyNotify)g_free,
109
 
                               (GDestroyNotify)g_free);
110
 
 
111
 
    if (!(file = g_fopen (dsc_filename, "r")))
112
 
    {
113
 
        g_hash_table_destroy (headers);
114
 
        g_free (dsc_filename);
115
 
        return NULL;
116
 
    }
117
 
    while (fgets (line, 128, file))
118
 
    {
119
 
        gchar** data;
120
 
 
121
 
        if (line == NULL)
122
 
            continue;
123
 
 
124
 
        g_strchomp (line);
125
 
        data = g_strsplit (line, ":", 2);
126
 
        if (data[0] && data[1])
127
 
            g_hash_table_insert (headers, g_strdup (data[0]),
128
 
                                 g_strdup (g_strchug (data[1])));
129
 
        g_strfreev (data);
130
 
    }
131
 
    fclose (file);
132
 
    g_free (dsc_filename);
133
 
    return headers;
134
 
}
135
 
 
136
 
static GFile*
137
 
web_cache_tmp_prepare (gchar* filename)
138
 
{
139
 
    GFile *file;
140
 
 
141
 
    gchar* tmp_filename = g_strdup_printf ("%s.tmp", filename);
142
 
    if (g_access (tmp_filename, F_OK) == 0)
143
 
    {
144
 
        g_free (tmp_filename);
145
 
        return NULL;
146
 
    }
147
 
    file = g_file_new_for_path (tmp_filename);
148
 
    g_free (tmp_filename);
149
 
 
150
 
    return file;
151
 
}
152
 
 
153
 
static void
154
 
web_cache_set_content_type (SoupMessage* msg,
155
 
                            SoupBuffer*  buffer)
156
 
{
157
 
    gchar* sniffed_type;
158
 
    SoupContentSniffer* sniffer = soup_content_sniffer_new ();
159
 
    if ((sniffed_type = soup_content_sniffer_sniff (sniffer, msg, buffer, NULL)))
160
 
    {
161
 
        g_signal_emit_by_name (msg, "content-sniffed", sniffed_type, NULL);
162
 
        g_free (sniffed_type);
163
 
    }
164
 
    else
165
 
    {
166
 
        const gchar* content_type = soup_message_headers_get_one (
167
 
            msg->response_headers, "Content-Type");
168
 
        g_signal_emit_by_name (msg, "content-sniffed", content_type, NULL);
169
 
    }
170
 
}
171
 
 
172
 
static void
173
 
web_cache_message_finished_cb (SoupMessage*   msg,
174
 
                               GOutputStream* stream)
175
 
{
176
 
    gchar* headers;
177
 
    gchar* tmp_headers;
178
 
    gchar* tmp_data;
179
 
    gchar* filename;
180
 
 
181
 
    filename = g_object_get_data (G_OBJECT (stream), "filename");
182
 
    headers = g_strdup_printf ("%s.dsc", filename);
183
 
    tmp_headers = g_strdup_printf ("%s.dsc.tmp", filename);
184
 
    tmp_data = g_strdup_printf ("%s.tmp", filename);
185
 
    g_output_stream_close (stream, NULL, NULL);
186
 
 
187
 
    if (msg->status_code == SOUP_STATUS_OK)
188
 
    {
189
 
        g_rename (tmp_data, filename);
190
 
        g_rename (tmp_headers, headers);
191
 
    }
192
 
    else
193
 
    {
194
 
        g_unlink (tmp_data);
195
 
        g_unlink (tmp_headers);
196
 
    }
197
 
 
198
 
    g_object_unref (stream);
199
 
    g_free (headers);
200
 
    g_free (tmp_headers);
201
 
    g_free (tmp_data);
202
 
}
203
 
 
204
 
static void web_cache_pause_message (SoupMessage* msg)
205
 
{
206
 
    SoupSession* session;
207
 
    session = g_object_get_data (G_OBJECT (msg), "session");
208
 
    soup_session_pause_message (session, msg);
209
 
}
210
 
 
211
 
static void web_cache_unpause_message (SoupMessage* msg)
212
 
{
213
 
    SoupSession* session;
214
 
    session = g_object_get_data (G_OBJECT (msg), "session");
215
 
    soup_session_unpause_message (session, msg);
216
 
}
217
 
 
218
 
static void
219
 
web_cache_message_got_chunk_cb (SoupMessage* msg,
220
 
                                SoupBuffer*  chunk,
221
 
                                GOutputStream* stream)
222
 
{
223
 
    if (!chunk->data || !chunk->length)
224
 
        return;
225
 
    /* FIXME g_output_stream_write_async (stream, chunk->data, chunk->length,
226
 
        G_PRIORITY_DEFAULT, NULL, NULL, (gpointer)chunk->length); */
227
 
    g_output_stream_write (stream, chunk->data, chunk->length, NULL, NULL);
228
 
}
229
 
 
230
 
static void
231
 
web_cache_message_rewrite_async_cb (GFile *file,
232
 
                                    GAsyncResult* res,
233
 
                                    SoupMessage*  msg)
234
 
{
235
 
    SoupBuffer *buffer;
236
 
    char *data;
237
 
    gsize length;
238
 
    GError *error = NULL;
239
 
 
240
 
    if (g_file_load_contents_finish (file, res, &data, &length, NULL, &error))
241
 
    {
242
 
        buffer = soup_buffer_new (SOUP_MEMORY_TEMPORARY, data, length);
243
 
        web_cache_set_content_type (msg, buffer);
244
 
        soup_message_body_append_buffer (msg->response_body, buffer);
245
 
        /* FIXME? */
246
 
        web_cache_unpause_message (msg);
247
 
        g_signal_emit_by_name (msg, "got-chunk", buffer, NULL);
248
 
        soup_buffer_free (buffer);
249
 
        g_free (data);
250
 
        soup_message_got_body (msg);
251
 
        soup_message_finished (msg);
252
 
    }
253
 
    g_object_unref (file);
254
 
    g_object_unref (msg);
255
 
}
256
 
 
257
 
static void
258
 
web_cache_message_rewrite (SoupMessage*  msg,
259
 
                           gchar*        filename)
260
 
{
261
 
    GHashTableIter iter;
262
 
    gpointer key, value;
263
 
    GFile *file;
264
 
 
265
 
    GHashTable* cache_headers = web_cache_get_headers (filename);
266
 
    if (!cache_headers)
267
 
        return;
268
 
 
269
 
    soup_message_set_status (msg, SOUP_STATUS_OK);
270
 
    g_hash_table_iter_init (&iter, cache_headers);
271
 
    while (g_hash_table_iter_next (&iter, &key, &value))
272
 
        soup_message_headers_replace (msg->response_headers, key, value);
273
 
    g_signal_emit_by_name (msg, "got-headers", NULL);
274
 
    g_hash_table_destroy (cache_headers);
275
 
 
276
 
    /* FIXME? It seems libsoup already said "goodbye" by the time
277
 
       the asynchronous function is starting to send data */
278
 
    web_cache_pause_message (msg);
279
 
    file = g_file_new_for_path (filename);
280
 
    g_free (filename);
281
 
    g_object_ref (msg);
282
 
    g_file_load_contents_async (file, NULL,
283
 
        (GAsyncReadyCallback)web_cache_message_rewrite_async_cb, msg);
284
 
}
285
 
 
286
 
static void
287
 
web_cache_mesage_got_headers_cb (SoupMessage* msg,
288
 
                                 gchar*       filename)
289
 
{
290
 
    const gchar* nocache;
291
 
    SoupMessageHeaders *hdrs = msg->response_headers;
292
 
    const char* cl;
293
 
 
294
 
    /* Skip files downloaded by the user */
295
 
    if (g_object_get_data (G_OBJECT (msg), "midori-web-cache-download"))
296
 
        return;
297
 
 
298
 
    /* Skip big files */
299
 
    cl = soup_message_headers_get_one (hdrs, "Content-Length");
300
 
    if (cl && atoi (cl) > MAXLENGTH)
301
 
        return;
302
 
 
303
 
    nocache = soup_message_headers_get_one (hdrs, "Pragma");
304
 
    if (!nocache)
305
 
        nocache = soup_message_headers_get_one (hdrs, "Cache-Control");
306
 
    if (nocache && g_regex_match_simple ("no-cache|no-store", nocache,
307
 
                                         G_REGEX_CASELESS, G_REGEX_MATCH_NOTEMPTY))
308
 
    {
309
 
        return;
310
 
    }
311
 
 
312
 
    if (msg->status_code == SOUP_STATUS_NOT_MODIFIED)
313
 
    {
314
 
        /* g_debug ("loading from cache: %s", filename); */
315
 
        g_signal_handlers_disconnect_by_func (msg,
316
 
            web_cache_mesage_got_headers_cb, filename);
317
 
        web_cache_message_rewrite (msg, filename);
318
 
    }
319
 
    else if (msg->status_code == SOUP_STATUS_OK)
320
 
    {
321
 
        GFile* file;
322
 
        GOutputStream* ostream;
323
 
 
324
 
        /* g_debug ("updating cache: %s", filename); */
325
 
        if (!(file = web_cache_tmp_prepare (filename)))
326
 
            return;
327
 
        if (!web_cache_save_headers (msg, filename))
328
 
            return;
329
 
 
330
 
        ostream = (GOutputStream*)g_file_append_to (file,
331
 
            G_FILE_CREATE_PRIVATE | G_FILE_CREATE_REPLACE_DESTINATION, NULL, NULL);
332
 
        g_object_unref (file);
333
 
 
334
 
        if (!ostream)
335
 
            return;
336
 
 
337
 
        g_object_set_data_full (G_OBJECT (ostream), "filename",
338
 
                                filename, (GDestroyNotify)g_free);
339
 
        g_signal_connect (msg, "got-chunk",
340
 
            G_CALLBACK (web_cache_message_got_chunk_cb), ostream);
341
 
        g_signal_connect (msg, "finished",
342
 
            G_CALLBACK (web_cache_message_finished_cb), ostream);
343
 
    }
344
 
}
345
 
 
346
 
static void
347
 
web_cache_session_request_queued_cb (SoupSession*     session,
348
 
                                     SoupMessage*     msg,
349
 
                                     MidoriExtension* extension)
350
 
{
351
 
    SoupURI* soup_uri = soup_message_get_uri (msg);
352
 
    gchar* uri = soup_uri_to_string (soup_uri, FALSE);
353
 
 
354
 
    if (midori_uri_is_http (uri) && !g_strcmp0 (msg->method, "GET"))
355
 
    {
356
 
        gchar* filename = web_cache_get_cached_path (extension, uri);
357
 
        GHashTable* cache_headers;
358
 
        gchar* etag;
359
 
        gchar* last_modified;
360
 
 
361
 
        cache_headers = web_cache_get_headers (filename);
362
 
        if (cache_headers)
363
 
        {
364
 
            etag = g_hash_table_lookup (cache_headers, "ETag");
365
 
            last_modified = g_hash_table_lookup (cache_headers, "Last-Modified");
366
 
            if (etag)
367
 
                soup_message_headers_replace (msg->request_headers,
368
 
                                             "If-None-Match", etag);
369
 
            if (last_modified)
370
 
                soup_message_headers_replace (msg->request_headers,
371
 
                                              "If-Modified-Since", last_modified);
372
 
            g_hash_table_destroy (cache_headers);
373
 
        }
374
 
        g_object_set_data (G_OBJECT (msg), "session", session);
375
 
        g_signal_connect (msg, "got-headers",
376
 
                G_CALLBACK (web_cache_mesage_got_headers_cb), filename);
377
 
 
378
 
    }
379
 
    g_free (uri);
380
 
}
381
 
 
382
 
static void
383
 
web_cache_add_download_cb (MidoriBrowser*   browser,
384
 
                           WebKitDownload*  download,
385
 
                           MidoriExtension* extension)
386
 
{
387
 
    WebKitNetworkRequest* request = webkit_download_get_network_request (download);
388
 
    SoupMessage* msg = webkit_network_request_get_message (request);
389
 
    if (msg)
390
 
        g_object_set_data (G_OBJECT (msg), "midori-web-cache-download",
391
 
                           (gpointer)0xdeadbeef);
392
 
}
393
 
 
394
 
static void
395
 
web_cache_deactivate_cb (MidoriExtension* extension,
396
 
                         MidoriBrowser*   browser);
397
 
 
398
 
static void
399
 
web_cache_app_add_browser_cb (MidoriApp*       app,
400
 
                              MidoriBrowser*   browser,
401
 
                              MidoriExtension* extension)
402
 
{
403
 
    g_signal_connect (browser, "add-download",
404
 
        G_CALLBACK (web_cache_add_download_cb), extension);
405
 
    g_signal_connect (extension, "deactivate",
406
 
        G_CALLBACK (web_cache_deactivate_cb), browser);
407
 
}
408
 
 
409
 
static void
410
 
web_cache_deactivate_cb (MidoriExtension* extension,
411
 
                         MidoriBrowser*   browser)
412
 
{
413
 
    MidoriApp* app = midori_extension_get_app (extension);
414
 
    SoupSession* session = webkit_get_default_session ();
415
 
 
416
 
    g_signal_handlers_disconnect_by_func (
417
 
        session, web_cache_session_request_queued_cb, extension);
418
 
    g_signal_handlers_disconnect_by_func (
419
 
        extension, web_cache_deactivate_cb, browser);
420
 
    g_signal_handlers_disconnect_by_func (
421
 
        app, web_cache_app_add_browser_cb, extension);
422
 
    g_signal_handlers_disconnect_by_func (
423
 
        browser, web_cache_add_download_cb, extension);
424
 
}
425
 
 
426
 
static void
427
 
web_cache_activate_cb (MidoriExtension* extension,
428
 
                       MidoriApp*       app)
429
 
{
430
 
    KatzeArray* browsers;
431
 
    MidoriBrowser* browser;
432
 
    SoupSession* session = webkit_get_default_session ();
433
 
 
434
 
    katze_mkdir_with_parents (web_cache_get_cache_dir (), 0700);
435
 
    g_signal_connect (session, "request-queued",
436
 
                      G_CALLBACK (web_cache_session_request_queued_cb), extension);
437
 
 
438
 
    browsers = katze_object_get_object (app, "browsers");
439
 
    KATZE_ARRAY_FOREACH_ITEM (browser, browsers)
440
 
        web_cache_app_add_browser_cb (app, browser, extension);
441
 
    g_signal_connect (app, "add-browser",
442
 
        G_CALLBACK (web_cache_app_add_browser_cb), extension);
443
 
 
444
 
    g_object_unref (browsers);
445
 
}
446
 
 
447
 
static void
448
 
web_cache_clear_cache_cb (void)
449
 
{
450
 
    midori_paths_remove_path (web_cache_get_cache_dir ());
451
 
}
452
 
#endif
453
 
 
454
 
MidoriExtension*
455
 
extension_init (void)
456
 
{
457
 
    #if WEBKIT_CHECK_VERSION (1, 3, 11)
458
 
    return NULL;
459
 
    #else
460
 
    MidoriExtension* extension = g_object_new (MIDORI_TYPE_EXTENSION,
461
 
        "name", _("Web Cache"),
462
 
        "description", _("Cache HTTP communication on disk"),
463
 
        "version", "0.1" MIDORI_VERSION_SUFFIX,
464
 
        "authors", "Christian Dywan <christian@twotoasts.de>",
465
 
        NULL);
466
 
 
467
 
    g_signal_connect (extension, "activate",
468
 
        G_CALLBACK (web_cache_activate_cb), NULL);
469
 
 
470
 
    midori_private_data_register_item ("web-cache", _("Web Cache"),
471
 
        G_CALLBACK (web_cache_clear_cache_cb));
472
 
 
473
 
    return extension;
474
 
    #endif
475
 
}