home *** CD-ROM | disk | FTP | other *** search
/ Chip 2000 May / Chip_2000-05_cd2.bin / dosutils / gtar109 / dir_os2.c < prev    next >
C/C++ Source or Header  |  1991-01-14  |  4KB  |  208 lines
  1. /*
  2.  * @(#)dir.c 1.4 87/11/06 Public Domain.
  3.  *
  4.  *  A public domain implementation of BSD directory routines for
  5.  *  MS-DOS.  Written by Michael Rendell ({uunet,utai}michael@garfield),
  6.  *  August 1897
  7.  *  Ported to OS/2 by Kai Uwe Rommel
  8.  *  December 1989, February 1990
  9.  */
  10.  
  11. #include <sys/types.h>
  12. #include <sys/stat.h>
  13. #include <sys/dir.h>
  14.  
  15. #include <stdio.h>
  16. #include <malloc.h>
  17. #include <string.h>
  18.  
  19. #define INCL_NOPM
  20. #include <os2.h>
  21.  
  22. #include <extlib.h>
  23.  
  24.  
  25. int attributes = A_DIR | A_HIDDEN;
  26.  
  27.  
  28. static char *getdirent(char *);
  29. static void free_dircontents(struct _dircontents *);
  30.  
  31. static HDIR hdir;
  32. static USHORT count;
  33. static FILEFINDBUF find;
  34. static BOOL lower;
  35.  
  36.  
  37. DIR *opendir(char *name)
  38. {
  39.   struct stat statb;
  40.   DIR *dirp;
  41.   char c;
  42.   char *s;
  43.   struct _dircontents *dp;
  44.   char nbuf[MAXPATHLEN + 1];
  45.  
  46.   strcpy(nbuf, name);
  47.  
  48.   if ( ((c = nbuf[strlen(nbuf) - 1]) == '\\' || c == '/') &&
  49.        (strlen(nbuf) > 1) )
  50.   {
  51.     nbuf[strlen(nbuf) - 1] = 0;
  52.  
  53.     if ( nbuf[strlen(nbuf) - 1] == ':' )
  54.       strcat(nbuf, "\\.");
  55.   }
  56.   else
  57.     if ( nbuf[strlen(nbuf) - 1] == ':' )
  58.       strcat(nbuf, ".");
  59.  
  60.   if (stat(nbuf, &statb) < 0 || (statb.st_mode & S_IFMT) != S_IFDIR)
  61.     return NULL;
  62.  
  63.   if ( (dirp = malloc(sizeof(DIR))) == NULL )
  64.     return NULL;
  65.  
  66.   if ( nbuf[strlen(nbuf) - 1] == '.' )
  67.     strcpy(nbuf + strlen(nbuf) - 1, "*.*");
  68.   else
  69.     if ( ((c = nbuf[strlen(nbuf) - 1]) == '\\' || c == '/') &&
  70.          (strlen(nbuf) == 1) )
  71.       strcat(nbuf, "*.*");
  72.     else
  73.       strcat(nbuf, "\\*.*");
  74.  
  75.   dirp -> dd_loc = 0;
  76.   dirp -> dd_contents = dirp -> dd_cp = NULL;
  77.  
  78.   if ((s = getdirent(nbuf)) == NULL)
  79.     return dirp;
  80.  
  81.   do
  82.   {
  83.     if (((dp = malloc(sizeof(struct _dircontents))) == NULL) ||
  84.         ((dp -> _d_entry = malloc(strlen(s) + 1)) == NULL)      )
  85.     {
  86.       if (dp)
  87.         free(dp);
  88.       free_dircontents(dirp -> dd_contents);
  89.  
  90.       return NULL;
  91.     }
  92.  
  93.     if (dirp -> dd_contents)
  94.       dirp -> dd_cp = dirp -> dd_cp -> _d_next = dp;
  95.     else
  96.       dirp -> dd_contents = dirp -> dd_cp = dp;
  97.  
  98.     strcpy(dp -> _d_entry, s);
  99.     dp -> _d_next = NULL;
  100.  
  101.     dp -> _d_size = find.cbFile;
  102.     dp -> _d_mode = find.attrFile;
  103.     dp -> _d_time = *(unsigned *) &(find.ftimeLastWrite);
  104.     dp -> _d_date = *(unsigned *) &(find.fdateLastWrite);
  105.   }
  106.   while ((s = getdirent(NULL)) != NULL);
  107.  
  108.   dirp -> dd_cp = dirp -> dd_contents;
  109.  
  110.   return dirp;
  111. }
  112.  
  113.  
  114. void closedir(DIR * dirp)
  115. {
  116.   free_dircontents(dirp -> dd_contents);
  117.   free(dirp);
  118. }
  119.  
  120.  
  121. struct direct *readdir(DIR * dirp)
  122. {
  123.   static struct direct dp;
  124.  
  125.   if (dirp -> dd_cp == NULL)
  126.     return NULL;
  127.  
  128.   dp.d_namlen = dp.d_reclen =
  129.     strlen(strcpy(dp.d_name, dirp -> dd_cp -> _d_entry));
  130.  
  131.   dp.d_ino = 0;
  132.  
  133.   dp.d_size = dirp -> dd_cp -> _d_size;
  134.   dp.d_mode = dirp -> dd_cp -> _d_mode;
  135.   dp.d_time = dirp -> dd_cp -> _d_time;
  136.   dp.d_date = dirp -> dd_cp -> _d_date;
  137.  
  138.   dirp -> dd_cp = dirp -> dd_cp -> _d_next;
  139.   dirp -> dd_loc++;
  140.  
  141.   return &dp;
  142. }
  143.  
  144.  
  145. void seekdir(DIR * dirp, long off)
  146. {
  147.   long i = off;
  148.   struct _dircontents *dp;
  149.  
  150.   if (off >= 0)
  151.   {
  152.     for (dp = dirp -> dd_contents; --i >= 0 && dp; dp = dp -> _d_next);
  153.  
  154.     dirp -> dd_loc = off - (i + 1);
  155.     dirp -> dd_cp = dp;
  156.   }
  157. }
  158.  
  159.  
  160. long telldir(DIR * dirp)
  161. {
  162.   return dirp -> dd_loc;
  163. }
  164.  
  165.  
  166. static void free_dircontents(struct _dircontents * dp)
  167. {
  168.   struct _dircontents *odp;
  169.  
  170.   while (dp)
  171.   {
  172.     if (dp -> _d_entry)
  173.       free(dp -> _d_entry);
  174.  
  175.     dp = (odp = dp) -> _d_next;
  176.     free(odp);
  177.   }
  178. }
  179.  
  180.  
  181. static char *getdirent(char *dir)
  182. {
  183.   int done;
  184.  
  185.   if (dir != NULL)
  186.   {                       /* get first entry */
  187.     lower = IsFileSystemFAT(dir);
  188.  
  189.     hdir = HDIR_CREATE;
  190.     count = 1;
  191.     done = DosFindFirst(dir, &hdir, attributes,
  192.             &find, sizeof(find), &count, 0L);
  193.   }
  194.   else                       /* get next entry */
  195.     done = DosFindNext(hdir, &find, sizeof(find), &count);
  196.  
  197.   if ( lower )
  198.     strlwr(find.achName);
  199.  
  200.   if (done == 0)
  201.     return find.achName;
  202.   else
  203.   {
  204.     DosFindClose(hdir);
  205.     return NULL;
  206.   }
  207. }
  208.