b82f3e57a6acd2eb82b602e7d354d41edbdd3ba2
[src/app-framework-binder.git] / src / afb-config.c
1 /*
2  * Copyright (C) 2015, 2016, 2017 "IoT.bzh"
3  * Author José Bollo <jose.bollo@iot.bzh>
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  *   http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 #define _GNU_SOURCE
19
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <getopt.h>
24 #include <limits.h>
25 #include <unistd.h>
26
27 #include <json-c/json.h>
28
29 #include "verbose.h"
30 #include "afb-config.h"
31 #include "afb-hook.h"
32
33 #include <afb/afb-binding-v1.h>
34
35 #if !defined(BINDING_INSTALL_DIR)
36 #error "you should define BINDING_INSTALL_DIR"
37 #endif
38 #if !defined(AFB_VERSION)
39 #error "you should define AFB_VERSION"
40 #endif
41
42 // default
43 #define DEFLT_CNTX_TIMEOUT  3600        // default Client Connection
44                                         // Timeout
45 #define DEFLT_API_TIMEOUT   20          // default Plugin API Timeout [0=NoLimit
46                                         // for Debug Only]
47 #define DEFLT_CACHE_TIMEOUT 100000      // default Static File Chache
48                                         // [Client Side Cache
49                                         // 100000~=1day]
50 #define CTX_NBCLIENTS       10          // allow a default of 10 authenticated
51                                         // clients
52
53
54 // Define command line option
55 #define SET_BACKGROUND     2
56 #define SET_FORGROUND      3
57
58 #define SET_ROOT_DIR       6
59 #define SET_ROOT_BASE      7
60 #define SET_ROOT_API       8
61 #define SET_ALIAS          9
62
63 #define SET_CACHE_TIMEOUT  10
64 #define SET_SESSION_DIR    11
65
66 #define SET_LDPATH         13
67 #define SET_APITIMEOUT     14
68 #define SET_CNTXTIMEOUT    15
69 #define SET_WEAK_LDPATH    16
70 #define NO_LDPATH          17
71
72 #define SET_MODE           18
73
74 #define DBUS_CLIENT        20
75 #define DBUS_SERVICE       21
76 #define SO_BINDING         22
77
78 #define SET_SESSIONMAX     23
79
80 #define WS_CLIENT          24
81 #define WS_SERVICE         25
82
83 #define SET_ROOT_HTTP      26
84
85 #define SET_NO_HTTPD       28
86
87 #define ADD_CALL           'c'
88 #define SET_TRACEDITF      'D'
89 #define SET_TRACEEVT       'E'
90 #define SET_EXEC           'e'
91 #define DISPLAY_HELP       'h'
92 #if defined(WITH_MONITORING_OPTION)
93 #define SET_MONITORING     'M'
94 #endif
95 #define SET_NAME           'n'
96 #define SET_TCP_PORT       'p'
97 #define SET_QUIET          'q'
98 #define SET_RNDTOKEN       'r'
99 #define SET_TRACESVC       'S'
100 #define SET_TRACEREQ       'T'
101 #define SET_AUTH_TOKEN     't'
102 #define SET_UPLOAD_DIR     'u'
103 #define DISPLAY_VERSION    'V'
104 #define SET_VERBOSE        'v'
105 #define SET_WORK_DIR       'w'
106
107 const char shortopts[] =
108         "c:D:E:ehn:p:qrT:t:u:Vvw:"
109 #if defined(WITH_MONITORING_OPTION)
110         "M"
111 #endif
112 ;
113
114 // Command line structure hold cli --command + help text
115 typedef struct {
116         int val;                // command number within application
117         int has_arg;            // command number within application
118         char *name;             // command as used in --xxxx cli
119         char *help;             // help text
120 } AFB_options;
121
122 // Supported option
123 static AFB_options cliOptions[] = {
124 /* *INDENT-OFF* */
125         {SET_VERBOSE,       0, "verbose",     "Verbose Mode, repeat to increase verbosity"},
126         {SET_QUIET,         0, "quiet",       "Quiet Mode, repeat to decrease verbosity"},
127
128         {SET_FORGROUND,     0, "foreground",  "Get all in foreground mode"},
129         {SET_BACKGROUND,    0, "daemon",      "Get all in background mode"},
130
131         {SET_NAME,          1, "name",        "Set the visible name"},
132
133         {SET_TCP_PORT,      1, "port",        "HTTP listening TCP port  [default 1234]"},
134         {SET_ROOT_HTTP,     1, "roothttp",    "HTTP Root Directory [default no root http (files not served but apis still available)]"},
135         {SET_ROOT_BASE,     1, "rootbase",    "Angular Base Root URL [default /opa]"},
136         {SET_ROOT_API,      1, "rootapi",     "HTML Root API URL [default /api]"},
137         {SET_ALIAS,         1, "alias",       "Multiple url map outside of rootdir [eg: --alias=/icons:/usr/share/icons]"},
138
139         {SET_APITIMEOUT,    1, "apitimeout",  "Binding API timeout in seconds [default 10]"},
140         {SET_CNTXTIMEOUT,   1, "cntxtimeout", "Client Session Context Timeout [default 900]"},
141         {SET_CACHE_TIMEOUT, 1, "cache-eol",   "Client cache end of live [default 3600]"},
142
143         {SET_WORK_DIR,      1, "workdir",     "Set the working directory [default: $PWD or current working directory]"},
144         {SET_UPLOAD_DIR,    1, "uploaddir",   "Directory for uploading files [default: workdir]"},
145         {SET_ROOT_DIR,      1, "rootdir",     "Root Directory of the application [default: workdir]"},
146         {SET_SESSION_DIR,   1, "sessiondir",  "OBSOLETE (was: Sessions file path)"},
147
148         {SET_LDPATH,        1, "ldpaths",     "Load bindings from dir1:dir2:... [default = " BINDING_INSTALL_DIR "]"},
149         {SO_BINDING,        1, "binding",     "Load the binding of path"},
150         {SET_WEAK_LDPATH,   1, "weak-ldpaths","Same as --ldpaths but ignore errors"},
151         {NO_LDPATH,         0, "no-ldpaths",  "Discard default ldpaths loading"},
152
153         {SET_AUTH_TOKEN,    1, "token",       "Initial Secret [default=random, use --token="" to allow any token]"},
154         {SET_RNDTOKEN,      0, "random-token","Enforce a random token"},
155
156         {DISPLAY_VERSION,   0, "version",     "Display version and copyright"},
157         {DISPLAY_HELP,      0, "help",        "Display this help"},
158
159         {SET_MODE,          1, "mode",        "Set the mode: either local, remote or global"},
160
161         {DBUS_CLIENT,       1, "dbus-client", "Bind to an afb service through dbus"},
162         {DBUS_SERVICE,      1, "dbus-server", "Provides an afb service through dbus"},
163         {WS_CLIENT,         1, "ws-client",   "Bind to an afb service through websocket"},
164         {WS_SERVICE,        1, "ws-server",   "Provides an afb service through websockets"},
165
166         {SET_SESSIONMAX,    1, "session-max", "Max count of session simultaneously [default 10]"},
167
168         {SET_TRACEREQ,      1, "tracereq",    "Log the requests: no, common, extra, all"},
169         {SET_TRACEDITF,     1, "traceditf",   "Log the requests: no, common, extra, all"},
170         {SET_TRACESVC,      1, "tracesvc",    "Log the requests: no, all"},
171         {SET_TRACEEVT,      1, "traceevt",    "Log the requests: no, common, extra, all"},
172
173         {ADD_CALL,          1, "call",        "call at start format of val: API/VERB:json-args"},
174
175         {SET_NO_HTTPD,      0, "no-httpd",    "Forbids HTTP service"},
176         {SET_EXEC,          0, "exec",        "Execute the remaining arguments"},
177
178 #if defined(WITH_MONITORING_OPTION)
179         {SET_MONITORING,    0, "monitoring",  "enable HTTP monitoring at <ROOT>/monitoring/"},
180 #endif
181         {0, 0, NULL, NULL}
182 /* *INDENT-ON* */
183 };
184
185
186 struct enumdesc
187 {
188         const char *name;
189         int value;
190 };
191
192 static struct enumdesc tracereq_desc[] = {
193         { "no",     0 },
194         { "common", afb_hook_flags_req_common },
195         { "extra",  afb_hook_flags_req_extra },
196         { "all",    afb_hook_flags_req_all },
197         { NULL, 0 }
198 };
199
200 static struct enumdesc traceditf_desc[] = {
201         { "no",     0 },
202         { "common", afb_hook_flags_ditf_common },
203         { "extra",  afb_hook_flags_ditf_extra },
204         { "all",    afb_hook_flags_ditf_all },
205         { NULL, 0 }
206 };
207
208 static struct enumdesc tracesvc_desc[] = {
209         { "no",     0 },
210         { "all",    afb_hook_flags_svc_all },
211         { NULL, 0 }
212 };
213
214 static struct enumdesc traceevt_desc[] = {
215         { "no",     0 },
216         { "common", afb_hook_flags_evt_common },
217         { "extra",  afb_hook_flags_evt_extra },
218         { "all",    afb_hook_flags_evt_all },
219         { NULL, 0 }
220 };
221
222 static struct enumdesc mode_desc[] = {
223         { "local",  AFB_MODE_LOCAL },
224         { "remote", AFB_MODE_REMOTE },
225         { "global", AFB_MODE_GLOBAL },
226         { NULL, 0 }
227 };
228
229 /*----------------------------------------------------------
230  | printversion
231  |   print version and copyright
232  +--------------------------------------------------------- */
233 static void printVersion(FILE * file)
234 {
235         static const char version[] =
236                 "\n"
237                 "  AFB [Application Framework Binder] version="AFB_VERSION"\n"
238                 "\n"
239                 "  Copyright (C) 2015, 2016, 2017 \"IoT.bzh\"\n"
240                 "  AFB comes with ABSOLUTELY NO WARRANTY.\n"
241                 "  Licence Apache 2\n"
242                 "\n";
243
244         fprintf(file, "%s", version);
245 }
246
247 /*----------------------------------------------------------
248  | printHelp
249  |   print information from long option array
250  +--------------------------------------------------------- */
251
252 static void printHelp(FILE * file, const char *name)
253 {
254         int ind;
255         char command[50];
256
257         fprintf(file, "%s:\nallowed options\n", name);
258         for (ind = 0; cliOptions[ind].name != NULL; ind++) {
259                 strcpy(command, cliOptions[ind].name);
260                 if (cliOptions[ind].has_arg)
261                         strcat(command, "=xxxx");
262                 fprintf(file, "  --%-15s %s\n", command, cliOptions[ind].help);
263         }
264         fprintf(file,
265                 "Example:\n  %s  --verbose --port=1234 --token='azerty' --ldpaths=build/bindings:/usr/lib64/agl/bindings\n",
266                 name);
267 }
268
269
270 /*----------------------------------------------------------
271  |   adds a string to the list
272  +--------------------------------------------------------- */
273 static void list_add(struct afb_config_list **head, char *value)
274 {
275         struct afb_config_list *item;
276
277         /*
278          * search tail
279          */
280         item = *head;
281         while (item != NULL) {
282                 head = &item->next;
283                 item = item->next;
284         }
285
286         /*
287          * alloc the item
288          */
289         item = malloc(sizeof *item);
290         if (item == NULL) {
291                 ERROR("out of memory");
292                 exit(1);
293         }
294
295         /*
296          * init the item
297          */
298         *head = item;
299         item->value = value;
300         item->next = NULL;
301 }
302
303 /*---------------------------------------------------------
304  |   helpers for argument scanning
305  +--------------------------------------------------------- */
306
307 static const char *name_of_option(int optc)
308 {
309         AFB_options *o = cliOptions;
310         while (o->name && o->val != optc)
311                 o++;
312         return o->name ? : "<unknown-option-name>";
313 }
314
315 static const char *current_argument(int optc)
316 {
317         if (optarg == 0) {
318                 ERROR("option [--%s] needs a value i.e. --%s=xxx",
319                       name_of_option(optc), name_of_option(optc));
320                 exit(1);
321         }
322         return optarg;
323 }
324
325 static char *argvalstr(int optc)
326 {
327         char *result = strdup(current_argument(optc));
328         if (result == NULL) {
329                 ERROR("can't alloc memory");
330                 exit(1);
331         }
332         return result;
333 }
334
335 static int argvalenum(int optc, struct enumdesc *desc)
336 {
337         int i;
338         size_t len;
339         char *list;
340         const char *name = current_argument(optc);
341
342         i = 0;
343         while(desc[i].name && strcmp(desc[i].name, name))
344                 i++;
345         if (!desc[i].name) {
346                 len = 0;
347                 i = 0;
348                 while(desc[i].name)
349                         len += strlen(desc[i++].name);
350                 list = malloc(len + i + i);
351                 if (!i || !list)
352                         ERROR("option [--%s] bad value (found %s)",
353                                 name_of_option(optc), name);
354                 else {
355                         i = 0;
356                         strcpy(list, desc[i].name ? : "");
357                         while(desc[++i].name)
358                                 strcat(strcat(list, ", "), desc[i].name);
359                         ERROR("option [--%s] bad value, only accepts values %s (found %s)",
360                                 name_of_option(optc), list, name);
361                 }
362                 free(list);
363                 exit(1);
364         }
365         return desc[i].value;
366 }
367
368 static int argvalint(int optc, int mini, int maxi, int base)
369 {
370         const char *beg, *end;
371         long int val;
372         beg = current_argument(optc);
373         val = strtol(beg, (char**)&end, base);
374         if (*end || end == beg) {
375                 ERROR("option [--%s] requires a valid integer (found %s)",
376                         name_of_option(optc), beg);
377                 exit(1);
378         }
379         if (val < (long int)mini || val > (long int)maxi) {
380                 ERROR("option [--%s] value out of bounds (not %d<=%ld<=%d)",
381                         name_of_option(optc), mini, val, maxi);
382                 exit(1);
383         }
384         return (int)val;
385 }
386
387 static int argvalintdec(int optc, int mini, int maxi)
388 {
389         return argvalint(optc, mini, maxi, 10);
390 }
391
392 static void noarg(int optc)
393 {
394         if (optarg != 0) {
395                 ERROR("option [--%s] need no value (found %s)", name_of_option(optc), optarg);
396                 exit(1);
397         }
398 }
399
400 static char **make_exec(char **argv)
401 {
402         char **result, *iter;
403         size_t length;
404         int i;
405
406         length = 0;
407         for (i = 0 ; argv[i] ; i++)
408                 length += strlen(argv[i]) + 1;
409
410         result = malloc(length + ((unsigned)(i + 1)) * sizeof *result);
411         if (result == NULL) {
412                 ERROR("can't alloc memory");
413                 exit(1);
414         }
415
416         iter = (char*)&result[i+1];
417         for (i = 0 ; argv[i] ; i++) {
418                 result[i] = iter;
419                 iter = stpcpy(iter, argv[i]) + 1;
420         }
421         result[i] = NULL;
422         return result;
423 }
424
425 /*---------------------------------------------------------
426  |   Parse option and launch action
427  +--------------------------------------------------------- */
428
429 static void parse_arguments(int argc, char **argv, struct afb_config *config)
430 {
431         char *programName = argv[0];
432         int optc, ind;
433         int nbcmd;
434         struct option *gnuOptions;
435
436         // ------------------ Process Command Line -----------------------
437
438         // build GNU getopt info from cliOptions
439         nbcmd = sizeof(cliOptions) / sizeof(AFB_options);
440         gnuOptions = malloc(sizeof(*gnuOptions) * (unsigned)nbcmd);
441         for (ind = 0; ind < nbcmd; ind++) {
442                 gnuOptions[ind].name = cliOptions[ind].name;
443                 gnuOptions[ind].has_arg = cliOptions[ind].has_arg;
444                 gnuOptions[ind].flag = 0;
445                 gnuOptions[ind].val = cliOptions[ind].val;
446         }
447
448         // get all options from command line
449         while ((optc = getopt_long(argc, argv, shortopts, gnuOptions, NULL)) != EOF) {
450                 switch (optc) {
451                 case SET_VERBOSE:
452                         verbosity++;
453                         break;
454
455                 case SET_QUIET:
456                         verbosity--;
457                         break;
458
459                 case SET_TCP_PORT:
460                         config->httpdPort = argvalintdec(optc, 1024, 32767);
461                         break;
462
463                 case SET_APITIMEOUT:
464                         config->apiTimeout = argvalintdec(optc, 0, INT_MAX);
465                         break;
466
467                 case SET_CNTXTIMEOUT:
468                         config->cntxTimeout = argvalintdec(optc, 0, INT_MAX);
469                         break;
470
471                 case SET_ROOT_DIR:
472                         config->rootdir = argvalstr(optc);
473                         INFO("Forcing Rootdir=%s", config->rootdir);
474                         break;
475
476                 case SET_ROOT_HTTP:
477                         config->roothttp = argvalstr(optc);
478                         INFO("Forcing Root HTTP=%s", config->roothttp);
479                         break;
480
481                 case SET_ROOT_BASE:
482                         config->rootbase = argvalstr(optc);
483                         INFO("Forcing Rootbase=%s", config->rootbase);
484                         break;
485
486                 case SET_ROOT_API:
487                         config->rootapi = argvalstr(optc);
488                         INFO("Forcing Rootapi=%s", config->rootapi);
489                         break;
490
491                 case SET_ALIAS:
492                         list_add(&config->aliases, argvalstr(optc));
493                         break;
494
495                 case SET_AUTH_TOKEN:
496                         config->token = argvalstr(optc);
497                         break;
498
499                 case SET_LDPATH:
500                         list_add(&config->ldpaths, argvalstr(optc));
501                         break;
502
503                 case SET_WEAK_LDPATH:
504                         list_add(&config->weak_ldpaths, argvalstr(optc));
505                         break;
506
507                 case NO_LDPATH:
508                         noarg(optc);
509                         config->no_ldpaths = 1;
510                         break;
511
512                 case ADD_CALL:
513                         list_add(&config->calls, argvalstr(optc));
514                         break;
515
516                 case SET_SESSION_DIR:
517                         /* config->sessiondir = argvalstr(optc); */
518                         WARNING("Obsolete option %s ignored", name_of_option(optc));
519                         break;
520
521                 case SET_UPLOAD_DIR:
522                         config->uploaddir = argvalstr(optc);
523                         break;
524
525                 case SET_WORK_DIR:
526                         config->workdir = argvalstr(optc);
527                         break;
528
529                 case SET_CACHE_TIMEOUT:
530                         config->cacheTimeout = argvalintdec(optc, 0, INT_MAX);
531                         break;
532
533                 case SET_SESSIONMAX:
534                         config->nbSessionMax = argvalintdec(optc, 1, INT_MAX);
535                         break;
536
537                 case SET_FORGROUND:
538                         noarg(optc);
539                         config->background = 0;
540                         break;
541
542                 case SET_BACKGROUND:
543                         noarg(optc);
544                         config->background = 1;
545                         break;
546
547                 case SET_NAME:
548                         config->name = argvalstr(optc);
549                         break;
550
551                 case SET_MODE:
552                         config->mode = argvalenum(optc, mode_desc);
553                         break;
554
555                 case DBUS_CLIENT:
556                         list_add(&config->dbus_clients, argvalstr(optc));
557                         break;
558
559                 case DBUS_SERVICE:
560                         list_add(&config->dbus_servers, argvalstr(optc));
561                         break;
562
563                 case WS_CLIENT:
564                         list_add(&config->ws_clients, argvalstr(optc));
565                         break;
566
567                 case WS_SERVICE:
568                         list_add(&config->ws_servers, argvalstr(optc));
569                         break;
570
571                 case SO_BINDING:
572                         list_add(&config->so_bindings, argvalstr(optc));
573                         break;
574
575                 case SET_TRACEREQ:
576                         config->tracereq = argvalenum(optc, tracereq_desc);
577                         break;
578
579                 case SET_TRACEDITF:
580                         config->traceditf = argvalenum(optc, traceditf_desc);
581                         break;
582
583                 case SET_TRACESVC:
584                         config->tracesvc = argvalenum(optc, tracesvc_desc);
585                         break;
586
587                 case SET_TRACEEVT:
588                         config->traceevt = argvalenum(optc, traceevt_desc);
589                         break;
590
591                 case SET_NO_HTTPD:
592                         noarg(optc);
593                         config->noHttpd = 1;
594                         break;
595
596                 case SET_EXEC:
597                         config->exec = make_exec(&argv[optind]);
598                         optind = argc; /* stop option scanning */
599                         break;
600
601                 case SET_RNDTOKEN:
602                         config->random_token = 1;
603                         break;
604
605 #if defined(WITH_MONITORING_OPTION)
606                 case SET_MONITORING:
607                         config->monitoring = 1;
608                         break;
609 #endif
610
611                 case DISPLAY_VERSION:
612                         noarg(optc);
613                         printVersion(stdout);
614                         exit(0);
615
616                 case DISPLAY_HELP:
617                         printHelp(stdout, programName);
618                         exit(0);
619
620                 default:
621                         exit(1);
622                 }
623         }
624         free(gnuOptions);
625 }
626
627 static void fulfill_config(struct afb_config *config)
628 {
629         // default HTTP port
630         if (config->httpdPort == 0)
631                 config->httpdPort = 1234;
632
633         // default binding API timeout
634         if (config->apiTimeout == 0)
635                 config->apiTimeout = DEFLT_API_TIMEOUT;
636
637         // default AUTH_TOKEN
638         if (config->random_token)
639                 config->token = NULL;
640
641         // cache timeout default one hour
642         if (config->cacheTimeout == 0)
643                 config->cacheTimeout = DEFLT_CACHE_TIMEOUT;
644
645         // cache timeout default one hour
646         if (config->cntxTimeout == 0)
647                 config->cntxTimeout = DEFLT_CNTX_TIMEOUT;
648
649         // max count of sessions
650         if (config->nbSessionMax == 0)
651                 config->nbSessionMax = CTX_NBCLIENTS;
652
653         /* set directories */
654         if (config->workdir == NULL)
655                 config->workdir = ".";
656
657         if (config->rootdir == NULL)
658                 config->rootdir = ".";
659
660         if (config->uploaddir == NULL)
661                 config->uploaddir = ".";
662
663         // if no Angular/HTML5 rootbase let's try '/' as default
664         if (config->rootbase == NULL)
665                 config->rootbase = "/opa";
666
667         if (config->rootapi == NULL)
668                 config->rootapi = "/api";
669
670         if (config->ldpaths == NULL && config->weak_ldpaths == NULL && !config->no_ldpaths)
671                 list_add(&config->ldpaths, BINDING_INSTALL_DIR);
672
673 #if defined(WITH_MONITORING_OPTION)
674         if (config->monitoring)
675                 list_add(&config->aliases, strdup("/monitoring:"BINDING_INSTALL_DIR"/monitoring"));
676 #endif
677
678         // if no config dir create a default path from uploaddir
679         if (config->console == NULL) {
680                 config->console = malloc(512);
681                 strncpy(config->console, config->uploaddir, 512);
682                 strncat(config->console, "/AFB-console.out", 512);
683         }
684 }
685
686 void afb_config_dump(struct afb_config *config)
687 {
688         struct afb_config_list *l;
689         struct enumdesc *e;
690         char **v;
691
692 #define NN(x)   (x)?:""
693 #define P(...)  fprintf(stderr, __VA_ARGS__)
694 #define PF(x)   P("-- %15s: ", #x)
695 #define PE      P("\n")
696 #define S(x)    PF(x);P("%s",NN(config->x));PE;
697 #define D(x)    PF(x);P("%d",config->x);PE;
698 #define B(x)    PF(x);P("%s",config->x?"yes":"no");PE;
699 #define L(x)    PF(x);l=config->x;if(l){P("%s\n",NN(l->value));for(l=l->next;l;l=l->next)P("-- %15s  %s\n","",NN(l->value));}else PE;
700 #define E(x,d)  for(e=d;e->name&&e->value!=config->x;e++);if(e->name){PF(x);P("%s",e->name);PE;}else{D(x);}
701 #define V(x)    P("-- %15s:", #x);for(v=config->x;v&&*v;v++)P(" %s",*v); PE;
702
703         P("---BEGIN-OF-CONFIG---\n");
704         S(console)
705         S(rootdir)
706         S(roothttp)
707         S(rootbase)
708         S(rootapi)
709         S(workdir)
710         S(uploaddir)
711         S(token)
712         S(name)
713
714         L(aliases)
715         L(dbus_clients)
716         L(dbus_servers)
717         L(ws_clients)
718         L(ws_servers)
719         L(so_bindings)
720         L(ldpaths)
721         L(weak_ldpaths)
722         L(calls)
723
724         V(exec)
725
726         D(httpdPort)
727         D(cacheTimeout)
728         D(apiTimeout)
729         D(cntxTimeout)
730         D(nbSessionMax)
731
732         E(mode,mode_desc)
733         E(tracereq,tracereq_desc)
734         E(traceditf,traceditf_desc)
735         E(tracesvc,tracesvc_desc)
736         E(traceevt,traceevt_desc)
737
738         B(no_ldpaths)
739         B(noHttpd)
740         B(background)
741         B(monitoring)
742         B(random_token)
743         P("---END-OF-CONFIG---\n");
744
745 #undef V
746 #undef E
747 #undef L
748 #undef B
749 #undef D
750 #undef S
751 #undef PE
752 #undef PF
753 #undef P
754 #undef NN
755 }
756
757 static void on_environment_list(struct afb_config_list **to, const char *name)
758 {
759         char *value = getenv(name);
760
761         if (value)
762                 list_add(to, value);
763 }
764
765 static void on_environment_enum(int *to, const char *name, struct enumdesc *desc)
766 {
767         char *value = getenv(name);
768
769         if (value) {
770                 while (desc->name) {
771                         if (strcmp(desc->name, value))
772                                 desc++;
773                         else {
774                                 *to = desc->value;
775                                 return;
776                         }
777                 }
778                 WARNING("Unknown value %s for environment variable %s, ignored", value, name);
779         }
780 }
781
782 static void parse_environment(struct afb_config *config)
783 {
784         on_environment_enum(&config->tracereq, "AFB_TRACEREQ", tracereq_desc);
785         on_environment_enum(&config->traceditf, "AFB_TRACEDITF", traceditf_desc);
786         on_environment_enum(&config->tracesvc, "AFB_TRACESVC", tracesvc_desc);
787         on_environment_enum(&config->traceevt, "AFB_TRACEEVT", traceevt_desc);
788         on_environment_list(&config->ldpaths, "AFB_LDPATHS");
789 }
790
791 struct afb_config *afb_config_parse_arguments(int argc, char **argv)
792 {
793         struct afb_config *result;
794
795         result = calloc(1, sizeof *result);
796
797         parse_environment(result);
798         parse_arguments(argc, argv, result);
799         fulfill_config(result);
800         if (verbosity >= 3)
801                 afb_config_dump(result);
802         return result;
803 }
804
805 struct json_object *afb_config_json(struct afb_config *config)
806 {
807         struct json_object *r, *a;
808         struct afb_config_list *l;
809         struct enumdesc *e;
810         char **v;
811
812 #define XA(t,o)         json_object_array_add(t,o);
813 #define XO(t,x,o)       json_object_object_add(t,x,o);
814 #define YS(s)           ((s)?json_object_new_string(s):NULL)
815
816 #define AO(o)           XA(a,o)
817 #define AS(s)           AO(YS(s))
818 #define RO(x,o)         XO(r,x,o)
819 #define RS(x,s)         RO(x,YS(s))
820 #define RA(x)           RO(x,(a=json_object_new_array()))
821 #define RI(x,i)         RO(x,json_object_new_int(i))
822 #define RB(x,b)         RO(x,json_object_new_boolean(b))
823
824 #define S(x)            RS(#x,config->x)
825 #define V(x)            RA(#x);for(v=config->x;v&&*v;v++)AS(*v);
826 #define L(x)            RA(#x);for(l=config->x;l;l=l->next)AS(l->value);
827 #define D(x)            RI(#x,config->x)
828 #define B(x)            RB(#x,config->x)
829 #define E(x,d)          for(e=d;e->name&&e->value!=config->x;e++);if(e->name){RS(#x,e->name);}else{D(x);}
830
831         r = json_object_new_object();
832         S(console)
833         S(rootdir)
834         S(roothttp)
835         S(rootbase)
836         S(rootapi)
837         S(workdir)
838         S(uploaddir)
839         S(token)
840         S(name)
841
842         L(aliases)
843         L(dbus_clients)
844         L(dbus_servers)
845         L(ws_clients)
846         L(ws_servers)
847         L(so_bindings)
848         L(ldpaths)
849         L(weak_ldpaths)
850         L(calls)
851
852         V(exec)
853
854         D(httpdPort)
855         D(cacheTimeout)
856         D(apiTimeout)
857         D(cntxTimeout)
858         D(nbSessionMax)
859
860         E(mode,mode_desc)
861         E(tracereq,tracereq_desc)
862         E(traceditf,traceditf_desc)
863         E(tracesvc,tracesvc_desc)
864         E(traceevt,traceevt_desc)
865
866         B(no_ldpaths)
867         B(noHttpd)
868         B(background)
869         B(monitoring)
870         B(random_token)
871
872 #undef E
873 #undef B
874 #undef D
875 #undef L
876 #undef V
877 #undef S
878
879 #undef RB
880 #undef RI
881 #undef RA
882 #undef RS
883 #undef RS
884 #undef AS
885 #undef AO
886
887 #undef YS
888 #undef XO
889 #undef XA
890
891         return r;
892 }
893