static void check_response (SoupMessage *msg, const char *expected_encoding, const char *expected_content_type, MessageContentStatus status) { const char *coding, *type; 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 (expected_encoding) { if (!coding || g_ascii_strcasecmp (coding, expected_encoding) != 0) { debug_printf (1, " Unexpected Content-Encoding: %s\n", coding ? coding : "(none)"); errors++; } } else { if (coding) { debug_printf (1, " Unexpected Content-Encoding: %s\n", coding); errors++; } } if (status != NO_CHECK) { if (status == EXPECT_DECODED) { if (!(soup_message_get_flags (msg) & SOUP_MESSAGE_CONTENT_DECODED)) { debug_printf (1, " SOUP_MESSAGE_CONTENT_DECODED not set!\n"); errors++; } } else { if (soup_message_get_flags (msg) & SOUP_MESSAGE_CONTENT_DECODED) { debug_printf (1, " SOUP_MESSAGE_CONTENT_DECODED set!\n"); errors++; } } } type = soup_message_headers_get_one (msg->response_headers, "Content-Type"); if (!type || g_ascii_strcasecmp (type, expected_content_type) != 0) { debug_printf (1, " Unexpected Content-Type: %s\n", type ? type : "(none)"); errors++; } }
void ResourceRequest::updateFromSoupMessage(SoupMessage* soupMessage) { bool shouldPortBeResetToZero = m_url.hasPort() && !m_url.port(); m_url = soupURIToKURL(soup_message_get_uri(soupMessage)); // SoupURI cannot differeniate between an explicitly specified port 0 and // no port specified. if (shouldPortBeResetToZero) m_url.setPort(0); m_httpMethod = String::fromUTF8(soupMessage->method); updateFromSoupMessageHeaders(soupMessage->request_headers); if (soupMessage->request_body->data) m_httpBody = FormData::create(soupMessage->request_body->data, soupMessage->request_body->length); SoupURI* firstParty = soup_message_get_first_party(soupMessage); if (firstParty) m_firstPartyForCookies = soupURIToKURL(firstParty); m_soupFlags = soup_message_get_flags(soupMessage); // FIXME: m_allowCookies should probably be handled here and on // doUpdatePlatformRequest somehow. }
void ResourceResponse::updateFromSoupMessage(SoupMessage* soupMessage) { SoupURI* soupURI = soup_message_get_uri(soupMessage); GOwnPtr<gchar> uri(soup_uri_to_string(soupURI, FALSE)); m_url = KURL(KURL(), String::fromUTF8(uri.get())); m_httpStatusCode = soupMessage->status_code; SoupMessageHeadersIter headersIter; const char* headerName; const char* headerValue; soup_message_headers_iter_init(&headersIter, soupMessage->response_headers); while (soup_message_headers_iter_next(&headersIter, &headerName, &headerValue)) m_httpHeaderFields.set(String::fromUTF8(headerName), String::fromUTF8(headerValue)); m_soupFlags = soup_message_get_flags(soupMessage); String contentType = soup_message_headers_get_one(soupMessage->response_headers, "Content-Type"); setMimeType(extractMIMETypeFromMediaType(contentType)); setTextEncodingName(extractCharsetFromMediaType(contentType)); setExpectedContentLength(soup_message_headers_get_content_length(soupMessage->response_headers)); setHTTPStatusText(soupMessage->reason_phrase); setSuggestedFilename(filenameFromHTTPContentDisposition(httpHeaderField("Content-Disposition"))); }
void ResourceRequest::updateFromSoupMessage(SoupMessage* soupMessage) { SoupURI* soupURI = soup_message_get_uri(soupMessage); GOwnPtr<gchar> uri(soup_uri_to_string(soupURI, FALSE)); m_url = KURL(KURL(), String::fromUTF8(uri.get())); m_httpMethod = String::fromUTF8(soupMessage->method); SoupMessageHeadersIter headersIter; const char* headerName; const char* headerValue; soup_message_headers_iter_init(&headersIter, soupMessage->request_headers); while (soup_message_headers_iter_next(&headersIter, &headerName, &headerValue)) m_httpHeaderFields.set(String::fromUTF8(headerName), String::fromUTF8(headerValue)); if (soupMessage->request_body->data) m_httpBody = FormData::create(soupMessage->request_body->data, soupMessage->request_body->length); #ifdef HAVE_LIBSOUP_2_29_90 SoupURI* firstParty = soup_message_get_first_party(soupMessage); if (firstParty) { GOwnPtr<gchar> firstPartyURI(soup_uri_to_string(firstParty, FALSE)); m_firstPartyForCookies = KURL(KURL(), String::fromUTF8(firstPartyURI.get())); } #endif m_soupFlags = soup_message_get_flags(soupMessage); // FIXME: m_allowCookies should probably be handled here and on // doUpdatePlatformRequest somehow. }
void cb_wv_notify_load_status(WebKitWebView *view, GParamSpec *pspec, Browser *b) { WebKitWebFrame *frame; WebKitWebDataSource *source; WebKitNetworkRequest *request; SoupMessage *message; char *uri; switch (webkit_web_view_get_load_status(b->UI.view)) { case WEBKIT_LOAD_COMMITTED: uri = browser_get_uri(b); if (strstr(uri, "https://") == uri) { /* get ssl state */ frame = webkit_web_view_get_main_frame(b->UI.view); source = webkit_web_frame_get_data_source(frame); request = webkit_web_data_source_get_request(source); message = webkit_network_request_get_message(request); b->State.ssl = soup_message_get_flags(message) ^ SOUP_MESSAGE_CERTIFICATE_TRUSTED; } break; case WEBKIT_LOAD_FINISHED: /* add uri to history */ if (!private_browsing && (uri = (char *)webkit_web_view_get_uri(b->UI.view))) { history_add(uri); } b->State.progress = 100; break; default: break; } /* update browser (statusbar, progress, position) */ browser_update(b); }
static void do_digest_nonce_test (SoupSession *session, const char *nth, const char *uri, gboolean use_auth_cache, gboolean expect_401, gboolean expect_signal) { SoupMessage *msg; gboolean got_401; msg = soup_message_new (SOUP_METHOD_GET, uri); if (!use_auth_cache) { SoupMessageFlags flags = soup_message_get_flags (msg); soup_message_set_flags (msg, flags | SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE); } if (expect_signal) { g_signal_connect (session, "authenticate", G_CALLBACK (digest_nonce_authenticate), NULL); } soup_message_add_status_code_handler (msg, "got_headers", SOUP_STATUS_UNAUTHORIZED, G_CALLBACK (digest_nonce_unauthorized), &got_401); got_401 = FALSE; soup_session_send_message (session, msg); soup_test_assert (got_401 == expect_401, "%s request %s a 401 Unauthorized!\n", nth, got_401 ? "got" : "did not get"); soup_test_assert_message_status (msg, SOUP_STATUS_OK); g_object_unref (msg); }
/* ghtml_get_security */ SurferSecurity ghtml_get_security(GtkWidget * widget) { SurferSecurity security = SS_NONE; #if WEBKIT_CHECK_VERSION(1, 1, 0) GHtml * ghtml; WebKitWebFrame * frame; char const * location; WebKitWebDataSource *source; WebKitNetworkRequest *request; SoupMessage * message; #endif #if WEBKIT_CHECK_VERSION(1, 1, 0) ghtml = g_object_get_data(G_OBJECT(widget), "ghtml"); frame = webkit_web_view_get_main_frame(WEBKIT_WEB_VIEW(ghtml->view)); if((location = webkit_web_frame_get_uri(frame)) != NULL && strncmp(location, "https://", 8) == 0) { security = SS_UNTRUSTED; source = webkit_web_frame_get_data_source(frame); request = webkit_web_data_source_get_request(source); message = webkit_network_request_get_message(request); if(ghtml->ssl == TRUE && message != NULL && soup_message_get_flags(message) & SOUP_MESSAGE_CERTIFICATE_TRUSTED) security = SS_TRUSTED; } #endif return security; }
void ResourceRequest::updateFromSoupMessage(SoupMessage* soupMessage) { m_url = soupURIToKURL(soup_message_get_uri(soupMessage)); m_httpMethod = String::fromUTF8(soupMessage->method); m_httpHeaderFields.clear(); SoupMessageHeadersIter headersIter; const char* headerName; const char* headerValue; soup_message_headers_iter_init(&headersIter, soupMessage->request_headers); while (soup_message_headers_iter_next(&headersIter, &headerName, &headerValue)) { m_httpHeaderFields.set(String::fromUTF8(headerName), String::fromUTF8(headerValue)); } if (soupMessage->request_body->data) m_httpBody = FormData::create(soupMessage->request_body->data, soupMessage->request_body->length); SoupURI* firstParty = soup_message_get_first_party(soupMessage); if (firstParty) m_firstPartyForCookies = soupURIToKURL(firstParty); m_soupFlags = soup_message_get_flags(soupMessage); // FIXME: m_allowCookies should probably be handled here and on // doUpdatePlatformRequest somehow. }
static void do_message_has_authorization_header_test (void) { SoupSession *session; SoupMessage *msg; SoupAuthManager *manager; SoupAuth *auth = NULL; char *token; guint auth_id; char *uri; g_test_bug ("775882"); SOUP_TEST_SKIP_IF_NO_APACHE; session = soup_test_session_new (SOUP_TYPE_SESSION, NULL); uri = g_strconcat (base_uri, "Digest/realm1/", NULL); msg = soup_message_new ("GET", uri); auth_id = g_signal_connect (session, "authenticate", G_CALLBACK (has_authorization_header_authenticate), &auth); soup_session_send_message (session, msg); soup_test_assert_message_status (msg, SOUP_STATUS_OK); soup_test_assert (SOUP_IS_AUTH (auth), "Expected a SoupAuth"); token = soup_auth_get_authorization (auth, msg); g_object_unref (auth); g_object_unref (msg); g_signal_handler_disconnect (session, auth_id); manager = SOUP_AUTH_MANAGER (soup_session_get_feature (session, SOUP_TYPE_AUTH_MANAGER)); soup_auth_manager_clear_cached_credentials (manager); msg = soup_message_new ("GET", uri); soup_message_headers_replace (msg->request_headers, "Authorization", token); auth_id = g_signal_connect (session, "authenticate", G_CALLBACK (has_authorization_header_authenticate_assert), NULL); soup_session_send_message (session, msg); soup_test_assert_message_status (msg, SOUP_STATUS_OK); g_object_unref (msg); /* Check that we can also provide our own Authorization header when not using credentials cache. */ soup_auth_manager_clear_cached_credentials (manager); msg = soup_message_new ("GET", uri); soup_message_headers_replace (msg->request_headers, "Authorization", token); soup_message_set_flags (msg, soup_message_get_flags (msg) | SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE); soup_session_send_message (session, msg); soup_test_assert_message_status (msg, SOUP_STATUS_OK); g_object_unref (msg); g_free (token); g_signal_handler_disconnect (session, auth_id); g_free (uri); soup_test_session_abort_unref (session); }
void ResourceResponse::updateFromSoupMessage(SoupMessage* soupMessage) { m_url = soupURIToKURL(soup_message_get_uri(soupMessage)); m_httpStatusCode = soupMessage->status_code; setHTTPStatusText(soupMessage->reason_phrase); m_soupFlags = soup_message_get_flags(soupMessage); GTlsCertificate* certificate = 0; soup_message_get_https_status(soupMessage, &certificate, &m_tlsErrors); m_certificate = certificate; updateFromSoupMessageHeaders(soupMessage->response_headers); }
static void process_hsts_header(SoupMessage *msg, gpointer data) { HSTSProvider *provider = (HSTSProvider*)data; SoupURI *uri = soup_message_get_uri(msg); SoupMessageHeaders *hdrs; const char *header; if (!g_hostname_is_ip_address(uri->host) && (soup_message_get_flags(msg) & SOUP_MESSAGE_CERTIFICATE_TRUSTED) ){ g_object_get(G_OBJECT(msg), SOUP_MESSAGE_RESPONSE_HEADERS, &hdrs, NULL); /* TODO according to RFC 6797 8.1 we must only use the first header */ header = soup_message_headers_get_one(hdrs, HSTS_HEADER_NAME); if (header) { parse_hsts_header(provider, uri->host, header); } } }
static void auth_got_body (SoupMessage *msg, gpointer manager) { SoupAuthManagerPrivate *priv = SOUP_AUTH_MANAGER (manager)->priv; SoupAuth *auth; g_mutex_lock (&priv->lock); auth = lookup_auth (priv, msg); if (auth && soup_auth_is_ready (auth, msg)) { if (SOUP_IS_CONNECTION_AUTH (auth)) { SoupMessageFlags flags; flags = soup_message_get_flags (msg); soup_message_set_flags (msg, flags & ~SOUP_MESSAGE_NEW_CONNECTION); } soup_session_requeue_message (priv->session, msg); } g_mutex_unlock (&priv->lock); }
static void do_ssl_test_for_session (SoupSession *session, SoupURI *uri) { SoupMessage *msg; GTlsCertificate *cert = NULL; GTlsCertificateFlags flags; gboolean is_https; msg = soup_message_new_from_uri ("GET", uri); soup_session_send_message (session, msg); soup_test_assert_message_status (msg, SOUP_STATUS_SSL_FAILED); is_https = soup_message_get_https_status (msg, &cert, &flags); soup_test_assert (!is_https, "get_http_status() returned TRUE? (flags %x)", flags); g_assert_null (cert); g_assert_false (soup_message_get_flags (msg) & SOUP_MESSAGE_CERTIFICATE_TRUSTED); g_object_unref (msg); }
static void queue_message (SoupSession *session, SoupMessage *msg, SoupSessionCallback callback, gpointer user_data) { SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session); SoupMessageQueueItem *item; item = soup_message_queue_append (priv->queue, msg, callback, user_data); soup_message_set_io_status (msg, SOUP_MESSAGE_IO_STATUS_QUEUED); g_signal_connect_after (msg, "finished", G_CALLBACK (message_finished), item); if (!(soup_message_get_flags (msg) & SOUP_MESSAGE_NO_REDIRECT)) { soup_message_add_header_handler ( msg, "got_body", "Location", G_CALLBACK (redirect_handler), session); } g_signal_emit (session, signals[REQUEST_QUEUED], 0, msg); }
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); }