authz/listfile.c

   1 /*
   2  * QEMU access control list file authorization driver
   3  *
   4  * Copyright (c) 2018 Red Hat, Inc.
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "authz/listfile.h"
  23 #include "trace.h"
  24 #include "qemu/error-report.h"
  25 #include "qemu/main-loop.h"
  26 #include "qemu/module.h"
  27 #include "qemu/sockets.h"
  28 #include "qemu/filemonitor.h"
  29 #include "qom/object_interfaces.h"
  30 #include "qapi/qapi-visit-authz.h"
  31 #include "qapi/qmp/qjson.h"
  32 #include "qapi/qmp/qobject.h"
  33 #include "qapi/qobject-input-visitor.h"
  34
  35
  36 static bool
  37 qauthz_list_file_is_allowed(QAuthZ *authz,
  38                             const char *identity,
  39                             Error **errp)
  40 {
  41     QAuthZListFile *fauthz = QAUTHZ_LIST_FILE(authz);
  42     if (fauthz->list) {
  43         return qauthz_is_allowed(fauthz->list, identity, errp);
  44     }
  45
  46     return false;
  47 }
  48
  49
  50 static QAuthZ *
  51 qauthz_list_file_load(QAuthZListFile *fauthz, Error **errp)
  52 {
  53     GError *err = NULL;
  54     gchar *content = NULL;
  55     gsize len;
  56     QObject *obj = NULL;
  57     QDict *pdict;
  58     Visitor *v = NULL;
  59     QAuthZ *ret = NULL;
  60
  61     trace_qauthz_list_file_load(fauthz, fauthz->filename);
  62     if (!g_file_get_contents(fauthz->filename, &content, &len, &err)) {
  63         error_setg(errp, "Unable to read '%s': %s",
  64                    fauthz->filename, err->message);
  65         goto cleanup;
  66     }
  67
  68     obj = qobject_from_json(content, errp);
  69     if (!obj) {
  70         goto cleanup;
  71     }
  72
  73     pdict = qobject_to(QDict, obj);
  74     if (!pdict) {
  75         error_setg(errp, "File '%s' must contain a JSON object",
  76                    fauthz->filename);
  77         goto cleanup;
  78     }
  79
  80     v = qobject_input_visitor_new(obj);
  81
  82     ret = (QAuthZ *)user_creatable_add_type(TYPE_QAUTHZ_LIST,
  83                                             NULL, pdict, v, errp);
  84
  85  cleanup:
  86     visit_free(v);
  87     qobject_unref(obj);
  88     if (err) {
  89         g_error_free(err);
  90     }
  91     g_free(content);
  92     return ret;
  93 }
  94
  95
  96 static void
  97 qauthz_list_file_event(int64_t wd G_GNUC_UNUSED,
  98                        QFileMonitorEvent ev G_GNUC_UNUSED,
  99                        const char *name G_GNUC_UNUSED,
 100                        void *opaque)
 101 {
 102     QAuthZListFile *fauthz = opaque;
 103     Error *err = NULL;
 104
 105     if (ev != QFILE_MONITOR_EVENT_MODIFIED &&
 106         ev != QFILE_MONITOR_EVENT_CREATED) {
 107         return;
 108     }
 109
 110     object_unref(OBJECT(fauthz->list));
 111     fauthz->list = qauthz_list_file_load(fauthz, &err);
 112     trace_qauthz_list_file_refresh(fauthz,
 113                                    fauthz->filename, fauthz->list ? 1 : 0);
 114     if (!fauthz->list) {
 115         error_report_err(err);
 116     }
 117 }
 118
 119 static void
 120 qauthz_list_file_complete(UserCreatable *uc, Error **errp)
 121 {
 122     QAuthZListFile *fauthz = QAUTHZ_LIST_FILE(uc);
 123     gchar *dir = NULL, *file = NULL;
 124
 125     if (!fauthz->filename) {
 126         error_setg(errp, "filename not provided");
 127         return;
 128     }
 129
 130     fauthz->list = qauthz_list_file_load(fauthz, errp);
 131     if (!fauthz->list) {
 132         return;
 133     }
 134
 135     if (!fauthz->refresh) {
 136         return;
 137     }
 138
 139     fauthz->file_monitor = qemu_file_monitor_new(errp);
 140     if (!fauthz->file_monitor) {
 141         return;
 142     }
 143
 144     dir = g_path_get_dirname(fauthz->filename);
 145     if (g_str_equal(dir, ".")) {
 146         error_setg(errp, "Filename must be an absolute path");
 147         goto cleanup;
 148     }
 149     file = g_path_get_basename(fauthz->filename);
 150     if (g_str_equal(file, ".")) {
 151         error_setg(errp, "Path has no trailing filename component");
 152         goto cleanup;
 153     }
 154
 155     fauthz->file_watch = qemu_file_monitor_add_watch(
 156         fauthz->file_monitor, dir, file,
 157         qauthz_list_file_event, fauthz, errp);
 158     if (fauthz->file_watch < 0) {
 159         goto cleanup;
 160     }
 161
 162  cleanup:
 163     g_free(file);
 164     g_free(dir);
 165 }
 166
 167
 168 static void
 169 qauthz_list_file_prop_set_filename(Object *obj,
 170                                    const char *value,
 171                                    Error **errp G_GNUC_UNUSED)
 172 {
 173     QAuthZListFile *fauthz = QAUTHZ_LIST_FILE(obj);
 174
 175     g_free(fauthz->filename);
 176     fauthz->filename = g_strdup(value);
 177 }
 178
 179
 180 static char *
 181 qauthz_list_file_prop_get_filename(Object *obj,
 182                                    Error **errp G_GNUC_UNUSED)
 183 {
 184     QAuthZListFile *fauthz = QAUTHZ_LIST_FILE(obj);
 185
 186     return g_strdup(fauthz->filename);
 187 }
 188
 189
 190 static void
 191 qauthz_list_file_prop_set_refresh(Object *obj,
 192                                   bool value,
 193                                   Error **errp G_GNUC_UNUSED)
 194 {
 195     QAuthZListFile *fauthz = QAUTHZ_LIST_FILE(obj);
 196
 197     fauthz->refresh = value;
 198 }
 199
 200
 201 static bool
 202 qauthz_list_file_prop_get_refresh(Object *obj,
 203                                   Error **errp G_GNUC_UNUSED)
 204 {
 205     QAuthZListFile *fauthz = QAUTHZ_LIST_FILE(obj);
 206
 207     return fauthz->refresh;
 208 }
 209
 210
 211 static void
 212 qauthz_list_file_finalize(Object *obj)
 213 {
 214     QAuthZListFile *fauthz = QAUTHZ_LIST_FILE(obj);
 215
 216     object_unref(OBJECT(fauthz->list));
 217     g_free(fauthz->filename);
 218     qemu_file_monitor_free(fauthz->file_monitor);
 219 }
 220
 221
 222 static void
 223 qauthz_list_file_class_init(ObjectClass *oc, void *data)
 224 {
 225     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
 226     QAuthZClass *authz = QAUTHZ_CLASS(oc);
 227
 228     ucc->complete = qauthz_list_file_complete;
 229
 230     object_class_property_add_str(oc, "filename",
 231                                   qauthz_list_file_prop_get_filename,
 232                                   qauthz_list_file_prop_set_filename);
 233     object_class_property_add_bool(oc, "refresh",
 234                                    qauthz_list_file_prop_get_refresh,
 235                                    qauthz_list_file_prop_set_refresh);
 236
 237     authz->is_allowed = qauthz_list_file_is_allowed;
 238 }
 239
 240
 241 static void
 242 qauthz_list_file_init(Object *obj)
 243 {
 244     QAuthZListFile *authz = QAUTHZ_LIST_FILE(obj);
 245
 246     authz->file_watch = -1;
 247 #ifdef CONFIG_INOTIFY1
 248     authz->refresh = true;
 249 #endif
 250 }
 251
 252
 253 QAuthZListFile *qauthz_list_file_new(const char *id,
 254                                      const char *filename,
 255                                      bool refresh,
 256                                      Error **errp)
 257 {
 258     return QAUTHZ_LIST_FILE(
 259         object_new_with_props(TYPE_QAUTHZ_LIST_FILE,
 260                               object_get_objects_root(),
 261                               id, errp,
 262                               "filename", filename,
 263                               "refresh", refresh ? "yes" : "no",
 264                               NULL));
 265 }
 266
 267
 268 static const TypeInfo qauthz_list_file_info = {
 269     .parent = TYPE_QAUTHZ,
 270     .name = TYPE_QAUTHZ_LIST_FILE,
 271     .instance_init = qauthz_list_file_init,
 272     .instance_size = sizeof(QAuthZListFile),
 273     .instance_finalize = qauthz_list_file_finalize,
 274     .class_init = qauthz_list_file_class_init,
 275     .interfaces = (InterfaceInfo[]) {
 276         { TYPE_USER_CREATABLE },
 277         { }
 278     }
 279 };
 280
 281
 282 static void
 283 qauthz_list_file_register_types(void)
 284 {
 285     type_register_static(&qauthz_list_file_info);
 286 }
 287
 288
 289 type_init(qauthz_list_file_register_types);