find.c File Reference

#include "libisofs.h"
#include "node.h"
#include <fnmatch.h>
#include <string.h>

Include dependency graph for find.c:

Go to the source code of this file.

Data Structures
struct	iso_find_condition
struct	find_iter_data
struct	cond_times
struct	logical_binary_conditions

Functions
static int	get_next (struct find_iter_data *iter, IsoNode **n)
static void	update_next (IsoDirIter *iter)
static int	find_iter_next (IsoDirIter *iter, IsoNode **node)
static int	find_iter_has_next (IsoDirIter *iter)
static void	find_iter_free (IsoDirIter *iter)
static int	find_iter_take (IsoDirIter *iter)
static int	find_iter_remove (IsoDirIter *iter)
void	find_notify_child_taken (IsoDirIter *iter, IsoNode *node)
int	iso_dir_find_children (IsoDir *dir, IsoFindCondition *cond, IsoDirIter **iter)
	Find all directory children that match the given condition. More...
static int	cond_name_matches (IsoFindCondition *cond, IsoNode *node)
static void	cond_name_free (IsoFindCondition *cond)
IsoFindCondition *	iso_new_find_conditions_name (const char *wildcard)
	Create a new condition that checks if the node name matches the given wildcard. More...
static int	cond_mode_matches (IsoFindCondition *cond, IsoNode *node)
static void	cond_mode_free (IsoFindCondition *cond)
IsoFindCondition *	iso_new_find_conditions_mode (mode_t mask)
	Create a new condition that checks the node mode against a mode mask. More...
static int	cond_gid_matches (IsoFindCondition *cond, IsoNode *node)
static void	cond_gid_free (IsoFindCondition *cond)
IsoFindCondition *	iso_new_find_conditions_gid (gid_t gid)
	Create a new condition that checks the node gid. More...
static int	cond_uid_matches (IsoFindCondition *cond, IsoNode *node)
static void	cond_uid_free (IsoFindCondition *cond)
IsoFindCondition *	iso_new_find_conditions_uid (uid_t uid)
	Create a new condition that checks the node uid. More...
static int	cond_time_matches (IsoFindCondition *cond, IsoNode *node)
static void	cond_time_free (IsoFindCondition *cond)
IsoFindCondition *	iso_new_find_conditions_atime (time_t time, enum iso_find_comparisons comparison)
	Create a new condition that checks the time of last access. More...
IsoFindCondition *	iso_new_find_conditions_mtime (time_t time, enum iso_find_comparisons comparison)
	Create a new condition that checks the time of last modification. More...
IsoFindCondition *	iso_new_find_conditions_ctime (time_t time, enum iso_find_comparisons comparison)
	Create a new condition that checks the time of last status change. More...
static void	cond_logical_binary_free (IsoFindCondition *cond)
static int	cond_logical_and_matches (IsoFindCondition *cond, IsoNode *node)
IsoFindCondition *	iso_new_find_conditions_and (IsoFindCondition *a, IsoFindCondition *b)
	Create a new condition that check if the two given conditions are valid. More...
static int	cond_logical_or_matches (IsoFindCondition *cond, IsoNode *node)
IsoFindCondition *	iso_new_find_conditions_or (IsoFindCondition *a, IsoFindCondition *b)
	Create a new condition that check if at least one the two given conditions is valid. More...
static void	cond_not_free (IsoFindCondition *cond)
static int	cond_not_matches (IsoFindCondition *cond, IsoNode *node)
IsoFindCondition *	iso_new_find_conditions_not (IsoFindCondition *negate)
	Create a new condition that check if the given conditions is false. More...

Variables
static struct iso_dir_iter_iface	find_iter_class

Function Documentation

cond_gid_free()

static void cond_gid_free ( IsoFindCondition *  cond )

static

Definition at line 396 of file find.c.

{
    free(cond->data);
}

References find_iter_data::cond, and iso_find_condition::data.

Referenced by iso_new_find_conditions_gid().

cond_gid_matches()

static int cond_gid_matches ( IsoFindCondition *  cond, IsoNode *  node  )

static

Definition at line 389 of file find.c.

{
    gid_t *gid = (gid_t*) cond->data;
    return node->gid == *gid ? 1 : 0;
}

References find_iter_data::cond, iso_find_condition::data, and Iso_Node::gid.

