node.h File Reference

#include "libisofs.h"
#include "stream.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

Include dependency graph for node.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	iso_extended_info
struct	Iso_Node
struct	Iso_Dir
struct	Iso_File
struct	Iso_Symlink
struct	Iso_Special
struct	iso_dir_iter_iface
struct	Iso_Dir_Iter
	An iterator for directory children. More...
struct	zisofs_zf_info
	Parameter structure which is to be managed by zisofs_zf_xinfo_func. More...

Macros
#define	LIBISOFS_NODE_NAME_MAX   255
#define	LIBISOFS_NODE_PATH_MAX   1024

Typedefs
typedef struct iso_extended_info	IsoExtendedInfo
	The extended information is a way to attach additional information to each IsoNode. More...

Functions
int	iso_node_new_root (IsoDir **root)
int	iso_node_new_dir (char *name, IsoDir **dir)
	Create a new IsoDir. More...
int	iso_node_new_file (char *name, IsoStream *stream, IsoFile **file)
	Create a new file node. More...
int	iso_node_new_symlink (char *name, char *dest, IsoSymlink **link)
	Creates a new IsoSymlink node. More...
int	iso_node_new_special (char *name, mode_t mode, dev_t dev, IsoSpecial **special)
	Create a new special file node. More...
int	iso_node_is_valid_name (const char *name)
	Check if a given name is valid for an iso node. More...
int	iso_node_is_valid_link_dest (const char *dest)
	Check if a given path is valid for the destination of a link. More...
void	iso_dir_find (IsoDir *dir, const char *name, IsoNode ***pos)
	Find the position where to insert a node. More...
int	iso_dir_exists (IsoDir *dir, const char *name, IsoNode ***pos)
	Check if a node with the given name exists in a dir. More...
int	iso_dir_insert (IsoDir *dir, IsoNode *node, IsoNode **pos, enum iso_replace_mode replace)
	Inserts a given node in a dir, at the specified position. More...
int	iso_dir_iter_register (IsoDirIter *iter)
	Add a new iterator to the registry. More...
void	iso_dir_iter_unregister (IsoDirIter *iter)
	Unregister a directory iterator. More...
void	iso_notify_dir_iters (IsoNode *node, int flag)
int	iso_node_set_perms_internal (IsoNode *node, mode_t mode, int flag)
	See API function iso_node_set_permissions() More...
int	iso_aa_get_acl_text (unsigned char *aa_string, mode_t st_mode, char **access_text, char **default_text, int flag)
	Like iso_node_get_acl_text() with param node replaced by aa_string and st_mode from where to obtain the ACLs. More...
int	iso_aa_get_attrs (unsigned char *aa_string, size_t *num_attrs, char ***names, size_t **value_lengths, char ***values, int flag)
	Backend of iso_node_get_attrs() with parameter node replaced by the AAIP string from where to get the attribute list. More...
int	iso_aa_lookup_attr (unsigned char *aa_string, char *name, size_t *value_length, char **value, int flag)
	Search given name. More...
int	zisofs_zf_xinfo_func (void *data, int flag)
	Function to identify and manage ZF parameters which do not stem from ZF fields (those are known to the FileSource) and do not stem from filters ("ziso" knows them globally, "osiz" knows them individually) but rather from an inspection of the file content header for zisofs magic number and plausible parameters. More...
int	iso_file_zf_by_magic (IsoFile *file, int flag)
	Checks whether a file effectively bears a zisofs file header and eventually marks this by a struct zisofs_zf_info as xinfo of the file node. More...
int	iso_node_get_id (IsoNode *node, unsigned int *fs_id, dev_t *dev_id, ino_t *ino_id, int flag)
int	iso_node_set_unique_id (IsoNode *node, IsoImage *image, int flag)
int	iso_node_set_ino (IsoNode *node, ino_t ino, int flag)
int	iso_node_cmp_flag (IsoNode *n1, IsoNode *n2, int flag)
int	iso_file_set_isofscx (IsoFile *file, unsigned int checksum_index, int flag)
	Set the checksum index (typically coming from IsoFileSrc.checksum_index) of a regular file node. More...
int	iso_root_set_isofsca (IsoNode *node, uint32_t start_lba, uint32_t end_lba, uint32_t count, uint32_t size, char *typetext, int flag)
	Set the checksum area description. More...
int	iso_root_get_isofsca (IsoNode *node, uint32_t *start_lba, uint32_t *end_lba, uint32_t *count, uint32_t *size, char typetext[81], int flag)
	Get the checksum area description. More...
int	iso_root_set_isofsnt (IsoNode *node, uint32_t truncate_mode, uint32_t truncate_length, int flag)
	Record and get truncation parameters as of iso_image_set_truncate_mode() by "isofs.nt". More...
int	iso_root_get_isofsnt (IsoNode *node, uint32_t *truncate_mode, uint32_t *truncate_length, int flag)
int	iso_node_clone_xinfo (IsoNode *from_node, IsoNode *to_node, int flag)
	Copy the xinfo list from one node to the another. More...
int	iso_px_ino_xinfo_func (void *data, int flag)
	The iso_node_xinfo_func instance which governs the storing of the inode number from Rock Ridge field PX. More...
int	iso_px_ino_xinfo_cloner (void *old_data, void **new_data, int flag)
int	zisofs_zf_xinfo_cloner (void *old_data, void **new_data, int flag)
int	iso_dir_get_node_trunc (IsoDir *dir, int truncate_length, const char *name, IsoNode **node)

Macro Definition Documentation

LIBISOFS_NODE_NAME_MAX

#define LIBISOFS_NODE_NAME_MAX   255

Definition at line 43 of file node.h.

LIBISOFS_NODE_PATH_MAX

#define LIBISOFS_NODE_PATH_MAX   1024

Definition at line 53 of file node.h.

Typedef Documentation

IsoExtendedInfo

typedef struct iso_extended_info IsoExtendedInfo

The extended information is a way to attach additional information to each IsoNode.

External applications may want to use this extension system to store application specific information related to each node. On the other side, libisofs may make use of this struct to attach information to nodes in some particular, uncommon, cases, without incrementing the size of the IsoNode struct.

It is implemented like a chained list.

Definition at line 1 of file node.h.

Function Documentation

iso_aa_get_acl_text()

