arcname.c File Reference

#include "precomp.h"
#include "filesup.h"
#include "partlist.h"
#include "arcname.h"
#include <debug.h>

Include dependency graph for arcname.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Typedefs
typedef enum _ADAPTER_TYPE	ADAPTER_TYPE
typedef enum _ADAPTER_TYPE *	PADAPTER_TYPE
typedef enum _CONTROLLER_TYPE	CONTROLLER_TYPE
typedef enum _CONTROLLER_TYPE *	PCONTROLLER_TYPE
typedef enum _PERIPHERAL_TYPE	PERIPHERAL_TYPE
typedef enum _PERIPHERAL_TYPE *	PPERIPHERAL_TYPE

Enumerations
enum	_ADAPTER_TYPE {   EisaAdapter , ScsiAdapter , MultiAdapter , NetAdapter ,   RamdiskAdapter , AdapterTypeMax }
enum	_CONTROLLER_TYPE { DiskController , CdRomController , ControllerTypeMax }
enum	_PERIPHERAL_TYPE { RDiskPeripheral , FDiskPeripheral , CdRomPeripheral , PeripheralTypeMax }

Functions
PCSTR	ArcGetNextTokenA (IN PCSTR ArcPath, OUT PANSI_STRING TokenSpecifier, OUT PULONG Key)
static PCWSTR	ArcGetNextTokenU (IN PCWSTR ArcPath, OUT PUNICODE_STRING TokenSpecifier, OUT PULONG Key)
ULONG	ArcMatchTokenA (IN PCSTR CandidateToken, IN const PCSTR *TokenTable)
ULONG	ArcMatchTokenU (IN PCWSTR CandidateToken, IN const PCWSTR *TokenTable)
static ULONG	ArcMatchToken_UStr (IN PCUNICODE_STRING CandidateToken, IN const PCWSTR *TokenTable)
BOOLEAN	ArcPathNormalize (OUT PUNICODE_STRING NormalizedArcPath, IN PCWSTR ArcPath)
static NTSTATUS	ParseArcName (IN OUT PCWSTR *ArcNamePath, OUT PULONG pAdapterKey, OUT PULONG pControllerKey, OUT PULONG pPeripheralKey, OUT PULONG pPartitionNumber, OUT PADAPTER_TYPE pAdapterType, OUT PCONTROLLER_TYPE pControllerType, OUT PPERIPHERAL_TYPE pPeripheralType, OUT PBOOLEAN pUseSignature)
static NTSTATUS	ResolveArcNameNtSymLink (OUT PUNICODE_STRING NtName, IN PUNICODE_STRING ArcName)
static NTSTATUS	ResolveArcNameManually (OUT PUNICODE_STRING NtName, IN OUT PCWSTR *ArcNamePath, IN PPARTLIST PartList)
BOOLEAN	ArcPathToNtPath (OUT PUNICODE_STRING NtPath, IN PCWSTR ArcPath, IN PPARTLIST PartList OPTIONAL)

Variables
const PCSTR	AdapterTypes_A []
const PCWSTR	AdapterTypes_U []
const PCSTR	ControllerTypes_A []
const PCWSTR	ControllerTypes_U []
const PCSTR	PeripheralTypes_A []
const PCWSTR	PeripheralTypes_U []

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 30 of file arcname.c.

Typedef Documentation

ADAPTER_TYPE

typedef enum _ADAPTER_TYPE ADAPTER_TYPE

CONTROLLER_TYPE

typedef enum _CONTROLLER_TYPE CONTROLLER_TYPE

PADAPTER_TYPE

typedef enum _ADAPTER_TYPE * PADAPTER_TYPE

PCONTROLLER_TYPE

typedef enum _CONTROLLER_TYPE * PCONTROLLER_TYPE

PERIPHERAL_TYPE

typedef enum _PERIPHERAL_TYPE PERIPHERAL_TYPE

PPERIPHERAL_TYPE

typedef enum _PERIPHERAL_TYPE * PPERIPHERAL_TYPE

Enumeration Type Documentation

_ADAPTER_TYPE

enum _ADAPTER_TYPE

Enumerator
EisaAdapter
ScsiAdapter
MultiAdapter
NetAdapter
RamdiskAdapter
AdapterTypeMax

