Revision 2:9d8793c23b46, committed 2013-10-04

Comitter:

Bobty

Date:

Fri Oct 04 07:41:28 2013 +0000

Parent:

1:75bb184de749

Child:

3:594136d34a32

Commit message:

Initial Revision Working

Changed in this revision

--- a/RdWebServer.cpp	Thu Sep 19 12:06:18 2013 +0000
+++ b/RdWebServer.cpp	Fri Oct 04 07:41:28 2013 +0000
@@ -3,6 +3,44 @@
 #define MAX_CMDSTR_LEN 100
 #define MAX_ARGSTR_LEN 100
 
+bool RdFileCacheEntry::readLocalFileIntoCache(char* fileName)
+{
+    printf("Reading into cache %s\n\r", fileName);
+    LocalFileSystem local("local");
+    FILE* fp = fopen(fileName, "r");
+    if (fp == NULL)
+    {
+        printf("Failed to open file\n\r");
+        return false;
+    }
+    fseek(fp, 0, SEEK_END);
+    _nFileLen = (int)ftell(fp);
+    _pFileContent = new char[_nFileLen];
+    if (!_pFileContent)
+    {
+        printf("Failed to allocate %lu\n\r", _nFileLen);
+        fclose(fp);
+        return false;
+    }
+    fseek(fp, 0, SEEK_SET);
+    char* pMem = _pFileContent;
+    char fileBuf[500];
+    int totCnt = 0;
+    int rdCnt;
+    while ((rdCnt = fread(fileBuf, sizeof( char ), 500, fp)) == 500) 
+    {
+        memcpy(pMem, fileBuf, rdCnt);
+        pMem += rdCnt;
+        totCnt += rdCnt;
+    }
+    memcpy(pMem, fileBuf, rdCnt);
+    totCnt += rdCnt;
+    fclose(fp);
+    printf("Success in caching %d bytes (read %d)\n\r", _nFileLen, totCnt);
+    _bCacheValid = true;
+    return true;
+}
+
 RdWebServer::RdWebServer()
 {
     _serverIsListening = false;
@@ -11,6 +49,9 @@
 
 RdWebServer::~RdWebServer()
 {
+    // Clean-up - probably never called as we're on a microcontroller!
+    for (std::vector<RdWebServerCmdDef*>::iterator it = _commands.begin() ; it != _commands.end(); ++it)
+        delete (*it);
 }
 
 bool RdWebServer::init(int port, DigitalOut* pStatusLed)
@@ -24,23 +65,23 @@
     //setup tcp socket
     if(_socketSrv.bind(port)< 0) 
     {
-        printf("tcp server bind failed.\n\r");
+        printf("TCP server bind fail\n\r");
         return false;
     }
     else 
     {
-        printf("tcp server bind successed.\n\r");
+//        printf("TCP server bind success\n\r");
         _serverIsListening = true;
     }
 
     if(_socketSrv.listen(1) < 0)
     {
-        printf("tcp server listen failed.\n\r");
+        printf("TCP server listen fail\n\r");
         return false;
     }
     else 
     {
-        printf("tcp server is listening...\n\r");
+        printf("TCP server is listening...\r\n");
     }
     
     return true;
@@ -83,73 +124,257 @@
     }
     return true;
 }
