/*
*  DIR by Richard Conn
*
* Revision History --
*  DIR Version 1.1 -- Modified by Frank Wancho
*              Several changes made to provide operation with MORE
*  DIR Version 1.0 by Richard Conn
*
*      DIR is an enhanced directory display utility for UNIX.
* It produces a sorted listing of file names and sizes in two columns,
* and the files are sorted down the columns.  If a file is a directory,
* its name is prefixed with a "D".  File count and size totals are displayed
* at the bottom of the listing.
*
*/

/*  C Libraries  */
#include <stdio.h>
#include <sys/types.h>
#include <sys/dir.h>
#include <sys/stat.h>
#define BUFSIZE 256

/*  Structure of a Directory Element as Stored for DIR  */
struct dirnode {
       char name[DIRSIZ];      /* Name of File */
       int dir;                /* Dir or Not? */
       off_t size;             /* Size in Bytes */
       short mode;             /* R/W/X */
       struct dirnode *next;   /* Ptr to Next File */
};

/*  Global Environment */
struct environ {
       int showhid;            /* Show Hidden Files? */
       int showrwx;            /* Show Attributes? */
       int filecnt;            /* Number of Files in List */
       off_t totsize;          /* Sum of All File Sizes */
       struct dirnode *first;  /* Ptr to First Elt in List */
       struct dirnode *last;   /* Ptr to Last Elt in List */
};

FILE    *out;

main(argc,argv)
char *argv[];
{
       char buf[BUFSIZE];
       struct environ env;
       int i, first;

       /* Init Environment */
       env.first = NULL;       /* No First Entry */
       env.showhid = 0;        /* No Hidden Files */
       env.showrwx = 0;        /* No R/W/X */
       env.filecnt = 0;        /* No Files */
       env.totsize = 0;        /* Accumulated File Size */

       /* Build Linked List of DIR Elements */
       if (argc == 1) build(".",&env,0);       /* current dir */
       else {
               first = 1;                              /* first file is 1 */
               if (*argv[1] == '-') {
                       first = 2;                      /* first file is 2 */
                       opts(argv[1],&env);
                       if (argc == 2) build(".",&env,0);       /* curr dir */
               }
               for (i=first; i<argc; i++) build(argv[i],&env,0);       /* ea */
       }

       /* Sort Linked List of DIR Elements */
       sort(&env);

       /* Display Results */
       out=popen("more","w");
       display(&env);
       pclose(out);
}

/*  Process Command Options  */
opts(cmdstr,env)
char *cmdstr;
struct environ *env;
{
       while (*cmdstr != '\0')
               switch (*cmdstr++) {
               case 'A' :
               case 'a' :
                       env->showrwx = 1;       /* show file attributes */
                       break;
               case 'H' :
               case 'h' :
                       env->showhid = 1;       /* show hidden files */
               default :
                       break;
               }
}

/*  Display Entries in Linked List  */
display(env)
struct environ *env;
{
       struct dirnode *lptr, *rptr, *elt();
       char *fname;
       int i;

       if (env->filecnt > 0) {
               fprintf(out,"  -- Filename --  - Size -");
               if (env->showrwx) fprintf(out,"  Atr");
       }
       if (env->filecnt > 1) {
               fprintf(out,"      -- Filename --  - Size -");
               if (env->showrwx) fprintf(out,"  Atr");
       }
       fprintf(out,"\n");
       lptr = elt(0,env);      /* Pt to first element in left col */
       rptr = elt(env->filecnt%2 ? env->filecnt/2+1 : env->filecnt/2, env);
       for (i=0; i < env->filecnt/2; i++) {
               prelt(lptr,env);        /* Print Left Element */
               prelt(rptr,env);        /* Print Right Element */
               fprintf(out,"\n");      /* New Line */
               lptr = lptr->next;      /* Pt to next */
               rptr = rptr->next;
       }
       if (env->filecnt%2) {
               prelt(lptr,env);        /* Print Odd Element */
               fprintf(out,"\n");
       }
       fprintf(out,"           -- %d Entries Displayed, %ld Bytes --\n",
       env->filecnt, env->totsize);
}

/*  Print Element Pointed To  */
prelt(ptr,env)
struct dirnode *ptr;
struct environ *env;
{
       char *fname;
       int j;

       if (ptr->dir) fprintf(out,"D ");                /* Print Dir Flag */
       else fprintf(out,"  ");
       fname = ptr->name;
       for (j=0; j < DIRSIZ; j++)                      /* Print File Name */
               if (*fname == '\0') fputc(' ',out);
               else fputc(*fname++,out);
       fprintf(out,"  %8ld", ptr->size);               /* Print File Size */
       if (env->showrwx) fprintf(out,"  %c%c%c",       /* Print RWX Flags */
       (ptr->mode & S_IREAD)  ? 'r' : '-',
       (ptr->mode & S_IWRITE) ? 'w' : '-',
       (ptr->mode & S_IEXEC)  ? 'x' : '-');
       fprintf(out,"    ");
}

