src/win32/dirent.c

/* 
   dir.c for MS-DOS by Samuel Lam <skl@van-bc.UUCP>, June/87 
*/ 
 
/* #ifdef WIN32 */
/* 
 * @(#)dir.c 1.4 87/11/06 Public Domain. 
 * 
 *  A public domain implementation of BSD directory routines for 
 *  MS-DOS.  Written by Michael Rendell ({uunet,utai}michael@garfield), 
 *  August 1897 
 *  Ported to OS/2 by Kai Uwe Rommel 
 *  December 1989, February 1990 
 *  Ported to Windows NT 22 May 91 
 *    other mods Summer '92 brianmo@microsoft.com 
 *  opendirx() was horribly written, very inefficient, and did not take care
 *    of all cases.  It is still not too clean, but it is far more efficient.
 *    Changes made by Gordon Chaffee (chaffee@bugs-bunny.cs.berkeley.edu)
 */ 
 
 
/*Includes: 
 *      crt 
 */ 
#include <windows.h>
#include <stdlib.h> 
#include <string.h> 
#include <sys\types.h> 
#include <sys\stat.h> 
#define _SWISH_PORT
#include "dirent.h" 
#include "config.h"

/* 
 *      NT specific 
 */ 
#include <stdio.h> 
 
/* 
 *      random typedefs 
 */ 
#define HDIR        HANDLE 
#define HFILE       HANDLE 
#define PHFILE      PHANDLE 
 
/* 
 *      local functions 
 */ 
static char *getdirent(char *); 
static void free_dircontents(struct _dircontents *); 
 
static HDIR                             FindHandle; 
static WIN32_FIND_DATA  FileFindData; 
 
static struct dirent dp; 
 
DIR *opendirx(char *name, char *pattern) 
{ 
    struct stat statb; 
    DIR *dirp; 
    char c; 
    char *s; 
    struct _dircontents *dp; 
    int len;
    int unc;
    char path[ SW_MAXPATHNAME ]; 
    register char *ip, *op;
        
    for (ip = name, op = path; ; op++, ip++) {
                *op = *ip;
                if (*ip == '\0') {
                        break;
                }
    }

    len = ip - name;
    if (len > 0) {
                /* Windows NT required a trailing '/' at some point.  Now it MUST NOT have one.  */
//              unc = ((path[0] == '\\' || path[0] == '/') &&
//                      (path[1] == '\\' || path[1] == '/'));
                unc = 0;
                c = path[len - 1];
                if (unc) {
                        if (c != '\\' && c != '/') {
                                path[len] = '/';
                                len++;
                                path[len] ='\0';
                        }
                } else {
                        if ((c == '\\' || c == '/') && (len > 1)) {
                                len--;
                                path[len] = '\0';
                                
                                if (path[len - 1] == ':' ) {
                                        path[len] = '/'; len++;
                                        path[len] = '.'; len++;
                                        path[len] = '\0';
                                }
                        } else if (c == ':' ) {
                                path[len] = '.';
                                len++;
                                path[len] ='\0';
                        }
                }
    } else {
                unc = 0;
                path[0] = '.';
                path[1] = '\0';
                len = 1;
    }
        
    if (stat(path, &statb) < 0 || (statb.st_mode & S_IFMT) != S_IFDIR) {
                return NULL; 
    }
        
    dirp = malloc(sizeof(DIR));
    if (dirp == NULL) {
                return dirp;
    }
        
    c = path[len - 1];
    if (c == '.' ) {
                if (len == 1) {
                        len--;
                } else {
                        c = path[len - 2];
                        if (c == '\\' || c == ':') {
                                len--;
                        } else {
                                path[len] = '/';
                                len++;
                        }
                }
    } else if (!unc && ((len != 1) || (c != '\\' && c != '/'))) {
                path[len] = '/';
                len++;
    }
    strcpy(path + len, pattern);
        
    dirp -> dd_loc = 0; 
    dirp -> dd_contents = dirp -> dd_cp = NULL; 
        
    if ((s = getdirent(path)) == NULL) {
                return dirp;
    }
        
    do 
    { 
                if (((dp = malloc(sizeof(struct _dircontents))) == NULL) || 
                        ((dp -> _d_entry = malloc(strlen(s) + 1)) == NULL)      ) 
                { 
                        if (dp) 
                                free(dp); 
                        free_dircontents(dirp -> dd_contents); 
                        
                        return NULL; 
                } 
                
                if (dirp -> dd_contents) 
                        dirp -> dd_cp = dirp -> dd_cp -> _d_next = dp; 
                else 
                        dirp -> dd_contents = dirp -> dd_cp = dp; 
                
                strcpy(dp -> _d_entry, s); 
                dp -> _d_next = NULL; 
                
    } 
    while ((s = getdirent(NULL)) != NULL); 
        
    dirp -> dd_cp = dirp -> dd_contents; 
    return dirp; 
} 
 
DIR *opendir(char *name)
{
        return opendirx(name, "*");
} 

void closedir(DIR * dirp) 
{ 
        free_dircontents(dirp -> dd_contents); 
        free(dirp); 
} 
 