-  
+
+void RdWebServer::sendFromCache(RdFileCacheEntry* pCacheEntry, TCPSocketConnection* pClient, char* httpHeader)
+{
+    printf ("Sending file %s from cache %d bytes\r\n", pCacheEntry->_fileName, pCacheEntry->_nFileLen);
+    sprintf(httpHeader,"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: Close\r\n\r\n");
+    pClient->send(httpHeader,strlen(httpHeader));
+    char* pMem = pCacheEntry->_pFileContent;
+    int nLenLeft = pCacheEntry->_nFileLen;
+    int blkSize = 2048;
+    while(nLenLeft > 0)
+    {
+        if (blkSize > nLenLeft)
+            blkSize = nLenLeft;
+        pClient->send_all(pMem, blkSize);
+        pMem += blkSize;
+        nLenLeft -= blkSize;
+    }
+}
+
+void RdWebServer::handleLocalFileRequest(char* inFileName, char* argStr, TCPSocketConnection* pClient, char* httpHeader, bool bCacheIfPossible)
+{
+    const int HTTPD_MAX_FNAME_LENGTH = 127;
+    char localFilename[HTTPD_MAX_FNAME_LENGTH+1];
+    char reqFileNameStr[HTTPD_MAX_FNAME_LENGTH+1];
+
+    printf("Requesting local file %s\n\r", inFileName);
+    sprintf(reqFileNameStr, "/%s", inFileName);
+    sprintf(localFilename, "/local/%s", inFileName);
+        
+    if (bCacheIfPossible)
+    {
+        // Check if file already cached
+        bool bTryToCache = true;
+        for (std::vector<RdFileCacheEntry*>::iterator it = _cachedFiles.begin() ; it != _cachedFiles.end(); ++it)
+        {
+            if (strcmp(inFileName, (*it)->_fileName) == 0)
+            {
+                if ((*it)->_bCacheValid)
+                {
+                    sendFromCache(*it, pClient, httpHeader);
+                    return;
+                }
+                bTryToCache = false; // don't try to cache as cacheing must have already failed
+            }
+        }
+        
+        // See if we can cache the file
+        if (bTryToCache)
+        {
+            RdFileCacheEntry* pCacheEntry = new RdFileCacheEntry(inFileName);
+            if (pCacheEntry)
+            {
+                bool bCacheSuccess = pCacheEntry->readLocalFileIntoCache(localFilename);
+                // Store the cache entry even if reading failed (mem alloc or file not found, etc) so we don't try to cache again
+                _cachedFiles.push_back(pCacheEntry);
+                if (bCacheSuccess)
+                {
+                    sendFromCache(pCacheEntry, pClient, httpHeader);
+                    return;
+                }
+            }
+        }        
+    }
+    
+    LocalFileSystem local("local");
+    
+    FILE* fp = fopen(localFilename, "r");
+    if (fp == NULL)
+    {
+        printf ("Local file %s not found\r\n", localFilename);
+        sprintf(httpHeader,"HTTP/1.1 404 Not Found \r\nContent-Type: text\r\nConnection: Close\r\n\r\n");
+        pClient->send(httpHeader,strlen(httpHeader));
+        pClient->send(reqFileNameStr,strlen(reqFileNameStr));
+    }
+    else
+    {
+        printf ("Sending file %s from disk\r\n", localFilename);
+        sprintf(httpHeader,"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: Close\r\n\r\n");
+        pClient->send(httpHeader,strlen(httpHeader));
+        int rdCnt = 0;
+        char fileBuf[2000];
+        while ((rdCnt = fread(fileBuf, sizeof( char ), 2000, fp)) == 2000) 
+        {
+            pClient->send_all(fileBuf, rdCnt);
+        }
+        pClient->send_all(fileBuf, rdCnt);
+        fclose(fp);
+    }
+}
+
+void RdWebServer::handleSDFileRequest(char* inFileName, char* argStr, TCPSocketConnection* pClient, char* httpHeader)
+{
+    const int HTTPD_MAX_FNAME_LENGTH = 127;
+    char filename[HTTPD_MAX_FNAME_LENGTH+1];
+    
+    printf("Requesting file %s\n\r", inFileName);
+    
+    char *lstchr = strrchr(inFileName, NULL) -1;
+    if ('/' == *lstchr)
+    {
+        // printf("Open directory /sd/%s\n", inFileName);
+        *lstchr = 0;
+        sprintf(filename, "/sd/%s", inFileName);
+        DIR *d = opendir(filename);
+        if (d != NULL) {
+            sprintf(httpHeader,"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: Close\r\n\r\n");
+            pClient->send(httpHeader,strlen(httpHeader));
+            sprintf(httpHeader,"<html><head><title>Directory Listing</title></head><body><h1>%s</h1><ul>", inFileName);
+            pClient->send(httpHeader,strlen(httpHeader));
+            struct dirent *p;
+            while((p = readdir(d)) != NULL) {
+                // printf("%s\n", p->d_name);
+                sprintf(httpHeader,"<li>%s</li>", p->d_name);
+                pClient->send(httpHeader,strlen(httpHeader));
+            }
+        }
+        closedir(d);
+        // printf("Directory closed\n");
+        sprintf(httpHeader,"</ul></body></html>");
+        pClient->send(httpHeader,strlen(httpHeader));
+    }
+    else
+    {
+        sprintf(filename, "/sd/%s", inFileName);
+        // printf ("Filename %s\r\n", filename);
+        FILE* fp = fopen(filename, "r");
+        if (fp == NULL)
+        {
+            printf ("Filename %s not found\r\n", filename);
+            sprintf(httpHeader,"HTTP/1.1 404 Not Found \r\nContent-Type: text\r\nConnection: Close\r\n\r\n");
+            pClient->send(httpHeader,strlen(httpHeader));
+            pClient->send(inFileName,strlen(inFileName));
+        }
+        else
+        {
+            printf ("Sending file %s\r\n", filename);
+            sprintf(httpHeader,"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nConnection: Close\r\n\r\n");
+            pClient->send(httpHeader,strlen(httpHeader));
+            int rdCnt = 0;
+            char fileBuf[1024];
+            while ((rdCnt = fread(fileBuf, sizeof( char ), 1024, fp)) == 1024) 
+            {
+                pClient->send(fileBuf, rdCnt);
+            }
+            pClient->send(fileBuf, rdCnt);
+            fclose(fp);
+        }
+    }
+}
+
 void RdWebServer::run()
 {
     TCPSocketConnection client;
-    bool clientIsConnected = false;
-
+    const int HTTPD_MAX_HDR_LENGTH = 255;
+    char httpHeader[HTTPD_MAX_HDR_LENGTH+1];
+    const int HTTPD_MAX_REQ_LENGTH = 1023;
+    char buffer[HTTPD_MAX_REQ_LENGTH+1];
+    
     //listening for http GET request
-    while (isListening()) 
+    while (isListening())
     {
         //blocking mode(never timeout)
         if(_socketSrv.accept(client)<0) 
         {
-            printf("failed to accept connection.\n\r");
+            printf("TCP Socket failed to accept connection\n\r");
         }
         else
         {
-            printf("connection success!\n\rIP: %s\n\r",client.get_address());
-            clientIsConnected = true;
+            client.set_blocking(false, 1000);
+            printf("Connection from IP: %s\n\r",client.get_address());
             if (_pStatusLed != NULL)
                 *_pStatusLed = true;
+            Timer connectLimitTimer;
+            connectLimitTimer.start();
             
-            while(clientIsConnected) 
+            while(connectLimitTimer.read() < 5)  // 5 seconds timeout on HTTP operation
             {
-                char buffer[1024] = {};
-                switch(client.receive(buffer, 1023)) 
+                int rxLen = client.receive(buffer, 1023);
+                if (rxLen == -1)
+                {
+                    continue;
+                }
+                else if (rxLen == 0)
+                {
+                    printf("received buffer is empty.\n\r");
+                    break;                
+                }
+                else if (rxLen >= 1024)
                 {
-                    case 0:
-                        printf("recieved buffer is empty.\n\r");
-                        clientIsConnected = false;
-                        break;
-                    case -1:
-                        printf("failed to read data from client.\n\r");
-                        clientIsConnected = false;
-                        break;
-                    default:
-                        printf("Recieved Data: %d\n\r\n\r%.*s\n\r",strlen(buffer),strlen(buffer),buffer);
-                        if(buffer[0] == 'G' && buffer[1] == 'E' && buffer[2] == 'T' ) 
+                    sprintf(httpHeader,"HTTP/1.1 413 Request Entity Too Large \r\nContent-Type: text\r\nConnection: Close\r\n\r\n");
+                    client.send(httpHeader,strlen(httpHeader));
+                    client.send(buffer, rxLen);
+                    break;
+                }
+                buffer[rxLen] = '\0';
+//                printf("Received Data: %d\n\r\n\r%.*s\n\r",strlen(buffer),strlen(buffer),buffer);
+                if (strncmp(buffer, "GET ", 4) == 0)
+                {
+//                    printf("GET request incomming.\n\r");
+                    char cmdStr[MAX_CMDSTR_LEN];
+                    char argStr[MAX_ARGSTR_LEN];
+                    if (extractCmdArgs(buffer+3, cmdStr, MAX_CMDSTR_LEN, argStr, MAX_ARGSTR_LEN))
+                    {
+                        printf("CmdStr %s\n\r", cmdStr);
+                        printf("ArgStr %s\n\r", argStr);
+                        bool cmdFound = false;
+                        for (std::vector<RdWebServerCmdDef*>::iterator it = _commands.begin() ; it != _commands.end(); ++it)
                         {
-                            printf("GET request incomming.\n\r");
-                            char cmdStr[MAX_CMDSTR_LEN];
-                            char argStr[MAX_ARGSTR_LEN];
-                            if (extractCmdArgs(buffer+3, cmdStr, MAX_CMDSTR_LEN, argStr, MAX_ARGSTR_LEN))
-                            {
-                                printf("CmdStr %s\n\r", cmdStr);
-                                printf("ArgStr %s\n\r", argStr);
-                                for (std::vector<RdWebServerCmdDef*>::iterator it = _commands.begin() ; it != _commands.end(); ++it)
+//                            printf("Testing <<%s>> with <<%s>>\r\n", (*it)->_pCmdStr, cmdStr);
+                            if (strcasecmp((*it)->_pCmdStr, cmdStr) == 0)
+                            {                                    
+                                printf("FoundCmd <%s> Type %d\n\r", cmdStr, (*it)->_cmdType);
+                                cmdFound = true;
+                                if ((*it)->_cmdType == RdWebServerCmdDef::CMD_CALLBACK)
                                 {
-                                    if (strcasecmp((*it)->_pCmdStr, cmdStr) == 0)
-                                    {
-                                        printf("FoundCmd %s\n\r", cmdStr);
-                                        ((*it)->_callback)(argStr);
-                                    }
+                                    ((*it)->_callback)(cmdStr, argStr);
+                                }
+                                else if ((*it)->_cmdType == RdWebServerCmdDef::CMD_LOCALFILE)
+                                {
+                                    if ((*it)->_substFileName[0] != '\0')
+                                        handleLocalFileRequest((*it)->_substFileName, argStr, &client, httpHeader, (*it)->_bCacheIfPossible);
+                                    else
+                                        handleLocalFileRequest(cmdStr, argStr, &client, httpHeader, (*it)->_bCacheIfPossible);
                                 }
+                                else if ((*it)->_cmdType == RdWebServerCmdDef::CMD_SDCARDFILE)
+                                {
+                                    if ((*it)->_substFileName[0] != '\0')
+                                        handleSDFileRequest((*it)->_substFileName, argStr, &client, httpHeader);
+                                    else
+                                        handleSDFileRequest(cmdStr, argStr, &client, httpHeader);
+                                }
+                                break;
                             }
-                            
-                            //setup http response header & data
-                            char echoHeader[256] = {};
-                            sprintf(echoHeader,"HTTP/1.1 200 OK\n\rContent-Length: %d\n\rContent-Type: text\n\rConnection: Close\n\r\n\r",strlen(buffer));
-                            client.send(echoHeader,strlen(echoHeader));
-                            client.send(cmdStr,strlen(cmdStr));
-                            clientIsConnected = false;
-                            printf("done.\n\r");
                         }
-                        break;
+                        // If command not found see if it is a local file
+                        if (!cmdFound)
+                            handleLocalFileRequest(cmdStr, argStr, &client, httpHeader, false);
+                    }
+                    
+                    //setup http response header & data
+/*                    char httpHeader[256] = {};
+                    sprintf(httpHeader,"HTTP/1.1 200 OK\n\rContent-Length: %d\n\rContent-Type: text\n\rConnection: Close\n\r\n\r",strlen(buffer));
+                    client.send(httpHeader,strlen(httpHeader));
+                    client.send(cmdStr,strlen(cmdStr)); */
+                    //clientIsConnected = false;
+//                    printf("Server done.\n\r");
+                    break;
                 }
+                
             }
-            printf("close connection.\n\rtcp server is listening...\n\r");
+            printf("Connection closed ... TCP server is listening...\r\n");
             client.close();
             if (_pStatusLed != NULL)
                 *_pStatusLed = false;
@@ -157,8 +382,8 @@
     }
 }
 
-void RdWebServer::addCommand(char* pCmdStr, CmdCallbackType callback)
+void RdWebServer::addCommand(char* pCmdStr, int cmdType, CmdCallbackType callback, char* substFileName, bool cacheIfPossible)
 {
-    _commands.push_back(new RdWebServerCmdDef(pCmdStr, callback));
+    _commands.push_back(new RdWebServerCmdDef(pCmdStr, cmdType, callback, substFileName, cacheIfPossible));
 }
 

--- a/RdWebServer.h	Thu Sep 19 12:06:18 2013 +0000
+++ b/RdWebServer.h	Fri Oct 04 07:41:28 2013 +0000
@@ -6,18 +6,55 @@
 #include "mbed.h"
 #include "EthernetInterface.h"
 
-typedef void (*CmdCallbackType)(char* argStr);
+class RdFileCacheEntry
+{
+    public:
+        static const int CACHE_MAX_FNAME_LEN = 15;  // note local files on MBED are 8.3
+        RdFileCacheEntry(char* pFileName)
+        {
+            _bCacheValid = false;
+            strncpy(_fileName, pFileName, CACHE_MAX_FNAME_LEN-1);
+            _fileName[CACHE_MAX_FNAME_LEN-1] = '\0';
+            _pFileContent = NULL;
+        }
+        ~RdFileCacheEntry()
+        {
+            delete _pFileContent;
+        }
+        bool readLocalFileIntoCache(char* fileName);
+    public:
+        bool _bCacheValid;
+        char _fileName[CACHE_MAX_FNAME_LEN];
+        char* _pFileContent;
+        int _nFileLen;
+};
+
+typedef void (*CmdCallbackType)(char*cmdStr, char* argStr);
 
 class RdWebServerCmdDef
 {
     public:
-        RdWebServerCmdDef(char* pStr, CmdCallbackType callback)
+        static const int CMD_LOCALFILE = 1;
+        static const int CMD_CALLBACK = 2;
+        static const int CMD_SDCARDFILE = 3;
+        RdWebServerCmdDef(char* pStr, int cmdType, CmdCallbackType callback, char* substFileName, bool bCacheIfPossible)
         {
             _pCmdStr = pStr;
+            _cmdType = cmdType;
             _callback = callback;
+            _substFileName[0] = '\0';
+            if (substFileName != NULL)
+            {
+                strncpy(_substFileName, substFileName, RdFileCacheEntry::CACHE_MAX_FNAME_LEN);
+                _substFileName[RdFileCacheEntry::CACHE_MAX_FNAME_LEN-1] = '\0';
+            }
+            _bCacheIfPossible = bCacheIfPossible;
         };
         char* _pCmdStr;
+        int _cmdType;
         CmdCallbackType _callback;
+        char _substFileName[RdFileCacheEntry::CACHE_MAX_FNAME_LEN];
+        bool _bCacheIfPossible;
 };
 
 class RdWebServer
@@ -34,7 +71,7 @@
             return _serverIsListening;
         };
         
-        void addCommand(char* pCmdStr, CmdCallbackType callback);
+        void addCommand(char* pCmdStr, int cmdType, CmdCallbackType callback = NULL, char* substFileName = NULL, bool cacheIfPossible = false);
         
     private :
         int _port;
@@ -42,9 +79,14 @@
         TCPSocketServer _socketSrv;
         bool _serverIsListening;
         std::vector<RdWebServerCmdDef*> _commands;
+        std::vector<RdFileCacheEntry*> _cachedFiles;
         bool extractCmdArgs(char* buf, char* pCmdStr, int maxCmdStrLen, char* pArgStr, int maxArgStrLen);
 
-        
+        void handleLocalFileRequest(char* cmdStr, char* argStr, TCPSocketConnection* pClient, char* httpHeader, bool bCacheIfPossible);
+        void handleSDFileRequest(char* cmdStr, char* argStr, TCPSocketConnection* pClient, char* httpHeader);
+        void handleCGIRequest(char* pUriStr, char* pQueryStr);
+        void sendFromCache(RdFileCacheEntry* pCacheEntry, TCPSocketConnection* pClient, char* httpHeader);
+
 };
 
 #endif