void TestRunner::queueLoad(JSStringRef url, JSStringRef target)
{
GUniquePtr<gchar> relativeURL(JSStringCopyUTF8CString(url));
SoupURI* baseURI = soup_uri_new(webkit_web_frame_get_uri(mainFrame));
SoupURI* absoluteURI = soup_uri_new_with_base(baseURI, relativeURL.get());
soup_uri_free(baseURI);
if (!absoluteURI) {
WorkQueue::shared()->queue(new LoadItem(url, target));
return;
}
CString absoluteURIString = soupURIToStringPreservingPassword(absoluteURI);
JSRetainPtr<JSStringRef> absoluteURL(Adopt, JSStringCreateWithUTF8CString(absoluteURIString.data()));
WorkQueue::shared()->queue(new LoadItem(absoluteURL.get(), target));
soup_uri_free(absoluteURI);
}
/**
* soup_uri_new:
* @uri_string: a URI
*
* Parses an absolute URI.
*
* You can also pass %NULL for @uri_string if you want to get back an
* "empty" #SoupURI that you can fill in by hand. (You will need to
* call at least soup_uri_set_scheme() and soup_uri_set_path(), since
* those fields are required.)
*
* Return value: a #SoupURI, or %NULL.
**/
SoupURI *
soup_uri_new (const char *uri_string)
{
SoupURI *uri;
if (!uri_string)
return g_slice_new0 (SoupURI);
uri = soup_uri_new_with_base (NULL, uri_string);
if (!uri)
return NULL;
if (!uri->scheme) {
soup_uri_free (uri);
return NULL;
}
return uri;
}
/**
* soup_uri_new:
* @uri_string: (allow-none): a URI
*
* Parses an absolute URI.
*
* You can also pass %NULL for @uri_string if you want to get back an
* "empty" #SoupURI that you can fill in by hand. (You will need to
* call at least soup_uri_set_scheme() and soup_uri_set_path(), since
* those fields are required.)
*
* Return value: (nullable): a #SoupURI, or %NULL if the given string
* was found to be invalid.
**/
SoupURI *
soup_uri_new (const char *uri_string)
{
SoupURI *uri;
if (!uri_string)
return g_slice_new0 (SoupURI);
uri = soup_uri_new_with_base (NULL, uri_string);
if (!uri)
return NULL;
if (!SOUP_URI_IS_VALID (uri)) {
soup_uri_free (uri);
return NULL;
}
return uri;
}
static void
do_coding_empty_test (void)
{
SoupSession *session;
SoupMessage *msg;
SoupURI *uri;
SoupRequester *requester;
SoupRequest *req;
GByteArray *body;
debug_printf (1, "\nEmpty allegedly-encoded body test\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_CONTENT_DECODER,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER,
NULL);
requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER);
uri = soup_uri_new_with_base (base_uri, "/mbox");
debug_printf (1, " SoupMessage\n");
msg = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "empty");
soup_session_send_message (session, msg);
check_response (msg, "gzip", "text/plain", EXPECT_NOT_DECODED);
g_object_unref (msg);
debug_printf (1, " SoupRequest\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "empty");
g_object_unref (msg);
body = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_NOT_DECODED);
g_byte_array_free (body, TRUE);
g_object_unref (req);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
void LayoutTestController::queueLoad(JSStringRef url, JSStringRef target)
{
gchar* relativeURL = JSStringCopyUTF8CString(url);
SoupURI* baseURI = soup_uri_new(webkit_web_frame_get_uri(mainFrame));
SoupURI* absoluteURI = soup_uri_new_with_base(baseURI, relativeURL);
soup_uri_free(baseURI);
g_free(relativeURL);
gchar* absoluteCString;
if (absoluteURI) {
absoluteCString = soup_uri_to_string(absoluteURI, FALSE);
soup_uri_free(absoluteURI);
} else
absoluteCString = JSStringCopyUTF8CString(url);
JSRetainPtr<JSStringRef> absoluteURL(Adopt, JSStringCreateWithUTF8CString(absoluteCString));
g_free(absoluteCString);
WorkQueue::shared()->queue(new LoadItem(absoluteURL.get(), target));
}
SoupMessage *
dmap_connection_build_message (DMAPConnection * connection,
const char *path,
gboolean need_hash,
gdouble version,
gint req_id, gboolean send_close)
{
SoupMessage *message = NULL;
SoupURI *base_uri = NULL;
SoupURI *uri = NULL;
char *uri_str = NULL;
g_object_get (connection, "base-uri", &base_uri, NULL);
if (base_uri == NULL) {
return NULL;
}
uri = soup_uri_new_with_base (base_uri, path);
if (uri == NULL) {
return NULL;
}
message = soup_message_new_from_uri (SOUP_METHOD_GET, uri);
/* FIXME: only set Client-DAAP-Validation if need_hash? */
/* FIXME: only set Connection if send_close? */
uri_str = soup_uri_to_string (uri, FALSE);
message->request_headers =
dmap_connection_get_headers (connection, uri_str);
soup_message_headers_append (message->request_headers,
"User-Agent", DMAP_USER_AGENT);
soup_message_headers_append (message->request_headers,
"Connection", "close");
soup_uri_free (uri);
g_free (uri_str);
return message;
}
static void
do_cancel_while_reading_test_for_session (SoupSession *session)
{
SoupMessage *msg;
GThread *thread = NULL;
SoupURI *uri;
gboolean done = FALSE;
uri = soup_uri_new_with_base (base_uri, "/slow");
msg = soup_message_new_from_uri ("GET", uri);
soup_uri_free (uri);
g_object_set_data (G_OBJECT (msg), "session", session);
g_object_ref (msg);
g_object_ref (session);
if (SOUP_IS_SESSION_ASYNC (session))
g_timeout_add (100, cancel_message_timeout, msg);
else
thread = g_thread_new ("cancel_message_thread", cancel_message_thread, msg);
/* We intentionally don't use soup_session_send_message() here,
* because it holds an extra ref on the SoupMessageQueueItem
* relative to soup_session_queue_message().
*/
g_object_ref (msg);
soup_session_queue_message (session, msg, set_done, &done);
while (!done)
g_main_context_iteration (NULL, TRUE);
if (msg->status_code != SOUP_STATUS_CANCELLED) {
debug_printf (1, " FAILED: %d %s (expected Cancelled)\n",
msg->status_code, msg->reason_phrase);
errors++;
}
g_object_unref (msg);
if (thread)
g_thread_join (thread);
}
static void
do_cancel_while_reading_req_test_for_session (SoupSession *session)
{
SoupRequest *req;
SoupURI *uri;
GCancellable *cancellable;
GError *error = NULL;
uri = soup_uri_new_with_base (base_uri, "/slow");
req = soup_session_request_uri (session, uri, NULL);
soup_uri_free (uri);
cancellable = g_cancellable_new ();
if (SOUP_IS_SESSION_ASYNC (soup_request_get_session (req))) {
g_timeout_add (100, cancel_request_timeout, cancellable);
soup_test_request_send (req, cancellable, &error);
} else {
GThread *thread;
thread = g_thread_new ("cancel_request_thread", cancel_request_thread, g_object_ref (cancellable));
soup_test_request_send (req, cancellable, &error);
g_thread_unref (thread);
}
if (!error) {
debug_printf (1, " Request succeeded?\n");
errors++;
} else if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
debug_printf (1, " Unexpected error: %s\n",
error->message);
errors++;
}
g_clear_error (&error);
g_object_unref (req);
g_object_unref (cancellable);
}
/**
* soup_uri_new_with_base:
* @base: a base URI
* @uri_string: the URI
*
* Parses @uri_string relative to @base.
*
* Return value: a parsed #SoupURI.
**/
SoupURI *
soup_uri_new_with_base (SoupURI *base, const char *uri_string)
{
SoupURI *uri;
const char *end, *hash, *colon, *at, *path, *question;
const char *p, *hostend;
gboolean remove_dot_segments = TRUE;
int len;
/* First some cleanup steps (which are supposed to all be no-ops,
* but...). Skip initial whitespace, strip out internal tabs and
* line breaks, and ignore trailing whitespace.
*/
while (g_ascii_isspace (*uri_string))
uri_string++;
len = strcspn (uri_string, "\t\n\r");
if (uri_string[len]) {
char *clean = g_malloc (strlen (uri_string) + 1), *d;
const char *s;
for (s = uri_string, d = clean; *s; s++) {
if (*s != '\t' && *s != '\n' && *s != '\r')
*d++ = *s;
}
*d = '\0';
uri = soup_uri_new_with_base (base, clean);
g_free (clean);
return uri;
}
end = uri_string + len;
while (end > uri_string && g_ascii_isspace (end[-1]))
end--;
uri = g_slice_new0 (SoupURI);
/* Find fragment. */
hash = strchr (uri_string, '#');
if (hash) {
uri->fragment = uri_normalized_copy (hash + 1, end - hash + 1,
NULL);
end = hash;
}
/* Find scheme: initial [a-z+.-]* substring until ":" */
p = uri_string;
while (p < end && (g_ascii_isalnum (*p) ||
*p == '.' || *p == '+' || *p == '-'))
p++;
if (p > uri_string && *p == ':') {
uri->scheme = soup_uri_parse_scheme (uri_string, p - uri_string);
uri_string = p + 1;
}
if (uri_string == end && !base && !uri->fragment)
return uri;
/* Check for authority */
if (strncmp (uri_string, "//", 2) == 0) {
uri_string += 2;
path = uri_string + strcspn (uri_string, "/?#");
if (path > end)
path = end;
at = strchr (uri_string, '@');
if (at && at < path) {
colon = strchr (uri_string, ':');
if (colon && colon < at) {
uri->password = uri_decoded_copy (colon + 1,
at - colon - 1);
} else {
uri->password = NULL;
colon = at;
}
uri->user = uri_decoded_copy (uri_string,
colon - uri_string);
uri_string = at + 1;
} else
uri->user = uri->password = NULL;
/* Find host and port. */
if (*uri_string == '[') {
uri_string++;
hostend = strchr (uri_string, ']');
if (!hostend || hostend > path) {
soup_uri_free (uri);
return NULL;
}
if (*(hostend + 1) == ':')
colon = hostend + 1;
else
colon = NULL;
} else {
colon = memchr (uri_string, ':', path - uri_string);
hostend = colon ? colon : path;
}
uri->host = uri_decoded_copy (uri_string, hostend - uri_string);
if (colon && colon != path - 1) {
char *portend;
uri->port = strtoul (colon + 1, &portend, 10);
if (portend != (char *)path) {
soup_uri_free (uri);
return NULL;
}
}
uri_string = path;
}
/* Find query */
question = memchr (uri_string, '?', end - uri_string);
if (question) {
uri->query = uri_normalized_copy (question + 1,
end - (question + 1),
NULL);
end = question;
}
if (end != uri_string) {
uri->path = uri_normalized_copy (uri_string, end - uri_string,
NULL);
}
/* Apply base URI. This is spelled out in RFC 3986. */
if (base && !uri->scheme && uri->host)
uri->scheme = base->scheme;
else if (base && !uri->scheme) {
uri->scheme = base->scheme;
uri->user = g_strdup (base->user);
uri->password = g_strdup (base->password);
uri->host = g_strdup (base->host);
uri->port = base->port;
if (!uri->path) {
uri->path = g_strdup (base->path);
if (!uri->query)
uri->query = g_strdup (base->query);
remove_dot_segments = FALSE;
} else if (*uri->path != '/') {
char *newpath, *last;
last = strrchr (base->path, '/');
if (last) {
newpath = g_strdup_printf ("%.*s%s",
(int)(last + 1 - base->path),
base->path,
uri->path);
} else
newpath = g_strdup_printf ("/%s", uri->path);
g_free (uri->path);
uri->path = newpath;
}
}
if (remove_dot_segments && uri->path && *uri->path) {
char *p, *q;
/* Remove "./" where "." is a complete segment. */
for (p = uri->path + 1; *p; ) {
if (*(p - 1) == '/' &&
*p == '.' && *(p + 1) == '/')
memmove (p, p + 2, strlen (p + 2) + 1);
else
p++;
}
/* Remove "." at end. */
if (p > uri->path + 2 &&
*(p - 1) == '.' && *(p - 2) == '/')
*(p - 1) = '\0';
/* Remove "<segment>/../" where <segment> != ".." */
for (p = uri->path + 1; *p; ) {
if (!strncmp (p, "../", 3)) {
p += 3;
continue;
}
q = strchr (p + 1, '/');
if (!q)
break;
if (strncmp (q, "/../", 4) != 0) {
p = q + 1;
continue;
}
memmove (p, q + 4, strlen (q + 4) + 1);
p = uri->path + 1;
}
/* Remove "<segment>/.." at end where <segment> != ".." */
q = strrchr (uri->path, '/');
if (q && !strcmp (q, "/..")) {
p = q - 1;
while (p > uri->path && *p != '/')
p--;
if (strncmp (p, "/../", 4) != 0)
*(p + 1) = 0;
}
/* Remove extraneous initial "/.."s */
while (!strncmp (uri->path, "/../", 4))
memmove (uri->path, uri->path + 3, strlen (uri->path) - 2);
if (!strcmp (uri->path, "/.."))
uri->path[1] = '\0';
}
/* HTTP-specific stuff */
if (uri->scheme == SOUP_URI_SCHEME_HTTP ||
uri->scheme == SOUP_URI_SCHEME_HTTPS) {
if (!uri->path)
uri->path = g_strdup ("/");
if (!SOUP_URI_VALID_FOR_HTTP (uri)) {
soup_uri_free (uri);
return NULL;
}
}
if (uri->scheme == SOUP_URI_SCHEME_FTP) {
if (!uri->host) {
soup_uri_free (uri);
return NULL;
}
}
if (!uri->port)
uri->port = soup_scheme_default_port (uri->scheme);
if (!uri->path)
uri->path = g_strdup ("");
return uri;
}
static void
do_coding_req_test (void)
{
SoupSession *session;
SoupRequester *requester;
SoupRequest *req;
SoupMessage *msg;
SoupURI *uri;
GByteArray *plain, *cmp;
debug_printf (1, "\nSoupRequest tests\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
SOUP_SESSION_ADD_FEATURE_BY_TYPE, SOUP_TYPE_REQUESTER,
NULL);
requester = (SoupRequester *)soup_session_get_feature (session, SOUP_TYPE_REQUESTER);
uri = soup_uri_new_with_base (base_uri, "/mbox");
/* Plain text data, no claim */
debug_printf (1, " GET /mbox, plain\n");
req = soup_requester_request_uri (requester, uri, NULL);
plain = do_single_coding_req_test (req, NULL, "text/plain", EXPECT_NOT_DECODED);
g_object_unref (req);
/* Plain text data, claim gzip */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip\n");
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
req = soup_requester_request_uri (requester, uri, NULL);
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (req);
/* Plain text data, claim gzip w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, plus trailing junk\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "trailing-junk");
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed w/ junk");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim gzip with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, with server error\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "force-encode");
cmp = do_single_coding_req_test (req, "gzip", "text/plain", EXPECT_NOT_DECODED);
/* Failed content-decoding should have left the body untouched
* from what the server sent... which happens to be the
* uncompressed data.
*/
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "prefer-deflate-zlib");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, plus trailing junk\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "prefer-deflate-zlib, trailing-junk");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed w/ junk");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, with server error\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-zlib");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate (no zlib headers)*/
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data)\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "prefer-deflate-raw");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_DECODED);
check_req_bodies (plain, cmp, "plain", "compressed");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data), with server error\n");
req = soup_requester_request_uri (requester, uri, NULL);
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
soup_message_headers_append (msg->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-raw");
cmp = do_single_coding_req_test (req, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_req_bodies (plain, cmp, "plain", "mis-encoded");
g_byte_array_free (cmp, TRUE);
g_object_unref (msg);
g_object_unref (req);
g_byte_array_free (plain, TRUE);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
static void
do_coding_test (void)
{
SoupSession *session;
SoupMessage *msg, *msgz, *msgj, *msge, *msgzl, *msgzlj, *msgzle, *msgzlr, *msgzlre;
SoupURI *uri;
debug_printf (1, "SoupMessage tests\n");
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = soup_uri_new_with_base (base_uri, "/mbox");
/* Plain text data, no claim */
debug_printf (1, " GET /mbox, plain\n");
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
check_response (msg, NULL, "text/plain", EXPECT_NOT_DECODED);
/* Plain text data, claim gzip */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip\n");
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
msgz = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msgz);
check_response (msgz, "gzip", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgz, "plain", "compressed");
/* Plain text data, claim gzip w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, plus trailing junk\n");
msgj = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgj->request_headers,
"X-Test-Options", "trailing-junk");
soup_session_send_message (session, msgj);
check_response (msgj, "gzip", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgj, "plain", "compressed w/ junk");
/* Plain text data, claim gzip with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: gzip, with server error\n");
msge = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msge->request_headers,
"X-Test-Options", "force-encode");
soup_session_send_message (session, msge);
check_response (msge, "gzip", "text/plain", EXPECT_NOT_DECODED);
/* Failed content-decoding should have left the body untouched
* from what the server sent... which happens to be the
* uncompressed data.
*/
check_msg_bodies (msg, msge, "plain", "mis-encoded");
/* Plain text data, claim deflate */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate\n");
msgzl = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzl->request_headers,
"X-Test-Options", "prefer-deflate-zlib");
soup_session_send_message (session, msgzl);
check_response (msgzl, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzl, "plain", "compressed");
/* Plain text data, claim deflate w/ junk */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, plus trailing junk\n");
msgzlj = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlj->request_headers,
"X-Test-Options", "prefer-deflate-zlib, trailing-junk");
soup_session_send_message (session, msgzlj);
check_response (msgzlj, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzlj, "plain", "compressed w/ junk");
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate, with server error\n");
msgzle = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzle->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-zlib");
soup_session_send_message (session, msgzle);
check_response (msgzle, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_msg_bodies (msg, msgzle, "plain", "mis-encoded");
/* Plain text data, claim deflate (no zlib headers)*/
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data)\n");
msgzlr = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlr->request_headers,
"X-Test-Options", "prefer-deflate-raw");
soup_session_send_message (session, msgzlr);
check_response (msgzlr, "deflate", "text/plain", EXPECT_DECODED);
check_msg_bodies (msg, msgzlr, "plain", "compressed");
/* Plain text data, claim deflate with server error */
debug_printf (1, " GET /mbox, Accept-Encoding: deflate (raw data), with server error\n");
msgzlre = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgzlre->request_headers,
"X-Test-Options", "force-encode, prefer-deflate-raw");
soup_session_send_message (session, msgzlre);
check_response (msgzlre, "deflate", "text/plain", EXPECT_NOT_DECODED);
check_msg_bodies (msg, msgzlre, "plain", "mis-encoded");
g_object_unref (msg);
g_object_unref (msgzlre);
g_object_unref (msgzlr);
g_object_unref (msgzlj);
g_object_unref (msgzle);
g_object_unref (msgzl);
g_object_unref (msgz);
g_object_unref (msgj);
g_object_unref (msge);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
static void
do_timeout_req_test_for_session (SoupSession *session)
{
SoupRequester *requester;
SoupRequest *req;
SoupMessage *msg;
GInputStream *stream;
SoupSocket *sockets[4] = { NULL, NULL, NULL, NULL };
SoupURI *timeout_uri;
GError *error = NULL;
int i;
requester = soup_requester_new ();
soup_session_add_feature (session, SOUP_SESSION_FEATURE (requester));
g_object_unref (requester);
g_signal_connect (session, "request-started",
G_CALLBACK (request_started_socket_collector),
&sockets);
debug_printf (1, " First request\n");
timeout_uri = soup_uri_new_with_base (base_uri, "/timeout-persistent");
req = soup_requester_request_uri (requester, timeout_uri, NULL);
soup_uri_free (timeout_uri);
stream = soup_test_request_send (req, NULL, &error);
if (!stream) {
debug_printf (1, " Unexpected error on send: %s\n",
error->message);
errors++;
g_clear_error (&error);
} else {
soup_test_request_close_stream (req, stream, NULL, &error);
if (error) {
debug_printf (1, " Unexpected error on close: %s\n",
error->message);
errors++;
g_clear_error (&error);
}
g_object_unref (stream);
}
if (sockets[1]) {
debug_printf (1, " Message was retried??\n");
errors++;
sockets[1] = sockets[2] = sockets[3] = NULL;
}
g_object_unref (req);
debug_printf (1, " Second request\n");
req = soup_requester_request_uri (requester, base_uri, NULL);
stream = soup_test_request_send (req, NULL, &error);
if (!stream) {
debug_printf (1, " Unexpected error on send: %s\n",
error->message);
errors++;
g_clear_error (&error);
} else {
soup_test_request_close_stream (req, stream, NULL, &error);
if (error) {
debug_printf (1, " Unexpected error on close: %s\n",
error->message);
errors++;
g_clear_error (&error);
}
g_object_unref (stream);
}
msg = soup_request_http_get_message (SOUP_REQUEST_HTTP (req));
if (msg->status_code != SOUP_STATUS_OK) {
debug_printf (1, " Unexpected response: %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
if (sockets[1] != sockets[0]) {
debug_printf (1, " Message was not retried on existing connection\n");
errors++;
} else if (!sockets[2]) {
debug_printf (1, " Message was not retried after disconnect\n");
errors++;
} else if (sockets[2] == sockets[1]) {
debug_printf (1, " Message was retried on closed connection??\n");
errors++;
} else if (sockets[3]) {
debug_printf (1, " Message was retried again??\n");
errors++;
}
g_object_unref (msg);
g_object_unref (req);
for (i = 0; sockets[i]; i++)
g_object_unref (sockets[i]);
}
static void
do_batch_tests (gconstpointer data)
{
const SoupAuthTest *current_tests = data;
SoupSession *session;
SoupMessage *msg;
char *expected, *uristr;
SoupURI *base;
guint signal;
int i;
SOUP_TEST_SKIP_IF_NO_APACHE;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
base = soup_uri_new (base_uri);
for (i = 0; current_tests[i].url; i++) {
SoupURI *soup_uri = soup_uri_new_with_base (base, current_tests[i].url);
debug_printf (1, "Test %d: %s\n", i + 1, current_tests[i].explanation);
if (current_tests[i].url_auth) {
gchar *username = g_strdup_printf ("user%c", current_tests[i].provided[0]);
gchar *password = g_strdup_printf ("realm%c", current_tests[i].provided[0]);
soup_uri_set_user (soup_uri, username);
soup_uri_set_password (soup_uri, password);
g_free (username);
g_free (password);
}
msg = soup_message_new_from_uri (SOUP_METHOD_GET, soup_uri);
soup_uri_free (soup_uri);
if (!msg) {
g_printerr ("auth-test: Could not parse URI\n");
exit (1);
}
uristr = soup_uri_to_string (soup_message_get_uri (msg), FALSE);
debug_printf (1, " GET %s\n", uristr);
g_free (uristr);
expected = g_strdup (current_tests[i].expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_UNAUTHORIZED,
G_CALLBACK (handler), expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_OK,
G_CALLBACK (handler), expected);
signal = g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate),
(gpointer)¤t_tests[i]);
soup_session_send_message (session, msg);
g_signal_handler_disconnect (session, signal);
soup_test_assert_message_status (msg, current_tests[i].final_status);
soup_test_assert (!*expected,
"expected %d more round(s)\n",
(int)strlen (expected));
g_free (expected);
debug_printf (1, "\n");
g_object_unref (msg);
}
soup_uri_free (base);
soup_test_session_abort_unref (session);
}
static void
do_coding_test (void)
{
SoupSession *session;
SoupMessage *msg, *msgz, *msgj;
SoupURI *uri;
const char *coding;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
uri = soup_uri_new_with_base (base_uri, "/mbox");
debug_printf (1, "GET /mbox, plain\n");
msg = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msg);
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
debug_printf (1, " Unexpected status %d %s\n",
msg->status_code, msg->reason_phrase);
errors++;
}
coding = soup_message_headers_get_one (msg->response_headers, "Content-Encoding");
if (coding) {
debug_printf (1, " Unexpected Content-Encoding: %s\n",
coding);
errors++;
}
if (soup_message_get_flags (msg) & SOUP_MESSAGE_CONTENT_DECODED) {
debug_printf (1, " SOUP_MESSAGE_CONTENT_DECODED set!\n");
errors++;
}
debug_printf (1, "GET /mbox, Accept-Encoding: gzip\n");
soup_session_add_feature_by_type (session, SOUP_TYPE_CONTENT_DECODER);
msgz = soup_message_new_from_uri ("GET", uri);
soup_session_send_message (session, msgz);
if (!SOUP_STATUS_IS_SUCCESSFUL (msgz->status_code)) {
debug_printf (1, " Unexpected status %d %s\n",
msgz->status_code, msgz->reason_phrase);
errors++;
}
coding = soup_message_headers_get_one (msgz->response_headers, "Content-Encoding");
if (!coding || g_ascii_strcasecmp (coding, "gzip") != 0) {
debug_printf (1, " Unexpected Content-Encoding: %s\n",
coding ? coding : "(none)");
errors++;
}
if (!(soup_message_get_flags (msgz) & SOUP_MESSAGE_CONTENT_DECODED)) {
debug_printf (1, " SOUP_MESSAGE_CONTENT_DECODED not set!\n");
errors++;
}
if (msg->response_body->length != msgz->response_body->length) {
debug_printf (1, " Message length mismatch: %lu (plain) vs %lu (compressed)\n",
(gulong)msg->response_body->length,
(gulong)msgz->response_body->length);
errors++;
} else if (memcmp (msg->response_body->data,
msgz->response_body->data,
msg->response_body->length) != 0) {
debug_printf (1, " Message data mismatch (plain/compressed)\n");
errors++;
}
debug_printf (1, "GET /mbox, Accept-Encoding: gzip, plus trailing junk\n");
msgj = soup_message_new_from_uri ("GET", uri);
soup_message_headers_append (msgj->request_headers,
"X-Trailing-Junk", "junk!");
soup_session_send_message (session, msgj);
if (!SOUP_STATUS_IS_SUCCESSFUL (msgj->status_code)) {
debug_printf (1, " Unexpected status %d %s\n",
msgj->status_code, msgj->reason_phrase);
errors++;
}
coding = soup_message_headers_get_one (msgj->response_headers, "Content-Encoding");
if (!coding || g_ascii_strcasecmp (coding, "gzip") != 0) {
debug_printf (1, " Unexpected Content-Encoding: %s\n",
coding ? coding : "(none)");
errors++;
}
if (!(soup_message_get_flags (msgj) & SOUP_MESSAGE_CONTENT_DECODED)) {
debug_printf (1, " SOUP_MESSAGE_CONTENT_DECODED not set!\n");
errors++;
}
if (msg->response_body->length != msgj->response_body->length) {
debug_printf (1, " Message length mismatch: %lu (plain) vs %lu (compressed w/ junk)\n",
(gulong)msg->response_body->length,
(gulong)msgj->response_body->length);
errors++;
} else if (memcmp (msg->response_body->data,
msgj->response_body->data,
msg->response_body->length) != 0) {
debug_printf (1, " Message data mismatch (plain/compressed w/ junk)\n");
errors++;
}
g_object_unref (msg);
g_object_unref (msgz);
g_object_unref (msgj);
soup_uri_free (uri);
soup_test_session_abort_unref (session);
}
static void
redirect_handler (SoupMessage *msg, gpointer user_data)
{
SoupSession *session = user_data;
const char *new_loc;
SoupURI *new_uri;
new_loc = soup_message_headers_get_one (msg->response_headers,
"Location");
g_return_if_fail (new_loc != NULL);
if (msg->status_code == SOUP_STATUS_SEE_OTHER ||
(msg->status_code == SOUP_STATUS_FOUND &&
!SOUP_METHOD_IS_SAFE (msg->method))) {
/* Redirect using a GET */
g_object_set (msg,
SOUP_MESSAGE_METHOD, SOUP_METHOD_GET,
NULL);
soup_message_set_request (msg, NULL,
SOUP_MEMORY_STATIC, NULL, 0);
soup_message_headers_set_encoding (msg->request_headers,
SOUP_ENCODING_NONE);
} else if (msg->status_code == SOUP_STATUS_MOVED_PERMANENTLY ||
msg->status_code == SOUP_STATUS_TEMPORARY_REDIRECT ||
msg->status_code == SOUP_STATUS_FOUND) {
/* Don't redirect non-safe methods */
if (!SOUP_METHOD_IS_SAFE (msg->method))
return;
} else {
/* Three possibilities:
*
* 1) This was a non-3xx response that happened to
* have a "Location" header
* 2) It's a non-redirecty 3xx response (300, 304,
* 305, 306)
* 3) It's some newly-defined 3xx response (308+)
*
* We ignore all of these cases. In the first two,
* redirecting would be explicitly wrong, and in the
* last case, we have no clue if the 3xx response is
* supposed to be redirecty or non-redirecty. Plus,
* 2616 says unrecognized status codes should be
* treated as the equivalent to the x00 code, and we
* don't redirect on 300, so therefore we shouldn't
* redirect on 308+ either.
*/
return;
}
/* Location is supposed to be an absolute URI, but some sites
* are lame, so we use soup_uri_new_with_base().
*/
new_uri = soup_uri_new_with_base (soup_message_get_uri (msg), new_loc);
if (!new_uri) {
soup_message_set_status_full (msg,
SOUP_STATUS_MALFORMED,
"Invalid Redirect URL");
return;
}
soup_message_set_uri (msg, new_uri);
soup_uri_free (new_uri);
soup_session_requeue_message (session, msg);
}
static void
do_test (int n, SoupURI *base_uri, const char *path,
gboolean good_user, gboolean good_password,
gboolean offer_basic, gboolean offer_digest,
gboolean client_sends_basic, gboolean client_sends_digest,
gboolean server_requests_basic, gboolean server_requests_digest,
gboolean success)
{
SoupURI *uri;
char *uri_str;
GPtrArray *args;
GPid pid;
gboolean done;
debug_printf (1, "%2d. %s, %soffer Basic, %soffer Digest, %s user, %s password\n",
n, path, offer_basic ? "" : "don't ",
offer_digest ? "" : "don't ",
good_user ? "good" : "bad",
good_password ? "good" : "bad");
uri = soup_uri_new_with_base (base_uri, path);
uri_str = soup_uri_to_string (uri, FALSE);
soup_uri_free (uri);
args = g_ptr_array_new ();
g_ptr_array_add (args, "curl");
g_ptr_array_add (args, "-f");
g_ptr_array_add (args, "-s");
if (offer_basic || offer_digest) {
g_ptr_array_add (args, "-u");
if (good_user) {
if (good_password)
g_ptr_array_add (args, "user:password");
else
g_ptr_array_add (args, "user:badpassword");
} else {
if (good_password)
g_ptr_array_add (args, "baduser:password");
else
g_ptr_array_add (args, "baduser:badpassword");
}
if (offer_basic && offer_digest)
g_ptr_array_add (args, "--anyauth");
else if (offer_basic)
g_ptr_array_add (args, "--basic");
else
g_ptr_array_add (args, "--digest");
}
g_ptr_array_add (args, uri_str);
g_ptr_array_add (args, NULL);
memset (&test_data, 0, sizeof (test_data));
if (g_spawn_async (NULL, (char **)args->pdata, NULL,
G_SPAWN_SEARCH_PATH | G_SPAWN_STDOUT_TO_DEV_NULL | G_SPAWN_STDERR_TO_DEV_NULL | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, NULL, &pid, NULL)) {
done = FALSE;
g_child_watch_add (pid, curl_exited, &done);
while (!done)
g_main_context_iteration (NULL, TRUE);
} else
test_data.succeeded = FALSE;
g_ptr_array_free (args, TRUE);
g_free (uri_str);
if (server_requests_basic != test_data.server_requested_basic) {
errors++;
if (test_data.server_requested_basic)
debug_printf (1, " Server sent WWW-Authenticate: Basic, but shouldn't have!\n");
else
debug_printf (1, " Server didn't send WWW-Authenticate: Basic, but should have!\n");
}
if (server_requests_digest != test_data.server_requested_digest) {
errors++;
if (test_data.server_requested_digest)
debug_printf (1, " Server sent WWW-Authenticate: Digest, but shouldn't have!\n");
else
debug_printf (1, " Server didn't send WWW-Authenticate: Digest, but should have!\n");
}
if (client_sends_basic != test_data.client_sent_basic) {
errors++;
if (test_data.client_sent_basic)
debug_printf (1, " Client sent Authorization: Basic, but shouldn't have!\n");
else
debug_printf (1, " Client didn't send Authorization: Basic, but should have!\n");
}
if (client_sends_digest != test_data.client_sent_digest) {
errors++;
if (test_data.client_sent_digest)
debug_printf (1, " Client sent Authorization: Digest, but shouldn't have!\n");
else
debug_printf (1, " Client didn't send Authorization: Digest, but should have!\n");
}
if (success && !test_data.succeeded) {
errors++;
debug_printf (1, " Should have succeeded, but didn't!\n");
} else if (!success && test_data.succeeded) {
errors++;
debug_printf (1, " Should not have succeeded, but did!\n");
}
}
static gboolean
do_uri (SoupURI *base_uri, const char *base_str,
const char *in_uri, const char *out_uri,
const SoupURI *bits)
{
SoupURI *uri;
char *uri_string;
if (base_uri) {
debug_printf (1, "<%s> + <%s> = <%s>? ", base_str, in_uri,
out_uri ? out_uri : "ERR");
uri = soup_uri_new_with_base (base_uri, in_uri);
} else {
debug_printf (1, "<%s> => <%s>? ", in_uri,
out_uri ? out_uri : "ERR");
uri = soup_uri_new (in_uri);
}
if (!uri) {
if (out_uri) {
debug_printf (1, "ERR\n Could not parse %s\n", in_uri);
return FALSE;
} else {
debug_printf (1, "OK\n");
return TRUE;
}
}
if (bits != NULL) {
gboolean failed = FALSE;
if (!test_cmpstr (uri->scheme, bits->scheme))
failed = TRUE;
if (!test_cmpstr (uri->user, bits->user))
failed = TRUE;
if (!test_cmpstr (uri->password, bits->password))
failed = TRUE;
if (!test_cmpstr (uri->host, bits->host))
failed = TRUE;
if (uri->port != bits->port) {
debug_printf (1, "ERR\n port was %u, expected %u\n",
uri->port, bits->port);
failed = TRUE;
}
if (!test_cmpstr (uri->path, bits->path))
failed = TRUE;
if (!test_cmpstr (uri->query, bits->query))
failed = TRUE;
if (!test_cmpstr (uri->fragment, bits->fragment))
failed = TRUE;
if (failed)
return FALSE;
}
uri_string = soup_uri_to_string (uri, FALSE);
soup_uri_free (uri);
if (!out_uri) {
debug_printf (1, "ERR\n Got %s\n", uri_string);
return FALSE;
}
if (strcmp (uri_string, out_uri) != 0) {
debug_printf (1, "NO\n Unparses to <%s>\n", uri_string);
g_free (uri_string);
return FALSE;
}
g_free (uri_string);
debug_printf (1, "OK\n");
return TRUE;
}
static void
do_message (SoupSession *session, SoupURI *base_uri, const char *path,
gboolean get_ntlm_prompt, gboolean do_ntlm,
gboolean get_basic_prompt, gboolean do_basic,
guint status_code)
{
SoupURI *uri;
SoupMessage *msg;
NTLMState state = { FALSE, FALSE, FALSE, FALSE };
uri = soup_uri_new_with_base (base_uri, path);
msg = soup_message_new_from_uri ("GET", uri);
soup_uri_free (uri);
g_signal_connect (msg, "got_headers",
G_CALLBACK (prompt_check), &state);
g_signal_connect (msg, "got_headers",
G_CALLBACK (challenge_check), &state);
g_signal_connect (msg, "wrote-headers",
G_CALLBACK (request_check), &state);
g_signal_connect (msg, "wrote-headers",
G_CALLBACK (response_check), &state);
soup_session_send_message (session, msg);
debug_printf (1, " %-10s -> ", path);
if (state.got_ntlm_prompt) {
debug_printf (1, " NTLM_PROMPT");
if (!get_ntlm_prompt) {
debug_printf (1, "???");
errors++;
}
} else if (get_ntlm_prompt) {
debug_printf (1, " no-ntlm-prompt???");
errors++;
}
if (state.got_basic_prompt) {
debug_printf (1, " BASIC_PROMPT");
if (!get_basic_prompt) {
debug_printf (1, "???");
errors++;
}
} else if (get_basic_prompt) {
debug_printf (1, " no-basic-prompt???");
errors++;
}
if (state.sent_ntlm_request) {
debug_printf (1, " REQUEST");
if (!do_ntlm) {
debug_printf (1, "???");
errors++;
}
} else if (do_ntlm) {
debug_printf (1, " no-request???");
errors++;
}
if (state.got_ntlm_challenge) {
debug_printf (1, " CHALLENGE");
if (!do_ntlm) {
debug_printf (1, "???");
errors++;
}
} else if (do_ntlm) {
debug_printf (1, " no-challenge???");
errors++;
}
if (state.sent_ntlm_response) {
debug_printf (1, " NTLM_RESPONSE");
if (!do_ntlm) {
debug_printf (1, "???");
errors++;
}
} else if (do_ntlm) {
debug_printf (1, " no-ntlm-response???");
errors++;
}
if (state.sent_basic_response) {
debug_printf (1, " BASIC_RESPONSE");
if (!do_basic) {
debug_printf (1, "???");
errors++;
}
} else if (do_basic) {
debug_printf (1, " no-basic-response???");
errors++;
}
debug_printf (1, " -> %s", msg->reason_phrase);
if (msg->status_code != status_code) {
debug_printf (1, "???");
errors++;
}
debug_printf (1, "\n");
g_object_unref (msg);
}
SoupBuffer *
open_app_get_data_by_request (SoupSession *session, const gchar *request)
{
SoupMessage *msg;
SoupBuffer *buf;
const gchar *name;
const gchar *header;
const gchar *method;
g_return_val_if_fail (request != NULL, NULL);
// g_debug ("open_app_get_data_by_request: %s\n", request);
buf = NULL;
method = SOUP_METHOD_GET;
msg = soup_message_new (method, request);
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
soup_session_send_message (session, msg);
name = soup_message_get_uri (msg)->path;
if (SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code)) {
g_debug ("%s: %d %s\n", name, msg->status_code, msg->reason_phrase);
} else {
#ifdef SERVER_DEBUG
SoupMessageHeadersIter iter;
const gchar *hname, *value;
gchar *path = soup_uri_to_string (soup_message_get_uri (msg), TRUE);
g_debug ("%s %s HTTP/1.%d\n", method, path,
soup_message_get_http_version (msg));
g_free (path);
soup_message_headers_iter_init (&iter, msg->request_headers);
while (soup_message_headers_iter_next (&iter, &hname, &value))
g_debug ("%s: %s\r\n", hname, value);
g_debug ("\n");
g_debug ("HTTP/1.%d %d %s\n",
soup_message_get_http_version (msg),
msg->status_code, msg->reason_phrase);
soup_message_headers_iter_init (&iter, msg->response_headers);
while (soup_message_headers_iter_next (&iter, &hname, &value))
g_debug ("%s: %s\r\n", hname, value);
g_debug ("\n");
#endif
}
if (SOUP_STATUS_IS_REDIRECTION (msg->status_code)) {
header = soup_message_headers_get_one (msg->response_headers,
"Location");
if (header) {
SoupURI *request;
gchar *request_string;
g_debug (" -> %s\n", header);
request = soup_uri_new_with_base (soup_message_get_uri (msg), header);
request_string = soup_uri_to_string (request, FALSE);
buf = open_app_get_data_by_request (session, request_string);
g_free (request_string);
soup_uri_free (request);
}
} else if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
buf = soup_message_body_flatten (msg->response_body);
}
g_object_unref (msg);
return buf;
}
static void
do_soup_uri_null_tests (void)
{
SoupURI *uri, *uri2;
char *uri_string;
debug_printf (1, "\nsoup_uri_new (NULL)\n");
uri = soup_uri_new (NULL);
if (SOUP_URI_IS_VALID (uri) || SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: soup_uri_new(NULL) returns valid URI?\n");
errors++;
}
/* This implicitly also verifies that none of these methods g_warn */
if (soup_uri_get_scheme (uri) ||
soup_uri_get_user (uri) ||
soup_uri_get_password (uri) ||
soup_uri_get_host (uri) ||
soup_uri_get_port (uri) ||
soup_uri_get_path (uri) ||
soup_uri_get_query (uri) ||
soup_uri_get_fragment (uri)) {
debug_printf (1, " ERROR: soup_uri_new(NULL) returns non-empty URI?\n");
errors++;
}
expect_warning = TRUE;
uri2 = soup_uri_new_with_base (uri, "/path");
if (uri2 || expect_warning) {
debug_printf (1, " ERROR: soup_uri_new_with_base didn't fail on NULL URI?\n");
errors++;
expect_warning = FALSE;
}
expect_warning = TRUE;
uri_string = soup_uri_to_string (uri, FALSE);
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_to_string didn't fail on NULL URI?\n");
errors++;
expect_warning = FALSE;
} else if (*uri_string) {
debug_printf (1, " ERROR: soup_uri_to_string on NULL URI returned '%s'\n",
uri_string);
errors++;
}
g_free (uri_string);
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTP);
if (SOUP_URI_IS_VALID (uri) || SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: setting scheme on NULL URI makes it valid?\n");
errors++;
}
expect_warning = TRUE;
uri_string = soup_uri_to_string (uri, FALSE);
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_to_string didn't fail on scheme-only URI?\n");
errors++;
expect_warning = FALSE;
} else if (strcmp (uri_string, "http:") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string returned '%s' instead of 'http:'\n",
uri_string);
errors++;
}
g_free (uri_string);
soup_uri_set_host (uri, "localhost");
if (SOUP_URI_IS_VALID (uri)) {
debug_printf (1, " ERROR: setting scheme+host on NULL URI makes it valid?\n");
errors++;
}
if (SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: setting scheme+host on NULL URI makes it valid for http?\n");
errors++;
}
expect_warning = TRUE;
uri_string = soup_uri_to_string (uri, FALSE);
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_to_string didn't fail on scheme+host URI?\n");
errors++;
expect_warning = FALSE;
} else if (strcmp (uri_string, "http://localhost/") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string with NULL path returned '%s' instead of 'http://localhost/'\n",
uri_string);
errors++;
}
g_free (uri_string);
expect_warning = TRUE;
uri2 = soup_uri_new_with_base (uri, "/path");
if (expect_warning) {
debug_printf (1, " ERROR: soup_uri_new_with_base didn't warn on NULL+scheme URI?\n");
errors++;
expect_warning = FALSE;
} else if (!uri2) {
debug_printf (1, " ERROR: soup_uri_new_with_base didn't fix path on NULL+scheme URI\n");
errors++;
}
if (uri2) {
uri_string = soup_uri_to_string (uri2, FALSE);
if (!uri_string) {
debug_printf (1, " ERROR: soup_uri_to_string failed on uri2?\n");
errors++;
} else if (strcmp (uri_string, "http://localhost/path") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string returned '%s' instead of 'http://localhost/path'\n",
uri_string);
errors++;
}
g_free (uri_string);
soup_uri_free (uri2);
}
expect_warning = TRUE;
soup_uri_set_path (uri, NULL);
if (expect_warning) {
debug_printf (1, " ERROR: setting path to NULL doesn't warn\n");
errors++;
expect_warning = FALSE;
}
if (!uri->path || *uri->path) {
debug_printf (1, " ERROR: setting path to NULL != \"\"\n");
errors++;
soup_uri_set_path (uri, "");
}
uri_string = soup_uri_to_string (uri, FALSE);
if (!uri_string) {
debug_printf (1, " ERROR: soup_uri_to_string failed on complete URI?\n");
errors++;
} else if (strcmp (uri_string, "http://localhost/") != 0) {
debug_printf (1, " ERROR: soup_uri_to_string with empty path returned '%s' instead of 'http://localhost/'\n",
uri_string);
errors++;
}
g_free (uri_string);
if (!SOUP_URI_IS_VALID (uri)) {
debug_printf (1, " ERROR: setting scheme+path on NULL URI doesn't make it valid?\n");
errors++;
}
if (!SOUP_URI_VALID_FOR_HTTP (uri)) {
debug_printf (1, " ERROR: setting scheme+host+path on NULL URI doesn't make it valid for http?\n");
errors++;
}
soup_uri_free (uri);
}
static void
do_batch_tests (const gchar *base_uri_str, gint ntests)
{
SoupSession *session;
SoupMessage *msg;
char *expected;
SoupURI *base_uri;
int i;
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC, NULL);
g_signal_connect (session, "authenticate",
G_CALLBACK (authenticate), &i);
base_uri = soup_uri_new (base_uri_str);
for (i = 0; i < ntests; i++) {
SoupURI *soup_uri = soup_uri_new_with_base (base_uri, current_tests[i].url);
debug_printf (1, "Test %d: %s\n", i + 1, current_tests[i].explanation);
if (current_tests[i].url_auth) {
gchar *username = g_strdup_printf ("user%c", current_tests[i].provided[0]);
gchar *password = g_strdup_printf ("realm%c", current_tests[i].provided[0]);
soup_uri_set_user (soup_uri, username);
soup_uri_set_password (soup_uri, password);
g_free (username);
g_free (password);
}
msg = soup_message_new_from_uri (SOUP_METHOD_GET, soup_uri);
soup_uri_free (soup_uri);
if (!msg) {
fprintf (stderr, "auth-test: Could not parse URI\n");
exit (1);
}
debug_printf (1, " GET %s\n", soup_uri_to_string (soup_message_get_uri (msg), FALSE));
expected = g_strdup (current_tests[i].expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_UNAUTHORIZED,
G_CALLBACK (handler), expected);
soup_message_add_status_code_handler (
msg, "got_headers", SOUP_STATUS_OK,
G_CALLBACK (handler), expected);
soup_session_send_message (session, msg);
if (msg->status_code != SOUP_STATUS_UNAUTHORIZED &&
msg->status_code != SOUP_STATUS_OK) {
debug_printf (1, " %d %s !\n", msg->status_code,
msg->reason_phrase);
errors++;
}
if (*expected) {
debug_printf (1, " expected %d more round(s)\n",
(int)strlen (expected));
errors++;
}
g_free (expected);
if (msg->status_code != current_tests[i].final_status) {
debug_printf (1, " expected %d\n",
current_tests[i].final_status);
}
debug_printf (1, "\n");
g_object_unref (msg);
}
soup_uri_free (base_uri);
soup_test_session_abort_unref (session);
}
/**
* gupnp_device_info_get_icon_url:
* @info: A #GUPnPDeviceInfo
* @requested_mime_type: (allow-none) (transfer none): The requested file
* format, or %NULL for any
* @requested_depth: The requested color depth, or -1 for any
* @requested_width: The requested width, or -1 for any
* @requested_height: The requested height, or -1 for any
* @prefer_bigger: %TRUE if a bigger, rather than a smaller icon should be
* returned if no exact match could be found
* @mime_type: (out) (allow-none): The location where to store the the format
* of the returned icon, or %NULL. The returned string should be freed after
* use
* @depth: (out) (allow-none) : The location where to store the depth of the
* returned icon, or %NULL
* @width: (out) (allow-none) : The location where to store the width of the
* returned icon, or %NULL
* @height: (out) (allow-none) : The location where to store the height of the
* returned icon, or %NULL
*
* Get a URL pointing to the icon most closely matching the
* given criteria, or %NULL. If @requested_mime_type is set, only icons with
* this mime type will be returned. If @requested_depth is set, only icons with
* this or lower depth will be returned. If @requested_width and/or
* @requested_height are set, only icons that are this size or smaller are
* returned, unless @prefer_bigger is set, in which case the next biggest icon
* will be returned. The returned strings should be freed.
*
* Return value: (transfer full): a string, or %NULL. g_free() after use.
**/
char *
gupnp_device_info_get_icon_url (GUPnPDeviceInfo *info,
const char *requested_mime_type,
int requested_depth,
int requested_width,
int requested_height,
gboolean prefer_bigger,
char **mime_type,
int *depth,
int *width,
int *height)
{
GList *icons, *l;
xmlNode *element;
Icon *icon, *closest;
char *ret;
g_return_val_if_fail (GUPNP_IS_DEVICE_INFO (info), NULL);
/* List available icons */
icons = NULL;
element = xml_util_get_element (info->priv->element,
"iconList",
NULL);
if (!element)
return NULL;
for (element = element->children; element; element = element->next) {
if (!strcmp ("icon", (char *) element->name)) {
gboolean mime_type_ok;
icon = icon_parse (info, element);
if (requested_mime_type) {
mime_type_ok =
!strcmp (requested_mime_type,
(char *) icon->mime_type);
} else
mime_type_ok = TRUE;
if (requested_depth >= 0)
icon->weight = requested_depth - icon->depth;
/* Filter out icons with incorrect mime type or
* incorrect depth. */
if (mime_type_ok && icon->weight >= 0) {
if (requested_width >= 0) {
if (prefer_bigger) {
icon->weight +=
icon->width -
requested_width;
} else {
icon->weight +=
requested_width -
icon->width;
}
}
if (requested_height >= 0) {
if (prefer_bigger) {
icon->weight +=
icon->height -
requested_height;
} else {
icon->weight +=
requested_height -
icon->height;
}
}
icons = g_list_prepend (icons, icon);
} else
icon_free (icon);
}
}
if (icons == NULL)
return NULL;
/* Find closest match */
closest = NULL;
for (l = icons; l; l = l->next) {
icon = l->data;
/* Look between icons with positive weight first */
if (icon->weight >= 0) {
if (!closest || icon->weight < closest->weight)
closest = icon;
}
}
if (!closest) {
for (l = icons; l; l = l->next) {
icon = l->data;
/* No icons with positive weight, look at ones with
* negative weight */
if (!closest || icon->weight > closest->weight)
closest = icon;
}
}
/* Fill in return values */
if (closest) {
icon = closest;
if (mime_type) {
if (icon->mime_type) {
*mime_type = g_strdup
((char *) icon->mime_type);
} else
*mime_type = NULL;
}
if (depth)
*depth = icon->depth;
if (width)
*width = icon->width;
if (height)
*height = icon->height;
if (icon->url) {
SoupURI *uri;
uri = soup_uri_new_with_base (info->priv->url_base,
(const char *) icon->url);
ret = soup_uri_to_string (uri, FALSE);
soup_uri_free (uri);
} else
ret = NULL;
} else {
if (mime_type)
*mime_type = NULL;
if (depth)
*depth = -1;
if (width)
*width = -1;
if (height)
*height = -1;
ret = NULL;
}
/* Cleanup */
while (icons) {
icon_free (icons->data);
icons = g_list_delete_link (icons, icons);
}
return ret;
}
static void
get_url (const char *url)
{
const char *name;
SoupMessage *msg;
const char *header;
FILE *output_file = NULL;
msg = soup_message_new (head ? "HEAD" : "GET", url);
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
if (loop) {
g_object_ref (msg);
soup_session_queue_message (session, msg, finished, loop);
g_main_loop_run (loop);
} else
soup_session_send_message (session, msg);
name = soup_message_get_uri (msg)->path;
if (!debug) {
if (msg->status_code == SOUP_STATUS_SSL_FAILED) {
GTlsCertificateFlags flags;
if (soup_message_get_https_status (msg, NULL, &flags))
g_print ("%s: %d %s (0x%x)\n", name, msg->status_code, msg->reason_phrase, flags);
else
g_print ("%s: %d %s (no handshake status)\n", name, msg->status_code, msg->reason_phrase);
} else if (!quiet || SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code))
g_print ("%s: %d %s\n", name, msg->status_code, msg->reason_phrase);
}
if (SOUP_STATUS_IS_REDIRECTION (msg->status_code)) {
header = soup_message_headers_get_one (msg->response_headers,
"Location");
if (header) {
SoupURI *uri;
char *uri_string;
if (!debug && !quiet)
g_print (" -> %s\n", header);
uri = soup_uri_new_with_base (soup_message_get_uri (msg), header);
uri_string = soup_uri_to_string (uri, FALSE);
get_url (uri_string);
g_free (uri_string);
soup_uri_free (uri);
}
} else if (!head && SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
if (output_file_path) {
output_file = fopen (output_file_path, "w");
if (!output_file)
g_printerr ("Error trying to create file %s.\n", output_file_path);
} else if (!quiet)
output_file = stdout;
if (output_file) {
fwrite (msg->response_body->data,
1,
msg->response_body->length,
output_file);
if (output_file_path)
fclose (output_file);
}
}
}
static char *
do_request (SoupSession *session,
SoupURI *base_uri,
const char *method,
const char *path,
...)
{
SoupRequestHTTP *req;
SoupMessage *msg;
GInputStream *stream;
SoupURI *uri;
va_list ap;
const char *header, *value;
char buf[256];
gsize nread;
GError *error = NULL;
last_request_validated = last_request_hit_network = FALSE;
uri = soup_uri_new_with_base (base_uri, path);
req = soup_session_request_http_uri (session, method, uri, NULL);
soup_uri_free (uri);
msg = soup_request_http_get_message (req);
va_start (ap, path);
while ((header = va_arg (ap, const char *))) {
value = va_arg (ap, const char *);
soup_message_headers_append (msg->request_headers,
header, value);
}
g_object_unref (msg);
stream = soup_test_request_send (SOUP_REQUEST (req), NULL, &error);
if (!stream) {
debug_printf (1, " could not send request: %s\n",
error->message);
g_error_free (error);
g_object_unref (req);
return NULL;
}
last_request_hit_network = is_network_stream (stream);
g_input_stream_read_all (stream, buf, sizeof (buf), &nread,
NULL, &error);
if (error) {
debug_printf (1, " could not read response: %s\n",
error->message);
g_clear_error (&error);
}
soup_test_request_close_stream (SOUP_REQUEST (req), stream,
NULL, &error);
if (error) {
debug_printf (1, " could not close stream: %s\n",
error->message);
g_clear_error (&error);
}
g_object_unref (stream);
g_object_unref (req);
/* Cache writes are G_PRIORITY_LOW, so they won't have happened yet... */
soup_cache_flush ((SoupCache *)soup_session_get_feature (session, SOUP_TYPE_CACHE));
return nread ? g_memdup (buf, nread) : g_strdup ("");
}
