ReparsePnt.cpp

Go to the documentation of this file.

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Project: uLib - User mode utility library.
// Module: NTFS reparse point functions.
// Author: Copyright (c) Love Nystrom
// License: NNOSL (BSD descendant, see NNOSL.txt in the base directory).
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Ref: http://www.flexhex.com/docs/articles/hard-links.phtml
// Ref: Native code by Max Nemirovsky at community.osr.com
// https://community.osr.com/discussion/128702/fsctl-set-reparse-point-returns-error-invalid-reparse-data
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// The reparse tags are a DWORD. The 32 bits are laid out as follows:
//
// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
// +-+-+-+-+-----------------------+-------------------------------+
// |M|R|N|R|    Reserved bits      |       Reparse Tag Value       |
// +-+-+-+-+-----------------------+-------------------------------+
//
// M is the Microsoft bit. When set to 1, it denotes a tag owned by Microsoft.
// All ISVs must use a tag with a 0 in this position.
// Note: If a Microsoft tag is used by non-Microsoft software, the
// behavior is not defined.
//
// R is reserved. Must be zero for non-Microsoft tags.
//
// N is name surrogate. When set to 1, the file represents another named
// entity in the system.
//
// The M and N bits are OR-able.
//
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

#include <uLib/_Internal.h>
#include <uLib/UtilFunc.h>
#include <uLib/StrFunc.h>
#include <uLib/Debug.h>
#include <WinIoCtl.h>

//static const DWORD _TEST_RPTAG = 0xCAFE;
//static const GUID  _TEST_RPGUID = // {27A530A9-0F30-42d1-99ED-C9861C4EC6B2}
//{ 0x27a530a9, 0xf30, 0x42d1, { 0x99, 0xed, 0xc9, 0x86, 0x1c, 0x4e, 0xc6, 0xb2 }};

//#define OFFS2PTR( base,offs )  PVOID( PBYTE(base) + ULONG_PTR(offs) )
//#define PTR2OFFS( base,ptr )   ULONG( PBYTE(ptr) - PBYTE(base) )

#ifndef FSCTL_GET_REPARSE_POINT // ntifs.h and winioctl.h

  #ifndef CTL_CODE
    #define CTL_CODE( DeviceType, Function, Method, Access ) ( \
      ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
      )
  #endif
  #ifndef FILE_DEVICE_FILE_SYSTEM
    #define FILE_DEVICE_FILE_SYSTEM  0x00000009
  #endif
  #ifndef METHOD_BUFFERED
    #define METHOD_BUFFERED  0
  #endif
  #ifndef FILE_ANY_ACCESS
    #define FILE_ANY_ACCESS  0
  #endif

  // Get a REPARSE_DATA_BUFFER or REPARSE_GUID_DATA_BUFFER

  #define FSCTL_GET_REPARSE_POINT \
    CTL_CODE( FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS ) /* REPARSE_DATA_BUFFER */

  #define FSCTL_SET_REPARSE_POINT \
    CTL_CODE( FILE_DEVICE_FILE_SYSTEM, 41, METHOD_BUFFERED, FILE_SPECIAL_ACCESS ) /* REPARSE_DATA_BUFFER */

  #define FSCTL_DELETE_REPARSE_POINT \
    CTL_CODE( FILE_DEVICE_FILE_SYSTEM, 43, METHOD_BUFFERED, FILE_SPECIAL_ACCESS ) /* REPARSE_DATA_BUFFER */

#endif//ndef FSCTL_GET_REPARSE_POINT
#ifndef _NTIFS_ // Copy REPARSE_DATA_BUFFER from the DDK..

  typedef struct _REPARSE_DATA_BUFFER {
    ULONG  ReparseTag;
    USHORT ReparseDataLength;
    USHORT Reserved;
    union {
      struct {
        USHORT SubstituteNameOffset;
        USHORT SubstituteNameLength;
        USHORT PrintNameOffset;
        USHORT PrintNameLength;
        ULONG  Flags;
        WCHAR  PathBuffer[1];
      } SymbolicLinkReparseBuffer;
      struct {
        USHORT SubstituteNameOffset;
        USHORT SubstituteNameLength;
        USHORT PrintNameOffset;
        USHORT PrintNameLength;
        WCHAR  PathBuffer[1];
      } MountPointReparseBuffer;
      struct {
        UCHAR DataBuffer[1];
      } GenericReparseBuffer;
    };
  } REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;

  #define REPARSE_DATA_BUFFER_HEADER_SIZE \
    FIELD_OFFSET( REPARSE_DATA_BUFFER, GenericReparseBuffer )

  #ifndef SYMLINK_FLAG_RELATIVE
  #define SYMLINK_FLAG_RELATIVE       0x00000001
  #endif
  #ifndef IO_REPARSE_TAG_IIS_CACHE
  #define IO_REPARSE_TAG_IIS_CACHE    0xA0000010  // I don't know the data struct of this..
  #endif
  #define IO_REPARSE_TAG_VALID_VALUES 0xF000FFFF

  #define IsReparseTagValid(_tag) ( \
    !((_tag) & ~IO_REPARSE_TAG_VALID_VALUES) \
    && ((_tag) > IO_REPARSE_TAG_RESERVED_RANGE) \
    )

#endif//ndef _NTIFS_

#define MAX_REPARSE_BUFFER \
    MAXIMUM_REPARSE_DATA_BUFFER_SIZE // 16 kB

// SET_WRPD_PRIVILEGE - WRPD == WriteReParseData
// Afaik, FSCTL_SET_REPARSE_POINT requires SE_RESTORE_NAME.
// Set to 1 to include privilege setting code..

#define SET_WRPD_PRIVILEGE 1

#if 0 // Memo - These are declared in WinNT.h
  typedef struct _REPARSE_GUID_DATA_BUFFER
  {
    ULONG  ReparseTag;
    USHORT ReparseDataLength;
    USHORT Reserved;
    GUID   ReparseGuid;
    struct {
      UCHAR  DataBuffer[1];
    } GenericReparseBuffer;
  }
  REPARSE_GUID_DATA_BUFFER, *PREPARSE_GUID_DATA_BUFFER;

  #define REPARSE_GUID_DATA_BUFFER_HEADER_SIZE \
    FIELD_OFFSET( REPARSE_GUID_DATA_BUFFER, GenericReparseBuffer )
#endif

//==-------------------------------------------------------------------------------------
//  LOCAL SUBS
//==-------------------------------------------------------------------------------------

// PONDER: Some of these a prime candidates for public low level use..!

HANDLE _OpenReparsePoint( CSTR LinkName, ACCESS_MASK Access, DWORD Share ) // public
// Open an FS object in a manner suitable for reparse data access.
{
    return CheckHandle( CreateFile(
        LinkName, Access, Share, NULL, OPEN_EXISTING,
        FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS,
        NULL
        ));
}

static bool _IsNameSurrogateTag( DWORD Tag )
// Accept only tags that are known (symlink and mount point).
{
    bool ok =  IsReparseTagValid( Tag );
    if (!ok) SetLastError( ERROR_INVALID_DATA ); // Not a proper tag..
    else
    {
      #if 0  // Flaw: This doesn't exclude future unknown surrogates.
        ok = IsReparseTagMicrosoft( Tag );
        if (ok ) ok = IsReparseTagNameSurrogate( Tag );
      #else  // So, be specific: We know symlinks and mount points.
        ok = (Tag == IO_REPARSE_TAG_SYMLINK);
        if (!ok) ok = (Tag == IO_REPARSE_TAG_MOUNT_POINT);
      #endif
        if (!ok) SetLastError( ERROR_NOT_SUPPORTED ); // Nothing known to resolve..
    }
    return ok;
}

