windows-server-2003/shell/ext/brfcase/filesync/linkinfo/volumeid.c

/*
 * volumeid.c - Volume ID ADT module.
 */


/* Headers
 **********/

#include "project.h"
#pragma hdrstop

#include "volumeid.h"


/* Constants
 ************/

/* local root path constants */

#define MAX_LOCAL_DRIVES            (TEXT('z') - TEXT('a') + 1)


/* Macros
 *********/

/* macros for accessing IVOLUMEID data */

#define IVOLID_Volume_Label_PtrA(pivolid) \
((LPSTR)(((PBYTE)(pivolid)) + (pivolid)->ucbVolumeLabelOffset))

#ifdef UNICODE
#define IVOLID_Volume_Label_PtrW(pivolid) \
((LPTSTR)(((PBYTE)(pivolid)) + (pivolid)->ucbVolumeLabelOffsetW))
#endif

#ifdef UNICODE
#define IVOLID_Volume_Label_Ptr(pivolid)   IVOLID_Volume_Label_PtrW(pivolid)
#else
#define IVOLID_Volume_Label_Ptr(pivolid)   IVOLID_Volume_Label_PtrA(pivolid)
#endif

    /* Types
     ********/

    /*
       @doc INTERNAL

       @struct IVOLUMEID | Internal definition of relocatable volume ID structure.
       An <t ILINKINFO> structure may contain an IVOLUMEID structure.  An IVOLUMEID
       structure consists of a header described as below, followed by
       variable-length data.
     */

    typedef struct _ivolumeidA
{
    /*
       @field UINT | ucbSize | Length of IVOLUMEID structure in bytes, including
       ucbSize field.
     */

    UINT ucbSize;

    /*
       @field UINT | uDriveType | The volume's host drive type, as returned by
       GetDriveType()
     */

    UINT uDriveType;

    /* @field DWORD | dwSerialNumber | The volume's serial number. */

    DWORD dwSerialNumber;

    /*
       @field UINT | ucbVolumeLabelOffset | Offset in bytes of volume label
       string from base of structure.
     */

    UINT ucbVolumeLabelOffset;
}
IVOLUMEIDA;
DECLARE_STANDARD_TYPES(IVOLUMEIDA);

#ifdef UNICODE
typedef struct _ivolumeidW
{
    /*
       @field UINT | ucbSize | Length of IVOLUMEID structure in bytes, including
       ucbSize field.
     */

    UINT ucbSize;

    /*
       @field UINT | uDriveType | The volume's host drive type, as returned by
       GetDriveType()
     */

    UINT uDriveType;

    /* @field DWORD | dwSerialNumber | The volume's serial number. */

    DWORD dwSerialNumber;

    /*
       @field UINT | ucbVolumeLabelOffset | Offset in bytes of volume label
       string from base of structure.
     */

    UINT ucbVolumeLabelOffset;

    /*
       This member is for storing the unicode version of the string
     */

    UINT ucbVolumeLabelOffsetW;
}
IVOLUMEIDW;
DECLARE_STANDARD_TYPES(IVOLUMEIDW);
#endif

#ifdef UNICODE
#define IVOLUMEID   IVOLUMEIDW
#define PIVOLUMEID  PIVOLUMEIDW
#define CIVOLUMEID  CIVOLUMEIDW
#define PCIVOLUMEID PCIVOLUMEIDW
#else
#define IVOLUMEID   IVOLUMEIDA
#define PIVOLUMEID  PIVOLUMEIDA
#define CIVOLUMEID  CIVOLUMEIDA
#define PCIVOLUMEID PCIVOLUMEIDA
#endif

/***************************** Private Functions *****************************/

/* Module Prototypes
 ********************/

PRIVATE_CODE BOOL UnifyIVolumeIDInfo(UINT, DWORD, LPCTSTR, PIVOLUMEID *, PUINT);
PRIVATE_CODE BOOL IsPathOnVolume(LPCTSTR, PCIVOLUMEID, PBOOL);
PRIVATE_CODE COMPARISONRESULT CompareUINTs(UINT, UINT);

#if defined(DEBUG) || defined (VSTF)

PRIVATE_CODE BOOL IsValidPCIVOLUMEID(PCIVOLUMEID);

