static void received_announcement (GSSDPResourceBrowser *resource_browser, SoupMessageHeaders *headers) { const char *header; header = soup_message_headers_get_one (headers, "NT"); if (!header) return; /* No target specified */ if (!check_target_compat (resource_browser, header)) return; /* Target doesn't match */ header = soup_message_headers_get_one (headers, "NTS"); if (!header) return; /* No announcement type specified */ /* Check announcement type */ if (strncmp (header, SSDP_ALIVE_NTS, strlen (SSDP_ALIVE_NTS)) == 0) resource_available (resource_browser, headers); else if (strncmp (header, SSDP_BYEBYE_NTS, strlen (SSDP_BYEBYE_NTS)) == 0) resource_unavailable (resource_browser, headers); else if (strncmp (header, SSDP_UPDATE_NTS, strlen (SSDP_UPDATE_NTS)) == 0) resource_update (resource_browser, headers); }
/* Server handlers for "*" work but are separate from handlers for * all other URIs. #590751 */ static void do_star_test (void) { SoupSession *session; SoupMessage *msg; SoupURI *star_uri; const char *handled_by; debug_printf (1, "\nOPTIONS *\n"); session = soup_test_session_new (SOUP_TYPE_SESSION_SYNC, NULL); star_uri = soup_uri_copy (base_uri); soup_uri_set_path (star_uri, "*"); debug_printf (1, " Testing with no handler\n"); msg = soup_message_new_from_uri ("OPTIONS", star_uri); soup_session_send_message (session, msg); if (msg->status_code != SOUP_STATUS_NOT_FOUND) { debug_printf (1, " Unexpected response: %d %s\n", msg->status_code, msg->reason_phrase); errors++; } handled_by = soup_message_headers_get_one (msg->response_headers, "X-Handled-By"); if (handled_by) { /* Should have been rejected by SoupServer directly */ debug_printf (1, " Message reached handler '%s'\n", handled_by); errors++; } g_object_unref (msg); soup_server_add_handler (server, "*", server_star_callback, NULL, NULL); debug_printf (1, " Testing with handler\n"); msg = soup_message_new_from_uri ("OPTIONS", star_uri); soup_session_send_message (session, msg); if (msg->status_code != SOUP_STATUS_OK) { debug_printf (1, " Unexpected response: %d %s\n", msg->status_code, msg->reason_phrase); errors++; } handled_by = soup_message_headers_get_one (msg->response_headers, "X-Handled-By"); if (!handled_by) { debug_printf (1, " Message did not reach handler!\n"); errors++; } else if (strcmp (handled_by, "star_callback") != 0) { debug_printf (1, " Message reached incorrect handler '%s'\n", handled_by); errors++; } g_object_unref (msg); soup_test_session_abort_unref (session); soup_uri_free (star_uri); }
static void resource_update (GSSDPResourceBrowser *resource_browser, SoupMessageHeaders *headers) { GSSDPResourceBrowserPrivate *priv; const char *usn; const char *boot_id_header; const char *next_boot_id_header; char *canonical_usn; guint boot_id; guint next_boot_id; gint64 out; priv = gssdp_resource_browser_get_instance_private (resource_browser); usn = soup_message_headers_get_one (headers, "USN"); boot_id_header = soup_message_headers_get_one (headers, "BOOTID.UPNP.ORG"); next_boot_id_header = soup_message_headers_get_one (headers, "NEXTBOOTID.UPNP.ORG"); if (!usn) return; /* No USN specified */ if (!boot_id_header) return; if (!next_boot_id_header) return; if (!g_ascii_string_to_signed (boot_id_header, 10, 0, G_MAXINT32, &out, NULL)) return; boot_id = out; if (!g_ascii_string_to_signed (next_boot_id_header, 10, 0, G_MAXINT32, &out, NULL)) return; next_boot_id = out; if (priv->version > 0) { char *version; version = g_strrstr (usn, ":"); canonical_usn = g_strndup (usn, version - usn); } else { canonical_usn = g_strdup (usn); } /* Only continue if we know about this. if not, there will be an * announcement afterwards anyway */ if (!g_hash_table_lookup (priv->resources, canonical_usn)) goto out; g_signal_emit (resource_browser, signals[RESOURCE_UPDATE], 0, usn, boot_id, next_boot_id); out: g_free (canonical_usn); }
/* * * We have two headeers we care about, Content-ID which we use as steam_type and * * Status which we read when stream_type equals STREAM_ERROR. * */ static void multipart_read_headers (MultiPartData *multipart_data) { multipart_data->headers = soup_multipart_input_stream_get_headers (multipart_data->multipart); if (multipart_data->headers) { multipart_data->method = soup_message_headers_get_one (multipart_data->headers, "rstrnt-method"); multipart_data->path = soup_message_headers_get_one (multipart_data->headers, "rstrnt-path"); } }
static gboolean is_websocket_client (SnraServerClient * client) { /* Check for request headers. Example: * Upgrade: websocket * Connection: Upgrade, Keep-Alive * Sec-WebSocket-Key: XYZABC123 * Sec-WebSocket-Protocol: aurena * Sec-WebSocket-Version: 13 */ SoupMessage *msg = client->event_pipe; SoupMessageHeaders *req_hdrs = msg->request_headers; const gchar *val; gint protocol_ver = 0; if ((val = soup_message_headers_get_one (req_hdrs, "Upgrade")) == NULL) return FALSE; if (g_ascii_strcasecmp (val, "websocket") != 0) return FALSE; if ((val = soup_message_headers_get_list (req_hdrs, "Connection")) == NULL) return FALSE; /* Connection params list must request upgrade to websocket */ if (!http_list_contains_value (val, "upgrade")) return FALSE; if ((val = soup_message_headers_get_one (req_hdrs, "Sec-WebSocket-Key")) == NULL) return FALSE; if ((val = soup_message_headers_get_list (req_hdrs, "Sec-WebSocket-Protocol")) == NULL) return FALSE; if (!http_list_contains_value (val, "aurena")) return FALSE; /* Requested protocol version must be 13 or 8 */ if ((val = soup_message_headers_get_list (req_hdrs, "Sec-WebSocket-Version")) == NULL) return FALSE; if (http_list_contains_value (val, "13")) protocol_ver = 13; else if (http_list_contains_value (val, "8")) protocol_ver = 8; if (protocol_ver == 0) return FALSE; /* No supported version found */ g_print ("WebSocket connection with protocol %d\n", protocol_ver); client->websocket_protocol = protocol_ver; return TRUE; }
static void request_started (SoupSession *session, SoupMessage *msg, SoupSocket *socket) { if (soup_message_headers_get_one (msg->request_headers, "If-Modified-Since") || soup_message_headers_get_one (msg->request_headers, "If-None-Match")) { debug_printf (2, " Conditional request for %s\n", soup_message_get_uri (msg)->path); last_request_validated = TRUE; } }
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++; } }
/** * soup_message_headers_get_encoding: * @hdrs: a #SoupMessageHeaders * * Gets the message body encoding that @hdrs declare. This may not * always correspond to the encoding used on the wire; eg, a HEAD * response may declare a Content-Length or Transfer-Encoding, but * it will never actually include a body. * * Return value: the encoding declared by @hdrs. **/ SoupEncoding soup_message_headers_get_encoding (SoupMessageHeaders *hdrs) { const char *header; if (hdrs->encoding != -1) return hdrs->encoding; /* If Transfer-Encoding was set, hdrs->encoding would already * be set. So we don't need to check that possibility. */ header = soup_message_headers_get_one (hdrs, "Content-Length"); if (header) { content_length_setter (hdrs, header); if (hdrs->encoding != -1) return hdrs->encoding; } /* Per RFC 2616 4.4, a response body that doesn't indicate its * encoding otherwise is terminated by connection close, and a * request that doesn't indicate otherwise has no body. Note * that SoupMessage calls soup_message_headers_set_encoding() * to override the response body default for our own * server-side messages. */ hdrs->encoding = (hdrs->type == SOUP_MESSAGE_HEADERS_RESPONSE) ? SOUP_ENCODING_EOF : SOUP_ENCODING_NONE; return hdrs->encoding; }
static void do_aliases_test_for_session (SoupSession *session, const char *redirect_protocol) { SoupMessage *msg; SoupURI *uri; const char *redirected_protocol; uri = soup_uri_new_with_base (base_uri, "/alias-redirect"); msg = soup_message_new_from_uri ("GET", uri); if (redirect_protocol) soup_message_headers_append (msg->request_headers, "X-Redirect-Protocol", redirect_protocol); soup_uri_free (uri); soup_session_send_message (session, msg); redirected_protocol = soup_message_headers_get_one (msg->response_headers, "X-Redirected-Protocol"); if (g_strcmp0 (redirect_protocol, redirected_protocol)) { debug_printf (1, " redirect went to %s, should have gone to %s!\n", redirected_protocol ? redirected_protocol : "(none)", redirect_protocol ? redirect_protocol : "(none)"); errors++; } else if (redirect_protocol && !SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { debug_printf (1, " msg failed? (%d %s)\n", msg->status_code, msg->reason_phrase); errors++; } else if (!redirect_protocol && SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { debug_printf (1, " msg succeeded? (%d %s)\n", msg->status_code, msg->reason_phrase); errors++; } g_object_unref (msg); }
static void ipv6_server_callback (SoupServer *server, SoupMessage *msg, const char *path, GHashTable *query, SoupClientContext *context, gpointer data) { const char *host; char expected_host[128]; host = soup_message_headers_get_one (msg->request_headers, "Host"); if (!host) { debug_printf (1, " request has no Host header!\n"); errors++; soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST); return; } g_snprintf (expected_host, sizeof (expected_host), "[::1]:%d", soup_server_get_port (server)); if (strcmp (host, expected_host) == 0) soup_message_set_status (msg, SOUP_STATUS_OK); else { debug_printf (1, " request has incorrect Host header '%s'\n", host); errors++; soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST); } }
static void contentSniffedCallback(SoupMessage* msg, const char* sniffedType, GHashTable *params, gpointer data) { if (sniffedType) { const char* officialType = soup_message_headers_get_one(msg->response_headers, "Content-Type"); if (!officialType || strcmp(officialType, sniffedType)) soup_message_headers_set_content_type(msg->response_headers, sniffedType, params); } // The 304 status code (SOUP_STATUS_NOT_MODIFIED) needs to be fed // into WebCore, as opposed to other kinds of redirections, which // are handled by soup directly, so we special-case it here and in // gotChunk. if (SOUP_STATUS_IS_TRANSPORT_ERROR(msg->status_code) || (SOUP_STATUS_IS_REDIRECTION(msg->status_code) && (msg->status_code != SOUP_STATUS_NOT_MODIFIED)) || (msg->status_code == SOUP_STATUS_UNAUTHORIZED)) return; RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data); if (!handle) return; ResourceHandleInternal* d = handle->getInternal(); if (d->m_cancelled) return; ResourceHandleClient* client = handle->client(); if (!client) return; fillResponseFromMessage(msg, &d->m_response); client->didReceiveResponse(handle.get(), d->m_response); }
static void authentication_info_cb (SoupMessage *msg, gpointer data) { SoupAuth *auth = data; SoupAuthDigestPrivate *priv = SOUP_AUTH_DIGEST_GET_PRIVATE (auth); const char *header; GHashTable *auth_params; char *nextnonce; if (auth != soup_message_get_auth (msg)) return; header = soup_message_headers_get_one (msg->response_headers, soup_auth_is_for_proxy (auth) ? "Proxy-Authentication-Info" : "Authentication-Info"); g_return_if_fail (header != NULL); auth_params = soup_header_parse_param_list (header); if (!auth_params) return; nextnonce = g_strdup (g_hash_table_lookup (auth_params, "nextnonce")); if (nextnonce) { g_free (priv->nonce); priv->nonce = nextnonce; } soup_header_free_param_list (auth_params); }
// This callback will not be called if the content sniffer is disabled in startHttp. static void contentSniffedCallback(SoupMessage* msg, const char* sniffedType, GHashTable *params, gpointer data) { if (sniffedType) { const char* officialType = soup_message_headers_get_one(msg->response_headers, "Content-Type"); if (!officialType || strcmp(officialType, sniffedType)) soup_message_headers_set_content_type(msg->response_headers, sniffedType, params); } if (statusWillBeHandledBySoup(msg->status_code)) return; RefPtr<ResourceHandle> handle = static_cast<ResourceHandle*>(data); if (!handle) return; ResourceHandleInternal* d = handle->getInternal(); if (d->m_cancelled) return; ResourceHandleClient* client = handle->client(); if (!client) return; fillResponseFromMessage(msg, &d->m_response); client->didReceiveResponse(handle.get(), d->m_response); }
static int identify_auth (SoupMessage *msg) { const char *header; int num; header = soup_message_headers_get_one (msg->request_headers, "Authorization"); if (!header) return 0; if (!g_ascii_strncasecmp (header, "Basic ", 6)) { char *token; gsize len; token = (char *)g_base64_decode (header + 6, &len); num = token[len - 1] - '0'; g_free (token); } else { const char *user; user = strstr (header, "username=\"user"); if (user) num = user[14] - '0'; else num = 0; } g_assert (num >= 0 && num <= 4); return num; }
GdkPixbuf* utils_download_picture_if_newer(SoupSession* soup, const gchar* url, gint64 timestamp) { SoupMessage* msg; guint soup_status; const gchar* last_modified; GdkPixbuf* ret; msg = soup_message_new(SOUP_METHOD_HEAD, url); soup_status = soup_session_send_message(soup, msg); if (SOUP_STATUS_IS_SUCCESSFUL(soup_status) && (last_modified = soup_message_headers_get_one(msg->response_headers, "Last-Modified")) != NULL && utils_http_full_date_to_timestamp(last_modified) < timestamp) { g_info("{Utils} No new content at url '%s'", url); ret = NULL; } else ret = utils_download_picture(soup, url); g_object_unref(msg); return ret; }
static void serverCallback(SoupServer* server, SoupMessage* message, const char* path, GHashTable*, SoupClientContext*, gpointer) { if (message->method != SOUP_METHOD_GET) { soup_message_set_status(message, SOUP_STATUS_NOT_IMPLEMENTED); return; } if (g_str_equal(path, "/")) { const char* acceptLanguage = soup_message_headers_get_one(message->request_headers, "Accept-Language"); soup_message_set_status(message, SOUP_STATUS_OK); soup_message_body_append(message->response_body, SOUP_MEMORY_COPY, acceptLanguage, strlen(acceptLanguage)); soup_message_body_complete(message->response_body); } else if (g_str_equal(path, "/empty")) { const char* emptyHTML = "<html><body></body></html>"; soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, emptyHTML, strlen(emptyHTML)); soup_message_body_complete(message->response_body); soup_message_set_status(message, SOUP_STATUS_OK); } else if (g_str_equal(path, "/appcache")) { const char* appcacheHTML = "<html manifest=appcache.manifest><body></body></html>"; soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, appcacheHTML, strlen(appcacheHTML)); soup_message_body_complete(message->response_body); soup_message_set_status(message, SOUP_STATUS_OK); } else if (g_str_equal(path, "/appcache.manifest")) { const char* appcacheManifest = "CACHE MANIFEST\nCACHE:\nappcache/foo.txt\n"; soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, appcacheManifest, strlen(appcacheManifest)); soup_message_body_complete(message->response_body); soup_message_set_status(message, SOUP_STATUS_OK); } else if (g_str_equal(path, "/appcache/foo.txt")) { soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, "foo", 3); soup_message_body_complete(message->response_body); soup_message_set_status(message, SOUP_STATUS_OK); } else soup_message_set_status(message, SOUP_STATUS_NOT_FOUND); }
static void do_put (SoupServer *server, SoupMessage *msg, const char *path) { struct stat st; FILE *f; gboolean created = TRUE; if (stat (path, &st) != -1) { const char *match = soup_message_headers_get_one (msg->request_headers, "If-None-Match"); if (match && !strcmp (match, "*")) { soup_message_set_status (msg, SOUP_STATUS_CONFLICT); return; } if (!S_ISREG (st.st_mode)) { soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN); return; } created = FALSE; } f = fopen (path, "w"); if (!f) { soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR); return; } fwrite (msg->request_body->data, 1, msg->request_body->length, f); fclose (f); soup_message_set_status (msg, created ? SOUP_STATUS_CREATED : SOUP_STATUS_OK); }
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"))); }
static gboolean check_password (SoupAuthDomain *domain, SoupMessage *msg, const char *username, const char *password) { const char *header; GHashTable *params; const char *msg_username; char hex_urp[33]; gboolean accept; header = soup_message_headers_get_one (msg->request_headers, "Authorization"); if (strncmp (header, "Digest ", 7) != 0) return FALSE; params = soup_header_parse_param_list (header + 7); if (!params) return FALSE; msg_username = g_hash_table_lookup (params, "username"); if (!msg_username || strcmp (msg_username, username) != 0) { soup_header_free_param_list (params); return FALSE; } soup_auth_digest_compute_hex_urp (username, soup_auth_domain_get_realm (domain), password, hex_urp); accept = check_hex_urp (domain, msg, params, username, hex_urp); soup_header_free_param_list (params); return accept; }
static void callback (SoupSession * session, SoupMessage * msg, gpointer user_data) { GstSoupHttpClientSink *souphttpsink = GST_SOUP_HTTP_CLIENT_SINK (user_data); GST_DEBUG_OBJECT (souphttpsink, "callback status=%d %s", msg->status_code, msg->reason_phrase); g_mutex_lock (&souphttpsink->mutex); g_cond_signal (&souphttpsink->cond); souphttpsink->message = NULL; if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { souphttpsink->failures++; if (souphttpsink->retries && (souphttpsink->retries < 0 || souphttpsink->retries >= souphttpsink->failures)) { guint64 retry_delay; const char *retry_after = soup_message_headers_get_one (msg->response_headers, "Retry-After"); if (retry_after) { gchar *end = NULL; retry_delay = g_ascii_strtoull (retry_after, &end, 10); if (end || errno) { retry_delay = souphttpsink->retry_delay; } else { retry_delay = MAX (retry_delay, souphttpsink->retry_delay); } GST_WARNING_OBJECT (souphttpsink, "Could not write to HTTP URI: " "status: %d %s (retrying PUT after %" G_GINT64_FORMAT " seconds with Retry-After: %s)", msg->status_code, msg->reason_phrase, retry_delay, retry_after); } else { retry_delay = souphttpsink->retry_delay; GST_WARNING_OBJECT (souphttpsink, "Could not write to HTTP URI: " "status: %d %s (retrying PUT after %" G_GINT64_FORMAT " seconds)", msg->status_code, msg->reason_phrase, retry_delay); } souphttpsink->timer = g_timeout_source_new_seconds (retry_delay); g_source_set_callback (souphttpsink->timer, (GSourceFunc) (send_message), souphttpsink, NULL); g_source_attach (souphttpsink->timer, souphttpsink->context); } else { souphttpsink->status_code = msg->status_code; souphttpsink->reason_phrase = g_strdup (msg->reason_phrase); } g_mutex_unlock (&souphttpsink->mutex); return; } g_list_free_full (souphttpsink->sent_buffers, (GDestroyNotify) gst_buffer_unref); souphttpsink->sent_buffers = NULL; souphttpsink->failures = 0; send_message_locked (souphttpsink); g_mutex_unlock (&souphttpsink->mutex); }
static void databases_items_xxx (DMAPShare * share, SoupServer * server, SoupMessage * msg, const char *path, GHashTable * query, SoupClientContext * context) { DMAPDb *db; const gchar *transcode_mimetype; const gchar *rest_of_path; const gchar *id_str; guint id; const gchar *range_header; guint64 filesize; guint64 offset = 0; DAAPRecord *record; rest_of_path = strchr (path + 1, '/'); id_str = rest_of_path + 9; id = strtoul (id_str, NULL, 10); g_object_get (share, "db", &db, NULL); record = DAAP_RECORD (dmap_db_lookup_by_id (db, id)); g_object_get (record, "filesize", &filesize, NULL); DMAP_SHARE_GET_CLASS (share)->message_add_standard_headers (share, msg); soup_message_headers_append (msg->response_headers, "Accept-Ranges", "bytes"); range_header = soup_message_headers_get_one (msg->request_headers, "Range"); if (range_header) { const gchar *s; gchar *content_range; s = range_header + 6; /* bytes= */ offset = atoll (s); content_range = g_strdup_printf ("bytes %" G_GUINT64_FORMAT "-%" G_GUINT64_FORMAT "/%" G_GUINT64_FORMAT, offset, filesize, filesize); soup_message_headers_append (msg->response_headers, "Content-Range", content_range); g_debug ("Content range is %s.", content_range); g_free (content_range); soup_message_set_status (msg, SOUP_STATUS_PARTIAL_CONTENT); } else { soup_message_set_status (msg, SOUP_STATUS_OK); } g_object_get (share, "transcode-mimetype", &transcode_mimetype, NULL); send_chunked_file (server, msg, record, filesize, offset, transcode_mimetype); g_object_unref (record); }
static void network_process_callback (SoupSession *session, SoupMessage *msg, gpointer user_data) { updateJobPtr job = (updateJobPtr)user_data; SoupDate *last_modified; const gchar *tmp = NULL; job->result->source = soup_uri_to_string (soup_message_get_uri(msg), FALSE); if (SOUP_STATUS_IS_TRANSPORT_ERROR (msg->status_code)) { job->result->returncode = msg->status_code; job->result->httpstatus = 0; } else { job->result->httpstatus = msg->status_code; job->result->returncode = 0; } debug1 (DEBUG_NET, "download status code: %d", msg->status_code); debug1 (DEBUG_NET, "source after download: >>>%s<<<", job->result->source); job->result->data = g_memdup (msg->response_body->data, msg->response_body->length+1); job->result->size = (size_t)msg->response_body->length; debug1 (DEBUG_NET, "%d bytes downloaded", job->result->size); job->result->contentType = g_strdup (soup_message_headers_get_content_type (msg->response_headers, NULL)); /* Update last-modified date */ tmp = soup_message_headers_get_one (msg->response_headers, "Last-Modified"); if (tmp) { /* The string may be badly formatted, which will make * soup_date_new_from_string() return NULL */ last_modified = soup_date_new_from_string (tmp); if (last_modified) { job->result->updateState->lastModified = soup_date_to_time_t (last_modified); soup_date_free (last_modified); } } /* Update ETag value */ tmp = soup_message_headers_get_one (msg->response_headers, "ETag"); if (tmp) { job->result->updateState->etag = g_strdup(tmp); } update_process_finished_job (job); }
static void disappear_request_read (SoupServer *server, SoupMessage *msg, SoupClientContext *context, gpointer user_data) { /* Remove the WWW-Authenticate header if this was a failed attempt */ if (soup_message_headers_get_one (msg->request_headers, "Authorization") && msg->status_code == SOUP_STATUS_UNAUTHORIZED) soup_message_headers_remove (msg->response_headers, "WWW-Authenticate"); }
SnraServerClient * snra_server_client_new (SoupServer * soup, SoupMessage * msg, SoupClientContext * context) { SnraServerClient *client = g_object_new (SNRA_TYPE_SERVER_CLIENT, NULL); const gchar *accept_challenge; gchar *accept_reply; client->soup = soup; client->event_pipe = msg; client->host = g_strdup (soup_client_context_get_host (context)); client->net_event_sig = g_signal_connect (msg, "network-event", G_CALLBACK (snra_server_client_network_event), client); client->disco_sig = g_signal_connect (msg, "finished", G_CALLBACK (snra_server_client_disconnect), client); if (!is_websocket_client (client)) { client->type = SNRA_SERVER_CLIENT_CHUNKED; client->need_body_complete = TRUE; soup_message_headers_set_encoding (msg->response_headers, SOUP_ENCODING_CHUNKED); soup_message_set_status (msg, SOUP_STATUS_OK); return client; } /* Otherwise, it's a websocket client */ client->type = SNRA_SERVER_CLIENT_WEBSOCKET; client->need_body_complete = FALSE; client->socket = soup_client_context_get_socket (context); client->in_bufptr = client->in_buf = g_new0 (gchar, 1024); client->in_bufsize = 1024; client->in_bufavail = 0; accept_challenge = soup_message_headers_get_one (msg->request_headers, "Sec-WebSocket-Key"); accept_reply = calc_websocket_challenge_reply (accept_challenge); soup_message_headers_set_encoding (msg->response_headers, SOUP_ENCODING_EOF); soup_message_set_status (msg, SOUP_STATUS_SWITCHING_PROTOCOLS); soup_message_headers_replace (msg->response_headers, "Upgrade", "websocket"); soup_message_headers_replace (msg->response_headers, "Connection", "Upgrade"); soup_message_headers_replace (msg->response_headers, "Sec-WebSocket-Accept", accept_reply); soup_message_headers_replace (msg->response_headers, "Sec-WebSocket-Protocol", "aurena"); g_free (accept_reply); client->wrote_info_sig = g_signal_connect (msg, "wrote-informational", G_CALLBACK (snra_server_client_wrote_headers), client); return client; }
/* local_db_needs_update function returns TRUE on success and FALSE on failure. * It sets the parameter needs_update to TRUE if the local database needs * to be updated. */ static gboolean local_db_needs_update (SoupSession *session, const char *db_uri, GFile *db_local, gboolean *needs_update, GError **error) { GFileInfo *db_local_info; SoupMessage *msg; SoupDate *date; const gchar *db_time_str; guint64 db_time; guint64 db_local_time; guint status_code; if (g_file_query_exists (db_local, NULL) == FALSE) { *needs_update = TRUE; return TRUE; } msg = soup_message_new ("HEAD", db_uri); status_code = soup_session_send_message (session, msg); if (status_code != SOUP_STATUS_OK) { g_set_error_literal (error, SOUP_HTTP_ERROR, status_code, msg->reason_phrase); return FALSE; } db_time_str = soup_message_headers_get_one (msg->response_headers, "Last-Modified"); date = soup_date_new_from_string (db_time_str); db_time = (guint64) soup_date_to_time_t (date); soup_date_free (date); g_object_unref (msg); db_local_info = g_file_query_info (db_local, "time::modified", G_FILE_QUERY_INFO_NONE, NULL, error); if (!db_local_info) return FALSE; db_local_time = g_file_info_get_attribute_uint64 (db_local_info, "time::modified"); if (db_time <= db_local_time) *needs_update = FALSE; else *needs_update = TRUE; g_object_unref (db_local_info); return TRUE; }
static void soup_session_cb (SoupSession *session, SoupMessage *msg, gpointer user_data) { DQTask *task = user_data; if (SOUP_STATUS_IS_REDIRECTION (msg->status_code)) { const char *header = soup_message_headers_get_one (msg->response_headers, "Location"); if (header) { SoupURI *uri; uri = soup_uri_new_with_base (soup_message_get_uri (msg), header); soup_message_set_uri (msg, uri); soup_uri_free (uri); soup_session_requeue_message (session, msg); return; } } else if (SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) { void *cache; task->any.callback (task->any.queue, task->any.uri, msg->response_body->data, msg->response_body->length, NULL, task->any.userdata); /* add the contents to the cache */ cache = g_memdup (msg->response_body->data, msg->response_body->length); mex_download_queue_cache_insert (task->any.queue, task->any.uri, cache, msg->response_body->length); } else if (msg->status_code != SOUP_STATUS_CANCELLED) { /* FIXME: Also create an error on failure */ task->any.callback (task->any.queue, task->any.uri, NULL, 0, NULL, task->any.userdata); } /* The message is unref'd by the session */ task->soup.message = NULL; mex_download_queue_free (task); }
static void request_check (SoupMessage *msg, gpointer user_data) { NTLMState *state = user_data; const char *header; header = soup_message_headers_get_one (msg->request_headers, "Authorization"); if (header && !strncmp (header, "NTLM " NTLM_REQUEST_START, strlen ("NTLM " NTLM_REQUEST_START))) state->sent_ntlm_request = TRUE; }
static void serverCallback(SoupServer* server, SoupMessage* message, const char* path, GHashTable*, SoupClientContext*, gpointer) { if (message->method != SOUP_METHOD_GET) { soup_message_set_status(message, SOUP_STATUS_NOT_IMPLEMENTED); return; } soup_message_set_status(message, SOUP_STATUS_OK); const char* userAgent = soup_message_headers_get_one(message->request_headers, "User-Agent"); soup_message_body_append(message->response_body, SOUP_MEMORY_COPY, userAgent, strlen(userAgent)); soup_message_body_complete(message->response_body); }
static void soap_got_headers (SoupMessage *msg, gpointer data) { ESoapMessagePrivate *priv = E_SOAP_MESSAGE_GET_PRIVATE (msg); const gchar *size; size = soup_message_headers_get_one (msg->response_headers, "Content-Length"); if (size) priv->response_size = strtol (size, NULL, 10); }
static void server_callback (SoupServer *server, SoupMessage *msg, const char *path, GHashTable *query, SoupClientContext *context, gpointer data) { const char *accept_encoding, *junk; GSList *codings; char *file = NULL, *contents; gsize length; accept_encoding = soup_message_headers_get_list (msg->request_headers, "Accept-Encoding"); if (accept_encoding) codings = soup_header_parse_quality_list (accept_encoding, NULL); else codings = NULL; if (codings && g_slist_find_custom (codings, "gzip", (GCompareFunc)g_ascii_strcasecmp)) { file = g_strdup_printf (SRCDIR "/resources%s.gz", path); if (g_file_test (file, G_FILE_TEST_EXISTS)) { soup_message_headers_append (msg->response_headers, "Content-Encoding", "gzip"); } else { g_free (file); file = NULL; } } if (!file) file = g_strdup_printf (SRCDIR "/resources%s", path); if (!g_file_get_contents (file, &contents, &length, NULL)) { /* If path.gz exists but can't be read, we'll send back * the error with "Content-Encoding: gzip" but there's * no body, so, eh. */ soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND); return; } soup_message_set_status (msg, SOUP_STATUS_OK); soup_message_body_append (msg->response_body, SOUP_MEMORY_TAKE, contents, length); junk = soup_message_headers_get_one (msg->request_headers, "X-Trailing-Junk"); if (junk) { soup_message_body_append (msg->response_body, SOUP_MEMORY_COPY, junk, strlen (junk)); } }