2 Copyright 2016, 2017 IoT.bzh
4 author: José Bollo <jose.bollo@iot.bzh>
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
10 http://www.apache.org/licenses/LICENSE-2.0
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.
23 #include <sys/types.h>
30 #include <json-c/json.h>
33 #include "utils-file.h"
35 #include "wgtpkg-mustach.h"
36 #include "utils-json.h"
38 #include "utils-systemd.h"
40 #include "wgtpkg-unit.h"
45 #define isblank(c) ((c)==' '||(c)=='\t')
48 /* the template for all units */
49 static char *template;
52 * Search for the 'pattern' in 'text'.
53 * Returns 1 if 'text' matches the 'pattern' or else returns 0.
54 * When returning 1 and 'after' isn't NULL, the pointer to the
55 * first character after the pettern in 'text' is stored in 'after'.
56 * The characters '\n' and ' ' have a special meaning in the search:
57 * * '\n': matches any space or tabs (including none) followed
58 * either by '\n' or '\0' (end of the string)
59 * * ' ': matches any space or tabs but at least one.
61 static int matches(const char *pattern, char *text, char **after)
99 * Pack a null terminated 'text' by removing empty lines,
100 * lines made of blanks and terminated with \, lines
101 * starting with the 'purge' character (can be null).
102 * Lines made of the 'purge' character followed with
103 * "nl" exactly (without quotes ") are replaced with
106 * Returns the size after packing (offset of the ending null).
108 static size_t pack(char *text, char purge)
110 char *read; /* read iterator */
111 char *write; /* write iterator */
112 char *begin; /* begin the copied text of the line */
113 char *start; /* first character of the line that isn't blanck */
114 char c; /* currently scanned character (pointed by read) */
115 char emit; /* flag telling whether line is to be copied */
116 char cont; /* flag telling whether the line continues the previous one */
117 char nextcont; /* flag telling whether the line will continues the next one */
120 c = *(write = read = text);
122 /* iteration over lines */
124 /* computes emit, nextcont, emit and start for the current line */
129 while (c && c != '\n') {
131 if (c == '\\' && read[1] == '\n')
143 /* emit the line if not empty */
144 if (emit || (cont && !nextcont)) {
145 /* removes the blanks on the left of not continuing lines */
148 /* check if purge applies */
149 if (purge && *begin == purge) {
150 /* yes, insert new line if requested */
151 if (!strncmp(begin+1, "nl\n",3))
154 /* copies the line */
155 while (begin != read)
161 return (size_t)(write - text);
165 * Searchs the first character of the next line
166 * of the 'text' and returns its address
167 * Returns NULL if there is no next line.
169 static inline char *nextline(char *text)
171 char *result = strchr(text, '\n');
172 return result + !!result;
176 * Search in 'text' the offset of a line beginning with the 'pattern'
177 * Returns NULL if not found or the address of the line contning the pattern
178 * If args isn't NULL and the pattern is found, the pointed pattern is
179 * updated with the address of the character following the found pattern.
181 static char *offset(char *text, const char *pattern, char **args)
183 while (text && !matches(pattern, text, args))
184 text = nextline(text);
191 static int process_one_unit(char *spec, struct unitdesc *desc)
193 char *nsoc, *nsrv, *name, *wanted;
194 int isuser, issystem, issock, isserv, iswanted;
197 /* finds the configuration directive of the unit */
198 isuser = !!offset(spec, "%systemd-unit user\n", NULL);
199 issystem = !!offset(spec, "%systemd-unit system\n", NULL);
200 issock = !!offset(spec, "%systemd-unit socket ", &nsoc);
201 isserv = !!offset(spec, "%systemd-unit service ", &nsrv);
202 iswanted = !!offset(spec, "%systemd-unit wanted-by ", &wanted);
204 /* check the unit scope */
205 if ((isuser + issystem) == 1) {
206 desc->scope = isuser ? unitscope_user : unitscope_system;
208 desc->scope = unitscope_unknown;
211 /* check the unit type */
212 if ((issock + isserv) == 1) {
214 desc->type = unittype_socket;
217 desc->type = unittype_service;
220 len = strcspn(name, " \t\n");
221 desc->name = strndup(name, len);
222 desc->name_length = desc->name ? len : 0;
224 desc->type = unittype_unknown;
226 desc->name_length = 0;
230 len = strcspn(wanted, " \t\n");
231 desc->wanted_by = strndup(wanted, len);
232 desc->wanted_by_length = len;
234 desc->wanted_by = NULL;
235 desc->wanted_by_length = 0;
238 desc->content = spec;
239 desc->content_length = pack(spec, '%');
245 * Processes all the units of the 'corpus'.
246 * Each unit of the corpus is separated and packed and its
247 * charactistics are stored in a descriptor.
248 * At the end if no error was found, calls the function 'process'
249 * with its given 'closure' and the array descripbing the units.
250 * Return 0 in case of success or a negative value in case of error.
252 static int process_all_units(char *corpus, const struct unitconf *conf, int (*process)(void *closure, const struct generatedesc *desc), void *closure, struct json_object *jdesc)
255 char *beg, *end, *befbeg, *aftend;
257 struct generatedesc gdesc;
265 /* while there is a unit in the corpus */
267 befbeg = offset(corpus, "%begin ", &beg);
268 end = offset(corpus, "%end ", &aftend);
271 /* %end detected without %begin */
272 ERROR("unexpected %%end at end");
278 /* unterminated unit !! */
279 ERROR("unterminated unit description!!");
282 } else if (end < befbeg) {
283 /* sequence %end ... %begin detected !! */
284 ERROR("unexpected %%end before %%begin");
288 befbeg = offset(beg, "%begin ", NULL);
289 if (befbeg && befbeg < end) {
290 /* sequence %begin ... %begin ... %end detected !! */
291 ERROR("unexpected %%begin after %%begin");
297 if (matches("systemd-unit\n", beg, &beg)) {
298 if (!matches("systemd-unit\n", aftend, &corpus)) {
299 /* end doesnt match */
300 ERROR("unmatched %%begin systemd-unit (matching end mismatch)");
303 /* allocates a descriptor for the unit */
304 u = realloc((void*)gdesc.units, ((unsigned)gdesc.nunits + 1) * sizeof *gdesc.units);
308 /* creates the unit description */
310 u = &u[gdesc.nunits];
311 memset(u, 0, sizeof *u);
312 rc2 = process_one_unit(beg, u);
318 ERROR("unexpected %%begin name");
323 /* records the error if there is an error */
330 /* call the function that processes the units */
331 if (rc == 0 && process)
332 rc = process(closure, &gdesc);
334 /* cleanup and frees */
335 while(gdesc.nunits) {
336 free((void*)(gdesc.units[--gdesc.nunits].name));
337 free((void*)(gdesc.units[gdesc.nunits].wanted_by));
339 free((void*)gdesc.units);
345 * Clear the unit generator
347 void unit_generator_close_template()
354 * Initialises the unit generator with the content of the file of path 'filename'.
355 * Returns 0 in case of success or a negative number in case of error.
357 int unit_generator_open_template(const char *filename)
363 unit_generator_close_template();
364 rc = getfile(filename ? : FWK_UNIT_CONF, &template, NULL);
366 size = pack(template, ';');
367 tmp = realloc(template, 1 + size);
374 static int add_metadata(struct json_object *jdesc, const struct unitconf *conf)
378 sprintf(portstr, "%d", conf->port);
379 return j_add_many_strings_m(jdesc,
380 "#metadata.install-dir", conf->installdir,
381 "#metadata.app-data-dir", "/home/%i/app-data",
382 "#metadata.icons-dir", conf->icondir,
383 "#metadata.http-port", portstr,
388 * Applies the object 'jdesc' augmented of meta data coming
389 * from 'conf' to the current unit generator.
390 * The current unit generator will be set to the default one if not unit
391 * was previously set using the function 'unit_generator_open_template'.
392 * The callback function 'process' is then called with the
393 * unit descriptors array and the expected closure.
394 * Return what returned process in case of success or a negative
397 int unit_generator_process(struct json_object *jdesc, const struct unitconf *conf, int (*process)(void *closure, const struct generatedesc *desc), void *closure)
403 rc = add_metadata(jdesc, conf);
405 ERROR("can't set the metadata. %m");
407 rc = template ? 0 : unit_generator_open_template(NULL);
410 rc = apply_mustach(template, jdesc, &instance, &size);
412 rc = process_all_units(instance, conf, process, closure, jdesc);
419 /**************** SPECIALIZED PART *****************************/
421 static int check_unit_desc(const struct unitdesc *desc, int tells)
423 if (desc->scope != unitscope_unknown && desc->type != unittype_unknown && desc->name != NULL)
427 if (desc->scope == unitscope_unknown)
428 ERROR("unit of unknown scope");
429 if (desc->type == unittype_unknown)
430 ERROR("unit of unknown type");
431 if (desc->name == NULL)
432 ERROR("unit of unknown name");
438 static int get_unit_path(char *path, size_t pathlen, const struct unitdesc *desc)
440 int rc = systemd_get_unit_path(
441 path, pathlen, desc->scope == unitscope_user,
442 desc->name, desc->type == unittype_socket ? "socket" : "service");
445 ERROR("can't get the unit path for %s", desc->name);
450 static int get_wants_path(char *path, size_t pathlen, const struct unitdesc *desc)
452 int rc = systemd_get_wants_path(
453 path, pathlen, desc->scope == unitscope_user, desc->wanted_by,
454 desc->name, desc->type == unittype_socket ? "socket" : "service");
457 ERROR("can't get the wants path for %s and %s", desc->name, desc->wanted_by);
462 static int get_wants_target(char *path, size_t pathlen, const struct unitdesc *desc)
464 int rc = systemd_get_wants_target(
466 desc->name, desc->type == unittype_socket ? "socket" : "service");
469 ERROR("can't get the wants target for %s", desc->name);
474 static int do_uninstall_units(void *closure, const struct generatedesc *desc)
479 const struct unitdesc *u;
482 for (i = 0 ; i < desc->nunits ; i++) {
484 rc2 = check_unit_desc(u, 0);
486 rc2 = get_unit_path(path, sizeof path, u);
490 if (rc2 < 0 && rc == 0)
492 if (u->wanted_by != NULL) {
493 rc2 = get_wants_path(path, sizeof path, u);
498 if (rc2 < 0 && rc == 0)
504 static int do_install_units(void *closure, const struct generatedesc *desc)
508 char path[PATH_MAX + 1], target[PATH_MAX + 1];
509 const struct unitdesc *u;
512 while (i < desc->nunits) {
514 rc = check_unit_desc(u, 1);
516 rc = get_unit_path(path, sizeof path, u);
518 rc = putfile(path, u->content, u->content_length);
519 if (rc >= 0 && u->wanted_by != NULL) {
520 rc = get_wants_path(path, sizeof path, u);
522 rc = get_wants_target(target, sizeof target, u);
524 unlink(path); /* TODO? check? */
525 rc = symlink(target, path);
538 do_uninstall_units(closure, desc);
543 static int do_install_uninstall(
544 struct wgt_info *ifo,
545 const struct unitconf *conf,
546 int (*doer)(void *, const struct generatedesc *)
550 struct json_object *jdesc;
552 jdesc = wgt_info_to_json(ifo);
556 rc = unit_generator_process(jdesc, conf, doer, NULL);
557 json_object_put(jdesc);
562 int unit_install(struct wgt_info *ifo, const struct unitconf *conf)
564 return do_install_uninstall(ifo, conf, do_install_units);
567 int unit_uninstall(struct wgt_info *ifo, const struct unitconf *conf)
569 return do_install_uninstall(ifo, conf, do_uninstall_units);