int iso_aa_get_acl_text	(	unsigned char *	aa_string,
		mode_t	st_mode,
		char **	access_text,
		char **	default_text,
		int	flag
	)

Like iso_node_get_acl_text() with param node replaced by aa_string and st_mode from where to obtain the ACLs.

All other parameter specs apply.

Definition at line 2180 of file node.c.

{
    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;
}

References iso_aa_get_attrs(), and iso_attr_get_acl_text().

Referenced by default_create_node(), and src_aa_to_node().

iso_aa_get_attrs()

int iso_aa_get_attrs	(	unsigned char *	aa_string,
		size_t *	num_attrs,
		char ***	names,
		size_t **	value_lengths,
		char ***	values,
		int	flag
	)

Backend of iso_node_get_attrs() with parameter node replaced by the AAIP string from where to get the attribute list.

All other parameter specs apply.

Definition at line 1647 of file node.c.

{
    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 ((size_t) (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;
}

References aaip_count_bytes(), aaip_decode_attrs(), aaip_get_decoded_attrs(), attrs_cleanout_name(), and ISO_AAIP_BAD_AASTRING.

Referenced by iso_aa_get_acl_text(), iso_aa_lookup_attr(), and iso_node_get_attrs().

iso_aa_lookup_attr()

int iso_aa_lookup_attr	(	unsigned char *	aa_string,
		char *	name,
		size_t *	value_length,
		char **	value,
		int	flag
	)

Search given name.

Eventually calloc() and copy value. Add trailing 0 byte for caller convenience.

Returns

1= found , 0= not found , <0 error

Definition at line 1724 of file node.c.

{
    size_t num_attrs = 0, *value_lengths = NULL;
    char **names = NULL, **values = NULL;
    int i, ret = 0, found = 0;
 
    ret = iso_aa_get_attrs(aa_string, &num_attrs, &names,
                           &value_lengths, &values, 0);
    if (ret < 0)
        return ret;
    for (i = 0; i < (int) num_attrs; i++) {
        if (strcmp(names[i], name))
    continue;
        *value_length = value_lengths[i];
        *value = calloc(*value_length + 1, 1);
        if (*value == NULL) {
            found = ISO_OUT_OF_MEM;
    break;
        }
        if (*value_length > 0)
            memcpy(*value, values[i], *value_length);
        (*value)[*value_length] = 0;
        found = 1;
    break;
    }
    iso_aa_get_attrs(aa_string, &num_attrs, &names,
                     &value_lengths, &values, 1 << 15);
    return found;
}

References iso_aa_get_attrs(), and ISO_OUT_OF_MEM.

Referenced by iso_image_import(), and iso_node_lookup_attr().

iso_dir_exists()

int iso_dir_exists	(	IsoDir *	dir,
		const char *	name,
		IsoNode ***	pos
	)

Check if a node with the given name exists in a dir.

Parameters

dir	A valid dir. It can't be NULL
name	The node name to search for. It can't be NULL
pos	If not NULL, will be filled with the position where to insert. If the node exists, (**pos) will refer to the given node.

Returns

1 if node exists, 0 if not

Definition at line 1338 of file node.c.

{
    IsoNode **node;
 
    iso_dir_find(dir, name, &node);
    if (pos) {
        *pos = node;
    }
    return (*node != NULL && !strcmp((*node)->name, name)) ? 1 : 0;
}

References iso_dir_find().

Referenced by iso_add_dir_src_rec(), iso_dir_get_node(), iso_tree_add_new_cut_out_node(), iso_tree_add_new_dir(), iso_tree_add_new_file(), iso_tree_add_new_node(), iso_tree_add_new_special(), iso_tree_add_new_symlink(), iso_tree_add_node_builder(), and make_really_unique_name().

iso_dir_find()

void iso_dir_find	(	IsoDir *	dir,
		const char *	name,
		IsoNode ***	pos
	)

Find the position where to insert a node.

Parameters

dir	A valid dir. It can't be NULL
name	The node name to search for. It can't be NULL
pos	Will be filled with the position where to insert. It can't be NULL

Definition at line 1330 of file node.c.

{
    *pos = &(dir->children);
    while (**pos != NULL && strcmp((**pos)->name, name) < 0) {
        *pos = &((**pos)->next);
    }
}

References Iso_Dir::children.

Referenced by iso_dir_add_node(), and iso_dir_exists().

iso_dir_get_node_trunc()

int iso_dir_get_node_trunc	(	IsoDir *	dir,
		int	truncate_length,
		const char *	name,
		IsoNode **	node
	)

Definition at line 654 of file node.c.

{
    int ret;
    char *trunc = NULL;
 
    if ((int) strlen(name) <= truncate_length) {
        ret = iso_dir_get_node(dir, name, node);
        return ret;
    }
    trunc = strdup(name);
    if (trunc == NULL)
        return ISO_OUT_OF_MEM;
    ret = iso_truncate_rr_name(1, truncate_length, trunc, 1);
    if (ret < 0)
        goto ex;
    ret = iso_dir_get_node(dir, trunc, node);
    if (ret == 0)
        ret = 2;
ex:;
    LIBISO_FREE_MEM(trunc);
    return ret;
}

References iso_dir_get_node(), ISO_OUT_OF_MEM, iso_truncate_rr_name(), and LIBISO_FREE_MEM.

Referenced by iso_image_dir_get_node(), and iso_tree_path_to_node_flag().

iso_dir_insert()

int iso_dir_insert	(	IsoDir *	dir,
		IsoNode *	node,
		IsoNode **	pos,
		enum iso_replace_mode	replace
	)

Inserts a given node in a dir, at the specified position.

Parameters

dir	Dir where to insert. It can't be NULL
node	The node to insert. It can't be NULL
pos	Position where the node will be inserted. It is a pointer previously obtained with a call to iso_dir_exists() or iso_dir_find(). It can't be NULL.
replace	Whether to replace an old node with the same name with the new node.

Returns

If success, number of children in dir. < 0 on error

Definition at line 1349 of file node.c.

{
    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;
            }
            if ((node->mode & S_IFMT) != ((*pos)->mode & S_IFMT)) {
                /* different file types */
                return ISO_NODE_NAME_NOT_UNIQUE;
            }
            break;
        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;
}

References ISO_ASSERT_FAILURE, ISO_NODE_NAME_NOT_UNIQUE, iso_node_unref(), ISO_REPLACE_ALWAYS, ISO_REPLACE_IF_NEWER, ISO_REPLACE_IF_SAME_TYPE, ISO_REPLACE_IF_SAME_TYPE_AND_NEWER, ISO_REPLACE_NEVER, Iso_Node::mode, Iso_Node::mtime, Iso_Node::name, Iso_Dir::nchildren, Iso_Node::next, and Iso_Node::parent.

Referenced by iso_add_dir_src_rec(), iso_dir_add_node(), iso_tree_add_new_cut_out_node(), iso_tree_add_new_dir(), iso_tree_add_new_file(), iso_tree_add_new_node(), iso_tree_add_new_special(), iso_tree_add_new_symlink(), and iso_tree_add_node_builder().

iso_dir_iter_register()

int iso_dir_iter_register

(

IsoDirIter *

iter

)

Add a new iterator to the registry.

The iterator register keeps track of all iterators being used, and are notified when directory structure changes.

Definition at line 1418 of file node.c.

{
    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;
}

References ISO_OUT_OF_MEM, ISO_SUCCESS, iter_reg_node::iter, and iter_reg.

Referenced by iso_dir_find_children(), and iso_dir_get_children().

iso_dir_iter_unregister()

void iso_dir_iter_unregister

(

IsoDirIter *

iter

)

Unregister a directory iterator.

Definition at line 1434 of file node.c.

{
    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;
    }
}

