static int getEventId(void *ptr)
{
int i,ans;
LockMdsShrMutex(&eventIdMutex,&eventIdMutex_initialized);
if(eventTopIdx >= MAX_EVENTS - 1) //If top reached, find some hole
{
for(i = 0; i < MAX_EVENTS; i++)
{
if(!eventInfos[i])
{
eventInfos[i] = ptr;
ans = i+1;
}
}
if (i == MAX_EVENTS)
{
printf("Too Many events!!");
ans = 0;
}
}
else
{
eventInfos[eventTopIdx] = ptr;
eventTopIdx++;
ans= eventTopIdx;
}
UnlockMdsShrMutex(&eventIdMutex);
return ans;
}
static int getSocket()
{
LockMdsShrMutex(&getSocketMutex,&getSocketMutex_initialized);
if(!sendSocket)
{
if((sendSocket = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
perror("Error creating socket\n");
sendSocket = -1;
}
}
UnlockMdsShrMutex(&getSocketMutex);
return sendSocket;
}
static int releaseEventInfo(void *ptr)
{
int i,status=0;
LockMdsShrMutex(&eventIdMutex,&eventIdMutex_initialized);
for(i = 0; i < eventTopIdx; i++)
{
if(eventInfos[i] == ptr)
{
free(((struct EventInfo *)ptr)->eventName);
free(ptr);
eventInfos[i] = 0;
status=1;
}
}
UnlockMdsShrMutex(&eventIdMutex);
return status;
}
static int getPort()
{
char *portStr;
struct servent *serverInfo;
LockMdsShrMutex(&getPortMutex,&getPortMutex_initialized);
if(udpPort == -1)
{
portStr = getenv("mdsevent_port");
if(portStr)
{
sscanf(portStr, "%d", &udpPort);
}
else
{
serverInfo = getservbyname("mdsplus_event", "udp");
if(serverInfo)
udpPort = serverInfo->s_port;
else
udpPort = MULTICAST_EVENT_PORT;
}
}
UnlockMdsShrMutex(&getPortMutex);
return udpPort;
}
/****************************************************************
* mdsdcl_do_command:
* Effectively, the main MDSDCL routine ...
****************************************************************/
int mdsdcl_do_command(
void *command /* <r:opt> command -- cstring or dsc */
)
{
int tblidx;
int sts,stsParse;
int tried_indirect = 0;
struct _mdsdcl_io *io;
static char doMacro[12];
static DYNAMIC_DESCRIPTOR(dsc_cmd);
struct _mdsdcl_ctrl *ctrl = &MdsdclGetThreadStatic()->ctrl;
#ifdef vms
extern int MDSDCL$MSG_TO_RET();
extern int MDSDCL$OUT_OF_BAND_AST();
#endif
/*---------------------------------------------------------------
* Executable:
*--------------------------------------------------------------*/
LockMdsShrMutex(&mdsdclMutex,&mdsdclMutex_initialized);
if (!ctrl->tbladr[0]) mdsdcl_initialize(ctrl);
tblidx = ctrl->tables;
if (!doMacro[0])
{ /* first time ... */
sprintf(doMacro,"DO %cMACRO ",'/');
}
io = ctrl->ioLevel + ctrl->depth;
if (command)
{
str_trim(&io->last_command,command);
str_copy_dx(&dsc_cmd,&io->last_command);
mdsdcl_insert_symbols(io->ioParameter,&dsc_cmd);
}
else
{
str_free1_dx(&io->last_command);
str_free1_dx(&dsc_cmd);
}
/*-------------------------------------------------------
* Try each table in turn ...
*------------------------------------------------------*/
for ( ; tblidx>0 ; tblidx--)
{
do {
stsParse = mdsdcl_dcl_parse(&dsc_cmd,ctrl,tblidx);
} while(stsParse == CLI_STS_NOCOMD);
/* 25-Feb-03: ignore blank lines -- TRG */
if (~stsParse & 1)
{
if ((stsParse == CLI_STS_EOF) || (stsParse == CLI_STS_NOCOMD)) {
UnlockMdsShrMutex(&mdsdclMutex);
return(stsParse);
} else if (stsParse == MDSDCL_STS_INDIRECT_EOF) {
UnlockMdsShrMutex(&mdsdclMutex);
return(stsParse); /*--------------------> return */
}
}
io = ctrl->ioLevel + ctrl->depth;
if (!dsc_cmd.dscA_pointer)
str_copy_dx(&dsc_cmd,&io->last_command);
if (stsParse & 1)
{ /* Try to dispatch the routine ... */
sts = cli_dispatch(ctrl);
if (sts != CLI_STS_INVROUT)
{
if (ctrl->verify && sts != 3)
displayCmdline(dsc_cmd.dscA_pointer);
if (~sts & 1)
{
if (dsc_cmd.dscA_pointer)
MdsMsg(0,"--> failed on line '%s'",
dsc_cmd.dscA_pointer);
mdsdcl_close_indirect_all();
}
UnlockMdsShrMutex(&mdsdclMutex);
return(sts); /*--------------------> return */
}
}
}
/*-------------------------------------------------------
* Command not found in any table: try it as a macro ...
*------------------------------------------------------*/
if (ctrl->verify)
displayCmdline(dsc_cmd.dscA_pointer);
tblidx = 1; /* i.e., the table for DO/MACRO */
str_prefix(&dsc_cmd,doMacro);
sts = mdsdcl_dcl_parse(&dsc_cmd,ctrl,tblidx);
if (sts & 1)
{ /* Try to dispatch the macro ... */
sts = cli_dispatch(ctrl);
}
else if (sts == CLI_STS_IVQUAL)
{
MdsMsg(0,"No such command"); /* CLI_STS_IVQUAL msg is suppressed
* by cli_process_qualifier() */
}
if (~sts & 1)
mdsdcl_close_indirect_all();
UnlockMdsShrMutex(&mdsdclMutex);
return(sts); /*--------------------> return */
}
static void lock()
{
LockMdsShrMutex(&eventMutex,&eventMutex_initialized);
}
int MDSUdpEvent(char *evName, int bufLen, char *buf)
{
char multiIp[64];
int udpSocket;
struct sockaddr_in sin;
char *msg, *currPtr;
int msgLen, nameLen, actBufLen;
int status, error;
struct hostent *hp =(struct hostent *) NULL;
initialize();
getMulticastAddr(evName, multiIp);
udpSocket = getSocket();
#ifdef HAVE_VXWORKS_H
bzero((char *)&sin, sizeof(struct sockaddr_in));
sin.sin_family = AF_INET;
sin.sin_port = htons( getPort() );
sin.sin_len = (u_char)(sizeof(struct sockaddr_in));
if(((sin.sin_addr.s_addr = inet_addr(multiIp)) == ERROR) &&
((sin.sin_addr.s_addr = hostGetByName(multiIp)) == ERROR))
perror("Unknown recipient name in IP address initialization\n");
#else
memset((char *)&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
hp = gethostbyname(multiIp);
if (hp == NULL)
{
unsigned int addr = inet_addr(multiIp);
if (addr != 0xffffffff)
hp = gethostbyaddr((const char *) &addr, (int) sizeof(addr), AF_INET);
}
if(hp != NULL)
memcpy(&sin.sin_addr, hp->h_addr_list[0], hp->h_length);
sin.sin_port = htons( getPort() );
#endif
nameLen = strlen(evName);
if(bufLen < MAX_MSG_LEN - (4 + 4 + nameLen))
actBufLen = bufLen;
else
actBufLen = MAX_MSG_LEN - (4 + 4 + nameLen);
msgLen = 4 + nameLen + 4 + actBufLen;
msg = malloc(msgLen);
currPtr = msg;
*((unsigned int *)currPtr) = htonl(nameLen);
currPtr += 4;
memcpy(currPtr, evName, nameLen);
currPtr += nameLen;
*((unsigned int *)currPtr) = htonl(bufLen);
currPtr += 4;
memcpy(currPtr, buf, bufLen);
LockMdsShrMutex(&sendEventMutex,&sendEventMutex_initialized);
if(sendto(udpSocket, msg, msgLen, 0,
(struct sockaddr *)&sin, sizeof(sin))==-1)
{
perror("Error sending UDP message!\n");
#ifdef HAVE_WINDOWS_H
error = WSAGetLastError();
switch(error)
{
case WSANOTINITIALISED: printf("WSAENETDOWN\n"); break;
case WSAENETDOWN: printf("WSAENETDOWN\n"); break;
case WSAEADDRINUSE: printf("WSAEADDRINUSE\n"); break;
case WSAEINTR : printf("WSAEINTR\n"); break;
case WSAEINPROGRESS: printf("WSAEINPROGRESS\n"); break;
case WSAEALREADY: printf("WSAEALREADY\n"); break;
case WSAEADDRNOTAVAIL: printf("WSAEADDRNOTAVAIL\n"); break;
case WSAEAFNOSUPPORT: printf("WSAEAFNOSUPPORT\n"); break;
case WSAECONNREFUSED : printf("WSAECONNREFUSED\n"); break;
case WSAEFAULT : printf("WSAEFAULT\n"); break;
default: printf("BOH\n");
}
#endif
status = 0;
}
else
status = 1;
UnlockMdsShrMutex(&sendEventMutex);
return status;
}
int TreeLockNci(TREE_INFO *info, int readonly, int nodenum, int *deleted) {
int status = MDS_IO_LOCK(readonly ? info->nci_file->get : info->nci_file->put,
nodenum * 42,42,readonly ? MDS_IO_LOCK_RD : MDS_IO_LOCK_WRT,deleted);
LockMdsShrMutex(&NCIMutex,&NCIMutex_initialized);
return status;
}