Referenced by iso_new_find_conditions_gid().

cond_logical_and_matches()

static int cond_logical_and_matches ( IsoFindCondition *  cond, IsoNode *  node  )

static

Definition at line 650 of file find.c.

{
    struct logical_binary_conditions *data = cond->data;
    return data->a->matches(data->a, node) && data->b->matches(data->b, node);
}

References logical_binary_conditions::a, logical_binary_conditions::b, iso_find_condition::data, and iso_find_condition::matches.

Referenced by iso_new_find_conditions_and().

cond_logical_binary_free()

static void cond_logical_binary_free ( IsoFindCondition *  cond )

static

Definition at line 638 of file find.c.

{
    struct logical_binary_conditions *data;
    data = cond->data;
    data->a->free(data->a);
    free(data->a);
    data->b->free(data->b);
    free(data->b);
    free(cond->data);
}

References logical_binary_conditions::a, logical_binary_conditions::b, iso_find_condition::data, and iso_find_condition::free.

Referenced by iso_new_find_conditions_and(), and iso_new_find_conditions_or().

cond_logical_or_matches()

static int cond_logical_or_matches ( IsoFindCondition *  cond, IsoNode *  node  )

static

Definition at line 691 of file find.c.

{
    struct logical_binary_conditions *data = cond->data;
    return data->a->matches(data->a, node) || data->b->matches(data->b, node);
}

References logical_binary_conditions::a, logical_binary_conditions::b, iso_find_condition::data, and iso_find_condition::matches.

Referenced by iso_new_find_conditions_or().

cond_mode_free()

static void cond_mode_free ( IsoFindCondition *  cond )

static

Definition at line 344 of file find.c.

{
    free(cond->data);
}

References find_iter_data::cond, and iso_find_condition::data.

Referenced by iso_new_find_conditions_mode().

cond_mode_matches()

static int cond_mode_matches ( IsoFindCondition *  cond, IsoNode *  node  )

static

Definition at line 337 of file find.c.

{
    mode_t *mask = (mode_t*) cond->data;
    return node->mode & *mask ? 1 : 0;
}

References find_iter_data::cond, iso_find_condition::data, and Iso_Node::mode.

Referenced by iso_new_find_conditions_mode().

cond_name_free()

static void cond_name_free ( IsoFindCondition *  cond )

static

Definition at line 303 of file find.c.

{
    free(cond->data);
}

References find_iter_data::cond, and iso_find_condition::data.

Referenced by iso_new_find_conditions_name().

cond_name_matches()

static int cond_name_matches ( IsoFindCondition *  cond, IsoNode *  node  )

static

Definition at line 295 of file find.c.

{
    char *pattern = (char*) cond->data;
    int ret = fnmatch(pattern, node->name, 0);
    return ret == 0 ? 1 : 0;
}

References find_iter_data::cond, iso_find_condition::data, and Iso_Node::name.

Referenced by iso_new_find_conditions_name().

cond_not_free()

static void cond_not_free ( IsoFindCondition *  cond )

static

Definition at line 732 of file find.c.

{
    IsoFindCondition *negate = cond->data;
    negate->free(negate);
    free(negate);
}

References iso_find_condition::data, and iso_find_condition::free.

Referenced by iso_new_find_conditions_not().

cond_not_matches()

static int cond_not_matches ( IsoFindCondition *  cond, IsoNode *  node  )

static

Definition at line 740 of file find.c.

{
    IsoFindCondition *negate = cond->data;
    return !(negate->matches(negate, node));
}

References iso_find_condition::data, and iso_find_condition::matches.

Referenced by iso_new_find_conditions_not().

cond_time_free()

static void cond_time_free ( IsoFindCondition *  cond )

static

Definition at line 514 of file find.c.

{
    free(cond->data);
}

References iso_find_condition::data.

Referenced by iso_new_find_conditions_atime(), iso_new_find_conditions_ctime(), and iso_new_find_conditions_mtime().

cond_time_matches()

static int cond_time_matches ( IsoFindCondition *  cond, IsoNode *  node  )

static

Definition at line 486 of file find.c.

