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);
}
static void
gss_program_jpeg_resource (GssTransaction * t)
{
GssProgram *program = (GssProgram *) t->resource->priv;
GstBuffer *buffer = NULL;
if (!program->enable_streaming || program->state != GSS_PROGRAM_STATE_RUNNING) {
soup_message_set_status (t->msg, SOUP_STATUS_NO_CONTENT);
return;
}
if (program->jpegsink) {
g_object_get (program->jpegsink, "last-buffer", &buffer, NULL);
}
if (buffer) {
soup_message_set_status (t->msg, SOUP_STATUS_OK);
soup_message_set_response (t->msg, "image/jpeg", SOUP_MEMORY_COPY,
(void *) GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer));
gst_buffer_unref (buffer);
} else {
gss_html_error_404 (t->server, t->msg);
}
}
static void
server_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *context, gpointer data)
{
SlowData *sd;
if (msg->method != SOUP_METHOD_GET) {
soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
soup_message_set_status (msg, SOUP_STATUS_OK);
if (!strcmp (path, "/fast")) {
soup_message_set_response (msg, "text/plain",
SOUP_MEMORY_STATIC, "OK\r\n", 4);
return;
}
soup_message_headers_set_encoding (msg->response_headers,
SOUP_ENCODING_CHUNKED);
g_object_ref (msg);
soup_server_pause_message (server, msg);
sd = g_new (SlowData, 1);
sd->server = server;
sd->msg = msg;
sd->timeout = soup_add_timeout (
soup_server_get_async_context (server),
200, add_body_chunk, sd);
g_signal_connect (msg, "finished",
G_CALLBACK (request_failed), sd);
}
static void
serverCallback(SoupServer* server, SoupMessage* message, const char* path, GHashTable* query, SoupClientContext* context, void* data)
{
if (message->method != SOUP_METHOD_GET) {
soup_message_set_status(message, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
if (g_str_equal(path, "/favicon.ico")) {
soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
soup_message_body_complete(message->response_body);
return;
}
char* contents;
gsize length;
if (g_str_equal(path, "/icon/favicon.ico")) {
GUniquePtr<char> pathToFavicon(g_build_filename(Test::getResourcesDir().data(), "blank.ico", nullptr));
g_file_get_contents(pathToFavicon.get(), &contents, &length, 0);
soup_message_body_append(message->response_body, SOUP_MEMORY_TAKE, contents, length);
} else if (g_str_equal(path, "/nofavicon")) {
static const char* noFaviconHTML = "<html><head><body>test</body></html>";
soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, noFaviconHTML, strlen(noFaviconHTML));
} else {
static const char* contentsHTML = "<html><head><link rel='icon' href='/icon/favicon.ico' type='image/x-ico; charset=binary'></head><body>test</body></html>";
soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, contentsHTML, strlen(contentsHTML));
}
soup_message_set_status(message, SOUP_STATUS_OK);
soup_message_body_complete(message->response_body);
}
void get(SoupServer *server,
SoupMessage *msg,
const char *path)
{
struct btval key, val;
key.data = (void*)path+1;
key.size = strlen(path)-1;
key.free_data = FALSE;
key.mp = NULL;
g_debug ("GET\n Path=%s\n Fetching key %s", path, (char*)key.data);
const struct btree_stat *stat = btree_stat(btree);
show_dbstats("",stat);
if (0 == btree_get(btree,&key,&val)) {
g_debug ("hmm %s", (char*)val.data);
GVariant *gv = g_variant_new_from_data(G_VARIANT_TYPE_VARIANT, val.data, val.size, TRUE, NULL, NULL);
char *debug = g_variant_print (gv, TRUE);
g_debug ("converted to %s", debug);
g_free (debug);
g_variant_unref(gv);
soup_message_set_status (msg, SOUP_STATUS_OK);
} else {
soup_message_set_status (msg, SOUP_STATUS_NOT_FOUND);
}
// soup_message_set_response (msg, "application/json", SOUP_MEMORY_STATIC,
// );
}
static void
serverCallback(SoupServer *server, SoupMessage *message, const char *path, GHashTable *query, SoupClientContext *context, void *data)
{
if (message->method != SOUP_METHOD_GET) {
soup_message_set_status(message, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
soup_message_set_status(message, SOUP_STATUS_OK);
char *contents;
gsize length;
if (g_str_equal(path, "/favicon.ico")) {
GError *error = NULL;
g_file_get_contents("blank.ico", &contents, &length, &error);
g_assert(!error);
} else {
contents = g_strdup("<html><body>test</body></html>");
length = strlen(contents);
}
soup_message_body_append(message->response_body, SOUP_MEMORY_TAKE, contents, length);
soup_message_body_complete(message->response_body);
}
static void
tunnel_connected_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
Tunnel *tunnel = user_data;
GError *error = NULL;
tunnel->server.iostream = (GIOStream *)
g_socket_client_connect_to_host_finish (G_SOCKET_CLIENT (object), result, &error);
if (!tunnel->server.iostream) {
soup_message_set_status (tunnel->msg, SOUP_STATUS_BAD_GATEWAY);
soup_message_set_response (tunnel->msg, "text/plain",
SOUP_MEMORY_COPY,
error->message, strlen (error->message));
g_error_free (error);
soup_server_unpause_message (tunnel->self, tunnel->msg);
tunnel_close (tunnel);
return;
}
tunnel->server.istream = g_io_stream_get_input_stream (tunnel->server.iostream);
tunnel->server.ostream = g_io_stream_get_output_stream (tunnel->server.iostream);
soup_message_set_status (tunnel->msg, SOUP_STATUS_OK);
soup_server_unpause_message (tunnel->self, tunnel->msg);
g_signal_connect (tunnel->msg, "finished",
G_CALLBACK (start_tunnel), tunnel);
}
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);
}
}
void serverHandleStatic(SoupServer *server,
SoupMessage *msg,
const char *path,
GHashTable *query,
SoupClientContext *client,
gpointer user_data)
{
gchar *current_dir = g_get_current_dir();
gchar full_file_path[256];
sprintf(full_file_path, "%s%s", current_dir, path);
bool ok = false;
//TODO: reject .. in path
int fd = open(full_file_path, O_RDONLY);
if(fd != -1) {
struct stat sstat;
if(fstat(fd, &sstat) != -1) {
size_t len = (size_t)sstat.st_size;
void *addr = mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
if(addr != MAP_FAILED) {
const gchar *content_type = getContentType(path);
soup_message_set_response(msg, content_type, SOUP_MEMORY_COPY, addr, len);
soup_message_set_status(msg, 200);
fprintf(stderr, "GET: %s, size is %ld, type is '%s'\n", full_file_path, len, content_type);
ok = true;
}
}
close(fd);
}
if(!ok) {
soup_message_set_status(msg, 404);
fprintf(stderr, "ERROR: %s\n", full_file_path);
}
}
/* For real request testing */
static void
server_callback(SoupServer* server, SoupMessage* msg,
const char* path, GHashTable* query,
SoupClientContext* context, gpointer data)
{
if (msg->method != SOUP_METHOD_GET) {
soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
soup_message_set_status(msg, SOUP_STATUS_OK);
if (g_str_equal(path, "/favicon.ico")) {
char* contents;
gsize length;
GError* error = NULL;
g_file_get_contents("blank.ico", &contents, &length, &error);
g_assert(!error);
soup_message_body_append(msg->response_body, SOUP_MEMORY_TAKE, contents, length);
} else if (g_str_equal(path, "/bigdiv.html")) {
char* contents = g_strdup("<html><body><div style=\"background-color: green; height: 1200px;\"></div></body></html>");
soup_message_body_append(msg->response_body, SOUP_MEMORY_TAKE, contents, strlen(contents));
} else if (g_str_equal(path, "/iframe.html")) {
char* contents = g_strdup("<html><body><div style=\"background-color: green; height: 50px;\"></div><iframe src=\"bigdiv.html\"></iframe></body></html>");
soup_message_body_append(msg->response_body, SOUP_MEMORY_TAKE, contents, strlen(contents));
} else {
char* contents = g_strdup("<html><body>test</body></html>");
soup_message_body_append(msg->response_body, SOUP_MEMORY_TAKE, contents, strlen(contents));
}
soup_message_body_complete(msg->response_body);
}
static void httpServerCallback(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, "/test-script")) {
GOwnPtr<char> pathToFile(g_build_filename(Test::getResourcesDir().data(), "link-title.js", NULL));
char* contents;
gsize length;
g_file_get_contents(pathToFile.get(), &contents, &length, 0);
soup_message_body_append(message->response_body, SOUP_MEMORY_TAKE, contents, length);
soup_message_set_status(message, SOUP_STATUS_OK);
soup_message_body_complete(message->response_body);
} else if (g_str_equal(path, "/test-image")) {
GOwnPtr<char> pathToFile(g_build_filename(Test::getWebKit1TestResoucesDir().data(), "blank.ico", NULL));
char* contents;
gsize length;
g_file_get_contents(pathToFile.get(), &contents, &length, 0);
soup_message_body_append(message->response_body, SOUP_MEMORY_TAKE, contents, length);
soup_message_set_status(message, SOUP_STATUS_OK);
soup_message_body_complete(message->response_body);
} else
soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
}
/* For real request testing */
static void
server_callback(SoupServer* server, SoupMessage* msg,
const char* path, GHashTable* query,
SoupClientContext* context, gpointer data)
{
if (msg->method != SOUP_METHOD_GET) {
soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
soup_message_set_status(msg, SOUP_STATUS_OK);
if (g_str_equal(path, "/test_loading_status") || g_str_equal(path, "/test_loading_status2"))
soup_message_body_append(msg->response_body, SOUP_MEMORY_STATIC, HTML_STRING, strlen(HTML_STRING));
else if (g_str_equal(path, "/test_load_error")) {
soup_message_set_status(msg, SOUP_STATUS_CANT_CONNECT);
} else if (g_str_equal(path, "/test_loading_cancelled")) {
soup_message_headers_set_encoding(msg->response_headers, SOUP_ENCODING_CHUNKED);
soup_message_body_append(msg->response_body, SOUP_MEMORY_STATIC, HTML_STRING, strlen(HTML_STRING));
soup_server_unpause_message(server, msg);
return;
}
soup_message_body_complete(msg->response_body);
}
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);
}
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;
}
static void
process_image_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *context, gpointer user_data) {
UiConnection *self = (UiConnection *)user_data;
// Lookup network
Network *network = NULL;
{
const gchar *graph_id = g_hash_table_lookup(query, "graph");
network = (graph_id) ? g_hash_table_lookup(self->network_map, graph_id) : NULL;
}
if (!network) {
soup_message_set_status_full(msg, SOUP_STATUS_BAD_REQUEST, "'graph' not specified or wrong");
return;
}
// Lookup node
Processor *processor = NULL;
{
const gchar *node_id = g_hash_table_lookup(query, "node");
processor = (node_id) ? network_processor(network, node_id) : NULL;
}
if (!processor) {
soup_message_set_status_full(msg, SOUP_STATUS_BAD_REQUEST, "'node' not specified or wrong");
return;
}
// Render output
// FIXME: allow region-of-interest and scale as query params
gchar *rgba = NULL;
GeglRectangle roi;
const gboolean success = processor_blit(processor, babl_format("R'G'B'A u8"), &roi, &rgba);
if (!success) {
soup_message_set_status(msg, SOUP_STATUS_BAD_REQUEST);
g_free(rgba);
return;
}
if (!(roi.width > 0 && roi.height > 0)) {
soup_message_set_status(msg, SOUP_STATUS_BAD_REQUEST);
g_free(rgba);
return;
}
// Compress to PNG
{
PngEncoder *encoder = png_encoder_new();
png_encoder_encode_rgba(encoder, roi.width, roi.height, rgba);
char *png = encoder->buffer;
const size_t len = encoder->size;
soup_message_set_status(msg, SOUP_STATUS_OK);
soup_message_set_response(msg, "image/png", SOUP_MEMORY_COPY, png, len);
png_encoder_free(encoder);
}
}
static void prv_soup_server_cb(SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *client, gpointer user_data)
{
rsu_host_file_t *hf;
rsu_host_server_t *hs = user_data;
const gchar *file_name;
SoupMessageHeaders *hdrs;
if (msg->method != SOUP_METHOD_GET) {
soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
goto on_error;
}
hf = prv_host_server_find_file(hs, path, &file_name);
if (!hf) {
soup_message_set_status(msg, SOUP_STATUS_NOT_FOUND);
goto on_error;
}
if (hf->mapped_file) {
g_mapped_file_ref(hf->mapped_file);
++hf->mapped_count;
} else {
hf->mapped_file = g_mapped_file_new(file_name, FALSE, NULL);
if (!hf->mapped_file) {
soup_message_set_status(msg, SOUP_STATUS_NOT_FOUND);
goto on_error;
}
hf->mapped_count = 1;
}
g_signal_connect(msg, "finished",
G_CALLBACK(prv_soup_message_finished_cb), hf);
g_object_get(msg, "response-headers", &hdrs, NULL);
/* TODO: Need to add the relevant DLNA headers */
/* soup_message_headers_append(hdrs, "contentFeatures.dlna.org",
"DLNA.ORG_PN=PNG_LRG;DLNA.ORG_OP=01;"DLNA.ORG_FLAGS=00f00000000000000000000000000000");
soup_message_headers_append(hdrs, "Connection", "close");
*/
soup_message_set_status(msg, SOUP_STATUS_OK);
soup_message_set_response(msg, hf->mime_type, SOUP_MEMORY_STATIC,
g_mapped_file_get_contents(hf->mapped_file),
g_mapped_file_get_length(hf->mapped_file));
on_error:
return;
}
/* For real request testing */
static void
server_callback(SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *context, gpointer data)
{
if (msg->method != SOUP_METHOD_GET) {
soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
soup_message_set_status(msg, SOUP_STATUS_OK);
/* PDF */
if (g_str_equal(path, "/pdf")) {
char* contents;
gsize length;
GError* error = NULL;
g_file_get_contents("test.pdf", &contents, &length, &error);
g_assert(!error);
soup_message_body_append(msg->response_body, SOUP_MEMORY_TAKE, contents, length);
} else if (g_str_equal(path, "/html")) {
char* contents;
gsize length;
GError* error = NULL;
g_file_get_contents("test.html", &contents, &length, &error);
g_assert(!error);
soup_message_body_append(msg->response_body, SOUP_MEMORY_TAKE, contents, length);
} else if (g_str_equal(path, "/text")) {
char* contents;
gsize length;
GError* error = NULL;
soup_message_headers_append(msg->response_headers, "Content-Disposition", "attachment; filename=test.txt");
g_file_get_contents("test.txt", &contents, &length, &error);
g_assert(!error);
soup_message_body_append(msg->response_body, SOUP_MEMORY_TAKE, contents, length);
} else if (g_str_equal(path, "/ogg")) {
char* contents;
gsize length;
GError* error = NULL;
g_file_get_contents("test.ogg", &contents, &length, &error);
g_assert(!error);
soup_message_body_append(msg->response_body, SOUP_MEMORY_TAKE, contents, length);
}
soup_message_body_complete(msg->response_body);
}
static void
tunnel_message_completed (SoupMessage *msg, gpointer user_data)
{
SoupMessageQueueItem *item = user_data;
SoupSession *session = item->session;
if (item->state == SOUP_MESSAGE_RESTARTING) {
soup_message_restarted (msg);
if (item->conn) {
soup_session_send_queue_item (session, item, tunnel_message_completed);
return;
}
soup_message_set_status (msg, SOUP_STATUS_TRY_AGAIN);
}
item->state = SOUP_MESSAGE_FINISHED;
if (!SOUP_STATUS_IS_SUCCESSFUL (msg->status_code)) {
if (item->conn)
soup_connection_disconnect (item->conn);
if (msg->status_code == SOUP_STATUS_TRY_AGAIN) {
item->related->state = SOUP_MESSAGE_AWAITING_CONNECTION;
g_object_unref (item->related->conn);
item->related->conn = NULL;
} else
soup_message_set_status (item->related->msg, msg->status_code);
goto done;
}
if (!soup_connection_start_ssl (item->conn)) {
if (item->conn)
soup_connection_disconnect (item->conn);
soup_message_set_status (item->related->msg, SOUP_STATUS_SSL_FAILED);
goto done;
}
g_signal_connect (item->conn, "disconnected",
G_CALLBACK (connection_closed), item->session);
soup_connection_set_state (item->conn, SOUP_CONNECTION_IDLE);
soup_connection_set_state (item->conn, SOUP_CONNECTION_IN_USE);
item->related->state = SOUP_MESSAGE_READY;
done:
soup_message_finished (msg);
if (item->related->msg->status_code)
item->related->state = SOUP_MESSAGE_FINISHING;
do_idle_run_queue (item->session);
soup_message_queue_item_unref (item->related);
soup_session_unqueue_item (session, item);
soup_message_queue_item_unref (item);
g_object_unref (session);
}
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
hello_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *context, gpointer data)
{
char *title, *name, *fmt;
const char *content_type;
GString *buf;
if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_HEAD) {
soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
if (query) {
title = g_hash_table_lookup (query, "title");
name = g_hash_table_lookup (query, "n@me");
fmt = g_hash_table_lookup (query, "fmt");
} else
title = name = fmt = NULL;
buf = g_string_new (NULL);
if (!query || (fmt && !strcmp (fmt, "html"))) {
content_type = "text/html";
g_string_append (buf, "<html><head><title>forms-test: hello</title></head><body>\r\n");
if (title && name) {
/* mumble mumble html-escape... */
g_string_append_printf (buf, "<p>Hello, <b><em>%s</em> %s</b></p>\r\n",
title, name);
}
g_string_append (buf, "<form action='/hello' method='get'>"
"<p>Title: <input name='title'></p>"
"<p>Name: <input name='n@me'></p>"
"<p><input type=hidden name='fmt' value='html'></p>"
"<p><input type=submit></p>"
"</form>\r\n");
g_string_append (buf, "</body></html>\r\n");
} else {
content_type = "text/plain";
if (title && name) {
char *uptitle = g_ascii_strup (title, -1);
g_string_append_printf (buf, "Hello, %s %s",
uptitle, name);
g_free (uptitle);
}
}
soup_message_set_response (msg, content_type,
SOUP_MEMORY_TAKE,
buf->str, buf->len);
g_string_free (buf, FALSE);
soup_message_set_status (msg, SOUP_STATUS_OK);
}
static void
soup_rpc_callback (SoupServerContext *context, SoupMessage *msg, gpointer data)
{
xmlrpc_env env;
xmlrpc_mem_block *output;
const char *username;
RCDIdentity *identity = NULL;
RCDRPCMethodData *method_data;
xmlrpc_env_init (&env);
method_data = g_new0 (RCDRPCMethodData, 1);
/* Get the username from the auth context and get its identity */
username = soup_server_auth_get_user (context->auth);
if (strcmp (username, rcd_prefs_get_mid ()) == 0) {
identity = rcd_identity_new ();
identity->username = g_strdup ("server");
identity->privileges = rcd_privileges_from_string ("superuser");
}
else
identity = rcd_identity_lookup (username);
g_assert (identity != NULL);
method_data->host = soup_server_context_get_client_host (context);
method_data->identity = identity;
output = process_rpc_call (
&env, msg->request.body, msg->request.length, method_data);
rcd_identity_free (method_data->identity);
g_free (method_data);
soup_message_add_header (msg->response_headers,
"Server", "Red Carpet Daemon/"VERSION);
if (env.fault_occurred) {
soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST);
return;
}
/* Let Soup free the data for us */
msg->response.owner = SOUP_BUFFER_SYSTEM_OWNED;
msg->response.length = XMLRPC_TYPED_MEM_BLOCK_SIZE(char, output);
msg->response.body = g_memdup(
XMLRPC_TYPED_MEM_BLOCK_CONTENTS(char, output), msg->response.length);
soup_message_set_status (msg, SOUP_STATUS_OK);
xmlrpc_mem_block_free(output);
} /* soup_rpc_callback */
void serverHandleJournal(SoupServer *server,
SoupMessage *msg,
const char *path,
GHashTable *query,
SoupClientContext *client,
gpointer user_data)
{
bool ok = false;
if(strcmp(path, "/journal/journal.html") == 0) {
GDBusProxy *journal = g_dbus_proxy_new_for_bus_sync(
G_BUS_TYPE_SESSION, G_DBUS_PROXY_FLAGS_NONE, NULL,
"org.laptop.sugar.DataStore",
"/org/laptop/sugar/DataStore",
"org.laptop.sugar.DataStore",
NULL, NULL);
GVariant *params = g_variant_new("(a{sv}as)", NULL, NULL);
GError *error = NULL;
GVariant *result = g_dbus_proxy_call_sync(
journal, "find", params, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if(error != NULL) {fprintf(stderr, "error: %d, %d, %s\n", error->domain, error->code, error->message);}
if(result != NULL) {
soup_message_headers_replace(msg->response_headers, "Content-Type", "text/html");
append(msg, "<html><body>");
GVariant *results = NULL;
guint32 count = -1;
g_variant_get(result, "(@aa{sv}u)", &results, &count);
GVariant *dictionary = NULL;
GVariantIter results_iter;
g_variant_iter_init(&results_iter, results);
while (g_variant_iter_loop(&results_iter, "@a{sv}", &dictionary)) {
append(msg, "<p><a href='");
append(msg, lookup(dictionary, "uid", "invalid object id"));
append(msg, "'>");
append(msg, lookup(dictionary, "title", "invalid title"));
append(msg, "</a></p>");
}
append(msg, "</body></html>");
soup_message_set_status(msg, 200);
fprintf(stderr, "GET: %s\n", path);
ok = true;
}
}
if(!ok) {
soup_message_set_status(msg, 404);
fprintf(stderr, "ERROR: %s\n", path);
}
}
static void
gss_program_jpeg_resource (GssTransaction * t)
{
GssProgram *program = (GssProgram *) t->resource->priv;
#if GST_CHECK_VERSION(1,0,0)
GstSample *sample = NULL;
#endif
GstBuffer *buffer = NULL;
if (!program->enable_streaming || program->state != GSS_PROGRAM_STATE_RUNNING) {
soup_message_set_status (t->msg, SOUP_STATUS_NO_CONTENT);
return;
}
#if GST_CHECK_VERSION(1,0,0)
if (program->jpegsink) {
g_object_get (program->jpegsink, "last-sample", &sample, NULL);
}
if (sample) {
GstMapInfo mapinfo;
buffer = gst_sample_get_buffer (sample);
if (buffer) {
soup_message_set_status (t->msg, SOUP_STATUS_OK);
gst_buffer_map (buffer, &mapinfo, GST_MAP_READ);
soup_message_set_response (t->msg, "image/jpeg", SOUP_MEMORY_COPY,
(char *) mapinfo.data, mapinfo.size);
gst_buffer_unmap (buffer, &mapinfo);
}
gst_sample_unref (sample);
return;
}
#else
if (program->jpegsink) {
g_object_get (program->jpegsink, "last-buffer", &buffer, NULL);
}
if (buffer) {
soup_message_set_status (t->msg, SOUP_STATUS_OK);
soup_message_set_response (t->msg, "image/jpeg", SOUP_MEMORY_COPY,
(char *) GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer));
gst_buffer_unref (buffer);
return;
}
#endif
gss_html_error_404 (t->server, t->msg);
}
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));
}
}
static void serverCallback(SoupServer* server, SoupMessage* msg, const char* path, GHashTable* query, SoupClientContext* context, gpointer data)
{
if (msg->method != SOUP_METHOD_GET) {
soup_message_set_status(msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
soup_message_set_status(msg, SOUP_STATUS_OK);
char* body = g_strdup_printf("<html><title>%s</title><body>%s</body></html>", path + 1, path + 1);
soup_message_body_append(msg->response_body, SOUP_MEMORY_TAKE, body, strlen(body));
soup_message_body_complete(msg->response_body);
}
static void
md5_post_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *context, gpointer data)
{
const char *content_type;
GHashTable *params;
const char *fmt;
char *filename, *md5sum, *redirect_uri;
SoupBuffer *file;
SoupURI *uri;
content_type = soup_message_headers_get_content_type (msg->request_headers, NULL);
if (!content_type || strcmp (content_type, "multipart/form-data") != 0) {
soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST);
return;
}
params = soup_form_decode_multipart (msg, "file",
&filename, NULL, &file);
if (!params) {
soup_message_set_status (msg, SOUP_STATUS_BAD_REQUEST);
return;
}
fmt = g_hash_table_lookup (params, "fmt");
md5sum = g_compute_checksum_for_data (G_CHECKSUM_MD5,
(gpointer)file->data,
file->length);
soup_buffer_free (file);
uri = soup_uri_copy (soup_message_get_uri (msg));
soup_uri_set_query_from_fields (uri,
"file", filename ? filename : "",
"md5sum", md5sum,
"fmt", fmt ? fmt : "html",
NULL);
redirect_uri = soup_uri_to_string (uri, FALSE);
soup_message_set_status (msg, SOUP_STATUS_SEE_OTHER);
soup_message_headers_replace (msg->response_headers, "Location",
redirect_uri);
g_free (redirect_uri);
soup_uri_free (uri);
g_free (md5sum);
g_free (filename);
g_hash_table_destroy (params);
}
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
soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
}
static void
server_callback (SoupServer *server, SoupMessage *msg,
const char *path, GHashTable *query,
SoupClientContext *context, gpointer data)
{
if (msg->method != SOUP_METHOD_GET && msg->method != SOUP_METHOD_HEAD) {
soup_message_set_status (msg, SOUP_STATUS_NOT_IMPLEMENTED);
return;
}
soup_message_set_response (msg, "text/plain",
SOUP_MEMORY_STATIC,
"OK\r\n", 4);
soup_message_set_status (msg, SOUP_STATUS_OK);
}
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, "/")) {
static const char* responseString = "<html><body>Testing!</body></html>";
soup_message_set_status(message, SOUP_STATUS_OK);
soup_message_body_append(message->response_body, SOUP_MEMORY_STATIC, responseString, strlen(responseString));
soup_message_body_complete(message->response_body);
} else
soup_message_set_status(message, SOUP_STATUS_NOT_FOUND);
}
void
dacp_share_login (DMAPShare * share,
SoupServer * server,
SoupMessage * message,
const char *path,
GHashTable * query, SoupClientContext * context)
{
gchar *pairing_guid;
g_debug ("(DACP) Path is %s.", path);
if (query) {
g_hash_table_foreach (query, debug_param, NULL);
}
pairing_guid = g_hash_table_lookup (query, "pairing-guid");
if (pairing_guid != NULL) {
gboolean allow_login;
g_signal_emit (share, signals[LOOKUP_GUID], 0, pairing_guid,
&allow_login);
if (!allow_login) {
g_debug ("Unknown remote trying to connect");
soup_message_set_status (message,
SOUP_STATUS_FORBIDDEN);
return;
}
}
_dmap_share_login (share, server, message, path, query, context);
}
