X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=src%2Fjournal%2Fjournal-gatewayd.c;h=63d974477677029ea3f86b42290a146f72360c8c;hp=33dda266b6a31f049a1e286889fc64db5e427126;hb=4a1909bb6655a1ba84b426546acb9a518aa9b679;hpb=c6511e859c35b12de4e6fb5f58d7258d9de3b8f2 diff --git a/src/journal/journal-gatewayd.c b/src/journal/journal-gatewayd.c index 33dda266b..63d974477 100644 --- a/src/journal/journal-gatewayd.c +++ b/src/journal/journal-gatewayd.c @@ -50,12 +50,16 @@ typedef struct RequestMeta { bool follow; bool discrete; + + uint64_t n_fields; + bool n_fields_set; } RequestMeta; static const char* const mime_types[_OUTPUT_MODE_MAX] = { [OUTPUT_SHORT] = "text/plain", [OUTPUT_JSON] = "application/json", - [OUTPUT_EXPORT] = "application/vnd.fdo.journal" + [OUTPUT_JSON_SSE] = "text/event-stream", + [OUTPUT_EXPORT] = "application/vnd.fdo.journal", }; static RequestMeta *request_meta(void **connection_cls) { @@ -233,7 +237,7 @@ static ssize_t request_reader_entries( m->tmp = tmpfile(); if (!m->tmp) { log_error("Failed to create temporary file: %m"); - return MHD_CONTENT_READER_END_WITH_ERROR;; + return MHD_CONTENT_READER_END_WITH_ERROR; } } @@ -275,18 +279,20 @@ static int request_parse_accept( RequestMeta *m, struct MHD_Connection *connection) { - const char *accept; + const char *header; assert(m); assert(connection); - accept = MHD_lookup_connection_value(connection, MHD_HEADER_KIND, "Accept"); - if (!accept) + header = MHD_lookup_connection_value(connection, MHD_HEADER_KIND, "Accept"); + if (!header) return 0; - if (streq(accept, mime_types[OUTPUT_JSON])) + if (streq(header, mime_types[OUTPUT_JSON])) m->mode = OUTPUT_JSON; - else if (streq(accept, mime_types[OUTPUT_EXPORT])) + else if (streq(header, mime_types[OUTPUT_JSON_SSE])) + m->mode = OUTPUT_JSON_SSE; + else if (streq(header, mime_types[OUTPUT_EXPORT])) m->mode = OUTPUT_EXPORT; else m->mode = OUTPUT_SHORT; @@ -322,14 +328,13 @@ static int request_parse_range( colon2 = strchr(colon + 1, ':'); if (colon2) { - char *t; + char _cleanup_free_ *t; t = strndup(colon + 1, colon2 - colon - 1); if (!t) return -ENOMEM; r = safe_atoi64(t, &m->n_skip); - free(t); if (r < 0) return r; } @@ -410,6 +415,38 @@ static int request_parse_arguments_iterator( return MHD_YES; } + if (streq(key, "boot")) { + if (isempty(value)) + r = true; + else { + r = parse_boolean(value); + if (r < 0) { + m->argument_parse_error = r; + return MHD_NO; + } + } + + if (r) { + char match[9 + 32 + 1] = "_BOOT_ID="; + sd_id128_t bid; + + r = sd_id128_get_boot(&bid); + if (r < 0) { + log_error("Failed to get boot ID: %s", strerror(-r)); + return MHD_NO; + } + + sd_id128_to_string(bid, match + 9); + r = sd_journal_add_match(m->journal, match, sizeof(match)-1); + if (r < 0) { + m->argument_parse_error = r; + return MHD_NO; + } + } + + return MHD_YES; + } + p = strjoin(key, "=", strempty(value), NULL); if (!p) { m->argument_parse_error = log_oom(); @@ -495,6 +532,153 @@ static int request_handler_entries( return r; } +static int output_field(FILE *f, OutputMode m, const char *d, size_t l) { + const char *eq; + size_t j; + + eq = memchr(d, '=', l); + if (!eq) + return -EINVAL; + + j = l - (eq - d + 1); + + if (m == OUTPUT_JSON) { + fprintf(f, "{ \"%.*s\" : ", (int) (eq - d), d); + json_escape(f, eq+1, j, OUTPUT_FULL_WIDTH); + fputs(" }\n", f); + } else { + fwrite(eq+1, 1, j, f); + fputc('\n', f); + } + + return 0; +} + +static ssize_t request_reader_fields( + void *cls, + uint64_t pos, + char *buf, + size_t max) { + + RequestMeta *m = cls; + int r; + size_t n, k; + + assert(m); + assert(buf); + assert(max > 0); + assert(pos >= m->delta); + + pos -= m->delta; + + while (pos >= m->size) { + off_t sz; + const void *d; + size_t l; + + /* End of this field, so let's serialize the next + * one */ + + if (m->n_fields_set && + m->n_fields <= 0) + return MHD_CONTENT_READER_END_OF_STREAM; + + r = sd_journal_enumerate_unique(m->journal, &d, &l); + if (r < 0) { + log_error("Failed to advance field index: %s", strerror(-r)); + return MHD_CONTENT_READER_END_WITH_ERROR; + } else if (r == 0) + return MHD_CONTENT_READER_END_OF_STREAM; + + pos -= m->size; + m->delta += m->size; + + if (m->n_fields_set) + m->n_fields -= 1; + + if (m->tmp) + rewind(m->tmp); + else { + m->tmp = tmpfile(); + if (!m->tmp) { + log_error("Failed to create temporary file: %m"); + return MHD_CONTENT_READER_END_WITH_ERROR; + } + } + + r = output_field(m->tmp, m->mode, d, l); + if (r < 0) { + log_error("Failed to serialize item: %s", strerror(-r)); + return MHD_CONTENT_READER_END_WITH_ERROR; + } + + sz = ftello(m->tmp); + if (sz == (off_t) -1) { + log_error("Failed to retrieve file position: %m"); + return MHD_CONTENT_READER_END_WITH_ERROR; + } + + m->size = (uint64_t) sz; + } + + if (fseeko(m->tmp, pos, SEEK_SET) < 0) { + log_error("Failed to seek to position: %m"); + return MHD_CONTENT_READER_END_WITH_ERROR; + } + + n = m->size - pos; + if (n > max) + n = max; + + errno = 0; + k = fread(buf, 1, n, m->tmp); + if (k != n) { + log_error("Failed to read from file: %s", errno ? strerror(errno) : "Premature EOF"); + return MHD_CONTENT_READER_END_WITH_ERROR; + } + + return (ssize_t) k; +} + +static int request_handler_fields( + struct MHD_Connection *connection, + const char *field, + void *connection_cls) { + + struct MHD_Response *response; + RequestMeta *m; + int r; + + assert(connection); + assert(connection_cls); + + m = request_meta(connection_cls); + if (!m) + return respond_oom(connection); + + r = open_journal(m); + if (r < 0) + return respond_error(connection, MHD_HTTP_INTERNAL_SERVER_ERROR, "Failed to open journal: %s\n", strerror(-r)); + + if (request_parse_accept(m, connection) < 0) + return respond_error(connection, MHD_HTTP_BAD_REQUEST, "Failed to parse Accept header.\n"); + + r = sd_journal_query_unique(m->journal, field); + if (r < 0) + return respond_error(connection, MHD_HTTP_BAD_REQUEST, "Failed to query unique fields.\n"); + + response = MHD_create_response_from_callback(MHD_SIZE_UNKNOWN, 4*1024, request_reader_fields, m, NULL); + if (!response) + return respond_oom(connection); + + MHD_add_response_header(response, "Content-Type", mime_types[m->mode == OUTPUT_JSON ? OUTPUT_JSON : OUTPUT_SHORT]); + + r = MHD_queue_response(connection, MHD_HTTP_OK, response); + MHD_destroy_response(response); + + return r; +} + static int request_handler_redirect( struct MHD_Connection *connection, const char *target) { @@ -663,6 +847,9 @@ static int request_handler( if (streq(url, "/entries")) return request_handler_entries(connection, connection_cls); + if (startswith(url, "/fields/")) + return request_handler_fields(connection, url + 8, connection_cls); + if (streq(url, "/browse")) return request_handler_file(connection, DOCUMENT_ROOT "/browse.html", "text/html"); @@ -673,7 +860,7 @@ static int request_handler( } int main(int argc, char *argv[]) { - struct MHD_Daemon *daemon = NULL; + struct MHD_Daemon *d = NULL; int r = EXIT_FAILURE, n; if (argc > 1) { @@ -693,7 +880,7 @@ int main(int argc, char *argv[]) { log_error("Can't listen on more than one socket."); goto finish; } else if (n > 0) { - daemon = MHD_start_daemon( + d = MHD_start_daemon( MHD_USE_THREAD_PER_CONNECTION|MHD_USE_POLL|MHD_USE_DEBUG, 19531, NULL, NULL, @@ -702,7 +889,7 @@ int main(int argc, char *argv[]) { MHD_OPTION_NOTIFY_COMPLETED, request_meta_free, NULL, MHD_OPTION_END); } else { - daemon = MHD_start_daemon( + d = MHD_start_daemon( MHD_USE_DEBUG|MHD_USE_THREAD_PER_CONNECTION|MHD_USE_POLL, 19531, NULL, NULL, @@ -711,7 +898,7 @@ int main(int argc, char *argv[]) { MHD_OPTION_END); } - if (!daemon) { + if (!d) { log_error("Failed to start daemon!"); goto finish; } @@ -721,8 +908,8 @@ int main(int argc, char *argv[]) { r = EXIT_SUCCESS; finish: - if (daemon) - MHD_stop_daemon(daemon); + if (d) + MHD_stop_daemon(d); return r; }