int E2050Reboot(char * inetAddr)
{
struct sockaddr_in serverAddr;
SOCKET fd;
int status;
int nbytes;
errno = 0;
fd = epicsSocketCreate(PF_INET, SOCK_STREAM, 0);
if(fd == -1) {
printf("can't create socket %s\n",strerror(errno));
return(-1);
}
memset((char*)&serverAddr, 0, sizeof(struct sockaddr_in));
serverAddr.sin_family = PF_INET;
/* 23 is telnet port */
status = aToIPAddr(inetAddr,23,&serverAddr);
if(status) {
printf("aToIPAddr failed\n");
return(-1);
}
errno = 0;
status = connect(fd,(struct sockaddr*)&serverAddr, sizeof(serverAddr));
if(status) {
printf("can't connect %s\n",strerror (errno));
epicsSocketDestroy(fd);
return(-1);
}
nbytes = send(fd,"reboot\ny\n",9,0);
if(nbytes!=9) printf("nbytes %d expected 9\n",nbytes);
epicsSocketDestroy(fd);
epicsThreadSleep(20.0);
return(0);
}
/*
* caPutLogClientInit()
*/
int epicsShareAPI caPutLogClientInit (const char *addr_str)
{
int status;
struct sockaddr_in saddr;
long default_port = 7011;
if (caPutLogClient!=NULL) {
return caPutLogSuccess;
}
if (!addr_str || !addr_str[0]) {
addr_str = envGetConfigParamPtr(&EPICS_CA_PUT_LOG_ADDR);
}
status = aToIPAddr (addr_str, default_port, &saddr);
if (status<0) {
fprintf (stderr, "caPutLog: bad address or host name\n");
return caPutLogError;
}
caPutLogClient = logClientCreate (saddr.sin_addr, ntohs(saddr.sin_port));
if (!caPutLogClient) {
return caPutLogError;
}
else {
return caPutLogSuccess;
}
}
/*
* addAddrToChannelAccessAddressList ()
*/
extern "C" void epicsShareAPI addAddrToChannelAccessAddressList
( ELLLIST *pList, const ENV_PARAM *pEnv,
unsigned short port, int ignoreNonDefaultPort )
{
osiSockAddrNode *pNewNode;
const char *pStr;
const char *pToken;
struct sockaddr_in addr;
char buf[32u]; /* large enough to hold an IP address */
int status;
pStr = envGetConfigParamPtr (pEnv);
if (!pStr) {
return;
}
while ( ( pToken = getToken (&pStr, buf, sizeof (buf) ) ) ) {
status = aToIPAddr ( pToken, port, &addr );
if (status<0) {
fprintf ( stderr, "%s: Parsing '%s'\n", __FILE__, pEnv->name);
fprintf ( stderr, "\tBad internet address or host name: '%s'\n", pToken);
continue;
}
if ( ignoreNonDefaultPort && ntohs ( addr.sin_port ) != port ) {
continue;
}
pNewNode = (osiSockAddrNode *) calloc (1, sizeof(*pNewNode));
if (pNewNode==NULL) {
fprintf ( stderr, "addAddrToChannelAccessAddressList(): no memory available for configuration\n");
return;
}
pNewNode->addr.ia = addr;
/*
* LOCK applied externally
*/
ellAdd (pList, &pNewNode->node);
}
return;
}
int E5810Reboot(char * inetAddr,char *password)
{
struct sockaddr_in serverAddr;
SOCKET fd;
int status;
int nbytes;
if(password==0 || strlen(password)<2) password = defaultPassword;
errno = 0;
fd = epicsSocketCreate(PF_INET, SOCK_STREAM, 0);
if(fd == -1) {
printf("can't create socket %s\n",strerror(errno));
return(-1);
}
memset((char*)&serverAddr, 0, sizeof(struct sockaddr_in));
serverAddr.sin_family = PF_INET;
/* 23 is telnet port */
status = aToIPAddr(inetAddr,23,&serverAddr);
if(status) {
printf("aToIPAddr failed\n");
return(-1);
}
errno = 0;
status = connect(fd,(struct sockaddr*)&serverAddr, sizeof(serverAddr));
if(status) {
printf("can't connect %s\n",strerror (errno));
epicsSocketDestroy(fd);
return(-1);
}
nbytes = send(fd,"reboot\n",7,0);
if(nbytes!=7) printf("nbytes %d expected 7\n",nbytes);
epicsThreadSleep(1.0);
nbytes = send(fd,password,(int)strlen(password),0);
if(nbytes!=strlen(password))
printf("nbytes %d expected %d\n",nbytes,(int)strlen(password));
epicsThreadSleep(1.0);
nbytes = send(fd,"\ny\n",3,0);
if(nbytes!=3) printf("nbytes %d expected 3\n",nbytes);
epicsThreadSleep(1.0);
epicsSocketDestroy(fd);
epicsThreadSleep(20.0);
return(0);
}
/*+/subr**********************************************************************
* NAME envGetInetAddrConfigParam - get value of an inet addr config parameter
*
* DESCRIPTION
* Gets the value of a configuration parameter and copies it into
* the caller's (struct in_addr) buffer. If the configuration parameter
* isn't found in the environment, then the default value for
* the parameter is copied.
*
* If no parameter is found and there is no default, then -1 is
* returned and the callers buffer is unmodified.
*
* RETURNS
* 0, or
* -1 if an error is encountered
*
* EXAMPLE
* 1. Get the value for the inet address environment parameter EPICS_INET.
*
* #include "envDefs.h"
* struct in_addr addr;
* long status;
*
* status = envGetInetAddrConfigParam(&EPICS_INET, &addr);
* if (status == 0) {
* printf("the s_addr is: %x\n", addr.s_addr);
* }
* else {
* printf("%s could not be found or was not an inet address\n",
* EPICS_INET.name);
* }
*
*-*/
long epicsShareAPI envGetInetAddrConfigParam(
const ENV_PARAM *pParam,/* I pointer to config param structure */
struct in_addr *pAddr /* O pointer to struct to receive inet addr */
)
{
char text[128];
char *ptext;
long status;
struct sockaddr_in sin;
ptext = envGetConfigParam(pParam, sizeof text, text);
if (ptext) {
status = aToIPAddr (text, 0u, &sin);
if (status == 0) {
*pAddr = sin.sin_addr;
return 0;
}
(void)fprintf(stderr,"Unable to find an IP address or valid host name in %s=%s\n",
pParam->name, text);
}
return -1;
}
int TDS3000Reboot(char * inetAddr)
{
struct sockaddr_in serverAddr;
int fd;
int status;
int nbytes;
char *url;
int urlLen;
url = "GET /resetinst.cgi HTTP/1.0\n\n";
urlLen = strlen(url);
errno = 0;
fd = epicsSocketCreate(PF_INET, SOCK_STREAM, 0);
if(fd == -1) {
printf("can't create socket %s\n",strerror(errno));
return(-1);
}
memset((char*)&serverAddr, 0, sizeof(struct sockaddr_in));
serverAddr.sin_family = PF_INET;
/* 80 is http port */
status = aToIPAddr(inetAddr,80,&serverAddr);
if(status) {
printf("aToIPAddr failed\n");
return(-1);
}
errno = 0;
status = connect(fd,(struct sockaddr*)&serverAddr, sizeof(serverAddr));
if(status) {
printf("can't connect %s\n",strerror (errno));
close(fd);
return(-1);
}
nbytes = send(fd,url,urlLen,0);
if(nbytes!=urlLen) printf("nbytes %d expected %d\n",nbytes,urlLen);
close(fd);
return(0);
}
int epicsShareAPI logAlarmsInit (
) {
DBENTRY dbentry;
DBENTRY *pdbentry=&dbentry;
long status;
int numRecords=0;
int tid[MSG_TASK_NUM], btid, ctid, rtid;
int normalRangeSize, overRangeSize;
struct sockaddr_in *psin;
int node;
char string[32];
char *pstring, *serverList, *ptok, *pheader;
int i;
if (initialized) {
errlogPrintf ("logAlarmsInit: already initialized\n");
return ERROR;
}
clkRate = sysClkRateGet();
tickInitWait = (unsigned long)(clkRate * INIT_DELAY_SEC + 0.5);
tickMaxSilent = (unsigned long)(clkRate * BEACON_IDLE_SEC + 0.5);
tickBeaconPeriod = (unsigned long)(clkRate * BEACON_PERIOD_SEC + 0.5);
tickBeaconReplyTmo = (unsigned long)(clkRate * BEACON_REPLY_TMO_SEC + 0.5);
tickMessageReplyTmo = (unsigned long)(clkRate * MESSAGE_REPLY_TMO_SEC + 0.5);
/* wait time between retrying to send messages (>= 1 tick) */
tickMsgRetryWait = (unsigned long)(clkRate * MESSAGE_RETRY_WAIT_SEC + 0.5);
if (tickMsgRetryWait == 0UL) tickMsgRetryWait = 1UL;
if(!pdbbase) {
errlogPrintf ("logAlarmsInit: No database has been loaded\n");
return ERROR;
}
serverList = getenv ("EPICS_ALARM_SERVER_INET");
if (!serverList) {
errlogPrintf ("logAlarmsInit: EPICS_ALARM_SERVER_INET env not defined\n");
return ERROR;
}
pstring = getenv ("EPICS_ALARM_MESSAGE_PORT");
if (!pstring)
msg_port = DEFAULT_MSG_PORT;
else {
msg_port = (unsigned short) atoi (pstring);
if (msg_port < 1024) {
msg_port = DEFAULT_MSG_PORT;
errlogPrintf ("Port number EPICS_ALARM_MESSAGE_PORT is wrong\n");
}
}
pstring = getenv ("EPICS_ALARM_COMMAND_PORT");
if (!pstring)
cmd_port = DEFAULT_CMD_PORT;
else {
cmd_port = (unsigned short) atoi (pstring);
if (cmd_port < 1024) {
cmd_port = DEFAULT_CMD_PORT;
errlogPrintf ("Port number EPICS_ALARM_COMMAND_PORT is wrong\n");
}
}
/* if allAcceptOption is set, commands are accepted from all servers */
pstring = getenv ("EPICS_ALARM_COMMAND_ACCEPT_ALL");
if (strcmp (pstring, "YES") == 0)
allAcceptOption = TRUE;
psin = &msgServerAddr[0];
node = 0;
ptok = strtok_r (serverList, " ", &pstring);
while (ptok && node < SERVERS_MAX && aToIPAddr (ptok, msg_port, psin) == 0) {
node++;
psin++;
ptok = strtok_r (NULL, " ", &pstring);
}
numServersConfigured = node;
if (numServersConfigured == 0) {
errlogPrintf (
"logAlarmsInit: No server correctly defined in EPICS_ALARM_SERVER_INET\n");
}
wakeupSem = semBCreate (SEM_Q_FIFO, SEM_EMPTY);
if (!wakeupSem) {
errlogPrintf ("logAlarmsInit: Reader wakeup semaphore could not be created\n");
return ERROR;
}
bucketSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
if (!bucketSem) {
errlogPrintf ("logAlarmsInit: Hash facility mutex could not be created\n");
cleanup (1);
return ERROR;
}
ringSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
if (!ringSem) {
errlogPrintf ("logAlarmsInit: Ring r/w mutex could not be created\n");
cleanup (2);
return ERROR;
}
ringWriteSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
if (!ringWriteSem) {
errlogPrintf ("logAlarmsInit: Ring (write) mutex could not be created\n");
cleanup (3);
return ERROR;
}
msgSockSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
if (!msgSockSem) {
errlogPrintf ("logAlarmsInit: MsgSocket mutex could not be created\n");
cleanup (4);
return ERROR;
}
dbInitEntry(pdbbase,pdbentry);
status = dbFirstRecordType(pdbentry);
while(!status) {
int numRecordsType;
numRecordsType = dbGetNRecords(pdbentry);
DEBUG2(4,"There are %d records of type %s\n",
numRecordsType, dbGetRecordTypeName(pdbentry))
numRecords += numRecordsType;
status = dbNextRecordType(pdbentry);
}
dbFinishEntry(pdbentry);
normalRangeSize = (int)(numRecords * RING_NORMAL_MULTI) + 1;
overRangeSize = numRecords + numRecords / RING_OVER_DIVI + 1;
ringSize = normalRangeSize + overRangeSize;
pRingBottom = (msgBuffer_t *)calloc (ringSize, sizeof(msgBuffer_t));
if (!pRingBottom) {
errlogPrintf ("logAlarmsInit: Ring buffer could not be created\n");
cleanup (5);
return ERROR;
}
pRingTop = pRingBottom + ringSize;
DEBUG2(2,"pRingBottom:%lu pRingTop:%lu\n",
(unsigned long)pRingBottom, (unsigned long)pRingTop)
ringHighWater = normalRangeSize;
DEBUG2(2,"Ring buffer size:%d highwater:%d\n",ringSize,ringHighWater)
pRingRead = pRingBottom;
pRingWrite = pRingBottom;
msgLost = 0;
pbuck = bucketCreate (numRecords);
if (!pbuck) {
errlogPrintf ("logAlarmsInit: Hash table could not be initalized\n");
cleanup (6);
return ERROR;
}
serverSelected = -1;
serverSelectedLast = -1;
queueAllRecords();
/* spawn alarm beacon task */
btid = taskSpawn ("Al'Beacon", BEACON_TASK_PRIO, BEACON_TASK_OPTIONS,
BEACON_TASK_STACK, (FUNCPTR)alarmBeaconTask,0,0,0,0,0,0,0,0,0,0);
if (!btid) {
errlogPrintf ("logAlarmsInit: Beacon task could not be spawned\n");
cleanup (7);
return ERROR;
}
DEBUG1(1,"alarmBeaconTask started. Task-ID = 0x%x\n", btid);
msg_soc = socket (AF_INET, SOCK_DGRAM, 0);
if (msg_soc < 0) {
errlogPrintf ("Message socket create failed\n");
cleanup (7);
return ERROR;
}
bzero ((char *) &msgReplyInAddr, sockAddrSize);
msgReplyInAddr.sin_port = htons(msg_port);
msgReplyInAddr.sin_family = AF_INET;
msgReplyInAddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind (msg_soc, (struct sockaddr*)&msgReplyInAddr, sockAddrSize) < 0 ) {
errlogPrintf ("Message socket bind failed\n");
cleanup (8);
return ERROR;
}
cmd_soc = socket (AF_INET, SOCK_DGRAM, 0);
if (cmd_soc < 0) {
errlogPrintf ("Command socket create failed\n");
cleanup (8);
return ERROR;
}
bzero ((char *) &cmdServerAddr, sockAddrSize);
cmdServerAddr.sin_port = htons(cmd_port);
cmdServerAddr.sin_family = AF_INET;
cmdServerAddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind (cmd_soc, (struct sockaddr*)&cmdServerAddr, sockAddrSize) < 0 ) {
errlogPrintf ("Command socket bind failed\n");
cleanup (9);
return ERROR;
}
/* spawn alarm message tasks */
for (i=0; i<MSG_TASK_NUM; i++) {
sprintf (string, "Al'Msg%d", i+1);
tid[i] = taskSpawn (string, CLIENT_TASK_PRIO, CLIENT_TASK_OPTIONS,
CLIENT_TASK_STACK, (FUNCPTR)alarmMessageTask,i+1,0,0,0,0,0,0,0,0,0);
if (!tid[i]) {
errlogPrintf (
"logAlarmsInit: Message task %d could not be spawned\n");
cleanup (9);
while (i > 0) taskDelete (tid[--i]);
taskDelete (btid);
return ERROR;
}
}
/* spawn alarm log control (command receiver) server task */
ctid = taskSpawn ("Al'Command", CONTROL_TASK_PRIO, CONTROL_TASK_OPTIONS,
CONTROL_TASK_STACK, (FUNCPTR)alarmCommandTask,0,0,0,0,0,0,0,0,0,0);
if (!ctid) {
errlogPrintf ("logAlarmsInit: Control task could not be spawned\n");
cleanup (9);
taskDelete (btid);
for (i=0; i<MSG_TASK_NUM; i++) taskDelete (tid[i]);
return ERROR;
}
/* spawn message reply receiver task */
rtid = taskSpawn ("Al'ReplyRx", REPLY_TASK_PRIO, REPLY_TASK_OPTIONS,
REPLY_TASK_STACK, (FUNCPTR)replyReceiveTask,0,0,0,0,0,0,0,0,0,0);
if (!rtid) {
errlogPrintf ("logAlarmsInit: Reply receiver task could not be spawned\n");
cleanup (9);
taskDelete (btid);
taskDelete (ctid);
for (i=0; i<MSG_TASK_NUM; i++) taskDelete (tid[i]);
return ERROR;
}
pheader = messageHeader;
pstring = getenv ("EPICS_IOC_NAME");
if (pstring) /* given IOC name */
pheader = messageHeader +
sprintf (messageHeader, "HOST=%s;", pstring);
pheader +=
sprintf (pheader, "HOST-PHYS=%s;APPLICATION=logAlarms;",
gethostname (string, sizeof(string)) ? "TOO_LONG" : string);
pstring = getenv ("EPICS_FACILITY");
if (pstring) /* name of application facility */
pheader +=
sprintf (pheader, "FACILITY=%s;", pstring);
/* calculate the remaining space in the message string */
textMsgSize = MAX_MESSAGE_LENGTH - (pheader-messageHeader);
epicsPrintf("logAlarms started\n");
recGblAlarmHook = (RECGBL_ALARM_HOOK_ROUTINE)logEvent;
DEBUG1(3,"recGblAlarmHook = 0x%lx\n",(unsigned long)recGblAlarmHook)
initialized = TRUE;
return OK;
}