#endif


/*
 ** UnifyIVolumeIDInfo()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PRIVATE_CODE BOOL UnifyIVolumeIDInfo(UINT uDriveType, DWORD dwSerialNumber,
        LPCTSTR pcszVolumeLabel, PIVOLUMEID *ppivolid,
        PUINT pucbIVolumeIDLen)
{
    BOOL bResult;
#ifdef UNICODE
    CHAR szAnsiVolumeLabel[MAX_PATH];
    BOOL bUnicode;
    UINT cchVolumeLabel;
    UINT cchChars;
#endif

    /* dwSerialNumber may be any value. */

    ASSERT(IsValidDriveType(uDriveType));
    ASSERT(IS_VALID_STRING_PTR(pcszVolumeLabel, CSTR));
    ASSERT(IS_VALID_WRITE_PTR(ppivolid, PIVOLUMEID));
    ASSERT(IS_VALID_WRITE_PTR(pucbIVolumeIDLen, UINT));

    /* Assume we won't overflow *pucbIVolumeIDLen here. */

#ifdef UNICODE
    /* Determine whether we need a full fledged UNICODE volume ID */
    bUnicode = FALSE;
    cchVolumeLabel = WideCharToMultiByte(CP_ACP, 0, pcszVolumeLabel, -1,
            szAnsiVolumeLabel, ARRAYSIZE(szAnsiVolumeLabel), 0, 0);
    if ( cchVolumeLabel == 0 )
    {
        bUnicode = TRUE;
    }
    else
    {
        WCHAR szWideVolumeLabel[MAX_PATH];

        cchChars = MultiByteToWideChar(CP_ACP, 0, szAnsiVolumeLabel, -1,
                szWideVolumeLabel, ARRAYSIZE(szWideVolumeLabel));
        if ( cchChars == 0 || lstrcmp(pcszVolumeLabel,szWideVolumeLabel) != 0 )
        {
            bUnicode = TRUE;
        }
    }

    if ( bUnicode )
    {
        UINT ucbDataSize;

        /* (+ 1) for null terminator. */

        ucbDataSize = SIZEOF(IVOLUMEIDW) + cchVolumeLabel;
        ucbDataSize = ALIGN_WORD_CNT(ucbDataSize);
        ucbDataSize += (lstrlen(pcszVolumeLabel) + 1) * SIZEOF(TCHAR);
        *pucbIVolumeIDLen = ucbDataSize;
    }
    else
    {
        /* (+ 1) for null terminator. */

        *pucbIVolumeIDLen = SIZEOF(IVOLUMEIDA) +
            cchVolumeLabel;
    }
#else
    /* (+ 1) for null terminator. */

    *pucbIVolumeIDLen = SIZEOF(**ppivolid) +
        (lstrlen(pcszVolumeLabel) + 1) * SIZEOF(TCHAR);
#endif

    bResult = AllocateMemory(*pucbIVolumeIDLen, ppivolid);

    if (bResult)
    {
        (*ppivolid)->ucbSize = *pucbIVolumeIDLen;
        (*ppivolid)->uDriveType = uDriveType;
        (*ppivolid)->dwSerialNumber = dwSerialNumber;

        /* Append volume label. */

#ifdef UNICODE
        if ( bUnicode )
        {
            (*ppivolid)->ucbVolumeLabelOffset = SIZEOF(IVOLUMEIDW);
            (*ppivolid)->ucbVolumeLabelOffsetW = ALIGN_WORD_CNT(
                                                                SIZEOF(IVOLUMEIDW)+cchVolumeLabel);

            lstrcpy(IVOLID_Volume_Label_PtrW(*ppivolid), pcszVolumeLabel);
        }
        else
        {
            (*ppivolid)->ucbVolumeLabelOffset = SIZEOF(IVOLUMEIDA);
        }
        lstrcpyA(IVOLID_Volume_Label_PtrA(*ppivolid), szAnsiVolumeLabel);
#else

        lstrcpy(IVOLID_Volume_Label_Ptr(*ppivolid), pcszVolumeLabel);
#endif
    }

    ASSERT(! bResult ||
            (IS_VALID_STRUCT_PTR(*ppivolid, CIVOLUMEID) &&
             EVAL(*pucbIVolumeIDLen == GetVolumeIDLen((PCVOLUMEID)*ppivolid))));

    return(bResult);
}