static CSTR _AbsTargetPrefixPath( CSTR TargetPath )
// Absolute symlink targets need to be preceeded by the "nonparsed" (\??\) prefix.
{
    static __thread_local TCHAR PfxPath[ MAX_PATH ] = _T("\\??\\");

    // NOTE: Using a "local" critsec instead of a TLS buffer would preclude
    // using a local buffer, since we couldn't leave it until /after/
    // some thread has finished using the buffer.
    // A hack to avoid using a TLS slot would be to turn this into a macro
    // (or a __forceinline if the compiler can guarantee it will ALWAYS be expanded).

    if (_tcsncmp( TargetPath, PfxPath, 4 ) != 0)
    {
        _tcsncpyz( &PfxPath[4], TargetPath, MAX_PATH-4 );
        TargetPath = PfxPath;
    }
    return TargetPath;
}

#if 0 // Absolute symlink targets need to be preceeded by the "nonparsed" (\??\) prefix.
#define ABS_TARGET_PREFIX_PATH( TargetPath ) \
    TCHAR _PfxPath[ MAX_PATH ] = _T("\\??\\"); \
    if (_tcsncmp( TargetPath, _PfxPath, 4 ) != 0) { \
        _tcsncpyz( &_PfxPath[4], TargetPath, MAX_PATH-4 ); \
        TargetPath = _PfxPath; \
    }
#endif

bool _CanReparse( CSTR PathName ) // public
// Return true if the volume of an FS object supports reparsing.
{
    DWORD volFlg = __GetVolumeFlags( PathName );
    bool ok = BITS_SET( FILE_SUPPORTS_REPARSE_POINTS, volFlg );
    if (!ok) SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
    return ok;
}

static bool _CanSetReparseData( CSTR PathName )
// Return true if the volume supports reparsing and there isn't already reparse data set.
{
    BOOL ok = _CanReparse( PathName ); // Volume supports reparsing?
    if (ok)
    {
        ULARGE_INTEGER attr = GetAttributeAndReparseTag( PathName );

        // PathName must exist, and *not* be a reparse point already.

        bool objExist = (attr.LowPart != _BAD_ATTRIBUTE);
        bool alreadySet = BITS_SET( FILE_ATTRIBUTE_REPARSE_POINT, attr.LowPart );
        // PS: Don't worry that alreadySet will become true for _BAD_ATTRIBUTE.
        // The logic below prevents it from affecting the result, and this masking
        // operation is cheaper than the alternate isolatory logic would be.

        if (!objExist) SetLastError( ERROR_FILE_NOT_FOUND );
        else if (alreadySet) SetLastError( ERROR_ALREADY_INITIALIZED );
        ok = objExist && !alreadySet;
    }
    return bool_cast( ok );
}

static void _ShNfyDirOf( CSTR Path, LONG evId )
// Notify the shell that the contents of an existing folder have changed.
{
    TCHAR szDir[ MAX_PATH ];
    _tcsncpyz( szDir, Path, dimof(szDir) );
    PathRemoveFileSpec( szDir );
    SHChangeNotify( evId, SHCNF_PATH, szDir, NULL );
}

//++ _GetReparseData ++------------------------------------------------------------------

// Use FSCTL_GET_REPARSE_POINT to extract the reparse data from an FS object, or return
// the required buffer size. On NTFS this reads data from the ::$REPARSE_POINT file stream.

// PONDER:
// STATUS_BUFFER_OVERFLOW The buffer that the OutputBuffer parameter points to is large enough to hold the fixed portion of the REPARSE_GUID_DATA_BUFFER or REPARSE_DATA_BUFFER structure but not the user-defined data. In this case, only the fixed portion of the reparse point data is returned in the OutputBuffer buffer. The LengthReturned parameter to FltFsControlFile receives the actual length, in bytes, of data returned. This is a warning code.
// STATUS_BUFFER_TOO_SMALL The buffer that the OutputBuffer parameter points to is not large enough to hold the reparse point data. The LengthReturned parameter to FltFsControlFile (or the Information member of the IoStatus parameter to ZwFsControlFile) receives the required buffer size. In this case, no reparse point data is returned. This is an error code.
// STATUS_IO_REPARSE_DATA_INVALID One of the specified parameter values was invalid. This is an error code.
// STATUS_NOT_A_REPARSE_POINT The file or directory is not a reparse point. This is an error code.

ULARGE_INTEGER _GetReparseData( HANDLE hObj, PVOID Buffer, DWORD cbBuffer ) // public
{
    DWORD cbRtn, headerSize;
    REPARSE_GUID_DATA_BUFFER rpd, *pd; // The larger of the two RP structs.
    ULARGE_INTEGER info = {{0,0}};

    if (!hObj) SetLastError( ERROR_INVALID_HANDLE );
    else
    {
        if (!Buffer) // then use temp buffer to query data size.
        {
            IF_DEBUG( memset( &rpd, 0, sizeof(rpd) ));
            Buffer = &rpd;
            cbBuffer = sizeof(rpd);
        }
        BOOL ok = DeviceIoControl(
            hObj, FSCTL_GET_REPARSE_POINT, NULL,0,
            Buffer, cbBuffer, &cbRtn, NULL
            );
        pd = (PREPARSE_GUID_DATA_BUFFER) Buffer;
        if (ok)
        {
            info.HighPart = pd->ReparseTag;
            info.LowPart = cbRtn;
        }
        else if (GetLastError() == ERROR_MORE_DATA) // STATUS_BUFFER_OVERFLOW
        {
            // Return the required buffer size, depending on reparse type.
            // Err on the safe (larger) side if uncertain.

            if (IsReparseTagNameSurrogate( pd->ReparseTag )
            && IsReparseTagMicrosoft( pd->ReparseTag ))
                headerSize = REPARSE_DATA_BUFFER_HEADER_SIZE;
            else headerSize = REPARSE_GUID_DATA_BUFFER_HEADER_SIZE;

            info.HighPart = pd->ReparseTag;
            info.LowPart = pd->ReparseDataLength + headerSize;
        }
    }
    return info;
}

//++ _SetReparseData ++-----------------------------------------------------------------

// TODO: Test _SetReparseData() as a stand-alone call.

bool _SetReparseData( HANDLE hObj, PREPARSE_DATA_BUFFER pRpd, OPTIN DWORD cbRpd DEF_(0) ) // public
{
  #if SET_WRPD_PRIVILEGE // AFAIK, SE_RESTORE_NAME is required..
    HANDLE hToken; TOKEN_PRIVILEGES tp = { 1, { 0,0,0 }};
    BOOL prvOk = __EnableProcPrivilege( SE_RESTORE_NAME, &tp.Privileges[0], &hToken );
  #endif

    DWORD cbRtn, error = 0;
    if (!cbRpd) cbRpd = pRpd->ReparseDataLength + REPARSE_DATA_BUFFER_HEADER_SIZE;
    BOOL ok = __ChkOkGetErr( DeviceIoControl(
        hObj, FSCTL_SET_REPARSE_POINT, pRpd, cbRpd, NULL,0, &cbRtn, NULL
        ), &error );

    TRACE_IF( !ok, DP_ERROR, _F("FSCTL_SET_REPARSE_POINT failed: %s\n"), SysErrorMsg( error ));
  #if SET_WRPD_PRIVILEGE
    if (prvOk) RestorePrivilege( hToken, &tp );
    if (hToken) CloseHandle( hToken );
  #endif
    if (!ok && error) SetLastError( error );
    return bool_cast( ok );
};

