X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fhttp-svc.c;h=dd0e32e52cbd716df8054929ad30a245a93d31ba;hb=631b0be76caa4ad4bbbbbfe1ca333dc9aa192ce0;hp=fa0440b9c9a28b2aa91e5e6d8d9c94b349444925;hpb=7aae8b046213dc7041e741b5e8b2757255701183;p=src%2Fapp-framework-binder.git diff --git a/src/http-svc.c b/src/http-svc.c index fa0440b9..dd0e32e5 100644 --- a/src/http-svc.c +++ b/src/http-svc.c @@ -1,227 +1,52 @@ /* - * Copyright (C) 2016 "IoT.bzh" - * Author José Bollo + * Copyright 2016 IoT.bzh + * Author: José Bollo * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * http://www.apache.org/licenses/LICENSE-2.0 * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. */ + #define _GNU_SOURCE #include #include #include #include -#include "../include/local-def.h" - - - -enum afb_method { - afb_method_none = 0, - afb_method_get = 1, - afb_method_post = 2, - afb_method_head = 4, - afb_method_connect = 8, - afb_method_delete = 16, - afb_method_options = 32, - afb_method_patch = 64, - afb_method_put = 128, - afb_method_trace = 256, - afb_method_all = 511 -}; -struct afb_req_post { - const char *upload_data; - size_t *upload_data_size; -}; +#include "../include/local-def.h" +#include "afb-method.h" +#include "afb-hreq.h" -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 *, struct afb_hreq_post *, void *); void *data; int priority; }; -static char empty_string[1] = ""; - -enum afb_method get_method(const char *method) -{ - switch (method[0] & ~' ') { - case 'C': - return afb_method_connect; - case 'D': - return afb_method_delete; - case 'G': - return afb_method_get; - case 'H': - return afb_method_head; - case 'O': - return afb_method_options; - case 'P': - switch (method[1] & ~' ') { - case 'A': - return afb_method_patch; - case 'O': - return afb_method_post; - case 'U': - return afb_method_put; - } - break; - case 'T': - return afb_method_trace; - } - return afb_method_none; -} - -#if !defined(MHD_HTTP_METHOD_PATCH) -#define MHD_HTTP_METHOD_PATCH "PATCH" -#endif -const char *get_method_name(enum afb_method method) -{ - switch (method) { - case afb_method_get: - return MHD_HTTP_METHOD_GET; - case afb_method_post: - return MHD_HTTP_METHOD_POST; - case afb_method_head: - return MHD_HTTP_METHOD_HEAD; - case afb_method_connect: - return MHD_HTTP_METHOD_CONNECT; - case afb_method_delete: - return MHD_HTTP_METHOD_DELETE; - case afb_method_options: - return MHD_HTTP_METHOD_OPTIONS; - case afb_method_patch: - return MHD_HTTP_METHOD_PATCH; - case afb_method_put: - return MHD_HTTP_METHOD_PUT; - case afb_method_trace: - return MHD_HTTP_METHOD_TRACE; - default: - return NULL; - } -} - -/* 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; +struct afb_diralias { + const char *alias; + const char *directory; + size_t lendir; + int dirfd; +}; - 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; -} -int afb_request_one_page_api_redirect(struct afb_req *request, struct afb_req_post *post, void *data) +int afb_request_one_page_api_redirect( + struct afb_hreq *request, + struct afb_hreq_post *post, + void *data) { size_t plen; char *url; @@ -243,14 +68,17 @@ int afb_request_one_page_api_redirect(struct afb_req *request, struct afb_req_po url[plen++] = '#'; url[plen++] = '!'; memcpy(&url[plen], &request->tail[1], request->lentail); - return afb_request_redirect_to(request, url); + return afb_hreq_redirect_to(request, 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) +struct afb_hsrv_handler *afb_hsrv_handler_new( + struct afb_hsrv_handler *head, + const char *prefix, + int (*handler) (struct afb_hreq *, struct afb_hreq_post *, 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 / */ @@ -284,147 +112,67 @@ 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_req_add_handler( + AFB_session * session, + const char *prefix, + int (*handler) (struct afb_hreq *, struct afb_hreq_post *, 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 = afb_hsrv_handler_new(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) +static int relay_to_doRestApi(struct afb_hreq *request, struct afb_hreq_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 int afb_req_reply_file_if_exist(struct afb_req *request, int dirfd, const char *filename) +static int handle_alias(struct afb_hreq *request, struct afb_hreq_post *post, void *data) { - 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; - } - - /* 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; - } + struct afb_diralias *da = data; - /* Don't serve special files */ - if (!S_ISREG(st.st_mode)) { - close(fd); - afb_req_reply_error(request, MHD_HTTP_FORBIDDEN); + if (request->method != afb_method_get) { + afb_hreq_reply_error(request, MHD_HTTP_METHOD_NOT_ALLOWED); 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); + if (!afb_hreq_valid_tail(request)) { + afb_hreq_reply_error(request, MHD_HTTP_FORBIDDEN); 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; - } - - /* create the response */ - response = MHD_create_response_from_fd((size_t) st.st_size, fd); - status = MHD_HTTP_OK; - -#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); - } -#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; + return afb_hreq_reply_file(request, da->dirfd, &request->tail[1]); } -static int afb_req_reply_file(struct afb_req *request, int dirfd, const char *filename) -{ - 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; -} - -static int handle_alias(struct afb_req *request, struct afb_req_post *post, void *data) +int afb_req_add_alias(AFB_session * session, const char *prefix, const char *alias, int priority) { - char *path; - const char *alias = data; - size_t lenalias; + struct afb_diralias *da; + int dirfd; - if (request->method != afb_method_get) { - afb_req_reply_error(request, MHD_HTTP_METHOD_NOT_ALLOWED); - return 1; + dirfd = open(alias, O_PATH|O_DIRECTORY); + if (dirfd < 0) { + /* TODO message */ + return 0; } - - if (!validsubpath(request->tail)) { - afb_req_reply_error(request, MHD_HTTP_FORBIDDEN); - return 1; + da = malloc(sizeof *da); + if (da != NULL) { + da->alias = prefix; + da->directory = alias; + da->lendir = strlen(da->directory); + da->dirfd = dirfd; + if (afb_req_add_handler(session, prefix, handle_alias, (void *)alias, priority)) + return 1; + free(da); } - - 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); + close(dirfd); + return 0; } static int my_default_init(AFB_session * session) @@ -448,24 +196,28 @@ static int my_default_init(AFB_session * session) return 1; } -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 **recorder) { - struct afb_req_post post; - struct afb_req request; + struct afb_hreq_post post; + struct afb_hreq request; enum afb_method method; AFB_session *session; - struct afb_req_handler *iter; + struct afb_hsrv_handler *iter; session = cls; post.upload_data = upload_data; post.upload_data_size = upload_data_size; #if 0 - struct afb_req *previous; + struct afb_hreq *previous; previous = *recorder; if (previous) { @@ -486,7 +238,7 @@ static int access_handler(void *cls, method = get_method(methodstr); if (method == afb_method_none) { - afb_req_reply_error(&request, MHD_HTTP_BAD_REQUEST); + afb_hreq_reply_error(&request, MHD_HTTP_BAD_REQUEST); return MHD_YES; } @@ -496,7 +248,7 @@ static int access_handler(void *cls, request.method = method; request.tail = request.url = url; request.lentail = request.lenurl = strlen(url); - request.recorder = (struct afb_req **)recorder; + request.recorder = (struct afb_hreq **)recorder; request.post_handler = NULL; request.post_completed = NULL; request.post_data = NULL; @@ -504,7 +256,7 @@ static int access_handler(void *cls, /* search an handler for the request */ iter = session->handlers; while (iter) { - if (afb_req_unprefix(&request, iter->prefix, iter->length)) { + if (afb_hreq_unprefix(&request, iter->prefix, iter->length)) { if (iter->handler(&request, &post, iter->data)) return MHD_YES; request.tail = request.url; @@ -514,7 +266,7 @@ static int access_handler(void *cls, } /* no handler */ - afb_req_reply_error(&request, method != afb_method_get ? MHD_HTTP_BAD_REQUEST : MHD_HTTP_NOT_FOUND); + afb_hreq_reply_error(&request, method != afb_method_get ? MHD_HTTP_BAD_REQUEST : MHD_HTTP_NOT_FOUND); return MHD_YES; }