Definition at line 37 of file arcname.c.

{
    EisaAdapter,
    ScsiAdapter,
    MultiAdapter,
    NetAdapter,
    RamdiskAdapter,
    AdapterTypeMax
} ADAPTER_TYPE, *PADAPTER_TYPE;

_CONTROLLER_TYPE

enum _CONTROLLER_TYPE

Enumerator
DiskController
CdRomController
ControllerTypeMax

Definition at line 66 of file arcname.c.

{
    DiskController,
    CdRomController,
    ControllerTypeMax
} CONTROLLER_TYPE, *PCONTROLLER_TYPE;

_PERIPHERAL_TYPE

enum _PERIPHERAL_TYPE

Enumerator
RDiskPeripheral
FDiskPeripheral
CdRomPeripheral
PeripheralTypeMax

Definition at line 86 of file arcname.c.

{
//  VDiskPeripheral,
    RDiskPeripheral,
    FDiskPeripheral,
    CdRomPeripheral,
    PeripheralTypeMax
} PERIPHERAL_TYPE, *PPERIPHERAL_TYPE;

Function Documentation

ArcGetNextTokenA()

PCSTR ArcGetNextTokenA	(	IN PCSTR	ArcPath,
		OUT PANSI_STRING	TokenSpecifier,
		OUT PULONG	Key
	)

Definition at line 115 of file arcname.c.

{
    NTSTATUS Status;
    PCSTR p = ArcPath;
    SIZE_T SpecifierLength;
    ULONG KeyValue;
 
    /*
     * We must have a valid "specifier(key)" string, where 'specifier'
     * cannot be the empty string, and is followed by '('.
     */
    p = strchr(p, '(');
    if (p == NULL)
        return NULL; /* No '(' found */
    if (p == ArcPath)
        return NULL; /* Path starts with '(' and is thus invalid */
 
    SpecifierLength = (p - ArcPath) * sizeof(CHAR);
    if (SpecifierLength > MAXUSHORT)
    {
        return NULL;
    }
 
    /*
     * The strtoul function skips any leading whitespace.
     *
     * Note that if the token is "specifier()" then strtoul won't perform
     * any conversion and return 0, therefore effectively making the token
     * equivalent to "specifier(0)", as it should be.
     */
    // KeyValue = atoi(p);
    KeyValue = strtoul(p, (PSTR*)&p, 10);
 
    /* Skip any trailing whitespace */
    while (isspace(*p)) ++p;
 
    /* The token must terminate with ')' */
    if (*p != ')')
        return NULL;
#if 0
    p = strchr(p, ')');
    if (p == NULL)
        return NULL;
#endif
 
    /* We should have succeeded, copy the token specifier in the buffer */
    Status = RtlStringCbCopyNA(TokenSpecifier->Buffer,
                               TokenSpecifier->MaximumLength,
                               ArcPath, SpecifierLength);
    if (!NT_SUCCESS(Status))
        return NULL;
 
    TokenSpecifier->Length = (USHORT)SpecifierLength;
 
    /* We succeeded, return the token key value */
    *Key = KeyValue;
 
    /* Next token starts just after */
    return ++p;
}

ArcGetNextTokenU()

static PCWSTR ArcGetNextTokenU ( IN PCWSTR  ArcPath, OUT PUNICODE_STRING  TokenSpecifier, OUT PULONG  Key  )

static

Definition at line 180 of file arcname.c.