//++ _GetNameSurrogates ++---------------------------------------------------------------
// Extract the subst and print names from a symlink or mount point and null terminate them.

static bool _GetNameSurrogates( PREPARSE_DATA_BUFFER pRpd, WSTR wzSubst, WSTR wzPrint )
{
    bool isMountPoint = (pRpd->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT);
    bool isSymLink = (pRpd->ReparseTag == IO_REPARSE_TAG_SYMLINK);
    bool ok = isMountPoint || isSymLink;
    if (ok)
    {
        // NOTE: The following works fine because MountPointReparseBuffer and
        // SymbolicLinkReparseBuffer are identical as far as lengths and offsets.

        USHORT ccSubst = pRpd->MountPointReparseBuffer.SubstituteNameLength / WCHAR_SIZE;
        USHORT ccPrint = pRpd->MountPointReparseBuffer.PrintNameLength / WCHAR_SIZE;
        USHORT ccSubstOffs = pRpd->MountPointReparseBuffer.SubstituteNameOffset / WCHAR_SIZE;
        USHORT ccPrintOffs = pRpd->MountPointReparseBuffer.PrintNameOffset / WCHAR_SIZE;

        WSTR rpdPath = isMountPoint
            ? pRpd->MountPointReparseBuffer.PathBuffer
            : pRpd->SymbolicLinkReparseBuffer.PathBuffer;

        if (wzSubst) wcsncpyz( wzSubst, &rpdPath[ccSubstOffs], ccSubst+1 );
        if (wzPrint) wcsncpyz( wzPrint, &rpdPath[ccPrintOffs], ccPrint+1 );
    }
    return ok;
}

//++ _CreateNameSurrogate ++-----------------------------------------------------------
// Use FSCTL_SET_REPARSE_POINT to write the ::$REPARSE_POINT stream of the link object.

// PONDER: Change name to _SetSurrogateName..?
// TODO: Find out what happens if one tries to overwrite reparse data..
// WIP: Factorize the code that calls FSCTL_SET_REPARSE_POINT,
// to facilitate writing a RP data update funtion for exisiting RPs.
// See _SetReparseData()

namespace { // internal
    enum eCnsFlags // CreateNameSurrogate flags
    {
        CNSF_RELATIVE   = WORD( SYMLINK_FLAG_RELATIVE ), // 0x01
        CNSF_MOUNTPOINT = 0x0002, // If this bit is zero, we create a symlink instead
        CNSF_SYMLINK    = 0x0000, // i.e. Mountpoint bit is unset..
        CNSF_DIRECTORY  = 0x0004, // Directory symlink or junction/mountpoint
        CNSF_NOPARSE    = 0x0008 // Don't modify the target path string.
    };
} // end internal

