Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

dirent.c @ 49
Tweet

Last change on this file since 49 was 49, checked in by Sam Hocevar, 15 years ago
Imported original public domain release, for future reference.
Property svn:keywords set to `Id`
File size: 16.8 KB

Line
1	/****************************************************************************************
2	*
3	* File: dirent.c
4	* Created: 7/3/93 By: George T. Talbot
5	* Purpose: Implements UNIX-like directory reading for the Macintosh.
6	*
7	* Modifications:
8	*
9	* Notes:
10	* 1) These routines will NOT work under A/UX.
11	* 2) WD = working directory
12	* 3) CD = change directory
13	* 4) FS = file system
14	* 5) Mac filesystems allow spaces as part of pathnames!
15	* 6) All routines which return a path use the default Macintosh path separator,
16	* a colon (":").
17	*
18	****************************************************************************************/
19
20	#include "dirent.h"
21	//#include <pascal.h>
22	#include <string.h>
23
24	OSErr dd_errno; /* Global errno to check after calls to dirent routines */
25	char dd_separator = ":"; / If you're feeling brave, change this to "/" */
26	int dd_xform_seps = false;
27
28	/****************************************************************************************
29	*
30	* This function, given a Macintosh-style pathname, will open a directory to that path.
31	* NOTES: 1) passing in nil will get you the current directory.
32	* 2) ".:", "..:" & "Å:" are supported at the beginning of paths ONLY
33	* by this routine.
34	* 3) "/" will be turned into ":" by this routine.
35	*
36	* Calls: PBHGetVol(), PBHGetCatInfo(), PBHSetVol(), hopendir(), CtoPstr()
37	* Called By: <general purpose>
38	* Globals Used: dd_errno
39	* Parameters: pointer to C-string pathname or nil for current directory
40	* Returns: pointer to directory management block or nil & dd_errno will be set
41	*
42	****************************************************************************************/
43
44	DIR opendir(char dirname)
45	{
46	WDPBRec pb;
47	CInfoPBRec cpb;
48	short vRefNum;
49	long dirID;
50	char *dname;
51	DIR *temp;
52	char path_temp[MAXPATHLEN+1]; /* Temporary area for building pathname */
53
54	/* Save the current path */
55	pb.ioCompletion = nil;
56	pb.ioNamePtr = nil;
57
58	if (dd_errno = PBHGetVol(&pb, false))
59	return nil;
60
61	vRefNum = pb.ioWDVRefNum;
62	dirID = pb.ioWDDirID;
63
64	/* dname points to the desired pathname */
65	dname = dirname;
66
67	/* If no pathname was passed in, or there are no ".", ".." or "Å" special directory
68	* names, then handle the pathname as normal.
69	*/
70	if (dirname == nil)
71	goto opendir_fallthrough;
72
73	/* If there's not '.', '..' or 'Å', fall through */
74	if ((dirname[0] != '.') && (dirname[0] != 'Å'))
75	goto opendir_fallthrough;
76
77	/* If there's a 'Å', treat it like '..' */
78	if (dirname[0] == 'Å')
79	{
80	dname = &(dirname[1]);
81	goto path_dotdot;
82	}
83
84	/* If the pathname has "." (current directory) in front of it... */
85	if (dirname[1] != '.')
86	{
87	/* Skip over the "." and fall through */
88	dname = &(dirname[1]);
89	goto opendir_fallthrough;
90	}
91
92	/* Skip over the ".." */
93	dname = &(dirname[2]);
94
95	path_dotdot:
96	/* If we get here, the directory has ".." in front of it... */
97
98	/* First, get the directory info on the current directory. We do this so
99	* that we can get the directory's parent
100	*/
101	cpb.dirInfo.ioCompletion = nil;
102	cpb.dirInfo.ioNamePtr = (unsigned char *)path_temp;
103	/* Unused, but must be set because of
104	* bug in Apple File Sharing.
105	*/
106	cpb.dirInfo.ioVRefNum = vRefNum;
107	cpb.dirInfo.ioFDirIndex = -1;
108	cpb.dirInfo.ioDrDirID = dirID;
109
110	if (dd_errno = PBGetCatInfo(&cpb, false))
111	return nil;
112
113	/* Temporarily CD to the parent directory */
114	pb.ioCompletion = nil;
115	pb.ioNamePtr = nil;
116	pb.ioVRefNum = pb.ioWDVRefNum;
117	pb.ioWDDirID = cpb.dirInfo.ioDrParID;
118
119	if (dd_errno = PBHSetVol(&pb, false))
120	return nil;
121
122	/* This is the common code for all three cases above */
123	opendir_fallthrough:
124	/* If the pathname is too long (this is a Macintosh FS constraint), then return */
125	if (strlen(dname) > MAXPATHLEN)
126	{
127	/* Set the error */
128	dd_errno = bdNamErr;
129	temp = nil;
130
131	/* Go to the common exit, where we CD back to the saved WD */
132	goto opendir_exit;
133	}
134
135	/* If this call was passed a pathname */
136	if (dname != nil)
137	{
138	/* Copy the pathname into a temp */
139	strcpy(path_temp, dname);
140
141	/* Turn it into a Pascal string for the Mac FS */
142	CtoPstr(path_temp);
143
144	/* Change any "/" to ":" for the Mac FS */
145	if (dd_xform_seps)
146	{
147	int i;
148
149	for (i=1; i<= path_temp[0]; ++i)
150	if (path_temp[i] == '/')
151	path_temp[i] = ':';
152	}
153
154	/* Try and open the directory */
155	temp = hopendir(path_temp, 0, 0);
156	}
157	else
158	/* If this call wasn't passed a pathname, then we call hopendir() with nil to
159	* tell it to open the current working directory.
160	*/
161	temp = hopendir(nil, 0, 0);
162
163	/* This is the common exit code which restores the current WD */
164	opendir_exit:
165	pb.ioCompletion = nil;
166	pb.ioNamePtr = nil;
167	pb.ioVRefNum = vRefNum;
168	pb.ioWDDirID = dirID;
169
170	if (dd_errno = PBHSetVol(&pb, false))
171	{
172	/* If this call failed, then get rid of the structures created by hopendir() */
173	closedir(temp);
174	return nil;
175	}
176
177	return temp;
178	}
179
180	/****************************************************************************************
181	*
182	* This function actually opens the directory. If you feel brave, you can call it.
183	* If you pass in a dirname, then set vRefNum and dirID to 0. All named opens are
184	* relative to the current WD. If you pass in vRefNum and dirID, then don't bother
185	* passing in a name. This routine WILL CHANGE YOUR CURRENT WORKING DIRECTORY!
186	*
187	* Calls: NewHandle(), PBHGetCatInfo(), PBHSetVol(), PtoCstr(), BlockMove(),
188	* DisposHandle(), MoveHHi(), HLock(), MemError()
189	* Called By: opendir(), and you if you feel brave.
190	* Globals Used: dd_errno
191	* Parameters: pointer to Pascal-string pathname, vRefNum, dirID of desired
192	* directory. If you pass in a WDRefNum as the vRefNum, set dirID to 0
193	* Returns: pointer to directory management block or nil & dd_errno will be set
194	*
195	****************************************************************************************/
196
197	DIR hopendir(char dirname, short vRefNum, long dirID)
198	{
199	DIR *curh, cur;
200	CInfoPBRec cpb;
201	WDPBRec pb;
202	Str63 name;
203
204	/* Get memory for the directory structure */
205	curh = (DIR **) NewHandle(sizeof(DIR));
206
207	/* Did we get it? */
208	if (curh == nil)
209	{
210	dd_errno = MemError();
211	return nil;
212	}
213
214	/* Move it high and lock it */
215	MoveHHi((Handle)curh);
216	HLock((Handle)curh);
217	cur = *curh;
218
219	/* If we're supposed to open anything but the current directory, set the current
220	* working directory to the desired directory.
221	*/
222	if ((dirname != nil) \|\| (vRefNum != 0) \|\| (dirID != 0))
223	{
224	pb.ioCompletion = nil;
225	pb.ioNamePtr = (unsigned char *)dirname;
226	pb.ioVRefNum = vRefNum;
227	pb.ioWDDirID = dirID;
228
229	if (dd_errno = PBHSetVol(&pb, false))
230	goto failure_exit;
231	}
232
233	cur->dd_buf = nil;
234
235	/* Get info on the desired directory (its name, etc.) */
236	cpb.dirInfo.ioCompletion = nil;
237	cpb.dirInfo.ioNamePtr = name;
238	cpb.dirInfo.ioVRefNum = vRefNum;
239	cpb.dirInfo.ioFDirIndex = -1;
240	cpb.dirInfo.ioDrDirID = dirID;
241
242	if (dd_errno = PBGetCatInfo(&cpb, false))
243	goto failure_exit;
244
245	/* Save the directory info */
246	cur->dir_fsp.vRefNum = vRefNum;
247	cur->dd_fd = cpb.dirInfo.ioDrDirID;
248	cur->dd_parent = cpb.dirInfo.ioDrParID;
249
250	BlockMove(name, cur->dir_fsp.name, sizeof(Str63));
251
252	/* Convert the name to a C-style string */
253	PtoCstr(cur->dir_fsp.name);
254
255	/* Set up our directory structure to read the first entry */
256	cur->dd_off = 1;
257	cur->dd_numents = cpb.dirInfo.ioDrNmFls;
258	cur->dd_cached = false;
259
260	return cur;
261
262	/* This code is branched-to in case of error. It frees up the memory and returns. */
263	failure_exit:
264	DisposHandle((Handle) curh);
265	return nil;
266	}
267
268	/****************************************************************************************
269	*
270	* This function returns the index of the directory entry to be next read.
271	*
272	* Calls: nothing
273	* Called By: <general purpose>
274	* Globals Used: none
275	* Parameters: pointer to the directory management block
276	* Returns: index of the next directory entry to be read.
277	*
278	****************************************************************************************/
279
280	long telldir(DIR *dirp)
281	{
282	if (dirp->dd_off > dirp->dd_numents)
283	return -1;
284	else
285	return dirp->dd_off-1; /* The -1 is because Macs start at 1 & not 0 for dir index,
286	* and this is a little more POSIX.
287	*/
288	}
289
290	/****************************************************************************************
291	*
292	* This function closes the directory opened with opendir() or hopendir()
293	*
294	* Calls: DisposHandle(), RecoverHandle()
295	* Called By: <general purpose>
296	* Globals Used: none
297	* Parameters: pointer to the directory management block
298	* Returns: 0 (always successful)
299	*
300	****************************************************************************************/
301
302	int closedir(DIR *dirp)
303	{
304	struct dirent **cur;
305
306	/* Dispose of any directory entries read in. */
307	cur = dirp->dd_buf;
308
309	dd_errno = noErr;
310
311	while (cur)
312	{
313	struct dirent **next;
314
315	next = (*cur)->next;
316
317	DisposHandle((Handle) cur);
318
319	if (dd_errno == noErr)
320	dd_errno = MemError();
321
322	cur = next;
323	}
324
325	/* Dispose of the directory managment block */
326	DisposHandle(RecoverHandle((Ptr) dirp));
327
328	if (dd_errno == noErr)
329	dd_errno = MemError();
330
331	return dd_errno?-1:0;
332	}
333
334	/****************************************************************************************
335	*
336	* This function sets the index of the next-read directory entry. It will also search
337	* the list of read entries so that an entry won't be read from disk more than once.
338	*
339	* Calls: nothing
340	* Called By: <general purpose>
341	* Globals Used: none
342	* Parameters: pointer to the directory management block, index of directory
343	* Returns: nothing
344	*
345	****************************************************************************************/
346
347	void seekdir(DIR *dirp, long loc)
348	{
349	struct dirent **cur;
350
351	dirp->dd_off = loc+1; /* The +1 is because the Mac indexes directories
352	* from 1 and not 0 and we want to be a little bit
353	* POSIX
354	*/
355
356	/* Search through the entries that we've read already */
357	cur = dirp->dd_buf;
358
359	while (cur)
360	{
361	/* If we find the entry that we've seeked to, set up so that readdir() will
362	* return this one instead of reading a new one.
363	*/
364	if (loc == (*cur)->d_off)
365	{
366	dirp->dd_cached = true;
367	dirp->dd_cache_hint = cur;
368
369	return;
370	}
371
372	cur = (*cur)->next;
373	}
374
375	/* If we didn't find it, then tell readdir() to get the entry from the FS */
376	dirp->dd_cached = false;
377	}
378
379	/****************************************************************************************
380	*
381	* This function will read the next directory entry from disk. It will return nil and
382	* set dd_errno to noErr when the end of the directory is reached. It will avoid
383	* reading directory entries from disk more than once.
384	*
385	* Calls: nothing
386	* Called By: <general purpose>
387	* Globals Used: none
388	* Parameters: pointer to the directory management block
389	* Returns: pointer to directory entry or nil if an error occurred and dd_errno
390	* will be set. If the last entry has already been read, this will
391	* return nil and dd_errno will be set to noErr.
392	*
393	****************************************************************************************/
394
395	struct dirent readdir(DIR dirp)
396	{
397	CInfoPBRec cpb;
398	struct dirent *meh, me;
399
400	/* If the entry has been read already, then return the already present entry */
401	if (dirp->dd_cached)
402	me = *(dirp->dd_cache_hint);
403	else
404	/* Otherwise, read it from disk... */
405	{
406	/* Past the end of the directory? */
407	if (dirp->dd_off > dirp->dd_numents)
408	{
409	dd_errno = noErr;
410	return nil;
411	}
412
413	/* Allocate space for a new entry */
414	meh = (struct dirent **) NewHandle(sizeof(struct dirent));
415
416	/* Enough memory? */
417	if (meh == nil)
418	{
419	dd_errno = MemError();
420	return nil;
421	}
422
423	/* Lock the entry */
424	MoveHHi((Handle) meh);
425	HLock((Handle) meh);
426
427	me = *meh;
428
429	/* Get the entry's info from disk */
430	me->fsp.name[0] = 0;
431
432	cpb.dirInfo.ioCompletion = nil;
433	cpb.dirInfo.ioNamePtr = me->fsp.name;
434	cpb.dirInfo.ioVRefNum = dirp->dir_fsp.vRefNum;
435	cpb.dirInfo.ioFDirIndex = dirp->dd_off;
436	cpb.dirInfo.ioDrDirID = dirp->dd_fd;
437
438	if (dd_errno = PBGetCatInfo(&cpb, false))
439	{
440	DisposHandle((Handle) meh);
441	return nil;
442	}
443
444	/* Set up the dirent structure */
445	me->d_off = dirp->dd_off-1;
446	me->fsp.vRefNum = cpb.dirInfo.ioVRefNum;
447	me->d_fileno = cpb.dirInfo.ioDrDirID;
448	me->d_parent = cpb.dirInfo.ioDrParID;
449
450	/* C strings only! */
451	PtoCstr(me->fsp.name);
452
453	/* Add it to the list for this directory */
454	me->next = dirp->dd_buf;
455
456	dirp->dd_buf = meh;
457	}
458
459	/* Seek to the next entry */
460	seekdir(dirp, dirp->dd_off);
461
462	/* Return what we've found */
463	return me;
464	}
465
466	/****************************************************************************************
467	*
468	* This function will give an absolute pathname to a given directory.
469	*
470	* Calls: NewPtr(), DisposPtr(), PBGetCatInfo()
471	* Called By: <general purpose>
472	* Globals Used: none
473	* Parameters: vRefNum and startDirID of desired path, pointer to path name storage,
474	* length of path name storage, pointer to C-string separator.
475	* Returns: bdNamErr if the path would overflow the storage,
476	* some other error code if something else happened,
477	* or noErr on success.
478	*
479	****************************************************************************************/
480
481	OSErr hgetwd(short vRefNum, long startDirID, char path, int max_path_len, char sep)
482	{
483	long curDirID;
484	OSErr err;
485	CInfoPBRec pb;
486	Str63 name;
487	char *temp_path;
488
489	/* Start with an empty path */
490	path[0] = 0;
491
492	/* Get memory for a temporary path */
493	temp_path = (char *) NewPtr(max_path_len);
494
495	if (temp_path == nil)
496	return MemError();
497
498	/* Start at the given directory */
499	curDirID = startDirID;
500
501	do {
502	/* Get cat info for the current directory */
503	name[0] = 0;
504
505	pb.dirInfo.ioCompletion = nil;
506	pb.dirInfo.ioNamePtr = name;
507	pb.dirInfo.ioVRefNum = vRefNum;
508	pb.dirInfo.ioFDirIndex = -1;
509	pb.dirInfo.ioDrDirID = curDirID;
510
511	if (err = PBGetCatInfo(&pb, false))
512	{
513	DisposPtr((Ptr) temp_path);
514	return err;
515	}
516
517	/* Convert name to a C string */
518	PtoCstr(name);
519
520	/* Check that we don't overflow storage */
521	if ((strlen((char*)name) + strlen(path) + strlen(sep)) >= max_path_len)
522	{
523	DisposPtr((Ptr) temp_path);
524	return bdNamErr;
525	}
526
527	/* Prepend the name and separator */
528	strcpy(temp_path, path);
529	strcpy(path, (char*)name);
530	strcat(path, sep);
531	strcat(path, temp_path);
532
533	/* Move "up" one directory */
534	curDirID = pb.dirInfo.ioDrParID;
535	}
536	/* Until we hit the root directory */
537	while (pb.dirInfo.ioDrDirID != fsRtDirID);
538
539	/* Get rid of our temp storage and return */
540	DisposPtr((Ptr) temp_path);
541
542	return MemError();
543	}
544
545	/****************************************************************************************
546	*
547	* This function will change the current working directory.
548	*
549	* Calls: opendir(), closedir(), PBHSetVol()
550	* Called By: <general purpose>
551	* Globals Used: none
552	* Parameters: C-string pathname.
553	* Returns: -1 on failure, 0 on success. Sets dd_errno on failure.
554	*
555	****************************************************************************************/
556
557	int chdir(char *path)
558	{
559	DIR *d;
560	short vRefNum;
561	long dirID;
562	WDPBRec pb;
563
564	/* Open the directory */
565	d = opendir(path);
566
567	if (d == nil)
568	return -1;
569
570	/* Get the Mac FS identification for this directory */
571	vRefNum = d->dd_volume;
572	dirID = d->dd_fd;
573
574	/* Close the directory */
575	closedir(d);
576
577	/* CD to the new directory */
578	pb.ioCompletion = nil;
579	pb.ioNamePtr = nil;
580	pb.ioVRefNum = vRefNum;
581	pb.ioWDDirID = dirID;
582
583	dd_errno = PBHSetVol(&pb, false);
584
585	return dd_errno?-1:0;
586	}
587
588	/****************************************************************************************
589	*
590	* This function will get the current working directory's path.
591	*
592	* Calls: PBHGetVol(), hgetwd()
593	* Called By: <general purpose>
594	* Globals Used: none
595	* Parameters: pointer to a buffer of MAXPATHLEN bytes.
596	* Returns: pointer to the buffer on success, on failure, nil and dd_errno will
597	* be set.
598	*
599	****************************************************************************************/
600
601	char getwd(char path)
602	{
603	WDPBRec pb;
604
605	/* Get the current working directory */
606	pb.ioCompletion = nil;
607	pb.ioNamePtr = nil;
608
609	if (dd_errno = PBHGetVol(&pb, false))
610	return nil;
611
612	/* Transform it into a path */
613	if (dd_errno = hgetwd(pb.ioWDVRefNum, pb.ioWDDirID, path, MAXPATHLEN-1, dd_separator))
614	return nil;
615
616	return path;
617	}
618
619	/****************************************************************************************
620	*
621	* This function will get the path to a given (already opened) directory.
622	*
623	* Calls: hgetwd()
624	* Called By: <general purpose>
625	* Globals Used: none
626	* Parameters: pointer to a buffer of MAXPATHLEN bytes.
627	* Returns: pointer to the buffer on success, on failure, nil and dd_errno will
628	* be set.
629	*
630	****************************************************************************************/
631
632	char pathdir(DIR dirp, char *path)
633	{
634	if (dd_errno = hgetwd(dirp->dd_volume, dirp->dd_fd, path, MAXPATHLEN-1, dd_separator))
635	return nil;
636
637	return path;
638	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: abuse/tags/pd/macabuse/imlib/port/mac/dirent.c @ 49 Tweet

Download in other formats:

source: abuse/tags/pd/macabuse/imlib/port/mac/dirent.c @ 49
Tweet