src/core/core-varlink.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include "core-varlink.h"
   4 #include "mkdir.h"
   5 #include "user-util.h"
   6 #include "varlink.h"
   7
   8 typedef struct LookupParameters {
   9         const char *user_name;
  10         const char *group_name;
  11         union {
  12                 uid_t uid;
  13                 gid_t gid;
  14         };
  15         const char *service;
  16 } LookupParameters;
  17
  18 static int build_user_json(const char *user_name, uid_t uid, JsonVariant **ret) {
  19         assert(user_name);
  20         assert(uid_is_valid(uid));
  21         assert(ret);
  22
  23         return json_build(ret, JSON_BUILD_OBJECT(
  24                                    JSON_BUILD_PAIR("record", JSON_BUILD_OBJECT(
  25                                        JSON_BUILD_PAIR("userName", JSON_BUILD_STRING(user_name)),
  26                                        JSON_BUILD_PAIR("uid", JSON_BUILD_UNSIGNED(uid)),
  27                                        JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(uid)),
  28                                        JSON_BUILD_PAIR("realName", JSON_BUILD_STRING("Dynamic User")),
  29                                        JSON_BUILD_PAIR("homeDirectory", JSON_BUILD_STRING("/")),
  30                                        JSON_BUILD_PAIR("shell", JSON_BUILD_STRING(NOLOGIN)),
  31                                        JSON_BUILD_PAIR("locked", JSON_BUILD_BOOLEAN(true)),
  32                                        JSON_BUILD_PAIR("service", JSON_BUILD_STRING("io.systemd.DynamicUser")),
  33                                        JSON_BUILD_PAIR("disposition", JSON_BUILD_STRING("dynamic"))))));
  34 }
  35
  36 static bool user_match_lookup_parameters(LookupParameters *p, const char *name, uid_t uid) {
  37         assert(p);
  38
  39         if (p->user_name && !streq(name, p->user_name))
  40                 return false;
  41
  42         if (uid_is_valid(p->uid) && uid != p->uid)
  43                 return false;
  44
  45         return true;
  46 }
  47
  48 static int vl_method_get_user_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
  49
  50         static const JsonDispatch dispatch_table[] = {
  51                 { "uid",      JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid,      offsetof(LookupParameters, uid),       0         },
  52                 { "userName", JSON_VARIANT_STRING,   json_dispatch_const_string, offsetof(LookupParameters, user_name), JSON_SAFE },
  53                 { "service",  JSON_VARIANT_STRING,   json_dispatch_const_string, offsetof(LookupParameters, service),   0         },
  54                 {}
  55         };
  56
  57         _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
  58         LookupParameters p = {
  59                 .uid = UID_INVALID,
  60         };
  61         _cleanup_free_ char *found_name = NULL;
  62         uid_t found_uid = UID_INVALID, uid;
  63         Manager *m = userdata;
  64         const char *un;
  65         int r;
  66
  67         assert(parameters);
  68         assert(m);
  69
  70         r = json_dispatch(parameters, dispatch_table, NULL, 0, &p);
  71         if (r < 0)
  72                 return r;
  73
  74         if (!streq_ptr(p.service, "io.systemd.DynamicUser"))
  75                 return varlink_error(link, "io.systemd.UserDatabase.BadService", NULL);
  76
  77         if (uid_is_valid(p.uid))
  78                 r = dynamic_user_lookup_uid(m, p.uid, &found_name);
  79         else if (p.user_name)
  80                 r = dynamic_user_lookup_name(m, p.user_name, &found_uid);
  81         else {
  82                 Iterator i;
  83                 DynamicUser *d;
  84
  85                 HASHMAP_FOREACH(d, m->dynamic_users, i) {
  86                         r = dynamic_user_current(d, &uid);
  87                         if (r == -EAGAIN) /* not realized yet? */
  88                                 continue;
  89                         if (r < 0)
  90                                 return r;
  91
  92                         if (!user_match_lookup_parameters(&p, d->name, uid))
  93                                 continue;
  94
  95                         if (v) {
  96                                 r = varlink_notify(link, v);
  97                                 if (r < 0)
  98                                         return r;
  99
 100                                 v = json_variant_unref(v);
 101                         }
 102
 103                         r = build_user_json(d->name, uid, &v);
 104                         if (r < 0)
 105                                 return r;
 106                 }
 107
 108                 if (!v)
 109                         return varlink_error(link, "io.systemd.UserDatabase.NoRecordFound", NULL);
 110
 111                 return varlink_reply(link, v);
 112         }
 113         if (r == -ESRCH)
 114                 return varlink_error(link, "io.systemd.UserDatabase.NoRecordFound", NULL);
 115         if (r < 0)
 116                 return r;
 117
 118         uid = uid_is_valid(found_uid) ? found_uid : p.uid;
 119         un = found_name ?: p.user_name;
 120
 121         if (!user_match_lookup_parameters(&p, un, uid))
 122                 return varlink_error(link, "io.systemd.UserDatabase.ConflictingRecordFound", NULL);
 123
 124         r = build_user_json(un, uid, &v);
 125         if (r < 0)
 126                 return r;
 127
 128         return varlink_reply(link, v);
 129 }
 130
 131 static int build_group_json(const char *group_name, gid_t gid, JsonVariant **ret) {
 132         assert(group_name);
 133         assert(gid_is_valid(gid));
 134         assert(ret);
 135
 136         return json_build(ret, JSON_BUILD_OBJECT(
 137                                    JSON_BUILD_PAIR("record", JSON_BUILD_OBJECT(
 138                                        JSON_BUILD_PAIR("groupName", JSON_BUILD_STRING(group_name)),
 139                                        JSON_BUILD_PAIR("description", JSON_BUILD_STRING("Dynamic Group")),
 140                                        JSON_BUILD_PAIR("gid", JSON_BUILD_UNSIGNED(gid)),
 141                                        JSON_BUILD_PAIR("service", JSON_BUILD_STRING("io.systemd.DynamicUser")),
 142                                        JSON_BUILD_PAIR("disposition", JSON_BUILD_STRING("dynamic"))))));
 143     }
 144
 145 static bool group_match_lookup_parameters(LookupParameters *p, const char *name, gid_t gid) {
 146         assert(p);
 147
 148         if (p->group_name && !streq(name, p->group_name))
 149                 return false;
 150
 151         if (gid_is_valid(p->gid) && gid != p->gid)
 152                 return false;
 153
 154         return true;
 155 }
 156
 157 static int vl_method_get_group_record(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
 158
 159         static const JsonDispatch dispatch_table[] = {
 160                 { "gid",       JSON_VARIANT_UNSIGNED, json_dispatch_uid_gid,      offsetof(LookupParameters, gid),        0         },
 161                 { "groupName", JSON_VARIANT_STRING,   json_dispatch_const_string, offsetof(LookupParameters, group_name), JSON_SAFE },
 162                 { "service",   JSON_VARIANT_STRING,   json_dispatch_const_string, offsetof(LookupParameters, service),    0         },
 163                 {}
 164         };
 165
 166         _cleanup_(json_variant_unrefp) JsonVariant *v = NULL;
 167         LookupParameters p = {
 168                 .gid = GID_INVALID,
 169         };
 170         _cleanup_free_ char *found_name = NULL;
 171         uid_t found_gid = GID_INVALID, gid;
 172         Manager *m = userdata;
 173         const char *gn;
 174         int r;
 175
 176         assert(parameters);
 177         assert(m);
 178
 179         r = json_dispatch(parameters, dispatch_table, NULL, 0, &p);
 180         if (r < 0)
 181                 return r;
 182
 183         if (!streq_ptr(p.service, "io.systemd.DynamicUser"))
 184                 return varlink_error(link, "io.systemd.UserDatabase.BadService", NULL);
 185
 186         if (gid_is_valid(p.gid))
 187                 r = dynamic_user_lookup_uid(m, (uid_t) p.gid, &found_name);
 188         else if (p.group_name)
 189                 r = dynamic_user_lookup_name(m, p.group_name, (uid_t*) &found_gid);
 190         else {
 191                 DynamicUser *d;
 192                 Iterator i;
 193
 194                 HASHMAP_FOREACH(d, m->dynamic_users, i) {
 195                         uid_t uid;
 196
 197                         r = dynamic_user_current(d, &uid);
 198                         if (r == -EAGAIN)
 199                                 continue;
 200                         if (r < 0)
 201                                 return r;
 202
 203                         if (!group_match_lookup_parameters(&p, d->name, (gid_t) uid))
 204                                 continue;
 205
 206                         if (v) {
 207                                 r = varlink_notify(link, v);
 208                                 if (r < 0)
 209                                         return r;
 210
 211                                 v = json_variant_unref(v);
 212                         }
 213
 214                         r = build_group_json(d->name, (gid_t) uid, &v);
 215                         if (r < 0)
 216                                 return r;
 217                 }
 218
 219                 if (!v)
 220                         return varlink_error(link, "io.systemd.UserDatabase.NoRecordFound", NULL);
 221
 222                 return varlink_reply(link, v);
 223         }
 224         if (r == -ESRCH)
 225                 return varlink_error(link, "io.systemd.UserDatabase.NoRecordFound", NULL);
 226         if (r < 0)
 227                 return r;
 228
 229         gid = gid_is_valid(found_gid) ? found_gid : p.gid;
 230         gn = found_name ?: p.group_name;
 231
 232         if (!group_match_lookup_parameters(&p, gn, gid))
 233                 return varlink_error(link, "io.systemd.UserDatabase.ConflictingRecordFound", NULL);
 234
 235         r = build_group_json(gn, gid, &v);
 236         if (r < 0)
 237                 return r;
 238
 239         return varlink_reply(link, v);
 240 }
 241
 242 static int vl_method_get_memberships(Varlink *link, JsonVariant *parameters, VarlinkMethodFlags flags, void *userdata) {
 243
 244         static const JsonDispatch dispatch_table[] = {
 245                 { "userName",  JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, user_name),  JSON_SAFE },
 246                 { "groupName", JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, group_name), JSON_SAFE },
 247                 { "service",   JSON_VARIANT_STRING, json_dispatch_const_string, offsetof(LookupParameters, service),    0         },
 248                 {}
 249         };
 250
 251         LookupParameters p = {};
 252         int r;
 253
 254         assert(parameters);
 255
 256         r = json_dispatch(parameters, dispatch_table, NULL, 0, &p);
 257         if (r < 0)
 258                 return r;
 259
 260         if (!streq_ptr(p.service, "io.systemd.DynamicUser"))
 261                 return varlink_error(link, "io.systemd.UserDatabase.BadService", NULL);
 262
 263         /* We don't support auxiliary groups with dynamic users. */
 264         return varlink_error(link, "io.systemd.UserDatabase.NoRecordFound", NULL);
 265 }
 266
 267 int manager_varlink_init(Manager *m) {
 268         _cleanup_(varlink_server_unrefp) VarlinkServer *s = NULL;
 269         int r;
 270
 271         assert(m);
 272
 273         if (m->varlink_server)
 274                 return 0;
 275
 276         if (!MANAGER_IS_SYSTEM(m))
 277                 return 0;
 278
 279         r = varlink_server_new(&s, VARLINK_SERVER_ACCOUNT_UID);
 280         if (r < 0)
 281                 return log_error_errno(r, "Failed to allocate varlink server object: %m");
 282
 283         varlink_server_set_userdata(s, m);
 284
 285         r = varlink_server_bind_method_many(
 286                         s,
 287                         "io.systemd.UserDatabase.GetUserRecord",  vl_method_get_user_record,
 288                         "io.systemd.UserDatabase.GetGroupRecord", vl_method_get_group_record,
 289                         "io.systemd.UserDatabase.GetMemberships", vl_method_get_memberships);
 290         if (r < 0)
 291                 return log_error_errno(r, "Failed to register varlink methods: %m");
 292
 293         if (!MANAGER_IS_TEST_RUN(m)) {
 294                 (void) mkdir_p("/run/systemd/userdb", 0755);
 295
 296                 r = varlink_server_listen_address(s, "/run/systemd/userdb/io.systemd.DynamicUser", 0666);
 297                 if (r < 0)
 298                         return log_error_errno(r, "Failed to bind to varlink socket: %m");
 299         }
 300
 301         r = varlink_server_attach_event(s, m->event, SD_EVENT_PRIORITY_NORMAL);
 302         if (r < 0)
 303                 return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
 304
 305         m->varlink_server = TAKE_PTR(s);
 306         return 0;
 307 }
 308
 309 void manager_varlink_done(Manager *m) {
 310         assert(m);
 311
 312         m->varlink_server = varlink_server_unref(m->varlink_server);
 313 }