/*
 * Filename:    dirent.c
 *
 * Purpose:     UNIX directory services
 *
 * Routines:    opendir
 *              closedir
 *              readdir
 *              seekdir
 *              rewindir
 *              telldir
 *              freedirlist       s
 *
 *              * = Routines called by function pointer.
 *              s = Static functions.
 *
 *  Modification History:
       25/08/95      - WATCOMC, and extended DIR to include
                       d_size, d_attr, d_time and d_date fields.
       29/05/96      - Documentation
                     - Rewinddir
                     - Modified readdir() to return a directory
                       based structure.
       12/06/00      - Skip volume labels
       19/07/00      - Changed search attribute from 0Xff to
                       explicit attributes, as 0XFF returns
                       only the share name under Win9x.
       01/07/01      WIN32
*
* $Name:  $Source: /cvsroot/device/DEVL/UTILS/LIBWIN32/dirent.c,v $
* $Revision: 1.2 $ $Date: 2004/05/10 09:35:02 $ $State: Exp $
* $Author: ayoung $ $Locker:  $
*.........................................................................*/
/*
*     Include files
*     -------------
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#define  _DIRENT_SOURCE
#include <unistd.h>
#include "dirent.h"
#include <windows.h>

#define DISABLE_HARD_ERRORS     SetErrorMode (0)
#define ENABLE_HARD_ERRORS      SetErrorMode (SEM_FAILCRITICALERRORS | \
                                        SEM_NOOPENFILEERRORBOX)

static void                     freedirlist(struct _dirlist *);


/*-Open a directory-----------------------------------------------------------

   Synopsis:
         DIR *opendir
               (
                   const char *pName
               )

   Purpose:
       The opendir() function opens a directory stream corre-
       sponding to the directory name, and returns a pointer to
       the directory stream. The stream is positioned at the
       first entry in the directory.

   Parameters:
       const char *pName,  Specifies the name of directory

   Returns:

       The opendir() function returns a pointer to the  directory
       stream or NULL if an error occurred, and 'errno' is set to
       one of the following manifest constants.

       Constant      Description
       ---------------------------------------------------------------
       EACESS        Permission denied.
       EMFILE        Too many file descriptors in use by process.
       ENFILE        Too many files are currently open in the system.
       ENOENT        Directory does not exist.
       ENOMEM        Insufficient memory to complete the operation.
       ENOTDIR       Name is not a directory.

   Notes:
       SVID 3, POSIX, BSD 4.3

   See also:
       open(2), readdir(3), closedir(3), rewinddir(3),
       seekdir(3), telldir(3), scandir(3)
----------------------------------------------------------------------------*/
DIR *
opendir( char *pName )
{
   static       int id = 1;     /* singleton */
   WIN32_FIND_DATA finddata;
   HANDLE       hSearch;
   struct       _dirlist *pDirlist;
   char         path[ MAX_PATH ];
   BOOL         isHPFS;
   DIR          *pDir;
   int          i, len;
   int          rc;

/* Copy to working buffer */
   if ((len = strlen(pName)) == 0)
   {
      errno = ENOTDIR;
      return (DIR *)NULL;
   }

/* Convert path */
   if (_fullpath(path, pName, sizeof(path)) == NULL)
   {
   /* Unknown, assume DOS */
      char *last;

      (void) strcpy(path, pName);
      for (i = 0; path[i]; i++)
          if (path[i] == '/')
              path[i] = '\\';       /* convert */
      last = &path[len - 1];

   /* Ok, DOS is very picky about its directory names.
    * The following are valid.
    *  c:/
    *  c:.
    *  c:name/name1
    *
    *  c:name/ is not valid
    */
       if ((*last == '\\') && (len > 1) &&
                (!((len == 3) && (path[1] == ':'))))
           *(last--) = 0;
   }

/* Is a directory ? */
   if (strcmp(path, ".") != 0)
   {
       struct _stat sb;

       DISABLE_HARD_ERRORS;
       rc = _stat (path, &sb);
       ENABLE_HARD_ERRORS;
       if (rc)
          return (DIR *)NULL;
       if (!S_ISDIR(sb.st_mode))
       {
          errno = ENOTDIR;
          return (DIR *)NULL;
       }
   }
                                /* extended file system */
   isHPFS = IsHPFSFileSystem(path);

/* Strip trailing slashes, so we can append "\*.*" */
   len = strlen(path);
   while (len > 0)
   {
      len--;
      if (path[len] == '\\')
         path[len] = '\0';      /* remove slash */
      else {
         len++;                 /* end of path */
         break;
      }
   }

   path[len++] = '\\';          /* insert pattern */
   path[len++] = '*';
   path[len++] = '.';
   path[len++] = '*';
   path[len++] = 0;

/* Create DIR structure */
   if ((pDir = (DIR *)calloc(sizeof(DIR), 1)) == (DIR *)NULL)
      return (DIR *)NULL;

   if ((pDir->dd_buf =
          (char *)malloc(sizeof(struct dirent))) == (char *)NULL)
   {
      free(pDir);
      return (DIR *)NULL;
   }

   pDir->dd_id    = id++;       /* generate unique directory identifier */
   pDir->dd_fd    = -1;         /* file descriptor */
   pDir->dd_loc   = 0L;
   pDir->dd_ddloc = (struct _dirlist *)NULL;

/* Open directory */
   DISABLE_HARD_ERRORS;
   hSearch = FindFirstFile( path, &finddata );
   ENABLE_HARD_ERRORS;

   if (hSearch == 0)
   {
      rc = GetLastError();
#if defined(ERROR_EMPTY_DIR)
      if (rc == ERROR_EMPTY_DIR)
          return (pDir);        /* entry list */
#endif
      free(pDir);
      errno = ENOENT;
      return (DIR *)NULL;
   }

/* Create directory entries */
   do {
#if defined(FILE_ATTRIBUTE_VOLUME)
   /* Skip volume labels */
      if (finddata.ff_attrib & FILE_ATTRIBUTE_VOLUME)
         continue;
#endif
   /* Skip '.' */
      if ( strcmp(finddata.cFileName, ".") == 0 )
         continue;

   /* Create new entry */
      pDirlist = (struct _dirlist *)calloc(1, sizeof(struct _dirlist));
      if (pDirlist == (struct _dirlist *)NULL)
      {
         freedirlist(pDir->dd_contents);
         FindClose(hSearch);
         return (DIR *)NULL;
      }

      pDirlist->dl_entry   = malloc( strlen(finddata.cFileName)+1 );
      if (pDirlist->dl_entry == (char *)NULL)
      {
         free(pDirlist);
         freedirlist(pDir->dd_contents);
         FindClose(hSearch);
         return (DIR *)NULL;
      }

      if (pDir->dd_contents)
         pDir->dd_current  = pDir->dd_current->dl_next = pDirlist;
      else
      {
         pDir->dd_contents = pDir->dd_current = pDirlist;
      }

      (void) strcpy(pDirlist->dl_entry, finddata.cFileName);
      if (!isHPFS)
         strlwr(pDirlist->dl_entry);
//TODO..
//    pDirlist->dl_ctime   = finddata.ftCreationTime;
//    pDirlist->dl_mtime   = finddata.ftLastWriteTime;
//    pDirlist->dl_qsize   = (finddata.nFileSizeHigh * (MAXDWORD+1)) +
//                              finddata.nFileSizeLow;

      pDirlist->dl_size2   = finddata.nFileSizeHigh;
      pDirlist->dl_size    = finddata.nFileSizeLow;
      pDirlist->dl_attr    = finddata.dwFileAttributes;
      pDirlist->dl_next    = (struct _dirlist *)NULL;

   } while ( FindNextFile(hSearch, &finddata) );
   FindClose( hSearch );
   pDir->dd_current = pDir->dd_contents;

   return (pDir);
}


