int CALLBACK CompareLicenses(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
/*++
Routine Description:
Notification handler for LVM_SORTITEMS.
Arguments:
lParam1 - object to sort.
lParam2 - object to sort.
lParamSort - sort criteria.
Return Values:
Same as lstrcmp.
--*/
{
CLicense * pLic1 = (CLicense *) lParam1;
CLicense * pLic2 = (CLicense *) lParam2;
VALIDATE_OBJECT( pLic1, CLicense );
VALIDATE_OBJECT( pLic2, CLicense );
int iResult;
switch (g_removeColumnInfo.nSortedItem)
{
case LVID_REMOVE_SERIAL_NUMBER:
iResult = pLic1->m_dwCertificateID - pLic2->m_dwCertificateID;
break;
case LVID_REMOVE_PRODUCT_NAME:
iResult = pLic1->m_strProduct.CompareNoCase( pLic2->m_strProduct );
break;
case LVID_REMOVE_NUM_LICENSES:
iResult = pLic1->m_lQuantity - pLic2->m_lQuantity;
break;
case LVID_REMOVE_SOURCE:
iResult = pLic1->GetSourceDisplayName().CompareNoCase( pLic2->GetSourceDisplayName() );
break;
default:
iResult = 0;
break;
}
return g_removeColumnInfo.bSortOrder ? -iResult : iResult;
}
JNIEXPORT void JNICALL
Java_org_oic_simulator_server_SimulatorSingleResource_stopUpdation
(JNIEnv *env, jobject object, jint id)
{
SimulatorSingleResourceSP singleResource = simulatorSingleResourceToCpp(env, object);
VALIDATE_OBJECT(env, singleResource)
singleResource->stopUpdation(id);
}
JNIEXPORT void JNICALL
Java_org_oic_simulator_server_SimulatorSingleResource_updateAttribute
(JNIEnv *env, jobject object, jstring attrName, jobject attrValue)
{
VALIDATE_INPUT(env, !attrName, "Attribute name is null!")
VALIDATE_INPUT(env, !attrValue, "Attribute value is null!")
SimulatorSingleResourceSP singleResource = simulatorSingleResourceToCpp(env, object);
VALIDATE_OBJECT(env, singleResource)
SimulatorResourceModel::ValueVariant value;
if (!AttributeValueToCpp(env, attrValue, value))
{
throwSimulatorException(env, SIMULATOR_ERROR,
"Failed to covnert AttributeValue java object!");
return;
}
SimulatorResourceModel::Attribute attribute(JniString(env, attrName).get());
attribute.setValue(value);
singleResource->updateAttributeValue(attribute);
}
BOOL CCertRemoveSelectDlg::RefreshLicenses()
/*++
Routine Description:
Refresh internal license list with data from license server.
Arguments:
None.
Return Values:
BOOL.
--*/
{
ResetLicenses();
if ( ConnectServer() )
{
NTSTATUS NtStatus;
DWORD ResumeHandle = 0L;
int iLicense = 0;
do
{
DWORD EntriesRead;
DWORD TotalEntries;
LPBYTE ReturnBuffer = NULL;
DWORD Level = LlsCapabilityIsSupported( m_hLls, LLS_CAPABILITY_SECURE_CERTIFICATES ) ? 1 : 0;
BeginWaitCursor();
NtStatus = ::LlsLicenseEnum( m_hLls,
Level,
&ReturnBuffer,
LLS_PREFERRED_LENGTH,
&EntriesRead,
&TotalEntries,
&ResumeHandle );
EndWaitCursor();
if ( ( STATUS_SUCCESS == NtStatus )
|| ( STATUS_MORE_ENTRIES == NtStatus ) )
{
CLicense* pLicense;
PLLS_LICENSE_INFO_0 pLicenseInfo0;
PLLS_LICENSE_INFO_1 pLicenseInfo1;
pLicenseInfo0 = (PLLS_LICENSE_INFO_0)ReturnBuffer;
pLicenseInfo1 = (PLLS_LICENSE_INFO_1)ReturnBuffer;
while (EntriesRead--)
{
if ( ( m_strProductName.IsEmpty() || !m_strProductName.CompareNoCase( Level ? pLicenseInfo1->Product : pLicenseInfo0->Product ) )
&& ( m_strSourceToUse.IsEmpty() || !m_strSourceToUse.CompareNoCase( Level ? pLicenseInfo1->Source : TEXT("None") ) ) )
{
// we want to list this license
// have we seen this certificate yet?
for ( int i=0; i < m_licenseArray.GetSize(); i++ )
{
pLicense = (CLicense*) m_licenseArray[ i ];
VALIDATE_OBJECT( pLicense, CLicense );
if ( ( ( 1 == Level )
&& ( pLicense->m_dwCertificateID == pLicenseInfo1->CertificateID )
&& ( pLicense->m_dwAllowedModes == pLicenseInfo1->AllowedModes )
&& ( pLicense->m_dwMaxQuantity == pLicenseInfo1->MaxQuantity )
&& ( !pLicense->m_strSource.CompareNoCase( pLicenseInfo1->Source ) )
&& ( !pLicense->m_strProduct.CompareNoCase( pLicenseInfo1->Product ) )
&& ( !memcmp( pLicense->m_adwSecrets,
pLicenseInfo1->Secrets,
sizeof( pLicense->m_adwSecrets ) ) ) )
|| ( ( 0 == Level )
&& ( !pLicense->m_strProduct.CompareNoCase( pLicenseInfo0->Product ) ) ) )
{
// we've seen this certificate before; update the tally
pLicense->m_lQuantity += ( Level ? pLicenseInfo1->Quantity : pLicenseInfo0->Quantity );
break;
}
}
if ( i >= m_licenseArray.GetSize() )
{
// we haven't seen this certificate yet; create a new license for it
if ( 1 == Level )
{
pLicense = new CLicense( pLicenseInfo1->Product,
pLicenseInfo1->Vendor,
pLicenseInfo1->Admin,
pLicenseInfo1->Date,
pLicenseInfo1->Quantity,
pLicenseInfo1->Comment,
pLicenseInfo1->AllowedModes,
pLicenseInfo1->CertificateID,
pLicenseInfo1->Source,
pLicenseInfo1->ExpirationDate,
pLicenseInfo1->MaxQuantity,
pLicenseInfo1->Secrets );
::LlsFreeMemory( pLicenseInfo1->Product );
::LlsFreeMemory( pLicenseInfo1->Admin );
::LlsFreeMemory( pLicenseInfo1->Comment );
::LlsFreeMemory( pLicenseInfo1->Source );
}
else
{
ASSERT( 0 == Level );
pLicense = new CLicense( pLicenseInfo0->Product,
TEXT( "Microsoft" ),
pLicenseInfo0->Admin,
pLicenseInfo0->Date,
pLicenseInfo0->Quantity,
pLicenseInfo0->Comment );
::LlsFreeMemory( pLicenseInfo0->Product );
::LlsFreeMemory( pLicenseInfo0->Admin );
::LlsFreeMemory( pLicenseInfo0->Comment );
}
if ( NULL == pLicense )
{
NtStatus = ERROR_OUTOFMEMORY;
break;
}
m_licenseArray.Add( pLicense );
}
}
pLicenseInfo1++;
pLicenseInfo0++;
}
::LlsFreeMemory(ReturnBuffer);
}
} while ( STATUS_MORE_ENTRIES == NtStatus );
theApp.SetLastLlsError( NtStatus ); // called api
if ( STATUS_SUCCESS == NtStatus )
{
// add per server entries
LPTSTR pszServerName = m_strServerName.GetBuffer(0);
if ( NULL != pszServerName )
{
BeginWaitCursor();
HKEY hKeyLocalMachine;
NtStatus = RegConnectRegistry( pszServerName, HKEY_LOCAL_MACHINE, &hKeyLocalMachine );
if ( ERROR_SUCCESS != NtStatus )
{
theApp.SetLastError( NtStatus );
}
else
{
HKEY hKeyLicenseInfo;
NtStatus = RegOpenKeyEx( hKeyLocalMachine, TEXT( "SYSTEM\\CurrentControlSet\\Services\\LicenseInfo" ), 0, KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS | KEY_SET_VALUE, &hKeyLicenseInfo );
if ( ERROR_SUCCESS != NtStatus )
{
theApp.SetLastError( NtStatus );
}
else
{
NTSTATUS ntEnum;
BOOL bFoundKey = FALSE;
DWORD iSubKey = 0;
// if the service is 3.51-style per server, add it to the list
do
{
TCHAR szKeyName[ 128 ];
DWORD cchKeyName = sizeof( szKeyName ) / sizeof( *szKeyName );
ntEnum = RegEnumKeyEx( hKeyLicenseInfo, iSubKey++, szKeyName, &cchKeyName, NULL, NULL, NULL, NULL );
if ( ERROR_SUCCESS == ntEnum )
{
HKEY hKeyProduct;
NtStatus = RegOpenKeyEx( hKeyLicenseInfo, szKeyName, 0, KEY_QUERY_VALUE | KEY_SET_VALUE, &hKeyProduct );
if ( ERROR_SUCCESS == NtStatus )
{
DWORD dwType;
TCHAR szDisplayName[ 128 ];
DWORD cbDisplayName = sizeof( szDisplayName );
NtStatus = RegQueryValueEx( hKeyProduct, TEXT( "DisplayName" ), NULL, &dwType, (LPBYTE) szDisplayName, &cbDisplayName );
if ( ERROR_SUCCESS == NtStatus )
{
// is this product secure?
BOOL bIsSecure = FALSE;
if ( LlsCapabilityIsSupported( m_hLls, LLS_CAPABILITY_SECURE_CERTIFICATES ) )
{
NtStatus = ::LlsProductSecurityGet( m_hLls, szDisplayName, &bIsSecure );
theApp.SetLastLlsError( NtStatus );
if ( STATUS_SUCCESS != NtStatus )
{
bIsSecure = FALSE;
}
}
if ( !bIsSecure )
{
#ifdef REMOVE_CONCURRENT_ONLY_IF_PER_SERVER_MODE
// not secure; is it in per server mode?
DWORD dwMode;
DWORD cbMode = sizeof( dwMode );
NtStatus = RegQueryValueEx( hKeyProduct, TEXT( "Mode" ), NULL, &dwType, (LPBYTE) &dwMode, &cbMode );
if ( ( ERROR_SUCCESS == NtStatus ) && dwMode )
{
// per server mode; add to list
#endif
DWORD dwConcurrentLimit;
DWORD cbConcurrentLimit = sizeof( dwConcurrentLimit );
NtStatus = RegQueryValueEx( hKeyProduct, TEXT( "ConcurrentLimit" ), NULL, &dwType, (LPBYTE) &dwConcurrentLimit, &cbConcurrentLimit );
if ( ( ERROR_SUCCESS == NtStatus )
&& ( 0 < dwConcurrentLimit )
&& ( m_strProductName.IsEmpty() || !m_strProductName.CompareNoCase( szDisplayName ) )
&& ( m_strSourceToUse.IsEmpty() || !m_strSourceToUse.CompareNoCase( TEXT("None") ) ) )
{
CLicense * pLicense = new CLicense( szDisplayName,
TEXT(""),
TEXT(""),
0,
dwConcurrentLimit,
TEXT(""),
LLS_LICENSE_MODE_ALLOW_PER_SERVER );
if ( NULL != pLicense )
{
m_licenseArray.Add( pLicense );
}
}
}
#ifdef REMOVE_CONCURRENT_ONLY_IF_PER_SERVER_MODE
}
#endif
}
RegCloseKey( hKeyProduct );
}
}
} while ( ERROR_SUCCESS == ntEnum );
RegCloseKey( hKeyLicenseInfo );
}
RegCloseKey( hKeyLocalMachine );
}
m_strServerName.ReleaseBuffer();
}
EndWaitCursor();
m_bLicensesRefreshed = TRUE;
// remove any entries from the list that aren't removable
for ( int i=0; i < m_licenseArray.GetSize(); )
{
CLicense* pLicense = (CLicense*) m_licenseArray[ i ];
VALIDATE_OBJECT( pLicense, CLicense );
if ( pLicense->m_lQuantity <= 0 )
{
delete pLicense;
m_licenseArray.RemoveAt( i );
}
else
{
i++;
}
}
}
else
{
theApp.DisplayLastError();
ResetLicenses();
}
}
return m_bLicensesRefreshed;
}
void CCertRemoveSelectDlg::OnGetDispInfoCertificateList(NMHDR* pNMHDR, LRESULT* pResult)
/*++
Routine Description:
Handler for LVN_GETDISPINFO of certificate list view.
Arguments:
pNMHDR (NMHDR*)
pResult (LRESULT*)
Return Values:
None.
--*/
{
LV_ITEM* plvItem = &((LV_DISPINFO*)pNMHDR)->item;
ASSERT(plvItem);
CLicense* pLicense = (CLicense*)plvItem->lParam;
VALIDATE_OBJECT(pLicense, CLicense);
switch (plvItem->iSubItem)
{
case LVID_REMOVE_SERIAL_NUMBER:
plvItem->iImage = BMPI_CERTIFICATE;
{
CString strSerialNumber;
strSerialNumber.Format( TEXT("%ld"), (LONG) ( pLicense->m_dwCertificateID ) );
lstrcpyn( plvItem->pszText, strSerialNumber, plvItem->cchTextMax );
}
break;
case LVID_REMOVE_PRODUCT_NAME:
lstrcpyn( plvItem->pszText, pLicense->m_strProduct, plvItem->cchTextMax );
break;
case LVID_REMOVE_LICENSE_MODE:
lstrcpyn( plvItem->pszText, pLicense->GetAllowedModesString(), plvItem->cchTextMax );
break;
case LVID_REMOVE_NUM_LICENSES:
{
CString strLicenses;
strLicenses.Format( TEXT("%ld"), (LONG) ( pLicense->m_lQuantity ) );
lstrcpyn( plvItem->pszText, strLicenses, plvItem->cchTextMax );
}
break;
case LVID_REMOVE_SOURCE:
lstrcpyn( plvItem->pszText, pLicense->GetSourceDisplayName(), plvItem->cchTextMax );
break;
default:
ASSERT( FALSE );
break;
}
*pResult = 0;
}
