static void add_host_entry_to_file(HSTSProvider *provider, const char *host,
HSTSEntry *entry)
{
char *date = soup_date_to_string(entry->expires_at, SOUP_DATE_ISO8601_FULL);
util_file_append(
vb.files[FILES_HSTS], HSTS_FILE_FORMAT, host, date, entry->include_sub_domains ? 'y' : 'n'
);
g_free(date);
}
gchar *
twitter_http_date_from_time_t (time_t time_)
{
SoupDate *soup_date;
gchar *retval;
soup_date = soup_date_new_from_time_t (time_);
retval = soup_date_to_string (soup_date, SOUP_DATE_HTTP);
soup_date_free (soup_date);
return retval;
}
void rygel_mediathek_rss_container_update (RygelMediathekRssContainer* self) {
#line 342 "rygel-mediathek-rss-container.c"
char* _tmp0_;
SoupMessage* _tmp1_;
SoupMessage* message;
#line 98 "rygel-mediathek-rss-container.vala"
g_return_if_fail (self != NULL);
#line 99 "rygel-mediathek-rss-container.vala"
message = (_tmp1_ = soup_message_new ("GET", _tmp0_ = g_strdup_printf ("http://www.zdf.de/ZDFmediathek/content/%u?view=rss", self->priv->zdf_content_id)), _g_free0 (_tmp0_), _tmp1_);
#line 102 "rygel-mediathek-rss-container.vala"
if (self->priv->last_modified != NULL) {
#line 103 "rygel-mediathek-rss-container.vala"
g_debug (_ ("Requesting change since %s"), soup_date_to_string (self->priv->last_modified, SOUP_DATE_HTTP));
#line 105 "rygel-mediathek-rss-container.vala"
soup_message_headers_append (message->request_headers, "If-Modified-Since", soup_date_to_string (self->priv->last_modified, SOUP_DATE_HTTP));
#line 356 "rygel-mediathek-rss-container.c"
}
#line 109 "rygel-mediathek-rss-container.vala"
soup_session_queue_message ((SoupSession*) RYGEL_MEDIATHEK_ROOT_CONTAINER (((RygelMediaObject*) self)->parent)->session, _g_object_ref0 (message), _rygel_mediathek_rss_container_on_feed_got_soup_session_callback, self);
#line 360 "rygel-mediathek-rss-container.c"
_g_object_unref0 (message);
}
/*
* Send a discovery response
*/
static gboolean
discovery_response_timeout (gpointer user_data)
{
DiscoveryResponse *response = user_data;
GSSDPClient *client;
SoupDate *date;
char *al, *date_str, *message;
guint max_age;
char *usn;
GSSDPResourceGroup *self = response->resource->resource_group;
GSSDPResourceGroupPrivate *priv;
priv = gssdp_resource_group_get_instance_private (self);
/* Send message */
client = priv->client;
max_age = priv->max_age;
al = construct_al (response->resource);
usn = construct_usn (response->resource->usn,
response->target,
response->resource->target);
date = soup_date_new_from_now (0);
date_str = soup_date_to_string (date, SOUP_DATE_HTTP);
soup_date_free (date);
message = g_strdup_printf (SSDP_DISCOVERY_RESPONSE,
(char *) response->resource->locations->data,
al ? al : "",
usn,
gssdp_client_get_server_id (client),
max_age,
response->target,
date_str);
_gssdp_client_send_message (client,
response->dest_ip,
response->dest_port,
message,
_GSSDP_DISCOVERY_RESPONSE);
g_free (message);
g_free (date_str);
g_free (al);
g_free (usn);
discovery_response_free (response);
return FALSE;
}
static void
check_good (SoupDateFormat format, const char *strdate)
{
SoupDate *date;
char *strdate2;
date = make_date (strdate);
if (date)
strdate2 = soup_date_to_string (date, format);
if (!check_ok (strdate, date))
return;
if (strcmp (strdate, strdate2) != 0) {
debug_printf (1, " restringification failed: '%s' -> '%s'\n",
strdate, strdate2);
errors++;
}
g_free (strdate2);
}
void
print_cookie(char *msg, SoupCookie *c)
{
if (c == NULL)
return;
if (msg) {
DNPRINTF(XT_D_COOKIE, "%s\n", msg);
}
DNPRINTF(XT_D_COOKIE, "name : %s\n", c->name);
DNPRINTF(XT_D_COOKIE, "value : %s\n", c->value);
DNPRINTF(XT_D_COOKIE, "domain : %s\n", c->domain);
DNPRINTF(XT_D_COOKIE, "path : %s\n", c->path);
DNPRINTF(XT_D_COOKIE, "expires : %s\n",
c->expires ? soup_date_to_string(c->expires, SOUP_DATE_HTTP) : "");
DNPRINTF(XT_D_COOKIE, "secure : %d\n", c->secure);
DNPRINTF(XT_D_COOKIE, "http_only: %d\n", c->http_only);
DNPRINTF(XT_D_COOKIE, "====================================\n");
}
/**
* Saves all entries of given provider in given file.
*/
static void save_entries(HSTSProvider *provider, const char *file)
{
GHashTableIter iter;
char *host, *date;
HSTSEntry *entry;
FILE *f;
HSTSProviderPrivate *priv = HSTS_PROVIDER_GET_PRIVATE(provider);
if ((f = fopen(file, "w"))) {
flock(fileno(f), LOCK_EX);
g_hash_table_iter_init(&iter, priv->whitelist);
while (g_hash_table_iter_next (&iter, (gpointer)&host, (gpointer)&entry)) {
date = soup_date_to_string(entry->expires_at, SOUP_DATE_ISO8601_FULL);
fprintf(f, HSTS_FILE_FORMAT, host, date, entry->include_sub_domains ? 'y' : 'n');
g_free(date);
}
flock(fileno(f), LOCK_UN);
fclose(f);
}
}
static void
got_headers (SoupMessage *req, SoupClientContext *client)
{
SoupServer *server = client->server;
SoupServerPrivate *priv = SOUP_SERVER_GET_PRIVATE (server);
SoupURI *uri;
SoupDate *date;
char *date_string;
SoupAuthDomain *domain;
GSList *iter;
gboolean rejected = FALSE;
char *auth_user;
if (!priv->raw_paths) {
char *decoded_path;
uri = soup_message_get_uri (req);
decoded_path = soup_uri_decode (uri->path);
soup_uri_set_path (uri, decoded_path);
g_free (decoded_path);
}
/* Add required response headers */
date = soup_date_new_from_now (0);
date_string = soup_date_to_string (date, SOUP_DATE_HTTP);
soup_message_headers_replace (req->response_headers, "Date",
date_string);
g_free (date_string);
soup_date_free (date);
/* Now handle authentication. (We do this here so that if
* the request uses "Expect: 100-continue", we can reject it
* immediately rather than waiting for the request body to
* be sent.
*/
for (iter = priv->auth_domains; iter; iter = iter->next) {
domain = iter->data;
if (soup_auth_domain_covers (domain, req)) {
auth_user = soup_auth_domain_accepts (domain, req);
if (auth_user) {
client->auth_domain = g_object_ref (domain);
client->auth_user = auth_user;
return;
}
rejected = TRUE;
}
}
/* If no auth domain rejected it, then it's ok. */
if (!rejected)
return;
for (iter = priv->auth_domains; iter; iter = iter->next) {
domain = iter->data;
if (soup_auth_domain_covers (domain, req))
soup_auth_domain_challenge (domain, req);
}
}
void
aws_s3_client_read_async (AwsS3Client *client,
const gchar *bucket,
const gchar *path,
AwsS3ClientDataHandler handler,
gpointer handler_data,
GDestroyNotify handler_notify,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
AwsS3ClientPrivate *priv = aws_s3_client_get_instance_private (client);
g_autoptr(GTask) task = NULL;
g_autofree gchar *auth = NULL;
g_autofree gchar *date_str = NULL;
g_autofree gchar *signature = NULL;
g_autofree gchar *uri = NULL;
g_autoptr(SoupDate) date = NULL;
g_autoptr(GString) str = NULL;
g_autoptr(SoupMessage) message = NULL;
ReadState *state;
guint16 port;
g_return_if_fail (AWS_IS_S3_CLIENT(client));
g_return_if_fail (bucket);
g_return_if_fail (path);
g_return_if_fail (g_utf8_validate(bucket, -1, NULL));
g_return_if_fail (g_utf8_validate(path, -1, NULL));
g_return_if_fail (handler != NULL);
task = g_task_new (client, cancellable, callback, user_data);
g_task_set_source_tag (task, aws_s3_client_read_async);
state = read_state_new (handler, handler_data, handler_notify);
g_task_set_task_data (task, state, read_state_free);
/*
* Strip leading '/' from the path.
*/
while (g_utf8_get_char (path) == '/')
path = g_utf8_next_char (path);
/*
* Determine our connection port.
*/
port = priv->port_set ? priv->port : (priv->secure ? 443 : 80);
/*
* Build our HTTP request message.
*/
uri = g_strdup_printf ("%s://%s:%d/%s/%s",
priv->secure ? "https" : "http",
priv->host,
port,
bucket,
path);
message = soup_message_new (SOUP_METHOD_GET, uri);
soup_message_body_set_accumulate (message->response_body, FALSE);
g_signal_connect_object (message,
"got-chunk",
G_CALLBACK (aws_s3_client_read_got_chunk),
task,
0);
g_signal_connect_object (message,
"got-headers",
G_CALLBACK (aws_s3_client_read_got_headers),
task,
0);
/*
* Set the Host header for systems that may be proxying.
*/
if (priv->host != NULL)
soup_message_headers_append (message->request_headers, "Host", priv->host);
/*
* Add the Date header which we need for signing.
*/
date = soup_date_new_from_now (0);
date_str = soup_date_to_string (date, SOUP_DATE_HTTP);
soup_message_headers_append (message->request_headers, "Date", date_str);
/*
* Sign our request.
*/
str = g_string_new ("GET\n\n\n");
g_string_append_printf (str, "%s\n", date_str);
g_string_append_printf (str, "/%s/%s", bucket, path);
signature = aws_credentials_sign (priv->creds, str->str, str->len, G_CHECKSUM_SHA1);
/*
* Attach request signature to our headers.
*/
auth = g_strdup_printf ("AWS %s:%s",
aws_credentials_get_access_key (priv->creds),
signature);
soup_message_headers_append (message->request_headers, "Authorization", auth);
/*
* Submit our request to the target.
*/
soup_session_queue_message (SOUP_SESSION (client),
g_steal_pointer (&message),
aws_s3_client_read_cb,
g_steal_pointer (&task));
}
static gint _cookie_permission_manager_ask_for_policy(CookiePermissionManager *self,
MidoriView *inView,
SoupMessage *inMessage,
GSList *inUnknownCookies)
{
/* Ask user for policy of unkndown domains in an undistracting way.
* The idea is to put the message not in a modal window but into midori's info bar.
* Then we'll set up our own GMainLoop to simulate a modal info bar. We need to
* connect to all possible signals of info bar, web view and so on to handle user's
* decision and to get out of our own GMainLoop. After that webkit resumes processing
* data.
*/
CookiePermissionManagerPrivate *priv=self->priv;
GtkWidget *infobar;
/* FIXME: Find a way to add "details" widget */
#ifndef NO_INFOBAR_DETAILS
GtkWidget *widget;
GtkWidget *contentArea;
GtkWidget *vbox, *hbox;
GtkWidget *expander;
GtkListStore *listStore;
GtkTreeIter listIter;
GtkWidget *scrolled;
GtkWidget *list;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
#endif
gchar *text;
gint numberDomains, numberCookies;
GSList *sortedCookies, *cookies;
WebKitWebView *webkitView;
CookiePermissionManagerModalInfobar *modalInfo;
/* Get webkit view of midori view */
webkitView=WEBKIT_WEB_VIEW(midori_view_get_web_view(inView));
modalInfo=g_new0(CookiePermissionManagerModalInfobar, 1);
/* Create a copy of cookies and sort them */
sortedCookies=_cookie_permission_manager_get_number_domains_and_cookies(self,
inUnknownCookies,
&numberDomains,
&numberCookies);
/* FIXME: Find a way to add "details" widget */
#ifndef NO_INFOBAR_DETAILS
/* Create list model and fill in data */
listStore=gtk_list_store_new(N_COLUMN,
G_TYPE_STRING, /* DOMAIN_COLUMN */
G_TYPE_STRING, /* PATH_COLUMN */
G_TYPE_STRING, /* NAME_COLUMN */
G_TYPE_STRING, /* VALUE_COLUMN */
G_TYPE_STRING /* EXPIRE_DATE_COLUMN */);
for(cookies=sortedCookies; cookies; cookies=cookies->next)
{
SoupCookie *cookie=(SoupCookie*)cookies->data;
SoupDate *cookieDate=soup_cookie_get_expires(cookie);
if(cookieDate) text=soup_date_to_string(cookieDate, SOUP_DATE_HTTP);
else text=g_strdup(_("Till session end"));
gtk_list_store_append(listStore, &listIter);
gtk_list_store_set(listStore,
&listIter,
DOMAIN_COLUMN, soup_cookie_get_domain(cookie),
PATH_COLUMN, soup_cookie_get_path(cookie),
NAME_COLUMN, soup_cookie_get_name(cookie),
VALUE_COLUMN, soup_cookie_get_value(cookie),
EXPIRE_DATE_COLUMN, text,
-1);
g_free(text);
}
#endif
/* Create description text */
if(numberDomains==1)
{
const gchar *cookieDomain=soup_cookie_get_domain((SoupCookie*)sortedCookies->data);
if(*cookieDomain=='.') cookieDomain++;
if(numberCookies>1)
text=g_strdup_printf(_("The website %s wants to store %d cookies."), cookieDomain, numberCookies);
else
text=g_strdup_printf(_("The website %s wants to store a cookie."), cookieDomain);
}
else
{
text=g_strdup_printf(_("Multiple websites want to store %d cookies in total."), numberCookies);
}
/* Create info bar message and buttons */
infobar=midori_view_add_info_bar(inView,
GTK_MESSAGE_QUESTION,
text,
G_CALLBACK(_cookie_permission_manager_on_infobar_policy_decision),
NULL,
_("_Accept"), COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT,
_("Accept for this _session"), COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT_FOR_SESSION,
_("De_ny"), COOKIE_PERMISSION_MANAGER_POLICY_BLOCK,
_("Deny _this time"), COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED,
NULL);
g_free(text);
/* midori_view_add_info_bar() in version 0.4.8 expects a GObject as user data
* but I don't want to create an GObject just for a simple struct. So set object
* data by our own
*/
g_object_set_data_full(G_OBJECT(infobar), "cookie-permission-manager-infobar-data", modalInfo, (GDestroyNotify)g_free);
/* FIXME: Find a way to add "details" widget */
#ifndef NO_INFOBAR_DETAILS
/* Get content area of infobar */
contentArea=gtk_info_bar_get_content_area(GTK_INFO_BAR(infobar));
/* Create list and set up columns of list */
list=gtk_tree_view_new_with_model(GTK_TREE_MODEL(listStore));
#ifndef HAVE_GTK3
gtk_widget_set_size_request(list, -1, 100);
#endif
renderer=gtk_cell_renderer_text_new();
column=gtk_tree_view_column_new_with_attributes(_("Domain"),
renderer,
"text", DOMAIN_COLUMN,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
renderer=gtk_cell_renderer_text_new();
column=gtk_tree_view_column_new_with_attributes(_("Path"),
renderer,
"text", PATH_COLUMN,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
renderer=gtk_cell_renderer_text_new();
column=gtk_tree_view_column_new_with_attributes(_("Name"),
renderer,
"text", NAME_COLUMN,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
renderer=gtk_cell_renderer_text_new();
column=gtk_tree_view_column_new_with_attributes(_("Value"),
renderer,
"text", VALUE_COLUMN,
NULL);
g_object_set(G_OBJECT(renderer),
"ellipsize", PANGO_ELLIPSIZE_END,
"width-chars", 30,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
renderer=gtk_cell_renderer_text_new();
column=gtk_tree_view_column_new_with_attributes(_("Expire date"),
renderer,
"text", EXPIRE_DATE_COLUMN,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(list), column);
scrolled=gtk_scrolled_window_new(NULL, NULL);
#ifdef HAVE_GTK3
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), 100);
#endif
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrolled), list);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(expander), scrolled);
gtk_widget_show_all(vbox);
gtk_container_add(GTK_CONTAINER(contentArea), vbox);
/* Set state of expander based on config 'show-details-when-ask' */
gtk_expander_set_expanded(GTK_EXPANDER(expander),
midori_extension_get_boolean(priv->extension, "show-details-when-ask"));
g_signal_connect_swapped(expander, "notify::expanded", G_CALLBACK(_cookie_permission_manager_when_ask_expander_changed), self);
#endif
/* Show all widgets of info bar */
gtk_widget_show_all(infobar);
/* Connect signals to quit main loop */
g_signal_connect(webkitView, "navigation-policy-decision-requested", G_CALLBACK(_cookie_permission_manager_on_infobar_webview_navigate), infobar);
g_signal_connect(infobar, "destroy", G_CALLBACK(_cookie_permission_manager_on_infobar_destroy), modalInfo);
/* Let info bar be modal and set response to default */
modalInfo->response=COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED;
modalInfo->mainLoop=g_main_loop_new(NULL, FALSE);
GDK_THREADS_LEAVE();
g_main_loop_run(modalInfo->mainLoop);
GDK_THREADS_ENTER();
g_main_loop_unref(modalInfo->mainLoop);
modalInfo->mainLoop=NULL;
/* Disconnect signal handler to webkit's web view */
g_signal_handlers_disconnect_by_func(webkitView, G_CALLBACK(_cookie_permission_manager_on_infobar_webview_navigate), infobar);
/* Store user's decision in database if it is not a temporary block.
* We use the already sorted list of cookies to prevent multiple
* updates of database for the same domain. This sorted list is a copy
* to avoid a reorder of cookies
*/
if(modalInfo->response!=COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED)
{
const gchar *lastDomain=NULL;
/* Iterate through cookies and store decision for each domain once */
for(cookies=sortedCookies; cookies; cookies=cookies->next)
{
SoupCookie *cookie=(SoupCookie*)cookies->data;
const gchar *cookieDomain=soup_cookie_get_domain(cookie);
if(*cookieDomain=='.') cookieDomain++;
/* Store decision if new domain found while iterating through cookies */
if(!lastDomain || g_ascii_strcasecmp(lastDomain, cookieDomain)!=0)
{
gchar *sql;
gchar *error=NULL;
gint success;
sql=sqlite3_mprintf("INSERT OR REPLACE INTO policies (domain, value) VALUES ('%q', %d);",
cookieDomain,
modalInfo->response);
success=sqlite3_exec(priv->database, sql, NULL, NULL, &error);
if(success!=SQLITE_OK) g_warning(_("SQL fails: %s"), error);
if(error) sqlite3_free(error);
sqlite3_free(sql);
lastDomain=cookieDomain;
}
}
}
/* Free up allocated resources */
g_slist_free(sortedCookies);
/* Return response */
return(modalInfo->response==COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED ?
COOKIE_PERMISSION_MANAGER_POLICY_BLOCK : modalInfo->response);
}
/* Downloads a feed specified in the request structure, returns
the downloaded data or NULL in the request structure.
If the webserver reports a permanent redirection, the
feed url will be modified and the old URL 'll be freed. The
request structure will also contain the HTTP status and the
last modified string.
*/
void
network_process_request (const updateJobPtr job)
{
SoupMessage *msg;
SoupDate *date;
gboolean do_not_track = FALSE;
g_assert (NULL != job->request);
debug1 (DEBUG_NET, "downloading %s", job->request->source);
if (job->request->postdata && (debug_level & DEBUG_VERBOSE) && (debug_level & DEBUG_NET))
debug1 (DEBUG_NET, " postdata=>>>%s<<<", job->request->postdata);
/* Prepare the SoupMessage */
msg = soup_message_new (job->request->postdata ? SOUP_METHOD_POST : SOUP_METHOD_GET,
job->request->source);
if (!msg) {
g_warning ("The request for %s could not be parsed!", job->request->source);
return;
}
/* Set the postdata for the request */
if (job->request->postdata) {
soup_message_set_request (msg,
"application/x-www-form-urlencoded",
SOUP_MEMORY_STATIC, /* libsoup won't free the postdata */
job->request->postdata,
strlen (job->request->postdata));
}
/* Set the If-Modified-Since: header */
if (job->request->updateState && update_state_get_lastmodified (job->request->updateState)) {
gchar *datestr;
date = soup_date_new_from_time_t (update_state_get_lastmodified (job->request->updateState));
datestr = soup_date_to_string (date, SOUP_DATE_HTTP);
soup_message_headers_append (msg->request_headers,
"If-Modified-Since",
datestr);
g_free (datestr);
soup_date_free (date);
}
/* Set the If-None-Match header */
if (job->request->updateState && update_state_get_etag (job->request->updateState)) {
soup_message_headers_append(msg->request_headers,
"If-None-Match",
update_state_get_etag (job->request->updateState));
}
/* Set the I-AM header */
if (job->request->updateState &&
(update_state_get_lastmodified (job->request->updateState) ||
update_state_get_etag (job->request->updateState))) {
soup_message_headers_append(msg->request_headers,
"A-IM",
"feed");
}
/* Support HTTP content negotiation */
soup_message_headers_append(msg->request_headers, "Accept", "application/atom+xml,application/xml;q=0.9,text/xml;q=0.8,*/*;q=0.7");
/* Set the authentication */
if (!job->request->authValue &&
job->request->options &&
job->request->options->username &&
job->request->options->password) {
SoupURI *uri = soup_message_get_uri (msg);
soup_uri_set_user (uri, job->request->options->username);
soup_uri_set_password (uri, job->request->options->password);
}
if (job->request->authValue) {
soup_message_headers_append (msg->request_headers, "Authorization",
job->request->authValue);
}
/* Add requested cookies */
if (job->request->updateState && job->request->updateState->cookies) {
soup_message_headers_append (msg->request_headers, "Cookie",
job->request->updateState->cookies);
soup_message_disable_feature (msg, SOUP_TYPE_COOKIE_JAR);
}
/* TODO: Right now we send the msg, and if it requires authentication and
* we didn't provide one, the petition fails and when the job is processed
* it sees it needs authentication and displays a dialog, and if credentials
* are entered, it queues a new job with auth credentials. Instead of that,
* we should probably handle authentication directly here, connecting the
* msg to a callback in case of 401 (see soup_message_add_status_code_handler())
* displaying the dialog ourselves, and requeing the msg if we get credentials */
/* Add Do Not Track header according to settings */
conf_get_bool_value (DO_NOT_TRACK, &do_not_track);
if (do_not_track)
soup_message_headers_append (msg->request_headers, "DNT", "1");
/* If the feed has "dont use a proxy" selected, use 'session2' which is non-proxy */
if (job->request->options && job->request->options->dontUseProxy)
soup_session_queue_message (session2, msg, network_process_callback, job);
else
soup_session_queue_message (session, msg, network_process_callback, job);
}
static void
check_conversion (const struct conversion *conv)
{
SoupDate *date;
char *str;
debug_printf (2, "%s\n", conv->source);
date = make_date (conv->source);
if (!date) {
debug_printf (1, " date parsing failed for '%s'.\n", conv->source);
errors++;
return;
}
str = soup_date_to_string (date, SOUP_DATE_HTTP);
if (!str || strcmp (str, conv->http) != 0) {
debug_printf (1, " conversion of '%s' to HTTP failed:\n"
" wanted: %s\n got: %s\n",
conv->source, conv->http, str ? str : "(null)");
errors++;
}
g_free (str);
str = soup_date_to_string (date, SOUP_DATE_COOKIE);
if (!str || strcmp (str, conv->cookie) != 0) {
debug_printf (1, " conversion of '%s' to COOKIE failed:\n"
" wanted: %s\n got: %s\n",
conv->source, conv->cookie, str ? str : "(null)");
errors++;
}
g_free (str);
str = soup_date_to_string (date, SOUP_DATE_RFC2822);
if (!str || strcmp (str, conv->rfc2822) != 0) {
debug_printf (1, " conversion of '%s' to RFC2822 failed:\n"
" wanted: %s\n got: %s\n",
conv->source, conv->rfc2822, str ? str : "(null)");
errors++;
}
g_free (str);
str = soup_date_to_string (date, SOUP_DATE_ISO8601_COMPACT);
if (!str || strcmp (str, conv->compact) != 0) {
debug_printf (1, " conversion of '%s' to COMPACT failed:\n"
" wanted: %s\n got: %s\n",
conv->source, conv->compact, str ? str : "(null)");
errors++;
}
g_free (str);
str = soup_date_to_string (date, SOUP_DATE_ISO8601_FULL);
if (!str || strcmp (str, conv->full) != 0) {
debug_printf (1, " conversion of '%s' to FULL failed:\n"
" wanted: %s\n got: %s\n",
conv->source, conv->full, str ? str : "(null)");
errors++;
}
g_free (str);
str = soup_date_to_string (date, SOUP_DATE_ISO8601_XMLRPC);
if (!str || strcmp (str, conv->xmlrpc) != 0) {
debug_printf (1, " conversion of '%s' to XMLRPC failed:\n"
" wanted: %s\n got: %s\n",
conv->source, conv->xmlrpc, str ? str : "(null)");
errors++;
}
g_free (str);
soup_date_free (date);
}
/* Downloads a feed specified in the request structure, returns
the downloaded data or NULL in the request structure.
If the the webserver reports a permanent redirection, the
feed url will be modified and the old URL 'll be freed. The
request structure will also contain the HTTP status and the
last modified string.
*/
void
network_process_request (const updateJobPtr const job)
{
SoupMessage *msg;
SoupDate *date;
g_assert (NULL != job->request);
debug1 (DEBUG_NET, "downloading %s", job->request->source);
/* Prepare the SoupMessage */
msg = soup_message_new (job->request->postdata ? SOUP_METHOD_POST : SOUP_METHOD_GET,
job->request->source);
if (!msg) {
g_warning ("The request for %s could not be parsed!", job->request->source);
return;
}
/* Set the postdata for the request */
if (job->request->postdata) {
soup_message_set_request (msg,
"application/x-www-form-urlencoded",
SOUP_MEMORY_STATIC, /* libsoup won't free the postdata */
job->request->postdata,
strlen (job->request->postdata));
}
/* Set the If-Modified-Since: header */
if (job->request->updateState && job->request->updateState->lastModified) {
gchar *datestr;
date = soup_date_new_from_time_t (job->request->updateState->lastModified);
datestr = soup_date_to_string (date, SOUP_DATE_HTTP);
soup_message_headers_append (msg->request_headers,
"If-Modified-Since",
datestr);
g_free (datestr);
soup_date_free (date);
}
/* Set the authentication */
if (!job->request->authValue &&
job->request->options &&
job->request->options->username &&
job->request->options->password) {
SoupURI *uri = soup_message_get_uri (msg);
soup_uri_set_user (uri, job->request->options->username);
soup_uri_set_password (uri, job->request->options->password);
}
if (job->request->authValue) {
soup_message_headers_append (msg->request_headers, "Authorization",
job->request->authValue);
}
/* Add requested cookies */
if (job->request->updateState && job->request->updateState->cookies) {
soup_message_headers_append (msg->request_headers, "Cookie",
job->request->updateState->cookies);
soup_message_disable_feature (msg, SOUP_TYPE_COOKIE_JAR);
}
/* TODO: Right now we send the msg, and if it requires authentication and
* we didn't provide one, the petition fails and when the job is processed
* it sees it needs authentication and displays a dialog, and if credentials
* are entered, it queues a new job with auth credentials. Instead of that,
* we should probably handle authentication directly here, connecting the
* msg to a callback in case of 401 (see soup_message_add_status_code_handler())
* displaying the dialog ourselves, and requeing the msg if we get credentials */
/* If the feed has "dont use a proxy" selected, disable the proxy for the msg */
if ((job->request->options && job->request->options->dontUseProxy) ||
(network_get_proxy_host () == NULL))
soup_message_disable_feature (msg, SOUP_TYPE_PROXY_URI_RESOLVER);
soup_session_queue_message (session, msg, network_process_callback, job);
}
static gboolean
test_dateChange (void)
{
GHashTable *structval;
SoupDate *date, *result;
char *timestamp;
GValue retval;
gboolean ok;
debug_printf (1, "dateChange (date, struct of ints -> time): ");
date = soup_date_new (1970 + (rand () % 50),
1 + rand () % 12,
1 + rand () % 28,
rand () % 24,
rand () % 60,
rand () % 60);
if (debug_level >= 2) {
timestamp = soup_date_to_string (date, SOUP_DATE_ISO8601_XMLRPC);
debug_printf (2, "date: %s, {", timestamp);
g_free (timestamp);
}
structval = soup_value_hash_new ();
if (rand () % 3) {
date->year = 1970 + (rand () % 50);
debug_printf (2, "tm_year: %d, ", date->year - 1900);
soup_value_hash_insert (structval, "tm_year",
G_TYPE_INT, date->year - 1900);
}
if (rand () % 3) {
date->month = 1 + rand () % 12;
debug_printf (2, "tm_mon: %d, ", date->month - 1);
soup_value_hash_insert (structval, "tm_mon",
G_TYPE_INT, date->month - 1);
}
if (rand () % 3) {
date->day = 1 + rand () % 28;
debug_printf (2, "tm_mday: %d, ", date->day);
soup_value_hash_insert (structval, "tm_mday",
G_TYPE_INT, date->day);
}
if (rand () % 3) {
date->hour = rand () % 24;
debug_printf (2, "tm_hour: %d, ", date->hour);
soup_value_hash_insert (structval, "tm_hour",
G_TYPE_INT, date->hour);
}
if (rand () % 3) {
date->minute = rand () % 60;
debug_printf (2, "tm_min: %d, ", date->minute);
soup_value_hash_insert (structval, "tm_min",
G_TYPE_INT, date->minute);
}
if (rand () % 3) {
date->second = rand () % 60;
debug_printf (2, "tm_sec: %d, ", date->second);
soup_value_hash_insert (structval, "tm_sec",
G_TYPE_INT, date->second);
}
debug_printf (2, "} -> ");
ok = (do_xmlrpc ("dateChange", &retval,
SOUP_TYPE_DATE, date,
G_TYPE_HASH_TABLE, structval,
G_TYPE_INVALID) &&
check_xmlrpc (&retval, SOUP_TYPE_DATE, &result));
g_hash_table_destroy (structval);
if (!ok) {
soup_date_free (date);
return FALSE;
}
if (debug_level >= 2) {
timestamp = soup_date_to_string (result, SOUP_DATE_ISO8601_XMLRPC);
debug_printf (2, "%s: ", timestamp);
g_free (timestamp);
}
ok = ((date->year == result->year) &&
(date->month == result->month) &&
(date->day == result->day) &&
(date->hour == result->hour) &&
(date->minute == result->minute) &&
(date->second == result->second));
soup_date_free (date);
soup_date_free (result);
debug_printf (1, "%s\n", ok ? "OK!" : "WRONG!");
return ok;
}