1139 lines
36 KiB
C
1139 lines
36 KiB
C
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1997.
|
|
//
|
|
// File: license.h
|
|
//
|
|
// Contents:
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// History: 12-03-97 FredCh Created
|
|
// 12-16-97 v-sbhatt Modified
|
|
// 12-22-97 HueiWang Add Extension OID
|
|
// 12-23-97 HueiWang Use structure instead of multiple OID
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#ifndef _LICENSE_H_
|
|
#define _LICENSE_H_
|
|
|
|
#include "platform.h"
|
|
|
|
#if defined(_WIN64)
|
|
#define UNALIGNED __unaligned
|
|
#define UNALIGNED64 __unaligned
|
|
#elif !defined (OS_WINCE)
|
|
#define UNALIGNED
|
|
#define UNALIGNED64
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Random number length
|
|
//
|
|
|
|
#define LICENSE_RANDOM 32
|
|
#define LICENSE_PRE_MASTER_SECRET 48
|
|
#define LICENSE_MAC_WRITE_KEY 16
|
|
#define LICENSE_SESSION_KEY 16
|
|
#define LICENSE_MAC_DATA 16
|
|
#define LICENSE_HWID_LENGTH 20
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Licensing protocol versions
|
|
//
|
|
#ifndef OS_WIN16
|
|
#ifndef OS_WINCE
|
|
#define CALL_TYPE _stdcall
|
|
#else
|
|
#define CALL_TYPE
|
|
#endif
|
|
#else
|
|
#define CALL_TYPE
|
|
#endif //CALL_TYPE
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Licensing protocol version
|
|
//
|
|
// The lowest byte of the version DWORD will be the preamble version.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define LICENSE_PROTOCOL_VERSION_1_0 0x00010000
|
|
#define LICENSE_PROTOCOL_VERSION_2_0 0x00020000
|
|
|
|
//
|
|
// INT CompareTLSVersions(VERSION a, VERSION b);
|
|
//
|
|
|
|
#define CompareTLSVersions(a, b) \
|
|
(HIWORD(a) == HIWORD(b) ? LOWORD(a) - LOWORD(b) : \
|
|
HIWORD(a) - HIWORD(b))
|
|
|
|
|
|
#define PREAMBLE_VERSION_1_0 0x01
|
|
#define PREAMBLE_VERSION_2_0 0x02
|
|
#define PREAMBLE_VERSION_3_0 0x03
|
|
|
|
#define LICENSE_CURRENT_PREAMBLE_VERSION PREAMBLE_VERSION_3_0
|
|
|
|
#define LICENSE_TS_40_PROTOCOL_VERSION LICENSE_PROTOCOL_VERSION_1_0 | PREAMBLE_VERSION_2_0
|
|
#define LICENSE_TS_50_PROTOCOL_VERSION LICENSE_PROTOCOL_VERSION_1_0 | PREAMBLE_VERSION_3_0
|
|
#define LICENSE_TS_51_PROTOCOL_VERSION LICENSE_PROTOCOL_VERSION_2_0 | PREAMBLE_VERSION_3_0
|
|
|
|
#define LICENSE_HYDRA_40_PROTOCOL_VERSION LICENSE_TS_40_PROTOCOL_VERSION
|
|
|
|
#if 1
|
|
#define LICENSE_HIGHEST_PROTOCOL_VERSION LICENSE_PROTOCOL_VERSION_1_0 | LICENSE_CURRENT_PREAMBLE_VERSION
|
|
#else
|
|
#define LICENSE_HIGHEST_PROTOCOL_VERSION LICENSE_PROTOCOL_VERSION_2_0 | LICENSE_CURRENT_PREAMBLE_VERSION
|
|
#endif
|
|
|
|
#define GET_PREAMBLE_VERSION( _Version ) ( BYTE )( _Version & 0x000000FF )
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Context flags used by the client and server licensing protocol APIs:
|
|
//
|
|
// LICENSE_CONTEXT_NO_SERVER_AUTHENTICATION
|
|
//
|
|
// Do not authenticate the server. Server authentication is done through
|
|
// validating the server's certificate.
|
|
//
|
|
// LICENSE_CONTEXT_USE_PROPRIETORY_CERT
|
|
//
|
|
// Use in conjunction with the LICENSE_CONTEXT_NO_SERVER_AUTHENTICATION
|
|
// flag to let that server know that a proprietory certificate has
|
|
// been transmitted to the client.
|
|
//
|
|
// LICENSE_CONTEXT_USE_X509_CERT
|
|
//
|
|
// Use in conjunction with the LICENSE_CONTEXT_NO_SERVER_AUTHENTICATION
|
|
// flag to let that server know that an X509 certificate has
|
|
// been transmitted to the client.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define LICENSE_CONTEXT_NO_SERVER_AUTHENTICATION 0x00000001
|
|
#define LICENSE_CONTEXT_USE_PROPRIETORY_CERT 0x00000002
|
|
#define LICENSE_CONTEXT_USE_X509_CERT 0x00000004
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Hydra subtree Specific OID
|
|
//
|
|
#define szOID_PKIX_HYDRA_CERT_ROOT "1.3.6.1.4.1.311.18"
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// License Info root at 1.3.6.1.4.1.311.18.1
|
|
//
|
|
// Reserved
|
|
//
|
|
#define szOID_PKIX_LICENSE_INFO "1.3.6.1.4.1.311.18.1"
|
|
|
|
//
|
|
// structure for License Info
|
|
//
|
|
|
|
typedef struct __LicenseInfo {
|
|
|
|
DWORD dwVersion;
|
|
DWORD dwQuantity;
|
|
WORD wSerialNumberOffset;
|
|
WORD wSerialNumberSize;
|
|
WORD wScopeOffset;
|
|
WORD wScopeSize;
|
|
WORD wIssuerOffset;
|
|
WORD wIssuerSize;
|
|
BYTE bVariableDataStart[1];
|
|
|
|
} CERT_LICENSE_INFO;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef CERT_LICENSE_INFO FAR * LPCERT_LICENSE_INFO;
|
|
#else
|
|
typedef CERT_LICENSE_INFO *LPCERT_LICENSE_INFO;
|
|
#endif //OS_WIN16
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Manufacturer value 1.3.6.1.4.1.311.18.2
|
|
// DWORD for manufacturer data
|
|
//
|
|
#define szOID_PKIX_MANUFACTURER "1.3.6.1.4.1.311.18.2"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Manufacturer Specfic Data
|
|
//
|
|
// Reserved
|
|
//
|
|
#define szOID_PKIX_MANUFACTURER_MS_SPECIFIC "1.3.6.1.4.1.311.18.3"
|
|
|
|
// structure for MS manufacturer specific data
|
|
typedef struct __MSManufacturerData {
|
|
DWORD dwVersion; // bit 31 - 1 Temp. License.
|
|
DWORD dwPlatformID;
|
|
DWORD dwLanguageID;
|
|
WORD dwMajorVersion;
|
|
WORD dwMinorVersion;
|
|
WORD wProductIDOffset;
|
|
WORD wProductIDSize;
|
|
BYTE bVariableDataStart[1];
|
|
} MSMANUFACTURER_DATA;
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// OID for Certificate Version Stamp
|
|
//
|
|
// Reserved.
|
|
//
|
|
#define szOID_PKIX_HYDRA_CERT_VERSION szOID_PKIX_HYDRA_CERT_ROOT ".4"
|
|
|
|
#define TERMSERV_CERT_VERSION_UNKNOWN 0xFFFFFFFF
|
|
#define TERMSERV_CERT_VERSION_BETA 0x00000000 // Beta2 license
|
|
#define TERMSERV_CERT_VERSION_NO_CERT 0x00010000 // New License without
|
|
// license server's
|
|
// certificate
|
|
#define TERMSERV_CERT_VERSION_RC1 0x00010001 // New license with
|
|
// license server's
|
|
// certificate
|
|
|
|
//
|
|
// We don't support this certificate format.
|
|
//
|
|
//#define HYDRA_CERT_VERSION_CURRENT 0x00020001 // License issued by
|
|
// // enforce version of
|
|
// // license server
|
|
|
|
#define TERMSERV_CERT_VERSION_MAJOR(x) HIWORD(x)
|
|
#define TERMSERV_CERT_VERSION_MINOR(x) LOWORD(x)
|
|
#define TERMSERV_CERT_VERSION_CURRENT 0x00050001
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// OID for License Server to identify licensed product.
|
|
//
|
|
#define szOID_PKIX_LICENSED_PRODUCT_INFO szOID_PKIX_HYDRA_CERT_ROOT ".5"
|
|
|
|
//
|
|
// dwFlags in LICENSED_VERSION_INFO
|
|
//
|
|
// Bit 31 - 1 if temporary license, 0 if perm. license
|
|
// Bit 24 to 30 - Any flag specific to temporary license, currently, there is none.
|
|
// Bit 23 - 1 if RTM License, 0 if beta license.
|
|
// Bit 16 to 22 - License server version.
|
|
// Bit 20 to 22 - Major version.
|
|
// Bit 16 to 19 - Minor version.
|
|
// Bit 15 - Enforce license server.
|
|
// Bit 0 to 3 is reserved by license server for internal use.
|
|
// Other bits are not use.
|
|
//
|
|
#define LICENSED_VERSION_TEMPORARY 0x80000000
|
|
#define LICENSED_VERSION_RTM 0x00800000
|
|
#define LICENSE_ISSUER_ENFORCE_TYPE 0x00008000
|
|
|
|
#define GET_LICENSE_ISSUER_VERSION(dwVersion) \
|
|
(((dwVersion) & 0x007F0000) >> 16)
|
|
|
|
#define GET_LICENSE_ISSUER_MAJORVERSION(dwVersion) \
|
|
(((dwVersion) & 0x00700000) >> 20)
|
|
|
|
#define GET_LICENSE_ISSUER_MINORVERSION(dwVersion) \
|
|
(((dwVersion) & 0x000F0000) >> 16)
|
|
|
|
#define IS_LICENSE_ISSUER_ENFORCE(dwVersion) \
|
|
(((dwVersion) & LICENSE_ISSUER_ENFORCE_TYPE) > 0)
|
|
|
|
#define IS_LICENSE_ISSUER_RTM(dwVersion) \
|
|
(((dwVersion) & LICENSED_VERSION_RTM) > 0)
|
|
|
|
|
|
typedef struct _LicensedVersionInfo {
|
|
WORD wMajorVersion; // Product Major Version
|
|
WORD wMinorVersion; // Product Minor Version
|
|
DWORD dwFlags; // Product version specific flags
|
|
} LICENSED_VERSION_INFO;
|
|
|
|
#define LICENSED_PRODUCT_INFO_VERSION 0x0003000
|
|
|
|
typedef struct _LicensedProductInfo {
|
|
DWORD dwVersion; // structure version identifier
|
|
DWORD dwQuantity; // number of licenses
|
|
DWORD dwPlatformID; // Client platform ID
|
|
DWORD dwLanguageID; // Licensed Language ID
|
|
|
|
WORD wOrgProductIDOffset; // Offset to original licensed Product ID
|
|
WORD wOrgProductIDSize; // Size of original licensed product ID
|
|
|
|
WORD wAdjustedProductIdOffset; // Policy modified licensed product Id
|
|
WORD wAdjustedProductIdSize; // size of Policy modified licensed Id.
|
|
|
|
WORD wVersionInfoOffset; // Offset to array of LicensedVersionInfo
|
|
WORD wNumberOfVersionInfo; // Number of VersionInfo entries
|
|
BYTE bVariableDataStart[1]; // Variable data start.
|
|
} LICENSED_PRODUCT_INFO;
|
|
|
|
//
|
|
// OID for License Server specific info.
|
|
//
|
|
#define szOID_PKIX_MS_LICENSE_SERVER_INFO szOID_PKIX_HYDRA_CERT_ROOT ".6"
|
|
#define MS_LICENSE_SERVER_INFO_VERSION1 0x0001000
|
|
#define MS_LICENSE_SERVER_INFO_VERSION2 0x0003000
|
|
|
|
//
|
|
// Version 1 structure
|
|
//
|
|
typedef struct _MsLicenseServerInfo10 {
|
|
DWORD dwVersion;
|
|
WORD wIssuerOffset; // Offset to issuer
|
|
WORD wScopeOffset; // Offset to scope
|
|
BYTE bVariableDataStart[1];
|
|
} MS_LICENSE_SERVER_INFO10;
|
|
|
|
typedef struct _MsLicenseServerInfo {
|
|
DWORD dwVersion;
|
|
WORD wIssuerOffset; // Offset to issuer
|
|
WORD wIssuerIdOffset; // offset to issuer's setup ID
|
|
WORD wScopeOffset; // Offset to scope
|
|
BYTE bVariableDataStart[1];
|
|
} MS_LICENSE_SERVER_INFO;
|
|
|
|
|
|
//---------------------------------------------------------------------------
|
|
//
|
|
// Extension OID reserved for product policy module - only one is allowed.
|
|
//
|
|
#define szOID_PKIS_PRODUCT_SPECIFIC_OID szOID_PKIX_HYDRA_CERT_ROOT ".7"
|
|
|
|
//
|
|
//
|
|
//
|
|
#define szOID_PKIS_TLSERVER_SPK_OID szOID_PKIX_HYDRA_CERT_ROOT ".8"
|
|
|
|
//
|
|
// Save certificate chain into memory
|
|
// This flag is passed into CertSaveStore() dwSaveAs parameter
|
|
// Open should use same to open the store.
|
|
|
|
#define szLICENSE_BLOB_SAVEAS_TYPE sz_CERT_STORE_PROV_PKCS7
|
|
#define LICENSE_BLOB_SAVEAS_TYPE CERT_STORE_SAVE_AS_PKCS7
|
|
|
|
#define OID_ISSUER_LICENSE_SERVER_NAME szOID_COMMON_NAME
|
|
#define OID_ISSUER_LICENSE_SERVER_SCOPE szOID_LOCALITY_NAME
|
|
|
|
#define OID_SUBJECT_CLIENT_COMPUTERNAME szOID_COMMON_NAME
|
|
#define OID_SUBJECT_CLIENT_USERNAME szOID_LOCALITY_NAME
|
|
#define OID_SUBJECT_CLIENT_HWID szOID_DEVICE_SERIAL_NUMBER
|
|
|
|
|
|
#ifdef OS_WIN16
|
|
typedef MSMANUFACTURER_DATA FAR *LPMSMANUFACTURER_DATA;
|
|
#else
|
|
typedef MSMANUFACTURER_DATA *LPMSMANUFACTURER_DATA;
|
|
#endif //OS_WIN16
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
#define LICENSE_GRACE_PERIOD 60
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Product Info for Hydra
|
|
//
|
|
|
|
#define PRODUCT_INFO_COMPANY_NAME L"Microsoft Corporation"
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// The Product SKU is made up of the following fields:
|
|
// x-y-z where x is the product identifer, y is the version
|
|
// and z and the type.
|
|
//
|
|
|
|
#define PRODUCT_INFO_SKU_PRODUCT_ID L"A02"
|
|
#define PRODUCT_INFO_INTERNET_SKU_PRODUCT_ID L"B96"
|
|
#define PRODUCT_INFO_CONCURRENT_SKU_PRODUCT_ID L"C50" // not the same as what marketing uses, but that's okay
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Microsoft Windows Terminal Server version definition.
|
|
//
|
|
|
|
#define MICROSOFT_WINDOWS_TERMINAL_SERVER_4_0 0x00040000
|
|
#define MICROSOFT_WINDOWS_TERMINAL_SERVER_5_0 0x00050000
|
|
#define MICROSOFT_WINDOWS_TERMINAL_SERVER_5_1 0x00050001
|
|
|
|
|
|
#define CURRENT_TERMINAL_SERVER_VERSION MICROSOFT_WINDOWS_TERMINAL_SERVER_5_1
|
|
|
|
|
|
#define TERMSRV_OS_INDEX_WINNT_5_0 0x00000000
|
|
#define TERMSRV_OS_INDEX_WINNT_5_1 0x00000001
|
|
#define TERMSRV_OS_INDEX_WINNT_POST_5_1 0x00000002
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Scope name
|
|
//
|
|
#ifndef OS_WINCE //SCOPE_NAME is being defined by iprtrmib.h which is included by iphlpapi.h
|
|
#define SCOPE_NAME "microsoft.com"
|
|
#endif
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Maximum product info string length in bytes
|
|
//
|
|
|
|
#define MAX_PRODUCT_INFO_STRING_LENGTH 255
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Different crypt algid definitions
|
|
// We are keeping an option open to generatize it in future
|
|
//
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Key exchange algorithms
|
|
//
|
|
|
|
#define KEY_EXCHANGE_ALG_RSA 1
|
|
#define KEY_EXCHANGE_ALG_DH 2
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Certificate Signature Algorithms
|
|
//
|
|
|
|
#define SIGNATURE_ALG_RSA 1
|
|
#define SIGNATURE_ALG_DSS 2
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Symmetric cryptographic algorithms
|
|
//
|
|
|
|
#define BASIC_RC4_128 1
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// MAC generation algorithms
|
|
//
|
|
|
|
#define MAC_MD5_SHA 1
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// hydra client to hydra server message types
|
|
//
|
|
|
|
#define HC_LICENSE_INFO 0x12
|
|
#define HC_NEW_LICENSE_REQUEST 0x13
|
|
#define HC_PLATFORM_INFO 0x14
|
|
#define HC_PLATFORM_CHALENGE_RESPONSE 0x15
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// hydra server to hydra client message types
|
|
//
|
|
|
|
#define HS_LICENSE_REQUEST 0x01
|
|
#define HS_PLATFORM_CHALLENGE 0x02
|
|
#define HS_NEW_LICENSE 0x03
|
|
#define HS_UPGRADE_LICENSE 0x04
|
|
|
|
#define LICENSE_VERSION_1 0x01
|
|
|
|
|
|
#define GM_ERROR_ALERT 0xFF
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Error and alert codes
|
|
//
|
|
|
|
#define GM_HC_ERR_INVALID_SERVER_CERTIFICATE 0x00000001
|
|
#define GM_HC_ERR_NO_LICENSE 0x00000002
|
|
#define GM_HC_ERR_INVALID_MAC 0x00000003
|
|
#define GM_HS_ERR_INVALID_SCOPE 0x00000004
|
|
#define GM_HS_ERR_INVALID_MAC 0x00000005
|
|
#define GM_HS_ERR_NO_LICENSE_SERVER 0x00000006
|
|
#define GM_HS_ERR_VALID_CLIENT 0x00000007
|
|
#define GM_HS_ERR_INVALID_CLIENT 0x00000008
|
|
#define GM_HS_ERR_LICENSE_UPGRADE 0x00000009
|
|
#define GM_HS_ERR_EXPIRED_LICENSE 0x0000000A
|
|
#define GM_HS_ERR_INVALID_PRODUCTID 0x0000000B
|
|
#define GM_HS_ERR_INVALID_MESSAGE_LEN 0x0000000C
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// License status and status codes
|
|
//
|
|
|
|
typedef DWORD LICENSE_STATUS;
|
|
|
|
#define LICENSE_STATUS_OK 0x00000000
|
|
#define LICENSE_STATUS_OUT_OF_MEMORY 0x00000001
|
|
#define LICENSE_STATUS_INSUFFICIENT_BUFFER 0x00000002
|
|
#define LICENSE_STATUS_INVALID_INPUT 0x00000003
|
|
#define LICENSE_STATUS_INVALID_CLIENT_CONTEXT 0x00000004
|
|
#define LICENSE_STATUS_INITIALIZATION_FAILED 0x00000005
|
|
#define LICENSE_STATUS_INVALID_SIGNATURE 0x00000006
|
|
#define LICENSE_STATUS_INVALID_CRYPT_STATE 0x00000007
|
|
#define LICENSE_STATUS_CONTINUE 0x00000008
|
|
#define LICENSE_STATUS_ISSUED_LICENSE 0x00000009
|
|
#define LICENSE_STATUS_CLIENT_ABORT 0x0000000A
|
|
#define LICENSE_STATUS_SERVER_ABORT 0x0000000B
|
|
#define LICENSE_STATUS_NO_CERTIFICATE 0x0000000C
|
|
#define LICENSE_STATUS_NO_PRIVATE_KEY 0x0000000D
|
|
#define LICENSE_STATUS_SEND_ERROR 0x0000000E
|
|
#define LICENSE_STATUS_INVALID_RESPONSE 0x0000000F
|
|
#define LICENSE_STATUS_CONTEXT_INITIALIZATION_ERROR 0x00000010
|
|
#define LICENSE_STATUS_NO_MESSAGE 0x00000011
|
|
#define LICENSE_STATUS_INVALID_CLIENT_STATE 0x00000012
|
|
#define LICENSE_STATUS_OPEN_STORE_ERROR 0x00000013
|
|
#define LICENSE_STATUS_CLOSE_STORE_ERROR 0x00000014
|
|
#define LICENSE_STATUS_WRITE_STORE_ERROR 0x00000015
|
|
#define LICENSE_STATUS_INVALID_STORE_HANDLE 0x00000016
|
|
#define LICENSE_STATUS_DUPLICATE_LICENSE_ERROR 0x00000017
|
|
#define LICENSE_STATUS_INVALID_MAC_DATA 0x00000018
|
|
#define LICENSE_STATUS_INCOMPLETE_MESSAGE 0x00000019
|
|
#define LICENSE_STATUS_RESTART_NEGOTIATION 0x0000001A
|
|
#define LICENSE_STATUS_NO_LICENSE_SERVER 0x0000001B
|
|
#define LICENSE_STATUS_NO_PLATFORM_CHALLENGE 0x0000001C
|
|
#define LICENSE_STATUS_NO_LICENSE_SERVER_SECRET_KEY 0x0000001D
|
|
#define LICENSE_STATUS_INVALID_SERVER_CONTEXT 0x0000001E
|
|
#define LICENSE_STATUS_CANNOT_DECODE_LICENSE 0x0000001F
|
|
#define LICENSE_STATUS_INVALID_LICENSE 0x00000020
|
|
#define LICENSE_STATUS_CANNOT_VERIFY_HWID 0x00000021
|
|
#define LICENSE_STATUS_NO_LICENSE_ERROR 0x00000022
|
|
#define LICENSE_STATUS_EXPIRED_LICENSE 0x00000023
|
|
#define LICENSE_STATUS_MUST_UPGRADE_LICENSE 0x00000024
|
|
#define LICENSE_STATUS_UNSPECIFIED_ERROR 0x00000025
|
|
#define LICENSE_STATUS_INVALID_PLATFORM_CHALLENGE_RESPONSE 0x00000026
|
|
#define LICENSE_STATUS_SHOULD_UPGRADE_LICENSE 0x00000027
|
|
#define LICENSE_STATUS_CANNOT_UPGRADE_LICENSE 0x00000028
|
|
#define LICENSE_STATUS_CANNOT_FIND_CLIENT_IMAGE 0x00000029
|
|
#define LICENSE_STATUS_CANNOT_READ_CLIENT_IMAGE 0x0000002A
|
|
#define LICENSE_STATUS_CANNOT_WRITE_CLIENT_IMAGE 0x0000002B
|
|
#define LICENSE_STATUS_CANNOT_FIND_ISSUER_CERT 0x0000002C
|
|
#define LICENSE_STATUS_NOT_HYDRA 0x0000002D
|
|
#define LICENSE_STATUS_INVALID_X509_NAME 0x0000002E
|
|
#define LICENSE_STATUS_NOT_SUPPORTED 0x0000002F
|
|
#define LICENSE_STATUS_INVALID_CERTIFICATE 0x00000030
|
|
#define LICENSE_STATUS_NO_ATTRIBUTES 0x00000031
|
|
#define LICENSE_STATUS_NO_EXTENSION 0x00000032
|
|
#define LICENSE_STATUS_ASN_ERROR 0x00000033
|
|
#define LICENSE_STATUS_INVALID_HANDLE 0x00000034
|
|
#define LICENSE_STATUS_CANNOT_MAKE_KEY_PAIR 0x00000035
|
|
#define LICENSE_STATUS_AUTHENTICATION_ERROR 0x00000036
|
|
#define LICENSE_STATUS_CERTIFICATE_REQUEST_ERROR 0x00000037
|
|
#define LICENSE_STATUS_CANNOT_OPEN_SECRET_STORE 0x00000038
|
|
#define LICENSE_STATUS_CANNOT_STORE_SECRET 0x00000039
|
|
#define LICENSE_STATUS_CANNOT_RETRIEVE_SECRET 0x0000003A
|
|
#define LICENSE_STATUS_UNSUPPORTED_VERSION 0x0000003B
|
|
#define LICENSE_STATUS_NO_INTERNET_LICENSE_INSTALLED 0x0000003C
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// State transitions
|
|
//
|
|
|
|
#define ST_TOTAL_ABORT 0x00000001
|
|
#define ST_NO_TRANSITION 0x00000002
|
|
#define ST_RESET_PHASE_TO_START 0x00000003
|
|
#define ST_RESEND_LAST_MESSAGE 0x00000004
|
|
|
|
|
|
#define PLATFORM_WINNT_40 0x00040000
|
|
#define PLATFORM_WINCE_20 0x00020001
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// message exchange supporting structures
|
|
//
|
|
|
|
typedef struct _Product_Info
|
|
{
|
|
DWORD dwVersion;
|
|
DWORD cbCompanyName;
|
|
PBYTE pbCompanyName;
|
|
DWORD cbProductID;
|
|
PBYTE pbProductID;
|
|
} Product_Info;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Product_Info FAR *PProduct_Info;
|
|
#else
|
|
typedef Product_Info *PProduct_Info;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
|
|
typedef struct _Duration
|
|
{
|
|
FILETIME NotBefore;
|
|
FILETIME NotAfter;
|
|
|
|
} Duration;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Duration FAR * PDuration;
|
|
#else
|
|
typedef Duration *PDuration;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
typedef struct _New_License_Info
|
|
{
|
|
DWORD dwVersion; //Added -Shubho
|
|
DWORD cbScope;
|
|
PBYTE pbScope;
|
|
DWORD cbCompanyName;
|
|
PBYTE pbCompanyName;
|
|
DWORD cbProductID;
|
|
PBYTE pbProductID;
|
|
DWORD cbLicenseInfo;
|
|
PBYTE pbLicenseInfo;
|
|
|
|
}New_License_Info;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef New_License_Info FAR * PNew_License_Info;
|
|
#else
|
|
typedef New_License_Info *PNew_License_Info;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// binary blob format to support expanded message format
|
|
//
|
|
|
|
typedef struct _Binary_Blob
|
|
{
|
|
WORD wBlobType;
|
|
WORD wBlobLen;
|
|
PBYTE pBlob;
|
|
|
|
} Binary_Blob;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Binary_Blob FAR * PBinary_Blob;
|
|
#else
|
|
typedef Binary_Blob UNALIGNED* PBinary_Blob;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Binary Blob Data Types
|
|
//
|
|
|
|
#define BB_DATA_BLOB 0x0001
|
|
#define BB_RANDOM_BLOB 0x0002
|
|
#define BB_CERTIFICATE_BLOB 0x0003
|
|
#define BB_ERROR_BLOB 0x0004
|
|
#define BB_DH_KEY_BLOB 0x0005
|
|
#define BB_RSA_KEY_BLOB 0x0006
|
|
#define BB_DSS_SIGNATURE_BLOB 0x0007
|
|
#define BB_RSA_SIGNATURE_BLOB 0x0008
|
|
#define BB_ENCRYPTED_DATA_BLOB 0x0009
|
|
#define BB_MAC_DATA_BLOB 0x000A
|
|
#define BB_INTEGER_BLOB 0x000B
|
|
#define BB_NAME_BLOB 0x000C
|
|
#define BB_KEY_EXCHG_ALG_BLOB 0x000D
|
|
#define BB_SCOPE_BLOB 0x000E
|
|
#define BB_CLIENT_USER_NAME_BLOB 0x000F
|
|
#define BB_CLIENT_MACHINE_NAME_BLOB 0x0010
|
|
|
|
//////////////////////////////////////////////////////
|
|
// Binary Blob Data Version Numbers
|
|
//
|
|
|
|
#define BB_ERROR_BLOB_VERSION 0x0001
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// message exchange structures for licensing protocol
|
|
//
|
|
|
|
typedef struct _Preamble
|
|
{
|
|
BYTE bMsgType; // Contains the type of message
|
|
BYTE bVersion; // Contains the version no. info.
|
|
WORD wMsgSize; // Length of the whole message including PREAMBLE
|
|
|
|
} Preamble;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Preamble FAR * PPreamble;
|
|
#else
|
|
typedef Preamble * PPreamble;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
typedef struct _Scope_List
|
|
{
|
|
DWORD dwScopeCount;
|
|
PBinary_Blob Scopes;
|
|
|
|
} Scope_List;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Scope_List FAR * PScope_List;
|
|
#else
|
|
typedef Scope_List * PScope_List;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
typedef struct _License_Error_Message
|
|
{
|
|
DWORD dwErrorCode;
|
|
DWORD dwStateTransition;
|
|
Binary_Blob bbErrorInfo;
|
|
|
|
} License_Error_Message;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef License_Error_Message FAR * PLicense_Error_Message;
|
|
#else
|
|
typedef License_Error_Message * PLicense_Error_Message;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
typedef struct _Hydra_Client_License_Info
|
|
{
|
|
DWORD dwPrefKeyExchangeAlg;
|
|
DWORD dwPlatformID;
|
|
BYTE ClientRandom[LICENSE_RANDOM];
|
|
Binary_Blob EncryptedPreMasterSecret;
|
|
Binary_Blob LicenseInfo;
|
|
Binary_Blob EncryptedHWID;
|
|
BYTE MACData[LICENSE_MAC_DATA];
|
|
|
|
} Hydra_Client_License_Info;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Hydra_Client_License_Info FAR * PHydra_Client_License_Info;
|
|
#else
|
|
typedef Hydra_Client_License_Info * PHydra_Client_License_Info;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
typedef struct _Hydra_Client_New_License_Request
|
|
{
|
|
DWORD dwPrefKeyExchangeAlg;
|
|
DWORD dwPlatformID;
|
|
BYTE ClientRandom[LICENSE_RANDOM];
|
|
Binary_Blob EncryptedPreMasterSecret;
|
|
Binary_Blob ClientUserName;
|
|
Binary_Blob ClientMachineName;
|
|
|
|
} Hydra_Client_New_License_Request;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Hydra_Client_New_License_Request FAR * PHydra_Client_New_License_Request;
|
|
#else
|
|
typedef Hydra_Client_New_License_Request * PHydra_Client_New_License_Request;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
//
|
|
// High Byte - Major version, Low Byte - Minor version
|
|
//
|
|
#define PLATFORMCHALLENGE_VERSION 0x0100
|
|
|
|
#define CURRENT_PLATFORMCHALLENGE_VERSION PLATFORMCHALLENGE_VERSION
|
|
|
|
//
|
|
// Client Platform Challenge Type
|
|
//
|
|
#define WIN32_PLATFORMCHALLENGE_TYPE 0x0100
|
|
#define WIN16_PLATFORMCHALLENGE_TYPE 0x0200
|
|
#define WINCE_PLATFORMCHALLENGE_TYPE 0x0300
|
|
#define OTHER_PLATFORMCHALLENGE_TYPE 0xFF00
|
|
|
|
|
|
//
|
|
// Client License Detail level -
|
|
//
|
|
// This should be in LicenseRequest but
|
|
// 1) Require changes to RPC interface.
|
|
// 2) Nothing in structure for us to identify version.
|
|
// 3) Current licensing protocol, no way to tell actual client type
|
|
//
|
|
|
|
//
|
|
// client license + license server's self signed
|
|
//
|
|
#define LICENSE_DETAIL_SIMPLE 0x0001
|
|
|
|
//
|
|
// license chain up to issuer of license server's certificate
|
|
//
|
|
#define LICENSE_DETAIL_MODERATE 0x0002
|
|
|
|
//
|
|
// Detail client license chain up to root.
|
|
//
|
|
#define LICENSE_DETAIL_DETAIL 0x0003
|
|
|
|
typedef struct __PlatformChallengeResponseData
|
|
{
|
|
WORD wVersion; // structure version
|
|
WORD wClientType; // client type
|
|
WORD wLicenseDetailLevel; // license detail, TS will re-modify this value
|
|
WORD cbChallenge; // size of client challenge response data
|
|
BYTE pbChallenge[1]; // start of variable length data
|
|
} PlatformChallengeResponseData;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef PlatformChallengeResponseData FAR * PPlatformChallengeResponseData;
|
|
#else
|
|
typedef PlatformChallengeResponseData * PPlatformChallengeResponseData;
|
|
#endif //OS_WIN16
|
|
|
|
#define PLATFORM_CHALLENGE_LENGTH 64
|
|
|
|
typedef struct _Hydra_Client_Platform_Challenge_Response
|
|
{
|
|
Binary_Blob EncryptedChallengeResponse;
|
|
Binary_Blob EncryptedHWID;
|
|
BYTE MACData[LICENSE_MAC_DATA];
|
|
|
|
} Hydra_Client_Platform_Challenge_Response;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Hydra_Client_Platform_Challenge_Response FAR * PHydra_Client_Platform_Challenge_Response;
|
|
#else
|
|
typedef Hydra_Client_Platform_Challenge_Response * PHydra_Client_Platform_Challenge_Response;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
typedef struct _Hydra_Server_License_Request
|
|
{
|
|
BYTE ServerRandom[LICENSE_RANDOM];
|
|
Product_Info ProductInfo;
|
|
Binary_Blob KeyExchngList;
|
|
Binary_Blob ServerCert;
|
|
Scope_List ScopeList;
|
|
|
|
} Hydra_Server_License_Request;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Hydra_Server_License_Request FAR * PHydra_Server_License_Request;
|
|
#else
|
|
typedef Hydra_Server_License_Request * PHydra_Server_License_Request;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
typedef struct _Hydra_Server_Platform_Challenge
|
|
{
|
|
DWORD dwConnectFlags;
|
|
Binary_Blob EncryptedPlatformChallenge;
|
|
BYTE MACData[LICENSE_MAC_DATA];
|
|
|
|
} Hydra_Server_Platform_Challenge;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Hydra_Server_Platform_Challenge FAR * PHydra_Server_Platform_Challenge;
|
|
#else
|
|
typedef Hydra_Server_Platform_Challenge * PHydra_Server_Platform_Challenge;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
typedef struct _Hydra_Server_New_License
|
|
{
|
|
Binary_Blob EncryptedNewLicenseInfo;
|
|
BYTE MACData[LICENSE_MAC_DATA];
|
|
|
|
} Hydra_Server_New_License;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Hydra_Server_New_License FAR * PHydra_Server_New_License;
|
|
#else
|
|
typedef Hydra_Server_New_License * PHydra_Server_New_License;
|
|
#endif //OS_WIN16
|
|
|
|
typedef Hydra_Server_New_License Hydra_Server_Upgrade_License;
|
|
typedef PHydra_Server_New_License PHydra_Server_Upgrade_License;
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Hydra Server Authentication Certificate structures;
|
|
// Here we assume that before Licensing module comes into play
|
|
// the client will somehow notify the Server about the supported
|
|
// Provider and the Hydra Server will accordingly provide
|
|
// appropriate certificate
|
|
//
|
|
|
|
typedef struct _Hydra_Server_Cert
|
|
{
|
|
DWORD dwVersion;
|
|
DWORD dwSigAlgID;
|
|
DWORD dwKeyAlgID;
|
|
Binary_Blob PublicKeyData;
|
|
Binary_Blob SignatureBlob;
|
|
|
|
} Hydra_Server_Cert;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Hydra_Server_Cert FAR * PHydra_Server_Cert;
|
|
#else
|
|
typedef Hydra_Server_Cert * PHydra_Server_Cert;
|
|
#endif //OS_WIN16
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Hydra Client HWID structure
|
|
// Note : We have to finalize on this structure and generation algorithm.
|
|
// Currently we have hardcoded these values in Cryptkey.c. - Shubho
|
|
|
|
typedef struct _HWID
|
|
{
|
|
DWORD dwPlatformID;
|
|
DWORD Data1;
|
|
DWORD Data2;
|
|
DWORD Data3;
|
|
DWORD Data4;
|
|
|
|
} HWID;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef HWID FAR * PHWID;
|
|
#else
|
|
typedef HWID * PHWID;
|
|
#endif //OS_WIN16
|
|
|
|
typedef struct _LicenseRequest
|
|
{
|
|
PBYTE pbEncryptedHwid;
|
|
DWORD cbEncryptedHwid;
|
|
DWORD dwLanguageID;
|
|
DWORD dwPlatformID;
|
|
PProduct_Info pProductInfo;
|
|
|
|
} LICENSEREQUEST;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef LICENSEREQUEST FAR * PLICENSEREQUEST;
|
|
#else
|
|
typedef LICENSEREQUEST * PLICENSEREQUEST;
|
|
#endif //OS_WIN16
|
|
|
|
//
|
|
// dwLicenseVersion Value
|
|
//
|
|
// HYDRA_CERT_VERSION_BETA Beta2 client license
|
|
// HYDRA_CERT_VERSION_NO_CERT Post Beta2 license without certificate chain
|
|
// HYDRA_CERT_VERSION_CURRENT Post Beta2 license with certificate chain
|
|
//
|
|
typedef struct _LicensedProduct
|
|
{
|
|
DWORD dwLicenseVersion;
|
|
DWORD dwQuantity;
|
|
|
|
PBYTE pbOrgProductID; // original license request product Id
|
|
DWORD cbOrgProductID; // size of original license request product Id
|
|
|
|
LICENSEREQUEST LicensedProduct; // licensed product
|
|
LICENSED_VERSION_INFO* pLicensedVersion; // licensed product version
|
|
DWORD dwNumLicensedVersion; // number of licensed product version
|
|
|
|
LPTSTR szIssuer;
|
|
LPTSTR szIssuerId; // license server setup ID
|
|
LPTSTR szIssuerScope;
|
|
LPTSTR szLicensedClient;
|
|
LPTSTR szLicensedUser;
|
|
LPTSTR szIssuerDnsName;
|
|
|
|
HWID Hwid;
|
|
|
|
FILETIME NotBefore; // license's validity
|
|
FILETIME NotAfter;
|
|
|
|
PBYTE pbPolicyData; // Policy specfic extension
|
|
DWORD cbPolicyData; // size of policy specific extension
|
|
ULARGE_INTEGER ulSerialNumber; // Client license's serial number
|
|
} LICENSEDPRODUCT;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef LICENSEDPRODUCT FAR * PLICENSEDPRODUCT;
|
|
#else
|
|
typedef LICENSEDPRODUCT *PLICENSEDPRODUCT;
|
|
#endif //OS_WIN16
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Types of certificate used by the server to authenticate itself to the clients
|
|
//
|
|
// CERT_TYPE_PROPRIETORY
|
|
// Proprietory format certificate
|
|
//
|
|
// CERT_TYPE_X509
|
|
// X509 format certificate
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
typedef enum
|
|
{
|
|
CERT_TYPE_INVALID = 0,
|
|
CERT_TYPE_PROPRIETORY = 1,
|
|
CERT_TYPE_X509 = 2
|
|
|
|
} CERT_TYPE;
|
|
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Ceritificate Blob. Each blob contains an X509 certificate
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
typedef struct _Cert_Blob
|
|
{
|
|
DWORD cbCert; // size of this certificate blob
|
|
BYTE abCert[1]; // beginning byte of this certificate
|
|
|
|
} Cert_Blob;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Cert_Blob FAR * PCert_Blob;
|
|
#else
|
|
typedef Cert_Blob * PCert_Blob;
|
|
#endif //OS_WIN16
|
|
|
|
//+----------------------------------------------------------------------------
|
|
//
|
|
// Certificate chain with a number of certificate blobs
|
|
//
|
|
// The most significant bit denotes whether the certificate that has been
|
|
// issued is temporary. The license server will issue a temporary certificate
|
|
// if it has not yet obtained a certificate from the clearing house.
|
|
//
|
|
// We also assume that the chain is in the order such that each subsequent
|
|
// certificate belongs to the issuer of the previous certificate.
|
|
//
|
|
//+----------------------------------------------------------------------------
|
|
|
|
typedef struct _Cert_Chain
|
|
{
|
|
DWORD dwVersion; // version of this structure
|
|
DWORD dwNumCertBlobs; // Number of certificate blobs
|
|
Cert_Blob CertBlob[1]; // First certificate blob
|
|
|
|
} Cert_Chain;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef Cert_Chain FAR * PCert_Chain;
|
|
#else
|
|
typedef Cert_Chain * PCert_Chain;
|
|
#endif //OS_WIN16
|
|
|
|
#define CERT_CHAIN_VERSION_1 0x00000001
|
|
#define CERT_CHAIN_VERSION_2 0x00000002
|
|
#define MAX_CERT_CHAIN_VERSION CERT_CHAIN_VERSION_2
|
|
|
|
#define GET_CERTIFICATE_VERSION( x ) ( 0x0FFFFFFF & x )
|
|
#define IS_TEMP_CERTIFICATE( x ) ( 0xF0000000 & x )
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// LICENSE_CAPABILITIES
|
|
//
|
|
// Data structure used to initialize a licensing context.
|
|
//
|
|
// KeyExchangeAlg - The key exchange algorithm: RSA or Diffie Helman
|
|
// ProtocolVer - The supported licensing protocol
|
|
// fAuthenticateServer - Whether the client is going to authenticate the server
|
|
// CertType - Indicate the type of certificate that has already been transmitted
|
|
// to the client.
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
typedef struct _LICENSE_CAPABILITIES
|
|
{
|
|
DWORD KeyExchangeAlg;
|
|
DWORD ProtocolVer;
|
|
BOOL fAuthenticateServer;
|
|
CERT_TYPE CertType;
|
|
DWORD cbClientName;
|
|
PBYTE pbClientName;
|
|
|
|
} LICENSE_CAPABILITIES;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef LICENSE_CAPABILITIES FAR * PLICENSE_CAPABILITIES;
|
|
#else
|
|
typedef LICENSE_CAPABILITIES * PLICENSE_CAPABILITIES;
|
|
#endif //OS_WIN16
|
|
typedef PLICENSE_CAPABILITIES LPLICENSE_CAPABILITIES;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// Client licensing info retrievable by terminal server
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
typedef struct _TS_LICENSE_INFO
|
|
{
|
|
ULARGE_INTEGER ulSerialNumber; // Client license's serial number
|
|
|
|
DWORD dwProductVersion;
|
|
PBYTE pbOrgProductID; // original license request product Id
|
|
DWORD cbOrgProductID; // size of original license request product Id
|
|
|
|
BOOL fTempLicense;
|
|
|
|
LPTSTR szIssuer;
|
|
LPTSTR szIssuerId; // license server setup ID
|
|
|
|
FILETIME NotBefore; // license's validity
|
|
FILETIME NotAfter;
|
|
|
|
LPTSTR szLicensedClient; // client's machine name
|
|
LPTSTR szLicensedUser; // client's user name
|
|
|
|
PBYTE pbRawLicense; // storage for marking it later
|
|
DWORD cbRawLicense;
|
|
|
|
DWORD dwSupportFlags;
|
|
|
|
} TS_LICENSE_INFO;
|
|
|
|
#ifdef OS_WIN16
|
|
typedef TS_LICENSE_INFO FAR * PTS_LICENSE_INFO;
|
|
#else
|
|
typedef TS_LICENSE_INFO * PTS_LICENSE_INFO;
|
|
#endif //OS_WIN16
|
|
typedef PTS_LICENSE_INFO LPTS_LICENSE_INFO;
|
|
|
|
// Support Flags: which DCRs are supported
|
|
#define SUPPORT_PER_SEAT_REISSUANCE 0x1
|
|
#define SUPPORT_PER_SEAT_POST_LOGON 0x2
|
|
#define SUPPORT_CONCURRENT 0x4
|
|
#define SUPPORT_WHISTLER_CAL 0x8
|
|
|
|
#define ALL_KNOWN_SUPPORT_FLAGS (SUPPORT_PER_SEAT_REISSUANCE|SUPPORT_PER_SEAT_POST_LOGON|SUPPORT_CONCURRENT|SUPPORT_WHISTLER_CAL)
|
|
|
|
// Mark Flags: bits marking the license
|
|
|
|
#define MARK_FLAG_USER_AUTHENTICATED 0x1
|
|
|
|
|
|
#endif //_LICENSE_H_
|
|
|