{
    time_t node_time;
    struct cond_times *data = cond->data;
    
    switch (data->what_time) {
    case 0: node_time = node->atime; break;
    case 1: node_time = node->mtime; break;
    default: node_time = node->ctime; break;
    }
    
    switch (data->comparison) {
    case ISO_FIND_COND_GREATER:
        return node_time > data->time ? 1 : 0;
    case ISO_FIND_COND_GREATER_OR_EQUAL:
        return node_time >= data->time ? 1 : 0;
    case ISO_FIND_COND_EQUAL:
        return node_time == data->time ? 1 : 0;
    case ISO_FIND_COND_LESS:
        return node_time < data->time ? 1 : 0;
    case ISO_FIND_COND_LESS_OR_EQUAL:
        return node_time <= data->time ? 1 : 0;
    }
    /* should never happen */
    return 0;
}

References Iso_Node::atime, cond_times::comparison, Iso_Node::ctime, iso_find_condition::data, ISO_FIND_COND_EQUAL, ISO_FIND_COND_GREATER, ISO_FIND_COND_GREATER_OR_EQUAL, ISO_FIND_COND_LESS, ISO_FIND_COND_LESS_OR_EQUAL, Iso_Node::mtime, cond_times::time, and cond_times::what_time.

Referenced by iso_new_find_conditions_atime(), iso_new_find_conditions_ctime(), and iso_new_find_conditions_mtime().

cond_uid_free()

static void cond_uid_free ( IsoFindCondition *  cond )

static

Definition at line 441 of file find.c.

{
    free(cond->data);
}

References find_iter_data::cond, and iso_find_condition::data.

Referenced by iso_new_find_conditions_uid().

cond_uid_matches()

static int cond_uid_matches ( IsoFindCondition *  cond, IsoNode *  node  )

static

Definition at line 434 of file find.c.

{
    uid_t *uid = (uid_t*) cond->data;
    return node->uid == *uid ? 1 : 0;
}

References find_iter_data::cond, iso_find_condition::data, and Iso_Node::uid.

Referenced by iso_new_find_conditions_uid().

find_iter_free()

static void find_iter_free ( IsoDirIter *  iter )

static

Definition at line 168 of file find.c.

{
    struct find_iter_data *data = iter->data;
    if (data->free_cond) {
        data->cond->free(data->cond);
        free(data->cond);
    }
    
    iso_node_unref((IsoNode*)data->dir);
 
    /* free refs to nodes */
    if (data->prev) {
        iso_node_unref(data->prev);
    }
    if (data->current) {
        iso_node_unref(data->current);
    }
 
    /* free underlying iter */
    iso_dir_iter_free(data->iter);
    free(iter->data);
}

References find_iter_data::cond, find_iter_data::current, Iso_Dir_Iter::data, find_iter_data::dir, iso_find_condition::free, find_iter_data::free_cond, iso_dir_iter_free(), iso_node_unref(), find_iter_data::iter, and find_iter_data::prev.

find_iter_has_next()

static int find_iter_has_next ( IsoDirIter *  iter )

static

Definition at line 160 of file find.c.

{
    struct find_iter_data *data = iter->data;
    
    return (data->current != NULL);
}

References find_iter_data::current, Iso_Dir_Iter::data, and find_iter_data::iter.

find_iter_next()

static int find_iter_next ( IsoDirIter *  iter, IsoNode **  node  )

static

Definition at line 142 of file find.c.

{
    struct find_iter_data *data;
    
    if (iter == NULL || node == NULL) {
        return ISO_NULL_POINTER;
    }
    data = iter->data;
    
    if (data->err < 0) {
        return data->err;
    }
    *node = data->current;
    update_next(iter);
    return (*node == NULL) ? 0 : ISO_SUCCESS;
}

References find_iter_data::current, Iso_Dir_Iter::data, find_iter_data::err, ISO_NULL_POINTER, ISO_SUCCESS, find_iter_data::iter, and update_next().

find_iter_remove()

static int find_iter_remove ( IsoDirIter *  iter )

static

Definition at line 203 of file find.c.

{
    struct find_iter_data *data = iter->data;
 
    if (data->prev == NULL) {
        return ISO_ERROR; /* next not called or end of dir */
    }
    return iso_node_remove(data->prev);
}

References Iso_Dir_Iter::data, ISO_ERROR, iso_node_remove(), find_iter_data::iter, and find_iter_data::prev.

find_iter_take()

static int find_iter_take ( IsoDirIter *  iter )

static

Definition at line 192 of file find.c.