{
    NTSTATUS Status;
    PCWSTR p = ArcPath;
    SIZE_T SpecifierLength;
    ULONG KeyValue;
 
    /*
     * We must have a valid "specifier(key)" string, where 'specifier'
     * cannot be the empty string, and is followed by '('.
     */
    p = wcschr(p, L'(');
    if (p == NULL)
        return NULL; /* No '(' found */
    if (p == ArcPath)
        return NULL; /* Path starts with '(' and is thus invalid */
 
    SpecifierLength = (p - ArcPath) * sizeof(WCHAR);
    if (SpecifierLength > UNICODE_STRING_MAX_BYTES)
    {
        return NULL;
    }
 
    ++p;
 
    /*
     * The strtoul function skips any leading whitespace.
     *
     * Note that if the token is "specifier()" then strtoul won't perform
     * any conversion and return 0, therefore effectively making the token
     * equivalent to "specifier(0)", as it should be.
     */
    // KeyValue = _wtoi(p);
    KeyValue = wcstoul(p, (PWSTR*)&p, 10);
 
    /* Skip any trailing whitespace */
    while (iswspace(*p)) ++p;
 
    /* The token must terminate with ')' */
    if (*p != L')')
        return NULL;
#if 0
    p = wcschr(p, L')');
    if (p == NULL)
        return NULL;
#endif
 
    /* We should have succeeded, copy the token specifier in the buffer */
    Status = RtlStringCbCopyNW(TokenSpecifier->Buffer,
                               TokenSpecifier->MaximumLength,
                               ArcPath, SpecifierLength);
    if (!NT_SUCCESS(Status))
        return NULL;
 
    TokenSpecifier->Length = (USHORT)SpecifierLength;
 
    /* We succeeded, return the token key value */
    *Key = KeyValue;
 
    /* Next token starts just after */
    return ++p;
}

Referenced by ParseArcName().

ArcMatchToken_UStr()

static ULONG ArcMatchToken_UStr ( IN PCUNICODE_STRING  CandidateToken, IN const PCWSTR *  TokenTable  )

static

Definition at line 278 of file arcname.c.

{
    ULONG Index = 0;
#if 0
    SIZE_T Length;
#else
    UNICODE_STRING Token;
#endif
 
    while (TokenTable[Index])
    {
#if 0
        Length = wcslen(TokenTable[Index]);
        if ((Length == CandidateToken->Length / sizeof(WCHAR)) &&
            (_wcsnicmp(CandidateToken->Buffer, TokenTable[Index], Length) == 0))
        {
            break;
        }
#else
        RtlInitUnicodeString(&Token, TokenTable[Index]);
        if (RtlEqualUnicodeString(CandidateToken, &Token, TRUE))
            break;
#endif
 
        ++Index;
    }
 
    return Index;
}

Referenced by ParseArcName().

ArcMatchTokenA()

ULONG ArcMatchTokenA	(	IN PCSTR	CandidateToken,
		IN const PCSTR *	TokenTable
	)

Definition at line 248 of file arcname.c.

{
    ULONG Index = 0;
 
    while (TokenTable[Index] && _stricmp(CandidateToken, TokenTable[Index]) != 0)
    {
        ++Index;
    }
 
    return Index;
}

ArcMatchTokenU()

ULONG ArcMatchTokenU	(	IN PCWSTR	CandidateToken,
		IN const PCWSTR *	TokenTable
	)

Definition at line 263 of file arcname.c.

{
    ULONG Index = 0;
 
    while (TokenTable[Index] && _wcsicmp(CandidateToken, TokenTable[Index]) != 0)
    {
        ++Index;
    }
 
    return Index;
}

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().

ParseArcName()

static NTSTATUS ParseArcName ( IN OUT PCWSTR *  ArcNamePath, OUT PULONG  pAdapterKey, OUT PULONG  pControllerKey, OUT PULONG  pPeripheralKey, OUT PULONG  pPartitionNumber, OUT PADAPTER_TYPE  pAdapterType, OUT PCONTROLLER_TYPE  pControllerType, OUT PPERIPHERAL_TYPE  pPeripheralType, OUT PBOOLEAN  pUseSignature  )

static

Definition at line 381 of file arcname.c.

