archive/archived
Archived
1
0
Fork 0
Code Activity

notify/fscrawl: fixed up src/notify/tree, ADT, new API, new name.

Browse source
This commit is contained in:
Henrik Hautakoski 2010-09-30 23:04:11 +02:00
parent 9fbe9cfc23
commit 8d7b4a74c7
8 changed files with 260 additions and 277 deletions
Download patch file Download diff file Expand all files Collapse all files

184
src/notify/fscrawl.c Normal file
View file

@ -0,0 +1,184 @@
/* notify/fscrawl.c - Filesystem traversal
*
* (C) Copyright 2010 Henrik Hautakoski <henrik@fiktivkod.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*/
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <dirent.h>
#include "../common/strbuf.h"
#include "../common/path.h"
#include "../common/debug.h"
#include "fscrawl.h"
#define MAX_DEPTH 0x20
#define isrefdir(x) (!strcmp((x)->d_name, ".") || !strcmp((x)->d_name, ".."))
struct __fscrawl {
strbuf_t path;
DIR *dirs[MAX_DEPTH];
unsigned char depth;
fs_entry ent;
};
static int mvup(struct __fscrawl *f) {
if (closedir(f->dirs[f->depth]) == -1) {
perror("TREE");
return -1;
}
if (f->depth == 0)
return 0;
dprint("tree_next_ent: tree depth is: %i \n", f->depth);
f->depth--;
if (f->path.buf[f->path.len-1] == '/')
strbuf_reduce(&f->path, 1);
strbuf_rchop(&f->path, '/');
strbuf_term(&f->path, '/');
return 1;
}
static int mvdown(struct __fscrawl *f, const char *dir) {
DIR *ds = NULL;
if (f->depth >= MAX_DEPTH-1)
return 0;
strbuf_term(&f->path, '/');
strbuf_append_str(&f->path, dir);
strbuf_term(&f->path, '/');
ds = opendir(f->path.buf);
if (!ds) {
if (errno != EACCES)
perror("opendir");
errno = 0;
strbuf_reduce(&f->path, 1);
strbuf_rchop(&f->path, '/');
strbuf_term(&f->path, '/');
return 0;
}
f->dirs[++f->depth] = ds;
return 1;
}
fscrawl_t fsc_open(const char *path) {
int i;
struct __fscrawl *f = malloc(sizeof(struct __fscrawl));
if (f == NULL)
return NULL;
strbuf_init(&f->path);
char *npath = path_normalize(path, NULL, 1);
if (!npath)
return NULL;
/* set the normalized path as the string buffer */
strbuf_attach(&f->path, npath, strlen(npath), strlen(npath));
f->depth = 0;
f->dirs[f->depth] = opendir(f->path.buf);
if (!f->dirs[f->depth]) {
perror("fsc_open");
errno = 0;
strbuf_free(&f->path);
free(f);
return NULL;
}
f->ent.name = NULL;
f->ent.base = NULL;
f->ent.dir = 0;
return f;
}
void fsc_close(fscrawl_t f) {
int i;
for(i=0; i < f->depth; i++)
closedir(f->dirs[i]);
strbuf_free(&f->path);
free(f);
}
fs_entry* fsc_cpy(fs_entry *ent) {
void *ptr = malloc(sizeof(fs_entry));
if (ptr == NULL)
return NULL;
memcpy(ptr, ent, sizeof(fs_entry));
return ptr;
}
fs_entry* fsc_read(fscrawl_t f) {
struct dirent *ent = NULL;
if (!f)
return NULL;
if (f->ent.dir)
mvdown(f, f->ent.name);
for(;;) {
ent = readdir(f->dirs[f->depth]);
if (ent) {
if (isrefdir(ent))
continue;
break;
}
if (errno) {
perror("fsc_read");
errno = 0;
continue;
}
if (mvup(f))
continue;
fsc_close(f);
return NULL;
}
f->ent.base = f->path.buf;
f->ent.name = &ent->d_name[0];
f->ent.dir = ent->d_type == 4;
return &f->ent;
}

30
src/notify/fscrawl.h Normal file
View file

@ -0,0 +1,30 @@
/* notify/fscrawl.h - Filesystem traversal
*
* (C) Copyright 2010 Henrik Hautakoski <henrik@fiktivkod.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*/
#ifndef __NOTIFY_FSCRAWL_H
#define __NOTIFY_FSCRAWL_H
typedef struct {
char *name;
char *base;
unsigned char dir;
} fs_entry;
typedef struct __fscrawl *fscrawl_t;
fscrawl_t fsc_open(const char *path);
void fsc_close(fscrawl_t f);
fs_entry* fsc_cpy(fs_entry *ent);
fs_entry* fsc_read(fscrawl_t f);
#endif /* __NOTIFY_FSCRAWL_H */

