ClRcT clLoadEnvVars()
{
ClRcT rc = CL_OK;
ClCharT missing[512];
ClCharT * temp=NULL;
ClInt32T i = 0;
missing[0] = 0;
clEoWithOutCpm = clParseEnvBoolean("ASP_WITHOUT_CPM");
if (1) /* Required environment variables */
{
const ClCharT* envvars[] = { "ASP_NODENAME", "ASP_COMPNAME", "ASP_RUNDIR", "ASP_LOGDIR", "ASP_BINDIR", "ASP_CONFIG", "ASP_DBDIR", 0 };
ClCharT* storage[] = { ASP_NODENAME , ASP_COMPNAME , ASP_RUNDIR , ASP_LOGDIR , ASP_BINDIR , ASP_CONFIG , ASP_DBDIR, 0 };
for (i=0; envvars[i] != 0; i++)
{
temp = getenv(envvars[i]);
if (temp) strncpy(storage[i],temp,CL_MAX_NAME_LENGTH-1);
else
{
strcat(missing,envvars[i]);
strcat(missing," ");
}
}
}
if (1) /* Optional environment variables */
{
const ClCharT* envvars[] = { "ASP_APP_BINDIR", 0 }; /* This won't be defined if the AMF is run */
ClCharT* storage[] = { ASP_APP_BINDIR, 0 };
for (i=0; envvars[i] != 0; i++)
{
temp = getenv(envvars[i]);
if (temp) strncpy(storage[i],temp,CL_MAX_NAME_LENGTH-1);
}
}
strcpy(CL_APP_BINDIR,ASP_APP_BINDIR);
temp = getenv("ASP_NODEADDR");
if (temp) ASP_NODEADDR = atoi(temp);
else strcat(missing,"ASP_NODEADDR ");
SYSTEM_CONTROLLER = clParseEnvBoolean("SYSTEM_CONTROLLER");
ASP_SC_PROMOTE = clParseEnvBoolean("ASP_SC_PROMOTE");
if (missing[0])
{
clLog(CL_LOG_SEV_CRITICAL, CL_LOG_AREA, CL_LOG_CTXT_INI, "The following required environment variables are not set: %s.", missing);
rc = CL_ERR_DOESNT_EXIST;
}
if (1)
{
ClCharT *iocAddressStr;
iocAddressStr = getenv("ASP_NODEADDR");
if (iocAddressStr != NULL)
{
clAspLocalId = atoi(iocAddressStr); /* Deprecated */
ASP_NODEADDR = atoi(iocAddressStr);
}
else
{
clLog(CL_LOG_SEV_CRITICAL, CL_LOG_AREA, CL_LOG_CTXT_INI, "ASP_NODEADDR environment variable not set.");
rc = CL_ERR_DOESNT_EXIST;
}
}
return rc;
}
static ClRcT
cdbGDBMOpen(ClDBFileT dbFile,
ClDBNameT dbName,
ClDBFlagT dbFlag,
ClUint32T maxKeySize,
ClUint32T maxRecordSize,
ClDBHandleT* pDBHandle)
{
ClRcT errorCode = CL_OK;
GDBMHandle_t* pGDBMHandle = NULL;
ClUint32T read_write = 0;
ClDBTypeT dbType = CL_DB_TYPE_BTREE;
CL_FUNC_ENTER();
NULL_CHECK(pDBHandle);
NULL_CHECK(dbName);
/* Validate the flag */
if(dbFlag >= CL_DB_MAX_FLAG) {
errorCode = CL_DBAL_RC(CL_ERR_INVALID_PARAMETER);
CL_DEBUG_PRINT (CL_DEBUG_WARN,("Invalid Flag"));
CL_FUNC_EXIT();
return(errorCode);
}
/* Validate database type */
if(dbType >= CL_DB_MAX_TYPE) {
errorCode = CL_DBAL_RC(CL_ERR_INVALID_PARAMETER);
CL_DEBUG_PRINT (CL_DEBUG_WARN,("Invalid DB Type"));
CL_FUNC_EXIT();
return(errorCode);
}
pGDBMHandle = (GDBMHandle_t*)clHeapCalloc(1,sizeof(GDBMHandle_t));
if(NULL == pGDBMHandle) {
errorCode = CL_DBAL_RC(CL_ERR_NO_MEMORY);
CL_DEBUG_PRINT (CL_DEBUG_TRACE,("Memory allocation failed."));
CL_FUNC_EXIT();
return(errorCode);
}
pGDBMHandle->syncMode = CL_FALSE;
if(CL_DB_SYNC & dbFlag)
{
dbFlag &= ~(CL_DB_SYNC);
pGDBMHandle->syncMode = CL_TRUE;
}
/* Let the env variable override the coded behaviour */
if (getenv("ASP_DB_SYNC"))
{
if (clParseEnvBoolean("ASP_DB_SYNC") == CL_TRUE)
{
pGDBMHandle->syncMode = CL_TRUE;
}
else
{
pGDBMHandle->syncMode = CL_FALSE;
}
}
if(CL_DB_CREAT == dbFlag) {
read_write = GDBM_NEWDB | GDBM_NOLOCK;
}
else {
pGDBMHandle->gdbmInstance = gdbm_open((ClCharT*)dbName, CL_GDBM_BLOCK_SIZE, GDBM_READER, CL_GDBM_FILE_MODE, NULL);
if ((NULL == pGDBMHandle->gdbmInstance) && (CL_DB_APPEND != dbFlag)) {
clHeapFree(pGDBMHandle);
errorCode = CL_DBAL_RC(CL_ERR_NOT_EXIST);
CL_DEBUG_PRINT ( CL_DEBUG_WARN,("\nGDBM Open failed."));
CL_FUNC_EXIT();
return(errorCode);
}
if (NULL != pGDBMHandle->gdbmInstance) gdbm_close(pGDBMHandle->gdbmInstance);
if (CL_DB_OPEN == dbFlag)
read_write = GDBM_WRITER;
else if (CL_DB_APPEND == dbFlag)
read_write = GDBM_WRCREAT;
else
{
clHeapFree(pGDBMHandle);
errorCode = CL_DBAL_RC(CL_ERR_BAD_FLAG);
CL_DEBUG_PRINT (CL_DEBUG_WARN,("\nInvalid DB flag. GDBM open failed."));
CL_FUNC_EXIT();
return(errorCode);
}
}
if(CL_TRUE == pGDBMHandle->syncMode)
{
read_write |= GDBM_SYNC;
}
/* Create/Open the GDBM database */
pGDBMHandle->gdbmInstance = gdbm_open((ClCharT*)dbName, CL_GDBM_BLOCK_SIZE, read_write, CL_GDBM_FILE_MODE, NULL);
if(NULL == (pGDBMHandle->gdbmInstance)) {
/* if the creation failed, return error */
clHeapFree(pGDBMHandle);
errorCode = CL_DBAL_RC(CL_DBAL_ERR_DB_ERROR);
CL_DEBUG_PRINT ( CL_DEBUG_WARN,("\nGDBM Open failed."));
CL_FUNC_EXIT();
return(errorCode);
}
pGDBMHandle->deleteRecCnt = 0;
/* Return the handle to the created/opened database */
*pDBHandle = (ClDBHandleT)pGDBMHandle;
CL_FUNC_EXIT();
return(CL_OK);
}
static ClRcT _clPluginHelperGetIpNodeAddress(const ClCharT *xportType, const ClCharT *devIf, ClCharT *hostAddress, ClCharT *networkMask, ClCharT *broadcast, ClUint32T *ipAddressMask, ClCharT *xportSubnetPrefix)
{
ClCharT envSubNetType[CL_MAX_FIELD_LENGTH] = { 0 };
ClCharT xportSubnet[CL_MAX_FIELD_LENGTH] = { 0 };
ClCharT *subnetMask = NULL;
ClCharT *subnetPrefix = NULL;
ClUint32T CIDR, ipMask, ip, mask;
ClRcT rc;
if (!xportType)
{
return CL_ERR_INVALID_PARAMETER;
}
else
{
snprintf(envSubNetType, CL_MAX_FIELD_LENGTH, "ASP_%s_SUBNET", xportType);
subnetMask = getenv(envSubNetType);
if (subnetMask == NULL)
{
subnetMask = ASP_PLUGIN_SUBNET_DEFAULT;
}
subnetPrefix = strrchr(subnetMask, '/');
if(!subnetPrefix)
{
subnetPrefix = ASP_PLUGIN_SUBNET_PREFIX_DEFAULT;
}
else
{
++subnetPrefix;
}
if(! (CIDR = atoi(subnetPrefix) ) )
{
clLogInfo("IOC", CL_LOG_PLUGIN_HELPER_AREA, "%s", subnetMask);
return CL_ERR_INVALID_PARAMETER;
}
xportSubnetPrefix[0] = 0;
strncat(xportSubnetPrefix, subnetPrefix, CL_MAX_FIELD_LENGTH-1);
snprintf(xportSubnet, sizeof(xportSubnet), "%s", subnetMask);
mask = _clPluginHelperBitFillRShift(CIDR);
_clPluginHelperConvertInternetToHostAddress(&ip, xportSubnet);
/* network address */
ipMask = (ip & mask);
/* Try to get address from devif */
rc = CL_OK+1; /* start with any error condition, so the if below this one will be taken */
if (clParseEnvBoolean("ASP_UDP_USE_EXISTING_IP"))
{
rc = _clPluginHelperDevToIpAddress(devIf, hostAddress);
if (rc == CL_OK) clLogInfo("IOC",CL_LOG_PLUGIN_HELPER_AREA,"Use existing IP address [%s] as this nodes transport address.", hostAddress);
else clLogError("IOC",CL_LOG_PLUGIN_HELPER_AREA,"Configured to use an existing IP address for message transport. But address lookup failed on device [%s] error [0x%x]", devIf, rc);
}
if (rc != CL_OK)
{
/* Automatic assignment of IP address */
_clPluginHelperConvertHostToInternetAddress(ipMask + gIocLocalBladeAddress, hostAddress);
}
_clPluginHelperConvertHostToInternetAddress(mask, networkMask);
_clPluginHelperConvertHostToInternetAddress(ip | ~mask, broadcast);
*ipAddressMask = ipMask;
}
return CL_OK;
}
ClRcT clNodeCacheInitialize(ClBoolT createFlag)
{
ClRcT rc = CL_OK;
ClUint32T capability = 0;
SaNameT nodeName = {0};
if(gpClNodeCache)
goto out;
gClAspNativeLeaderElection = !clParseEnvBoolean("CL_ASP_OPENAIS_LEADER_ELECTION");
snprintf(gClNodeCacheSegment, sizeof(gClNodeCacheSegment)-1,
"%s_%d", CL_NODE_CACHE_SEGMENT, clIocLocalAddressGet());
if(createFlag == CL_TRUE)
{
rc = clNodeCacheCreate();
}
else
{
rc = clNodeCacheOpen();
}
if(rc != CL_OK)
{
clLogError("NODE", "CACHE", "Segment initialize returned [%#x]", rc);
goto out;
}
CL_ASSERT(gpClNodeCache != NULL);
if(!createFlag)
{
goto out;
}
CL_NODE_CACHE_HEADER_BASE(gpClNodeCache)->maxNodes = CL_IOC_MAX_NODES;
CL_NODE_CACHE_HEADER_BASE(gpClNodeCache)->currentNodes = 0;
memset(CL_NODE_CACHE_HEADER_BASE(gpClNodeCache)->nodeMap, 0,
sizeof(CL_NODE_CACHE_HEADER_BASE(gpClNodeCache)->nodeMap));
if(clCpmIsSC())
{
CL_NODE_CACHE_SC_CAPABILITY_SET(capability);
CL_NODE_CACHE_SC_PROMOTE_CAPABILITY_SET(capability);
}
else if(clCpmIsSCCapable())
{
CL_NODE_CACHE_SC_PROMOTE_CAPABILITY_SET(capability);
CL_NODE_CACHE_PL_CAPABILITY_SET(capability);
}
else
{
CL_NODE_CACHE_PL_CAPABILITY_SET(capability);
}
clCpmLocalNodeNameGet(&nodeName);
clNodeCacheUpdate(clIocLocalAddressGet(),CL_VERSION_CURRENT, capability, &nodeName);
rc = clOsalMsync(gpClNodeCache, CL_NODE_CACHE_SEGMENT_SIZE, MS_ASYNC);
if(rc != CL_OK)
{
clLogError("NODE", "CACHE", "Node cache segment msync returned [%#x]", rc);
goto out;
}
gClNodeCacheOwner = CL_TRUE;
out:
return rc;
}
