mirror of
https://github.com/reactos/reactos.git
synced 2024-09-09 20:30:04 +00:00
461 lines
10 KiB
C
461 lines
10 KiB
C
/* $Id: path.c,v 1.2 2002/02/20 09:17:57 hyperion Exp $
|
|
*/
|
|
/*
|
|
* COPYRIGHT: See COPYING in the top level directory
|
|
* PROJECT: ReactOS POSIX+ Subsystem
|
|
* FILE: subsys/psx/lib/psxdll/misc/path.c
|
|
* PURPOSE: POSIX subsystem path utilities
|
|
* PROGRAMMER: KJK::Hyperion <noog@libero.it>
|
|
* UPDATE HISTORY:
|
|
* 31/01/2002: Created
|
|
*/
|
|
|
|
#include <ddk/ntddk.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <psx/stdlib.h>
|
|
#include <psx/pdata.h>
|
|
#include <psx/path.h>
|
|
|
|
BOOLEAN
|
|
__PdxPosixPathGetNextComponent_U
|
|
(
|
|
IN UNICODE_STRING PathName,
|
|
IN OUT PUNICODE_STRING PathComponent,
|
|
OUT PBOOLEAN TrailingDelimiter OPTIONAL
|
|
)
|
|
{
|
|
int i, j;
|
|
USHORT l = PathName.Length / sizeof(WCHAR);
|
|
|
|
if(PathComponent->Buffer == 0)
|
|
i = 0;
|
|
else
|
|
i = ((ULONG)PathComponent->Buffer - (ULONG)PathName.Buffer + PathComponent->Length) / sizeof(WCHAR);
|
|
|
|
/* skip leading empty components */
|
|
while(1)
|
|
if(i >= l)
|
|
{
|
|
PathComponent->Length = PathComponent->MaximumLength = 0;
|
|
return (FALSE);
|
|
}
|
|
else if(IS_CHAR_DELIMITER_U(PathName.Buffer[i]))
|
|
i ++;
|
|
else
|
|
break;
|
|
|
|
if(i > l)
|
|
{
|
|
PathComponent->Length = PathComponent->MaximumLength = 0;
|
|
return (FALSE);
|
|
}
|
|
|
|
PathComponent->Buffer = &PathName.Buffer[i];
|
|
|
|
j = i + 1;
|
|
|
|
/* advance until the end of the string, or the next delimiter */
|
|
while(1)
|
|
{
|
|
if(j >= l)
|
|
{
|
|
|
|
if(TrailingDelimiter != 0)
|
|
*TrailingDelimiter = FALSE;
|
|
|
|
break;
|
|
}
|
|
else if (IS_CHAR_DELIMITER_U(PathName.Buffer[j]))
|
|
{
|
|
|
|
if(TrailingDelimiter != 0)
|
|
*TrailingDelimiter = TRUE;
|
|
|
|
break;
|
|
}
|
|
else
|
|
j ++;
|
|
}
|
|
|
|
PathComponent->Length = PathComponent->MaximumLength = (j - i) * sizeof(WCHAR);
|
|
|
|
return (TRUE);
|
|
|
|
}
|
|
|
|
BOOLEAN
|
|
__PdxPosixPathResolve_U
|
|
(
|
|
IN UNICODE_STRING PathName,
|
|
OUT PUNICODE_STRING ResolvedPathName,
|
|
IN WCHAR PathDelimiter OPTIONAL
|
|
)
|
|
{
|
|
UNICODE_STRING wstrThisComponent = {0, 0, NULL};
|
|
PWCHAR pwcCurPos;
|
|
PWCHAR pwcStartPos;
|
|
BOOLEAN bIsDirectory;
|
|
|
|
if(PathDelimiter == 0)
|
|
PathDelimiter = L'/';
|
|
|
|
/* start from the beginning of the return buffer */
|
|
pwcCurPos = ResolvedPathName->Buffer;
|
|
|
|
/* path begins with a delimiter (absolute path) */
|
|
if(IS_CHAR_DELIMITER_U(PathName.Buffer[0]))
|
|
{
|
|
/* put a delimiter in front of the return buffer */
|
|
*pwcCurPos = PathDelimiter;
|
|
/* move to next character */
|
|
pwcCurPos ++;
|
|
}
|
|
|
|
pwcStartPos = pwcCurPos;
|
|
|
|
/* repeat until the end of the path string */
|
|
while(__PdxPosixPathGetNextComponent_U(PathName, &wstrThisComponent, &bIsDirectory))
|
|
{
|
|
/* ".": skip */
|
|
if(IS_COMPONENT_DOT_U(wstrThisComponent))
|
|
continue;
|
|
/* "..": go back to the last component */
|
|
else if(IS_COMPONENT_DOTDOT_U(wstrThisComponent))
|
|
{
|
|
if(pwcCurPos == pwcStartPos)
|
|
continue;
|
|
|
|
/* skip the last (undefined) character */
|
|
pwcCurPos --;
|
|
/* down to the previous path delimiter */
|
|
do{ pwcCurPos --; }while(!IS_CHAR_DELIMITER_U(*pwcCurPos));
|
|
/* include the delimiter */
|
|
pwcCurPos ++;
|
|
}
|
|
else
|
|
{
|
|
/* copy this component into the return string */
|
|
memcpy
|
|
(
|
|
pwcCurPos,
|
|
wstrThisComponent.Buffer,
|
|
wstrThisComponent.Length
|
|
);
|
|
|
|
/* move the current position to the end of the string */
|
|
pwcCurPos = (PWCHAR)((PBYTE)pwcCurPos + wstrThisComponent.Length);
|
|
|
|
/* component had a trailing delimiter */
|
|
if(bIsDirectory)
|
|
{
|
|
/* append a delimiter */
|
|
*pwcCurPos = PathDelimiter;
|
|
/* on to next character */
|
|
pwcCurPos ++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* set the return string's length as the byte offset between the initial buffer
|
|
position and the current position */
|
|
ResolvedPathName->Length = ((ULONG)pwcCurPos - (ULONG)ResolvedPathName->Buffer);
|
|
|
|
return (TRUE);
|
|
|
|
}
|
|
|
|
BOOLEAN
|
|
__PdxPosixPathGetNextComponent_A
|
|
(
|
|
IN ANSI_STRING PathName,
|
|
IN OUT PANSI_STRING PathComponent,
|
|
OUT PBOOLEAN TrailingDelimiter OPTIONAL
|
|
)
|
|
{
|
|
int i, j;
|
|
|
|
if(PathComponent->Buffer == 0)
|
|
i = 0;
|
|
else
|
|
i = ((ULONG)PathComponent->Buffer - (ULONG)PathName.Buffer + PathComponent->Length);
|
|
|
|
/* skip leading empty components */
|
|
while(1)
|
|
if(i >= PathName.Length)
|
|
{
|
|
PathComponent->Length = PathComponent->MaximumLength = 0;
|
|
return (FALSE);
|
|
}
|
|
else if(IS_CHAR_DELIMITER_A(PathName.Buffer[i]))
|
|
i ++;
|
|
else
|
|
break;
|
|
|
|
if(i > PathName.Length)
|
|
{
|
|
PathComponent->Length = PathComponent->MaximumLength = 0;
|
|
return (FALSE);
|
|
}
|
|
|
|
PathComponent->Buffer = &PathName.Buffer[i];
|
|
|
|
j = i + 1;
|
|
|
|
/* advance until the end of the string, or the next delimiter */
|
|
while(1)
|
|
{
|
|
if(j >= PathName.Length)
|
|
{
|
|
|
|
if(TrailingDelimiter != 0)
|
|
*TrailingDelimiter = FALSE;
|
|
|
|
break;
|
|
}
|
|
else if (IS_CHAR_DELIMITER_A(PathName.Buffer[j]))
|
|
{
|
|
|
|
if(TrailingDelimiter != 0)
|
|
*TrailingDelimiter = TRUE;
|
|
|
|
break;
|
|
}
|
|
else
|
|
j ++;
|
|
}
|
|
|
|
PathComponent->Length = PathComponent->MaximumLength = j - i;
|
|
|
|
return (TRUE);
|
|
|
|
}
|
|
|
|
BOOLEAN
|
|
__PdxPosixPathResolve_A
|
|
(
|
|
IN ANSI_STRING PathName,
|
|
OUT PANSI_STRING ResolvedPathName,
|
|
IN CHAR PathDelimiter OPTIONAL
|
|
)
|
|
{
|
|
ANSI_STRING strThisComponent = {0, 0, NULL};
|
|
PCHAR pcCurPos;
|
|
PCHAR pcStartPos;
|
|
BOOLEAN bIsDirectory;
|
|
|
|
if(PathDelimiter == 0)
|
|
PathDelimiter = '/';
|
|
|
|
/* start from the beginning of the return buffer */
|
|
pcCurPos = ResolvedPathName->Buffer;
|
|
|
|
/* path begins with a delimiter (absolute path) */
|
|
if(IS_CHAR_DELIMITER_A(PathName.Buffer[0]))
|
|
{
|
|
/* put a delimiter in front of the return buffer */
|
|
*pcCurPos = PathDelimiter;
|
|
/* move to next character */
|
|
pcCurPos ++;
|
|
}
|
|
|
|
pcStartPos = pcCurPos;
|
|
|
|
/* repeat until the end of the path string */
|
|
while(__PdxPosixPathGetNextComponent_A(PathName, &strThisComponent, &bIsDirectory))
|
|
{
|
|
/* ".": skip */
|
|
if(IS_COMPONENT_DOT_A(strThisComponent))
|
|
continue;
|
|
/* "..": go back to the last component */
|
|
else if(IS_COMPONENT_DOTDOT_A(strThisComponent))
|
|
{
|
|
if(pcCurPos == pcStartPos)
|
|
continue;
|
|
|
|
/* skip the last (undefined) character */
|
|
pcCurPos --;
|
|
/* down to the previous path delimiter */
|
|
do{ pcCurPos --; }while(!IS_CHAR_DELIMITER_A(*pcCurPos));
|
|
/* include the delimiter */
|
|
pcCurPos ++;
|
|
}
|
|
else
|
|
{
|
|
/* copy this component into the return string */
|
|
strncpy
|
|
(
|
|
pcCurPos,
|
|
strThisComponent.Buffer,
|
|
strThisComponent.Length
|
|
);
|
|
|
|
/* move the current position to the end of the string */
|
|
pcCurPos = (PCHAR)((PBYTE)pcCurPos + strThisComponent.Length);
|
|
|
|
/* component had a trailing delimiter */
|
|
if(bIsDirectory)
|
|
{
|
|
/* append a delimiter */
|
|
*pcCurPos = PathDelimiter;
|
|
/* on to next character */
|
|
pcCurPos ++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* set the return string's length as the byte offset between the initial buffer
|
|
position and the current position */
|
|
ResolvedPathName->Length = ((ULONG)pcCurPos - (ULONG)ResolvedPathName->Buffer);
|
|
|
|
return (TRUE);
|
|
|
|
}
|
|
|
|
BOOLEAN
|
|
__PdxPosixPathNameToNtPathName
|
|
(
|
|
IN PWCHAR PosixPath,
|
|
OUT PUNICODE_STRING NativePath,
|
|
IN PUNICODE_STRING CurDir OPTIONAL,
|
|
IN PUNICODE_STRING RootDir OPTIONAL
|
|
)
|
|
{
|
|
UNICODE_STRING wstrPosixPath;
|
|
UNICODE_STRING wstrTempString;
|
|
|
|
/* parameter validation */
|
|
if
|
|
(
|
|
PosixPath == 0 ||
|
|
NativePath == 0 ||
|
|
NativePath->Buffer == 0 ||
|
|
NativePath->MaximumLength == 0 ||
|
|
(RootDir != 0 && RootDir->Buffer == 0)
|
|
)
|
|
{
|
|
errno = EINVAL;
|
|
return (FALSE);
|
|
}
|
|
|
|
RtlInitUnicodeString(&wstrPosixPath, PosixPath);
|
|
|
|
/* path is null */
|
|
if(0 == wstrPosixPath.Length)
|
|
{
|
|
errno = EINVAL;
|
|
return (FALSE);
|
|
}
|
|
|
|
/* first, copy the root path into the return buffer */
|
|
/* if no root dir passed by the caller... */
|
|
if(RootDir == 0)
|
|
/* return buffer too small */
|
|
if(NativePath->MaximumLength < sizeof(WCHAR))
|
|
{
|
|
errno = ENOBUFS;
|
|
return (FALSE);
|
|
}
|
|
/* set the first character to a backslash, and set length accordingly */
|
|
else
|
|
{
|
|
NativePath->Buffer[0] = L'\\';
|
|
NativePath->Length = sizeof(WCHAR);
|
|
}
|
|
/* ... else copy the root dir into the return buffer */
|
|
else
|
|
/* return buffer too small */
|
|
if(NativePath->MaximumLength < RootDir->Length)
|
|
{
|
|
errno = ENOBUFS;
|
|
return (FALSE);
|
|
}
|
|
/* copy the root directory into the return buffer, and set length */
|
|
else
|
|
{
|
|
memcpy(NativePath->Buffer, RootDir->Buffer, RootDir->Length);
|
|
NativePath->Length = RootDir->Length;
|
|
}
|
|
|
|
/* path is "/" - our work is done */
|
|
if(sizeof(WCHAR) == wstrPosixPath.Length && IS_CHAR_DELIMITER_U(wstrPosixPath.Buffer[0]))
|
|
return (TRUE);
|
|
|
|
/* temp string pointing to the tail of the return buffer */
|
|
wstrTempString.Length = 0;
|
|
wstrTempString.MaximumLength = NativePath->MaximumLength - NativePath->Length;
|
|
wstrTempString.Buffer = (PWCHAR)(((PBYTE)(NativePath->Buffer)) + NativePath->Length);
|
|
|
|
/* path begins with '/': absolute path. Append the resolved path to the return buffer */
|
|
if(IS_CHAR_DELIMITER_U(wstrPosixPath.Buffer[0]))
|
|
{
|
|
/* copy the resolved path in the return buffer */
|
|
__PdxPosixPathResolve_U(wstrPosixPath, &wstrTempString, L'\\');
|
|
|
|
return (TRUE);
|
|
}
|
|
else
|
|
{
|
|
UNICODE_STRING wstrAbsolutePath;
|
|
|
|
if(CurDir == 0)
|
|
CurDir = __PdxGetCurDir();
|
|
|
|
/* initialize the buffer for the absolute path */
|
|
wstrAbsolutePath.Length = 0;
|
|
wstrAbsolutePath.MaximumLength = 0xFFFF;
|
|
wstrAbsolutePath.Buffer = __malloc(0xFFFF);
|
|
|
|
/* if the current directory is not null... */
|
|
if(!(CurDir->Buffer == 0 || CurDir->Length == 0))
|
|
{
|
|
/* copy it into the absolute path buffer */
|
|
memcpy(wstrAbsolutePath.Buffer, CurDir->Buffer, CurDir->Length);
|
|
wstrAbsolutePath.Length += CurDir->Length;
|
|
}
|
|
|
|
/* not enough space to append an extra slash */
|
|
if((wstrAbsolutePath.MaximumLength - wstrAbsolutePath.Length) < (USHORT)sizeof(WCHAR))
|
|
{
|
|
__free(wstrAbsolutePath.Buffer);
|
|
NativePath->Length = 0;
|
|
errno = ENOBUFS;
|
|
return (FALSE);
|
|
}
|
|
|
|
/* append an extra slash */
|
|
wstrAbsolutePath.Buffer[wstrAbsolutePath.Length / sizeof(WCHAR)] = L'/';
|
|
wstrAbsolutePath.Length += sizeof(WCHAR);
|
|
|
|
/* not enough space to copy the relative path */
|
|
if((wstrAbsolutePath.MaximumLength - wstrAbsolutePath.Length) < wstrPosixPath.Length)
|
|
{
|
|
__free(wstrAbsolutePath.Buffer);
|
|
NativePath->Length = 0;
|
|
errno = ENOBUFS;
|
|
return (FALSE);
|
|
}
|
|
|
|
/* append the relative path to the absolute path */
|
|
memcpy(
|
|
(PWCHAR)(((PBYTE)wstrAbsolutePath.Buffer) + wstrAbsolutePath.Length),
|
|
wstrPosixPath.Buffer,
|
|
wstrPosixPath.Length
|
|
);
|
|
wstrAbsolutePath.Length += wstrPosixPath.Length;
|
|
|
|
/* resolve the path */
|
|
__PdxPosixPathResolve_U(wstrAbsolutePath, &wstrTempString, L'\\');
|
|
|
|
__free(wstrAbsolutePath.Buffer);
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
|
|
}
|
|
|
|
/* EOF */
|
|
|