/*
 ** IsPathOnVolume()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PRIVATE_CODE BOOL IsPathOnVolume(LPCTSTR pcszDrivePath, PCIVOLUMEID pcivolid,
        PBOOL pbOnVolume)
{
    BOOL bResult;
    PVOLUMEID pvolid;
    UINT ucbVolumeIDLen;

    ASSERT(IsDrivePath(pcszDrivePath));
    ASSERT(IS_VALID_STRUCT_PTR(pcivolid, CIVOLUMEID));
    ASSERT(IS_VALID_WRITE_PTR(pcivolid, CIVOLUMEID));

    bResult = CreateVolumeID(pcszDrivePath, &pvolid, &ucbVolumeIDLen);

    if (bResult)
    {
        *pbOnVolume = (CompareVolumeIDs(pvolid, (PCVOLUMEID)pcivolid)
                == CR_EQUAL);

        DestroyVolumeID(pvolid);
    }

    return(bResult);
}


/*
 ** CompareUINTs()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PRIVATE_CODE COMPARISONRESULT CompareUINTs(UINT uFirst, UINT uSecond)
{
    COMPARISONRESULT cr;

    /* Any UINTs are valid input. */

    if (uFirst < uSecond)
        cr = CR_FIRST_SMALLER;
    else if (uFirst > uSecond)
        cr = CR_FIRST_LARGER;
    else
        cr = CR_EQUAL;

    ASSERT(IsValidCOMPARISONRESULT(cr));

    return(cr);
}


#if defined(DEBUG) || defined (VSTF)

/*
 ** IsValidPCIVOLUMEID()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PRIVATE_CODE BOOL IsValidPCIVOLUMEID(PCIVOLUMEID pcivolid)
{
    /* dwSerialNumber may be any value. */

    return(IS_VALID_READ_PTR(pcivolid, CIVOLUMEID) &&
            IS_VALID_READ_BUFFER_PTR(pcivolid, CIVOLUMEID, pcivolid->ucbSize) &&
            EVAL(IsValidDriveType(pcivolid->uDriveType)) &&
            EVAL(IsContained(pcivolid, pcivolid->ucbSize,
                    IVOLID_Volume_Label_Ptr(pcivolid),
                    lstrlen(IVOLID_Volume_Label_Ptr(pcivolid))*SIZEOF(TCHAR))));
}

#endif


/****************************** Public Functions *****************************/


/*
 ** CreateVolumeID()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PUBLIC_CODE BOOL CreateVolumeID(LPCTSTR pcszDrivePath, PVOLUMEID *ppvolid,
        PUINT pucbVolumeIDLen)
{
    BOOL bResult;
    /* "C:\" + null terminator. */
    TCHAR rgchRootPath[3 + 1];
    TCHAR rgchVolumeLabel[MAX_PATH_LEN];
    DWORD dwSerialNumber;

    ASSERT(IsDrivePath(pcszDrivePath));
    ASSERT(IS_VALID_WRITE_PTR(ppvolid, PVOLUMEID));
    ASSERT(IS_VALID_WRITE_PTR(pucbVolumeIDLen, UINT));

    /* Get volume's label and serial number. */

    MyLStrCpyN(rgchRootPath, pcszDrivePath, ARRAYSIZE(rgchRootPath));

    bResult = GetVolumeInformation(rgchRootPath, rgchVolumeLabel,
            ARRAYSIZE(rgchVolumeLabel), &dwSerialNumber,
            NULL, NULL, NULL, 0);

    if (bResult)
        /* Wrap them up. */
        bResult = UnifyIVolumeIDInfo(GetDriveType(rgchRootPath), dwSerialNumber,
                rgchVolumeLabel, (PIVOLUMEID *)ppvolid,
                pucbVolumeIDLen);

    ASSERT(! bResult ||
            IS_VALID_STRUCT_PTR((PCIVOLUMEID)*ppvolid, CIVOLUMEID));

    return(bResult);
}