{
    struct find_iter_data *data = iter->data;
 
    if (data->prev == NULL) {
        return ISO_ERROR; /* next not called or end of dir */
    }
    return iso_node_take(data->prev);
}

References Iso_Dir_Iter::data, ISO_ERROR, iso_node_take(), find_iter_data::iter, and find_iter_data::prev.

find_notify_child_taken()

void find_notify_child_taken	(	IsoDirIter *	iter,
		IsoNode *	node
	)

Definition at line 213 of file find.c.

{
    struct find_iter_data *data = iter->data;
    
    if (data->prev == node) {
        /* free our ref */
        iso_node_unref(node);
        data->prev = NULL;
    } else if (data->current == node) {
        iso_node_unref(node);
        data->current = NULL;
        update_next(iter);
    }
}

get_next()

static int get_next ( struct find_iter_data *  iter, IsoNode **  n  )

static

Definition at line 56 of file find.c.

{
    int ret;
    
    if (iter->itersec != NULL) {
        ret = iso_dir_iter_next(iter->itersec, n);
        if (ret <= 0) {
            /* secondary item no more needed */
            iso_dir_iter_free(iter->itersec);
            iter->itersec = NULL;
        }
        if (ret != 0) {
            /* success or error */
            return ret;
        }
    }
    
    /* 
     * we reach here if:
     * - no secondary item is present
     * - secondary item has no more items
     */
 
    while ((ret = iso_dir_iter_next(iter->iter, n)) == 1) {
        if (iter->cond->matches(iter->cond, *n)) {
            return ISO_SUCCESS;
        } else if (ISO_NODE_IS_DIR(*n)) {
            /* recurse on child dir */
            struct find_iter_data *data;
            ret = iso_dir_find_children((IsoDir*)*n, iter->cond, 
                                        &iter->itersec);
            if (ret < 0) {
                return ret;
            }
            data = iter->itersec->data;
            data->free_cond = 0; /* we don't need sec iter to free cond */
            return get_next(iter, n);
        }
    }
    return ret;
}

References find_iter_data::cond, Iso_Dir_Iter::data, find_iter_data::free_cond, iso_dir_find_children(), iso_dir_iter_free(), iso_dir_iter_next(), ISO_NODE_IS_DIR, ISO_SUCCESS, find_iter_data::iter, find_iter_data::itersec, and iso_find_condition::matches.

Referenced by update_next().

iso_dir_find_children()

int iso_dir_find_children	(	IsoDir *	dir,
		IsoFindCondition *	cond,
		IsoDirIter **	iter
	)

Find all directory children that match the given condition.

Parameters

dir	Directory where we will search children.
cond	Condition that the children must match in order to be returned. It will be free together with the iterator. Remember to delete it if this function return error.
iter	Iterator that returns only the children that match condition.

Returns

1 on success, < 0 on error

Since

0.6.4

Definition at line 238 of file find.c.

{
    int ret;
    IsoDirIter *children;
    IsoDirIter *it;
    struct find_iter_data *data;
 
    if (dir == NULL || cond == NULL || iter == NULL) {
        return ISO_NULL_POINTER;
    }
    it = malloc(sizeof(IsoDirIter));
    if (it == NULL) {
        return ISO_OUT_OF_MEM;
    }
    data = malloc(sizeof(struct find_iter_data));
    if (data == NULL) {
        free(it);
        return ISO_OUT_OF_MEM;
    }
    ret = iso_dir_get_children(dir, &children);
    if (ret < 0) {
        free(it);
        free(data);
        return ret;
    }
 
    it->class = &find_iter_class;
    it->dir = (IsoDir*)dir;
    data->iter = children;
    data->itersec = NULL;
    data->cond = cond;
    data->free_cond = 1;
    data->err = 0;
    data->prev = data->current = NULL;
    it->data = data;
    
    if (iso_dir_iter_register(it) < 0) {
        free(it);
        return ISO_OUT_OF_MEM;
    }
 
    iso_node_ref((IsoNode*)dir);
    
    /* take another ref to the original dir */
    data->dir = (IsoDir*)dir;
    iso_node_ref((IsoNode*)dir);
 
    update_next(it);
    
    *iter = it;
    return ISO_SUCCESS;
}