References iter_reg_node::iter, iter_reg, and iter_reg_node::next.

Referenced by iso_dir_iter_free().

iso_file_set_isofscx()

int iso_file_set_isofscx	(	IsoFile *	file,
		unsigned int	checksum_index,
		int	flag
	)

Set the checksum index (typically coming from IsoFileSrc.checksum_index) of a regular file node.

The index is encoded as xattr "isofs.cx" with four bytes of value.

Definition at line 2887 of file node.c.

{
    static char *names = "isofs.cx";
    static size_t value_lengths[1] = {4};
    unsigned char value[4];
    char *valuept;
    int i, ret;
 
    valuept= (char *) value;
    if (flag & 1) {
        ret = iso_node_set_attrs((IsoNode *) file, (size_t) 1,
                             &names, value_lengths, &valuept, 4 | 8);
        return ret;
    }
    for(i = 0; i < 4; i++)
        value[3 - i] = (checksum_index >> (8 * i)) & 0xff;
    ret = iso_node_set_attrs((IsoNode *) file, (size_t) 1,
                             &names, value_lengths, &valuept, 2 | 8);
    return ret;
}

References iso_node_set_attrs().

Referenced by checksum_prepare_nodes(), iso_file_src_create(), and process_preserved_cx().

iso_file_zf_by_magic()

int iso_file_zf_by_magic	(	IsoFile *	file,
		int	flag
	)

Checks whether a file effectively bears a zisofs file header and eventually marks this by a struct zisofs_zf_info as xinfo of the file node.

Parameters

flag	bit0= inquire the most original stream of the file bit1= permission to overwrite existing zisofs_zf_info bit2= if no zisofs header is found: create xinfo with parameters which indicate no zisofs

Returns

1= zf xinfo added, 0= no zisofs data found , 2= found existing zf xinfo and flag bit1 was not set <0 means error

Definition at line 2448 of file node.c.

{
    int ret, stream_type, header_size_div4, block_size_log2, version;
    uint64_t uncompressed_size;
    IsoStream *stream, *input_stream;
    struct zisofs_zf_info *zf = NULL;
    void *xipt;
    uint8_t algo[2];
 
    /* Intimate friendship with this function in filters/zisofs.c */
    int ziso_is_zisofs_stream(IsoStream *stream, int *stream_type,
                              uint8_t zisofs_algo[2],
                              int *header_size_div4, int *block_size_log2,
                              uint64_t *uncompressed_size, int flag);
 
    ret = iso_node_get_xinfo((IsoNode *) file, zisofs_zf_xinfo_func, &xipt);
    if (ret == 1) {
        if (!(flag & 2))
            return 2;
        ret = iso_node_remove_xinfo((IsoNode *) file, zisofs_zf_xinfo_func);
        if (ret < 0)
            return ret;
    }
    input_stream = stream = iso_file_get_stream(file);
    while (flag & 1) {
        input_stream = iso_stream_get_input_stream(stream, 0);
        if (input_stream == NULL)
    break;
        stream = input_stream;
    }
    version = ((flag >> 8) & 0xff);
    algo[0] = algo[1] = 0;
    ret = ziso_is_zisofs_stream(stream, &stream_type, algo, &header_size_div4,
                                &block_size_log2, &uncompressed_size, 3);
    if (ret < 0)
        return ret;
    if (version < 2 && ret > 0 && (algo[0] != 'p' || algo[1] != 'z'))
        ret = 0;
    if (ret != 1 || stream_type != 2) {
        if (!(flag & 4))
            return 0;
        algo[0] = algo[1] = 0;
        header_size_div4 = 0;
        block_size_log2 = 0;
        uncompressed_size = 0;
    }
    zf = calloc(1, sizeof(struct zisofs_zf_info));
    if (zf == NULL)
        return ISO_OUT_OF_MEM;
    zf->zisofs_algo[0] = algo[0];
    zf->zisofs_algo[1] = algo[1];
    zf->uncompressed_size = uncompressed_size;
    zf->header_size_div4 = header_size_div4;
    zf->block_size_log2 = block_size_log2;
    ret = iso_node_add_xinfo((IsoNode *) file, zisofs_zf_xinfo_func, zf);
    return ret;
}

References zisofs_zf_info::block_size_log2, zisofs_zf_info::header_size_div4, iso_file_get_stream(), iso_node_add_xinfo(), iso_node_get_xinfo(), iso_node_remove_xinfo(), ISO_OUT_OF_MEM, iso_stream_get_input_stream(), zisofs_zf_info::uncompressed_size, ziso_is_zisofs_stream(), zisofs_zf_info::zisofs_algo, and zisofs_zf_xinfo_func().

Referenced by iso_node_zf_by_magic().

iso_node_clone_xinfo()

int iso_node_clone_xinfo	(	IsoNode *	from_node,
		IsoNode *	to_node,
		int	flag
	)