/*
 ** DestroyVolumeID()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PUBLIC_CODE void DestroyVolumeID(PVOLUMEID pvolid)
{
    ASSERT(IS_VALID_STRUCT_PTR(pvolid, CVOLUMEID));

    FreeMemory(pvolid);

    return;
}


/*
 ** CompareVolumeIDs()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 **
 ** Volume ID data is compared in the following order:
 **    1) drive type
 **    2) volume serial number
 **
 ** N.b., volume labels are ignored.
 */
PUBLIC_CODE COMPARISONRESULT CompareVolumeIDs(PCVOLUMEID pcvolidFirst,
        PCVOLUMEID pcvolidSecond)
{
    COMPARISONRESULT cr;

    ASSERT(IS_VALID_STRUCT_PTR(pcvolidFirst, CVOLUMEID));
    ASSERT(IS_VALID_STRUCT_PTR(pcvolidSecond, CVOLUMEID));

    /* Compare VOLUMEIDs piece by piece. */

    cr = CompareUINTs(((PCIVOLUMEID)pcvolidFirst)->uDriveType,
            ((PCIVOLUMEID)pcvolidSecond)->uDriveType);

    if (cr == CR_EQUAL)
        cr = CompareDWORDs(((PCIVOLUMEID)pcvolidFirst)->dwSerialNumber,
                ((PCIVOLUMEID)pcvolidSecond)->dwSerialNumber);

    return(cr);
}


/*
 ** SearchForLocalPath()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PUBLIC_CODE BOOL SearchForLocalPath(PCVOLUMEID pcvolid, LPCTSTR pcszFullPath,
        DWORD dwInFlags, LPTSTR pszFoundPathBuf, int cchMax)
{
    BOOL bResult;
    BOOL bAvailable;
#if defined(DEBUG) && defined(UNICODE)
    WCHAR szWideVolumeLabel[MAX_PATH];
    LPWSTR pszWideVolumeLabel;
#endif

    ASSERT(IS_VALID_STRUCT_PTR(pcvolid, CVOLUMEID));
    ASSERT(IsFullPath(pcszFullPath));
    ASSERT(FLAGS_ARE_VALID(dwInFlags, ALL_SFLP_IFLAGS));
    ASSERT(IS_VALID_WRITE_BUFFER_PTR(pszFoundPathBuf, STR, cchMax));

#if defined(DEBUG) && defined(UNICODE)
    if (((PCIVOLUMEID)pcvolid)->ucbVolumeLabelOffset == SIZEOF(IVOLUMEIDA))
    {
        pszWideVolumeLabel = szWideVolumeLabel;
        MultiByteToWideChar(CP_ACP, 0, IVOLID_Volume_Label_PtrA((PCIVOLUMEID)pcvolid), -1,
                szWideVolumeLabel, ARRAYSIZE(szWideVolumeLabel));
    }
    else
    {
        pszWideVolumeLabel = IVOLID_Volume_Label_Ptr((PCIVOLUMEID)pcvolid);
    }
#endif

    /* Were we given a local path to check first? */

    if (IsLocalDrivePath(pcszFullPath))
        /* Yes.  Check it. */
        bResult = IsPathOnVolume(pcszFullPath, (PCIVOLUMEID)pcvolid,
                &bAvailable);
    else
    {
        /* No. */

        bAvailable = FALSE;
        bResult = TRUE;
    }

    if (bResult)
    {
        /* Did we find the volume? */

        if (bAvailable)
        {
            /* Yes. */

            ASSERT(lstrlen(pcszFullPath) < MAX_PATH_LEN);
            lstrcpyn(pszFoundPathBuf, pcszFullPath, cchMax);
        }
        else
        {
            /*
             * No.  Should we search other matching local devices for the volume?
             */

            if (IS_FLAG_SET(dwInFlags, SFLP_IFL_LOCAL_SEARCH))
            {
                TCHAR chOriginalDrive;
                UINT uDrive;
                DWORD dwLogicalDrives;

                /* Yes. */

#ifdef UNICODE
                WARNING_OUT((TEXT("SearchForLocalPath(): Searching for local volume \"%s\", as requested."),
                            pszWideVolumeLabel));
#else
                WARNING_OUT((TEXT("SearchForLocalPath(): Searching for local volume \"%s\", as requested."),
                            IVOLID_Volume_Label_Ptr((PCIVOLUMEID)pcvolid)));
#endif

                ASSERT(IsCharAlpha(*pcszFullPath));
                chOriginalDrive = *pcszFullPath;

                ASSERT(lstrlen(pcszFullPath) < MAX_PATH_LEN);
                lstrcpyn(pszFoundPathBuf, pcszFullPath, cchMax);

                /* Get bit mask of local logical drives. */

                dwLogicalDrives = GetLogicalDrives();

                for (uDrive = 0; uDrive < MAX_LOCAL_DRIVES; uDrive++)
                {
                    if (IS_FLAG_SET(dwLogicalDrives, (1 << uDrive)))
                    {
                        TCHAR chDrive;

                        chDrive = (TCHAR)(TEXT('A') + uDrive);
                        ASSERT(IsCharAlpha(chDrive));

                        if (chDrive != chOriginalDrive)
                        {
                            TCHAR rgchLocalRootPath[DRIVE_ROOT_PATH_LEN];

                            lstrcpyn(rgchLocalRootPath, TEXT("A:\\"), ARRAYSIZE(rgchLocalRootPath));
                            rgchLocalRootPath[0] = chDrive;

                            /*
                             * Does this drive's type match the target volume's drive
                             * type?
                             */

                            if (GetDriveType(rgchLocalRootPath) == ((PCIVOLUMEID)pcvolid)->uDriveType)
                            {
                                /* Yes.  Check the volume. */

                                TRACE_OUT((TEXT("SearchForLocalPath(): Checking local root path %s."),
                                            rgchLocalRootPath));

                                bResult = IsPathOnVolume(rgchLocalRootPath,
                                        (PCIVOLUMEID)pcvolid,
                                        &bAvailable);

                                if (bResult)
                                {
                                    if (bAvailable)
                                    {
                                        ASSERT(lstrlen(pcszFullPath) < MAX_PATH_LEN);
                                        lstrcpyn(pszFoundPathBuf, pcszFullPath, cchMax);

                                        ASSERT(IsCharAlpha(*pszFoundPathBuf));
                                        *pszFoundPathBuf = chDrive;

                                        TRACE_OUT((TEXT("SearchForLocalPath(): Found matching volume on local path %s."),
                                                    pszFoundPathBuf));

                                        break;
                                    }
                                }
                                else
                                    break;
                            }
                        }
                    }
                }
            }
            else
                /* No. */
#ifdef UNICODE
                WARNING_OUT((TEXT("SearchForLocalPath(): Not searching for local volume \"%s\", as requested."),
                            pszWideVolumeLabel));
#else
            WARNING_OUT((TEXT("SearchForLocalPath(): Not searching for local volume \"%s\", as requested."),
                        IVOLID_Volume_Label_Ptr((PCIVOLUMEID)pcvolid)));
#endif
        }
    }

    ASSERT(! bResult ||
            ! bAvailable ||
            IsLocalDrivePath(pszFoundPathBuf));

    return(bResult && bAvailable);
}


