static void got_headers (SoupMessage *msg, int *headers_count) { SoupMessageHeadersIter iter; gboolean is_next; const char* name, *value; *headers_count = *headers_count + 1; soup_message_headers_iter_init (&iter, msg->response_headers); is_next = soup_message_headers_iter_next (&iter, &name, &value); check_is_next (is_next); if (g_str_equal (name, "Date")) { is_next = soup_message_headers_iter_next (&iter, &name, &value); check_is_next (is_next); } if (!g_str_equal (name, "Content-Type")) { debug_printf (1, " expected `Content-Type' got %s\n", name); errors++; } if (!g_str_equal (value, "multipart/x-mixed-replace; boundary=cut-here")) { debug_printf (1, " expected `multipart/x-mixed-replace; boundary=cut-here' got %s\n", value); 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); 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 server_callback (SoupServer *server, SoupMessage *msg, const char *path, GHashTable *query, SoupClientContext *context, gpointer data) { char *file_path; SoupMessageHeadersIter iter; const char *name, *value; g_print ("%s %s HTTP/1.%d\n", msg->method, path, soup_message_get_http_version (msg)); soup_message_headers_iter_init (&iter, msg->request_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) g_print ("%s: %s\n", name, value); if (msg->request_body->length) g_print ("%s\n", msg->request_body->data); file_path = g_strdup_printf (".%s", path); if (msg->method == SOUP_METHOD_GET || msg->method == SOUP_METHOD_HEAD) do_get (server, msg, file_path); else if (msg->method == SOUP_METHOD_PUT) do_put (server, msg, file_path); else soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED); g_free (file_path); g_print (" -> %d %s\n\n", msg->status_code, msg->reason_phrase); }
static void server_callback (SoupServer *server, SoupMessage *msg, const char *path, GHashTable *query, SoupClientContext *context, gpointer data) { UiConnection *self = (UiConnection *)data; imgflo_debug("%s %s HTTP/1.%d\n", msg->method, path, soup_message_get_http_version(msg)); ensure_hostname_set(self, soup_message_get_uri(msg)); if (msg->method == SOUP_METHOD_GET && g_strcmp0(path, "/process") == 0) { process_image_callback(server, msg, path, query, context, self); } else if (msg_is_upgrade(msg)) { // fall-through, let libsoup WebSocket handle this } else if (msg->method == SOUP_METHOD_GET && g_strcmp0(path, "/") == 0) { serve_frontpage(server, msg, path, query, context, self); } else { imgflo_warning("Unknown HTTP request: %s, %s", msg->method, path); SoupMessageHeadersIter iter; const char *name, *value; soup_message_headers_iter_init(&iter, msg->request_headers); while (soup_message_headers_iter_next(&iter, &name, &value)) imgflo_debug("%s: %s\n", name, value); if (msg->request_body->length) imgflo_debug("%s\n", msg->request_body->data); soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED); } }
static JSValueRef get_message_data(SoupMessage *msg) { const char *name, *value; SoupMessageHeadersIter iter; JSObjectRef o = NULL, ho; JSValueRef ret; JSStringRef s; JSContextRef ctx = scripts_get_global_context(); if (ctx == NULL) { return NIL; } o = JSObjectMake(ctx, NULL, NULL); js_set_object_property(ctx, o, "body", msg->response_body->data, NULL); ho = JSObjectMake(ctx, NULL, NULL); soup_message_headers_iter_init(&iter, msg->response_headers); while (soup_message_headers_iter_next(&iter, &name, &value)) js_set_object_property(ctx, ho, name, value, NULL); s = JSStringCreateWithUTF8CString("headers"); JSObjectSetProperty(ctx, o, s, ho, kJSDefaultProperty, NULL); JSStringRelease(s); ret = o; scripts_release_global_context(); return ret; }
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 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) { 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 server_callback (SoupServer *server, SoupMessage *msg, const char *path, GHashTable *query, SoupClientContext *context, gpointer data) { SoupMessageHeadersIter iter; const char *name, *value; g_print("%s %s HTTP/1.%d\n", msg->method, path, soup_message_get_http_version(msg)); if (g_strcmp0(path, "/process") == 0 && msg->method == SOUP_METHOD_GET) { process_image_callback(server, msg, path, query, context, data); } else { soup_message_headers_iter_init(&iter, msg->request_headers); while (soup_message_headers_iter_next(&iter, &name, &value)) g_print("%s: %s\n", name, value); if (msg->request_body->length) g_print("%s\n", msg->request_body->data); g_print(" -> %d %s\n\n", msg->status_code, msg->reason_phrase); soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED); } }
void ResourceRequest::updateFromSoupMessageHeaders(SoupMessageHeaders* soupHeaders) { m_httpHeaderFields.clear(); SoupMessageHeadersIter headersIter; soup_message_headers_iter_init(&headersIter, soupHeaders); const char* headerName; const char* headerValue; while (soup_message_headers_iter_next(&headersIter, &headerName, &headerValue)) m_httpHeaderFields.set(String::fromUTF8(headerName), String::fromUTF8(headerValue)); }
static gboolean msg_is_upgrade(SoupMessage *msg) { const char *name, *value; SoupMessageHeadersIter iter; soup_message_headers_iter_init(&iter, msg->request_headers); while (soup_message_headers_iter_next(&iter, &name, &value)) { if (g_strcmp0(name, "Connection") == 0 && g_strcmp0(value, "Upgrade") == 0) { return TRUE; } } return FALSE; }
static void fillResponseFromMessage(SoupMessage* msg, ResourceResponse* response) { SoupMessageHeadersIter iter; const char* name = 0; const char* value = 0; soup_message_headers_iter_init(&iter, msg->response_headers); while (soup_message_headers_iter_next(&iter, &name, &value)) response->setHTTPHeaderField(name, value); GHashTable* contentTypeParameters = 0; String contentType = soup_message_headers_get_content_type(msg->response_headers, &contentTypeParameters); // When the server sends multiple Content-Type headers, soup will // give us their values concatenated with commas as a separator; // we need to handle this and use only one value. We use the first // value, and add all the parameters, afterwards, if any. Vector<String> contentTypes; contentType.split(',', true, contentTypes); contentType = contentTypes[0]; if (contentTypeParameters) { GString* parametersString = g_string_new(0); GHashTableIter hashTableIter; const char* hashKey; const char* hashValue; g_hash_table_iter_init(&hashTableIter, contentTypeParameters); while (g_hash_table_iter_next(&hashTableIter, reinterpret_cast<void**>(const_cast<char**>(&hashKey)), reinterpret_cast<void**>(const_cast<char**>(&hashValue)))) { // Work-around bug in soup which causes a crash; // See http://bugzilla.gnome.org/show_bug.cgi?id=577728 if (!hashValue) hashValue = ""; g_string_append(parametersString, "; "); soup_header_g_string_append_param(parametersString, hashKey, hashValue); } contentType += String(parametersString->str); g_string_free(parametersString, true); g_hash_table_destroy(contentTypeParameters); } response->setMimeType(extractMIMETypeFromMediaType(contentType)); char* uri = soup_uri_to_string(soup_message_get_uri(msg), false); response->setURL(KURL(KURL(), uri)); g_free(uri); response->setTextEncodingName(extractCharsetFromMediaType(contentType)); response->setExpectedContentLength(soup_message_headers_get_content_length(msg->response_headers)); response->setHTTPStatusCode(msg->status_code); response->setHTTPStatusText(msg->reason_phrase); response->setSuggestedFilename(filenameFromHTTPContentDisposition(response->httpHeaderField("Content-Disposition"))); }
void gss_soup_dump_request_headers (SoupMessage * msg) { SoupMessageHeadersIter iter; const char *name; const char *value; soup_message_headers_iter_init (&iter, msg->request_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) { GST_ERROR ("%s: %s", name, value); } }
void gss_transaction_dump (GssTransaction * t) { SoupMessageHeadersIter iter; const char *name; const char *value; g_print ("Request: %s %s\n", t->msg->method, t->path); if (t->query) { GHashTableIter iter; char *key, *value; g_hash_table_iter_init (&iter, t->query); while (g_hash_table_iter_next (&iter, (gpointer) & key, (gpointer) & value)) { g_print (" %s=%s\n", key, value); } } if (t->msg->method == SOUP_METHOD_POST) { g_print ("Content:\n%s\n", t->msg->request_body->data); } g_print ("From: %s\n", soup_address_get_physical (soup_client_context_get_address (t->client))); g_print ("Status: %d\n", t->msg->status_code); g_print ("Request Headers:\n"); soup_message_headers_iter_init (&iter, t->msg->request_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) { g_print (" %s: %s\n", name, value); } g_print ("Response Headers:\n"); soup_message_headers_iter_init (&iter, t->msg->response_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) { g_print (" %s: %s\n", name, value); } g_print ("\n"); }
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)); }
static void server_callback (SoupServer *server, SoupMessage *msg, const char *path, GHashTable *query, SoupClientContext *context, gpointer data) { SoupMessageHeadersIter iter; soup_message_headers_iter_init (&iter, msg->request_headers); if (msg->method == SOUP_METHOD_GET || msg->method == SOUP_METHOD_HEAD) do_get (server, msg, path); else if (msg->method == SOUP_METHOD_PUT) do_put (server, msg, path); else soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED); }
static void print_response (SoupLogger *logger, SoupMessage *msg) { SoupLoggerPrivate *priv = SOUP_LOGGER_GET_PRIVATE (logger); SoupLoggerLogLevel log_level; SoupMessageHeadersIter iter; const char *name, *value; if (priv->response_filter) { log_level = priv->response_filter (logger, msg, priv->response_filter_data); } else log_level = priv->level; if (log_level == SOUP_LOGGER_LOG_NONE) return; soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '<', "HTTP/1.%d %u %s\n", soup_message_get_http_version (msg), msg->status_code, msg->reason_phrase); soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '<', "Soup-Debug-Timestamp: %lu", (unsigned long)time (0)); soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '<', "Soup-Debug: %s %u (%p)", g_type_name_from_instance ((GTypeInstance *)msg), soup_logger_get_id (logger, msg), msg); if (log_level == SOUP_LOGGER_LOG_MINIMAL) return; soup_message_headers_iter_init (&iter, msg->response_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) { soup_logger_print (logger, SOUP_LOGGER_LOG_HEADERS, '<', "%s: %s", name, value); } if (log_level == SOUP_LOGGER_LOG_HEADERS) return; if (msg->response_body->data) { soup_logger_print (logger, SOUP_LOGGER_LOG_BODY, '<', "\n%s", msg->response_body->data); } }
static void fillResponseFromMessage(SoupMessage* msg, ResourceResponse* response) { SoupMessageHeadersIter iter; const char* name = NULL; const char* value = NULL; soup_message_headers_iter_init(&iter, msg->response_headers); while (soup_message_headers_iter_next(&iter, &name, &value)) response->setHTTPHeaderField(name, value); String contentType = soup_message_headers_get(msg->response_headers, "Content-Type"); char* uri = soup_uri_to_string(soup_message_get_uri(msg), FALSE); response->setUrl(KURL(uri)); g_free(uri); response->setMimeType(extractMIMETypeFromMediaType(contentType)); response->setTextEncodingName(extractCharsetFromMediaType(contentType)); response->setExpectedContentLength(soup_message_headers_get_content_length(msg->response_headers)); response->setHTTPStatusCode(msg->status_code); response->setSuggestedFilename(filenameFromHTTPContentDisposition(response->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)); m_httpBody = FormData::create(soupMessage->request_body->data, soupMessage->request_body->length); // FIXME: m_allowHTTPCookies and m_firstPartyForCookies should // probably be handled here and on doUpdatePlatformRequest // somehow. }
void ResourceResponse::updateFromSoupMessageHeaders(const SoupMessageHeaders* messageHeaders) { SoupMessageHeaders* headers = const_cast<SoupMessageHeaders*>(messageHeaders); SoupMessageHeadersIter headersIter; const char* headerName; const char* headerValue; // updateFromSoupMessage could be called several times for the same ResourceResponse object, // thus, we need to clear old header values and update m_httpHeaderFields from soupMessage headers. m_httpHeaderFields.clear(); soup_message_headers_iter_init(&headersIter, headers); while (soup_message_headers_iter_next(&headersIter, &headerName, &headerValue)) { String headerNameString = String::fromUTF8WithLatin1Fallback(headerName, strlen(headerName)); HTTPHeaderMap::const_iterator it = m_httpHeaderFields.find(headerNameString); if (it == m_httpHeaderFields.end() || (it != m_httpHeaderFields.end() && it->value.isEmpty())) m_httpHeaderFields.set(headerNameString, String::fromUTF8WithLatin1Fallback(headerValue, strlen(headerValue))); else { StringBuilder builder; builder.append(it->value); builder.appendLiteral(", "); builder.append(String::fromUTF8WithLatin1Fallback(headerValue, strlen(headerValue))); m_httpHeaderFields.set(headerNameString, builder.toString()); } } String contentType; const char* officialType = soup_message_headers_get_one(headers, "Content-Type"); if (!m_sniffedContentType.isEmpty() && m_sniffedContentType != officialType) contentType = m_sniffedContentType; else contentType = officialType; setMimeType(extractMIMETypeFromMediaType(contentType)); setTextEncodingName(extractCharsetFromMediaType(contentType)); setExpectedContentLength(soup_message_headers_get_content_length(headers)); setSuggestedFilename(filenameFromHTTPContentDisposition(httpHeaderField("Content-Disposition")));}
static void get_response_headers (SoupMessage *msg, GString *headers, SoupEncoding *encoding, gpointer user_data) { SoupEncoding claimed_encoding; SoupMessageHeadersIter iter; const char *name, *value; handle_partial_get (msg); g_string_append_printf (headers, "HTTP/1.%c %d %s\r\n", soup_message_get_http_version (msg) == SOUP_HTTP_1_0 ? '0' : '1', msg->status_code, msg->reason_phrase); claimed_encoding = soup_message_headers_get_encoding (msg->response_headers); if ((msg->method == SOUP_METHOD_HEAD || msg->status_code == SOUP_STATUS_NO_CONTENT || msg->status_code == SOUP_STATUS_NOT_MODIFIED || SOUP_STATUS_IS_INFORMATIONAL (msg->status_code)) || (msg->method == SOUP_METHOD_CONNECT && SOUP_STATUS_IS_SUCCESSFUL (msg->status_code))) *encoding = SOUP_ENCODING_NONE; else *encoding = claimed_encoding; if (claimed_encoding == SOUP_ENCODING_CONTENT_LENGTH && !soup_message_headers_get_content_length (msg->response_headers)) { soup_message_headers_set_content_length (msg->response_headers, msg->response_body->length); } soup_message_headers_iter_init (&iter, msg->response_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) g_string_append_printf (headers, "%s: %s\r\n", name, value); g_string_append (headers, "\r\n"); }
static void check_headers (SoupMultipartInputStream* multipart, unsigned passes) { SoupMessageHeaders *headers; SoupMessageHeadersIter iter; gboolean is_next; const char *name, *value; headers = soup_multipart_input_stream_get_headers (multipart); soup_message_headers_iter_init (&iter, headers); switch (passes) { case 0: is_next = soup_message_headers_iter_next (&iter, &name, &value); check_is_next (is_next); if (!g_str_equal (name, "Content-Type")) { debug_printf (1, " [0] expected `Content-Type' got %s\n", name); errors++; } if (!g_str_equal (value, "text/html")) { debug_printf (1, " [0] expected `text/html' got %s\n", value); errors++; } is_next = soup_message_headers_iter_next (&iter, &name, &value); check_is_next (is_next); if (!g_str_equal (name, "Content-Length")) { debug_printf (1, " [0] expected `Content-Length' got %s\n", name); errors++; } if (!g_str_equal (value, "30")) { debug_printf (1, " [0] expected `30' got %s\n", value); errors++; } break; case 1: is_next = soup_message_headers_iter_next (&iter, &name, &value); check_is_next (is_next); if (!g_str_equal (name, "Content-Length")) { debug_printf (1, " [1] expected `Content-Length' got %s\n", name); errors++; } if (!g_str_equal (value, "10")) { debug_printf (1, " [1] expected `10' got %s\n", value); errors++; } break; case 2: case 3: is_next = soup_message_headers_iter_next (&iter, &name, &value); check_is_next (is_next); if (!g_str_equal (name, "Content-Type")) { debug_printf (1, " [%d] expected `Content-Type' got %s\n", passes, name); errors++; } if (!g_str_equal (value, "text/css")) { debug_printf (1, " [%d] expected `text/html' got %s\n", passes, value); errors++; } break; default: debug_printf (1, " unexpected part received\n"); break; } }
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 get_request_headers (SoupMessage *req, GString *header, SoupEncoding *encoding, gpointer user_data) { SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (req); gboolean proxy = GPOINTER_TO_UINT (user_data); SoupURI *uri = soup_message_get_uri (req); char *uri_host; char *uri_string; SoupMessageHeadersIter iter; const char *name, *value; if (strchr (uri->host, ':')) uri_host = g_strdup_printf ("[%s]", uri->host); else uri_host = uri->host; if (req->method == SOUP_METHOD_CONNECT) { /* CONNECT URI is hostname:port for tunnel destination */ uri_string = g_strdup_printf ("%s:%d", uri_host, uri->port); } else { /* Proxy expects full URI to destination. Otherwise * just the path. */ uri_string = soup_uri_to_string (uri, !proxy); } if (priv->http_version == SOUP_HTTP_1_0) { g_string_append_printf (header, "%s %s HTTP/1.0\r\n", req->method, uri_string); } else { g_string_append_printf (header, "%s %s HTTP/1.1\r\n", req->method, uri_string); if (!soup_message_headers_get_one (req->request_headers, "Host")) { if (soup_uri_uses_default_port (uri)) { g_string_append_printf (header, "Host: %s\r\n", uri_host); } else { g_string_append_printf (header, "Host: %s:%d\r\n", uri_host, uri->port); } } } g_free (uri_string); if (uri_host != uri->host) g_free (uri_host); *encoding = soup_message_headers_get_encoding (req->request_headers); if ((*encoding == SOUP_ENCODING_CONTENT_LENGTH || *encoding == SOUP_ENCODING_NONE) && (req->request_body->length > 0 || soup_message_headers_get_one (req->request_headers, "Content-Type")) && !soup_message_headers_get_content_length (req->request_headers)) { *encoding = SOUP_ENCODING_CONTENT_LENGTH; soup_message_headers_set_content_length (req->request_headers, req->request_body->length); } soup_message_headers_iter_init (&iter, req->request_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) g_string_append_printf (header, "%s: %s\r\n", name, value); g_string_append (header, "\r\n"); }
static void print_request (SoupLogger *logger, SoupMessage *msg, SoupSession *session, SoupSocket *socket, gboolean restarted) { SoupLoggerPrivate *priv = SOUP_LOGGER_GET_PRIVATE (logger); SoupLoggerLogLevel log_level; SoupMessageHeadersIter iter; const char *name, *value; SoupURI *uri; if (priv->request_filter) { log_level = priv->request_filter (logger, msg, priv->request_filter_data); } else log_level = priv->level; if (log_level == SOUP_LOGGER_LOG_NONE) return; uri = soup_message_get_uri (msg); if (msg->method == SOUP_METHOD_CONNECT) { soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>', "CONNECT %s:%u HTTP/1.%d", uri->host, uri->port, soup_message_get_http_version (msg)); } else { soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>', "%s %s%s%s HTTP/1.%d", msg->method, uri->path, uri->query ? "?" : "", uri->query ? uri->query : "", soup_message_get_http_version (msg)); } soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>', "Soup-Debug-Timestamp: %lu", (unsigned long)time (0)); soup_logger_print (logger, SOUP_LOGGER_LOG_MINIMAL, '>', "Soup-Debug: %s %u (%p), %s %u (%p), %s %u (%p)%s", g_type_name_from_instance ((GTypeInstance *)session), soup_logger_get_id (logger, session), session, g_type_name_from_instance ((GTypeInstance *)msg), soup_logger_get_id (logger, msg), msg, g_type_name_from_instance ((GTypeInstance *)socket), soup_logger_get_id (logger, socket), socket, restarted ? ", restarted" : ""); if (log_level == SOUP_LOGGER_LOG_MINIMAL) return; if (!soup_message_headers_get_one (msg->request_headers, "Host")) { char *uri_host; if (strchr (uri->host, ':')) uri_host = g_strdup_printf ("[%s]", uri->host); else if (g_hostname_is_non_ascii (uri->host)) uri_host = g_hostname_to_ascii (uri->host); else uri_host = uri->host; soup_logger_print (logger, SOUP_LOGGER_LOG_HEADERS, '>', "Host: %s%c%u", uri_host, soup_uri_uses_default_port (uri) ? '\0' : ':', uri->port); if (uri_host != uri->host) g_free (uri_host); } soup_message_headers_iter_init (&iter, msg->request_headers); while (soup_message_headers_iter_next (&iter, &name, &value)) { if (!g_ascii_strcasecmp (name, "Authorization") && !g_ascii_strncasecmp (value, "Basic ", 6)) soup_logger_print_basic_auth (logger, value); else { soup_logger_print (logger, SOUP_LOGGER_LOG_HEADERS, '>', "%s: %s", name, value); } } if (log_level == SOUP_LOGGER_LOG_HEADERS) return; if (msg->request_body->length && soup_message_body_get_accumulate (msg->request_body)) { SoupBuffer *request; request = soup_message_body_flatten (msg->request_body); g_return_if_fail (request != NULL); soup_buffer_free (request); if (soup_message_headers_get_expectations (msg->request_headers) != SOUP_EXPECTATION_CONTINUE) { soup_logger_print (logger, SOUP_LOGGER_LOG_BODY, '>', "\n%s", msg->request_body->data); } } }