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 static 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 static 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 static int config_parse_listen(
 123                 const char *filename,
 124                 unsigned line,
 125                 const char *section,
 126                 const char *lvalue,
 127                 const char *rvalue,
 128                 void *data,
 129                 void *userdata) {
 130
 131         assert(filename);
 132         assert(lvalue);
 133         assert(rvalue);
 134         assert(data);
 135
 136         return address_parse(data, rvalue);
 137 }
 138
 139 static int config_parse_type(
 140                 const char *filename,
 141                 unsigned line,
 142                 const char *section,
 143                 const char *lvalue,
 144                 const char *rvalue,
 145                 void *data,
 146                 void *userdata) {
 147
 148         int *type = data;
 149
 150         assert(filename);
 151         assert(lvalue);
 152         assert(rvalue);
 153         assert(data);
 154
 155         if (streq(rvalue, "stream"))
 156                 *type = SOCK_STREAM;
 157         else if (streq(rvalue, "dgram"))
 158                 *type = SOCK_DGRAM;
 159         else
 160                 return -EINVAL;
 161
 162         return 0;
 163 }
 164
 165 int name_load_fragment(Name *n) {
 166
 167         const char *const section_table[_NAME_TYPE_MAX] = {
 168                 [NAME_SERVICE]   = "Service",
 169                 [NAME_TIMER]     = "Timer",
 170                 [NAME_SOCKET]    = "Socket",
 171                 [NAME_MILESTONE] = "Milestone",
 172                 [NAME_DEVICE]    = "Device",
 173                 [NAME_MOUNT]     = "Mount",
 174                 [NAME_AUTOMOUNT] = "Automount",
 175                 [NAME_SNAPSHOT]  = "Snapshot"
 176         };
 177
 178         const ConfigItem items[] = {
 179                 { "Names",         config_parse_names,  &n->meta.names,                           "Meta"   },
 180                 { "Description",   config_parse_string, &n->meta.description,                     "Meta"   },
 181                 { "Requires",      config_parse_deps,   n->meta.dependencies+NAME_REQUIRES,       "Meta"   },
 182                 { "SoftRequires",  config_parse_deps,   n->meta.dependencies+NAME_SOFT_REQUIRES,  "Meta"   },
 183                 { "Wants",         config_parse_deps,   n->meta.dependencies+NAME_WANTS,          "Meta"   },
 184                 { "Requisite",     config_parse_deps,   n->meta.dependencies+NAME_REQUISITE,      "Meta"   },
 185                 { "SoftRequisite", config_parse_deps,   n->meta.dependencies+NAME_SOFT_REQUISITE, "Meta"   },
 186                 { "Conflicts",     config_parse_deps,   n->meta.dependencies+NAME_CONFLICTS,      "Meta"   },
 187                 { "Before",        config_parse_deps,   n->meta.dependencies+NAME_BEFORE,         "Meta"   },
 188                 { "After",         config_parse_deps,   n->meta.dependencies+NAME_AFTER,          "Meta"   },
 189                 { "Listen",        config_parse_listen, &n->socket.address,                       "Socket" },
 190                 { "Type",          config_parse_type,   &n->socket.address.type,                  "Socket" },
 191                 { NULL, NULL, NULL, NULL }
 192         };
 193
 194         const
 195
 196         char *t;
 197         int r;
 198         void *state;
 199         const char *sections[3];
 200
 201         assert(n);
 202         assert(n->meta.state == NAME_STUB);
 203
 204         sections[0] = "Meta";
 205         sections[1] = section_table[n->meta.type];
 206         sections[2] = NULL;
 207
 208         SET_FOREACH(t, n->meta.names, state)
 209                 if ((r = config_parse(t, sections, items, n)) < 0)
 210                         goto fail;
 211
 212         r = 0;
 213
 214 fail:
 215         return r;
 216 }