#if 1 // V2 - TODO: Verify it still works..
static bool _CreateNameSurrogate( CSTR LinkName, CSTR TargetName, CSTR PrintName, WORD Flags )
{
    BOOL ok = _CanReparse( LinkName );
  #if 0 // No longer required (since Win6.0 ?)
    if (ok && (Flags & CNSF_DIRECTORY)) ok = (TargetName[ _tcslen(TargetName) - 1 ] != BSLASH);
  #endif
    if (ok)
    {
        DWORD error = 0;
        ACCESS_MASK Access = FILE_WRITE_ATTRIB_EA;
        HANDLE hLink = _OpenReparsePoint( LinkName, Access, FILE_SHARE_READ );
        ok = __ChkOkGetErr( hLink != NULL, &error );
        if (ok)
        {
            WORD cbSubstName, cbPrintName, cbPrintOffs, ccPrintOffs, cbPathBufOffs, cbBuf;

            if (!PrintName) PrintName = TargetName;
          #ifdef _UNICODE
            #define wzTargetName TargetName
            #define wszPrintName PrintName
          #else
            WCHAR wzTargetName[ MAX_PATH ], wszPrintName[ MAX_PATH ];
            MultiByteToWideChar( CP_ACP, 0, TargetName,-1, wzTargetName, MAX_PATH );
            MultiByteToWideChar( CP_ACP, 0, PrintName,-1, wszPrintName, MAX_PATH );
          #endif
            // Don't include any prefix in the print name.
            WCSTR wzPrintName = SkipPathPrefixW( wszPrintName );

            cbSubstName = (WORD) wcslen( wzTargetName ) * sizeof(WCHAR);
            cbPrintName = (WORD) wcslen( wzPrintName ) * sizeof(WCHAR);
            cbPrintOffs = cbSubstName + sizeof(WCHAR); // Add null terminator (option)
            ccPrintOffs = cbPrintOffs / sizeof(WCHAR);

            // SymbolicLinkReparseBuffer has an additional Flags field before the buffer.

            cbPathBufOffs = (Flags & CNSF_MOUNTPOINT)
                ? FIELD_OFFSET( REPARSE_DATA_BUFFER, MountPointReparseBuffer.PathBuffer )
                : FIELD_OFFSET( REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer );

            cbBuf = cbPathBufOffs + cbSubstName + cbPrintName + 2*sizeof(WCHAR); // 2 nulls

            PREPARSE_DATA_BUFFER prdb = (PREPARSE_DATA_BUFFER) mem_Alloc( cbBuf );
            ok = __ChkOkGetErr( prdb != NULL, &error );
            if (ok)
            {
                if (Flags & CNSF_MOUNTPOINT)
                    prdb->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
                else
                {
                    prdb->ReparseTag = IO_REPARSE_TAG_SYMLINK;
                    prdb->SymbolicLinkReparseBuffer.Flags = (Flags & CNSF_RELATIVE);
                }
                prdb->ReparseDataLength = cbBuf - REPARSE_DATA_BUFFER_HEADER_SIZE;

                // NOTA BENE: The following works fine because MountPointReparseBuffer and
                // SymbolicLinkReparseBuffer are identical as far as offsets and lengths.
                // Also note that SubstituteNameOffset is already zeroed by mem_Alloc.

                prdb->MountPointReparseBuffer.SubstituteNameLength = cbSubstName;
                prdb->MountPointReparseBuffer.PrintNameLength = cbPrintName;
                prdb->MountPointReparseBuffer.PrintNameOffset = cbPrintOffs;

                WSTR pwzPathBuf = (WSTR)( PBYTE(prdb) + cbPathBufOffs );
                memcpy( pwzPathBuf, wzTargetName, cbSubstName );
                memcpy( pwzPathBuf + ccPrintOffs, wzPrintName, cbPrintName );

                ok = _SetReparseData( hLink, prdb, cbBuf ); // TODO: Test this call

                mem_Free( prdb );
            }
            CloseHandle( hLink );
        }
        if (!ok && error) SetLastError( error );
    }
    return bool_cast( ok );
}
#else
static bool _CreateNameSurrogate( CSTR LinkName, CSTR TargetName, CSTR PrintName, WORD Flags )
{
    BOOL ok = _CanReparse( LinkName );
  #if 0 // No longer required (since Win6.0 ?)
    if (ok && (Flags & CNSF_DIRECTORY)) ok = (TargetName[ _tcslen(TargetName) - 1 ] != BSLASH);
  #endif
    if (ok)
    {
        DWORD error = 0;
      #if SET_WRPD_PRIVILEGE
        HANDLE hToken; TOKEN_PRIVILEGES tp = { 1, { 0,0 }};
        BOOL prvOk = __EnableProcPrivilege( SE_RESTORE_NAME, &tp.Privileges[0], &hToken );
      #endif

        ACCESS_MASK Access = FILE_WRITE_ATTRIB_EA;
        HANDLE hLink = _OpenReparsePoint( LinkName, Access, FILE_SHARE_READ );
        ok = __ChkOkGetErr( hLink != NULL, &error );
        if (ok)
        {
            DWORD cbRtn;
            WORD cbSubstName, cbPrintName, cbPrintOffs, ccPrintOffs, cbPathBufOffs, cbBuf;

            if (!PrintName) PrintName = TargetName;
          #ifdef _UNICODE
            #define wzTargetName TargetName
            #define wszPrintName PrintName
          #else
            WCHAR wzTargetName[ MAX_PATH ], wszPrintName[ MAX_PATH ];
            MultiByteToWideChar( CP_ACP, 0, TargetName,-1, wzTargetName, MAX_PATH );
            MultiByteToWideChar( CP_ACP, 0, PrintName,-1, wszPrintName, MAX_PATH );
          #endif
            // Don't include any prefix in the print name.
            WCSTR wzPrintName = SkipPathPrefixW( wszPrintName );

            cbSubstName = (WORD) wcslen( wzTargetName ) * sizeof(WCHAR);
            cbPrintName = (WORD) wcslen( wzPrintName ) * sizeof(WCHAR);
            cbPrintOffs = cbSubstName + sizeof(WCHAR); // Add null terminator (option)
            ccPrintOffs = cbPrintOffs / sizeof(WCHAR);

            // SymbolicLinkReparseBuffer has an additional Flags field before the buffer.

            cbPathBufOffs = (Flags & CNSF_MOUNTPOINT)
                ? FIELD_OFFSET( REPARSE_DATA_BUFFER, MountPointReparseBuffer.PathBuffer )
                : FIELD_OFFSET( REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer );

            cbBuf = cbPathBufOffs + cbSubstName + cbPrintName + 2*sizeof(WCHAR); // 2 nulls

            PREPARSE_DATA_BUFFER prdb = (PREPARSE_DATA_BUFFER) mem_Alloc( cbBuf );
            ok = __ChkOkGetErr( prdb != NULL, &error );
            if (ok)
            {
                if (Flags & CNSF_MOUNTPOINT)
                    prdb->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
                else
                {
                    prdb->ReparseTag = IO_REPARSE_TAG_SYMLINK;
                    prdb->SymbolicLinkReparseBuffer.Flags = (Flags & CNSF_RELATIVE);
                }
                prdb->ReparseDataLength = cbBuf - REPARSE_DATA_BUFFER_HEADER_SIZE;

                // NOTA BENE: The following works because MountPointReparseBuffer and
                // SymbolicLinkReparseBuffer are identical as far as offsets and lengths.
                // Also note that SubstituteNameOffset is already zeroed by allocator.

                prdb->MountPointReparseBuffer.SubstituteNameLength = cbSubstName;
                prdb->MountPointReparseBuffer.PrintNameLength = cbPrintName;
                prdb->MountPointReparseBuffer.PrintNameOffset = cbPrintOffs;

                WSTR pwzPathBuf = (WSTR)( PBYTE(prdb) + cbPathBufOffs );
                memcpy( pwzPathBuf, wzTargetName, cbSubstName );
                memcpy( pwzPathBuf + ccPrintOffs, wzPrintName, cbPrintName );

                ok = __ChkOkGetErr( DeviceIoControl(
                    hLink, FSCTL_SET_REPARSE_POINT, prdb, cbBuf, NULL,0, &cbRtn, NULL
                    ), &error );

                mem_Free( prdb );
            }
            CloseHandle( hLink );
        }
      #if SET_WRPD_PRIVILEGE
        if (prvOk) RestorePrivilege( hToken, &tp );
        if (hToken) CloseHandle( hToken );
      #endif
        if (!ok && error) SetLastError( error );
    }
    return bool_cast( ok );
}
#endif //_CreateNameSurrogate

//==-----------------------------------------------------------------------------------
//  PUBLIC
//==-----------------------------------------------------------------------------------

// Return file attributes in LowPart, and reparse tag, if any, in HighPart.
#if 1 // Faster execution in the typcal case..

ULARGE_INTEGER GetAttributeAndReparseTag( CSTR PathName )
{
    WIN32_FIND_DATA fd;
    ULARGE_INTEGER info = {{0,0}};

    // Since the vast majority of files/dirs will _not_ be reparse points,
    // we don't waste time with an entire FindFirstFile for them..

    info.LowPart = GetFileAttributes( PathName );
    if (info.LowPart == INVALID_FILE_ATTRIBUTES)
    {
        info.LowPart = 0;
        TRACE( DP_ERROR, _F("GetFileAttributes: %s\n"), SysErrorMsg() );
    }
    else if (BITS_SET( FILE_ATTRIBUTE_REPARSE_POINT, info.LowPart ))
    {
        if (BITS_SET( FILE_ATTRIBUTE_DIRECTORY, info.LowPart ))
            PathName = WithoutBackslash( PathName );

        HANDLE hf = FindFirstFile( PathName, &fd );
        if (hf != INVALID_HANDLE_VALUE)
        {
            info.HighPart = fd.dwReserved0; // Ref.MSDN: The reparse tag.
            FindClose( hf );
        }
    }
    return info;
}

#else // Naive approach, wasteful of CPU cycles..
ULARGE_INTEGER GetAttributeAndReparseTag( CSTR PathName )
{
    WIN32_FIND_DATA fd;
    ULARGE_INTEGER info = {{0,0}};
    HANDLE hf = FindFirstFile( WithoutBackslash( PathName ), &fd );
    if (hf != INVALID_HANDLE_VALUE) {
        info.LowPart = fd.dwFileAttributes;
        info.HighPart = fd.dwReserved0; // Ref.MSDN: The reparse tag.
        FindClose( hf );
    }
    return info;
}
#endif

//++ IsSymLink/IsSymLinkDir/IsJunctionDir ++-----------------------------------

#define FA_REPARSE_DIR \
    (FILE_ATTRIBUTE_DIRECTORY| FILE_ATTRIBUTE_REPARSE_POINT)

