Share via


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