static ClRcT
initSocket()
{
char *ipaddr;
in_addr_t addr_val;
char *port;
uint16_t port_num;
CL_FUNC_ENTER();
//
// We'll want to get the address where we'll send instrumentation
// information out of the environment. Initialize the sockaddr
// so after we create the socket we can connect it to the address.
if ((ipaddr = getenv("CL_LOGGING_ADDR")) == 0)
{
clOsalPrintf("No value for CL_LOGGING_ADDR\n");
CL_FUNC_EXIT();
return CL_RC(0, CL_ERR_INVALID_PARAMETER);
}
if ((port = getenv("CL_LOGGING_PORT")) == 0)
{
clOsalPrintf("No value for CL_LOGGING_PORT\n");
CL_FUNC_EXIT();
return CL_RC(0, CL_ERR_INVALID_PARAMETER);
}
addr_val = inet_addr(ipaddr);
port_num = atoi(port);
memset(&instaddr, 0, sizeof instaddr);
instaddr.sin_port = htons(port_num);
instaddr.sin_addr.s_addr = addr_val;
sock = socket(PF_INET, SOCK_DGRAM, 0);
if (sock == -1)
{
clOsalPrintf("Failed to open socket");
return CL_OSAL_ERR_OS_ERROR;
}
// if (connect(sock, &instaddr, sizeof addr) != 0)
// {
// clOsalPrintf("Failed to connect socket to %s/%s\n", ipaddr, port);
// close(sock);
// sock = -1;
// CL_FUNC_EXIT();
// return CL_OSAL_ERR_OS_ERROR;
// }
CL_FUNC_EXIT();
return CL_OK;
}
ClUint32T clGetTable ( ClSnmpReqInfoT* reqInfo,
void* data,
ClInt32T* pErrCode)
{
ClMedOpT opInfo;
ClMedVarBindT *tempVarInfo = NULL;
ClInt32T errorCode = CL_OK;
ClInt32T retVal = 0;
ClCharT oid[CL_SNMP_DISPLAY_STRING_SIZE];
opInfo.varCount = 1;
tempVarInfo =
(ClMedVarBindT *) clHeapCalloc(1,opInfo.varCount * sizeof (ClMedVarBindT));
if (tempVarInfo == NULL)
{
clLogError("SNM","OPE", "Failed while allocating the varbind.");
return (CL_RC(CL_CID_SNMP, CL_ERR_NO_MEMORY));
}
retVal = 0;
strcpy(oid, reqInfo->oid);
/*oid received till this point is that of the table. Add .1.1 to
get oid of the first entry in the table
*/
strcat(oid,".1.1");
opInfo.varInfo = tempVarInfo;
opInfo.varInfo[0].pVal = data;
opInfo.varInfo[0].errId = 0;
opInfo.varInfo[0].pInst = reqInfo;
opInfo.opCode = reqInfo->opCode;
opInfo.varInfo[0].attrId.id = (ClUint8T*)oid;
opInfo.varInfo[0].attrId.len = (ClUint32T)strlen(oid) + 1;
opInfo.varInfo[0].len = reqInfo->dataLen;
errorCode = clMedOperationExecute (gSubAgentInfo.medHdl, &opInfo);
if ((opInfo.varInfo[0].errId == 0) && (errorCode == 0))
{
clHeapFree (tempVarInfo);
return (CL_OK);
}
else
{
if (errorCode != CL_OK)
*pErrCode = errorCode;
else
*pErrCode = opInfo.varInfo[0].errId;
clLogError(CL_LOG_AREA_UNSPECIFIED,CL_LOG_CONTEXT_UNSPECIFIED,
"clMedOperationExecute returned error. error code = %x, error id = %d",
errorCode, opInfo.varInfo[0].errId);
}
clHeapFree (tempVarInfo);
return (errorCode);
}
ClUint32T clGetTableAttr ( ClSnmpReqInfoT* reqInfo,
void *data,
ClInt32T *pErrCode)
{
ClMedOpT opInfo;
ClMedVarBindT *tempVarInfo = NULL;
ClInt32T errorCode = CL_OK;
opInfo.varCount = 1;
tempVarInfo =
(ClMedVarBindT *) clHeapCalloc(1,opInfo.varCount * sizeof (ClMedVarBindT));
if (tempVarInfo == NULL)
{
clLogError("SNM","OPE", "Failed while allocating the varbind.");
return (CL_RC(CL_CID_SNMP, CL_ERR_NO_MEMORY));
}
opInfo.varInfo = tempVarInfo;
opInfo.varInfo[0].errId = 0;
opInfo.varInfo[0].pInst = reqInfo;
opInfo.opCode = reqInfo->opCode;
opInfo.varInfo[0].pVal = data;
opInfo.varInfo[0].len = reqInfo->dataLen;
opInfo.varInfo[0].attrId.id = (ClUint8T*)reqInfo->oid;
opInfo.varInfo[0].attrId.len = (ClUint32T)strlen(reqInfo->oid) + 1;
opInfo.varInfo[0].len = reqInfo->dataLen;
errorCode = clMedOperationExecute (gSubAgentInfo.medHdl, &opInfo);
*pErrCode = opInfo.varInfo[0].errId;
reqInfo->dataLen = opInfo.varInfo[0].len;
if ((opInfo.varInfo[0].errId == 0) && (errorCode == 0))
{
clHeapFree(tempVarInfo);
return (CL_OK);
}
else
{
clHeapFree(tempVarInfo);
return (errorCode);
}
}
ClRcT
clInstSetIdentity(const ClNameT *nodeName, const ClNameT *compName)
{
CL_FUNC_ENTER();
if (myInstId == 0)
{
return CL_RC(0, CL_ERR_NOT_INITIALIZED);
}
if (myInstId->nodeName.length == 0)
{
memcpy(&myInstId->nodeName, nodeName, sizeof *nodeName);
}
if (myInstId->compName.length == 0)
{
memcpy(&myInstId->compName, compName, sizeof *compName);
}
CL_FUNC_EXIT();
return CL_OK;
}
ClRcT
clInstInitId()
{
ClRcT rc = CL_OK;
InstrumentedId *tmpPtr = 0;
CL_FUNC_ENTER();
// check whether the id has been initialized
if (myInstId != 0)
{
CL_FUNC_EXIT();
return CL_OK;
}
if (sock == -1)
{
rc = initSocket();
if (rc != CL_OK)
{
clOsalPrintf("failed to initialize instrumentation socket\n");
return rc;
}
}
// Nope, not initialized, so try to initialize it here.
// First, try to lock a mutex so that only one thread
// will be creating the id.
// Then, try to get our component name, our local node name
// and then allocate the id and set it from the component
// and local node name.
// Finally, unlock and delete the mutex.
if (!id_mutex)
{
if ((rc = clOsalMutexCreateAndLock(&id_mutex)) != CL_OK)
{
clOsalPrintf("Failed [0x%x] to create and lock mutex\n", rc);
CL_FUNC_EXIT();
return rc;
}
}
else
{
// Some other thread must have come through here and set
// the mutex before us. We're done.
CL_FUNC_EXIT();
return CL_OK;
}
if ((tmpPtr = clHeapCalloc(1, sizeof (InstrumentedId))) == 0)
{
clOsalPrintf("failed to allocate InstrumentedID\n");
rc = CL_RC(0, CL_ERR_NO_MEMORY);
goto breakdown;
}
memset(&tmpPtr->compName, 0, sizeof tmpPtr->compName);
memset(&tmpPtr->nodeName, 0, sizeof tmpPtr->nodeName);
rc = CL_OK;
myInstId = tmpPtr;
tmpPtr = 0;
breakdown:
clOsalMutexUnlock(id_mutex);
clOsalMutexDelete(id_mutex);
id_mutex = 0;
CL_FUNC_EXIT();
return rc;
}
ClRcT
clInstSendMessage(int msgType, const char *msg)
{
char msgBuf[INST_BUF_SIZE];
ClRcT rc = CL_OK;
int space;
char *ptr = msgBuf;
CL_FUNC_ENTER();
if ((rc = clInstInitId()) != CL_OK)
{
clOsalPrintf("Failed [0x%x] to initialize Instrumentation id\n", rc);
CL_FUNC_EXIT();
return rc;
}
//
// Fill in the msgBuf: msgType,nodeName,compName,msg
// Check that we have room for the message, formatting it
// as we go. Finally, send it over the socket which should
// already been connected in clInstInitId
sprintf(msgBuf, "%d", CL_INST_VERSION);
space = sizeof msgBuf - 1;
sprintf(msgBuf+1, "%d,", msgType);
space = sizeof msgBuf - 2;
ptr += strlen(ptr);
space = (sizeof msgBuf) - (ptr - msgBuf);
if (myInstId->nodeName.length == 0)
{
strcpy(ptr, "unknown_node,");
}
else
{
if ((myInstId->nodeName.length + 1) >= space)
{
clOsalPrintf("nodeName (%s) too long for remaining space (%d)\n",
myInstId->nodeName.value, space);
}
else
{
strcpy(ptr, myInstId->nodeName.value);
strcat(ptr, ",");
}
}
ptr += strlen(ptr);
space = (sizeof msgBuf) - (ptr - msgBuf);
if (myInstId->compName.length == 0)
{
strcat(ptr, "unknown_component,");
}
else
{
if ((myInstId->compName.length + 1) >= space)
{
clOsalPrintf("compName (%s) too long for remaining space (%d)\n",
myInstId->compName.value, space);
return CL_RC(0, CL_ERR_BUFFER_OVERRUN);
}
else
{
strcpy(ptr, myInstId->compName.value);
strcat(ptr, ",");
}
}
ptr += strlen(ptr);
space = (sizeof msgBuf) - (ptr - msgBuf);
// check that there's enough room for the message in our buffer
// and if there is then copy it in.
if (strlen(msg) >= space)
{
strncpy(ptr, msg, space - 4); // room for "..."
ptr += (space - 4);
strcpy(ptr, "...");
}
else
{
strcpy(ptr, msg);
}
ptr += strlen(ptr);
space = (sizeof msgBuf) - (ptr - msgBuf);
if (sendto(sock, msgBuf, ptr - msgBuf, 0, &instaddr, sizeof instaddr) == -1)
{
clOsalPrintf("Failed to send message, sock = %d, errno = %d\n", sock, errno);
return CL_OSAL_ERR_OS_ERROR;
}
CL_FUNC_EXIT();
return rc;
}
