![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to file.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous_trunk / src|
Return to file.c CVS log | Up to [Previous NeXT emulator] / previous_trunk / src |
1.1 root 1: /*
2: Hatari - file.c
3:
4: This file is distributed under the GNU Public License, version 2 or at
5: your option any later version. Read the file gpl.txt for details.
6:
7: Common file access functions.
8: */
9: const char File_fileid[] = "Hatari file.c : " __DATE__ " " __TIME__;
10:
11: #include <sys/types.h>
12: #include <sys/stat.h>
13: #include <sys/time.h>
14: #include <fcntl.h>
15: #include <unistd.h>
16: #include <assert.h>
17: #include <errno.h>
18: #include <zlib.h>
19:
20: #if defined(WIN32) && !defined(_VCWIN_)
21: #include <winsock2.h>
22: #endif
23:
24: #include "main.h"
25: #include "dialog.h"
26: #include "file.h"
27: #include "createBlankImage.h"
28: #include "str.h"
29: #include "zip.h"
30:
31: #if defined(WIN32)
32: #define ftello ftell
33: #endif
34:
35: /*-----------------------------------------------------------------------*/
36: /**
37: * Remove any '/'s from end of filenames, but keeps / intact
38: */
39: void File_CleanFileName(char *pszFileName)
40: {
41: int len;
42:
43: len = strlen(pszFileName);
44:
45: /* Remove end slashes from filename! But / remains! Doh! */
46: while (len > 2 && pszFileName[--len] == PATHSEP)
47: pszFileName[len] = '\0';
48: }
49:
50:
51: /*-----------------------------------------------------------------------*/
52: /**
53: * Add '/' to end of filename
54: */
55: void File_AddSlashToEndFileName(char *pszFileName)
56: {
57: int len;
58:
59: len = strlen(pszFileName);
60:
61: /* Check dir/filenames */
62: if (len != 0)
63: {
64: if (pszFileName[len-1] != PATHSEP)
65: {
66: pszFileName[len] = PATHSEP; /* Must use end slash */
67: pszFileName[len+1] = '\0';
68: }
69: }
70: }
71:
72:
73: /*-----------------------------------------------------------------------*/
74: /**
75: * Does filename extension match? If so, return TRUE
76: */
77: bool File_DoesFileExtensionMatch(const char *pszFileName, const char *pszExtension)
78: {
79: if (strlen(pszFileName) < strlen(pszExtension))
80: return false;
81: /* Is matching extension? */
82: if (!strcasecmp(&pszFileName[strlen(pszFileName)-strlen(pszExtension)], pszExtension))
83: return true;
84:
85: /* No */
86: return false;
87: }
88:
89:
90: /*-----------------------------------------------------------------------*/
91: /**
92: * Check if filename is from root
93: *
94: * Return TRUE if filename is '/', else give FALSE
95: */
96: static bool File_IsRootFileName(const char *pszFileName)
97: {
98: if (pszFileName[0] == '\0') /* If NULL string return! */
99: return false;
100:
101: if (pszFileName[0] == PATHSEP)
102: return true;
103:
104: #ifdef WIN32
105: if (pszFileName[1] == ':')
106: return true;
107: #endif
108:
109: #ifdef GEKKO
110: if (strlen(pszFileName) > 2 && pszFileName[2] == ':') // sd:
111: return true;
112: if (strlen(pszFileName) > 3 && pszFileName[3] == ':') // fat:
113: return true;
114: if (strlen(pszFileName) > 4 && pszFileName[4] == ':') // fat3:
115: return true;
116: #endif
117:
118: return false;
119: }
120:
121:
122: /*-----------------------------------------------------------------------*/
123: /**
124: * Return string, to remove 'C:' part of filename
125: */
126: const char *File_RemoveFileNameDrive(const char *pszFileName)
127: {
128: if ( (pszFileName[0] != '\0') && (pszFileName[1] == ':') )
129: return &pszFileName[2];
130: else
131: return pszFileName;
132: }
133:
134:
135: /*-----------------------------------------------------------------------*/
136: /**
137: * Check if filename end with a '/'
138: *
139: * Return TRUE if filename ends with '/'
140: */
141: bool File_DoesFileNameEndWithSlash(char *pszFileName)
142: {
143: if (pszFileName[0] == '\0') /* If NULL string return! */
144: return false;
145:
146: /* Does string end in a '/'? */
147: if (pszFileName[strlen(pszFileName)-1] == PATHSEP)
148: return true;
149:
150: return false;
151: }
152:
153:
154: /*-----------------------------------------------------------------------*/
155: /**
156: * Read file from disk into allocated buffer and return the buffer
157: * or NULL for error. If pFileSize is non-NULL, read file size
158: * is set to that.
159: */
160: Uint8 *File_Load(const char *pszFileName, long *pFileSize, const char * const ppszExts[])
161: {
162: char *filepath = NULL;
163: Uint8 *pFile = NULL;
164: long FileSize = 0;
165:
166: /* Does the file exist? If not, see if can scan for other extensions and try these */
167: if (!File_Exists(pszFileName) && ppszExts)
168: {
169: /* Try other extensions, if succeeds, returns correct one */
170: filepath = File_FindPossibleExtFileName(pszFileName, ppszExts);
171: }
172: if (!filepath)
173: filepath = strdup(pszFileName);
174:
175: /* Is it a gzipped file? */
176: if (File_DoesFileExtensionMatch(filepath, ".gz"))
177: {
178: gzFile hGzFile;
179: /* Open and read gzipped file */
180: hGzFile = gzopen(filepath, "rb");
181: if (hGzFile != NULL)
182: {
183: /* Find size of file: */
184: do
185: {
186: /* Seek through the file until we hit the end... */
187: gzseek(hGzFile, 1024, SEEK_CUR);
188: }
189: while (!gzeof(hGzFile));
190: FileSize = gztell(hGzFile);
191: gzrewind(hGzFile);
192: /* Read in... */
193: pFile = malloc(FileSize);
194: if (pFile)
195: FileSize = gzread(hGzFile, pFile, FileSize);
196:
197: gzclose(hGzFile);
198: }
199: }
200: else if (File_DoesFileExtensionMatch(filepath, ".zip"))
201: {
202: /* It is a .ZIP file! -> Try to load the first file in the archive */
203: pFile = ZIP_ReadFirstFile(filepath, &FileSize, ppszExts);
204: }
205: else /* It is a normal file */
206: {
207: FILE *hDiskFile;
208: /* Open and read normal file */
209: hDiskFile = fopen(filepath, "rb");
210: if (hDiskFile != NULL)
211: {
212: /* Find size of file: */
213: fseek(hDiskFile, 0, SEEK_END);
214: FileSize = ftell(hDiskFile);
215: fseek(hDiskFile, 0, SEEK_SET);
216: /* Read in... */
217: pFile = malloc(FileSize);
218: if (pFile)
219: FileSize = fread(pFile, 1, FileSize, hDiskFile);
220:
221: fclose(hDiskFile);
222: }
223: }
224: free(filepath);
225:
226: /* Store size of file we read in (or 0 if failed) */
227: if (pFileSize)
228: *pFileSize = FileSize;
229:
230: return pFile; /* Return to where read in/allocated */
231: }
232:
233:
234: /*-----------------------------------------------------------------------*/
235: /**
236: * Save file to disk, return FALSE if errors
237: */
238: bool File_Save(const char *pszFileName, const Uint8 *pAddress, size_t Size, bool bQueryOverwrite)
239: {
240: bool bRet = false;
241:
242: /* Check if need to ask user if to overwrite */
243: if (bQueryOverwrite)
244: {
245: /* If file exists, ask if OK to overwrite */
246: if (!File_QueryOverwrite(pszFileName))
247: return false;
248: }
249:
250: /* Normal file or gzipped file? */
251: if (File_DoesFileExtensionMatch(pszFileName, ".gz"))
252: {
253: gzFile hGzFile;
254: /* Create a gzipped file: */
255: hGzFile = gzopen(pszFileName, "wb");
256: if (hGzFile != NULL)
257: {
258: /* Write data, set success flag */
259: if (gzwrite(hGzFile, pAddress, Size) == (int)Size)
260: bRet = true;
261:
262: gzclose(hGzFile);
263: }
264: }
265: else
266: {
267: FILE *hDiskFile;
268: /* Create a normal file: */
269: hDiskFile = fopen(pszFileName, "wb");
270: if (hDiskFile != NULL)
271: {
272: /* Write data, set success flag */
273: if (fwrite(pAddress, 1, Size, hDiskFile) == Size)
274: bRet = true;
275:
276: fclose(hDiskFile);
277: }
278: }
279:
280: return bRet;
281: }
282:
283:
284: /*-----------------------------------------------------------------------*/
285: /**
286: * Return size of file, -1 if error
287: */
288: off_t File_Length(const char *pszFileName)
289: {
290: FILE *hDiskFile;
291: off_t FileSize;
292:
293: hDiskFile = fopen(pszFileName, "rb");
294: if (hDiskFile!=NULL)
295: {
296: fseek(hDiskFile, 0, SEEK_END);
297: FileSize = ftello(hDiskFile);
298: fseek(hDiskFile, 0, SEEK_SET);
299: fclose(hDiskFile);
300: return FileSize;
301: }
302:
303: return -1;
304: }
305:
306:
307: /*-----------------------------------------------------------------------*/
308: /**
309: * Return TRUE if file exists, is readable or writable at least and is not
310: * a directory.
311: */
312: bool File_Exists(const char *filename)
313: {
314: struct stat buf;
315: if (stat(filename, &buf) == 0 &&
316: (buf.st_mode & (S_IRUSR|S_IWUSR)) && !(buf.st_mode & S_IFDIR))
317: {
318: /* file points to user readable regular file */
319: return true;
320: }
321: return false;
322: }
323:
324:
325: /*-----------------------------------------------------------------------*/
326: /**
327: * Return TRUE if directory exists.
328: */
329: bool File_DirExists(const char *path)
330: {
331: struct stat buf;
332: return (stat(path, &buf) == 0 && S_ISDIR(buf.st_mode));
333: }
334:
335:
336: /*-----------------------------------------------------------------------*/
337: /**
338: * Find if file exists, and if so ask user if OK to overwrite
339: */
340: bool File_QueryOverwrite(const char *pszFileName)
341: {
342: const char *fmt;
343: char *szString;
344: bool ret = true;
345:
346: /* Try and find if file exists */
347: if (File_Exists(pszFileName))
348: {
349: fmt = "File '%s' exists, overwrite?";
350: /* File does exist, are we OK to overwrite? */
351: szString = malloc(strlen(pszFileName) + strlen(fmt) + 1);
352: sprintf(szString, fmt, pszFileName);
353: fprintf(stderr, "%s\n", szString);
354: ret = DlgAlert_Query(szString);
355: free(szString);
356: }
357: return ret;
358: }
359:
360:
361: /*-----------------------------------------------------------------------*/
362: /**
363: * Try filename with various extensions and check if file exists
364: * - if so, return allocated string which caller should free,
365: * otherwise return NULL
366: */
367: char * File_FindPossibleExtFileName(const char *pszFileName, const char * const ppszExts[])
368: {
369: char *szSrcDir, *szSrcName, *szSrcExt;
370: int i;
371:
372: /* Allocate temporary memory for strings: */
373: szSrcDir = malloc(3 * FILENAME_MAX);
374: if (!szSrcDir)
375: {
376: perror("File_FindPossibleExtFileName");
377: return false;
378: }
379: szSrcName = szSrcDir + FILENAME_MAX;
380: szSrcExt = szSrcName + FILENAME_MAX;
381:
382: /* Split filename into parts */
383: File_SplitPath(pszFileName, szSrcDir, szSrcName, szSrcExt);
384:
385: /* Scan possible extensions */
386: for (i = 0; ppszExts[i]; i++)
387: {
388: char *szTempFileName;
389:
390: /* Re-build with new file extension */
391: szTempFileName = File_MakePath(szSrcDir, szSrcName, ppszExts[i]);
392: if (szTempFileName)
393: {
394: /* Does this file exist? */
395: if (File_Exists(szTempFileName))
396: {
397: free(szSrcDir);
398: /* return filename without extra strings */
399: return szTempFileName;
400: }
401: free(szTempFileName);
402: }
403: }
404: free(szSrcDir);
405: return NULL;
406: }
407:
408:
409: /*-----------------------------------------------------------------------*/
410: /**
411: * Split a complete filename into path, filename and extension.
412: * If pExt is NULL, don't split the extension from the file name!
413: * It's safe for pSrcFileName and pDir to be the same string.
414: */
415: void File_SplitPath(const char *pSrcFileName, char *pDir, char *pName, char *pExt)
416: {
417: char *ptr1, *ptr2;
418:
419: /* Build pathname: */
420: ptr1 = strrchr(pSrcFileName, PATHSEP);
421: if (ptr1)
422: {
423: strcpy(pName, ptr1+1);
424: memmove(pDir, pSrcFileName, ptr1-pSrcFileName);
425: pDir[ptr1-pSrcFileName] = 0;
426: }
427: else
428: {
429: strcpy(pName, pSrcFileName);
430: sprintf(pDir, ".%c", PATHSEP);
431: }
432:
433: /* Build the raw filename: */
434: if (pExt != NULL)
435: {
436: ptr2 = strrchr(pName+1, '.');
437: if (ptr2)
438: {
439: pName[ptr2-pName] = 0;
440: /* Copy the file extension: */
441: strcpy(pExt, ptr2+1);
442: }
443: else
444: pExt[0] = 0;
445: }
446: }
447:
448:
449: /*-----------------------------------------------------------------------*/
450: /**
451: * Construct a complete filename from path, filename and extension.
452: * Return the constructed filename.
453: * pExt can also be NULL.
454: */
455: char * File_MakePath(const char *pDir, const char *pName, const char *pExt)
456: {
457: char *filepath;
458: int len;
459:
460: /* dir or "." + "/" + name + "." + ext + \0 */
461: len = strlen(pDir) + 2 + strlen(pName) + 1 + (pExt ? strlen(pExt) : 0) + 1;
462: filepath = malloc(len);
463: if (!filepath)
464: {
465: perror("File_MakePath");
466: return NULL;
467: }
468: if (!pDir[0])
469: {
470: filepath[0] = '.';
471: filepath[1] = '\0';
472: } else {
473: strcpy(filepath, pDir);
474: }
475: len = strlen(filepath);
476: if (filepath[len-1] != PATHSEP)
477: {
478: filepath[len++] = PATHSEP;
479: }
480: strcpy(&filepath[len], pName);
481:
482: if (pExt != NULL && pExt[0])
483: {
484: len += strlen(pName);
485: if (pExt[0] != '.')
486: strcat(&filepath[len++], ".");
487: strcat(&filepath[len], pExt);
488: }
489: return filepath;
490: }
491:
492:
493: /*-----------------------------------------------------------------------*/
494: /**
495: * Shrink a file name to a certain length and insert some dots if we cut
496: * something away (useful for showing file names in a dialog).
497: */
498: void File_ShrinkName(char *pDestFileName, const char *pSrcFileName, int maxlen)
499: {
500: int srclen = strlen(pSrcFileName);
501: if (srclen < maxlen)
502: strcpy(pDestFileName, pSrcFileName); /* It fits! */
503: else
504: {
505: assert(maxlen > 6);
506: strncpy(pDestFileName, pSrcFileName, maxlen/2);
507: if (maxlen&1) /* even or uneven? */
508: pDestFileName[maxlen/2-1] = 0;
509: else
510: pDestFileName[maxlen/2-2] = 0;
511: strcat(pDestFileName, "...");
512: strcat(pDestFileName, &pSrcFileName[strlen(pSrcFileName)-maxlen/2+1]);
513: }
514: }
515:
516:
517: /*-----------------------------------------------------------------------*/
518: /**
519: * Open given filename in given mode and handle "stdout" & "stderr"
520: * filenames specially. Return FILE* to the opened file or NULL on error.
521: */
522: FILE *File_Open(const char *path, const char *mode)
523: {
524: int wr = 0, rd = 0;
525: FILE *fp;
526:
527: /* empty name signifies file that shouldn't be opened/enabled */
528: if (!*path)
529: return NULL;
530:
531: /* special "stdout" and "stderr" files can be used
532: * for files which are written or appended
533: */
534: if (strchr(mode, 'w') || strchr(mode, 'a'))
535: wr = 1;
536: if (strchr(mode, 'r'))
537: rd = 1;
538: if (strcmp(path, "stdin") == 0)
539: {
540: assert(rd && !wr);
541: return stdin;
542: }
543: if (strcmp(path, "stdout") == 0)
544: {
545: assert(wr && !rd);
546: return stdout;
547: }
548: if (strcmp(path, "stderr") == 0)
549: {
550: assert(wr && !rd);
551: return stderr;
552: }
553: /* Open a normal log file */
554: fp = fopen(path, mode);
555: if (!fp)
556: fprintf(stderr, "Can't open file '%s' (wr=%i, rd=%i):\n %s\n",
557: path, wr, rd, strerror(errno));
558:
559: /* printf("'%s' opened in mode '%s'\n", path, mode, fp); */
560: return fp;
561: }
562:
563:
564: /*-----------------------------------------------------------------------*/
565: /**
566: * Close given FILE pointer and return the closed pointer
567: * as NULL for the idiom "fp = File_Close(fp);"
568: */
569: FILE *File_Close(FILE *fp)
570: {
571: if (fp && fp != stdin && fp != stdout && fp != stderr)
572: {
573: fclose(fp);
574: }
575: return NULL;
576: }
577:
578:
579: /*-----------------------------------------------------------------------*/
580: /**
581: * Read data from given FILE pointer to buffer and return status
582: */
583: bool File_Read(Uint8 *data, Uint32 size, Uint64 offset, FILE *fp)
584: {
585: if (fseek(fp, offset, SEEK_SET))
586: {
587: fprintf(stderr, "File seek failed:\n %s\n", strerror(errno));
588: return false;
589: }
590: if (fread(data, size, 1, fp) != 1)
591: {
592: fprintf(stderr, "Error occured while reading file.\n");
593: return false;
594: }
595: return true;
596: }
597:
598:
599: /*-----------------------------------------------------------------------*/
600: /**
601: * Write data to given FILE pointer and return status
602: */
603: bool File_Write(Uint8 *data, Uint32 size, Uint64 offset, FILE *fp)
604: {
605: if (fseek(fp, offset, SEEK_SET))
606: {
607: fprintf(stderr, "File seek failed:\n %s\n", strerror(errno));
608: return false;
609: }
610: if (fwrite(data, size, 1, fp) != 1)
611: {
612: fprintf(stderr, "Error occured while writing file.\n");
613: return false;
614: }
615: return true;
616: }
617:
618:
619: /*-----------------------------------------------------------------------*/
620: /**
621: * Check if input is available at the specified file descriptor.
622: */
623: bool File_InputAvailable(FILE *fp)
624: {
625: #if HAVE_SELECT
626: fd_set rfds;
627: struct timeval tv;
628: int fh;
629: int ret;
630:
631: if (!fp || (fh = fileno(fp)) == -1)
632: return false;
633:
634: /* Add the file handle to the file descriptor set */
635: FD_ZERO(&rfds);
636: FD_SET(fh, &rfds);
637:
638: /* Return immediately */
639: tv.tv_sec = 0;
640: tv.tv_usec = 0;
641:
642: /* Check if file descriptor is ready for a read */
643: ret = select(fh+1, &rfds, NULL, NULL, &tv);
644:
645: if (ret > 0)
646: return true; /* Data available */
647: #endif
648:
649: return false;
650: }
651:
652:
653: /*-----------------------------------------------------------------------*/
654: /**
655: * Wrapper for File_MakeAbsoluteName() which special-cases stdin/out/err
656: * named files and empty file name. The given buffer should be opened
657: * with File_Open() and closed with File_Close() if this function is used!
658: * (On Linux one can use /dev/stdout etc, this is intended for other OSes)
659: */
660: void File_MakeAbsoluteSpecialName(char *path)
661: {
662: if (path[0] &&
663: strcmp(path, "stdin") != 0 &&
664: strcmp(path, "stdout") != 0 &&
665: strcmp(path, "stderr") != 0)
666: File_MakeAbsoluteName(path);
667: }
668:
669: /*-----------------------------------------------------------------------*/
670: /**
671: * Create a clean absolute file name from a (possibly) relative file name.
672: * I.e. filter out all occurancies of "./" and "../".
673: * pFileName needs to point to a buffer of at least FILENAME_MAX bytes.
674: */
675: void File_MakeAbsoluteName(char *pFileName)
676: {
677: char *pTempName;
678: int inpos, outpos;
679:
680: inpos = 0;
681: pTempName = malloc(FILENAME_MAX);
682: if (!pTempName)
683: {
684: perror("File_MakeAbsoluteName - malloc");
685: return;
686: }
687:
688: /* Is it already an absolute name? */
689: if (File_IsRootFileName(pFileName))
690: {
691: outpos = 0;
692: }
693: else
694: {
695: if (!getcwd(pTempName, FILENAME_MAX))
696: {
697: perror("File_MakeAbsoluteName - getcwd");
698: free(pTempName);
699: return;
700: }
701: File_AddSlashToEndFileName(pTempName);
702: outpos = strlen(pTempName);
703: }
704:
705: /* Now filter out the relative paths "./" and "../" */
706: while (pFileName[inpos] != 0 && outpos < FILENAME_MAX)
707: {
708: if (pFileName[inpos] == '.' && pFileName[inpos+1] == PATHSEP)
709: {
710: /* Ignore "./" */
711: inpos += 2;
712: }
713: else if (pFileName[inpos] == '.' && pFileName[inpos+1] == 0)
714: {
715: inpos += 1; /* Ignore "." at the end of the path string */
716: if (outpos > 1)
717: pTempName[outpos - 1] = 0; /* Remove the last slash, too */
718: }
719: else if (pFileName[inpos] == '.' && pFileName[inpos+1] == '.'
720: && (pFileName[inpos+2] == PATHSEP || pFileName[inpos+2] == 0))
721: {
722: /* Handle "../" */
723: char *pSlashPos;
724: inpos += 2;
725: pTempName[outpos - 1] = 0;
726: pSlashPos = strrchr(pTempName, PATHSEP);
727: if (pSlashPos)
728: {
729: *(pSlashPos + 1) = 0;
730: outpos = strlen(pTempName);
731: }
732: else
733: {
734: pTempName[0] = PATHSEP;
735: outpos = 1;
736: }
737: /* Were we already at the end of the string or is there more to come? */
738: if (pFileName[inpos] == PATHSEP)
739: {
740: /* There was a slash after the '..', so skip slash and
741: * simply proceed with next part */
742: inpos += 1;
743: }
744: else
745: {
746: /* We were at the end of the string, so let's remove the slash
747: * from the new string, too */
748: if (outpos > 1)
749: pTempName[outpos - 1] = 0;
750: }
751: }
752: else
753: {
754: /* Copy until next slash or end of input string */
755: while (pFileName[inpos] != 0 && outpos < FILENAME_MAX)
756: {
757: pTempName[outpos++] = pFileName[inpos++];
758: if (pFileName[inpos - 1] == PATHSEP)
759: break;
760: }
761: }
762: }
763:
764: pTempName[outpos] = 0;
765:
766: strcpy(pFileName, pTempName); /* Copy back */
767: free(pTempName);
768: }
769:
770:
771: /*-----------------------------------------------------------------------*/
772: /**
773: * Create a valid path name from a possibly invalid name by erasing invalid
774: * path parts at the end of the string. If string doesn't contain any path
775: * component, it will be pointed to the root directory. Empty string will
776: * be left as-is to prevent overwriting past allocated area.
777: */
778: void File_MakeValidPathName(char *pPathName)
779: {
780: struct stat dirstat;
781: char *pLastSlash;
782:
783: do
784: {
785: /* Check for a valid path */
786: if (stat(pPathName, &dirstat) == 0 && S_ISDIR(dirstat.st_mode))
787: {
788: break;
789: }
790:
791: pLastSlash = strrchr(pPathName, PATHSEP);
792: if (pLastSlash)
793: {
794: /* Erase the (probably invalid) part after the last slash */
795: *pLastSlash = 0;
796: }
797: else
798: {
799: if (pPathName[0])
800: {
801: /* point to root */
802: pPathName[0] = PATHSEP;
803: pPathName[1] = 0;
804: }
805: return;
806: }
807: }
808: while (pLastSlash);
809:
810: /* Make sure that path name ends with a slash */
811: File_AddSlashToEndFileName(pPathName);
812: }
813:
814:
815: /*-----------------------------------------------------------------------*/
816: /**
817: * Remove given number of path elements from the end of the given path.
818: * Leaves '/' at the end if path still has directories. Given path
819: * may not be empty.
820: */
821: void File_PathShorten(char *path, int dirs)
822: {
823: int i, n = 0;
824: /* ignore last char, it may or may not be '/' */
825: i = strlen(path)-1;
826: assert(i >= 0);
827: while(i > 0 && n < dirs) {
828: if (path[--i] == PATHSEP)
829: n++;
830: }
831: if (path[i] == PATHSEP) {
832: path[i+1] = '\0';
833: } else {
834: path[0] = PATHSEP;
835: path[1] = '\0';
836: }
837: }
838:
839:
840: /*-----------------------------------------------------------------------*/
841: /*
842: If "/." or "/.." at end, remove that and in case of ".." remove
843: also preceding dir (go one dir up). Leave '/' at the end of
844: the path.
845: */
846: void File_HandleDotDirs(char *path)
847: {
848: int len = strlen(path);
849: if (len >= 2 &&
850: path[len-2] == PATHSEP &&
851: path[len-1] == '.')
852: {
853: /* keep in same dir */
854: path[len-1] = '\0';
855: }
856: else if (len >= 3 &&
857: path[len-3] == PATHSEP &&
858: path[len-2] == '.' &&
859: path[len-1] == '.')
860: {
861: /* go one dir up */
862: if (len == 3) {
863: path[1] = 0; /* already root */
864: } else {
865: char *ptr;
866: path[len-3] = 0;
867: ptr = strrchr(path, PATHSEP);
868: if (ptr)
869: *(ptr+1) = 0;
870: }
871: }
872: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.