/* Watch code for Xen Store Daemon. Copyright (C) 2005 Rusty Russell IBM Corporation This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; If not, see . */ #include #include #include #include #include #include #include #include "talloc.h" #include "list.h" #include "watch.h" #include "xenstore_lib.h" #include "utils.h" #include "domain.h" #include "transaction.h" struct watch { /* Watches on this connection */ struct list_head list; /* Offset into path for skipping prefix (used for relative paths). */ unsigned int prefix_len; char *token; char *node; }; /* Is child a subnode of parent, or equal? */ static bool is_child(const char *child, const char *parent) { unsigned int len = strlen(parent); /* * / should really be "" for this algorithm to work, but that's a * usability nightmare. */ if (streq(parent, "/")) return true; if (strncmp(child, parent, len) != 0) return false; return child[len] == '/' || child[len] == '\0'; } static const char *get_watch_path(const struct watch *watch, const char *name) { return name + watch->prefix_len; } /* * Check permissions of a specific watch to fire: * Either the node itself or its parent have to be readable by the connection * the watch has been setup for. In case a watch event is created due to * changed permissions we need to take the old permissions into account, too. */ static bool watch_permitted(struct connection *conn, const void *ctx, const char *name, const struct node *node, struct node_perms *perms) { unsigned int perm; const struct node *parent; char *parent_name; if (perms) { perm = perm_for_conn(conn, perms); if (perm & XS_PERM_READ) return true; } if (!node) { node = read_node_const(conn, ctx, name); if (!node) return false; } perm = perm_for_conn_from_node(conn, node); if (perm & XS_PERM_READ) return true; parent = node->parent; if (!parent) { parent_name = get_parent(ctx, node->name); if (!parent_name) return false; parent = read_node_const(conn, ctx, parent_name); if (!parent) return false; } perm = perm_for_conn_from_node(conn, parent); return perm & XS_PERM_READ; } /* * Check whether any watch events are to be sent. * Temporary memory allocations are done with ctx. * We need to take the (potential) old permissions of the node into account * as a watcher losing permissions to access a node should receive the * watch event, too. */ void fire_watches(struct connection *conn, const void *ctx, const char *name, const struct node *node, bool exact, struct node_perms *perms) { struct connection *i; struct buffered_data *req; struct watch *watch; /* During transactions, don't fire watches, but queue them. */ if (conn && conn->transaction) { queue_watches(conn, name, exact); return; } req = domain_is_unprivileged(conn) ? conn->in : NULL; /* Create an event for each watch. */ list_for_each_entry(i, &connections, list) { if (!watch_permitted(i, ctx, name, node, perms)) continue; list_for_each_entry(watch, &i->watches, list) { if (exact) { if (streq(name, watch->node)) send_event(req, i, get_watch_path(watch, name), watch->token); } else { if (is_child(name, watch->node)) send_event(req, i, get_watch_path(watch, name), watch->token); } } } } static int destroy_watch(void *_watch) { trace_destroy(_watch, "watch"); return 0; } static int check_watch_path(struct connection *conn, const void *ctx, const char **path, bool *relative) { *relative = !strstarts(*path, "/") && !strstarts(*path, "@"); *path = canonicalize(conn, ctx, *path, true); return *path ? 0 : errno; } static struct watch *add_watch(struct connection *conn, const char *path, const char *token, bool relative, bool no_quota_check) { struct watch *watch; watch = talloc(conn, struct watch); if (!watch) goto nomem; watch->node = talloc_strdup(watch, path); watch->token = talloc_strdup(watch, token); if (!watch->node || !watch->token) goto nomem; if (domain_memory_add(conn, conn->id, strlen(path) + strlen(token), no_quota_check)) goto nomem; watch->prefix_len = relative ? strlen(get_implicit_path(conn)) + 1 : 0; domain_watch_inc(conn); list_add_tail(&watch->list, &conn->watches); talloc_set_destructor(watch, destroy_watch); return watch; nomem: talloc_free(watch); errno = ENOMEM; return NULL; } int do_watch(const void *ctx, struct connection *conn, struct buffered_data *in) { struct watch *watch; const char *vec[2]; bool relative; if (get_strings(in, vec, ARRAY_SIZE(vec)) != ARRAY_SIZE(vec)) return EINVAL; errno = check_watch_path(conn, ctx, &(vec[0]), &relative); if (errno) return errno; /* Check for duplicates. */ list_for_each_entry(watch, &conn->watches, list) { if (streq(watch->node, vec[0]) && streq(watch->token, vec[1])) return EEXIST; } if (domain_watch(conn) > hard_quotas[ACC_WATCH].val) return E2BIG; watch = add_watch(conn, vec[0], vec[1], relative, false); if (!watch) return errno; trace_create(watch, "watch"); send_ack(conn, XS_WATCH); /* * We fire once up front: simplifies clients and restart. * This event will not be linked to the XS_WATCH request. */ send_event(NULL, conn, get_watch_path(watch, watch->node), watch->token); return 0; } int do_unwatch(const void *ctx, struct connection *conn, struct buffered_data *in) { struct watch *watch; const char *node; const char *vec[2]; if (get_strings(in, vec, ARRAY_SIZE(vec)) != ARRAY_SIZE(vec)) return EINVAL; node = canonicalize(conn, ctx, vec[0], true); if (!node) return errno; list_for_each_entry(watch, &conn->watches, list) { if (streq(watch->node, node) && streq(watch->token, vec[1])) { list_del(&watch->list); domain_memory_add_nochk(conn, conn->id, -strlen(watch->node) - strlen(watch->token)); talloc_free(watch); domain_watch_dec(conn); send_ack(conn, XS_UNWATCH); return 0; } } return ENOENT; } void conn_delete_all_watches(struct connection *conn) { struct watch *watch; while ((watch = list_top(&conn->watches, struct watch, list))) { list_del(&watch->list); domain_memory_add_nochk(conn, conn->id, -strlen(watch->node) - strlen(watch->token)); talloc_free(watch); domain_watch_dec(conn); } } const char *dump_state_watches(FILE *fp, struct connection *conn, unsigned int conn_id) { const char *ret = NULL; struct watch *watch; struct xs_state_watch sw; struct xs_state_record_header head; const char *path; head.type = XS_STATE_TYPE_WATCH; list_for_each_entry(watch, &conn->watches, list) { head.length = sizeof(sw); sw.conn_id = conn_id; path = get_watch_path(watch, watch->node); sw.path_length = strlen(path) + 1; sw.token_length = strlen(watch->token) + 1; head.length += sw.path_length + sw.token_length; head.length = ROUNDUP(head.length, 3); if (fwrite(&head, sizeof(head), 1, fp) != 1) return "Dump watch state error"; if (fwrite(&sw, sizeof(sw), 1, fp) != 1) return "Dump watch state error"; if (fwrite(path, sw.path_length, 1, fp) != 1) return "Dump watch path error"; if (fwrite(watch->token, sw.token_length, 1, fp) != 1) return "Dump watch token error"; ret = dump_state_align(fp); if (ret) return ret; } return ret; } void read_state_watch(const void *ctx, const void *state) { const struct xs_state_watch *sw = state; struct connection *conn; const char *path, *token; bool relative; conn = get_connection_by_id(sw->conn_id); if (!conn) barf("connection not found for read watch"); path = (char *)sw->data; token = path + sw->path_length; /* Don't check success, we want the relative information only. */ check_watch_path(conn, ctx, &path, &relative); if (!path) barf("allocation error for read watch"); if (!add_watch(conn, path, token, relative, true)) barf("error adding watch"); } /* * Local variables: * mode: C * c-file-style: "linux" * indent-tabs-mode: t * c-basic-offset: 8 * tab-width: 8 * End: */