Revision 22:9e246a41abe8, committed 2015-04-27

Comitter:

jderiso2

Date:

Mon Apr 27 17:38:13 2015 +0000

Parent:

21:f042d41ddf10

Commit message:

updates;

Changed in this revision

--- a/HTTPClient.cpp	Wed Apr 22 01:46:05 2015 +0000
+++ b/HTTPClient.cpp	Mon Apr 27 17:38:13 2015 +0000
@@ -21,16 +21,16 @@
 #if 1
 //Enable debug
 #include <cstdio>
-//#define DBG(x, ...) std::printf("[HTTPClient : DBG]"x"\r\n", ##__VA_ARGS__); 
+//#define DBG(x, ...) std::printf("[HTTPClient : DBG]"x"\r\n", ##__VA_ARGS__);
 #define DBG(X, ...)
-#define WARN(x, ...) std::printf("[HTTPClient : WARN]"x"\r\n", ##__VA_ARGS__); 
-#define ERR(x, ...) std::printf("[HTTPClient : ERR]"x"\r\n", ##__VA_ARGS__); 
+#define WARN(x, ...) std::printf("[HTTPClient : WARN]"x"\r\n", ##__VA_ARGS__);
+#define ERR(x, ...) std::printf("[HTTPClient : ERR]"x"\r\n", ##__VA_ARGS__);
 
 #else
 //Disable debug
-#define DBG(x, ...) 
+#define DBG(x, ...)
 #define WARN(x, ...)
-#define ERR(x, ...) 
+#define ERR(x, ...)
 
 #endif
 
@@ -49,7 +49,7 @@
 #include "HTTPClient.h"
 
 HTTPClient::HTTPClient() :
-m_sock(), m_basicAuthUser(NULL), m_basicAuthPassword(NULL), m_httpResponseCode(0)
+    m_sock(), m_basicAuthUser(NULL), m_basicAuthPassword(NULL), m_httpResponseCode(0)
 {
 
 }
@@ -62,41 +62,41 @@
 #if 0
 void HTTPClient::basicAuth(const char* user, const char* password) //Basic Authentification
 {
-  m_basicAuthUser = user;
-  m_basicAuthPassword = password;
+    m_basicAuthUser = user;
+    m_basicAuthPassword = password;
 }
 #endif
 
 HTTPResult HTTPClient::get(const char* url, IHTTPDataIn* pDataIn, int timeout /*= HTTP_CLIENT_DEFAULT_TIMEOUT*/) //Blocking
 {
-  return connect(url, HTTP_GET, NULL, pDataIn, timeout);
+    return connect(url, HTTP_GET, NULL, pDataIn, timeout);
 }
 
 HTTPResult HTTPClient::get(const char* url, char* result, size_t maxResultLen, int timeout /*= HTTP_CLIENT_DEFAULT_TIMEOUT*/) //Blocking
 {
-  HTTPText str(result, maxResultLen);
-  return get(url, &str, timeout);
+    HTTPText string_result(result, maxResultLen);
+    return get(url, &string_result, timeout);
 }
 
 HTTPResult HTTPClient::post(const char* url, const IHTTPDataOut& dataOut, IHTTPDataIn* pDataIn, int timeout /*= HTTP_CLIENT_DEFAULT_TIMEOUT*/) //Blocking
 {
-  return connect(url, HTTP_POST, (IHTTPDataOut*)&dataOut, pDataIn, timeout);
+    return connect(url, HTTP_POST, (IHTTPDataOut*)&dataOut, pDataIn, timeout);
 }
 
 HTTPResult HTTPClient::put(const char* url, const IHTTPDataOut& dataOut, IHTTPDataIn* pDataIn, int timeout /*= HTTP_CLIENT_DEFAULT_TIMEOUT*/) //Blocking
 {
-  return connect(url, HTTP_PUT, (IHTTPDataOut*)&dataOut, pDataIn, timeout);
+    return connect(url, HTTP_PUT, (IHTTPDataOut*)&dataOut, pDataIn, timeout);
 }
 
 HTTPResult HTTPClient::del(const char* url, IHTTPDataIn* pDataIn, int timeout /*= HTTP_CLIENT_DEFAULT_TIMEOUT*/) //Blocking
 {
-  return connect(url, HTTP_DELETE, NULL, pDataIn, timeout);
+    return connect(url, HTTP_DELETE, NULL, pDataIn, timeout);
 }
 
 
 int HTTPClient::getHTTPResponseCode()
 {
-  return m_httpResponseCode;
+    return m_httpResponseCode;
 }
 
 #define CHECK_CONN_ERR(ret) \
@@ -116,627 +116,527 @@
   } while(0)
 
 HTTPResult HTTPClient::connect(const char* url, HTTP_METH method, IHTTPDataOut* pDataOut, IHTTPDataIn* pDataIn, int timeout) //Execute request
