2011-02-16 02:18:10 +03:00
|
|
|
/*
|
|
|
|
* Copyright 2011 Vincent Sanders <vince@netsurf-browser.org>
|
|
|
|
*
|
|
|
|
* This file is part of NetSurf.
|
|
|
|
*
|
|
|
|
* NetSurf is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; version 2 of the License.
|
|
|
|
*
|
|
|
|
* NetSurf is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2011-03-17 12:21:02 +03:00
|
|
|
/* about: URL handling.
|
|
|
|
*
|
|
|
|
* Based on the data fetcher by Rob Kendrick
|
|
|
|
* This fetcher provides a simple scheme for the user to access
|
|
|
|
* information from the browser from a known, fixed URL.
|
|
|
|
*/
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <inttypes.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <strings.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <dirent.h>
|
|
|
|
#include <limits.h>
|
|
|
|
#include <stdarg.h>
|
|
|
|
|
2011-09-27 01:07:19 +04:00
|
|
|
#include <libwapcaplet/libwapcaplet.h>
|
|
|
|
|
2011-02-16 02:18:10 +03:00
|
|
|
#include "utils/config.h"
|
|
|
|
#include "content/dirlist.h"
|
|
|
|
#include "content/fetch.h"
|
|
|
|
#include "content/fetchers/about.h"
|
|
|
|
#include "content/urldb.h"
|
|
|
|
#include "desktop/netsurf.h"
|
|
|
|
#include "desktop/options.h"
|
|
|
|
#include "utils/log.h"
|
|
|
|
#include "utils/messages.h"
|
|
|
|
#include "utils/url.h"
|
|
|
|
#include "utils/utils.h"
|
|
|
|
#include "utils/ring.h"
|
2011-03-13 14:59:20 +03:00
|
|
|
#include "utils/testament.h"
|
2011-10-11 02:41:31 +04:00
|
|
|
#include "image/image_cache.h"
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
struct fetch_about_context;
|
|
|
|
|
|
|
|
typedef bool (*fetch_about_handler)(struct fetch_about_context *);
|
|
|
|
|
|
|
|
/** Context for an about fetch */
|
|
|
|
struct fetch_about_context {
|
|
|
|
struct fetch_about_context *r_next, *r_prev;
|
|
|
|
|
|
|
|
struct fetch *fetchh; /**< Handle for this fetch */
|
|
|
|
|
|
|
|
bool aborted; /**< Flag indicating fetch has been aborted */
|
|
|
|
bool locked; /**< Flag indicating entry is already entered */
|
|
|
|
|
2011-09-29 19:31:54 +04:00
|
|
|
nsurl *url; /**< The full url the fetch refers to */
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
fetch_about_handler handler;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct fetch_about_context *ring = NULL;
|
|
|
|
|
|
|
|
/** issue fetch callbacks with locking */
|
2011-11-09 01:51:42 +04:00
|
|
|
static inline bool fetch_about_send_callback(const fetch_msg *msg,
|
|
|
|
struct fetch_about_context *ctx)
|
2011-02-16 02:18:10 +03:00
|
|
|
{
|
|
|
|
ctx->locked = true;
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_send_callback(msg, ctx->fetchh);
|
2011-02-16 02:18:10 +03:00
|
|
|
ctx->locked = false;
|
|
|
|
|
|
|
|
return ctx->aborted;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool fetch_about_send_header(struct fetch_about_context *ctx,
|
|
|
|
const char *fmt, ...)
|
|
|
|
{
|
|
|
|
char header[64];
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_msg msg;
|
2011-02-16 02:18:10 +03:00
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
|
|
|
|
vsnprintf(header, sizeof header, fmt, ap);
|
|
|
|
|
|
|
|
va_end(ap);
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_HEADER;
|
|
|
|
msg.data.header_or_data.buf = (const uint8_t *) header;
|
|
|
|
msg.data.header_or_data.len = strlen(header);
|
|
|
|
|
|
|
|
fetch_about_send_callback(&msg, ctx);
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
return ctx->aborted;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static bool fetch_about_blank_handler(struct fetch_about_context *ctx)
|
|
|
|
{
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_msg msg;
|
|
|
|
const char buffer[2] = { ' ', '\0' };
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
/* content is going to return ok */
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_set_http_code(ctx->fetchh, 200);
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
/* content type */
|
|
|
|
if (fetch_about_send_header(ctx, "Content-Type: text/html"))
|
|
|
|
goto fetch_about_blank_handler_aborted;
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_DATA;
|
|
|
|
msg.data.header_or_data.buf = (const uint8_t *) buffer;
|
|
|
|
msg.data.header_or_data.len = strlen(buffer);
|
|
|
|
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-02-16 02:18:10 +03:00
|
|
|
goto fetch_about_blank_handler_aborted;
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_FINISHED;
|
|
|
|
|
|
|
|
fetch_about_send_callback(&msg, ctx);
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
fetch_about_blank_handler_aborted:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static bool fetch_about_credits_handler(struct fetch_about_context *ctx)
|
|
|
|
{
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_msg msg;
|
|
|
|
|
2011-02-24 01:27:55 +03:00
|
|
|
/* content is going to return redirect */
|
|
|
|
fetch_set_http_code(ctx->fetchh, 302);
|
2011-02-16 02:18:10 +03:00
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_REDIRECT;
|
|
|
|
msg.data.redirect = "resource:credits.html";
|
|
|
|
|
|
|
|
fetch_about_send_callback(&msg, ctx);
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-05-14 04:17:25 +04:00
|
|
|
|
2011-03-13 01:38:00 +03:00
|
|
|
static bool fetch_about_licence_handler(struct fetch_about_context *ctx)
|
|
|
|
{
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_msg msg;
|
|
|
|
|
2011-03-13 01:38:00 +03:00
|
|
|
/* content is going to return redirect */
|
|
|
|
fetch_set_http_code(ctx->fetchh, 302);
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_REDIRECT;
|
|
|
|
msg.data.redirect = "resource:licence.html";
|
|
|
|
|
|
|
|
fetch_about_send_callback(&msg, ctx);
|
2011-03-13 01:38:00 +03:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-10-11 02:41:31 +04:00
|
|
|
/** Handler to generate about:cache page.
|
|
|
|
*
|
|
|
|
* Shows details of current iamge cache
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static bool fetch_about_imagecache_handler(struct fetch_about_context *ctx)
|
|
|
|
{
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_msg msg;
|
2012-03-25 20:42:45 +04:00
|
|
|
char buffer[2048]; /* output buffer */
|
2011-10-11 02:41:31 +04:00
|
|
|
int code = 200;
|
|
|
|
int slen;
|
|
|
|
unsigned int cent_loop = 0;
|
|
|
|
int res = 0;
|
2011-03-13 01:38:00 +03:00
|
|
|
|
2011-10-11 02:41:31 +04:00
|
|
|
/* content is going to return ok */
|
|
|
|
fetch_set_http_code(ctx->fetchh, code);
|
|
|
|
|
|
|
|
/* content type */
|
|
|
|
if (fetch_about_send_header(ctx, "Content-Type: text/html"))
|
|
|
|
goto fetch_about_imagecache_handler_aborted;
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_DATA;
|
|
|
|
msg.data.header_or_data.buf = (const uint8_t *) buffer;
|
|
|
|
|
2011-10-11 11:19:20 +04:00
|
|
|
/* page head */
|
2011-10-11 02:41:31 +04:00
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
|
|
|
"<html>\n<head>\n"
|
|
|
|
"<title>NetSurf Browser Image Cache Status</title>\n"
|
|
|
|
"<link rel=\"stylesheet\" type=\"text/css\" "
|
|
|
|
"href=\"resource:internal.css\">\n"
|
|
|
|
"</head>\n"
|
|
|
|
"<body id =\"cachelist\">\n"
|
|
|
|
"<p class=\"banner\">"
|
|
|
|
"<a href=\"http://www.netsurf-browser.org/\">"
|
|
|
|
"<img src=\"resource:netsurf.png\" alt=\"NetSurf\"></a>"
|
|
|
|
"</p>\n"
|
|
|
|
"<h1>NetSurf Browser Image Cache Status</h1>\n" );
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-10-11 02:41:31 +04:00
|
|
|
goto fetch_about_imagecache_handler_aborted;
|
|
|
|
|
2011-10-11 11:19:20 +04:00
|
|
|
/* image cache summary */
|
2011-10-12 16:34:11 +04:00
|
|
|
slen = image_cache_snsummaryf(buffer, sizeof(buffer),
|
2012-04-12 17:06:21 +04:00
|
|
|
"<p>Configured limit of %a hysteresis of %b</p>\n"
|
|
|
|
"<p>Total bitmap size in use %c (in %d)</p>\n"
|
|
|
|
"<p>Age %es</p>\n"
|
|
|
|
"<p>Peak size %f (in %g)</p>\n"
|
|
|
|
"<p>Peak image count %h (size %i)</p>\n"
|
2011-10-12 16:34:11 +04:00
|
|
|
"<p>Cache total/hit/miss/fail (counts) %j/%k/%l/%m "
|
2012-04-12 17:06:21 +04:00
|
|
|
"(%pj%%/%pk%%/%pl%%/%pm%%)</p>\n"
|
2011-10-12 16:34:11 +04:00
|
|
|
"<p>Cache total/hit/miss/fail (size) %n/%o/%q/%r "
|
2012-04-12 17:06:21 +04:00
|
|
|
"(%pn%%/%po%%/%pq%%/%pr%%)</p>\n"
|
2011-10-12 16:34:11 +04:00
|
|
|
"<p>Total images never rendered: %s "
|
2012-04-12 17:06:21 +04:00
|
|
|
"(includes %t that were converted)</p>\n"
|
2011-10-12 16:34:11 +04:00
|
|
|
"<p>Total number of excessive conversions: %u "
|
|
|
|
"(from %v images converted more than once)"
|
2012-04-12 17:06:21 +04:00
|
|
|
"</p>\n"
|
|
|
|
"<p>Bitmap of size %w had most (%x) conversions</p>\n"
|
|
|
|
"<h2>Current image cache contents</h2>\n");
|
2011-10-11 11:19:20 +04:00
|
|
|
if (slen >= (int) (sizeof(buffer)))
|
|
|
|
goto fetch_about_imagecache_handler_aborted; /* overflow */
|
2011-10-11 02:41:31 +04:00
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-10-11 02:41:31 +04:00
|
|
|
goto fetch_about_imagecache_handler_aborted;
|
|
|
|
|
2011-10-11 11:19:20 +04:00
|
|
|
|
|
|
|
/* image cache entry table */
|
2011-10-11 02:41:31 +04:00
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
2012-04-12 17:43:57 +04:00
|
|
|
"<p class=\"imagecachelist\">\n"
|
|
|
|
"<strong>"
|
|
|
|
"<span>Entry</span>"
|
|
|
|
"<span>Content Key</span>"
|
|
|
|
"<span>Redraw Count</span>"
|
|
|
|
"<span>Conversion Count</span>"
|
|
|
|
"<span>Last Redraw</span>"
|
|
|
|
"<span>Bitmap Age</span>"
|
|
|
|
"<span>Bitmap Size</span>"
|
|
|
|
"<span>Source</span>"
|
|
|
|
"</strong>\n");
|
2011-10-11 02:41:31 +04:00
|
|
|
do {
|
|
|
|
res = image_cache_snentryf(buffer + slen, sizeof buffer - slen,
|
|
|
|
cent_loop,
|
2012-04-12 17:43:57 +04:00
|
|
|
"<a href=\"%U\">"
|
|
|
|
"<span>%e</span>"
|
|
|
|
"<span>%k</span>"
|
|
|
|
"<span>%r</span>"
|
|
|
|
"<span>%c</span>"
|
|
|
|
"<span>%a</span>"
|
|
|
|
"<span>%g</span>"
|
|
|
|
"<span>%s</span>"
|
|
|
|
"<span>%o</span>"
|
|
|
|
"</a>\n");
|
2011-10-11 02:41:31 +04:00
|
|
|
if (res <= 0)
|
|
|
|
break; /* last option */
|
|
|
|
|
|
|
|
if (res >= (int) (sizeof buffer - slen)) {
|
|
|
|
/* last entry would not fit in buffer, submit buffer */
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-10-11 02:41:31 +04:00
|
|
|
goto fetch_about_imagecache_handler_aborted;
|
|
|
|
slen = 0;
|
|
|
|
} else {
|
|
|
|
/* normal addition */
|
|
|
|
slen += res;
|
|
|
|
cent_loop++;
|
|
|
|
}
|
|
|
|
} while (res > 0);
|
|
|
|
|
|
|
|
slen += snprintf(buffer + slen, sizeof buffer - slen,
|
2012-04-12 17:43:57 +04:00
|
|
|
"</p>\n</body>\n</html>\n");
|
2011-10-11 02:41:31 +04:00
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-10-11 02:41:31 +04:00
|
|
|
goto fetch_about_imagecache_handler_aborted;
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_FINISHED;
|
|
|
|
fetch_about_send_callback(&msg, ctx);
|
2011-10-11 02:41:31 +04:00
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
fetch_about_imagecache_handler_aborted:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Handler to generate about:config page */
|
2011-02-21 00:04:53 +03:00
|
|
|
static bool fetch_about_config_handler(struct fetch_about_context *ctx)
|
|
|
|
{
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_msg msg;
|
2011-02-21 00:04:53 +03:00
|
|
|
char buffer[1024];
|
|
|
|
int code = 200;
|
|
|
|
int slen;
|
|
|
|
unsigned int opt_loop = 0;
|
|
|
|
int res = 0;
|
|
|
|
|
|
|
|
/* content is going to return ok */
|
|
|
|
fetch_set_http_code(ctx->fetchh, code);
|
|
|
|
|
|
|
|
/* content type */
|
|
|
|
if (fetch_about_send_header(ctx, "Content-Type: text/html"))
|
|
|
|
goto fetch_about_config_handler_aborted;
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_DATA;
|
|
|
|
msg.data.header_or_data.buf = (const uint8_t *) buffer;
|
|
|
|
|
2011-02-21 00:04:53 +03:00
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
2011-03-18 15:10:15 +03:00
|
|
|
"<html>\n<head>\n"
|
|
|
|
"<title>NetSurf Browser Config</title>\n"
|
|
|
|
"<link rel=\"stylesheet\" type=\"text/css\" "
|
|
|
|
"href=\"resource:internal.css\">\n"
|
|
|
|
"</head>\n"
|
|
|
|
"<body id =\"configlist\">\n"
|
2011-03-13 02:00:19 +03:00
|
|
|
"<p class=\"banner\">"
|
|
|
|
"<a href=\"http://www.netsurf-browser.org/\">"
|
|
|
|
"<img src=\"resource:netsurf.png\" alt=\"NetSurf\"></a>"
|
2011-03-18 15:10:15 +03:00
|
|
|
"</p>\n"
|
|
|
|
"<h1>NetSurf Browser Config</h1>\n"
|
|
|
|
"<table class=\"config\">\n"
|
2011-03-17 13:20:04 +03:00
|
|
|
"<tr><th></th><th></th><th></th></tr>\n");
|
2011-02-21 00:04:53 +03:00
|
|
|
|
|
|
|
do {
|
2012-03-22 13:34:34 +04:00
|
|
|
res = nsoption_snoptionf(buffer + slen, sizeof buffer - slen,
|
2011-02-21 01:38:43 +03:00
|
|
|
opt_loop,
|
2011-03-17 13:20:04 +03:00
|
|
|
"<tr><th>%k</th><td>%t</td><td>%V</td></tr>\n");
|
2011-02-21 00:04:53 +03:00
|
|
|
if (res <= 0)
|
|
|
|
break; /* last option */
|
|
|
|
|
2011-02-21 02:41:50 +03:00
|
|
|
if (res >= (int) (sizeof buffer - slen)) {
|
2011-02-21 00:04:53 +03:00
|
|
|
/* last entry would not fit in buffer, submit buffer */
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-02-21 00:04:53 +03:00
|
|
|
goto fetch_about_config_handler_aborted;
|
|
|
|
slen = 0;
|
|
|
|
} else {
|
|
|
|
/* normal addition */
|
|
|
|
slen += res;
|
|
|
|
opt_loop++;
|
|
|
|
}
|
|
|
|
} while (res > 0);
|
|
|
|
|
|
|
|
slen += snprintf(buffer + slen, sizeof buffer - slen,
|
2011-03-18 15:10:15 +03:00
|
|
|
"</table>\n</body>\n</html>\n");
|
2011-02-21 00:04:53 +03:00
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-02-21 00:04:53 +03:00
|
|
|
goto fetch_about_config_handler_aborted;
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_FINISHED;
|
|
|
|
fetch_about_send_callback(&msg, ctx);
|
2011-02-21 00:04:53 +03:00
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
fetch_about_config_handler_aborted:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-10-11 02:41:31 +04:00
|
|
|
|
2011-02-21 00:04:53 +03:00
|
|
|
/** Generate the text of a Choices file which represents the current
|
|
|
|
* in use options.
|
|
|
|
*/
|
|
|
|
static bool fetch_about_choices_handler(struct fetch_about_context *ctx)
|
|
|
|
{
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_msg msg;
|
2011-02-21 00:04:53 +03:00
|
|
|
char buffer[1024];
|
|
|
|
int code = 200;
|
|
|
|
int slen;
|
|
|
|
unsigned int opt_loop = 0;
|
|
|
|
int res = 0;
|
|
|
|
|
|
|
|
/* content is going to return ok */
|
|
|
|
fetch_set_http_code(ctx->fetchh, code);
|
|
|
|
|
|
|
|
/* content type */
|
|
|
|
if (fetch_about_send_header(ctx, "Content-Type: text/plain"))
|
|
|
|
goto fetch_about_choices_handler_aborted;
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_DATA;
|
|
|
|
msg.data.header_or_data.buf = (const uint8_t *) buffer;
|
|
|
|
|
2011-02-21 00:04:53 +03:00
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
|
|
|
"# Automatically generated current NetSurf browser Choices\n");
|
|
|
|
|
|
|
|
do {
|
2012-03-22 13:34:34 +04:00
|
|
|
res = nsoption_snoptionf(buffer + slen,
|
2011-02-21 00:04:53 +03:00
|
|
|
sizeof buffer - slen,
|
|
|
|
opt_loop,
|
|
|
|
"%k:%v\n");
|
|
|
|
if (res <= 0)
|
|
|
|
break; /* last option */
|
|
|
|
|
2011-02-21 02:41:50 +03:00
|
|
|
if (res >= (int) (sizeof buffer - slen)) {
|
2011-02-21 00:04:53 +03:00
|
|
|
/* last entry would not fit in buffer, submit buffer */
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-02-21 00:04:53 +03:00
|
|
|
goto fetch_about_choices_handler_aborted;
|
|
|
|
slen = 0;
|
|
|
|
} else {
|
|
|
|
/* normal addition */
|
|
|
|
slen += res;
|
|
|
|
opt_loop++;
|
|
|
|
}
|
|
|
|
} while (res > 0);
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-02-21 00:04:53 +03:00
|
|
|
goto fetch_about_choices_handler_aborted;
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_FINISHED;
|
|
|
|
fetch_about_send_callback(&msg, ctx);
|
2011-02-21 00:04:53 +03:00
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
fetch_about_choices_handler_aborted:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-03-13 14:59:20 +03:00
|
|
|
/** Generate the text of an svn testament which represents the current
|
|
|
|
* build-tree status
|
|
|
|
*/
|
2012-06-04 19:48:21 +04:00
|
|
|
typedef struct { const char *leaf; const char *modtype; } modification_t;
|
2011-03-13 14:59:20 +03:00
|
|
|
static bool fetch_about_testament_handler(struct fetch_about_context *ctx)
|
|
|
|
{
|
2011-03-17 15:12:55 +03:00
|
|
|
static modification_t modifications[] = WT_MODIFICATIONS;
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_msg msg;
|
2011-03-13 14:59:20 +03:00
|
|
|
char buffer[1024];
|
|
|
|
int code = 200;
|
|
|
|
int slen;
|
2011-03-17 15:12:55 +03:00
|
|
|
int i;
|
|
|
|
|
2011-03-13 14:59:20 +03:00
|
|
|
|
|
|
|
/* content is going to return ok */
|
|
|
|
fetch_set_http_code(ctx->fetchh, code);
|
|
|
|
|
|
|
|
/* content type */
|
|
|
|
if (fetch_about_send_header(ctx, "Content-Type: text/plain"))
|
|
|
|
goto fetch_about_testament_handler_aborted;
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_DATA;
|
|
|
|
msg.data.header_or_data.buf = (const uint8_t *) buffer;
|
|
|
|
|
2011-03-13 14:59:20 +03:00
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
|
|
|
"# Automatically generated by NetSurf build system\n\n");
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-03-13 14:59:20 +03:00
|
|
|
goto fetch_about_testament_handler_aborted;
|
|
|
|
|
2011-03-17 15:12:55 +03:00
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
2012-06-04 19:48:21 +04:00
|
|
|
#if defined(WT_BRANCHISTRUNK) || defined(WT_BRANCHISMASTER)
|
|
|
|
"# This is a *DEVELOPMENT* build from the main line.\n\n"
|
|
|
|
#elif defined(WT_BRANCHISTAG) && (WT_MODIFIED == 0)
|
|
|
|
"# This is a tagged build of NetSurf\n"
|
|
|
|
#ifdef WT_TAGIS
|
|
|
|
"# The tag used was '" WT_TAGIS "'\n\n"
|
|
|
|
#else
|
|
|
|
"\n"
|
|
|
|
#endif
|
|
|
|
#elif defined(WT_NO_SVN) || defined(WT_NO_GIT)
|
2011-03-18 15:10:15 +03:00
|
|
|
"# This NetSurf was built outside of our revision "
|
|
|
|
"control environment.\n"
|
|
|
|
"# This testament is therefore very useful.\n\n"
|
2011-03-13 14:59:20 +03:00
|
|
|
#else
|
2012-06-04 19:48:21 +04:00
|
|
|
"# This NetSurf was built from a branch (" WT_BRANCHPATH ").\n\n"
|
2012-10-06 21:12:57 +04:00
|
|
|
#endif
|
|
|
|
#if defined(CI_BUILD)
|
|
|
|
"# This build carries the CI build number '" CI_BUILD "'\n\n"
|
2011-03-13 14:59:20 +03:00
|
|
|
#endif
|
2011-03-17 15:12:55 +03:00
|
|
|
);
|
2011-11-09 01:51:42 +04:00
|
|
|
|
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-03-13 14:59:20 +03:00
|
|
|
goto fetch_about_testament_handler_aborted;
|
|
|
|
|
2011-03-17 15:12:55 +03:00
|
|
|
|
2011-03-13 14:59:20 +03:00
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
2011-03-17 15:12:55 +03:00
|
|
|
"Built by %s (%s) from %s at revision %s\n\n",
|
|
|
|
GECOS, USERNAME, WT_BRANCHPATH, WT_REVID);
|
2011-03-13 14:59:20 +03:00
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-03-13 14:59:20 +03:00
|
|
|
goto fetch_about_testament_handler_aborted;
|
2011-03-17 15:12:55 +03:00
|
|
|
|
2011-03-13 15:17:18 +03:00
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
2011-03-17 15:12:55 +03:00
|
|
|
"Built on %s in %s\n\n",
|
|
|
|
WT_HOSTNAME, WT_ROOT);
|
2011-03-13 15:17:18 +03:00
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-03-13 15:17:18 +03:00
|
|
|
goto fetch_about_testament_handler_aborted;
|
2011-03-17 15:12:55 +03:00
|
|
|
|
|
|
|
if (WT_MODIFIED > 0) {
|
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
|
|
|
"Working tree has %d modification%s\n\n",
|
|
|
|
WT_MODIFIED, WT_MODIFIED == 1 ? "" : "s");
|
|
|
|
} else {
|
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
|
|
|
"Working tree is not modified.\n");
|
|
|
|
}
|
2011-03-13 14:59:20 +03:00
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-03-13 14:59:20 +03:00
|
|
|
goto fetch_about_testament_handler_aborted;
|
2011-03-17 15:12:55 +03:00
|
|
|
|
|
|
|
for (i = 0; i < WT_MODIFIED; ++i) {
|
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
2012-06-04 19:48:21 +04:00
|
|
|
" %s %s\n",
|
2011-03-17 15:12:55 +03:00
|
|
|
modifications[i].modtype,
|
|
|
|
modifications[i].leaf);
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-03-17 15:12:55 +03:00
|
|
|
goto fetch_about_testament_handler_aborted;
|
|
|
|
|
|
|
|
}
|
2011-11-09 01:51:42 +04:00
|
|
|
|
|
|
|
msg.type = FETCH_FINISHED;
|
|
|
|
fetch_about_send_callback(&msg, ctx);
|
2011-03-13 14:59:20 +03:00
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
fetch_about_testament_handler_aborted:
|
|
|
|
return false;
|
|
|
|
}
|
2011-02-21 00:04:53 +03:00
|
|
|
|
2011-05-14 04:17:25 +04:00
|
|
|
static bool fetch_about_logo_handler(struct fetch_about_context *ctx)
|
|
|
|
{
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_msg msg;
|
|
|
|
|
2011-05-14 04:17:25 +04:00
|
|
|
/* content is going to return redirect */
|
|
|
|
fetch_set_http_code(ctx->fetchh, 302);
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_REDIRECT;
|
|
|
|
msg.data.redirect = "resource:netsurf.png";
|
|
|
|
|
|
|
|
fetch_about_send_callback(&msg, ctx);
|
2011-05-14 04:17:25 +04:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-07-21 16:12:51 +04:00
|
|
|
static bool fetch_about_welcome_handler(struct fetch_about_context *ctx)
|
|
|
|
{
|
|
|
|
fetch_msg msg;
|
|
|
|
|
|
|
|
/* content is going to return redirect */
|
|
|
|
fetch_set_http_code(ctx->fetchh, 302);
|
|
|
|
|
|
|
|
msg.type = FETCH_REDIRECT;
|
|
|
|
msg.data.redirect = "resource:welcome.html";
|
|
|
|
|
|
|
|
fetch_about_send_callback(&msg, ctx);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-03-17 13:20:04 +03:00
|
|
|
/* Forward declaration because this handler requires the handler table. */
|
|
|
|
static bool fetch_about_about_handler(struct fetch_about_context *ctx);
|
|
|
|
|
2011-02-16 02:18:10 +03:00
|
|
|
struct about_handlers {
|
2011-03-17 15:24:40 +03:00
|
|
|
const char *name; /**< name to match in url */
|
2011-10-10 23:46:46 +04:00
|
|
|
int name_len;
|
|
|
|
lwc_string *lname; /**< Interned name */
|
2011-03-17 15:24:40 +03:00
|
|
|
fetch_about_handler handler; /* handler for the url */
|
2012-04-13 16:29:52 +04:00
|
|
|
bool hidden; /* Flag indicating if entry should show in listing */
|
2011-02-16 02:18:10 +03:00
|
|
|
};
|
|
|
|
|
2011-10-10 23:46:46 +04:00
|
|
|
/** List of about paths and their handlers */
|
2012-07-21 16:12:51 +04:00
|
|
|
struct about_handlers about_handler_list[] = {
|
2012-04-13 16:29:52 +04:00
|
|
|
{ "credits", SLEN("credits"), NULL,
|
|
|
|
fetch_about_credits_handler, false },
|
|
|
|
{ "licence", SLEN("licence"), NULL,
|
|
|
|
fetch_about_licence_handler, false },
|
|
|
|
{ "license", SLEN("license"), NULL,
|
|
|
|
fetch_about_licence_handler, true },
|
2012-07-21 16:12:51 +04:00
|
|
|
{ "welcome", SLEN("welcome"), NULL,
|
|
|
|
fetch_about_welcome_handler, false },
|
2012-04-13 16:29:52 +04:00
|
|
|
{ "config", SLEN("config"), NULL,
|
|
|
|
fetch_about_config_handler, false },
|
|
|
|
{ "Choices", SLEN("Choices"), NULL,
|
|
|
|
fetch_about_choices_handler, false },
|
|
|
|
{ "testament", SLEN("testament"), NULL,
|
|
|
|
fetch_about_testament_handler, false },
|
|
|
|
{ "about", SLEN("about"), NULL,
|
|
|
|
fetch_about_about_handler, true },
|
|
|
|
{ "logo", SLEN("logo"), NULL,
|
|
|
|
fetch_about_logo_handler, true },
|
|
|
|
/* details about the image cache */
|
|
|
|
{ "imagecache", SLEN("imagecache"), NULL,
|
|
|
|
fetch_about_imagecache_handler, true },
|
2011-10-11 02:41:31 +04:00
|
|
|
/* The default blank page */
|
2012-04-13 16:29:52 +04:00
|
|
|
{ "blank", SLEN("blank"), NULL,
|
|
|
|
fetch_about_blank_handler, true }
|
2011-02-16 02:18:10 +03:00
|
|
|
};
|
|
|
|
|
2012-07-21 16:12:51 +04:00
|
|
|
#define about_handler_list_len (sizeof(about_handler_list) / \
|
|
|
|
sizeof(struct about_handlers))
|
2011-02-16 02:18:10 +03:00
|
|
|
|
2011-03-17 13:20:04 +03:00
|
|
|
/**
|
|
|
|
* List all the valid about: paths available
|
|
|
|
*
|
|
|
|
* \param ctx The fetch context.
|
|
|
|
* \return true for sucess or false to generate an error.
|
|
|
|
*/
|
|
|
|
static bool fetch_about_about_handler(struct fetch_about_context *ctx)
|
|
|
|
{
|
2011-11-09 01:51:42 +04:00
|
|
|
fetch_msg msg;
|
2011-03-17 13:20:04 +03:00
|
|
|
char buffer[1024];
|
|
|
|
int code = 200;
|
|
|
|
int slen;
|
|
|
|
unsigned int abt_loop = 0;
|
|
|
|
int res = 0;
|
|
|
|
|
|
|
|
/* content is going to return ok */
|
|
|
|
fetch_set_http_code(ctx->fetchh, code);
|
|
|
|
|
|
|
|
/* content type */
|
|
|
|
if (fetch_about_send_header(ctx, "Content-Type: text/html"))
|
|
|
|
goto fetch_about_config_handler_aborted;
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_DATA;
|
|
|
|
msg.data.header_or_data.buf = (const uint8_t *) buffer;
|
|
|
|
|
2011-03-17 13:20:04 +03:00
|
|
|
slen = snprintf(buffer, sizeof buffer,
|
2011-03-18 15:10:15 +03:00
|
|
|
"<html>\n<head>\n"
|
|
|
|
"<title>NetSurf List of About pages</title>\n"
|
|
|
|
"<link rel=\"stylesheet\" type=\"text/css\" "
|
|
|
|
"href=\"resource:internal.css\">\n"
|
|
|
|
"</head>\n"
|
|
|
|
"<body id =\"aboutlist\">\n"
|
2011-03-17 13:20:04 +03:00
|
|
|
"<p class=\"banner\">"
|
|
|
|
"<a href=\"http://www.netsurf-browser.org/\">"
|
|
|
|
"<img src=\"resource:netsurf.png\" alt=\"NetSurf\"></a>"
|
2011-03-18 15:10:15 +03:00
|
|
|
"</p>\n"
|
|
|
|
"<h1>NetSurf List of About pages</h1>\n"
|
2011-03-17 13:20:04 +03:00
|
|
|
"<ul>\n");
|
|
|
|
|
|
|
|
for (abt_loop = 0; abt_loop < about_handler_list_len; abt_loop++) {
|
2011-03-17 15:09:48 +03:00
|
|
|
|
2011-03-17 15:26:59 +03:00
|
|
|
/* Skip over hidden entries */
|
2011-03-17 15:24:40 +03:00
|
|
|
if (about_handler_list[abt_loop].hidden)
|
2011-03-17 15:09:48 +03:00
|
|
|
continue;
|
|
|
|
|
2011-03-17 13:20:04 +03:00
|
|
|
res = snprintf(buffer + slen, sizeof buffer - slen,
|
|
|
|
"<li><a href=\"about:%s\">about:%s</a></li>\n",
|
|
|
|
about_handler_list[abt_loop].name,
|
|
|
|
about_handler_list[abt_loop].name);
|
|
|
|
if (res <= 0)
|
|
|
|
break; /* last option */
|
|
|
|
|
|
|
|
if (res >= (int)(sizeof buffer - slen)) {
|
|
|
|
/* last entry would not fit in buffer, submit buffer */
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-03-17 13:20:04 +03:00
|
|
|
goto fetch_about_config_handler_aborted;
|
|
|
|
slen = 0;
|
|
|
|
} else {
|
|
|
|
/* normal addition */
|
|
|
|
slen += res;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
slen += snprintf(buffer + slen, sizeof buffer - slen,
|
2011-03-18 15:10:15 +03:00
|
|
|
"</ul>\n</body>\n</html>\n");
|
2011-03-17 13:20:04 +03:00
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.data.header_or_data.len = slen;
|
|
|
|
if (fetch_about_send_callback(&msg, ctx))
|
2011-03-17 13:20:04 +03:00
|
|
|
goto fetch_about_config_handler_aborted;
|
|
|
|
|
2011-11-09 01:51:42 +04:00
|
|
|
msg.type = FETCH_FINISHED;
|
|
|
|
fetch_about_send_callback(&msg, ctx);
|
2011-03-17 13:20:04 +03:00
|
|
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
fetch_about_config_handler_aborted:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-16 02:18:10 +03:00
|
|
|
/** callback to initialise the about fetcher. */
|
2011-09-27 01:07:19 +04:00
|
|
|
static bool fetch_about_initialise(lwc_string *scheme)
|
2011-02-16 02:18:10 +03:00
|
|
|
{
|
2011-10-10 23:46:46 +04:00
|
|
|
unsigned int abt_loop = 0;
|
|
|
|
lwc_error error;
|
|
|
|
|
|
|
|
for (abt_loop = 0; abt_loop < about_handler_list_len; abt_loop++) {
|
|
|
|
error = lwc_intern_string(about_handler_list[abt_loop].name,
|
|
|
|
about_handler_list[abt_loop].name_len,
|
|
|
|
&about_handler_list[abt_loop].lname);
|
2011-10-11 10:55:20 +04:00
|
|
|
if (error != lwc_error_ok) {
|
|
|
|
while (abt_loop-- != 0) {
|
|
|
|
lwc_string_unref(about_handler_list[abt_loop].lname);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
2011-10-10 23:46:46 +04:00
|
|
|
}
|
|
|
|
|
2011-02-16 02:18:10 +03:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-10-10 23:46:46 +04:00
|
|
|
/** callback to finalise the about fetcher. */
|
2011-09-27 01:07:19 +04:00
|
|
|
static void fetch_about_finalise(lwc_string *scheme)
|
2011-02-16 02:18:10 +03:00
|
|
|
{
|
2011-10-10 23:46:46 +04:00
|
|
|
unsigned int abt_loop = 0;
|
|
|
|
for (abt_loop = 0; abt_loop < about_handler_list_len; abt_loop++) {
|
|
|
|
lwc_string_unref(about_handler_list[abt_loop].lname);
|
|
|
|
}
|
2011-02-16 02:18:10 +03:00
|
|
|
}
|
|
|
|
|
2011-11-27 18:14:36 +04:00
|
|
|
static bool fetch_about_can_fetch(const nsurl *url)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-02-16 02:18:10 +03:00
|
|
|
/** callback to set up a about fetch context. */
|
|
|
|
static void *
|
|
|
|
fetch_about_setup(struct fetch *fetchh,
|
2011-09-29 19:31:54 +04:00
|
|
|
nsurl *url,
|
2011-02-16 02:18:10 +03:00
|
|
|
bool only_2xx,
|
|
|
|
const char *post_urlenc,
|
|
|
|
const struct fetch_multipart_data *post_multipart,
|
|
|
|
const char **headers)
|
|
|
|
{
|
|
|
|
struct fetch_about_context *ctx;
|
|
|
|
unsigned int handler_loop;
|
2011-09-29 19:31:54 +04:00
|
|
|
lwc_string *path;
|
2011-10-10 23:46:46 +04:00
|
|
|
bool match;
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
ctx = calloc(1, sizeof(*ctx));
|
|
|
|
if (ctx == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2011-09-29 19:31:54 +04:00
|
|
|
path = nsurl_get_component(url, NSURL_PATH);
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
for (handler_loop = 0;
|
|
|
|
handler_loop < about_handler_list_len;
|
|
|
|
handler_loop++) {
|
|
|
|
ctx->handler = about_handler_list[handler_loop].handler;
|
2011-10-10 23:46:46 +04:00
|
|
|
if (lwc_string_isequal(path,
|
|
|
|
about_handler_list[handler_loop].lname,
|
|
|
|
&match) == lwc_error_ok && match) {
|
2011-02-16 02:18:10 +03:00
|
|
|
break;
|
2011-10-10 23:46:46 +04:00
|
|
|
}
|
2011-02-16 02:18:10 +03:00
|
|
|
}
|
|
|
|
|
2011-10-15 13:47:37 +04:00
|
|
|
if (path != NULL)
|
|
|
|
lwc_string_unref(path);
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
ctx->fetchh = fetchh;
|
2011-09-29 19:31:54 +04:00
|
|
|
ctx->url = nsurl_ref(url);
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
RING_INSERT(ring, ctx);
|
|
|
|
|
|
|
|
return ctx;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** callback to free a about fetch */
|
|
|
|
static void fetch_about_free(void *ctx)
|
|
|
|
{
|
|
|
|
struct fetch_about_context *c = ctx;
|
2011-09-29 19:31:54 +04:00
|
|
|
nsurl_unref(c->url);
|
2011-02-16 02:18:10 +03:00
|
|
|
RING_REMOVE(ring, c);
|
|
|
|
free(ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/** callback to start a about fetch */
|
|
|
|
static bool fetch_about_start(void *ctx)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** callback to abort a about fetch */
|
|
|
|
static void fetch_about_abort(void *ctx)
|
|
|
|
{
|
|
|
|
struct fetch_about_context *c = ctx;
|
|
|
|
|
|
|
|
/* To avoid the poll loop having to deal with the fetch context
|
|
|
|
* disappearing from under it, we simply flag the abort here.
|
|
|
|
* The poll loop itself will perform the appropriate cleanup.
|
|
|
|
*/
|
|
|
|
c->aborted = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** callback to poll for additional about fetch contents */
|
2011-09-27 01:07:19 +04:00
|
|
|
static void fetch_about_poll(lwc_string *scheme)
|
2011-02-16 02:18:10 +03:00
|
|
|
{
|
|
|
|
struct fetch_about_context *c, *next;
|
|
|
|
|
|
|
|
if (ring == NULL) return;
|
|
|
|
|
|
|
|
/* Iterate over ring, processing each pending fetch */
|
|
|
|
c = ring;
|
|
|
|
do {
|
|
|
|
/* Ignore fetches that have been flagged as locked.
|
|
|
|
* This allows safe re-entrant calls to this function.
|
|
|
|
* Re-entrancy can occur if, as a result of a callback,
|
|
|
|
* the interested party causes fetch_poll() to be called
|
|
|
|
* again.
|
|
|
|
*/
|
|
|
|
if (c->locked == true) {
|
2011-02-24 01:41:17 +03:00
|
|
|
next = c->r_next;
|
2011-02-16 02:18:10 +03:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Only process non-aborted fetches */
|
|
|
|
if (c->aborted == false) {
|
|
|
|
/* about fetches can be processed in one go */
|
|
|
|
c->handler(c);
|
|
|
|
}
|
|
|
|
|
2011-02-24 01:41:17 +03:00
|
|
|
/* Compute next fetch item at the last possible moment
|
|
|
|
* as processing this item may have added to the ring
|
|
|
|
*/
|
|
|
|
next = c->r_next;
|
2011-02-16 02:18:10 +03:00
|
|
|
|
|
|
|
fetch_remove_from_queues(c->fetchh);
|
|
|
|
fetch_free(c->fetchh);
|
|
|
|
|
|
|
|
/* Advance to next ring entry, exiting if we've reached
|
|
|
|
* the start of the ring or the ring has become empty
|
|
|
|
*/
|
|
|
|
} while ( (c = next) != ring && ring != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void fetch_about_register(void)
|
|
|
|
{
|
2011-09-27 01:07:19 +04:00
|
|
|
lwc_string *scheme;
|
|
|
|
|
|
|
|
if (lwc_intern_string("about", SLEN("about"),
|
|
|
|
&scheme) != lwc_error_ok) {
|
|
|
|
die("Failed to initialise the fetch module "
|
|
|
|
"(couldn't intern \"about\").");
|
|
|
|
}
|
|
|
|
|
|
|
|
fetch_add_fetcher(scheme,
|
2011-02-16 02:18:10 +03:00
|
|
|
fetch_about_initialise,
|
2011-11-27 18:14:36 +04:00
|
|
|
fetch_about_can_fetch,
|
2011-02-16 02:18:10 +03:00
|
|
|
fetch_about_setup,
|
|
|
|
fetch_about_start,
|
|
|
|
fetch_about_abort,
|
|
|
|
fetch_about_free,
|
|
|
|
fetch_about_poll,
|
|
|
|
fetch_about_finalise);
|
|
|
|
}
|