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 Library 8 * General Public License, version 2. 9 * %End-Header% 10 */ 11 12 #include "config.h" 13 #include <stdio.h> 14 #include <string.h> 15 #if HAVE_UNISTD_H 16 #include <unistd.h> 17 #endif 18 #if HAVE_ERRNO_H 19 #include <errno.h> 20 #endif 21 22 #include "ext2_fs.h" 23 #include "ext2fsP.h" 24 25 #define EXT4_MAX_REC_LEN ((1<<16)-1) 26 27 errcode_t ext2fs_get_rec_len(ext2_filsys fs, 28 struct ext2_dir_entry *dirent, 29 unsigned int *rec_len) 30 { 31 unsigned int len = dirent->rec_len; 32 33 if (fs->blocksize < 65536) 34 *rec_len = len; 35 else if (len == EXT4_MAX_REC_LEN || len == 0) 36 *rec_len = fs->blocksize; 37 else 38 *rec_len = (len & 65532) | ((len & 3) << 16); 39 return 0; 40 } 41 42 errcode_t ext2fs_set_rec_len(ext2_filsys fs, 43 unsigned int len, 44 struct ext2_dir_entry *dirent) 45 { 46 if ((len > fs->blocksize) || (fs->blocksize > (1 << 18)) || (len & 3)) 47 return EINVAL; 48 if (len < 65536) { 49 dirent->rec_len = len; 50 return 0; 51 } 52 if (len == fs->blocksize) { 53 if (fs->blocksize == 65536) 54 dirent->rec_len = EXT4_MAX_REC_LEN; 55 else 56 dirent->rec_len = 0; 57 } else 58 dirent->rec_len = (len & 65532) | ((len >> 16) & 3); 59 return 0; 60 } 61 62 /* 63 * This function checks to see whether or not a potential deleted 64 * directory entry looks valid. What we do is check the deleted entry 65 * and each successive entry to make sure that they all look valid and 66 * that the last deleted entry ends at the beginning of the next 67 * undeleted entry. Returns 1 if the deleted entry looks valid, zero 68 * if not valid. 69 */ 70 static int ext2fs_validate_entry(ext2_filsys fs, char *buf, 71 unsigned int offset, 72 unsigned int final_offset) 73 { 74 struct ext2_dir_entry *dirent; 75 unsigned int rec_len; 76 #define DIRENT_MIN_LENGTH 12 77 78 while ((offset < final_offset) && 79 (offset <= fs->blocksize - DIRENT_MIN_LENGTH)) { 80 dirent = (struct ext2_dir_entry *)(buf + offset); 81 if (ext2fs_get_rec_len(fs, dirent, &rec_len)) 82 return 0; 83 offset += rec_len; 84 if ((rec_len < 8) || 85 ((rec_len % 4) != 0) || 86 ((ext2fs_dirent_name_len(dirent)+8) > (int) rec_len)) 87 return 0; 88 } 89 return (offset == final_offset); 90 } 91 92 errcode_t ext2fs_dir_iterate2(ext2_filsys fs, 93 ext2_ino_t dir, 94 int flags, 95 char *block_buf, 96 int (*func)(ext2_ino_t dir, 97 int entry, 98 struct ext2_dir_entry *dirent, 99 int offset, 100 int blocksize, 101 char *buf, 102 void *priv_data), 103 void *priv_data) 104 { 105 struct dir_context ctx; 106 errcode_t retval; 107 108 EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); 109 110 retval = ext2fs_check_directory(fs, dir); 111 if (retval) 112 return retval; 113 114 ctx.dir = dir; 115 ctx.flags = flags; 116 if (block_buf) 117 ctx.buf = block_buf; 118 else { 119 retval = ext2fs_get_mem(fs->blocksize, &ctx.buf); 120 if (retval) 121 return retval; 122 } 123 ctx.func = func; 124 ctx.priv_data = priv_data; 125 ctx.errcode = 0; 126 retval = ext2fs_block_iterate3(fs, dir, BLOCK_FLAG_READ_ONLY, 0, 127 ext2fs_process_dir_block, &ctx); 128 if (!block_buf) 129 ext2fs_free_mem(&ctx.buf); 130 if (retval == EXT2_ET_INLINE_DATA_CANT_ITERATE) { 131 (void) ext2fs_inline_data_dir_iterate(fs, dir, &ctx); 132 retval = 0; 133 } 134 if (retval) 135 return retval; 136 return ctx.errcode; 137 } 138 139 struct xlate { 140 int (*func)(struct ext2_dir_entry *dirent, 141 int offset, 142 int blocksize, 143 char *buf, 144 void *priv_data); 145 void *real_private; 146 }; 147 148 static int xlate_func(ext2_ino_t dir EXT2FS_ATTR((unused)), 149 int entry EXT2FS_ATTR((unused)), 150 struct ext2_dir_entry *dirent, int offset, 151 int blocksize, char *buf, void *priv_data) 152 { 153 struct xlate *xl = (struct xlate *) priv_data; 154 155 return (*xl->func)(dirent, offset, blocksize, buf, xl->real_private); 156 } 157 158 errcode_t ext2fs_dir_iterate(ext2_filsys fs, 159 ext2_ino_t dir, 160 int flags, 161 char *block_buf, 162 int (*func)(struct ext2_dir_entry *dirent, 163 int offset, 164 int blocksize, 165 char *buf, 166 void *priv_data), 167 void *priv_data) 168 { 169 struct xlate xl; 170 171 xl.real_private = priv_data; 172 xl.func = func; 173 174 return ext2fs_dir_iterate2(fs, dir, flags, block_buf, 175 xlate_func, &xl); 176 } 177 178 179 /* 180 * Helper function which is private to this module. Used by 181 * ext2fs_dir_iterate() and ext2fs_dblist_dir_iterate() 182 */ 183 int ext2fs_process_dir_block(ext2_filsys fs, 184 blk64_t *blocknr, 185 e2_blkcnt_t blockcnt, 186 blk64_t ref_block EXT2FS_ATTR((unused)), 187 int ref_offset EXT2FS_ATTR((unused)), 188 void *priv_data) 189 { 190 struct dir_context *ctx = (struct dir_context *) priv_data; 191 unsigned int offset = 0; 192 unsigned int next_real_entry = 0; 193 int ret = 0; 194 int changed = 0; 195 int do_abort = 0; 196 unsigned int rec_len, size, buflen; 197 int entry; 198 struct ext2_dir_entry *dirent; 199 int csum_size = 0; 200 int inline_data; 201 errcode_t retval = 0; 202 203 if (blockcnt < 0) 204 return 0; 205 206 entry = blockcnt ? DIRENT_OTHER_FILE : DIRENT_DOT_FILE; 207 208 /* If a dir has inline data, we don't need to read block */ 209 inline_data = !!(ctx->flags & DIRENT_FLAG_INCLUDE_INLINE_DATA); 210 if (!inline_data) { 211 ctx->errcode = ext2fs_read_dir_block4(fs, *blocknr, ctx->buf, 0, 212 ctx->dir); 213 if (ctx->errcode) 214 return BLOCK_ABORT; 215 /* If we handle a normal dir, we traverse the entire block */ 216 buflen = fs->blocksize; 217 } else { 218 buflen = ctx->buflen; 219 } 220 221 if (ext2fs_has_feature_metadata_csum(fs->super)) 222 csum_size = sizeof(struct ext2_dir_entry_tail); 223 224 while (offset < buflen - 8) { 225 dirent = (struct ext2_dir_entry *) (ctx->buf + offset); 226 if (ext2fs_get_rec_len(fs, dirent, &rec_len)) 227 return BLOCK_ABORT; 228 if (((offset + rec_len) > buflen) || 229 (rec_len < 8) || 230 ((rec_len % 4) != 0) || 231 ((ext2fs_dirent_name_len(dirent)+8) > (int) rec_len)) { 232 ctx->errcode = EXT2_ET_DIR_CORRUPTED; 233 return BLOCK_ABORT; 234 } 235 if (!dirent->inode) { 236 /* 237 * We just need to check metadata_csum when this 238 * dir hasn't inline data. That means that 'buflen' 239 * should be blocksize. 240 */ 241 if (!inline_data && 242 (offset == buflen - csum_size) && 243 (dirent->rec_len == csum_size) && 244 (dirent->name_len == EXT2_DIR_NAME_LEN_CSUM)) { 245 if (!(ctx->flags & DIRENT_FLAG_INCLUDE_CSUM)) 246 goto next; 247 entry = DIRENT_CHECKSUM; 248 } else if (!(ctx->flags & DIRENT_FLAG_INCLUDE_EMPTY)) 249 goto next; 250 } 251 252 ret = (ctx->func)(ctx->dir, 253 (next_real_entry > offset) ? 254 DIRENT_DELETED_FILE : entry, 255 dirent, offset, 256 buflen, ctx->buf, 257 ctx->priv_data); 258 if (entry < DIRENT_OTHER_FILE) 259 entry++; 260 261 if (ret & DIRENT_CHANGED) { 262 if (ext2fs_get_rec_len(fs, dirent, &rec_len)) 263 return BLOCK_ABORT; 264 changed++; 265 } 266 if (ret & DIRENT_ABORT) { 267 do_abort++; 268 break; 269 } 270 next: 271 if (next_real_entry == offset) 272 next_real_entry += rec_len; 273 274 if (ctx->flags & DIRENT_FLAG_INCLUDE_REMOVED) { 275 size = (ext2fs_dirent_name_len(dirent) + 11) & ~3; 276 277 if (rec_len != size) { 278 unsigned int final_offset; 279 280 final_offset = offset + rec_len; 281 offset += size; 282 while (offset < final_offset && 283 !ext2fs_validate_entry(fs, ctx->buf, 284 offset, 285 final_offset)) 286 offset += 4; 287 continue; 288 } 289 } 290 offset += rec_len; 291 } 292 293 if (changed) { 294 if (!inline_data) { 295 ctx->errcode = ext2fs_write_dir_block4(fs, *blocknr, 296 ctx->buf, 297 0, ctx->dir); 298 if (ctx->errcode) 299 return BLOCK_ABORT; 300 } else { 301 /* 302 * return BLOCK_INLINE_DATA_CHANGED to notify caller 303 * that inline data has been changed. 304 */ 305 retval = BLOCK_INLINE_DATA_CHANGED; 306 } 307 } 308 if (do_abort) 309 return retval | BLOCK_ABORT; 310 return retval; 311 } 312
