static void
do_get (OtTrivialHttpd *self,
SoupServer *server,
SoupMessage *msg,
const char *path,
SoupClientContext *context)
{
char *slash;
int ret;
struct stat stbuf;
httpd_log (self, "serving %s\n", path);
if (opt_expected_cookies)
{
GSList *cookies = soup_cookies_from_request (msg);
GSList *l;
int i;
for (i = 0 ; opt_expected_cookies[i] != NULL; i++)
{
gboolean found = FALSE;
gchar *k = opt_expected_cookies[i];
gchar *v = strchr (k, '=') + 1;
for (l = cookies; l != NULL ; l = g_slist_next (l))
{
SoupCookie *c = l->data;
if (!strncmp (k, soup_cookie_get_name (c), v - k - 1) &&
!strcmp (v, soup_cookie_get_value (c)))
{
found = TRUE;
break;
}
}
if (!found)
{
httpd_log (self, "Expected cookie not found %s\n", k);
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
soup_cookies_free (cookies);
goto out;
}
}
soup_cookies_free (cookies);
}
if (opt_expected_headers)
{
for (int i = 0 ; opt_expected_headers[i] != NULL; i++)
{
const gchar *kv = opt_expected_headers[i];
const gchar *eq = strchr (kv, '=');
g_assert (eq);
{
g_autofree char *k = g_strndup (kv, eq - kv);
const gchar *expected_v = eq + 1;
const gchar *found_v = soup_message_headers_get_one (msg->request_headers, k);
if (!found_v)
{
httpd_log (self, "Expected header not found %s\n", k);
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
if (strcmp (found_v, expected_v) != 0)
{
httpd_log (self, "Expected header %s: %s but found %s\n", k, expected_v, found_v);
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
}
}
}
if (strstr (path, "../") != NULL)
{
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
if (opt_random_500s_percentage > 0 &&
emitted_random_500s_count < opt_random_500s_max &&
g_random_int_range (0, 100) < opt_random_500s_percentage)
{
emitted_random_500s_count++;
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
while (path[0] == '/')
path++;
do
ret = fstatat (self->root_dfd, path, &stbuf, 0);
while (ret == -1 && errno == EINTR);
if (ret == -1)
{
if (errno == EPERM)
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
else if (errno == ENOENT)
soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
else
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
if (!is_safe_to_access (&stbuf))
{
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
if (S_ISDIR (stbuf.st_mode))
{
slash = strrchr (path, '/');
if (!slash || slash[1])
{
g_autofree char *redir_uri = NULL;
redir_uri = g_strdup_printf ("%s/", soup_message_get_uri (msg)->path);
soup_message_set_redirect (msg, SOUP_STATUS_MOVED_PERMANENTLY,
redir_uri);
}
else
{
g_autofree char *index_realpath = g_strconcat (path, "/index.html", NULL);
if (fstatat (self->root_dfd, index_realpath, &stbuf, 0) != -1)
{
g_autofree char *index_path = g_strconcat (path, "/index.html", NULL);
do_get (self, server, msg, index_path, context);
}
else
{
GString *listing = get_directory_listing (self->root_dfd, path);
soup_message_set_response (msg, "text/html",
SOUP_MEMORY_TAKE,
listing->str, listing->len);
soup_message_set_status (msg, SOUP_STATUS_OK);
g_string_free (listing, FALSE);
}
}
}
else
{
if (!S_ISREG (stbuf.st_mode))
{
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
if (msg->method == SOUP_METHOD_GET)
{
glnx_autofd int fd = -1;
g_autoptr(GMappedFile) mapping = NULL;
gsize buffer_length, file_size;
SoupRange *ranges;
int ranges_length;
gboolean have_ranges;
fd = openat (self->root_dfd, path, O_RDONLY | O_CLOEXEC);
if (fd < 0)
{
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
mapping = g_mapped_file_new_from_fd (fd, FALSE, NULL);
if (!mapping)
{
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
(void) close (fd); fd = -1;
file_size = g_mapped_file_get_length (mapping);
have_ranges = soup_message_headers_get_ranges(msg->request_headers, file_size, &ranges, &ranges_length);
if (opt_force_ranges && !have_ranges && g_strrstr (path, "/objects") != NULL)
{
SoupSocket *sock;
buffer_length = file_size/2;
soup_message_headers_set_content_length (msg->response_headers, file_size);
soup_message_headers_append (msg->response_headers,
"Connection", "close");
/* soup-message-io will wait for us to add
* another chunk after the first, to fill out
* the declared Content-Length. Instead, we
* forcibly close the socket at that point.
*/
sock = soup_client_context_get_socket (context);
g_signal_connect (msg, "wrote-chunk", G_CALLBACK (close_socket), sock);
}
else
buffer_length = file_size;
if (have_ranges)
{
if (ranges_length > 0 && ranges[0].start >= file_size)
{
soup_message_set_status (msg, SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE);
soup_message_headers_free_ranges (msg->request_headers, ranges);
goto out;
}
soup_message_headers_free_ranges (msg->request_headers, ranges);
}
if (buffer_length > 0)
{
SoupBuffer *buffer;
buffer = soup_buffer_new_with_owner (g_mapped_file_get_contents (mapping),
buffer_length,
g_mapped_file_ref (mapping),
(GDestroyNotify)g_mapped_file_unref);
soup_message_body_append_buffer (msg->response_body, buffer);
soup_buffer_free (buffer);
}
}
else /* msg->method == SOUP_METHOD_HEAD */
{
g_autofree char *length = NULL;
/* We could just use the same code for both GET and
* HEAD (soup-message-server-io.c will fix things up).
* But we'll optimize and avoid the extra I/O.
*/
length = g_strdup_printf ("%lu", (gulong)stbuf.st_size);
soup_message_headers_append (msg->response_headers,
"Content-Length", length);
}
soup_message_set_status (msg, SOUP_STATUS_OK);
}
out:
{
guint status = 0;
g_autofree gchar *reason = NULL;
g_object_get (msg,
"status-code", &status,
"reason-phrase", &reason,
NULL);
httpd_log (self, " status: %s (%u)\n", reason, status);
}
return;
}
static void
korva_upnp_file_server_handle_request (SoupServer *server,
SoupMessage *msg,
const char *path,
GHashTable *query,
SoupClientContext *client,
gpointer user_data)
{
KorvaUPnPFileServer *self = KORVA_UPNP_FILE_SERVER (user_data);
GMatchInfo *info;
char *id;
GFile *file;
KorvaUPnPHostData *data;
ServeData *serve_data;
SoupRange *ranges = NULL;
int length;
const char *content_features;
GError *error = NULL;
goffset size;
if (msg->method != SOUP_METHOD_HEAD &&
msg->method != SOUP_METHOD_GET) {
soup_message_set_status (msg, SOUP_STATUS_METHOD_NOT_ALLOWED);
return;
}
g_debug ("Got %s request for uri: %s", msg->method, path);
soup_message_headers_foreach (msg->request_headers, print_header, NULL);
soup_server_pause_message (server, msg);
soup_message_set_status (msg, SOUP_STATUS_OK);
if (!g_regex_match (self->priv->path_regex,
path,
0,
&info)) {
soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
g_match_info_free (info);
goto out;
}
id = g_match_info_fetch (info, 1);
g_match_info_free (info);
file = g_hash_table_lookup (self->priv->id_map, id);
g_free (id);
if (file == NULL) {
soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
goto out;
}
data = g_hash_table_lookup (self->priv->host_data, file);
if (data == NULL) {
soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
goto out;
}
if (!korva_upnp_host_data_valid_for_peer (data, soup_client_context_get_host (client))) {
soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
goto out;
}
serve_data = g_slice_new0 (ServeData);
serve_data->host_data = data;
g_object_add_weak_pointer (G_OBJECT (data), (gpointer *) &(serve_data->host_data));
korva_upnp_host_data_add_request (data);
size = korva_upnp_host_data_get_size (data);
if (soup_message_headers_get_ranges (msg->request_headers, size, &ranges, &length)) {
goffset start, end;
start = ranges[0].start;
end = ranges[0].end;
if (start > size || start > end || end > size) {
soup_message_set_status (msg, SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE);
g_slice_free (ServeData, serve_data);
goto out;
} else {
soup_message_set_status (msg, SOUP_STATUS_PARTIAL_CONTENT);
soup_message_headers_set_content_range (msg->response_headers, start, end, size);
}
serve_data->start = start;
serve_data->end = end;
} else {
serve_data->start = 0;
serve_data->end = size - 1;
soup_message_set_status (msg, SOUP_STATUS_OK);
}
soup_message_headers_set_content_length (msg->response_headers,
serve_data->end - serve_data->start + 1);
soup_message_headers_set_content_type (msg->response_headers,
korva_upnp_host_data_get_content_type (data),
NULL);
content_features = soup_message_headers_get_one (msg->request_headers,
"getContentFeatures.dlna.org");
if (content_features != NULL && atol (content_features) == 1) {
const GVariant *value;
value = korva_upnp_host_data_lookup_meta_data (data, "DLNAProfile");
if (value == NULL) {
soup_message_headers_append (msg->response_headers,
"contentFeatures.dlna.org", "*");
} else {
soup_message_headers_append (msg->response_headers,
"contentFeatures.dlna.org",
korva_upnp_host_data_get_protocol_info (data));
}
}
soup_message_headers_append (msg->response_headers, "Connection", "close");
g_debug ("Response headers:");
soup_message_headers_foreach (msg->response_headers, print_header, NULL);
if (g_ascii_strcasecmp (msg->method, "HEAD") == 0) {
g_debug ("Handled HEAD request of %s: %d", path, msg->status_code);
g_slice_free (ServeData, serve_data);
goto out;
}
soup_message_headers_set_encoding (msg->response_headers, SOUP_ENCODING_CONTENT_LENGTH);
soup_message_body_set_accumulate (msg->response_body, FALSE);
serve_data->stream = G_INPUT_STREAM (g_file_read (file, NULL, &error));
serve_data->server = server;
if (error != NULL) {
g_warning ("Failed to MMAP file %s: %s",
path,
error->message);
g_error_free (error);
g_slice_free (ServeData, serve_data);
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
g_seekable_seek (G_SEEKABLE (serve_data->stream), serve_data->start, G_SEEK_SET, NULL, NULL);
/* Drop timeout until the message is done */
korva_upnp_host_data_cancel_timeout (data);
g_signal_connect (msg,
"wrote-chunk",
G_CALLBACK (korva_upnp_file_server_on_wrote_chunk),
serve_data);
g_signal_connect (msg,
"wrote-headers",
G_CALLBACK (korva_upnp_file_server_on_wrote_chunk),
serve_data);
g_signal_connect (msg,
"finished",
G_CALLBACK (korva_upnp_file_server_on_finished),
serve_data);
out:
if (ranges != NULL) {
soup_message_headers_free_ranges (msg->request_headers, ranges);
}
soup_server_unpause_message (server, msg);
}
static void
gss_adaptive_resource_get_dash_range_fragment (GssTransaction * t,
GssAdaptive * adaptive, const char *path)
{
gboolean have_range;
SoupRange *ranges;
int n_ranges;
int index;
GssAdaptiveLevel *level;
gsize start, end;
/* skip over content/ */
path += 8;
if (path[0] != 'a' && path[0] != 'v') {
GST_ERROR ("bad path: %s", path);
return;
}
index = strtoul (path + 1, NULL, 10);
level = NULL;
if (path[0] == 'a') {
if (index < adaptive->n_audio_levels) {
level = &adaptive->audio_levels[index];
}
} else {
if (index < adaptive->n_video_levels) {
level = &adaptive->video_levels[index];
}
}
if (level == NULL) {
GST_ERROR ("bad level: %c%d from path %s", path[0], index, path);
return;
}
if (t->msg->method == SOUP_METHOD_HEAD) {
GST_DEBUG ("%s: HEAD", path);
soup_message_headers_set_content_length (t->msg->response_headers,
level->track->dash_size);
return;
}
have_range = soup_message_headers_get_ranges (t->msg->request_headers,
level->track->dash_size, &ranges, &n_ranges);
if (have_range) {
if (n_ranges != 1) {
GST_ERROR ("too many ranges");
}
start = ranges[0].start;
end = ranges[0].end + 1;
} else {
start = 0;
end = level->track->dash_size;
}
GST_DEBUG ("%s: range: %ld-%ld", path, start, end);
t->start = start;
t->end = end;
if (have_range) {
soup_message_headers_set_content_range (t->msg->response_headers,
ranges[0].start, ranges[0].end, level->track->dash_size);
soup_message_set_status (t->msg, SOUP_STATUS_PARTIAL_CONTENT);
soup_message_headers_free_ranges (t->msg->response_headers, ranges);
} else {
soup_message_set_status (t->msg, SOUP_STATUS_OK);
}
soup_message_headers_replace (t->msg->response_headers, "Content-Type",
(path[0] == 'v') ? "video/mp4" : "audio/mp4");
{
GssAdaptiveQuery *query;
soup_server_pause_message (t->soupserver, t->msg);
query = g_malloc0 (sizeof (GssAdaptiveQuery));
query->adaptive = adaptive;
query->level = level;
gss_transaction_process_async (t, gss_adaptive_dash_range_async,
gss_adaptive_dash_range_async_finish, query);
}
}
static void
handle_partial_get (SoupMessage *msg)
{
SoupRange *ranges;
int nranges;
SoupBuffer *full_response;
/* Make sure the message is set up right for us to return a
* partial response; it has to be a GET, the status must be
* 200 OK (and in particular, NOT already 206 Partial
* Content), and the SoupServer must have already filled in
* the response body
*/
if (msg->method != SOUP_METHOD_GET ||
msg->status_code != SOUP_STATUS_OK ||
soup_message_headers_get_encoding (msg->response_headers) !=
SOUP_ENCODING_CONTENT_LENGTH ||
msg->response_body->length == 0 ||
!soup_message_body_get_accumulate (msg->response_body))
return;
/* Oh, and there has to have been a valid Range header on the
* request, of course.
*/
if (!soup_message_headers_get_ranges (msg->request_headers,
msg->response_body->length,
&ranges, &nranges))
return;
full_response = soup_message_body_flatten (msg->response_body);
if (!full_response) {
soup_message_headers_free_ranges (msg->request_headers, ranges);
return;
}
soup_message_set_status (msg, SOUP_STATUS_PARTIAL_CONTENT);
soup_message_body_truncate (msg->response_body);
if (nranges == 1) {
SoupBuffer *range_buf;
/* Single range, so just set Content-Range and fix the body. */
soup_message_headers_set_content_range (msg->response_headers,
ranges[0].start,
ranges[0].end,
full_response->length);
range_buf = soup_buffer_new_subbuffer (full_response,
ranges[0].start,
ranges[0].end - ranges[0].start + 1);
soup_message_body_append_buffer (msg->response_body, range_buf);
soup_buffer_free (range_buf);
} else {
SoupMultipart *multipart;
SoupMessageHeaders *part_headers;
SoupBuffer *part_body;
const char *content_type;
int i;
/* Multiple ranges, so build a multipart/byteranges response
* to replace msg->response_body with.
*/
multipart = soup_multipart_new ("multipart/byteranges");
content_type = soup_message_headers_get_one (msg->response_headers,
"Content-Type");
for (i = 0; i < nranges; i++) {
part_headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_MULTIPART);
if (content_type) {
soup_message_headers_append (part_headers,
"Content-Type",
content_type);
}
soup_message_headers_set_content_range (part_headers,
ranges[i].start,
ranges[i].end,
full_response->length);
part_body = soup_buffer_new_subbuffer (full_response,
ranges[i].start,
ranges[i].end - ranges[i].start + 1);
soup_multipart_append_part (multipart, part_headers,
part_body);
soup_message_headers_free (part_headers);
soup_buffer_free (part_body);
}
soup_multipart_to_message (multipart, msg->response_headers,
msg->response_body);
soup_multipart_free (multipart);
}
soup_buffer_free (full_response);
soup_message_headers_free_ranges (msg->request_headers, ranges);
}
static void
do_get (OtTrivialHttpd *self,
SoupServer *server,
SoupMessage *msg,
const char *path,
SoupClientContext *context)
{
char *slash;
int ret;
struct stat stbuf;
g_autofree char *safepath = NULL;
httpd_log (self, "serving %s\n", path);
if (strstr (path, "../") != NULL)
{
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
if (opt_random_500s_percentage > 0 &&
emitted_random_500s_count < opt_random_500s_max &&
g_random_int_range (0, 100) < opt_random_500s_percentage)
{
emitted_random_500s_count++;
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
if (path[0] == '/')
path++;
safepath = g_build_filename (gs_file_get_path_cached (self->root), path, NULL);
do
ret = stat (safepath, &stbuf);
while (ret == -1 && errno == EINTR);
if (ret == -1)
{
if (errno == EPERM)
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
else if (errno == ENOENT)
soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
else
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
if (!is_safe_to_access (&stbuf))
{
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
if (S_ISDIR (stbuf.st_mode))
{
slash = strrchr (safepath, '/');
if (!slash || slash[1])
{
g_autofree char *redir_uri = NULL;
redir_uri = g_strdup_printf ("%s/", soup_message_get_uri (msg)->path);
soup_message_set_redirect (msg, SOUP_STATUS_MOVED_PERMANENTLY,
redir_uri);
}
else
{
g_autofree char *index_realpath = g_strconcat (safepath, "/index.html", NULL);
if (stat (index_realpath, &stbuf) != -1)
{
g_autofree char *index_path = g_strconcat (path, "/index.html", NULL);
do_get (self, server, msg, index_path, context);
}
else
{
GString *listing = get_directory_listing (safepath);
soup_message_set_response (msg, "text/html",
SOUP_MEMORY_TAKE,
listing->str, listing->len);
soup_message_set_status (msg, SOUP_STATUS_OK);
g_string_free (listing, FALSE);
}
}
}
else
{
if (!S_ISREG (stbuf.st_mode))
{
soup_message_set_status (msg, SOUP_STATUS_FORBIDDEN);
goto out;
}
if (msg->method == SOUP_METHOD_GET)
{
g_autoptr(GMappedFile) mapping = NULL;
gsize buffer_length, file_size;
SoupRange *ranges;
int ranges_length;
gboolean have_ranges;
mapping = g_mapped_file_new (safepath, FALSE, NULL);
if (!mapping)
{
soup_message_set_status (msg, SOUP_STATUS_INTERNAL_SERVER_ERROR);
goto out;
}
file_size = g_mapped_file_get_length (mapping);
have_ranges = soup_message_headers_get_ranges(msg->request_headers, file_size, &ranges, &ranges_length);
if (opt_force_ranges && !have_ranges && g_strrstr (path, "/objects") != NULL)
{
SoupSocket *sock;
buffer_length = file_size/2;
soup_message_headers_set_content_length (msg->response_headers, file_size);
soup_message_headers_append (msg->response_headers,
"Connection", "close");
/* soup-message-io will wait for us to add
* another chunk after the first, to fill out
* the declared Content-Length. Instead, we
* forcibly close the socket at that point.
*/
sock = soup_client_context_get_socket (context);
g_signal_connect (msg, "wrote-chunk", G_CALLBACK (close_socket), sock);
}
else
buffer_length = file_size;
if (have_ranges)
{
if (ranges_length > 0 && ranges[0].start >= file_size)
{
soup_message_set_status (msg, SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE);
soup_message_headers_free_ranges (msg->request_headers, ranges);
goto out;
}
soup_message_headers_free_ranges (msg->request_headers, ranges);
}
if (buffer_length > 0)
{
SoupBuffer *buffer;
buffer = soup_buffer_new_with_owner (g_mapped_file_get_contents (mapping),
buffer_length,
g_mapped_file_ref (mapping),
(GDestroyNotify)g_mapped_file_unref);
soup_message_body_append_buffer (msg->response_body, buffer);
soup_buffer_free (buffer);
}
}
else /* msg->method == SOUP_METHOD_HEAD */
{
g_autofree char *length = NULL;
/* We could just use the same code for both GET and
* HEAD (soup-message-server-io.c will fix things up).
* But we'll optimize and avoid the extra I/O.
*/
length = g_strdup_printf ("%lu", (gulong)stbuf.st_size);
soup_message_headers_append (msg->response_headers,
"Content-Length", length);
}
soup_message_set_status (msg, SOUP_STATUS_OK);
}
out:
{
guint status = 0;
g_autofree gchar *reason = NULL;
g_object_get (msg,
"status-code", &status,
"reason-phrase", &reason,
NULL);
httpd_log (self, " status: %s (%u)\n", reason, status);
}
return;
}