/*-Close a directory----------------------------------------------------------

   Synopsis:
         int closedir
               (
                   DIR *pDir
               )

   Purpose:
       The  closedir() function closes the directory stream asso-
       ciated with dir.  The directory stream descriptor 'pDir' is
       not available after this call.

   Parameters:
       DIR *pDir,       Specifies the open directory

   Returns:
       The  closedir()  function  returns  0  on success or -1 on
       failure and 'errno' is set to one of the following manifest
       constants.

       Constant      Description
       ---------------------------------------------------------------
       EBADF         Invalid directory stream descriptor dir.

   Notes:
       SVID 3, POSIX, BSD 4.3

   See also
       close(2), opendir(3), readdir(3), rewinddir(3),
       seekdir(3), telldir(3), scandir(3)
----------------------------------------------------------------------------*/
int
closedir( DIR *pDir )
{
   if (pDir == (DIR *)NULL)
      return 1;                                 /* EBADF */
   freedirlist(pDir->dd_contents);
   free((char *)pDir->dd_buf);
   free((char *)pDir);
   return 0;
}


/*-Read a directory-----------------------------------------------------------

   Synopsis:
         struct dirent *readdir
               (
                   DIR  *pDir
               )

   Purpose:
       The readdir()  function  returns  a  pointer  to a dirent
       structure representing the next  directory  entry  in  the
       directory  stream  pointed  to be dir.  It returns NULL on
       reaching the end-of-file or if an error occurred.

       The data returned by readdir() is overwritten by subse-
       quent calls to readdir() for the same directory stream.

   Parameters:
       DIR *pDir,    Specifies the open directory

   Returns:
       The  readdir()  function  returns  a  pointer  to a dirent
       structure, or NULL if an error occurs  or  end-of-file  is
       reached, and 'errno' is set to one of the following manifest
       constants.

       Constant      Description
       ------------------------------------------------------------
       EBADF         Invalid directory stream descriptor dir.

   Notes:
       SVID 3, POSIX, BSD 4.3

   See also:
       read(2), opendir(3), closedir(3), rewinddir(3),
       seekdir(3), telldir(3), scandir(3)
----------------------------------------------------------------------------*/
struct dirent *
readdir( DIR *pDir )
{
   struct _dirlist *pEntry;
   struct dirent *pDirent;

/* Retrieve associated fields */
   if (pDir->dd_current == (struct _dirlist *)NULL)
      return (struct dirent *)NULL;
   pEntry  = pDir->dd_current;
   pDirent = (struct dirent *)pDir->dd_buf;

/* Standard fields */
   strcpy(pDirent->d_name, pEntry->dl_entry);
   pDirent->d_namlen = (u_short) strlen(pDirent->d_name);
   pDirent->d_reclen = sizeof(struct dirent);
   (void)strlwr(pDirent->d_name);
   pDirent->d_fileno = 0;

/* The following field are extensions */
   pDirent->d_ctime = pEntry->dl_ctime;
   pDirent->d_mtime = pEntry->dl_mtime;
   pDirent->d_size  = pEntry->dl_size;
   pDirent->d_attr  = pEntry->dl_attr;

/* Update current location */
   pDir->dd_current = pEntry->dl_next;
   pDir->dd_loc++;

   return (pDirent);
}