{
    // NTSTATUS Status;
    WCHAR TokenBuffer[50];
    UNICODE_STRING Token;
    PCWSTR p, q;
    ULONG AdapterKey = 0;
    ULONG ControllerKey = 0;
    ULONG PeripheralKey = 0;
    ULONG PartitionNumber = 0;
    ADAPTER_TYPE AdapterType = AdapterTypeMax;
    CONTROLLER_TYPE ControllerType = ControllerTypeMax;
    PERIPHERAL_TYPE PeripheralType = PeripheralTypeMax;
    BOOLEAN UseSignature = FALSE;
 
    /*
     * The format of ArcName is:
     *    adapter(www)[controller(xxx)peripheral(yyy)[partition(zzz)][filepath]] ,
     * where the [filepath] part is not being parsed.
     */
 
    RtlInitEmptyUnicodeString(&Token, TokenBuffer, sizeof(TokenBuffer));
 
    p = *ArcNamePath;
 
    /* Retrieve the adapter */
    p = ArcGetNextTokenU(p, &Token, &AdapterKey);
    if (!p)
    {
        DPRINT1("No adapter specified!\n");
        return STATUS_OBJECT_PATH_SYNTAX_BAD;
    }
 
    /* Check for the 'signature()' pseudo-adapter, introduced in Windows 2000 */
    if (_wcsicmp(Token.Buffer, L"signature") == 0)
    {
        /*
         * We've got a signature! Remember this for later, and set the adapter type to SCSI.
         * We however check that the rest of the ARC path is valid by parsing the other tokens.
         * AdapterKey stores the disk signature value (that holds in a ULONG).
         */
        UseSignature = TRUE;
        AdapterType = ScsiAdapter;
    }
    else
    {
        /* Check for regular adapters */
        // ArcMatchTokenU(Token.Buffer, AdapterTypes_U);
        AdapterType = (ADAPTER_TYPE)ArcMatchToken_UStr(&Token, AdapterTypes_U);
        if (AdapterType >= AdapterTypeMax)
        {
            DPRINT1("Invalid adapter type %wZ\n", &Token);
            return STATUS_OBJECT_NAME_INVALID;
        }
 
        /* Check for adapters that don't take any extra controller or peripheral nodes */
        if (AdapterType == NetAdapter || AdapterType == RamdiskAdapter)
        {
            // if (*p)
            //     return STATUS_OBJECT_PATH_SYNTAX_BAD;
 
            if (AdapterType == NetAdapter)
            {
                DPRINT1("%S(%lu) path is not supported!\n", AdapterTypes_U[AdapterType], AdapterKey);
                return STATUS_NOT_SUPPORTED;
            }
 
            goto Quit;
        }
    }
 
    /* Here, we have either an 'eisa', a 'scsi/signature', or a 'multi' adapter */
 
    /* Check for a valid controller */
    p = ArcGetNextTokenU(p, &Token, &ControllerKey);
    if (!p)
    {
        DPRINT1("%S(%lu) adapter doesn't have a controller!\n", AdapterTypes_U[AdapterType], AdapterKey);
        return STATUS_OBJECT_PATH_SYNTAX_BAD;
    }
    // ArcMatchTokenU(Token.Buffer, ControllerTypes_U);
    ControllerType = (CONTROLLER_TYPE)ArcMatchToken_UStr(&Token, ControllerTypes_U);
    if (ControllerType >= ControllerTypeMax)
    {
        DPRINT1("Invalid controller type %wZ\n", &Token);
        return STATUS_OBJECT_NAME_INVALID;
    }
 
    /* Here the controller can only be either a disk or a CDROM */
 
    /*
     * Ignore the controller in case we have a 'multi' adapter.
     * I guess a similar condition holds for the 'eisa' adapter too...
     *
     * For SignatureAdapter, as similar for ScsiAdapter, the controller key corresponds
     * to the disk target ID. Note that actually, the implementation just ignores the
     * target ID, as well as the LUN, and just loops over all the available disks and
     * searches for the one having the correct signature.
     */
    if ((AdapterType == MultiAdapter /* || AdapterType == EisaAdapter */) && ControllerKey != 0)
    {
        DPRINT1("%S(%lu) adapter with %S(%lu non-zero), ignored!\n",
               AdapterTypes_U[AdapterType], AdapterKey,
               ControllerTypes_U[ControllerType], ControllerKey);
        ControllerKey = 0;
    }
 
    /*
     * Only the 'scsi' adapter supports a direct 'cdrom' controller.
     * For the others, we need a 'disk' controller to which a 'cdrom' peripheral can talk to.
     */
    if ((AdapterType != ScsiAdapter) && (ControllerType == CdRomController))
    {
        DPRINT1("%S(%lu) adapter cannot have a CDROM controller!\n", AdapterTypes_U[AdapterType], AdapterKey);
        return STATUS_OBJECT_PATH_INVALID;
    }
 
    /* Check for a valid peripheral */
    p = ArcGetNextTokenU(p, &Token, &PeripheralKey);
    if (!p)
    {
        DPRINT1("%S(%lu)%S(%lu) adapter-controller doesn't have a peripheral!\n",
               AdapterTypes_U[AdapterType], AdapterKey,
               ControllerTypes_U[ControllerType], ControllerKey);
        return STATUS_OBJECT_PATH_SYNTAX_BAD;
    }
    // ArcMatchTokenU(Token.Buffer, PeripheralTypes_U);
    PeripheralType = (PERIPHERAL_TYPE)ArcMatchToken_UStr(&Token, PeripheralTypes_U);
    if (PeripheralType >= PeripheralTypeMax)
    {
        DPRINT1("Invalid peripheral type %wZ\n", &Token);
        return STATUS_OBJECT_NAME_INVALID;
    }
 
    /*
     * If we had a 'cdrom' controller already, the corresponding peripheral can only be 'fdisk'
     * (see for example the ARC syntax for SCSI CD-ROMs: scsi(x)cdrom(y)fdisk(z) where z == 0).
     */
    if ((ControllerType == CdRomController) && (PeripheralType != FDiskPeripheral))
    {
        DPRINT1("%S(%lu) controller cannot have a %S(%lu) peripheral! (note that we haven't check whether the adapter was SCSI or not)\n",
               ControllerTypes_U[ControllerType], ControllerKey,
               PeripheralTypes_U[PeripheralType], PeripheralKey);
        return STATUS_OBJECT_PATH_INVALID;
    }
 
    /* For a 'scsi' adapter, the possible peripherals are only 'rdisk' or 'fdisk' */
    if (AdapterType == ScsiAdapter && !(PeripheralType == RDiskPeripheral || PeripheralType == FDiskPeripheral))
    {
        DPRINT1("%S(%lu)%S(%lu) SCSI adapter-controller has an invalid peripheral %S(%lu) !\n",
               AdapterTypes_U[AdapterType], AdapterKey,
               ControllerTypes_U[ControllerType], ControllerKey,
               PeripheralTypes_U[PeripheralType], PeripheralKey);
        return STATUS_OBJECT_PATH_INVALID;
    }
 
#if 0
    if (AdapterType == SignatureAdapter && PeripheralKey != 0)
    {
        DPRINT1("%S(%lu) adapter with %S(%lu non-zero), ignored!\n",
               AdapterTypes_U[AdapterType], AdapterKey,
               PeripheralTypes_U[PeripheralType], PeripheralKey);
        PeripheralKey = 0;
    }
#endif
 
    /* Check for the optional 'partition' specifier */
    q = ArcGetNextTokenU(p, &Token, &PartitionNumber);
    if (q && _wcsicmp(Token.Buffer, L"partition") == 0)
    {
        /* We've got a partition! */
        p = q;
    }
    else
    {
        /*
         * Either no other ARC token was found, or we've got something else
         * (possibly invalid or not)...
         */
        PartitionNumber = 0;
    }
 
    // TODO: Check the partition number in case of fdisks and cdroms??
 
Quit:
    /* Return the results */
    *ArcNamePath      = p;
    *pAdapterKey      = AdapterKey;
    *pControllerKey   = ControllerKey;
    *pPeripheralKey   = PeripheralKey;
    *pPartitionNumber = PartitionNumber;
    *pAdapterType     = AdapterType;
    *pControllerType  = ControllerType;
    *pPeripheralType  = PeripheralType;
    *pUseSignature    = UseSignature;
 
    return STATUS_SUCCESS;
}

