libmicrohttpd demo

#include "web.h" #include "mytime.h" #include #include #include #include #include #include #include #include #include #include #include #include #define PAGE "libmicrohttpd demo"\ "libmicrohttpd demo" static void sqliteError(void *pArg, int iErrCode, const char *zMsg) { // @CLEANUP: We should stuff these somewhere, but for now just print it fprintf(stderr, "(%d) %s\n", iErrCode, zMsg); } struct PostCollector { char *data; size_t size; size_t capacity; }; struct Request { struct Server *server; struct PostCollector pp; }; void prepare_database(struct App *app) { // @CLEANUP: Move this to main? doesn't belong here at least sqlite3_config(SQLITE_CONFIG_LOG, sqliteError, NULL); sqlite3_config(SQLITE_CONFIG_URI, 1); int err; printf("Running migrations against %s\n", app->dbname); sqlite3 *conn; if((err = sqlite3_open(app->dbname, &conn)) != SQLITE_OK) { fprintf(stderr, "(%d) %s\n", err, sqlite3_errmsg(conn)); abort(); } sqlite3_db_config(conn, SQLITE_DBCONFIG_ENABLE_FKEY, 1, NULL); if(sqlite3_exec(conn, "CREATE TABLE IF NOT EXISTS migration (id INTEGER PRIMARY KEY NOT NULL)", NULL, NULL, NULL) != SQLITE_OK) { abort(); } sqlite3_stmt *stmt; if(sqlite3_prepare_v2(conn, "SELECT MAX(id) FROM migration", -1, &stmt, NULL) != SQLITE_OK) { abort(); } uint64_t maxVersion = 0; while((err = sqlite3_step(stmt)) == SQLITE_ROW) { maxVersion = sqlite3_column_int64(stmt, 0); } if(err != SQLITE_DONE) { abort(); } if(sqlite3_finalize(stmt) != SQLITE_OK) { abort(); } if(maxVersion < 1) { char *prog = "BEGIN TRANSACTION;" "CREATE TABLE backups (" "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " "client TEXT NOT NULL, " "status TEXT NOT NULL, " "started TEXT NOT NULL, " "completed TEXT " ") STRICT"; if(sqlite3_exec(conn, prog, NULL, NULL, NULL) != SQLITE_OK) { abort(); } sqlite3_stmt *stmt; if(sqlite3_prepare_v2(conn, "INSERT INTO migration (id) VALUES (?1)", -1, &stmt, NULL) != SQLITE_OK) { abort(); } if(sqlite3_bind_int64(stmt, 1, 1) != SQLITE_OK) { abort(); } if(sqlite3_step(stmt) != SQLITE_DONE) { abort(); } if(sqlite3_finalize(stmt) != SQLITE_OK) { abort(); } if(sqlite3_exec(conn, "COMMIT TRANSACTION", NULL, NULL, NULL) != SQLITE_OK) { abort(); } } if(maxVersion < 2) { char *prog = "BEGIN TRANSACTION;" "CREATE TABLE clients (" "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " "name TEXT NOT NULL " ") STRICT;" "INSERT INTO clients(name) " "SELECT b.client " "FROM backups b " "GROUP BY b.client;" "CREATE TABLE backups_next (" "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, " "client INTEGER NOT NULL, " "status TEXT NOT NULL, " "started TEXT NOT NULL, " "completed TEXT ," "FOREIGN KEY(client) REFERENCES clients(id)" ") STRICT;" "INSERT INTO backups_next(id, client, status, started, completed) " "SELECT b.id, c.id, b.status, b.started, b.completed " "FROM backups b " "JOIN clients c ON b.client = c.name;" "DROP TABLE backups;" "ALTER TABLE backups_next RENAME TO backups;"; if(sqlite3_exec(conn, prog, NULL, NULL, NULL) != SQLITE_OK) { abort(); } sqlite3_stmt *stmt; if(sqlite3_prepare_v2(conn, "INSERT INTO migration (id) VALUES (?1)", -1, &stmt, NULL) != SQLITE_OK) { abort(); } if(sqlite3_bind_int64(stmt, 1, 2) != SQLITE_OK) { abort(); } if(sqlite3_step(stmt) != SQLITE_DONE) { abort(); } if(sqlite3_finalize(stmt) != SQLITE_OK) { abort(); } if(sqlite3_exec(conn, "COMMIT TRANSACTION", NULL, NULL, NULL) != SQLITE_OK) { abort(); } } if(maxVersion < 3) { char *prog = "BEGIN TRANSACTION;" "CREATE UNIQUE INDEX clients_name ON clients(name)"; if(sqlite3_exec(conn, prog, NULL, NULL, NULL) != SQLITE_OK) { abort(); } sqlite3_stmt *stmt; if(sqlite3_prepare_v2(conn, "INSERT INTO migration (id) VALUES (?1)", -1, &stmt, NULL) != SQLITE_OK) { abort(); } if(sqlite3_bind_int64(stmt, 1, 3) != SQLITE_OK) { abort(); } if(sqlite3_step(stmt) != SQLITE_DONE) { abort(); } if(sqlite3_finalize(stmt) != SQLITE_OK) { abort(); } if(sqlite3_exec(conn, "COMMIT TRANSACTION", NULL, NULL, NULL) != SQLITE_OK) { abort(); } } } enum ReportEvent { REV_BEGIN, REV_FINISH, }; // @CLEANUP: This should live somewhere else, but I don't have a spot for it yet. int submit_report(struct App *app, char *client, enum ReportEvent event) { sqlite3 *conn; int err; if((err = sqlite3_open(app->dbname, &conn)) != SQLITE_OK) { abort(); } struct timespec now = get_current_time(); int64_t clientId; { sqlite3_stmt *stmt; if(sqlite3_prepare_v2(conn, "SELECT id FROM clients WHERE name = ?1", -1, &stmt, NULL) != SQLITE_OK) { abort(); } if(sqlite3_bind_text(stmt, 1, client, -1, SQLITE_STATIC) != SQLITE_OK) { abort(); } if(sqlite3_step(stmt) != SQLITE_ROW) { abort(); } if(sqlite3_column_type(stmt, 0) == SQLITE_NULL) { abort(); } clientId = sqlite3_column_int64(stmt, 0); if(sqlite3_step(stmt) != SQLITE_DONE) { abort(); } if(sqlite3_finalize(stmt) != SQLITE_OK) { abort(); } } switch(event) { case REV_BEGIN: { sqlite3_stmt *stmt; if(sqlite3_prepare_v2(conn, "INSERT INTO backups (client, status, started) VALUES (?1, ?2, datetime(?3, 'unixepoch', 'subsec'))", -1, &stmt, NULL) != SQLITE_OK) { abort(); } if(sqlite3_bind_int64(stmt, 1, clientId) != SQLITE_OK) { abort(); } if(sqlite3_bind_text(stmt, 2, "RUNNING", -1, SQLITE_STATIC) != SQLITE_OK) { abort(); } if(sqlite3_bind_double(stmt, 3, TIME_AS_FLOAT(now)) != SQLITE_OK) { abort(); } if(sqlite3_step(stmt) != SQLITE_DONE) { abort(); } if(sqlite3_finalize(stmt) != SQLITE_OK) { abort(); } break; } case REV_FINISH: { uint64_t backupId; sqlite3_stmt *stmt; if(sqlite3_prepare_v2(conn, "SELECT id FROM backups WHERE client = ?1 AND status = 'RUNNING'", -1, &stmt, NULL) != SQLITE_OK) { abort(); } if(sqlite3_bind_int64(stmt, 1, clientId) != SQLITE_OK) { abort(); } if(sqlite3_step(stmt) != SQLITE_ROW) { abort(); } if(sqlite3_column_type(stmt, 0) == SQLITE_NULL) { abort(); } backupId = sqlite3_column_int64(stmt, 0); if(sqlite3_step(stmt) != SQLITE_DONE) { abort(); } if(sqlite3_finalize(stmt) != SQLITE_OK) { abort(); } stmt = NULL; if(sqlite3_prepare_v2(conn, "UPDATE backups SET status = ?1, completed = datetime(?2, 'unixepoch', 'subsec') WHERE id = ?3", -1, &stmt, NULL) != SQLITE_OK) { abort(); } if(sqlite3_bind_text(stmt, 1, "FINISHED", -1, SQLITE_STATIC) != SQLITE_OK) { abort(); } if(sqlite3_bind_double(stmt, 2, TIME_AS_FLOAT(now)) != SQLITE_OK) { abort(); } if(sqlite3_bind_int64(stmt, 3, backupId) != SQLITE_OK) { abort(); } if(sqlite3_step(stmt) != SQLITE_DONE) { abort(); } if(sqlite3_finalize(stmt) != SQLITE_OK) { abort(); } break; } } return 0; } struct CreateClientResult { int64_t id; char* name; }; int create_client(struct Request *req, char *name, struct CreateClientResult *result) { sqlite3 *conn; int err; if((err = sqlite3_open(req->server->app->dbname, &conn)) != SQLITE_OK) { abort(); } { sqlite3_stmt *stmt; if(sqlite3_prepare_v2(conn, "INSERT INTO clients (name) VALUES (?1)", -1, &stmt, NULL) != SQLITE_OK) { abort(); } if(sqlite3_bind_text(stmt, 1, name, -1, SQLITE_STATIC) != SQLITE_OK) { abort(); } if(sqlite3_step(stmt) != SQLITE_DONE) { abort(); } result->id = sqlite3_last_insert_rowid(conn); if(sqlite3_finalize(stmt) != SQLITE_OK) { abort(); } } return 0; } int list_clients(struct Request *req, char **response, size_t *response_len) { sqlite3 *conn; int err; if((err = sqlite3_open(req->server->app->dbname, &conn)) != SQLITE_OK) { abort(); } *response = malloc(4096); char *cursor = *response; size_t written; written = snprintf(cursor, *response + 4096 - cursor, "{ \"page\": [ "); if(written >= *response + 4096 - cursor) abort(); cursor += written; { sqlite3_stmt *stmt; if(sqlite3_prepare_v2(conn, "SELECT c.id, c.name FROM clients c WHERE c.id > ?1 ORDER BY c.id ASC LIMIT ?2", -1, &stmt, NULL) != SQLITE_OK) { abort(); } if(sqlite3_bind_int64(stmt, 1, -1) != SQLITE_OK) { abort(); } if(sqlite3_bind_int64(stmt, 2, 16) != SQLITE_OK) { abort(); } int ret; int index = 0; while((ret = sqlite3_step(stmt)) == SQLITE_ROW) { assert(index < 16); if(sqlite3_column_type(stmt, 0) == SQLITE_NULL) { abort(); } int64_t clientId = sqlite3_column_int64(stmt, 0); const uint8_t *name = sqlite3_column_text(stmt, 1); written = snprintf(cursor, *response + 4096 - cursor, "{ \"id\": \"%ld\", \"name\": \"%s\" }, ", clientId, name); if(written >= *response + 4096 - cursor) abort(); cursor += written; index++; } if(ret != SQLITE_DONE) { abort(); } // Remove the last comma and space if(index > 0) cursor -= 2; written = snprintf(cursor, *response + 4096 - cursor, " ] }"); if(written >= *response + 4096 - cursor) abort(); cursor += written; *response_len = cursor - *response; if(sqlite3_finalize(stmt) != SQLITE_OK) { abort(); } } return 0; } static ssize_t file_reader(void *cls, uint64_t pos, char *buf, size_t max) { FILE *f = cls; fseek(f, pos, SEEK_SET); size_t read = fread(buf, 1, max, f); if(read > 0) { return read; } if(feof(f)) { return MHD_CONTENT_READER_END_OF_STREAM; } abort(); } static void file_close(void *cls) { FILE *f = cls; fclose(f); } static enum MHD_Result create_post_collector(struct PostCollector *c) { c->data = malloc(512); c->size = 0; c->capacity = 512; return MHD_YES; } static enum MHD_Result collect_post(struct PostCollector *c, const char *data, size_t *data_len) { size_t newSize = c->size + *data_len; if(newSize > c->capacity) { while(newSize > c->capacity) c->capacity *= 2; c->data = realloc(c->data, c->capacity); } memcpy(c->data + c->size, data, *data_len); c->size = newSize; return MHD_YES; } static enum MHD_Result destroy_post_collector(struct PostCollector *c) { if(c->capacity != 0) { free(c->data); c->capacity = 0; } return MHD_YES; } static enum MHD_Result handler( void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *version, const char *upload_data, size_t *upload_data_size, void **ptr ) { struct Server *server = cls; int ret; // For the first call where con_cls points at NULL we have to create the // connection state struct Request *request = *ptr; if (request == NULL) { request = calloc(1, sizeof(struct Request)); if(request == NULL) { return MHD_NO; } *ptr = request; request->server = server; if(strcmp(method, "POST") == 0) { create_post_collector(&request->pp); } return MHD_YES; } if(strcmp(method, "POST") == 0) { collect_post(&request->pp, upload_data, upload_data_size); if (*upload_data_size != 0) { *upload_data_size = 0; return MHD_YES; } if(strcmp(url, "/api/report") == 0) { cJSON *rootJson = cJSON_ParseWithLength(request->pp.data, request->pp.size); cJSON *clientJson = cJSON_GetObjectItemCaseSensitive(rootJson, "client"); if(!cJSON_IsString(clientJson) || clientJson->valuestring == NULL) { abort(); } cJSON *eventJson = cJSON_GetObjectItemCaseSensitive(rootJson, "event"); if(!cJSON_IsString(eventJson) || eventJson->valuestring == NULL) { abort(); } enum ReportEvent event; if(strcmp(eventJson->valuestring, "begin_backup") == 0) { event = REV_BEGIN; } else if(strcmp(eventJson->valuestring, "end_backup") == 0) { event = REV_FINISH; } else { abort(); } ret = submit_report(server->app, clientJson->valuestring, event); if(ret != 0) { // Should actually return an error page, but this will do for now return MHD_NO; } cJSON_Delete(rootJson); // We've taken in all the data, now we can use it destroy_post_collector(&request->pp); struct MHD_Response *response = MHD_create_response_from_buffer( 0, "", MHD_RESPMEM_PERSISTENT ); ret = MHD_add_response_header(response, "Content-Type", "application/json"); if(ret != MHD_YES) return ret; ret = MHD_queue_response( connection, MHD_HTTP_NO_CONTENT, response ); MHD_destroy_response(response); return ret; } else if(strcmp(url, "/api/client") == 0) { cJSON *rootJson = cJSON_ParseWithLength(request->pp.data, request->pp.size); cJSON *nameJson = cJSON_GetObjectItemCaseSensitive(rootJson, "name"); if(!cJSON_IsString(nameJson) || nameJson->valuestring == NULL) { abort(); } struct CreateClientResult result; ret = create_client(request, nameJson->valuestring, &result); if(ret != 0) { // Should actually return an error page, but this will do for now return MHD_NO; } cJSON_Delete(rootJson); // We've taken in all the data, now we can use it destroy_post_collector(&request->pp); char *buf = malloc(1024); size_t buf_len = snprintf(buf, 1024, "{ \"id\": \"%ld\" }", result.id); if(buf_len >= 1024) { abort(); } struct MHD_Response *response = MHD_create_response_from_buffer( buf_len, buf, MHD_RESPMEM_MUST_FREE ); ret = MHD_add_response_header(response, "Content-Type", "application/json"); if(ret != MHD_YES) return ret; ret = MHD_queue_response( connection, MHD_HTTP_OK, response ); MHD_destroy_response(response); return ret; } else { // Not found destroy_post_collector(&request->pp); struct MHD_Response *response = MHD_create_response_from_buffer( 0, "", MHD_RESPMEM_PERSISTENT ); ret = MHD_add_response_header(response, "Content-Type", "application/json"); if(ret != MHD_YES) return ret; ret = MHD_queue_response( connection, MHD_HTTP_NOT_FOUND, response ); MHD_destroy_response(response); return ret; } } else if (strcmp(method, "GET") == 0) { if (*upload_data_size != 0) return MHD_NO; if(strcmp(url, "/api/client") == 0) { char *body; size_t body_len; ret = list_clients(request, &body, &body_len); if(ret != 0) { // Should actually return an error page, but this will do for now return MHD_NO; } struct MHD_Response *response = MHD_create_response_from_buffer( body_len, body, MHD_RESPMEM_MUST_FREE ); ret = MHD_add_response_header(response, "Content-Type", "application/json"); if(ret != MHD_YES) return ret; ret = MHD_queue_response( connection, MHD_HTTP_OK, response ); MHD_destroy_response(response); return ret; } else { // @SECURITY: We should restrict this lookup. Look at openat2(2) char path[512]; if(snprintf(path, sizeof(path), "static/%s", url) >= sizeof(path)) abort(); struct stat statbuf; FILE *f = NULL; if(stat(path, &statbuf) == 0 && (S_ISREG(statbuf.st_mode) || S_ISLNK(statbuf.st_mode))) { f = fopen(path, "rb"); } if(f != NULL) { struct MHD_Response *response = MHD_create_response_from_callback( statbuf.st_size, statbuf.st_blksize, &file_reader, f, &file_close ); ret = MHD_queue_response( connection, MHD_HTTP_OK, response ); MHD_destroy_response(response); return ret; } else { struct MHD_Response *response = MHD_create_response_from_buffer( strlen(server->page), (void *)server->page, MHD_RESPMEM_PERSISTENT ); ret = MHD_queue_response( connection, MHD_HTTP_OK, response ); MHD_destroy_response(response); return ret; } } } return MHD_NO; } static void request_completed_callback ( void *cls, struct MHD_Connection *connection, void **con_cls, enum MHD_RequestTerminationCode toe ) { struct Request *request = *con_cls; destroy_post_collector(&request->pp); free(request); } static struct MHD_Daemon *d = NULL; int web_begin(struct Server *server, int port) { assert(d == NULL); server->page = PAGE; d = MHD_start_daemon( MHD_USE_THREAD_PER_CONNECTION, port, NULL, NULL, &handler, server, MHD_OPTION_NOTIFY_COMPLETED, &request_completed_callback, NULL, MHD_OPTION_END ); if (d == NULL) return 1; return 0; } int web_join(struct Server *server) { assert(d != NULL); MHD_stop_daemon(d); d = NULL; return 0; }