fs/isofs/dir.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *  linux/fs/isofs/dir.c
0004  *
0005  *  (C) 1992, 1993, 1994  Eric Youngdale Modified for ISO 9660 filesystem.
0006  *
0007  *  (C) 1991  Linus Torvalds - minix filesystem
0008  *
0009  *  Steve Beynon               : Missing last directory entries fixed
0010  *  (stephen@askone.demon.co.uk)      : 21st June 1996
0011  *
0012  *  isofs directory handling functions
0013  */
0014 #include <linux/gfp.h>
0015 #include "isofs.h"
0016
0017 int isofs_name_translate(struct iso_directory_record *de, char *new, struct inode *inode)
0018 {
0019     char * old = de->name;
0020     int len = de->name_len[0];
0021     int i;
0022
0023     for (i = 0; i < len; i++) {
0024         unsigned char c = old[i];
0025         if (!c)
0026             break;
0027
0028         if (c >= 'A' && c <= 'Z')
0029             c |= 0x20;  /* lower case */
0030
0031         /* Drop trailing '.;1' (ISO 9660:1988 7.5.1 requires period) */
0032         if (c == '.' && i == len - 3 && old[i + 1] == ';' && old[i + 2] == '1')
0033             break;
0034
0035         /* Drop trailing ';1' */
0036         if (c == ';' && i == len - 2 && old[i + 1] == '1')
0037             break;
0038
0039         /* Convert remaining ';' to '.' */
0040         /* Also '/' to '.' (broken Acorn-generated ISO9660 images) */
0041         if (c == ';' || c == '/')
0042             c = '.';
0043
0044         new[i] = c;
0045     }
0046     return i;
0047 }
0048
0049 /* Acorn extensions written by Matthew Wilcox <willy@infradead.org> 1998 */
0050 int get_acorn_filename(struct iso_directory_record *de,
0051                 char *retname, struct inode *inode)
0052 {
0053     int std;
0054     unsigned char *chr;
0055     int retnamlen = isofs_name_translate(de, retname, inode);
0056
0057     if (retnamlen == 0)
0058         return 0;
0059     std = sizeof(struct iso_directory_record) + de->name_len[0];
0060     if (std & 1)
0061         std++;
0062     if (de->length[0] - std != 32)
0063         return retnamlen;
0064     chr = ((unsigned char *) de) + std;
0065     if (strncmp(chr, "ARCHIMEDES", 10))
0066         return retnamlen;
0067     if ((*retname == '_') && ((chr[19] & 1) == 1))
0068         *retname = '!';
0069     if (((de->flags[0] & 2) == 0) && (chr[13] == 0xff)
0070         && ((chr[12] & 0xf0) == 0xf0)) {
0071         retname[retnamlen] = ',';
0072         sprintf(retname+retnamlen+1, "%3.3x",
0073             ((chr[12] & 0xf) << 8) | chr[11]);
0074         retnamlen += 4;
0075     }
0076     return retnamlen;
0077 }
0078
0079 /*
0080  * This should _really_ be cleaned up some day..
0081  */
0082 static int do_isofs_readdir(struct inode *inode, struct file *file,
0083         struct dir_context *ctx,
0084         char *tmpname, struct iso_directory_record *tmpde)
0085 {
0086     unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
0087     unsigned char bufbits = ISOFS_BUFFER_BITS(inode);
0088     unsigned long block, offset, block_saved, offset_saved;
0089     unsigned long inode_number = 0; /* Quiet GCC */
0090     struct buffer_head *bh = NULL;
0091     int len;
0092     int map;
0093     int first_de = 1;
0094     char *p = NULL;     /* Quiet GCC */
0095     struct iso_directory_record *de;
0096     struct isofs_sb_info *sbi = ISOFS_SB(inode->i_sb);
0097
0098     offset = ctx->pos & (bufsize - 1);
0099     block = ctx->pos >> bufbits;
0100
0101     while (ctx->pos < inode->i_size) {
0102         int de_len;
0103
0104         if (!bh) {
0105             bh = isofs_bread(inode, block);
0106             if (!bh)
0107                 return 0;
0108         }
0109
0110         de = (struct iso_directory_record *) (bh->b_data + offset);
0111
0112         de_len = *(unsigned char *)de;
0113
0114         /*
0115          * If the length byte is zero, we should move on to the next
0116          * CDROM sector.  If we are at the end of the directory, we
0117          * kick out of the while loop.
0118          */
0119
0120         if (de_len == 0) {
0121             brelse(bh);
0122             bh = NULL;
0123             ctx->pos = (ctx->pos + ISOFS_BLOCK_SIZE) & ~(ISOFS_BLOCK_SIZE - 1);
0124             block = ctx->pos >> bufbits;
0125             offset = 0;
0126             continue;
0127         }
0128
0129         block_saved = block;
0130         offset_saved = offset;
0131         offset += de_len;
0132
0133         /* Make sure we have a full directory entry */
0134         if (offset >= bufsize) {
0135             int slop = bufsize - offset + de_len;
0136             memcpy(tmpde, de, slop);
0137             offset &= bufsize - 1;
0138             block++;
0139             brelse(bh);
0140             bh = NULL;
0141             if (offset) {
0142                 bh = isofs_bread(inode, block);
0143                 if (!bh)
0144                     return 0;
0145                 memcpy((void *) tmpde + slop, bh->b_data, offset);
0146             }
0147             de = tmpde;
0148         }
0149         /* Basic sanity check, whether name doesn't exceed dir entry */
0150         if (de_len < de->name_len[0] +
0151                     sizeof(struct iso_directory_record)) {
0152             printk(KERN_NOTICE "iso9660: Corrupted directory entry"
0153                    " in block %lu of inode %lu\n", block,
0154                    inode->i_ino);
0155             brelse(bh);
0156             return -EIO;
0157         }
0158
0159         if (first_de) {
0160             isofs_normalize_block_and_offset(de,
0161                             &block_saved,
0162                             &offset_saved);
0163             inode_number = isofs_get_ino(block_saved,
0164                             offset_saved, bufbits);
0165         }
0166
0167         if (de->flags[-sbi->s_high_sierra] & 0x80) {
0168             first_de = 0;
0169             ctx->pos += de_len;
0170             continue;
0171         }
0172         first_de = 1;
0173
0174         /* Handle the case of the '.' directory */
0175         if (de->name_len[0] == 1 && de->name[0] == 0) {
0176             if (!dir_emit_dot(file, ctx))
0177                 break;
0178             ctx->pos += de_len;
0179             continue;
0180         }
0181
0182         len = 0;
0183
0184         /* Handle the case of the '..' directory */
0185         if (de->name_len[0] == 1 && de->name[0] == 1) {
0186             if (!dir_emit_dotdot(file, ctx))
0187                 break;
0188             ctx->pos += de_len;
0189             continue;
0190         }
0191
0192         /* Handle everything else.  Do name translation if there
0193            is no Rock Ridge NM field. */
0194
0195         /*
0196          * Do not report hidden files if so instructed, or associated
0197          * files unless instructed to do so
0198          */
0199         if ((sbi->s_hide && (de->flags[-sbi->s_high_sierra] & 1)) ||
0200             (!sbi->s_showassoc &&
0201                 (de->flags[-sbi->s_high_sierra] & 4))) {
0202             ctx->pos += de_len;
0203             continue;
0204         }
0205
0206         map = 1;
0207         if (sbi->s_rock) {
0208             len = get_rock_ridge_filename(de, tmpname, inode);
0209             if (len != 0) {     /* may be -1 */
0210                 p = tmpname;
0211                 map = 0;
0212             }
0213         }
0214         if (map) {
0215 #ifdef CONFIG_JOLIET
0216             if (sbi->s_joliet_level) {
0217                 len = get_joliet_filename(de, tmpname, inode);
0218                 p = tmpname;
0219             } else
0220 #endif
0221             if (sbi->s_mapping == 'a') {
0222                 len = get_acorn_filename(de, tmpname, inode);
0223                 p = tmpname;
0224             } else
0225             if (sbi->s_mapping == 'n') {
0226                 len = isofs_name_translate(de, tmpname, inode);
0227                 p = tmpname;
0228             } else {
0229                 p = de->name;
0230                 len = de->name_len[0];
0231             }
0232         }
0233         if (len > 0) {
0234             if (!dir_emit(ctx, p, len, inode_number, DT_UNKNOWN))
0235                 break;
0236         }
0237         ctx->pos += de_len;
0238     }
0239     if (bh)
0240         brelse(bh);
0241     return 0;
0242 }
0243
0244 /*
0245  * Handle allocation of temporary space for name translation and
0246  * handling split directory entries.. The real work is done by
0247  * "do_isofs_readdir()".
0248  */
0249 static int isofs_readdir(struct file *file, struct dir_context *ctx)
0250 {
0251     int result;
0252     char *tmpname;
0253     struct iso_directory_record *tmpde;
0254     struct inode *inode = file_inode(file);
0255
0256     tmpname = (char *)__get_free_page(GFP_KERNEL);
0257     if (tmpname == NULL)
0258         return -ENOMEM;
0259
0260     tmpde = (struct iso_directory_record *) (tmpname+1024);
0261
0262     result = do_isofs_readdir(inode, file, ctx, tmpname, tmpde);
0263
0264     free_page((unsigned long) tmpname);
0265     return result;
0266 }
0267
0268 const struct file_operations isofs_dir_operations =
0269 {
0270     .llseek = generic_file_llseek,
0271     .read = generic_read_dir,
0272     .iterate_shared = isofs_readdir,
0273 };
0274
0275 /*
0276  * directories can handle most operations...
0277  */
0278 const struct inode_operations isofs_dir_inode_operations =
0279 {
0280     .lookup = isofs_lookup,
0281 };
0282
0283