Copy the xinfo list from one node to the another.

Definition at line 286 of file node.c.

{
    void *handle = NULL, *data, *new_data;
    iso_node_xinfo_func proc;
    iso_node_xinfo_cloner cloner;
    int ret;
 
    iso_node_remove_all_xinfo(to_node, 0);
    while (1) {
        ret = iso_node_get_next_xinfo(from_node, &handle, &proc, &data);
        if (ret <= 0)
    break;
        ret = iso_node_xinfo_get_cloner(proc, &cloner, 0);
        if (ret == 0)
            return ISO_XINFO_NO_CLONE;
        if (ret < 0)
            return ret;
        ret = (*cloner)(data, &new_data, 0);
        if (ret < 0)
    break;
        ret = iso_node_add_xinfo(to_node, proc, new_data);
        if (ret < 0)
    break;
    }
    if (ret < 0) {
        iso_node_remove_all_xinfo(to_node, 0);
    } else {
        ret = iso_node_revert_xinfo_list(to_node, 0);
    }
    return ret;
}

References iso_node_add_xinfo(), iso_node_get_next_xinfo(), iso_node_remove_all_xinfo(), iso_node_revert_xinfo_list(), iso_node_xinfo_get_cloner(), and ISO_XINFO_NO_CLONE.

Referenced by iso_tree_copy_node_attr().

iso_node_cmp_flag()

int iso_node_cmp_flag	(	IsoNode *	n1,
		IsoNode *	n2,
		int	flag
	)

Definition at line 2743 of file node.c.

{
    int ret1, ret2;
    unsigned int fs_id1, fs_id2;
    dev_t dev_id1, dev_id2;
    ino_t ino_id1, ino_id2;
    IsoFile *f1 = NULL, *f2 = NULL;
    IsoSymlink *l1 = NULL, *l2 = NULL;
    IsoSpecial *s1 = NULL, *s2 = NULL;
    void *x1, *x2;
 
    if (n1 == n2)
        return 0;
    if (n1->type != n2->type)
        return (n1->type < n2->type ? -1 : 1);
 
    /* Imported or explicit ISO image node id has priority */
    ret1 = (iso_node_get_id(n1, &fs_id1, &dev_id1, &ino_id1, 1) > 0);
    ret2 = (iso_node_get_id(n2, &fs_id2, &dev_id2, &ino_id2, 1) > 0);
    if (ret1 != ret2)
        return (ret1 < ret2 ? -1 : 1);
    if (ret1) {
        /* fs_id and dev_id do not matter here.
           Both nodes have explicit inode numbers of the emerging image.
         */
        if (ino_id1 != ino_id2)
            return (ino_id1 < ino_id2 ? -1 : 1);
        if (ino_id1 == 0) /* Image ino 0 is always unique */
            return (n1 < n2 ? -1 : 1);
        goto image_inode_match;
    }
 
    if (n1->type == LIBISO_FILE) {
 
        f1 = (IsoFile *) n1;
        f2 = (IsoFile *) n2;
        ret1 = iso_stream_cmp_ino(f1->stream, f2->stream, 0);
        if (ret1)
            return ret1;
        goto inode_match;
 
    } else if (n1->type == LIBISO_SYMLINK) {
 
        l1 = (IsoSymlink *) n1;
        l2 = (IsoSymlink *) n2;
        fs_id1 = l1->fs_id;
        dev_id1 = l1->st_dev;
        ino_id1 = l1->st_ino;
        fs_id2 = l2->fs_id;
        dev_id2 = l2->st_dev;
        ino_id2 = l2->st_ino;
 
    } else if (n1->type == LIBISO_SPECIAL) {
 
        s1 = (IsoSpecial *) n1;
        s2 = (IsoSpecial *) n2;
        fs_id1 = s1->fs_id;
        dev_id1 = s1->st_dev;
        ino_id1 = s1->st_ino;
        fs_id2 = s2->fs_id;
        dev_id2 = s2->st_dev;
        ino_id2 = s2->st_ino;
 
    } else {
        return (n1 < n2 ? -1 : 1); /* case n1 == n2 is handled above */
    }
    if (fs_id1 != fs_id2)
        return (fs_id1 < fs_id2 ? -1 : 1);
    if (dev_id1 != dev_id2)
        return (dev_id1 < dev_id2 ? -1 : 1);
    if (ino_id1 != ino_id2)
        return (ino_id1 < ino_id2 ? -1 : 1);
    if (fs_id1 == 0 && dev_id1 == 0 && ino_id1 == 0)
        return (n1 < n2 ? -1 : 1);
 
inode_match:;
 
    if (flag & 2) {
        /* What comes here has no predefined image ino resp. image_ino == 0 .
           Regard this as not equal.
        */
        return (n1 < n2 ? -1 : 1);
    }
 
image_inode_match:;
 
    if (!(flag & 1))
        return 0;
    if (n1->type == LIBISO_SYMLINK) {
        l1 = (IsoSymlink *) n1;
        l2 = (IsoSymlink *) n2;
        ret1 = strcmp(l1->dest, l2->dest);
        if (ret1)
            return ret1;
    } else if (n1->type == LIBISO_SPECIAL) {
        s1 = (IsoSpecial *) n1;
        s2 = (IsoSpecial *) n2;
        if (s1->dev != s2->dev)
            return (s1->dev < s2->dev ? -1 : 1);
    }
 
    if (n1->mode != n2->mode)
        return (n1->mode < n2->mode ? -1 : 1);
    if (n1->uid != n2->uid)
        return (n1->uid < n2->uid ? -1 : 1);
    if (n1->gid != n2->gid)
        return (n1->gid < n2->gid ? -1 : 1);
    if (n1->atime != n2->atime)
        return (n1->atime < n2->atime ? -1 : 1);
    if (n1->mtime != n2->mtime)
        return (n1->mtime < n2->mtime ? -1 : 1);
    if (n1->ctime != n2->ctime)
        return (n1->ctime < n2->ctime ? -1 : 1);
 
    /* Compare xinfo */
    /* :( cannot compare general xinfo because data length is not known :( */
 
    /* compare aa_string */
    ret1 = iso_node_get_xinfo(n1, aaip_xinfo_func, &x1);
    ret2 = iso_node_get_xinfo(n2, aaip_xinfo_func, &x2);
    if (ret1 != ret2)
        return (ret1 < ret2 ? -1 : 1);
    if (ret1 == 1) {
        ret1 = aaip_count_bytes((unsigned char *) x1, 0);
        ret2 = aaip_count_bytes((unsigned char *) x2, 0);
        if (ret1 != ret2)
            return (ret1 < ret2 ? -1 : 1);
        ret1 = memcmp(x1, x2, ret1);
        if (ret1)
            return ret1;
    }
 
    return 0;
}