/*  Shell Sort Directory Entries (See Pg 108 of K&R for Algorithm)  */
sort(env)
struct environ *env;
{
       int gap, i, j;
       struct dirnode dir, *eltj, *eltjg, *elt();

       for (gap = env->filecnt/2; gap > 0; gap /= 2)
               for (i = gap; i < env->filecnt; i++)
                       for (j = i-gap; j >= 0; j -= gap) {
                               eltj = elt(j,env);      /* pt to elt j */
                               eltjg = elt(j+gap,env); /* pt to elt j+gap */
                               if (strcmp(eltj->name,eltjg->name) <= 0)
                                       break;
                               /* temp = v[j] */
                               *dir.name = '\0';       /* clear str */
                               strcat(dir.name,eltj->name);
                               dir.dir = eltj->dir;
                               dir.size = eltj->size;
                               dir.mode = eltj->mode;
                               /* v[j] = v[j+gap] */
                               *eltj->name = '\0';     /* clear str */
                               strcat(eltj->name,eltjg->name);
                               eltj->dir = eltjg->dir;
                               eltj->size = eltjg->size;
                               eltj->mode = eltjg->mode;
                               /* v[j+gap] = temp */
                               *eltjg->name = '\0';    /* clear str */
                               strcat(eltjg->name,dir.name);
                               eltjg->dir = dir.dir;
                               eltjg->size = dir.size;
                               eltjg->mode = dir.mode;
                       }
}

/* Point to Nth (Starting at 0) Element in Linked List */
struct dirnode *elt(n,env)
int n;
struct environ *env;
{
       struct dirnode *rover;
       int i;

       rover = env->first;     /* pt to first element */
       for (i=0; i<n; i++) rover = rover->next;        /* adv thru list */
       return (rover);
}

/* Build Linked List Structure Containing Directory Entries */
build(name,env,level)
char *name;
struct environ *env;
int level;
{
       struct stat stbuf;
       struct dirnode dir;
       struct dirnode *calloc();
       char *nameptr;
       int i, ccnt;

       /* Check for File Existence */
       if (stat(name,&stbuf) == -1) {
               fprintf(stderr,"Can't find %s\n", name);
               return;
       }

       /* Check to See if File is a Directory */
       if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {      /* we have a dir */
               directory(name,env,level);
               if (!level) return;
       }

       /*  Check Hidden Entries */
       if (*name == '.' && !(env->showhid)) return;

       /*  Store Entry in Memory  */
       if (env->first == NULL) {       /* First Entry Processing */
               env->first = calloc(1, sizeof(dir));
               env->last = env->first;
       }
       else {                          /* Nth Entry Processing */
               (*env->last).next = calloc(1, sizeof(dir));
               env->last = (*env->last).next;
       }
       if (env->last == NULL) {
               fprintf(stderr, "Dynamic Memory Overflow\n");
               exit(0);
       }

       /* Store Entry Values */
       env->filecnt++;         /* Increment File Count */
       (*env->last).next = NULL;
       nameptr = name;         /* Pt to first char of file name */
       ccnt = strlen(name);    /* Number of chars in file name */
       for (i=0; i < ccnt; i++)        /* Find Last Part of Name */
               if (*name++ == '/') nameptr = name;
       strcat((*env->last).name,nameptr);      /* Save File Name */
       (*env->last).size = stbuf.st_size;      /* Save File Size */
       (*env->last).mode = stbuf.st_mode;      /* Save Mode Bits */
       env->totsize += stbuf.st_size;          /* Increment Total Sizes */
       if ((stbuf.st_mode & S_IFMT) == S_IFDIR)        /* Set Dir Flag */
               (*env->last).dir = 1;
       else (*env->last).dir = 0;
}

/* Process All Entries in a Directory */
directory(name,env,level)
char *name;
struct environ *env;
int level;
{
       struct direct dirbuf;
       char *nbp, *nep;
       char dirname[BUFSIZE];
       char filename[DIRSIZ];
       int i,fd;

       if (level) return;      /* don't recurse */

       /* Build Name of Directory into DIRNAME */
       nep = dirname;
       nbp = name;
       while (*nbp != '\0') *nep++ = *nbp++;
       *nep = '\0';    /* terminate string */
       if (nep+DIRSIZ+2 >= dirname+BUFSIZE)    /* name too long */
               return;

       /* Log Into Directory */
       if (chdir(dirname)) {
               fprintf(stderr, "Directory %s Not Found\n", dirname);
               return;
       }

       /* Open Directory File */
       if ((fd = open(".",0)) == -1) return;

       /* Read Through the Elements in the Directory */
       while (read(fd, (char *)&dirbuf, sizeof(dirbuf)) > 0) {
               if (dirbuf.d_ino == 0)  /* slot not in use */
                       continue;
               for (i=0, nep=filename; i<DIRSIZ; i++)  /* build file name */
                       *nep++ = dirbuf.d_name[i];
               *nep++ = '\0';
               build(filename,env,level+1);    /* reenter build for new file */
       }
       close(fd);
}

You are viewing proxied material from gopher.quux.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.