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);
}
}
}