Referenced by ResolveArcNameManually().

ResolveArcNameManually()

static NTSTATUS ResolveArcNameManually ( OUT PUNICODE_STRING  NtName, IN OUT PCWSTR *  ArcNamePath, IN PPARTLIST  PartList  )

static

Definition at line 689 of file arcname.c.

{
    NTSTATUS Status;
    ULONG AdapterKey;
    ULONG ControllerKey;
    ULONG PeripheralKey;
    ULONG PartitionNumber;
    ADAPTER_TYPE AdapterType;
    CONTROLLER_TYPE ControllerType;
    PERIPHERAL_TYPE PeripheralType;
    BOOLEAN UseSignature;
    SIZE_T NameLength;
 
    PDISKENTRY DiskEntry;
    PPARTENTRY PartEntry = NULL;
 
    if (NtName->MaximumLength < sizeof(UNICODE_NULL))
        return STATUS_BUFFER_TOO_SMALL;
 
    /* Parse the ARC path */
    Status = ParseArcName(ArcNamePath,
                          &AdapterKey,
                          &ControllerKey,
                          &PeripheralKey,
                          &PartitionNumber,
                          &AdapterType,
                          &ControllerType,
                          &PeripheralType,
                          &UseSignature);
    if (!NT_SUCCESS(Status))
        return Status;
 
    // TODO: Check the partition number in case of fdisks and cdroms??
 
    /* Check for adapters that don't take any extra controller or peripheral node */
    if (AdapterType == NetAdapter || AdapterType == RamdiskAdapter)
    {
        if (AdapterType == NetAdapter)
        {
            DPRINT1("%S(%lu) path is not supported!\n", AdapterTypes_U[AdapterType], AdapterKey);
            return STATUS_NOT_SUPPORTED;
        }
 
        Status = RtlStringCbPrintfW(NtName->Buffer, NtName->MaximumLength,
                                    L"\\Device\\Ramdisk%lu", AdapterKey);
    }
    else
    if (ControllerType == CdRomController) // and so, AdapterType == ScsiAdapter and PeripheralType == FDiskPeripheral
    {
        Status = RtlStringCbPrintfW(NtName->Buffer, NtName->MaximumLength,
                                    L"\\Device\\Scsi\\CdRom%lu", ControllerKey);
    }
    else
    /* Now, ControllerType == DiskController */
    if (PeripheralType == CdRomPeripheral)
    {
        Status = RtlStringCbPrintfW(NtName->Buffer, NtName->MaximumLength,
                                    L"\\Device\\CdRom%lu", PeripheralKey);
    }
    else
    if (PeripheralType == FDiskPeripheral)
    {
        Status = RtlStringCbPrintfW(NtName->Buffer, NtName->MaximumLength,
                                    L"\\Device\\Floppy%lu", PeripheralKey);
    }
    else
    if (PeripheralType == RDiskPeripheral)
    {
        if (UseSignature)
        {
            /* The disk signature is stored in AdapterKey */
            DiskEntry = GetDiskBySignature(PartList, AdapterKey);
        }
        else
        {
            DiskEntry = GetDiskBySCSI(PartList, AdapterKey,
                                      ControllerKey, PeripheralKey);
        }
        if (!DiskEntry)
            return STATUS_OBJECT_PATH_NOT_FOUND; // STATUS_NOT_FOUND;
 
        if (PartitionNumber != 0)
        {
            PartEntry = GetPartition(DiskEntry, PartitionNumber);
            if (!PartEntry)
                return STATUS_OBJECT_PATH_NOT_FOUND; // STATUS_DEVICE_NOT_PARTITIONED;
            ASSERT(PartEntry->DiskEntry == DiskEntry);
        }
 
        Status = RtlStringCbPrintfW(NtName->Buffer, NtName->MaximumLength,
                                    L"\\Device\\Harddisk%lu\\Partition%lu",
                                    DiskEntry->DiskNumber, PartitionNumber);
    }
#if 0 // FIXME: Not implemented yet!
    else
    if (PeripheralType == VDiskPeripheral)
    {
        // TODO: Check how Win 7+ deals with virtual disks.
        Status = RtlStringCbPrintfW(NtName->Buffer, NtName->MaximumLength,
                                    L"\\Device\\VirtualHarddisk%lu\\Partition%lu",
                                    PeripheralKey, PartitionNumber);
    }
#endif
 
    if (!NT_SUCCESS(Status))
    {
        /* Returned NtName is invalid, so zero it out */
        *NtName->Buffer = UNICODE_NULL;
        NtName->Length = 0;
 
        return Status;
    }
 
    /* Update NtName length */
    NameLength = wcslen(NtName->Buffer);
    if (NameLength > UNICODE_STRING_MAX_CHARS)
    {
        return STATUS_NAME_TOO_LONG;
    }
 
    NtName->Length = (USHORT)NameLength * sizeof(WCHAR);
 
    return STATUS_SUCCESS;
}