/*-Set the next of next readdir()---------------------------------------------

   Synopsis:
       void seekdir
               (
                   DIR *pDir, off_t off
               )

   Purpose:
       The seekdir() function sets the location in the  directory
       stream  from  which  the  next  readdir() call will start.
       seekdir() should  be  used  with  an  offset  returned  by
       telldir().

   Parameters:
       DIR *pDir,    Specifies the open directory
       off_t off     Offset

   Returns:
       The seekdir() function returns no value.

   Notes:
       BSD 4.3

   See also:
       lseek(2), opendir(3), readdir(3), closedir(3),  rewinddir(3),
       telldir(3), scandir(3)
----------------------------------------------------------------------------*/
void
seekdir( DIR *pDir, long off )
{
   struct _dirlist *pDirlist;
   long i = off;

   if (off > 0) {
      for (pDirlist = pDir->dd_contents;
            --i >= 0 && pDirlist;
             pDirlist = pDirlist->dl_next
          )
         ;
      pDir->dd_loc = off - (i+1);
      pDir->dd_current = pDirlist;
   }
}


/*-Reset directory stream-----------------------------------------------------

   Synopsis:
       void rewinddir
            (
               DIR *pDir
            )

   Purpose:
       The rewinddir() function resets the position of the direc-
       tory stream dir to the beginning of the directory.

   Parameters:
       DIR *pDir,    Specifies the open directory

   Returns:
       The readdir() function returns no value.

   Notes:
       SVID 3, POSIX, BSD 4.3

   See also:
       opendir(3), readdir(3), closedir(3), seekdir(3),
       telldir(3), scandir(3)
----------------------------------------------------------------------------*/
void
rewinddir( DIR *pDir )
{
   seekdir(pDir, (long)0);
}


/*-Return current location in directory stream-------------------------------

   Synopsis:
       long telldir
            (
               DIR *pDir
            )

   Purpose:
       The telldir() function returns the current location
       associated with the directory stream dir.

   Parameters:
       DIR *pDir,    Specifies the open directory

   Returns:
       The telldir() function returns the current location in the
       directory stream or -1 if an error occurs.

       EBADF         Invalid directory stream descriptor dir.

   Notes:
       BSD 4.3

   See also;
       opendir(3), readdir(3), closedir(3), rewinddir(3),
       seekdir(3), scandir(3)
----------------------------------------------------------------------------*/
long
telldir( DIR *pDir )
{
   return (pDir->dd_loc);
}


/*
 * IsHPFS ---
 *      Is High Performance File System
 */
int
IsHPFSFileSystem( const char *directory )
{
        char             bName[4];
        DWORD            flags;
        DWORD            maxname;
        BOOL             rc;
        unsigned int     nDrive;
        char             szCurDir [MAX_PATH];

        if (isalpha (directory[0]) && (directory[1] == ':'))
                nDrive = toupper (directory[0]) - '@';
        else
        {
                GetCurrentDirectory (MAX_PATH, szCurDir);
                nDrive = szCurDir[0] - 'A' + 1;
        }

/* Set up the drive name */
        strcpy(bName, "x:\\");
        bName[0] = (char) (nDrive + '@');

/* Read the volume info, if we fail - assume non-HPFS */
        DISABLE_HARD_ERRORS;
        rc = GetVolumeInformation (bName, (LPTSTR)NULL, 0,
                (LPDWORD)NULL, &maxname, &flags, (LPTSTR)NULL, 0);
        ENABLE_HARD_ERRORS;

        return ((rc) && (flags & (FS_CASE_SENSITIVE | \
                        FS_CASE_IS_PRESERVED))) ? TRUE : FALSE;
}


/*
 * freedirlist ---
 *      Dispose of the directory list
 */
static void
freedirlist( struct _dirlist *pDirlist )
{
   struct _dirlist *opDirlist;

   while (pDirlist)
   {
      if (pDirlist->dl_entry)
         free(pDirlist->dl_entry);
      pDirlist = (opDirlist = pDirlist)->dl_next;
      free(opDirlist);
   }
}