References aaip_count_bytes(), aaip_xinfo_func(), Iso_Node::atime, Iso_Node::ctime, Iso_Symlink::dest, Iso_Special::dev, Iso_Symlink::fs_id, Iso_Special::fs_id, Iso_Node::gid, iso_node_get_id(), iso_node_get_xinfo(), iso_stream_cmp_ino(), LIBISO_FILE, LIBISO_SPECIAL, LIBISO_SYMLINK, Iso_Node::mode, Iso_Node::mtime, Iso_Symlink::st_dev, Iso_Special::st_dev, Iso_Symlink::st_ino, Iso_Special::st_ino, Iso_File::stream, Iso_Node::type, and Iso_Node::uid.

Referenced by ecma119_node_cmp_flag(), and iso_node_cmp_ino().

iso_node_get_id()

int iso_node_get_id	(	IsoNode *	node,
		unsigned int *	fs_id,
		dev_t *	dev_id,
		ino_t *	ino_id,
		int	flag
	)

Definition at line 2592 of file node.c.

{
    int ret;
    IsoFile *file;
    IsoSymlink *symlink;
    IsoSpecial *special;
    void *xipt;
    
    ret = iso_node_get_xinfo(node, iso_px_ino_xinfo_func, &xipt);
    if (ret < 0)
        goto no_id;
    if (ret == 1) {
        *fs_id = ISO_IMAGE_FS_ID;
        *dev_id = 0;
        *ino_id = *((ino_t *) xipt);
        return 2;
    }
 
    if (node->type == LIBISO_FILE) {
        file= (IsoFile *) node;
        iso_stream_get_id(file->stream, fs_id, dev_id, ino_id);
        if (*fs_id != ISO_IMAGE_FS_ID && (flag & 1)) {
            ret = 0;
            goto no_id;
        }
        return 1;
 
    } else if (node->type == LIBISO_SYMLINK) {
        symlink = (IsoSymlink *) node;
        if (symlink->fs_id != ISO_IMAGE_FS_ID && (flag & 1)) {
            ret = 0;
            goto no_id;
        }
        *fs_id = symlink->fs_id;
        *dev_id = symlink->st_dev;
        *ino_id = symlink->st_ino;
        return 1;
 
    } else if (node->type == LIBISO_SPECIAL) {
        special = (IsoSpecial *) node;
        if (special->fs_id != ISO_IMAGE_FS_ID && (flag & 1)) {
            ret = 0;
            goto no_id;
        }
        *fs_id = special->fs_id;
        *dev_id = special->st_dev;
        *ino_id = special->st_ino;
        return 1;
 
    }
 
    ret = 0;
no_id:;
    *fs_id = 0;
    *dev_id = 0;
    *ino_id = 0;
    return ret;
}

References Iso_Symlink::fs_id, Iso_Special::fs_id, ISO_IMAGE_FS_ID, iso_node_get_xinfo(), iso_px_ino_xinfo_func(), iso_stream_get_id(), LIBISO_FILE, LIBISO_SPECIAL, LIBISO_SYMLINK, Iso_Symlink::st_dev, Iso_Special::st_dev, Iso_Symlink::st_ino, Iso_Special::st_ino, Iso_File::stream, and Iso_Node::type.

Referenced by img_register_ino(), img_update_ino(), iso_node_cmp_flag(), and match_hardlinks().

iso_node_is_valid_link_dest()

int iso_node_is_valid_link_dest

(

const char *

dest

)

Check if a given path is valid for the destination of a link.

Returns

1 if yes, 0 if not

Definition at line 1283 of file node.c.

{
    int ret;
    char *ptr, *brk_info, *component;
 
    /* a dest can't be NULL */
    if (dest == NULL) {
        return ISO_NULL_POINTER;
    }
 
    /* guard against the empty string or big dest... */
    if (dest[0] == '\0') {
#ifdef Libisofs_debug_rr_reserveD
        fprintf(stderr, "libisofs_DEBUG: ISO_RR_NAME_RESERVED by empty link target\n");
#endif
        return ISO_RR_NAME_RESERVED;
    }
    if (strlen(dest) > LIBISOFS_NODE_PATH_MAX)
        return ISO_RR_PATH_TOO_LONG;
 
    /* check that all components are valid */
    if (!strcmp(dest, "/")) {
        /* "/" is a valid component */
        return 1;
    }
 
    ptr = strdup(dest);
    if (ptr == NULL) {
        return ISO_OUT_OF_MEM;
    }
 
    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;
}

References iso_node_is_valid_name(), ISO_NULL_POINTER, ISO_OUT_OF_MEM, ISO_RR_NAME_RESERVED, ISO_RR_PATH_TOO_LONG, and LIBISOFS_NODE_PATH_MAX.

Referenced by iso_node_new_symlink(), and iso_symlink_set_dest().

iso_node_is_valid_name()

int iso_node_is_valid_name

(

const char *

name

)

Check if a given name is valid for an iso node.

Returns

1 if yes, <0 if not. The value is a specific ISO_* error code.

1 if yes, 0 if not

Definition at line 1245 of file node.c.

{
    /* a name can't be NULL */
    if (name == NULL) {
        return ISO_NULL_POINTER;
    }
 
    /* guard against the empty string or big names... */
    if (name[0] == '\0')
        goto rr_reserved;
    if (strlen(name) > LIBISOFS_NODE_NAME_MAX)
        return ISO_RR_NAME_TOO_LONG;
 
    /* ...against "." and ".." names... */
    if (!strcmp(name, ".") || !strcmp(name, ".."))
        goto rr_reserved;
 
    /* ...and against names with '/' */
    if (strchr(name, '/') != NULL)
        goto rr_reserved;
 
    return 1;
 
rr_reserved:;
/* # define Libisofs_debug_rr_reserveD */
#ifdef Libisofs_debug_rr_reserveD
    fprintf(stderr, "libisofs_DEBUG: ISO_RR_NAME_RESERVED with '%s'\n", name);
#endif
    
    return ISO_RR_NAME_RESERVED;
}

