ClusDocEx.h

This header file loads the necessary libraries and utilities and defines some useful constants, macros, and functions. For any example to compile, the code from ClusDocEx.h must be available.


#ifndef _CLUSDOCEX_H
#define _CLUSDOCEX_H
//////////////////////////////////////////////////////////////////////
//
//  ClusDocEx.h
//  
//  Defines constants, functions, and macros used by code examples 
//  for the Failover Cluster API as presented in the 
//  Windows SDK documentation.
//
//////////////////////////////////////////////////////////////////////

//  Enable Unicode

    #ifndef UNICODE

        #define UNICODE

    #endif

    #ifndef _UNICODE

        #define _UNICODE

    #endif


//  Windows/WCHAR support

    #include <windows.h>

    #include <tchar.h>

    #include <StrSafe.h>

//  Failover Cluster API Compiler Directives

    #include <ClusAPI.h>                   // Cluster API.

    #include <ResApi.h>                    // Resource API.

    #pragma comment( lib, "ClusAPI.lib" )  // Cluster API library.

    #pragma comment( lib, "ResUtils.lib" ) // Utility Library.

//////////////////////////////////////////////////////////////////////

//  Constants

//  For specifying string and buffer sizes:

    const DWORD ClusDocEx_DEFAULT_CCH = 256; 

    const DWORD ClusDocEx_DEFAULT_CB  = 256 * sizeof( WCHAR );


//////////////////////////////////////////////////////////////////////

//  Functions

//--------------------------------------------------------------------
//  ClusDocEx_ListEntrySize
//
//  Calculates the size of a value list entry based on the
//  byte size of the data. This is an overloaded function
//  that can be called in two ways:
//
//  Arguments:
//
//      cbDataLength [in]  Byte size of the data to be added
//                         as a value list entry.
//                 - OR -
//      lpszData     [in]  NULL-terminated Unicode string containing
//                         the data to be added as a value list entry.
//
//  Return Value:
//
//      (DWORD) Total byte size required for a value list entry
//              containing the data.
//
//--------------------------------------------------------------------
inline
DWORD
WINAPI
ClusDocEx_ListEntrySize
(
    DWORD cbDataLength
)
{
    return
    (
        sizeof( CLUSPROP_VALUE ) +     // Syntax and length.
        ALIGN_CLUSPROP( cbDataLength ) // Data and padding.
    );
}

//--------------------------------------------------------------------
//  ClusDocEx_DebugPrint
//   
//  Displays debug information.
//        
//  Arguments:
//      LPWSTR lpszMessage  [in]  Optional user-defined message.
//      DWORD  dwErrorCode  [in]  Any system error code.
//
//  Return Value:
//      None.
//--------------------------------------------------------------------
inline
void
ClusDocEx_DebugPrint
( 
    LPWSTR lpszMessage,
    DWORD dwErrorCode
)
{
    LPVOID lpMsgBuf = NULL;

//  FormatMessage is a function
    FormatMessage( ( FORMAT_MESSAGE_ALLOCATE_BUFFER |
                     FORMAT_MESSAGE_FROM_SYSTEM ),
                   NULL,
                   dwErrorCode,
                   MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
                   (LPTSTR) &lpMsgBuf,
                   0,
                   NULL );

    wprintf( L"\n(+)\n" );

    if( lpszMessage != NULL )
        wprintf( L"...%ls\n", lpszMessage );

    wprintf( L"...Line %li of %ls\n", __LINE__, __FILE__ );

    wprintf( L"...Result = %li: %ls \n", 
             dwErrorCode, (LPWSTR)lpMsgBuf );

    wprintf( L"(-)\n\n" );

//  Free the buffer allocated by FormatMessage
    LocalFree( lpMsgBuf );
}


//--------------------------------------------------------------------
//  ClusDocEx_ShowBuffer
//
//  Displays a block of memory as a sequence of bytes.
//
//  Arguments:
//
//      lpData     [in]  Pointer to the start of the data to read.
//      cbLength   [in]  Number of bytes to read.
//
//  Return Value:
//
//      None.
//--------------------------------------------------------------------
inline
void
ClusDocEx_ShowBuffer
(
    LPVOID lpData, 
    DWORD cbLength
)
{
    DWORD dw;
    CLUSPROP_BUFFER_HELPER cbh;

    if( lpData != NULL )
    {       
        cbh.pb = (PBYTE) lpData;

        wprintf( L"\n\nBegin...\n\n" );
        wprintf( L"Address   +0  +1  +2  +3  +4  +5  +6  +7  +8  +9  +A  +B  +C  +D  +E  +F\n" );
        wprintf( L"--------  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --\n%08lX  ", cbh.pb );
        
        for( dw = 0 ; dw < cbLength ; dw++ )
        {           
            wprintf( L"%02lX  ", cbh.pb[dw] );
     
            if( ( ( dw + 1 ) % 16 ) == 0 )
                wprintf( L"\n%08lX  ", cbh.pb + dw + 1 );
        }

        wprintf( L"\n\n...end\n\n" );
    }
    else
    {
        wprintf( L"\nNULL buffer.\n\n" );
    }
}

