home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / MODEM / YAM.ZIP / YAM7.C < prev    next >
Encoding:
C/C++ Source or Header  |  1988-07-28  |  17.8 KB  |  834 lines
  1. /*
  2. >>:yam7.c 04-Mar-84 (diff 08-11-81)
  3.  * Logfile sprinf fixed to write correct length record
  4.  * closerx fixed so as not to pad a file abnormal due to write errors
  5.  * File open and close stuff and more ...
  6.  * This file assumes operation on a CP/M system
  7.  */
  8.  
  9. #include <YAM.H>
  10.  
  11. /* dpb dph blocks from CP/M Interface Guide Sect 6.5 */
  12.  
  13. struct dpb {    /* CP/M Version 2 Disk Parameter Block */
  14.     unsigned dpb_spt;    /* sectors per track */
  15.     char dpb_bsh;        /* block shift factor */
  16.     char dpb_blm;
  17.     char dpb_exm;        /* Extent Mask */
  18.     unsigned dpb_dsm;    /* Highest block number on this disk */
  19.     unsigned dpb_drm;    /* total number of directory entries -1 */
  20.     unsigned dpb_al;    /* bit field corresponding to direc blocks */
  21.     unsigned dpb_cks;    /* size of the directory check vector */
  22.     unsigned dpb_off;    /* number of reserved tracks on this disk */
  23. };
  24.  
  25. char *call();
  26.  
  27. struct dph {    /* CP/M Version 2 Disk Parameter Header */
  28.     char **dph_xlt;        /* logical to physical xlat vector */
  29.     int dph_ooo;
  30.     char *dph_dirbuf;    /* 128 byte scratchpad for directory use */
  31.     struct dpb *dph_dpb;    /* disk param block for this type of disk */
  32.     char **dph_csv;        /* scratch area for detecting changed disks */
  33.     char *dph_alv;        /* pointer to bit vector alloc map for disk */
  34. };
  35.  
  36. struct fcb {    /* CP/M Version 2 fcb AS SEEN BY THE USER */
  37.     char    dr;        /* drive number */
  38.     char    fname[8];    /* fname[1] used by TAG2 */
  39.     char    ftype[3];    /* ftype[1] 8th bit set for $SYS */
  40.     char    ex;        /* file extent normally 0 */
  41.     char    s1;        /* reserved for bdos's benefit */
  42.     char    s2;        /* likewise, =0 on call to open,make,search */
  43.     char    rc;        /* record count for extent[ex]  0...128 */
  44.     char    dmap[16];
  45.     char    cr;        /* current record, initialized to 0 by usr */
  46.     unsigned recn;        /* highest record number */
  47.     char    recovf;        /* overflow of above */
  48. };
  49.  
  50. /* following are BIOS calls */
  51. #define CONST 2            /* bios console char ready */
  52. #define CONIN 3            /* bios cons char input */
  53. #define CONOUT 4        /* bios cons char output */
  54.  
  55. /* following are BDOS calls */
  56. #define BDOS 5            /* address used to call bdos */
  57. #define SELDSK 14        /* bdos select disk 0=default disk */
  58. #define SRCH 17         /* bdos search for file pattern*/
  59. #define SRCHNXT 18        /* search for next occurrence */
  60. #define GETDEFDISK 25        /* get current disk  (0-15) */
  61. #define SETDMA 26        /* set address for read, write, etc. */
  62. #define GETALLOCP 27        /* get address of allocation vector */
  63. #define SETATTRIB 30        /* update file attributes */
  64. #define GETDPBP 31        /* get DPB address for disk */
  65. #define SETGETUSER 32        /* set or get user number */
  66. #define COMPFILSIZ 35        /* compute file size into recn and recovf */
  67. #define UFNSIZE 15        /* a:foobar12.urk\0 is 15 chars */
  68.  
  69. openrx(name)
  70. char *name;
  71. {
  72.  
  73. #ifdef RESTRICTED
  74.     char *s;
  75.     if(s=cisubstr(name, ".com"))    /* upload .com files as .obj */
  76.         strcpy(s, ".OBJ");
  77.     if(cisubstr(name, "$$$"))
  78.         return ERROR;        /* don't allow upload of $$$.sub */
  79.     for(s=name; *s; )
  80.         if(*s++ > 'z')
  81.             return ERROR;    /* no garbage names please */
  82. #endif
  83.     unspace(name);
  84.     lprintf("'%s' ", name);        /* show the name right away */
  85.     if(!Creamfile && fopen(name, fout) != ERROR) {
  86.         fclose(fout);
  87.         printf("Exists ", name);
  88. #ifdef XMODEM
  89.         return ERROR;
  90. #else
  91.         printf("Replace it (y/n)??");
  92.         if(tolower(getchar())!= 'y')
  93.             return ERROR;
  94. #endif
  95.     }
  96.     if(fcreat(name, fout)==ERROR){
  97.         printf("Can't create %s\n", name);
  98.         return ERROR;
  99.     }
  100.     Rfile= TRUE;
  101.     strcpy(Rname, name);
  102.     Dumping= !Squelch;
  103.     lprintf("Created%s\n", Dumping? "" : " recording OFF");
  104.     return OK;
  105. }
  106.  
  107. closerx(pad)
  108. {
  109.     if(Rfile) {
  110.         if(!Quiet)
  111.             lpstat("Closing %s", Rname);
  112. #ifdef BDSC
  113.         if(pad && (fout._nleft != ERROR))
  114.         /* only if requested, and file not error aborted */
  115.             do
  116.                 putc(CPMEOF, fout);
  117.                 while(fout._nleft % SECSIZ);
  118. #endif
  119.         fflush(fout);
  120.         fclose(fout);
  121.         Rfile=FALSE;
  122. #ifdef LOGFILE
  123.         logfile(Rname, pad?'*':'R');    /* record file xmsn */
  124. #endif
  125.     }
  126. }
  127.  
  128. opentx(name)
  129. char *name;
  130. {
  131.     int printf();
  132. #ifdef XMODEM
  133.     int lprintf();
  134. #endif
  135.     struct fcb *fp, *fcbaddr();
  136.     int (*fnx)();
  137. #ifndef CDOS
  138.     unsigned spm, dminutes;
  139.     struct fcb fstat;
  140.     spm= Baudrate/23;
  141. #endif
  142. #ifdef XMODEM
  143.     fnx=Batch? lprintf : printf;
  144. #else
  145.     fnx=printf;
  146. #endif
  147.     (*fnx)("'%s' ", name);
  148.     unspace(name);
  149.  
  150.  
  151.     if(fopen(name, fin)==ERROR){
  152.         printf("Can't open %s\n", name);
  153.         return ERROR;
  154.     }
  155. #ifdef RESTRICTED
  156.     if(cisubstr(name, ".bad")
  157.      || (fp=fcbaddr(fin._fd))==ERROR
  158.      || (fp->fname[1] & 0200)    /* tag2 */
  159.      || (fp->ftype[1] & 0200)    /* $SYS */
  160.      ) {
  161.         fclose(fin); printf("\n'%s' Not for Distribution\n", name);
  162.         return ERROR;
  163.     }
  164. #endif
  165.     Tfile= TRUE;
  166.     strcpy(Tname, name);
  167. #ifndef CDOS
  168.     setfcb( &fstat, name);
  169.     bdos(COMPFILSIZ, &fstat);
  170.     dminutes= 1+((10*(1+fstat.recn))/spm)+(fstat.recn/20);
  171.     (*fnx)("Open %u Sectors %u.%u Minutes\n",
  172.       fstat.recn, dminutes/10, dminutes%10);
  173. #else
  174.     (*fnx)("Open\n");
  175. #endif
  176.     return OK;
  177. }
  178.  
  179. /* closetx(status) call with status != 0 if incomplete file xmsn */
  180. closetx(status)
  181. {
  182.     if(Tfile) {
  183.         fclose(fin);
  184.         if(!Quiet)
  185.             lpstat("%s closed", Tname);
  186. #ifdef LOGFILE
  187.         if(!status)
  188.             logfile(Tname, 's');        /* record file xmsn */
  189. #endif
  190.         Tfile=FALSE;
  191.     }
  192. }
  193. /* search the phone file for name */
  194. getphone(name, buffer)
  195. char *name, *buffer;
  196. {
  197.     closetx(TRUE);
  198.  
  199.     if(fopen(PHONES, fin)==ERROR) {
  200.         printf("Cannot open %s\n", PHONES);
  201.         return ERROR;
  202.     } else {
  203.         while(fgets(buffer, fin))
  204.             if(cmdeq(buffer, name)) {
  205.                 fclose(fin);
  206.                 return OK;
  207.             }
  208.     }
  209.     printf("Can't find data for %s\n", name);
  210.     fclose(fin);
  211.     return ERROR;
  212. }
  213.  
  214. /* change default disk and optionally, user number */
  215. chdir(p)
  216. char *p;
  217. {
  218.     unsigned newuser;
  219.  
  220.     if(Rfile||Tfile) {
  221.         printf("Must close files first\n");
  222.         return ERROR;
  223.     }
  224.     newuser=user; *p=toupper(*p);
  225.     if(index(*p, DISKS)) {
  226.         defdisk= *p - 'A';
  227.         bdos(SELDSK, defdisk);
  228. #ifdef CDOS
  229.         return OK;
  230. #else
  231.         printdfr();
  232.         if(!isdigit(p[1]))
  233.             return;
  234.         if((newuser=atoi(p+1)) <= MAXUSER) {
  235.             bdos(SETGETUSER, newuser);
  236.             user=newuser;
  237.             return OK;
  238.         }
  239. #endif
  240.     }
  241.     printf("Disk %c and/or User %d Illegal\n", *p, newuser);
  242.     return ERROR;
  243. }
  244.  
  245. /* fetch default disk and user number */
  246. initdd()
  247. {
  248.     Secpblk=SECPBLK;
  249.     defdisk= bdos(GETDEFDISK,0);
  250. #ifdef CDOS
  251.     user=0;
  252. #else
  253.     user=bdos(SETGETUSER, 0377);
  254. #endif
  255. }
  256.  
  257. dolist(argc, argp)
  258. char **argp;
  259.  
  260. {
  261.     int listfile();
  262. #ifdef XMODEM
  263.     printf("^S pauses, ^K skips to next file, ^X terminates\n");
  264. #endif
  265.     expand(listfile, argc, argp);
  266.     putch('\n');
  267. }
  268.  
  269. listfile(name)
  270. char *name;
  271.  
  272. {
  273.     char *p;
  274.     int c,d;
  275.  
  276. #ifdef XMODEM
  277.     printf("\nListing '%s'\n\022", name);
  278. #endif
  279.     closetx(TRUE);
  280.     if(opentx(name)==ERROR)
  281.         return ERROR;
  282. #ifdef USQ
  283.     if((c=getw(fin))==RECOGNIZE)
  284.         c=unsqueeze();
  285.     else if(c != ERROR) {
  286.         putcty(c);
  287.         putcty(c>>8);    /* pdp-11 sequence */
  288. #else
  289.     else {
  290. #endif
  291.         while((c=getc(fin))!=EOF && c != CPMEOF) {
  292.             if( !(c=putcty(c)))
  293.                 continue;
  294.             if(c == CNTRLC || c == CAN || c == CNTRLK) {
  295.                 break;
  296.             }
  297.         }
  298.     }
  299.     if(c != CPMEOF)
  300.         putchar('\n');
  301.     /* record complete xmsn iff terminated by (CPM)EOF */
  302.     closetx(c != CPMEOF);
  303. #ifdef XMODEM
  304.     sendline(024);    /* squelch in case user downloading */
  305. #endif        
  306.     /* cancel rest of files if ^C or ^X */
  307.     if(c == CNTRLC || c == CAN)
  308.         return ERROR;
  309.     else
  310.         return OK;
  311. }
  312.  
  313. /* fill buf with count chars padding with ^Z for CPM */
  314. filbuf(buf, count)
  315. char *buf;
  316. {
  317.     register c, m;
  318.     m=count;
  319.     while((c=getc(fin))!=EOF) {
  320.         *buf++ =c;
  321.         if(--m == 0)
  322.             break;
  323.     }
  324.     if(m==count)
  325.         return 0;
  326.     else
  327.         while(--m>=0)
  328.             *buf++ = 032;
  329.     return count;
  330. }
  331.  
  332. dodir(argc, argp)
  333. char **argp;
  334. {
  335.     int pdirent();
  336.     cfast=0;        /* counter for 4 across format */
  337.     expand(pdirent, argc, argp);
  338. #ifndef CDOS
  339.     putch('\n');
  340.     printdfr();
  341. #endif
  342. }
  343.  
  344. pdirent(name)
  345. {
  346.     printf("%-14s%c", name, (++cfast%DIRCOLS)?' ':'\n');
  347. }
  348. #ifndef CDOS
  349. /* docomp does a directory listing showing sectors for each matched file
  350.  * and computes total transmission time of matched files in batch mode
  351.  * time is sum of:
  352.  *     number of files * open/close time (assumed 5 seconds)
  353.  *    time to xmit and ACK each sector assuming no path delay or error
  354.  *    disk i/o time at each end, not dependent on baud rate
  355.  */
  356. docomp(argc,argp)
  357. char **argp;
  358. {
  359.     unsigned compsecs();
  360.     unsigned spm;    /* sectors per minute-baud */
  361.     unsigned dminutes;    /* tenths of minutes */
  362.     cfast=Numsecs=Numblks=0;
  363.     expand(compsecs, argc, argp);
  364.     /* (Baudrate*60)/(10 bits each char * 136 chars) */
  365.     spm= Baudrate/23;
  366.     dminutes= Numfiles+((10*(Numfiles+Numsecs))/spm)+(Numsecs/20);
  367.     printf("\n%u Files %u Blocks %u K\n",
  368.       Numfiles, Numblks, (Numblks*(Secpblk/8)));
  369.     printf("%u Sectors %u.%u Minutes Xmsn Time at %u Baud\n",
  370.       Numsecs, dminutes/10, dminutes%10, Baudrate);
  371.  
  372. }
  373. /* add file length (in CP/M 128 byte records) to Numsecs */
  374. unsigned compsecs(ufn)
  375. char *ufn;
  376. {
  377.     struct fcb fstat;
  378.     printf("%-14s", ufn);
  379.     unspace(ufn);
  380.     setfcb( &fstat, ufn);
  381.     bdos(COMPFILSIZ, &fstat);
  382.     Numsecs += fstat.recn;
  383.     Numblks += (fstat.recn+Secpblk)/Secpblk;
  384.     printf("%4u%c",fstat.recn, (++cfast%DIRCOLS)?' ':'\n');
  385.     return fstat.recn;
  386. }
  387. #endif
  388.  
  389. expand(fnx, argc, argp)
  390. int (*fnx)();
  391. char **argp;
  392. {
  393.     char name[PATHLEN], *s;
  394.     Numfiles=0;
  395.  
  396.     if(argc<=0)
  397.         return e1xpand(fnx, "*.*");
  398.     else
  399.         while(--argc>=0) {
  400.             /* change b: to b:*.*  */
  401.             strcpy(name, *argp++);
  402.             if((s=index(':', name)) && *++s == 0)
  403.                 strcpy(s, "*.*");
  404.             if(e1xpand(fnx, name)==ERROR)
  405.                 return ERROR;
  406.         }
  407.     return OK;
  408. }
  409.  
  410. /*
  411.  * e1xpand expands ambiguous pathname afnp
  412.  * calling fnx for each.
  413.  * Modified from: Parameter list builder by Richard Greenlaw
  414.  *                251 Colony Ct. Gahanna, Ohio 43230
  415.  */
  416. e1xpand(fnx, afnp)
  417. int (*fnx)();
  418. char *afnp;    /* possible ambiguous file name*/
  419. {
  420.     struct fcb sfcb, *pfcb;
  421.     FLAG first;
  422.     char *p, *q, i, byteaddr;
  423.     int filecount, m;
  424.     char tbuf[SECSIZ];
  425.     struct {
  426.         char xYxx[UFNSIZE];        /* unambiguous file name */
  427.     } *fp;
  428.     int strcmp();
  429.  
  430.  
  431.     /* build CPM fcb   */
  432.     unspace(afnp);
  433.     if(setfcb(&sfcb, afnp) == ERROR) {
  434.         printf("%s is bad pattern\n", afnp);
  435.         return ERROR;
  436.     }
  437.  
  438.     if(Wrapped || (bufend-bufcq)<2048) {
  439.         dumprxbuff();        /* I need the space for building the pathlist */
  440.         clearbuff();        /* so the printer won't try to list dir's */
  441.         bufmark=bufst;
  442.     } else
  443.         bufmark=bufcq;
  444.  
  445.     /* Search disk directory for all ufns which match afn*/
  446.     for(fp=bufmark,filecount=0,first=TRUE;; fp++,filecount++) {
  447. tryanother:
  448.         bdos(SETDMA, tbuf);
  449.         /* seems CP/M outta know whether to use SRCH or SRCHNXT !! */
  450.         byteaddr=bdos(first? SRCH:SRCHNXT, &sfcb); first=FALSE;
  451.         if(byteaddr==255)
  452.             break;
  453.         /* calculate pointer to filename fcb returned by bdos */
  454.         pfcb = (tbuf + 32 * (byteaddr % 4));
  455. #ifdef RESTRICTED
  456.         /* check for $SYS or tag bit on 2nd byte of filename (TAG2) */
  457.         if((pfcb->fname[1]&0200) ||(pfcb->ftype[1]&0200))
  458.             goto tryanother;
  459. #else
  460.         /* check for $SYS with Sysfil flag */
  461.         if((pfcb->ftype[1]&0200) && !Sysfil)
  462.             goto tryanother;
  463. #endif
  464.  
  465.         Numfiles++;
  466.         p = fp;
  467.         if(fp>bufend) {    /* Note: assumes some slop after bufend! */
  468.             printf("Out of Memory for pathname expansion\n");
  469.             return ERROR;
  470.         }
  471.         if(*(afnp+1) == ':') {
  472.             /* Drive spec.*/
  473.             *p++ = *afnp;
  474.             *p++ = ':';
  475.         }
  476.  
  477.         /*Copy filename from directory*/
  478.         q = pfcb;
  479.         for(i =8; i; --i)
  480.             *p++ = (0177& *++q);
  481.         *p++ = '.' ;
  482.  
  483.         /*Copy file extent*/
  484.         for(i = 3; i; --i)
  485.             *p++ = (0177& *++q);
  486.         *p = '\0' ;
  487.  
  488.     }
  489.     if(filecount==0) {
  490.         printf("'%s' NOT FOUND\n", afnp);
  491.         return ERROR;
  492.     }
  493.  
  494.     qsort(bufmark, filecount, UFNSIZE, strcmp);
  495.  
  496.     for(fp=bufmark; --filecount>=0;) {
  497.         p=fp++;
  498.         /* execute desired function with real pathname */
  499.         if((*fnx)(p)==ERROR)
  500.             return ERROR;
  501.     }
  502.     return OK;
  503. }
  504.  
  505. /*
  506.  * cisubstr(string, token) searches for lower case token in string s
  507.  * returns pointer to token within string if found, NULL otherwise
  508.  */
  509. char *cisubstr(s, t)
  510. char *s,*t;
  511. {
  512.     char *ss,*tt;
  513.     /* search for first char of token */
  514.     for(ss=s; *s; s++)
  515.         if(tolower(*s)==*t)
  516.             /* compare token with substring */
  517.             for(ss=s,tt=t; ;) {
  518.                 if(*tt==0)
  519.                     return s;
  520.                 if(tolower(*ss++) != *tt++)
  521.                     break;
  522.             }
  523.     return NULL;
  524. }
  525.  
  526. /* copy string s onto itself deleting spaces "hello there" > "hellothere" */
  527. unspace(s)
  528. char *s;
  529. {
  530.     char *p;
  531.     for(p=s; *s; s++)
  532.         if(*s != ' ')
  533.             *p++ = *s;
  534.     *p++ =0;
  535. }
  536.  
  537. #ifdef LOGFILE
  538. /*
  539.  * logfile keeps a record of files transmitted.
  540.  * Mode is 's' for send file, 'r' for receive file, 't' for type file
  541.  * Lifted from xcmodem by J. Wierda, R. Hart, and W. Earnest
  542. */
  543.  
  544. #define RPB 4    /* log records per buffer */
  545. #define LRL 32    /* logical rec length LRL*RPB == SECSIZ */
  546.  
  547. logfile(name, mode)
  548. char *name;
  549. char mode;
  550. {
  551.     struct fcb *fcbaddr(), *fp;
  552.     int fd, rnum, bnum, thedisk;
  553.     char *i, *lrec, lbuf[SECSIZ+2];
  554.     char date_str[6], time_str[6];
  555.  
  556.     /* find out what disk was used */
  557.  
  558.     thedisk = defdisk + 'a';
  559.     if(i = index(':', name)) {
  560.         thedisk = *name;
  561.         name = ++i;
  562.     }
  563.     bdos(SETGETUSER, 0);    /* get it from user 0 */
  564.     fd = open(LOGFILE,2);
  565.     if(fd == ERROR) {    /* if file absent, create and initialize it */
  566.         fd = creat(LOGFILE);
  567.         if(fd == ERROR)
  568.             return;
  569.         else {
  570.             rnum=1;
  571.             fp = fcbaddr(fd);
  572.             fp->fname[1] |= 0200;    /* set TAG2 bit */
  573.             fp->ftype[1] |= 0200;    /* set SYS bit */
  574.             bdos(SETATTRIB, fp);    /* and update attributes */
  575.         }
  576.     }
  577.     else {
  578.         read(fd, lbuf, 1);
  579.         rnum = atoi(lbuf)+1;
  580.     }
  581.     setmem(lbuf, SECSIZ, 0);
  582.     sprintf(lbuf, "%d\r\n", rnum);
  583.     seek(fd,0,0);
  584.     write(fd, lbuf, 1);        /* update last record number */
  585.     bnum = rnum/RPB;
  586.     rnum = (rnum%RPB)*LRL;
  587.     seek(fd, bnum, 0);
  588.     if(rnum == 0)
  589.         setmem(lbuf, SECSIZ, 0);
  590.     else
  591.         read(fd, lbuf, 1);
  592.     if (time(time_str)){
  593.         sprintf(time_str,"fill");
  594.     }
  595.     if (date(date_str)){
  596.         sprintf(date_str,"");
  597.     }
  598.     sprintf(&lbuf[rnum], "\r\n%c    %c%02d    %-12s    %5s    %5s",
  599.      mode, thedisk, user, name, time_str, date_str);
  600.     seek(fd, bnum, 0);
  601.     write(fd,lbuf,1);
  602.     close(fd);
  603.     bdos(SETGETUSER, user);
  604. }
  605.  
  606. #ifdef LOGCLOCK
  607.  
  608. #include <CLOCK.H>
  609.  
  610. /* Real time system clock functions
  611.  
  612.    Extracted from DATEDEMO.C
  613.  
  614.    By Bill Bolton,
  615.    Software Tools,
  616.    P.O. Box 80,
  617.    Newport Beach,
  618.    NSW, 2106,
  619.    AUSTRALIA
  620.  
  621.    Source Address TCY-396
  622.    Phone (+61 2) 997-1018
  623.  
  624.    Version 1.1 for Godbout Systsem Support 1 clock 19/1/82
  625.  
  626.     char    date_str[5];    /* string (character array) for date */
  627.     char    time_str[5];    /* string for time */
  628.     date(srt) will fill a string with date formatted as follows:
  629.  
  630.     "11/5" (in Eurodate format)
  631. */
  632.  
  633. date(str)
  634.  
  635. char    *str;        /* pointer to date string */
  636.  
  637. {
  638.     int    month[1];    /* month of the year, range 1 to 12 */
  639.     int    mday[1];    /* day of the current month, range 0 to 31 */
  640.  
  641.     if (get_date(month,mday)){
  642.         return(-1);
  643.     } 
  644.     sprintf(str,"%d/%d",*mday,*month);
  645.     return(0);
  646. }
  647.  
  648. /* get_date(month,mday) provides the basic data for formatting
  649.    a date string, fetched from the clock board and converted to a useable
  650.    set of values */
  651.  
  652. int get_date(month,mday)
  653.  
  654. int    *month;        /* pointer to current month */
  655. int    *mday;        /* pointer to day of the month */
  656.  
  657. {
  658.     if (inp(CDATA) == 0XFF )      /* no clock board present */
  659.         return(-1);
  660.     *month = ((read_digit(MONTH10) & 1) * 10) + read_digit(MONTH1);
  661.     *mday = ((read_digit(DAY10) & 3) * 10) + read_digit(DAY1);
  662.     outp(CLKCMD,0);
  663.     return(0);
  664. }
  665.  
  666.  
  667. int read_digit(address)
  668.  
  669. int    address;
  670.  
  671. {
  672.     int    instruct;
  673.  
  674.     instruct = address + CREAD;
  675.     outp(CLKCMD,instruct);
  676.     return (inp(CDATA));
  677. }
  678.  
  679. /* time(str,format) fills a string with the time of day in the 
  680.    following format :
  681.  
  682.         18:00
  683. */
  684.  
  685. time(str)
  686.  
  687. char    *str;        /* string to fill with time */
  688.  
  689. {
  690.     int    t[4];
  691.  
  692.     if (read_clock(t)){
  693.         return(-1);
  694.     } 
  695.     sprintf(str,"%d%d:%d%d",t[0],t[1],t[2],t[3]);
  696.     return(0);
  697. }
  698.  
  699. /* read_clock(t) fills an array with the time of day digits read from
  700.    the clock board
  701. */
  702.  
  703. int read_clock(t)
  704.  
  705. int    *t;        /* array to store clock digits */
  706.  
  707. {
  708.     int    ptr;    /* pointer into digit array */
  709.  
  710.     if (inp(CDATA) == 0XFF )    /* no clock board present */
  711.         return(-1);
  712.     t[0] = (read_digit(HOUR10) & 3);
  713.     t[1] = read_digit(HOUR1);
  714.     t[2] = (read_digit(MIN10) & 7);
  715.     t[3] = read_digit(MIN1);
  716.     outp(CLKCMD,0);
  717.     return(0);
  718. }
  719.  
  720. #else /* LOGCLOCK */
  721.  
  722. time(str)
  723. char *str;
  724.  
  725. {
  726.     return(-1);
  727. }
  728.  
  729. date(str)
  730. char *str;
  731.  
  732. {
  733.     return(-1);
  734. }
  735.  
  736. #endif /* LOGCLOCK */
  737.  
  738. #endif /* LOGFILE */
  739.  
  740.  
  741. docrck(argc, argp)
  742. char **argp;
  743. {
  744.     int crckfile();
  745.  
  746.     expand(crckfile, argc, argp);
  747. }
  748.  
  749. /* Accumulate and print a "crck" for a file */
  750. crckfile(name)
  751. char *name;
  752. {
  753.     unsigned crck();
  754.     char crbuf[SECSIZ]; int fd,st;
  755.  
  756.     printf("%14s ", name); unspace(name);
  757.     if((fd=open(name, 0))==ERROR)
  758.         return ERROR;
  759.  
  760.     oldcrc=0;
  761.     while((st=read(fd, crbuf, 1)) ==1)
  762.             oldcrc=crck(crbuf, SECSIZ, oldcrc);
  763.     close(fd);
  764.     if(st != 0)
  765.         printf("READ ERROR\n");
  766.     else
  767.         printf("CRCK= %04x\n", oldcrc);
  768.     return OK;
  769. }
  770.  
  771. /* print number of free blocks on default disk */
  772. printdfr()
  773. {
  774.     struct dpb *dp;
  775.  
  776.     dp=call(BDOS, 0, 0, GETDPBP, defdisk);
  777.     Secpblk= 1 << dp->dpb_bsh;
  778.     printf("%u kb Free on %c\n", getfree(defdisk), defdisk+'A');
  779. }
  780.  
  781. /* return total free kilobytes of disk */
  782. unsigned getfree(disk)
  783. {
  784.     struct dpb *dp;
  785.     /* unsigned */ char v, c, *s;
  786.     unsigned total, count;
  787.  
  788.     bdos(SELDSK, disk);
  789.     dp=call(BDOS, 0, 0, GETDPBP, disk);
  790.     s=call(BDOS, 0, 0, GETALLOCP, disk);
  791.     total=0;
  792.     count=dp->dpb_dsm+1;
  793.     for(;;) {
  794.         v= *s++;
  795.         for(c=0200; c; c>>=1) {
  796.             if((v & c)==0)
  797.                 ++total;
  798.             if(--count ==0) {
  799.                 bdos(SELDSK, defdisk);
  800.                 return total << dp->dpb_bsh-3;
  801.             }
  802.         }
  803.     }
  804. }
  805.  
  806. doerase(argc, argp)
  807. char **argp;
  808. {
  809.     int erasefile();
  810.     expand(erasefile, argc, argp);
  811. #ifndef CDOS
  812.     printdfr();
  813. #endif
  814. }
  815.  
  816. erasefile(ufn)
  817. char *ufn;
  818. {
  819.     register c;
  820.     unspace(ufn);
  821.     printf("Erase %s (y/n/q)? ",ufn);
  822.     c=getchar();
  823.     putchar('\n');
  824.     if(tolower(c)=='y')
  825.         unlink(ufn);
  826.     else if(tolower(c)=='n')
  827.         return FALSE;
  828.     else
  829.         return ERROR;
  830.     return FALSE;
  831. }
  832.  
  833. /* end of YAM7.C */
  834.