load-fragment.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   2
   3 #include <assert.h>
   4 #include <errno.h>
   5 #include <string.h>
   6
   7 #include "name.h"
   8 #include "strv.h"
   9 #include "conf-parser.h"
  10 #include "load-fragment.h"
  11
  12 int config_parse_deps(
  13                 const char *filename,
  14                 unsigned line,
  15                 const char *section,
  16                 const char *lvalue,
  17                 const char *rvalue,
  18                 void *data,
  19                 void *userdata) {
  20
  21         Set **set = data;
  22         Name *name = userdata;
  23         char *w;
  24         size_t l;
  25         char *state;
  26
  27         assert(filename);
  28         assert(lvalue);
  29         assert(rvalue);
  30         assert(data);
  31
  32         FOREACH_WORD(w, &l, rvalue, state) {
  33                 char *t;
  34                 int r;
  35                 Name *other;
  36
  37                 if (!(t = strndup(w, l)))
  38                         return -ENOMEM;
  39
  40                 r = manager_load_name(name->meta.manager, t, &other);
  41                 free(t);
  42
  43                 if (r < 0)
  44                         return r;
  45
  46                 if (!*set)
  47                         if (!(*set = set_new(trivial_hash_func, trivial_compare_func)))
  48                                 return -ENOMEM;
  49
  50                 if ((r = set_put(*set, other)) < 0)
  51                         return r;
  52         }
  53
  54         return 0;
  55 }
  56
  57 int config_parse_names(
  58                 const char *filename,
  59                 unsigned line,
  60                 const char *section,
  61                 const char *lvalue,
  62                 const char *rvalue,
  63                 void *data,
  64                 void *userdata) {
  65
  66         Set **set = data;
  67         Name *name = userdata;
  68         char *w;
  69         size_t l;
  70         char *state;
  71
  72         assert(filename);
  73         assert(lvalue);
  74         assert(rvalue);
  75         assert(data);
  76
  77         FOREACH_WORD(w, &l, rvalue, state) {
  78                 char *t;
  79                 int r;
  80                 Name *other;
  81
  82                 if (!(t = strndup(w, l)))
  83                         return -ENOMEM;
  84
  85                 other = manager_get_name(name->meta.manager, t);
  86
  87                 if (other) {
  88
  89                         if (other != name) {
  90
  91                                 if (other->meta.state != NAME_STUB) {
  92                                         free(t);
  93                                         return -EEXIST;
  94                                 }
  95
  96                                 if ((r = name_merge(name, other) < 0)) {
  97                                         free(t);
  98                                         return r;
  99                                 }
 100                         }
 101
 102                 } else {
 103
 104                         if (!*set)
 105                                 if (!(*set = set_new(trivial_hash_func, trivial_compare_func))) {
 106                                         free(t);
 107                                         return -ENOMEM;
 108                                 }
 109
 110                         if ((r = set_put(*set, t)) < 0) {
 111                                 free(t);
 112                                 return r;
 113                         }
 114                 }
 115
 116                 free(t);
 117         }
 118
 119         return 0;
 120 }
 121
 122 int name_load_fragment(Name *n) {
 123
 124         const ConfigItem items[] = {
 125                 { "Names",         config_parse_names,  &n->meta.names,                           "Meta" },
 126                 { "Description",   config_parse_string, &n->meta.description,                     "Meta" },
 127                 { "Requires",      config_parse_deps,   n->meta.dependencies+NAME_REQUIRES,       "Meta" },
 128                 { "SoftRequires",  config_parse_deps,   n->meta.dependencies+NAME_SOFT_REQUIRES,  "Meta" },
 129                 { "Wants",         config_parse_deps,   n->meta.dependencies+NAME_WANTS,          "Meta" },
 130                 { "Requisite",     config_parse_deps,   n->meta.dependencies+NAME_REQUISITE,      "Meta" },
 131                 { "SoftRequisite", config_parse_deps,   n->meta.dependencies+NAME_SOFT_REQUISITE, "Meta" },
 132                 { "Conflicts",     config_parse_deps,   n->meta.dependencies+NAME_CONFLICTS,      "Meta" },
 133                 { "Before",        config_parse_deps,   n->meta.dependencies+NAME_BEFORE,         "Meta" },
 134                 { "After",         config_parse_deps,   n->meta.dependencies+NAME_AFTER,          "Meta" },
 135                 { NULL, NULL, NULL, NULL }
 136         };
 137
 138         char *t;
 139         int r;
 140         void *state;
 141
 142         assert(n);
 143         assert(n->meta.state == NAME_STUB);
 144
 145         SET_FOREACH(t, n->meta.names, state)
 146                 if ((r = config_parse(t, items, n)) < 0)
 147                         goto fail;
 148
 149         r = 0;
 150
 151 fail:
 152         return r;
 153 }