Diff: SnCommAfar.cpp

Revision:

3:24c5f0f50bf1

Parent:

2:e67f7c158087

Child:

4:a91682e19d6b

--- a/SnCommAfar.cpp	Tue Jul 24 02:07:23 2012 +0000
+++ b/SnCommAfar.cpp	Tue Jul 31 04:59:16 2012 +0000
@@ -40,8 +40,6 @@
                                                  const SnConfigFrame& conf,
                                                  const SnEventFrame& evt,
                                                  char* const genBuf) {
-    // timer = timer for full window
-    // timeout = number of seconds to try to connect (not full window)
     
     const bool canCon = Connect(timeout);
     
@@ -55,10 +53,32 @@
     return ret;
 }
 
+SnCommWin::ECommWinResult SnCommAfar::WaitHandshake(const uint32_t timeout,
+                                                    char* const buf,
+                                                    const uint32_t bsize) {
+    printf("WaitHandshake, to=%u\r\n",timeout);
+    
+    uint32_t mlen=0; // this message length
+    const bool rd = GetWS().read(buf, mlen, bsize, timeout, fB64buf, fbblen);
+    if (rd) {
+        uint32_t msgLen=0;
+        uint8_t  msgCode=0;
+        const char* b = buf;
+        SnHeaderFrame::ReadFrom(b, msgCode, msgLen);
+        if (msgCode==SnHeaderFrame::kHandshakeCode) {
+            return SnCommWin::kOkWithMsg;
+        } else {
+            // TODO: somehow handle unexpected message?
+            return SnCommWin::kUnexpectedRec;
+        }
+    }
+    return SnCommWin::kOkNoMsg;
+}
 
 SnCommWin::ECommWinResult SnCommAfar::GetConfig(SnConfigFrame& conf,
                                                 const uint32_t timeOut,
-                                                char* const confBuf) {
+                                                char* const confBuf,
+                                                const uint32_t bsize) {
     // confBuf assumed to alread be of allocated size
     
     printf("GetConfig, to=%u\r\n",timeOut);
@@ -73,16 +93,23 @@
     const char* b = confBuf;
     while ( (redConf==false) && (time(0) < timeOut) ) {
         uint32_t msglen=0; // this message length
-        redConf = GetWS().read(confBuf+mread, msglen, timeOut);
+        redConf = GetWS().read(confBuf+mread, msglen, bsize, timeOut, fB64buf, fbblen);
         mread += msglen;
         if (redConf) {
             if (readHeader && mread>=SnHeaderFrame::SizeOf()) {
+                printf("read head from %x\r\n",b);
                 SnHeaderFrame::ReadFrom(b, mcode, mlen);
                 // TODO: check that mcode is kConfigCode? What to do if not?
+                printf("mcode=%02x, mlen=%u\r\n", mcode, mlen);
                 readHeader=false;
             }
-            if (mread>=mlen) {
+            printf("mread=%u, mlen=%u\r\n", mread, mlen);
+            if (readHeader==false &&
+                 ((mread-SnHeaderFrame::SizeOf())>=mlen)) {
+                printf("read config from %x\r\n",b);
                 conf.ReadFrom(b);
+                printf("after read conf, b=%x (%d)\r\n",
+                    b, int(b-confBuf));
                 res = SnCommWin::kOkWithMsg;
             } else {
                 redConf=false;
@@ -101,7 +128,9 @@
                                                  char* const genBuf) {
     // TODO: check if connected?
     const uint32_t ssize = SnStatusFrame::SizeOf(conf);
-    SnStatusFrame::WriteTo(genBuf, SnConfigFrame::kAfar, conf, evt, genBuf);
+    char* b = genBuf;
+    SnHeaderFrame::WriteTo(b, SnHeaderFrame::kStatusCode, ssize);
+    SnStatusFrame::WriteTo(b, SnConfigFrame::kAfar, conf, evt, genBuf);
 #ifdef DEBUG
     printf("status frame:\r\n");
     for (uint32_t i=0; i<msize; i++) {
@@ -110,14 +139,24 @@
     printf("\r\n");
 #endif
     const bool ok = GetWS().sendBinary(
-        SnHeaderFrame::GetHdBuf(SnHeaderFrame::kStatusCode, ssize),
-        SnHeaderFrame::SizeOf(),
-        genBuf, ssize);
+        genBuf, b-genBuf, fB64buf);
     printf("status sent\r\n");
     return ok ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
 }
 
+SnCommWin::ECommWinResult SnCommAfar::SendFilename(const char* fn, char* const genBuf) {
+    printf("afar send filename %s\r\n",fn);
+    const size_t flen = strlen(fn);
+    char* b = genBuf;
+    SnHeaderFrame::WriteTo(b, SnHeaderFrame::kFilenameCode, flen);
+    sprintf(b, "%s", fn);
+    const bool ok = GetWS().sendBinary(
+        genBuf, SnHeaderFrame::SizeOf()+flen, fB64buf);
+    return ok ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
+}
+
 SnCommWin::ECommWinResult SnCommAfar::SendData(FILE* inf) {
+    printf("afar send whole file\r\n");
     fseek(inf, 0, SEEK_END);
     const int32_t fsize = ftell(inf);
     fseek(inf, 0, SEEK_SET);
@@ -128,7 +167,8 @@
         const bool ok = GetWS().sendBinary(
             SnHeaderFrame::GetHdBuf(SnHeaderFrame::kFileCode, fsize),
             SnHeaderFrame::SizeOf(),
-            inf, fsize);
+            inf, fsize,
+            fB64buf);
         return ok ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
     }
 }
@@ -139,10 +179,18 @@
                                                     char* const genBuf,
                                                     const uint32_t nevts,
                                                     const uint32_t firstEvt) {
+    printf("afar send conf and events\r\n");
     // firstEvt==0 ==> start at beginning
     // nevts==0 ==> NO events! (see SnCommWin::SendData
     //    for the fcn to send the full file)
-
+    
+    const int fpos = ftell(inf);
+    if (fpos>0) {
+        fseek(inf, 0, SEEK_SET);
+    }
+    
+    printf("fpos=%d\r\n",fpos);
+    
     // TODO: check memory for temporary config/event frames?
     uint64_t macadr;
     uint32_t run;
@@ -162,41 +210,66 @@
     // 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);
+    
+    printf("repack=%d, esize=%u\r\n",(int)repack,esize);
     
     // send the header and conf
     char* b = genBuf;
+    SnHeaderFrame::WriteTo(b, SnHeaderFrame::kConfAndEvtsCode, conf.SizeOf());
     conf.WriteTo(b);
+    
     bool ok  = GetWS().sendBinary(
-        SnHeaderFrame::GetHdBuf(SnHeaderFrame::kConfAndEvtsCode,
-                                conf.SizeOf()),
-        SnHeaderFrame::SizeOf(),
-        genBuf, conf.SizeOf());
+        genBuf, conf.SizeOf()+SnHeaderFrame::SizeOf(),
+        fB64buf);
+    
+    printf("ok=%d, nevts=%u\r\n",(int)ok,nevts);
     
     // size of event sent over afar
     const uint32_t ssize = (repack) ?
         SnEventFrame::SizeOf(sLoseLSB, sLoseMSB) :
         esize;
     
+    // move up to first event
+    if (firstEvt>0) {
+        printf("skip ahead %d\r\n",firstEvt*esize);
+        fseek(inf, (firstEvt*esize), SEEK_CUR);
+    }
+    
+    // get file size
+    const int fcur = ftell(inf);
+    fseek(inf, 0, SEEK_END);
+    const int fend = ftell(inf);
+    fseek(inf, fcur, SEEK_SET);
+    
     for (uint32_t i=0; (i<nevts) && ok; i++) {
-        if (repack) {
-            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);
+        if (feof(inf)==0 && ferror(inf)==0 && ((ftell(inf)+ssize)<=fend)) {
+            printf("sending evt %u\r\n",i);
+            if (repack) {
+                evt.ReadFrom(inf, genBuf,
+                    conf.GetWvLoseLSB(), conf.GetWvLoseMSB(),
+                    conf.GetWvBaseline());
+                // must be after evt.Read, since that uses the buffer
+                b = genBuf;
+                SnHeaderFrame::WriteTo(b, SnHeaderFrame::kEventCode, ssize);
+                evt.WriteTo(b, sLoseLSB, sLoseMSB, sWvBase);
+                ok &= GetWS().sendBinary(
+                    genBuf, ssize+SnHeaderFrame::SizeOf(),
+                    fB64buf);
+            } else {
+                ok &= GetWS().sendBinary(
+                    SnHeaderFrame::GetHdBuf(SnHeaderFrame::kEventCode,
+                                            ssize),
+                    SnHeaderFrame::SizeOf(),
+                    inf, ssize,
+                    fB64buf);
+            }
         } else {
-            ok &= GetWS().sendBinary(
-                SnHeaderFrame::GetHdBuf(SnHeaderFrame::kEventCode,
-                                        ssize),
-                SnHeaderFrame::SizeOf(),
-                inf, ssize);
+            printf("cannot send requested event\r\n");
+            ok=false;
         }
     }
+    
+    fseek(inf, fpos, SEEK_SET);
+    
     return ok ? SnCommWin::kOkMsgSent : SnCommWin::kFailPartSent;
 }