← Back to branch summary

~ubuntu-branches/debian/jessie/arcboot/jessie

« back to all changes in this revision

Viewing changes to e2fslib/dir_iterate.c

  • Committer: Bazaar Package Importer
  • Author(s): Guido Guenther
  • Date: 2004-03-02 12:01:14 UTC
  • Revision ID: james.westby@ubuntu.com-20040302120114-0pukal9hlpt3k0l7
Tags: 0.3.8.1
correct subarch detection for IP32

Show diffs side-by-side

added added

removed removed

Lines of Context:
e2fslib/dir_iterate.c
 
1
/*
 
2
 * dir_iterate.c --- ext2fs directory iteration operations
 
3
 * 
 
4
 * Copyright (C) 1993, 1994, 1994, 1995, 1996, 1997 Theodore Ts'o.
 
5
 *
 
6
 * %Begin-Header%
 
7
 * This file may be redistributed under the terms of the GNU Public
 
8
 * License.
 
9
 * %End-Header%
 
10
 */
 
11
 
 
12
#include <stdio.h>
 
13
#include <string.h>
 
14
#if HAVE_UNISTD_H
 
15
#include <unistd.h>
 
16
#endif
 
17
#if HAVE_ERRNO_H
 
18
#include <errno.h>
 
19
#endif
 
20
 
 
21
#include "ext2_fs.h"
 
22
#include "ext2fsP.h"
 
23
 
 
24
errcode_t ext2fs_dir_iterate(ext2_filsys fs,
 
25
                             ext2_ino_t dir,
 
26
                             int flags,
 
27
                             char *block_buf,
 
28
                             int (*func)(struct ext2_dir_entry *dirent,
 
29
                                         int    offset,
 
30
                                         int    blocksize,
 
31
                                         char   *buf,
 
32
                                         void   *priv_data),
 
33
                             void *priv_data)
 
34
{
 
35
        struct          dir_context     ctx;
 
36
        errcode_t       retval;
 
37
        
 
38
        EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
 
39
 
 
40
        retval = ext2fs_check_directory(fs, dir);
 
41
        if (retval)
 
42
                return retval;
 
43
        
 
44
        ctx.dir = dir;
 
45
        ctx.flags = flags;
 
46
        if (block_buf)
 
47
                ctx.buf = block_buf;
 
48
        else {
 
49
                retval = ext2fs_get_mem(fs->blocksize, (void **) &ctx.buf);
 
50
                if (retval)
 
51
                        return retval;
 
52
        }
 
53
        ctx.func = func;
 
54
        ctx.func2 = 0;
 
55
        ctx.priv_data = priv_data;
 
56
        ctx.errcode = 0;
 
57
        retval = ext2fs_block_iterate2(fs, dir, 0, 0,
 
58
                                       ext2fs_process_dir_block, &ctx);
 
59
        if (!block_buf)
 
60
                ext2fs_free_mem((void **) &ctx.buf);
 
61
        if (retval)
 
62
                return retval;
 
63
        return ctx.errcode;
 
64
}
 
65
 
 
66
/*
 
67
 * Helper function which is private to this module.  Used by
 
68
 * ext2fs_dir_iterate() and ext2fs_dblist_dir_iterate()
 
69
 */
 
70
int ext2fs_process_dir_block(ext2_filsys        fs,
 
71
                             blk_t              *blocknr,
 
72
                             e2_blkcnt_t                blockcnt,
 
73
                             blk_t              ref_block,
 
74
                             int                        ref_offset,
 
75
                             void               *priv_data)
 
76
{
 
77
        struct dir_context *ctx = (struct dir_context *) priv_data;
 
78
        int             offset = 0;
 
79
        int             ret = 0;
 
80
        int             changed = 0;
 
81
        int             do_abort = 0;
 
82
        int             entry;
 
83
        struct ext2_dir_entry *dirent;
 
84
 
 
85
        if (blockcnt < 0)
 
86
                return 0;
 
87
 
 
88
        entry = blockcnt ? DIRENT_OTHER_FILE : DIRENT_DOT_FILE;
 
89
        
 
90
        ctx->errcode = ext2fs_read_dir_block(fs, *blocknr, ctx->buf);
 
91
        if (ctx->errcode)
 
92
                return BLOCK_ABORT;
 
93
 
 
94
        while (offset < fs->blocksize) {
 
95
                dirent = (struct ext2_dir_entry *) (ctx->buf + offset);
 
96
                if (((offset + dirent->rec_len) > fs->blocksize) ||
 
97
                    (dirent->rec_len < 8) ||
 
98
                    ((dirent->rec_len % 4) != 0) ||
 
99
                    (((dirent->name_len & 0xFF)+8) > dirent->rec_len)) {
 
100
                        ctx->errcode = EXT2_ET_DIR_CORRUPTED;
 
101
                        return BLOCK_ABORT;
 
102
                }
 
103
                if (!dirent->inode &&
 
104
                    !(ctx->flags & DIRENT_FLAG_INCLUDE_EMPTY))
 
105
                        goto next;
 
106
 
 
107
                if (ctx->func)
 
108
                        ret = (ctx->func)(dirent, offset, fs->blocksize,
 
109
                                          ctx->buf, ctx->priv_data);
 
110
                else if (ctx->func2) {
 
111
                        ret = (ctx->func2)(ctx->dir, entry, dirent, offset,
 
112
                                           fs->blocksize, ctx->buf,
 
113
                                           ctx->priv_data);
 
114
                        if (entry < DIRENT_OTHER_FILE)
 
115
                                entry++;
 
116
                }
 
117
                        
 
118
                if (ret & DIRENT_CHANGED)
 
119
                        changed++;
 
120
                if (ret & DIRENT_ABORT) {
 
121
                        do_abort++;
 
122
                        break;
 
123
                }
 
124
next:           
 
125
                offset += dirent->rec_len;
 
126
        }
 
127
 
 
128
        if (changed) {
 
129
                ctx->errcode = ext2fs_write_dir_block(fs, *blocknr, ctx->buf);
 
130
                if (ctx->errcode)
 
131
                        return BLOCK_ABORT;
 
132
        }
 
133
        if (do_abort)
 
134
                return BLOCK_ABORT;
 
135
        return 0;
 
136
}
 
137