References ISO_NULL_POINTER, ISO_RR_NAME_RESERVED, ISO_RR_NAME_TOO_LONG, and LIBISOFS_NODE_NAME_MAX.

Referenced by iso_node_is_valid_link_dest(), iso_node_new_dir(), iso_node_new_file(), iso_node_new_special(), iso_node_new_symlink(), iso_node_set_name_trunc(), and iso_tree_add_boot_node().

iso_node_new_dir()

int iso_node_new_dir	(	char *	name,
		IsoDir **	dir
	)

Create a new IsoDir.

Attributes, uid/gid, timestamps, etc are set to default (0) values. You must set them.

Parameters

name	Name for the node. It is not strdup() so you shouldn't use this reference when this function returns successfully. NULL is not allowed.
dir

Returns

1 on success, < 0 on error.

Definition at line 1481 of file node.c.

{
    IsoDir *new;
    int ret;
 
    if (dir == NULL || name == NULL) {
        return ISO_NULL_POINTER;
    }
 
    /* check if the name is valid */
    ret = iso_node_is_valid_name(name);
    if (ret < 0)
        return ret;
 
    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;
}

References iso_node_is_valid_name(), ISO_NULL_POINTER, ISO_OUT_OF_MEM, ISO_SUCCESS, and LIBISO_DIR.

Referenced by default_create_node(), and iso_tree_add_new_dir().

iso_node_new_file()

int iso_node_new_file	(	char *	name,
		IsoStream *	stream,
		IsoFile **	file
	)

Create a new file node.

Attributes, uid/gid, timestamps, etc are set to default (0) values. You must set them.

Parameters

name	Name for the node. It is not strdup() so you shouldn't use this reference when this function returns successfully. NULL is not allowed.
stream	Source for file contents. The reference is taken by the node, you must call iso_stream_ref() if you need your own ref.

Returns

1 on success, < 0 on error.

Definition at line 1507 of file node.c.

{
    IsoFile *new;
    int ret;
 
    if (file == NULL || name == NULL || stream == NULL) {
        return ISO_NULL_POINTER;
    }
 
    /* check if the name is valid */
    ret = iso_node_is_valid_name(name);
    if (ret < 0)
        return ret;
 
    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->from_old_session = 0;
    new->explicit_weight = 0;
    new->sort_weight = 0;
    new->stream = stream;
 
    *file = new;
    return ISO_SUCCESS;
}

References iso_node_is_valid_name(), ISO_NULL_POINTER, ISO_OUT_OF_MEM, ISO_SUCCESS, and LIBISO_FILE.

Referenced by default_create_file(), default_create_node(), and iso_tree_add_new_file().

iso_node_new_root()

int iso_node_new_root

(

IsoDir **

root

)

Definition at line 1460 of file node.c.

{
    IsoDir *dir;
    time_t now;
 
    dir = calloc(1, sizeof(IsoDir));
    if (dir == NULL) {
        return ISO_OUT_OF_MEM;
    }
    dir->node.refcount = 1;
    dir->node.type = LIBISO_DIR;
    iso_nowtime(&now, 0);
    dir->node.atime = dir->node.ctime = dir->node.mtime = now;
    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;
}

References Iso_Node::atime, Iso_Node::ctime, iso_nowtime(), ISO_OUT_OF_MEM, ISO_SUCCESS, LIBISO_DIR, Iso_Node::mode, Iso_Node::mtime, Iso_Dir::node, Iso_Node::parent, Iso_Node::refcount, and Iso_Node::type.

Referenced by iso_image_import(), and iso_image_new().

iso_node_new_special()

int iso_node_new_special	(	char *	name,
		mode_t	mode,
		dev_t	dev,
		IsoSpecial **	special
	)

Create a new special file node.

As far as libisofs concerns, an special file is a block device, a character device, a FIFO (named pipe) or a socket. You can choose the specific kind of file you want to add by setting mode properly (see man 2 stat).

Note that special files are only written to image when Rock Ridge extensions are enabled. Moreover, a special file is just a directory entry in the image tree, no data is written beyond that.

Owner and hidden atts are taken from parent. You can modify any of them later.

Parameters

name	name for the new special file. It is not strdup() so you shouldn't use this reference when this function returns successfully. NULL is not allowed.
mode	file type and permissions for the new node. Note that you can't specify any kind of file here, only special types are allowed. i.e, S_IFSOCK, S_IFBLK, S_IFCHR and S_IFIFO are valid types; S_IFLNK, S_IFREG and S_IFDIR aren't.
dev	device ID, equivalent to the st_rdev field in man 2 stat.
special	place where to store a pointer to the newly created special file.

Returns

1 on success, < 0 otherwise

Definition at line 1573 of file node.c.

{
    IsoSpecial *new;
    int ret;
 
    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 */
    ret = iso_node_is_valid_name(name);
    if (ret < 0)
        return ret;
 
    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;
    new->fs_id = 0;
    new->st_dev = 0;
    new->st_ino = 0;
    *special = new;
    return ISO_SUCCESS;
}

References iso_node_is_valid_name(), ISO_NULL_POINTER, ISO_OUT_OF_MEM, ISO_SUCCESS, ISO_WRONG_ARG_VALUE, and LIBISO_SPECIAL.

Referenced by default_create_node(), and iso_tree_add_new_special().

iso_node_new_symlink()

int iso_node_new_symlink	(	char *	name,
		char *	dest,
		IsoSymlink **	link
	)

Creates a new IsoSymlink node.

Attributes, uid/gid, timestamps, etc are set to default (0) values. You must set them.

Parameters

name	name for the new symlink. It is not strdup() so you shouldn't use this reference when this function returns successfully. NULL is not allowed.
dest	destination of the link. It is not strdup() so you shouldn't use this reference when this function returns successfully. NULL is not allowed.
link	place where to store a pointer to the newly created link.

Returns

1 on success, < 0 otherwise

Definition at line 1538 of file node.c.

