archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/termsrv/license/tlserver/tlsdb/lictab.cpp

1154 lines
29 KiB
Raw Permalink Blame History

//+--------------------------------------------------------------------------
//
// Copyright (c) 1997-1999 Microsoft Corporation
//
// File: lictab.cpp
//
// Contents:
//
// History:
//
//---------------------------------------------------------------------------
#include "Licensed.h"
LPCTSTR __LicensedIndexOnLicenseId::pszIndexName = LICENSE_ID_INDEXNAME;
LPCTSTR __LicensedIndexOnLicenseId::pszIndexKey = LICENSE_ID_INDEXNAME_INDEXKEY;
LPCTSTR __LicensedIndexOnKeyPackId::pszIndexName = LICENSE_KEYPACKID_INDEXNAME;
LPCTSTR __LicensedIndexOnKeyPackId::pszIndexKey = LICENSE_KEYPACKID_INDEXNAME_INDEXKEY;
LPCTSTR __LicensedIndexOnLastModifyTime::pszIndexName = LICENSE_KEYPACKID_INDEXNAME;
LPCTSTR __LicensedIndexOnLastModifyTime::pszIndexKey = LICENSE_KEYPACKID_INDEXNAME_INDEXKEY;
LPCTSTR __LicensedIndexOnMachineName::pszIndexName = LICENSE_CLIENT_MACHINENAME_INDEXNAME;
LPCTSTR __LicensedIndexOnMachineName::pszIndexKey = LICENSE_CLIENT_MACHINENAME_INDEXNAME_INDEXKEY;
LPCTSTR __LicensedIndexOnUserName::pszIndexName = LICENSE_CLIENT_USERNAME_INDEXNAME;
LPCTSTR __LicensedIndexOnUserName::pszIndexKey = LICENSE_CLIENT_USERNAME_INDEXNAME_INDEXKEY;
LPCTSTR __LicensedIndexOnHwid::pszIndexName = LICENSE_CLIENT_HWID_INDEXNAME;
LPCTSTR __LicensedIndexOnHwid::pszIndexKey = LICENSE_CLIENT_HWID_INDEXNAME_INDEXKEY;
LPCTSTR __LicensedIndexOnMatchHwid::pszIndexName = LICENSE_MATCHHWID_INDEXNAME;
LPCTSTR __LicensedIndexOnMatchHwid::pszIndexKey = LICENSE_MATCHHWID_INDEXNAME_INDEXKEY;
LPCTSTR __LicensedIndexOnExpireDate::pszIndexName = LICENSE_EXPIREDATE_INDEXNAME;
LPCTSTR __LicensedIndexOnExpireDate::pszIndexKey = LICENSE_EXPIREDATE_INDEXNAME_INDEXKEY;
CCriticalSection LicensedTable::g_TableLock;
LPCTSTR LicensedTable::pszTableName = LICENSE_TABLE_NAME;
//-------------------------------------------------------------------
TLSJBIndex
LicensedTable::g_TableIndex[] =
{
// Index on license ID.
{
LICENSE_ID_INDEXNAME,
LICENSE_ID_INDEXNAME_INDEXKEY,
-1,
JET_bitIndexPrimary,
TLSTABLE_INDEX_DEFAULT_DENSITY
},
//
// Index on licensed keypack id.
{
LICENSE_KEYPACKID_INDEXNAME,
LICENSE_KEYPACKID_INDEXNAME_INDEXKEY,
-1,
JET_bitIndexIgnoreNull,
TLSTABLE_INDEX_DEFAULT_DENSITY
},
// index on last modify time.
{
LICENSE_LASTMODIFY_INDEXNAME,
LICENSE_LASTMODIFY_INDEXNAME_INDEXKEY,
-1,
JET_bitIndexIgnoreNull,
TLSTABLE_INDEX_DEFAULT_DENSITY
},
// Index on machine name
{
LICENSE_CLIENT_MACHINENAME_INDEXNAME,
LICENSE_CLIENT_MACHINENAME_INDEXNAME_INDEXKEY,
-1,
0,
TLSTABLE_INDEX_DEFAULT_DENSITY
},
// index on user name
{
LICENSE_CLIENT_USERNAME_INDEXNAME,
LICENSE_CLIENT_USERNAME_INDEXNAME_INDEXKEY,
-1,
0,
TLSTABLE_INDEX_DEFAULT_DENSITY
},
// index on client machine's hardware id
{
LICENSE_CLIENT_HWID_INDEXNAME,
LICENSE_CLIENT_HWID_INDEXNAME_INDEXKEY,
-1,
JET_bitIndexIgnoreNull,
TLSTABLE_INDEX_DEFAULT_DENSITY
},
// index on client hardware id matching hint
{
LICENSE_MATCHHWID_INDEXNAME,
LICENSE_MATCHHWID_INDEXNAME_INDEXKEY,
-1,
JET_bitIndexIgnoreNull,
TLSTABLE_INDEX_DEFAULT_DENSITY
},
// index on license expiration date
{
LICENSE_EXPIREDATE_INDEXNAME,
LICENSE_EXPIREDATE_INDEXNAME_INDEXKEY,
-1,
JET_bitIndexIgnoreNull,
TLSTABLE_INDEX_DEFAULT_DENSITY
},
};
int
LicensedTable::g_NumTableIndex = sizeof(LicensedTable::g_TableIndex) / sizeof(LicensedTable::g_TableIndex[0]);
TLSJBColumn
LicensedTable::g_Columns[] =
{
//
// Entry status
{
LICENSE_COLUMN_ENTRYSTATUS,
JET_coltypUnsignedByte,
0,
JET_bitColumnFixed,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// Licensed ID
{
LICENSE_COLUMN_ID_COLUMN,
JET_coltypLong,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// KeyPackId
{
LICENSE_COLUMN_KEYPACKID,
JET_coltypLong,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// KeyPackLicenseId
{
LICENSE_COLUMN_LICENSEID,
JET_coltypLong,
0,
JET_bitColumnFixed,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// Last modify time
{
LICENSE_COLUMN_LASTMODIFYTIME,
JET_coltypBinary,
sizeof(FILETIME),
JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// SystemBios
{
LICENSE_COLUMN_SYSTEMBIOS,
JET_coltypLong,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// Video Bios
{
LICENSE_COLUMN_VIDEOBIOS,
JET_coltypLong,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// Floppy Bios
{
LICENSE_COLUMN_FLOPPYBIOS,
JET_coltypLong,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// Harddisk size
{
LICENSE_COLUMN_HARDDISKSIZE,
JET_coltypLong,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// RAM size
{
LICENSE_COLUMN_RAMSIZE,
JET_coltypLong,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// Match HWID
{
LICENSE_COLUMN_MATCHHWID,
JET_coltypIEEEDouble,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// Machine name
{
LICENSE_COLUMN_MACHINENAME,
//JET_coltypLongText,
JB_COLTYPE_TEXT,
(MAX_JETBLUE_TEXT_LENGTH + 1)*sizeof(TCHAR),
0,
JBSTRING_NULL,
_tcslen(JBSTRING_NULL),
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// User Name
{
LICENSE_COLUMN_USERNAME,
//JET_coltypLongText,
JB_COLTYPE_TEXT,
(MAX_JETBLUE_TEXT_LENGTH + 1)*sizeof(TCHAR),
0,
JBSTRING_NULL,
_tcslen(JBSTRING_NULL),
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// Number of licenses for this client
{
LICENSE_COLUMN_NUMLICENSES,
JET_coltypLong,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// IssuedDate
{
LICENSE_COLUMN_ISSUEDATE,
JET_coltypLong,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// ExpireDate
{
LICENSE_COLUMN_EXPIREDATE,
JET_coltypLong,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
},
//
// License Status
{
LICENSE_COLUMN_LICENSESTATUS,
JET_coltypUnsignedByte,
0,
JET_bitColumnFixed | JET_bitColumnNotNULL,
NULL,
0,
TLS_JETBLUE_COLUMN_CODE_PAGE,
TLS_JETBLUE_COLUMN_COUNTRY_CODE,
TLS_JETBLUE_COLUMN_LANGID
}
};
int
LicensedTable::g_NumColumns=sizeof(LicensedTable::g_Columns) / sizeof(LicensedTable::g_Columns[0]);
///////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------
BOOL
LicensedTable::ResolveToTableColumn()
/*
*/
{
m_JetErr = ucEntryStatus.AttachToTable(
*this,
LICENSE_COLUMN_ENTRYSTATUS
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = dwKeyPackLicenseId.AttachToTable(
*this,
LICENSE_COLUMN_LICENSEID
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = ftLastModifyTime.AttachToTable(
*this,
LICENSE_COLUMN_LASTMODIFYTIME
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = dwLicenseId.AttachToTable(
*this,
LICENSE_COLUMN_ID_COLUMN
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = dwKeyPackId.AttachToTable(
*this,
LICENSE_COLUMN_KEYPACKID
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = szMachineName.AttachToTable(
*this,
LICENSE_COLUMN_MACHINENAME
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = szUserName.AttachToTable(
*this,
LICENSE_COLUMN_USERNAME
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = ftIssueDate.AttachToTable(
*this,
LICENSE_COLUMN_ISSUEDATE
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = ftExpireDate.AttachToTable(
*this,
LICENSE_COLUMN_EXPIREDATE
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = ucLicenseStatus.AttachToTable(
*this,
LICENSE_COLUMN_LICENSESTATUS
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = dwNumLicenses.AttachToTable(
*this,
LICENSE_COLUMN_NUMLICENSES
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = dwSystemBiosChkSum.AttachToTable(
*this,
LICENSE_COLUMN_SYSTEMBIOS
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = dwVideoBiosChkSum.AttachToTable(
*this,
LICENSE_COLUMN_VIDEOBIOS
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = dwFloppyBiosChkSum.AttachToTable(
*this,
LICENSE_COLUMN_FLOPPYBIOS
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = dwHardDiskSize.AttachToTable(
*this,
LICENSE_COLUMN_HARDDISKSIZE
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = dwRamSize.AttachToTable(
*this,
LICENSE_COLUMN_RAMSIZE
);
if(IsSuccess() == FALSE)
goto cleanup;
m_JetErr = dbLowerBound.AttachToTable(
*this,
LICENSE_COLUMN_MATCHHWID
);
cleanup:
return IsSuccess();
}
//------------------------------------------------------------
inline CLASS_PRIVATE BOOL
LicensedTable::ProcessSingleColumn(
BOOL bFetch,
TLSColumnBase& column,
DWORD offset,
PVOID pbData,
DWORD cbData,
PDWORD pcbDataReturn,
LPCTSTR szColumnName
)
/*
*/
{
if(bFetch)
{
m_JetErr = column.FetchColumnValue(
pbData,
cbData,
offset,
pcbDataReturn
);
}
else
{
m_JetErr = column.InsertColumnValue(
pbData,
cbData,
offset
);
}
REPORTPROCESSFAILED(
bFetch,
GetTableName(),
szColumnName,
m_JetErr
);
return IsSuccess();
}
//------------------------------------------------------------
CLASS_PRIVATE BOOL
LicensedTable::ProcessRecord(
LICENSEDCLIENT* licensed,
BOOL bFetch,
DWORD dwParam,
BOOL bUpdate
)
/*
*/
{
DWORD dwSize;
if(bFetch == FALSE)
{
BeginUpdate(bUpdate);
// any update will require update on lastmodifytime column
if(!(dwParam & LICENSE_PROCESS_LASTMODIFYTIME))
{
JB_ASSERT(FALSE);
dwParam |= LICENSE_PROCESS_LASTMODIFYTIME;
}
}
else
{
SetLastJetError(JET_errSuccess);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_KEYPACKLICENSEID)
{
ProcessSingleColumn(
bFetch,
dwKeyPackLicenseId,
0,
&(licensed->dwKeyPackLicenseId),
sizeof(licensed->dwKeyPackLicenseId),
&dwSize,
LICENSE_COLUMN_LICENSEID
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_LASTMODIFYTIME)
{
ProcessSingleColumn(
bFetch,
ftLastModifyTime,
0,
&(licensed->ftLastModifyTime),
sizeof(licensed->ftLastModifyTime),
&dwSize,
LICENSE_COLUMN_LASTMODIFYTIME
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_LICENSEID)
{
// primary index, can't change
if(bUpdate == FALSE)
{
ProcessSingleColumn(
bFetch,
dwLicenseId,
0,
&(licensed->dwLicenseId),
sizeof(licensed->dwLicenseId),
&dwSize,
LICENSE_COLUMN_ID_COLUMN
);
}
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_KEYPACKID)
{
ProcessSingleColumn(
bFetch,
dwKeyPackId,
0,
&(licensed->dwKeyPackId),
sizeof(licensed->dwKeyPackId),
&dwSize,
LICENSE_COLUMN_KEYPACKID
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_MACHINENAME)
{
ProcessSingleColumn(
bFetch,
szMachineName,
0,
licensed->szMachineName,
sizeof(licensed->szMachineName),
&dwSize,
LICENSE_COLUMN_MACHINENAME
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_USERNAME)
{
ProcessSingleColumn(
bFetch,
szUserName,
0,
licensed->szUserName,
sizeof(licensed->szUserName),
&dwSize,
LICENSE_COLUMN_USERNAME
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_ISSUEDATE)
{
ProcessSingleColumn(
bFetch,
ftIssueDate,
0,
&(licensed->ftIssueDate),
sizeof(licensed->ftIssueDate),
&dwSize,
LICENSE_COLUMN_ISSUEDATE
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_EXPIREDATE)
{
ProcessSingleColumn(
bFetch,
ftExpireDate,
0,
&(licensed->ftExpireDate),
sizeof(licensed->ftExpireDate),
&dwSize,
LICENSE_COLUMN_EXPIREDATE
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_NUMLICENSES)
{
ProcessSingleColumn(
bFetch,
dwNumLicenses,
0,
&(licensed->dwNumLicenses),
sizeof(licensed->dwNumLicenses),
&dwSize,
LICENSE_COLUMN_NUMLICENSES
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_LICENSESTATUS)
{
ProcessSingleColumn(
bFetch,
ucLicenseStatus,
0,
&(licensed->ucLicenseStatus),
sizeof(licensed->ucLicenseStatus),
&dwSize,
LICENSE_COLUMN_LICENSESTATUS
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_SYSTEMBIOS)
{
ProcessSingleColumn(
bFetch,
dwSystemBiosChkSum,
0,
&(licensed->dwSystemBiosChkSum),
sizeof(licensed->dwSystemBiosChkSum),
&dwSize,
LICENSE_COLUMN_SYSTEMBIOS
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_VIDEOBIOS)
{
ProcessSingleColumn(
bFetch,
dwVideoBiosChkSum,
0,
&(licensed->dwVideoBiosChkSum),
sizeof(licensed->dwVideoBiosChkSum),
&dwSize,
LICENSE_COLUMN_VIDEOBIOS
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_FLOPPYBIOS)
{
ProcessSingleColumn(
bFetch,
dwFloppyBiosChkSum,
0,
&(licensed->dwFloppyBiosChkSum),
sizeof(licensed->dwFloppyBiosChkSum),
&dwSize,
LICENSE_COLUMN_FLOPPYBIOS
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_HARDDISKSIZE)
{
ProcessSingleColumn(
bFetch,
dwHardDiskSize,
0,
&(licensed->dwHardDiskSize),
sizeof(licensed->dwHardDiskSize),
&dwSize,
LICENSE_COLUMN_HARDDISKSIZE
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_RAMSIZE)
{
ProcessSingleColumn(
bFetch,
dwRamSize,
0,
&(licensed->dwRamSize),
sizeof(licensed->dwRamSize),
&dwSize,
LICENSE_COLUMN_RAMSIZE
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_ENTRYSTATUS)
{
ProcessSingleColumn(
bFetch,
ucEntryStatus,
0,
&(licensed->ucEntryStatus),
sizeof(licensed->ucEntryStatus),
&dwSize,
LICENSE_COLUMN_ENTRYSTATUS
);
}
if(IsSuccess() == FALSE)
goto cleanup;
if(dwParam & LICENSE_PROCESS_MATCHHWID)
{
ProcessSingleColumn(
bFetch,
dbLowerBound,
0,
&(licensed->dbLowerBound),
sizeof(licensed->dbLowerBound),
&dwSize,
LICENSE_COLUMN_MATCHHWID
);
}
cleanup:
//
// For inserting/updating record
if(bFetch == FALSE)
{
JET_ERR jetErr;
jetErr = GetLastJetError();
EndUpdate(IsSuccess() == FALSE);
if(jetErr != JET_errSuccess && IsSuccess() == FALSE)
SetLastJetError(jetErr);
}
return IsSuccess();
}
//-------------------------------------------------------
JBKeyBase*
LicensedTable::EnumerationIndex(
BOOL bMatchAll,
DWORD dwParam,
LICENSEDCLIENT* pLicensed,
BOOL* bCompareKey
)
/*
*/
{
JBKeyBase* index=NULL;
*bCompareKey = bMatchAll;
if(dwParam == LICENSE_COLUMN_SEARCH_HWID)
{
if(bMatchAll)
{
index = new TLSLicensedIndexHwid(pLicensed);
}
else
{
index = new TLSLicensedIndexMatchHwid(pLicensed);
}
}
else if(dwParam & LICENSE_PROCESS_KEYPACKID)
{
index = new TLSLicensedIndexKeyPackId(pLicensed);
}
else if(dwParam & LICENSE_PROCESS_MACHINENAME)
{
index = new TLSLicensedIndexMachineName(pLicensed);
}
else if(dwParam & LICENSE_PROCESS_USERNAME)
{
index = new TLSLicensedIndexUserName(pLicensed);
}
else if(dwParam & LICENSE_PROCESS_LASTMODIFYTIME)
{
index = new TLSLicensedIndexLastModifyTime(pLicensed);
}
else if(dwParam & LICENSE_PROCESS_EXPIREDATE)
{
index = new TLSLicensedIndexExpireDate(pLicensed);
}
else
{
// use default primary index for iteration, compare key
// is depends on whether primary index column is in the
// field.
index = new TLSLicensedIndexLicenseId(pLicensed);
*bCompareKey = (bMatchAll && (dwParam & LICENSE_PROCESS_LICENSEID));
}
return index;
}
//-------------------------------------------------------
BOOL
LicensedTable::EqualValue(
LICENSEDCLIENT& s1,
LICENSEDCLIENT& s2,
BOOL bMatchAll,
DWORD dwParam
)
/*
*/
{
BOOL bRetCode = TRUE;
if(dwParam & LICENSE_PROCESS_ENTRYSTATUS)
{
bRetCode = (s1.ucEntryStatus == s2.ucEntryStatus);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_KEYPACKLICENSEID)
{
bRetCode = (s1.dwKeyPackLicenseId == s2.dwKeyPackLicenseId);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_LASTMODIFYTIME)
{
bRetCode = (CompareFileTime(&s1.ftLastModifyTime, &s2.ftLastModifyTime) == 0);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_LICENSEID)
{
bRetCode = (s1.dwLicenseId == s2.dwLicenseId);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_KEYPACKID)
{
bRetCode = (s1.dwKeyPackId == s2.dwKeyPackId);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_MACHINENAME)
{
bRetCode = (_tcscmp(s1.szMachineName, s2.szMachineName) == 0);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_USERNAME)
{
bRetCode = (_tcscmp(s1.szUserName, s2.szUserName) == 0);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_ISSUEDATE)
{
bRetCode = (s1.ftIssueDate == s2.ftIssueDate);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_EXPIREDATE)
{
bRetCode = (s1.ftExpireDate == s2.ftExpireDate);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_NUMLICENSES)
{
bRetCode = (s1.dwNumLicenses == s2.dwNumLicenses);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_LICENSESTATUS)
{
bRetCode = (s1.ucLicenseStatus == s2.ucLicenseStatus);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_SYSTEMBIOS)
{
bRetCode = (s1.dwSystemBiosChkSum == s2.dwSystemBiosChkSum);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_VIDEOBIOS)
{
bRetCode = (s1.dwVideoBiosChkSum == s2.dwVideoBiosChkSum);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_FLOPPYBIOS)
{
bRetCode = (s1.dwFloppyBiosChkSum == s2.dwFloppyBiosChkSum);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_HARDDISKSIZE)
{
bRetCode = (s1.dwHardDiskSize == s2.dwHardDiskSize);
if(bMatchAll != bRetCode)
goto cleanup;
}
if(dwParam & LICENSE_PROCESS_RAMSIZE)
{
bRetCode = (s1.dwRamSize == s2.dwRamSize);
}
if(dwParam & LICENSE_PROCESS_MATCHHWID)
{
bRetCode = (s1.dbLowerBound == s2.dbLowerBound);
}
cleanup:
return bRetCode;
}
//--------------------------------------------------------
BOOL
LicensedTable::UpgradeTable(
IN DWORD dwOldVersion,
IN DWORD dwNewVersion
)
/*++
++*/
{
int nExpDate = g_NumTableIndex-1;
unsigned long keylength;
BOOL fRet = TRUE;
if(dwOldVersion > dwNewVersion)
{
// We don't know how to handle later versions
JB_ASSERT(FALSE);
return FALSE;
}
if(OpenTable(TRUE, JET_bitTableUpdatable) == FALSE)
return FALSE;
//
// check if expiration date index exists
//
if (DoesIndexExist(g_TableIndex[nExpDate].pszIndexName))
{
goto cleanup;
}
//
// Insert new index for expiration date
//
if (g_TableIndex[nExpDate].cbKey == -1)
{
// calculate index key length
keylength = 2;
while(g_TableIndex[nExpDate].pszIndexKey[keylength-1] != _TEXT('\0') ||
(g_TableIndex[nExpDate].pszIndexKey[keylength-2] != _TEXT('\0')))
{
keylength++;
}
if(keylength >= TLS_JETBLUE_MAX_INDEXKEY_LENGTH)
{
fRet = FALSE;
goto cleanup;
}
}
else
{
keylength = g_TableIndex[nExpDate].cbKey;
}
AddJetIndex(g_TableIndex[nExpDate].pszIndexName,
g_TableIndex[nExpDate].pszIndexKey,
keylength,
g_TableIndex[nExpDate].jbGrbit,
g_TableIndex[nExpDate].ulDensity
);
cleanup:
return CloseTable() && fRet;
}