/*
 ** GetVolumeIDLen()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PUBLIC_CODE UINT GetVolumeIDLen(PCVOLUMEID pcvolid)
{
    ASSERT(IS_VALID_STRUCT_PTR(pcvolid, CVOLUMEID));

    return(((PCIVOLUMEID)pcvolid)->ucbSize);
}


/*
 ** GetVolumeSerialNumber()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PUBLIC_CODE BOOL GetVolumeSerialNumber(PCVOLUMEID pcvolid,
        PCDWORD *ppcdwSerialNumber)
{
    ASSERT(IS_VALID_STRUCT_PTR(pcvolid, CVOLUMEID));
    ASSERT(IS_VALID_WRITE_PTR(ppcdwSerialNumber, PCDWORD));

    *ppcdwSerialNumber = &(((PCIVOLUMEID)pcvolid)->dwSerialNumber);

    ASSERT(IS_VALID_READ_PTR(*ppcdwSerialNumber, CDWORD));

    return(TRUE);
}


/*
 ** GetVolumeDriveType()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PUBLIC_CODE BOOL GetVolumeDriveType(PCVOLUMEID pcvolid, PCUINT *ppcuDriveType)
{
    ASSERT(IS_VALID_STRUCT_PTR(pcvolid, CVOLUMEID));
    ASSERT(IS_VALID_WRITE_PTR(ppcuDriveType, PCUINT));

    *ppcuDriveType = &(((PCIVOLUMEID)pcvolid)->uDriveType);

    ASSERT(IS_VALID_READ_PTR(*ppcuDriveType, CUINT));

    return(TRUE);
}


/*
 ** GetVolumeLabel()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PUBLIC_CODE BOOL GetVolumeLabel(PCVOLUMEID pcvolid, LPCSTR *ppcszVolumeLabel)
{
    ASSERT(IS_VALID_STRUCT_PTR(pcvolid, CVOLUMEID));
    ASSERT(IS_VALID_WRITE_PTR(ppcszVolumeLabel, LPCTSTR));

    *ppcszVolumeLabel = IVOLID_Volume_Label_PtrA((PCIVOLUMEID)pcvolid);

    ASSERT(IS_VALID_STRING_PTRA(*ppcszVolumeLabel, CSTR));

    return(TRUE);
}

#ifdef UNICODE
/*
 ** GetVolumeLabelW()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PUBLIC_CODE BOOL GetVolumeLabelW(PCVOLUMEID pcvolid, LPCWSTR *ppcszVolumeLabel)
{
    ASSERT(IS_VALID_STRUCT_PTR(pcvolid, CVOLUMEID));
    ASSERT(IS_VALID_WRITE_PTR(ppcszVolumeLabel, LPCTSTR));

    if (((PCIVOLUMEID)pcvolid)->ucbVolumeLabelOffset == SIZEOF(IVOLUMEIDW))
    {
        *ppcszVolumeLabel = IVOLID_Volume_Label_PtrW((PCIVOLUMEID)pcvolid);

        ASSERT(IS_VALID_STRING_PTR(*ppcszVolumeLabel, CSTR));
    }
    else
    {
        *ppcszVolumeLabel = NULL;
    }

    return(TRUE);
}
#endif

/*
 ** CompareDWORDs()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PUBLIC_CODE COMPARISONRESULT CompareDWORDs(DWORD dwFirst, DWORD dwSecond)
{
    COMPARISONRESULT cr;

    /* Any DWORDs are valid input. */

    if (dwFirst < dwSecond)
        cr = CR_FIRST_SMALLER;
    else if (dwFirst > dwSecond)
        cr = CR_FIRST_LARGER;
    else
        cr = CR_EQUAL;

    ASSERT(IsValidCOMPARISONRESULT(cr));

    return(cr);
}