// UNDER CONSIDERATTION
// Optionally use and return the attrib/tag pair.
//
//bool IsSymLink( CSTR PathName, OPTIO ULARGE_INTEGER* pAttrTag DEF_(NULL))
//
//bool _IsSymLinkTag( CSTR PathName, ULARGE_INTEGER* pAttrTag )
//{
//    ULARGE_INTEGER tag;
//    // Use attrib-tag pair if one was given, else get one.
//
//    if (pAttrTag && pAttrTag->HighPart) tag = *pAttrTag;
//    else tag = GetAttributeAndReparseTag( PathName );
//    if (pAttrTag && !pAttrTag->HighPart) *pAttrTag = tag; // Return if given tag was zero.
//
//    // Now check it..
//
//    bool ok = BITS_SET( FILE_ATTRIBUTE_REPARSE_POINT, tag.LowPart );
//    if (ok) ok = (tag.HighPart == IO_REPARSE_TAG_SYMLINK);
//    return ok;
//}

bool IsSymLink( CSTR PathName )
{
    ULARGE_INTEGER tag = GetAttributeAndReparseTag( PathName );
    bool ok = BITS_SET( FILE_ATTRIBUTE_REPARSE_POINT, tag.LowPart );
    if (ok) ok = (tag.HighPart == IO_REPARSE_TAG_SYMLINK);
    return ok;
}

bool IsSymLinkDir( CSTR PathName )
{
    ULARGE_INTEGER tag = GetAttributeAndReparseTag( PathName );
    bool ok = BITS_SET( FA_REPARSE_DIR, tag.LowPart );
    if (ok) ok = (tag.HighPart == IO_REPARSE_TAG_SYMLINK);
    return ok;
}

bool IsJunctionDir( CSTR PathName )
// Test if pathName is an NTFS junction-mounted directory/volume.
{
    ULARGE_INTEGER tag = GetAttributeAndReparseTag( PathName );
    bool ok = BITS_SET( FA_REPARSE_DIR, tag.LowPart );
    // Determine if it's a JUNCTION, not a SYMLINKD.
    if (ok) ok = (tag.HighPart == IO_REPARSE_TAG_MOUNT_POINT);
    return ok;
}

//++ Is directory a mounted volume? ++-----------------------------------------

bool IsVolumeMountPoint( CSTR PathName, TSTR VolNameBuf, UINT ccBuf )
{
    bool ok = IsJunctionDir( PathName );
    if (ok) {
        // IO_REPARSE_TAG_MOUNT_POINT is inconclusive, since it's true
        // for directory junctions as well as volume junctions.
        // Use GetVolumeNameForVolumeMountPoint to determine if it's a volume.

        TCHAR volname[ 64 ]; // Volume GUID name >>> \\?\Volume{GUID}
        if (!VolNameBuf || !ccBuf) // If caller doesn't want the volume name..
        {
            VolNameBuf = volname;
            ccBuf = dimof(volname);
        }
        // Volume APIs require a trailing backslash.
        // However, GetAttributeAndReparseTag fails if there *is* one,
        // so we'll add one on the fly for GetVolumeNameForVolumeMountPoint.

        PathName = WithBackslash( PathName );

        // Verify that the junction is a mount point.

        ok = bool_cast(
            GetVolumeNameForVolumeMountPoint(
                PathName, VolNameBuf, ccBuf
                ));
    }
    return ok;
}

//++ RemoveReparseData ++-------------------------------------------------------------------

// STATUS_IO_REPARSE_DATA_INVALID One of the specified parameter values was invalid. This is an error code.
// STATUS_NOT_A_REPARSE_POINT The file or directory is not a reparse point. This is an error code.

bool RemoveReparseData( CSTR PathName )
{
    DWORD error = 0;
    ULARGE_INTEGER attr = GetAttributeAndReparseTag( PathName );
    BOOL ok = (attr.LowPart & FILE_ATTRIBUTE_REPARSE_POINT);
    if (!ok) error = ERROR_NOT_A_REPARSE_POINT; // i.e. STATUS_NOT_A_REPARSE_POINT
    else
    {
        DWORD cbRtn;
        REPARSE_DATA_BUFFER rpd;
        ZeroMemory( &rpd, sizeof(rpd) );
        rpd.ReparseTag = attr.HighPart;

        ACCESS_MASK Access = DELETE| FILE_WRITE_ATTRIB_EA;
        HANDLE hObj = _OpenReparsePoint( PathName, Access, FILE_SHARE_NONE );
        ok = __ChkOkGetErr( hObj != NULL, &error );
        if ( ok )
        {
            ok = __ChkOkGetErr( DeviceIoControl(
                hObj, FSCTL_DELETE_REPARSE_POINT,
                &rpd, REPARSE_DATA_BUFFER_HEADER_SIZE, NULL,0, &cbRtn, NULL
                ), &error );
            CloseHandle( hObj );
        }
    }
    if (!ok && error) SetLastError( error );
    return bool_cast( ok );
}

//++ SetCustomReparseData ++-------------------------------------------------------------

bool SetCustomReparseData(
    CSTR PathName, ULONG Tag, REFGUID Guid, PVOID pData, WORD cbData
    )
{
    DWORD error = 0;

    // PONDER: Is it legit to simply overwrite previous reparse data..?
    // After observing FSCTL_SET_REPARSE_POINT I'm inclined to think the
    // IoCtrl don't really bother with the content, just the protocol.

    BOOL ok = _CanSetReparseData( PathName );
    if (ok)
    {
        HANDLE hObj = _OpenReparsePoint( PathName, FILE_WRITE_ATTRIB_EA, FILE_SHARE_READ );
        ok = __ChkOkGetErr( hObj != NULL, &error );
        if (ok)
        {
            DWORD cbBuf, cbRtn;

            cbBuf = FIELD_OFFSET( REPARSE_GUID_DATA_BUFFER, GenericReparseBuffer.DataBuffer[ cbData ] );
            PREPARSE_GUID_DATA_BUFFER prdb = (PREPARSE_GUID_DATA_BUFFER) mem_Alloc( cbBuf );

            prdb->ReparseTag = Tag; // E.g. 0x15;
            prdb->ReparseGuid = Guid;
            prdb->ReparseDataLength = cbData;
            memcpy( prdb->GenericReparseBuffer.DataBuffer, pData, cbData );

            ok = __ChkOkGetErr( DeviceIoControl(
                hObj, FSCTL_SET_REPARSE_POINT, prdb, cbBuf, NULL,0, &cbRtn, NULL
                ), &error );

            mem_Free( prdb );
            CloseHandle( hObj );
        }
    }
    if (!ok && error) SetLastError( error );
    return bool_cast( ok );
}

//++ CreateJunction ++-------------------------------------------------------------------

// PONDER: Implement AllowUpdate parameter..?

//bool CreateJunctionDir( CSTR LinkName, CSTR TargetPath, CSTR PrintName, bool AllowUpdate DEF_(false) );

// AllowUpdate allows update of the link target of an existing junction dir if true.
// If false, the function will fail with ERROR_FILE_EXISTS if LinkName exist.

