2.11BSD#431 - /usr/src/local/mtools/dir_read.c

   1: #include <stdio.h>
   2: #include "msdos.h"
   3: 
   4: long dir_chain[MAX_DIR_SECS];       /* chain of sectors in directory */
   5: unsigned char *dir_buf;         /* the directory buffer */
   6: int dir_dirty;              /* is the buffer dirty? */
   7: 
   8: extern int dir_len, dir_start, clus_size, dir_entries, fat_error;
   9: extern unsigned int last_fat;
  10: 
  11: /*
  12:  * Read a directory entry, return a pointer a static structure.
  13:  */
  14: 
  15: struct directory *
  16: dir_read(num)
  17: int num;
  18: {
  19:     char *memcpy();
  20:     unsigned char *offset;
  21:     static struct directory dir;
  22: 
  23:     offset = dir_buf + (num * MDIR_SIZE);
  24:     memcpy((char *) &dir, (char *) offset, MDIR_SIZE);
  25:     return(&dir);
  26: }
  27: 
  28: /*
  29:  * Fill in the global variable dir_chain[].  Argument is the starting
  30:  * cluster number.  Returns -1 on error.
  31:  */
  32: 
  33: int
  34: fill_chain(num)
  35: unsigned int num;
  36: {
  37:     register int i, length;
  38:     unsigned int next, fat_decode();
  39:     unsigned char *offset;
  40:     char *malloc();
  41:     void free(), perror(), exit(), disk_read(), dir_flush();
  42: 
  43:     length = 0;
  44:     /* CONSTCOND */
  45:     while (1) {
  46:         dir_chain[length] = (long) (num - 2) * clus_size + dir_start + dir_len;
  47:         length++;
  48:                     /* sectors, not clusters! */
  49:         for (i = 1; i < clus_size; i++) {
  50:             dir_chain[length] = dir_chain[length - 1] + 1L;
  51:             length++;
  52:         }
  53: 
  54:         if (length >= MAX_DIR_SECS) {
  55:             fprintf(stderr, "fill_chain: directory too large\n");
  56:             return(-1);
  57:         }
  58:                     /* get next cluster number */
  59:         next = fat_decode(num);
  60:         if (next == 1) {
  61:             fprintf(stderr, "fill_chain: FAT problem\n");
  62:             fat_error++;
  63:             return(-1);
  64:         }
  65:                     /* end of cluster chain */
  66:         if (next >= last_fat)
  67:             break;
  68:         num = next;
  69:     }
  70:     if (dir_dirty)
  71:         dir_flush();
  72:                     /* fill the dir_buf */
  73:     free((char *) dir_buf);
  74:     dir_buf = (unsigned char *) malloc((unsigned int) length * MSECTOR_SIZE);
  75:     if (dir_buf == NULL) {
  76:         perror("fill_chain: malloc");
  77:         exit(1);
  78:     }
  79: 
  80:     for (i = 0; i < length; i++) {
  81:         offset = dir_buf + (i * MSECTOR_SIZE);
  82:         disk_read(dir_chain[i], offset, MSECTOR_SIZE);
  83:     }
  84: 
  85:     dir_entries = length * 16;
  86:     return(0);
  87: }
  88: 
  89: /*
  90:  * Reset the global variable dir_chain[] to the root directory.
  91:  */
  92: 
  93: void
  94: reset_chain(code)
  95: int code;
  96: {
  97:     register int i;
  98:     char *malloc();
  99:     void free(), disk_read(), dir_flush(), exit(), perror();
 100: 
 101:     if (dir_dirty)
 102:         dir_flush();
 103: 
 104:     for (i = 0; i < dir_len; i++)
 105:         dir_chain[i] = (long) dir_start + i;
 106: 
 107:     if (code == OLD)
 108:         free((char *) dir_buf);
 109: 
 110:     dir_buf = (unsigned char *) malloc((unsigned int) dir_len * MSECTOR_SIZE);
 111:     if (dir_buf == NULL) {
 112:         perror("reset_chain: malloc");
 113:         exit(1);
 114:     }
 115:     disk_read((long) dir_start, dir_buf, dir_len * MSECTOR_SIZE);
 116: 
 117:     dir_entries = dir_len * 16;
 118:     return;
 119: }
 120: 
 121: /*
 122:  * Get rid of spaces in an MSDOS 'raw' name (one that has come from the
 123:  * directory structure) so that it can be used for regular expression
 124:  * matching with a unix filename.  Also used to 'unfix' a name that has
 125:  * been altered by dos_name().  Returns a pointer a static buffer.
 126:  */
 127: 
 128: char *
 129: unix_name(name, ext)
 130: unsigned char *name, *ext;
 131: {
 132:     char *s, tname[9], text[4], *strcpy(), *strcat(), *strchr();
 133:     char *strncpy();
 134:     static char ans[13];
 135: 
 136:     strncpy(tname, (char *) name, 8);
 137:     tname[8] = '\0';
 138:     if (s = strchr(tname, ' '))
 139:         *s = '\0';
 140: 
 141:     strncpy(text, (char *) ext, 3);
 142:     text[3] = '\0';
 143:     if (s = strchr(text, ' '))
 144:         *s = '\0';
 145: 
 146:     if (*text) {
 147:         strcpy(ans, tname);
 148:         strcat(ans, ".");
 149:         strcat(ans, text);
 150:     }
 151:     else
 152:         strcpy(ans, tname);
 153:     return(ans);
 154: }

Defined functions

Defined variables