static void dataFeedAccept (int fd, void *userData) { RADSOCK_ID newConnection; WVIEW_ALARM_CLIENT *client; newConnection = radSocketServerAcceptConnection(alarmsWork.dataFeedServer); if (newConnection == NULL) { statusUpdateMessage("dataFeed: accept connection failed!"); radMsgLog (PRI_MEDIUM, "dataFeed: accept connection failed!"); return; } // stick him on the data feed client list client = (WVIEW_ALARM_CLIENT *) malloc(sizeof(*client)); if (client == NULL) { radMsgLog (PRI_MEDIUM, "dataFeedAccept: malloc failed!"); radSocketDestroy(newConnection); return; } memset(client, 0, sizeof (*client)); client->client = newConnection; radSocketSetBlocking(client->client, TRUE); // add it to our descriptors of interest: if (radProcessIORegisterDescriptor(radSocketGetDescriptor(client->client), ClientDataRX, (void*)client->client) == ERROR) { statusUpdateMessage("dataFeedAccept: register descriptor failed!"); radMsgLog (PRI_MEDIUM, "dataFeedAccept: register descriptor failed!"); radSocketDestroy(client->client); return; } radListAddToEnd(&alarmsWork.clientList, (NODE_PTR)client); statusIncrementStat(ALARM_STATS_CLIENTS); radMsgLog (PRI_STATUS, "dataFeed: client %s:%d accepted...", radSocketGetHost (client->client), radSocketGetPort (client->client)); return; }
static void ClientDataRX (int fd, void *userData) { RADSOCK_ID client = (RADSOCK_ID)userData; int retVal; ULONG dateTime; retVal = datafeedSyncStartOfFrame(client); switch (retVal) { case ERROR: /* problems! - bail out */ statusUpdateMessage("ClientDataRX: socket error during sync - disconnecting"); radMsgLog (PRI_HIGH, "ClientDataRX: socket error during sync - disconnecting"); RemoveClient(client); break; case ERROR_ABORT: // This guy has bailed out: statusUpdateMessage("ClientDataRX: socket far-end closed"); radMsgLog (PRI_MEDIUM, "ClientDataRX: socket far-end closed"); RemoveClient(client); break; case FALSE: radMsgLog (PRI_STATUS, "ClientDataRX: RX sync failure - ignoring"); break; case DF_RQST_ARCHIVE_PKT_TYPE: // OK, read the unix time sent to retrieve the record: if (radSocketReadExact(client, (void *)&dateTime, sizeof(dateTime)) != sizeof (dateTime)) { statusUpdateMessage("ClientDataRX: socket read error - disconnecting"); radMsgLog (PRI_HIGH, "ClientDataRX: socket read error - disconnecting"); RemoveClient(client); break; } // Convert from network byte order: dateTime = ntohl(dateTime); // Now we have the date and time, get busy: SendNextArchiveRecord(client, dateTime); break; } return; }
static void timerHandler (void *parm) { time_t ntime; struct tm locTime; radProcessTimerStart (cwopWork.timer, CWOP_MINUTE_INTERVAL); ntime = time (NULL); localtime_r (&ntime, &locTime); if ((locTime.tm_min % cwopWork.reportInterval) == cwopWork.callSignOffset) { // Time to send a packet if we have any new data: if (cwopWork.rxArchive) { processCWOP (); cwopWork.rxArchive = FALSE; } else { if (cwopWork.rxFirstArchive) { statusUpdateMessage("no new archive data received since last CWOP submission"); radMsgLog (PRI_MEDIUM, "wvcwopd: no new archive data received since last CWOP submission:"); } } } return; }
int htmlIdleState (int state, void *stimulus, void *data) { STIM *stim = (STIM *)stimulus; HTML_WORK *work = (HTML_WORK *)data; uint16_t year, month, day, hour, minute, second; WVIEW_MSG_REQUEST msg; switch (stim->type) { case STIM_DUMMY: // this one starts this state machine - send the archive request msg.requestType = WVIEW_RQST_TYPE_STATION_INFO; if (radMsgRouterMessageSend (WVIEW_MSG_TYPE_REQUEST, &msg, sizeof(msg)) == ERROR) { radMsgLog (PRI_HIGH, "htmlIdleState: radMsgRouterMessageSend failed!"); statusUpdateMessage("radMsgRouterMessageSend failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } // initialize the DST state change detector here wvutilsDetectDSTInit (); statusUpdate(STATUS_WAITING_FOR_WVIEW); return HTML_STATE_STATION_INFO; } return state; }
static void defaultSigHandler (int signum) { int retVal; switch (signum) { case SIGHUP: // user wants us to change the verbosity setting retVal = wvutilsToggleVerbosity (); radMsgLog (PRI_STATUS, "wvcwopd: SIGHUP - toggling log verbosity %s", ((retVal == 0) ? "OFF" : "ON")); radProcessSignalCatch(signum, defaultSigHandler); return; case SIGPIPE: // we have a far end socket disconnection, we'll handle it in the // "read/write" code radProcessSignalCatch(signum, defaultSigHandler); break; case SIGILL: case SIGBUS: case SIGFPE: case SIGSEGV: case SIGXFSZ: case SIGSYS: // unrecoverable radProcessSignalCatch- we must exit right now! radMsgLog (PRI_CATASTROPHIC, "wvcwopd: recv unrecoverable signal %d: aborting!", signum); abort (); case SIGCHLD: wvutilsWaitForChildren(); radProcessSignalCatch(signum, defaultSigHandler); return; default: if (cwopWork.exiting) { radProcessSignalCatch(signum, defaultSigHandler); return; } // Exit here in case the socket transaction is hung statusUpdateMessage("exiting normally"); statusUpdate(STATUS_SHUTDOWN); radMsgLog (PRI_HIGH, "wvcwopd: recv sig %d: exiting now!", signum); radMsgRouterExit (); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (0); } return; }
int htmlRunState (int state, void *stimulus, void *data) { STIM *stim = (STIM *)stimulus; HTML_WORK *work = (HTML_WORK *)data; WVIEW_MSG_LOOP_DATA *loop = (WVIEW_MSG_LOOP_DATA *)stim->msg; WVIEW_MSG_HILOW_DATA *hilow = (WVIEW_MSG_HILOW_DATA *)stim->msg; WVIEW_MSG_ARCHIVE_NOTIFY *arcNot = (WVIEW_MSG_ARCHIVE_NOTIFY *)stim->msg; switch (stim->type) { case STIM_QMSG: if (stim->msgType == WVIEW_MSG_TYPE_LOOP_DATA) { work->mgrId->loopStore = loop->loopData; return state; } else if (stim->msgType == WVIEW_MSG_TYPE_HILOW_DATA) { work->mgrId->hilowStore = hilow->hilowData; return state; } else if (stim->msgType == WVIEW_MSG_TYPE_ARCHIVE_NOTIFY) { processNewArchiveRecord (work, arcNot); return state; } break; case STIM_TIMER: if (stim->timerNumber == TIMER_GENERATE) { // ... request the next batch of data if (requestDataPackets (work) == ERROR) { radMsgLog (PRI_HIGH, "htmlRunState: requestDataPackets failed!"); statusUpdateMessage("requestDataPackets failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } radProcessTimerStart(work->rxTimer, HTML_RX_PACKETS_TIMEOUT); work->numDataReceived = 0; return HTML_STATE_DATA; } return state; } return state; }
static void SendNextArchiveRecord(RADSOCK_ID client, ULONG dateTime) { ARCHIVE_PKT recordStore; ARCHIVE_PKT networkStore; WVIEW_ALARM_CLIENT* alarmClient; alarmClient = FindClient(client); if (alarmClient == NULL) { radMsgLog (PRI_HIGH, "SendNextArchiveRecord: failed to get client!"); return; } if (dbsqliteArchiveInit() == ERROR) { radMsgLog (PRI_HIGH, "SendNextArchiveRecord: failed to open archive db!"); return; } if (dbsqliteArchiveGetNextRecord((time_t)dateTime, &recordStore) == ERROR) { WriteArchiveToClient(client, NULL); alarmClient->syncInProgress = FALSE; return; } dbsqliteArchiveExit(); // Mark the sync in progress: alarmClient->syncInProgress = TRUE; // OK, send the bloody thing: datafeedConvertArchive_HTON(&networkStore, &recordStore); if (WriteArchiveToClient(client, &networkStore) == ERROR) { statusUpdateMessage("SendNextArchiveRecord: failed to write archive record!"); radMsgLog (PRI_HIGH, "SendNextArchiveRecord: failed to write archive record!"); return; } return; }
static void processCWOP () { RADSOCK_ID socket; time_t ntime; struct tm *gmTime; char cwopBuffer[256], login[64]; int length = 0; char *serv; int port; volatile WVIEW_MSG_ARCHIVE_NOTIFY Notify; memcpy ((void*)&Notify, (void*)&cwopWork.ArchiveMsg, sizeof(WVIEW_MSG_ARCHIVE_NOTIFY)); // format the CWOP data ntime = time (NULL); gmTime = gmtime (&ntime); length = sprintf (cwopBuffer, "%s>APRS,TCPXX*,qAX,%s:@", cwopWork.callSign, cwopWork.callSign); length += sprintf (&cwopBuffer[length], "%2.2d%2.2d%2.2dz", gmTime->tm_mday, gmTime->tm_hour, gmTime->tm_min); length += sprintf (&cwopBuffer[length], "%s/%s", cwopWork.latitude, cwopWork.longitude); // check for any wind registered if (Notify.wspeed < 0) { length += sprintf (&cwopBuffer[length], "_..."); } else { length += sprintf (&cwopBuffer[length], "_%3.3d", Notify.winddir); } length += sprintf (&cwopBuffer[length], "/%3.3d", Notify.wspeed); length += sprintf (&cwopBuffer[length], "g%3.3d", Notify.hiwspeed); if (Notify.temp < 0) { if (((Notify.temp * (-1)) % 10) >= 5) { Notify.temp -= 10; } length += sprintf (&cwopBuffer[length], "t-%2.2d", (Notify.temp * (-1))/10); } else { if ((Notify.temp % 10) >= 5) { Notify.temp += 10; } length += sprintf (&cwopBuffer[length], "t%3.3d", Notify.temp/10); } length += sprintf (&cwopBuffer[length], "P%3.3d", Notify.rainDay); if (Notify.humidity >= 0 && Notify.humidity <= 100) { length += sprintf (&cwopBuffer[length], "h%2.2d", Notify.humidity % 100); } length += sprintf (&cwopBuffer[length], "b%5.5d", (int)(10 * wvutilsConvertINHGToHPA((float)Notify.altimeter/1000.0))); sprintf (&cwopBuffer[length], ".%s", wvutilsCreateCWOPVersion(globalWviewVersionStr)); // connect to the CWOP server - try the primary then secondary then tertiary socket = radSocketClientCreate (cwopWork.server1, cwopWork.portNo1); if (socket == NULL) { statusUpdateMessage("CWOP-connect: failed to connect to server"); statusIncrementStat(CWOP_STATS_CONNECT_ERRORS); wvutilsLogEvent (PRI_MEDIUM, "CWOP-connect: failed to connect to %s:%d", cwopWork.server1, cwopWork.portNo1); // try the secondary server socket = radSocketClientCreate (cwopWork.server2, cwopWork.portNo2); if (socket == NULL) { statusUpdateMessage("CWOP-connect: failed to connect to server"); statusIncrementStat(CWOP_STATS_CONNECT_ERRORS); wvutilsLogEvent (PRI_MEDIUM, "CWOP-connect: failed to connect to %s:%d", cwopWork.server2, cwopWork.portNo2); // try the tertiary server socket = radSocketClientCreate (cwopWork.server3, cwopWork.portNo3); if (socket == NULL) { // we are all out of luck this time! statusUpdateMessage("CWOP-connect: failed to connect to server"); statusIncrementStat(CWOP_STATS_CONNECT_ERRORS); wvutilsLogEvent (PRI_MEDIUM, "CWOP-connect: failed to connect to %s:%d", cwopWork.server3, cwopWork.portNo3); radMsgLog (PRI_HIGH, "CWOP-connect: failed to connect to all 3 APRS servers!"); return; } else { serv = cwopWork.server3; port = cwopWork.portNo3; } } else { serv = cwopWork.server2; port = cwopWork.portNo2; } } else { serv = cwopWork.server1; port = cwopWork.portNo1; } // wait 1 second ... radUtilsSleep (1000); // transmit the data sprintf (login, "user %6s pass %d vers %s", cwopWork.callSign, (int)getPasscode(cwopWork.callSign), globalWviewVersionStr); length = strlen (login); login[length] = 0x0D; // tack on the CR and LF login[length+1] = 0x0A; login[length+2] = 0; if (radSocketWriteExact (socket, login, length + 2) != (length + 2)) { statusUpdateMessage("CWOP-error: failed to login to server"); radMsgLog (PRI_HIGH, "CWOP-error: %d: failed to login to %s:%d!", errno, serv, port); radSocketDestroy (socket); return; } // wait 3 seconds ... radUtilsSleep (3000); // write the data record wvutilsLogEvent (PRI_STATUS, "CWOP-send: %s", cwopBuffer); length = strlen (cwopBuffer); cwopBuffer[length] = 0x0D; // tack on the CR and LF cwopBuffer[length+1] = 0x0A; cwopBuffer[length+2] = 0; if (radSocketWriteExact (socket, cwopBuffer, length + 2) != (length + 2)) { statusUpdateMessage("CWOP-error: failed to write to server"); radMsgLog (PRI_HIGH, "CWOP-error: %d: failed to write to %s:%d!", errno, serv, port); radSocketDestroy (socket); return; } statusIncrementStat(CWOP_STATS_PKTS_SENT); // wait 3 more seconds ... radUtilsSleep (3000); // close connection and cleanup radSocketDestroy (socket); return; }
/* ... the main entry point for the wvcwopd process */ int main (int argc, char *argv[]) { void (*alarmHandler)(int); int retVal; FILE *pidfile; int iValue; double dValue; const char* sValue; int runAsDaemon = TRUE; if (argc > 1) { if (!strcmp(argv[1], "-f")) { runAsDaemon = FALSE; } } memset (&cwopWork, 0, sizeof (cwopWork)); /* ... initialize some system stuff first */ retVal = cwopSysInit (&cwopWork); if (retVal == ERROR) { radMsgLogInit (PROC_NAME_CWOP, FALSE, TRUE); radMsgLog (PRI_CATASTROPHIC, "wvcwopd init failed!"); radMsgLogExit (); exit (1); } else if (retVal == ERROR_ABORT) { exit (2); } /* ... call the global radlib system init function */ if (radSystemInit (WVIEW_SYSTEM_ID) == ERROR) { radMsgLogInit (PROC_NAME_CWOP, TRUE, TRUE); radMsgLog (PRI_CATASTROPHIC, "radSystemInit failed!"); radMsgLogExit (); exit (1); } /* ... call the radlib process init function */ if (radProcessInit (PROC_NAME_CWOP, cwopWork.fifoFile, PROC_NUM_TIMERS_CWOP, runAsDaemon, // TRUE for daemon msgHandler, evtHandler, NULL) == ERROR) { printf ("\nradProcessInit failed: %s\n\n", PROC_NAME_CWOP); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } cwopWork.myPid = getpid (); pidfile = fopen (cwopWork.pidFile, "w"); if (pidfile == NULL) { radMsgLog (PRI_CATASTROPHIC, "lock file create failed!"); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } fprintf (pidfile, "%d", getpid ()); fclose (pidfile); alarmHandler = radProcessSignalGetHandler (SIGALRM); radProcessSignalCatchAll (defaultSigHandler); radProcessSignalCatch (SIGALRM, alarmHandler); radProcessSignalRelease(SIGABRT); // get our configuration values if (wvconfigInit(FALSE) == ERROR) { radMsgLog (PRI_CATASTROPHIC, "wvconfigInit failed!"); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // Is the CWOP daemon enabled? iValue = wvconfigGetBooleanValue(configItem_ENABLE_CWOP); if (iValue == ERROR || iValue == 0) { wvconfigExit (); radMsgLog (PRI_CATASTROPHIC, "CWOP daemon is NOT enabled - exiting..."); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // get the wview verbosity setting if (wvutilsSetVerbosity (WV_VERBOSE_WVCWOPD) == ERROR) { wvconfigExit (); radMsgLog (PRI_CATASTROPHIC, "wvutilsSetVerbosity failed!"); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // get the APRS call sign sValue = wvconfigGetStringValue(configItemCWOP_APRS_CALL_SIGN); if (sValue == NULL) { // we can't do without this! wvconfigExit (); radMsgLog (PRI_CATASTROPHIC, "%s failed!", configItemCWOP_APRS_CALL_SIGN); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { wvstrncpy (cwopWork.callSign, sValue, sizeof(cwopWork.callSign)); if (sValue[strlen(sValue)-1] >= '0' && sValue[strlen(sValue)-1] <= '9') { cwopWork.callSignOffset = atoi(&sValue[strlen(sValue)-1]); } else { cwopWork.callSignOffset = (sValue[strlen(sValue)-1] % 10); } cwopWork.callSignOffset %= 10; } // get the primary APRS server sValue = wvconfigGetStringValue(configItemCWOP_APRS_SERVER1); if (sValue == NULL) { // we can't do without this! wvconfigExit (); radMsgLog (PRI_CATASTROPHIC, "%s failed!", configItemCWOP_APRS_SERVER1); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { wvstrncpy (cwopWork.server1, sValue, sizeof(cwopWork.server1)); } // get the primary APRS port number iValue = wvconfigGetINTValue(configItemCWOP_APRS_PORTNO1); if (iValue < 0) { // we can't do without this! wvconfigExit (); radMsgLog (PRI_CATASTROPHIC, "%s failed!", configItemCWOP_APRS_PORTNO1); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { cwopWork.portNo1 = iValue; } // get the secondary APRS server sValue = wvconfigGetStringValue(configItemCWOP_APRS_SERVER2); if (sValue == NULL) { // we can't do without this! wvconfigExit (); radMsgLog (PRI_CATASTROPHIC, "%s failed!", configItemCWOP_APRS_SERVER2); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { wvstrncpy (cwopWork.server2, sValue, sizeof(cwopWork.server2)); } // get the primary APRS port number iValue = wvconfigGetINTValue(configItemCWOP_APRS_PORTNO2); if (iValue < 0) { // we can't do without this! wvconfigExit (); radMsgLog (PRI_CATASTROPHIC, "%s failed!", configItemCWOP_APRS_PORTNO2); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { cwopWork.portNo2 = iValue; } // get the tertiary APRS server sValue = wvconfigGetStringValue(configItemCWOP_APRS_SERVER3); if (sValue == NULL) { // we can't do without this! wvconfigExit (); radMsgLog (PRI_CATASTROPHIC, "%s failed!", configItemCWOP_APRS_SERVER3); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { wvstrncpy (cwopWork.server3, sValue, sizeof(cwopWork.server3)); } // get the primary APRS port number iValue = wvconfigGetINTValue(configItemCWOP_APRS_PORTNO3); if (iValue < 0) { // we can't do without this! wvconfigExit (); radMsgLog (PRI_CATASTROPHIC, "%s failed!", configItemCWOP_APRS_PORTNO3); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { cwopWork.portNo3 = iValue; } // get the fine pitch latitude that APRS requires sValue = wvconfigGetStringValue(configItemCWOP_LATITUDE); if (sValue == NULL) { // we can't do without this! wvconfigExit (); radMsgLog (PRI_CATASTROPHIC, "%s failed!", configItemCWOP_LATITUDE); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { wvstrncpy (cwopWork.latitude, sValue, sizeof(cwopWork.latitude)); } // get the fine pitch longitude that APRS requires sValue = wvconfigGetStringValue(configItemCWOP_LONGITUDE); if (sValue == NULL) { // we can't do without this! wvconfigExit (); radMsgLog (PRI_CATASTROPHIC, "%s failed!", configItemCWOP_LONGITUDE); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { wvstrncpy (cwopWork.longitude, sValue, sizeof(cwopWork.longitude)); } // get the WX packet logging preference iValue = wvconfigGetBooleanValue(configItemCWOP_LOG_WX_PACKET); if (iValue <= 0) { // just disable it cwopWork.logWXPackets = 0; } else { cwopWork.logWXPackets = iValue; } wvconfigExit (); if (statusInit(cwopWork.statusFile, cwopStatusLabels) == ERROR) { radMsgLog (PRI_HIGH, "statusInit failed - exiting..."); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } statusUpdate(STATUS_BOOTING); // wait a bit here before continuing radUtilsSleep (500); cwopWork.timer = radTimerCreate (NULL, timerHandler, NULL); if (cwopWork.timer == NULL) { statusUpdateMessage("radTimerCreate failed"); radMsgLog (PRI_HIGH, "radTimerCreate failed"); statusUpdate(STATUS_ERROR); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } radProcessTimerStart (cwopWork.timer, CWOP_MINUTE_INTERVAL); // register with the radlib message router if (radMsgRouterInit (WVIEW_RUN_DIR) == ERROR) { statusUpdateMessage("radMsgRouterInit failed"); radMsgLog (PRI_HIGH, "radMsgRouterInit failed!"); statusUpdate(STATUS_ERROR); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // enable message reception from the radlib router for SHUTDOWN msgs radMsgRouterMessageRegister (WVIEW_MSG_TYPE_SHUTDOWN); // wait for the wview daemon to be ready if (waitForWviewDaemon () == ERROR) { radMsgLog (PRI_HIGH, "waitForWviewDaemon failed"); statusUpdate(STATUS_ERROR); radMsgRouterExit (); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // enable message reception from the radlib router for archive notifications radMsgRouterMessageRegister (WVIEW_MSG_TYPE_ARCHIVE_NOTIFY); // enable message reception from the radlib router for POLL msgs radMsgRouterMessageRegister (WVIEW_MSG_TYPE_POLL); radMsgLog (PRI_STATUS, "CWOP: configured to submit station %s data to:", cwopWork.callSign); radMsgLog (PRI_STATUS, "CWOP: Primary: %s:%d", cwopWork.server1, cwopWork.portNo1); radMsgLog (PRI_STATUS, "CWOP: Secondary: %s:%d", cwopWork.server2, cwopWork.portNo2); radMsgLog (PRI_STATUS, "CWOP: Tertiary: %s:%d", cwopWork.server3, cwopWork.portNo3); radMsgLog (PRI_STATUS, "CWOP: Submitting every %d minutes at offset minute: %d", cwopWork.reportInterval, cwopWork.callSignOffset); // enter normal processing cwopWork.inMainLoop = TRUE; statusUpdate(STATUS_RUNNING); statusUpdateMessage("Normal operation"); radMsgLog (PRI_STATUS, "running..."); while (!cwopWork.exiting) { // wait on something interesting if (radProcessWait (0) == ERROR) { cwopWork.exiting = TRUE; } } statusUpdateMessage("exiting normally"); radMsgLog (PRI_STATUS, "exiting normally..."); statusUpdate(STATUS_SHUTDOWN); radMsgRouterExit (); radTimerDelete (cwopWork.timer); cwopSysExit (&cwopWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (0); }
static int waitForWviewDaemon (void) { WVIEW_MSG_REQUEST msg; char srcQName[QUEUE_NAME_LENGTH+1]; UINT msgType; UINT length; void *recvBfr; int retVal, done = FALSE; // enable message reception from the radlib router for the archive path radMsgRouterMessageRegister (WVIEW_MSG_TYPE_STATION_INFO); msg.requestType = WVIEW_RQST_TYPE_STATION_INFO; if (radMsgRouterMessageSend (WVIEW_MSG_TYPE_REQUEST, &msg, sizeof(msg)) == ERROR) { statusUpdateMessage("waitForWviewDaemon: radMsgRouterMessageSend failed!"); radMsgLog (PRI_HIGH, "waitForWviewDaemon: radMsgRouterMessageSend failed!"); radMsgRouterMessageDeregister (WVIEW_MSG_TYPE_STATION_INFO); return ERROR; } statusUpdate(STATUS_WAITING_FOR_WVIEW); // now wait for the response here while (!done) { radUtilsSleep (50); if ((retVal = radQueueRecv (radProcessQueueGetID (), srcQName, &msgType, &recvBfr, &length)) == FALSE) { continue; } else if (retVal == ERROR) { statusUpdateMessage("waitForWviewDaemon: queue is closed!"); radMsgLog (PRI_STATUS, "waitForWviewDaemon: queue is closed!"); radMsgRouterMessageDeregister (WVIEW_MSG_TYPE_STATION_INFO); return ERROR; } // is this what we want? if (msgType == WVIEW_MSG_TYPE_STATION_INFO) { // yes! done = TRUE; cwopWork.reportInterval = ((WVIEW_MSG_STATION_INFO*)recvBfr)->archiveInterval; if (cwopWork.reportInterval < 10) { cwopWork.reportInterval = 10; } } else if (msgType == WVIEW_MSG_TYPE_SHUTDOWN) { statusUpdateMessage("waitForWviewDaemon: received shutdown from wviewd"); radMsgLog (PRI_HIGH, "waitForWviewDaemon: received shutdown from wviewd"); radMsgRouterMessageDeregister (WVIEW_MSG_TYPE_STATION_INFO); return ERROR; } // release the received buffer radBufferRls (recvBfr); } // disable message reception from the radlib router for the archive path radMsgRouterMessageDeregister (WVIEW_MSG_TYPE_STATION_INFO); return OK; }
/* ... the main entry point for the daemon process */ int main (int argc, char *argv[]) { void (*alarmHandler)(int); FILE *pidfile; int iValue; double dValue; const char* sValue; int runAsDaemon = TRUE; if (argc > 1) { if (!strcmp(argv[1], "-f")) { runAsDaemon = FALSE; } } /* ... start with a clean slate */ memset (&wviewdWork, 0, sizeof (wviewdWork)); /* ... initialize some system stuff first */ if (daemonSysInit (&wviewdWork) == -1) { radMsgLogInit (PROC_NAME_DAEMON, TRUE, TRUE); radMsgLog (PRI_CATASTROPHIC, "system init failed!\n"); radMsgLogExit (); exit (1); } /* ... call the global radlib system init function */ if (radSystemInit (WVIEW_SYSTEM_ID) == ERROR) { radMsgLogInit (PROC_NAME_DAEMON, TRUE, TRUE); radMsgLog (PRI_CATASTROPHIC, "radSystemInit failed!"); radMsgLogExit (); exit (1); } /* ... call the radlib process init function */ if (radProcessInit (PROC_NAME_DAEMON, wviewdWork.fifoFile, PROC_NUM_TIMERS_DAEMON, runAsDaemon, // TRUE for daemon msgHandler, evtHandler, NULL) == ERROR) { printf ("\nradProcessInit failed: %s\n\n", PROC_NAME_DAEMON); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } wviewdWork.myPid = getpid (); pidfile = fopen (wviewdWork.pidFile, "w"); if (pidfile == NULL) { radMsgLog (PRI_CATASTROPHIC, "lock file create failed!\n"); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } fprintf (pidfile, "%d", getpid ()); fclose (pidfile); alarmHandler = radProcessSignalGetHandler (SIGALRM); radProcessSignalCatchAll (defaultSigHandler); radProcessSignalCatch (SIGALRM, alarmHandler); radProcessSignalRelease(SIGABRT); radMsgLog (PRI_STATUS, "%s starting ...", globalWviewVersionStr); radTimeGetMSSinceEpoch(); wvutilsDetectDSTInit(); // get our configuration values: if (wvconfigInit(TRUE) == ERROR) { radMsgLog (PRI_CATASTROPHIC, "config database is missing!!!\n"); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // get the wview verbosity setting if (wvutilsSetVerbosity (WV_VERBOSE_WVIEWD) == ERROR) { wvconfigExit(); radMsgLog (PRI_CATASTROPHIC, "wvutilsSetVerbosity failed!"); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } ///// STATION_INTERFACE PROCESSING BEGIN ///// sValue = wvconfigGetStringValue(configItem_STATION_STATION_TYPE); if (sValue == NULL) { radMsgLog (PRI_MEDIUM, "no station type given, defaulting to 'VantagePro'..."); strcpy (wviewdWork.stationType, "VantagePro"); } else { wvstrncpy(wviewdWork.stationType, sValue, sizeof(wviewdWork.stationType)); } if ((!strcmp(wviewdWork.stationType, "WMRUSB")) || (!strcmp(wviewdWork.stationType, "WH1080"))) { // USB stations: radMsgLog (PRI_MEDIUM, "station interface: native USB ..."); } else { sValue = wvconfigGetStringValue(configItem_STATION_STATION_INTERFACE); if (sValue == NULL) { radMsgLog (PRI_MEDIUM, "no station interface given, defaulting to 'serial'..."); strcpy (wviewdWork.stationInterface, "serial"); } else { wvstrncpy(wviewdWork.stationInterface, sValue, sizeof(wviewdWork.stationInterface)); } // process the interface type if (!strcmp (wviewdWork.stationInterface, "serial")) { radMsgLog (PRI_MEDIUM, "station interface: serial ..."); // we need a device name for serial IFs sValue = wvconfigGetStringValue(configItem_STATION_STATION_DEV); if (sValue == NULL) { wvconfigExit(); radMsgLog (PRI_CATASTROPHIC, "no serial device given, aborting..."); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { wvstrncpy(wviewdWork.stationDevice, sValue, sizeof(wviewdWork.stationDevice)); } // grab the DTR toggle flag: iValue = wvconfigGetBooleanValue(configItem_STATION_STATION_DTR); if (iValue >= 0) { wviewdWork.stationToggleDTR = iValue; } else { wviewdWork.stationToggleDTR = TRUE; } } else if (!strcmp (wviewdWork.stationInterface, "ethernet")) { radMsgLog (PRI_MEDIUM, "station interface: ethernet ..."); // we need host and port for ethernet sValue = wvconfigGetStringValue(configItem_STATION_STATION_HOST); if (sValue == NULL) { wvconfigExit(); radMsgLog (PRI_CATASTROPHIC, "no hostname given, aborting..."); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { wvstrncpy(wviewdWork.stationHost, sValue, sizeof(wviewdWork.stationHost)); iValue = wvconfigGetINTValue(configItem_STATION_STATION_PORT); if (iValue <= 0) { wvconfigExit(); radMsgLog (PRI_CATASTROPHIC, "no port given, aborting..."); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { wviewdWork.stationPort = iValue; // grab the Weatherlink IP flag: iValue = wvconfigGetBooleanValue(configItem_STATION_STATION_WLIP); if (iValue >= 0) { wviewdWork.stationIsWLIP = iValue; } else { wviewdWork.stationIsWLIP = FALSE; } } } } else { // invalid type specified - abort wvconfigExit(); radMsgLog (PRI_CATASTROPHIC, "invalid STATION_INTERFACE %s given, aborting...", wviewdWork.stationInterface); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } } ///// STATION_INTERFACE PROCESSING END ///// iValue = wvconfigGetINTValue(configItem_STATION_STATION_RAIN_SEASON_START); if (iValue <= 0) { radMsgLog (PRI_MEDIUM, "Rain Season Start Month not found - defaulting to 1 (JAN)...\n"); wviewdWork.stationRainSeasonStart = 1; } else { wviewdWork.stationRainSeasonStart = iValue; if (wviewdWork.stationRainSeasonStart < 1 || wviewdWork.stationRainSeasonStart > 12) { radMsgLog (PRI_MEDIUM, "Invalid Rain Season Start Month %d found - defaulting to 1 (JAN)...\n", wviewdWork.stationRainSeasonStart); wviewdWork.stationRainSeasonStart = 1; } else { radMsgLog (PRI_STATUS, "Rain Season Start Month set to %d\n", wviewdWork.stationRainSeasonStart); } } dValue = wvconfigGetDOUBLEValue(configItem_STATION_STATION_RAIN_STORM_TRIGGER_START); if (dValue <= 0.0) { radMsgLog (PRI_MEDIUM, "no rain storm start trigger given, defaulting to 0.05 in/hr..."); wviewdWork.stationRainStormTrigger = 0.05; } else { wviewdWork.stationRainStormTrigger = (float)dValue; radMsgLog (PRI_STATUS, "Rain Storm Start Trigger set to %5.2f in/hr\n", wviewdWork.stationRainStormTrigger); } iValue = wvconfigGetINTValue(configItem_STATION_STATION_RAIN_STORM_IDLE_STOP); if (iValue <= 0) { radMsgLog (PRI_MEDIUM, "no rain storm idle stop time given, defaulting to 12 hours..."); wviewdWork.stationRainStormIdleHours = 12; } else { wviewdWork.stationRainStormIdleHours = iValue; radMsgLog (PRI_STATUS, "Rain Storm Stop Time set to %d hours\n", wviewdWork.stationRainStormIdleHours); } dValue = wvconfigGetDOUBLEValue(configItem_STATION_STATION_RAIN_YTD); if (dValue < 0.0) { radMsgLog (PRI_MEDIUM, "no rain YTD preset given, defaulting to 0.00 inches..."); wviewdWork.stationRainStormIdleHours = 12; } else { wviewdWork.stationRainYTDPreset = (float)dValue; radMsgLog (PRI_STATUS, "Rain YTD preset set to %.2f inches\n", wviewdWork.stationRainYTDPreset); } dValue = wvconfigGetDOUBLEValue(configItem_STATION_STATION_ET_YTD); if (dValue < 0.0) { radMsgLog (PRI_MEDIUM, "no ET YTD preset given, defaulting to 0.000 inches..."); wviewdWork.stationETYTDPreset = 0; } else { wviewdWork.stationETYTDPreset = (float)dValue; radMsgLog (PRI_STATUS, "ET YTD preset set to %.3f inches\n", wviewdWork.stationETYTDPreset); } iValue = wvconfigGetINTValue(configItem_STATION_STATION_RAIN_ET_YTD_YEAR); if (iValue < 0) { radMsgLog (PRI_MEDIUM, "no rain/ET YTD Year given, disabling..."); wviewdWork.stationRainETPresetYear = 0; } else { wviewdWork.stationRainETPresetYear = iValue; if (wviewdWork.stationRainETPresetYear < 2000 || wviewdWork.stationRainETPresetYear > 3000) { radMsgLog (PRI_MEDIUM, "bad rain/ET YTD Year given, disabling..."); wviewdWork.stationRainETPresetYear = 0; } else { radMsgLog (PRI_STATUS, "rain/ET YTD preset Year set to %d\n", wviewdWork.stationRainETPresetYear); } } iValue = wvconfigGetINTValue(configItem_STATION_POLL_INTERVAL); if (iValue < 0) { radMsgLog (PRI_MEDIUM, "no POLL_INTERVAL retrieved, setting to 30 seconds..."); wviewdWork.cdataInterval = 30000; } else { wviewdWork.cdataInterval = iValue * 1000; } if (((wviewdWork.cdataInterval % 1000) != 0) || ((wviewdWork.cdataInterval/1000) > 60) || ((60 % (wviewdWork.cdataInterval/1000)) != 0)) { radMsgLog (PRI_MEDIUM, "station polling interval %d found in wview.conf is invalid:", wviewdWork.cdataInterval); radMsgLog (PRI_MEDIUM, "defaulting to 30 seconds ..."); radMsgLog (PRI_MEDIUM, "Note: station polling interval must be less than 60 seconds"); radMsgLog (PRI_MEDIUM, " and an even divisor of 60 seconds (10000, 15000, 30000)"); wviewdWork.cdataInterval = 30 * 1000; } else { radMsgLog (PRI_STATUS, "station polling interval set to %d seconds", (wviewdWork.cdataInterval/1000)); } iValue = wvconfigGetINTValue(configItem_STATION_PUSH_INTERVAL); if (iValue < 0) { radMsgLog (PRI_MEDIUM, "no PUSH_INTERVAL retrieved, setting to 60 seconds..."); wviewdWork.pushInterval = 60000; } else { wviewdWork.pushInterval = iValue * 1000; } // Calibration configuration: dValue = wvconfigGetDOUBLEValue(configItemCAL_MULT_BAROMETER); if (dValue <= 0.0) { wviewdWork.calMBarometer = 1.00; } else { wviewdWork.calMBarometer = dValue; } dValue = wvconfigGetDOUBLEValue(configItemCAL_CONST_BAROMETER); wviewdWork.calCBarometer = dValue; dValue = wvconfigGetDOUBLEValue(configItemCAL_MULT_PRESSURE); if (dValue <= 0.0) { wviewdWork.calMPressure = 1.00; } else { wviewdWork.calMPressure = dValue; } dValue = wvconfigGetDOUBLEValue(configItemCAL_CONST_PRESSURE); wviewdWork.calCPressure = dValue; dValue = wvconfigGetDOUBLEValue(configItemCAL_MULT_ALTIMETER); if (dValue <= 0.0) { wviewdWork.calMAltimeter = 1.00; } else { wviewdWork.calMAltimeter = dValue; } dValue = wvconfigGetDOUBLEValue(configItemCAL_CONST_ALTIMETER); wviewdWork.calCAltimeter = dValue; dValue = wvconfigGetDOUBLEValue(configItemCAL_MULT_INTEMP); if (dValue <= 0.0) { wviewdWork.calMInTemp = 1.00; } else { wviewdWork.calMInTemp = dValue; } dValue = wvconfigGetDOUBLEValue(configItemCAL_CONST_INTEMP); wviewdWork.calCInTemp = dValue; dValue = wvconfigGetDOUBLEValue(configItemCAL_MULT_OUTTEMP); if (dValue <= 0.0) { wviewdWork.calMOutTemp = 1.00; } else { wviewdWork.calMOutTemp = dValue; } dValue = wvconfigGetDOUBLEValue(configItemCAL_CONST_OUTTEMP); wviewdWork.calCOutTemp = dValue; dValue = wvconfigGetDOUBLEValue(configItemCAL_MULT_INHUMIDITY); if (dValue <= 0.0) { wviewdWork.calMInHumidity = 1.00; } else { wviewdWork.calMInHumidity = dValue; } dValue = wvconfigGetDOUBLEValue(configItemCAL_CONST_INHUMIDITY); wviewdWork.calCInHumidity = dValue; dValue = wvconfigGetDOUBLEValue(configItemCAL_MULT_OUTHUMIDITY); if (dValue <= 0.0) { wviewdWork.calMOutHumidity = 1.00; } else { wviewdWork.calMOutHumidity = dValue; } dValue = wvconfigGetDOUBLEValue(configItemCAL_CONST_OUTHUMIDITY); wviewdWork.calCOutHumidity = dValue; dValue = wvconfigGetDOUBLEValue(configItemCAL_MULT_WINDSPEED); if (dValue <= 0.0) { wviewdWork.calMWindSpeed = 1.00; } else { wviewdWork.calMWindSpeed = dValue; } dValue = wvconfigGetDOUBLEValue(configItemCAL_CONST_WINDSPEED); wviewdWork.calCWindSpeed = dValue; dValue = wvconfigGetDOUBLEValue(configItemCAL_MULT_WINDDIR); if (dValue <= 0.0) { wviewdWork.calMWindDir = 1.00; } else { wviewdWork.calMWindDir = dValue; } dValue = wvconfigGetDOUBLEValue(configItemCAL_CONST_WINDDIR); wviewdWork.calCWindDir = dValue; dValue = wvconfigGetDOUBLEValue(configItemCAL_MULT_RAIN); if (dValue <= 0.0) { wviewdWork.calMRain = 1.00; } else { wviewdWork.calMRain = dValue; } dValue = wvconfigGetDOUBLEValue(configItemCAL_CONST_RAIN); wviewdWork.calCRain = dValue; dValue = wvconfigGetDOUBLEValue(configItemCAL_MULT_RAINRATE); if (dValue <= 0.0) { wviewdWork.calMRainRate = 1.00; } else { wviewdWork.calMRainRate = dValue; } dValue = wvconfigGetDOUBLEValue(configItemCAL_CONST_RAINRATE); wviewdWork.calCRainRate = dValue; iValue = wvconfigGetBooleanValue(configItem_ENABLE_EMAIL); if (iValue >= 0) { wviewdWork.IsAlertEmailsEnabled = iValue; } if (wviewdWork.IsAlertEmailsEnabled) { sValue = wvconfigGetStringValue(configItem_TO_EMAIL_ADDRESS); if (sValue == NULL) { radMsgLog (PRI_HIGH, "NO alert email TO address given - disabling email alerts..."); wviewdWork.IsAlertEmailsEnabled = 0; } else { wvstrncpy (wviewdWork.alertEmailToAdrs, sValue, sizeof(wviewdWork.alertEmailToAdrs)); } sValue = wvconfigGetStringValue(configItem_FROM_EMAIL_ADDRESS); if (sValue == NULL) { radMsgLog (PRI_HIGH, "NO alert email FROM address given - disabling email alerts..."); wviewdWork.IsAlertEmailsEnabled = 0; } else { wvstrncpy (wviewdWork.alertEmailFromAdrs, sValue, sizeof(wviewdWork.alertEmailFromAdrs)); } iValue = wvconfigGetBooleanValue(configItem_SEND_TEST_EMAIL); if (iValue >= 0) { wviewdWork.IsTestEmailEnabled = iValue; } } iValue = wvconfigGetBooleanValue(configItem_HTMLGEN_STATION_SHOW_IF); if (iValue >= 0) { wviewdWork.showStationIF = iValue; } else { wviewdWork.showStationIF = TRUE; } wvconfigExit (); if (statusInit(wviewdWork.statusFile, wviewStatusLabels) == ERROR) { radMsgLog (PRI_HIGH, "statusInit failed - exiting..."); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } statusUpdate(STATUS_BOOTING); // ... Initialize the archive database interface: if (dbsqliteArchiveInit() == ERROR) { radMsgLog (PRI_HIGH, "dbsqliteArchiveInit failed"); statusUpdateMessage("dbsqliteArchiveInit failed"); statusUpdate(STATUS_ERROR); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // Initialize timers: wviewdWork.archiveTimer = radTimerCreate (NULL, archiveTimerHandler, NULL); if (wviewdWork.archiveTimer == NULL) { radMsgLog (PRI_HIGH, "radTimerCreate failed"); statusUpdateMessage("radTimerCreate failed"); statusUpdate(STATUS_ERROR); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } wviewdWork.cdataTimer = radTimerCreate (NULL, cdtimerHandler, NULL); if (wviewdWork.cdataTimer == NULL) { radMsgLog (PRI_HIGH, "radTimerCreate failed"); statusUpdateMessage("radTimerCreate failed"); statusUpdate(STATUS_ERROR); radTimerDelete (wviewdWork.archiveTimer); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } wviewdWork.pushTimer = radTimerCreate (NULL, pushTimerHandler, NULL); if (wviewdWork.pushTimer == NULL) { radMsgLog (PRI_HIGH, "radTimerCreate failed"); statusUpdateMessage("radTimerCreate failed"); statusUpdate(STATUS_ERROR); radTimerDelete (wviewdWork.cdataTimer); radTimerDelete (wviewdWork.archiveTimer); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } wviewdWork.syncTimer = radTimerCreate (NULL, syncTimerHandler, NULL); if (wviewdWork.syncTimer == NULL) { radMsgLog (PRI_HIGH, "sync radTimerCreate failed"); statusUpdateMessage("radTimerCreate failed"); statusUpdate(STATUS_ERROR); radTimerDelete (wviewdWork.cdataTimer); radTimerDelete (wviewdWork.pushTimer); radTimerDelete (wviewdWork.archiveTimer); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } wviewdWork.ifTimer = radTimerCreate (NULL, ifTimerHandler, NULL); if (wviewdWork.ifTimer == NULL) { radMsgLog (PRI_HIGH, "sync radTimerCreate failed"); statusUpdateMessage("radTimerCreate failed"); statusUpdate(STATUS_ERROR); radTimerDelete (wviewdWork.syncTimer); radTimerDelete (wviewdWork.cdataTimer); radTimerDelete (wviewdWork.pushTimer); radTimerDelete (wviewdWork.archiveTimer); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } radProcessEventsAdd (STATION_INIT_COMPLETE_EVENT); radProcessEventsAdd (STATION_LOOP_COMPLETE_EVENT); // register with the radlib message router if (radMsgRouterInit (WVIEW_RUN_DIR) == ERROR) { radMsgLog (PRI_HIGH, "radMsgRouterInit failed!"); statusUpdateMessage("radMsgRouterInit failed"); statusUpdate(STATUS_ERROR); radTimerDelete (wviewdWork.ifTimer); radTimerDelete (wviewdWork.syncTimer); radTimerDelete (wviewdWork.cdataTimer); radTimerDelete (wviewdWork.pushTimer); radTimerDelete (wviewdWork.archiveTimer); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // enable message reception from the radlib router for worker requests radMsgRouterMessageRegister (WVIEW_MSG_TYPE_REQUEST); // enable message reception from the radlib router for POLL msgs radMsgRouterMessageRegister (WVIEW_MSG_TYPE_POLL); // enable message reception from the radlib router for ALERT msgs radMsgRouterMessageRegister (WVIEW_MSG_TYPE_ALERT); // enable message reception from the radlib router for STATION_DATA msgs radMsgRouterMessageRegister (WVIEW_MSG_TYPE_STATION_DATA); // Initialize the HILOW database interface: // (this cannot occur before the MsgRouter is initialized) if (dbsqliteHiLowInit(TRUE) == ERROR) { radMsgLog (PRI_HIGH, "dbsqliteHiLowInit failed"); statusUpdateMessage("dbsqliteHiLowInit failed"); statusUpdate(STATUS_ERROR); stationSendShutdown(&wviewdWork); radMsgRouterExit (); radTimerDelete (wviewdWork.ifTimer); radTimerDelete (wviewdWork.syncTimer); radTimerDelete (wviewdWork.cdataTimer); radTimerDelete (wviewdWork.pushTimer); radTimerDelete (wviewdWork.archiveTimer); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // initialize the station abstraction radMsgLog (PRI_STATUS, "-- Station Init Start --"); if (stationInit (&wviewdWork, daemonArchiveIndication) == ERROR) { radMsgLog (PRI_HIGH, "stationInit failed!"); statusUpdateMessage("stationInit failed"); statusUpdate(STATUS_ERROR); stationSendShutdown(&wviewdWork); radMsgRouterExit (); radTimerDelete (wviewdWork.ifTimer); radTimerDelete (wviewdWork.syncTimer); radTimerDelete (wviewdWork.cdataTimer); radTimerDelete (wviewdWork.pushTimer); radTimerDelete (wviewdWork.archiveTimer); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // register the station interface if it is device-based: if (wviewdWork.medium.type == MEDIUM_TYPE_DEVICE) { if (radProcessIORegisterDescriptor (wviewdWork.medium.fd, stationDataCallback, NULL) == ERROR) { radMsgLog (PRI_HIGH, "IORegDescriptor failed"); statusUpdateMessage("IORegDescriptor failed"); statusUpdate(STATUS_ERROR); stationSendShutdown(&wviewdWork); radMsgRouterExit (); radTimerDelete (wviewdWork.ifTimer); radTimerDelete (wviewdWork.syncTimer); radTimerDelete (wviewdWork.cdataTimer); radTimerDelete (wviewdWork.pushTimer); radTimerDelete (wviewdWork.archiveTimer); stationExit (&wviewdWork); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } } // Send test email if it is enabled: if (wviewdWork.IsTestEmailEnabled) { radMsgLog(PRI_STATUS, "Sending test email..."); emailAlertSend(ALERT_TYPE_TEST); } statusUpdate(STATUS_RUNNING); statusUpdateMessage("Normal operation"); radMsgLog (PRI_STATUS, "running..."); while (!wviewdWork.exiting) { // wait on timers, events, file descriptors, msgs if (radProcessWait (0) == ERROR) { wviewdWork.exiting = TRUE; } } statusUpdateMessage("exiting normally"); radMsgLog (PRI_STATUS, "exiting normally..."); statusUpdate(STATUS_SHUTDOWN); computedDataExit (&wviewdWork); radMsgRouterExit (); radTimerDelete (wviewdWork.ifTimer); radTimerDelete (wviewdWork.syncTimer); radTimerDelete (wviewdWork.pushTimer); radTimerDelete (wviewdWork.cdataTimer); radTimerDelete (wviewdWork.archiveTimer); stationExit (&wviewdWork); dbsqliteHiLowExit(); dbsqliteArchiveExit(); daemonSysExit (&wviewdWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (0); }
// the main entry point for the wvpmond process int main (int argc, char *argv[]) { void (*alarmHandler)(int); int i, retVal, intValue, iValue; FILE *pidfile, *markerFile; struct stat fileStatus; char* subString; char markerPath[PMON_MAX_PATH], markerVal[32]; int runAsDaemon = TRUE; if (argc > 1) { if (!strcmp(argv[1], "-f")) { runAsDaemon = FALSE; } } memset (&procmonWork, 0, sizeof (procmonWork)); // initialize some system stuff first retVal = procmonSysInit (&procmonWork); if (retVal == ERROR) { radMsgLogInit (PROC_NAME_PMON, FALSE, TRUE); radMsgLog (PRI_CATASTROPHIC, "wvpmond init failed!\n"); radMsgLogExit (); exit (1); } else if (retVal == ERROR_ABORT) { exit (2); } // call the global radlib system init function if (radSystemInit (WVIEW_SYSTEM_ID) == ERROR) { radMsgLogInit (PROC_NAME_PMON, TRUE, TRUE); radMsgLog (PRI_CATASTROPHIC, "radSystemInit failed!"); radMsgLogExit (); exit (1); } // call the radlib process init function if (radProcessInit (PROC_NAME_PMON, procmonWork.fifoFile, PROC_NUM_TIMERS_PMON, runAsDaemon, // TRUE for daemon msgHandler, evtHandler, NULL) == ERROR) { printf ("\nradProcessInit failed: %s\n\n", PROC_NAME_PMON); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } procmonWork.myPid = getpid (); pidfile = fopen (procmonWork.pidFile, "w"); if (pidfile == NULL) { radMsgLog (PRI_CATASTROPHIC, "lock file create failed!\n"); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } fprintf (pidfile, "%d", getpid ()); fclose (pidfile); alarmHandler = radProcessSignalGetHandler (SIGALRM); radProcessSignalCatchAll (defaultSigHandler); radProcessSignalCatch (SIGALRM, alarmHandler); radProcessSignalRelease(SIGABRT); if (wvconfigInit(FALSE) == ERROR) { radMsgLog (PRI_CATASTROPHIC, "wvconfigInit failed!\n"); radMsgRouterExit (); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // Is the procmon daemon enabled? iValue = wvconfigGetBooleanValue(configItem_ENABLE_PROCMON); if (iValue == ERROR || iValue == 0) { radMsgLog (PRI_CATASTROPHIC, "process monitor daemon is disabled - exiting..."); wvconfigExit (); radMsgRouterExit (); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // Close here; we'll re-open after waiting for the wviewd daemon to be ready: wvconfigExit(); if (statusInit(procmonWork.statusFile, pmonStatusLabels) == ERROR) { radMsgLog (PRI_HIGH, "statusInit failed - exiting..."); wvconfigExit (); radMsgRouterExit (); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } statusUpdate(STATUS_BOOTING); // register with the radlib message router if (radMsgRouterInit (WVIEW_RUN_DIR) == ERROR) { radMsgLog (PRI_HIGH, "radMsgRouterInit failed!"); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // enable message reception from the radlib router for SHUTDOWN msgs radMsgRouterMessageRegister (WVIEW_MSG_TYPE_SHUTDOWN); // wait for the wview daemon to be ready if (waitForWviewDaemon () == ERROR) { radMsgLog (PRI_HIGH, "waitForWviewDaemon failed"); statusUpdate(STATUS_ERROR); radMsgRouterExit (); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } procmonWork.pollTimer = radProcessTimerCreate (NULL, pollTimerHandler, NULL); if (procmonWork.pollTimer == NULL) { radMsgLog (PRI_HIGH, "radTimerCreate failed"); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } procmonWork.tickTimer = radProcessTimerCreate (NULL, tickTimerHandler, NULL); if (procmonWork.tickTimer == NULL) { radMsgLog (PRI_HIGH, "radTimerCreate failed"); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } if (wvconfigInit(FALSE) == ERROR) { radMsgLog (PRI_CATASTROPHIC, "wvconfigInit failed!\n"); statusUpdateMessage("wvconfigInit failed"); statusUpdate(STATUS_ERROR); radMsgRouterExit (); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // Populate our process table: memset (procmonWork.process, 0, sizeof(PMON_PROCESS) * PMON_PROCESS_MAX); for (i = 0; i < PMON_PROCESS_MAX; i ++) { iValue = wvconfigGetINTValue(configIDs[i]); if (iValue < 0) { // we can't do without this! radMsgLog (PRI_CATASTROPHIC, "PMON: %s: failed!", configIDs[i]); statusUpdateMessage("wvconfigGetINTValue failed"); statusUpdate(STATUS_ERROR); wvconfigExit(); radMsgRouterExit (); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { procmonWork.process[i].timeout = iValue; radMsgLog (PRI_STATUS, "PMON: %s: %d", procNames[i], procmonWork.process[i].timeout); } if (procmonWork.process[i].timeout <= 0) { radMsgLog (PRI_STATUS, "PMON: %s process monitoring is disabled", procNames[i]); procmonWork.process[i].ticks = -1; procmonWork.process[i].pid = -1; } else { // Populate the rest of the values: wvstrncpy (procmonWork.process[i].binFile, argv[0], PMON_MAX_PATH); subString = strstr (procmonWork.process[i].binFile, "wvpmond"); if (subString == NULL) { radMsgLog (PRI_CATASTROPHIC, "PMON: %s is invalid for bin path!", procmonWork.process[i].binFile); statusUpdateMessage("invalid for bin path"); statusUpdate(STATUS_ERROR); wvconfigExit(); radMsgRouterExit (); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } if (! strcmp(procNames[i], "wviewd")) { // Get the process name from the marker file: sprintf(markerPath, "%s/wview-binary", WVIEW_CONFIG_DIR); if (stat (markerPath, &fileStatus) != 0) { radMsgLog (PRI_HIGH, "PMON: wview-binary file is missing - was 'make install' run?"); statusUpdateMessage("wview-binary file is missing"); statusUpdate(STATUS_ERROR); radMsgRouterExit (); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } markerFile = fopen(markerPath, "r"); if (markerFile == NULL) { radMsgLog (PRI_HIGH, "PMON: failed to open wview-binary file - was 'make install' run?"); statusUpdateMessage("failed to open wview-binary file"); statusUpdate(STATUS_ERROR); radMsgRouterExit (); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } if (fgets(markerVal, 32, markerFile) == NULL) { radMsgLog (PRI_HIGH, "PMON: failed to read wview-binary file - was 'make install' run?"); statusUpdateMessage("failed to read wview-binary file"); statusUpdate(STATUS_ERROR); fclose(markerFile); radMsgRouterExit (); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // Strip off CR/LF (caused by hand-editing of file!): stripEOLValues(markerVal); sprintf(subString, "%s", markerVal); fclose(markerFile); } else { sprintf (subString, "%s", procNames[i]); } sprintf (procmonWork.process[i].pidFile, "%s/%s.pid", WVIEW_RUN_DIR, procNames[i]); if (stat (procmonWork.process[i].pidFile, &fileStatus) == -1) { // Process is not running, mark it invalid radMsgLog (PRI_STATUS, "PMON: pid file %s not present, disable monitoring...", procmonWork.process[i].pidFile); procmonWork.process[i].timeout = 0; procmonWork.process[i].ticks = -1; procmonWork.process[i].pid = -1; } else { // Get his pid from the pidfile procmonWork.process[i].pid = pmonGetProcessPid (procmonWork.process[i].pidFile); if (procmonWork.process[i].pid == ERROR) { radMsgLog (PRI_CATASTROPHIC, "PMON: failed to READ %s!", procmonWork.process[i].pidFile); statusUpdateMessage("failed to read pid file"); statusUpdate(STATUS_ERROR); wvconfigExit(); radMsgRouterExit (); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } } // Setup the state machine procmonWork.process[i].stateMachine = radStatesInit (&procmonWork); radStatesAddHandler (procmonWork.process[i].stateMachine, PMON_STATE_IDLE, IdleStateHandler); radStatesAddHandler (procmonWork.process[i].stateMachine, PMON_STATE_WAIT_RESP, WaitRespStateHandler); radStatesAddHandler (procmonWork.process[i].stateMachine, PMON_STATE_WAIT_EXIT, WaitExitStateHandler); radStatesAddHandler (procmonWork.process[i].stateMachine, PMON_STATE_WAIT_START, WaitStartStateHandler); radStatesSetState (procmonWork.process[i].stateMachine, PMON_STATE_IDLE); } } wvconfigExit(); radMsgRouterMessageRegister (WVIEW_MSG_TYPE_POLL_RESPONSE); // Start the timers: radProcessTimerStart (procmonWork.pollTimer, PMON_POLL_INTERVAL); radProcessTimerStart (procmonWork.tickTimer, PMON_TICK_INTERVAL); // enter normal processing procmonWork.inMainLoop = TRUE; statusUpdate(STATUS_RUNNING); statusUpdateMessage("Normal operation"); radMsgLog (PRI_STATUS, "running..."); while (!procmonWork.exiting) { // wait on something interesting if (radProcessWait (0) == ERROR) { procmonWork.exiting = TRUE; } } statusUpdateMessage("exiting normally"); radMsgLog (PRI_STATUS, "exiting normally..."); statusUpdate(STATUS_SHUTDOWN); radMsgRouterExit (); radProcessTimerDelete (procmonWork.pollTimer); radProcessTimerDelete (procmonWork.tickTimer); procmonSysExit (&procmonWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (0); }
/* ... the main entry point for the ssh process */ int main (int argc, char *argv[]) { void (*alarmHandler)(int); STIM stim; int i; int seconds; time_t ntime; struct tm locTime; int offset, retVal; long msOffset; FILE *pidfile; int runAsDaemon = TRUE; if (argc > 1) { if (!strcmp(argv[1], "-f")) { runAsDaemon = FALSE; } } memset (&sshWork, 0, sizeof (sshWork)); /* ... initialize some system stuff first */ retVal = sshSysInit (&sshWork); if (retVal == ERROR) { radMsgLogInit (PROC_NAME_SSH, FALSE, TRUE); radMsgLog (PRI_CATASTROPHIC, "ssh init failed!"); radMsgLogExit (); exit (1); } else if (retVal == ERROR_ABORT) { exit (2); } /* ... call the global radlib system init function */ if (radSystemInit (WVIEW_SYSTEM_ID) == ERROR) { radMsgLogInit (PROC_NAME_SSH, TRUE, TRUE); radMsgLog (PRI_CATASTROPHIC, "radSystemInit failed!"); radMsgLogExit (); exit (1); } /* ... call the radlib process init function */ if (radProcessInit (PROC_NAME_SSH, sshWork.fifoFile, PROC_NUM_TIMERS_SSH, runAsDaemon, // TRUE for daemon msgHandler, evtHandler, NULL) == ERROR) { printf ("\nradProcessInit failed: %s\n\n", PROC_NAME_SSH); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } sshWork.myPid = getpid (); pidfile = fopen (sshWork.pidFile, "w"); if (pidfile == NULL) { radMsgLog (PRI_CATASTROPHIC, "lock file create failed!"); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } fprintf (pidfile, "%d", getpid ()); fclose (pidfile); alarmHandler = radProcessSignalGetHandler (SIGALRM); radProcessSignalCatchAll (SSHDefaultSigHandler); radProcessSignalCatch (SIGALRM, alarmHandler); radProcessSignalRelease(SIGABRT); sshWork.timer = radTimerCreate (NULL, timerHandler, NULL); if (sshWork.timer == NULL) { radMsgLog (PRI_HIGH, "radTimerCreate failed - exiting"); sshSysExit (&sshWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // ... initialize the ssh utilities retVal = sshUtilsInit (&sshWork.sshData); if (retVal != OK) { if (retVal == ERROR) { radMsgLog (PRI_HIGH, "sshUtilsInit failed - exiting"); } radTimerDelete (sshWork.timer); sshSysExit (&sshWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { sshWork.sshId = &sshWork.sshData; } if (statusInit(sshWork.statusFile, sshStatusLabels) == ERROR) { radMsgLog (PRI_HIGH, "statusInit failed - exiting..."); sshSysExit (&sshWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } statusUpdate(STATUS_BOOTING); statusUpdateStat(SSH_STATS_RULES_DEFINED, radListGetNumberOfNodes(&sshWork.sshData.rules)); // ... start THE timer ntime = time (NULL); localtime_r (&ntime, &locTime); seconds = locTime.tm_sec - 15; // start at 15 secs past /* ... start the ssh timer to go off 1 min past the next archive record */ offset = locTime.tm_min % 5; if (offset) offset = 6 - offset; else offset = 1; if (seconds < -60) { offset += 1; offset += 60; } radMsgLog (PRI_HIGH, "SSH: starting updates in %d mins %d secs", ((seconds > 0) ? ((offset > 0) ? offset-1 : offset) : offset), (seconds > 0) ? 60 - seconds : (-1) * seconds); msOffset = radTimeGetMSSinceEpoch () % 1000; msOffset -= 250; // land on 250 ms mark sshWork.msOffset = 0; radProcessTimerStart (sshWork.timer, ((((offset * 60) - seconds) * 1000)) - msOffset); statusUpdate(STATUS_RUNNING); statusUpdateMessage("Normal operation"); while (!sshWork.exiting) { /* ... wait on timers, events, file descriptors, msgs, everything! */ if (radProcessWait (0) == ERROR) { sshWork.exiting = TRUE; } } statusUpdateMessage("exiting normally"); radMsgLog (PRI_STATUS, "exiting normally..."); statusUpdate(STATUS_SHUTDOWN); if (sshWork.sshId != NULL) { sshUtilsExit (sshWork.sshId); } radTimerDelete (sshWork.timer); sshSysExit (&sshWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (0); }
int htmlStationInfoState (int state, void *stimulus, void *data) { STIM *stim = (STIM *)stimulus; HTML_WORK *work = (HTML_WORK *)data; int seconds; WVIEW_MSG_STATION_INFO *msg = (WVIEW_MSG_STATION_INFO *)stim->msg; time_t ntime; struct tm locTime; long offset, msOffset; long oldSecs, newSecs; int currDay, currMonth, currYear; float gmtOffsetHours; int16_t tempShort; FILE* indicateFile; ntime = time (NULL); localtime_r (&ntime, &locTime); currDay = locTime.tm_mday; currMonth = locTime.tm_mon + 1; currYear = locTime.tm_year + 1900; #ifdef HAVE_TM_GMTOFF gmtOffsetHours = locTime.tm_gmtoff/(60.0*60.0); #else gmtOffsetHours = gmtoffset()/(60.0*60.0); #endif switch (stim->type) { case STIM_QMSG: if (stim->msgType == WVIEW_MSG_TYPE_STATION_INFO) { radMsgRouterMessageDeregister(WVIEW_MSG_TYPE_STATION_INFO); ntime = msg->lastArcTime; localtime_r (&ntime, &locTime); radMsgLog (PRI_STATUS, "received station info from wviewd: " "%4.4d%2.2d%2.2d %2.2d:%2.2d:%2.2d", locTime.tm_year + 1900, locTime.tm_mon + 1, locTime.tm_mday, locTime.tm_hour, locTime.tm_min, locTime.tm_sec); work->archiveInterval = msg->archiveInterval; // Initialize the archive database interface: if (dbsqliteArchiveInit() == ERROR) { radMsgLog (PRI_HIGH, "dbsqliteArchiveInit failed"); statusUpdateMessage("dbsqliteArchiveInit failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } // initialize the htmlMgr now that we know the archive interval: work->mgrId = htmlmgrInit (WVIEW_CONFIG_DIR, work->isMetricUnits, work->imagePath, work->htmlPath, work->archiveInterval, work->isExtendedData, work->stationName, work->stationCity, work->stationState, msg->elevation, msg->latitude, msg->longitude, work->mphaseIncrease, work->mphaseDecrease, work->mphaseFull, work->radarURL, work->forecastURL, work->dateFormat, work->isDualUnits); if (work->mgrId == NULL) { radMsgLog (PRI_HIGH, "htlmgrInit failed!"); statusUpdateMessage("htlmgrInit failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } wvstrncpy (work->mgrId->stationType, msg->stationType, sizeof(work->mgrId->stationType)); // ... initialize the sun times now sunTimesGetSunRiseSet (currYear, currMonth, currDay, (float)work->mgrId->stationLatitude/10, (float)work->mgrId->stationLongitude/10, RS_TYPE_SUN, &work->mgrId->sunrise, &work->mgrId->sunset); sunTimesGetSunRiseSet (currYear, currMonth, currDay, (float)work->mgrId->stationLatitude/10, (float)work->mgrId->stationLongitude/10, RS_TYPE_CIVIL, &work->mgrId->civilrise, &work->mgrId->civilset); sunTimesGetSunRiseSet (currYear, currMonth, currDay, (float)work->mgrId->stationLatitude/10, (float)work->mgrId->stationLongitude/10, RS_TYPE_ASTRO, &work->mgrId->astrorise, &work->mgrId->astroset); sunTimesGetSunRiseSet (currYear, currMonth, currDay, (float)work->mgrId->stationLatitude/10, (float)work->mgrId->stationLongitude/10, RS_TYPE_MIDDAY, &work->mgrId->midday, &tempShort); work->mgrId->dayLength = sunTimesGetDayLength (currYear, currMonth, currDay, (float)work->mgrId->stationLatitude/10, (float)work->mgrId->stationLongitude/10); GetMoonRiseSetTimes (currYear, currMonth, currDay, (float)gmtOffsetHours, (float)work->mgrId->stationLatitude/10, (float)work->mgrId->stationLongitude/10, &work->mgrId->moonrise, NULL, &work->mgrId->moonset, NULL); // ... initialize the barometric pressure trend algorithm: radMsgLog (PRI_STATUS, "initializing barometric pressure trend"); if (htmlmgrBPTrendInit (work->mgrId, work->timerInterval/60000) == ERROR) { radMsgLog (PRI_HIGH, "htmlmgrBPTrendInit failed!"); statusUpdateMessage("htmlmgrBPTrendInit failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } // ... load up our historical stores for the history charts: radMsgLog (PRI_STATUS, "initializing historical stores (this may take some time...)"); if (htmlmgrHistoryInit (work->mgrId) == ERROR) { radMsgLog (PRI_HIGH, "htmlStationInfoState: htmlmgrHistoryInit failed!"); statusUpdateMessage("htmlmgrHistoryInit failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } // store the "last" values ntime = time(NULL); localtime_r (&ntime, &locTime); work->histLastHour = locTime.tm_hour; work->histLastDay = locTime.tm_mday; // Initialize the HILOW database interface: // (this cannot occur before wviewd sends us the archive time) if (dbsqliteHiLowInit(FALSE) == ERROR) { radMsgLog (PRI_CATASTROPHIC, "dbsqliteHiLowInit failed!"); statusUpdateMessage("dbsqliteHiLowInit failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } // initialize the NOAA database: if (dbsqliteNOAAInit() == ERROR) { radMsgLog (PRI_CATASTROPHIC, "dbsqliteNOAAInit failed!"); statusUpdateMessage("dbsqliteNOAAInit failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } // initialize the NOAA report generator radMsgLog (PRI_STATUS, "NOAA: initializing reports (this may take some time...)"); work->noaaId = noaaGenerateInit (work->mgrId->imagePath, work->isMetricUnits, msg->latitude, msg->longitude, msg->elevation, work->stationName, work->stationCity, work->stationState, msg->lastArcTime); if (work->noaaId == NULL) { radMsgLog (PRI_CATASTROPHIC, "noaaGenerateInit failed!"); statusUpdateMessage("noaaGenerateInit failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } // initialize the archive record browser generator radMsgLog (PRI_STATUS, "ARCREC: initializing archive browser files (this may take some time...)"); if (arcrecGenerateInit (work->mgrId->imagePath, work->arcrecDaysToKeep, work->isMetricUnits, work->archiveInterval) == ERROR) { radMsgLog (PRI_CATASTROPHIC, "arcrecGenerateInit failed!"); statusUpdateMessage("arcrecGenerateInit failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } // initial data request then start the data acquisition timer if (requestDataPackets (work) == ERROR) { radMsgLog (PRI_HIGH, "htmlStationInfoState: requestDataPackets failed!"); statusUpdateMessage("requestDataPackets failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } radProcessTimerStart (work->rxTimer, HTML_RX_PACKETS_TIMEOUT); // wait here until a new second arrives ntime = time (NULL); localtime_r (&ntime, &locTime); oldSecs = newSecs = locTime.tm_sec; while (oldSecs == newSecs) { ntime = time (NULL); localtime_r (&ntime, &locTime); newSecs = locTime.tm_sec; } /* ... start the data timer to go off at the next 5 minute ... interval plus the user offset */ ntime = time (NULL); localtime_r (&ntime, &locTime); seconds = locTime.tm_sec - 10L; // start at 10 secs past offset = locTime.tm_min % 5L; // where are we in period? offset = 5 - offset; // how many mins to get to "0"? offset %= 5; // don't want "5" offset += work->startOffset; // user start in period if (offset == 0L) // prevent negative timeout seconds -= 60L; // make neg so timeout is pos if (seconds < -60L) { offset += 1L; seconds += 60L; } radMsgLog (PRI_STATUS, "starting html generation in %d mins %d secs", ((seconds > 0L) ? ((offset > 0L) ? offset - 1L : offset) : offset), (seconds > 0L) ? 60L - seconds : (-1L) * seconds); work->nextGenerationTime.tv_sec = (long)ntime + ((offset * 60L) - seconds); work->nextGenerationTime.tv_usec = 250L * 1000L; msOffset = 250L; // land on 250 ms mark radProcessTimerStart (work->timer, ((((offset * 60L) - seconds) * 1000L)) + msOffset); // 20041224 - Add an immediate generation cycle so longer // duration archive intervals don't have to wait up to 30 minutes // for the first generation radMsgLog (PRI_STATUS, "doing initial html generation now..."); work->numDataReceived = 0; statusUpdate(STATUS_RUNNING); statusUpdateMessage("Normal operation"); // Save an indicator in the run directory so web apps know when we are up: indicateFile = fopen (work->indicateFile, "w"); if (indicateFile == NULL) { radMsgLog (PRI_CATASTROPHIC, "indicator file create failed!"); statusUpdateMessage("indicator file create failed!"); statusUpdate(STATUS_ERROR); return HTML_STATE_ERROR; } fprintf (indicateFile, "%d", (int)msg->lastArcTime); fclose (indicateFile); return HTML_STATE_DATA; } break; } return state; }
/* ... the main entry point for the alarm process */ int main (int argc, char *argv[]) { void (*alarmHandler)(int); int retVal; FILE *pidfile; WVIEW_ALARM *alarm; int runAsDaemon = TRUE; if (argc > 1) { if (!strcmp(argv[1], "-f")) { runAsDaemon = FALSE; } } memset (&alarmsWork, 0, sizeof (alarmsWork)); radListReset (&alarmsWork.alarmList); radListReset (&alarmsWork.clientList); /* ... initialize some system stuff first */ retVal = alarmsSysInit (&alarmsWork); if (retVal == ERROR) { radMsgLogInit (PROC_NAME_ALARMS, FALSE, TRUE); radMsgLog (PRI_CATASTROPHIC, "wvalarmd sysinit failed!"); radMsgLogExit (); exit (1); } else if (retVal == ERROR_ABORT) { exit (2); } /* ... call the global radlib system init function */ if (radSystemInit (WVIEW_SYSTEM_ID) == ERROR) { radMsgLogInit (PROC_NAME_ALARMS, TRUE, TRUE); radMsgLog (PRI_CATASTROPHIC, "radSystemInit failed!"); radMsgLogExit (); exit (1); } /* ... call the radlib process init function */ if (radProcessInit (PROC_NAME_ALARMS, alarmsWork.fifoFile, PROC_NUM_TIMERS_ALARMS, runAsDaemon, // TRUE for daemon msgHandler, evtHandler, NULL) == ERROR) { printf ("\nradProcessInit failed: %s\n\n", PROC_NAME_ALARMS); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } alarmsWork.myPid = getpid (); pidfile = fopen (alarmsWork.pidFile, "w"); if (pidfile == NULL) { radMsgLog (PRI_CATASTROPHIC, "lock file create failed!"); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } fprintf (pidfile, "%d", getpid ()); fclose (pidfile); alarmHandler = radProcessSignalGetHandler (SIGALRM); radProcessSignalCatchAll (defaultSigHandler); radProcessSignalCatch (SIGALRM, alarmHandler); radProcessSignalRelease(SIGABRT); // grab all of our alarm definitions from the config database retVal = readAlarmsConfig (); if (retVal == ERROR_ABORT) { radMsgLog (PRI_HIGH, "ALARM daemon not enabled - exiting..."); alarmsSysExit (&alarmsWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (0); } else if (retVal < 0) { radMsgLog (PRI_HIGH, "readAlarmsConfig failed - " "is there a problem with the wview config database?"); alarmsSysExit (&alarmsWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } else { radMsgLog (PRI_STATUS, "alarms: added %d alarm definitions", retVal); } if (statusInit(alarmsWork.statusFile, alarmsStatusLabels) == ERROR) { radMsgLog (PRI_HIGH, "ALARM status init failed - exiting..."); alarmsSysExit (&alarmsWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } statusUpdate(STATUS_BOOTING); statusUpdateStat(ALARM_STATS_ALARMS, retVal); // wait a bit here before continuing radUtilsSleep (500); // register with the radlib message router if (radMsgRouterInit (WVIEW_RUN_DIR) == ERROR) { statusUpdateMessage("radMsgRouterInit failed!"); radMsgLog (PRI_HIGH, "radMsgRouterInit failed!"); statusUpdate(STATUS_ERROR); alarmsSysExit (&alarmsWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // enable message reception from the radlib router for SHUTDOWN msgs radMsgRouterMessageRegister (WVIEW_MSG_TYPE_SHUTDOWN); // wait for the wview daemon to be ready if (waitForWviewDaemon () == ERROR) { radMsgLog (PRI_HIGH, "waitForWviewDaemon failed"); statusUpdate(STATUS_ERROR); radMsgRouterExit (); alarmsSysExit (&alarmsWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // finally, initialize our data feed socket alarmsWork.dataFeedServer = radSocketServerCreate(WV_DATAFEED_PORT); if (alarmsWork.dataFeedServer == NULL) { statusUpdateMessage("radSocketServerCreate failed"); radMsgLog (PRI_HIGH, "radSocketServerCreate failed..."); statusUpdate(STATUS_ERROR); radMsgRouterExit (); alarmsSysExit (&alarmsWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // add it to our descriptors of interest if (radProcessIORegisterDescriptor(radSocketGetDescriptor(alarmsWork.dataFeedServer), dataFeedAccept, NULL) == ERROR) { statusUpdateMessage("radProcessIORegisterDescriptor server failed"); radMsgLog (PRI_HIGH, "radProcessIORegisterDescriptor failed..."); statusUpdate(STATUS_ERROR); radSocketDestroy (alarmsWork.dataFeedServer); radMsgRouterExit (); alarmsSysExit (&alarmsWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // enable message reception from the radlib router for loop data radMsgRouterMessageRegister (WVIEW_MSG_TYPE_LOOP_DATA_SVC); // enable message reception from the radlib router for archive data radMsgRouterMessageRegister (WVIEW_MSG_TYPE_ARCHIVE_DATA); // enable message reception from the radlib router for POLL msgs radMsgRouterMessageRegister (WVIEW_MSG_TYPE_POLL); // enter normal processing alarmsWork.inMainLoop = TRUE; statusUpdate(STATUS_RUNNING); statusUpdateMessage("Normal operation"); radMsgLog (PRI_STATUS, "running..."); // Do we need to trigger a test alarm? if (alarmsWork.doTest) { if (1 <= alarmsWork.doTestNumber && alarmsWork.doTestNumber <= ALARMS_MAX) { // Generate the bad boy: retVal = 1; for (alarm = (WVIEW_ALARM *) radListGetFirst (&alarmsWork.alarmList); retVal <= ALARMS_MAX && alarm != NULL; alarm = (WVIEW_ALARM *) radListGetNext (&alarmsWork.alarmList, (NODE_PTR)alarm)) { if (retVal == alarmsWork.doTestNumber) { // This is the one to test: alarm->triggerValue = -1; // run user script here if (executeScript(alarm) != 0) { radMsgLog (PRI_MEDIUM, "Test Alarm %d: script %s failed", retVal, alarm->scriptToRun); } else { radMsgLog (PRI_MEDIUM, "Test Alarm %d: script %s executed", retVal, alarm->scriptToRun); } retVal = ALARMS_MAX; } retVal ++; } } else { radMsgLog (PRI_MEDIUM, "Test Alarm: bad alarm index %d given!", alarmsWork.doTestNumber); } } while (!alarmsWork.exiting) { // wait on something interesting if (radProcessWait (0) == ERROR) { alarmsWork.exiting = TRUE; } } statusUpdateMessage("exiting normally"); radMsgLog (PRI_STATUS, "exiting normally..."); statusUpdate(STATUS_SHUTDOWN); radSocketDestroy (alarmsWork.dataFeedServer); radMsgRouterExit (); alarmsSysExit (&alarmsWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (0); }
static void defaultSigHandler (int signum) { int retVal; switch (signum) { case SIGHUP: // user wants us to change the verbosity setting retVal = wvutilsToggleVerbosity (); radMsgLog (PRI_STATUS, "wvalarmd: SIGHUP - toggling log verbosity %s", ((retVal == 0) ? "OFF" : "ON")); radProcessSignalCatch(signum, defaultSigHandler); return; case SIGPIPE: // we have a far end socket disconnection, we'll handle it in the // "read/write" code alarmsWork.sigpipe = TRUE; radProcessSignalCatch(signum, defaultSigHandler); break; case SIGCHLD: wvutilsWaitForChildren(); radProcessSignalCatch(signum, defaultSigHandler); break; case SIGILL: case SIGBUS: case SIGFPE: case SIGSEGV: case SIGXFSZ: case SIGSYS: // unrecoverable radProcessSignalCatch- we must exit right now! radMsgLog (PRI_CATASTROPHIC, "wvalarmd: recv catastrophic signal %d: aborting!", signum); abort (); default: // can we allow the process to exit normally? if (!alarmsWork.inMainLoop) { // NO! - we gotta bail here! statusUpdateMessage("wvalarmd: recv signal exiting now!"); radMsgLog (PRI_HIGH, "wvalarmd: recv signal %d: exiting now!", signum); if (alarmsWork.dataFeedServer) radSocketDestroy (alarmsWork.dataFeedServer); radMsgRouterExit (); alarmsSysExit (&alarmsWork); radProcessExit (); radSystemExit (WVIEW_SYSTEM_ID); exit (1); } // we can allow the process to exit normally... statusUpdateMessage("wvalarmd: recv catastrophic signal exiting gracefully!"); radMsgLog (PRI_HIGH, "wvalarmd: recv signal %d: exiting gracefully!", signum); alarmsWork.exiting = TRUE; radProcessSetExitFlag (); radProcessSignalCatch(signum, defaultSigHandler); break; } return; }