// end ClusDocEx_ShowBuffer


//--------------------------------------------------------------------
//  ClusDocEx_ConvertArg
//
//  Converts single-byte strings to Unicode strings.
//  Used to make command-line arguments and console input
//  ready for use in cluster functions.
//
//  Returns an error code.
//--------------------------------------------------------------------
inline
DWORD
ConvertArg( 
    char *pszArg,       // Single-byte string to convert.
    LPWSTR lpszOut,     // Wide character buffer to return result.
    DWORD cchOutChars   // Size of the buffer as a count of WCHARs.
)
{
    MultiByteToWideChar( 
        CP_ACP,                   // Specifies the code page to use.
        ( MB_PRECOMPOSED |  
          MB_ERR_INVALID_CHARS ), // Flags governing the conversion.
        pszArg,
        -1,
        lpszOut,
        int( cchOutChars )
    );

    return GetLastError();
}


//////////////////////////////////////////////////////////////////////

//  Forward Declarations

void
ClusDocEx_BasicPropertyValueList();

LPVOID 
ClusDocEx_CreateValueListEntry(
    IN DWORD dwSyntax,
    IN DWORD cbLength,
    IN LPVOID lpData,
    OUT LPDWORD lpcbEntrySize
);

DWORD
ClusDocEx_FindSyntax( 
    IN LPVOID lpList,
    IN DWORD cbListSize,
    IN DWORD dwSyntax,
    IN DWORD cbStartPos = 0 
);

void
ClusDocEx_CreateRequiredDependenciesList();

BOOL   
ClusDocEx_NodIsSignatureAvailable(
    IN HCLUSTER hCluster,
    IN HNODE    hNode,
    IN DWORD    dwSignature 
);

LPVOID
ClusDocEx_CreatePropertyListEntry(
    IN LPWSTR lpszPropName,
    IN DWORD dwSyntax,
    IN DWORD cbLength,
    IN LPVOID lpData,
    OUT LPDWORD lpcbEntrySize
);

LPVOID
ClusDocEx_GrpCreatePropertyList(
    LPDWORD lpcbPropListSize,
    DWORD dwAutoFailbackType,
    LPWSTR lpszDescription,
    DWORD dwFailbackWindowEnd,
    DWORD dwFailbackWindowStart,
    DWORD dwFailoverPeriod,
    DWORD dwFailoverThreshold,
    DWORD dwPersistentState 
);

DWORD 
GrpGetRWCDwPropValue( 
    IN HGROUP hGroup,
    IN LPCWSTR lpszPropName,
    OUT LPDWORD lpdwPropValue
);

HCLUSTER ClusDocEx_OpenLocalClusterWithName();

DWORD
ClusDocEx_ResAddPossibleOwner( 
    LPWSTR lpszResourceName,
    LPWSTR lpszNodeName,
    LPWSTR lpszClusterName 
);

LPVOID
ClusDocEx_GrpGetControlCodeOutput(
    IN HGROUP hGroup,
    IN HNODE hNode,
    IN DWORD dwControlCode,
    OUT LPDWORD lpcbResultSize
);

LPVOID
ClusDocEx_NetGetControlCodeOutput(
    IN HNETWORK hNetwork,
    IN HNODE hNode,
    IN DWORD dwControlCode,
    OUT LPDWORD lpcbResultSize
);

LPVOID
ClusDocEx_NICGetControlCodeOutput(
    IN HNETINTERFACE hNetInterface,
    IN HNODE hNode,
    IN DWORD dwControlCode,
    OUT LPDWORD lpcbResultSize
);

LPVOID
ClusDocEx_NodGetControlCodeOutput(
    IN HNODE hNode,
    IN HNODE hHostNode,
    IN DWORD dwControlCode,
    OUT LPDWORD lpcbResultSize
);

LPVOID
ClusDocEx_ResGetControlCodeOutput(
    IN HRESOURCE hResource,
    IN HNODE hNode,
    IN DWORD dwControlCode,
    OUT LPDWORD lpcbResultSize
);

