Diff: SnCommAfar.cpp

Revision:

2:e67f7c158087

Parent:

1:e392595b4b76

Child:

3:24c5f0f50bf1

--- a/SnCommAfar.cpp	Fri Jul 20 19:04:02 2012 +0000
+++ b/SnCommAfar.cpp	Tue Jul 24 02:07:23 2012 +0000
@@ -4,13 +4,15 @@
 #include "SnConfigFrame.h"
 #include "SnEventFrame.h"
 #include "SnStatusFrame.h"
+#include "SnHeaderFrame.h"
+#include "SnSDUtils.h"
 
 Websocket& SnCommAfar::GetWS() {
     // only one make one socket
     //static Websocket* ws = new Websocket("ws://snowflake.ps.uci.edu:6767/ws");
     // TODO: fix DNS
     // TODO: remove hardcoded IP addresses from Websocket.cpp
-    static Websocket* ws = new Websocket("ws://128.195.204.151:6767/ws");
+    static Websocket* ws = new Websocket("ws://128.195.204.151:6776/ws");
     return *ws;
 }
 
@@ -37,8 +39,7 @@
                                                  const bool sendStatus,
                                                  const SnConfigFrame& conf,
                                                  const SnEventFrame& evt,
-                                                 char* const evtBuf,
-                                                 char* const statBuf) {
+                                                 char* const genBuf) {
     // timer = timer for full window
     // timeout = number of seconds to try to connect (not full window)
     
@@ -48,7 +49,7 @@
                                            : SnCommWin::kCanNotConnect;
     
     if (canCon && sendStatus) {
-        ret = SendStatus(conf, evt, evtBuf, statBuf);
+        ret = SendStatus(conf, evt, genBuf);
     }
     
     return ret;
@@ -64,18 +65,31 @@
     
     SnCommWin::ECommWinResult res = SnCommWin::kUndefFail;
     
-    bool readConf = false;
-    while ( (readConf==false) && (time(0) < timeOut) ) {
-        //printf("trying to read config\r\n");
-        // TODO: check if read works (for binary)
-        readConf = GetWS().read(confBuf, timeOut);
-        if (readConf) {
-            const char* b = confBuf;
-            conf.ReadFrom(b);
-            res = SnCommWin::kOkWithMsg;
+    bool redConf = false; 
+    bool readHeader = true;
+    uint8_t mcode=0x0;
+    uint32_t mlen=0; // length of message specified in header
+    uint32_t mread=0; // length of messages received so far
+    const char* b = confBuf;
+    while ( (redConf==false) && (time(0) < timeOut) ) {
+        uint32_t msglen=0; // this message length
+        redConf = GetWS().read(confBuf+mread, msglen, timeOut);
+        mread += msglen;
+        if (redConf) {
+            if (readHeader && mread>=SnHeaderFrame::SizeOf()) {
+                SnHeaderFrame::ReadFrom(b, mcode, mlen);
+                // TODO: check that mcode is kConfigCode? What to do if not?
+                readHeader=false;
+            }
+            if (mread>=mlen) {
+                conf.ReadFrom(b);
+                res = SnCommWin::kOkWithMsg;
+            } else {
+                redConf=false;
+            }
         }
     }
-    if (readConf==false) {
+    if (redConf==false) {
         res = SnCommWin::kOkNoMsg;
     }
 
@@ -84,78 +98,104 @@
 
 SnCommWin::ECommWinResult SnCommAfar::SendStatus(const SnConfigFrame& conf,
                                                  const SnEventFrame& evt,
-                                                 char* const evtBuf,
-                                                 char* const statBuf) {
+                                                 char* const genBuf) {
     // TODO: check if connected?
-    SnStatusFrame::WriteTo(statBuf, SnConfigFrame::kAfar, conf, evt, evtBuf);
+    const uint32_t ssize = SnStatusFrame::SizeOf(conf);
+    SnStatusFrame::WriteTo(genBuf, SnConfigFrame::kAfar, conf, evt, genBuf);
 #ifdef DEBUG
     printf("status frame:\r\n");
-    for (uint32_t i=0; i<SnStatusFrame::SizeOf(conf); i++) {
-        printf("%02X ",statBuf[i]);
+    for (uint32_t i=0; i<msize; i++) {
+        printf("%02X ",genBuf[i]);
     }
     printf("\r\n");
 #endif
-    GetWS().sendBinary(statBuf, SnStatusFrame::SizeOf(conf));
-    //base64enc(statBuf, SnStatusFrame::SizeOf(conf), gB64Buf);
-    //GetWS().send(gB64Buf);
+    const bool ok = GetWS().sendBinary(
+        SnHeaderFrame::GetHdBuf(SnHeaderFrame::kStatusCode, ssize),
+        SnHeaderFrame::SizeOf(),
+        genBuf, ssize);
     printf("status sent\r\n");
-    return SnCommWin::kOkMsgSent;
+    return ok ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
 }
 
 SnCommWin::ECommWinResult SnCommAfar::SendData(FILE* inf) {
     fseek(inf, 0, SEEK_END);
-    const uint32_t fsize = ftell(inf);
+    const int32_t fsize = ftell(inf);
     fseek(inf, 0, SEEK_SET);
-    const bool ok = GetWS().sendBinary(inf, fsize);
-    return ok ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
+    if (fsize<0) {
+        return SnCommWin::kFailNoneSent;
+    } else {
+        // send file data with header
+        const bool ok = GetWS().sendBinary(
+            SnHeaderFrame::GetHdBuf(SnHeaderFrame::kFileCode, fsize),
+            SnHeaderFrame::SizeOf(),
+            inf, fsize);
+        return ok ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
+    }
 }
 
 SnCommWin::ECommWinResult SnCommAfar::SendConfAndEvents(FILE* inf,
                                                     const SnConfigFrame& curConf,
                                                     SnEventFrame& evt,
-                                                    char* const evtBuf,
-                                                    char* const confBuf,
+                                                    char* const genBuf,
                                                     const uint32_t nevts,
                                                     const uint32_t firstEvt) {
     // firstEvt==0 ==> start at beginning
     // nevts==0 ==> NO events! (see SnCommWin::SendData
     //    for the fcn to send the full file)
-    
+
     // TODO: check memory for temporary config/event frames?
+    uint64_t macadr;
+    uint32_t run;
+    uint16_t seq;
+    SnSDUtils::ReadFileHeader(inf, macadr, run, seq);
     SnConfigFrame conf;
     conf.ReadFrom(inf);
-    char* b = confBuf;
+    
+    uint8_t sLoseLSB=0, sLoseMSB=0;
+    uint16_t sWvBase=0;
+    curConf.GetPackParsFor(SnConfigFrame::kAfar, sLoseLSB, sLoseMSB, sWvBase);
+    // do we have to unpack & repack events?
+    const bool repack =    (sLoseLSB != conf.GetWvLoseLSB())
+                        && (sLoseMSB != conf.GetWvLoseMSB())
+                        && (sWvBase  != conf.GetWvBaseline());
+    
+    // size of event in file
+    const uint32_t esize = SnEventFrame::SizeOf(conf.GetWvLoseLSB(),
+                                                conf.GetWvLoseMSB());
+    // move up to first event
+    fseek(inf, conf.SizeOf() + (firstEvt*esize), SEEK_SET);
+    
+    // send the header and conf
+    char* b = genBuf;
     conf.WriteTo(b);
-    bool ok = GetWS().sendBinary(confBuf, conf.SizeOf());
-
-    if (ok) {
-        uint8_t sLoseLSB=0, sLoseMSB=0;
-        uint16_t sWvBase=0;
-        conf.GetPackParsFor(SnConfigFrame::kAfar, sLoseLSB, sLoseMSB, sWvBase);
-        // do we have to unpack & repack events?
-        const bool repack =    (sLoseLSB != conf.GetWvLoseLSB())
-                            && (sLoseMSB != conf.GetWvLoseMSB())
-                            && (sWvBase  != conf.GetWvBaseline());
-        
-        // size of event in file
-        const uint32_t esize = SnEventFrame::SizeOf(conf.GetWvLoseLSB(),
-                                                    conf.GetWvLoseMSB());
-        // move up to first event
-        fseek(inf, conf.SizeOf() + (firstEvt*esize), SEEK_SET);
+    bool ok  = GetWS().sendBinary(
+        SnHeaderFrame::GetHdBuf(SnHeaderFrame::kConfAndEvtsCode,
+                                conf.SizeOf()),
+        SnHeaderFrame::SizeOf(),
+        genBuf, conf.SizeOf());
+    
+    // size of event sent over afar
+    const uint32_t ssize = (repack) ?
+        SnEventFrame::SizeOf(sLoseLSB, sLoseMSB) :
+        esize;
+    
+    for (uint32_t i=0; (i<nevts) && ok; i++) {
         if (repack) {
-            // repack ==> send event by event
-            // size of event sent over afar
-            const uint32_t ssize = SnEventFrame::SizeOf(sLoseLSB, sLoseMSB);
-            for (uint32_t i=0; (i<nevts) && ok; i++) {
-                evt.ReadFrom(inf, evtBuf,
-                    conf.GetWvLoseLSB(), conf.GetWvLoseMSB(),
-                    conf.GetWvBaseline());
-                evt.WriteTo(evtBuf, sLoseLSB, sLoseMSB, sWvBase);
-                ok = GetWS().sendBinary(evtBuf, ssize);
-            }
+            evt.ReadFrom(inf, genBuf,
+                conf.GetWvLoseLSB(), conf.GetWvLoseMSB(),
+                conf.GetWvBaseline());
+            evt.WriteTo(genBuf, sLoseLSB, sLoseMSB, sWvBase);
+            ok &= GetWS().sendBinary(
+                SnHeaderFrame::GetHdBuf(SnHeaderFrame::kEventCode,
+                                        ssize),
+                SnHeaderFrame::SizeOf(),
+                genBuf, ssize);
         } else {
-            // no repacking ==> just send the bytes from the file
-            ok = GetWS().sendBinary(inf, nevts*esize);
+            ok &= GetWS().sendBinary(
+                SnHeaderFrame::GetHdBuf(SnHeaderFrame::kEventCode,
+                                        ssize),
+                SnHeaderFrame::SizeOf(),
+                inf, ssize);
         }
     }
     return ok ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;