void sendEventMessageOption121(int Len , unsigned char *option121Data)
{
char *buf = (char*)malloc(sizeof(CmsMsgHeader)+Len);
//char buf[sizeof(CmsMsgHeader) + Len]= {0};
CmsMsgHeader *msg=(CmsMsgHeader *) buf;
unsigned char *Data = (unsigned char *) (msg+1);
CmsRet ret;
int i;
msg->type = CMS_MSG_DHCPC_OPTION121;
msg->src = MAKE_SPECIFIC_EID(getpid(), EID_DHCPC);
msg->dst = EID_SSK;
msg->flags_event = 1;
msg->dataLength = Len;
//strncpy(Data , option121Data , Len);
for(i=0 ; i<Len ; i++) Data[i] = option121Data[i];
if ((ret = cmsMsg_send(msgHandle, msg)) != CMSRET_SUCCESS)
{
cmsLog_error("could not send out DHCPC_STATUS_CHANGED, ret=%d", ret);
}
else
{
cmsLog_notice("sent out DHCPC_OPTION121 (Len=%d)", Len);
}
free(buf);
return;
}
void cmsMem_initSharedMem(void *addr, UINT32 len)
{
mStats.shmAllocStart = (UINT32) addr;
mStats.shmAllocEnd = mStats.shmAllocStart + len;
mStats.shmTotalBytes = len;
cmsLog_notice("shm pool: %p-%p", mStats.shmAllocStart, mStats.shmAllocEnd);
bpool(addr, len);
}
void cmsMem_initSharedMemPointer(void *addr, UINT32 len)
{
/*
* You might be tempted to do a memset(&mStats, 0, sizeof(mStats)) here.
* But don't do it. mStats will be initialized to all zeros anyways since
* it is in the bss. And smd will start using the memory allocator before
* it calls cmsMem_initSharedMemPointer, so if we zero out the structure
* at the beginning of this function, the counters will be wrong.
*/
mStats.shmAllocStart = (UINT32) addr;
mStats.shmAllocEnd = mStats.shmAllocStart + len;
mStats.shmTotalBytes = len;
cmsLog_notice("shm pool: %p-%p", mStats.shmAllocStart, mStats.shmAllocEnd);
bcm_secondary_bpool(addr);
}
char *cmsUtl_strncpy(char *dest, const char *src, SINT32 dlen)
{
if((src == NULL) || (dest == NULL))
{
cmsLog_error("null pointer reference src =%u ,dest =%u", src, dest);
}
if( strlen(src)+1 > dlen )
{
cmsLog_notice("truncating:src string length > dest buffer");
strncpy(dest,src,dlen-1);
dest[dlen-1] ='\0';
}
else
{
strcpy(dest,src);
}
return dest;
}
/** Set contents of a scratch pad buffer identified by tokenId.
*
* This function follows the logic of the same function name in
* bcmdrivers/opensource/char/board/bcm963xx/impl1/bcm63xx_flash.c
*
* @return 0 - ok, -1 - fail.
*/
int fake_kerSysScratchPadSet(char *tokenId, char *tokBuf, int bufLen)
{
PSP_TOKEN pToken = NULL;
char *pShareBuf = NULL;
char *pBuf = NULL;
SP_HEADER SPHead;
SP_TOKEN SPToken;
char *curPtr;
int sts = -1;
if (fInfo.flash_scratch_pad_length == 0)
return sts;
if( bufLen >= (int) (fInfo.flash_scratch_pad_length - sizeof(SP_HEADER) -
sizeof(SP_TOKEN)) )
{
cmsLog_error("Scratch pad overflow by %d bytes. Information not saved.\n",
bufLen - fInfo.flash_scratch_pad_length - sizeof(SP_HEADER) -
sizeof(SP_TOKEN));
return sts;
}
if( (pShareBuf = fake_getSharedBlks( fInfo.flash_scratch_pad_start_blk,
(fInfo.flash_scratch_pad_start_blk +
fInfo.flash_scratch_pad_number_blk) )) == NULL )
{
return sts;
}
// pBuf points to SP buf
pBuf = pShareBuf + fInfo.flash_scratch_pad_blk_offset;
// form header info.
memset((char *)&SPHead, 0, sizeof(SP_HEADER));
memcpy(SPHead.SPMagicNum, MAGIC_NUMBER, MAGIC_NUM_LEN);
SPHead.SPVersion = SP_VERSION;
// form token info.
memset((char*)&SPToken, 0, sizeof(SP_TOKEN));
strncpy(SPToken.tokenName, tokenId, TOKEN_NAME_LEN - 1);
SPToken.tokenLen = bufLen;
if(memcmp(((PSP_HEADER)pBuf)->SPMagicNum, MAGIC_NUMBER, MAGIC_NUM_LEN) != 0)
{
// new sp, so just flash the token
cmsLog_notice("No scratch pad found. Initialize scratch pad...\n");
memcpy(pBuf, (char *)&SPHead, sizeof(SP_HEADER));
curPtr = pBuf + sizeof(SP_HEADER);
memcpy(curPtr, (char *)&SPToken, sizeof(SP_TOKEN));
curPtr += sizeof(SP_TOKEN);
if( tokBuf )
memcpy(curPtr, tokBuf, bufLen);
}
else
{
int putAtEnd = 1;
int curLen;
int usedLen;
int skipLen;
/* Calculate the used length. */
usedLen = sizeof(SP_HEADER);
curPtr = pBuf + sizeof(SP_HEADER);
pToken = (PSP_TOKEN) curPtr;
skipLen = (pToken->tokenLen + 0x03) & ~0x03;
while( pToken->tokenName[0] >= 'A' && pToken->tokenName[0] <= 'z' &&
strlen(pToken->tokenName) < TOKEN_NAME_LEN &&
pToken->tokenLen > 0 &&
pToken->tokenLen < fInfo.flash_scratch_pad_length &&
usedLen < fInfo.flash_scratch_pad_length )
{
usedLen += sizeof(SP_TOKEN) + skipLen;
curPtr += sizeof(SP_TOKEN) + skipLen;
pToken = (PSP_TOKEN) curPtr;
skipLen = (pToken->tokenLen + 0x03) & ~0x03;
}
if( usedLen + SPToken.tokenLen + sizeof(SP_TOKEN) >
(UINT32) fInfo.flash_scratch_pad_length )
{
cmsLog_error("Scratch pad overflow by %d bytes. Information not saved.\n",
(usedLen + SPToken.tokenLen + sizeof(SP_TOKEN)) -
fInfo.flash_scratch_pad_length);
/* mwang: did not free pShareBuf, memory leak. */
return sts;
}
curPtr = pBuf + sizeof(SP_HEADER);
curLen = sizeof(SP_HEADER);
while( curLen < usedLen )
{
pToken = (PSP_TOKEN) curPtr;
skipLen = (pToken->tokenLen + 0x03) & ~0x03;
if (strncmp(pToken->tokenName, tokenId, TOKEN_NAME_LEN) == 0)
{
// The token id already exists.
if( tokBuf && pToken->tokenLen == bufLen )
{
// The length of the new data and the existing data is the
// same. Overwrite the existing data.
memcpy((curPtr+sizeof(SP_TOKEN)), tokBuf, bufLen);
putAtEnd = 0;
}
else
{
// The length of the new data and the existing data is
// different. Shift the rest of the scratch pad to this
// token's location and put this token's data at the end.
char *nextPtr = curPtr + sizeof(SP_TOKEN) + skipLen;
int copyLen = usedLen - (curLen+sizeof(SP_TOKEN) + skipLen);
memcpy( curPtr, nextPtr, copyLen );
memset( curPtr + copyLen, 0x00,
fInfo.flash_scratch_pad_length - (curLen + copyLen) );
usedLen -= sizeof(SP_TOKEN) + skipLen;
}
break;
}
// get next token
curPtr += sizeof(SP_TOKEN) + skipLen;
curLen += sizeof(SP_TOKEN) + skipLen;
} // end while
if( putAtEnd )
{
if( tokBuf )
{
memcpy( pBuf + usedLen, &SPToken, sizeof(SP_TOKEN) );
memcpy( pBuf + usedLen + sizeof(SP_TOKEN), tokBuf, bufLen );
}
memcpy( pBuf, &SPHead, sizeof(SP_HEADER) );
}
} // else if not new sp
sts = fake_setSharedBlks(fInfo.flash_scratch_pad_start_blk,
(fInfo.flash_scratch_pad_number_blk + fInfo.flash_scratch_pad_start_blk),
pShareBuf);
fake_retriedKfree(pShareBuf);
return sts;
}
CmsRet oalMsg_init(CmsEntityId eid, void **msgHandle)
{
CmsMsgHandle *handle;
const CmsEntityInfo *eInfo;
struct sockaddr_un serverAddr;
SINT32 rc;
if ((eInfo = cmsEid_getEntityInfo(eid)) == NULL)
{
cmsLog_error("Invalid eid %d", eid);
return CMSRET_INVALID_ARGUMENTS;
}
if ((handle = (CmsMsgHandle *) cmsMem_alloc(sizeof(CmsMsgHandle), ALLOC_ZEROIZE)) == NULL)
{
cmsLog_error("could not allocate storage for msg handle");
return CMSRET_RESOURCE_EXCEEDED;
}
/* store caller's eid */
handle->eid = eid;
#ifdef DESKTOP_LINUX
/*
* Applications may be run without smd on desktop linux, so if we
* don't see a socket for smd, don't bother connecting to it.
*/
{
struct stat statbuf;
if ((rc = stat(SMD_MESSAGE_ADDR, &statbuf)) < 0)
{
handle->commFd = CMS_INVALID_FD;
handle->standalone = TRUE;
*msgHandle = (void *) handle;
cmsLog_notice("no smd server socket detected, running in standalone mode.");
return CMSRET_SUCCESS;
}
}
#endif /* DESKTOP_LINUX */
/*
* Create a unix domain socket.
*/
handle->commFd = socket(AF_LOCAL, SOCK_STREAM, 0);
if (handle->commFd < 0)
{
cmsLog_error("Could not create socket");
cmsMem_free(handle);
return CMSRET_INTERNAL_ERROR;
}
/*
* Set close-on-exec, even though all apps should close their
* fd's before fork and exec.
*/
if ((rc = fcntl(handle->commFd, F_SETFD, FD_CLOEXEC)) != 0)
{
cmsLog_error("set close-on-exec failed, rc=%d errno=%d", rc, errno);
close(handle->commFd);
cmsMem_free(handle);
return CMSRET_INTERNAL_ERROR;
}
/*
* Connect to smd.
*/
memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sun_family = AF_LOCAL;
strncpy(serverAddr.sun_path, SMD_MESSAGE_ADDR, sizeof(serverAddr.sun_path));
rc = connect(handle->commFd, (struct sockaddr *) &serverAddr, sizeof(serverAddr));
if (rc != 0)
{
cmsLog_error("connect to %s failed, rc=%d errno=%d", SMD_MESSAGE_ADDR, rc, errno);
close(handle->commFd);
cmsMem_free(handle);
return CMSRET_INTERNAL_ERROR;
}
else
{
cmsLog_debug("commFd=%d connected to smd", handle->commFd);
}
/* send a launched message to smd */
{
CmsRet ret;
CmsMsgHeader launchMsg = EMPTY_MSG_HEADER;
launchMsg.type = CMS_MSG_APP_LAUNCHED;
launchMsg.src = (eInfo->flags & EIF_MULTIPLE_INSTANCES) ? MAKE_SPECIFIC_EID(getpid(), eid) : eid;
launchMsg.dst = EID_SMD;
launchMsg.flags_event = 1;
if ((ret = oalMsg_send(handle->commFd, &launchMsg)) != CMSRET_SUCCESS)
{
close(handle->commFd);
cmsMem_free(handle);
return CMSRET_INTERNAL_ERROR;
}
else
{
cmsLog_debug("sent LAUNCHED message to smd");
}
}
/* successful, set handle pointer */
*msgHandle = (void *) handle;
return CMSRET_SUCCESS;
}
static void handler_sigterm(int signum)
{
cmsLog_notice("received signal %d", signum);
common_exit(0);
}
