Return to dir.c CVS log

Up to [Early Linux] / linux / fs / msdos

Annotation of linux/fs/msdos/dir.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *  linux/fs/msdos/dir.c
                      3:  *
                      4:  *  Written 1992 by Werner Almesberger
                      5:  *
                      6:  *  MS-DOS directory handling functions
                      7:  */
                      8: 
                      9: #include <asm/segment.h>
                     10: 
                     11: #include <linux/sched.h>
                     12: #include <linux/fs.h>
                     13: #include <linux/msdos_fs.h>
                     14: #include <linux/errno.h>
                     15: #include <linux/stat.h>
                     16: 
                     17: static int msdos_dummy_read(struct inode *inode,struct file *filp,char *buf,
                     18:     int count);
                     19: static int msdos_readdir(struct inode *inode,struct file *filp,
                     20:     struct dirent *dirent,int count);
                     21: 
                     22: 
                     23: static struct file_operations msdos_dir_operations = {
                     24:        NULL,                   /* lseek - default */
                     25:        msdos_dummy_read,       /* read */
                     26:        NULL,                   /* write - bad */
                     27:        msdos_readdir,          /* readdir */
                     28:        NULL,                   /* select - default */
                     29:        NULL,                   /* ioctl - default */
                     30:        NULL,                   /* no special open code */
                     31:        NULL                    /* no special release code */
                     32: };
                     33: 
                     34: struct inode_operations msdos_dir_inode_operations = {
                     35:        &msdos_dir_operations,  /* default directory file-ops */
                     36:        msdos_create,           /* create */
                     37:        msdos_lookup,           /* lookup */
                     38:        NULL,                   /* link */
                     39:        msdos_unlink,           /* unlink */
                     40:        NULL,                   /* symlink */
                     41:        msdos_mkdir,            /* mkdir */
                     42:        msdos_rmdir,            /* rmdir */
                     43:        NULL,                   /* mknod */
                     44:        msdos_rename,           /* rename */
                     45:        NULL,                   /* readlink */
                     46:        NULL,                   /* follow_link */
                     47:        msdos_bmap,             /* bmap */
                     48:        NULL                    /* truncate */
                     49: };
                     50: 
                     51: 
                     52: /* So  grep *  doesn't complain in the presence of directories. */
                     53: 
                     54: static int msdos_dummy_read(struct inode *inode,struct file *filp,char *buf,
                     55:     int count)
                     56: {
                     57:        static long last_warning = 0;
                     58: 
                     59:        if (CURRENT_TIME-last_warning >= 10) {
                     60:                printk("COMPATIBILITY WARNING: reading a directory\r\n");
                     61:                last_warning = CURRENT_TIME;
                     62:        }
                     63:        return 0;
                     64: }
                     65: 
                     66: 
                     67: static int msdos_readdir(struct inode *inode,struct file *filp,
                     68:     struct dirent *dirent,int count)
                     69: {
                     70:        int ino,i,i2,last;
                     71:        char c,*walk;
                     72:        struct buffer_head *bh;
                     73:        struct msdos_dir_entry *de;
                     74: 
                     75:        if (!inode || !S_ISDIR(inode->i_mode)) return -EBADF;
                     76:        if (inode->i_ino == MSDOS_ROOT_INO) {
                     77: /* Fake . and .. for the root directory. */
                     78:                if (filp->f_pos == 2) filp->f_pos = 0;
                     79:                else if (filp->f_pos < 2) {
                     80:                                walk = filp->f_pos++ ? ".." : ".";
                     81:                                for (i = 0; *walk; walk++)
                     82:                                        put_fs_byte(*walk,dirent->d_name+i++);
                     83:                                put_fs_long(MSDOS_ROOT_INO,&dirent->d_ino);
                     84:                                put_fs_byte(0,dirent->d_name+i);
                     85:                                put_fs_word(i,&dirent->d_reclen);
                     86:                                return i;
                     87:                        }
                     88:        }
                     89:        if (filp->f_pos & (sizeof(struct msdos_dir_entry)-1)) return -ENOENT;
                     90:        bh = NULL;
                     91:        while ((ino = msdos_get_entry(inode,&filp->f_pos,&bh,&de)) > -1) {
                     92:                if (de->name[0] && ((unsigned char *) (de->name))[0] !=
                     93:                    DELETED_FLAG && !(de->attr & ATTR_VOLUME)) {
                     94:                        for (i = last = 0; i < 8; i++) {
                     95:                                if (!(c = de->name[i])) break;
                     96:                                if (c >= 'A' && c <= 'Z') c += 32;
                     97:                                if (c != ' ') last = i+1;
                     98:                                put_fs_byte(c,i+dirent->d_name);
                     99:                        }
                    100:                        i = last;
                    101:                        if (de->ext[0] && de->ext[0] != ' ') {
                    102:                                put_fs_byte('.',i+dirent->d_name);
                    103:                                i++;
                    104:                                for (i2 = 0; i2 < 3; i2++) {
                    105:                                        if (!(c = de->ext[i2])) break;
                    106:                                        if (c >= 'A' && c <= 'Z') c += 32;
                    107:                                        put_fs_byte(c,i+dirent->d_name);
                    108:                                        i++;
                    109:                                        if (c != ' ') last = i;
                    110:                                }
                    111:                        }
                    112:                        if (i = last) {
                    113:                                if (!strcmp(de->name,MSDOS_DOT))
                    114:                                        ino = inode->i_ino;
                    115:                                else if (!strcmp(de->name,MSDOS_DOTDOT))
                    116:                                                ino = msdos_parent_ino(inode,0);
                    117:                                put_fs_long(ino,&dirent->d_ino);
                    118:                                put_fs_byte(0,i+dirent->d_name);
                    119:                                put_fs_word(i,&dirent->d_reclen);
                    120:                                brelse(bh);
                    121:                                return i;
                    122:                        }
                    123:                }
                    124:        }
                    125:        if (bh) brelse(bh);
                    126:        return 0;
                    127: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.