Referenced by ArcPathToNtPath().

ResolveArcNameNtSymLink()

static NTSTATUS ResolveArcNameNtSymLink ( OUT PUNICODE_STRING  NtName, IN PUNICODE_STRING  ArcName  )

static

Definition at line 599 of file arcname.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE DirectoryHandle, LinkHandle;
    UNICODE_STRING ArcNameDir;
 
    if (NtName->MaximumLength < sizeof(UNICODE_NULL))
        return STATUS_BUFFER_TOO_SMALL;
 
    /* Open the \ArcName object directory */
    RtlInitUnicodeString(&ArcNameDir, L"\\ArcName");
    InitializeObjectAttributes(&ObjectAttributes,
                               &ArcNameDir,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    Status = NtOpenDirectoryObject(&DirectoryHandle,
                                   DIRECTORY_ALL_ACCESS,
                                   &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtOpenDirectoryObject(%wZ) failed, Status 0x%08lx\n", &ArcNameDir, Status);
        return Status;
    }
 
    /* Open the ARC name link */
    InitializeObjectAttributes(&ObjectAttributes,
                               ArcName,
                               OBJ_CASE_INSENSITIVE,
                               DirectoryHandle,
                               NULL);
    Status = NtOpenSymbolicLinkObject(&LinkHandle,
                                      SYMBOLIC_LINK_QUERY,
                                      &ObjectAttributes);
 
    /* Close the \ArcName object directory handle */
    NtClose(DirectoryHandle);
 
    /* Check for success */
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("NtOpenSymbolicLinkObject(%wZ) failed, Status 0x%08lx\n", ArcName, Status);
        return Status;
    }
 
    /* Reserve one WCHAR for the NULL-termination */
    NtName->MaximumLength -= sizeof(UNICODE_NULL);
 
    /* Resolve the link and close its handle */
    Status = NtQuerySymbolicLinkObject(LinkHandle, NtName, NULL);
    NtClose(LinkHandle);
 
    /* Restore the NULL-termination */
    NtName->MaximumLength += sizeof(UNICODE_NULL);
 
    /* Check for success */
    if (!NT_SUCCESS(Status))
    {
        /* We failed, don't touch NtName */
        DPRINT1("NtQuerySymbolicLinkObject(%wZ) failed, Status 0x%08lx\n", ArcName, Status);
    }
    else
    {
        /* We succeeded, NULL-terminate NtName */
        NtName->Buffer[NtName->Length / sizeof(WCHAR)] = UNICODE_NULL;
    }
 
    return Status;
}