bool CreateJunctionDir( CSTR LinkName, CSTR TargetName, CSTR PrintName )
{
    BOOL ok = __ChkOkSetErr( !DirExist( LinkName ), ERROR_FILE_EXISTS );
    if (ok) ok = __ChkOkSetErr( !PathIsRelative( TargetName ), ERROR_INVALID_PARAMETER );
    if (ok)
    {
        DWORD error = 0;
        ok = __ChkOkGetErr( CreateDirectory( LinkName, NULL ), &error );
        if (ok)
        {
            WORD Flags = CNSF_MOUNTPOINT| CNSF_DIRECTORY;

            if (!PrintName) PrintName = TargetName;
            TargetName = SkipPathPrefix( TargetName );
            TargetName = _AbsTargetPrefixPath( TargetName );

            ok = __ChkOkGetErr( _CreateNameSurrogate(
                LinkName, TargetName, PrintName, Flags
                ), &error );

            if (ok) _ShNfyDirOf( LinkName, SHCNE_MKDIR );
            else RemoveDirectory( LinkName ); // Defer to OS error checks..
        }
        if (!ok && error) SetLastError( error );
    }
    return bool_cast( ok );
}

//++ DeleteJunction ++-------------------------------------------------------------------

bool DeleteJunctionDir( CSTR DirName )
{
    DWORD error = 0;
    BOOL ok = __ChkOkGetErr( IsJunctionDir( DirName ), &error );
    if (ok)
    {
        // This call may be superfluous since we're deleting the directory,
        // and the FS would have to remove it anyway. Alas, it's unspecified
        // whether it would do so or return an error, so play it safe.

        ok = __ChkOkGetErr( RemoveReparseData( DirName ), &error );

        // Since a junction can only be created on an empty directory
        // in the first place, there's no reason to verify it's empty.
        // If the IoCtl succeeded, we can go ahead and delete it.

        if ( ok ) RemoveDirectory( DirName );
        // FIXME? Notify parent dir of deletion..
        if ( ok ) _ShNfyDirOf( DirName, SHCNE_RMDIR );
    }
    if (!ok && error) SetLastError( error );
    return bool_cast( ok );
}

//++ CreateSymLink ++--------------------------------------------------------------------

bool CreateSymLink( CSTR LinkName, CSTR TargetName, CSTR PrintName )
{
    DWORD LnkAttr = GetFileAttributes( LinkName ); // Link must *not* exist.
    BOOL ok = __ChkOkSetErr( LnkAttr == _BAD_ATTRIBUTE, ERROR_FILE_EXISTS );
    if (ok)
    {
        BOOL TrgRelative = PathIsRelative( TargetName );
        if (!PrintName) PrintName = TargetName; // Before re-prefixing

        // If target is relative, change dir to the link path, since the target path
        // is relative to it, else make sure the target name is prefixed correctly.

        CSTR saveDir = NULL;
        if (TrgRelative) saveDir = __ChangeToDirOf( LinkName );
        else TargetName = _AbsTargetPrefixPath( TargetName );

        // Determine if target is a directory or file, so we
        // know if we should create and emtpy file or directory.

        DWORD TrgAttr = GetFileAttributes( TargetName ); // Target must exist.
        ok = __ChkOkSetErr( TrgAttr != _BAD_ATTRIBUTE, ERROR_FILE_NOT_FOUND );
        if (ok)
        {
            WORD Flags = CNSF_SYMLINK;
            if (TrgRelative) Flags |= CNSF_RELATIVE;

            BOOL ObjCreated, TrgIsDir = (TrgAttr & FILE_ATTRIBUTE_DIRECTORY);
            LPSECURITY_ATTRIBUTES pSec = NULL; // PONDER: Use &DefSec ..?
            if (TrgIsDir)
            {
                ok = ObjCreated = CreateDirectory( LinkName, pSec );
                Flags |= CNSF_DIRECTORY;
            }
            else // Target ia a file..
            {
                HANDLE hFile = CreateFile( LinkName, GENERIC_WRITE, 0, pSec, CREATE_NEW, 0, NULL );
                ok = ObjCreated = (hFile != _BAD_HANDLE);
                if (ok) CloseHandle( hFile );
            }

            if (ok) ok = _CreateNameSurrogate( LinkName, TargetName, PrintName, Flags );

            if (!ok && ObjCreated)
            {
                if (TrgIsDir) RemoveDirectory( LinkName );
                else DeleteFile( LinkName );
            }
        }

        if (saveDir) DoneDirectory( saveDir );
    }
    return  bool_cast( ok );
}

//++ GetReparseTarget ++-----------------------------------------------------------------

#pragma warning( disable: 4996 )
#if 1 // version 2 - so far, so good

static const WCHAR _BSLASH = L'\\';

//
// TODO: Factorize GetReparseTarget to facilitate recursive surrogate expansion
// to produce correct results for nested reparse paths. In particular, focus on
// relative surrogates (only in symlinks), as they are the problematic ones..
//

