4010fb1efa50e2d130d1c8ab824c2aca52acc695
[src/app-framework-main.git] / src / afm-udb.c
1 /*
2  Copyright (C) 2015-2018 IoT.bzh
3
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 #include <stdlib.h>
20 #include <stdio.h>
21 #include <assert.h>
22 #include <string.h>
23 #include <errno.h>
24 #include <dirent.h>
25 #include <fcntl.h>
26 #include <unistd.h>
27 #include <sys/types.h>
28
29 #include <json-c/json.h>
30
31 #include "utils-json.h"
32 #include "utils-systemd.h"
33 #include "utils-file.h"
34
35 #include "afm-udb.h"
36
37 static const char x_afm_prefix[] = "X-AFM-";
38 static const char service_extension[] = ".service";
39 static const char key_unit_path[] = "-unit-path";
40 static const char key_unit_name[] = "-unit-name";
41 static const char key_unit_scope[] = "-unit-scope";
42 static const char scope_user[] = "user";
43 static const char scope_system[] = "system";
44 static const char key_id[] = "id";
45
46 #define x_afm_prefix_length  (sizeof x_afm_prefix - 1)
47 #define service_extension_length  (sizeof service_extension - 1)
48
49 /*
50  * The structure afm_apps records the data about applications
51  * for several accesses.
52  */
53 struct afm_apps {
54         struct json_object *prvarr; /* array of the private data of apps */
55         struct json_object *pubarr; /* array of the public data of apps */
56         struct json_object *pubobj; /* hash of application's publics */
57         struct json_object *prvobj; /* hash of application's privates */
58 };
59
60 /*
61  * The structure afm_udb records the applications
62  * for a set of directories recorded as a linked list
63  */
64 struct afm_udb {
65         struct afm_apps applications;   /* the data about applications */
66         int refcount;                   /* count of references to the structure */
67         int system;                     /* is managing system units? */
68         int user;                       /* is managing user units? */
69         size_t prefixlen;               /* length of the prefix */
70         char prefix[1];                 /* filtering prefix */
71 };
72
73 /*
74  * The structure afm_updt is internally used for updates
75  */
76 struct afm_updt {
77         struct afm_udb *afudb;
78         struct afm_apps applications;
79 };
80
81 /*
82  * The default language
83  */
84 static char *default_lang;
85
86 /*
87  * Release the data of the afm_apps object 'apps'.
88  */
89 static void apps_put(struct afm_apps *apps)
90 {
91         json_object_put(apps->prvarr);
92         json_object_put(apps->pubarr);
93         json_object_put(apps->pubobj);
94         json_object_put(apps->prvobj);
95 }
96
97 /*
98  * Append the field 'data' to the field 'name' of the 'object'.
99  * When a second append is done to one field, it is automatically
100  * transformed to an array.
101  * Return 0 in case of success or -1 in case of error.
102  */
103 static int append_field(
104                 struct json_object *object,
105                 const char *name,
106                 struct json_object *data
107 )
108 {
109         struct json_object *item, *array;
110
111         if (!json_object_object_get_ex(object, name, &item))
112                 json_object_object_add(object, name, data);
113         else {
114                 if (json_object_is_type(item, json_type_array))
115                         array = item;
116                 else {
117                         array = json_object_new_array();
118                         if (!array)
119                                 goto error;
120                         json_object_array_add(array, item);
121                         json_object_object_add(object, name, array);
122                 }
123                 json_object_array_add(array, data);
124         }
125         return 0;
126  error:
127         json_object_put(data);
128         errno = ENOMEM;
129         return -1;
130 }
131
132 /*
133  * Adds the field of 'name' and 'value' in 'priv' and also if possible in 'pub'
134  * Returns 0 on success or -1 on error.
135  */
136 static int add_field(
137                 struct json_object *priv,
138                 struct json_object *pub,
139                 const char *name,
140                 const char *value
141 )
142 {
143         long int ival;
144         char *end;
145         struct json_object *v;
146
147         /* try to adapt the value to its type */
148         errno = 0;
149         ival = strtol(value, &end, 10);
150         if (*value && !*end && !errno) {
151                 /* integer value */
152                 v = json_object_new_int64(ival);
153         } else {
154                 /* string value */
155                 v = json_object_new_string(value);
156         }
157         if (!v) {
158                 errno = ENOMEM;
159                 return -1;
160         }
161
162         /* add the value */
163         if (name[0] == '-') {
164                 append_field(priv, &name[1], v);
165         } else {
166                 append_field(priv, name, json_object_get(v));
167                 append_field(pub, name, v);
168         }
169         return 0;
170 }
171
172 /*
173  * Adds the field of 'name' and 'value' in 'priv' and also if possible in 'pub'
174  * Returns 0 on success or -1 on error.
175  */
176 static int add_fields_of_content(
177                 struct json_object *priv,
178                 struct json_object *pub,
179                 char *content,
180                 size_t length
181 )
182 {
183         char *name, *value, *read, *write;
184
185         read = strstr(content, x_afm_prefix);
186         while (read) {
187                 name = read + x_afm_prefix_length;
188                 value = strchr(name, '=');
189                 if (value == NULL)
190                         read = strstr(name, x_afm_prefix);
191                 else {
192                         *value++ = 0;
193                         read = write = value;
194                         while(*read && *read != '\n') {
195                                 if (read[0] != '\\')
196                                         *write++ = *read++;
197                                 else {
198                                         switch(*++read) {
199                                         case 'n': *write++ = '\n'; break;
200                                         case '\n': *write++ = ' '; break;
201                                         default: *write++ = '\\'; *write++ = *read; break;
202                                         }
203                                         read += !!*read;
204                                 }
205                         }
206                         read = strstr(read, x_afm_prefix);
207                         *write = 0;
208                         if (add_field(priv, pub, name, value) < 0)
209                                 return -1;
210                 }
211         }
212         return 0;
213 }
214
215 /*
216  * Adds the application widget 'desc' of the directory 'path' to the
217  * afm_apps object 'apps'.
218  * Returns 0 in case of success.
219  * Returns -1 and set errno in case of error
220  */
221 static int addunit(
222                 struct afm_apps *apps,
223                 int isuser,
224                 const char *unitpath,
225                 const char *unitname,
226                 char *content,
227                 size_t length
228 )
229 {
230         struct json_object *priv, *pub, *id;
231         const char *strid;
232         size_t len;
233
234         /* create the application structure */
235         priv = json_object_new_object();
236         if (!priv)
237                 return -1;
238
239         pub = json_object_new_object();
240         if (!pub)
241                 goto error;
242
243         /* make the unit name */
244         len = strlen(unitname);
245         assert(len >= (sizeof service_extension - 1));
246         assert(!memcmp(&unitname[len - (sizeof service_extension - 1)], service_extension, sizeof service_extension));
247
248         /* adds the values */
249         if (add_fields_of_content(priv, pub, content, length)
250          || add_field(priv, pub, key_unit_path, unitpath)
251          || add_field(priv, pub, key_unit_name, unitname)
252          || add_field(priv, pub, key_unit_scope, isuser ? scope_user : scope_system))
253                 goto error;
254
255         /* get the id */
256         if (!json_object_object_get_ex(pub, key_id, &id)) {
257                 errno = EINVAL;
258                 goto error;
259         }
260         strid = json_object_get_string(id);
261
262         /* record the application structure */
263         json_object_get(pub);
264         json_object_array_add(apps->pubarr, pub);
265         json_object_object_add(apps->pubobj, strid, pub);
266         json_object_get(priv);
267         json_object_array_add(apps->prvarr, priv);
268         json_object_object_add(apps->prvobj, strid, priv);
269         return 0;
270
271 error:
272         json_object_put(pub);
273         json_object_put(priv);
274         return -1;
275 }
276
277 /*
278  * read a unit file
279  */
280 static int read_unit_file(const char *path, char **content, size_t *length)
281 {
282         int rc, st;
283         char c, *read, *write;
284
285         /* read the file */
286         rc = getfile(path, content, length);
287         if (rc >= 0) {
288                 /* removes any comment and join continued lines */
289                 st = 0;
290                 read = write = *content;
291                 for (;;) {
292                         do { c = *read++; } while (c == '\r');
293                         if (!c)
294                                 break;
295                         switch (st) {
296                         case 0:
297                                 /* state 0: begin of a line */
298                                 if (c == ';' || c == '#') {
299                                         st = 3; /* removes lines starting with ; or # */
300                                         break;
301                                 }
302                                 if (c == '\n')
303                                         break; /* removes empty lines */
304 enter_state_1:
305                                 st = 1;
306                                 /*@fallthrough@*/
307                         case 1:
308                                 /* state 1: emitting a normal line */
309                                 if (c == '\\')
310                                         st = 2;
311                                 else {
312                                         *write++ = c;
313                                         if (c == '\n')
314                                                 st = 0;
315                                 }
316                                 break;
317                         case 2:
318                                 /* state 2: character after '\' */
319                                 if (c == '\n')
320                                         c = ' ';
321                                 else
322                                         *write++ = '\\';
323                                 goto enter_state_1;
324                         case 3:
325                                 /* state 3: inside a comment, wait its end */
326                                 if (c == '\n')
327                                         st = 0;
328                                 break;
329                         }
330                 }
331                 if (st == 1)
332                         *write++ = '\n';
333                 *write = 0;
334                 *length = (size_t)(write - *content);
335                 *content = realloc(*content, *length + 1);
336         }
337         return rc;
338 }
339
340 /*
341  * called for each unit
342  */
343 static int update_cb(void *closure, const char *name, const char *path, int isuser)
344 {
345         struct afm_updt *updt = closure;
346         char *content;
347         size_t length;
348         int rc;
349
350         /* prefix filtering */
351         length = updt->afudb->prefixlen;
352         if (length && strncmp(updt->afudb->prefix, name, length))
353                 return 0;
354
355         /* only services */
356         length = strlen(name);
357         if (length < service_extension_length || strcmp(service_extension, name + length - service_extension_length))
358                 return 0;
359
360         /* reads the file */
361         rc = read_unit_file(path, &content, &length);
362         if (rc < 0)
363                 return 0;
364
365         /* process the file */
366         rc = addunit(&updt->applications, isuser, path, name, content, length);
367         /* TODO: if (rc < 0)
368                 ERROR("Ignored boggus unit %s (error: %m)", path); */
369         free(content);
370         return 0;
371 }
372
373 /*
374  * Creates an afm_udb object and returns it with one reference added.
375  * Return NULL with errno = ENOMEM if memory exhausted.
376  */
377 struct afm_udb *afm_udb_create(int sys, int usr, const char *prefix)
378 {
379         size_t length;
380         struct afm_udb *afudb;
381
382         length = prefix ? strlen(prefix) : 0;
383         afudb = malloc(length + sizeof * afudb);
384         if (afudb == NULL)
385                 errno = ENOMEM;
386         else {
387                 afudb->refcount = 1;
388                 afudb->applications.prvarr = NULL;
389                 afudb->applications.pubarr = NULL;
390                 afudb->applications.pubobj = NULL;
391                 afudb->applications.prvobj = NULL;
392                 afudb->system = sys;
393                 afudb->user = usr;
394                 afudb->prefixlen = length;
395                 if (length)
396                         memcpy(afudb->prefix, prefix, length);
397                 afudb->prefix[length] = 0;
398                 if (afm_udb_update(afudb) < 0) {
399                         afm_udb_unref(afudb);
400                         afudb = NULL;
401                 }
402         }
403         return afudb;
404 }
405
406 /*
407  * Adds a reference to an existing afm_udb.
408  */
409 void afm_udb_addref(struct afm_udb *afudb)
410 {
411         assert(afudb);
412         afudb->refcount++;
413 }
414
415 /*
416  * Removes a reference to an existing afm_udb object.
417  * Removes the objet if there no more reference to it.
418  */
419 void afm_udb_unref(struct afm_udb *afudb)
420 {
421         assert(afudb);
422         if (!--afudb->refcount) {
423                 /* no more reference, clean the memory used by the object */
424                 apps_put(&afudb->applications);
425                 free(afudb);
426         }
427 }
428
429 /*
430  * Regenerate the list of applications of the afm_bd object 'afudb'.
431  * Returns 0 in case of success.
432  * Returns -1 and set errno in case of error
433  */
434 int afm_udb_update(struct afm_udb *afudb)
435 {
436         struct afm_updt updt;
437         struct afm_apps tmp;
438
439         /* lock the db */
440         afm_udb_addref(afudb);
441         updt.afudb = afudb;
442
443         /* create the result */
444         updt.applications.prvarr = json_object_new_array();
445         updt.applications.pubarr = json_object_new_array();
446         updt.applications.pubobj = json_object_new_object();
447         updt.applications.prvobj = json_object_new_object();
448         if (updt.applications.pubarr == NULL
449          || updt.applications.prvarr == NULL
450          || updt.applications.pubobj == NULL
451          || updt.applications.prvobj == NULL) {
452                 errno = ENOMEM;
453                 goto error;
454         }
455
456         /* scan the units */
457         if (afudb->user)
458                 if (systemd_unit_list(1, update_cb, &updt) < 0)
459                         goto error;
460         if (afudb->system)
461                 if (systemd_unit_list(0, update_cb, &updt) < 0)
462                         goto error;
463
464         /* commit the result */
465         tmp = afudb->applications;
466         afudb->applications = updt.applications;
467         apps_put(&tmp);
468         afm_udb_addref(afudb);
469         return 0;
470
471 error:
472         apps_put(&updt.applications);
473         afm_udb_addref(afudb);
474         return -1;
475 }
476
477 void afm_udb_set_default_lang(const char *lang)
478 {
479         char *oldval = default_lang;
480         default_lang = lang ? strdup(lang) : NULL;
481         free(oldval);
482 }
483
484 /*
485  * Get the list of the applications private data of the afm_udb object 'afudb'.
486  * The list is returned as a JSON-array that must be released using
487  * 'json_object_put'.
488  * Returns NULL in case of error.
489  */
490 struct json_object *afm_udb_applications_private(struct afm_udb *afudb, int uid)
491 {
492         return json_object_get(afudb->applications.prvarr);
493 }
494
495 /*
496  * Get the list of the applications public data of the afm_udb object 'afudb'.
497  * The list is returned as a JSON-array that must be released using
498  * 'json_object_put'.
499  * Returns NULL in case of error.
500  */
501 struct json_object *afm_udb_applications_public(struct afm_udb *afudb, int uid, const char *lang)
502 {
503         return json_object_get(afudb->applications.pubarr);
504 }
505
506 /*
507  * Get the private data of the applications of 'id' in the afm_udb object 'afudb'.
508  * It returns a JSON-object that must be released using 'json_object_put'.
509  * Returns NULL in case of error.
510  */
511 static struct json_object *get_no_case(struct json_object *object, const char *id, int uid, const char *lang)
512 {
513         struct json_object *result;
514         struct json_object_iter i;
515
516         /* search case sensitively */
517         if (json_object_object_get_ex(object, id, &result))
518                 return json_object_get(result);
519
520         /* fallback to a case insensitive search */
521         json_object_object_foreachC(object, i) {
522                 if (!strcasecmp(i.key, id))
523                         return json_object_get(i.val);
524         }
525         return NULL;
526 }
527
528 /*
529  * Get the private data of the applications of 'id' in the afm_udb object 'afudb'.
530  * It returns a JSON-object that must be released using 'json_object_put'.
531  * Returns NULL in case of error.
532  */
533 struct json_object *afm_udb_get_application_private(struct afm_udb *afudb, const char *id, int uid)
534 {
535         return get_no_case(afudb->applications.prvobj, id, uid, NULL);
536 }
537
538 /*
539  * Get the public data of the applications of 'id' in the afm_udb object 'afudb'.
540  * It returns a JSON-object that must be released using 'json_object_put'.
541  * Returns NULL in case of error.
542  */
543 struct json_object *afm_udb_get_application_public(struct afm_udb *afudb,
544                                                         const char *id, int uid, const char *lang)
545 {
546         return get_no_case(afudb->applications.pubobj, id, uid, lang);
547 }
548
549
550
551 #if defined(TESTAPPFWK)
552 #include <stdio.h>
553 int main()
554 {
555 struct afm_udb *afudb = afm_udb_create(1, 1, NULL);
556 printf("array = %s\n", json_object_to_json_string_ext(afudb->applications.pubarr, 3));
557 printf("pubobj = %s\n", json_object_to_json_string_ext(afudb->applications.pubobj, 3));
558 printf("prvobj = %s\n", json_object_to_json_string_ext(afudb->applications.prvobj, 3));
559 return 0;
560 }
561 #endif
562