lib/ext2fs/dirblock.c

   1 /*
   2  * dirblock.c --- directory block routines.
   3  *
   4  * Copyright (C) 1995, 1996 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 #if HAVE_UNISTD_H
  15 #include <unistd.h>
  16 #endif
  17 #include <string.h>
  18 #include <time.h>
  19
  20 #include "ext2_fs.h"
  21 #include "ext2fs.h"
  22
  23 errcode_t ext2fs_read_dir_block3(ext2_filsys fs, blk64_t block,
  24                                  void *buf, int flags EXT2FS_ATTR((unused)))
  25 {
  26         errcode_t       retval;
  27         char            *p, *end;
  28         struct ext2_dir_entry *dirent;
  29         unsigned int    name_len, rec_len;
  30
  31
  32         retval = io_channel_read_blk64(fs->io, block, 1, buf);
  33         if (retval)
  34                 return retval;
  35
  36         p = (char *) buf;
  37         end = (char *) buf + fs->blocksize;
  38         while (p < end-8) {
  39                 dirent = (struct ext2_dir_entry *) p;
  40 #ifdef WORDS_BIGENDIAN
  41                 dirent->inode = ext2fs_swab32(dirent->inode);
  42                 dirent->rec_len = ext2fs_swab16(dirent->rec_len);
  43                 dirent->name_len = ext2fs_swab16(dirent->name_len);
  44 #endif
  45                 name_len = dirent->name_len;
  46 #ifdef WORDS_BIGENDIAN
  47                 if (flags & EXT2_DIRBLOCK_V2_STRUCT)
  48                         dirent->name_len = ext2fs_swab16(dirent->name_len);
  49 #endif
  50                 if ((retval = ext2fs_get_rec_len(fs, dirent, &rec_len)) != 0)
  51                         return retval;
  52                 if ((rec_len < 8) || (rec_len % 4)) {
  53                         rec_len = 8;
  54                         retval = EXT2_ET_DIR_CORRUPTED;
  55                 } else if (((name_len & 0xFF) + 8) > rec_len)
  56                         retval = EXT2_ET_DIR_CORRUPTED;
  57                 p += rec_len;
  58         }
  59         return retval;
  60 }
  61
  62 /*
  63  * Compute the total directory entry data length.
  64  * This includes the filename and an implicit NUL terminator (always present),
  65  * and optional extensions.  Each extension has a bit set in the high 4 bits of
  66  * de->file_type, and the extension length is the first byte in each entry.
  67  */
  68 int ext2_get_dirent_dirdata_size(struct ext2_dir_entry_2 *de,
  69                                  char dirdata_flags)
  70 {
  71         char *len = de->name + de->name_len + 1 /* NUL terminator */;
  72         int dlen = 0;
  73         __u8 extra_data_flags = (de->file_type & ~EXT2_FT_MASK) >> 4;
  74
  75         dirdata_flags >>= 4;
  76         while ((extra_data_flags & dirdata_flags) != 0) {
  77                 if (extra_data_flags & 1) {
  78                         if (dirdata_flags & 1)
  79                                 dlen += *len;
  80
  81                         len += *len;
  82                 }
  83                 extra_data_flags >>= 1;
  84                 dirdata_flags >>= 1;
  85         }
  86
  87         /* add NUL terminator byte to dirdata length */
  88         return dlen + (dlen != 0);
  89 }
  90
  91 int ext2_get_dirent_size(struct ext2_dir_entry_2 *de)
  92 {
  93         return ext2_get_dirent_dirdata_size(de, ~EXT2_FT_MASK);
  94 }
  95
  96 errcode_t ext2fs_read_dir_block2(ext2_filsys fs, blk_t block,
  97                                  void *buf, int flags EXT2FS_ATTR((unused)))
  98 {
  99         return ext2fs_read_dir_block3(fs, block, buf, flags);
 100 }
 101
 102 errcode_t ext2fs_read_dir_block(ext2_filsys fs, blk_t block,
 103                                  void *buf)
 104 {
 105         return ext2fs_read_dir_block3(fs, block, buf, 0);
 106 }
 107
 108
 109 errcode_t ext2fs_write_dir_block3(ext2_filsys fs, blk64_t block,
 110                                   void *inbuf, int flags EXT2FS_ATTR((unused)))
 111 {
 112 #ifdef WORDS_BIGENDIAN
 113         errcode_t       retval;
 114         char            *p, *end;
 115         char            *buf = 0;
 116         unsigned int    rec_len;
 117         struct ext2_dir_entry *dirent;
 118
 119         retval = ext2fs_get_mem(fs->blocksize, &buf);
 120         if (retval)
 121                 return retval;
 122         memcpy(buf, inbuf, fs->blocksize);
 123         p = buf;
 124         end = buf + fs->blocksize;
 125         while (p < end) {
 126                 dirent = (struct ext2_dir_entry *) p;
 127                 if ((retval = ext2fs_get_rec_len(fs, dirent, &rec_len)) != 0)
 128                         return retval;
 129                 if ((rec_len < 8) ||
 130                     (rec_len % 4)) {
 131                         ext2fs_free_mem(&buf);
 132                         return (EXT2_ET_DIR_CORRUPTED);
 133                 }
 134                 p += rec_len;
 135                 dirent->inode = ext2fs_swab32(dirent->inode);
 136                 dirent->rec_len = ext2fs_swab16(dirent->rec_len);
 137                 dirent->name_len = ext2fs_swab16(dirent->name_len);
 138
 139                 if (flags & EXT2_DIRBLOCK_V2_STRUCT)
 140                         dirent->name_len = ext2fs_swab16(dirent->name_len);
 141         }
 142         retval = io_channel_write_blk64(fs->io, block, 1, buf);
 143         ext2fs_free_mem(&buf);
 144         return retval;
 145 #else
 146         return io_channel_write_blk64(fs->io, block, 1, (char *) inbuf);
 147 #endif
 148 }
 149
 150 errcode_t ext2fs_write_dir_block2(ext2_filsys fs, blk_t block,
 151                                  void *inbuf, int flags EXT2FS_ATTR((unused)))
 152 {
 153         return ext2fs_write_dir_block3(fs, block, inbuf, flags);
 154 }
 155
 156 errcode_t ext2fs_write_dir_block(ext2_filsys fs, blk_t block,
 157                                  void *inbuf)
 158 {
 159         return ext2fs_write_dir_block3(fs, block, inbuf, 0);
 160 }
 161