struct dirent *readdir(DIR * dirp) 
{ 
        /* static struct dirent dp; */ 
        if (dirp -> dd_cp == NULL) 
                return NULL; 
        
        /*strcpy(dp.d_name,dirp->dd_cp->_d_entry); */ 
        
        dp.d_name = dirp->dd_cp->_d_entry; 
        
        dp.d_namlen = dp.d_reclen = 
                strlen(dp.d_name); 
        
        dp.d_ino = dirp->dd_loc+1; /* fake the inode */ 
        
        dirp -> dd_cp = dirp -> dd_cp -> _d_next; 
        dirp -> dd_loc++; 
        
        
        return &dp; 
} 

void seekdir(DIR * dirp, long off) 
{ 
        long i = off; 
        struct _dircontents *dp; 
        
        if (off >= 0) 
        { 
                for (dp = dirp -> dd_contents; --i >= 0 && dp; dp = dp -> _d_next); 
                
                dirp -> dd_loc = off - (i + 1); 
                dirp -> dd_cp = dp; 
        } 
} 
 
 
long telldir(DIR * dirp) 
{ 
        return dirp -> dd_loc; 
} 

static void free_dircontents(struct _dircontents * dp) 
{ 
        struct _dircontents *odp; 
        
        while (dp) 
        { 
                if (dp -> _d_entry) 
                        free(dp -> _d_entry); 
                
                dp = (odp = dp) -> _d_next; 
                free(odp); 
        } 
} 
/* end of "free_dircontents" */ 

static char *getdirent(char *dir) 
{ 
    int got_dirent; 
        
    if (dir != NULL) 
    {                                  /* get first entry */ 
                if ((FindHandle = FindFirstFile( dir, &FileFindData )) 
                        == (HDIR)0xffffffff) 
                { 
                        return NULL; 
                } 
                got_dirent = 1;
    } 
    else                                       /* get next entry */ 
                got_dirent = FindNextFile( FindHandle, &FileFindData ); 
        
    if (got_dirent) 
                return FileFindData.cFileName; 
    else 
    { 
                FindClose(FindHandle); 
                return NULL; 
    } 
} 
/* end of getdirent() */ 

struct passwd * _cdecl
getpwnam(char *name)
{
    return NULL;
}

struct passwd * _cdecl
getpwuid(int uid)
{
    return NULL;
}

int
getuid()
{
    return 0;
}

void _cdecl
endpwent(void)
{
}

