home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c005 / 2.ddi / ZAP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-04-13  |  11.3 KB  |  421 lines
  1. /**
  2. *
  3. *  ZAP    Delete a subdirectory and all its contents
  4. *
  5. *  This program deletes all files from the specified
  6. *  directory and then removes the directory.  If a directory
  7. *  is encountered in the subdirectory, it is processed and
  8. *  removed as well.  ZAP is invoked with the command
  9. *
  10. *         zap directory
  11. *
  12. *  where "directory" is any directory on the system.
  13. *  ZAP reports disk space allocation and the total number
  14. *  of files deleted.  ZAP removes an entire directory, so you
  15. *  can easily remove a large number of files rapidly . . . use
  16. *  caution when using ZAP.
  17. *
  18. *  If a DOS critical error occurs (such as disk drive door open)
  19. *  the error will be reported and the user will be asked to
  20. *  correct the condition and press a key to continue.
  21. *
  22. *  Version 3.0    (C)Copyright Blaise Computing Inc. 1983, 1984, 1986
  23. *
  24. *  Version 3.02 March 23, 1987
  25. *        Corrected test for 0xff in write_str() by casting 0xff
  26. *            to char.
  27. *        Prevented overflow of report[] array in crit_err().
  28. *        Removed call to itoa() (which is not supported by
  29. *            Lattice C versions 3.00-3.11.)
  30. *
  31. **/
  32.  
  33. #include <ctype.h>
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36. #include <string.h>
  37.  
  38. #include <bfile.h>
  39. #include <bdirect.h>
  40. #include <bisr.h>
  41. #include <bprogctl.h>
  42. #include <bquery.h>
  43.  
  44. #if MSC300
  45. #include <malloc.h>
  46. #include <memory.h>
  47. #endif
  48.  
  49. #define  OK_EXIT    0          /* Exit codes              */
  50. #define  BAD_USAGE    101
  51. #define  DIR_NOT_FOUND    102
  52. #define  INSUFF_MEMORY    103
  53. #define  ILL_FILENAME    104
  54.  
  55. #define  STACKSIZE  3000          /* Items for the critical       */
  56. #define  NUMSTACKS     2          /* error ISR.              */
  57. ISRCTRL crit_blk              = {0};
  58. char    crit_stk[STACKSIZE*NUMSTACKS] = {0};
  59.  
  60. int  deldir(char *);
  61. void crit_err(ALLREG *,ISRCTRL *,ISRMSG *);
  62. void write_str(char *);
  63. void wait_key(void);
  64.  
  65. void main(argc,argv)
  66. int  argc;
  67. char *argv[];
  68. {
  69.     int      dfiles;
  70.     char     *pdirectory,pdir[MAX_FLEN];
  71.     int      last;
  72.     unsigned aclus,tclus,bsec,sclus;
  73.     FSPEC    finfo;
  74.     long     freebytes;
  75.     char     old_dir[MAX_FLEN];
  76.     int      old_drive;
  77.  
  78.     /* Install DOS critical error handler.                  */
  79.  
  80.     isinstal(0x24,crit_err,"ZAP3.02CRIT ERR",
  81.          &crit_blk,crit_stk,STACKSIZE,NUMSTACKS);
  82.  
  83.     /* Display welcome message and check for directory              */
  84.  
  85.     printf("ZAP  Subdirectory Removal\n");
  86.     printf("Version 3.02");
  87.     printf("  (C)Copyright Blaise Computing Inc. 1983, 1984, 1986\n\n");
  88.  
  89.     if (argc != 2)
  90.     {
  91.     printf("ZAP requires a subdirectory specification ");
  92.     printf("and is invoked by:\n");
  93.     printf("\n            zap directory\n");
  94.     pcexit(BAD_USAGE);
  95.     }
  96.  
  97.     pdirectory = argv[1];
  98.                       /* Check for valid directory    */
  99.                       /* name.                  */
  100.     if (flnorm(pdirectory,pdir,&last))
  101.     {
  102.     printf("Illegal directory name:  <%s>\n",pdir);
  103.     pcexit(ILL_FILENAME);
  104.     }
  105.     if (pdir[last] != '\0')           /* If not root directory,       */
  106.                       /* make sure it exists.          */
  107.     if (drsfirst(pdir,AT_DIR,&finfo))
  108.     {
  109.         printf("Directory <%s> could not be found.\n",pdir);
  110.         pcexit(DIR_NOT_FOUND);
  111.     }
  112.  
  113.     /* Switch to target drive                          */
  114.  
  115.     old_drive = drretdrv();
  116.     drsetdrv(toupper((int) pdir[0]) - 'A');
  117.  
  118.     /* Save initial directory on target drive                  */
  119.  
  120.     drcurdir(0,old_dir);
  121.  
  122.     /* Report disk space utilization                      */
  123.  
  124.     freebytes = qydisksp(0,&aclus,&tclus,&bsec,&sclus);
  125.     printf("Total Disk Space : %8ld\n",
  126.                  (long)tclus * (long)sclus * (long)bsec);
  127.     printf("Free Space       : %8ld\n",freebytes);
  128.  
  129.     /* Process the directory                          */
  130.  
  131.     dfiles = deldir(pdir);
  132.  
  133.     /* Report overall results                          */
  134.  
  135.     freebytes = qydisksp(0,&aclus,&tclus,&bsec,&sclus);
  136.     printf("Files Deleted : %8d\n", dfiles);
  137.     printf("Free Space    : %8ld\n",freebytes);
  138.  
  139.     /* Restore initial directory on target drive (if it's still       */
  140.     /* there).                                  */
  141.  
  142.     drchdir(old_dir);
  143.  
  144.     /* Restore original drive.                          */
  145.  
  146.     drsetdrv(old_drive);
  147.  
  148.     pcexit(OK_EXIT);
  149. }
  150.  
  151. /**
  152. *
  153. * Name        deldir -- Delete all files and remove the directory
  154. *
  155. * Synopsis    dfiles = deldir(pdir);
  156. *
  157. *        int  dfiles      The number of files deleted
  158. *        char *pdir      The directory name
  159. *
  160. * Description    This function deletes all files in the specified
  161. *        directory.  If a subdirectory is encountered, it is
  162. *        processed by calling deldir() recursively.
  163. *
  164. * Method    The DOS communication area which is used by DRSFIRST and
  165. *        DRSNEXT is saved when calling deldir() recursively,
  166. *        because the area is statically defined by DRSFIRST.
  167. *
  168. * Returns    dfiles          The total number (in all sub-
  169. *                  directories) of files deleted.
  170. *
  171. **/
  172.  
  173. int  deldir(pdir)
  174. char *pdir;
  175. {
  176.     int   ercode,dfiles;
  177.     FSPEC info;
  178.     char  dirname[MAX_FLEN];
  179.     int   last;
  180.  
  181.     char  loc_area[sizeof(b_drbuffer)];
  182.  
  183.     if (ercode = drchdir(pdir))       /* Down to subdirectory          */
  184.     {
  185.     printf("Error %d changing to directory %s\n",ercode,pdir);
  186.     pcexit(ercode);
  187.     }
  188.     printf("\nProcessing %s\n",pdir);
  189.  
  190.     dfiles = 0;
  191.                       /* Begin the search          */
  192.     for (ercode = drsfirst("*.*",
  193.                AT_RDONLY+AT_HIDDEN+AT_SYSTEM+AT_DIR,
  194.                &info);
  195.      ercode == 0;
  196.      ercode = drsnext(&info))
  197.     {
  198.     if (info.fname[0] != '.')
  199.         if (info.fattr == AT_DIR)    /* Another directory          */
  200.         {
  201.         memcpy(loc_area,b_drbuffer,sizeof(b_drbuffer));
  202.         dfiles += deldir(info.fname);
  203.         memcpy(b_drbuffer,loc_area,sizeof(b_drbuffer));
  204.         }
  205.         else
  206.         {
  207.         if (info.fattr & AT_RDONLY)  /* Must reset attribute  */
  208.                          /* before deleting.      */
  209.             flsetatr(info.fname,AT_GENERAL);
  210.  
  211.         if (ercode = fldelete(info.fname))
  212.             printf("       Error %d deleting file %s\n",
  213.                ercode,
  214.                info.fname);
  215.         else
  216.         {
  217.             printf("       %s\n",info.fname);
  218.             dfiles++;
  219.         }
  220.         }
  221.     }
  222.  
  223.     if (   0    == flnorm(pdir,dirname,&last)
  224.     && '\0' != dirname[last])
  225.     {                      /* This wasn't the root         */
  226.     drchdir("..");
  227.     ercode = drrmdir(pdir);       /* Now remove the directory     */
  228.     }
  229.     else
  230.     ercode = 0;
  231.  
  232.     if (ercode == 0)
  233.     printf("    %s processing complete.\n\n",pdir);
  234.     else
  235.     printf("    Error %d removing directory %s\n\n",ercode,pdir);
  236.  
  237.     return(dfiles);
  238. }
  239.  
  240. /**
  241. *
  242. * Name        crit_err -- Handle DOS critical error
  243. *
  244. * Synopsis    (To be called only from ISR dispatcher.)
  245. *
  246. *        crit_err(pregs,pisrblk,pmsg);
  247. *
  248. *        ALLREG *pregs      Pointer to structure containing
  249. *                  register values in effect when
  250. *                  interrupt occurred.
  251. *        ISRCTRL *pisrblk  Pointer to control block for this
  252. *                  ISR.
  253. *        ISRMSG *pmsg      Pointer to structure containing
  254. *                  messages between this ISR and the
  255. *                  dispatcher.
  256. *
  257. * Description    This function analyzes the information provided by DOS
  258. *        in the machine registers, reports the error and the
  259. *        device on which it occurs, and awaits a keystroke.  It
  260. *        returns to DOS in such a way as to request another
  261. *        retry.
  262. *
  263. * Returns    pregs->ax.hl.l      Value 1, thereby requesting a retry.
  264. *
  265. **/
  266.  
  267. void crit_err(pregs,pisrblk,pmsg)
  268. ALLREG    *pregs;
  269. ISRCTRL *pisrblk;
  270. ISRMSG    *pmsg;
  271. {
  272.     ADS        dev_header_ads;
  273.     DEV_HEADER dh;
  274.     ADS        dh_ads;
  275.     char       report[100];
  276.     int        bad_fat;
  277.  
  278.     static char *message[] =
  279.     {
  280.     "Attempt to write on write-protected diskette", /* 0x00       */
  281.     "Unknown unit",                                 /* 0x01       */
  282.     "Drive not ready",                              /* 0x02       */
  283.     "Unknown command",                              /* 0x03       */
  284.     "Data error (CRC)",                             /* 0x04       */
  285.     "Bad request structure length",                 /* 0x05       */
  286.     "Seek error",                                   /* 0x06       */
  287.     "Unknown media type",                           /* 0x07       */
  288.     "Sector not found",                             /* 0x08       */
  289.     "Printer out of paper",                         /* 0x09       */
  290.     "Write fault",                                  /* 0x0a       */
  291.     "Read fault",                                   /* 0x0b       */
  292.     "General failure",                              /* 0x0c       */
  293.     "Unknown error 13",                             /* 0x0d       */
  294.     "Unknown error 14",                             /* 0x0e       */
  295.     "Invalid disk change"                           /* 0x0f       */
  296.     };
  297.     static char *area[4] =          /* Area on disk in which error  */
  298.     {                      /* may occur.              */
  299.     "DOS area (system files)",
  300.     "file allocation table",
  301.     "directory",
  302.     "data area"
  303.     };
  304.  
  305.     bad_fat = 0;
  306.  
  307.     if (pregs->ax.hl.h & 0x80)
  308.     {                      /* Character device or FAT      */
  309.                       /* error.               */
  310.     dev_header_ads.r = pregs->si;
  311.     dev_header_ads.s = pregs->bp;
  312.     utabsptr((char *) &dh,&dh_ads);
  313.     utslmove(&dev_header_ads,&dh_ads,sizeof(dh));
  314.     if (dh.attr & 0x8000)
  315.         sprintf(report,
  316.             "\015\012Critical error on device \"%-.8s\":",
  317.             dh.name);
  318.     else
  319.     {
  320.         bad_fat = 1;
  321.         sprintf(report,
  322.             "\015\012Bad FAT on drive %c:",
  323.             pregs->ax.hl.l + 'A');
  324.     }
  325.     }
  326.     else                  /* Disk error.              */
  327.     sprintf(report,
  328.         "\015\012Critical error while %s %s on drive %c:",
  329.         (pregs->ax.hl.h & 1) ? "writing" : "reading",
  330.         area[(pregs->ax.hl.h & 6) >> 1],
  331.         pregs->ax.hl.l + 'A');
  332.     write_str(report);
  333.     write_str("\015\012");
  334.     write_str(message[utlobyte(pregs->di)]);
  335.     write_str("\015\012");
  336.  
  337.     write_str(report);
  338.  
  339.  
  340.     if (bad_fat)
  341.     {
  342.     write_str("\015\012TURN THE COMPUTER OFF!\007\015\012");
  343.     while (1)              /* Hang the computer in an      */
  344.         atoi(report);          /* infinite loop.           */
  345.     }
  346.     else
  347.     {
  348.     write_str("\015\012Correct condition and press any key.\015\012");
  349.     wait_key();
  350.     pregs->ax.hl.l = 1;          /* Retry.               */
  351.     }
  352. }
  353.  
  354. /**
  355. *
  356. * Name        write_str -- Write string to DOS console using only DOS
  357. *                 functions 1-12.  Ignore CTRL-BREAK.
  358. *
  359. * Synopsis    write_str(pstring);
  360. *
  361. *        char *pstring      Pointer to beginning of character
  362. *                  array containing message to write.
  363. *                  The string must be terminated by NUL
  364. *                  ('\0') as usual.
  365. *
  366. * Description    This function writes a string to the DOS console using
  367. *        DOS functions 1-12 only.  CTRL-BREAK and CTRL-C are
  368. *        ignored.
  369. *
  370. * Returns    (None.    Function return type is void.)
  371. *
  372. **/
  373.  
  374. void write_str(pstring)
  375. char *pstring;
  376. {
  377.     DOSREG regs;
  378.     char   ch;
  379.  
  380.     regs.ax = 0x0600;
  381.     while (ch = *pstring++)
  382.     {
  383.     if (ch != (char) 0xff)          /* Added (char) 8/28/86.          */
  384.     {
  385.         regs.dx = utbyword(0,ch);
  386.         dos(®s);
  387.     }
  388.     }
  389. }
  390.  
  391. /**
  392. *
  393. * Name        wait_key -- Await keystroke and discard it.
  394. *                (Use DOS functions 1-12 only.)
  395. *
  396. * Synopsis    wait_key();
  397. *
  398. * Description    This function discards any pending keystrokes, waits for
  399. *        one more keystroke, and discards it.  If the new
  400. *        keystroke is CTRL-BREAK or CTRL-C, the program is
  401. *        aborted.
  402. *
  403. * Returns    (None.    Function return type is void.)
  404. *
  405. **/
  406.  
  407. void wait_key()
  408. {
  409.     DOSREG regs;
  410.  
  411.     regs.ax = 0x0c08;           /* Flush keyboard & await one key. */
  412.     dos(®s);
  413.  
  414.     if (utlobyte(regs.ax) == 0)    /* If IBM PC extended character,   */
  415.     {                   /* read & discard the second       */
  416.     regs.ax = 0x0600;       /* byte of the keystroke.          */
  417.     regs.dx = 0x00ff;
  418.     dos(®s);
  419.     }
  420. }
  421.