static int os2_delete(DIR *d)
{
off_t offsets[READDIR_SIZE];
int i, j;
struct dirent *de;
char names[READDIR_SIZE][30];
/* scan, remembering offsets */
for (i=0, de=readdir(d);
de && i < READDIR_SIZE;
de=readdir(d), i++) {
offsets[i] = telldir(d);
strcpy(names[i], de->d_name);
}
if (i == 0) {
return 0;
}
/* delete the first few */
for (j=0; j<MIN(i, DELETE_SIZE); j++) {
char fname[40];
sprintf(fname, TESTDIR "/%s", names[j]);
unlink(fname) == 0 || FAILED("unlink");
}
/* seek to just after the deletion */
seekdir(d, offsets[j-1]);
/* return number deleted */
return j;
}
void seekdir_test(void)
{
DIR * dirp;
long save3 = 0;
long cur;
int i = 0;
struct dirent *dp;
dirp = opendir ("/");
save3 = telldir(dirp);
for (dp = readdir(dirp); dp != RT_NULL; dp = readdir(dirp))
{
rt_kprintf("direntry: %s\n", dp->d_name);
/* 保存第三个目录项的目录指针 */
if (i++ == 3)
{
save3 = telldir(dirp);
}
}
/* 回到刚才保存的第三个目录项的目录指针 */
seekdir (dirp, save3);
rt_kprintf("seek dientry to: %d\n", save3);
for (dp = readdir(dirp); dp != RT_NULL; dp = readdir(dirp))
{
rt_kprintf("direntry: %s\n", dp->d_name);
}
/* 关闭目录 */
closedir (dirp);
}
void SeekTest (void)
{
int num_children = 10;
dir_s dir = NilDir;
DIR *d;
struct dirent *entry;
int i;
dir.name = RndName();
mkdir(dir.name, 0777);
AddChildren(&dir, num_children);
d = opendir(dir.name);
while ((entry = readdir(d)) != NULL) {
SaveTell(d, entry, &dir);
}
for (i = 0; i < 27; i++) {
int k = urand(num_children);
file_s *file = &dir.file[k];
seekdir(d, file->tell);
entry = readdir(d);
if (strcmp(entry->d_name, file->name) != 0) {
PrError("Seekdir failed. Looking for %s found %s",
entry->d_name, file->name);
}
}
closedir(d);
DeleteChildren(&dir);
rmdir(dir.name);
free(dir.name);
}
static int pifs_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *info)
{
DIR *dir = (DIR *) info->fh;
if (offset) {
seekdir(dir, offset);
}
int ret;
do {
errno = 0;
struct dirent *de = readdir(dir);
if (!de) {
if (errno) {
return -errno;
} else {
break;
}
}
ret = filler(buf, de->d_name, NULL, de->d_off);
} while (ret == 0);
return 0;
}
int GetConsecutiveFileCount(const char * dir, const char *nameTag, int maxS){
DIR *dirp;
struct dirent *dent;
dirp = opendir(dir);
if (!dirp)
return 0;
int res = 0;
for(int i=0;i<maxS;i++){
char cName[256];
sprintf(cName,nameTag,i);
bool bFound = false;
seekdir(dirp,0);
while ((dent = readdir(dirp)) != NULL)
{
if(strcmp(cName,dent->d_name)==0){
bFound = true;
break;
}
}
if(bFound){
res = i+1;
}else{
break;
}
}
closedir(dirp);
return res;
}
/*
* Read the directory entries and return the information about
* each entry
*/
int
fs_readdir(fs_fhandle_t *ts_fh, char *path, long *dpos,
char *nm, int *el, fs_fhandle_t *efh, struct stat64 *est)
{
struct dirent *dp;
char file_path[PATH_MAX + 1];
DIR *dirp;
int rv;
if ((dirp = opendir(ts_fh->fh_fpath)) == NULL)
return (errno);
seekdir(dirp, *dpos);
if ((dp = readdir(dirp)) == NULL) {
rv = 0; /* skip this dir */
*el = 0;
} else {
(void) snprintf(file_path, PATH_MAX, "%s/", path);
(void) strlcat(file_path, dp->d_name, PATH_MAX + 1);
rv = fs_getstat(file_path, efh, est);
if (rv == 0) {
*dpos = telldir(dirp);
(void) strlcpy(nm, dp->d_name, NAME_MAX + 1);
*el = strlen(dp->d_name);
} else {
*el = 0;
}
}
(void) closedir(dirp);
return (rv);
}
void
loop(DIR *dp, int i)
{
struct dirent *f;
char file[PATH_MAX];
long pos, remember = -1;
rewinddir(dp);
snprintf(file, sizeof file, "%d", i);
for (;;) {
pos = telldir(dp);
f = readdir(dp);
if (f == NULL)
break;
if (strcmp(file, f->d_name) == 0)
remember = pos;
}
if (remember == -1)
errx(1, "remember");
seekdir(dp, remember);
if (telldir(dp) != remember)
errx(1, "tell after seek");
if (telldir(dp) != remember)
errx(1, "tell after tell");
f = readdir(dp);
if (f == NULL)
err(1, "seek to %s %ld", file, remember);
if (strcmp(f->d_name, file) != 0)
err(1, "name mismatch: %s != %s\n", f->d_name, file);
}
static int xmp_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
struct xmp_dirp *d = get_dirp(fi);
(void) path;
if (offset != d->offset) {
seekdir(d->dp, offset);
d->entry = NULL;
d->offset = offset;
}
while (1) {
struct stat st;
off_t nextoff;
if (!d->entry) {
d->entry = readdir(d->dp);
if (!d->entry)
break;
}
memset(&st, 0, sizeof(st));
st.st_ino = d->entry->d_ino;
st.st_mode = d->entry->d_type << 12;
nextoff = telldir(d->dp);
if (filler(buf, d->entry->d_name, &st, nextoff))
break;
d->entry = NULL;
d->offset = nextoff;
}
return 0;
}
int BuscaArchivosDirectorio(int id,char szPath[],char szFile[])
{
struct dirent *dirent=NULL;
off_t i;
DIR *dir =Conexion[id].directorio;
if (dir==NULL)
{
//printf("Opendir\n\r");
dir = opendir(szPath);
}
if (!dir)
{
printf("Directorio invalido\n\r");
dir=NULL;
Conexion[id].directorio=dir;
return -1;
}
else
{
//printf("read dir\n\r");
dirent=readdir(dir);
if (!dirent)
{
//printf("close dir\n\r");
closedir(dir);
dir=NULL;
Conexion[id].directorio=dir;
return -1;
}
//Si son archivos especiales...
//printf("%s\n\r",dirent->d_name);
if ((memcmp(dirent->d_name,".",1)==0) ||
(memcmp(dirent->d_name,"..",2)==0))
{
seekdir(dir,telldir(dir));
Conexion[id].directorio=dir;
return -1;
}
seekdir(dir,telldir(dir));
Conexion[id].directorio=dir;
sprintf(szFile,"%s/%s",szPath,dirent->d_name);
printf("File %s\n\r",szFile);
return 1;
}
}
static int SeekDir (lua_State * L)
{
DIR * dir = D(L);
if (dir != 0 && lua_isnumber(L, 2)) seekdir(dir, LI(L, 2));
return 0;
}
/*******************************************************************
Seek a dir.
********************************************************************/
BOOL get_dirent_seekdir(PDENT_HND hnd, int pos)
{
struct dirent_state *dirp;
dirp = (struct dirent_state*)get_policy_state_info(hnd);
if (dirp == NULL || dirp->dir == NULL) return(False);
seekdir(dirp->dir, pos);
return True;
}
/*--------------------------------------------------------------------
* seek FLOAT
*/
static void readdir_seek(t_readdir *x, t_floatarg pos)
{
if (!x->x_dir) {
pd_error(x, "readdir: seek %g: no directory opened!", pos);
return;
}
seekdir(x->x_dir, (off_t)pos);
}
TEST(dirent, seekdir_telldir) {
DIR* d = opendir("/proc/self");
ASSERT_TRUE(d != NULL);
std::vector<long> offset_list;
std::vector<std::string> name_list;
dirent* e = NULL;
offset_list.push_back(telldir(d));
ASSERT_EQ(0L, offset_list.back());
while ((e = readdir(d)) != NULL) {
name_list.push_back(e->d_name);
offset_list.push_back(telldir(d));
// Make sure telldir() point to the next entry.
ASSERT_EQ(e->d_off, offset_list.back());
}
long end_offset = telldir(d);
// telldir() should not pass the end of the file.
ASSERT_EQ(offset_list.back(), end_offset);
offset_list.pop_back();
for (size_t i = 0; i < offset_list.size(); ++i) {
seekdir(d, offset_list[i]);
ASSERT_EQ(offset_list[i], telldir(d));
e = readdir(d);
ASSERT_TRUE(e != NULL);
ASSERT_STREQ(name_list[i].c_str(), e->d_name);
}
for (int i = static_cast<int>(offset_list.size()) - 1; i >= 0; --i) {
seekdir(d, offset_list[i]);
ASSERT_EQ(offset_list[i], telldir(d));
e = readdir(d);
ASSERT_TRUE(e != NULL);
ASSERT_STREQ(name_list[i].c_str(), e->d_name);
}
// Seek to the end, read NULL.
seekdir(d, end_offset);
ASSERT_EQ(end_offset, telldir(d));
errno = 0;
ASSERT_EQ(NULL, readdir(d));
ASSERT_EQ(0, errno);
ASSERT_EQ(0, closedir(d));
}
void
dir_node_rewind ( dir_node* node ) {
if ( !empty_dir_node(node) ) {
DIR* dirp = node->dir_ptr;
assert(dirp);
assert(node->loc != 0);
seekdir(dirp, node->loc);
}
}
G_BEGIN_DECLS
gint32
Mono_Posix_Syscall_seekdir (void *dir, mph_off_t offset)
{
mph_return_if_off_t_overflow (offset);
seekdir ((DIR*) dir, (off_t) offset);
return 0;
}
int
run_dir_tests (char *testpath)
{
int ret = -1;
DIR *dh = NULL;
struct dirent *dire = NULL;
assert (testpath);
fprintf (stdout, "Testing mkdir");
ret = mkdir (testpath, 0);
check_err (ret, "mkdir", 2);
fprintf (stdout, "Testing rmdir");
ret = rmdir (testpath);
check_err (ret, "rmdir", 2);
fprintf (stdout, "Testing opendir");
ret = 0;
dh = opendir (testpath);
if (!dh)
ret = -1;
check_err (ret, "opendir", 2);
fprintf (stdout, "Testing readdir");
ret = 0;
dire = readdir (dh);
if (!dire)
ret = -1;
check_err (ret, "readdir", 1);
fprintf (stdout, "Testing readdir_r");
ret = readdir_r (dh, dire, &dire);
check_err (ret, "readdir_r", 1);
fprintf (stdout, "Testing rewinddir");
rewinddir (dh);
check_err (-1, "rewinddir", 1);
fprintf (stdout, "Testing seekdir");
seekdir (dh, 0);
check_err (-1, "seekdir", 2);
fprintf (stdout, "Testing telldir");
ret = telldir (dh);
check_err (ret, "telldir", 2);
fprintf (stdout, "Testing closedir");
ret = closedir (dh);
check_err (ret, "closedir", 2);
return 0;
}
int main(int argc, char **argv) {
struct stat s;
char first[256], second[256];
DIR *d = opendir(".");
struct dirent *de = readdir(d);
assert(de);
strcpy(first, de->d_name);
off_t pos = telldir(d);
printf("pos: %d\n", telldir(d));
de = readdir(d);
assert(de);
strcpy(second, de->d_name);
// Go back to second and check
seekdir(d, pos);
de = readdir(d);
assert(de);
assert(strcmp(de->d_name, second) == 0);
// Go to end, then back to 2nd
while (de)
de = readdir(d);
assert(!errno);
seekdir(d, pos);
assert(telldir(d) == pos);
de = readdir(d);
assert(de);
assert(strcmp(de->d_name, second) == 0);
// Go to beginning and check
rewinddir(d);
de = readdir(d);
assert(de);
assert(strcmp(de->d_name, first) == 0);
closedir(d);
return 0;
}
void traverse(char const *dir)
{
char name[PATH_MAX];
DIR *d;
struct dirent *dd;
off_t o;
struct stat s;
char *delim = "/";
/* если в качестве каталога передан корневой каталог,
* разделитель не нужен */
if (!strcmp(dir, "/")) delim = "";
/* открываем каталог */
if (!(d = opendir(dir))) {
/* не смогли открыть */
perror(dir);
return;
}
/* считываем, пока dd не равен NULL, то есть
* пока есть записи в каталоге */
while ((dd = readdir(d))) {
/* пропускаем . и .. */
if (!strcmp(dd->d_name, ".") || !strcmp(dd->d_name, ".."))
continue;
/* формируем полный путь */
snprintf(name, PATH_MAX, "%s%s%s", dir, delim, dd->d_name);
/* получаем информацию о файле
* используем lstat, чтобы не зациклиться на символических
* связях */
if (lstat(name, &s) < 0) continue;
/* проверяем, что это каталог */
if (S_ISDIR(s.st_mode)) {
/* запоминаем текущее положение в каталоге */
o = telldir(d);
/* экономим файловые дескрипторы */
closedir(d);
/* вызываем себя рекурсивно */
traverse(name);
/* восстанавливаем старое положение */
if (!(d = opendir(dir))) {
perror(dir);
return;
}
seekdir(d, o);
} else {
/* печатаем путь */
printf("%s\n", name);
}
}
closedir(d);
}
/*
* call-seq:
* dir.seek( integer ) => dir
*
* Seeks to a particular location in <em>dir</em>. <i>integer</i>
* must be a value returned by <code>Dir#tell</code>.
*
* d = Dir.new("testdir") #=> #<Dir:0x401b3c40>
* d.read #=> "."
* i = d.tell #=> 12
* d.read #=> ".."
* d.seek(i) #=> #<Dir:0x401b3c40>
* d.read #=> ".."
*/
static VALUE
dir_seek(VALUE dir, VALUE pos)
{
struct dir_data *dirp;
off_t p = NUM2OFFT(pos);
GetDIR(dir, dirp);
#ifdef HAVE_SEEKDIR
seekdir(dirp->dir, p);
return dir;
#else
rb_notimplement();
#endif
}
char *read_dir(void *stream, unsigned long long *pos,
unsigned long long *ino_out, int *len_out)
{
DIR *dir = stream;
struct dirent *ent;
seekdir(dir, *pos);
ent = readdir(dir);
if(ent == NULL) return(NULL);
*len_out = strlen(ent->d_name);
*ino_out = ent->d_ino;
*pos = telldir(dir);
return(ent->d_name);
}
/* FIXME: seekdir(previous d_off) OK?
* If not, substitute saved_dir_position for d_off in last returned.
* If so, get rid of saved_dir_position and 2nd seekdir.
*/
static u32
_read_dir_linux (Fid *f, u8* buf, u64 offset, u32 count)
{
int i, n = 0;
off_t saved_dir_pos;
if (offset == 0)
rewinddir (f->dir);
else
seekdir (f->dir, offset);
do {
saved_dir_pos = telldir (f->dir);
if (!(f->dirent = readdir (f->dir))) /* FIXME: use readdir_r */
break;
i = _copy_dirent_linux (f, buf + n, count - n);
if (i == 0) {
seekdir (f->dir, saved_dir_pos);
break;
}
n += i;
} while (n < count);
return n;
}
/* LVM support - Kirby Bohling */
static void
uuidcache_init_lvm(void) {
char buffer[PATH_MAX];
char lvm_device[PATH_MAX];
DIR *vg_dir, *lv_list;
struct dirent *vg_iter, *lv_iter;
char uuid[16], *label;
vg_dir = opendir(VG_DIR);
if (vg_dir == NULL) /* to be expected */
return;
seekdir(vg_dir, 2);
while ((vg_iter = readdir(vg_dir)) != 0) {
sprintf(buffer, "%s/%s/LVs", VG_DIR, vg_iter->d_name);
lv_list = opendir(buffer);
if (lv_list == NULL) {
perror("uuidcache_init_lvm");
continue;
}
seekdir(lv_list, 2);
while ((lv_iter = readdir(lv_list)) != 0) {
/* Now we have the file.. could open it and read out
* where the device is, read the first line, second
* field... Instead we guess.
*/
sprintf(lvm_device, "%s/%s/%s", DEVLABELDIR,
vg_iter->d_name, lv_iter->d_name);
if (!get_label_uuid(lvm_device, &label, uuid))
uuidcache_addentry(xstrdup(lvm_device),
label, uuid);
}
closedir(lv_list);
}
closedir(vg_dir);
}
Object* Dir::control(STATE, Fixnum* kind, Integer* pos) {
guard(state);
switch(kind->to_native()) {
case 0:
seekdir(os(), pos->to_native());
return cTrue;
case 1:
rewinddir(os());
return cTrue;
case 2:
return Integer::from(state, telldir(os()));
}
return cNil;
}
s32 sal_DirectoryGet(const char *path, struct SAL_DIRECTORY_ENTRY *dir,
s32 startIndex, s32 count)
{
s32 fileCount=0;
DIR *d;
struct dirent *de;
uint32_t entriesRead=0;
char fullFilename[256];
s32 endIndex=startIndex+count;
long loc;
d = opendir(path);
if (d)
{
loc=telldir(d);
seekdir(d,loc+startIndex);
while ((de = readdir(d)))
{
if(startIndex >= endIndex)
{
//exit loop
break;
}
//Is entry a file or directory
if (de->d_type == 4) // Directory
{
strcpy(dir[fileCount].filename,de->d_name);
strcpy(dir[fileCount].displayName,de->d_name);
dir[fileCount].type=SAL_FILE_TYPE_DIRECTORY;
}
else
{
//File
strcpy(dir[fileCount].filename,de->d_name);
strcpy(dir[fileCount].displayName,de->d_name);
dir[fileCount].type=SAL_FILE_TYPE_FILE;
}
fileCount++;
startIndex++;
}
closedir(d);
}
return SAL_ERROR;
// return SAL_OK;
}
static int unspillfds(struct nftw *state, char *truncatep)
{
struct directory *d;
char ch;
ch = *truncatep, *truncatep = '\0';
(d = state->dirs)->dir = opendir(state->pathname);
*truncatep = ch;
if (d->dir != NULL) {
--state->limit;
seekdir(d->dir, d->posn);
dircntl(d->dir, D_SETFLAG, dircntl(d->dir, D_GETFLAG) | D_FLAG_STAT);
return(0);
}
state->error = errno;
return(-1);
}
int libc_dirent()
{
DIR * dirp;
long int save3 = 0;
long int cur;
int i = 0;
int result = 0;
struct dirent *dp;
dirp = opendir("/");
for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp))
{
/* save position 3 (after fourth entry) */
if (i++ == 3)
save3 = telldir(dirp);
printf("%s\n", dp->d_name);
/* stop at 400 (just to make sure dirp->__offset and dirp->__size are
scrambled */
if (i == 400)
break;
}
printf("going back past 4-th entry...\n");
/* go back to saved entry */
seekdir(dirp, save3);
/* Check whether telldir equals to save3 now. */
cur = telldir(dirp);
if (cur != save3)
{
printf("seekdir (d, %ld); telldir (d) == %ld\n", save3, cur);
result = 1;
}
/* print remaining files (3-last) */
for (dp = readdir(dirp); dp != NULL; dp = readdir(dirp))
printf("%s\n", dp->d_name);
closedir(dirp);
return result;
}
int main (int argc, char *argv[])
{
if (argc == 1) {
argv[1] = ".";
}
printf("opened %s\n", argv[1]);
DIR *d = opendir(argv[1]);
struct dirent *e = NULL, se;
long int pos = 0;
int i = 0;
do {
if (i == 3) {
pos = telldir(d);
}
e = readdir(d);
if (i == 3) {
if (e)
se = *e;
else
pos = 0;
}
i++;
} while (e);
if (pos) {
seekdir(d, pos);
e = readdir(d);
if (e) {
if (se.d_fileno != e->d_fileno ||
strcmp(se.d_name, e->d_name) != 0) {
printf("seekdir -> readdir FAILED\n");
} else {
printf("OK\n");
}
} else
printf("seekdir FAILED!\n");
}
closedir(d);
return 0;
}
int *get_fds(pid_t pid)
{
const char *fd_path_mode="/proc/%d/fd";
char buf[32];
DIR *dp;
struct dirent dirent_buf,*dirent_p=NULL;
int *ret=NULL;
int cnt=0,i=0;
sprintf(buf,fd_path_mode,pid);
if((dp=opendir(buf))==NULL)
{
perr("Open %s error\n%s",buf,strerror(errno));
return NULL;
}
while(1)
{
if(readdir_r(dp,&dirent_buf,&dirent_p)<0)
{perr("%s",strerror(errno));closedir(dp);return NULL;}
if(!dirent_p)
break;
if(strcmp(dirent_p->d_name,".")&&strcmp(dirent_p->d_name,".."))
cnt++;
}
if((ret=malloc((cnt+1)*sizeof(int)))==NULL)
{
perr("%s",strerror(errno));closedir(dp);return NULL;
}
while(i<=cnt)
ret[i++]=-1;
seekdir(dp,0);
i=0;
while(i!=cnt)
{
if(readdir_r(dp,&dirent_buf,&dirent_p)<0)
{perr("%s",strerror(errno));closedir(dp);return NULL;}
if(!dirent_p)
break;
if(strcmp(dirent_p->d_name,".")&&strcmp(dirent_p->d_name,".."))
ret[i++]=atoi(dirent_p->d_name);
}
closedir(dp);
return ret;
}
static int pr_readdir(const char* path, void* buf, fuse_fill_dir_t filler,off_t offset,struct fuse_file_info* fi)
{
int res = 0;
struct stat st;
struct dirent* de;
DIR* dp = get_dirp(fi);
(void)path;
seekdir(dp,offset);
while((de = readdir(dp)) != NULL)
{
struct stat st;
memset(&st,0,sizeof(st));
st.st_ino = de->d_ino;
st.st_mode = de->d_type << 12;
if(filler(buf,de->d_name,&st,telldir(dp)))
break;
}
return res;
}
int main()
{
const char *filePath = "ndk";
DIR *directory = opendir(filePath);
struct dirent *p;
long dir_pos;
while ((p = readdir(directory)) != NULL) {
char *name = p->d_name;
if ((strcmp(name, ".") == 0) || (strcmp(name, "..") == 0)) continue;
if (strcmp(name, "obj") == 0) {
// record current dir point's position.
dir_pos = telldir(directory);
}
printf("File-ino: %ld\n", p->d_ino);
printf("File-off: %ld\n", p->d_off);
printf("File-reclen: %u\n", p->d_reclen);
printFileType(p->d_type);
printf("File-name: %s\n", name);
printf("------------------------------------------\n");
}
// Move dir pointer position to "obj"
seekdir(directory, dir_pos);
while ((p = readdir(directory)) != NULL) {
char *name = p->d_name;
if ((strcmp(name, ".") == 0) || (strcmp(name, "..") == 0)) continue;
if (strcmp(name, "obj") == 0) {
dir_pos = telldir(directory);
}
printf("File-ino: %ld\n", p->d_ino);
printf("File-off: %ld\n", p->d_off);
printf("File-reclen: %u\n", p->d_reclen);
printFileType(p->d_type);
printf("File-name: %s\n", name);
printf("------------------------------------------\n");
}
closedir(directory);
return 0;
}
