arcname.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
BOOLEAN	ArcPathNormalize (OUT PUNICODE_STRING NormalizedArcPath, IN PCWSTR ArcPath)
BOOLEAN	ArcPathToNtPath (OUT PUNICODE_STRING NtPath, IN PCWSTR ArcPath, IN PPARTLIST PartList OPTIONAL)

Function Documentation

ArcPathNormalize()

BOOLEAN ArcPathNormalize	(	OUT PUNICODE_STRING	NormalizedArcPath,
		IN PCWSTR	ArcPath
	)

Definition at line 312 of file arcname.c.

{
    NTSTATUS Status;
    PCWSTR EndOfArcName;
    PCWSTR p;
    SIZE_T PathLength;
 
    if (NormalizedArcPath->MaximumLength < sizeof(UNICODE_NULL))
        return FALSE;
 
    *NormalizedArcPath->Buffer = UNICODE_NULL;
    NormalizedArcPath->Length = 0;
 
    EndOfArcName = wcschr(ArcPath, OBJ_NAME_PATH_SEPARATOR);
    if (!EndOfArcName)
        EndOfArcName = ArcPath + wcslen(ArcPath);
 
    while ((p = wcsstr(ArcPath, L"()")) && (p < EndOfArcName))
    {
#if 0
        Status = RtlStringCbCopyNW(NormalizedArcPath->Buffer,
                                   NormalizedArcPath->MaximumLength,
                                   ArcPath, (p - ArcPath) * sizeof(WCHAR));
#else
        Status = RtlStringCbCatNW(NormalizedArcPath->Buffer,
                                  NormalizedArcPath->MaximumLength,
                                  ArcPath, (p - ArcPath) * sizeof(WCHAR));
#endif
        if (!NT_SUCCESS(Status))
            return FALSE;
 
        Status = RtlStringCbCatW(NormalizedArcPath->Buffer,
                                 NormalizedArcPath->MaximumLength,
                                 L"(0)");
        if (!NT_SUCCESS(Status))
            return FALSE;
#if 0
        NormalizedArcPath->Buffer += wcslen(NormalizedArcPath->Buffer);
#endif
        ArcPath = p + 2;
    }
 
    Status = RtlStringCbCatW(NormalizedArcPath->Buffer,
                             NormalizedArcPath->MaximumLength,
                             ArcPath);
    if (!NT_SUCCESS(Status))
        return FALSE;
 
    PathLength = wcslen(NormalizedArcPath->Buffer);
    if (PathLength > UNICODE_STRING_MAX_CHARS)
    {
        return FALSE;
    }
 
    NormalizedArcPath->Length = (USHORT)PathLength * sizeof(WCHAR);
    return TRUE;
}

Referenced by _tmain().

ArcPathToNtPath()

BOOLEAN ArcPathToNtPath	(	OUT PUNICODE_STRING	NtPath,
		IN PCWSTR	ArcPath,
		IN PPARTLIST PartList	OPTIONAL
	)

Definition at line 819 of file arcname.c.

{
    NTSTATUS Status;
    PCWSTR BeginOfPath;
    UNICODE_STRING ArcName;
    SIZE_T PathLength;
 
    /* TODO: We should "normalize" the path, i.e. expand all the xxx() into xxx(0) */
 
    if (NtPath->MaximumLength < sizeof(UNICODE_NULL))
        return FALSE;
 
    *NtPath->Buffer = UNICODE_NULL;
    NtPath->Length = 0;
 
    /*
     * - First, check whether the ARC path is already inside \\ArcName
     *   and if so, map it to the corresponding NT path.
     * - Only then, if we haven't found any ArcName, try to build a
     *   NT path by deconstructing the ARC path, using its disk and
     *   partition numbers. We may use here our disk/partition list.
     *
     * See also freeldr/arcname.c
     *
     * Note that it would be nice to maintain a cache of these mappings.
     */
 
    /*
     * Initialize the ARC name to resolve, by cutting the ARC path at the first
     * NT path separator. The ARC name therefore ends where the NT path part starts.
     */
    RtlInitUnicodeString(&ArcName, ArcPath);
    BeginOfPath = wcschr(ArcName.Buffer, OBJ_NAME_PATH_SEPARATOR);
    if (BeginOfPath)
        ArcName.Length = (ULONG_PTR)BeginOfPath - (ULONG_PTR)ArcName.Buffer;
 
    /* Resolve the ARC name via NT SymLinks. Note that NtPath is returned NULL-terminated. */
    Status = ResolveArcNameNtSymLink(NtPath, &ArcName);
    if (!NT_SUCCESS(Status))
    {
        /* We failed, attempt a manual resolution */
        DPRINT1("ResolveArcNameNtSymLink(ArcName = '%wZ') for ArcPath = '%S' failed, Status 0x%08lx\n", &ArcName, ArcPath, Status);
 
        /*
         * We failed at directly resolving the ARC path, and we cannot perform
         * a manual resolution because we don't have any disk/partition list,
         * we therefore fail here.
         */
        if (!PartList)
        {
            DPRINT1("PartList == NULL, cannot perform a manual resolution\n");
            return FALSE;
        }
 
        *NtPath->Buffer = UNICODE_NULL;
        NtPath->Length = 0;
 
        BeginOfPath = ArcPath;
        Status = ResolveArcNameManually(NtPath, &BeginOfPath, PartList);
        if (!NT_SUCCESS(Status))
        {
            /* We really failed this time, bail out */
            DPRINT1("ResolveArcNameManually(ArcPath = '%S') failed, Status 0x%08lx\n", ArcPath, Status);
            return FALSE;
        }
    }
 
    /*
     * We succeeded. Concatenate the rest of the system-specific path. We know the path is going
     * to be inside the NT namespace, therefore we can use the path string concatenation function
     * that uses '\\' as the path separator.
     */
    if (BeginOfPath && *BeginOfPath)
    {
        Status = ConcatPaths(NtPath->Buffer, NtPath->MaximumLength / sizeof(WCHAR), 1, BeginOfPath);
        if (!NT_SUCCESS(Status))
        {
            /* Buffer not large enough, or whatever...: just bail out */
            return FALSE;
        }
    }
 
    PathLength = wcslen(NtPath->Buffer);
    if (PathLength > UNICODE_STRING_MAX_CHARS)
    {
        return FALSE;
    }
 
    NtPath->Length = (USHORT)PathLength * sizeof(WCHAR);
 
    return TRUE;
}

Referenced by _tmain(), and EnumerateInstallations().