Referenced by ArcPathToNtPath().

Variable Documentation

AdapterTypes_A

const PCSTR AdapterTypes_A[]

Initial value:

=
{
    "eisa",
    "scsi",
    "multi",
    "net",
    "ramdisk",
    NULL
}

Definition at line 46 of file arcname.c.

AdapterTypes_U

const PCWSTR AdapterTypes_U[]

Initial value:

=
{
    L"eisa",
    L"scsi",
    L"multi",
    L"net",
    L"ramdisk",
    NULL
}

Definition at line 55 of file arcname.c.

Referenced by ParseArcName(), and ResolveArcNameManually().

ControllerTypes_A

const PCSTR ControllerTypes_A[]

Initial value:

=
{
    "disk",
    "cdrom",
    NULL
}

Definition at line 72 of file arcname.c.

ControllerTypes_U

const PCWSTR ControllerTypes_U[]

Initial value:

=
{
    L"disk",
    L"cdrom",
    NULL
}

Definition at line 78 of file arcname.c.

Referenced by ParseArcName().

PeripheralTypes_A

const PCSTR PeripheralTypes_A[]

Initial value:

=
{
 
    "rdisk",
    "fdisk",
    "cdrom",
    NULL
}

Definition at line 94 of file arcname.c.

PeripheralTypes_U

const PCWSTR PeripheralTypes_U[]

Initial value:

=
{
 
    L"rdisk",
    L"fdisk",
    L"cdrom",
    NULL
}

Definition at line 102 of file arcname.c.

Referenced by ParseArcName().