SHORT FLEXlm::InitFLEXlm(CString exePath, CString availableLicsFileName, VOID *funcPtr)
{
if (m_bIsInitialized) return RET_NO_ERROR;
{
//Make sure the registry entry for the license file exists (Did the user configure the license file?)
HKEY flexKey = NULL;
LONG result = 0;
result = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\FLEXlm License Manager", 0, KEY_QUERY_VALUE, &flexKey);
if (result != ERROR_SUCCESS)
{
LPVOID lpMsgBuf;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, result, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0, NULL);
m_sErrMsg = NO_LICMGR_S + "\n\n" + (LPCTSTR)lpMsgBuf;
// Free the buffer.
LocalFree( lpMsgBuf );
return RET_INVALID_PARAM;
}
const int licPathSize = 64; // This allows a successful RegQueryValueEx() when executing a Release Build with debug info and optimization. (knv)
char licPath[licPathSize];
DWORD bufLen = licPathSize;
result = RegQueryValueEx(flexKey, "RSI_LM_LICENSE_FILE", NULL, NULL, (LPBYTE)licPath, &bufLen);
if ((result == ERROR_SUCCESS && strlen(licPath) <= 0) || (result != ERROR_SUCCESS && result != ERROR_MORE_DATA))
{
LPVOID lpMsgBuf;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, result, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&lpMsgBuf, 0, NULL);
m_sErrMsg = NOT_CONFIG_S + "\n\n" + (LPCTSTR)lpMsgBuf;
// Free the buffer.
LocalFree( lpMsgBuf );
return RET_INVALID_PARAM;
}
RegCloseKey(flexKey);
}
if (!m_bLicsAreGood) return RET_NO_LIC;
SHORT result = 0;
m_sErrMsg.Empty();
flexObj = this;
m_bUseLog = m_bCreateLicList = FALSE;
m_saLicsToCheck.RemoveAll();
m_sCwd = exePath;
m_sAvailLicFName = availableLicsFileName;
VOID *voidPtr = NULL;
CString key;
//check in any checked out licenses
POSITION pos = m_jobMap.GetStartPosition();
while (pos)
{
m_jobMap.GetNextAssoc(pos, key, voidPtr);
CheckIn(key);
}
readLicAvailablity();
gExitFuncPtr = (FUNCPTR*)funcPtr;
result = lc_set_attr(m_lmJob, LM_A_USER_EXITCALL, (LM_A_VAL_TYPE)OnFLEXlmExitCall);
result = lc_set_attr(m_lmJob, LM_A_CHECKOUTFILTER, (LM_A_VAL_TYPE)OnCheckOutFilter);
result = lc_set_attr(m_lmJob, LM_A_CHECK_INTERVAL, (LM_A_VAL_TYPE)30);
result = lc_set_attr(m_lmJob, LM_A_RETRY_INTERVAL, (LM_A_VAL_TYPE)30);
result = lc_set_attr(m_lmJob, LM_A_PROMPT_FOR_FILE, (LM_A_VAL_TYPE)FALSE);
m_bIsInitialized = TRUE;
return RET_NO_ERROR;
}
/* Hand over strings as well as their length (necessary under Irix!),
1 to check in and 0 to check out, returns 0 if OK, 666 otherwise */
int toolCheckLicenseC( unsigned int Flag,
char *Feature,
char *Version,
char *License )
{
/* FLEXlm stuff */
#define CHECK_OUT 1
#define CHECK_HEARTBEAT 2
#define CHECK_IN 3
#if FLEXLM == EIN
struct vendorcode7 code;
LM_HANDLE *lm_job;
#define MAX_NUMBER_OF_LM_JOBS 64
static int number_of_lm_jobs = 0;
static LM_HANDLE *checked_out_lm_jobs[MAX_NUMBER_OF_LM_JOBS];
int no_job = 0;
int no_license = 0;
int flag = 0;
int heartbeat_ok, num_reconnects, num_minutes;
#define STRING_SIZE 256
static char checked_out_features[MAX_NUMBER_OF_LM_JOBS][STRING_SIZE];
int current_job = 0;
#ifdef VERBOSE
CONFIG *pos = 0;
CONFIG *conf;
int days = 0;
#endif /* VERBOSE */
#endif /* FLEXlm */
/* Declare return value */
#define RETURN_ERROR 666
int return_value = RETURN_ERROR;
/* Allocate and copy strings (...) */
char *feature, *version, *license;
feature = (char*)malloc(sizeof(char)*(strlen(Feature)+1));
strcpy ( feature, Feature );
version = (char*)malloc(sizeof(char)*(strlen(Version)+1));
strcpy ( version, Version );
license = (char*)malloc(sizeof(char)*(strlen(License)+1));
strcpy ( license, License );
/* Check allocation */
if ( ( feature == NULL ) || ( version == NULL ) || ( license == NULL ) ) {
printf ( strcat( "\nError in routine 'toolCheckLicenseC',",
" unable to allocate buffers\n\n" ) );
exit(RETURN_ERROR);
}
/* Actual call */
#if FLEXLM == EIN
flag = Flag;
/* Check out */
if ( flag == CHECK_OUT ) {
no_job = lc_new_job ( 0, 0, &code, &lm_job );
if ( no_job ) {
printf ( "\nUnable to allocate 'new job'\n\n%s\n\n",
lc_errstring(lm_job));
lc_perror(lm_job,"lc_new_job failed" );
exit(RETURN_ERROR);
}
lc_set_attr ( lm_job, LM_A_CHECK_INTERVAL, (LM_A_VAL_TYPE) -1 );
lc_set_attr ( lm_job, LM_A_RETRY_INTERVAL, (LM_A_VAL_TYPE) -1 );
lc_set_attr ( lm_job, LM_A_RETRY_COUNT, (LM_A_VAL_TYPE) 2 );
lc_set_attr ( lm_job, LM_A_LICENSE_DEFAULT, (LM_A_VAL_TYPE)license );
no_license = lc_checkout ( lm_job, feature, version, 1,
LM_CO_NOWAIT, &code, LM_DUP_NONE );
/* Store job specifics (for future use: 'heartbeat', and release) */
if ( ! no_license ) {
return_value = 0;
if ( ( number_of_lm_jobs < MAX_NUMBER_OF_LM_JOBS ) &&
( strlen(feature) < STRING_SIZE ) ) {
checked_out_lm_jobs[number_of_lm_jobs] = lm_job;
strcpy ( checked_out_features[number_of_lm_jobs], feature );
number_of_lm_jobs++ ;
} else {
printf ( "\nWarning: dimensionality problem in routine toolCheckLicenseC!" );
printf ( "\n Number of 'jobs': %d (maximum number: %d)",
number_of_lm_jobs, MAX_NUMBER_OF_LM_JOBS );
printf ( "\n String length: %d (maximum length: %d)\n\n",
strlen(feature), STRING_SIZE );
};
/* Get chatty */
#ifdef VERBOSE
printf ( "\n%s\n%s\n%s\n%s\n\n", feature, version, platform,
license );
conf = lc_next_conf ( lm_job, feature, &pos );
days = lc_expire_days ( lm_job, conf );
if ( days == LM_FOREVER ) {
printf ( "\nPermanent license\n\n" );
} else {
printf ( "\nLicense expires in %d day(s)\n\n", days );
}
#endif /* VERBOSE */
} else { /* (NB: no license found!) */
#ifdef VERBOSE
printf ( "\n%s\n", lc_errstring(lm_job) );
#endif /* VERBOSE */
lc_free_job ( lm_job );
}
/* 'Heartbeat' (i.e.: check whether the license is still available)*/
} else if ( flag == CHECK_HEARTBEAT ) {
return_value = 0;
for ( current_job = 0; current_job < number_of_lm_jobs;
current_job ++ ) {
#ifdef VERBOSE
printf ( "\n'Heartbeat' for feature: %s\n\n",
checked_out_features[current_job] );
#endif /* VERBOSE */
num_reconnects = 1;
num_minutes = 60;
heartbeat_ok = lc_heartbeat ( checked_out_lm_jobs[current_job],
&num_reconnects, num_minutes );
if ( heartbeat_ok != 0 ) {
return_value = RETURN_ERROR;
#ifdef VERBOSE
printf ( "\n%s\n",
lc_errstring(checked_out_lm_jobs[current_job]) );
#endif /* VERBOSE */
};
}
/* Check out (i.e.: 'release the licenses') */
} else if ( flag == CHECK_IN ) {
return_value = 0;
for ( current_job = 0; current_job < number_of_lm_jobs;
current_job ++ ) {
#ifdef VERBOSE
printf ( "\nChecked out feature: %s\n\n",
checked_out_features[current_job] );
#endif /* VERBOSE */
lc_checkin ( checked_out_lm_jobs[current_job],
checked_out_features[current_job], 0 );
lc_free_job ( checked_out_lm_jobs[current_job] );
}
/* Wrong call parameter! */
} else {
return_value = RETURN_ERROR;
#ifdef VERBOSE
printf ( strcat ( "\nRoutine 'toolCheckLicenseC' called",
" with unrecognised parameters\n\n" ) );
#endif /* VERBOSE */
}
#ifdef DEBUG
printf ( "\nWarning: debug!\n\n%s\n%s\n%s\n%s\n\n", feature, version,
platform, license );
return_value = RETURN_ERROR;
#endif /* DEBUG */
#endif /* FLEXlm */
/* That's all folks! */
return return_value;
}