LPVOID
ClusDocEx_RtpGetControlCodeOutput(
    IN LPWSTR lpszType,
    IN HCLUSTER hCluster,
    IN HNODE hNode,
    IN DWORD dwControlCode,
    OUT LPDWORD lpcbResultSize
);

DWORD
ClusDocEx_SetResourceName(
    HRESOURCE hResource,
    LPWSTR lpszResName
);

void
ClusDocEx_ShowBinary( 
    DWORD dwNum 
);

void 
ClusDocEx_ParseCode( 
    char* pName, 
    DWORD dwCode 
);

DWORD ClusDocEx_ParseDword( 
    DWORD dwNumber, 
    int iHighBit, 
    int iLowBit 
);

DWORD 
WINAPI
ClusDocEx_EventPort( 
     LPVOID hCluster
);

void 
ClusDocEx_EventMessage( 
    HCLUSTER hCluster,
    DWORD    dwNotifyKey,
    DWORD    dwFilterType,
    LPWSTR   lpszObjectName 
);

DWORD
ClusDocEx_GrpEnumResources(
    IN HGROUP hGroup,
    IN OUT LPVOID lpOutBuffer,
    IN DWORD  cbOutBufferSize,
    OUT LPDWORD lpcbResultSize
);

LPWSTR
ClusDocEx_ResDescribeState( 
    HRESOURCE hRdsource 
);

DWORD 
ClusDocEx_ResGetRWCDwordProperty(
    IN LPWSTR lpszResName, 
    IN LPWSTR lpszPropName,
    OUT LPDWORD lpdwPropvalue
);

DWORD
ClusDocEx_GrpResetPropertyDefaults( 
    IN HGROUP hGroup 
);

HGROUP
ClusDocEx_GrpCreateVirtualServer(
    IN HCLUSTER hCluster,
    IN LPWSTR   lpszGroupName,
    IN LPWSTR   lpszIPResName,
    IN LPWSTR   lpszNetResName,
    IN LPWSTR   lpszIPAddress,
    IN LPWSTR   lpszNetworkName,
    IN LPWSTR   lpszSubnetMask
);

HRESOURCE
ClusDocEx_ResCreateDisk(
    IN HCLUSTER hCluster,
    IN HGROUP   hGroup,
    IN LPWSTR   lpszDriveLtr
);

HRESOURCE
ClusDocEx_ResCreateIPAddress(
    IN HGROUP hGroup,
    IN LPWSTR lpszResName,
    IN LPWSTR lpszAddress,
    IN LPWSTR lpszNetwork,
    IN LPWSTR lpszSubnetMask
);

HRESOURCE
ClusDocEx_ResCreateNetworkName(
    IN HGROUP    hGroup,
    IN HRESOURCE hIPDependency,
    IN LPWSTR    lpszResName,
    IN LPWSTR    lpszNetName
);

int
ClusDocEx_IsGroupProperty
(
    IN HGROUP hGroup,
    IN LPWSTR lpszPropName
);

LPVOID
ClusDocEx_ResGetRWCProperties(
    IN HRESOURCE hRes,
    IN HNODE     hNode,
    OUT LPDWORD  lpcbDataSize
);

LPWSTR
ClusDocEx_ResGetName(
    IN HRESOURCE hRes,
    IN HNODE     hNode
);

LPVOID
ClusDocEx_ResGetRWPProperties(
    IN HRESOURCE hRes,
    IN HNODE     hNode,
    OUT LPDWORD  lpcbDataSize
);

LPVOID
ClusDocEx_ResGetRegistryCheckpoints(
    IN HRESOURCE hRes,
    IN HNODE     hNode,
    OUT LPDWORD  lpcbDataSize
);

LPVOID
ClusDocEx_ResGetRequiredDependencies(
    IN HRESOURCE hRes,
    IN HNODE     hNode,
    OUT LPDWORD  lpcbDataSize
);

LPWSTR
ClusDocEx_ResGetResourceType(
    IN HRESOURCE hRes,
    IN HNODE     hNode
);

LPVOID
ClusDocEx_ResGetROCProperties(
    IN HRESOURCE hRes,
    IN HNODE     hNode,
    OUT LPDWORD  lpcbDataSize
);

LPVOID
ClusDocEx_ResGetROPProperties(
    IN HRESOURCE hRes,
    IN HNODE     hNode,
    OUT LPDWORD  lpcbDataSize
);

//////////////////////////////////////////////////////////////////////

#endif

// end ClusDocEx.h

 

 

Show: