X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fhttp-svc.c;h=9fa6e84cdfa11a7ed23a753418f111f5914b99f7;hb=1205c90cccd3144bab24b4b5fd8dcbf0d0e6b570;hp=8af11d2eba32c4f73d4da22120502ae77ab799ce;hpb=2a3fbda636c93c9f22a064e5c5f537c2232d626d;p=src%2Fapp-framework-binder.git diff --git a/src/http-svc.c b/src/http-svc.c index 8af11d2e..9fa6e84c 100644 --- a/src/http-svc.c +++ b/src/http-svc.c @@ -23,139 +23,39 @@ #include "../include/local-def.h" #include "afb-method.h" +#include "afb-hreq.h" +#include "afb-websock.h" +#include "afb-apis.h" +#include "session.h" +#include "afb-req-itf.h" +#define JSON_CONTENT "application/json" +#define FORM_CONTENT MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA -struct afb_req_post { - const char *upload_data; - size_t *upload_data_size; -}; - -struct afb_req { - AFB_session *session; - struct MHD_Connection *connection; - enum afb_method method; - const char *url; - size_t lenurl; - const char *tail; - size_t lentail; - struct afb_req **recorder; - int (*post_handler) (struct afb_req *, struct afb_req_post *); - int (*post_completed) (struct afb_req *, struct afb_req_post *); - void *post_data; -}; - -struct afb_req_handler { - struct afb_req_handler *next; +struct afb_hsrv_handler { + struct afb_hsrv_handler *next; const char *prefix; size_t length; - int (*handler) (struct afb_req *, struct afb_req_post *, void *); + int (*handler) (struct afb_hreq *, void *); void *data; int priority; }; -static char empty_string[1] = ""; - -/* a valid subpath is a relative path not looking deeper than root using .. */ -static int validsubpath(const char *subpath) -{ - int l = 0, i = 0; - - while (subpath[i]) { - switch (subpath[i++]) { - case '.': - if (!subpath[i]) - break; - if (subpath[i] == '/') { - i++; - break; - } - if (subpath[i++] == '.') { - if (!subpath[i]) { - if (--l < 0) - return 0; - break; - } - if (subpath[i++] == '/') { - if (--l < 0) - return 0; - break; - } - } - default: - while (subpath[i] && subpath[i] != '/') - i++; - l++; - case '/': - break; - } - } - return 1; -} - -/* - * Removes the 'prefix' of 'length' frome the tail of 'request' - * if and only if the prefix exists and is terminated by a leading - * slash - */ -int afb_req_unprefix(struct afb_req *request, const char *prefix, size_t length) -{ - /* check the prefix ? */ - if (length > request->lentail || (request->tail[length] && request->tail[length] != '/') - || memcmp(prefix, request->tail, length)) - return 0; - - /* removes successives / */ - while (length < request->lentail && request->tail[length + 1] == '/') - length++; - - /* update the tail */ - request->lentail -= length; - request->tail += length; - return 1; -} - -int afb_req_valid_tail(struct afb_req *request) -{ - return validsubpath(request->tail); -} - -void afb_req_reply_error(struct afb_req *request, unsigned int status) -{ - char *buffer; - int length; - struct MHD_Response *response; - - length = asprintf(&buffer, "error %u", status); - if (length > 0) - response = MHD_create_response_from_buffer((unsigned)length, buffer, MHD_RESPMEM_MUST_FREE); - else { - buffer = "error"; - response = MHD_create_response_from_buffer(strlen(buffer), buffer, MHD_RESPMEM_PERSISTENT); - } - if (!MHD_queue_response(request->connection, status, response)) - fprintf(stderr, "Failed to reply error code %u", status); - MHD_destroy_response(response); -} - -int afb_request_redirect_to(struct afb_req *request, const char *url) -{ - struct MHD_Response *response; - - response = MHD_create_response_from_buffer(0, empty_string, MHD_RESPMEM_PERSISTENT); - MHD_add_response_header(response, "Location", url); - MHD_queue_response(request->connection, MHD_HTTP_MOVED_PERMANENTLY, response); - MHD_destroy_response(response); - if (verbose) - fprintf(stderr, "redirect from [%s] to [%s]\n", request->url, url); - return 1; -} +struct afb_diralias { + const char *alias; + const char *directory; + size_t lendir; + int dirfd; +}; -int afb_request_one_page_api_redirect(struct afb_req *request, struct afb_req_post *post, void *data) +int afb_hreq_one_page_api_redirect( + struct afb_hreq *hreq, + void *data) { size_t plen; char *url; - if (request->lentail >= 2 && request->tail[1] == '#') + if (hreq->lentail >= 2 && hreq->tail[1] == '#') return 0; /* * Here we have for example: @@ -166,20 +66,23 @@ int afb_request_one_page_api_redirect(struct afb_req *request, struct afb_req_po * * Let compute plen that include the / at end (for "/pre/") */ - plen = request->lenurl - request->lentail + 1; - url = alloca(request->lenurl + 3); - memcpy(url, request->url, plen); + plen = hreq->lenurl - hreq->lentail + 1; + url = alloca(hreq->lenurl + 3); + memcpy(url, hreq->url, plen); url[plen++] = '#'; url[plen++] = '!'; - memcpy(&url[plen], &request->tail[1], request->lentail); - return afb_request_redirect_to(request, url); + memcpy(&url[plen], &hreq->tail[1], hreq->lentail); + return afb_hreq_redirect_to(hreq, url); } -struct afb_req_handler *afb_req_handler_new(struct afb_req_handler *head, const char *prefix, - int (*handler) (struct afb_req *, struct afb_req_post *, void *), - void *data, int priority) +static struct afb_hsrv_handler *new_handler( + struct afb_hsrv_handler *head, + const char *prefix, + int (*handler) (struct afb_hreq *, void *), + void *data, + int priority) { - struct afb_req_handler *link, *iter, *previous; + struct afb_hsrv_handler *link, *iter, *previous; size_t length; /* get the length of the prefix without its leading / */ @@ -213,249 +116,273 @@ struct afb_req_handler *afb_req_handler_new(struct afb_req_handler *head, const return head; } -int afb_req_add_handler(AFB_session * session, const char *prefix, - int (*handler) (struct afb_req *, struct afb_req_post *, void *), void *data, int priority) +int afb_hsrv_add_handler( + AFB_session * session, + const char *prefix, + int (*handler) (struct afb_hreq *, void *), + void *data, + int priority) { - struct afb_req_handler *head; + struct afb_hsrv_handler *head; - head = afb_req_handler_new(session->handlers, prefix, handler, data, priority); + head = new_handler(session->handlers, prefix, handler, data, priority); if (head == NULL) return 0; session->handlers = head; return 1; } -static int relay_to_doRestApi(struct afb_req *request, struct afb_req_post *post, void *data) -{ - return doRestApi(request->connection, request->session, &request->tail[1], get_method_name(request->method), - post->upload_data, post->upload_data_size, (void **)request->recorder); -} +static const char uuid_header[] = "x-afb-uuid"; +static const char uuid_arg[] = "uuid"; +static const char uuid_cookie[] = "uuid"; -static int afb_req_reply_file_if_exist(struct afb_req *request, int dirfd, const char *filename) +static struct AFB_clientCtx *afb_hreq_context(struct afb_hreq *hreq) { - int rc; - int fd; - unsigned int status; - struct stat st; - char etag[1 + 2 * sizeof(int)]; - const char *inm; - struct MHD_Response *response; - - /* Opens the file or directory */ - fd = openat(dirfd, filename, O_RDONLY); - if (fd < 0) { - if (errno == ENOENT) - return 0; - afb_req_reply_error(request, MHD_HTTP_FORBIDDEN); - return 1; + const char *uuid; + + if (hreq->context == NULL) { + uuid = afb_hreq_get_header(hreq, uuid_header); + if (uuid == NULL) + uuid = afb_hreq_get_argument(hreq, uuid_arg); + if (uuid == NULL) + uuid = afb_hreq_get_cookie(hreq, uuid_cookie); + hreq->context = _ctxClientGet(uuid); } + return hreq->context; +} - /* Retrieves file's status */ - if (fstat(fd, &st) != 0) { - close(fd); - afb_req_reply_error(request, MHD_HTTP_INTERNAL_SERVER_ERROR); - return 1; - } - - /* Don't serve directory */ - if (S_ISDIR(st.st_mode)) { - rc = afb_req_reply_file_if_exist(request, fd, "index.html"); - close(fd); - return rc; - } - - /* Don't serve special files */ - if (!S_ISREG(st.st_mode)) { - close(fd); - afb_req_reply_error(request, MHD_HTTP_FORBIDDEN); - return 1; - } - - /* Check the method */ - if ((request->method & (afb_method_get | afb_method_head)) == 0) { - close(fd); - afb_req_reply_error(request, MHD_HTTP_METHOD_NOT_ALLOWED); - return 1; - } - - /* computes the etag */ - sprintf(etag, "%08X%08X", ((int)(st.st_mtim.tv_sec) ^ (int)(st.st_mtim.tv_nsec)), (int)(st.st_size)); - - /* checks the etag */ - inm = MHD_lookup_connection_value(request->connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_IF_NONE_MATCH); - if (inm && 0 == strcmp(inm, etag)) { - /* etag ok, return NOT MODIFIED */ - close(fd); - if (verbose) - fprintf(stderr, "Not Modified: [%s]\n", filename); - response = MHD_create_response_from_buffer(0, empty_string, MHD_RESPMEM_PERSISTENT); - status = MHD_HTTP_NOT_MODIFIED; - } else { - /* check the size */ - if (st.st_size != (off_t) (size_t) st.st_size) { - close(fd); - afb_req_reply_error(request, MHD_HTTP_INTERNAL_SERVER_ERROR); - return 1; - } +static int afb_hreq_websocket_switch(struct afb_hreq *hreq, void *data) +{ + int later; - /* create the response */ - response = MHD_create_response_from_fd((size_t) st.st_size, fd); - status = MHD_HTTP_OK; + afb_hreq_context(hreq); + if (hreq->lentail != 0 || !afb_websock_check(hreq, &later)) + return 0; -#if defined(USE_MAGIC_MIME_TYPE) - /* set the type */ - if (request->session->magic) { - const char *mimetype = magic_descriptor(request->session->magic, fd); - if (mimetype != NULL) - MHD_add_response_header(response, MHD_HTTP_HEADER_CONTENT_TYPE, mimetype); + if (!later) { + struct afb_websock *ws = afb_websock_create(hreq->connection); + if (ws == NULL) { + /* TODO */ + } else { + /* TODO */ } -#endif } - - /* fills the value and send */ - MHD_add_response_header(response, MHD_HTTP_HEADER_CACHE_CONTROL, request->session->cacheTimeout); - MHD_add_response_header(response, MHD_HTTP_HEADER_ETAG, etag); - MHD_queue_response(request->connection, status, response); - MHD_destroy_response(response); return 1; } -static int afb_req_reply_file(struct afb_req *request, int dirfd, const char *filename) +static int afb_hreq_rest_api(struct afb_hreq *hreq, void *data) { - int rc = afb_req_reply_file_if_exist(request, dirfd, filename); - if (rc == 0) - afb_req_reply_error(request, MHD_HTTP_NOT_FOUND); - return 1; + const char *api, *verb; + size_t lenapi, lenverb; + + api = hreq->tail; + lenapi = strspn(api, "/"); + verb = &hreq->tail[lenapi]; + verb = &verb[strcspn(verb, "/")]; + lenverb = strspn(verb, "/"); + + if (!(*api && *verb && lenapi && lenverb)) + return 0; + + return afb_apis_handle(afb_hreq_to_req(hreq), api, lenapi, verb, lenverb); } -static int handle_alias(struct afb_req *request, struct afb_req_post *post, void *data) +static int handle_alias(struct afb_hreq *hreq, void *data) { - char *path; - const char *alias = data; - size_t lenalias; + struct afb_diralias *da = data; - if (request->method != afb_method_get) { - afb_req_reply_error(request, MHD_HTTP_METHOD_NOT_ALLOWED); + if (hreq->method != afb_method_get) { + afb_hreq_reply_error(hreq, MHD_HTTP_METHOD_NOT_ALLOWED); return 1; } - if (!validsubpath(request->tail)) { - afb_req_reply_error(request, MHD_HTTP_FORBIDDEN); + if (!afb_hreq_valid_tail(hreq)) { + afb_hreq_reply_error(hreq, MHD_HTTP_FORBIDDEN); return 1; } - lenalias = strlen(alias); - path = alloca(lenalias + request->lentail + 1); - memcpy(path, alias, lenalias); - memcpy(&path[lenalias], request->tail, request->lentail + 1); - return afb_req_reply_file(request, AT_FDCWD, path); -} - -int afb_req_add_alias(AFB_session * session, const char *prefix, const char *alias, int priority) -{ - return afb_req_add_handler(session, prefix, handle_alias, (void *)alias, priority); + return afb_hreq_reply_file(hreq, da->dirfd, &hreq->tail[1]); } -static int my_default_init(AFB_session * session) +int afb_hsrv_add_alias(AFB_session * session, const char *prefix, const char *alias, int priority) { - int idx; + struct afb_diralias *da; + int dirfd; - if (!afb_req_add_handler(session, session->config->rootapi, relay_to_doRestApi, NULL, 1)) + dirfd = open(alias, O_PATH|O_DIRECTORY); + if (dirfd < 0) { + /* TODO message */ return 0; + } + da = malloc(sizeof *da); + if (da != NULL) { + da->alias = prefix; + da->directory = alias; + da->lendir = strlen(da->directory); + da->dirfd = dirfd; + if (afb_hsrv_add_handler(session, prefix, handle_alias, da, priority)) + return 1; + free(da); + } + close(dirfd); + return 0; +} - for (idx = 0; session->config->aliasdir[idx].url != NULL; idx++) - if (!afb_req_add_alias - (session, session->config->aliasdir[idx].url, session->config->aliasdir[idx].path, 0)) - return 0; - - if (!afb_req_add_alias(session, "", session->config->rootdir, -10)) - return 0; +void afb_hsrv_reply_error(struct MHD_Connection *connection, unsigned int status) +{ + char *buffer; + int length; + struct MHD_Response *response; - if (!afb_req_add_handler(session, session->config->rootbase, afb_request_one_page_api_redirect, NULL, -20)) - return 0; + length = asprintf(&buffer, "error %u", status); + if (length > 0) + response = MHD_create_response_from_buffer((unsigned)length, buffer, MHD_RESPMEM_MUST_FREE); + else { + buffer = "error"; + response = MHD_create_response_from_buffer(strlen(buffer), buffer, MHD_RESPMEM_PERSISTENT); + } + if (!MHD_queue_response(connection, status, response)) + fprintf(stderr, "Failed to reply error code %u", status); + MHD_destroy_response(response); +} - return 1; +static int postproc(void *cls, + enum MHD_ValueKind kind, + const char *key, + const char *filename, + const char *content_type, + const char *transfer_encoding, + const char *data, + uint64_t off, + size_t size) +{ + struct afb_hreq *hreq = cls; + if (filename != NULL) + return afb_hreq_post_add_file(hreq, key, filename, data, size); + else + return afb_hreq_post_add(hreq, key, data, size); } -static int access_handler(void *cls, - struct MHD_Connection *connection, - const char *url, - const char *methodstr, - const char *version, const char *upload_data, size_t * upload_data_size, void **recorder) +static int access_handler( + void *cls, + struct MHD_Connection *connection, + const char *url, + const char *methodstr, + const char *version, + const char *upload_data, + size_t *upload_data_size, + void **recordreq) { - struct afb_req_post post; - struct afb_req request; + int rc; + struct afb_hreq *hreq; enum afb_method method; AFB_session *session; - struct afb_req_handler *iter; + struct afb_hsrv_handler *iter; + const char *type; session = cls; - post.upload_data = upload_data; - post.upload_data_size = upload_data_size; - -#if 0 - struct afb_req *previous; - - previous = *recorder; - if (previous) { - assert((void **)previous->recorder == recorder); - assert(previous->session == session); - assert(previous->connection == connection); - assert(previous->method == get_method(methodstr)); - assert(previous->url == url); - - /* TODO */ -/* - assert(previous->post_handler != NULL); - previous->post_handler(previous, &post); - return MHD_NO; -*/ + hreq = *recordreq; + if (hreq == NULL) { + /* create the request */ + hreq = calloc(1, sizeof *hreq); + if (hreq == NULL) + goto internal_error; + *recordreq = hreq; + + /* get the method */ + method = get_method(methodstr); + method &= afb_method_get | afb_method_post; + if (method == afb_method_none) + goto bad_request; + + /* init the request */ + hreq->session = cls; + hreq->connection = connection; + hreq->method = method; + hreq->version = version; + hreq->tail = hreq->url = url; + hreq->lentail = hreq->lenurl = strlen(url); + + /* init the post processing */ + if (method == afb_method_post) { + type = afb_hreq_get_header(hreq, MHD_HTTP_HEADER_CONTENT_TYPE); + if (type == NULL) { + /* an empty post, let's process it as a get */ + hreq->method = afb_method_get; + } else if (strcasestr(type, FORM_CONTENT) != NULL) { + hreq->postform = MHD_create_post_processor (connection, 65500, postproc, hreq); + if (hreq->postform == NULL) + goto internal_error; + } else if (strcasestr(type, JSON_CONTENT) == NULL) { + afb_hsrv_reply_error(connection, MHD_HTTP_UNSUPPORTED_MEDIA_TYPE); + return MHD_YES; + } + } } -#endif - method = get_method(methodstr); - if (method == afb_method_none) { - afb_req_reply_error(&request, MHD_HTTP_BAD_REQUEST); - return MHD_YES; + /* process further data */ + if (*upload_data_size) { + if (hreq->postform != NULL) { + if (!MHD_post_process (hreq->postform, upload_data, *upload_data_size)) + goto internal_error; + } else { + if (!afb_hreq_post_add(hreq, NULL, upload_data, *upload_data_size)) + goto internal_error; + } + *upload_data_size = 0; + return MHD_YES; } - /* init the request */ - request.session = cls; - request.connection = connection; - request.method = method; - request.tail = request.url = url; - request.lentail = request.lenurl = strlen(url); - request.recorder = (struct afb_req **)recorder; - request.post_handler = NULL; - request.post_completed = NULL; - request.post_data = NULL; + /* flush the data */ + afb_hreq_post_end(hreq); + if (hreq->postform != NULL) { + rc = MHD_destroy_post_processor(hreq->postform); + hreq->postform = NULL; + if (rc == MHD_NO) + goto bad_request; + } /* search an handler for the request */ iter = session->handlers; while (iter) { - if (afb_req_unprefix(&request, iter->prefix, iter->length)) { - if (iter->handler(&request, &post, iter->data)) + if (afb_hreq_unprefix(hreq, iter->prefix, iter->length)) { + if (iter->handler(hreq, iter->data)) return MHD_YES; - request.tail = request.url; - request.lentail = request.lenurl; + hreq->tail = hreq->url; + hreq->lentail = hreq->lenurl; } iter = iter->next; } /* no handler */ - afb_req_reply_error(&request, method != afb_method_get ? MHD_HTTP_BAD_REQUEST : MHD_HTTP_NOT_FOUND); + afb_hreq_reply_error(hreq, MHD_HTTP_NOT_FOUND); + return MHD_YES; + +bad_request: + afb_hsrv_reply_error(connection, MHD_HTTP_BAD_REQUEST); + return MHD_YES; + +internal_error: + afb_hsrv_reply_error(connection, MHD_HTTP_INTERNAL_SERVER_ERROR); return MHD_YES; } /* Because of POST call multiple time requestApi we need to free POST handle here */ -static void end_handler(void *cls, struct MHD_Connection *connection, void **con_cls, +static void end_handler(void *cls, struct MHD_Connection *connection, void **recordreq, enum MHD_RequestTerminationCode toe) { - AFB_PostHandle *posthandle = *con_cls; + AFB_session *session; + struct afb_hreq *hreq; - /* if post handle was used let's free everything */ - if (posthandle != NULL) - endPostRequest(posthandle); + session = cls; + hreq = *recordreq; + + if (hreq != NULL) { + if (hreq->postform != NULL) + MHD_destroy_post_processor(hreq->postform); + afb_hreq_drop_data(hreq); + free(hreq); + } } static int new_client_handler(void *cls, const struct sockaddr *addr, socklen_t addrlen) @@ -484,28 +411,45 @@ static int init_lib_magic (AFB_session *session) /* Warning: should not use NULL for DB [libmagic bug wont pass efence check] */ if (magic_load(session->magic, MAGIC_DB) != 0) { fprintf(stderr,"cannot load magic database - %s\n", magic_error(session->magic)); -/* magic_close(session->magic); session->magic = NULL; return 0; -*/ } return 1; } #endif -AFB_error httpdStart(AFB_session * session) +static int my_default_init(AFB_session * session) { + int idx; + + if (!afb_hsrv_add_handler(session, session->config->rootapi, afb_hreq_websocket_switch, NULL, 20)) + return 0; + + if (!afb_hsrv_add_handler(session, session->config->rootapi, afb_hreq_rest_api, NULL, 10)) + return 0; + for (idx = 0; session->config->aliasdir[idx].url != NULL; idx++) + if (!afb_hsrv_add_alias (session, session->config->aliasdir[idx].url, session->config->aliasdir[idx].path, 0)) + return 0; + + if (!afb_hsrv_add_alias(session, "", session->config->rootdir, -10)) + return 0; + + if (!afb_hsrv_add_handler(session, session->config->rootbase, afb_hreq_one_page_api_redirect, NULL, -20)) + return 0; + + return 1; +} + +AFB_error httpdStart(AFB_session * session) +{ if (!my_default_init(session)) { printf("Error: initialisation of httpd failed"); return AFB_FATAL; } - /* Initialise Client Session Hash Table */ - ctxStoreInit(CTX_NBCLIENTS); - #if defined(USE_MAGIC_MIME_TYPE) /*TBD open libmagic cache [fail to pass EFENCE check (allocating 0 bytes)] */ init_lib_magic (session); @@ -517,7 +461,7 @@ AFB_error httpdStart(AFB_session * session) } session->httpd = MHD_start_daemon( - MHD_USE_EPOLL_LINUX_ONLY | MHD_USE_TCP_FASTOPEN | MHD_USE_DEBUG, + MHD_USE_EPOLL_LINUX_ONLY | MHD_USE_TCP_FASTOPEN | MHD_USE_DEBUG | MHD_USE_SUSPEND_RESUME, (uint16_t) session->config->httpdPort, /* port */ new_client_handler, NULL, /* Tcp Accept call back + extra attribute */ access_handler, session, /* Http Request Call back + extra attribute */