/* * Copyright (c) 2007 Vreixo Formoso * * This file is part of the libisofs project; you can redistribute it and/or * modify it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. See COPYING file for details. */ #include "libisofs.h" #include "node.h" #include "stream.h" #ifdef Libisofs_with_aaiP #include "aaip_0_2.h" #endif #include #include #include #include #include struct dir_iter_data { /* points to the last visited child, to NULL before start */ IsoNode *pos; /* Some control flags. * bit 0 -> 1 if next called, 0 reseted at start or on deletion */ int flag; }; /** * Increments the reference counting of the given node. */ void iso_node_ref(IsoNode *node) { ++node->refcount; } /** * Decrements the reference couting of the given node. * If it reach 0, the node is free, and, if the node is a directory, * its children will be unref() too. */ void iso_node_unref(IsoNode *node) { if (--node->refcount == 0) { switch (node->type) { case LIBISO_DIR: { IsoNode *child = ((IsoDir*)node)->children; while (child != NULL) { IsoNode *tmp = child->next; child->parent = NULL; iso_node_unref(child); child = tmp; } } break; case LIBISO_FILE: { IsoFile *file = (IsoFile*) node; iso_stream_unref(file->stream); } break; case LIBISO_SYMLINK: { IsoSymlink *link = (IsoSymlink*) node; free(link->dest); } default: /* other kind of nodes does not need to delete anything here */ break; } if (node->xinfo) { IsoExtendedInfo *info = node->xinfo; while (info != NULL) { IsoExtendedInfo *tmp = info->next; /* free extended info */ info->process(info->data, 1); free(info); info = tmp; } } free(node->name); free(node); } } /** * Add extended information to the given node. Extended info allows * applications (and libisofs itself) to add more information to an IsoNode. * You can use this facilities to associate new information with a given * node. * * Each node keeps a list of added extended info, meaning you can add several * extended info data to each node. Each extended info you add is identified * by the proc parameter, a pointer to a function that knows how to manage * the external info data. Thus, in order to add several types of extended * info, you need to define a "proc" function for each type. * * @param node * The node where to add the extended info * @param proc * A function pointer used to identify the type of the data, and that * knows how to manage it * @param data * Extended info to add. * @return * 1 if success, 0 if the given node already has extended info of the * type defined by the "proc" function, < 0 on error */ int iso_node_add_xinfo(IsoNode *node, iso_node_xinfo_func proc, void *data) { IsoExtendedInfo *info; IsoExtendedInfo *pos; if (node == NULL || proc == NULL) { return ISO_NULL_POINTER; } pos = node->xinfo; while (pos != NULL) { if (pos->process == proc) { return 0; /* extended info already added */ } pos = pos->next; } info = malloc(sizeof(IsoExtendedInfo)); if (info == NULL) { return ISO_OUT_OF_MEM; } info->next = node->xinfo; info->data = data; info->process = proc; node->xinfo = info; return ISO_SUCCESS; } /** * Remove the given extended info (defined by the proc function) from the * given node. * * @return * 1 on success, 0 if node does not have extended info of the requested * type, < 0 on error */ int iso_node_remove_xinfo(IsoNode *node, iso_node_xinfo_func proc) { IsoExtendedInfo *pos, *prev; if (node == NULL || proc == NULL) { return ISO_NULL_POINTER; } prev = NULL; pos = node->xinfo; while (pos != NULL) { if (pos->process == proc) { /* this is the extended info we want to remove */ pos->process(pos->data, 1); if (prev != NULL) { prev->next = pos->next; } else { node->xinfo = pos->next; } free(pos); return ISO_SUCCESS; } prev = pos; pos = pos->next; } /* requested xinfo not found */ return 0; } /** * Get the given extended info (defined by the proc function) from the * given node. * * @param data * Will be filled with the extended info corresponding to the given proc * function * @return * 1 on success, 0 if node does not have extended info of the requested * type, < 0 on error */ int iso_node_get_xinfo(IsoNode *node, iso_node_xinfo_func proc, void **data) { IsoExtendedInfo *pos; if (node == NULL || proc == NULL || data == NULL) { return ISO_NULL_POINTER; } pos = node->xinfo; while (pos != NULL) { if (pos->process == proc) { /* this is the extended info we want */ *data = pos->data; return ISO_SUCCESS; } pos = pos->next; } /* requested xinfo not found */ return 0; } /** * Get the type of an IsoNode. */ enum IsoNodeType iso_node_get_type(IsoNode *node) { return node->type; } /** * Set the name of a node. * * @param name The name in UTF-8 encoding */ int iso_node_set_name(IsoNode *node, const char *name) { char *new; if ((IsoNode*)node->parent == node) { /* you can't change name of the root node */ return ISO_WRONG_ARG_VALUE; } /* check if the name is valid */ if (!iso_node_is_valid_name(name)) { return ISO_WRONG_ARG_VALUE; } if (node->parent != NULL) { /* check if parent already has a node with same name */ if (iso_dir_get_node(node->parent, name, NULL) == 1) { return ISO_NODE_NAME_NOT_UNIQUE; } } new = strdup(name); if (new == NULL) { return ISO_OUT_OF_MEM; } free(node->name); node->name = new; if (node->parent != NULL) { IsoDir *parent; int res; /* take and add again to ensure correct children order */ parent = node->parent; iso_node_take(node); res = iso_dir_add_node(parent, node, 0); if (res < 0) { return res; } } return ISO_SUCCESS; } /** * Get the name of a node (in UTF-8). * The returned string belongs to the node and should not be modified nor * freed. Use strdup if you really need your own copy. */ const char *iso_node_get_name(const IsoNode *node) { return node->name; } /* ts A90128 */ /** * See API function iso_node_set_permissions() * * @param flag bit0= do not adjust ACL * @return >0 success , <0 error */ int iso_node_set_perms_internal(IsoNode *node, mode_t mode, int flag) { int ret; node->mode = (node->mode & S_IFMT) | (mode & ~S_IFMT); #ifdef Libisofs_with_aaiP /* ts A90119 */ /* If the node has ACL info : update ACL */ ret = 1; if (!(flag & 1)) ret = iso_node_set_acl_text(node, "", "", 2); return ret; #endif } /** * Set the permissions for the node. This attribute is only useful when * Rock Ridge extensions are enabled. * * @param mode * bitmask with the permissions of the node, as specified in 'man 2 stat'. * The file type bitfields will be ignored, only file permissions will be * modified. */ void iso_node_set_permissions(IsoNode *node, mode_t mode) { iso_node_set_perms_internal(node, mode, 0); } /** * Get the permissions for the node */ mode_t iso_node_get_permissions(const IsoNode *node) { return node->mode & ~S_IFMT; } /** * Get the mode of the node, both permissions and file type, as specified in * 'man 2 stat'. */ mode_t iso_node_get_mode(const IsoNode *node) { return node->mode; } /** * Set the user id for the node. This attribute is only useful when * Rock Ridge extensions are enabled. */ void iso_node_set_uid(IsoNode *node, uid_t uid) { node->uid = uid; } /** * Get the user id of the node. */ uid_t iso_node_get_uid(const IsoNode *node) { return node->uid; } /** * Set the group id for the node. This attribute is only useful when * Rock Ridge extensions are enabled. */ void iso_node_set_gid(IsoNode *node, gid_t gid) { node->gid = gid; } /** * Get the group id of the node. */ gid_t iso_node_get_gid(const IsoNode *node) { return node->gid; } /** * Set the time of last modification of the file */ void iso_node_set_mtime(IsoNode *node, time_t time) { node->mtime = time; } /** * Get the time of last modification of the file */ time_t iso_node_get_mtime(const IsoNode *node) { return node->mtime; } /** * Set the time of last access to the file */ void iso_node_set_atime(IsoNode *node, time_t time) { node->atime = time; } /** * Get the time of last access to the file */ time_t iso_node_get_atime(const IsoNode *node) { return node->atime; } /** * Set the time of last status change of the file */ void iso_node_set_ctime(IsoNode *node, time_t time) { node->ctime = time; } /** * Get the time of last status change of the file */ time_t iso_node_get_ctime(const IsoNode *node) { return node->ctime; } void iso_node_set_hidden(IsoNode *node, int hide_attrs) { /* you can't hide root node */ if ((IsoNode*)node->parent != node) { node->hidden = hide_attrs; } } /** * Add a new node to a dir. Note that this function don't add a new ref to * the node, so you don't need to free it, it will be automatically freed * when the dir is deleted. Of course, if you want to keep using the node * after the dir life, you need to iso_node_ref() it. * * @param dir * the dir where to add the node * @param child * the node to add. You must ensure that the node hasn't previously added * to other dir, and that the node name is unique inside the child. * Otherwise this function will return a failure, and the child won't be * inserted. * @param replace * if the dir already contains a node with the same name, whether to * replace or not the old node with this. * @return * number of nodes in dir if succes, < 0 otherwise */ int iso_dir_add_node(IsoDir *dir, IsoNode *child, enum iso_replace_mode replace) { IsoNode **pos; if (dir == NULL || child == NULL) { return ISO_NULL_POINTER; } if ((IsoNode*)dir == child) { return ISO_WRONG_ARG_VALUE; } /* * check if child is already added to another dir, or if child * is the root node, where parent == itself */ if (child->parent != NULL || child->parent == (IsoDir*)child) { return ISO_NODE_ALREADY_ADDED; } iso_dir_find(dir, child->name, &pos); return iso_dir_insert(dir, child, pos, replace); } /** * Locate a node inside a given dir. * * @param name * The name of the node * @param node * Location for a pointer to the node, it will filled with NULL if the dir * doesn't have a child with the given name. * The node will be owned by the dir and shouldn't be unref(). Just call * iso_node_ref() to get your own reference to the node. * Note that you can pass NULL is the only thing you want to do is check * if a node with such name already exists on dir. * @return * 1 node found, 0 child has no such node, < 0 error * Possible errors: * ISO_NULL_POINTER, if dir or name are NULL */ int iso_dir_get_node(IsoDir *dir, const char *name, IsoNode **node) { int ret; IsoNode **pos; if (dir == NULL || name == NULL) { return ISO_NULL_POINTER; } ret = iso_dir_exists(dir, name, &pos); if (ret == 0) { if (node) { *node = NULL; } return 0; /* node not found */ } if (node) { *node = *pos; } return 1; } /** * Get the number of children of a directory. * * @return * >= 0 number of items, < 0 error * Possible errors: * ISO_NULL_POINTER, if dir is NULL */ int iso_dir_get_children_count(IsoDir *dir) { if (dir == NULL) { return ISO_NULL_POINTER; } return dir->nchildren; } static int iter_next(IsoDirIter *iter, IsoNode **node) { struct dir_iter_data *data; if (iter == NULL || node == NULL) { return ISO_NULL_POINTER; } data = iter->data; /* clear next flag */ data->flag &= ~0x01; if (data->pos == NULL) { /* we are at the beginning */ data->pos = iter->dir->children; if (data->pos == NULL) { /* empty dir */ *node = NULL; return 0; } } else { if (data->pos->parent != iter->dir) { /* this can happen if the node has been moved to another dir */ /* TODO specific error */ return ISO_ERROR; } if (data->pos->next == NULL) { /* no more children */ *node = NULL; return 0; } else { /* free reference to current position */ iso_node_unref(data->pos); /* it is never last ref!! */ /* advance a position */ data->pos = data->pos->next; } } /* ok, take a ref to the current position, to prevent internal errors * if deleted somewhere */ iso_node_ref(data->pos); data->flag |= 0x01; /* set next flag */ /* return pointed node */ *node = data->pos; return ISO_SUCCESS; } /** * Check if there're more children. * * @return * 1 dir has more elements, 0 no, < 0 error * Possible errors: * ISO_NULL_POINTER, if iter is NULL */ static int iter_has_next(IsoDirIter *iter) { struct dir_iter_data *data; if (iter == NULL) { return ISO_NULL_POINTER; } data = iter->data; if (data->pos == NULL) { return iter->dir->children == NULL ? 0 : 1; } else { return data->pos->next == NULL ? 0 : 1; } } static void iter_free(IsoDirIter *iter) { struct dir_iter_data *data; data = iter->data; if (data->pos != NULL) { iso_node_unref(data->pos); } free(data); } static IsoNode** iso_dir_find_node(IsoDir *dir, IsoNode *node) { IsoNode **pos; pos = &(dir->children); while (*pos != NULL && *pos != node) { pos = &((*pos)->next); } return pos; } /** * Removes a child from a directory. * The child is not freed, so you will become the owner of the node. Later * you can add the node to another dir (calling iso_dir_add_node), or free * it if you don't need it (with iso_node_unref). * * @return * 1 on success, < 0 error */ int iso_node_take(IsoNode *node) { IsoNode **pos; IsoDir* dir; if (node == NULL) { return ISO_NULL_POINTER; } dir = node->parent; if (dir == NULL) { return ISO_NODE_NOT_ADDED_TO_DIR; } pos = iso_dir_find_node(dir, node); if (pos == NULL) { /* should never occur */ return ISO_ASSERT_FAILURE; } /* notify iterators just before remove */ iso_notify_dir_iters(node, 0); *pos = node->next; node->parent = NULL; node->next = NULL; dir->nchildren--; return ISO_SUCCESS; } /** * Removes a child from a directory and free (unref) it. * If you want to keep the child alive, you need to iso_node_ref() it * before this call, but in that case iso_node_take() is a better * alternative. * * @return * 1 on success, < 0 error */ int iso_node_remove(IsoNode *node) { int ret; ret = iso_node_take(node); if (ret == ISO_SUCCESS) { iso_node_unref(node); } return ret; } /* * Get the parent of the given iso tree node. No extra ref is added to the * returned directory, you must take your ref. with iso_node_ref() if you * need it. * * If node is the root node, the same node will be returned as its parent. * * This returns NULL if the node doesn't pertain to any tree * (it was removed/take). */ IsoDir *iso_node_get_parent(IsoNode *node) { return node->parent; } /* TODO #00005 optimize iso_dir_iter_take */ static int iter_take(IsoDirIter *iter) { struct dir_iter_data *data; if (iter == NULL) { return ISO_NULL_POINTER; } data = iter->data; if (!(data->flag & 0x01)) { return ISO_ERROR; /* next not called or end of dir */ } if (data->pos == NULL) { return ISO_ASSERT_FAILURE; } /* clear next flag */ data->flag &= ~0x01; return iso_node_take(data->pos); } static int iter_remove(IsoDirIter *iter) { int ret; IsoNode *pos; struct dir_iter_data *data; if (iter == NULL) { return ISO_NULL_POINTER; } data = iter->data; pos = data->pos; ret = iter_take(iter); if (ret == ISO_SUCCESS) { /* remove node */ iso_node_unref(pos); } return ret; } void iter_notify_child_taken(IsoDirIter *iter, IsoNode *node) { IsoNode *pos, *pre; struct dir_iter_data *data; data = iter->data; if (data->pos == node) { pos = iter->dir->children; pre = NULL; while (pos != NULL && pos != data->pos) { pre = pos; pos = pos->next; } if (pos == NULL || pos != data->pos) { return; } /* dispose iterator reference */ iso_node_unref(data->pos); if (pre == NULL) { /* node is a first position */ iter->dir->children = pos->next; data->pos = NULL; } else { pre->next = pos->next; data->pos = pre; iso_node_ref(pre); /* take iter ref */ } } } static struct iso_dir_iter_iface iter_class = { iter_next, iter_has_next, iter_free, iter_take, iter_remove, iter_notify_child_taken }; int iso_dir_get_children(const IsoDir *dir, IsoDirIter **iter) { IsoDirIter *it; struct dir_iter_data *data; if (dir == NULL || iter == NULL) { return ISO_NULL_POINTER; } it = malloc(sizeof(IsoDirIter)); if (it == NULL) { return ISO_OUT_OF_MEM; } data = malloc(sizeof(struct dir_iter_data)); if (data == NULL) { free(it); return ISO_OUT_OF_MEM; } it->class = &iter_class; it->dir = (IsoDir*)dir; data->pos = NULL; data->flag = 0x00; it->data = data; if (iso_dir_iter_register(it) < 0) { free(it); return ISO_OUT_OF_MEM; } iso_node_ref((IsoNode*)dir); /* tak a ref to the dir */ *iter = it; return ISO_SUCCESS; } int iso_dir_iter_next(IsoDirIter *iter, IsoNode **node) { if (iter == NULL || node == NULL) { return ISO_NULL_POINTER; } return iter->class->next(iter, node); } int iso_dir_iter_has_next(IsoDirIter *iter) { if (iter == NULL) { return ISO_NULL_POINTER; } return iter->class->has_next(iter); } void iso_dir_iter_free(IsoDirIter *iter) { if (iter != NULL) { iso_dir_iter_unregister(iter); iter->class->free(iter); iso_node_unref((IsoNode*)iter->dir); free(iter); } } int iso_dir_iter_take(IsoDirIter *iter) { if (iter == NULL) { return ISO_NULL_POINTER; } return iter->class->take(iter); } int iso_dir_iter_remove(IsoDirIter *iter) { if (iter == NULL) { return ISO_NULL_POINTER; } return iter->class->remove(iter); } /** * Get the destination of a node. * The returned string belongs to the node and should not be modified nor * freed. Use strdup if you really need your own copy. */ const char *iso_symlink_get_dest(const IsoSymlink *link) { return link->dest; } /** * Set the destination of a link. */ int iso_symlink_set_dest(IsoSymlink *link, const char *dest) { char *d; if (!iso_node_is_valid_link_dest(dest)) { /* guard against null or empty dest */ return ISO_WRONG_ARG_VALUE; } d = strdup(dest); if (d == NULL) { return ISO_OUT_OF_MEM; } free(link->dest); link->dest = d; return ISO_SUCCESS; } /** * Sets the order in which a node will be written on image. High weihted files * will be written first, so in a disc them will be written near the center. * * @param node * The node which weight will be changed. If it's a dir, this function * will change the weight of all its children. For nodes other that dirs * or regular files, this function has no effect. * @param w * The weight as a integer number, the greater this value is, the * closer from the begining of image the file will be written. */ void iso_node_set_sort_weight(IsoNode *node, int w) { if (node->type == LIBISO_DIR) { IsoNode *child = ((IsoDir*)node)->children; while (child) { iso_node_set_sort_weight(child, w); child = child->next; } } else if (node->type == LIBISO_FILE) { ((IsoFile*)node)->sort_weight = w; } } /** * Get the sort weight of a file. */ int iso_file_get_sort_weight(IsoFile *file) { return file->sort_weight; } /** * Get the size of the file, in bytes */ off_t iso_file_get_size(IsoFile *file) { return iso_stream_get_size(file->stream); } /** * Get the IsoStream that represents the contents of the given IsoFile. * * If you open() the stream, it should be close() before image generation. * * @return * The IsoStream. No extra ref is added, so the IsoStream belong to the * IsoFile, and it may be freed together with it. Add your own ref with * iso_stream_ref() if you need it. * * @since 0.6.4 */ IsoStream *iso_file_get_stream(IsoFile *file) { return file->stream; } /** * Get the device id (major/minor numbers) of the given block or * character device file. The result is undefined for other kind * of special files, of first be sure iso_node_get_mode() returns either * S_IFBLK or S_IFCHR. * * @since 0.6.6 */ dev_t iso_special_get_dev(IsoSpecial *special) { return special->dev; } /** * Get the block lba of a file node, if it was imported from an old image. * * @param file * The file * @param lba * Will be filled with the kba * @param flag * Reserved for future usage, submit 0 * @return * 1 if lba is valid (file comes from old image), 0 if file was newly * added, i.e. it does not come from an old image, < 0 error * * @since 0.6.4 */ int iso_file_get_old_image_lba(IsoFile *file, uint32_t *lba, int flag) { int ret; int section_count; struct iso_file_section *sections; if (file == NULL || lba == NULL) { return ISO_NULL_POINTER; } ret = iso_file_get_old_image_sections(file, §ion_count, §ions, flag); if (ret <= 0) { return ret; } if (section_count != 1) { free(sections); return ISO_WRONG_ARG_VALUE; } *lba = sections[0].block; free(sections); return 0; } /* * Like iso_file_get_old_image_lba(), but take an IsoNode. * * @return * 1 if lba is valid (file comes from old image), 0 if file was newly * added, i.e. it does not come from an old image, 2 node type has no * LBA (no regular file), < 0 error * * @since 0.6.4 */ int iso_node_get_old_image_lba(IsoNode *node, uint32_t *lba, int flag) { if (node == NULL) { return ISO_NULL_POINTER; } if (ISO_NODE_IS_FILE(node)) { return iso_file_get_old_image_lba((IsoFile*)node, lba, flag); } else { return 2; } } /** * Check if a given name is valid for an iso node. * * @return * 1 if yes, 0 if not */ int iso_node_is_valid_name(const char *name) { /* a name can't be NULL */ if (name == NULL) { return 0; } /* guard against the empty string or big names... */ if (name[0] == '\0' || strlen(name) > 255) { return 0; } /* ...against "." and ".." names... */ if (!strcmp(name, ".") || !strcmp(name, "..")) { return 0; } /* ...and against names with '/' */ if (strchr(name, '/') != NULL) { return 0; } return 1; } /** * Check if a given path is valid for the destination of a link. * * @return * 1 if yes, 0 if not */ int iso_node_is_valid_link_dest(const char *dest) { int ret; char *ptr, *brk_info, *component; /* a dest can't be NULL */ if (dest == NULL) { return 0; } /* guard against the empty string or big dest... */ if (dest[0] == '\0' || strlen(dest) > PATH_MAX) { return 0; } /* check that all components are valid */ if (!strcmp(dest, "/")) { /* "/" is a valid component */ return 1; } ptr = strdup(dest); if (ptr == NULL) { return 0; } ret = 1; component = strtok_r(ptr, "/", &brk_info); while (component) { if (strcmp(component, ".") && strcmp(component, "..")) { ret = iso_node_is_valid_name(component); if (ret == 0) { break; } } component = strtok_r(NULL, "/", &brk_info); } free(ptr); return ret; } void iso_dir_find(IsoDir *dir, const char *name, IsoNode ***pos) { *pos = &(dir->children); while (**pos != NULL && strcmp((**pos)->name, name) < 0) { *pos = &((**pos)->next); } } int iso_dir_exists(IsoDir *dir, const char *name, IsoNode ***pos) { IsoNode **node; iso_dir_find(dir, name, &node); if (pos) { *pos = node; } return (*node != NULL && !strcmp((*node)->name, name)) ? 1 : 0; } int iso_dir_insert(IsoDir *dir, IsoNode *node, IsoNode **pos, enum iso_replace_mode replace) { if (*pos != NULL && !strcmp((*pos)->name, node->name)) { /* a node with same name already exists */ switch(replace) { case ISO_REPLACE_NEVER: return ISO_NODE_NAME_NOT_UNIQUE; case ISO_REPLACE_IF_NEWER: if ((*pos)->mtime >= node->mtime) { /* old file is newer */ return ISO_NODE_NAME_NOT_UNIQUE; } break; case ISO_REPLACE_IF_SAME_TYPE_AND_NEWER: if ((*pos)->mtime >= node->mtime) { /* old file is newer */ return ISO_NODE_NAME_NOT_UNIQUE; } /* fall down */ case ISO_REPLACE_IF_SAME_TYPE: if ((node->mode & S_IFMT) != ((*pos)->mode & S_IFMT)) { /* different file types */ return ISO_NODE_NAME_NOT_UNIQUE; } break; case ISO_REPLACE_ALWAYS: break; default: /* CAN'T HAPPEN */ return ISO_ASSERT_FAILURE; } /* if we are reach here we have to replace */ node->next = (*pos)->next; (*pos)->parent = NULL; (*pos)->next = NULL; iso_node_unref(*pos); *pos = node; node->parent = dir; return dir->nchildren; } node->next = *pos; *pos = node; node->parent = dir; return ++dir->nchildren; } /* iterators are stored in a linked list */ struct iter_reg_node { IsoDirIter *iter; struct iter_reg_node *next; }; /* list header */ static struct iter_reg_node *iter_reg = NULL; /** * Add a new iterator to the registry. The iterator register keeps track of * all iterators being used, and are notified when directory structure * changes. */ int iso_dir_iter_register(IsoDirIter *iter) { struct iter_reg_node *new; new = malloc(sizeof(struct iter_reg_node)); if (new == NULL) { return ISO_OUT_OF_MEM; } new->iter = iter; new->next = iter_reg; iter_reg = new; return ISO_SUCCESS; } /** * Unregister a directory iterator. */ void iso_dir_iter_unregister(IsoDirIter *iter) { struct iter_reg_node **pos; pos = &iter_reg; while (*pos != NULL && (*pos)->iter != iter) { pos = &(*pos)->next; } if (*pos) { struct iter_reg_node *tmp = (*pos)->next; free(*pos); *pos = tmp; } } void iso_notify_dir_iters(IsoNode *node, int flag) { struct iter_reg_node *pos = iter_reg; while (pos != NULL) { IsoDirIter *iter = pos->iter; if (iter->dir == node->parent) { iter->class->notify_child_taken(iter, node); } pos = pos->next; } } int iso_node_new_root(IsoDir **root) { IsoDir *dir; dir = calloc(1, sizeof(IsoDir)); if (dir == NULL) { return ISO_OUT_OF_MEM; } dir->node.refcount = 1; dir->node.type = LIBISO_DIR; dir->node.atime = dir->node.ctime = dir->node.mtime = time(NULL); dir->node.mode = S_IFDIR | 0555; /* set parent to itself, to prevent root to be added to another dir */ dir->node.parent = dir; *root = dir; return ISO_SUCCESS; } int iso_node_new_dir(char *name, IsoDir **dir) { IsoDir *new; if (dir == NULL || name == NULL) { return ISO_NULL_POINTER; } /* check if the name is valid */ if (!iso_node_is_valid_name(name)) { return ISO_WRONG_ARG_VALUE; } new = calloc(1, sizeof(IsoDir)); if (new == NULL) { return ISO_OUT_OF_MEM; } new->node.refcount = 1; new->node.type = LIBISO_DIR; new->node.name = name; new->node.mode = S_IFDIR; *dir = new; return ISO_SUCCESS; } int iso_node_new_file(char *name, IsoStream *stream, IsoFile **file) { IsoFile *new; if (file == NULL || name == NULL || stream == NULL) { return ISO_NULL_POINTER; } /* check if the name is valid */ if (!iso_node_is_valid_name(name)) { return ISO_WRONG_ARG_VALUE; } new = calloc(1, sizeof(IsoFile)); if (new == NULL) { return ISO_OUT_OF_MEM; } new->node.refcount = 1; new->node.type = LIBISO_FILE; new->node.name = name; new->node.mode = S_IFREG; new->stream = stream; *file = new; return ISO_SUCCESS; } int iso_node_new_symlink(char *name, char *dest, IsoSymlink **link) { IsoSymlink *new; if (link == NULL || name == NULL || dest == NULL) { return ISO_NULL_POINTER; } /* check if the name is valid */ if (!iso_node_is_valid_name(name)) { return ISO_WRONG_ARG_VALUE; } /* check if destination is valid */ if (!iso_node_is_valid_link_dest(dest)) { /* guard against null or empty dest */ return ISO_WRONG_ARG_VALUE; } new = calloc(1, sizeof(IsoSymlink)); if (new == NULL) { return ISO_OUT_OF_MEM; } new->node.refcount = 1; new->node.type = LIBISO_SYMLINK; new->node.name = name; new->dest = dest; new->node.mode = S_IFLNK; *link = new; return ISO_SUCCESS; } int iso_node_new_special(char *name, mode_t mode, dev_t dev, IsoSpecial **special) { IsoSpecial *new; if (special == NULL || name == NULL) { return ISO_NULL_POINTER; } if (S_ISLNK(mode) || S_ISREG(mode) || S_ISDIR(mode)) { return ISO_WRONG_ARG_VALUE; } /* check if the name is valid */ if (!iso_node_is_valid_name(name)) { return ISO_WRONG_ARG_VALUE; } new = calloc(1, sizeof(IsoSpecial)); if (new == NULL) { return ISO_OUT_OF_MEM; } new->node.refcount = 1; new->node.type = LIBISO_SPECIAL; new->node.name = name; new->node.mode = mode; new->dev = dev; *special = new; return ISO_SUCCESS; } /* ts A90202 */ /* @param flag bit0= inverse: cleanout everything but del_name */ static int attrs_cleanout_name(char *del_name, size_t *num_attrs, char **names, size_t *value_lengths, char **values, int flag) { size_t i, w; for (w = i = 0; i < *num_attrs; i++) { if ((strcmp(names[i], del_name) == 0) ^ (flag & 1)) continue; if (w == i) { w++; continue; } names[w] = names[i]; value_lengths[w] = value_lengths[i]; values[w] = values[i]; names[i] = values[i] = NULL; value_lengths[i] = 0; w++; } *num_attrs = w; return 1; } #ifdef Libisofs_with_aaiP /* ts A90207 */ /** * Backend of iso_node_get_attrs() with parameter node replaced by the * AA string from where to get the attribute list. * All other parameter specs apply. */ static int iso_aa_get_attrs(unsigned char *aa_string, size_t *num_attrs, char ***names, size_t **value_lengths, char ***values, int flag) { struct aaip_state *aaip= NULL; unsigned char *rpt; size_t len, todo, consumed; int is_done = 0, first_round= 1, ret; if (flag & (1 << 15)) aaip_get_decoded_attrs(&aaip, num_attrs, names, value_lengths, values, 1 << 15); *num_attrs = 0; *names = NULL; *value_lengths = NULL; *values = NULL; if (flag & (1 << 15)) return 1; rpt = aa_string; len = aaip_count_bytes(rpt, 0); while (!is_done) { todo = len - (rpt - aa_string); if (todo > 2048) todo = 2048; if (todo == 0) { /* Out of data while still prompted to submit */ ret = ISO_AAIP_BAD_AASTRING; goto ex; } /* Allow 1 million bytes of memory consumption, 100,000 attributes */ ret = aaip_decode_attrs(&aaip, (size_t) 1000000, (size_t) 100000, rpt, todo, &consumed, first_round); rpt+= consumed; first_round= 0; if (ret == 1) continue; if (ret == 2) break; /* aaip_decode_attrs() reports error */ ret = ISO_AAIP_BAD_AASTRING; goto ex; } if (rpt - aa_string != len) { /* aaip_decode_attrs() returns 2 but still bytes are left */ ret = ISO_AAIP_BAD_AASTRING; goto ex; } ret = aaip_get_decoded_attrs(&aaip, num_attrs, names, value_lengths, values, 0); if (ret != 1) { /* aaip_get_decoded_attrs() failed */ ret = ISO_AAIP_BAD_AASTRING; goto ex; } if (!(flag & 1)) { /* Clean out eventual ACL attribute resp. all other xattr */ attrs_cleanout_name("", num_attrs, *names, *value_lengths, *values, !!(flag & 4)); } ret = 1; ex:; aaip_decode_attrs(&aaip, (size_t) 1000000, (size_t) 100000, rpt, todo, &consumed, 1 << 15); return ret; } #endif /* ! Libisofs_with_aaiP */ /* ts A90116 */ int iso_node_get_attrs(IsoNode *node, size_t *num_attrs, char ***names, size_t **value_lengths, char ***values, int flag) { #ifdef Libisofs_with_aaiP void *xipt; unsigned char *aa_string = NULL; int ret; if (flag & (1 << 15)) { iso_aa_get_attrs(aa_string, num_attrs, names, value_lengths, values, 1 << 15); return 1; } *num_attrs = 0; *names = NULL; *value_lengths = NULL; *values = NULL; ret = iso_node_get_xinfo(node, aaip_xinfo_func, &xipt); if (ret != 1) return 1; aa_string = (unsigned char *) xipt; ret = iso_aa_get_attrs(aa_string, num_attrs, names, value_lengths, values, flag); return ret; #else /* Libisofs_with_aaiP */ *num_attrs = 0; *names = NULL; *value_lengths = NULL; *values = NULL; #endif /* ! Libisofs_with_aaiP */ return 1; } /* ts A90205 */ /* Enlarge attribute list */ static int attr_enlarge_list(char ***names, size_t **value_lengths, char ***values, size_t new_num, int flag) { void *newpt; newpt = realloc(*names, new_num * sizeof(char *)); if (newpt == NULL) return ISO_OUT_OF_MEM; *names = (char **) newpt; newpt = realloc(*values, new_num * sizeof(char *)); if (newpt == NULL) return ISO_OUT_OF_MEM; *values = (char **) newpt; newpt = realloc(*value_lengths, new_num * sizeof(size_t)); if (newpt == NULL) return ISO_OUT_OF_MEM; *value_lengths = (size_t *) newpt; return 1; } /* ts A90205 */ /* Merge attribute list of node and given new attribute list into attribute list returned by m_* parameters. The m_* paramters have finally to be freed by a call with bit15 set. @param flag Bitfield for control purposes bit0= delete all old names which begin by "user." (but not if bit2 is set) bit2= delete the given names rather than overwrite their content bit4= do not overwrite value of empty name bit15= release memory and return 1 */ static int iso_node_merge_xattr(IsoNode *node, size_t num_attrs, char **names, size_t *value_lengths, char **values, size_t *m_num_attrs, char ***m_names, size_t **m_value_lengths, char ***m_values, int flag) { int ret; size_t new_names = 0, deleted = 0, i, j, w; if (flag & (1 << 15)) { iso_node_get_attrs(node, m_num_attrs, m_names, m_value_lengths, m_values, 1 << 15); return 1; } ret = iso_node_get_attrs(node, m_num_attrs, m_names, m_value_lengths, m_values, 1); if (ret < 0) return ret; if ((flag & 1) && (!(flag & 4))) { /* Delete unmatched user space pairs */ for (j = 0; j < *m_num_attrs; j++) { if (strncmp((*m_names)[j], "user.", 5) != 0) continue; for (i = 0; i < num_attrs; i++) { if (names[i] == NULL || (*m_names)[j] == NULL) continue; if (strcmp(names[i], (*m_names)[j]) == 0) break; } if (i >= num_attrs) { /* Delete unmatched pair */ free((*m_names)[j]); (*m_names)[j] = NULL; deleted++; } } } /* Handle existing names, count non-existing names */ for (i = 0; i < num_attrs; i++) { if (names[i] == NULL) continue; if (names[i][0] == 0 && (flag & 16)) continue; for (j = 0; j < *m_num_attrs; j++) { if ((*m_names)[j] == NULL) continue; if (strcmp(names[i], (*m_names)[j]) == 0) { if ((*m_values)[j] != NULL) free((*m_values)[j]); (*m_values)[j] = NULL; (*m_value_lengths)[j] = 0; if (flag & 4) { /* Delete pair */ free((*m_names)[j]); (*m_names)[j] = NULL; deleted++; } else { (*m_values)[j] = calloc(value_lengths[i] + 1, 1); if ((*m_values)[j] == NULL) return ISO_OUT_OF_MEM; memcpy((*m_values)[j], values[i], value_lengths[i]); (*m_values)[j][value_lengths[i]] = 0; (*m_value_lengths)[j] = value_lengths[i]; } break; } } if (j >= *m_num_attrs) new_names++; } if (new_names > 0 && (flag & 4)) { /* >>> warn of non-existing name on delete ? */; } else if (new_names > 0) { ret = attr_enlarge_list(m_names, m_value_lengths, m_values, *m_num_attrs + new_names, 0); if (ret < 0) return ret; /* Set new pairs */; w = *m_num_attrs; for (i = 0; i < num_attrs; i++) { if (names[i] == NULL) continue; if (names[i][0] == 0 && (flag & 16)) continue; for (j = 0; j < *m_num_attrs; j++) { if ((*m_names)[j] == NULL) continue; if (strcmp(names[i], (*m_names)[j]) == 0) continue; } if (j < *m_num_attrs) /* Name is not new */ continue; (*m_names)[w] = strdup(names[i]); if ((*m_names)[w] == NULL) return ISO_OUT_OF_MEM; (*m_values)[w] = calloc(value_lengths[i] + 1, 1); if ((*m_values)[w] == NULL) return ISO_OUT_OF_MEM; memcpy((*m_values)[w], values[i], value_lengths[i]); (*m_values)[w][value_lengths[i]] = 0; (*m_value_lengths)[w] = value_lengths[i]; w++; } *m_num_attrs = w; } if (deleted > 0) { /* Garbage collection */ w = 0; for (j = 0; j < *m_num_attrs; j++) { if ((*m_names)[j] == NULL) continue; (*m_names)[w] = (*m_names)[j]; (*m_values)[w] = (*m_values)[j]; (*m_value_lengths)[w] = (*m_value_lengths)[j]; w++; } *m_num_attrs = w; } return 1; } /* ts A90121 */ int iso_node_set_attrs(IsoNode *node, size_t num_attrs, char **names, size_t *value_lengths, char **values, int flag) { #ifdef Libisofs_with_aaiP int ret, acl_saved = 0; size_t sret, result_len, m_num = 0, *m_value_lengths = NULL, i; unsigned char *result; char *a_acl = NULL, *d_acl = NULL, **m_names = NULL, **m_values = NULL; if (!(flag & 8)) for (i = 0; i < num_attrs; i++) if (strncmp(names[i], "user.", 5) != 0 && names[i][0] != 0) return ISO_AAIP_NON_USER_NAME; if ((flag & (2 | 4)) || !(flag & 8)) { /* Merge old and new lists */ ret = iso_node_merge_xattr( node, num_attrs, names, value_lengths, values, &m_num, &m_names, &m_value_lengths, &m_values, (flag & 4) | (!(flag & 2)) | ((!(flag & 1)) << 4)); if (ret < 0) goto ex; num_attrs = m_num; names = m_names; value_lengths = m_value_lengths; values = m_values; } else if (!(flag & 1)) { iso_node_get_acl_text(node, &a_acl, &d_acl, 16); acl_saved = 1; } if (num_attrs == 0) { ret = iso_node_remove_xinfo(node, aaip_xinfo_func); if (ret < 0) goto ex; if (acl_saved && (a_acl != NULL || d_acl != NULL)) { ret = iso_node_set_acl_text(node, a_acl, d_acl, 0); if (ret < 0) goto ex; } ret = 1; goto ex; } sret = aaip_encode(num_attrs, names, value_lengths, values, &result_len, &result, 0); if (sret == 0) { ret = ISO_OUT_OF_MEM; goto ex; } ret = iso_node_remove_xinfo(node, aaip_xinfo_func); if (ret < 0) goto ex; ret = iso_node_add_xinfo(node, aaip_xinfo_func, result); if (ret < 0) goto ex; if (ret == 0) { /* >>> something is messed up with xinfo: an aa_string still exists */; ret = ISO_ERROR; goto ex; } if (acl_saved) { ret = iso_node_set_acl_text(node, a_acl, d_acl, 0); if (ret < 0) goto ex; } ret = 1; ex:; /* Dispose eventual merged list */ iso_node_merge_xattr(node, num_attrs, names, value_lengths, values, &m_num, &m_names, &m_value_lengths, &m_values, 1 << 15); return ret; #else /* Libisofs_with_aaiP */ return ISO_AAIP_NOT_ENABLED; #endif /* ! Libisofs_with_aaiP */ } #ifdef Libisofs_with_aaiP static int iso_decode_acl(unsigned char *v_data, size_t v_len, size_t *consumed, char **text, size_t *text_fill, int flag) { int ret; *text= NULL; ret = aaip_decode_acl(v_data, v_len, consumed, NULL, (size_t) 0, text_fill, 1); if (ret <= 0) return 0; if (*text_fill == 0) return ret; *text = calloc(*text_fill + 42, 1); /* 42 for aaip_update_acl_st_mode */ if (*text == NULL) return ISO_OUT_OF_MEM; ret = aaip_decode_acl(v_data, v_len, consumed, *text, *text_fill, text_fill, 0); if (ret <= 0) { free(*text); *text= NULL; return 0; } return ret; } /* ts A90207 */ /** * Backend of iso_node_get_acl_text() with parameter node replaced by the * attribute list from where to get the ACL and by the associated st_mode * permission bits. All other parameter specs apply. */ static int iso_attr_get_acl_text(size_t num_attrs, char **names, size_t *value_lengths, char **values, mode_t st_mode, char **access_text, char **default_text, int flag) { size_t i, consumed, text_fill = 0; size_t v_len; unsigned char *v_data; int ret, from_posix= 0; if (flag & (1 << 15)) { if (*access_text != NULL) free(*access_text); *access_text = NULL; if (*default_text != NULL) free(*default_text); *default_text = NULL; return 1; } *access_text = *default_text = NULL; for(i = 0; i < num_attrs; i++) { if (names[i][0]) /* searching the empty name */ continue; v_data = (unsigned char *) values[i]; v_len = value_lengths[i]; /* "access" ACL */ ret = iso_decode_acl(v_data, v_len, &consumed, access_text, &text_fill, 0); if (ret <= 0) goto bad_decode; if (ret == 2) { v_data += consumed; v_len -= consumed; ret = iso_decode_acl(v_data, v_len, &consumed, default_text, &text_fill, 0); if (ret == 0) goto bad_decode; } break; } if (*access_text == NULL && !(flag & 16)) { from_posix = 1; *access_text = calloc(42, 1); /* 42 for aaip_update_acl_st_mode */ } if (*access_text != NULL) { aaip_add_acl_st_mode(*access_text, st_mode, 0); text_fill = strlen(*access_text); } if (*access_text == NULL && *default_text == NULL) ret = 0; else ret = 1 + from_posix; ex:; return ret; bad_decode:; ret = ISO_AAIP_BAD_ACL; goto ex; } #endif /* ! Libisofs_with_aaiP */ /* ts A90130 */ int iso_node_get_acl_text(IsoNode *node, char **access_text, char **default_text, int flag) { #ifdef Libisofs_with_aaiP size_t num_attrs = 0, *value_lengths = NULL; char **names = NULL, **values = NULL; mode_t st_mode = 0; int ret; if (flag & (1 << 15)) { iso_attr_get_acl_text(num_attrs, names, value_lengths, values, st_mode, access_text, default_text, 1 << 15); return 1; } ret = iso_node_get_attrs(node, &num_attrs, &names, &value_lengths, &values, 1); if (ret < 0) return ret; st_mode = iso_node_get_permissions(node); ret = iso_attr_get_acl_text(num_attrs, names, value_lengths, values, st_mode, access_text, default_text, flag); iso_node_get_attrs(node, &num_attrs, &names, &value_lengths, &values, 1 << 15); /* free memory */ return ret; #else /* Libisofs_with_aaiP */ *access_text = *default_text = NULL; return ISO_AAIP_NOT_ENABLED; #endif /* ! Libisofs_with_aaiP */ } #ifdef Libisofs_with_aaiP /* ts A90207 */ int iso_aa_get_acl_text(unsigned char *aa_string, mode_t st_mode, char **access_text, char **default_text, int flag) { int ret; size_t num_attrs = 0, *value_lengths = NULL; char **names = NULL, **values = NULL; if (flag & (1 << 15)) { iso_attr_get_acl_text(num_attrs, names, value_lengths, values, st_mode, access_text, default_text, 1 << 15); return 1; } ret = iso_aa_get_attrs(aa_string, &num_attrs, &names, &value_lengths, &values, 1); if (ret < 0) goto ex; ret = iso_attr_get_acl_text(num_attrs, names, value_lengths, values, st_mode, access_text, default_text, flag); ex:; iso_aa_get_attrs(aa_string, &num_attrs, &names, &value_lengths, &values, 1 << 15); return ret; } #endif /* Libisofs_with_aaiP */ /* ts A90130 */ int iso_node_set_acl_text(IsoNode *node, char *access_text, char *default_text, int flag) { #ifdef Libisofs_with_aaiP size_t num_attrs = 0, *value_lengths = NULL, i, j, consumed; size_t a_text_fill = 0, d_text_fill = 0; size_t v_len, acl_len= 0; char **names = NULL, **values = NULL, *a_text = NULL, *d_text = NULL; unsigned char *v_data, *acl= NULL; int ret; mode_t st_mode; st_mode = iso_node_get_permissions(node); if (!(flag & 2)) { /* want not to update ACL by st_mode */ /* >>> validate and rectify text */; } ret = iso_node_get_attrs(node, &num_attrs, &names, &value_lengths, &values, 1); if (ret < 0) return ret; for(i = 0; i < num_attrs; i++) { if (names[i][0]) /* searching the empty name */ continue; v_data = (unsigned char *) values[i]; v_len = value_lengths[i]; if (flag & 2) { /* update "access" ACL by st_mode */ /* read "access" ACL */ ret = iso_decode_acl(v_data, v_len, &consumed, &a_text, &a_text_fill, 0); if (ret == 0) goto bad_decode; if (ret < 0) goto ex; if (ret == 2) { /* read "default" ACL */ v_data += consumed; v_len -= consumed; ret = iso_decode_acl(v_data, v_len, &consumed, &d_text, &d_text_fill, 0); if (ret == 0) goto bad_decode; if (ret < 0) goto ex; } /* Update "access" ACL by st_mode */ if (a_text == NULL) { ret = 1; goto ex; } ret = aaip_cleanout_st_mode(a_text, &st_mode, 8); if (ret < 0) { ret = ISO_AAIP_BAD_ACL_TEXT; goto ex; } ret = 1; if (a_text != NULL || d_text != NULL) ret = aaip_encode_both_acl(a_text, d_text, st_mode, &acl_len, &acl, 2 | 8); } else { ret = 1; if (access_text != NULL || default_text != NULL) ret = aaip_encode_both_acl(access_text, default_text, st_mode, &acl_len, &acl, 2 | 8); } if (ret <= 0) { ret = ISO_OUT_OF_MEM; goto ex; } if(acl == NULL) { /* Delete whole ACL attribute */ /* Update S_IRWXG by eventual "group::" ACL entry. With ACL it reflected the "mask::" entry. */ if (a_text != NULL) free(a_text); ret = iso_decode_acl(v_data, v_len, &consumed, &a_text, &a_text_fill, 0); if (ret == 0) goto bad_decode; if (ret < 0) goto ex; ret = aaip_cleanout_st_mode(a_text, &st_mode, 4 | 16); if (ret < 0) goto ex; iso_node_set_perms_internal(node, st_mode, 1); /* Delete the attribute pair */ if (values[i] != NULL) free(values[i]); for (j = i + 1; j < num_attrs; j++) { names[j - 1] = names[j]; value_lengths[j - 1] = value_lengths[j]; values[j - 1] = values[j]; } num_attrs--; } else { /* replace variable value */; if (values[i] != NULL) free(values[i]); values[i] = (char *) acl; acl = NULL; value_lengths[i] = acl_len; } /* Encode attributes and attach to node */ ret = iso_node_set_attrs(node, num_attrs, names, value_lengths, values, 1 | 8); if (ret <= 0) goto ex; goto update_perms; } /* There is no ACL yet */ if ((flag & 2) || (access_text == NULL && default_text == NULL)) { /* thus no need to update ACL by st_mode or to delete ACL */ ret = 1; goto ex; } ret = aaip_encode_both_acl(access_text, default_text, st_mode, &acl_len, &acl, 2 | 8); if (ret <= 0) { ret = ISO_AAIP_BAD_ACL_TEXT; goto ex; } ret = attr_enlarge_list(&names, &value_lengths, &values, num_attrs + 1, 0); if (ret < 0) goto ex; /* Set new ACL attribute */ names[num_attrs] = strdup(""); if (names[num_attrs] == NULL) { ret = ISO_OUT_OF_MEM; goto ex; } values[num_attrs] = (char *) acl; acl = NULL; value_lengths[num_attrs] = acl_len; num_attrs++; /* Encode attributes and attach to node */ ret = iso_node_set_attrs(node, num_attrs, names, value_lengths, values, 1 | 8); if (ret < 0) goto ex; update_perms:; if(access_text != NULL && !(flag & (1 | 2))) { /* Update node permissions by acl_text */ st_mode = iso_node_get_permissions(node); ret = aaip_cleanout_st_mode(access_text, &st_mode, 4); if (ret < 0) { ret = ISO_AAIP_BAD_ACL_TEXT; goto ex; } iso_node_set_perms_internal(node, st_mode, 1); } ret = 1; ex:; iso_node_get_attrs(node, &num_attrs, &names, &value_lengths, &values, 1 << 15); /* free memory */ if (a_text != NULL) free(a_text); if (d_text != NULL) free(d_text); if(acl != NULL) free(acl); return ret; bad_decode:; ret = ISO_AAIP_BAD_ACL; goto ex; #else /* Libisofs_with_aaiP */ if (access_text != NULL || default_text != NULL) return ISO_AAIP_NOT_ENABLED; return 1; #endif /* ! Libisofs_with_aaiP */ } /* ts A90206 */ mode_t iso_node_get_perms_wo_acl(const IsoNode *node) { #ifdef Libisofs_with_aaiP mode_t st_mode; int ret; char *a_text = NULL, *d_text = NULL; st_mode = iso_node_get_permissions(node); ret = iso_node_get_acl_text((IsoNode *) node, &a_text, &d_text, 16); if (ret != 1) goto ex; aaip_cleanout_st_mode(a_text, &st_mode, 4 | 16); ex:; iso_node_get_acl_text((IsoNode *) node, &a_text, &d_text, 1 << 15); return st_mode; #else /* Libisofs_with_aaiP */ return iso_node_get_permissions(node); #endif /* ! Libisofs_with_aaiP */ }