{
    IsoSymlink *new;
    int ret;
 
    if (link == NULL || name == NULL || dest == NULL) {
        return ISO_NULL_POINTER;
    }
 
    /* check if the name is valid */
    ret = iso_node_is_valid_name(name);
    if (ret < 0)
        return ret;
 
    /* check if destination is valid */
    ret = iso_node_is_valid_link_dest(dest);
    if (ret < 0) 
        return ret;
 
    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;
    new->fs_id = 0;
    new->st_dev = 0;
    new->st_ino = 0;
    *link = new;
    return ISO_SUCCESS;
}

References iso_node_is_valid_link_dest(), iso_node_is_valid_name(), ISO_NULL_POINTER, ISO_OUT_OF_MEM, ISO_SUCCESS, and LIBISO_SYMLINK.

Referenced by default_create_node(), and iso_tree_add_new_symlink().

iso_node_set_ino()

int iso_node_set_ino	(	IsoNode *	node,
		ino_t	ino,
		int	flag
	)

Definition at line 2672 of file node.c.

{
    int ret;
    IsoFile *file;
    IsoSymlink *symlink;
    IsoSpecial *special;
    void *xipt;
    
    ret = iso_node_get_xinfo(node, iso_px_ino_xinfo_func, &xipt);
    if (ret < 0)
        return ret;
    if (ret == 1) {
        ret = iso_node_set_ino_xinfo(node, ino, 1);
        if (ret < 0)
            return ret;
        return 2;
    }
    if (node->type == LIBISO_FILE) {
        file= (IsoFile *) node;
        ret = iso_stream_set_image_ino(file->stream, ino, 0);
        if (ret < 0 || ret == 1)
            return ret;
        /* ret == 0 means that the stream is not from loaded ISO image */
 
    } else if (node->type == LIBISO_SYMLINK) {
        symlink = (IsoSymlink *) node;
        if (symlink->fs_id == ISO_IMAGE_FS_ID) {
            symlink->st_ino = ino;
            return 1;
        }
 
    } else if (node->type == LIBISO_SPECIAL) {
        special = (IsoSpecial *) node;
        if (special->fs_id == ISO_IMAGE_FS_ID) {
            special->st_ino = ino;
            return 1;
        }
 
    }
    ret = iso_node_set_ino_xinfo(node, ino, 0);
    if (ret < 0)
        return ret;
    return 2;
}

References Iso_Symlink::fs_id, Iso_Special::fs_id, ISO_IMAGE_FS_ID, iso_node_get_xinfo(), iso_node_set_ino_xinfo(), iso_px_ino_xinfo_func(), iso_stream_set_image_ino(), LIBISO_FILE, LIBISO_SPECIAL, LIBISO_SYMLINK, Iso_Symlink::st_ino, Iso_Special::st_ino, Iso_File::stream, and Iso_Node::type.

Referenced by image_builder_create_node(), iso_image_import(), and iso_node_set_unique_id().

iso_node_set_perms_internal()

int iso_node_set_perms_internal	(	IsoNode *	node,
		mode_t	mode,
		int	flag
	)

See API function iso_node_set_permissions()

Parameters

flag	bit0= do not adjust ACL

Returns

>0 success , <0 error

Definition at line 430 of file node.c.

{
    int ret;
 
    node->mode = (node->mode & S_IFMT) | (mode & ~S_IFMT);
 
    /* If the node has ACL info : update ACL */
    ret = 1;
    if (!(flag & 1))
        ret = iso_node_set_acl_text(node, "", "", 2);
 
    return ret;
}

References iso_node_set_acl_text(), and Iso_Node::mode.

Referenced by default_create_node(), iso_node_set_acl_text(), and iso_node_set_permissions().

iso_node_set_unique_id()

int iso_node_set_unique_id	(	IsoNode *	node,
		IsoImage *	image,
		int	flag
	)

Definition at line 2718 of file node.c.

{
    int ret;
    ino_t ino;
 
    ino = img_give_ino_number(image, 0);
    ret = iso_node_set_ino(node, ino, 0);
    return ret;
}

References img_give_ino_number(), and iso_node_set_ino().

Referenced by img_update_ino().

iso_notify_dir_iters()

void iso_notify_dir_iters	(	IsoNode *	node,
		int	flag
	)

Definition at line 1448 of file node.c.

{
    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;
    }
}

References Iso_Dir_Iter::class, Iso_Dir_Iter::dir, iter_reg_node::iter, iter_reg, iter_reg_node::next, iso_dir_iter_iface::notify_child_taken, and Iso_Node::parent.

Referenced by iso_node_take().

iso_px_ino_xinfo_cloner()

int iso_px_ino_xinfo_cloner	(	void *	old_data,
		void **	new_data,
		int	flag
	)

Definition at line 2571 of file node.c.

{
    *new_data = NULL;
    if (flag)
        return ISO_XINFO_NO_CLONE; 
    *new_data = calloc(1, sizeof(ino_t));
    if (*new_data == NULL)
        return ISO_OUT_OF_MEM;
    memcpy(*new_data, old_data, sizeof(ino_t));
    return (int) sizeof(ino_t);
}

References ISO_OUT_OF_MEM, and ISO_XINFO_NO_CLONE.

Referenced by iso_init_with_flag().

iso_px_ino_xinfo_func()

int iso_px_ino_xinfo_func	(	void *	data,
		int	flag
	)

The iso_node_xinfo_func instance which governs the storing of the inode number from Rock Ridge field PX.

Definition at line 2559 of file node.c.

{
    if (flag == 1) {
        free(data);
    }
    return 1;
}

Referenced by iso_init_with_flag(), iso_node_get_id(), iso_node_set_ino(), and iso_node_set_ino_xinfo().

iso_root_get_isofsca()

int iso_root_get_isofsca	(	IsoNode *	node,
		uint32_t *	start_lba,
		uint32_t *	end_lba,
		uint32_t *	count,
		uint32_t *	size,
		char	typetext[81],
		int	flag
	)

Get the checksum area description.

node should be the root node. It is encoded as xattr "isofs.ca".

Definition at line 2941 of file node.c.

