X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fafb-hsrv.c;h=61e5c3c2e7a361315a387e5bd9d89dacb94f8d56;hb=65353dce81a629e042800bb7b86fcd869a76727e;hp=efbb93560abebfc990f1422fdd4018be0757bf74;hpb=94014f46d4751492133f65b12f1dea1cfa36d021;p=src%2Fapp-framework-binder.git diff --git a/src/afb-hsrv.c b/src/afb-hsrv.c index efbb9356..61e5c3c2 100644 --- a/src/afb-hsrv.c +++ b/src/afb-hsrv.c @@ -1,5 +1,5 @@ /* - * Copyright 2016 IoT.bzh + * Copyright (C) 2015-2020 "IoT.bzh" * Author: JosÃ© Bollo * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -17,26 +17,47 @@ #define _GNU_SOURCE +#include +#include #include #include #include #include #include +#include +#include +#include #include +#include #include +#if MHD_VERSION < 0x00095206 +# define MHD_ALLOW_SUSPEND_RESUME MHD_USE_SUSPEND_RESUME +#endif #include "afb-method.h" +#include "afb-context.h" +#include "afb-xreq.h" #include "afb-hreq.h" #include "afb-hsrv.h" -#include "afb-req-itf.h" -#include "verbose.h" -#include "utils-upoll.h" +#include "afb-fdev.h" +#include "afb-socket.h" +#include "fdev.h" +#include "verbose.h" +#include "locale-root.h" +#include "systemd.h" +#include "jobs.h" #define JSON_CONTENT "application/json" #define FORM_CONTENT MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA +struct hsrv_itf { + struct hsrv_itf *next; + struct afb_hsrv *hsrv; + struct fdev *fdev; + char uri[]; +}; struct hsrv_handler { struct hsrv_handler *next; @@ -48,36 +69,23 @@ struct hsrv_handler { }; struct hsrv_alias { - const char *alias; - const char *directory; - size_t lendir; - int dirfd; + struct locale_root *root; + int relax; }; struct afb_hsrv { unsigned refcount; struct hsrv_handler *handlers; + struct hsrv_itf *interfaces; struct MHD_Daemon *httpd; - struct upoll *upoll; + struct fdev *fdev; char *cache_to; }; - static void reply_error(struct MHD_Connection *connection, 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(connection, status, response)) - fprintf(stderr, "Failed to reply error code %u", status); + struct MHD_Response *response = MHD_create_response_from_buffer(0, NULL, MHD_RESPMEM_PERSISTENT); + MHD_queue_response(connection, status, response); MHD_destroy_response(response); } @@ -114,29 +122,38 @@ static int access_handler( struct afb_hsrv *hsrv; struct hsrv_handler *iter; const char *type; + enum json_tokener_error jerr; hsrv = cls; 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; + if (method == afb_method_none) { + WARNING("Unsupported HTTP operation %s", methodstr); + reply_error(connection, MHD_HTTP_BAD_REQUEST); + return MHD_YES; + } + + /* create the request */ + hreq = afb_hreq_create(); + if (hreq == NULL) { + ERROR("Can't allocate 'hreq'"); + reply_error(connection, MHD_HTTP_INTERNAL_SERVER_ERROR); + return MHD_YES; + } /* init the request */ + hreq->hsrv = hsrv; hreq->cacheTimeout = hsrv->cache_to; hreq->connection = connection; hreq->method = method; hreq->version = version; + hreq->lang = MHD_lookup_connection_value(connection, MHD_HEADER_KIND, MHD_HTTP_HEADER_ACCEPT_LANGUAGE); hreq->tail = hreq->url = url; hreq->lentail = hreq->lenurl = strlen(url); + *recordreq = hreq; /* init the post processing */ if (method == afb_method_post) { @@ -146,11 +163,21 @@ static int access_handler( 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; + if (hreq->postform == NULL) { + ERROR("Can't create POST processor"); + afb_hreq_reply_error(hreq, MHD_HTTP_INTERNAL_SERVER_ERROR); + } return MHD_YES; - } else if (strcasestr(type, JSON_CONTENT) == NULL) { - reply_error(connection, MHD_HTTP_UNSUPPORTED_MEDIA_TYPE); + } else if (strcasestr(type, JSON_CONTENT) != NULL) { + hreq->tokener = json_tokener_new(); + if (hreq->tokener == NULL) { + ERROR("Can't create tokener for POST"); + afb_hreq_reply_error(hreq, MHD_HTTP_INTERNAL_SERVER_ERROR); + } + return MHD_YES; + } else { + WARNING("Unsupported media type %s", type); + afb_hreq_reply_error(hreq, MHD_HTTP_UNSUPPORTED_MEDIA_TYPE); return MHD_YES; } } @@ -159,30 +186,63 @@ static int access_handler( /* 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; + if (!MHD_post_process (hreq->postform, upload_data, *upload_data_size)) { + ERROR("error in POST processor"); + afb_hreq_reply_error(hreq, MHD_HTTP_INTERNAL_SERVER_ERROR); + return MHD_YES; + } + } else if (hreq->tokener) { + hreq->json = json_tokener_parse_ex(hreq->tokener, upload_data, (int)*upload_data_size); + jerr = json_tokener_get_error(hreq->tokener); + if (jerr == json_tokener_continue) { + hreq->json = json_tokener_parse_ex(hreq->tokener, "", 1); + jerr = json_tokener_get_error(hreq->tokener); + } + if (jerr != json_tokener_success) { + ERROR("error in POST json: %s", json_tokener_error_desc(jerr)); + afb_hreq_reply_error(hreq, MHD_HTTP_BAD_REQUEST); + return MHD_YES; + } } *upload_data_size = 0; - return MHD_YES; + return MHD_YES; } /* flush the data */ if (hreq->postform != NULL) { rc = MHD_destroy_post_processor(hreq->postform); hreq->postform = NULL; - if (rc == MHD_NO) - goto bad_request; + if (rc == MHD_NO) { + ERROR("error detected in POST processing"); + afb_hreq_reply_error(hreq, MHD_HTTP_BAD_REQUEST); + return MHD_YES; + } + } + if (hreq->tokener != NULL) { + json_tokener_free(hreq->tokener); + hreq->tokener = NULL; + } + + if (hreq->scanned != 0) { + if (hreq->replied == 0 && hreq->suspended == 0) { + MHD_suspend_connection (connection); + hreq->suspended = 1; + } + return MHD_YES; } /* search an handler for the request */ + hreq->scanned = 1; iter = hsrv->handlers; while (iter) { if (afb_hreq_unprefix(hreq, iter->prefix, iter->length)) { - if (iter->handler(hreq, iter->data)) + if (iter->handler(hreq, iter->data)) { + if (hreq->replied == 0 && hreq->suspended == 0) { + MHD_suspend_connection (connection); + hreq->suspended = 1; + } return MHD_YES; + } hreq->tail = hreq->url; hreq->lentail = hreq->lenurl; } @@ -190,16 +250,9 @@ static int access_handler( } /* no handler */ + NOTICE("Unhandled request to %s", hreq->url); afb_hreq_reply_error(hreq, MHD_HTTP_NOT_FOUND); return MHD_YES; - -bad_request: - reply_error(connection, MHD_HTTP_BAD_REQUEST); - return MHD_YES; - -internal_error: - 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 */ @@ -209,9 +262,32 @@ static void end_handler(void *cls, struct MHD_Connection *connection, void **rec struct afb_hreq *hreq; hreq = *recordreq; - if (hreq->upgrade) - MHD_suspend_connection (connection); - afb_hreq_free(hreq); + if (hreq) { + afb_hreq_unref(hreq); + } +} + +static void do_run(int signum, void *arg) +{ + MHD_UNSIGNED_LONG_LONG to; + struct afb_hsrv *hsrv = arg; + + if (!signum) { + do { MHD_run(hsrv->httpd); } while(MHD_get_timeout(hsrv->httpd, &to) == MHD_YES && !to); + } + fdev_set_events(hsrv->fdev, EPOLLIN); +} + +void afb_hsrv_run(struct afb_hsrv *hsrv) +{ + fdev_set_events(hsrv->fdev, 0); + if (jobs_queue(hsrv, 0, do_run, hsrv) < 0) + do_run(0, hsrv); +} + +static void listen_callback(void *hsrv, uint32_t revents, struct fdev *fdev) +{ + afb_hsrv_run(hsrv); } static int new_client_handler(void *cls, const struct sockaddr *addr, socklen_t addrlen) @@ -262,19 +338,26 @@ static struct hsrv_handler *new_handler( static int handle_alias(struct afb_hreq *hreq, void *data) { + int rc; struct hsrv_alias *da = data; + struct locale_search *search; if (hreq->method != afb_method_get) { + if (da->relax) + return 0; afb_hreq_reply_error(hreq, MHD_HTTP_METHOD_NOT_ALLOWED); return 1; } - if (!afb_hreq_valid_tail(hreq)) { - afb_hreq_reply_error(hreq, MHD_HTTP_FORBIDDEN); - return 1; + search = locale_root_search(da->root, hreq->lang, 0); + rc = afb_hreq_reply_locale_file_if_exist(hreq, search, &hreq->tail[1]); + locale_search_unref(search); + if (rc == 0) { + if (da->relax) + return 0; + afb_hreq_reply_error(hreq, MHD_HTTP_NOT_FOUND); } - - return afb_hreq_reply_file(hreq, da->dirfd, &hreq->tail[1]); + return 1; } int afb_hsrv_add_handler( @@ -293,30 +376,39 @@ int afb_hsrv_add_handler( return 1; } -int afb_hsrv_add_alias(struct afb_hsrv *hsrv, const char *prefix, const char *alias, int priority) +int afb_hsrv_add_alias_root(struct afb_hsrv *hsrv, const char *prefix, struct locale_root *root, int priority, int relax) { struct hsrv_alias *da; - int dirfd; - 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(hsrv, prefix, handle_alias, da, priority)) + da->root = root; + da->relax = relax; + if (afb_hsrv_add_handler(hsrv, prefix, handle_alias, da, priority)) { + locale_root_addref(root); return 1; + } free(da); } - close(dirfd); return 0; } +int afb_hsrv_add_alias(struct afb_hsrv *hsrv, const char *prefix, int dirfd, const char *alias, int priority, int relax) +{ + struct locale_root *root; + int rc; + + root = locale_root_create_at(dirfd, alias); + if (root == NULL) { + ERROR("can't connect to directory %s: %m", alias); + rc = 0; + } else { + rc = afb_hsrv_add_alias_root(hsrv, prefix, root, priority, relax); + locale_root_unref(root); + } + return rc; +} + int afb_hsrv_set_cache_timeout(struct afb_hsrv *hsrv, int duration) { int rc; @@ -331,51 +423,59 @@ int afb_hsrv_set_cache_timeout(struct afb_hsrv *hsrv, int duration) return 1; } -int afb_hsrv_start(struct afb_hsrv *hsrv, uint16_t port, unsigned int connection_timeout) +int afb_hsrv_start(struct afb_hsrv *hsrv, unsigned int connection_timeout) { - struct upoll *upoll; + struct fdev *fdev; struct MHD_Daemon *httpd; const union MHD_DaemonInfo *info; httpd = MHD_start_daemon( - MHD_USE_EPOLL_LINUX_ONLY | MHD_USE_TCP_FASTOPEN | MHD_USE_DEBUG | MHD_USE_SUSPEND_RESUME, - port, /* port */ - new_client_handler, NULL, /* Tcp Accept call back + extra attribute */ - access_handler, hsrv, /* Http Request Call back + extra attribute */ - MHD_OPTION_NOTIFY_COMPLETED, end_handler, hsrv, - MHD_OPTION_CONNECTION_TIMEOUT, connection_timeout, - MHD_OPTION_END); /* options-end */ + MHD_USE_EPOLL + | MHD_ALLOW_UPGRADE + | MHD_USE_TCP_FASTOPEN + | MHD_USE_NO_LISTEN_SOCKET + | MHD_USE_DEBUG + | MHD_ALLOW_SUSPEND_RESUME, + 0, /* port */ + new_client_handler, NULL, /* Tcp Accept call back + extra attribute */ + access_handler, hsrv, /* Http Request Call back + extra attribute */ + MHD_OPTION_NOTIFY_COMPLETED, end_handler, hsrv, + MHD_OPTION_CONNECTION_TIMEOUT, connection_timeout, + MHD_OPTION_END); /* options-end */ if (httpd == NULL) { - printf("Error: httpStart invalid httpd port: %d", (int)port); + ERROR("httpStart invalid httpd"); return 0; } - info = MHD_get_daemon_info(httpd, MHD_DAEMON_INFO_EPOLL_FD_LINUX_ONLY); + info = MHD_get_daemon_info(httpd, MHD_DAEMON_INFO_EPOLL_FD); if (info == NULL) { MHD_stop_daemon(httpd); - fprintf(stderr, "Error: httpStart no pollfd"); + ERROR("httpStart no pollfd"); return 0; } - upoll = upoll_open(info->listen_fd, httpd); - if (upoll == NULL) { + fdev = afb_fdev_create(info->epoll_fd); + if (fdev == NULL) { MHD_stop_daemon(httpd); - fprintf(stderr, "Error: connection to upoll of httpd failed"); + ERROR("connection to events for httpd failed"); return 0; } - upoll_on_readable(upoll, (void*)MHD_run); + fdev_set_autoclose(fdev, 0); + fdev_set_events(fdev, EPOLLIN); + fdev_set_callback(fdev, listen_callback, hsrv); hsrv->httpd = httpd; - hsrv->upoll = upoll; + hsrv->fdev = fdev; return 1; } void afb_hsrv_stop(struct afb_hsrv *hsrv) { - if (hsrv->upoll) - upoll_close(hsrv->upoll); - hsrv->upoll = NULL; + if (hsrv->fdev != NULL) { + fdev_unref(hsrv->fdev); + hsrv->fdev = NULL; + } if (hsrv->httpd != NULL) MHD_stop_daemon(hsrv->httpd); hsrv->httpd = NULL; @@ -398,3 +498,95 @@ void afb_hsrv_put(struct afb_hsrv *hsrv) } } +static int hsrv_itf_connect(struct hsrv_itf *itf); + +static void hsrv_itf_callback(void *closure, uint32_t revents, struct fdev *fdev) +{ + struct hsrv_itf *itf = closure; + int fd, sts; + struct sockaddr addr; + socklen_t lenaddr; + + if ((revents & EPOLLHUP) != 0) { + ERROR("disconnection for server %s: %m", itf->uri); + hsrv_itf_connect(itf); + fdev_unref(fdev); + } else if ((revents & EPOLLIN) != 0) { + lenaddr = (socklen_t)sizeof addr; + fd = accept(fdev_fd(fdev), &addr, &lenaddr); + if (fd < 0) + ERROR("can't accept connection to %s: %m", itf->uri); + else { + sts = MHD_add_connection(itf->hsrv->httpd, fd, &addr, lenaddr); + if (sts != MHD_YES) { + ERROR("can't add incoming connection to %s: %m", itf->uri); + close(fd); + } + } + } +} + +static int hsrv_itf_connect(struct hsrv_itf *itf) +{ + struct sockaddr addr; + socklen_t lenaddr; + char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV]; + int rgni; + + itf->fdev = afb_socket_open_fdev_scheme(itf->uri, 1, "tcp"); + if (!itf->fdev) { + ERROR("can't create socket %s", itf->uri); + return 0; + } + fdev_set_events(itf->fdev, EPOLLIN); + fdev_set_callback(itf->fdev, hsrv_itf_callback, itf); + memset(&addr, 0, sizeof addr); + lenaddr = (socklen_t)sizeof addr; + getsockname(fdev_fd(itf->fdev), &addr, &lenaddr); + if (addr.sa_family == AF_INET && !((struct sockaddr_in*)&addr)->sin_addr.s_addr) { + strncpy(hbuf, "*", NI_MAXHOST); + sprintf(sbuf, "%d", (int)ntohs(((struct sockaddr_in*)&addr)->sin_port)); + } else { + rgni = getnameinfo(&addr, lenaddr, hbuf, sizeof hbuf, sbuf, sizeof sbuf, NI_NUMERICSERV); + if (rgni != 0) { + ERROR("getnameinfo returned %d: %s", rgni, gai_strerror(rgni)); + hbuf[0] = sbuf[0] = '?'; + hbuf[1] = sbuf[1] = 0; + } + } + NOTICE("Listening interface %s:%s", hbuf, sbuf); + return 1; +} + +int afb_hsrv_add_interface(struct afb_hsrv *hsrv, const char *uri) +{ + struct hsrv_itf *itf; + + itf = malloc(sizeof *itf + 1 + strlen(uri)); + if (itf == NULL) + return -1; + + itf->hsrv = hsrv; + itf->fdev = NULL; + strcpy(itf->uri, uri); + itf->next = hsrv->interfaces; + hsrv->interfaces = itf; + return hsrv_itf_connect(itf); +} + +int afb_hsrv_add_interface_tcp(struct afb_hsrv *hsrv, const char *itf, uint16_t port) +{ + int rc; + char buffer[1024]; + + if (itf == NULL) { + itf = "*"; /* awaiting getifaddrs impl */ + } + rc = snprintf(buffer, sizeof buffer, "tcp:%s:%d", itf, (int)port); + if (rc < 0 || rc >= (int)sizeof buffer) { + if (rc > 0) + errno = EINVAL; + return 0; + } + return afb_hsrv_add_interface(hsrv, buffer); +}