/* #endif */
1	adcroft	1.1	/*
2			dir.c for MS-DOS by Samuel Lam <skl@van-bc.UUCP>, June/87
3			*/
4
5			/* #ifdef WIN32 */
6			/*
7			* @(#)dir.c 1.4 87/11/06 Public Domain.
8			*
9			* A public domain implementation of BSD directory routines for
10			* MS-DOS. Written by Michael Rendell ({uunet,utai}michael@garfield),
11			* August 1897
12			* Ported to OS/2 by Kai Uwe Rommel
13			* December 1989, February 1990
14			* Ported to Windows NT 22 May 91
15			* other mods Summer '92 brianmo@microsoft.com
16			* opendirx() was horribly written, very inefficient, and did not take care
17			* of all cases. It is still not too clean, but it is far more efficient.
18			* Changes made by Gordon Chaffee (chaffee@bugs-bunny.cs.berkeley.edu)
19			*/
20
21
22			/*Includes:
23			* crt
24			*/
25			#include <windows.h>
26			#include <stdlib.h>
27			#include <string.h>
28			#include <sys\types.h>
29			#include <sys\stat.h>
30			#define _SWISH_PORT
31			#include "dirent.h"
32			#include "config.h"
33
34			/*
35			* NT specific
36			*/
37			#include <stdio.h>
38
39			/*
40			* random typedefs
41			*/
42			#define HDIR HANDLE
43			#define HFILE HANDLE
44			#define PHFILE PHANDLE
45
46			/*
47			* local functions
48			*/
49			static char getdirent(char );
50			static void free_dircontents(struct _dircontents *);
51
52			static HDIR FindHandle;
53			static WIN32_FIND_DATA FileFindData;
54
55			static struct dirent dp;
56
57			DIR opendirx(char name, char *pattern)
58			{
59			struct stat statb;
60			DIR *dirp;
61			char c;
62			char *s;
63			struct _dircontents *dp;
64			int len;
65			int unc;
66			char path[ SW_MAXPATHNAME ];
67			register char ip, op;
68
69			for (ip = name, op = path; ; op++, ip++) {
70			op = ip;
71			if (*ip == '\0') {
72			break;
73			}
74			}
75
76			len = ip - name;
77			if (len > 0) {
78			/* Windows NT required a trailing '/' at some point. Now it MUST NOT have one. */
79			// unc = ((path[0] == '\\' \|\| path[0] == '/') &&
80			// (path[1] == '\\' \|\| path[1] == '/'));
81			unc = 0;
82			c = path[len - 1];
83			if (unc) {
84			if (c != '\\' && c != '/') {
85			path[len] = '/';
86			len++;
87			path[len] ='\0';
88			}
89			} else {
90			if ((c == '\\' \|\| c == '/') && (len > 1)) {
91			len--;
92			path[len] = '\0';
93
94			if (path[len - 1] == ':' ) {
95			path[len] = '/'; len++;
96			path[len] = '.'; len++;
97			path[len] = '\0';
98			}
99			} else if (c == ':' ) {
100			path[len] = '.';
101			len++;
102			path[len] ='\0';
103			}
104			}
105			} else {
106			unc = 0;
107			path[0] = '.';
108			path[1] = '\0';
109			len = 1;
110			}
111
112			if (stat(path, &statb) < 0 \|\| (statb.st_mode & S_IFMT) != S_IFDIR) {
113			return NULL;
114			}
115
116			dirp = malloc(sizeof(DIR));
117			if (dirp == NULL) {
118			return dirp;
119			}
120
121			c = path[len - 1];
122			if (c == '.' ) {
123			if (len == 1) {
124			len--;
125			} else {
126			c = path[len - 2];
127			if (c == '\\' \|\| c == ':') {
128			len--;
129			} else {
130			path[len] = '/';
131			len++;
132			}
133			}
134			} else if (!unc && ((len != 1) \|\| (c != '\\' && c != '/'))) {
135			path[len] = '/';
136			len++;
137			}
138			strcpy(path + len, pattern);
139
140			dirp -> dd_loc = 0;
141			dirp -> dd_contents = dirp -> dd_cp = NULL;
142
143			if ((s = getdirent(path)) == NULL) {
144			return dirp;
145			}
146
147			do
148			{
149			if (((dp = malloc(sizeof(struct _dircontents))) == NULL) \|\|
150			((dp -> _d_entry = malloc(strlen(s) + 1)) == NULL) )
151			{
152			if (dp)
153			free(dp);
154			free_dircontents(dirp -> dd_contents);
155
156			return NULL;
157			}
158
159			if (dirp -> dd_contents)
160			dirp -> dd_cp = dirp -> dd_cp -> _d_next = dp;
161			else
162			dirp -> dd_contents = dirp -> dd_cp = dp;
163
164			strcpy(dp -> _d_entry, s);
165			dp -> _d_next = NULL;
166
167			}
168			while ((s = getdirent(NULL)) != NULL);
169
170			dirp -> dd_cp = dirp -> dd_contents;
171			return dirp;
172			}
173
174			DIR opendir(char name)
175			{
176			return opendirx(name, "*");
177			}
178
179			void closedir(DIR * dirp)
180			{
181			free_dircontents(dirp -> dd_contents);
182			free(dirp);
183			}
184
185			struct dirent readdir(DIR dirp)
186			{
187			/* static struct dirent dp; */
188			if (dirp -> dd_cp == NULL)
189			return NULL;
190
191			/strcpy(dp.d_name,dirp->dd_cp->_d_entry); /
192
193			dp.d_name = dirp->dd_cp->_d_entry;
194
195			dp.d_namlen = dp.d_reclen =
196			strlen(dp.d_name);
197
198			dp.d_ino = dirp->dd_loc+1; /* fake the inode */
199
200			dirp -> dd_cp = dirp -> dd_cp -> _d_next;
201			dirp -> dd_loc++;
202
203
204			return &dp;
205			}
206
207			void seekdir(DIR * dirp, long off)
208			{
209			long i = off;
210			struct _dircontents *dp;
211
212			if (off >= 0)
213			{
214			for (dp = dirp -> dd_contents; --i >= 0 && dp; dp = dp -> _d_next);
215
216			dirp -> dd_loc = off - (i + 1);
217			dirp -> dd_cp = dp;
218			}
219			}
220
221
222			long telldir(DIR * dirp)
223			{
224			return dirp -> dd_loc;
225			}
226
227			static void free_dircontents(struct _dircontents * dp)
228			{
229			struct _dircontents *odp;
230
231			while (dp)
232			{
233			if (dp -> _d_entry)
234			free(dp -> _d_entry);
235
236			dp = (odp = dp) -> _d_next;
237			free(odp);
238			}
239			}
240			/* end of "free_dircontents" */
241
242			static char getdirent(char dir)
243			{
244			int got_dirent;
245
246			if (dir != NULL)
247			{ /* get first entry */
248			if ((FindHandle = FindFirstFile( dir, &FileFindData ))
249			== (HDIR)0xffffffff)
250			{
251			return NULL;
252			}
253			got_dirent = 1;
254			}
255			else /* get next entry */
256			got_dirent = FindNextFile( FindHandle, &FileFindData );
257
258			if (got_dirent)
259			return FileFindData.cFileName;
260			else
261			{
262			FindClose(FindHandle);
263			return NULL;
264			}
265			}
266			/* end of getdirent() */
267
268			struct passwd * _cdecl
269			getpwnam(char *name)
270			{
271			return NULL;
272			}
273
274			struct passwd * _cdecl
275			getpwuid(int uid)
276			{
277			return NULL;
278			}
279
280			int
281			getuid()
282			{
283			return 0;
284			}
285
286			void _cdecl
287			endpwent(void)
288			{
289			}
290
291			/* #endif */