References Iso_Dir_Iter::class, find_iter_data::cond, find_iter_data::current, Iso_Dir_Iter::data, find_iter_data::dir, Iso_Dir_Iter::dir, find_iter_data::err, find_iter_class, find_iter_data::free_cond, iso_dir_get_children(), iso_dir_iter_register(), iso_node_ref(), ISO_NULL_POINTER, ISO_OUT_OF_MEM, ISO_SUCCESS, find_iter_data::iter, find_iter_data::itersec, find_iter_data::prev, and update_next().

Referenced by get_next(), and update_next().

iso_new_find_conditions_and()

IsoFindCondition* iso_new_find_conditions_and	(	IsoFindCondition *	a,
		IsoFindCondition *	b
	)

Create a new condition that check if the two given conditions are valid.

Parameters

a
b	IsoFindCondition to compare

Returns

The created IsoFindCondition, NULL on error.

Since

0.6.4

Definition at line 668 of file find.c.

{
    IsoFindCondition *cond;
    struct logical_binary_conditions *data;
    cond = malloc(sizeof(IsoFindCondition));
    if (cond == NULL) {
        return NULL;
    }
    data = malloc(sizeof(struct logical_binary_conditions));
    if (data == NULL) {
        free(cond);
        return NULL;
    }
    data->a = a;
    data->b = b;
    cond->data = data;
    cond->free = cond_logical_binary_free;
    cond->matches = cond_logical_and_matches;
    return cond;
}

References logical_binary_conditions::a, logical_binary_conditions::b, cond_logical_and_matches(), cond_logical_binary_free(), iso_find_condition::data, iso_find_condition::free, and iso_find_condition::matches.

iso_new_find_conditions_atime()

IsoFindCondition* iso_new_find_conditions_atime	(	time_t	time,
		enum iso_find_comparisons	comparison
	)

Create a new condition that checks the time of last access.

Parameters

time	Time to compare against IsoNode atime.
comparison	Comparison to be done between IsoNode atime and submitted time. Note that ISO_FIND_COND_GREATER, for example, is true if the node time is greater than the submitted time.

Returns

The created IsoFindCondition, NULL on error.

Since

0.6.4

Definition at line 533 of file find.c.

{
    IsoFindCondition *cond;
    struct cond_times *data;
    cond = malloc(sizeof(IsoFindCondition));
    if (cond == NULL) {
        return NULL;
    }
    data = malloc(sizeof(struct cond_times));
    if (data == NULL) {
        free(cond);
        return NULL;
    }
    data->time = time;
    data->comparison = comparison;
    data->what_time = 0; /* atime */
    cond->data = data;
    cond->free = cond_time_free;
    cond->matches = cond_time_matches;
    return cond;
}

References cond_times::comparison, cond_time_free(), cond_time_matches(), iso_find_condition::data, iso_find_condition::free, iso_find_condition::matches, cond_times::time, and cond_times::what_time.

iso_new_find_conditions_ctime()

IsoFindCondition* iso_new_find_conditions_ctime	(	time_t	time,
		enum iso_find_comparisons	comparison
	)

Create a new condition that checks the time of last status change.

Parameters

time	Time to compare against IsoNode ctime.
comparison	Comparison to be done between IsoNode ctime and submitted time. Note that ISO_FIND_COND_GREATER, for example, is true if the node time is greater than the submitted time.

Returns

The created IsoFindCondition, NULL on error.

Since

0.6.4

Definition at line 607 of file find.c.

{
    IsoFindCondition *cond;
    struct cond_times *data;
    cond = malloc(sizeof(IsoFindCondition));
    if (cond == NULL) {
        return NULL;
    }
    data = malloc(sizeof(struct cond_times));
    if (data == NULL) {
        free(cond);
        return NULL;
    }
    data->time = time;
    data->comparison = comparison;
    data->what_time = 2; /* ctime */
    cond->data = data;
    cond->free = cond_time_free;
    cond->matches = cond_time_matches;
    return cond;
}

References cond_times::comparison, cond_time_free(), cond_time_matches(), iso_find_condition::data, iso_find_condition::free, iso_find_condition::matches, cond_times::time, and cond_times::what_time.

iso_new_find_conditions_gid()

IsoFindCondition* iso_new_find_conditions_gid

(

gid_t

gid

)

Create a new condition that checks the node gid.

Parameters

gid	Desired Group Id.

Returns

The created IsoFindCondition, NULL on error.

Since

0.6.4

Definition at line 411 of file find.c.

