static void tickHandler(int userVal, xPL_ObjectPtr obj)
{
static Bool firstTime = TRUE;
/* Process clock tick update checking */
if(firstTime){
firstTime = FALSE;
xPL_clearMessageNamedValues(xplEventTriggerMessage);
xPL_addMessageNamedValue(xplEventTriggerMessage, "event", "ready");
xPL_sendMessage(xplEventTriggerMessage);
}
if(serialRetryTimer){ /* If this is non-zero, we lost the serial connection, wait retry time and try again */
serialRetryTimer--;
if(!serialRetryTimer){
if(!(serioStuff = serio_open(comPort, COM_BAUD_RATE))){
debug(DEBUG_UNEXPECTED,"Serial reconnect failed, trying later...");
serialRetryTimer = SERIAL_RETRY_TIME;
return;
}
else{
debug(DEBUG_EXPECTED,"Serial reconnect successful");
if(!xPL_addIODevice(serioHandler, 1234, serio_fd(serioStuff), TRUE, FALSE, FALSE))
fatal("Could not register serial I/O fd with xPL");
}
}
}
}
static void doLRRTrigger(String line)
{
String plist[4];
int i;
plist[0] = NULL;
/* Split the message */
if(3 == splitString(line, plist, ',', 3)){
/* If OPEN or CANCEL, clear the alarmLRR flag */
if((!strcmp(plist[2], "OPEN")) || (!strcmp(plist[2], "CANCEL")))
alarmLRR = FALSE;
/* Try to find a match to an xPL equivalent reporting state */
for(i = 0; lrrNameMap[i].ademco; i++){
if(!strcmp(lrrNameMap[i].ademco, plist[2]))
break;
}
if(lrrNameMap[i].ademco){ /* If match */
xPL_clearMessageNamedValues(xplEventTriggerMessage);
xPL_addMessageNamedValue(xplEventTriggerMessage, "event", lrrNameMap[i].xpl);
xPL_sendMessage(xplEventTriggerMessage);
/* Update the alarmLRR bit which reflects the status of all the alarms */
if(!strcmp(lrrNameMap[i].xpl, "alarm"))
alarmLRR = TRUE;
}
}
if(plist[0])
free(plist[0]);
}
static void doEXPTrigger(String line)
{
String plist[4];
int i;
expMapPtr_t e;
plist[0] = NULL;
/* Do not send zone state changes if armed */
if(stateBits.armed)
return;
/* Split the message */
if(3 == splitString(line, plist, ',', 3)){
for(e = expMapHead; e ; e = e->next){
/* debug(DEBUG_EXPECTED,"plist[0]: %s, plist[1]: %s, e->addr: %d, e->channel: %d", plist[0], plist[1], e->addr, e->channel); */
if((atoi(plist[0]) == e->addr)&&(atoi(plist[1]) == e->channel))
break;
}
if(e){ /* If match */
i = atoi(plist[2]);
xPL_clearMessageNamedValues(xplEventTriggerMessage);
xPL_addMessageNamedValue(xplEventTriggerMessage, "event", i ? "alert" : "normal");
xPL_addMessageNamedValue(xplEventTriggerMessage, "zone", e->zone);
xPL_sendMessage(xplEventTriggerMessage);
}
}
if(plist[0])
free(plist[0]);
}
/* Send an XPL Heartbeat immediatly */
Bool xPL_sendHeartbeat(xPL_ServicePtr theService) {
xPL_MessagePtr theHeartbeat;
/* Create the Heartbeat message, if needed */
if (theService->heartbeatMessage == NULL) {
/* Configure the heartbeat */
if (theService->configurableService && !theService->serviceConfigured) {
theHeartbeat = createHeartbeatMessage(theService, HBEAT_CONFIG);
} else {
theHeartbeat = createHeartbeatMessage(theService, HBEAT_NORMAL);
}
/* Install a new heartbeat message */
theService->heartbeatMessage = theHeartbeat;
xPL_Debug("SERVICE:: Just allocated a new Heartbeat message for the service");
} else
theHeartbeat = theService->heartbeatMessage;
/* Send the message */
if (!xPL_sendMessage(theHeartbeat)) return FALSE;
/* Update last heartbeat time */
theService->lastHeartbeatAt = time(NULL);
xPL_Debug("Sent Heatbeat message");
return TRUE;
}
void sendDevList(xPL_MessagePtr msg) {
int deviceCount = 0, i;
char deviceList[128];
xPL_MessagePtr message = NULL;
message = xPL_createBroadcastMessage(telldusService, xPL_MESSAGE_STATUS);
xPL_setSchema(message, "lighting", "devlist");
xPL_setMessageNamedValue(message, "network", xPL_getMessageNamedValue(msg, "network"));
if (xPL_strcmpIgnoreCase(xPL_getMessageNamedValue(msg, "network"), "1") == 0) {
xPL_setMessageNamedValue(message, "status", "ok");
deviceCount = tdGetNumberOfDevices();
for( i = 0; i < deviceCount; ++i ) {
if (i == 0) { /* First */
strcpy(deviceList, xPL_intToStr(tdGetDeviceId(i)));
} else {
strcat(deviceList, ",");
strcat(deviceList, xPL_intToStr(tdGetDeviceId(i)));
}
}
xPL_setMessageNamedValue(message, "device-count", xPL_intToStr(deviceCount) );
xPL_setMessageNamedValue(message, "device", deviceList );
} else {
xPL_setMessageNamedValue(message, "status", "not-found");
}
xPL_sendMessage(message);
xPL_releaseMessage(message);
}
int main(void)
{
char *data;
long m,n;
printf("%s%c%c\n",
"Content-Type:text/html;charset=iso-8859-1",13,10);
// printf("<h3>Multiplication results</h3>\n");
data = getenv("QUERY_STRING");
stripSpace(data);
char schemaclass[500];
char schematype[500];
char namedvaluearray[500];
char name[500];
char value[500];
char command[500];
char varcontent[500];
char jsoncontent[500];
char NVelement[500];
// printf("URL %s<BR>\n",data);
strcpy(command,data);
unencode(command);
findVarInURL(varcontent,data,"xplpacket");
unencode(varcontent);
stripSpace(varcontent);
xPL_initialize(xPL_getParsedConnectionType());
webgateway = xPL_createService("viknet", "webgateway", "default");
xPL_setServiceVersion(webgateway, "1.0");
/* Add a responder for time setting */
xPL_addServiceListener(webgateway, webgatewayMessageHandler, xPL_MESSAGE_ANY, "security", NULL, NULL);
xPL_setServiceEnabled(webgateway, TRUE);
/* Create a message to send */
xplMessage = xPL_createBroadcastMessage(webgateway, xPL_MESSAGE_COMMAND);
if (JSONfindObject(schemaclass,varcontent,"msgschemaclass")!=NULL && JSONfindObject(schematype,varcontent,"msgschematype")!=NULL)
xPL_setSchema(xplMessage, JSONtoString(schemaclass), JSONtoString(schematype));
else
xPL_setSchema(xplMessage, "schemaclass", "schematype");
JSONfindObject(namedvaluearray,varcontent,"namevaluelist");
int i;
for (i=0;i<JSONArrayLength(namedvaluearray);i++)
{
JSONArrayAt(NVelement,namedvaluearray,i);
if ( JSONfindObject(name,NVelement,"name") && JSONfindObject(value,NVelement,"value"))
xPL_addMessageNamedValue(xplMessage, JSONtoString(name), JSONtoString(value));
}
xPL_sendMessage(xplMessage);
// xPL_processMessages(0);
return 0;
}
void sendDevInfo(xPL_MessagePtr msg) {
xPL_MessagePtr message = NULL;
Bool found = FALSE, deviceCount = tdGetNumberOfDevices();
int deviceId = 0, methods = 0, i = 0, lastSentCommand, level = 0;
char *name, buffer[12], *value;
xPL_strToInt(xPL_getMessageNamedValue(msg, "device"), &deviceId);
for( i = 0; i < deviceCount; ++i ) {
if (tdGetDeviceId(i) == deviceId) {
found = TRUE;
break;
}
}
message = xPL_createBroadcastMessage(telldusService, xPL_MESSAGE_STATUS);
xPL_setSchema(message, "lighting", "devinfo");
xPL_setMessageNamedValue(message, "network", xPL_getMessageNamedValue(msg, "network"));
xPL_setMessageNamedValue(message, "device", xPL_getMessageNamedValue(msg, "device"));
if (xPL_strcmpIgnoreCase(xPL_getMessageNamedValue(msg, "network"), "1") == 0 && found == TRUE) {
lastSentCommand = tdLastSentCommand(deviceId, TELLSTICK_TURNON | TELLSTICK_TURNOFF | TELLSTICK_DIM);
if (lastSentCommand == TELLSTICK_TURNON) {
level = 100;
} else if (lastSentCommand == TELLSTICK_DIM) {
value = tdLastSentValue(deviceId);
level = atoi(value);
free(value);
level = round((float)level / 255.0 * 100.0);
if (level > 100) {
level = 100;
} else if (level < 0) {
level = 0;
}
} else {
level = 0;
}
methods = tdMethods(deviceId, TELLSTICK_TURNON | TELLSTICK_TURNOFF | TELLSTICK_DIM);
name = tdGetName(deviceId);
sprintf(buffer, "1,%s,0,%i", (methods & TELLSTICK_DIM ? "true" : "false"), level);
xPL_setMessageNamedValue(message, "status", "ok");
xPL_setMessageNamedValue(message, "name", name );
xPL_setMessageNamedValue(message, "report-on-manual", "false" );
xPL_setMessageNamedValue(message, "channel-count", "1" );
xPL_setMessageNamedValue(message, "primary-channel", "1" );
xPL_setMessageNamedValue(message, "channel", buffer );
xPL_setMessageNamedValue(message, "scene-count", "0" );
free(name);
} else {
xPL_setMessageNamedValue(message, "status", "not-found");
}
xPL_sendMessage(message);
xPL_releaseMessage(message);
}
/* updated and the message sent */
Bool xPL_sendServiceMessage(xPL_ServicePtr theService, xPL_MessagePtr theMessage) {
if ((theService == NULL) || (theMessage == NULL)) return FALSE;
/* Insure the message comes from this service */
theMessage->sourceVendor = theService->serviceVendor;
theMessage->sourceDeviceID = theService->serviceDeviceID;
theMessage->sourceInstanceID = theService->serviceInstanceID;
/* Send it on it's merry way */
return xPL_sendMessage(theMessage);
}
static void doZoneList()
{
zoneMapPtr_t zm;
xPL_setSchema(xplStatusMessage, "security", "zonelist");
xPL_clearMessageNamedValues(xplStatusMessage);
for(zm = zoneMapHead; zm; zm = zm->next){
xPL_addMessageNamedValue(xplStatusMessage, "zone-list", zm->zone_name);
}
if(!xPL_sendMessage(xplStatusMessage))
debug(DEBUG_UNEXPECTED, "request.zonelist transmission failed");
}
void sendNetList() {
xPL_MessagePtr message = NULL;
message = xPL_createBroadcastMessage(telldusService, xPL_MESSAGE_STATUS);
xPL_setSchema(message, "lighting", "netlist");
xPL_setMessageNamedValue(message, "status", "ok");
xPL_setMessageNamedValue(message, "network", "1");
/* Broadcast the message */
xPL_sendMessage(message);
xPL_releaseMessage(message);
}
void sendGatewayReadyMessage() {
xPL_MessagePtr gatewayReadyMessage = NULL;
/* Create a message to send */
gatewayReadyMessage = xPL_createBroadcastMessage(telldusService, xPL_MESSAGE_TRIGGER);
xPL_setSchema(gatewayReadyMessage, "lighting", "gateway");
/* Install the value and send the message */
xPL_setMessageNamedValue(gatewayReadyMessage, "report", "gateway-ready");
/* Broadcast the message */
xPL_sendMessage(gatewayReadyMessage);
xPL_releaseMessage(gatewayReadyMessage);
}
Bool sendMessage(int argc, String argv[]) {
int argIndex = 0;
xPL_ServicePtr theService = NULL;
xPL_MessagePtr theMessage = NULL;
String delimPtr;
/* Create service so we can create messages */
if ((theService = xPL_createService(srcVendor, srcDeviceID, srcInstanceID)) == NULL) {
fprintf(stderr, "Unable to create xPL service\n");
return FALSE;
}
/* Create an appropriate message */
if (msgTarget == NULL) {
if ((theMessage = xPL_createBroadcastMessage(theService, msgType)) == NULL) {
fprintf(stderr, "Unable to create broadcast message\n");
return FALSE;
}
} else {
if ((theMessage = xPL_createTargetedMessage(theService, msgType, tgtVendor, tgtDeviceID, tgtInstanceID)) == NULL) {
fprintf(stderr, "Unable to create targetted message\n");
return FALSE;
}
}
/* Install the schema */
xPL_setSchema(theMessage, msgSchemaClass, msgSchemaType);
/* Install named values */
for (argIndex = 1; argIndex < argc; argIndex++) {
if ((delimPtr = strstr(argv[argIndex], "=")) == NULL) {
fprintf(stderr, "Improperly formatted name/value pair %s\n", argv[argIndex]);
return FALSE;
}
/* Break them up and add it */
*delimPtr++ = '\0';
xPL_addMessageNamedValue(theMessage, argv[argIndex], delimPtr);
}
/* Send the message */
if (!xPL_sendMessage(theMessage)) {
fprintf(stderr, "Unable to send xPL message\n");
return FALSE;
}
return TRUE;
}
/* Send an Goodbye XPL Heartbeat immediatly */
Bool xPL_sendGoodbyeHeartbeat(xPL_ServicePtr theService) {
xPL_MessagePtr theHeartbeat;
/* Create a shutdown message */
if (theService->configurableService && !theService->serviceConfigured)
theHeartbeat = createHeartbeatMessage(theService, HBEAT_CONFIG_END);
else
theHeartbeat = createHeartbeatMessage(theService, HBEAT_NORMAL_END);
/* Send the message */
if (!xPL_sendMessage(theHeartbeat)) return FALSE;
/* Release message */
xPL_releaseMessage(theHeartbeat);
xPL_Debug("Sent Goodbye Heatbeat");
return TRUE;
}
static void doGateInfo()
{
int i;
String ws;
if(!(ws = mallocz(WS_SIZE)))
MALLOC_ERROR;
xPL_setSchema(xplStatusMessage, "security", "gateinfo");
xPL_clearMessageNamedValues(xplStatusMessage);
xPL_setMessageNamedValue(xplStatusMessage, "protocol", "ECP");
xPL_setMessageNamedValue(xplStatusMessage, "description", "ad2usb to xPL bridge");
xPL_setMessageNamedValue(xplStatusMessage, "version", VERSION);
xPL_setMessageNamedValue(xplStatusMessage, "author", "Stephen A. Rodgers");
xPL_setMessageNamedValue(xplStatusMessage, "info-url", "http://xpl.ohnosec.org");
snprintf(ws, WS_SIZE, "%u", zoneCount);
xPL_setMessageNamedValue(xplStatusMessage, "zone-count", ws);
/* Build comma delimited command list */
ws[0] = 0;
for(i = 0; basicCommandList[i] && (strlen(ws) + strlen(basicCommandList[i]) < WS_SIZE) ; i++){
strcat(ws, basicCommandList[i]);
strcat(ws, ",");
}
/* Strip comma from end of string if it is there */
i = strlen(ws);
if(i)
i--;
if(ws[i] == ',')
ws[i] = 0;
xPL_setMessageNamedValue(xplStatusMessage, "gateway-commands", ws);
if(!xPL_sendMessage(xplStatusMessage))
debug(DEBUG_UNEXPECTED, "request.gateinfo transmission failed");
free(ws);
}
static void doZoneInfo(xPL_MessagePtr theMessage)
{
const String zone = xPL_getMessageNamedValue(theMessage, "zone");
zoneMapPtr_t zm;
if(zone && (zm = zoneLookup(zone))){
xPL_setSchema(xplStatusMessage, "security", "zoneinfo");
/* Clear the message */
xPL_clearMessageNamedValues(xplStatusMessage);
/* Fill in the data */
xPL_addMessageNamedValue(xplStatusMessage, "id", zone);
xPL_addMessageNamedValue(xplStatusMessage, "zone-type", zm->zone_type);
xPL_addMessageNamedValue(xplStatusMessage, "alarm-type", zm->alarm_type);
xPL_addMessageNamedValue(xplStatusMessage, "area-count","0");
/* Send the message */
if(!xPL_sendMessage(xplStatusMessage))
debug(DEBUG_UNEXPECTED, "request.zoneinfo transmission failed");
}
}
void doArmDisarm(xPL_MessagePtr theMessage, int cmd)
{
const String code = xPL_getMessageNamedValue(theMessage, "id");
if(!code) /* If no code, then bail */
return;
if(cmd < 2){
if(stateBits.ready){
serio_printf(serioStuff, "%s%c", code, (cmd == 0) ? '3' : '2');
}
else{ /* arming failed, send error trigger message */
xPL_clearMessageNamedValues(xplEventTriggerMessage);
xPL_addMessageNamedValue(xplEventTriggerMessage, "event", "error");
xPL_sendMessage(xplEventTriggerMessage);
}
}
else{ /* disarm */
serio_printf(serioStuff, "%s1", code);
}
}
void sendNetInfo(xPL_MessagePtr msg) {
xPL_MessagePtr message = NULL;
message = xPL_createBroadcastMessage(telldusService, xPL_MESSAGE_STATUS);
xPL_setSchema(message, "lighting", "netinfo");
xPL_setMessageNamedValue(message, "network", xPL_getMessageNamedValue(msg, "network"));
if (xPL_strcmpIgnoreCase(xPL_getMessageNamedValue(msg, "network"), "1") == 0) {
xPL_setMessageNamedValue(message, "status", "ok");
xPL_setMessageNamedValue(message, "name", hostname );
xPL_setMessageNamedValue(message, "device-count", xPL_intToStr(tdGetNumberOfDevices()) );
xPL_setMessageNamedValue(message, "scene-count", "0" );
} else {
xPL_setMessageNamedValue(message, "status", "not-found");
}
xPL_sendMessage(message);
xPL_releaseMessage(message);
}
static void doGateStat()
{
String status = "disarmed";
xPL_setSchema(xplStatusMessage, "security", "gatestat");
/* Clear the message */
xPL_clearMessageNamedValues(xplStatusMessage);
/* Fill in the data */
xPL_addMessageNamedValue(xplStatusMessage, "ac-fail", stateBits.acfail ? "true" : "false");
xPL_addMessageNamedValue(xplStatusMessage, "low-battery", stateBits.lowbatt ? "true" : "false");
if(stateBits.alarm)
status = "alarm";
else if(stateBits.armed)
status = "armed";
xPL_addMessageNamedValue(xplStatusMessage, "status", status);
/* Send the message */
if(!xPL_sendMessage(xplStatusMessage))
debug(DEBUG_UNEXPECTED, "request.gatestat transmission failed");
}
void sendGatewayInfo() {
xPL_MessagePtr message = NULL;
message = xPL_createBroadcastMessage(telldusService, xPL_MESSAGE_STATUS);
xPL_setSchema(message, "lighting", "gateinfo");
xPL_setMessageNamedValue(message, "status", "ok");
xPL_setMessageNamedValue(message, "protocol", "TELLDUS");
xPL_setMessageNamedValue(message, "description", "xPL to Telldus TellStick gateway");
xPL_setMessageNamedValue(message, "version", TELLDUS_VERSION);
xPL_setMessageNamedValue(message, "author", "Telldus Technologies AB");
xPL_setMessageNamedValue(message, "info-url", "http://www.telldus.se");
xPL_setMessageNamedValue(message, "net-count", "1");
xPL_setMessageNamedValue(message, "preferred-net", "1");
xPL_setMessageNamedValue(message, "scenes-ok", "false");
xPL_setMessageNamedValue(message, "channels-ok", "false");
xPL_setMessageNamedValue(message, "fade-rate-ok", "false");
/* Broadcast the message */
xPL_sendMessage(message);
xPL_releaseMessage(message);
}
int xpl4l_timer(node_t* argXmlConfig)
{
static init = 1;
static time_t oldClockTime, oldTickTime;
time_t t;
struct tm *ts;
char buf[80];
Bool ret;
if ( init )
{
t = 0;
timer_loadConfig (argXmlConfig);
init = 0;
clockService = xPL_createService (XPLHAL4L_VENDOR, "clock", HAL4L_hostName);
xPL_setServiceVersion (clockService, XPLHAL4L_VERSION);
/* Add a responder for time setting */
xPL_addServiceListener (clockService, clockServiceHandler, xPL_MESSAGE_ANY, "clock", NULL, NULL);
/* Create a message to send */
clockTickMessage = xPL_createBroadcastMessage (clockService, xPL_MESSAGE_STATUS);
xPL_setSchema (clockTickMessage, "clock", "update");
/* Internals messages */
schedulerTickMessage = createInternalTickMessage();
xPL_addMessageListener(internalMessageHandler, NULL);
}
t = time (NULL);
ts = localtime(&t);
if ( timerConfig.clock_enabled && t%timerConfig.clock_interval==0 && t!=oldClockTime)
{
strftime(buf, sizeof(buf), "%Y%m%d%H%M%S", ts);
/* Install the value and send the message */
xPL_setMessageNamedValue (clockTickMessage, "time", buf);
/* Broadcast the message */
xPL_sendMessage (clockTickMessage);
oldClockTime = t;
}
if ( t%timerConfig.sched_interval==0 && t!=oldTickTime)
{
strftime(buf, sizeof(buf), "%a %Y-%m-%d %H:%M:%S %Z", ts);
/* Crée le messageBody si NULL et y ajoute une seule ligne si elle n'existe pas, sinon la met à jour */
xPL_setMessageNamedValue(schedulerTickMessage, "timestamp", buf);
strftime(buf, sizeof(buf), "%H:%M", ts);
xPL_setMessageNamedValue(schedulerTickMessage, "time", buf);
strftime(buf, sizeof(buf), "%Y", ts);
xPL_setMessageNamedValue(schedulerTickMessage, "year", buf);
strftime(buf, sizeof(buf), "%m", ts);
xPL_setMessageNamedValue(schedulerTickMessage, "month", buf);
strftime(buf, sizeof(buf), "%Y%m%d", ts);
xPL_setMessageNamedValue(schedulerTickMessage, "date", buf);
strftime(buf, sizeof(buf), "%d", ts);
xPL_setMessageNamedValue(schedulerTickMessage, "day", buf);
sprintf(buf, "%d", t);
xPL_setMessageNamedValue(schedulerTickMessage, "epoch", buf);
ret = xPL_dispatchMessageEvent(schedulerTickMessage);
printf ("Message dispatched = %s\n", ret == TRUE ? "TRUE":"FALSE");
oldTickTime = t;
}
}
void pmaxdMessageHandler(xPL_ServicePtr theService, xPL_MessagePtr theMessage, xPL_ObjectPtr userValue) {
DEBUG(LOG_DEBUG,"Received a pmaxd Message from %s-%s.%s of type %d for %s.%s\n",
xPL_getSourceVendor(theMessage), xPL_getSourceDeviceID(theMessage), xPL_getSourceInstanceID(theMessage),
xPL_getMessageType(theMessage), xPL_getSchemaClass(theMessage), xPL_getSchemaType(theMessage));
DEBUG(LOG_DEBUG,"xpl message received: %s",xPL_formatMessage(theMessage));
DEBUG(LOG_INFO,"command: %s ", xPL_getMessageNamedValue(theMessage, "command"));
if (strcmp("basic",xPL_getSchemaType(theMessage))==0 && xPL_getMessageNamedValue(theMessage, "command")!=NULL ) {
if (strcmp("arm-away",xPL_getMessageNamedValue(theMessage, "command"))==0 ) {
DEBUG(LOG_INFO,"arming away.........");
sendBuffer(&PowerlinkCommand[Pmax_ARMAWAY]);
}
if (strcmp("arm-home",xPL_getMessageNamedValue(theMessage, "command"))==0 ) {
DEBUG(LOG_INFO,"arming home........");
sendBuffer(&PowerlinkCommand[Pmax_ARMHOME]);
}
if (strcmp("disarm",xPL_getMessageNamedValue(theMessage, "command"))==0 ) {
DEBUG(LOG_INFO,"disarming.....");
sendBuffer(&PowerlinkCommand[Pmax_DISARM]);
}
}
DEBUG(LOG_INFO,"not a security basic");
if (strcmp("request",xPL_getSchemaType(theMessage))==0 && xPL_getMessageNamedValue(theMessage, "request")!=NULL ) {
DEBUG(LOG_INFO,"a security request");
if (strcmp("gatestat",xPL_getMessageNamedValue(theMessage, "request"))==0 ) {
DEBUG(LOG_INFO,"requesting getstat.....");
sendBuffer(&PowerlinkCommand[Pmax_REQSTATUS]);
int i;
for(i=0;i<50;i++) {
serialHandler();
}
if (lastValidSerialIO<(time(NULL)-10))
{ DEBUG(LOG_INFO,"lst serial command too old");}
else {
DEBUG(LOG_INFO,"lst serial recent enough");
/* Create a message to send */
pmaxdMessage = xPL_createBroadcastMessage(pmaxdService, xPL_MESSAGE_STATUS);
xPL_setSchema(pmaxdMessage, "security", "gatestat"); // setschema to security.basic
xPL_setMessageNamedValue(pmaxdMessage, "status", gatestat.status);
/* if (pmaxSystem.xplalarmstatus==AlarmArmed)
xPL_setMessageNamedValue(pmaxdMessage, "status", "armed");
else
xPL_setMessageNamedValue(pmaxdMessage, "status", "disarmed"); */
xPL_setMessageNamedValue(pmaxdMessage, "pmaxstatus", gatestat.pmstatus);
/*if (pmaxSystem.xplpmaxstatus==PmaxArmedAway)
xPL_setMessageNamedValue(pmaxdMessage, "pmaxstatus", "armed-away");
if (pmaxSystem.xplpmaxstatus==PmaxArmedHome)
xPL_setMessageNamedValue(pmaxdMessage, "pmaxstatus", "armed-home");
if (pmaxSystem.xplpmaxstatus==PmaxDisarmed)
xPL_setMessageNamedValue(pmaxdMessage, "pmaxstatus", "disarmed"); */
/*if (pmaxSystem.readytoarm)
xPL_setMessageNamedValue(pmaxdMessage, "readytoarm", "true");
else
xPL_setMessageNamedValue(pmaxdMessage, "readytoarm", "false");
*/
/*
if (pmaxSystem.status==0 || pmaxSystem.status==1 || pmaxSystem.status==2) {
xPL_setMessageNamedValue(pmaxdMessage, "status", "disarmed");
xPL_setMessageNamedValue(pmaxdMessage, "pmaxstatus", "disarmed");
}
if (pmaxSystem.status==4 || pmaxSystem.status==10 ) {
xPL_setMessageNamedValue(pmaxdMessage, "status", "armed");
xPL_setMessageNamedValue(pmaxdMessage, "pmaxstatus", "armed-home");
}
if (pmaxSystem.status==3 || pmaxSystem.status==5 || pmaxSystem.status==11) {
xPL_setMessageNamedValue(pmaxdMessage, "status", "armed");
xPL_setMessageNamedValue(pmaxdMessage, "pmaxstatus", "armed-away");
}
if ( (pmaxSystem.flags & 0x01)==1 ) {
xPL_setMessageNamedValue(pmaxdMessage, "readytoarm", "true");
}
else {
xPL_setMessageNamedValue(pmaxdMessage, "readytoarm", "false");
} */
/* Broadcast the message */
DEBUG(LOG_DEBUG,"xpl message sent: %s",xPL_formatMessage(pmaxdMessage));
xPL_sendMessage(pmaxdMessage);
}
}
if (strcmp("zonelist",xPL_getMessageNamedValue(theMessage, "request"))==0 ) {
DEBUG(LOG_INFO,"requesting zonelist.....");
pmaxdMessage = xPL_createBroadcastMessage(pmaxdService, xPL_MESSAGE_STATUS);
xPL_setSchema(pmaxdMessage, "security", "zonelist"); // setschema to security.basic
char zonelist[256];
zonelist[0]=0;
char id[10];
int i;
for (i=1;i<=30;i++) {
if (gatestat.zone[i].enrolled) {
//sprintf(id,"%d,",i);
strcat(zonelist,gatestat.zone[i].info.id);
strcat(zonelist,",");
}
}
zonelist[strlen(zonelist)-1]=0;
DEBUG(LOG_INFO,"zonelist: %s",zonelist);
xPL_setMessageNamedValue(pmaxdMessage, "zone-list", zonelist);
DEBUG(LOG_DEBUG,"xpl message sent: %s",xPL_formatMessage(pmaxdMessage));
xPL_sendMessage(pmaxdMessage);
}
if (strcmp("zoneinfo",xPL_getMessageNamedValue(theMessage, "request"))==0 ) {
int zone;
zone=0;
char * zonebuffer;
zonebuffer= xPL_getMessageNamedValue(theMessage, "zone");
// sscanf(zonebuffer,"%d",&zone);
int i;
for (i=1;i<=30;i++)
{
// pmaxSystem.sensor[i].type=perimeter;
if (strcmp(gatestat.zone[i].info.id,zonebuffer)==0) break;
}
zone=i;
DEBUG(LOG_INFO,"requesting zoneinfo for zone %s,%d.....",zonebuffer,zone);
pmaxdMessage = xPL_createBroadcastMessage(pmaxdService, xPL_MESSAGE_STATUS);
xPL_setSchema(pmaxdMessage, "security", "zoneinfo"); // setschema to security.basic
xPL_setMessageNamedValue(pmaxdMessage, "zone", zonebuffer);
xPL_setMessageNamedValue(pmaxdMessage, "zone-type", gatestat.zone[zone].info.zonetype);
// if (pmaxSystem.sensor[zone].type==interior ) xPL_setMessageNamedValue(pmaxdMessage, "zone-type", "interior");
// if (pmaxSystem.sensor[zone].type==perimeter ) xPL_setMessageNamedValue(pmaxdMessage, "zone-type", "perimeter");
DEBUG(LOG_DEBUG,"xpl message sent: %s",xPL_formatMessage(pmaxdMessage));
xPL_sendMessage(pmaxdMessage);
}
if (strcmp("zonestat",xPL_getMessageNamedValue(theMessage, "request"))==0 ) {
int zone;
zone=0;
char * zonebuffer;
zonebuffer=xPL_getMessageNamedValue(theMessage, "zone");
//sscanf(zonebuffer,"%d",&zone);
int i;
for (i=1;i<=30;i++)
{
if (strcmp(gatestat.zone[i].info.id,zonebuffer)==0) break;
}
zone=i;
DEBUG(LOG_INFO,"requesting zonestat for zone %s,%d.....",zonebuffer,zone);
pmaxdMessage = xPL_createBroadcastMessage(pmaxdService, xPL_MESSAGE_STATUS);
xPL_setSchema(pmaxdMessage, "security", "zonestat"); // setschema to security.basic
xPL_setMessageNamedValue(pmaxdMessage, "zone", zonebuffer);
xPL_setMessageNamedValue(pmaxdMessage, "alert", gatestat.zone[zone].stat.alert);
//if (pmaxSystem.sensor[zone].state==SensorClose ) xPL_setMessageNamedValue(pmaxdMessage, "alert", "false");
//if (pmaxSystem.sensor[zone].state==SensorOpen ) xPL_setMessageNamedValue(pmaxdMessage, "alert", "true");
xPL_setMessageNamedValue(pmaxdMessage, "armed", gatestat.zone[zone].stat.armed);
//if (pmaxSystem.sensor[zone].armed ) xPL_setMessageNamedValue(pmaxdMessage, "armed", "true");
//else xPL_setMessageNamedValue(pmaxdMessage, "armed", "false");
xPL_setMessageNamedValue(pmaxdMessage, "alarm", gatestat.zone[zone].stat.alarm);
xPL_setMessageNamedValue(pmaxdMessage, "state", gatestat.zone[zone].stat.state);
xPL_setMessageNamedValue(pmaxdMessage, "tamper", gatestat.zone[zone].stat.tamper);
//if (pmaxSystem.sensor[zone].tampered ) xPL_setMessageNamedValue(pmaxdMessage, "tamper", "true");
//else xPL_setMessageNamedValue(pmaxdMessage, "tamper", "false");
xPL_setMessageNamedValue(pmaxdMessage, "low-battery", gatestat.zone[zone].stat.lowbattery);
//if (pmaxSystem.sensor[zone].lowbattery ) xPL_setMessageNamedValue(pmaxdMessage, "low-battery", "true");
//else xPL_setMessageNamedValue(pmaxdMessage, "low-battery", "false");
DEBUG(LOG_DEBUG,"xpl message sent: %s",xPL_formatMessage(pmaxdMessage));
xPL_sendMessage(pmaxdMessage);
}
}
DEBUG(LOG_INFO,"end message handling");
}
int main(void)
{
pmaxSystem.status[0]=0;
pmaxSystem.pmaxstatus[0]=0;
pmaxSystem.readytoarm[0]=0;
pmaxSystem.PmaxStatus[0]=0;
int k;
for (k=0;k<31;k++)
{
pmaxSystem.sensor[k].type[0]=0;
pmaxSystem.sensor[k].alert[0]=0;
pmaxSystem.sensor[k].PmaxAlarmType[0]=0;
pmaxSystem.sensor[k].armed[0]=0;
pmaxSystem.sensor[k].alarmed[0]=0;
pmaxSystem.sensor[k].lowbattery[0]=0;
pmaxSystem.sensor[k].enrolled[0]=0;
pmaxSystem.sensor[k].tampered[0]=0;
pmaxSystem.sensor[k].id[0]=0;
}
// char *data;
long m,n;
printf("%s%c%c\n" ,
"Content-Type:text/html;charset=iso-8859-1",13,10);
xPL_initialize(xPL_getParsedConnectionType());
webgateway = xPL_createService("viknet", "webgateway", "default");
xPL_setServiceVersion(webgateway, "1.0");
/* Add a responder for time setting */
xPL_addServiceListener(webgateway, webgatewayMessageHandler, xPL_MESSAGE_ANY, "security", NULL, NULL);
xPL_setServiceEnabled(webgateway, TRUE);
// int j;
// for (j=0;j<10;j++)
// {
/* Create a message to send */
xplMessage = xPL_createBroadcastMessage(webgateway, xPL_MESSAGE_COMMAND);
xPL_setSchema(xplMessage, "security", "request");
xPL_setMessageNamedValue(xplMessage, "request", "zonelist");
xPL_sendMessage(xplMessage);
// printf("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n");
int i;
xplMessage = xPL_createBroadcastMessage(webgateway, xPL_MESSAGE_COMMAND);
xPL_setSchema(xplMessage, "security", "request");
xPL_setMessageNamedValue(xplMessage, "request", "gatestat");
xPL_sendMessage(xplMessage);
for (i=1;i<1000;i++)
{
usleep(1000);
if (nbzone!=0) break;
xPL_processMessages(0);
}
strcpy(tpzonelist,zonelist);
char * element;
// printf("yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy\n");
// printf("zone: %d, %s\n",nbzone,zonelist);
// for (i=0;i<nbzone;i++) {
// char * pch;
element = strtok (tpzonelist,",");
while (element != NULL)
{
// printf ("%s\n",element);
// xplListAt(element,zonelist,i);
// sprintf(element,"%d",i);
// printf("element: %s\n",element);
xplMessage = xPL_createBroadcastMessage(webgateway, xPL_MESSAGE_COMMAND);
xPL_setSchema(xplMessage, "security", "request");
xPL_setMessageNamedValue(xplMessage, "request", "zoneinfo");
xPL_setMessageNamedValue(xplMessage, "zone", element);
xPL_sendMessage(xplMessage);
xplMessage = xPL_createBroadcastMessage(webgateway, xPL_MESSAGE_COMMAND);
xPL_setSchema(xplMessage, "security", "request");
xPL_setMessageNamedValue(xplMessage, "request", "zonestat");
xPL_setMessageNamedValue(xplMessage, "zone", element);
xPL_sendMessage(xplMessage);
usleep(40000);
xPL_processMessages(0);
element = strtok (NULL, ",");
}
// printf("zonelist: %s\n",zonelist);
for (i=0;i<10;i++)
{
usleep(15000);
xPL_processMessages(0);
}
printf("{ \"status\":\"%s\",\"pmaxstatus\":\"%s\",\"readytoarm\":\"%s\",\"sensor\":[",pmaxSystem.status,pmaxSystem.pmaxstatus,pmaxSystem.readytoarm);
// strcpy(tpzonelist,zonelist);
// element = strtok (tpzonelist,",");
i=0;
// while (element != NULL)
char tmpbuff[200];
char buff[6000];
buff[0]=0;
for (i=0;i<31;i++)
{
// printf ("%s\n",element);
if ( strcmp(pmaxSystem.sensor[i].id,"")!=0 ) {
sprintf(tmpbuff,"{\"zone\":\"%s\",\"type\":\"%s\",\"alert\":\"%s\",\"armed\":\"%s\",\"tamper\":\"%s\",\"low-battery\":\"%s\",\"alarm\":\"%s\"},",
pmaxSystem.sensor[i].id,
pmaxSystem.sensor[i].type,
pmaxSystem.sensor[i].alert,
pmaxSystem.sensor[i].armed,
pmaxSystem.sensor[i].tampered,
pmaxSystem.sensor[i].lowbattery,
pmaxSystem.sensor[i].alarmed);
strcat(buff,tmpbuff);
//element = strtok (NULL, ",");
//if (element!=NULL)
//i++;
}
}
buff[strlen(buff)-1]=0;
printf("%s",buff);
printf("]}");
nbzone=0;
zonelist[0]=0;
//}
return 0;
}
