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