-{ 
-  m_httpResponseCode = 0; //Invalidate code
-  m_timeout = timeout;
-  
-  pDataIn->writeReset();
-  if( pDataOut )
-  {
-    pDataOut->readReset();
-  }
+{
+    m_httpResponseCode = 0; //Invalidate code
+    m_timeout = timeout;
+
+    pDataIn->writeReset();
+    if( pDataOut ) {
+        pDataOut->readReset();
+    }
 
-  char scheme[8];
-  uint16_t port;
-  char host[32];
-  char path[64];
-  //First we need to parse the url (http[s]://host[:port][/[path]]) -- HTTPS not supported (yet?)
-  HTTPResult res = parseURL(url, scheme, sizeof(scheme), host, sizeof(host), &port, path, sizeof(path));
-  if(res != HTTP_OK)
-  {
-    ERR("parseURL returned %d", res);
-    return res;
-  }
+   /* char scheme[8];
+    uint16_t port;
+    char host[32];
+    char path[64];*/
+    char scheme[16];
+    uint16_t port;
+    char host[64];
+    char path[128];
+    //First we need to parse the url (http[s]://host[:port][/[path]]) -- HTTPS not supported (yet?)
+    HTTPResult res = parseURL(url, scheme, sizeof(scheme), host, sizeof(host), &port, path, sizeof(path));
+    if(res != HTTP_OK) {
+        ERR("parseURL returned %d", res);
+        return res;
+    }
 
-  if(port == 0) //TODO do handle HTTPS->443
-  {
-    port = 80;
-  }
+    if(port == 0) { //TODO do handle HTTPS->443
+        port = 80;
+    }
 
-  DBG("Scheme: %s", scheme);
-  DBG("Host: %s", host);
-  DBG("Port: %d", port);
-  DBG("Path: %s", path);
+    DBG("Scheme: %s", scheme);
+    DBG("Host: %s", host);
+    DBG("Port: %d", port);
+    DBG("Path: %s", path);
 
-  //Connect
-  DBG("Connecting socket to server");
-  int ret = m_sock.connect(host, port);
-  if (ret < 0)
-  {
-    m_sock.close();
-    ERR("Could not connect");
-    return HTTP_CONN;
-  }
+    //Connect
+    DBG("Connecting socket to server");
+    int ret = m_sock.connect(host, port);
+    if (ret < 0) {
+        m_sock.close();
+        ERR("Could not connect");
+        return HTTP_CONN;
+    }
 
-  //Send request
-  DBG("Sending request");
-  char buf[CHUNK_SIZE];
-  const char* meth = (method==HTTP_GET)?"GET":(method==HTTP_POST)?"POST":(method==HTTP_PUT)?"PUT":(method==HTTP_DELETE)?"DELETE":"";
-  snprintf(buf, sizeof(buf), "%s %s HTTP/1.1\r\nHost: %s:%d\r\n", meth, path, host ,port); //Write request
-  DBG("Request line: buf.");
-  ret = send(buf);
-  if(ret)
-  {
-    m_sock.close();
-    ERR("Could not write request");
-    return HTTP_CONN;
-  }
-
-  //Send all headers
-
-  //Send default headers
-  DBG("Sending headers");
-  if( pDataOut != NULL )
-  {
-    if( pDataOut->getIsChunked() )
-    {
-      ret = send("Transfer-Encoding: chunked\r\n");
-      CHECK_CONN_ERR(ret);
-    }
-    else
-    {
-      snprintf(buf, sizeof(buf), "Content-Length: %d\r\n", pDataOut->getDataLen());
-      ret = send(buf);
-      CHECK_CONN_ERR(ret);
+    //Send request
+    DBG("Sending request");
+    char buf[CHUNK_SIZE];
+    const char* meth = (method==HTTP_GET)?"GET":(method==HTTP_POST)?"POST":(method==HTTP_PUT)?"PUT":(method==HTTP_DELETE)?"DELETE":"";
+    snprintf(buf, sizeof(buf), "%s %s HTTP/1.1\r\nHost: %s:%d\r\n", meth, path, host ,port); //Write request
+    DBG("Request line: buf.");
+    ret = send(buf);
+    if(ret) {
+        m_sock.close();
+        ERR("Could not write request");
+        return HTTP_CONN;
     }
-    char type[48];
-    if( pDataOut->getDataType(type, 48) == HTTP_OK )
-    {
-      snprintf(buf, sizeof(buf), "Content-Type: %s\r\n", type);
-      ret = send(buf);
-      CHECK_CONN_ERR(ret);
-    }
-    
-    //Send specific headers
-    while( pDataOut->getHeader(buf, sizeof(buf) - 3) ) //must have space left for CRLF + 0 terminating char
-    {
-      size_t headerlen = strlen(buf);
-      snprintf(buf + headerlen, sizeof(buf) - headerlen, "\r\n");
-      ret = send(buf);
-      CHECK_CONN_ERR(ret);
+
+    //Send all headers
+
+    //Send default headers
+    DBG("Sending headers");
+    if( pDataOut != NULL ) {
+        if( pDataOut->getIsChunked() ) {
+            ret = send("Transfer-Encoding: chunked\r\n");
+            CHECK_CONN_ERR(ret);
+        } else {
+            snprintf(buf, sizeof(buf), "Content-Length: %d\r\n", pDataOut->getDataLen());
+            ret = send(buf);
+            CHECK_CONN_ERR(ret);
+        }
+        char type[48];
+        if( pDataOut->getDataType(type, 48) == HTTP_OK ) {
+            snprintf(buf, sizeof(buf), "Content-Type: %s\r\n", type);
+            ret = send(buf);
+            CHECK_CONN_ERR(ret);
+        }
+
+        //Send specific headers
+        while( pDataOut->getHeader(buf, sizeof(buf) - 3) ) { //must have space left for CRLF + 0 terminating char
+            size_t headerlen = strlen(buf);
+            snprintf(buf + headerlen, sizeof(buf) - headerlen, "\r\n");
+            ret = send(buf);
+            CHECK_CONN_ERR(ret);
+        }
     }
-  }
-  
-  //Send specific headers
-  while( pDataIn->getHeader(buf, sizeof(buf) - 3) )
-  {
-    size_t headerlen = strlen(buf);
-    snprintf(buf + headerlen, sizeof(buf) - headerlen, "\r\n");
-    ret = send(buf);
-    CHECK_CONN_ERR(ret);
-  }
-  
-  //Close headers
-  DBG("Headers sent");
-  ret = send("\r\n");
-  CHECK_CONN_ERR(ret);
 
-  size_t trfLen;
-  
-  //Send data (if available)
-  if( pDataOut != NULL )
-  {
-    DBG("Sending data");
-    while(true)
-    {
-      size_t writtenLen = 0;
-      pDataOut->read(buf, CHUNK_SIZE, &trfLen);
-      if( pDataOut->getIsChunked() )
-      {
-        //Write chunk header
-        char chunkHeader[16];
-        snprintf(chunkHeader, sizeof(chunkHeader), "%X\r\n", trfLen); //In hex encoding
-        ret = send(chunkHeader);
+    //Send specific headers
+    while( pDataIn->getHeader(buf, sizeof(buf) - 3) ) {
+        size_t headerlen = strlen(buf);
+        snprintf(buf + headerlen, sizeof(buf) - headerlen, "\r\n");
+        ret = send(buf);
         CHECK_CONN_ERR(ret);
-      }
-      else if( trfLen == 0 )
-      {
-        break;
-      }
-      if( trfLen != 0 )
-      {
-        ret = send(buf, trfLen);
-        CHECK_CONN_ERR(ret);
-      }
+    }
+
+    //Close headers
+    DBG("Headers sent");
+    ret = send("\r\n");
+    CHECK_CONN_ERR(ret);
+
+    size_t trfLen;
 
-      if( pDataOut->getIsChunked()  )
-      {
-        ret = send("\r\n"); //Chunk-terminating CRLF
-        CHECK_CONN_ERR(ret);
-      }
-      else
-      {
-        writtenLen += trfLen;
-        if( writtenLen >= pDataOut->getDataLen() )
-        {
-          break;
-        }
-      }
+    //Send data (if available)
+    if( pDataOut != NULL ) {
+        DBG("Sending data");
+        while(true) {
+            size_t writtenLen = 0;
+            pDataOut->read(buf, CHUNK_SIZE, &trfLen);
+            if( pDataOut->getIsChunked() ) {
+                //Write chunk header
+                char chunkHeader[16];
+                snprintf(chunkHeader, sizeof(chunkHeader), "%X\r\n", trfLen); //In hex encoding
+                ret = send(chunkHeader);
+                CHECK_CONN_ERR(ret);
+            } else if( trfLen == 0 ) {
+                break;
+            }
+            if( trfLen != 0 ) {
+                ret = send(buf, trfLen);
+                CHECK_CONN_ERR(ret);
+            }
 
-      if( trfLen == 0 )
-      {
-        break;
-      }
-    }
-  }
-  
-  //Receive response
-  DBG("Receiving response");
-  ret = recv(buf, 1, CHUNK_SIZE - 1, &trfLen); //Read n bytes
-  CHECK_CONN_ERR(ret);
-
-  buf[trfLen] = '\0';
+            if( pDataOut->getIsChunked()  ) {
+                ret = send("\r\n"); //Chunk-terminating CRLF
+                CHECK_CONN_ERR(ret);
+            } else {
+                writtenLen += trfLen;
+                if( writtenLen >= pDataOut->getDataLen() ) {
+                    break;
+                }
+            }
 
-  //Make sure we got the first response line
-  char* crlfPtr = NULL;
-  while( true )
-  {
-    crlfPtr = strstr(buf, "\r\n");
-  if(crlfPtr == NULL)
-  {
-      if( trfLen < CHUNK_SIZE - 1 )
-      {
-        size_t newTrfLen;
-        ret = recv(buf + trfLen, 1, CHUNK_SIZE - trfLen - 1, &newTrfLen);
-        trfLen += newTrfLen;
-        buf[trfLen] = '\0';
-        DBG("Read %d chars; In buf: [%s]", newTrfLen, buf);
-        CHECK_CONN_ERR(ret);
-        continue;
-      }
-      else
-      {
-    PRTCL_ERR();
-  }
+            if( trfLen == 0 ) {
+                break;
+            }
+        }
     }
-    break;
-  }
 
-  int crlfPos = crlfPtr - buf;
-  buf[crlfPos] = '\0';
+    //Receive response
+    DBG("Receiving response");
+    ret = recv(buf, 1, CHUNK_SIZE - 1, &trfLen); //Read n bytes
+    CHECK_CONN_ERR(ret);
+
+    buf[trfLen] = '\0';
 
-  //Parse HTTP response
-  //if( sscanf(buf, "HTTP/%*d.%*d %d %*[^\r\n]", &m_httpResponseCode) != 1 )
-  if(crlfPos > 13)
-  {
-    buf[13] = '\0';
-  }
-  if( sscanf(buf, "HTTP/%*d.%*d %d", &m_httpResponseCode) != 1 ) //Kludge for newlib nano
-  {
-    //Cannot match string, error
-    ERR("Not a correct HTTP answer : %s\n", buf);
-    PRTCL_ERR();
-  }
-
-  if( (m_httpResponseCode < 200) || (m_httpResponseCode >= 300) )
-  {
-    //Did not return a 2xx code; TODO fetch headers/(&data?) anyway and implement a mean of writing/reading headers 
-    WARN("Response code %d", m_httpResponseCode);
-    PRTCL_ERR();
-  }
-
-  DBG("Reading headers");
+    //Make sure we got the first response line
+    char* crlfPtr = NULL;
+    while( true ) {
+        crlfPtr = strstr(buf, "\r\n");
+        if(crlfPtr == NULL) {
+            if( trfLen < CHUNK_SIZE - 1 ) {
+                size_t newTrfLen;
+                ret = recv(buf + trfLen, 1, CHUNK_SIZE - trfLen - 1, &newTrfLen);
+                trfLen += newTrfLen;
+                buf[trfLen] = '\0';
+                DBG("Read %d chars; In buf: [%s]", newTrfLen, buf);
+                CHECK_CONN_ERR(ret);
+                continue;
+            } else {
+                PRTCL_ERR();
+            }
+        }
+        break;
+    }
 
-  memmove(buf, &buf[crlfPos+2], trfLen - (crlfPos + 2) + 1); //Be sure to move NULL-terminating char as well
-  trfLen -= (crlfPos + 2);
+    int crlfPos = crlfPtr - buf;
+    buf[crlfPos] = '\0';
 
-  size_t recvContentLength = 0;
-  bool recvChunked = false;
-  bool recvLengthUnknown = true;
-  //Now get headers
-  while( true )
-  {
-    crlfPtr = strstr(buf, "\r\n");
-    if(crlfPtr == NULL)
-    {
-      if( trfLen < CHUNK_SIZE - 1 )
-      {
-        size_t newTrfLen;
-        ret = recv(buf + trfLen, 1, CHUNK_SIZE - trfLen - 1, &newTrfLen);
-        trfLen += newTrfLen;
-        buf[trfLen] = '\0';
-        DBG("Read %d chars; In buf: [%s]", newTrfLen, buf);
-        CHECK_CONN_ERR(ret);
-        continue;
-      }
-      else
-      {
+    //Parse HTTP response
+    //if( sscanf(buf, "HTTP/%*d.%*d %d %*[^\r\n]", &m_httpResponseCode) != 1 )
+    if(crlfPos > 13) {
+        buf[13] = '\0';
+    }
+    if( sscanf(buf, "HTTP/%*d.%*d %d", &m_httpResponseCode) != 1 ) { //Kludge for newlib nano
+        //Cannot match string, error
+        ERR("Not a correct HTTP answer : %s\n", buf);
         PRTCL_ERR();
-      }
+    }
+
+    if( (m_httpResponseCode < 200) || (m_httpResponseCode >= 300) ) {
+        //Did not return a 2xx code; TODO fetch headers/(&data?) anyway and implement a mean of writing/reading headers
+        WARN("Response code %d", m_httpResponseCode);
+        PRTCL_ERR();
     }
 
-    crlfPos = crlfPtr - buf;
+    DBG("Reading headers");
 
-    if(crlfPos == 0) //End of headers
-    {
-      DBG("Headers read");
-      memmove(buf, &buf[2], trfLen - 2 + 1); //Be sure to move NULL-terminating char as well
-      trfLen -= 2;
-      break;
-    }
+    memmove(buf, &buf[crlfPos+2], trfLen - (crlfPos + 2) + 1); //Be sure to move NULL-terminating char as well
+    trfLen -= (crlfPos + 2);
 
-    buf[crlfPos] = '\0';
-
-    char key[BUF_SIZE];
-    char value[BUF_SIZE];
+    size_t recvContentLength = 0;
+    bool recvChunked = false;
+    bool recvLengthUnknown = true;
+    //Now get headers
+    while( true ) {
+        crlfPtr = strstr(buf, "\r\n");
+        if(crlfPtr == NULL) {
+            if( trfLen < CHUNK_SIZE - 1 ) {
+                size_t newTrfLen;
+                ret = recv(buf + trfLen, 1, CHUNK_SIZE - trfLen - 1, &newTrfLen);
+                trfLen += newTrfLen;
+                buf[trfLen] = '\0';
+                DBG("Read %d chars; In buf: [%s]", newTrfLen, buf);
+                CHECK_CONN_ERR(ret);
+                continue;
+            } else {
+                PRTCL_ERR();
+            }
+        }
 
-    //key[31] = '\0';
-    //value[31] = '\0';
+        crlfPos = crlfPtr - buf;
 
-    memset(key, 0, BUF_SIZE);
-    memset(value, 0, BUF_SIZE);
+        if(crlfPos == 0) { //End of headers
+            DBG("Headers read");
+            memmove(buf, &buf[2], trfLen - 2 + 1); //Be sure to move NULL-terminating char as well
+            trfLen -= 2;
+            break;
+        }
+
+        buf[crlfPos] = '\0';
+
+        char key[BUF_SIZE];
+        char value[BUF_SIZE];
+
+        //key[31] = '\0';
+        //value[31] = '\0';
 
-    //int n = sscanf(buf, "%31[^:]: %31[^\r\n]", key, value);
-    
-    int n = 0;
-    
-    char* keyEnd = strchr(buf, ':');
-    if(keyEnd != NULL)
-    {
-      *keyEnd = '\0';
-      if(strlen(buf) < BUF_SIZE)
-      {
-        strcpy(key, buf);
-        n++;
-        char* valueStart = keyEnd + 2;
-        if( (valueStart - buf) < crlfPos )
-        {
-          if(strlen(valueStart) < BUF_SIZE)
-          { 
-            strcpy(value, valueStart);
-            n++;
-          }
+        memset(key, 0, BUF_SIZE);
+        memset(value, 0, BUF_SIZE);
+
+        //int n = sscanf(buf, "%31[^:]: %31[^\r\n]", key, value);
+
+        int n = 0;
+
+        char* keyEnd = strchr(buf, ':');
+        if(keyEnd != NULL) {
+            *keyEnd = '\0';
+            if(strlen(buf) < BUF_SIZE) {
+                strcpy(key, buf);
+                n++;
+                char* valueStart = keyEnd + 2;
+                if( (valueStart - buf) < crlfPos ) {
+                    if(strlen(valueStart) < BUF_SIZE) {
+                        strcpy(value, valueStart);
+                        n++;
+                    }
+                }
+            }
         }
-      }
-    }
-    if ( n == 2 )
-    {
-      DBG("Read header : %s: %s\n", key, value);
-      if( !strcmp(key, "Content-Length") )
-      {
-        sscanf(value, "%d", &recvContentLength);
-        recvLengthUnknown = false;
-        pDataIn->setDataLen(recvContentLength);
-      }
-      else if( !strcmp(key, "Transfer-Encoding") )
-      {
-        if( !strcmp(value, "Chunked") || !strcmp(value, "chunked") )
-        {
-          recvChunked = true;
-          recvLengthUnknown = false;
-          pDataIn->setIsChunked(true);
+        if ( n == 2 ) {
+            DBG("Read header : %s: %s\n", key, value);
+            if( !strcmp(key, "Content-Length") ) {
+                sscanf(value, "%d", &recvContentLength);
+                recvLengthUnknown = false;
+                pDataIn->setDataLen(recvContentLength);
+            } else if( !strcmp(key, "Transfer-Encoding") ) {
+                if( !strcmp(value, "Chunked") || !strcmp(value, "chunked") ) {
+                    recvChunked = true;
+                    recvLengthUnknown = false;
+                    pDataIn->setIsChunked(true);
+                }
+            } else if( !strcmp(key, "Content-Type") ) {
+                pDataIn->setDataType(value);
+            }
+
+            memmove(buf, &buf[crlfPos+2], trfLen - (crlfPos + 2) + 1); //Be sure to move NULL-terminating char as well
+            trfLen -= (crlfPos + 2);
+
+        } else {
+            ERR("Could not parse header");
+            PRTCL_ERR();
         }
-      }
-      else if( !strcmp(key, "Content-Type") )
-      {
-        pDataIn->setDataType(value);
-      }
 
-      memmove(buf, &buf[crlfPos+2], trfLen - (crlfPos + 2) + 1); //Be sure to move NULL-terminating char as well
-      trfLen -= (crlfPos + 2);
-
-    }
-    else
-    {
-      ERR("Could not parse header");
-      PRTCL_ERR();
     }
 
-  }
-
-  //Receive data
-  DBG("Receiving data");
-  while(true)
-  {
-    size_t readLen = 0;
+    //Receive data
+    DBG("Receiving data");
+    while(true) {
+        size_t readLen = 0;
 
-    if( recvChunked )
-    {
-      //Read chunk header
-      bool foundCrlf;
-      do
-      {
-        foundCrlf = false;
-        crlfPos=0;
-        buf[trfLen]=0;
-        if(trfLen >= 2)
-        {
-          for(; crlfPos < trfLen - 2; crlfPos++)
-          {
-            if( buf[crlfPos] == '\r' && buf[crlfPos + 1] == '\n' )
-            {
-              foundCrlf = true;
-              break;
+        if( recvChunked ) {
+            //Read chunk header
+            bool foundCrlf;
+            do {
+                foundCrlf = false;
+                crlfPos=0;
+                buf[trfLen]=0;
+                if(trfLen >= 2) {
+                    for(; crlfPos < trfLen - 2; crlfPos++) {
+                        if( buf[crlfPos] == '\r' && buf[crlfPos + 1] == '\n' ) {
+                            foundCrlf = true;
+                            break;
+                        }
+                    }
+                }
+                if(!foundCrlf) { //Try to read more
+                    if( trfLen < CHUNK_SIZE ) {
+                        size_t newTrfLen;
+                        ret = recv(buf + trfLen, 0, CHUNK_SIZE - trfLen - 1, &newTrfLen);
+                        trfLen += newTrfLen;
+                        CHECK_CONN_ERR(ret);
+                        continue;
+                    } else {
+                        PRTCL_ERR();
+                    }
+                }
+            } while(!foundCrlf);
+            buf[crlfPos] = '\0';
+            int n = sscanf(buf, "%x", &readLen);
+            if(n!=1) {
+                ERR("Could not read chunk length");
+                PRTCL_ERR();
             }
-          }
+
+            memmove(buf, &buf[crlfPos+2], trfLen - (crlfPos + 2)); //Not need to move NULL-terminating char any more
+            trfLen -= (crlfPos + 2);
+
+            if( readLen == 0 ) {
+                //Last chunk
+                break;
+            }
+        } else {
+            readLen = recvContentLength;
         }
-        if(!foundCrlf) //Try to read more
-        {
-          if( trfLen < CHUNK_SIZE )
-          {
-            size_t newTrfLen;
-            ret = recv(buf + trfLen, 0, CHUNK_SIZE - trfLen - 1, &newTrfLen);
-            trfLen += newTrfLen;
-            CHECK_CONN_ERR(ret);
-            continue;
-          }
-          else
-          {
-            PRTCL_ERR();
-          }
+
+        DBG("Retrieving %d bytes (%d bytes in buffer)", readLen, trfLen);
+        if (readLen == 0) {
+            m_sock.close();
+            DBG("Completed HTTP transaction");
+
+            return HTTP_OK;
         }
-      } while(!foundCrlf);
-      buf[crlfPos] = '\0';
-      int n = sscanf(buf, "%x", &readLen);
-      if(n!=1)
-      {
-        ERR("Could not read chunk length");
-        PRTCL_ERR();
-      }
+
+        do {
+            if(recvLengthUnknown ) {
+                readLen = trfLen;
+            }
+            pDataIn->write(buf, MIN(trfLen, readLen));
+            if(!recvLengthUnknown) {
+                if( trfLen > readLen ) {
+                    memmove(buf, &buf[readLen], trfLen - readLen);
+                    trfLen -= readLen;
+                    readLen = 0;
+                } else {
+                    readLen -= trfLen;
+                }
+            } else {
+                trfLen = 0;
+            }
 
-      memmove(buf, &buf[crlfPos+2], trfLen - (crlfPos + 2)); //Not need to move NULL-terminating char any more
-      trfLen -= (crlfPos + 2);
+            if(readLen || recvLengthUnknown) {
+                ret = recv(buf, 1, CHUNK_SIZE - trfLen - 1, &trfLen);
+                if(recvLengthUnknown && (ret == HTTP_CLOSED)) {
+                    //Write and exit
+                    pDataIn->write(buf, trfLen);
+                    break;
+                }
+                CHECK_CONN_ERR(ret);
+                if(recvLengthUnknown && (trfLen == 0)) {
+                    break;
+                }
+            }
+        } while(readLen || recvLengthUnknown);
 
-      if( readLen == 0 )
-      {
-        //Last chunk
-        break;
-      }
-    }
-    else
-    {
-      readLen = recvContentLength;
+        if( recvChunked ) {
+            if(trfLen < 2) {
+                size_t newTrfLen;
+                //Read missing chars to find end of chunk
+                ret = recv(buf + trfLen, 2 - trfLen, CHUNK_SIZE - trfLen - 1, &newTrfLen);
+                CHECK_CONN_ERR(ret);
+                trfLen += newTrfLen;
+            }
+            if( (buf[0] != '\r') || (buf[1] != '\n') ) {
+                ERR("Format error");
+                PRTCL_ERR();
+            }
+            memmove(buf, &buf[2], trfLen - 2);
+            trfLen -= 2;
+        } else {
+            break;
+        }
+
     }
 
-    DBG("Retrieving %d bytes (%d bytes in buffer)", readLen, trfLen);
-
-    do
-    {
-      if(recvLengthUnknown )
-      {
-        readLen = trfLen;
-      }
-      pDataIn->write(buf, MIN(trfLen, readLen));
-      if(!recvLengthUnknown)
-      {
-        if( trfLen > readLen )
-        {
-          memmove(buf, &buf[readLen], trfLen - readLen);
-          trfLen -= readLen;
-          readLen = 0;
-        }
-        else
-        {
-          readLen -= trfLen;
-        }
-      }
-      else
-      {
-        trfLen = 0;
-      }
+    m_sock.close();
+    DBG("Completed HTTP transaction");
 
-      if(readLen || recvLengthUnknown)
-      {
-        ret = recv(buf, 1, CHUNK_SIZE - trfLen - 1, &trfLen);
-        if(recvLengthUnknown && (ret == HTTP_CLOSED))
-        {
-          //Write and exit
-          pDataIn->write(buf, trfLen);
-          break;
-        }
-        CHECK_CONN_ERR(ret);
-        if(recvLengthUnknown && (trfLen == 0))
-        {
-          break;
-        }
-      }
-    } while(readLen || recvLengthUnknown);
-
-    if( recvChunked )
-    {
-      if(trfLen < 2)
-      {
-        size_t newTrfLen;
-        //Read missing chars to find end of chunk
-        ret = recv(buf + trfLen, 2 - trfLen, CHUNK_SIZE - trfLen - 1, &newTrfLen);
-        CHECK_CONN_ERR(ret);
-        trfLen += newTrfLen;
-      }
-      if( (buf[0] != '\r') || (buf[1] != '\n') )
-      {
-        ERR("Format error");
-        PRTCL_ERR();
-      }
-      memmove(buf, &buf[2], trfLen - 2);
-      trfLen -= 2;
-    }
-    else
-    {
-      break;
-    }
-
-  }
-
-  m_sock.close();
-  DBG("Completed HTTP transaction");
-
-  return HTTP_OK;
+    return HTTP_OK;
 }
 
 HTTPResult HTTPClient::recv(char* buf, size_t minLen, size_t maxLen, size_t* pReadLen) //0 on success, err code on failure
 {
-  DBG("Trying to read between %d and %d bytes", minLen, maxLen);
-  size_t readLen = 0;
-      
-  if(!m_sock.is_connected())
-  {
-    WARN("Connection was closed by server");
-    return HTTP_CLOSED; //Connection was closed by server 
-  }
-    
-  int ret;
-  while(readLen < maxLen)
-  {
-    if(readLen < minLen)
-    {
-      DBG("Trying to read at most %d bytes [Blocking]", minLen - readLen);
-      m_sock.set_blocking(false, m_timeout);
-      ret = m_sock.receive_all(buf + readLen, minLen - readLen);
-    }
-    else
-    {
-      DBG("Trying to read at most %d bytes [Not blocking]", maxLen - readLen);
-      m_sock.set_blocking(false, 0);
-      ret = m_sock.receive(buf + readLen, maxLen - readLen);
+    DBG("Trying to read between %d and %d bytes", minLen, maxLen);
+    size_t readLen = 0;
+
+    if(!m_sock.is_connected()) {
+        WARN("Connection was closed by server");
+        return HTTP_CLOSED; //Connection was closed by server
     }
-    
-    if( ret > 0)
-    {
-      readLen += ret;
-    }
-    else if( ret == 0 )
-    {
-      break;
+
+    int ret;
+    while(readLen < maxLen) {
+        if(readLen < minLen) {
+            DBG("Trying to read at most %d bytes [Blocking]", minLen - readLen);
+            m_sock.set_blocking(false, m_timeout);
+            ret = m_sock.receive_all(buf + readLen, minLen - readLen);
+        } else {
+            DBG("Trying to read at most %d bytes [Not blocking]", maxLen - readLen);
+            m_sock.set_blocking(false, 0);
+            ret = m_sock.receive(buf + readLen, maxLen - readLen);
+        }
+
+        if( ret > 0) {
+            readLen += ret;
+        } else if( ret == 0 ) {
+            break;
+        } else {
+            if(!m_sock.is_connected()) {
+                ERR("Connection error (recv returned %d)", ret);
+                *pReadLen = readLen;
+                return HTTP_CONN;
+            } else {
+                break;
+            }
+        }
+
+        if(!m_sock.is_connected()) {
+            break;
+        }
     }
-    else
-    {
-      if(!m_sock.is_connected())
-      {
-        ERR("Connection error (recv returned %d)", ret);
-        *pReadLen = readLen;
-        return HTTP_CONN;
-      }
-      else
-      {
-        break;      
-      }
-    }
-    
-    if(!m_sock.is_connected())
-    {
-      break;
-    }
-  }
-  DBG("Read %d bytes", readLen);
-  *pReadLen = readLen;
-  return HTTP_OK;
+    DBG("Read %d bytes", readLen);
+    *pReadLen = readLen;
+    return HTTP_OK;
 }
 
 HTTPResult HTTPClient::send(char* buf, size_t len) //0 on success, err code on failure
 {
-  if(len == 0)
-  {
-    len = strlen(buf);
-  }
-  DBG("Trying to write %d bytes", len);
-  size_t writtenLen = 0;
-    
-  if(!m_sock.is_connected())
-  {
-    WARN("Connection was closed by server");
-    return HTTP_CLOSED; //Connection was closed by server 
-  }
-  
-  m_sock.set_blocking(false, m_timeout);
-  int ret = m_sock.send_all(buf, len);
-  if(ret > 0)
-  {
-    writtenLen += ret;
-  }
-  else if( ret == 0 )
-  {
-    WARN("Connection was closed by server");
-    return HTTP_CLOSED; //Connection was closed by server
-  }
-  else
-  {
-    ERR("Connection error (send returned %d)", ret);
-    return HTTP_CONN;
-  }
-  
-  DBG("Written %d bytes", writtenLen);
-  return HTTP_OK;
+    if(len == 0) {
+        len = strlen(buf);
+    }
+    DBG("Trying to write %d bytes", len);
+    size_t writtenLen = 0;
+
+    if(!m_sock.is_connected()) {
+        WARN("Connection was closed by server");
+        return HTTP_CLOSED; //Connection was closed by server
+    }
+
+    m_sock.set_blocking(false, m_timeout);
+    int ret = m_sock.send_all(buf, len);
+    if(ret > 0) {
+        writtenLen += ret;
+    } else if( ret == 0 ) {
+        WARN("Connection was closed by server");
+        return HTTP_CLOSED; //Connection was closed by server
+    } else {
+        ERR("Connection error (send returned %d)", ret);
+        return HTTP_CONN;
+    }
+
+    DBG("Written %d bytes", writtenLen);
+    return HTTP_OK;
 }
 
 HTTPResult HTTPClient::parseURL(const char* url, char* scheme, size_t maxSchemeLen, char* host, size_t maxHostLen, uint16_t* port, char* path, size_t maxPathLen) //Parse URL
 {
-  char* schemePtr = (char*) url;
-  char* hostPtr = (char*) strstr(url, "://");
-  if(hostPtr == NULL)
-  {
-    WARN("Could not find host");
-    return HTTP_PARSE; //URL is invalid
-  }
+    char* schemePtr = (char*) url;
+    char* hostPtr = (char*) strstr(url, "://");
 
-  if( maxSchemeLen < hostPtr - schemePtr + 1 ) //including NULL-terminating char
-  {
-    WARN("Scheme str is too small (%d >= %d)", maxSchemeLen, hostPtr - schemePtr + 1);
-    return HTTP_PARSE;
-  }
-  memcpy(scheme, schemePtr, hostPtr - schemePtr);
-  scheme[hostPtr - schemePtr] = '\0';
-
-  hostPtr+=3;
+    if(hostPtr == NULL) {
+        WARN("Could not find host");
+        return HTTP_PARSE; //URL is invalid
+    }
 
-  size_t hostLen = 0;
-
-  char* portPtr = strchr(hostPtr, ':');
-  if( portPtr != NULL )
-  {
-    hostLen = portPtr - hostPtr;
-    portPtr++;
-    if( sscanf(portPtr, "%hu", port) != 1)
-    {
-      WARN("Could not find port");
-      return HTTP_PARSE;
+    if( maxSchemeLen < hostPtr - schemePtr + 1 ) { //including NULL-terminating char
+        WARN("Scheme str is too small (%d >= %d)", maxSchemeLen, hostPtr - schemePtr + 1);
+        return HTTP_PARSE;
     }
-  }
-  else
-  {
-    *port=0;
-  }
-  char* pathPtr = strchr(hostPtr, '/');
-  if( hostLen == 0 )
-  {
-    hostLen = pathPtr - hostPtr;
-  }
+    memcpy(scheme, schemePtr, hostPtr - schemePtr);
+    scheme[hostPtr - schemePtr] = '\0';
+
+    hostPtr+=3;
+
+    size_t hostLen = 0;
 
-  if( maxHostLen < hostLen + 1 ) //including NULL-terminating char
-  {
-    WARN("Host str is too small (%d >= %d)", maxHostLen, hostLen + 1);
-    return HTTP_PARSE;
-  }
-  memcpy(host, hostPtr, hostLen);
-  host[hostLen] = '\0';
+    char* portPtr = strchr(hostPtr, ':');
+    if( portPtr != NULL ) {
+        hostLen = portPtr - hostPtr;
+        portPtr++;
+        if( sscanf(portPtr, "%hu", port) != 1) {
+            WARN("Could not find port");
+            printf("got: %s\n", portPtr);
+            printf("host: %s]n", hostPtr);
+            return HTTP_PARSE;
+        }
+    } else {
+        *port=0;
+    }
+    char* pathPtr = strchr(hostPtr, '/');
+    if( hostLen == 0 ) {
+        hostLen = pathPtr - hostPtr;
+    }
 
-  size_t pathLen;
-  char* fragmentPtr = strchr(hostPtr, '#');
-  if(fragmentPtr != NULL)
-  {
-    pathLen = fragmentPtr - pathPtr;
-  }
-  else
-  {
-    pathLen = strlen(pathPtr);
-  }
+    if( maxHostLen < hostLen + 1 ) { //including NULL-terminating char
+        WARN("Host str is too small (%d >= %d)", maxHostLen, hostLen + 1);
+        return HTTP_PARSE;
+    }
+    memcpy(host, hostPtr, hostLen);
+    host[hostLen] = '\0';
 
-  if( maxPathLen < pathLen + 1 ) //including NULL-terminating char
-  {
-    WARN("Path str is too small (%d >= %d)", maxPathLen, pathLen + 1);
-    return HTTP_PARSE;
-  }
-  memcpy(path, pathPtr, pathLen);
-  path[pathLen] = '\0';
+    size_t pathLen;
+    char* fragmentPtr = NULL;//strchr(hostPtr, '#');
+    if(fragmentPtr != NULL) {
+        pathLen = fragmentPtr - pathPtr;
+    } else {
+        pathLen = strlen(pathPtr);
+    }
 
-  return HTTP_OK;
+    if( maxPathLen < pathLen + 1 ) { //including NULL-terminating char
+        WARN("Path str is too small (%d >= %d)", maxPathLen, pathLen + 1);
+        return HTTP_PARSE;
+    }
+    memcpy(path, pathPtr, pathLen);
+    path[pathLen] = '\0';
+
+    return HTTP_OK;
 }