static SoupURI *
uri_from_address (SoupAddress *addr)
{
SoupURI *proxy_uri;
proxy_uri = soup_uri_new (NULL);
soup_uri_set_scheme (proxy_uri, SOUP_URI_SCHEME_HTTP);
soup_uri_set_host (proxy_uri, soup_address_get_name (addr));
soup_uri_set_port (proxy_uri, soup_address_get_port (addr));
return proxy_uri;
}
static GObject *
constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GObject *server;
SoupServerPrivate *priv;
server = G_OBJECT_CLASS (soup_server_parent_class)->constructor (
type, n_construct_properties, construct_properties);
if (!server)
return NULL;
priv = SOUP_SERVER_GET_PRIVATE (server);
if (!priv->interface) {
priv->interface =
soup_address_new_any (SOUP_ADDRESS_FAMILY_IPV4,
priv->port);
}
if (priv->ssl_cert_file && priv->ssl_key_file) {
priv->ssl_creds = soup_ssl_get_server_credentials (
priv->ssl_cert_file,
priv->ssl_key_file);
if (!priv->ssl_creds) {
g_object_unref (server);
return NULL;
}
}
priv->listen_sock =
soup_socket_new (SOUP_SOCKET_LOCAL_ADDRESS, priv->interface,
SOUP_SOCKET_SSL_CREDENTIALS, priv->ssl_creds,
SOUP_SOCKET_ASYNC_CONTEXT, priv->async_context,
NULL);
if (!soup_socket_listen (priv->listen_sock)) {
g_object_unref (server);
return NULL;
}
/* Re-resolve the interface address, in particular in case
* the passed-in address had SOUP_ADDRESS_ANY_PORT.
*/
g_object_unref (priv->interface);
priv->interface = soup_socket_get_local_address (priv->listen_sock);
g_object_ref (priv->interface);
priv->port = soup_address_get_port (priv->interface);
return server;
}
const gchar *
soupcut_server_build_uri(SoupServer *server,
const gchar *path)
{
SoupAddress *address;
SoupURI *uri;
const gchar *uri_string;
g_object_get(server,
SOUP_SERVER_INTERFACE, &address,
NULL);
uri = soup_uri_new(NULL);
soup_uri_set_scheme(uri, SOUP_URI_SCHEME_HTTP);
soup_uri_set_host(uri, "localhost");
soup_uri_set_port(uri, soup_address_get_port(address));
soup_uri_set_path(uri, path);
uri_string = cut_take_string(soup_uri_to_string(uri, FALSE));
soup_uri_free(uri);
return uri_string;
}
SoupMessageQueueItem *
soup_session_make_connect_message (SoupSession *session,
SoupAddress *server_addr)
{
SoupSessionPrivate *priv = SOUP_SESSION_GET_PRIVATE (session);
SoupURI *uri;
SoupMessage *msg;
uri = soup_uri_new (NULL);
soup_uri_set_scheme (uri, SOUP_URI_SCHEME_HTTPS);
soup_uri_set_host (uri, soup_address_get_name (server_addr));
soup_uri_set_port (uri, soup_address_get_port (server_addr));
soup_uri_set_path (uri, "");
msg = soup_message_new_from_uri (SOUP_METHOD_CONNECT, uri);
soup_message_set_flags (msg, SOUP_MESSAGE_NO_REDIRECT);
soup_uri_free (uri);
/* Call the base implementation of soup_session_queue_message
* directly, to add msg to the SoupMessageQueue and cause all
* the right signals to be emitted.
*/
queue_message (session, msg, tunnel_connected, NULL);
return soup_message_queue_lookup (priv->queue, msg);
}
static guint
parse_request_headers (SoupMessage *msg, char *headers, guint headers_len,
SoupEncoding *encoding, gpointer sock)
{
SoupMessagePrivate *priv = SOUP_MESSAGE_GET_PRIVATE (msg);
char *req_method, *req_path, *url;
SoupHTTPVersion version;
const char *req_host;
guint status;
SoupURI *uri;
status = soup_headers_parse_request (headers, headers_len,
msg->request_headers,
&req_method,
&req_path,
&version);
if (!SOUP_STATUS_IS_SUCCESSFUL (status))
return status;
g_object_set (G_OBJECT (msg),
SOUP_MESSAGE_METHOD, req_method,
SOUP_MESSAGE_HTTP_VERSION, version,
NULL);
g_free (req_method);
/* Handle request body encoding */
*encoding = soup_message_headers_get_encoding (msg->request_headers);
if (*encoding == SOUP_ENCODING_UNRECOGNIZED) {
if (soup_message_headers_get_list (msg->request_headers, "Transfer-Encoding"))
return SOUP_STATUS_NOT_IMPLEMENTED;
else
return SOUP_STATUS_BAD_REQUEST;
}
/* Generate correct context for request */
req_host = soup_message_headers_get_one (msg->request_headers, "Host");
if (req_host && strchr (req_host, '/')) {
g_free (req_path);
return SOUP_STATUS_BAD_REQUEST;
}
if (!strcmp (req_path, "*") && req_host) {
/* Eg, "OPTIONS * HTTP/1.1" */
url = g_strdup_printf ("%s://%s",
soup_socket_is_ssl (sock) ? "https" : "http",
req_host);
uri = soup_uri_new (url);
if (uri)
soup_uri_set_path (uri, "*");
g_free (url);
} else if (*req_path != '/') {
/* Must be an absolute URI */
uri = soup_uri_new (req_path);
} else if (req_host) {
url = g_strdup_printf ("%s://%s%s",
soup_socket_is_ssl (sock) ? "https" : "http",
req_host, req_path);
uri = soup_uri_new (url);
g_free (url);
} else if (priv->http_version == SOUP_HTTP_1_0) {
/* No Host header, no AbsoluteUri */
SoupAddress *addr = soup_socket_get_local_address (sock);
uri = soup_uri_new (NULL);
soup_uri_set_scheme (uri, soup_socket_is_ssl (sock) ?
SOUP_URI_SCHEME_HTTPS :
SOUP_URI_SCHEME_HTTP);
soup_uri_set_host (uri, soup_address_get_physical (addr));
soup_uri_set_port (uri, soup_address_get_port (addr));
soup_uri_set_path (uri, req_path);
} else
uri = NULL;
g_free (req_path);
if (!SOUP_URI_VALID_FOR_HTTP (uri)) {
/* certainly not "a valid host on the server" (RFC2616 5.2.3)
* SOUP_URI_VALID_FOR_HTTP also guards against uri == NULL
*/
if (uri)
soup_uri_free (uri);
return SOUP_STATUS_BAD_REQUEST;
}
soup_message_set_uri (msg, uri);
soup_uri_free (uri);
return SOUP_STATUS_OK;
}
