ControlParser.cpp

00001 #include <stdio.h>
00002 #include <string.h>
00003 #include "ControlParser.h"
00004 #include "Peripheral.h"
00005 #include "LCDDisplay.h"
00006 #include "ConfigSync.h"
00007 #include "logging.h"
00008 
00009 
00010 void ControlParser::parse(const char *buf)
00011 {
00012         if (buf == NULL) return;
00013         const char *p = skipHTTPHeader(buf);
00014         if (p == NULL) return;
00015         Token tok;
00016         ptrPF = &ControlParser::parseGetOp;
00017         do {
00018                 p = lex(p, tok);
00019                 (this->*ptrPF)(tok);
00020         } while (*p);
00021 }
00022 
00023 
00024 void ControlParser::parseGetOp(Token& tok)
00025 {
00026         if (tok.type == Token::INT && strncmp("211", tok.p, tok.len)==0) {
00027                 opType = 211;
00028                 ptrPF = &ControlParser::parseRowNumber;
00029         } else {
00030                 parseError(tok);
00031         }
00032 }
00033 
00034 
00035 void ControlParser::parseRowNumber(Token& tok)
00036 {
00037         if (tok.type == Token::INT) {
00038                 if (opType == 86)
00039                         ptrPF = &ControlParser::parseAdviceTimeout;
00040                 else
00041                         ptrPF = &ControlParser::parseOpId;
00042         } else if (tok.type == Token::NONE) {
00043                 ptrPF = &ControlParser::parseAdviceTimeout;
00044         } else {
00045                 parseError(tok);
00046         }
00047 }
00048 
00049 
00050 void ControlParser::parseOpId(Token& tok)
00051 {
00052         if (tok.type == Token::INT) {
00053                 if (opType == 211) {
00054                         sscanf(tok.p, "%ld", &op.identifier);
00055                         ptrPF = &ControlParser::parseOpState;
00056                         return;
00057                 } else if (opType >= 220 && opType <= 222) {
00058                         ptrPF = &ControlParser::parseOpData;
00059                         return;
00060                 }
00061         }
00062         parseError(tok);
00063 }
00064 
00065 
00066 void ControlParser::parseOpState(Token& tok)
00067 {
00068         if (tok.type == Token::STRING) {
00069                 if (strncmp(strPending, tok.p, tok.len)==0) {
00070                         Operation *p = opool.alloc();
00071                         if (p) {
00072                                 p->identifier = op.identifier;
00073                                 p->state = OPERATION_EXECUTING;
00074                                 opool.put(p);
00075                         }
00076                         ptrPF = &ControlParser::parseOpType;
00077                         return;
00078                 }
00079         }
00080         parseError(tok);
00081 }
00082 
00083 
00084 void ControlParser::parseOpType(Token& tok)
00085 {
00086         if (tok.type == Token::INT) {
00087                 sscanf(tok.p, "%hu", &opType);
00088                 if (opType >= 220 && opType <= 222) {
00089                         ptrPF = &ControlParser::parseRowNumber;
00090                         return;
00091                 }
00092         }
00093         parseError(tok);
00094 }
00095 
00096 
00097 void ControlParser::parseOpData(Token& tok)
00098 {
00099         bool ret = true;
00100         if (opType == 220) {
00101                 if (strncmp("CLOSED", tok.p, tok.len) == 0) {
00102                         closeRelay();
00103                 } else if (strncmp("OPEN", tok.p, tok.len) == 0) {
00104                         openRelay();
00105                 } else {
00106                         aError("Relay op (%.*s)\n", (int)tok.len, tok.p);
00107                         ret = false;
00108                 }
00109         } else if (opType == 221) {
00110                 char line[30] = {0};
00111                 size_t num = tok.len < 30 ? tok.len : 30;
00112                 if (tok.type == Token::STRING)
00113                         strncpyEscape(line, tok.p, num);
00114                 else if (tok.type != Token::NONE)
00115                         strncpy(line, tok.p, num);
00116                 LCDDisplay::inst().setFirstLine(line);
00117         } else if (opType == 222) {
00118                 char config[128] = {0};
00119                 size_t num = tok.len < 127 ? tok.len : 127;
00120                 strncpy(config, tok.p, num);
00121                 ret = ConfigSync::inst().updateConfiguration(config);
00122         } else {
00123                 parseError(tok);
00124                 return;
00125         }
00126         Operation *p = opool.alloc();
00127         if (p) {
00128                 p->identifier = op.identifier;
00129                 p->state = ret ? OPERATION_SUCCESSFUL : OPERATION_FAILED;
00130                 opool.put(p);
00131         }
00132         ptrPF = &ControlParser::parseGetOpOrBayeuxAdvice;
00133 }
00134 
00135 
00136 void ControlParser::parseGetOpOrBayeuxAdvice(Token& tok)
00137 {
00138         if (strncmp("211", tok.p, tok.len) == 0) {
00139                 parseGetOp(tok);
00140         } else if (strncmp("86", tok.p, tok.len) == 0) {
00141                 parseBayeuxAdvice(tok);
00142         } else {
00143                 parseError(tok);
00144         }
00145 }
00146 
00147 
00148 void ControlParser::parseBayeuxAdvice(Token& tok)
00149 {
00150         if (strncmp("86", tok.p, tok.len) == 0) {
00151                 opType = 86;
00152                 ptrPF = &ControlParser::parseRowNumber;
00153         } else {
00154                 parseError(tok);
00155         }
00156 }
00157 
00158 
00159 void ControlParser::parseAdviceTimeout(Token& tok)
00160 {
00161         if (tok.type == Token::NONE) {
00162                 bayeuxTimeout = -1;
00163                 ptrPF = &ControlParser::parseAdviceInterval;
00164         } else if (tok.type == Token::INT) {
00165                 sscanf(tok.p, "%d", &bayeuxTimeout);
00166                 ptrPF = &ControlParser::parseAdviceInterval;
00167         } else {
00168                 parseError(tok);
00169         }
00170 }
00171 
00172 
00173 void ControlParser::parseAdviceInterval(Token& tok)
00174 {
00175         if (tok.type == Token::NONE) {
00176                 bayeuxInterval = 0;
00177                 ptrPF = &ControlParser::parseAdvicePolicy;
00178         } else if (tok.type == Token::INT) {
00179                 sscanf(tok.p, "%d", &bayeuxInterval);
00180                 ptrPF = &ControlParser::parseAdvicePolicy;
00181         } else {
00182                 parseError(tok);
00183         }
00184 }
00185 
00186 
00187 void ControlParser::parseAdvicePolicy(Token& tok)
00188 {
00189         if (tok.type == Token::STRING) {
00190                 if (strncmp("retry", tok.p, tok.len) == 0) {
00191                         bayeuxAdvice = BA_RETRY;
00192                 } else if (strncmp("handshake", tok.p, tok.len) == 0) {
00193                         bayeuxAdvice = BA_HANDSHAKE;
00194                 } else if (strncmp("none", tok.p, tok.len) == 0) {
00195                         bayeuxAdvice = BA_NONE;
00196                 } else {
00197                         parseError(tok);
00198                 }
00199         } else {
00200                 parseError(tok);
00201         }
00202 }
00203 
00204 
00205 void ControlParser::parseError(Token& tok)
00206 {
00207         aError("CtrlParse: %.*s[%d]\n", (int)tok.len, tok.p, tok.type);
00208         parseRecover(tok);
00209 }
00210 
00211 
00212 void ControlParser::parseRecover(Token& tok)
00213 {
00214         if (tok.type == Token::INT) {
00215                 int i = 0;
00216                 sscanf(tok.p, "%d", &i);
00217                 if (i == 211) {
00218                         parseGetOp(tok);
00219                 } else if (i >= 220 && i <= 222) {
00220                         parseOpType(tok);
00221                 } else if (i == 86) {
00222                         parseBayeuxAdvice(tok);
00223                 } else {
00224                         ptrPF = &ControlParser::parseRecover;
00225                 }
00226         } else {
00227                 ptrPF = &ControlParser::parseRecover;
00228         }
00229 }