Permalink
Find file
Fetching contributors…
Cannot retrieve contributors at this time
784 lines (714 sloc) 23.1 KB
/*
* Copyright (c) 2008-2009 Brent Fulgham <bfulgham@gmail.org>. All rights reserved.
* Copyright (c) 2009 Grant Erickson <gerickson@nuovations.com>. All rights reserved.
*
* This source code is a modified version of the CoreFoundation sources released by Apple Inc. under
* the terms of the APSL version 2.0 (see below).
*
* For information about changes from the original Apple source release can be found by reviewing the
* source control system for the project at https://sourceforge.net/svn/?group_id=246198.
*
* The original license information is as follows:
*
* Copyright (c) 2008 Apple Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
/* CFFileUtilities.c
Copyright 1999-2002, Apple, Inc. All rights reserved.
Responsibility: Christopher Kane
*/
#include "CFInternal.h"
#include "CFPriv.h"
#include <string.h>
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_LINUX
#include <unistd.h>
#include <dirent.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <pwd.h>
#include <fcntl.h>
#elif DEPLOYMENT_TARGET_WINDOWS
/* In typical fragile fashion, order of include on Windows is important */
#include <io.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <windows.h>
#define lseek _lseek
#define open _open
#define read _read
#define write _write
#define close _close
#endif
#include <errno.h>
#include <stdio.h>
#if DEPLOYMENT_TARGET_WINDOWS
#define CF_OPENFLGS (_O_BINARY|_O_NOINHERIT)
#else
#define CF_OPENFLGS (0)
#endif
__private_extern__ CFStringRef _CFCopyExtensionForAbstractType(CFStringRef abstractType) {
return (abstractType ? (CFStringRef)CFRetain(abstractType) : NULL);
}
__private_extern__ Boolean _CFCreateDirectory(const char *path) {
#if DEPLOYMENT_TARGET_WINDOWS || 0
return CreateDirectoryA(path, (LPSECURITY_ATTRIBUTES)NULL);
#else
int no_hang_fd = open("/dev/autofs_nowait", 0);
int ret = ((mkdir(path, 0777) == 0) ? true : false);
close(no_hang_fd);
return ret;
#endif
}
__private_extern__ Boolean _CFRemoveDirectory(const char *path) {
#if DEPLOYMENT_TARGET_WINDOWS || 0
return RemoveDirectoryA(path);
#else
int no_hang_fd = open("/dev/autofs_nowait", 0);
int ret = ((rmdir(path) == 0) ? true : false);
close(no_hang_fd);
return ret;
#endif
}
__private_extern__ Boolean _CFDeleteFile(const char *path) {
#if DEPLOYMENT_TARGET_WINDOWS || 0
return DeleteFileA(path);
#else
int no_hang_fd = open("/dev/autofs_nowait", 0);
int ret = unlink(path) == 0;
close(no_hang_fd);
return ret;
#endif
}
__private_extern__ Boolean _CFReadBytesFromFile(CFAllocatorRef alloc, CFURLRef url, void **bytes, CFIndex *length, CFIndex maxLength) {
// maxLength is the number of bytes desired, or 0 if the whole file is desired regardless of length.
struct stat statBuf;
int fd = -1;
char path[CFMaxPathSize];
if (!CFURLGetFileSystemRepresentation(url, true, (uint8_t *)path, CFMaxPathSize)) {
return false;
}
*bytes = NULL;
#if DEPLOYMENT_TARGET_WINDOWS || 0
fd = open(path, O_RDONLY|CF_OPENFLGS, 0666|_S_IREAD);
#else
int no_hang_fd = open("/dev/autofs_nowait", 0);
fd = open(path, O_RDONLY|CF_OPENFLGS, 0666);
#endif
if (fd < 0) {
#if !DEPLOYMENT_TARGET_WINDOWS
close(no_hang_fd);
#endif
return false;
}
if (fstat(fd, &statBuf) < 0) {
int saveerr = thread_errno();
close(fd);
#if !DEPLOYMENT_TARGET_WINDOWS
close(no_hang_fd);
#endif
thread_set_errno(saveerr);
return false;
}
if ((statBuf.st_mode & S_IFMT) != S_IFREG) {
close(fd);
#if !DEPLOYMENT_TARGET_WINDOWS
close(no_hang_fd);
#endif
thread_set_errno(EACCES);
return false;
}
if (statBuf.st_size == 0) {
*bytes = CFAllocatorAllocate(alloc, 4, 0); // don't return constant string -- it's freed!
if (__CFOASafe) __CFSetLastAllocationEventName(*bytes, "CFUtilities (file-bytes)");
*length = 0;
} else {
CFIndex desiredLength;
if ((maxLength >= statBuf.st_size) || (maxLength == 0)) {
desiredLength = statBuf.st_size;
} else {
desiredLength = maxLength;
}
*bytes = CFAllocatorAllocate(alloc, desiredLength, 0);
if (__CFOASafe) __CFSetLastAllocationEventName(*bytes, "CFUtilities (file-bytes)");
// fcntl(fd, F_NOCACHE, 1);
if (read(fd, *bytes, desiredLength) < 0) {
CFAllocatorDeallocate(alloc, *bytes);
close(fd);
#if !DEPLOYMENT_TARGET_WINDOWS
close(no_hang_fd);
#endif
return false;
}
*length = desiredLength;
}
close(fd);
#if !DEPLOYMENT_TARGET_WINDOWS
close(no_hang_fd);
#endif
return true;
}
__private_extern__ Boolean _CFWriteBytesToFile(CFURLRef url, const void *bytes, CFIndex length) {
struct stat statBuf;
int fd = -1;
int mode;
char path[CFMaxPathSize];
if (!CFURLGetFileSystemRepresentation(url, true, (uint8_t *)path, CFMaxPathSize)) {
return false;
}
#if DEPLOYMENT_TARGET_WINDOWS || 0
mode = 0666;
if (0 == stat(path, &statBuf)) {
mode = statBuf.st_mode;
} else if (thread_errno() != ENOENT) {
return false;
}
fd = open(path, O_WRONLY|O_CREAT|O_TRUNC|CF_OPENFLGS, 0666|_S_IWRITE);
if (fd < 0) {
return false;
}
if (length && write(fd, bytes, length) != length) {
int saveerr = thread_errno();
close(fd);
thread_set_errno(saveerr);
return false;
}
FlushFileBuffers((HANDLE)_get_osfhandle(fd));
close(fd);
#else
int no_hang_fd = open("/dev/autofs_nowait", 0);
mode = 0666;
if (0 == stat(path, &statBuf)) {
mode = statBuf.st_mode;
} else if (thread_errno() != ENOENT) {
close(no_hang_fd);
return false;
}
fd = open(path, O_WRONLY|O_CREAT|O_TRUNC|CF_OPENFLGS, 0666);
if (fd < 0) {
close(no_hang_fd);
return false;
}
if (length && write(fd, bytes, length) != length) {
int saveerr = thread_errno();
close(fd);
close(no_hang_fd);
thread_set_errno(saveerr);
return false;
}
fsync(fd);
close(fd);
close(no_hang_fd);
#endif
return true;
}
/* On Mac OS 8/9, one of dirSpec and dirURL must be non-NULL. On all other platforms, one of path and dirURL must be non-NULL
If both are present, they are assumed to be in-synch; that is, they both refer to the same directory. */
/* Lately, dirSpec appears to be (rightfully) unused. */
__private_extern__ CFMutableArrayRef _CFContentsOfDirectory(CFAllocatorRef alloc, char *dirPath, void *dirSpec, CFURLRef dirURL, CFStringRef matchingAbstractType) {
CFMutableArrayRef files = NULL;
Boolean releaseBase = false;
CFIndex pathLength = dirPath ? (CFIndex)strlen(dirPath) : 0;
// MF:!!! Need to use four-letter type codes where appropriate.
CFStringRef extension = (matchingAbstractType ? _CFCopyExtensionForAbstractType(matchingAbstractType) : NULL);
CFIndex extLen = (extension ? CFStringGetLength(extension) : 0);
uint8_t extBuff[CFMaxPathSize];
if (extLen > 0) {
CFStringGetBytes(extension, CFRangeMake(0, extLen), CFStringFileSystemEncoding(), 0, false, extBuff, CFMaxPathLength, &extLen);
extBuff[extLen] = '\0';
}
uint8_t pathBuf[CFMaxPathSize];
if (!dirPath) {
if (!CFURLGetFileSystemRepresentation(dirURL, true, pathBuf, CFMaxPathLength)) {
if (extension) CFRelease(extension);
return NULL;
} else {
dirPath = (char *)pathBuf;
pathLength = (CFIndex)strlen(dirPath);
}
}
#if (DEPLOYMENT_TARGET_MACOSX) || defined(__svr4__) || defined(__hpux__) || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
struct dirent buffer;
struct dirent *dp;
int err;
int no_hang_fd = open("/dev/autofs_nowait", 0);
DIR *dirp = opendir(dirPath);
if (!dirp) {
if (extension) {
CFRelease(extension);
}
close(no_hang_fd);
return NULL;
// raiseErrno("opendir", path);
}
files = CFArrayCreateMutable(alloc, 0, & kCFTypeArrayCallBacks);
while((0 == readdir_r(dirp, &buffer, &dp)) && dp) {
CFURLRef fileURL;
unsigned namelen = strlen(dp->d_name);
// skip . & ..; they cause descenders to go berserk
if (dp->d_name[0] == '.' && (namelen == 1 || (namelen == 2 && dp->d_name[1] == '.'))) {
continue;
}
if (extLen > namelen) continue; // if the extension is the same length or longer than the name, it can't possibly match.
if (extLen > 0) {
// Check to see if it matches the extension we're looking for.
if (strncmp(&(dp->d_name[namelen - extLen]), (char *)extBuff, extLen) != 0) {
continue;
}
}
if (dirURL == NULL) {
dirURL = CFURLCreateFromFileSystemRepresentation(alloc, (uint8_t *)dirPath, pathLength, true);
releaseBase = true;
}
if (dp->d_type == DT_DIR || dp->d_type == DT_UNKNOWN) {
Boolean isDir = (dp->d_type == DT_DIR);
if (!isDir) {
// Ugh; must stat.
char subdirPath[CFMaxPathLength];
struct stat statBuf;
strlcpy(subdirPath, dirPath, sizeof(subdirPath));
strlcat(subdirPath, "/", sizeof(subdirPath));
strlcat(subdirPath, dp->d_name, sizeof(subdirPath));
if (stat(subdirPath, &statBuf) == 0) {
isDir = ((statBuf.st_mode & S_IFMT) == S_IFDIR);
}
}
fileURL = CFURLCreateFromFileSystemRepresentationRelativeToBase(alloc, (uint8_t *)dp->d_name, namelen, isDir, dirURL);
} else {
fileURL = CFURLCreateFromFileSystemRepresentationRelativeToBase (alloc, (uint8_t *)dp->d_name, namelen, false, dirURL);
}
CFArrayAppendValue(files, fileURL);
CFRelease(fileURL);
}
err = closedir(dirp);
close(no_hang_fd);
if (err != 0) {
CFRelease(files);
if (releaseBase) {
CFRelease(dirURL);
}
if (extension) {
CFRelease(extension);
}
return NULL;
}
#elif DEPLOYMENT_TARGET_WINDOWS
WIN32_FIND_DATAA file;
HANDLE handle;
if (pathLength + 2 >= CFMaxPathLength) {
if (extension) {
CFRelease(extension);
}
return NULL;
}
if (NULL != dirPath) {
dirPath[pathLength] = '\'';
dirPath[pathLength + 1] = '*';
dirPath[pathLength + 2] = '\0';
handle = FindFirstFileA(dirPath, &file);
if (INVALID_HANDLE_VALUE == handle) {
dirPath[pathLength] = '\0';
if (extension) {
CFRelease(extension);
}
return NULL;
}
} else {
pathLength = 0;
}
files = CFArrayCreateMutable(alloc, 0, &kCFTypeArrayCallBacks);
do {
CFURLRef fileURL;
CFIndex namelen = (CFIndex)strlen(file.cFileName);
if (file.cFileName[0] == '.' && (namelen == 1 || (namelen == 2 && file.cFileName[1] == '.'))) {
continue;
}
if (extLen > 0) {
// Check to see if it matches the extension we're looking for.
if (_stricmp((char*)&(file.cFileName[namelen - extLen]), (char*)extBuff) != 0) {
continue;
}
}
if (dirURL == NULL) {
dirURL = CFURLCreateFromFileSystemRepresentation(alloc, (UInt8*)dirPath, pathLength, true);
releaseBase = true;
}
// MF:!!! What about the trailing slash?
fileURL = CFURLCreateFromFileSystemRepresentationRelativeToBase(alloc, (UInt8*)file.cFileName, namelen, false, dirURL);
CFArrayAppendValue(files, fileURL);
CFRelease(fileURL);
} while (FindNextFileA(handle, &file));
FindClose(handle);
dirPath[pathLength] = '\0';
#else
#error _CFContentsOfDirectory() unknown architechture, not implemented
#endif
if (extension) {
CFRelease(extension);
}
if (releaseBase) {
CFRelease(dirURL);
}
return files;
}
__private_extern__ SInt32 _CFGetFileProperties(CFAllocatorRef alloc, CFURLRef pathURL, Boolean *exists, SInt32 *posixMode, int64_t *size, CFDateRef *modTime, SInt32 *ownerID, CFArrayRef *dirContents) {
Boolean fileExists;
Boolean isDirectory = false;
#if DEPLOYMENT_TARGET_WINDOWS
struct _stati64 statBuf;
int fd = -1;
#else
struct stat64 statBuf;
#endif
char path[CFMaxPathSize];
if ((exists == NULL) && (posixMode == NULL) && (size == NULL) && (modTime == NULL) && (ownerID == NULL) && (dirContents == NULL)) {
// Nothing to do.
return 0;
}
if (!CFURLGetFileSystemRepresentation(pathURL, true, (uint8_t *)path, CFMaxPathLength)) {
return -1;
}
#if DEPLOYMENT_TARGET_WINDOWS
HANDLE hFile = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
if (INVALID_HANDLE_VALUE == hFile)
return -1;
fd = _open_osfhandle((intptr_t)hFile, _O_RDONLY|CF_OPENFLGS);
if (fd < 0) {
if (thread_errno() == ENOENT) {
fileExists = false;
} else {
CloseHandle (hFile);
return thread_errno();
}
}
else
{
if (_fstati64(fd, &statBuf) != 0) {
close(fd);
CloseHandle (hFile);
// stat failed, but why?
if (thread_errno() == ENOENT) {
fileExists = false;
} else {
return thread_errno();
}
} else {
close(fd);
CloseHandle (hFile);
fileExists = true;
isDirectory = ((statBuf.st_mode & S_IFMT) == S_IFDIR);
}
}
#else
if (stat64(path, &statBuf) != 0) {
// stat failed, but why?
if (thread_errno() == ENOENT) {
fileExists = false;
} else {
return thread_errno();
}
} else {
fileExists = true;
isDirectory = ((statBuf.st_mode & S_IFMT) == S_IFDIR);
}
#endif
if (exists != NULL) {
*exists = fileExists;
}
if (posixMode != NULL) {
if (fileExists) {
*posixMode = statBuf.st_mode;
} else {
*posixMode = 0;
}
}
if (size != NULL) {
if (fileExists) {
*size = statBuf.st_size;
} else {
*size = 0;
}
}
if (modTime != NULL) {
if (fileExists) {
#if DEPLOYMENT_TARGET_WINDOWS
CFAbsoluteTime theTime = (CFAbsoluteTime)statBuf.st_mtime;
#elif DEPLOYMENT_TARGET_LINUX
#if defined _BSD_SOURCE || defined _SVID_SOURCE
CFAbsoluteTime theTime = (CFAbsoluteTime)statBuf.st_mtim.tv_sec - kCFAbsoluteTimeIntervalSince1970;
theTime += (CFAbsoluteTime)statBuf.st_mtim.tv_nsec / 1000000000.0;
#else
CFAbsoluteTime theTime = (CFAbsoluteTime)statBuf.st_mtime - kCFAbsoluteTimeIntervalSince1970;
theTime += (CFAbsoluteTime)statBuf.st_mtimensec / 1000000000.0;
#endif /* defined _BSD_SOURCE || defined _SVID_SOURCE */
#else
CFAbsoluteTime theTime = (CFAbsoluteTime)statBuf.st_mtimespec.tv_sec - kCFAbsoluteTimeIntervalSince1970;
theTime += (CFAbsoluteTime)statBuf.st_mtimespec.tv_nsec / 1000000000.0;
#endif
*modTime = CFDateCreate(alloc, theTime);
} else {
*modTime = NULL;
}
}
if (ownerID != NULL) {
if (fileExists) {
*ownerID = statBuf.st_uid;
} else {
*ownerID = -1;
}
}
if (dirContents != NULL) {
if (fileExists && isDirectory) {
CFMutableArrayRef contents = _CFContentsOfDirectory(alloc, path, NULL, pathURL, NULL);
if (contents) {
*dirContents = contents;
} else {
*dirContents = NULL;
}
} else {
*dirContents = NULL;
}
}
return 0;
}
// MF:!!! Should pull in the rest of the UniChar based path utils from Foundation.
#if (DEPLOYMENT_TARGET_MACOSX) || defined(__svr4__) || defined(__hpux__) || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
#define UNIX_PATH_SEMANTICS
#elif DEPLOYMENT_TARGET_WINDOWS
#define WINDOWS_PATH_SEMANTICS
#else
#error Unknown platform
#endif
#if defined(WINDOWS_PATH_SEMANTICS)
#define CFPreferredSlash ((UniChar)'\\')
#elif defined(UNIX_PATH_SEMANTICS)
#define CFPreferredSlash ((UniChar)'/')
#elif defined(HFS_PATH_SEMANTICS)
#define CFPreferredSlash ((UniChar)':')
#else
#error Cannot define NSPreferredSlash on this platform
#endif
#if defined(HFS_PATH_SEMANTICS)
#define HAS_DRIVE(S) (false)
#define HAS_NET(S) (false)
#else
#define HAS_DRIVE(S) ((S)[1] == ':' && (('A' <= (S)[0] && (S)[0] <= 'Z') || ('a' <= (S)[0] && (S)[0] <= 'z')))
#define HAS_NET(S) ((S)[0] == '\\' && (S)[1] == '\\')
#endif
#if defined(WINDOWS_PATH_SEMANTICS)
#define IS_SLASH(C) ((C) == '\\' || (C) == '/')
#elif defined(UNIX_PATH_SEMANTICS)
#define IS_SLASH(C) ((C) == '/')
#elif defined(HFS_PATH_SEMANTICS)
#define IS_SLASH(C) ((C) == ':')
#endif
__private_extern__ Boolean _CFIsAbsolutePath(UniChar *unichars, CFIndex length) {
if (length < 1) {
return false;
}
#if defined(WINDOWS_PATH_SEMANTICS)
if (unichars[0] == '~') {
return true;
}
if (length < 2) {
return false;
}
if (HAS_NET(unichars)) {
return true;
}
if (length < 3) {
return false;
}
if (IS_SLASH(unichars[2]) && HAS_DRIVE(unichars)) {
return true;
}
#elif defined(HFS_PATH_SEMANTICS)
return !IS_SLASH(unichars[0]);
#else
if (unichars[0] == '~') {
return true;
}
if (IS_SLASH(unichars[0])) {
return true;
}
#endif
return false;
}
__private_extern__ Boolean _CFStripTrailingPathSlashes(UniChar *unichars, CFIndex *length) {
Boolean destHasDrive = (1 < *length) && HAS_DRIVE(unichars);
CFIndex oldLength = *length;
while (((destHasDrive && 3 < *length) || (!destHasDrive && 1 < *length)) && IS_SLASH(unichars[*length - 1])) {
(*length)--;
}
return (oldLength != *length);
}
__private_extern__ Boolean _CFAppendPathComponent(UniChar *unichars, CFIndex *length, CFIndex maxLength, UniChar *component, CFIndex componentLength) {
if (0 == componentLength) {
return true;
}
if (maxLength < *length + 1 + componentLength) {
return false;
}
switch (*length) {
case 0:
break;
case 1:
if (!IS_SLASH(unichars[0])) {
unichars[(*length)++] = CFPreferredSlash;
}
break;
case 2:
if (!HAS_DRIVE(unichars) && !HAS_NET(unichars)) {
unichars[(*length)++] = CFPreferredSlash;
}
break;
default:
unichars[(*length)++] = CFPreferredSlash;
break;
}
memmove(unichars + *length, component, componentLength * sizeof(UniChar));
*length += componentLength;
return true;
}
__private_extern__ Boolean _CFAppendPathExtension(UniChar *unichars, CFIndex *length, CFIndex maxLength, UniChar *extension, CFIndex extensionLength) {
if (maxLength < *length + 1 + extensionLength) {
return false;
}
if ((0 < extensionLength && IS_SLASH(extension[0])) || (1 < extensionLength && HAS_DRIVE(extension))) {
return false;
}
_CFStripTrailingPathSlashes(unichars, length);
switch (*length) {
case 0:
return false;
case 1:
if (IS_SLASH(unichars[0]) || unichars[0] == '~') {
return false;
}
break;
case 2:
if (HAS_DRIVE(unichars) || HAS_NET(unichars)) {
return false;
}
break;
case 3:
if (IS_SLASH(unichars[2]) && HAS_DRIVE(unichars)) {
return false;
}
break;
}
if (0 < *length && unichars[0] == '~') {
CFIndex idx;
Boolean hasSlash = false;
for (idx = 1; idx < *length; idx++) {
if (IS_SLASH(unichars[idx])) {
hasSlash = true;
break;
}
}
if (!hasSlash) {
return false;
}
}
unichars[(*length)++] = '.';
memmove(unichars + *length, extension, extensionLength * sizeof(UniChar));
*length += extensionLength;
return true;
}
__private_extern__ Boolean _CFTransmutePathSlashes(UniChar *unichars, CFIndex *length, UniChar replSlash) {
CFIndex didx, sidx, scnt = *length;
sidx = (1 < *length && HAS_NET(unichars)) ? 2 : 0;
didx = sidx;
while (sidx < scnt) {
if (IS_SLASH(unichars[sidx])) {
unichars[didx++] = replSlash;
for (sidx++; sidx < scnt && IS_SLASH(unichars[sidx]); sidx++);
} else {
unichars[didx++] = unichars[sidx++];
}
}
*length = didx;
return (scnt != didx);
}
__private_extern__ CFIndex _CFStartOfLastPathComponent(UniChar *unichars, CFIndex length) {
CFIndex idx;
if (length < 2) {
return 0;
}
for (idx = length - 1; idx; idx--) {
if (IS_SLASH(unichars[idx - 1])) {
return idx;
}
}
if ((2 < length) && HAS_DRIVE(unichars)) {
return 2;
}
return 0;
}
__private_extern__ CFIndex _CFLengthAfterDeletingLastPathComponent(UniChar *unichars, CFIndex length) {
CFIndex idx;
if (length < 2) {
return 0;
}
for (idx = length - 1; idx; idx--) {
if (IS_SLASH(unichars[idx - 1])) {
if ((idx != 1) && (!HAS_DRIVE(unichars) || idx != 3)) {
return idx - 1;
}
return idx;
}
}
if ((2 < length) && HAS_DRIVE(unichars)) {
return 2;
}
return 0;
}
__private_extern__ CFIndex _CFStartOfPathExtension(UniChar *unichars, CFIndex length) {
CFIndex idx;
if (length < 2) {
return 0;
}
for (idx = length - 1; idx; idx--) {
if (IS_SLASH(unichars[idx - 1])) {
return 0;
}
if (unichars[idx] != '.') {
continue;
}
if (idx == 2 && HAS_DRIVE(unichars)) {
return 0;
}
return idx;
}
return 0;
}
__private_extern__ CFIndex _CFLengthAfterDeletingPathExtension(UniChar *unichars, CFIndex length) {
CFIndex start = _CFStartOfPathExtension(unichars, length);
return ((0 < start) ? start : length);
}
#undef CF_OPENFLGS
#undef UNIX_PATH_SEMANTICS
#undef WINDOWS_PATH_SEMANTICS
#undef HFS_PATH_SEMANTICS
#undef CFPreferredSlash
#undef HAS_DRIVE
#undef HAS_NET
#undef IS_SLASH