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