home *** CD-ROM | disk | FTP | other *** search
/ Shareware Overload / ShartewareOverload.cdr / progm / cpgms.zip / LAR261.C < prev    next >
Text File  |  1985-08-05  |  27KB  |  1,121 lines
  1. /* 
  2.  * Lar - LU format library file maintainer 
  3.  *     by     Stephen C. Hemminger 
  4.  *         Bedford MA 
  5.  * 
  6.  *    DeSmet version T. Bonfield        Feb 84
  7.  *    DeSmet updates R. McVay            Mar 84
  8.  */
  9. #define VERSION        2
  10. #define REVISION    61
  11. #define LAST_MOD    "27 Oct 84"
  12. /* 
  13.  * DESCRIPTION 
  14.  *    Lar is a program to manipulate CP/M LU format libraries. 
  15.  *    The original CP/M library program LU is the product 
  16.  *    of Gary P. Novosielski. The primary use of lar is to combine several 
  17.  *    files together for upload/download to a personal computer. 
  18.  * 
  19.  * Usage: lar [-]key library [files] ...
  20.  * 
  21.  * Key functions are: 
  22.  * a - Add files to library    (also creates new libraries) 
  23.  * l - List directory of library
  24.  * e - Extract files from library 
  25.  * p - Print files in library 
  26.  * d - Delete files in library 
  27.  * r - Reorganize library 
  28.  * 
  29.  * EXAMPLES: 
  30.  * lar l foo.lbr        list all files in FOO.LBR 
  31.  * lar e foo.lbr 1.c 2.c    extract files 1.c, 2.c from FOO.LBR 
  32.  * lar p foo.lbr 1.c        display 1.c from FOO.LBR 
  33.  * lar a foo.lbr 1.c 2.c 3.c     add or replace files in FOO.LBR 
  34.  * 
  35.  * When creating a new library, you will be prompted for the maximum 
  36.  * number of entries it can contain. Assuming NEW.LBR doen't exist ... 
  37.  * lar a new.lbr        create an empty library 
  38.  * lar a new.lbr a.c,b.c,d.c    create NEW.LBR, add files. 
  39.  * 
  40.  * The Reorganize option causes <lbrfile>.tmp to be created, and 
  41.  * the contents of the old library to be copied into it. 
  42.  * 
  43.  * This program is public domain software, no warranty intended or 
  44.  * implied. 
  45.  * 
  46.  * 
  47.  * PORTABILITY 
  48.  *    The original version by Stephan C. Hemminger was set up for  
  49.  *    Version 7 UNIX, and was not useable as is. It has been hacked 
  50.  *    to fit the DeSmet C compiler for MSDOS. The basic 
  51.  *    problems were: fread() and fwrite() incompatibility, no  
  52.  *    text/binary differentiation problem in MSDOS. 
  53.  * 
  54.  *    Also, I have made random changes to the source merely to reflect 
  55.  *    my programming taste; he original code was quite good. I have also 
  56.  *    changed the wording of some errors, etc more in line with the current 
  57.  *    flavor of messages in the micro environment. The original Verbose 
  58.  *    flag option was removed, and made the default. No need to suppress 
  59.  *    what few messages and text there is. 
  60.  * 
  61.  *    As mentioned before, ther is no problem with text or binary files; 
  62.  *     they are treated identically. Control-Z characters are added to the 
  63.  *    end of all files to round it up to a multiple of 128 bytes. 
  64.  * 
  65.  *    Note that all files are kept as multiples of 128 bytes, to be  
  66.  *    compatible with the CP/M utility LU. This may present a problem 
  67.  *    with certain data files, but will be OK for text and .COM files 
  68.  *    anyways, and probably most other files. 
  69.  *                                             T. Bonfield
  70.  *
  71.  *  v1.1- added the exception handler for a "dashed" option and a default
  72.  *        library extension of .lbr. 
  73.  *      - fixed a bug that put the drive descriptor into the library file
  74.  *        entry.
  75.  *  v1.2- fixed a "member not found" bug by forcing all filenames to lower
  76.  *        case.
  77.  *      - changed the commands u->a and t->l to jive with LU better.
  78.  *  v1.3- fixed subtle "casting" bug in copyentry().
  79.  *      - copyentry() now uses acopy().
  80.  *      - rewrote fcopy() and acopy() to use 16K copy buffer to
  81.  *        eliminate disk thrashing on -a -e & -r.
  82.  *      - fixed "not enough room" bug in reorg().
  83.  *    v1.4- fixed bug in acopy() that crashed big member extractions.
  84.  *        - increased copy buffer size to 32K - 128.
  85.  *    v2.0-2.2- wildcards added by P.H. Mack based on v1.1
  86.  *    v2.3-2.4- ???
  87.  *    v2.5- wildcard references to members added to v1.4 (inspired by P.H. Mack)
  88.  *        - cleaned up acopy()'s handling of -p option
  89.  *        - generalized getname() & cvt_to_fcb a little
  90.  *    v2.6- wildcards for -a
  91.  *    v2.61-cleaned up a bit, sprinked in a few console status checks for
  92.  *          MultiLink users
  93.  *                                             R. McVay
  94.  * 
  95.  * * Unix is a trademark of Bell Labs. 
  96.  * ** CP/M is a trademark of Digital Research. 
  97.  */ 
  98.  
  99.  
  100. #include <stdio.h>
  101.  
  102. /* Library file status values: */ 
  103.  
  104. #define ACTIVE    0 
  105. #define UNUSED    0xff 
  106. #define    DELETED    0xfe 
  107. #define    CTRLZ    0x1a 
  108.  
  109. #define    MAXFILES 256
  110. #define    SECTOR     128 
  111. #define BIGBUFF 32640
  112. #define    DSIZE    (sizeof(struct ludir)) 
  113. #define    SLOTS_SEC (SECTOR/DSIZE) 
  114. #define    equal(s1, s2) (    strcmp(s1,s2) == 0 ) 
  115. #define FALSE    0 
  116. #define    TRUE    1 
  117. #define    BOOL    int 
  118.  
  119. /* Globals */ 
  120. char    *fname[MAXFILES]; 
  121. BOOL    ftouched[MAXFILES]; 
  122.  
  123. struct ludir {            /* internal dir. stucture, 32 bytes */ 
  124.     char    l_stat;        /* 12 byte filename: */ 
  125.     char    l_name[8];
  126.     char    l_ext[3];
  127.     int        l_off;            /* offset in library, */ 
  128.     int        l_len;            /* length of file, */ 
  129.     char    l_fill[16];        /* 16 byte filler, */ 
  130. } ldir[MAXFILES]; 
  131.  
  132. int        errcnt,
  133.         nfiles,
  134.         nslots; 
  135.  
  136. char    *getname(),
  137.         *strlower(),
  138.         *malloc(); 
  139.  
  140. long    lseek();
  141.  
  142. char    aname[20];        /* global library name reference */
  143.  
  144.  
  145. main(argc, argv) 
  146. int        argc; 
  147. char    *argv[]; 
  148. { 
  149.     char    *flagp,
  150.             *request; 
  151.  
  152.     if (argc < 3)
  153.         help(); 
  154.     if (*argv[1] == '-') /* strip the dash if present */
  155.         ++argv[1];
  156.     *argv[1] = tolower(*argv[1]);
  157.  
  158.     strcpy(aname, argv[2]);            /* name of LBR file, */ 
  159.     if ((index(aname, "*") > -1) || (index(aname, "?") > -1))
  160.             error("wildcards not allowed in library name");
  161.     if (index(aname, ".") == -1)    /* add default extension .lbr */
  162.         strcat(aname, ".lbr");
  163.     argv[2] = aname;
  164.  
  165.     filenames(argc, argv); 
  166.  
  167.     switch (*argv[1])
  168.     { 
  169.         case 'l':            /* list table of contents */
  170.             table(aname); 
  171.             break; 
  172.  
  173.         case 'a':            /* add */
  174.             update(aname); 
  175.             break; 
  176.  
  177.         case 'e':            /* extract members */
  178.             getfiles(aname, FALSE); 
  179.             break; 
  180.  
  181.         case 'p':            /* print members */
  182.             getfiles(aname, TRUE); 
  183.             break; 
  184.  
  185.         case 'd':            /* delete members */
  186.             delete(aname); 
  187.             break; 
  188.  
  189.         case 'r':            /* reorganize library */
  190.             reorg(aname); 
  191.             break; 
  192.  
  193.         default:            /* bad request */
  194.             printf("err: unrecognized function [%s]\n\n", argv[1]);
  195.             help(); 
  196.             break;
  197.     } 
  198.     exit(0); 
  199. } 
  200.  
  201.  
  202. /************************************************************************
  203. * Get file names, check for dups, and initialize                        * 
  204. * This is where we'll encounter and expand wildcards                    *
  205. ************************************************************************/
  206.  
  207. filenames(ac, av)
  208. int        ac;
  209. char    *av[]; 
  210. { 
  211.     int i,
  212.         j; 
  213.  
  214.     errcnt = 0; 
  215.     for (i = 3, j = 0; i < ac; i++, j++)
  216.     { 
  217.         fname[j] = calloc(15, 1);    /* we're going to copy all file args */
  218.         cvt_to_fcb(strlower(av[i]), fname[j]); 
  219.         ftouched[j] = FALSE; 
  220.         if (j >= MAXFILES) 
  221.             error("Too many file names."); /* we'll double check in wildexp() */
  222.         if (index(fname[j], "?") > -1)
  223.             j = wildexp(j, *av[1]);
  224.     } 
  225.     nfiles = j; 
  226.  
  227.     for (i = 0; i < nfiles; i++)     /* pack 'em back up */
  228.     {
  229.         j = index(fname[i], ":") + 1;
  230.         strcpy(fname[i]+j, getname(fname[i]+j));
  231.     }
  232.  
  233.     for (i = 0; i < nfiles; i++)
  234.     {
  235.         for (j = i + 1; j < nfiles; j++)
  236.         {
  237.             if (equal(fname[i], fname[j]))
  238.             { 
  239.                 printf("%s ", fname[i]); 
  240.                 error("duplicate file name"); 
  241.             }
  242.         }
  243.     } 
  244. } 
  245.  
  246.  
  247. /************************************************************************
  248. * Do wildcard expansion of ambiguous name at fname[j].                    *
  249. * Return the resulting "expanded" index to the last name in the fname    *
  250. * list.                                                                    *
  251. ************************************************************************/
  252.  
  253. wildexp(j, func)
  254. int        j;
  255. char    func;
  256. {
  257. #define    GETDTA    0x2F00
  258. #define    FIRST    0x1100
  259. #define    NEXT    0x1200
  260.     FILE    lfd;
  261.     char    pattern[15], libname[15];
  262.     int        i, k, mode, oj;
  263.     int        our_dta_oset, our_dta_seg;
  264.     extern    int    _rax, _rbx, _rdx, _rds, _res;
  265.  
  266.     struct fcb
  267.     {
  268.         char    drvnum,
  269.                 name[8],
  270.                 ext[3],
  271.                 misc[20];
  272.     } search_fcb;
  273.         
  274.  
  275.     strcpy(pattern, fname[j]);    /* this allows us to return an    */
  276.     free(fname[j]);                /* index to a valid name, even    */
  277.     oj = --j;                    /* if none is found here        */
  278.  
  279.     if (func == 'a')
  280.     {
  281.         /* Then expansion must be done on disk file names.    *
  282.          * Sorry, but this is very compiler dependent.    The    *
  283.          * following code uses DeSmet's _doint() and a pre-    *
  284.          * defined set of "register" variables.                */
  285.  
  286.         for (i = 0; i < 15; libname[i++] = '\0')
  287.             ;
  288.         cvt_to_fcb(aname, libname);
  289.  
  290.         _rax = GETDTA;
  291.         _doint(0x21);
  292.         our_dta_seg = _res;
  293.         our_dta_oset = _rbx;
  294.  
  295.         /* The first order of business is to set up the fcb    *
  296.          * the DOS will use as a pattern for the search.    */
  297.  
  298.         if (pattern[1] == ':')    /* set up drive number        */
  299.         {
  300.             search_fcb.drvnum = toupper(*pattern) - 'A' + 1;
  301.             strcpy(search_fcb.name, pattern + 2);
  302.         }
  303.         else
  304.         {
  305.             search_fcb.drvnum = '\0';
  306.             strcpy(search_fcb.name, pattern);
  307.         }
  308.  
  309.         /* Now we'll scan any matching filenames into         *
  310.          * fnames[] using an algorithm stolen shamelessly    *
  311.          * from sq18u.c.                                    */
  312.  
  313.         for (mode = FIRST;; mode = NEXT)
  314.         {
  315.             csts();        /* for MultiLink users */
  316.             _rdx = search_fcb;
  317.             _rds = -1;
  318.             _rax = mode;
  319.             _doint(0x21);
  320.             if ((_rax & 0xFF) == 0xFF)    /* no match found    */
  321.                 break;
  322.  
  323.             ++j;
  324.             if (j >= MAXFILES)
  325.                 error("(wildexp) too many files");
  326.             else
  327.                 fname[j] = calloc(15, 1);
  328.             if (!fname[j])
  329.                 error("(wildexp) out of memory");
  330.             else
  331.             {
  332.                 if (pattern[1] == ':')
  333.                 {
  334.                     fname[j][0] = *pattern;
  335.                     fname[j][1] = ':';
  336.                     i = 2;
  337.                 }
  338.                 else
  339.                     i = 0;
  340.                 _lmove(11, our_dta_oset + 1, our_dta_seg, &fname[j][i], _showds());
  341.                 fname[j][i + 11] = '\0';
  342.                 if (equal(libname, fname[j]))
  343.                 {
  344.                     free(fname[j]);
  345.                     --j;
  346.                 }
  347.             }
  348.         }
  349.     }
  350.     else
  351.     {
  352.         /* expansion is from names in library table of contents */
  353.         /* library name can't be ambiguous                        */
  354.         if ((lfd = open(aname, 2)) == -1)
  355.             cant(aname);
  356.         getdir(lfd);
  357.  
  358.         for (i = 1; i < nslots; i++)
  359.         {
  360.             csts();        /* for MultiLink users */
  361.             if (ldir[i].l_stat == ACTIVE)
  362.             {
  363.                 ldir[i].l_off = 0;    /* setting up end of string */
  364.                 if (amatch(pattern, ldir[i].l_name))
  365.                 {
  366.                     ++j;
  367.                     if (j >= MAXFILES)
  368.                         error("(wildexp) too many files");
  369.                     else
  370.                         fname[j] = calloc(15, 1);
  371.                     if (!fname[j])
  372.                         error("(wildexp) out of memory");
  373.                     else
  374.                         strcpy(fname[j], ldir[i].l_name);
  375.                 }
  376.             }
  377.         }
  378.     }
  379.     if (j == oj)
  380.         printf("wildexp: %s not matched\n", pattern);
  381.     return(j);
  382. }
  383.  
  384.  
  385. /************************************************************************
  386. * try to match a filename to an ambiguous pattern; lengths must match    *
  387. ************************************************************************/
  388.  
  389. amatch(pattern, fname)
  390. char    *pattern,
  391.         *fname;
  392. {
  393.     while (*pattern && *fname)
  394.     {
  395.         if ((*pattern != '?') && (*pattern != *fname))
  396.             return(FALSE);
  397.         ++pattern;
  398.         ++fname;
  399.     }
  400.     return(*pattern == *fname);
  401. }
  402.  
  403.  
  404. /************************************************************************
  405. * list the contents and statistics of the library                        *
  406. ************************************************************************/
  407.  
  408. table(lib) 
  409. char *lib; 
  410. { 
  411.     FILE    lfd; 
  412.     int        i,
  413.             total; 
  414.     int        active = 0, 
  415.             unused = 0, 
  416.             deleted = 0; 
  417.     char     *uname; 
  418.  
  419.     if ((lfd = open(lib,2)) == -1) 
  420.         cant(lib); 
  421.  
  422.     getdir(lfd); 
  423.     total =    ldir[0].l_len; 
  424.     printf("Name         Index    Length (128 byte blocks)\n"); 
  425.     printf("Directory    %4u    %6u\n", 0, total); 
  426.  
  427.     for (i = 1; i < nslots;    i++)
  428.     {
  429.         csts();        /* for MultiLink users */
  430.         switch(ldir[i].l_stat) 
  431.         { 
  432.             case ACTIVE: 
  433.                 active++; 
  434.                 uname = getname(&ldir[i].l_name); 
  435.                 total += ldir[i].l_len; 
  436.                 printf("%-12s %4u   %7u\n", uname,ldir[i].l_off,ldir[i].l_len); 
  437.                 break; 
  438.             case UNUSED: 
  439.                 unused++; 
  440.                 break; 
  441.             default: 
  442.                 deleted++; 
  443.                 break;
  444.         }
  445.     } 
  446.     printf("-----------------------------\n"); 
  447.     printf("Total blocks        %7u\n", total); 
  448.     printf("\nLibrary %s has %u slots, %u deleted, %u active, %u unused\n", 
  449.         lib, nslots, deleted, active, unused); 
  450.     close(lfd); 
  451.     not_found (); 
  452. } 
  453.  
  454.  
  455. /************************************************************************
  456. * add new members to a library; create the library if necessary            *
  457. ************************************************************************/
  458.  
  459. update(name) 
  460. char    *name; 
  461. { 
  462.     FILE    lfd; 
  463.     int        i; 
  464.      
  465.     if ((lfd = open(name,2)) == -1)
  466.     { 
  467.         if ((lfd = creat(name)) == -1) 
  468.             cant(name); 
  469.         initdir(lfd); 
  470.     }  
  471.     getdir(lfd);            /* read directory, */ 
  472.  
  473.     for (i = 0; (i < nfiles) && (errcnt == 0); i++) 
  474.         addfil(fname[i], lfd); 
  475.     if (errcnt != 0) 
  476.         printf("fatal errors - last file may be bad\n"); 
  477.     putdir(lfd); 
  478.     close(lfd); 
  479. } 
  480.  
  481.  
  482. /************************************************************************
  483. * extract (or print if pflag) a library member                            *
  484. ************************************************************************/
  485.  
  486. getfiles(name, pflag) 
  487. char    *name; 
  488. BOOL    pflag; 
  489. { 
  490.     FILE    lfd,
  491.             ofd; 
  492.     int        i; 
  493.     char    *unixname; 
  494.  
  495.     if ((lfd = open(name,2)) == -1) 
  496.         cant (name); 
  497.  
  498.     getdir(lfd); 
  499.  
  500.     for (i = 1; i < nslots;    i++) 
  501.     { 
  502.         if (ldir[i].l_stat == ACTIVE) 
  503.         {
  504.             unixname = getname(&ldir[i].l_name); 
  505.             if (filarg(unixname)) 
  506.             {
  507.                 printf("Extracting %s\n", unixname); 
  508.                 
  509.                 if (pflag) 
  510.                     ofd = STDOUT; 
  511.                 else 
  512.                     ofd = creat(unixname); 
  513.     
  514.                 if (ofd == -1) 
  515.                 { 
  516.                     printf("%s - can't create output file\n",unixname); 
  517.                     errcnt++; 
  518.                 } 
  519.                 else 
  520.                 { 
  521.                     lseek(lfd, (long) ldir[i].l_off * SECTOR,0); 
  522.                     acopy(lfd, ofd, ldir[i].l_len); 
  523.                     if (!pflag) 
  524.                         close(ofd); 
  525.                 } 
  526.             }
  527.         }
  528.     } 
  529.     close(lfd); 
  530.     not_found(); 
  531. } 
  532.  
  533.  
  534. /************************************************************************
  535. * mark a library directory entry as deleted                                *
  536. ************************************************************************/
  537.  
  538. delete(lname) 
  539. char    *lname; 
  540. { 
  541.     FILE    f; 
  542.     int        i; 
  543.  
  544.     if ((f = open(lname,2)) == -1) 
  545.         cant(lname); 
  546.  
  547.     if (nfiles <= 0) 
  548.         error("delete by name only"); 
  549.  
  550.     getdir(f); 
  551.     for (i = 0; i < nslots;    i++)
  552.     { 
  553.         if (filarg(getname(&ldir[i].l_name))) 
  554.             ldir[i].l_stat = DELETED; 
  555.     } 
  556.  
  557.     not_found(); 
  558.     if (errcnt > 0) 
  559.         printf("errors - library not updated\n"); 
  560.     else
  561.         putdir(f); 
  562.     close(f); 
  563. } 
  564.  
  565.  
  566. /************************************************************************
  567. * reorganize a library                                                    *
  568. ************************************************************************/
  569.  
  570. reorg(name) 
  571. char    *name; 
  572. { 
  573.     FILE    olib,
  574.             nlib; 
  575.     int        oldsize,
  576.             i,
  577.             j; 
  578.     struct    ludir    odir[MAXFILES]; 
  579.     char    tmpname[SECTOR]; 
  580.  
  581.     for (i = 0; (i < 8) && (name[i] != '.'); i++) /* copy filename, */ 
  582.         tmpname[i]= name[i];        /* strip off extention, */ 
  583.     tmpname[i]= '\0'; 
  584.     strcat(tmpname,".tmp");            /* make new name, */ 
  585.  
  586.     if ((olib = open(name,2)) == -1) 
  587.         cant(name); 
  588.  
  589.     if ((nlib = creat(tmpname)) == -1) 
  590.         cant(tmpname); 
  591.  
  592.     getdir(olib); 
  593.     printf("Old library has %d slots\n", oldsize = nslots); 
  594.     for (i = 0; i < nslots ; i++) 
  595.         copymem((char *)&odir[i], (char *)&ldir[i], sizeof(struct ludir)); 
  596.     initdir(nlib); 
  597.     errcnt = 0; 
  598.  
  599.     for (i = j = 1; (i < oldsize) && !errcnt; i++) 
  600.     {
  601.         if (odir[i].l_stat == ACTIVE)
  602.         { 
  603.             printf("Copying: %-8.8s.%3.3s\n", &odir[i].l_name, &odir[i].l_ext); 
  604.             copyentry(&odir[i], olib, &ldir[j], nlib); 
  605.             if (++j > nslots)
  606.             { 
  607.                 errcnt++; 
  608.                 printf("Not enough room in new library\n"); 
  609.             } 
  610.         }
  611.     } 
  612.  
  613.     close(olib); 
  614.     putdir(nlib); 
  615.     close(nlib); 
  616.  
  617.     if (errcnt)
  618.     { 
  619.         printf("Errors, library not updated\n"); 
  620.         unlink(tmpname); 
  621.     }
  622.     else
  623.     { 
  624.         unlink(name);            /* delete orig file, */ 
  625.         rename(tmpname,name);        /* rename it, */ 
  626.     } 
  627. } 
  628.  
  629.  
  630. /************************************************************************ 
  631. * print error message and exit                                            *
  632. ************************************************************************/
  633.  
  634. help()
  635. { 
  636.     printf("LAR v%d.%d - %s\n", VERSION, REVISION, LAST_MOD); 
  637.     printf("\nUsage: lar [-]<aledrp> library [files] ...\n"); 
  638.     printf("\nFunctions are:\n\ta - Add files to library (*)\n"); 
  639.     printf("\tl - List library directory\n"); 
  640.      printf("\te - Extract files from library (*)\n"); 
  641.     printf("\td - Delete files in library (*)\n"); 
  642.     printf("\tr - Reorganize library\n"); 
  643.     printf("\tp - Print files in library (*)\n"); 
  644.     printf("\nAssumed library extension is .LBR\n");
  645.     printf("\n(*) Wildcards allowed with these functions.\n");
  646.     exit(1); 
  647. }
  648.  
  649.  
  650. /************************************************************************ 
  651. * return index of t in s, -1 if none                                    *
  652. ************************************************************************/
  653.  
  654. index(s, t)
  655. char    *s,
  656.         *t;
  657. {
  658.     int        i,
  659.             j,
  660.             k;
  661.  
  662.     for (i = 0; s[i] != '\0'; i++)
  663.     {
  664.         for (j = i, k = 0; t[k] != '\0' && s[j] == t[k]; j++, k++)
  665.             ;
  666.         if (t[k] == '\0')
  667.             return(i);
  668.     }
  669.     return(-1);
  670. }
  671.  
  672.  
  673. /************************************************************************ 
  674. * print an error message string and exit                                *
  675. ************************************************************************/
  676.  
  677. error(str) 
  678. char *str; 
  679. { 
  680.     printf("LAR: %s\n", str); 
  681.     exit(1); 
  682. } 
  683.  
  684.  
  685. /************************************************************************
  686. * can't perform function because of file error                            *
  687. ************************************************************************/
  688.  
  689. cant(name) 
  690. char *name; 
  691. { 
  692.  
  693.     printf("%s: File open error\n", name); 
  694.     exit(1); 
  695. } 
  696.  
  697.  
  698. /************************************************************************
  699. * read the directory of a library into the ludir structure                *
  700. ************************************************************************/
  701.  
  702. getdir(f) 
  703. FILE f; 
  704. { 
  705.     int cnt; 
  706.  
  707.     lseek(f,0L,0); 
  708.     if (read(f,&ldir[0],DSIZE) != DSIZE)    /* read 1st entry to find */ 
  709.         error("No directory\n");            /* number of slots, */ 
  710.  
  711.     nslots = ldir[0].l_len * SLOTS_SEC; 
  712.     cnt = DSIZE * (nslots - 1);                /* already read one slot, */ 
  713.  
  714.     if (read(f,&ldir[1],cnt) != cnt) 
  715.         error("Can't read directory - is it a library?"); 
  716. } 
  717.  
  718.  
  719. /************************************************************************
  720. * write the ludir structure to the beginning of the library file        *
  721. ************************************************************************/
  722.  
  723. putdir(f) 
  724. FILE f; 
  725. { 
  726.  
  727.     lseek(f,0L,0); 
  728.     if (write(f,&ldir,nslots * DSIZE) != (nslots * DSIZE)) 
  729.         error("Can't write directory - library may be botched"); 
  730. } 
  731.  
  732.  
  733. /************************************************************************
  734. * format a virgin library directory                                        *
  735. ************************************************************************/
  736.  
  737. initdir(f) 
  738. FILE f; 
  739. { 
  740.     int i; 
  741.     int numsecs; 
  742.     char line[80]; 
  743.  
  744.     do
  745.     { 
  746.         puts ("Number of slots to allocate: "); 
  747.         gets(line); 
  748.         putchar('\n'); 
  749.         nslots = atoi (line); 
  750.         if (nslots < 1)
  751.         {
  752.             nslots = 0;
  753.             printf("Must have at least one!\n");
  754.         }
  755.         else if (nslots > MAXFILES)
  756.         {
  757.             nslots = 0; 
  758.             printf("Too many slots\n"); 
  759.         }
  760.     }
  761.     while (nslots == 0); 
  762.  
  763.     numsecs    = nslots / SLOTS_SEC; 
  764.     if (nslots != numsecs * SLOTS_SEC)
  765.         ++numsecs;
  766.     nslots = numsecs * SLOTS_SEC; 
  767.  
  768.     for (i = 0; i < nslots;    i++)
  769.     { 
  770.         ldir[i].l_stat = UNUSED; 
  771.         blank_fill(&ldir[i].l_name,8); 
  772.         blank_fill(&ldir[i].l_ext,3); 
  773.     } 
  774.     ldir[0].l_stat = ACTIVE; 
  775.     ldir[0].l_len = numsecs; 
  776.  
  777.     putdir(f); 
  778. } 
  779.  
  780.  
  781. /************************************************************************
  782. * Fill a string with blanks, no trailing null                            *
  783. ************************************************************************/
  784.  
  785. blank_fill(s, n)
  786. char    *s; 
  787. int        n; 
  788. { 
  789.     while (n--) *s++= ' '; 
  790. } 
  791.  
  792.  
  793. /************************************************************************
  794. * convert nm.ex to a Unix style string                                    *
  795. ************************************************************************/
  796.  
  797. char *getname(nm)
  798. char    *nm; 
  799. { 
  800.     static char namebuf[14]; 
  801.     int        i,
  802.             j; 
  803.  
  804.     for (i = 0; (i < 8) && (nm[i] != ' '); i++) 
  805.         namebuf[i] = tolower(nm[i]); 
  806.     namebuf[i++] = '.';
  807.     j = i;
  808.  
  809.     for (i = 8; (i < 11) && (nm[i] != ' '); i++, j++) 
  810.         namebuf[j] = tolower(nm[i]); 
  811.     namebuf[j] = '\0'; 
  812.  
  813.     return namebuf; 
  814. } 
  815.  
  816.  
  817. /************************************************************************
  818. * check if name matches argument list                                    *
  819. ************************************************************************/
  820.  
  821. filarg(name)
  822. char    *name; 
  823. { 
  824.     register int i;
  825.  
  826.     if (nfiles <= 0) 
  827.         return 1; 
  828.  
  829.     for (i = 0; i < nfiles;    i++) 
  830.     if (equal(name, fname[i]))
  831.     { 
  832.         ftouched[i] = TRUE; 
  833.         return    1; 
  834.     } 
  835.  
  836.     return 0; 
  837. } 
  838.  
  839.  
  840. /************************************************************************
  841. * tolower() all characters in a string                                *
  842. ************************************************************************/
  843.  
  844. char *strlower(string)
  845. char *string;
  846. {
  847.     char *ptr;
  848.  
  849.     ptr = string;
  850.     while (*string)
  851.     {
  852.         *string = tolower(*string);
  853.         ++string;
  854.     }
  855.     return(ptr);
  856. } 
  857.  
  858.  
  859. /************************************************************************
  860. * print an error message for unmatched argument and bump errcnt            *
  861. ************************************************************************/
  862.  
  863. not_found() 
  864. { 
  865.     register int i; 
  866.  
  867.     for (i = 0; i < nfiles;    i++) 
  868.     if (!ftouched[i])
  869.     { 
  870.         printf("%s : not in library.\n", fname[i]); 
  871.         errcnt++; 
  872.     } 
  873. } 
  874.  
  875.  
  876. /************************************************************************
  877. * copy nsec*128 bytes from one file to another                            *
  878. ************************************************************************/
  879.  
  880. acopy(fdi, fdo, nsecs) 
  881. FILE    fdi,
  882.         fdo; 
  883. int        nsecs; 
  884. { 
  885.     char    *buf; 
  886.     int        n,
  887.             i;
  888.  
  889.     if ((buf = malloc(BIGBUFF)) == 0)
  890.         error("acopy: not enough memory for BIGBUFF");
  891.  
  892.      do
  893.      { 
  894.         csts();        /* for MultiLink users */
  895.         if ((n = read(fdi, buf, min(BIGBUFF/SECTOR, nsecs) * SECTOR)) == -1) 
  896.             error("acopy: read error");
  897.         if (fdo == STDOUT)
  898.         {
  899.             for (i = 0; (i < n) && (buf[i] != CTRLZ); i++)
  900.                 putchar(buf[i]);
  901.             if (buf[i] == CTRLZ)
  902.                 puts("\n\n");
  903.         }
  904.         else if (write(fdo, buf, n) != n) 
  905.             error("acopy: write error"); 
  906.         nsecs -= n/SECTOR;
  907.     }
  908.     while (nsecs);
  909.  
  910.     free(buf);
  911. }
  912.  
  913.  
  914. /************************************************************************
  915. * return the lesser of two numbers                                        *
  916. ************************************************************************/
  917.  
  918. min(num1, num2)
  919. int        num1,
  920.         num2;
  921. {
  922.     if (num1 < num2)
  923.         return(num1);
  924.     else
  925.         return(num2);
  926. }
  927.  
  928.  
  929. /************************************************************************
  930. * add a member to the library                                            *
  931. ************************************************************************/
  932.  
  933. addfil(name, lfd) 
  934. char    *name; 
  935. FILE    lfd; 
  936. { 
  937.     FILE    ifd; 
  938.     int        secoffs,
  939.             numsecs, 
  940.             i; 
  941.  
  942.     if ((ifd = open(name,2)) == -1)
  943.     { 
  944.         printf("--- can't find library %s\n",name); 
  945.         errcnt++; 
  946.         return; 
  947.     } 
  948.     for (i = 0; i < nslots;    i++)
  949.     { 
  950.         if (equal(getname(&ldir[i].l_name), name))
  951.         { 
  952.             printf("Updating existing file %s\n", name); 
  953.             break; 
  954.         } 
  955.         if (ldir[i].l_stat != ACTIVE)
  956.         { 
  957.             printf("Adding new file %s\n", name); 
  958.             break; 
  959.         } 
  960.     } 
  961.     if (i >= nslots)
  962.     { 
  963.         printf("Can't add %s, library is full\n", name); 
  964.         errcnt++; 
  965.         return; 
  966.     } 
  967.  
  968.     ldir[i].l_stat = ACTIVE; 
  969.     name += index(name, ":") + 1;    /* remove drive descriptor */
  970.     cvt_to_fcb(name, &ldir[i].l_name); 
  971.     /* append to end */ 
  972.     secoffs    = lseek(lfd, 0L, 2) / SECTOR; 
  973.  
  974.     ldir[i].l_off = secoffs; 
  975.     numsecs = fcopy(ifd, lfd); 
  976.     ldir[i].l_len = numsecs; 
  977.     close(ifd); 
  978. } 
  979.  
  980.  
  981. /************************************************************************
  982. * copy a complete file into the library                                    *
  983. ************************************************************************/
  984.  
  985. fcopy(ifd, ofd) 
  986. FILE    ifd,
  987.         ofd; 
  988. { 
  989.     int        total = 0; 
  990.     int        n; 
  991.     char    *sectorbuf; 
  992.  
  993.     if ((sectorbuf = malloc(BIGBUFF)) == 0)
  994.         error("fcopy: no buffer");
  995.  
  996.     do
  997.     { 
  998.         csts();        /* for MultiLink users */
  999.         if ((n = read(ifd, sectorbuf, BIGBUFF)) == -1)
  1000.             error("fcopy: read error"); 
  1001.         while (n % SECTOR)
  1002.             sectorbuf[n++] = CTRLZ;
  1003.         if (write(ofd, sectorbuf, n) != n) 
  1004.             error("fcopy: write error"); 
  1005.         total += n/SECTOR; 
  1006.     }
  1007.     while (n == BIGBUFF);
  1008.  
  1009.     free(sectorbuf); 
  1010.     return total; 
  1011. } 
  1012.  
  1013.  
  1014. /************************************************************************
  1015. * copy a directory entry from one ludir structure to another            *
  1016. ************************************************************************/
  1017.  
  1018. copyentry(old, of, new, nf) 
  1019. struct    ludir    *old,
  1020.                 *new; 
  1021. FILE    of,
  1022.         nf; 
  1023. {  
  1024.     int        secoffs,
  1025.             numsecs;
  1026.  
  1027.     new->l_stat = ACTIVE; 
  1028.     copymem(&new->l_name, &old->l_name, 8); 
  1029.     copymem(&new->l_ext, &old->l_ext, 3); 
  1030.     lseek(of, (long)old->l_off * SECTOR, 0); /* home of subtle bug */
  1031.     secoffs = lseek(nf, 0L, 2) / SECTOR; 
  1032.  
  1033.     new->l_off = secoffs; 
  1034.     numsecs    = old->l_len; 
  1035.     new->l_len = numsecs; 
  1036.  
  1037.     acopy(of, nf, numsecs);
  1038. } 
  1039.  
  1040.  
  1041. /************************************************************************
  1042. * memory move used by copyentry()                                        *
  1043. ************************************************************************/
  1044.  
  1045. copymem(dst, src, n) 
  1046. char    *dst,
  1047.         *src; 
  1048. unsigned n; 
  1049. { 
  1050.     while(n--) 
  1051.         *dst++ = *src++; 
  1052. } 
  1053.  
  1054.  
  1055. /************************************************************************
  1056. * Convert a normal asciiz string to MSDOS/CPM FCB format.                *
  1057. * Make the filename portion 8 characters, extention 3 maximum.             * 
  1058. * Expand *'s into ?'s.                                                    *
  1059. * NOTE: doesn't end outname[] with \0, doesn't strip drive descriptor    *
  1060. ************************************************************************/
  1061.  
  1062. cvt_to_fcb(inname, outname) 
  1063. char    *inname; 
  1064. char    outname[]; 
  1065. { 
  1066.     char    c; 
  1067.     int        i,j; 
  1068.  
  1069.     for (i = 0; i <= index(inname, ":"); i++) /* do drive descriptor */
  1070.         outname[i] = inname[i];                  /* if present            */
  1071.     inname += i;
  1072.     outname += i;
  1073.  
  1074.     for (i = 0; i < 8; i++)        /* now expand the inname */
  1075.     { 
  1076.         switch (*inname)
  1077.         {
  1078.             case '\0':                /* if null or        */ 
  1079.             case '.':                /* if a dot            */
  1080.                 outname[i] = ' ';    /* pad with blanks, */ 
  1081.                 break;
  1082.  
  1083.             case '*':                /* if asterisk        */
  1084.                 outname[i] = '?';    /* pad with ?'s        */
  1085.                 break;
  1086.  
  1087.             default:
  1088.                 outname[i] = toupper(*inname); 
  1089.                 ++inname; 
  1090.         } 
  1091.     } 
  1092.  
  1093.     if (*inname == '*')        /* handle the *.ext case */
  1094.         ++inname;
  1095.     if (*inname == '.')
  1096.         ++inname;
  1097.  
  1098.     for (; i < 11; i++)        /* now expand the extension */
  1099.     { 
  1100.         switch (*inname)
  1101.         {
  1102.             case '\0':                /* if null or        */ 
  1103.                 outname[i] = ' ';    /* pad with blanks, */ 
  1104.                 break;
  1105.  
  1106.             case '*':                /* if asterisk        */
  1107.                 outname[i] = '?';        /* pad with ?'s        */
  1108.                 break;
  1109.  
  1110.             case '.':                /* if a dot, */ 
  1111.                 error("(cvt_to_fcb) invalid name");    /* error out */ 
  1112.                 break;
  1113.  
  1114.             default:
  1115.                 outname[i] = toupper(*inname); 
  1116.                 ++inname; 
  1117.         } 
  1118.     } 
  1119.     return; 
  1120. }