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, json_object_get(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_unref(afudb);
 469         return 0;
 470
 471 error:
 472         apps_put(&updt.applications);
 473         afm_udb_unref(afudb);
 474         return -1;
 475 }
 476
 477 /*
 478  * set the default language to 'lang'
 479  */
 480 void afm_udb_set_default_lang(const char *lang)
 481 {
 482         char *oldval = default_lang;
 483         default_lang = lang ? strdup(lang) : NULL;
 484         free(oldval);
 485 }
 486
 487 /*
 488  * Get the list of the applications private data of the afm_udb object 'afudb'.
 489  * The list is returned as a JSON-array that must be released using
 490  * 'json_object_put'.
 491  * Returns NULL in case of error.
 492  */
 493 struct json_object *afm_udb_applications_private(struct afm_udb *afudb, int uid)
 494 {
 495         return json_object_get(afudb->applications.prvarr);
 496 }
 497
 498 /*
 499  * Get the list of the applications public data of the afm_udb object 'afudb'.
 500  * The list is returned as a JSON-array that must be released using
 501  * 'json_object_put'.
 502  * Returns NULL in case of error.
 503  */
 504 struct json_object *afm_udb_applications_public(struct afm_udb *afudb, int uid, const char *lang)
 505 {
 506         return json_object_get(afudb->applications.pubarr);
 507 }
 508
 509 /*
 510  * Get the private data of the applications of 'id' in the afm_udb object 'afudb'.
 511  * It returns a JSON-object that must be released using 'json_object_put'.
 512  * Returns NULL in case of error.
 513  */
 514 static struct json_object *get_no_case(struct json_object *object, const char *id, int uid, const char *lang)
 515 {
 516         struct json_object *result;
 517         struct json_object_iter i;
 518
 519         /* search case sensitively */
 520         if (json_object_object_get_ex(object, id, &result))
 521                 return json_object_get(result);
 522
 523         /* fallback to a case insensitive search */
 524         json_object_object_foreachC(object, i) {
 525                 if (!strcasecmp(i.key, id))
 526                         return json_object_get(i.val);
 527         }
 528         return NULL;
 529 }
 530
 531 /*
 532  * Get the private data of the applications of 'id' in the afm_udb object 'afudb'.
 533  * It returns a JSON-object that must be released using 'json_object_put'.
 534  * Returns NULL in case of error.
 535  */
 536 struct json_object *afm_udb_get_application_private(struct afm_udb *afudb, const char *id, int uid)
 537 {
 538         return get_no_case(afudb->applications.prvobj, id, uid, NULL);
 539 }
 540
 541 /*
 542  * Get the public data of the applications of 'id' in the afm_udb object 'afudb'.
 543  * It returns a JSON-object that must be released using 'json_object_put'.
 544  * Returns NULL in case of error.
 545  */
 546 struct json_object *afm_udb_get_application_public(struct afm_udb *afudb,
 547                                                         const char *id, int uid, const char *lang)
 548 {
 549         return get_no_case(afudb->applications.pubobj, id, uid, lang);
 550 }
 551
 552
 553
 554 #if defined(TESTAPPFWK)
 555 #include <stdio.h>
 556 int main()
 557 {
 558 struct afm_udb *afudb = afm_udb_create(1, 1, NULL);
 559 printf("array = %s\n", json_object_to_json_string_ext(afudb->applications.pubarr, 3));
 560 printf("pubobj = %s\n", json_object_to_json_string_ext(afudb->applications.pubobj, 3));
 561 printf("prvobj = %s\n", json_object_to_json_string_ext(afudb->applications.prvobj, 3));
 562 return 0;
 563 }
 564 #endif
 565