#if defined(DEBUG) || defined (VSTF)

/*
 ** IsValidPCVOLUMEID()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PUBLIC_CODE BOOL IsValidPCVOLUMEID(PCVOLUMEID pcvolid)
{
    return(IS_VALID_STRUCT_PTR((PCIVOLUMEID)pcvolid, CIVOLUMEID));
}

#endif


#ifdef DEBUG

/*
 ** DumpVolumeID()
 **
 **
 **
 ** Arguments:
 **
 ** Returns:
 **
 ** Side Effects:  none
 */
PUBLIC_CODE void DumpVolumeID(PCVOLUMEID pcvolid)
{
    ASSERT(IS_VALID_STRUCT_PTR(pcvolid, CVOLUMEID));

    PLAIN_TRACE_OUT((TEXT("%s%s[local volume ID] ucbSize = %#x"),
                INDENT_STRING,
                INDENT_STRING,
                ((PCIVOLUMEID)pcvolid)->ucbSize));
    PLAIN_TRACE_OUT((TEXT("%s%s[local volume ID] drive type %u"),
                INDENT_STRING,
                INDENT_STRING,
                ((PCIVOLUMEID)pcvolid)->uDriveType));
    PLAIN_TRACE_OUT((TEXT("%s%s[local volume ID] serial number %#08lx"),
                INDENT_STRING,
                INDENT_STRING,
                ((PCIVOLUMEID)pcvolid)->dwSerialNumber));
    PLAIN_TRACE_OUT((TEXT("%s%s[local volume ID] label \"%s\""),
                INDENT_STRING,
                INDENT_STRING,
                IVOLID_Volume_Label_Ptr((PCIVOLUMEID)pcvolid)));

    return;
}

#endif