{
    int ret, len;
    size_t value_len;
    char *value = NULL, *rpt;
 
    ret = iso_node_lookup_attr(node, "isofs.ca", &value_len, &value, 0);
    if (ret <= 0)
        goto ex;
 
    /* Parse value of isofs.ca with
       4 byte START, 4 byte END, 4 byte COUNT, SIZE = 16,  MD5 */
    rpt = value;
    iso_util_decode_len_bytes(start_lba, rpt, &len,
                              value_len - (rpt - value), 0);
    rpt += len + 1;
    iso_util_decode_len_bytes(end_lba, rpt, &len,
                              value_len - (rpt - value), 0);
    rpt += len + 1;
    iso_util_decode_len_bytes(count, rpt, &len,
                              value_len - (rpt - value), 0);
    rpt += len + 1;
    iso_util_decode_len_bytes(size, rpt, &len,
                              value_len - (rpt - value), 0);
    rpt += len + 1;
    len = value_len - (rpt - value);
    if (len > 80)
        len = 80;
    memcpy(typetext, rpt, len);
    typetext[len] = 0;
 
    ret= ISO_SUCCESS;
ex:;
    if (value != NULL)
        free(value);
    return ret;
}

References iso_node_lookup_attr(), ISO_SUCCESS, and iso_util_decode_len_bytes().

Referenced by iso_image_import().

iso_root_get_isofsnt()

int iso_root_get_isofsnt	(	IsoNode *	node,
		uint32_t *	truncate_mode,
		uint32_t *	truncate_length,
		int	flag
	)

Definition at line 3001 of file node.c.

{
    int ret, len;
    size_t value_len;
    char *value = NULL, *rpt;
 
    ret = iso_node_lookup_attr(node, "isofs.nt", &value_len, &value, 0);
    if (ret <= 0)
        goto ex;
 
    rpt = value;
    iso_util_decode_len_bytes(truncate_mode, rpt, &len,
                              value_len - (rpt - value), 0);
    rpt += len + 1;
    iso_util_decode_len_bytes(truncate_length, rpt, &len,
                              value_len - (rpt - value), 0);
    ret= ISO_SUCCESS;
ex:;
    if (value != NULL)
        free(value);
    return ret;
}

References iso_node_lookup_attr(), ISO_SUCCESS, and iso_util_decode_len_bytes().

Referenced by iso_image_import().

iso_root_set_isofsca()

int iso_root_set_isofsca	(	IsoNode *	node,
		uint32_t	start_lba,
		uint32_t	end_lba,
		uint32_t	count,
		uint32_t	size,
		char *	typetext,
		int	flag
	)

Set the checksum area description.

node should be the root node. It is encoded as xattr "isofs.ca".

Definition at line 2910 of file node.c.

{
    char buffer[5 + 5 + 5 + 2 + 81], *wpt = buffer, *valuept = buffer;
    int result_len, ret;
    static char *names = "isofs.ca";
    static size_t value_lengths[1];
 
    /* Set value of isofs.ca with
       4 byte START, 4 byte END, 4 byte COUNT, SIZE = 16,  MD5 */
    iso_util_encode_len_bytes(start_lba, wpt, 4, &result_len, 0);
    wpt += result_len;
    iso_util_encode_len_bytes(end_lba, wpt, 4, &result_len, 0);
    wpt += result_len;
    iso_util_encode_len_bytes(count, wpt, 4, &result_len, 0);
    wpt += result_len;
    iso_util_encode_len_bytes(size, wpt, 1, &result_len, 0);
    wpt += result_len;
    strncpy(wpt, typetext, 80);
    if (strlen(typetext) > 80)
        wpt += 80;
    else
        wpt += strlen(typetext);
    value_lengths[0] = wpt - buffer;
    ret = iso_node_set_attrs(node, (size_t) 1,
                             &names, value_lengths, &valuept, 2 | 8);
    return ret;
}

References iso_node_set_attrs(), and iso_util_encode_len_bytes().

Referenced by checksum_prepare_image(), checksum_writer_compute_data_blocks(), and ecma119_writer_write_dirs().

iso_root_set_isofsnt()

int iso_root_set_isofsnt	(	IsoNode *	node,
		uint32_t	truncate_mode,
		uint32_t	truncate_length,
		int	flag
	)

Record and get truncation parameters as of iso_image_set_truncate_mode() by "isofs.nt".

Definition at line 2982 of file node.c.

{
    char buffer[5 + 5], *wpt = buffer, *valuept = buffer;
    int result_len, ret;
    static char *names = "isofs.nt";
    static size_t value_lengths[1];
 
    iso_util_encode_len_bytes(truncate_mode, wpt, 0, &result_len, 0);
    wpt += result_len;
    iso_util_encode_len_bytes(truncate_length, wpt, 0, &result_len, 0);
    wpt += result_len;
    value_lengths[0] = wpt - buffer;
    ret = iso_node_set_attrs(node, (size_t) 1,
                             &names, value_lengths, &valuept, 2 | 8);
    return ret;
}

References iso_node_set_attrs(), and iso_util_encode_len_bytes().

Referenced by ecma119_image_new().

zisofs_zf_xinfo_cloner()

int zisofs_zf_xinfo_cloner	(	void *	old_data,
		void **	new_data,
		int	flag
	)

Definition at line 2423 of file node.c.

{
    *new_data = NULL;
    if (flag)
        return ISO_XINFO_NO_CLONE;
    if (old_data == NULL)
        return 0;
    *new_data = calloc(1, sizeof(struct zisofs_zf_info));
    if (*new_data == NULL)
        return ISO_OUT_OF_MEM;
    memcpy(*new_data, old_data, sizeof(struct zisofs_zf_info));
    return (int) sizeof(struct zisofs_zf_info);
}

References ISO_OUT_OF_MEM, and ISO_XINFO_NO_CLONE.

Referenced by iso_init_with_flag().

zisofs_zf_xinfo_func()

int zisofs_zf_xinfo_func	(	void *	data,
		int	flag
	)

Function to identify and manage ZF parameters which do not stem from ZF fields (those are known to the FileSource) and do not stem from filters ("ziso" knows them globally, "osiz" knows them individually) but rather from an inspection of the file content header for zisofs magic number and plausible parameters.

The parameters get attached in struct zisofs_zf_info as xinfo to an IsoNode.

Definition at line 2411 of file node.c.

{
    if (flag & 1) {
        free(data);
    }
    return 1;
}

Referenced by add_zf_field(), iso_file_zf_by_magic(), iso_init_with_flag(), and iso_node_zf_by_magic().