{
    IsoFindCondition *cond;
    gid_t *data;
    cond = malloc(sizeof(IsoFindCondition));
    if (cond == NULL) {
        return NULL;
    }
    data = malloc(sizeof(gid_t));
    if (data == NULL) {
        free(cond);
        return NULL;
    }
    *data = gid;
    cond->data = data;
    cond->free = cond_gid_free;
    cond->matches = cond_gid_matches;
    return cond;
}

References find_iter_data::cond, cond_gid_free(), cond_gid_matches(), iso_find_condition::data, iso_find_condition::free, and iso_find_condition::matches.

iso_new_find_conditions_mode()

IsoFindCondition* iso_new_find_conditions_mode

(

mode_t

mask

)

Create a new condition that checks the node mode against a mode mask.

It can be used to check both file type and permissions.

For example:

iso_new_find_conditions_mode(S_IFREG) : search for regular files iso_new_find_conditions_mode(S_IFCHR | S_IWUSR) : search for character devices where owner has write permissions.

Parameters

mask	Mode mask to AND against node mode.

Returns

The created IsoFindCondition, NULL on error.

Since

0.6.4

Definition at line 366 of file find.c.

{
    IsoFindCondition *cond;
    mode_t *data;
    cond = malloc(sizeof(IsoFindCondition));
    if (cond == NULL) {
        return NULL;
    }
    data = malloc(sizeof(mode_t));
    if (data == NULL) {
        free(cond);
        return NULL;
    }
    *data = mask;
    cond->data = data;
    cond->free = cond_mode_free;
    cond->matches = cond_mode_matches;
    return cond;
}

References find_iter_data::cond, cond_mode_free(), cond_mode_matches(), iso_find_condition::data, iso_find_condition::free, and iso_find_condition::matches.

iso_new_find_conditions_mtime()

IsoFindCondition* iso_new_find_conditions_mtime	(	time_t	time,
		enum iso_find_comparisons	comparison
	)

Create a new condition that checks the time of last modification.

Parameters

time	Time to compare against IsoNode mtime.
comparison	Comparison to be done between IsoNode mtime and submitted time. Note that ISO_FIND_COND_GREATER, for example, is true if the node time is greater than the submitted time.

Returns

The created IsoFindCondition, NULL on error.

Since

0.6.4

Definition at line 570 of file find.c.

{
    IsoFindCondition *cond;
    struct cond_times *data;
    cond = malloc(sizeof(IsoFindCondition));
    if (cond == NULL) {
        return NULL;
    }
    data = malloc(sizeof(struct cond_times));
    if (data == NULL) {
        free(cond);
        return NULL;
    }
    data->time = time;
    data->comparison = comparison;
    data->what_time = 1; /* mtime */
    cond->data = data;
    cond->free = cond_time_free;
    cond->matches = cond_time_matches;
    return cond;
}

References cond_times::comparison, cond_time_free(), cond_time_matches(), iso_find_condition::data, iso_find_condition::free, iso_find_condition::matches, cond_times::time, and cond_times::what_time.

iso_new_find_conditions_name()

IsoFindCondition* iso_new_find_conditions_name

(

const char *

wildcard

)

Create a new condition that checks if the node name matches the given wildcard.

Parameters

wildcard

Returns

The created IsoFindCondition, NULL on error.

Since

0.6.4

Definition at line 318 of file find.c.

{
    IsoFindCondition *cond;
    if (wildcard == NULL) {
        return NULL;
    }
    cond = malloc(sizeof(IsoFindCondition));
    if (cond == NULL) {
        return NULL;
    }
    cond->data = strdup(wildcard);
    cond->free = cond_name_free;
    cond->matches = cond_name_matches;
    return cond;
}

References find_iter_data::cond, cond_name_free(), cond_name_matches(), iso_find_condition::data, iso_find_condition::free, and iso_find_condition::matches.

iso_new_find_conditions_not()

IsoFindCondition* iso_new_find_conditions_not

(

IsoFindCondition *

negate

)

Create a new condition that check if the given conditions is false.

Parameters

negate

Returns

The created IsoFindCondition, NULL on error.

Since

0.6.4

Definition at line 755 of file find.c.

{
    IsoFindCondition *cond;
    cond = malloc(sizeof(IsoFindCondition));
    if (cond == NULL) {
        return NULL;
    }
    cond->data = negate;
    cond->free = cond_not_free;
    cond->matches = cond_not_matches;
    return cond;
}

