/* fs.c
 *
 * fs [-h -s -p -t -f -ad -d -lnnn -v] path
 *
 * h  - help
 * s  - scan subdirectory
 * p  - prompt when screen is full
 * t  - show totals only
 * f  - report only matching files
 * ad - show how much files will use on drive d:
 * d  - show all directory entries
 * l  - minimum file size to show
 * v  - verify file name
 *
 * Written by: Eyal Lebedinsky
 * Date:       29 May 1988
 *
 * file size utility. will report size of file and amount of slack for all
 * files in path and optionally all subdirectory. path can contain a file
 * name with wild-characters to select files. detail lines show the file name
 * followed by file size and disk space used by the file. totals line shows
 * totals for above and % unused space. the directory structure is shown as
 * indentation.
 *
 * examples:
 *
 * >fs /s *.rep ---- show size for all file with extension 'rep' in current
 *		     directory and subdirectories.
 * >fs/fs \xyz\*.rep ---- list any file in 'xyz' directory or any subdirectory
 *			  with extention 'rep'.
 * >fs d:\read.me /f  /s ---- find all files called 'read.me' in drive d:
 * >fs *.* /aa /t ---- show how much space my files will take on a floppy.
 * >fs /aa /t ---- as above. no file defaults to '*.*'
 * >fs ---- directory list.
 * >fs /p ---- as above with pause at every screenfull.
 *
 * 28 Aug 93: add option l, v.
*/

#include <stdio.h>
#include <dos.h>
#include <direct.h>
#include <ctype.h>
#include <string.h>

static int option_t, option_s, option_p, option_f, option_a, option_d;
static int option_h, option_l, option_v;
static char temp_name[80], root[80], odir[80];
static int line_no, cnt;
static long csize, asize, l1, l2, l3, min_size;
static struct diskfree_t diskfree;

static void indent (i)
register int i;
{
   if (option_p) {
      if (line_no >= 24) {
	 printf ("Any key to continue");
	 getch ();
	 putch ('\r');
	 line_no = 1;
      }
      else
	 ++line_no;
   }

   if (option_f) {
      printf ("%s", root);
      return;
   }

   while (i--)
      printf ("   ");
}

static int
bad_filename (struct find_t *dir_entry, int depth)
{
	int	i, c;

	for (i = 0; i < 12 && 0 != (c = dir_entry->name[i]); ++i) {
		if ((c > 0 && c < 32) || c >= 128) {
			indent (depth);
			printf ("%-13.13s <BAD FILENAME[%d]=%02x>\n",
				dir_entry->name, i, (unsigned char)c);
			return (1);
		}
	}
	if (0 == i) {
		indent (depth);
		printf ("%-13.13s <NO FILENAME>\n", "");
		return (1);
	}
	return (0);
}

static void list_dir (file, depth, totals)
char *file;
int depth;
long totals[3];
{
   struct find_t dir_entry;
   long total[4], last_total;
   int eod, len;

   len = strlen (root);
   if (!option_f) {
      indent (depth++);
      printf ("%s\n", root);
   }

   total[0] = total[1] = total[2] = total[3] = 0L;

   strcpy (root + len, file);
   for (eod = _dos_findfirst (root, 0xffff, &dir_entry), root[len] = '\0',
	cnt = 0; !eod; eod = _dos_findnext (&dir_entry)) {
      if (option_v) {
         totals[2] += bad_filename (&dir_entry, depth);
         continue;
      }
      if (!(dir_entry.attrib & (_A_SUBDIR | _A_VOLID))) {
         if (option_l && dir_entry.size <= min_size)
            ;
         else {
	    total[0] += l1 = dir_entry.size;
	    total[1] += l2 = ((dir_entry.size + csize - 1L) / csize) * csize;
	    if (option_a)
	       total[3] += l3 = ((dir_entry.size + asize - 1L) / asize) * asize;
	    ++cnt;
	    if (!option_t) {
	       indent (depth);
	       printf ("%-13.13s %8lu %8lu\n", dir_entry.name, l1, l2);
	    }
	 }
      } else if (option_d && !option_t &&
		!(option_s && (dir_entry.attrib & _A_SUBDIR))) {
	 indent (depth);
	 printf ("%-13.13s %8s\n", dir_entry.name,
		dir_entry.attrib & _A_SUBDIR ? "<DIR>" : "<LABEL>");
      }
   }
   total[2] = cnt;
   if (!option_f && total[2]) {
      indent (depth);
      if (total[1])
	      l1 = (100L * (total[1] - total[0])) / total[1];
      else
	      l1 = 0;
      printf ("<%4lu files > %8lu %8lu %%%3lu in %s\n",
	      total[2], total[0], total[1], l1, root);
   }

   if (option_s) {
      last_total = total[2];

      strcpy (root + len, "*.*");
      for (eod = _dos_findfirst (root, _A_SUBDIR, &dir_entry); !eod;
	   eod = _dos_findnext (&dir_entry)) {
	 if (dir_entry.attrib & _A_SUBDIR && dir_entry.name[0] != '.') {
	    strcat (dir_entry.name, "\\");
	    strcpy (root + len, dir_entry.name);
	    list_dir (file, depth, total);
	 }
      }
      root[len] = '\0';
      if (!option_f && total[2] && last_total != total[2]) {
	 indent (depth-1);
	 if (total[1])
		l1 = (100L * (total[1] - total[0])) / total[1];
	 else
		l1 = 0;
	 printf ("=%4lu files = %8lu %8lu %%%3lu in %s\n",
		 total[2], total[0], total[1], l1, root);
      }
   }

   totals[0] += total[0];
   totals[1] += total[1];
   totals[2] += total[2];
   totals[3] += total[3];
   return;
}

