src/main.c

   1 /*
   2  * Copyright (C) 2015, 2016, 2017 "IoT.bzh"
   3  * Author "Fulup Ar Foll"
   4  * Author José Bollo <jose.bollo@iot.bzh>
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *   http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #define _GNU_SOURCE
  20
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <stdint.h>
  24 #include <signal.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27 #include <fcntl.h>
  28 #include <sys/stat.h>
  29 #include <sys/wait.h>
  30
  31 #if !defined(NO_CALL_PERSONALITY)
  32 #include <sys/personality.h>
  33 #endif
  34
  35 #include <json-c/json.h>
  36
  37 #include <systemd/sd-daemon.h>
  38
  39 #include "afb-config.h"
  40 #include "afb-hswitch.h"
  41 #include "afb-apiset.h"
  42 #include "afb-api-so.h"
  43 #include "afb-api-dbus.h"
  44 #include "afb-api-ws.h"
  45 #include "afb-hsrv.h"
  46 #include "afb-hreq.h"
  47 #include "afb-xreq.h"
  48 #include "jobs.h"
  49 #include "afb-session.h"
  50 #include "verbose.h"
  51 #include "afb-common.h"
  52 #include "afb-monitor.h"
  53 #include "afb-hook.h"
  54 #include "sd-fds.h"
  55 #include "afb-debug.h"
  56 #include "process-name.h"
  57 #include "afb-supervision.h"
  58
  59 /*
  60    if SELF_PGROUP == 0 the launched command is the group leader
  61    if SELF_PGROUP != 0 afb-daemon is the group leader
  62 */
  63 #define SELF_PGROUP 1
  64
  65 struct afb_apiset *main_apiset;
  66
  67 static struct afb_config *config;
  68 static pid_t childpid;
  69
  70 /*----------------------------------------------------------
  71  |   helpers for handling list of arguments
  72  +--------------------------------------------------------- */
  73
  74 /*
  75  * Calls the callback 'run' for each value of the 'list'
  76  * until the callback returns 0 or the end of the list is reached.
  77  * Returns either NULL if the end of the list is reached or a pointer
  78  * to the item whose value made 'run' return 0.
  79  * 'closure' is used for passing user data.
  80  */
  81 static struct afb_config_list *run_for_list(struct afb_config_list *list,
  82                                             int (*run) (void *closure, char *value),
  83                                             void *closure)
  84 {
  85         while (list && run(closure, list->value))
  86                 list = list->next;
  87         return list;
  88 }
  89
  90 static int run_start(void *closure, char *value)
  91 {
  92         int (*starter) (const char *value, struct afb_apiset *apiset) = closure;
  93         return starter(value, main_apiset) >= 0;
  94 }
  95
  96 static void apiset_start_list(struct afb_config_list *list,
  97                        int (*starter) (const char *value, struct afb_apiset *apiset), const char *message)
  98 {
  99         list = run_for_list(list, run_start, starter);
 100         if (list) {
 101                 ERROR("can't start %s %s", message, list->value);
 102                 exit(1);
 103         }
 104 }
 105
 106 /*----------------------------------------------------------
 107  | exit_handler
 108  |   Handles on exit specific actions
 109  +--------------------------------------------------------- */
 110 static void exit_handler()
 111 {
 112         struct sigaction siga;
 113
 114         memset(&siga, 0, sizeof siga);
 115         siga.sa_handler = SIG_IGN;
 116         sigaction(SIGTERM, &siga, NULL);
 117
 118         if (SELF_PGROUP)
 119                 killpg(0, SIGTERM);
 120         else if (childpid > 0)
 121                 killpg(childpid, SIGTERM);
 122 }
 123
 124 static void on_sigterm(int signum, siginfo_t *info, void *uctx)
 125 {
 126         NOTICE("Received SIGTERM");
 127         exit(0);
 128 }
 129
 130 static void on_sighup(int signum, siginfo_t *info, void *uctx)
 131 {
 132         NOTICE("Received SIGHUP");
 133         /* TODO */
 134 }
 135
 136 static void setup_daemon()
 137 {
 138         struct sigaction siga;
 139
 140         /* install signal handlers */
 141         memset(&siga, 0, sizeof siga);
 142         siga.sa_flags = SA_SIGINFO;
 143
 144         siga.sa_sigaction = on_sigterm;
 145         sigaction(SIGTERM, &siga, NULL);
 146
 147         siga.sa_sigaction = on_sighup;
 148         sigaction(SIGHUP, &siga, NULL);
 149
 150         /* handle groups */
 151         atexit(exit_handler);
 152
 153         /* ignore any SIGPIPE */
 154         signal(SIGPIPE, SIG_IGN);
 155 }
 156
 157 /*----------------------------------------------------------
 158  | daemonize
 159  |   set the process in background
 160  +--------------------------------------------------------- */
 161 static void daemonize()
 162 {
 163         int consoleFD;
 164         int pid;
 165
 166         // open /dev/console to redirect output messAFBes
 167         consoleFD = open(config->console, O_WRONLY | O_APPEND | O_CREAT, 0640);
 168         if (consoleFD < 0) {
 169                 ERROR("AFB-daemon cannot open /dev/console (use --foreground)");
 170                 exit(1);
 171         }
 172         // fork process when running background mode
 173         pid = fork();
 174
 175         // if fail nothing much to do
 176         if (pid == -1) {
 177                 ERROR("AFB-daemon Failed to fork son process");
 178                 exit(1);
 179         }
 180         // if in father process, just leave
 181         if (pid != 0)
 182                 _exit(0);
 183
 184         // son process get all data in standalone mode
 185         NOTICE("background mode [pid:%d console:%s]", getpid(),
 186                config->console);
 187
 188         // redirect default I/O on console
 189         close(2);
 190         dup(consoleFD);         // redirect stderr
 191         close(1);
 192         dup(consoleFD);         // redirect stdout
 193         close(0);               // no need for stdin
 194         close(consoleFD);
 195
 196 #if 0
 197         setsid();               // allow father process to fully exit
 198         sleep(2);               // allow main to leave and release port
 199 #endif
 200 }
 201
 202 /*---------------------------------------------------------
 203  | http server
 204  |   Handles the HTTP server
 205  +--------------------------------------------------------- */
 206 static int init_alias(void *closure, char *spec)
 207 {
 208         struct afb_hsrv *hsrv = closure;
 209         char *path = strchr(spec, ':');
 210
 211         if (path == NULL) {
 212                 ERROR("Missing ':' in alias %s. Alias ignored", spec);
 213                 return 1;
 214         }
 215         *path++ = 0;
 216         INFO("Alias for url=%s to path=%s", spec, path);
 217         return afb_hsrv_add_alias(hsrv, spec, afb_common_rootdir_get_fd(), path,
 218                                   0, 0);
 219 }
 220
 221 static int init_http_server(struct afb_hsrv *hsrv)
 222 {
 223         if (!afb_hsrv_add_handler
 224             (hsrv, config->rootapi, afb_hswitch_websocket_switch, main_apiset, 20))
 225                 return 0;
 226
 227         if (!afb_hsrv_add_handler
 228             (hsrv, config->rootapi, afb_hswitch_apis, main_apiset, 10))
 229                 return 0;
 230
 231         if (run_for_list(config->aliases, init_alias, hsrv))
 232                 return 0;
 233
 234         if (config->roothttp != NULL) {
 235                 if (!afb_hsrv_add_alias
 236                     (hsrv, "", afb_common_rootdir_get_fd(), config->roothttp,
 237                      -10, 1))
 238                         return 0;
 239         }
 240
 241         if (!afb_hsrv_add_handler
 242             (hsrv, config->rootbase, afb_hswitch_one_page_api_redirect, NULL,
 243              -20))
 244                 return 0;
 245
 246         return 1;
 247 }
 248
 249 static struct afb_hsrv *start_http_server()
 250 {
 251         int rc;
 252         struct afb_hsrv *hsrv;
 253
 254         if (afb_hreq_init_download_path(config->uploaddir)) {
 255                 ERROR("unable to set the upload directory %s", config->uploaddir);
 256                 return NULL;
 257         }
 258
 259         hsrv = afb_hsrv_create();
 260         if (hsrv == NULL) {
 261                 ERROR("memory allocation failure");
 262                 return NULL;
 263         }
 264
 265         if (!afb_hsrv_set_cache_timeout(hsrv, config->cacheTimeout)
 266             || !init_http_server(hsrv)) {
 267                 ERROR("initialisation of httpd failed");
 268                 afb_hsrv_put(hsrv);
 269                 return NULL;
 270         }
 271
 272         NOTICE("Waiting port=%d rootdir=%s", config->httpdPort, config->rootdir);
 273         NOTICE("Browser URL= http://localhost:%d", config->httpdPort);
 274
 275         rc = afb_hsrv_start(hsrv, (uint16_t) config->httpdPort, 15);
 276         if (!rc) {
 277                 ERROR("starting of httpd failed");
 278                 afb_hsrv_put(hsrv);
 279                 return NULL;
 280         }
 281
 282         return hsrv;
 283 }
 284
 285 /*---------------------------------------------------------
 286  | execute_command
 287  +--------------------------------------------------------- */
 288
 289 static void on_sigchld(int signum, siginfo_t *info, void *uctx)
 290 {
 291         if (info->si_pid == childpid) {
 292                 switch (info->si_code) {
 293                 case CLD_EXITED:
 294                 case CLD_KILLED:
 295                 case CLD_DUMPED:
 296                         childpid = 0;
 297                         if (!SELF_PGROUP)
 298                                 killpg(info->si_pid, SIGKILL);
 299                         waitpid(info->si_pid, NULL, 0);
 300                         exit(0);
 301                 }
 302         }
 303 }
 304
 305 /*
 306 # @@ @
 307 # @p port
 308 # @t token
 309 */
 310
 311 #define SUBST_CHAR  '@'
 312 #define SUBST_STR   "@"
 313
 314 static char *instanciate_string(char *arg, const char *port, const char *token)
 315 {
 316         char *resu, *it, *wr;
 317         int chg, dif;
 318
 319         /* get the changes */
 320         chg = 0;
 321         dif = 0;
 322         it = strchrnul(arg, SUBST_CHAR);
 323         while (*it) {
 324                 switch(*++it) {
 325                 case 'p': chg++; dif += (int)strlen(port) - 2; break;
 326                 case 't': chg++; dif += (int)strlen(token) - 2; break;
 327                 case SUBST_CHAR: it++; chg++; dif--; break;
 328                 default: break;
 329                 }
 330                 it = strchrnul(it, SUBST_CHAR);
 331         }
 332
 333         /* return arg when no change */
 334         if (!chg)
 335                 return arg;
 336
 337         /* allocates the result */
 338         resu = malloc((it - arg) + dif + 1);
 339         if (!resu) {
 340                 ERROR("out of memory");
 341                 return NULL;
 342         }
 343
 344         /* instanciate the arguments */
 345         wr = resu;
 346         for (;;) {
 347                 it = strchrnul(arg, SUBST_CHAR);
 348                 wr = mempcpy(wr, arg, it - arg);
 349                 if (!*it)
 350                         break;
 351                 switch(*++it) {
 352                 case 'p': wr = stpcpy(wr, port); break;
 353                 case 't': wr = stpcpy(wr, token); break;
 354                 default: *wr++ = SUBST_CHAR; /*@fallthrough@*/
 355                 case SUBST_CHAR: *wr++ = *it;
 356                 }
 357                 arg = ++it;
 358         }
 359
 360         *wr = 0;
 361         return resu;
 362 }
 363
 364 static int instanciate_environ(const char *port, const char *token)
 365 {
 366         extern char **environ;
 367         char *repl;
 368         int i;
 369
 370         /* instanciate the environment */
 371         for (i = 0 ; environ[i] ; i++) {
 372                 repl = instanciate_string(environ[i], port, token);
 373                 if (!repl)
 374                         return -1;
 375                 environ[i] = repl;
 376         }
 377         return 0;
 378 }
 379
 380 static int instanciate_command_args(const char *port, const char *token)
 381 {
 382         char *repl;
 383         int i;
 384
 385         /* instanciate the arguments */
 386         for (i = 0 ; config->exec[i] ; i++) {
 387                 repl = instanciate_string(config->exec[i], port, token);
 388                 if (!repl)
 389                         return -1;
 390                 config->exec[i] = repl;
 391         }
 392         return 0;
 393 }
 394
 395 static int execute_command()
 396 {
 397         struct sigaction siga;
 398         char port[20];
 399         const char *token;
 400         int rc;
 401
 402         /* check whether a command is to execute or not */
 403         if (!config->exec || !config->exec[0])
 404                 return 0;
 405
 406         if (SELF_PGROUP)
 407                 setpgid(0, 0);
 408
 409         /* install signal handler */
 410         memset(&siga, 0, sizeof siga);
 411         siga.sa_sigaction = on_sigchld;
 412         siga.sa_flags = SA_SIGINFO;
 413         sigaction(SIGCHLD, &siga, NULL);
 414
 415         /* fork now */
 416         childpid = fork();
 417         if (childpid)
 418                 return 0;
 419
 420         /* compute the string for port */
 421         if (config->httpdPort)
 422                 rc = snprintf(port, sizeof port, "%d", config->httpdPort);
 423         else
 424                 rc = snprintf(port, sizeof port, "%cp", SUBST_CHAR);
 425         if (rc < 0 || rc >= (int)(sizeof port)) {
 426                 ERROR("port->txt failed");
 427         }
 428         else {
 429                 /* instanciate arguments and environment */
 430                 token = afb_session_initial_token();
 431                 if (instanciate_command_args(port, token) >= 0
 432                  && instanciate_environ(port, token) >= 0) {
 433                         /* run */
 434                         if (!SELF_PGROUP)
 435                                 setpgid(0, 0);
 436                         execv(config->exec[0], config->exec);
 437                         ERROR("can't launch %s: %m", config->exec[0]);
 438                 }
 439         }
 440         exit(1);
 441         return -1;
 442 }
 443
 444 /*---------------------------------------------------------
 445  | startup calls
 446  +--------------------------------------------------------- */
 447
 448 struct startup_req
 449 {
 450         struct afb_xreq xreq;
 451         char *api;
 452         char *verb;
 453         struct afb_config_list *current;
 454         struct afb_session *session;
 455 };
 456
 457 static void startup_call_reply(struct afb_xreq *xreq, int status, struct json_object *obj)
 458 {
 459         struct startup_req *sreq = CONTAINER_OF_XREQ(struct startup_req, xreq);
 460
 461         if (status >= 0)
 462                 NOTICE("startup call %s returned %s", sreq->current->value, json_object_get_string(obj));
 463         else {
 464                 ERROR("startup call %s ERROR! %s", sreq->current->value, json_object_get_string(obj));
 465                 exit(1);
 466         }
 467 }
 468
 469 static void startup_call_current(struct startup_req *sreq);
 470
 471 static void startup_call_unref(struct afb_xreq *xreq)
 472 {
 473         struct startup_req *sreq = CONTAINER_OF_XREQ(struct startup_req, xreq);
 474
 475         free(sreq->api);
 476         free(sreq->verb);
 477         json_object_put(sreq->xreq.json);
 478         sreq->current = sreq->current->next;
 479         if (sreq->current)
 480                 startup_call_current(sreq);
 481         else {
 482                 afb_session_close(sreq->session);
 483                 afb_session_unref(sreq->session);
 484                 free(sreq);
 485         }
 486 }
 487
 488 static struct afb_xreq_query_itf startup_xreq_itf =
 489 {
 490         .reply = startup_call_reply,
 491         .unref = startup_call_unref
 492 };
 493
 494 static void startup_call_current(struct startup_req *sreq)
 495 {
 496         char *api, *verb, *json;
 497
 498         api = sreq->current->value;
 499         verb = strchr(api, '/');
 500         if (verb) {
 501                 json = strchr(verb, ':');
 502                 if (json) {
 503                         afb_xreq_init(&sreq->xreq, &startup_xreq_itf);
 504                         afb_context_init(&sreq->xreq.context, sreq->session, NULL);
 505                         sreq->xreq.context.validated = 1;
 506                         sreq->api = strndup(api, verb - api);
 507                         sreq->verb = strndup(verb + 1, json - verb - 1);
 508                         sreq->xreq.request.api = sreq->api;
 509                         sreq->xreq.request.verb = sreq->verb;
 510                         sreq->xreq.json = json_tokener_parse(json + 1);
 511                         if (sreq->api && sreq->verb && sreq->xreq.json) {
 512                                 afb_xreq_process(&sreq->xreq, main_apiset);
 513                                 return;
 514                         }
 515                 }
 516         }
 517         ERROR("Bad call specification %s", sreq->current->value);
 518         exit(1);
 519 }
 520
 521 static void run_startup_calls()
 522 {
 523         struct afb_config_list *list;
 524         struct startup_req *sreq;
 525
 526         list = config->calls;
 527         if (list) {
 528                 sreq = calloc(1, sizeof *sreq);
 529                 sreq->session = afb_session_create(3600);
 530                 sreq->current = list;
 531                 startup_call_current(sreq);
 532         }
 533 }
 534
 535 /*---------------------------------------------------------
 536  | job for starting the daemon
 537  +--------------------------------------------------------- */
 538
 539 static void start(int signum, void *arg)
 540 {
 541         struct afb_hsrv *hsrv;
 542
 543         afb_debug("start-entry");
 544
 545         if (signum) {
 546                 ERROR("start aborted: received signal %s", strsignal(signum));
 547                 exit(1);
 548         }
 549
 550         /* set the directories */
 551         mkdir(config->workdir, S_IRWXU | S_IRGRP | S_IXGRP);
 552         if (chdir(config->workdir) < 0) {
 553                 ERROR("Can't enter working dir %s", config->workdir);
 554                 goto error;
 555         }
 556         if (afb_common_rootdir_set(config->rootdir) < 0) {
 557                 ERROR("failed to set common root directory");
 558                 goto error;
 559         }
 560
 561         /* configure the daemon */
 562         if (afb_session_init(config->nbSessionMax, config->cntxTimeout, config->token)) {
 563                 ERROR("initialisation of session manager failed");
 564                 goto error;
 565         }
 566         main_apiset = afb_apiset_create("main", config->apiTimeout);
 567         if (!main_apiset) {
 568                 ERROR("can't create main api set");
 569                 goto error;
 570         }
 571         if (afb_monitor_init() < 0) {
 572                 ERROR("failed to setup monitor");
 573                 goto error;
 574         }
 575         if (afb_supervision_init() < 0) {
 576                 ERROR("failed to setup supervision");
 577                 goto error;
 578         }
 579
 580         /* install hooks */
 581         if (config->tracereq)
 582                 afb_hook_create_xreq(NULL, NULL, NULL, config->tracereq, NULL, NULL);
 583         if (config->traceditf)
 584                 afb_hook_create_ditf(NULL, config->traceditf, NULL, NULL);
 585         if (config->tracesvc)
 586                 afb_hook_create_svc(NULL, config->tracesvc, NULL, NULL);
 587         if (config->traceevt)
 588                 afb_hook_create_evt(NULL, config->traceevt, NULL, NULL);
 589
 590         /* load bindings */
 591         afb_debug("start-load");
 592         apiset_start_list(config->so_bindings, afb_api_so_add_binding, "the binding");
 593         apiset_start_list(config->dbus_clients, afb_api_dbus_add_client, "the afb-dbus client");
 594         apiset_start_list(config->ws_clients, afb_api_ws_add_client_weak, "the afb-websocket client");
 595         apiset_start_list(config->ldpaths, afb_api_so_add_pathset_fails, "the binding path set");
 596         apiset_start_list(config->weak_ldpaths, afb_api_so_add_pathset_nofails, "the weak binding path set");
 597
 598         apiset_start_list(config->dbus_servers, afb_api_dbus_add_server, "the afb-dbus service");
 599         apiset_start_list(config->ws_servers, afb_api_ws_add_server, "the afb-websocket service");
 600
 601         DEBUG("Init config done");
 602
 603         /* start the services */
 604         afb_debug("start-start");
 605 #if !defined(NO_CALL_PERSONALITY)
 606         personality((unsigned long)-1L);
 607 #endif
 608         if (afb_apiset_start_all_services(main_apiset, 1) < 0)
 609                 goto error;
 610
 611         /* start the HTTP server */
 612         afb_debug("start-http");
 613         if (!config->noHttpd) {
 614                 if (config->httpdPort <= 0) {
 615                         ERROR("no port is defined");
 616                         goto error;
 617                 }
 618
 619                 if (!afb_hreq_init_cookie(config->httpdPort, config->rootapi, config->cntxTimeout)) {
 620                         ERROR("initialisation of HTTP cookies failed");
 621                         goto error;
 622                 }
 623
 624                 hsrv = start_http_server();
 625                 if (hsrv == NULL)
 626                         goto error;
 627         }
 628
 629         /* run the startup calls */
 630         afb_debug("start-call");
 631         run_startup_calls();
 632
 633         /* run the command */
 634         afb_debug("start-exec");
 635         if (execute_command() < 0)
 636                 goto error;
 637
 638         /* ready */
 639         sd_notify(1, "READY=1");
 640         return;
 641 error:
 642         exit(1);
 643 }
 644
 645 /*---------------------------------------------------------
 646  | main
 647  |   Parse option and launch action
 648  +--------------------------------------------------------- */
 649
 650 int main(int argc, char *argv[])
 651 {
 652         afb_debug("main-entry");
 653
 654         // let's run this program with a low priority
 655         nice(20);
 656
 657         sd_fds_init();
 658
 659         // ------------- Build session handler & init config -------
 660         config = afb_config_parse_arguments(argc, argv);
 661         if (config->name) {
 662                 verbose_set_name(config->name, 0);
 663                 process_name_set_name(config->name);
 664                 process_name_replace_cmdline(argv, config->name);
 665         }
 666         afb_debug("main-args");
 667
 668         // --------- run -----------
 669         if (config->background) {
 670                 // --------- in background mode -----------
 671                 INFO("entering background mode");
 672                 daemonize();
 673         } else {
 674                 // ---- in foreground mode --------------------
 675                 INFO("entering foreground mode");
 676         }
 677         INFO("running with pid %d", getpid());
 678
 679         /* set the daemon environment */
 680         setup_daemon();
 681
 682         afb_debug("main-start");
 683
 684         /* enter job processing */
 685         jobs_start(3, 0, 50, start, NULL);
 686         WARNING("hoops returned from jobs_enter! [report bug]");
 687         return 1;
 688 }
 689