193
src/notify/tree.c
View file

@ -1,193 +0,0 @@
/* notify/tree.c - Filesystem traversal
*
* (C) Copyright 2010 Henrik Hautakoski <henrik@fiktivkod.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*/
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <malloc.h>
#include <errno.h>
#include <dirent.h>
#include "../common/path.h"
#include "tree.h"
#if 0
#define pdebug(...) fprintf(stderr, __VA_ARGS__)
#else
#define pdebug(...) 0
#endif
#define isrefdir(x) (!strcmp(x->d_name, ".") || !strcmp(x->d_name, ".."))
/* REF:1 */
static int have_perm(const char *base, const char *name) {
char buf[1024];
sprintf(buf, "%s%s", base, name);
return access(buf, R_OK | X_OK) == 0;
}
struct tree* tree_new(const char *path) {
int i;
struct tree *t = malloc(sizeof(struct tree));
if (t == NULL)
return NULL;
t->path = path_normalize(path, NULL, 0);
if (t->path == NULL) {
free(t);
return NULL;
}
t->depth = 0;
t->dirs[0] = opendir(t->path);
if (!t->dirs[0]) {
free(t->path);
free(t);
return NULL;
}
t->ent.name = NULL;
t->ent.base = NULL;
t->ent.dir = 0;
return t;
}
void tree_del(struct tree *tree) {
int i;
for(i=0; i < tree->depth; i++)
closedir(tree->dirs[i]);
if (tree->path != NULL)
free(tree->path);
free(tree);
}
/* REF:1 */
int tree_mvup(struct tree *tree) {
char *slash;
if (closedir(tree->dirs[tree->depth]) == -1) {
perror("TREE");
return -1;
}
if (tree->depth == 0)
return 0;
#if __DEBUG__
printf("tree_next_ent: tree depth is: %i \n", tree->depth);
#endif
tree->depth--;
slash = tree->path + strlen(tree->path)-1;
if (*slash == '/')
*slash = 0;
slash = strrchr(tree->path, '/');
*(slash+1) = 0;
tree->path = realloc(tree->path, sizeof(char) * (strlen(tree->path)+1));
return 1;
}
/* REF:1 */
int tree_mvdown(struct tree *tree, const char *dir) {
char buf[PATH_MAX];
DIR *ds;
if (tree->depth >= MAX_DEPTH-1)
return 0;
sprintf(buf, "%s%s/\0", tree->path, dir);
if ((ds = opendir(buf)) == NULL) {
if (errno != EACCES)
perror("DIROPEN");
return 0;
}
tree->path = realloc(tree->path, sizeof(char) * (strlen(buf)+1));
memcpy(tree->path, buf, strlen(buf)+1);
tree->dirs[++tree->depth] = ds;
return 1;
}
struct entry* tree_cpy_ent(struct entry *ent) {
struct entry *ptr = malloc(sizeof(struct entry));
if (ptr == NULL)
return NULL;
memcpy(ptr, ent, sizeof(struct entry));
return ptr;
}
/*
* NOTE: only read from the struct returned and DO NOT free it.
* use tree_cpy_ent() if you need to store it.
*/
struct entry* tree_next_ent(struct tree *tree) {
struct dirent *ent = NULL;
if (tree == NULL)
return NULL;
if (tree->ent.dir)
tree_mvdown(tree, tree->ent.name);
for(;;) {
ent = readdir(tree->dirs[tree->depth]);
if (ent == NULL) {
if (tree_mvup(tree))
continue;
tree_del(tree);
return NULL;
} else if (isrefdir(ent)) {
continue;
} else if (ent->d_type == 4) {
if (have_perm(tree->path, ent->d_name))
break;
} else {
break;
}
}
tree->ent.dir = ent->d_type == 4;
tree->ent.base = tree->path;
tree->ent.name = &ent->d_name[0];
return &tree->ent;
}

42
src/notify/tree.h
View file

@ -1,42 +0,0 @@
/* notify/tree.h - Filesystem traversal
*
* (C) Copyright 2010 Henrik Hautakoski <henrik@fiktivkod.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*/
#ifndef __NOTIFY_TREE_H
#define __NOTIFY_TREE_H
#define MAX_DEPTH 0x20
#include <dirent.h>
struct tree {
char *path;
DIR *dirs[MAX_DEPTH];
unsigned char depth;
/* REF:2 */
struct entry {
char *name;
char *base;
unsigned char dir;
} ent;
};
struct tree* tree_new(const char *path);
void tree_del(struct tree *tree);
int tree_mvup(struct tree *tree);
int tree_mvdown(struct tree *tree, const char *dir);
struct entry* tree_cpy_ent(struct entry *ent);
struct entry* tree_next_ent(struct tree *tree);
#endif /* __NOTIFY_TREE_H */