home *** CD-ROM | disk | FTP | other *** search
/ Oakland CPM Archive / oakcpm.iso / sigm / vol128 / umodem.lbr / CPMUTL.C next >
Encoding:
C/C++ Source or Header  |  1985-02-10  |  32.4 KB  |  1,040 lines
  1. /* copyright (c) by Aaron Wohl, 1981,1982
  2.   written by Aaron Wohl 12-24-81 (wohl@cmuc)
  3.   This file may be used for non-profit use provided this
  4.     this notice remains at the front of the file.
  5.  
  6.   This program reads and writes cpm format floppy disks.
  7.   cpm is a trade mark of Digital Reasearch.  It runs under
  8.   version 7 unix.  unix is a trademark of bell labs.
  9.   See the function help() for documentation.
  10.  
  11.   please mail any bug fixes to wohl@cmuc
  12.   the source for this file is on the unix host vlsi@cmuc
  13.     pathname /usr/avw/cpmutl/cpmutlVERSION-NUMBER.c
  14.     vlsi is on the arpanet running TCP-IP
  15.   a copy is also kept on mit-mc cpm;ar43:cpmutl VERSION-NUMBERc
  16.   and on [cmuc]ps:<wohl.bar>cpmutl.c.VERSION-NUMBER (for people that can't
  17.     figure out how to use ITS)
  18.   mail will be sent info-cpm announcing new versions
  19.   
  20. */
  21.  
  22. #define version 7
  23. #define when "10-28-82"
  24.  
  25. /* change log:
  26.  
  27.  ver   when          who                why
  28.  ---  --------  -------------   --------------------
  29.    2  12-27-81        wohl@cmuc   allow a trailing * to cross the . in a ufn
  30.    3  12-28-81        wohl@cmuc   remove refrences to cmu local functions
  31.                 honor the record count when reading
  32.    4   2- 9-82      wohl@cmuc   fix a '=> [cpm]' string to be '[cpm] =>'
  33.                 put with one filename arg uses it for both
  34.    5   5- 8-82        wohl@cmuc   initilize extent filler bytes to zero
  35.    6   5-17-82      wohl@cmuc   fix printout of free space (was 2k low)
  36.                 add support for user numbers
  37.                 add a \n to the interleving off message
  38.    7  10-28-82      mz@gp       for file get, close each file
  39.  
  40. Things to (think about) doing:
  41.  
  42. a) have the create file system function ask for confirmation
  43. b) multiple put should skip files with names that are too long or truncate the
  44.    name
  45. c) skip files which are directories (multiple put)
  46.  
  47.  
  48. */
  49.  
  50. #include <sys/types.h>
  51. #include <sys/stat.h>
  52. #include <stdio.h>
  53. #include <ctype.h>
  54.  
  55. #define TRUE 1
  56. #define FALSE 0
  57. #define MAX_USER 15        /* maximum user number */
  58. #define CP_NUMDIR 64        /* number of directory slots */
  59. #define DIR_EXT (CP_NUMDIR+1)    /* fake index to allocate directory space */
  60. #define CP_DIRSEC 16        /* number of sectors of directory */
  61. #define CP_NAMESIZE (8+3+1+1)    /* file name, name+ext+dot+null */
  62. #define CP_BASE    (26*2)        /* sector of start of file system */
  63. #define CP_SIZE    (26*77)        /* sectors on a disk */
  64. #define CP_CLUSTER 8        /* sectors in a allocation cluster */
  65. #define CP_CLCHAR (CP_CLUSTER*128) /* number of bytes in a cluster */
  66. #define CP_ALOC ((CP_SIZE-CP_BASE)/CP_CLUSTER) /* clusters per disk */
  67. #define SPACE 040        /* ascii space character */
  68. #define np(val) ((val) & 0177)    /* no parity please */
  69. #define FT_SZ 3            /* number of bytes in a file type */
  70. #define FN_SZ 8            /* number of bytes in a file name */
  71. #define SEC 128            /* bytes in a sector */
  72. #define DM 16            /* number of disk map entries */
  73. #define DELF 0xe5        /* entry type for a deleted file */
  74.  
  75. /* what a directory entry looks like */
  76. struct cp_dir_ext {
  77.   unsigned char cp_et;        /* entry type */
  78.   unsigned char cp_fn[FN_SZ];    /* file name */
  79.   unsigned char cp_ft[FT_SZ];    /* file type */
  80.   unsigned char cp_ex;        /* extent number */
  81.   unsigned char cp_fl[2];    /* filler */
  82.   unsigned char cp_rc;        /* record count */
  83.   unsigned char cp_dm[DM];    /* disk allocation map */
  84. };
  85.  
  86. struct cp_dir_ext cp_dir[CP_NUMDIR];
  87.  
  88. char cp_name[CP_NUMDIR][CP_NAMESIZE]; /* name as file.typ */
  89. int ext_next[CP_NUMDIR];    /* slot of next higher extent */
  90. int ext_prev[CP_NUMDIR];    /* slot of next lower extent */
  91. int cp_btb[CP_ALOC];        /* allocation bit table */
  92. int dsk_inuse;            /* number of clusters in use */
  93. int num_fil;            /* number of files */
  94. int num_ext;            /* number of extents */
  95. int dir_err;            /* number of directory errors */
  96.                 /*  includes number of i/o errors in dir */
  97. int io_err;            /* number of i/o errors */
  98. int user_num = 0;        /* current user number */
  99. int any_user = TRUE;        /* true if files from any user can be seen */
  100.  
  101. #define flag(c) (flg[(c) - 'a'])
  102.  
  103. char *man = { "clgp" };
  104.  
  105. char *flname;
  106. int fldes;
  107. long lseek();
  108.  
  109. int gcmd(),lcmd(),icmd(),ccmd(),pcmd(),ncmd(); /* command functions */
  110.  
  111. int (*comfun)();
  112. char flg[26];
  113. char mode = 'u';
  114. int file;
  115.  
  116. /* main program */
  117. main(argc, argv)
  118. char *argv[];
  119. { char *cp;
  120.   fprintf(stdout,"cpmutl version(%d), date:%s\n",version,when);
  121.   init_data();            /* initialize data */
  122.   cp = argv[1];
  123.   for(cp = argv[1]; *cp; cp++)
  124.     switch(*cp) {
  125.     case 'a':
  126.       flag('a')++;
  127.       continue;     
  128.  
  129.     case 't':
  130.       mode = 't';
  131.       continue;
  132.  
  133.     case 'b':
  134.       mode = 'b';
  135.       continue;
  136.  
  137.     case 'o':
  138.       flag('o')++;        /* allow writes to a damaged directory */
  139.       continue;
  140.  
  141.     case 'i':
  142.       flag('i')++;
  143.       continue;
  144.  
  145.     case 'n':
  146.       flag('w')++;        /* will be writing */
  147.       setcom(ncmd);
  148.       continue;
  149.  
  150.     case 'p':
  151.       flag('w')++;        /* will be writing */
  152.       setcom(pcmd);
  153.       continue;
  154.  
  155.     case 'c':
  156.       flag('w')++;        /* will be writing */
  157.       setcom(ccmd);
  158.       continue;
  159.  
  160.     case 'g':
  161.       setcom(gcmd);
  162.       continue;
  163.  
  164.     case 'l':
  165.       setcom(lcmd);
  166.       continue;
  167.  
  168.     case 'f':
  169.       flname = argv[2];
  170.       argv++;
  171.       argc--;
  172.       continue;
  173.  
  174.     case 'h':
  175.       help();
  176.  
  177.     case 'u':
  178.       user_num=0;        /* read in the number */
  179.       while(isdigit(*(cp+1)))
  180.         user_num = user_num * 10 + (*++cp - '0');
  181.       if(user_num > MAX_USER)
  182.         quit(1,"\ncpmutl:user number out of range\n");
  183.       any_user = FALSE;
  184.       continue;
  185.  
  186.     default:
  187.       quit(1,"\ncpmutl: bad option '%c'. use h for help\n", *cp);
  188.     }
  189.   if(comfun == 0) {
  190.       quit(1,"\ncpmutl: one of [%s] must be specified. use h for help\n",man);
  191.     }
  192.   (*comfun)(argc-2,&argv[2]);
  193.   fprintf(stdout,"\n");
  194.   exit(0);
  195. }
  196.  
  197. /* command parsing subroutines */
  198.  
  199. need_mode()
  200. { if(mode == 'u')
  201.     quit(1,"\ncpmutl: mode t(ext) or b(inary) must be specified\n");
  202. }
  203.  
  204. setcom(fun)
  205. int (*fun)();
  206. { if(comfun != 0)
  207.     quit(1,"\ncpmutl: only one of [%s] allowed\n", man);
  208.   comfun = fun;
  209. }
  210.  
  211. help()
  212. { fprintf(stdout,"commands:\n");
  213.   fprintf(stdout," l afn                  list  files matching afn\n");
  214.   fprintf(stdout," g afn [unix_prefix]    get files matching afn\n");
  215.   fprintf(stdout," p ufn unix_file_name   put a file to floppy\n");
  216.   fprintf(stdout," p '*' unix_files       put a bunch of files\n");
  217.   fprintf(stdout," n afn                  nuke - delete matching files\n");
  218.   fprintf(stdout," c                      create a new file system\n");
  219.   fprintf(stdout,"\noptions:\n");
  220.   fprintf(stdout," t - text mode             b - binary mode\n");
  221.   fprintf(stdout," i - don't do interleaving u - user number\n");
  222.   fprintf(stdout," a - absolute disk address, start.length e.g. 0.2002\n");
  223.   fprintf(stdout," f - use the named unix file instead of /dev/floppy\n");
  224.   fprintf(stdout," o - override, allows writes to a damaged directories\n");
  225.   fprintf(stdout,"\nterms:\n");
  226.   fprintf(stdout," afn - ambiguous cpm file name, e.g. *.asm or foo*\n");
  227.   fprintf(stdout,"   *** don't forget to quote afns to the shell, '*.asm'\n");
  228.   fprintf(stdout," ufn - unambiguous file name\n");
  229.   fprintf(stdout," interleaving - tracks 2-76 are normaly interleaved\n");
  230.   fprintf(stdout,"   with a skew of 6 sectors\n");
  231.   exit(1);
  232. }
  233.  
  234. /* create a new file system */
  235. ccmd()
  236. { int i;
  237.   fprintf(stdout,"initializing file system ");
  238.   fflush(stdout);
  239.   lread(CP_BASE,CP_DIRSEC,cp_dir);    /* read in the directory */
  240.                     /* so we can zap disk to undo this */
  241.   for(i=0; i<CP_NUMDIR; i++)
  242.     cp_dir[i].cp_et = DELF;        /* set all the extents deleted */
  243.   lwrite(CP_BASE,CP_DIRSEC,cp_dir);    /* write it back */
  244.   fprintf(stdout," [ok]\n");
  245. } 
  246.  
  247. /* get some files from the floppy */
  248. gcmd(argc,argv)
  249.  char *argv[];
  250.  int argc;
  251. { char *unix_name,*cpm_name;
  252.   int index,cur;
  253.   struct cp_dir_ext wild;
  254.   cpm_name = argv[0];
  255.   if (argc > 2) toomany();
  256.   if(flag('a')) {            /* want absolute disk addresses? */
  257.     if(argc < 2) toofew();
  258.     abs_read(cpm_name,argv[1]);
  259.     return;
  260.     }
  261.  
  262.   need_mode();                /* need have given a file mode */
  263.   if (argc == 1)
  264.     unix_name = "";            /* no unix prefix */
  265.   else
  266.     unix_name = argv[1];        /* use this unix prefix */
  267.   parse_ext(&wild,cpm_name);
  268.   getdir();                /* read the directory */
  269.   cur = -1;                /* start looking here */
  270.   while((cur = lookup(&wild,cur)) != -1) /* find the next matching file */
  271.     getfile(cur,unix_name);
  272. }
  273.  
  274. /* pcmd - put files on the floppy */
  275. pcmd(argc,argv)
  276.  char *argv[];
  277.  int argc;
  278. { int i;
  279.   char *uname;
  280.   if(argc<1) toofew();
  281.   if(flag('a')) {            /* want absolute disk addresses? */
  282.     if(argc<2) toofew();
  283.     if(argc > 2) toomany();
  284.     abs_write(argv[0],argv[1]);
  285.     return;
  286.     }
  287.  
  288.   need_mode();
  289.   getdir();
  290.   if (argc == 1)                /* only one arg? */
  291.     writefile(argv[0],argv[0]);
  292.   else
  293.     for(i=1; i<argc; i++)        /* write out the unix files */
  294.       writefile(argv[0],argv[i]);
  295. }
  296.  
  297. /* write a bunch of sectors into a file */
  298. abs_write(whereto,unix_name)
  299. { int start,size,status;
  300.   char buf[SEC];
  301.   FILE *ifile;
  302.   if(sscanf(whereto,"%d.%d",&start,&size) != 2)
  303.     quit(1,"\ncpmutl:can't parse start.size address\n");
  304.   if ((ifile = fopen(unix_name,"r")) == NULL) /* try to open the unix file */
  305.     quit(1,"\ncpmutl:can't open unix file %s for read\n",unix_name);
  306.   markerrs();
  307.   fprintf(stdout,"writing %s => sector %d, length %d ",unix_name,start,size);
  308.   fflush(stdout);
  309.   while(size--) {
  310.     if((status = fread(buf,1,SEC,ifile)) != SEC) /* read a sector from unix */
  311.       quit(1,"\ncpmutl:read error on unix file %s\n",unix_name);
  312.     lwrite(start,1,buf);
  313.     start++;                /* advance to the next sector */
  314.     }
  315.  reporterrs();
  316.  fclose(ifile);
  317. }
  318.  
  319. /* ndcm - nuke some files */
  320. ncmd(argc,argv)
  321. char *argv[];
  322. int argc;
  323. { struct cp_dir_ext del_ext;
  324.   if(argc < 1) toofew();
  325.   if(argc > 2) toomany();
  326.   getdir();                /* get the directory */
  327.   parse_ext(&del_ext,argv[0]);        /* parse the file spec to delete */
  328.   nuke_ext(&del_ext);            /* delete matching extents */
  329.   putdir();
  330. }
  331.  
  332. /* delete matching entries */
  333. nuke_ext(nuk_me)
  334. struct cp_dir_ext *nuk_me;
  335. { int i;
  336.   for(i=0; i<CP_NUMDIR; i++)
  337.     if((cp_dir[i].cp_et != DELF) &&
  338.        match_ext(nuk_me,&cp_dir[i]))    /* does this extent match? */
  339.       flush_ext(i);            /* yes flush it */
  340. }
  341.  
  342. /* flush this extent */
  343. flush_ext(index)
  344. { int i,where;
  345.   num_ext--;                /* one less extent exists */
  346.   if(cp_dir[index].cp_ex == 0)
  347.     fprintf(stdout,"deleting file:[%d]%s\n",
  348.       cp_dir[index].cp_et,cp_name[index]),
  349.     num_fil--;                /* one less file */
  350.   for(i=0; i<DM; i++)            /* release its disk space */
  351.     if((where = cp_dir[index].cp_dm[i]) != 0) { /* this cluster allocated? */
  352.       if(cp_btb[where] != index)    /* we did have it didn't we? */
  353.        dir_err++,            /* no, an error then */
  354.        fprintf(stderr,"\ncpmutl:cluster being deleted is not assigned\n"); 
  355.       cp_btb[where] = -1;
  356.       dsk_inuse--;
  357.       }
  358.   ext_prev[index] = -1;            /* no links this way */
  359.   ext_next[index] = -1;            /* or that */
  360.   cp_dir[index].cp_et = DELF;        /* do the deed */
  361. }
  362.  
  363. /* copy the name of an extent */
  364. copy_ext(src,dst)
  365. struct cp_dir_ext *src,*dst;
  366. { int i;
  367.   for(i=0; i<FN_SZ; i++)        /* copy over the file name */
  368.     dst->cp_fn[i] = src->cp_fn[i];
  369.   for(i=0; i<FT_SZ; i++)        /* copy over the file type */
  370.     dst->cp_ft[i] = src->cp_ft[i];
  371. }
  372.  
  373. /* lcmd - list the floppy directory */
  374. lcmd(argc,argv)
  375. char *argv[];
  376. int argc;
  377. { int i,cur,curext;
  378.   int totrec=0,totext=0,totk=0;
  379.   struct cp_dir_ext wild;
  380.   char *cpm_name;
  381.   if(argc > 1) toomany();
  382.   if(argc == 0)
  383.     cpm_name = "*.*";        /* default file name */
  384.   else
  385.     cpm_name = argv[0];
  386.   getdir();            /* read in the directory */
  387.   fprintf(stdout,
  388.     "disk status: %d files, %d extents, %dK allocated, %dK free\n\n",
  389.     num_fil,num_ext,dsk_inuse-2,CP_ALOC-dsk_inuse);
  390.   fprintf(stdout,"    recs     K   ex   usr name\n");
  391.  
  392.   parse_ext(&wild,cpm_name);    /* parse the cpm file name */
  393.   cur = -1;
  394.   while((cur = curext = lookup(&wild,cur)) != -1) { /* find a file */
  395.     int recsiz=0,ksiz=0,numext=0;
  396.     while(curext != -1) {        /* do all of its extents */
  397.       numext++;                /* found one more extent */
  398.       recsiz += cp_dir[curext].cp_rc;    /* this many records */
  399.       ksiz += ((cp_dir[curext].cp_rc+CP_CLUSTER-1)/CP_CLUSTER); /* k size */
  400.       curext = ext_next[curext];    /* move on */
  401.       }
  402.     fprintf(stdout,
  403.       "    %4d   %3dK  %2d   [%d]%s\n",recsiz,ksiz,numext,
  404.       cp_dir[cur].cp_et,cp_name[cur]);
  405.     totrec += recsiz;
  406.     totk += ksiz;
  407.     totext += numext;
  408.     }
  409.   fprintf(stdout,"    ----   ---   --\n");
  410.   fprintf(stdout,"    %4d   %3d   %2d\n",totrec,totk,totext);
  411. }
  412.  
  413. /*
  414.    read subroutines
  415. */
  416.  
  417. /* read a file from the floppy */
  418. getfile(index,unix_prefix)
  419. int index;
  420. char *unix_prefix;
  421. { int clstr,cur_io_err,extsiz,currec;
  422.   FILE *ofile;
  423.   char *unix_name;
  424.   char buf[100];            /* default to the prefix */
  425.   if (*unix_prefix == 0)        /* is there a unix file name */
  426.     unix_name = cp_name[index];        /* no, just use the cpm name */
  427.   else {
  428.     char *cp;
  429.     for(cp = unix_prefix; *cp; *cp++ );    /* find the end */
  430.     cp--;                /* point to the last char */
  431.     if (*cp != '/')            /* is this a prefix */
  432.       unix_name = unix_prefix;        /* no, its a name */
  433.     else
  434.       strcpy(buf,unix_prefix),        /* put on the prefix */
  435.       strcat(buf,cp_name[index]),    /* then the name */
  436.       unix_name = buf;            /* that's it */
  437.     }
  438.  
  439.   if ((ofile = fopen(unix_name,"w")) == NULL) /* try to open the unix file */
  440.     quit(1,"\ncpmutl:can't create unix file %s\n",unix_name);
  441.   fprintf(stdout,"[%d]%s => %s ",cp_dir[index].cp_et,
  442.                  cp_name[index],unix_name);
  443.   fflush(stdout);
  444.   markerrs();
  445.   for( ; index != -1; index=ext_next[index]) { /* all extents */
  446.     extsiz = cp_dir[index].cp_rc;    /* read all the records */
  447.     for(currec=0; currec < extsiz; currec++) { /* read all the records */
  448.      if(read_sector(cp_dir[index].cp_dm[currec/CP_CLUSTER],
  449.                     currec % CP_CLUSTER,ofile))
  450.        break;                /* stop at eof */
  451.      }
  452.     }
  453.   reporterrs();
  454.   fclose(ofile);
  455. }
  456.  
  457. /* more read subroutines */
  458.  
  459. /* read a bunch of sectors into a file */
  460. abs_read(wherefrom,unix_name)
  461. { int start,size,status;
  462.   char buf[SEC];
  463.   FILE *ofile;
  464.   if(sscanf(wherefrom,"%d.%d",&start,&size) != 2)
  465.     quit(1,"\ncpmutl:can't parse start.size address\n");
  466.   if ((ofile = fopen(unix_name,"w")) == NULL) /* try to open the unix file */
  467.     quit(1,"\ncpmutl:can't create unix file %s\n",unix_name);
  468.   markerrs();
  469.   fprintf(stdout,
  470.     "reading from sector %d, length %d => %s ",start,size,unix_name);
  471.   fflush(stdout);
  472.   while(size--) {
  473.     lread(start,1,buf);            /* read a sector from the floppy */
  474.     status=fwrite(buf,1,SEC,ofile);    /* write it to the file */
  475.     if(status != SEC)
  476.       quit(1,"\ncpmutl:file write error for unix file %s\n",unix_name);
  477.     start++;                /* advance to the next sector */
  478.     }
  479.   reporterrs();
  480.   fclose(ofile);
  481. }
  482.  
  483. /* read in a sector */
  484. int read_sector(dsk_adr,sec,ofile)
  485. int dsk_adr,sec;
  486. FILE *ofile;
  487. { int i;
  488.   char buf[SEC],cur;            /* sector buffer */
  489.   lread((dsk_adr*CP_CLUSTER)+CP_BASE+sec,1,buf); /* read it in */
  490.   if(sec == 0)                /* start of a cluster? */
  491.     putc('.',stdout),            /* yes */
  492.     fflush(stdout);
  493.   if (mode == 't') {
  494.     for(i=0; i<SEC; i++)        /* do text translation */
  495.       switch(cur=np(buf[i])) {
  496.       case 'Z'-64:
  497.         return TRUE;            /* stop at eof */
  498.       case 'M'-64:
  499.         continue;            /* throw away returns */
  500.       default:
  501.     if(fwrite((char *)&cur,1,1,ofile) != 1)
  502.           quit(1,"\ncpmutl:write error on unix file\n");
  503.       }
  504.     }
  505.   else if(fwrite(buf,SEC,1,ofile) != 1)
  506.     quit(1,"\ncpmutl:write error on unix file\n");
  507.  return FALSE;
  508. }
  509.  
  510. /* extent handling */
  511.  
  512. /* see if ext1 matches ext2 */
  513. /* the user number field of ext is checked against user_num */
  514. match_ext(ext1,ext2)
  515. struct cp_dir_ext *ext1,*ext2;
  516. { int i;
  517.   if(!any_user && ext2->cp_et != user_num)
  518.     return FALSE;        /* fail if not the correct user */
  519.   for(i=0; i<FN_SZ; i++)
  520.     if((np(ext1->cp_fn[i]) != np(ext2->cp_fn[i])) && /* fail if not equal */
  521.        (np(ext1->cp_fn[i]) != '?'))        /* and ext1 not wild */
  522.       return FALSE;
  523.   for(i=0; i<FT_SZ; i++)
  524.     if((np(ext1->cp_ft[i]) != np(ext2->cp_ft[i])) && /* fail if not equal */
  525.        (np(ext1->cp_ft[i]) != '?'))        /* and ext1 not wild */
  526.       return FALSE;
  527.   return TRUE;                    /* success */
  528. }
  529.  
  530. /* parse the passed extent */
  531. parse_ext(rslt,name)
  532. struct cp_dir_ext *rslt;
  533. char *name;
  534. { int i; char cur;
  535.   ini_ext(rslt);            /* initialize the extent */
  536.   for(i=0; i<FN_SZ; i++) {
  537.     cur = *name;            /* fetch the char */
  538.     if(islower(cur))
  539.       cur = toupper(cur);        /* convert to upper case */
  540.     if((cur == 0) || (cur == '.'))    /* stop at eos */
  541.       break;
  542.     else if(cur == '*')            /* is it a star? */
  543.       rslt->cp_fn[i] = '?';        /* fill out with ? then */
  544.     else
  545.       rslt->cp_fn[i] = cur,
  546.       name++;
  547.     }
  548.  
  549.   if(*name == '*') {            /* need to skip a star? */
  550.     *name++;                /* get out of the * */
  551.     if(*name == 0)            /* the end of the string? */
  552.      name = "*";            /* yes, start crosses the . then */
  553.     }
  554.   if(*name == '.') *name++;        /* maybe skip the separator */
  555.  
  556.   for(i=0; i<FT_SZ; i++) {
  557.     cur = *name;            /* fetch the char */
  558.     if(islower(cur))
  559.       cur = toupper(cur);        /* convert to upper case */
  560.     if(cur == 0)            /* stop at eos */
  561.       break;
  562.     else if(cur == '*')            /* is it a star? */
  563.       rslt->cp_ft[i] = '?';        /* fill out with ? then */
  564.     else
  565.       rslt->cp_ft[i] = cur,
  566.       name++;
  567.     }
  568.   if(*name == '*') *name++;        /* get out of the * */
  569.   if(*name != 0)
  570.     quit(1,"\ncpmutl:cpm file name to long\n");
  571. }
  572.  
  573. ini_ext(rslt)
  574. struct cp_dir_ext *rslt;
  575. { int i;
  576.   rslt->cp_et = user_num;    /* mark this extent in use */
  577.   for(i=0; i<FN_SZ; i++)    /* set up the file name */
  578.     rslt->cp_fn[i] = SPACE;
  579.   for(i=0; i<FT_SZ; i++)    /* and the file type */
  580.     rslt->cp_ft[i] = SPACE;
  581.   rslt->cp_rc = 0;        /* no records yet */
  582.   rslt->cp_ex = 0;        /* relative extent number */
  583.   for(i=0; i<DM; i++)
  584.     rslt->cp_dm[i] = 0;        /* no disk space assigned yet */
  585.   for(i=0; i<2; i++)
  586.     rslt->cp_fl[i] = 0;        /* initilize filler words */
  587. }
  588.  
  589. /* random small subroutines */
  590.  
  591. /* record io errors for a transfer */
  592. int cur_io_err;
  593. markerrs()
  594. { cur_io_err = io_err;
  595. }
  596.  
  597. /* print [ok] or number of io errors */
  598. reporterrs()
  599. { if(cur_io_err != io_err)
  600.     fprintf(stderr,"\ncpmutl:%d io errors\n",io_err-cur_io_err);
  601.   else
  602.     fprintf(stdout," [ok]\n");
  603. }
  604.  
  605. /* find the next file to match cpm_name */
  606. lookup(wild,index)
  607. int index;
  608. struct cp_dir_ext *wild;
  609. { index++;                /* skip over the current extent */
  610.   for( ; index<CP_NUMDIR; index++) {
  611.     if ((cp_dir[index].cp_et == DELF) || /* forget if deleted */
  612.         (cp_dir[index].cp_ex != 0) ||    /*  or not extent 0 */ 
  613.         (!match_ext(wild,&cp_dir[index])))
  614.       continue;                /* forget it */
  615.     return(index);            /* found a match */
  616.     };
  617.   return -1;                /* no more matches */
  618. }
  619.  
  620. /* assert that the directory has not been found to be inconsistent */
  621. dirok()
  622. { if (dir_err == 0)            /* is the directory ok? */
  623.     return;
  624.   if(flag('o')) {                /* override */
  625.     fprintf(stderr,
  626.       "\ncpmutl:directory has %d error(s).  proceeding...\n",dir_err);
  627.     return;
  628.     }
  629.   quit(1,"\ncpmutl:command aborted due to %d directory error(s)\n",dir_err);
  630. }
  631.  
  632. /* some more random subroutines */
  633.  
  634. /* too many args */
  635. toomany()
  636. { quit(1,"\ncpmutl:too many arguments\n");
  637. }
  638.  
  639. /* too few args */
  640. toofew()
  641. { quit(1,"\ncpmutl:too few arguments");
  642. }
  643.  
  644. /* initialize data */
  645. init_data()
  646. { int i;
  647.   for(i=0; i<CP_ALOC; i++)
  648.     cp_btb[i] = -1;        /* initialize the bit table to free */
  649.   dsk_inuse=num_fil=num_ext=0;    /* random statistics counters */
  650.   io_err=dir_err=0;        /* error counts */
  651.   for(i=0; i<CP_NUMDIR; i++) {    /* set up the links */
  652.     ext_next[i]=ext_prev[i] = -1; /* no links */
  653.     cp_name[i][0]=0;        /*  or names yet */
  654.     }
  655.   flname = "/dev/floppy";     /* default floppy file */
  656. }
  657.  
  658. /* mark a bit in use in the bit table */
  659. set_btb(where,who)
  660. int where,who;
  661. { if((who != DIR_EXT) &&    /* really part of the directory? */
  662.      (where == 0))        /* is it really allocated? */
  663.     return;            /* no, just a place holder */
  664.   if (where >= CP_ALOC) {    /* does this cluster exist? */
  665.     dir_err++;
  666.     fprintf(stderr,"\ncpmutl:illegal cluster %d in disk map for ",where);
  667.     prname(who);
  668.     fprintf(stderr,"\n");
  669.     }
  670.   else if (cp_btb[where] != -1) { /* has someone else already claimed it? */
  671.     dir_err++;
  672.     fprintf(stderr,"\ncpmutl:Cluster %d multiply linked:\n",where);
  673.     fprintf(stderr,"  first file: "); prname(who);
  674.     fprintf(stderr,"  second file: "); prname(cp_btb[where]);
  675.     }
  676.   else {
  677.     cp_btb[where] = who;    /* remember who has it for debugging */
  678.     dsk_inuse++;        /* one more cluster in use */
  679.     }
  680. }
  681.  
  682. /* print the name of a file */
  683. prname(index)
  684. int index;
  685. { int i,temp;
  686.   if(index == DIR_EXT)
  687.     fprintf(stderr,"directory\n");
  688.   else
  689.     fprintf(stderr,"name:[%d]%s, extent:%d, recs:%d, slot:%d\n",
  690.         cp_dir[index].cp_et,cp_name[index],cp_dir[index].cp_ex,
  691.         cp_dir[index].cp_rc,index);
  692. }
  693.  
  694. /* check that the record count for index is consistent with */
  695. /* the list of clusters allocated to it in the extent map */
  696. check_rc(index)
  697. int index;
  698. { int bit_aloc,j;
  699.   bit_aloc=(cp_dir[index].cp_rc+CP_CLUSTER-1)/CP_CLUSTER;
  700.   if(bit_aloc > DM) {            /* is it in range? */
  701.     dir_err++;                /* no */
  702.     fprintf(stderr,"\ncpmutl:record count out of bounds\n  for extent:");
  703.     prname(index);
  704.     return;                /* give up on this one */
  705.     }
  706.  
  707.   for(j=0; j<bit_aloc; j++)        /* there should be enough clusters */
  708.     if(cp_dir[index].cp_dm[j] == 0)    /* allocated to cover all records */
  709.       dir_err++,            /* else an error */
  710.       fprintf(stderr,
  711.         "\ncpmutl:allocation index %d should be allocated but isn't\n",j),
  712.       fprintf(stderr,"  for extent:"),
  713.       prname(j);
  714.  
  715.   for(j=bit_aloc; j<DM; j++)        /* the rest (if any) shouldn't be */
  716.     if(cp_dir[index].cp_dm[j] != 0)    /* allocated */
  717.       dir_err++,            /* else an error */
  718.       fprintf(stderr,
  719.         "\ncpmutl:allocation index %d shouldn't be allocated but is\n",j),
  720.       fprintf(stderr,"  for extent:"),
  721.       prname(j);
  722. }
  723.  
  724. /* link extra extents to there next lower extent */
  725. link_ext()
  726. { int index,j;
  727.   for(index=0; index<CP_NUMDIR; index++) { /* link to previous extents */
  728.     if ((cp_dir[index].cp_et == DELF) || /* if this extent is deleted */
  729.         (cp_dir[index].cp_ex == 0))    /*  or there is no lower extent */
  730.       continue;                /* then nothing to link to */
  731.     for(j=0; j<CP_NUMDIR; j++) {    /* find the lower extent */
  732.       if ((cp_dir[j].cp_ex != cp_dir[index].cp_ex-1) || /* wrong ext? */
  733.       (cp_dir[j].cp_et != cp_dir[index].cp_et) || /* or wrong user */
  734.           (strcmp(cp_name[j],cp_name[index]) != 0)) /*  or the wrong name */
  735.         continue;            /*  then keep looking */
  736.       ext_next[j] = index;        /* set the links */
  737.       ext_prev[index] = j;
  738.       if(cp_dir[j].cp_rc != SEC)    /* the lower extent does have the */
  739.         dir_err++,            /* correct record count doesn't it? */
  740.         fprintf(stderr,"\ncpmutl:incorrect record count: "),
  741.         prname(j);
  742.       break;
  743.       };
  744.     if (j >= CP_NUMDIR) {        /* was a lower extent found ? */
  745.       dir_err++;            /* no, that is an error */
  746.       fprintf(stderr,"\ncpmutl:can't find lower extent: "); prname(index);
  747.       }
  748.     }
  749. }
  750.  
  751. /* set cp_name from cp_fn and cp_ft */
  752. setname(index)
  753. { int i,j,temp;
  754.   j=0;                    /* index into the file name */    
  755.   for(i=0; i<FN_SZ; i++) {
  756.     temp = np(cp_dir[index].cp_fn[i]); /* no phoonly attributes */
  757.     if ((temp < SPACE) || temp == 0177)    /* is it printable? */
  758.       dir_err++,
  759.       fprintf(stderr,
  760.         "\ncpmutl:illegal char 0%o in file name, slot:%d\n",temp,index);
  761.     if (temp == SPACE)
  762.       break;                /* stop on a space */
  763.     cp_name[index][j++] = temp;
  764.     }
  765.   cp_name[index][j++] = '.';        /* put in the . */
  766.   for(i=0; i<FT_SZ; i++) {
  767.     temp = np(cp_dir[index].cp_ft[i]);    /* no phoonly attributes */
  768.     if ((temp < SPACE) || temp == 0177)    /* is it printable? */
  769.       dir_err++,
  770.       fprintf(stderr,
  771.         "\ncpmutl:illegal char 0%o in file type, slot:%d\n",temp,index);
  772.     if (temp == SPACE)
  773.       break;                /* stop on a space */
  774.     cp_name[index][j++] = temp;
  775.     }
  776.   cp_name[index][j++] = 0;
  777.  
  778.   for(j=0; cp_name[index][j] != 0; j++)    /* convert the name to lower case */
  779.     if(isupper(temp =  cp_name[index][j]))
  780.       cp_name[index][j] = tolower(temp);
  781. }
  782.  
  783. /* write the out the directory */
  784. putdir()
  785. { dirok();                /* make sure it is ok */
  786.   lwrite(CP_BASE,CP_DIRSEC,cp_dir);
  787.   dirok();                /* make sure it is ok */
  788. }
  789.  
  790. /*
  791.   read in the floppy directory
  792. */
  793. getdir()
  794. { int index,j;
  795.   lread(CP_BASE,CP_DIRSEC,cp_dir);    /* read in the directory */
  796.   for(j=0; j<2; j++)            /* allocate the directory */
  797.     set_btb(j,DIR_EXT);            /* so it isn't free */
  798.   for(index=0; index<CP_NUMDIR; index++) { /* parse each entry */
  799.     cp_name[index][0]=0;        /* initial name */
  800.     if (cp_dir[index].cp_et == DELF)    /* is this a deleted file? */
  801.       continue;                /* not interesting then */
  802.     setname(index);            /* make up cp_name */
  803.     num_ext++;                /* found one more extent in use */
  804.     if (cp_dir[index].cp_ex == 0)    /* is it the first extent? */
  805.       num_fil++;            /* yes */
  806.     for(j=0; j<DM ;j++)            /* record the disk blocks in use */
  807.       if (cp_dir[index].cp_dm[j] != 0)    /* is this entry in use? */
  808.         set_btb(cp_dir[index].cp_dm[j],index); /* yes, owned by this extent */
  809.     check_rc(index);            /* check that rc matches allocation */
  810.     }    
  811.   link_ext();                /* link extra extents to main file */
  812.   dirok();                /* make sure it is ok */
  813. }
  814.  
  815. int cur_ext;                /* current extent or -1 */
  816. int cur_pos;                /* current position in extent */
  817. char buff[CP_CLCHAR];            /* data buffer */
  818.  
  819. /* write a file */
  820. writefile(cpm_name,unix_name)
  821. char *unix_name,*cpm_name;
  822. { extern int cur_ext;
  823.   extern int cur_pos;
  824.   int i,cur_io_err;
  825.   FILE *ifile;
  826.   char *new_file_name,*scan;
  827.   char ch;
  828.   if((ifile = fopen(unix_name,"r")) == NULL) /* open the unix file */
  829.     quit(1,"\ncpmutl:open for read of unix file %s failed\n",unix_name);
  830.   new_file_name = cpm_name;        /* default to the users arg */
  831.   if(*cpm_name == '*') {        /* need to make up a name? */
  832.     new_file_name = unix_name;        /* yes, start with this one */
  833.     scan = unix_name;            /* scan for the last / */
  834.     while (*scan != 0)            /* scan the unix name */
  835.       if(*scan++ == '/')        /* is this a / ? */
  836.         new_file_name = scan;        /* yes, remember where it is */
  837.     }
  838.  
  839.   start_new_file(new_file_name);    /* prepare for some cpm_puts */
  840.   markerrs();
  841.   fprintf(stdout,"%s => [%d]%s ",unix_name,
  842.         cp_dir[cur_ext].cp_et,cp_name[cur_ext]);
  843.   fflush(stdout);
  844.   while(TRUE) {
  845.     i = fread((char *)&ch,1,1,ifile);    /* get the next input byte */
  846.     if(i == 0) break;            /* stop this at eof */
  847.     if(i != 1)
  848.       quit(1,"\ncpmutl:read error on unix file %s\n",unix_name);
  849.     if(mode == 't') {
  850.       if((ch = np(ch)) == '\n')
  851.         cpm_put('M'-64),        /* new line is cr */
  852.         cpm_put('J'-64);        /* then lf */
  853.       else
  854.         cpm_put(ch);
  855.       }
  856.     else
  857.       cpm_put(ch);
  858.     }
  859.  
  860.   if(mode == 't') cpm_put('Z'-64);    /* the finishing touch for text */
  861.   if((cur_pos % CP_CLCHAR) != 0)    /* data left in the floppy buffer */
  862.     flbuf();                /* yes, flush the buffer */
  863.   fclose(ifile);            /* close the input file */
  864.   putdir();                /* write the directory back */
  865.   reporterrs();
  866. }
  867.  
  868. /*
  869.   write routines
  870. */
  871.  
  872. cpm_put(curchar)
  873. char curchar;
  874. { extern int cur_ext;
  875.   extern int cur_pos;
  876.   extern char buff[];
  877.   int new_ext,i,buf_ptr;
  878.   if(cur_pos >= (CP_CLCHAR*DM)) {     /* this extent already full? */
  879.     new_ext = aloc_ext();        /* make the new extent */
  880.     cur_pos = 0;            /* reset position pointer */
  881.     copy_ext(&cp_dir[cur_ext],&cp_dir[new_ext]); /* copy over the name */
  882.     cp_dir[new_ext].cp_ex = cp_dir[cur_ext].cp_ex + 1;
  883.     ext_next[cur_ext] = new_ext;    /* forward link */
  884.     ext_prev[new_ext] = cur_ext;    /* back link */
  885.     cur_ext = new_ext;
  886.     setname(cur_ext);            /* set up cp_name for it */
  887.     }
  888.   if((cur_pos % SEC) == 0)        /* going into a new record ? */
  889.     cp_dir[cur_ext].cp_rc++;        /* yes */
  890.   buf_ptr = cur_pos % CP_CLCHAR;    /* where in the buffer */
  891.   if(buf_ptr == 0)            /* need a new cluster */
  892.     cp_dir[cur_ext].cp_dm[cur_pos / CP_CLCHAR] = aloc_cluster(cur_ext);
  893.   buff[buf_ptr] = curchar;        /* store the char */
  894.   if(buf_ptr == (CP_CLCHAR-1))        /* last char of the buffer? */
  895.     flbuf();                /* yes, flush the buffer */
  896.   cur_pos++;                /* advance to the next character */
  897. }
  898.  
  899. flbuf()
  900. { extern int cur_ext;
  901.   extern int cur_pos;
  902.   extern char buff[];
  903.   lwrite((cp_dir[cur_ext].cp_dm[cur_pos / CP_CLCHAR])*CP_CLUSTER+CP_BASE,
  904.       CP_CLUSTER,buff);            /* write out the buffer */
  905.   putc('.',stdout);
  906.   fflush(stdout);
  907. }
  908.  
  909. start_new_file(name)
  910. char *name;
  911. { extern int cur_ext;
  912.   extern int cur_pos;
  913.   int cur,i;
  914.   struct cp_dir_ext temp_ext;
  915.   parse_ext(&temp_ext,name);        /* parse the file name */
  916.   nuke_ext(&temp_ext);            /* nuke matching current extents */
  917.   cur_pos = 0;
  918.   cur_ext = aloc_ext();            /* make up an extent for the file */
  919.   copy_ext(&temp_ext,&cp_dir[cur_ext]);    /* give it a name */
  920.   num_fil++;                /* this extent is really a file */
  921.   setname(cur_ext);            /* set up cp_name */
  922.   dirok();                /* make sure directory is ok */
  923. }
  924.  
  925.  
  926. /* allocate a new extent */
  927. int aloc_ext()
  928. { int i,newext;
  929.   for(newext=0; newext<CP_NUMDIR; newext++) /* look through all the extents */
  930.     if(cp_dir[newext].cp_et == DELF)
  931.       break;
  932.   if(newext >= CP_NUMDIR)    /* was a free extent found? */
  933.     quit(1,"\ncpmutl:allocate extent failure, floppy directory full\n");
  934.     
  935.   num_ext++;            /* one more extent now in use */
  936.   ini_ext(&cp_dir[newext]);    /* clear it */
  937.   return(newext);        /* return the extent to the user */
  938. }
  939.  
  940. /* allocate a new cluster */
  941. int aloc_cluster(extent)
  942. int extent;
  943. { int i;
  944.   for(i=0; i<CP_ALOC; i++)
  945.     if(cp_btb[i] == -1) {
  946.     cp_btb[i] = extent;        /* record who has it */
  947.     dsk_inuse++;        /* one more cluster in use */
  948.     return i;            /* return it to the user */
  949.     }
  950.   quit(1,"\ncpmutl:allocate disk cluster failure, floppy file system full\n");
  951. }
  952.  
  953. /*
  954.   low level read/write support routines
  955. */
  956.  
  957. fl_init()
  958. { static int inited = 0;
  959.   int flmode = 0;
  960.   if(inited) return;        /* if already open leave it alone */
  961.   inited = 1;            /* yes */
  962.   if(flag('w')) flmode = 2;    /* need to write? */
  963.   if((fldes = open(flname,flmode)) < 0)
  964.     quit(1,"\ncpmutl:Open of floppy device %s failed",flname);
  965.   if(flag('i'))
  966.     fprintf(stdout," interleaving off\n"),
  967.     fflush(stdout);
  968. }
  969.  
  970. /*  logical to physical address translation */
  971. long trans(logical)
  972. register int logical;
  973. { static int xlate[] =
  974.     {1,7,13,19,25,5,11,17,23,3,9,15,21,2,8,14,20,26,6,12,18,24,4,10,16,22};
  975.   register int sector, track;
  976.  
  977.  
  978.   if ((logical < CP_BASE) ||    /* is this even in the file system? */
  979.       flag('i'))        /* is interleaving enabled? */
  980.     return(logical);        /* no, never interleaved */
  981.   sector = logical % 26;
  982.   sector = xlate[sector]-1;
  983.   track = logical / 26;
  984.  
  985.   return((track *26) + sector);
  986. }
  987.  
  988. /*
  989.   read/write block routines
  990. */
  991.  
  992. lread(startad,count,obuff)
  993. int startad, count;
  994. char *obuff;
  995. { long trans();
  996.   extern fldes;
  997.   fl_init();
  998.   while (count--) {
  999.     lseek(fldes, trans(startad)*SEC, 0);
  1000.     if (read(fldes,obuff,SEC) != SEC) {
  1001.       io_err++;
  1002.       fprintf(stderr,"\ncpmutl: read sector error %d\n",startad);
  1003.       if ((startad >= CP_BASE) && /* is this in the directory? */
  1004.           (startad <  (CP_BASE + CP_DIRSEC)))
  1005.         dir_err++;        /* it counts as a directory error */
  1006.       }
  1007.     obuff += SEC;
  1008.     startad++;
  1009.     }
  1010. }
  1011.  
  1012. /* write some sectors to the floppy doing interleaving */
  1013. lwrite(startad,count,obuff)
  1014. int startad, count;
  1015. char *obuff;
  1016. { long trans();
  1017.   extern fldes;
  1018.   fl_init();
  1019.   while(count--) {
  1020.     lseek(fldes, trans(startad)*SEC, 0);
  1021.     if (write(fldes,obuff,SEC) != SEC) {
  1022.       io_err++;
  1023.       fprintf(stderr,"\ncpmutl: write sector error %d\n",startad);
  1024.       if ((startad >= CP_BASE) && /* is this in the directory? */
  1025.           (startad <  (CP_BASE + CP_DIRSEC)))
  1026.         dir_err++;        /* it counts as a directory error */
  1027.       }
  1028.     obuff += SEC;
  1029.     startad++;
  1030.     }
  1031. }
  1032.  
  1033. /* quit - a cmu local function */
  1034. quit(status,fmt,args)
  1035. int status;
  1036. char *fmt;
  1037. { _doprnt(fmt,&args,stderr);
  1038.   exit(status);
  1039. }
  1040.