INT GetReparseTarget(
    CSTR LinkName, TSTR SubstPath, UINT cchSubst, TSTR PrintName, UINT cchPrint,
    PULARGE_INTEGER AttrTag
    )
{
    INT ccTarget = 0; // Result
    ULARGE_INTEGER attr = GetAttributeAndReparseTag( LinkName );

    if (AttrTag) *AttrTag = attr;
    if (!SubstPath || !cchSubst) SetLastError( ERROR_INVALID_PARAMETER );
    else if (_IsNameSurrogateTag( attr.HighPart )) // Mount point or symlink.
    {
        HANDLE hLink = _OpenReparsePoint( LinkName, FILE_READ_ATTRIB_EA, FILE_SHARE_READ );
        if (hLink)
        {
            ULARGE_INTEGER info = _GetReparseData( hLink, NULL, 0 ); // Query buf requirement
            if (info.QuadPart)
            {
                WORD ccTemp = 520, cbTemp = ccTemp * WCHAR_SIZE;
                WORD ccSubst = 260, cbSubst = ccSubst * WCHAR_SIZE;
                WORD ccPrint = 260, cbPrint = ccPrint * WCHAR_SIZE;
                PVOID pvBuf = mem_Alloc( info.LowPart + cbSubst + cbPrint + 2*cbTemp );
                if (pvBuf)
                {
                    PREPARSE_DATA_BUFFER prpd = (PREPARSE_DATA_BUFFER) pvBuf;
                    WSTR pwSubst = WSTR( PBYTE(pvBuf) + info.LowPart );
                    WSTR pwPrint = pwSubst + ccSubst;
                    WSTR pwTemp = pwPrint + ccPrint;
                    //WSTR pwTemp2 = pwTemp + ccTemp;

                    info = _GetReparseData( hLink, prpd, info.LowPart );
                    if (info.HighPart) // If we got the tag it was successful.
                    {
                        if (_GetNameSurrogates( prpd, pwSubst, pwPrint ))
                        {
                            TRACE( DP_DEBUG, _F("Subst: '%S', Print: '%S'\n"), pwSubst, pwPrint );
                            BOOL ok = true;
                            if ((prpd->ReparseTag == IO_REPARSE_TAG_SYMLINK)
                            && (prpd->SymbolicLinkReparseBuffer.Flags & SYMLINK_FLAG_RELATIVE))
                            {
                                // Nota bene: FSCTL_GET_REPARSE_POINT returns incomplete
                                // relative results for symlinks under other FS links!
                                //
                                // F.ex: Here "Links\" is itself a directory symlink and "SymLink-Ref\"
                                // and "slnk-DumpDlg.cxx" are other symlinks in that directory..
                                // The IOCTL returns an incomplete relative path...
                                //
                                // ERROR: LinkName       : F:\Source\CLib\uLib\tests\LinkTest\Links\SymLink-Ref\
                                // ERROR:   -> Relative  : ..\..\ref (incomplete)
                                // Should be   Relative  : ..\..\..\uLibLabs\Test\Links\..\..\ref
                                // ERROR:   -> Composite : F:\Source\CLib\uLib\tests\LinkTest\Links\..\..\ref
                                // ERROR:   -> Result    : F:\Source\CLib\uLib\tests\ref
                                // Should be   Result    : F:\Source\CLib\uLibLabs\ref

                                // PONDER: A somewhat cumbersome workaround here would be to recurse towards
                                // the root dir and concatenate the relative paths until we get a non-relative
                                // base dir, and then canonicalize the totality of it.
                                // This is probably best implementead by factorizing this function
                                // and implementing a static workroutine that resturns a status value
                                // indicating whether the reparse data is absolute or relative.

                                #if 1 // This is beset by the above dilemma..
                                {
                                  #ifdef _UNICODE
                                    WSTR pwCat = wcsnecpy( pwTemp, LinkName, ccTemp );
                                  #else
                                    int ccXlate = MultiByteToWideChar( CP_ACP, 0, LinkName,-1, pwTemp, ccTemp );
                                    WSTR pwCat = ccXlate ? pwTemp + ccXlate - 1 : pwTemp; // -1 takes pwCat to the NUL terminator..
                                  #endif
                                    // For directories, we remove any trailing '\' before wcsrchr().

                                    if (BITS_SET( FILE_ATTRIBUTE_DIRECTORY, attr.LowPart )
                                        && (*--pwCat == _BSLASH)) *pwCat = 0; // Remove ending backslash

                                    // Now replace the link name (filename or terminal subpath) with
                                    // the relative reparse path, so PathCanonicalize() works out right.
                                    // We insert the reparse path after the preceeding '\'.

                                    pwCat = 1 + wcsrchr( pwTemp, _BSLASH ); // '\' preceding link name
                                    wcscpy( pwCat, pwSubst ); // Add the relative target path
                                }
                                #else
                                {
                                    // TODO: Recurse the path and concatenate substitutes
                                    // to work around the multihop relative link shortcoming.
                                }
                                #endif
                                // Finally

                                ok = PathCanonicalizeW( pwSubst, pwTemp );
                                if (ok) ccTarget = 1 + (UINT) wcslen( pwSubst ); // Incl NUL
                                else SetLastError( ERROR_INVALID_REPARSE_DATA );
                            }
                            if (ok) // Final sanity check..
                            {
                                DWORD linkAttr = GetFileAttributesW( pwSubst );
                                if (linkAttr == _BAD_ATTRIBUTE)
                                    SetLastError( ERROR_INVALID_REPARSE_DATA ); // In lieu of a more precise errcode..
                                else
                                {
                                    // Emit the reparsed path to the caller's buffer.
                                    // The print name is emitted only if caller wants it.
                                  #ifdef _UNICODE
                                    WSTR wzEnd = wcsnecpy( SubstPath, pwSubst, cchSubst );
                                    ccTarget = INT( wzEnd - SubstPath + 1);
                                    if (PrintName) wcsnecpy( PrintName, pwPrint, cchPrint );
                                  #else
                                    ccTarget = WideCharToMultiByte(
                                        CP_ACP, 0, pwSubst,-1, SubstPath, cchSubst, NULL, NULL );
                                    if (PrintName) WideCharToMultiByte(
                                        CP_ACP, 0, pwPrint,-1, PrintName, cchPrint, NULL, NULL );
                                  #endif
                                }
                            }
                        }
                    }
                    mem_Free( pvBuf );
                }
            }
            CloseHandle( hLink );
        }
    }
    return ccTarget;
}
#else // version 1 - R&D
INT GetReparseTarget(
    IN CSTR LinkName, OUT TSTR TargetBuf, IN UINT BufLen,
    OPTOUT PULARGE_INTEGER AttrTag
    )
{
    INT ccTarget = 0; // Result
    ULARGE_INTEGER attr = GetAttributeAndReparseTag( LinkName );

    if (AttrTag) *AttrTag = attr;
    if (!TargetBuf || !BufLen) SetLastError( ERROR_INVALID_PARAMETER );
    else
    {
        if (!IsReparseTagValid( attr.HighPart ))
            SetLastError( ERROR_INVALID_DATA ); // Not a proper tag..
        else if (!IsReparseTagNameSurrogate( attr.HighPart ))
            SetLastError( ERROR_NOT_SUPPORTED ); // Nothing known to resolve..
        else
        {
            //HANDLE hLink = CheckHandle( CreateFile(
            //    LinkName, FILE_READ_ATTRIBUTES, FILE_SHARE_READ, NULL, OPEN_EXISTING,
            //    FILE_FLAG_OPEN_REPARSE_POINT| FILE_FLAG_BACKUP_SEMANTICS,
            //    NULL
            //    ));
            HANDLE hLink = _OpenReparsePoint( LinkName, FILE_READ_ATTRIBUTES, FILE_SHARE_READ );
            if (hLink) // (else there's a last error already in place)
            {
                static const UINT bufSize = MAX_REPARSE_BUFFER;
                PVOID rpdBuf = mem_Alloc( bufSize );
                DWORD cbRd, ccTrans;
                #ifdef _UNICODE
                UNUSED( ccTrans );
                #endif

                if (rpdBuf && DeviceIoControl(
                    hLink, FSCTL_GET_REPARSE_POINT, NULL,0, rpdBuf, bufSize, &cbRd, NULL ))
                {
                    if (!IsReparseTagMicrosoft( attr.HighPart )) // ISV tag
                    {
                        // FIXME: This will *never* be reached since a GUID repoint is *not* a name surrogate..!
                        // Put it under !IsReparseTagNameSurrogate or remove it.

                        PREPARSE_GUID_DATA_BUFFER pIsv = (PREPARSE_GUID_DATA_BUFFER) rpdBuf;
                        ccTarget = pIsv->ReparseDataLength;
                      #if 1 // Nothing known to resolve.. Probably can't do anything with it..
                        memcpy( TargetBuf, pIsv->GenericReparseBuffer.DataBuffer, min( (int)BufLen, ccTarget ));
                        //..or perhaps GetGUIDString( pIsv->ReparseGuid, TargetBuf, BufLen );
                      #endif
                        ccTarget = -ccTarget; // As documented...
                        SetLastError( ERROR_NOT_SUPPORTED );
                    }
                    else // Microsoft tag
                    {
                        PREPARSE_DATA_BUFFER rpd = (PREPARSE_DATA_BUFFER) rpdBuf;
                        #define _wchLen(_wcb) (_wcb / WCHAR_SIZE)
                        #define _prnStr(_rps) (_rps.PathBuffer + _wchLen(_rps.PrintNameOffset))
                        static const WCHAR _BSLASH = L'\\';

                        // Use the rear end of the 16kB buffer for temp strings (3-4kB)..

                        PWSTR pwTarget = PWSTR( rpdBuf ) + _wchLen( bufSize ) - 512; // tmpbuf for target (512 WCHAR)
                        PWSTR pwComposite = pwTarget - 1024; // temp buffer for relative composite
                        IF_DEBUG( PWSTR pwRelative = pwComposite - 512; ) // copy of relative result
                        PWSTR pwPrint;

                        switch( attr.HighPart )
                        {
                        case IO_REPARSE_TAG_IIS_CACHE: // Unknown to me..
                            TRACE( DP_DEBUG, _F("IIS_CACHE: %s\n"), LinkName );
                            SetLastError( ERROR_NOINTERFACE ); //ERROR_CANNOT_COPY, ERROR_INVALID_REPARSE_DATA, ERROR_REPARSE_OBJECT, ERROR_FOUND_OUT_OF_SCOPE
                            break;

                        case IO_REPARSE_TAG_MOUNT_POINT:
                            pwPrint = _prnStr( rpd-> MountPointReparseBuffer ); // "X:\somepath"
                            ccTarget = 1 + _wchLen( rpd-> MountPointReparseBuffer.PrintNameLength ); // Incl NUL
                            wcsncpyz( pwTarget, pwPrint, ccTarget );
                            goto __putResult;

                        case IO_REPARSE_TAG_SYMLINK:
                            // FIXME: Do *not* assume that Subst is at offset 0 of PathBuffer..!

                            pwPrint = _prnStr( rpd-> SymbolicLinkReparseBuffer ); // NB: Not null terminated
                            ccTarget = 1 + _wchLen( rpd-> SymbolicLinkReparseBuffer.PrintNameLength ); // Incl NUL
                            wcsncpyz( pwTarget, pwPrint, ccTarget );
                          #if _DEBUG
                            {
                                WCHAR _wzSubst[ MAX_PATH ], _wzPrint[ MAX_PATH ];
                                memset( _wzSubst, 0, sizeof(_wzSubst) );
                                memset( _wzPrint, 0, sizeof(_wzPrint) );
                                wcsncpyz( _wzSubst, // The following two lines are so Microsofty it makes me nauseous..
                                    &rpd->SymbolicLinkReparseBuffer.PathBuffer[ rpd->SymbolicLinkReparseBuffer.SubstituteNameOffset / WCHAR_SIZE ],
                                    (rpd->SymbolicLinkReparseBuffer.SubstituteNameLength  / WCHAR_SIZE ) + 1
                                    );
                                wcsncpyz( _wzPrint, // dito..
                                    &rpd->SymbolicLinkReparseBuffer.PathBuffer[ rpd->SymbolicLinkReparseBuffer.PrintNameOffset / WCHAR_SIZE ],
                                    (rpd->SymbolicLinkReparseBuffer.PrintNameLength / WCHAR_SIZE) + 1
                                    );
                                DPrint( DP_DEBUG, _F("Subst: %S, Print: %S\n"), _wzSubst, _wzPrint );
                            }
                          #endif
                            if (rpd->SymbolicLinkReparseBuffer.Flags & SYMLINK_FLAG_RELATIVE)
                            {
                                // Nota Bene: FSCTL_GET_REPARSE_POINT returns flawed
                                // results for relative symlinks under other links.
                                // See the sanity check further down...
                              #ifdef _UNICODE
                                PWSTR pwCat = wcsecpy( pwComposite, LinkName );
                              #else
                                PWSTR pwCat = pwComposite - 1 // -1 takes us to the NUL terminator..
                                    + MultiByteToWideChar( CP_ACP, 0, LinkName,-1, pwComposite,1024 );
                              #endif

                                // For directories, we replace the link terminal subpath
                                // (the link name) with the relative reparse path, so that
                                // PathCanonicalize will work out right.

                                if (BITS_SET( FILE_ATTRIBUTE_DIRECTORY, attr.LowPart )
                                    && (*--pwCat == _BSLASH)) *pwCat = 0; // Remove ending backslash

                                pwCat = 1 + wcsrchr( pwComposite, _BSLASH ); // '\' preceding link name
                                wcscpy( pwCat, pwTarget ); // Add the relative target path
                                IF_DEBUG( wcscpy( pwRelative, pwTarget ); ) // save a copy

                                if (PathCanonicalizeW( pwTarget, pwComposite ))
                                    ccTarget = 1 + (UINT) wcslen( pwTarget ); // Incl NUL
                                else ccTarget = -ccTarget; // Error
                            }

                        __putResult:
                            if (ccTarget > 0) // If not already in error
                            {
                                if ((int)BufLen < ccTarget)
                                {
                                    SetLastError( ERROR_INSUFFICIENT_BUFFER );
                                    ccTarget = -ccTarget;
                                }
                                else
                                {
                                  #ifdef _UNICODE
                                    wcsncpyz( TargetBuf, pwTarget, BufLen ); // ccTarget status quo
                                  #else
                                    ccTrans = WideCharToMultiByte( CP_ACP, 0, pwTarget,-1, TargetBuf, BufLen, NULL, NULL );
                                    if (!ccTrans) ccTarget = -ccTarget;
                                  #endif

                                    // Do a sanity check on the resulting path..

                                    DWORD trgAttr = GetFileAttributes( TargetBuf );
                                    if (trgAttr == _BAD_ATTRIBUTE) // If target doesn't exist
                                    {
                                        ccTarget = 0;
                                        SetLastError( ERROR_INVALID_REPARSE_DATA );

                                        TRACE( DP_ERROR, _F("LinkName       : %s\n"), LinkName );
                                        TRACE( DP_ERROR, _F("  -> Relative  : %S\n"), pwRelative );
                                        TRACE( DP_ERROR, _F("  -> Composite : %S\n"), pwComposite );
                                        TRACE( DP_ERROR, _F("  -> Result    : %s\n"), TargetBuf );

                                        // FSCTL_GET_REPARSE_POINT returns flawed relative results
                                        // for symlinks under other FS links !!!
                                        //
                                        // F.ex: Here "Links\" is itself a directory symlink and "SymLink-Ref\"
                                        // and "slnk-DumpDlg.cxx" are other symlinks in that directory..
                                        // The IOCTL returns an incomplete relative path...
                                        //
                                        // ERROR: LinkName       : F:\Source\CLib\uLib\tests\LinkTest\Links\SymLink-Ref\
                                        // ERROR:   -> Relative  : ..\..\ref (incomplete)
                                        // Should be   Relative  : ..\..\..\uLibLabs\Test\Links\..\..\ref
                                        // ERROR:   -> Composite : F:\Source\CLib\uLib\tests\LinkTest\Links\..\..\ref
                                        // ERROR:   -> Result    : F:\Source\CLib\uLib\tests\ref
                                        // Should be   Result    : F:\Source\CLib\uLibLabs\ref

                                        // PONDER: A somewhat cumbersome workaround here would be to recurse towards
                                        // the root dir and concatenate the relative paths until we get a non-relative
                                        // base dir, and then canonicalize the totality of it.
                                        // This is probably best implementead by factorizing this function
                                        // and implementing a static workroutine that resturns a status value
                                        // indicating whether the reparse data is absolute or relative.
                                    }
                                }
                            }
                            break;

                        default:
                            TRACE( DP_DEBUG, _F("Tag=0x%08X: '%s', Target unknown.\n"), attr.HighPart, LinkName );
                            break;
                        }
                        #undef _wchLen
                        #undef _prnStr
                    } // Microsoft tag
                }
                rpdBuf = mem_Free( rpdBuf );
                CloseHandle( hLink );
            }
        }
    }
    return ccTarget;
}
#endif
#pragma warning( default: 4996 )

// EOF