int
main (argc, argv)
int argc;
char *argv[]; {
   char file[13], *p, **i;
   long totals[4];
   int drive, tdrive, odrive, len, c;

   option_a = option_f = option_p, option_s, option_t = option_d =
   option_h = option_l = option_v = 0;
   for (i = argv+1; *i != NULL; ++i) {
      if (**i == '-' || **i == '/') {
	  for (p = *i + 1; *p != '\0'; ++p) {
	  switch (*p) {
	  case 'a':
	     if (p[1] == '\0')
		 option_h = 1;		/* error */
	     else
		 option_a = *++p;
	     break;

	  case 'd':
	     option_d = 1;
	     break;

	  case 'f':
	     option_f = 1;
	     break;

	  case '?':
	  case 'h':
	     option_h = 1;
	     break;

	  case 'l':
	     option_l = 1;
	     for (min_size = 0; c = p[1], isdigit (c); ++p)
	     	min_size = min_size * 10L + c - '0';
	     if ('k' == p[1])
	        ++p, min_size *= 1024L;
	     break;

	  case 'p':
	     option_p = 1;
	     break;

	  case 's':
	     option_s = 1;
	     break;

	  case 't':
	     option_t = 1;
	     break;

	  case 'v':
	     option_v = 1;
	     break;

	  default:
	     fprintf (stderr, "Ungnown option %c, ignored.\n", *p);
	     break;
	  } /* switch */
	  } /* for p */
      } /* if */
   } /* for args */

   if (option_h) {
	printf ("usage: fs [-h -s -p -t -f -ad -d] path\n");
	printf ("       s  - scan subdirectory\n");
	printf ("       p  - prompt when screen is full\n");
	printf ("       t  - show totals only\n");
	printf ("       f  - report only matching files\n");
	printf ("       ad - show how much files will use on drive d:\n");
	printf ("       d  - show all directory entries\n");
	printf ("       lN - show files larger than 'N' bytes\n");
	printf ("       v  - find bad file names\n");
	printf ("       h  - help\n");
	exit (1);
   }

   for (i = argv+1; *i != NULL && (**i == '-' || **i == '/'); ++i);
   strcpy (temp_name, *i);

   for (;;) {
      if (temp_name == NULL || !**i) { /* no parm. use all "currect" */
	 strcpy (file, "*.*");
	 getcwd (root, 80);
	 _dos_getdrive (&drive);
	 break;
      }

      p = temp_name + strlen (temp_name); /* extract file name */
      while (--p >= temp_name && *p && *p != ':' && *p != '\\');
      while (*++p == '.');

      if (p < temp_name) {	       /* no path , use "current" */
	 strcpy (file, temp_name);
	 getcwd (root, 80);
	 _dos_getdrive (&drive);
	 break;
      }

      if (*p) {
	 strcpy (file, p);	       /* get file */
	 *p = '\0';
      }
      else			       /* no file, use "*.*" */
	 strcpy (file, "*.*");

      _dos_getdrive (&odrive);	       /* remember old drive */

      if (temp_name[1] == ':') {
	 drive = (root[0] = toupper (*temp_name)) - 'A' + 1;
	 _dos_setdrive (drive, &tdrive);
	 _dos_getdrive (&tdrive);
	 if (drive != tdrive) {
	    printf ("Bad Drive: %c\n", temp_name[0]);
	    _dos_setdrive (odrive, &tdrive);
	    exit (4);
	 }
	 p = temp_name + 2;
      }
      else {
	 p = temp_name;
	 drive = odrive;
      }

      if (*p) {
	 getcwd (odir, 80);	       /* remember old directory */

	 if ((len = strlen (p) - 1) > 0 &&
	     p[len] == '\\')
	    p[len] = '\0';

	 if (chdir (p)) {	       /* move to new directory   */
	    printf ("Bad path: %s\n", p);
	    _dos_setdrive (odrive, &tdrive);
	    chdir (odir);
	    exit (4);
	 }
	 getcwd (root, 80);	       /* get new directory */
	 chdir (odir);		       /* restore old directory   */
      }
      else
	 getcwd (root, 80);	       /* get new directory */

      _dos_setdrive (odrive, &tdrive); /* restore old drive  */

      break;
   }

   len = strlen (root) - 1;
   if (root[len] != ':' && root[len] != '\\') {	/* add trailing '\' */
      root[++len] = '\\';
      root[++len] = '\0';
   }

   for (p = file; *p && *p != '.' && *p != '?' && *p != '*'; ++p);
   if (!*p) {			       /* file is all alpha */
      if (!_dos_getfileattr (*i, &len) && len & _A_SUBDIR) {
	 strcat (root, file);
	 strcat (root, "\\");
	 strcpy (file, "*.*");
       }
   }

   _dos_getdiskfree (drive, &diskfree);
   csize = diskfree.sectors_per_cluster * diskfree.bytes_per_sector;
   if (option_a) {
      drive = toupper (option_a) - 'A' + 1;
      _dos_getdiskfree (drive, &diskfree);
      asize = diskfree.sectors_per_cluster * diskfree.bytes_per_sector;
   }

   line_no = 0;
   totals[0] = totals[1] = totals[2] = totals[3] = 0;
   list_dir (file, 0, totals);

   if (option_f)
      printf ("%8lu files found\n", totals[2]);

   if (option_a) {
      if (totals[3])
	      l1 = (100L * (totals[3] - totals[0])) / totals[3];
      else
	      l1 = 0;
      printf ("= on drive %c: %8lu %8lu %%%3lu (%u bytes clusters)\n",
	      option_a, totals[0], totals[3], l1, asize);
   }

   return (0);
}