![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dirwrap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Synchronet] / sbbs / src / xpdev|
Return to dirwrap.c CVS log | Up to [Synchronet] / sbbs / src / xpdev |
1.1 root 1: /* dirwrap.c */
2:
3: /* Directory-related system-call wrappers */
4:
5: /* $Id: dirwrap.c,v 1.70 2006/08/24 00:20:48 deuce Exp $ */
6:
7: /****************************************************************************
8: * @format.tab-size 4 (Plain Text/Source Code File Header) *
9: * @format.use-tabs true (see http://www.synchro.net/ptsc_hdr.html) *
10: * *
11: * Copyright 2006 Rob Swindell - http://www.synchro.net/copyright.html *
12: * *
13: * This library is free software; you can redistribute it and/or *
14: * modify it under the terms of the GNU Lesser General Public License *
15: * as published by the Free Software Foundation; either version 2 *
16: * of the License, or (at your option) any later version. *
17: * See the GNU Lesser General Public License for more details: lgpl.txt or *
18: * http://www.fsf.org/copyleft/lesser.html *
19: * *
20: * Anonymous FTP access to the most recent released source is available at *
21: * ftp://vert.synchro.net, ftp://cvs.synchro.net and ftp://ftp.synchro.net *
22: * *
23: * Anonymous CVS access to the development source and modification history *
24: * is available at cvs.synchro.net:/cvsroot/sbbs, example: *
25: * cvs -d :pserver:[email protected]:/cvsroot/sbbs login *
26: * (just hit return, no password is necessary) *
27: * cvs -d :pserver:[email protected]:/cvsroot/sbbs checkout src *
28: * *
29: * For Synchronet coding style and modification guidelines, see *
30: * http://www.synchro.net/source.html *
31: * *
32: * You are encouraged to submit any modifications (preferably in Unix diff *
33: * format) via e-mail to [email protected] *
34: * *
35: * Note: If this box doesn't appear square, then you need to fix your tabs. *
36: ****************************************************************************/
37:
38: #include <string.h> /* strrchr */
39:
40: #if defined(_WIN32)
41:
42: #include <windows.h> /* WINAPI, etc */
43: #include <io.h> /* _findfirst */
44:
45: #elif defined __unix__
46:
47: #include <unistd.h> /* usleep */
48: #include <fcntl.h> /* O_NOCCTY */
49: #include <ctype.h> /* toupper */
50: #include <sys/param.h>
51:
52: #if defined(BSD)
53: #include <sys/mount.h>
54: #endif
55: #if defined(__FreeBSD__)
56: #include <sys/kbio.h>
57: #endif
58: #if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 300000000 /* NetBSD 3.0 */)
59: #include <sys/statvfs.h>
60: #endif
61:
62: #include <sys/ioctl.h> /* ioctl */
63:
64: #if defined(__GLIBC__) /* actually, BSD, but will work for now */
65: #include <sys/vfs.h> /* statfs() */
66: #endif
67:
68: #if defined(__solaris__)
69: #include <sys/statvfs.h>
70: #endif
71:
72: #endif /* __unix__ */
73:
74: #if defined(__WATCOMC__)
75: #include <dos.h>
76: #endif
77:
78: #include <sys/types.h> /* _dev_t */
79: #include <sys/stat.h> /* struct stat */
80:
81: #include <stdio.h> /* sprintf */
82: #include <stdlib.h> /* rand */
83: #include <errno.h> /* ENOENT definitions */
84:
85: #include "genwrap.h" /* strupr/strlwr */
86: #include "dirwrap.h" /* DLLCALL */
87:
88: /****************************************************************************/
89: /* Return the filename portion of a full pathname */
90: /****************************************************************************/
91: char* DLLCALL getfname(const char* path)
92: {
93: const char* fname;
94: const char* bslash;
95:
96: fname=strrchr(path,'/');
97: bslash=strrchr(path,'\\');
98: if(bslash>fname)
99: fname=bslash;
100: if(fname!=NULL)
101: fname++;
102: else
103: fname=(char*)path;
104: return((char*)fname);
105: }
106:
107: /****************************************************************************/
108: /* Return a pointer to a file's extesion (beginning with '.') */
109: /****************************************************************************/
110: char* DLLCALL getfext(const char* path)
111: {
112: char *fname;
113: char *fext;
114:
115: fname=getfname(path);
116: fext=strrchr(fname,'.');
117: if(fext==NULL || fext==fname)
118: return(NULL);
119: return(fext);
120: }
121:
122: /****************************************************************************/
123: /* Break a path name into components. */
124: /****************************************************************************/
125: #if defined(__unix__)
126: void DLLCALL _splitpath(const char *path, char *drive, char *dir, char *fname, char *ext)
127: {
128: char* p;
129:
130: ext[0]=0;
131: drive[0]=0; /* no drive letters on Unix */
132:
133: strcpy(dir,path); /* Optional directory path, including trailing slash. */
134: p=getfname(dir);
135: strcpy(fname,p); /* Base filename (no extension) */
136: if(p==dir)
137: dir[0]=0; /* no directory specified in path */
138: else
139: *p=0; /* truncate dir at filename */
140: p=getfext(fname);
141: if(p!=NULL) {
142: strcpy(ext,p); /* Optional filename extension, including leading period (.) */
143: *p=0;
144: }
145: }
146: #endif
147:
148: /****************************************************************************/
149: /* Win32 (minimal) implementation of POSIX.2 glob() function */
150: /* This code _may_ work on other DOS-based platforms (e.g. OS/2) */
151: /****************************************************************************/
152: #if !defined(__unix__)
153: static int _cdecl glob_compare( const void *arg1, const void *arg2 )
154: {
155: /* Compare all of both strings: */
156: return stricmp( * ( char** ) arg1, * ( char** ) arg2 );
157: }
158:
159: #if defined(__BORLANDC__)
160: #pragma argsused
161: #endif
162:
163: #if defined(__WATCOMC__)
164:
165: int DLLCALL glob(const char *pattern, int flags, void* unused, glob_t* glob)
166: {
167: struct find_t ff;
168: size_t found=0;
169: char path[MAX_PATH+1];
170: char* p;
171: char** new_pathv;
172:
173: if(!(flags&GLOB_APPEND)) {
174: glob->gl_pathc=0;
175: glob->gl_pathv=NULL;
176: }
177:
178: if(_dos_findfirst((char*)pattern,_A_NORMAL,&ff)!=0)
179: return(GLOB_NOMATCH);
180:
181: do {
182: if((flags&GLOB_PERIOD || ff.name[0]!='.') &&
183: (!(flags&GLOB_ONLYDIR) || ff.attrib&_A_SUBDIR)) {
184: if((new_pathv=realloc(glob->gl_pathv
185: ,(glob->gl_pathc+1)*sizeof(char*)))==NULL) {
186: globfree(glob);
187: return(GLOB_NOSPACE);
188: }
189: glob->gl_pathv=new_pathv;
190:
191: /* build the full pathname */
192: SAFECOPY(path,pattern);
193: p=getfname(path);
194: *p=0;
195: strcat(path,ff.name);
196:
197: if((glob->gl_pathv[glob->gl_pathc]=malloc(strlen(path)+2))==NULL) {
198: globfree(glob);
199: return(GLOB_NOSPACE);
200: }
201: strcpy(glob->gl_pathv[glob->gl_pathc],path);
202: if(flags&GLOB_MARK && ff.attrib&_A_SUBDIR)
203: strcat(glob->gl_pathv[glob->gl_pathc],"/");
204:
205: glob->gl_pathc++;
206: found++;
207: }
208: } while(_dos_findnext(&ff)==0);
209: _dos_findclose(&ff);
210:
211: if(found==0)
212: return(GLOB_NOMATCH);
213:
214: if(!(flags&GLOB_NOSORT)) {
215: qsort(glob->gl_pathv,found,sizeof(char*),glob_compare);
216: }
217:
218: return(0); /* success */
219: }
220:
221: #else
222:
223: int DLLCALL glob(const char *pattern, int flags, void* unused, glob_t* glob)
224: {
225: struct _finddata_t ff;
226: long ff_handle;
227: size_t found=0;
228: char path[MAX_PATH+1];
229: char* p;
230: char** new_pathv;
231:
232: if(!(flags&GLOB_APPEND)) {
233: glob->gl_pathc=0;
234: glob->gl_pathv=NULL;
235: }
236:
237: ff_handle=_findfirst((char*)pattern,&ff);
238: while(ff_handle!=-1) {
239: if((flags&GLOB_PERIOD || ff.name[0]!='.') &&
240: (!(flags&GLOB_ONLYDIR) || ff.attrib&_A_SUBDIR)) {
241: if((new_pathv=(char**)realloc(glob->gl_pathv
242: ,(glob->gl_pathc+1)*sizeof(char*)))==NULL) {
243: globfree(glob);
244: return(GLOB_NOSPACE);
245: }
246: glob->gl_pathv=new_pathv;
247:
248: /* build the full pathname */
249: SAFECOPY(path,pattern);
250: p=getfname(path);
251: *p=0;
252: strcat(path,ff.name);
253:
254: if((glob->gl_pathv[glob->gl_pathc]=(char*)malloc(strlen(path)+2))==NULL) {
255: globfree(glob);
256: return(GLOB_NOSPACE);
257: }
258: strcpy(glob->gl_pathv[glob->gl_pathc],path);
259: if(flags&GLOB_MARK && ff.attrib&_A_SUBDIR)
260: strcat(glob->gl_pathv[glob->gl_pathc],"/");
261:
262: glob->gl_pathc++;
263: found++;
264: }
265: if(_findnext(ff_handle, &ff)!=0) {
266: _findclose(ff_handle);
267: ff_handle=-1;
268: }
269: }
270:
271: if(found==0)
272: return(GLOB_NOMATCH);
273:
274: if(!(flags&GLOB_NOSORT)) {
275: qsort(glob->gl_pathv,found,sizeof(char*),glob_compare);
276: }
277:
278: return(0); /* success */
279: }
280:
281: #endif
282:
283: void DLLCALL globfree(glob_t* glob)
284: {
285: size_t i;
286:
287: if(glob==NULL)
288: return;
289:
290: if(glob->gl_pathv!=NULL) {
291: for(i=0;i<glob->gl_pathc;i++)
292: if(glob->gl_pathv[i]!=NULL)
293: free(glob->gl_pathv[i]);
294:
295: free(glob->gl_pathv);
296: glob->gl_pathv=NULL;
297: }
298: glob->gl_pathc=0;
299: }
300:
301: #endif /* !defined(__unix__) */
302:
303: /****************************************************************************/
304: /* POSIX directory operations using Microsoft _findfirst/next API. */
305: /****************************************************************************/
306: #if defined(_MSC_VER) || defined(__DMC__)
307: DIR* opendir(const char* dirname)
308: {
309: DIR* dir;
310:
311: if((dir=(DIR*)calloc(1,sizeof(DIR)))==NULL) {
312: errno=ENOMEM;
313: return(NULL);
314: }
315: sprintf(dir->filespec,"%.*s",sizeof(dir->filespec)-5,dirname);
316: if(*dir->filespec && dir->filespec[strlen(dir->filespec)-1]!='\\')
317: strcat(dir->filespec,"\\");
318: strcat(dir->filespec,"*.*");
319: dir->handle=_findfirst(dir->filespec,&dir->finddata);
320: if(dir->handle==-1) {
321: errno=ENOENT;
322: free(dir);
323: return(NULL);
324: }
325: return(dir);
326: }
327: struct dirent* readdir(DIR* dir)
328: {
329: if(dir==NULL)
330: return(NULL);
331: if(dir->end==TRUE)
332: return(NULL);
333: if(dir->handle==-1)
334: return(NULL);
335: sprintf(dir->dirent.d_name,"%.*s",sizeof(struct dirent)-1,dir->finddata.name);
336: if(_findnext(dir->handle,&dir->finddata)!=0)
337: dir->end=TRUE;
338: return(&dir->dirent);
339: }
340: int closedir (DIR* dir)
341: {
342: if(dir==NULL)
343: return(-1);
344: _findclose(dir->handle);
345: free(dir);
346: return(0);
347: }
348: void rewinddir(DIR* dir)
349: {
350: if(dir==NULL)
351: return;
352: _findclose(dir->handle);
353: dir->end=FALSE;
354: dir->handle=_findfirst(dir->filespec,&dir->finddata);
355: }
356: #endif /* defined(_MSC_VER) */
357:
358: /****************************************************************************/
359: /* Returns the time/date of the file in 'filename' in time_t (unix) format */
360: /****************************************************************************/
361: time_t DLLCALL fdate(const char* filename)
362: {
363: struct stat st;
364:
365: if(access(filename,0)==-1)
366: return(-1);
367:
368: if(stat(filename, &st)!=0)
369: return(-1);
370:
371: return(st.st_mtime);
372: }
373:
374: /****************************************************************************/
375: /* Change the access and modification times for specified filename */
376: /****************************************************************************/
377: int DLLCALL setfdate(const char* filename, time_t t)
378: {
379: struct utimbuf ut;
380:
381: memset(&ut,0,sizeof(ut));
382:
383: ut.actime=t;
384: ut.modtime=t;
385:
386: return(utime(filename,&ut));
387: }
388:
389: /****************************************************************************/
390: /* Returns the length of the file in 'filename' */
391: /****************************************************************************/
392: long DLLCALL flength(const char *filename)
393: {
394: #if defined(__BORLANDC__) && !defined(__unix__) /* stat() doesn't work right */
395:
396: long handle;
397: struct _finddata_t f;
398:
399: if(access((char*)filename,0)==-1)
400: return(-1L);
401:
402: if((handle=_findfirst((char*)filename,&f))==-1)
403: return(-1);
404:
405: _findclose(handle);
406:
407: return(f.size);
408:
409: #else
410:
411: struct stat st;
412:
413: if(access(filename,0)==-1)
414: return(-1L);
415:
416: if(stat(filename, &st)!=0)
417: return(-1L);
418:
419: return(st.st_size);
420:
421: #endif
422: }
423:
424:
425: /****************************************************************************/
426: /* Checks the file system for the existence of one or more files. */
427: /* Returns TRUE if it exists, FALSE if it doesn't. */
428: /* 'filespec' may *NOT* contain wildcards! */
429: /****************************************************************************/
430: static BOOL fnameexist(const char *filename)
431: {
432: if(access(filename,0)==-1)
433: return(FALSE);
434: if(!isdir(filename))
435: return(TRUE);
436: return(FALSE);
437: }
438:
439: /****************************************************************************/
440: /* Checks the file system for the existence of one or more files. */
441: /* Returns TRUE if it exists, FALSE if it doesn't. */
442: /* 'filespec' may contain wildcards! */
443: /****************************************************************************/
444: BOOL DLLCALL fexist(const char *filespec)
445: {
446: #if defined(_WIN32)
447:
448: long handle;
449: struct _finddata_t f;
450:
451: if(!strchr(filespec,'*') && !strchr(filespec,'?'))
452: return(fnameexist(filespec));
453:
454: if((handle=_findfirst((char*)filespec,&f))==-1)
455: return(FALSE);
456:
457: _findclose(handle);
458:
459: if(f.attrib&_A_SUBDIR)
460: return(FALSE);
461:
462: return(TRUE);
463:
464: #else /* Unix or OS/2 */
465:
466: /* portion by cmartin */
467:
468: glob_t g;
469: int c;
470:
471: if(!strchr(filespec,'*') && !strchr(filespec,'?'))
472: return(fnameexist(filespec));
473:
474: /* start the search */
475: glob(filespec, GLOB_MARK | GLOB_NOSORT, NULL, &g);
476:
477: if (!g.gl_pathc) {
478: /* no results */
479: globfree(&g);
480: return FALSE;
481: }
482:
483: /* make sure it's not a directory */
484: c = g.gl_pathc;
485: while (c--) {
486: if (*lastchar(g.gl_pathv[c]) != '/') {
487: globfree(&g);
488: return TRUE;
489: }
490: }
491:
492: globfree(&g);
493: return FALSE;
494:
495: #endif
496: }
497:
498: /****************************************************************************/
499: /* Fixes upper/lowercase filename for Unix file systems */
500: /****************************************************************************/
501: BOOL DLLCALL fexistcase(char *path)
502: {
503: #if defined(_WIN32)
504:
505: char* fname;
506: long handle;
507: struct _finddata_t f;
508:
509: if(access(path,0)==-1 && !strchr(path,'*') && !strchr(path,'?'))
510: return(FALSE);
511:
512: if((handle=_findfirst((char*)path,&f))==-1)
513: return(FALSE);
514:
515: _findclose(handle);
516:
517: if(f.attrib&_A_SUBDIR)
518: return(FALSE);
519:
520: fname=getfname(path); /* Find filename in path */
521: strcpy(fname,f.name); /* Correct filename */
522:
523: return(TRUE);
524:
525: #else /* Unix or OS/2 */
526:
527: char globme[MAX_PATH*4+1];
528: char fname[MAX_PATH+1];
529: char tmp[5];
530: char *p;
531: int i;
532: glob_t glb;
533:
534: if(!strchr(path,'*') && !strchr(path,'?') && fnameexist(path))
535: return(TRUE);
536:
537: SAFECOPY(globme,path);
538: p=getfname(globme);
539: SAFECOPY(fname,p);
540: *p=0;
541: for(i=0;fname[i];i++) {
542: if(isalpha(fname[i]))
543: sprintf(tmp,"[%c%c]",toupper(fname[i]),tolower(fname[i]));
544: else
545: sprintf(tmp,"%c",fname[i]);
546: strncat(globme,tmp,MAX_PATH*4);
547: }
548: #if 0
549: if(strcspn(path,"?*")!=strlen(path)) {
550: sprintf(path,"%.*s",MAX_PATH,globme);
551: return(fexist(path));
552: }
553: #endif
554:
555: if(glob(globme,GLOB_MARK,NULL,&glb) != 0)
556: return(FALSE);
557:
558: if(glb.gl_pathc>0) {
559: for(i=0;i<glb.gl_pathc;i++) {
560: if(*lastchar(glb.gl_pathv[i]) != '/')
561: break;
562: }
563: if(i<glb.gl_pathc) {
564: sprintf(path,"%.*s",MAX_PATH,glb.gl_pathv[i]);
565: globfree(&glb);
566: return TRUE;
567: }
568: }
569:
570: globfree(&glb);
571: return FALSE;
572:
573: #endif
574: }
575:
576: #if !defined(S_ISDIR)
577: #define S_ISDIR(x) ((x)&S_IFDIR)
578: #endif
579:
580: /****************************************************************************/
581: /* Returns TRUE if the filename specified is a directory */
582: /****************************************************************************/
583: BOOL DLLCALL isdir(const char *filename)
584: {
585: char path[MAX_PATH+1];
586: char* p;
587: struct stat st;
588:
589: SAFECOPY(path,filename);
590:
591: p=lastchar(path);
592: if(p!=path && IS_PATH_DELIM(*p)) { /* chop off trailing slash */
593: #if !defined(__unix__)
594: if(*(p-1)!=':') /* Don't change C:\ to C: */
595: #endif
596: *p=0;
597: }
598:
599: #if defined(__BORLANDC__) && !defined(__unix__) /* stat() doesn't work right */
600: if(stat(path, &st)!=0 || strchr(path,'*')!=NULL || strchr(path,'?')!=NULL)
601: #else
602: if(stat(path, &st)!=0)
603: #endif
604: return(FALSE);
605:
606: return(S_ISDIR(st.st_mode) ? TRUE : FALSE);
607: }
608:
609: /****************************************************************************/
610: /* Returns the attributes (mode) for specified 'filename' */
611: /****************************************************************************/
612: int DLLCALL getfattr(const char* filename)
613: {
614: #if defined(_WIN32)
615: long handle;
616: struct _finddata_t finddata;
617:
618: if((handle=_findfirst((char*)filename,&finddata))==-1) {
619: errno=ENOENT;
620: return(-1);
621: }
622: _findclose(handle);
623: return(finddata.attrib);
624: #else
625: struct stat st;
626:
627: if(stat(filename, &st)!=0) {
628: errno=ENOENT;
629: return(-1L);
630: }
631:
632: return(st.st_mode);
633: #endif
634: }
635:
636: #ifdef __unix__
637: int removecase(char *path)
638: {
639: char inpath[MAX_PATH+1];
640: char fname[MAX_PATH*4+1];
641: char tmp[5];
642: char *p;
643: int i;
644:
645: if(strchr(path,'?') || strchr(path,'*'))
646: return(-1);
647: SAFECOPY(inpath,path);
648: p=getfname(inpath);
649: fname[0]=0;
650: for(i=0;p[i];i++) {
651: if(isalpha(p[i]))
652: sprintf(tmp,"[%c%c]",toupper(p[i]),tolower(p[i]));
653: else
654: sprintf(tmp,"%c",p[i]);
655: strncat(fname,tmp,MAX_PATH*4);
656: }
657: *p=0;
658:
659: return(delfiles(inpath,fname)?-1:0);
660: }
661: #endif
662:
663: /****************************************************************************/
664: /* Deletes all files in dir 'path' that match file spec 'spec' */
665: /****************************************************************************/
666: ulong DLLCALL delfiles(char *inpath, char *spec)
667: {
668: char path[MAX_PATH+1];
669: char lastch;
670: uint i,files=0;
671: glob_t g;
672:
673: lastch=*lastchar(inpath);
674: if(!IS_PATH_DELIM(lastch) && lastch)
675: sprintf(path,"%s%c",inpath,PATH_DELIM);
676: else
677: strcpy(path,inpath);
678: strcat(path,spec);
679: glob(path,0,NULL,&g);
680: for(i=0;i<g.gl_pathc;i++) {
681: if(isdir(g.gl_pathv[i]))
682: continue;
683: CHMOD(g.gl_pathv[i],S_IWRITE); /* Incase it's been marked RDONLY */
684: if(remove(g.gl_pathv[i])==0)
685: files++;
686: }
687: globfree(&g);
688: return(files);
689: }
690:
691: /****************************************************************************/
692: /* Return free disk space in bytes (up to a maximum of 4GB) */
693: /****************************************************************************/
694: #if defined(_WIN32)
695: typedef BOOL(WINAPI * GetDiskFreeSpaceEx_t)
696: (LPCTSTR,PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
697:
698: static int bit_num(ulong val)
699: {
700: int i;
701:
702: for(i=31;i>=0;i--)
703: if(val&(1<<i))
704: return(i);
705:
706: return(-1);
707: }
708: #endif
709:
710: /* Unit should be a power-of-2 (e.g. 1024 to report kilobytes) or 1 (to report bytes) */
711: static ulong getdiskspace(const char* path, ulong unit, BOOL freespace)
712: {
713: #if defined(_WIN32)
714: char root[16];
715: DWORD TotalNumberOfClusters;
716: DWORD NumberOfFreeClusters;
717: DWORD BytesPerSector;
718: DWORD SectorsPerCluster;
719: ULARGE_INTEGER avail;
720: ULARGE_INTEGER size;
721: static HINSTANCE hK32;
722: GetDiskFreeSpaceEx_t GetDiskFreeSpaceEx;
723:
724: if(hK32 == NULL)
725: hK32 = LoadLibrary("KERNEL32");
726: GetDiskFreeSpaceEx
727: = (GetDiskFreeSpaceEx_t)GetProcAddress(hK32,"GetDiskFreeSpaceExA");
728:
729: if (GetDiskFreeSpaceEx!=NULL) { /* Windows 95-OSR2 or later */
730: if(!GetDiskFreeSpaceEx(
731: path, /* pointer to the directory name */
732: &avail, /* receives the number of bytes on disk avail to the caller */
733: &size, /* receives the number of bytes on disk */
734: NULL)) /* receives the free bytes on disk */
735: return(0);
736:
737: if(freespace)
738: size=avail;
739:
740: if(unit>1)
741: size.QuadPart=Int64ShrlMod32(size.QuadPart,bit_num(unit));
742:
743: #if defined(_ANONYMOUS_STRUCT)
744: if(size.HighPart)
745: #else
746: if(size.u.HighPart)
747: #endif
748: return(0xffffffff); /* 4GB max */
749:
750: #if defined(_ANONYMOUS_STRUCT)
751: return(size.LowPart);
752: #else
753: return(size.u.LowPart);
754: #endif
755: }
756:
757: /* Windows 95 (old way), limited to 2GB */
758: sprintf(root,"%.3s",path);
759: if(!GetDiskFreeSpace(
760: root, /* pointer to root path */
761: &SectorsPerCluster, /* pointer to sectors per cluster */
762: &BytesPerSector, /* pointer to bytes per sector */
763: &NumberOfFreeClusters, /* pointer to number of free clusters */
764: &TotalNumberOfClusters /* pointer to total number of clusters */
765: ))
766: return(0);
767:
768: if(freespace)
769: TotalNumberOfClusters = NumberOfFreeClusters;
770: if(unit>1)
771: TotalNumberOfClusters/=unit;
772: return(TotalNumberOfClusters*SectorsPerCluster*BytesPerSector);
773:
774:
775: #elif defined(__solaris__) || (defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 300000000 /* NetBSD 3.0 */))
776:
777: struct statvfs fs;
778: unsigned long blocks;
779:
780: if (statvfs(path, &fs) < 0)
781: return 0;
782:
783: if(freespace)
784: blocks=fs.f_bavail;
785: else
786: blocks=fs.f_blocks;
787:
788: if(unit>1)
789: blocks/=unit;
790: return fs.f_bsize * blocks;
791:
792: /* statfs is also used under FreeBSD (Though it *supports* statvfs() now too) */
793: #elif defined(__GLIBC__) || defined(BSD)
794:
795: struct statfs fs;
796: unsigned long blocks;
797:
798: if (statfs(path, &fs) < 0)
799: return 0;
800:
801: if(freespace)
802: blocks=fs.f_bavail;
803: else
804: blocks=fs.f_blocks;
805:
806: if(unit>1)
807: blocks/=unit;
808: return fs.f_bsize * blocks;
809:
810: #else
811:
812: fprintf(stderr,"\n*** !Missing getfreediskspace implementation ***\n");
813: return(0);
814:
815: #endif
816: }
817:
818: ulong DLLCALL getfreediskspace(const char* path, ulong unit)
819: {
820: return getdiskspace(path, unit, /* freespace? */TRUE);
821: }
822:
823: ulong DLLCALL getdisksize(const char* path, ulong unit)
824: {
825: return getdiskspace(path, unit, /* freespace? */FALSE);
826: }
827:
828: /****************************************************************************/
829: /* Resolves //, /./, and /../ in a path. Should work indetically to Windows */
830: /****************************************************************************/
831: #if defined(__unix__)
832: char * DLLCALL _fullpath(char *target, const char *path, size_t size) {
833: char *out;
834: char *p;
835:
836: if(target==NULL) {
837: if((target=malloc(MAX_PATH+1))==NULL) {
838: return(NULL);
839: }
840: }
841: out=target;
842: *out=0;
843:
844: if(*path != '/') {
845: if(*path == '~') {
846: p=getenv("HOME");
847: if(p==NULL || strlen(p)+strlen(path)>=size)
848: return(NULL);
849: strcpy(target,p);
850: out=strrchr(target,'\0');
851: path++;
852: }
853: else {
854: p=getcwd(NULL,size);
855: if(p==NULL || strlen(p)+strlen(path)>=size)
856: return(NULL);
857: strcpy(target,p);
858: free(p);
859: out=strrchr(target,'\0');
860: *(out++)='/';
861: *out=0;
862: out--;
863: }
864: }
865: strncat(target,path,size-1);
866:
867: /* if(stat(target,&sb))
868: return(NULL);
869: if(sb.st_mode&S_IFDIR)
870: strcat(target,"/"); */
871:
872: for(;*out;out++) {
873: while(*out=='/') {
874: if(*(out+1)=='/')
875: memmove(out,out+1,strlen(out));
876: else if(*(out+1)=='.' && (*(out+2)=='/' || *(out+2)==0))
877: memmove(out,out+2,strlen(out)-1);
878: else if(*(out+1)=='.' && *(out+2)=='.' && (*(out+3)=='/' || *(out+3)==0)) {
879: *out=0;
880: p=strrchr(target,'/');
881: if(p==NULL)
882: p=target;
883: memmove(p,out+3,strlen(out+3)+1);
884: out=p;
885: }
886: else {
887: out++;
888: }
889: }
890: }
891: return(target);
892: }
893: #endif
894:
895: /****************************************************************************/
896: /* Adds a trailing slash/backslash (path delimiter) on path strings */
897: /****************************************************************************/
898: char* DLLCALL backslash(char* path)
899: {
900: char* p;
901:
902: p=lastchar(path);
903:
904: if(*p && !IS_PATH_DELIM(*p)) {
905: #if defined(__unix__)
906: /* Convert trailing backslash to forwardslash on *nix */
907: if(*p!='\\')
908: #endif
909: p++;
910: *p=PATH_DELIM;
911: *(++p)=0;
912: }
913: return(path);
914: }
915:
916: /****************************************************************************/
917: /* Returns true if the specified filename an aboslute pathname */
918: /****************************************************************************/
919: BOOL DLLCALL isabspath(const char *filename)
920: {
921: char path[MAX_PATH+1];
922:
923: return(stricmp(filename,FULLPATH(path,filename,sizeof(path)))==0);
924: }
925:
926: /****************************************************************************/
927: /* Returns true if the specified filename is a full ("rooted") path */
928: /****************************************************************************/
929: BOOL DLLCALL isfullpath(const char* filename)
930: {
931: return(filename[0]=='/'
932: #ifdef WIN32
933: || filename[0]=='\\' || filename[1]==':'
934: #endif
935: );
936: }
937:
938: /****************************************************************************/
939: /* Matches file name against filespec */
940: /* Optionally not allowing * to match PATH_DELIM (for paths) */
941: /****************************************************************************/
942: BOOL DLLCALL wildmatch(const char *fname, const char *spec, BOOL path)
943: {
944: char *specp;
945: char *fnamep;
946:
947: specp=(char *)spec;
948: fnamep=(char *)fname;
949: for(;;specp++, fnamep++) {
950: switch(*specp) {
951: case '?':
952: if(!(*fnamep))
953: return(FALSE);
954: break;
955: case 0:
956: if(!*fnamep)
957: return(TRUE);
958: break;
959: case '*':
960: while(*specp=='*')
961: specp++;
962: for(;*fnamep!=*specp && *fnamep;fnamep++) {
963: if(path && IS_PATH_DELIM(*fnamep))
964: return(FALSE);
965: }
966: default:
967: if(*specp != *fnamep)
968: return(FALSE);
969: }
970: if(!(*specp && *fnamep))
971: break;
972: }
973: while(*specp=='*')
974: specp++;
975: if(*specp==*fnamep)
976: return(TRUE);
977: return(FALSE);
978: }
979:
980: /****************************************************************************/
981: /* Matches file name against filespec, ignoring case */
982: /****************************************************************************/
983: BOOL DLLCALL wildmatchi(const char *fname, const char *spec, BOOL path)
984: {
985: char* s1;
986: char* s2;
987: BOOL result;
988:
989: if((s1=strdup(fname))==NULL)
990: return(FALSE);
991: if((s2=strdup(spec))==NULL) {
992: free(s1);
993: return(FALSE);
994: }
995: strupr(s1);
996: strupr(s2);
997: result = wildmatch(s1, s2, path);
998: free(s1);
999: free(s2);
1000: return(result);
1001: }
1002:
1003: /****************************************************************************/
1004: /* Creates all the necessary directories in the specified path */
1005: /****************************************************************************/
1006: int DLLCALL mkdirs(const char* path)
1007: {
1008: const char* p=path;
1009: const char* tp;
1010: const char* sep=
1011: #ifdef _WIN32
1012: "\\"
1013: #endif
1014: "/";
1015: char dir[MAX_PATH+1];
1016: int result=0;
1017:
1018: #ifdef _WIN32
1019: if(p[1]==':') /* Skip drive letter, if specified */
1020: p+=2;
1021: #endif
1022:
1023: while(*p) {
1024: SKIP_CHARSET(p,sep);
1025: if(*p==0)
1026: break;
1027: tp=p;
1028: FIND_CHARSET(tp,sep);
1029: safe_snprintf(dir,sizeof(dir),"%.*s",tp-path, path);
1030: if(!isdir(dir)) {
1031: if((result=MKDIR(dir))!=0)
1032: break;
1033: }
1034: p=tp;
1035: }
1036:
1037: return(result);
1038: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.