domo/domo-iot
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Files
0962a1b776d8821393c02ce2da2c37e9c930cb03
domo-iot/src/rest/restd.c
NADAL Jean-Baptiste 0962a1b776 parameter management
2020-02-19 16:52:43 +01:00

959 lines
26 KiB
C
Raw Blame History

/*!
* restd.c
*
* Copyright (c) 2015-2020, NADAL Jean-Baptiste. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
* MA 02110-1301 USA
*
* @Author: NADAL Jean-Baptiste
* @Date: 07/02/2020
*
*/
/*------------------------------- INCLUDES ----------------------------------*/
#include <string.h>
#include <fcntl.h>
#include <stdbool.h>
#include <arpa/inet.h>
#include <sys/un.h>
#include <event2/buffer.h>
#include <event2/bufferevent.h>
#include <event2/event.h>
#include <event2/http.h>
#include <event2/listener.h>
#include <event2/keyvalq_struct.h>
#include <qlibc/qlibc.h>
#ifdef __linux__
#include <sys/eventfd.h>
#else
#include <sys/event.h>
#endif
#include "macro.h"
#include "restd.h"
struct mimetype_s
{
const char *extn;
const char *mime;
};
/*
* Local variables.
*/
static bool initialized = false;
/*
* Global variables.
*/
int _restd_log_level = RESTD_LOG_WARN;
/*--------------------------------------------------------------------------*/
static const struct mimetype_s g_mime_types[] = {
{"txt", "text/plain"},
{"log", "text/plain"},
{"js", "text/javascript"},
{"css", "text/css"},
{"htm", "text/html"},
{"html", "text/html"},
{"diff", "text/x-patch"},
{"patch", "text/x-patch"},
{"c", "text/x-csrc"},
{"h", "text/x-chdr"},
{"o", "text/x-object"},
{"ko", "text/x-object"},
{"bmp", "image/bmp"},
{"gif", "image/gif"},
{"png", "image/png"},
{"jpg", "image/jpeg"},
{"jpeg", "image/jpeg"},
{"svg", "image/svg+xml"},
{"json", "application/json"},
{"jsonp", "application/javascript"},
{"zip", "application/zip"},
{"pdf", "application/pdf"},
{"xml", "application/xml"},
{"xsl", "application/xml"},
{"doc", "application/msword"},
{"ppt", "application/vnd.ms-powerpoint"},
{"xls", "application/vnd.ms-excel"},
{"odt", "application/vnd.oasis.opendocument.text"},
{"odp", "application/vnd.oasis.opendocument.presentation"},
{"pl", "application/x-perl"},
{"sh", "application/x-shellscript"},
{"php", "application/x-php"},
{"deb", "application/x-deb"},
{"iso", "application/x-cd-image"},
{"tar.gz", "application/x-compressed-tar"},
{"tgz", "application/x-compressed-tar"},
{"gz", "application/x-gzip"},
{"tar.bz2", "application/x-bzip-compressed-tar"},
{"tbz", "application/x-bzip-compressed-tar"},
{"bz2", "application/x-bzip"},
{"tar", "application/x-tar"},
{"rar", "application/x-rar-compressed"},
{"mp3", "audio/mpeg"},
{"ogg", "audio/x-vorbis+ogg"},
{"wav", "audio/x-wav"},
{"mpg", "video/mpeg"},
{"mpeg", "video/mpeg"},
{"avi", "video/x-msvideo"},
{"README", "text/plain"},
{"log", "text/plain"},
{"cfg", "text/plain"},
{"conf", "text/plain"},
{"pac", "application/x-ns-proxy-autoconfig"},
{"wpad.dat", "application/x-ns-proxy-autoconfig"},
{"appcache", "text/cache-manifest"},
{"manifest", "text/cache-manifest"},
{NULL, NULL}};
/*--------------------------------------------------------------------------*/
/**
* Server option names and default values.
*/
#define RESTD_SERVER_OPTIONS { \
{"server.port", "8888"}, \
\
{"server.root_path", ""}, \
\
/* Addr format IPv4="1.2.3.4", IPv6="1:2:3:4:5:6", Unix="/path" */ \
{"server.addr", "0.0.0.0"}, \
\
{"server.backlog", "128"}, \
\
/* Set read timeout seconds. 0 means no timeout. */ \
{"server.timeout", "0"}, \
\
/* Enable or disable request pipelining, this change AD_DONE's behavior */ \
{"server.request_pipelining", "1"}, \
\
/* Run server in a separate thread */ \
{"server.thread", "0"}, \
\
/* Collect resources after stop */ \
{"server.free_on_stop", "1"}, \
\
/* End of array marker. Do not remove */ \
{"", "_END_"}};
/*------------------------------- FUNCTIONS ----------------------------------*/
static int set_undefined_options(restd_server_t *server);
char *restd_server_get_option(restd_server_t *server, const char *key);
int restd_server_get_option_int(restd_server_t *server, const char *key);
static void close_server(restd_server_t *server);
static void *server_loop(void *instance);
static void libevent_log_cb(int severity, const char *msg);
static int notify_loopexit(restd_server_t *server);
static void notify_cb(struct bufferevent *buffer, void *userdata);
void rest_request_cb(struct evhttp_request *req, void *arg);
void print_request_info(struct evhttp_request *req);
void restd_http_response_from_file(struct evhttp_request *req, int code, int fd, const char *content_type);
bool manage_hook(restd_hook_t *hook, restd_resp_t *response, const char *request_path);
/*--------------------------- PUBLIC FUNCTIONS -------------------------------*/
/*--------------------------------------------------------------------------
*
* Set debug output level.
*
* @param debug_level debug output level. 0 to disable.
*
* @return previous debug level.
*
* @note
* debug_level:
* REST_LOG_DISABLE
* REST_LOG_ERROR
* REST_LOG_WARN (default)
* REST_LOG_INFO
* REST_LOG_DEBUG
* REST_LOG_DEBUG2
*/
enum restd_log_e restd_log_level(enum restd_log_e log_level)
{
int prev = _restd_log_level;
_restd_log_level = log_level;
return prev;
}
/*--------------------------------------------------------------------------
*
* Create a server object.
*/
restd_server_t *restd_server_new(void)
{
if (initialized)
{
initialized = true;
}
restd_server_t *server = NEW_OBJECT(restd_server_t);
if (server == NULL)
{
return NULL;
}
// Initialize instance.
server->options = qhashtbl(0, 0);
server->stats = qhashtbl(100, QHASHTBL_THREADSAFE);
server->hooks = qlist(0);
//server->call_hooks = call_hooks;
if (server->options == NULL || server->stats == NULL || server->hooks == NULL)
{
restd_server_free(server);
return NULL;
}
DEBUG("Created a server object.");
return server;
}
/*--------------------------------------------------------------------------
*
* Release server object and all the resources.
*/
void restd_server_free(restd_server_t *server)
{
if (server == NULL)
return;
int thread = restd_server_get_option_int(server, "server.thread");
if (thread && server->thread)
{
notify_loopexit(server);
sleep(1);
close_server(server);
}
if (server->evhttp)
{
evhttp_free(server->evhttp);
}
if (server->evbase)
{
event_base_free(server->evbase);
}
if (server->options)
{
server->options->free(server->options);
}
if (server->stats)
{
server->stats->free(server->stats);
}
if (server->hooks)
{
qlist_t *tbl = server->hooks;
restd_hook_t *hook;
while ((hook = qlist_popfirst(tbl, NULL)))
{
restd_hook_free(hook);
}
qlist_free(server->hooks);
}
free(server);
DEBUG("Server terminated.");
}
/*--------------------------------------------------------------------------
*
* Start server.
*
* @return 0 if successful, otherwise -1.
*/
int restd_server_start(restd_server_t *server)
{
int ret;
DEBUG("Starting a server.");
if (server == NULL)
return -1;
// Set default options that were not set by user..
set_undefined_options(server);
// Hookup libevent's log message.
if (_restd_log_level >= RESTD_LOG_DEBUG)
{
event_set_log_callback(libevent_log_cb);
if (_restd_log_level >= RESTD_LOG_DEBUG2)
{
event_enable_debug_mode();
}
}
// Parse addr
int port = restd_server_get_option_int(server, "server.port");
char *addr = restd_server_get_option(server, "server.addr");
struct sockaddr *sockaddr = NULL;
size_t sockaddr_len = 0;
if (addr[0] == '/')
{ // Unix socket.
struct sockaddr_un unixaddr;
bzero((void *)&unixaddr, sizeof(struct sockaddr_un));
if (strlen(addr) >= sizeof(unixaddr.sun_path))
{
errno = EINVAL;
DEBUG("Too long unix socket name. '%s'", addr);
return -1;
}
unixaddr.sun_family = AF_UNIX;
strcpy(unixaddr.sun_path, addr); // no need of strncpy()
sockaddr = (struct sockaddr *)&unixaddr;
sockaddr_len = sizeof(unixaddr);
}
else if (strstr(addr, ":"))
{ // IPv6
struct sockaddr_in6 ipv6addr;
bzero((void *)&ipv6addr, sizeof(struct sockaddr_in6));
ipv6addr.sin6_family = AF_INET6;
ipv6addr.sin6_port = htons(port);
evutil_inet_pton(AF_INET6, addr, &ipv6addr.sin6_addr);
sockaddr = (struct sockaddr *)&ipv6addr;
sockaddr_len = sizeof(ipv6addr);
}
else
{ // IPv4
struct sockaddr_in ipv4addr;
bzero((void *)&ipv4addr, sizeof(struct sockaddr_in));
ipv4addr.sin_family = AF_INET;
ipv4addr.sin_port = htons(port);
ipv4addr.sin_addr.s_addr =
(IS_EMPTY_STR(addr)) ? INADDR_ANY : inet_addr(addr);
sockaddr = (struct sockaddr *)&ipv4addr;
sockaddr_len = sizeof(ipv4addr);
}
// Bind
if (!server->evbase)
{
server->evbase = event_base_new();
if (!server->evbase)
{
ERROR("Failed to create a new event base.");
return -1;
}
}
server->evhttp = evhttp_new(server->evbase);
if (!server->evhttp)
{
ERROR("Event http initialize failed!\n");
return -2;
}
evhttp_set_gencb(server->evhttp, rest_request_cb, server);
ret = evhttp_bind_socket(server->evhttp, addr, port);
if (ret != 0)
{
ERROR("Http bind server addr:%s & port:%d failed!\n", addr, port);
return -3;
}
// Listen
INFO("Listening on %s:%d", addr, port);
// Create a eventfd for notification channel.
#ifdef __linux__
int notifyfd = eventfd(0, 0);
#else
int notifyfd = kqueue();
#endif
server->notify_buffer = bufferevent_socket_new(server->evbase, notifyfd, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(server->notify_buffer, NULL, notify_cb, NULL, server);
int exitstatus = 0;
if (restd_server_get_option_int(server, "server.thread"))
{
DEBUG("Launching server as a thread.\n");
server->thread = NEW_OBJECT(pthread_t);
pthread_create(server->thread, NULL, &server_loop, (void *)server);
//pthread_detach(server->thread);
}
else
{
int *retval = server_loop(server);
exitstatus = *retval;
free(retval);
close_server(server);
if (restd_server_get_option_int(server, "server.free_on_stop"))
{
restd_server_free(server);
}
}
return exitstatus;
}
/*--------------------------------------------------------------------------*/
int restd_server_attach_event_loop(restd_server_t *server, struct event_base *ev_base)
{
if (server == NULL)
return -1;
server->evbase = ev_base;
return 0;
}
/*--------------------------------------------------------------------------*/
void restd_server_set_option(restd_server_t *server, const char *key, const char *value)
{
server->options->putstr(server->options, key, value);
}
/*--------------------------------------------------------------------------*/
void restd_server_register_hook_on_path(restd_server_t *server, enum evhttp_cmd_type method, const char *path,
restd_callback cb, void *userdata)
{
restd_hook_t *hook;
char *fragment;
// Init Hook.
hook = restd_hook_new();
hook->method = method;
hook->path = (path) ? strdup(path) : NULL;
hook->cb = cb;
hook->userdata = userdata;
hook->path_fragments = qstrtokenizer(path, "/");
// Split URI and detect parameter and action.
while ((fragment = qlist_popfirst(hook->path_fragments, NULL)) != NULL)
{
char *param;
param = strchr(fragment, ':');
if (param != NULL)
{
hook->has_param = true;
hook->param_name = strdup(param + 1);
}
if (hook->has_param == true)
{
hook->action_name = strdup(fragment);
}
free(fragment);
}
server->hooks->addlast(server->hooks, (void *)hook, sizeof(restd_hook_t));
free(hook);
}
/*--------------------------------------------------------------------------*/
void restd_http_response(restd_resp_t *response, int code, const char *contenttype, const char *data)
{
struct evbuffer *resp_buf;
struct evkeyvalq *resp_headers;
resp_buf = evhttp_request_get_output_buffer(response->request);
resp_headers = evhttp_request_get_output_headers(response->request);
if (data != NULL)
{
evbuffer_add(resp_buf, data, strlen(data));
}
evhttp_add_header(resp_headers, "Content-Type", contenttype);
evhttp_send_reply(response->request, code, NULL, resp_buf);
}
/*--------------------------------------------------------------------------*/
char *restd_http_get_body(restd_resp_t *response)
{
char *body = NULL;
struct evbuffer *buf;
buf = evhttp_request_get_input_buffer(response->request);
size_t len = evbuffer_get_length(buf);
body = malloc(len + 1);
int ret = evbuffer_copyout(buf, body, len);
body[len] = '\0';
return body;
}
/*--------------------------------------------------------------------------*/
restd_hook_t *restd_hook_new(void)
{
restd_hook_t *hook = NEW_OBJECT(restd_hook_t);
if (hook == NULL)
{
return NULL;
}
bzero((void *)hook, sizeof(restd_hook_t));
hook->has_param = false;
return hook;
}
/*--------------------------------------------------------------------------*/
void restd_hook_free(restd_hook_t *hook)
{
if (hook == NULL)
return;
qlist_free(hook->path_fragments);
if (hook->path)
free(hook->path);
if (hook->param_name)
free(hook->param_name);
if (hook->action_name)
free(hook->action_name);
free(hook);
}
/*--------------------------------------------------------------------------*/
restd_resp_t *restd_resp_new(void)
{
restd_resp_t *resp = NEW_OBJECT(restd_resp_t);
if (resp == NULL)
{
return NULL;
}
bzero((void *)resp, sizeof(restd_resp_t));
return resp;
}
/*--------------------------------------------------------------------------*/
void restd_resp_free(restd_resp_t *response)
{
if (response == NULL)
{
return;
}
if (response->parameter)
{
free(response->parameter);
}
if (response->action)
{
free(response->action);
}
free(response);
}
/*--------------------------- LOCAL FUNCTIONS -------------------------------*/
/*--------------------------------------------------------------------------*/
// Set default options that were not set by user..
static int set_undefined_options(restd_server_t *server)
{
int newentries = 0;
char *default_options[][2] = RESTD_SERVER_OPTIONS;
for (int i = 0; !IS_EMPTY_STR(default_options[i][0]); i++)
{
if (!restd_server_get_option(server, default_options[i][0]))
{
restd_server_set_option(server, default_options[i][0], default_options[i][1]);
newentries++;
}
DEBUG("%s=%s", default_options[i][0], restd_server_get_option(server, default_options[i][0]));
}
return newentries;
}
/*--------------------------------------------------------------------------
*
* Retrieve server option.
*/
char *restd_server_get_option(restd_server_t *server, const char *key)
{
return server->options->getstr(server->options, key, false);
}
/*--------------------------------------------------------------------------
*
* Retrieve server option in integer format.
*/
int restd_server_get_option_int(restd_server_t *server, const char *key)
{
char *value = restd_server_get_option(server, key);
return (value) ? atoi(value) : 0;
}
/*--------------------------------------------------------------------------*/
static void close_server(restd_server_t *server)
{
DEBUG("Closing server.");
if (server->notify_buffer)
{
bufferevent_free(server->notify_buffer);
server->notify_buffer = NULL;
}
if (server->listener)
{
evconnlistener_free(server->listener);
server->listener = NULL;
}
if (server->thread)
{
void *retval = NULL;
DEBUG("Waiting server's last loop to finish.");
pthread_join(*(server->thread), &retval);
free(retval);
free(server->thread);
server->thread = NULL;
}
INFO("Server closed.");
}
/*--------------------------------------------------------------------------*/
static void *server_loop(void *instance)
{
restd_server_t *server = (restd_server_t *)instance;
int *retval = NEW_OBJECT(int);
DEBUG("Loop start\n");
event_base_loop(server->evbase, 0);
DEBUG("Loop finished\n");
*retval = (event_base_got_break(server->evbase)) ? -1 : 0;
return retval;
}
/*--------------------------------------------------------------------------*/
static void libevent_log_cb(int severity, const char *msg)
{
switch (severity)
{
case _EVENT_LOG_MSG:
{
INFO("%s", msg);
break;
}
case _EVENT_LOG_WARN:
{
WARN("%s", msg);
break;
}
case _EVENT_LOG_ERR:
{
ERROR("%s", msg);
break;
}
default:
{
DEBUG("%s", msg);
break;
}
}
}
/*--------------------------------------------------------------------------
*
* If there's no event, loopbreak or loopexit call won't work until one more
* event arrived. So we use eventfd as a internal notification channel to let
* server get out of the loop without waiting for an event.
*/
static int notify_loopexit(restd_server_t *server)
{
uint64_t x = 0;
return bufferevent_write(server->notify_buffer, &x, sizeof(uint64_t));
}
/*--------------------------------------------------------------------------*/
static void notify_cb(struct bufferevent *buffer, void *userdata)
{
restd_server_t *server = (restd_server_t *)userdata;
event_base_loopexit(server->evbase, NULL);
DEBUG("Existing loop.");
}
/*--------------------------------------------------------------------------*/
static const char *file_mime_lookup(const char *path)
{
const struct mimetype_s *m = &g_mime_types[0];
const char *e;
while (m->extn)
{
e = &path[strlen(path) - 1];
while (e >= path)
{
if ((*e == '.' || *e == '/') && !strcasecmp(&e[1], m->extn))
return m->mime;
e--;
}
m++;
}
return "application/octet-stream";
}
/*--------------------------------------------------------------------------*/
static bool contain(const char *src, const char *dest, int len)
{
int len_src, len_dest;
int i = 0;
len_src = strlen(src);
if (len_src < len)
return false;
len_dest = strlen(dest);
if (len_dest < len)
return false;
while (i < len)
{
if (src[i] != dest[i])
return false;
i++;
}
return true;
}
/*--------------------------------------------------------------------------*/
void rest_request_cb(struct evhttp_request *req, void *arg)
{
restd_server_t *server = (restd_server_t *)arg;
char *root_path;
restd_resp_t *response;
response = restd_resp_new();
response->request = req;
#if 0
print_request_info(req);
#endif
const char *request_path = evhttp_request_get_uri(req);
qlist_t *hooks = server->hooks;
//int reason = RESTD_ERROR_PATH_NOT_FOUND;
qlist_obj_t obj;
bzero((void *)&obj, sizeof(qlist_obj_t));
while (hooks->getnext(hooks, &obj, false) == true)
{
restd_hook_t *hook = (restd_hook_t *)obj.data;
if (hook->cb)
{
//printf("==== call_hooks: method: %d - %d \n", hook->method, evhttp_request_get_command(req));
//printf("==== call_hooks: path: %s - %s\n", hook->path, request_path);
//printf("==== HOOK FOUND !!!!\n");
if (hook->method != evhttp_request_get_command(req))
{
//printf("==== Hook found but method failed -> next.\n");
//reason = RESTD_ERROR_METHOD_NOT_ALLOWED;
continue;
}
if (manage_hook(hook, response, request_path) == true)
{
restd_resp_free(response);
return;
}
}
}
restd_resp_free(response);
// No Hook Found check if it's a real file into document root.
root_path = restd_server_get_option(server, "server.root_path");
if ((root_path != NULL) && (strlen(root_path) != 0))
{
int fd;
char buf[1024] = "";
qstrcatf(buf, "%s%s", root_path, request_path);
fd = open(buf, 0);
if (fd != -1)
{
restd_http_response_from_file(req, 200, fd, file_mime_lookup(buf));
return;
}
else
{
// TODO 404
}
}
#if 0 // TODO
if (conn->server->error_handler != NULL)
{
return conn->server->error_handler(reason, conn, NULL);
}
else
#endif
{
evhttp_send_reply(req, 500, "Internal Error", NULL);
}
}
/*--------------------------------------------------------------------------*/
void print_request_info(struct evhttp_request *req)
{
const char *cmdtype;
struct evkeyvalq *headers;
struct evkeyval *header;
printf("request.\n");
switch (evhttp_request_get_command(req))
{
case EVHTTP_REQ_GET:
cmdtype = "GET";
break;
case EVHTTP_REQ_POST:
cmdtype = "POST";
break;
case EVHTTP_REQ_HEAD:
cmdtype = "HEAD";
break;
case EVHTTP_REQ_PUT:
cmdtype = "PUT";
break;
case EVHTTP_REQ_DELETE:
cmdtype = "DELETE";
break;
case EVHTTP_REQ_OPTIONS:
cmdtype = "OPTIONS";
break;
case EVHTTP_REQ_TRACE:
cmdtype = "TRACE";
break;
case EVHTTP_REQ_CONNECT:
cmdtype = "CONNECT";
break;
case EVHTTP_REQ_PATCH:
cmdtype = "PATCH";
break;
default:
cmdtype = "unknown";
break;
}
printf("Received a %s request for %s\nHeaders:\n",
cmdtype, evhttp_request_get_uri(req));
headers = evhttp_request_get_input_headers(req);
for (header = headers->tqh_first; header;
header = header->next.tqe_next)
{
printf(" %s: %s\n", header->key, header->value);
}
}
/*--------------------------------------------------------------------------*/
void restd_http_response_from_file(struct evhttp_request *req, int code, int fd, const char *content_type)
{
struct evbuffer *resp_buf;
struct evkeyvalq *resp_headers;
ev_off_t len;
resp_buf = evhttp_request_get_output_buffer(req);
resp_headers = evhttp_request_get_output_headers(req);
len = lseek(fd, 0, SEEK_END);
evbuffer_add_file(resp_buf, fd, 0, len);
evhttp_add_header(resp_headers, "Content-Type", content_type);
evhttp_send_reply(req, code, NULL, resp_buf);
}
/*--------------------------------------------------------------------------*/
bool manage_hook(restd_hook_t *hook, restd_resp_t *response, const char *request_path)
{
if ((hook->path != NULL) && (request_path != NULL))
{
int i = 0;
int pos = -1;
while (hook->path[i])
{
if (hook->path[i] == ':')
pos = i;
i++;
}
if (pos != -1 && contain(hook->path, request_path, pos))
{
const char *buffer = &request_path[pos];
// printf("buffer: <%s>\n", buffer);
// TODO conn->id = atoi(buffer);
hook->cb(response, hook->userdata);
return true;
}
else
{
int rett = strcmp(hook->path, request_path);
if (rett == 0)
{
hook->cb(response, hook->userdata);
return true;
}
}
}
return false;
}
Reference in New Issue View Git Blame Copy Permalink