References cond_not_free(), cond_not_matches(), iso_find_condition::data, iso_find_condition::free, and iso_find_condition::matches.

iso_new_find_conditions_or()

IsoFindCondition* iso_new_find_conditions_or	(	IsoFindCondition *	a,
		IsoFindCondition *	b
	)

Create a new condition that check if at least one the two given conditions is valid.

Parameters

a
b	IsoFindCondition to compare

Returns

The created IsoFindCondition, NULL on error.

Since

0.6.4

Definition at line 709 of file find.c.

{
    IsoFindCondition *cond;
    struct logical_binary_conditions *data;
    cond = malloc(sizeof(IsoFindCondition));
    if (cond == NULL) {
        return NULL;
    }
    data = malloc(sizeof(struct logical_binary_conditions));
    if (data == NULL) {
        free(cond);
        return NULL;
    }
    data->a = a;
    data->b = b;
    cond->data = data;
    cond->free = cond_logical_binary_free;
    cond->matches = cond_logical_or_matches;
    return cond;
}

References logical_binary_conditions::a, logical_binary_conditions::b, cond_logical_binary_free(), cond_logical_or_matches(), iso_find_condition::data, iso_find_condition::free, and iso_find_condition::matches.

iso_new_find_conditions_uid()

IsoFindCondition* iso_new_find_conditions_uid

(

uid_t

uid

)

Create a new condition that checks the node uid.

Parameters

uid	Desired User Id.

Returns

The created IsoFindCondition, NULL on error.

Since

0.6.4

Definition at line 456 of file find.c.

{
    IsoFindCondition *cond;
    uid_t *data;
    cond = malloc(sizeof(IsoFindCondition));
    if (cond == NULL) {
        return NULL;
    }
    data = malloc(sizeof(uid_t));
    if (data == NULL) {
        free(cond);
        return NULL;
    }
    *data = uid;
    cond->data = data;
    cond->free = cond_uid_free;
    cond->matches = cond_uid_matches;
    return cond;
}

References find_iter_data::cond, cond_uid_free(), cond_uid_matches(), iso_find_condition::data, iso_find_condition::free, and iso_find_condition::matches.

update_next()

static void update_next ( IsoDirIter *  iter )

static

Definition at line 99 of file find.c.

{
    int ret;
    IsoNode *n;
    struct find_iter_data *data = iter->data;
 
    if (data->prev) {
        iso_node_unref(data->prev);
    }
    data->prev = data->current;
    
    if (data->itersec == NULL && data->current != NULL 
            && ISO_NODE_IS_DIR(data->current)) {
        
        /* we need to recurse on child dir */
        struct find_iter_data *data2;
        ret = iso_dir_find_children((IsoDir*)data->current, data->cond, 
                                    &data->itersec);
        if (ret < 0) {
            data->current = NULL;
            data->err = ret;
            return;
        }
        data2 = data->itersec->data;
        data2->free_cond = 0; /* we don't need sec iter to free cond */
    }
    
    ret = get_next(data, &n);
    iso_node_unref((IsoNode*)iter->dir);
    if (ret == 1) {
        data->current = n;
        iso_node_ref(n);
        data->err = 0;
        iter->dir = n->parent;
    } else {
        data->current = NULL;
        data->err = ret;
        iter->dir = data->dir;
    }
    iso_node_ref((IsoNode*)iter->dir);
}

References find_iter_data::cond, find_iter_data::current, Iso_Dir_Iter::data, find_iter_data::dir, Iso_Dir_Iter::dir, find_iter_data::err, find_iter_data::free_cond, get_next(), iso_dir_find_children(), ISO_NODE_IS_DIR, iso_node_ref(), iso_node_unref(), find_iter_data::iter, find_iter_data::itersec, Iso_Node::parent, and find_iter_data::prev.

Referenced by find_iter_next(), and iso_dir_find_children().

Variable Documentation

find_iter_class

struct iso_dir_iter_iface find_iter_class

static

Initial value:

= {
        find_iter_next,
        find_iter_has_next,
        find_iter_free,
        find_iter_take,
        find_iter_remove,
        find_notify_child_taken
}

Definition at line 213 of file find.c.

Referenced by iso_dir_find_children().