Windows Kernel

Development Platform:
Visual C++

volumeid.c：Code Content
							/*
 * 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, MAX_PATH,
                                        0, 0);
   if ( cchVolumeLabel == 0 )
   {
      bUnicode = TRUE;
   }
   else
   {
      WCHAR szWideVolumeLabel[MAX_PATH];
      cchChars = MultiByteToWideChar(CP_ACP, 0,
                                     szAnsiVolumeLabel, -1,
                                     szWideVolumeLabel, MAX_PATH);
      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)
{
   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, MAX_PATH_LEN));
#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, MAX_PATH);
   }
   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);
         lstrcpy(pszFoundPathBuf, pcszFullPath);
      }
      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);
            lstrcpy(pszFoundPathBuf, pcszFullPath);
            /* 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];
                     lstrcpy(rgchLocalRootPath, TEXT("A:\"));
                     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);
                              lstrcpy(pszFoundPathBuf, pcszFullPath);
                              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

						