Web Server

Revision 33:41ac99847df8, committed 2014-01-03

Comitter:

WiredHome

Date:

Fri Jan 03 19:57:31 2014 +0000

Parent:

32:34dae3cae1b0

Child:

34:77d0f63f612a

Child:

35:87d3577800dc

Commit message:

Ongoing changes are working on supporting file upload.

Changed in this revision

--- a/Credentials.cpp	Thu Nov 28 18:22:32 2013 +0000
+++ b/Credentials.cpp	Fri Jan 03 19:57:31 2014 +0000
@@ -22,11 +22,11 @@
 {
     FILE *fp = fopen(file, "r");
 
-    cr->ssid = (char *)malloc(CREDENTIAL_SIZE);
-    cr->pass = (char *)malloc(CREDENTIAL_SIZE);
+    cr->ssid = (char *)malloc(SSID_SIZE);
+    cr->pass = (char *)malloc(PASS_SIZE);
     if (fp) {
-        fgets(cr->ssid, CREDENTIAL_SIZE, fp);
-        fgets(cr->pass, CREDENTIAL_SIZE, fp);
+        fgets(cr->ssid, SSID_SIZE, fp);     // Trusts that the sizes were not violated
+        fgets(cr->pass, PASS_SIZE, fp);
         fclose(fp);
         RTrim(cr->ssid);
         RTrim(cr->pass);
@@ -39,9 +39,11 @@
 void FreeCredentials(credentials * cr)
 {
     // first secure them by wiping them out
-    for (int i=0; i<CREDENTIAL_SIZE; i++) {
-        cr->ssid[i] = cr->pass[i] = '*';
-    }
+    for (int i=0; i<SSID_SIZE; i++)
+        cr->ssid[i] = '*';
+    for (int i=0; i<PASS_SIZE; i++)
+        cr->pass[i] = '*';
+    
     // then free the memory
     free(cr->ssid);
     free(cr->pass);

--- a/Credentials.h	Thu Nov 28 18:22:32 2013 +0000
+++ b/Credentials.h	Fri Jan 03 19:57:31 2014 +0000
@@ -15,7 +15,9 @@
     char * pass;
 } credentials;
 
-#define CREDENTIAL_SIZE 50
+// Size changed (from 50 for both) to comply with WiFi Specifications
+#define SSID_SIZE 30
+#define PASS_SIZE 64
 
 /** Read credentials from a file.
 *

--- a/Examples/DynamicFileIn.cpp	Thu Nov 28 18:22:32 2013 +0000
+++ b/Examples/DynamicFileIn.cpp	Fri Jan 03 19:57:31 2014 +0000
@@ -1,37 +1,267 @@
 /// Demonstration of dynamic page creation using the Smartware Web Server
 ///
 /// Here is a sample for file upload.
-
 #include "SW_HTTPServer.h"
 #include "DynamicFileIn.h"
+
+#define DEBUG "File"
 #include "Utility.h"
 
+// This defines the size of the largest file you are willing to accept
+//
+#define ACCEPT_MAX_BYTES (25000)
+
+// This defines the local cache, which should be about 2 x the size of a single chunk hand-off
+// which is based on the size of an ethernet data frame (~1500 bytes). So 2 x 1500 is a good number.
+#define ETHER_CHUNK (1500)
+#define PCACHE_SIZE (3000)
+#define MAX_BOUNDARY_LEN (150)      // Seems very generous...
+static int bytesInCache;
+static char * pCache;
+static char * boundary = "";        // for pointing at the boundary marker part of multipart/form-data in pCache
+static char * fqfn = NULL;          // for the filepath/filename
+static char * contenttype = NULL;   // for "text/plain", or "image/bmp"
+static int bytesWritten;
+
+static int FileSize(const char * dir, const char * filename);
+static char _tolower(char c);
+static int _strnicmp(const char * left, const char * right, int len);
+static char * _stristr(char * pHaystack, const char * pNeedle);
+static char * _strnbin(char * pBinstack, const char *pNeedle, int len);
+
 typedef enum {
     IDLE,
     ACCEPTED,
     REJECTED_TOO_LARGE
 } AcceptStatus;
 
+//
+//-----------------------------7de3ab1652086c
+//Content-Disposition: form-data; name="InFile"; filename="Len0700.txt"
+//Content-Type: text/plain
+//
+//__1 - _50 12345678901234567890123456789012345678
+//_51 - 100 12345678901234567890123456789012345678
+//101 - 150 12345678901234567890123456789012345678
+//151 - 200 12345678901234567890123456789012345678
+//201 - 250 12345678901234567890123456789012345678
+//251 - 300 12345678901234567890123456789012345678
+//301 - 350 12345678901234567890123456789012345678
+//351 - 400 12345678901234567890123456789012345678
+//401 - 450 12345678901234567890123456789012345678
+//451 - 500 12345678901234567890123456789012345678
+//501 - 550 12345678901234567890123456789012345678
+//551 - 600 12345678901234567890123456789012345678
+//601 - 650 12345678901234567890123456789012345678
+//651 - 700 12345678901234567890123456789012345678
+//
+//-----------------------------7de3ab1652086c--
+//^^ Boundary Definition                     ^^ Boundary Definition
+//   is appended to "--"                        is suffixed "--" indicating the end.
+//---
+//Content-Disposition: form-data; name="InFile"; filename="somefile.txt"\r\n
+//Content-Type: image/bmp\r\n
+//\r\n
+//BM6.... (where the ... is purely binary data data)
+//\r\n------webKitFormBoundary9A3C872FAC9BE23--\r\n
+//---
+//
+HTTPServer::CallBackResults ProcessCache(HTTPServer *svr, HTTPServer::CallBackType type)
+{
+    typedef enum {
+        Seeking_Boundary_Start,
+        Seeking_Filename,
+        Seeking_ContentType,
+        Seeking_Data
+    } EF_State_E;
+    static EF_State_E EF_State = Seeking_Boundary_Start;
+    static FILE * fp = NULL;
+
+    char * pDataStart = pCache;                 // start of data in this transaction
+    char * pDataEnd = pCache + bytesInCache;    // end of data in this transaction
+    char * pDBLcrlf;
+    char *p1, *p2, *p3;                         // general purpose pointer for processing the results
+    HTTPServer::CallBackResults ret = HTTPServer::ACCEPT_CONTINUE;
+
+    INFO("### Cache Begin\r\n%s\r\n### Cache End", pCache);
+    if (EF_State == Seeking_Boundary_Start) {
+        pDBLcrlf = _strnbin((char *)pDataStart, "\r\n\r\n", pDataEnd - pDataStart);    // find end of preamble
+        if (pDBLcrlf) {
+            p1 = _strnbin((char *)pDataStart, boundary, pDBLcrlf - pDataStart);   // is there a boundary in the cache?
+            if (p1) {
+                EF_State = Seeking_Filename;
+            }
+        }
+    }
+    
+    if (EF_State == Seeking_Filename) {
+        pDBLcrlf = _strnbin((char *)pDataStart, "\r\n\r\n", pDataEnd - pDataStart);    // find end of preamble
+        if (pDBLcrlf) {
+            p2 = _strnbin((char *)pDataStart, "Content-Disposition: ", pDBLcrlf - pDataStart);   // and the filename container?
+            if (p2) {
+                p2 = _strnbin((char *)p2, "filename=\"", pDBLcrlf - pDataStart);
+                if (p2) {   // found filename
+                    p2 += strlen("filename=\"");    // start of filename
+                    p3 = strchr(p2, '"');           // end of filename
+                    if (p3) {
+                        *p3 = '\0';
+                        fqfn = (char *)malloc(p3-p2 + strlen(svr->GetWebRoot())+2);
+                        if (fqfn) {
+                            strcpy(fqfn, svr->GetWebRoot());     // We could put it elsewhere
+                            strcat(fqfn, "/");
+                            strcat(fqfn, p2);
+                            *p3 = '"';              // Put this back so we can print the cache
+                            EF_State = Seeking_ContentType;
+                            pDataStart = p3 + 1;
+                        } else {
+                            ERR("Failed to allocate space for filename");
+                            ret = HTTPServer::ACCEPT_ERROR;
+                            EF_State = Seeking_Boundary_Start;
+                            bytesInCache = 0;
+                            return ret;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    if (EF_State == Seeking_ContentType) {
+        pDBLcrlf = _strnbin((char *)pDataStart, "\r\n\r\n", pDataEnd - pDataStart);    // find end of preamble
+        if (pDBLcrlf) {
+            p2 = _strnbin((char *)pDataStart, "Content-Type: ", pDBLcrlf - pDataStart);
+            if (p2) {
+                p2 += strlen("Content-Type: ");
+                p3 = strchr(p2, '\r');
+                if (p3) {
+                    *p3 = '\0';
+                    contenttype = (char *)malloc(p3-p2 + 2);
+                    if (contenttype) {
+                        strcpy(contenttype, p2);
+                        *p3 = '\r';             // put it back so we can print the cache
+                    } else {
+                        ERR("Failed to allocate space for content type");
+                        ret = HTTPServer::ACCEPT_ERROR;
+                        EF_State = Seeking_Boundary_Start;
+                        bytesInCache = 0;
+                        return ret;
+                    }
+                    pDataStart = pDBLcrlf + 4;  // Advance to the actual data
+                    EF_State = Seeking_Data;
+                }
+            }
+        }
+    }
+    
+    if (EF_State == Seeking_Data) {
+        if (!fp && fqfn) {
+            //INFO("Open file [%s]", fqfn);
+            fp = fopen(fqfn, "w");
+            if (!fp) {
+                ERR("failed to open [%s]", fqfn);
+                free(fqfn);
+                fqfn = NULL;
+                if (contenttype) {
+                    free(contenttype);
+                    contenttype = NULL;
+                }
+                ret = HTTPServer::ACCEPT_ERROR;
+                return ret;
+            }
+        }
+        if (fp) {
+            Timer t;
+            // The file is open, so we're writing data to it. 
+            // We do this until we find the ending boundary, but we may not have the [whole]
+            // ending boundary in the cache yet.
+            p1 = _strnbin((char *)pDataStart, boundary, pDataEnd - pDataStart);   // is there a boundary in the cache?
+            if (p1) {       // if we find the ending boundary, we can truncate and write the data ahead of the boundary
+                p1 -= 4;    // Actual ending boundary is "\r\n--" + "boundary" + "--", so back up 4.
+                *p1 = '\0';
+                pDataEnd = p1;
+                if (pDataEnd > pDataStart) {
+                    bytesWritten += pDataEnd - pDataStart;
+                    t.start();
+                    fwrite(pDataStart, 1, pDataEnd - pDataStart, fp);
+                    INFO("Writing %5d bytes, %5d total written, (reserve %d) in %d us", 
+                        pDataEnd - pDataStart, bytesWritten, 0, t.read_us());
+                    //INFO("Write: %s***", pDataStart);
+                    bytesInCache = 0;
+                    *pCache = '\0';         // this for debugging in case it is text and you want to print it.
+                } else {
+                    INFO("Not enough data to write (%d <= %d)", pDataEnd, pDataStart);
+                }
+            } else {  // didn't find the boundary, but it might be partially there...
+                // write the data, but not the last (strlen(boundary) + 4) 
+                // in case this transaction has some, but not all of the boundary
+                int reserve = strlen(boundary) + 4;
+                pDataEnd -= reserve;
+                if (pDataEnd > pDataStart) {
+                    bytesWritten += pDataEnd - pDataStart;
+                    t.start();
+                    fwrite(pDataStart, 1, pDataEnd - pDataStart, fp);
+                    INFO("Writing %5d bytes, %5d total written, (reserve %d) in %d us", 
+                        pDataEnd - pDataStart, bytesWritten, reserve, t.read_us());
+                    //INFO("Write: %s###", pDataStart);
+                    memcpy(pCache, pDataEnd, reserve+1);    // copies the trailing '\0'
+                    bytesInCache = reserve;
+                    //*(pCache + bytesInCache) = '\0';
+                    INFO("remaining: %s", pCache);
+                } else {
+                    INFO("Not enough data to write (%d <= %d)", pDataEnd, pDataStart);
+                }
+            }
+            ret = HTTPServer::ACCEPT_CONTINUE;
+        }
+    }
+
+    if (type == HTTPServer::DATA_TRANSFER_END) {
+        if (fp) {
+            fclose(fp);
+            fp = NULL;
+            if (fqfn) {
+                free(fqfn);
+                fqfn = NULL;
+            }
+            if (contenttype) {
+                free(contenttype);
+                contenttype = NULL;
+            }
+        }
+        if (pCache) {
+            //INFO("pCache - freed");
+            free(pCache);
+            pCache = NULL;
+            bytesInCache = 0;
+        }
+        ret = HTTPServer::ACCEPT_COMPLETE;
+    }
+    return ret;
+}
+
+
+
 /// DynamicFileIn
 ///
 /// This page lets you submit a file.
 ///
 /// You can see in main how this page was registered.
 ///
-HTTPServer::CallBackResults DynamicFileIn(HTTPServer *svr, HTTPServer::CallBackType type, const char * path, const HTTPServer::namevalue *params, int paramcount)
+HTTPServer::CallBackResults DynamicFileIn(
+    HTTPServer *svr,
+    HTTPServer::CallBackType type,
+    const char * path,
+    const HTTPServer::namevalue *params,
+    int count)
 {
     char buf[100];
     int clSize;     // content-length size to be transferred
-    char * p1;      // general purpose pointer for processing the results
-    char * p2;      // general purpose pointer for processing the results
-    static char * boundary = "";    // for pointing at the boundary marker part of multipart/form-data
     static AcceptStatus accept = IDLE;
     HTTPServer::CallBackResults ret = HTTPServer::ACCEPT_ERROR;
     DIR *d;
     struct dirent *p;
 
     switch (type) {
-    
         case HTTPServer::CONTENT_LENGTH_REQUEST:
             // Here we can find out how much data is headed our way,
             // and choose to accept or reject it.
@@ -41,84 +271,71 @@
             // also, for the multipart data, we have to learn and track
             // the boundary sequence, so we can parse the big block
             // successfully.
-            boundary = strstr((char *)svr->GetHeaderValue("Content-Type"), "boundary=");
+            boundary = _stristr((char *)svr->GetHeaderValue("Content-Type"), "boundary=");
             if (boundary)
                 boundary += strlen("boundary=");
+            //INFO("C-Len: %d, boundary: [%s]", clSize, boundary);
             //printf("InFile = [%s]\r\n", svr->GetHeaderValue("InFile"));
             // If we're happy with the size, and we have the boundary marker we need
-            if (clSize < 3000 && boundary) {    // arbitrarily chosen size to accept
-                accept = ACCEPTED;
-                ret = HTTPServer::ACCEPT_COMPLETE;
+            if (clSize < ACCEPT_MAX_BYTES && boundary) {
+                pCache = (char *)malloc(PCACHE_SIZE);
+                if (pCache) {
+                    //INFO("pCache - allocated");
+                    bytesInCache = 0;
+                    accept = ACCEPTED;
+                    ret = HTTPServer::ACCEPT_COMPLETE;
+                } else {
+                    accept = REJECTED_TOO_LARGE;    // can't get the RAM to host the stream
+                    ret = HTTPServer::ACCEPT_ERROR;
+                }
             } else {
                 accept = REJECTED_TOO_LARGE;
             }
             break;
 
+        case HTTPServer::DATA_TRANSFER_END:
+            //INFO("\r\n\\\\\\\\\\\\ Transfer Begin [%d, %d]\r\n%s\r\n////// Transfer End", count, bytesInCache, path);
+            // if there is anything there, copy it in.
+            if (count) {
+                memcpy(pCache + bytesInCache, path, count);
+                bytesInCache += count;
+                pCache[bytesInCache] = '\0';    // one past the data, so ok (and good for debugging text streams)
+            }
+            ret = ProcessCache(svr, type);
+            break;
+
         case HTTPServer::DATA_TRANSFER:
-            // Here's the big blob of data. We've got some painful work here.
-            // The blob looks kind of like this:
-            //---
-            //Content-Disposition: form-data; name="InFile"; filename="somefile.txt"\r\n
-            //Content-Type: text/plain\r\n
-            //\r\n
-            //Text in the file starts here\r\n
-            //and continues as needed.
-            //------webKitFormBoundary9A3C872FAC9BE23--\r\n
-            //---
-            // So, we'll work our way thru by extracting the filename, we'll
-            // assume it is text/plain, as in this example.
-            // If all looks well, we'll write it to the local file system,
-            // and return true.
-            printf("Data Transfer\r\n");
-            p1 = strchr((char *)path, '\r');
-            if (p1) {
-                p2 = strstr((char *)path, "filename=\"");
-                if (p2) {
-                    p2 += strlen("filename=\"");
-                    p1 = strchr(p2, '"');
-                    if (p1) {
-                        char * fn = p2;
-                        *p1 = '\0';
-                        p1 = strstr(p1+1, "\r\n\r\n");
-                        if (p1) {
-                            p1 += 4;        // finally, sitting on the start of the file data
-                            p2 = strstr(p1, boundary);  // find the end
-                            if (p2) {
-                                // now, create the file
-                                FILE * fp;
-                                *p2 = '\0';
-                                strcpy(buf, svr->GetWebRoot());
-                                strcat(buf, "/");
-                                strcat(buf, fn);
-                                printf("Writing to [%s]\r\n", buf);
-                                fp = fopen(buf, "w");
-                                if (fp) {
-                                    printf("writing data...\r\n");
-                                    fwrite(p1, 1, p2 - p1, fp);
-                                    fclose(fp);
-                                    printf("done.\r\n");
-                                    ret = HTTPServer::ACCEPT_COMPLETE;
-                                } else {
-                                    printf("failed to open [%s]\r\n", buf);
-                                }
-                            }
-                        }
-                    }
-                }
+            //INFO("\r\n\\\\\\\\\\\\ Transfer Begin [%d, %d]\r\n%s\r\n////// Transfer End", count, bytesInCache, path);
+            // We chose to accept the transfer, and it may come in chunks.
+            if (bytesInCache + count < PCACHE_SIZE - ETHER_CHUNK) { // room in the cache for more, juat accept it locally
+                memcpy(pCache + bytesInCache, path, count);
+                bytesInCache += count;
+                pCache[bytesInCache] = '\0'; // one past the data, so ok (and good for debugging text streams)
+                ret = HTTPServer::ACCEPT_CONTINUE;
+            } else if (bytesInCache + count < PCACHE_SIZE) {        // room in the cache, now process it.
+                memcpy(pCache + bytesInCache, path, count);
+                bytesInCache += count;
+                pCache[bytesInCache] = '\0';    // one past the data, so ok (and good for debugging text streams)
+                ret = ProcessCache(svr, type);  // now hand it off
+            } else {
+                ret = ProcessCache(svr, type);  // panic, ah!, ok, first hand it off then cache it
+                memcpy(pCache + bytesInCache, path, count);
+                bytesInCache += count;
+                pCache[bytesInCache] = '\0';    // one past the data, so ok (and good for debugging text streams)
+                ERR("FATAL - didn't flush pCache, was about to be overrun");
+                break;
             }
-            ret = HTTPServer::ACCEPT_COMPLETE;
             break;
-            
+
         case HTTPServer::SEND_PAGE:
-            // send the header
-            //printf("Sending page\r\n");
             svr->header(200, "OK", svr->GetSupportedType(".htm"));
-            // send some data
             svr->send("<html><head><title>Dynamic File Submit</title></head>\r\n");
             svr->send("<body>\r\n");
             svr->send("<h1>Smart WiFly Web Server</h1>\r\n");
-            svr->send("This example permits you to upload a small file. Select the file using ");
-            svr->send("the normal form gadget and submit it.");
+            sprintf(buf, "This example permits you to upload a file of not more than %d bytes. ", ACCEPT_MAX_BYTES);
+            svr->send(buf);
+            svr->send("If the file is one of the supported types, you can then download it too. ");
+            svr->send("Select the file using the form gadget and then submit it.");
             switch(accept) {
                 case IDLE:
                 default:
@@ -131,31 +348,38 @@
                     break;
             }
             // note that to accept a file, the form enctype is multipart/form-data.
+            svr->send("<blockquote>\r\n");
             sprintf(buf, "<form method='post' enctype='multipart/form-data' action='%s'>\r\n", path);
             svr->send(buf);
-            svr->send("<table border='1'>\r\n");
-            svr->send("<tr><td>&nbsp;</td><td>File</td><td><input type='file' name='InFile' size='40'></td></tr>\r\n");
-            svr->send("<tr><td>&nbsp;</td><td colspan='2'><input type='submit' value='submit'><input type='reset' value='clear'></td></tr>\r\n");
+            svr->send("<table border='0'>\r\n");
+            svr->send("<tr><td>File</td><td><input type='file' name='InFile' size='60'></td></tr>\r\n");
+            svr->send("<tr><td>&nbsp;</td><td><input type='submit' value='Submit'><input type='reset' value='Clear'></td></tr>\r\n");
             svr->send("</table>\r\n");
             svr->send("</form>\r\n");
+            svr->send("</blockquote>\r\n");
 #if 1
-            sprintf(buf, "Directory of [%s]:<br/>\r\n", svr->GetWebRoot());
+            sprintf(buf, "<h2>Directory of [%s]:</h2>\r\n", svr->GetWebRoot());
             svr->send(buf);
             d = opendir(svr->GetWebRoot());
             if ( d != NULL ) {
+                svr->send("<ul>\r\n");
                 while ( (p = readdir(d)) != NULL ) {
-                    sprintf(buf, " - %s<br/>\r\n", p->d_name);
+                    if (svr->GetSupportedType(p->d_name) != NULL)
+                        sprintf(buf, "<li><a href='%s'>%s</a> (%d bytes)</li>\r\n", p->d_name, p->d_name, FileSize(svr->GetWebRoot(), p->d_name)); // only supported types linked
+                    else
+                        sprintf(buf, "<li>%s (%d bytes)</li>\r\n", p->d_name, FileSize(svr->GetWebRoot(), p->d_name));     // We could skip/hide these if that makes more sense
                     svr->send(buf);
                 }
+                svr->send("</ul>\r\n");
                 closedir(d);
             } else {
                 svr->send("Unable to open directory!");
             }
 #endif
-            svr->send("<br/><a href='/'>Back to main</a></body></html>\r\n");
+            svr->send("<a href='/'>Back to main</a></body></html>\r\n");
             ret = HTTPServer::ACCEPT_COMPLETE;
             break;
-            
+
         default:
             printf("unknown command %d\r\n", type);
             ret = HTTPServer::ACCEPT_ERROR;
@@ -164,4 +388,82 @@
     return ret;
 }
 
+static int FileSize(const char * dir, const char * filename)
+{
+    int size = 0;
+    char * fqfn = (char *)malloc(strlen(dir) + strlen(filename) + 2);
+    if (fqfn) {
+        strcpy(fqfn, dir);
+        strcat(fqfn, "\\");
+        strcat(fqfn, filename);
+        FILE * f = fopen(fqfn,"r");
+        if (f) {
+            fseek(f, 0, SEEK_END); // seek to end of file
+            size = ftell(f);
+            fclose(f);
+        }
+    }
+    return size;
+}
 
+// very simple ASCII only function to convert
+// UPPERCASE to lowercase.
+//
+static char _tolower(char c)
+{
+    if (c >= 'A' && c <= 'Z')
+        c = c - 'A' + 'a';
+    return c;
+}
+
+// case insensitive compare
+static int _strnicmp(const char * left, const char * right, int len)
+{
+    if (!left || !right)
+        return 0;           // actually, can't compare so this is a small lie
+    while (len) {
+        if (_tolower(*left) < _tolower(*right))
+            return -1;
+        else if (_tolower(*left) > _tolower(*right))
+            return 1;
+        left++;
+        right++;
+        len--;
+    }
+    return 0;   // match
+}
+
+// Search a haystack string for a needle string - case insensitive.
+//
+static char * _stristr(char * pHaystack, const char * pNeedle)
+{
+    if (!pHaystack || !*pHaystack || !pNeedle || !*pNeedle)
+        return NULL;    // bad params
+    while (*pHaystack) {
+        if (_strnicmp(pHaystack, pNeedle, strlen(pNeedle)) == 0)
+            return pHaystack;
+        pHaystack++;
+    }
+    return NULL;
+}
+
+// Search the [possibly] binary haystack for the Needle, which is a string.
+// This is used to find the 'boundary' marker in a stream from the network
+// interface. The contents between the boundary markers could be text, or
+// it could be a binary stream. Since the haystack could be binary, we need
+// to control the search by a length parameter.
+//
+static char * _strnbin(char * pBinstack, const char *pNeedle, int len)
+{
+    char * pLast;
+    if (!pBinstack || !pNeedle || !*pNeedle || len == 0)
+        return NULL;    // bad params
+    len -= strlen(pNeedle); // only search [most] of the haystack
+    pLast = pBinstack + len;
+    while (pBinstack <= pLast) {
+        if (_strnicmp(pBinstack, pNeedle, strlen(pNeedle)) == 0)
+            return pBinstack;
+        pBinstack++;
+    }
+    return NULL;
+}

--- a/Examples/ServerConfig.cpp	Thu Nov 28 18:22:32 2013 +0000
+++ b/Examples/ServerConfig.cpp	Fri Jan 03 19:57:31 2014 +0000
@@ -33,10 +33,10 @@
     char security[10] = "";
     char timeserver[60] = "";
     char timezone[4] = "";       // -12
-    char *securityList[] = 
-        { "NONE", "WEP_128", "WPA1", "WPA", "WPA2_PSK", "n/a", "ADHOC", "n/a", "WPE_64" };
+    //char *securityList[] = 
+    //    { "NONE", "WEP_128", "WPA1", "WPA", "WPA2_PSK", "n/a", "ADHOC", "n/a", "WPE_64" };
     INI ini("/local/config.ini");
-            
+
     switch (type) {
         case HTTPServer::SEND_PAGE:
             // svr->GetParameter("SSID");

--- a/IniManager.lib	Thu Nov 28 18:22:32 2013 +0000
+++ b/IniManager.lib	Fri Jan 03 19:57:31 2014 +0000
@@ -1,1 +1,1 @@
-http://mbed.org/users/WiredHome/code/IniManager/#c63a794c1fee
+http://mbed.org/users/WiredHome/code/IniManager/#64fcaf06b012

--- a/SW_HTTPServer.lib	Thu Nov 28 18:22:32 2013 +0000
+++ b/SW_HTTPServer.lib	Fri Jan 03 19:57:31 2014 +0000
@@ -1,1 +1,1 @@
-http://mbed.org/users/WiredHome/code/SW_HTTPServer/#8f72be717a3c
+http://mbed.org/users/WiredHome/code/SW_HTTPServer/#ef165a67ab22

--- a/Utility/Utility.h	Thu Nov 28 18:22:32 2013 +0000
+++ b/Utility/Utility.h	Fri Jan 03 19:57:31 2014 +0000
@@ -13,4 +13,23 @@
 
 extern "C" void mbed_reset();
 
+// How to use this debug macro
+//
+// #define DEBUG "myfile"
+// #include "Utility.h"
+// ...
+// INFO("Stuff to show %d", var); // new-line is automatically appended
+// [I myfile  23] Stuff to show 23\r\n
+//
+#if (defined(DEBUG) && !defined(TARGET_LPC11U24))
+#define INFO(x, ...) std::printf("[INF %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
+#define WARN(x, ...) std::printf("[WRN %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
+#define ERR(x, ...)  std::printf("[ERR %s %3d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
+#else
+#define INFO(x, ...)
+#define WARN(x, ...)
+#define ERR(x, ...)
+#endif
+
+
 #endif // UTILITY_H

--- a/WiflyInterface.lib	Thu Nov 28 18:22:32 2013 +0000
+++ b/WiflyInterface.lib	Fri Jan 03 19:57:31 2014 +0000
@@ -1,1 +1,1 @@
-http://mbed.org/users/WiredHome/code/WiflyInterface/#a4831b1cb9a4
+http://mbed.org/users/WiredHome/code/WiflyInterface/#0729959263b7

--- a/main.cpp	Thu Nov 28 18:22:32 2013 +0000
+++ b/main.cpp	Fri Jan 03 19:57:31 2014 +0000
@@ -1,22 +1,22 @@
 /** @file main.cpp contains the main program that a user would write.
  * see the documentation above "main"
  */
-#include "mbed.h"               // ver 70
+#include "mbed.h"               // ver 75
 
 // Standard components
 #include "MODSERIAL.h"          // ver 32 of Erik Olieman's derivative from Andy Kircham
 
 // My components
 #include "Utility.h"            // a couple of simple helper functions
-#include "WiflyInterface.h"     // ver 51, derived from version 4 with my mods
+#include "WiflyInterface.h"     // ver 53, derived from mbed official ver 4
 #include "SW_HTTPServer.h"      // ver 31, derived from nweb
 #include "Credentials.h"        // ver 0, credential manager
 #include "DynamicPages.h"       // my dynamically generated pages
 #include "SecurePage.h"         // my secure pages
 #include "ServerConfig.h"       // various configuration options
 #include "DynamicFileIn.h"      // Upload a file to the server
-#include "MSCFileSystem.h"      //
-#include "SDFileSystem.h"       // ver 2, standard
+#include "MSCFileSystem.h"      // ver 1, this and SDFileSystem
+#include "SDFileSystem.h"       // ver 1, this and MSCFileSystem
 
 #define HTTP_SERVER_PORT 80
 
@@ -28,7 +28,7 @@
 
 
 LocalFileSystem local("local");         // some place to hold settings and maybe the static web pages
-MSCFileSystem msc("msc");
+MSCFileSystem msc("msc");               // Mass Storage on USB
 SDFileSystem sd(p5, p6, p7, p8, "sd");  // for the static web pages
 #define WEBROOT "/msc/web"
 
@@ -130,10 +130,12 @@
 /// @li I would like it to be faster (the interface from mbed to wifly is
 ///     limited to 230400 baud before it drops chars. HW handshake could
 ///     improve this, but the HW handshake pins on the LPC1768 are not
-///     brought out.
+///     both brought out.
 /// @li I would like to integrate this with the rtos.
 /// @li If a page has multiple components (e.g. images), it appears
 ///     unreliable. It doesn't see the request for the extra component.
+///     A poor workaround, for images, is to use a javascript to post-
+///     load them. This is fundamentally a constraint of the WiFly module.
 ///
 /// history:
 /// @li 20130602 added .txt to the supported types (e.g. robots.txt), so
@@ -155,7 +157,7 @@
 {
     credentials cr;     // handles the credentials
 
-    pc.baud(460800);    // I like a snappy terminal, so crank it up!
+    pc.baud(921600);    // I like a snappy terminal, so crank it up!
     pc.claim();         // capture stdout
     pc.printf("\r\nSmart WiFly - Build " __DATE__ " " __TIME__ "\r\n");
 
@@ -165,15 +167,13 @@
         error("     Waiting for user to fix this problem.         \r\n"); // flash and die
     }
 
-    // Instantiate the WiflyInterface
-    WiflyInterface wifly(p28, p27, p23, p24, cr.ssid, cr.pass, WPA);
-    // Release the credentials, which also secures them
-    FreeCredentials(&cr);
+    WiflyInterface wifly(p28, p27, p23, p24, cr.ssid, cr.pass, WPA);    // Instantiate the WiflyInterface
+    FreeCredentials(&cr);   // Release the credentials, which also secures them
 
     // Bring the WiFly interface online
     do {
         wifly.init(); // start it up as a client of my network using DHCP
-        wifly.baud(230400);     // Only 230K w/o HW flow control
+        wifly.baud(921600);     // Only 230K w/o HW flow control
         if (wifly.connect())
             break;
         pc.printf(" Failed to connect, retrying...\r\n");
@@ -201,7 +201,7 @@
     svr.RegisterHandler("/pass", SimpleSecurityCheck);
     svr.RegisterHandler("/config", ServerConfig);
     svr.RegisterHandler("/FileIn", DynamicFileIn);
-    
+
     // Let the human know it is ready - if they are watching
     pc.printf("Connect to this server at http://%s:%d\r\n", wifly.getIPAddress(), HTTP_SERVER_PORT);
 
@@ -213,10 +213,9 @@
             //pc.printf("Largest free mem block is %d\r\n", Free());
             ShowSignOfLife();
             }
-        svr.Poll();   // non-blocking, but not deterministic
-        //pc.printf("this %d, longest %d\r\n", thisRun, longestRun);
+        svr.Poll();   // non-blocking, but also not deterministic
         if (pc.readable())
-            WiFlyShell(wifly, pc);
+            WiFlyShell(wifly, pc);  // allow shell access at runtime (if user taps a key)
     }
 }
 

--- a/mbed.bld	Thu Nov 28 18:22:32 2013 +0000
+++ b/mbed.bld	Fri Jan 03 19:57:31 2014 +0000
@@ -1,1 +1,1 @@
-http://mbed.org/users/mbed_official/code/mbed/builds/673126e12c73
\ No newline at end of file
+http://mbed.org/users/mbed_official/code/mbed/builds/dc225afb6914
\ No newline at end of file