General fixes/improvements

Author: Ivan Kostoski

src/HTTPConnection.cpp

@@ -331,7 +331,13 @@ size_t HTTPConnection::getCacheSize() {
   return (_isKeepAlive ? HTTPS_KEEPALIVE_CACHESIZE : 0);
 }
 
-void HTTPConnection::loop() {
+/**
+ * Connection main async loop method
+ * 
+ * Returns true if there is more data to be processed in 
+ * the input buffers 
+ */
+bool HTTPConnection::loop() {
   // First, update the buffer
   // newByteCount will contain the number of new bytes that have to be processed
   updateBuffer();
@@ -379,7 +385,8 @@ void HTTPConnection::loop() {
         _connectionState = STATE_REQUEST_FINISHED;
       }
 
-      break;
+      if (_connectionState != STATE_REQUEST_FINISHED) break;
+
     case STATE_REQUEST_FINISHED: // Read headers
 
       while (_bufferProcessed < _bufferUnusedIdx && !isClosed()) {
@@ -414,7 +421,8 @@ void HTTPConnection::loop() {
         }
       }
 
-      break;
+      if (_connectionState != STATE_HEADERS_FINISHED) break;
+
     case STATE_HEADERS_FINISHED: // Handle body
       {
         HTTPS_LOGD("Resolving resource...");
@@ -520,19 +528,23 @@ void HTTPConnection::loop() {
             // we have no chance to do so.
             if (!_isKeepAlive) {
               // No KeepAlive -> We are done. Transition to next state.
+              HTTPS_LOGD("No keep-alive");
               if (!isClosed()) {
                 _connectionState = STATE_BODY_FINISHED;
               }
             } else {
               if (res.isResponseBuffered()) {
-                // If the response could be buffered:
+                // If the response is buffered:
+                HTTPS_LOGD("Buffered, set keep-alive");
                 res.setHeader("Connection", "keep-alive");
                 res.finalize();
+              } 
+              if (res.correctContentLength()) {
                 if (_clientState != CSTATE_CLOSED) {
                   // Refresh the timeout for the new request
                   refreshTimeout();
                   // Reset headers for the new connection
-                  _httpHeaders->clearAll();
+                  if (_httpHeaders) _httpHeaders->clearAll();
                   // Go back to initial state
                   _connectionState = STATE_INITIAL;
                 }
@@ -550,13 +562,16 @@ void HTTPConnection::loop() {
         }
 
       }
-      break;
+      if (_connectionState != STATE_BODY_FINISHED) break;
+
     case STATE_BODY_FINISHED: // Request is complete
       closeConnection();
       break;
+
     case STATE_CLOSING: // As long as we are in closing state, we call closeConnection() again and wait for it to finish or timeout
       closeConnection();
       break;
+
     case STATE_WEBSOCKET: // Do handling of the websocket
       refreshTimeout();  // don't timeout websocket connection
       if(pendingBufferSize() > 0) {
@@ -575,6 +590,8 @@ void HTTPConnection::loop() {
     }
   }
 
+  // Return true if connection has more data to process
+  return (!isClosed() && ((_bufferProcessed < _bufferUnusedIdx) || canReadData()));
 }
 
 

src/HTTPConnection.hpp

@@ -43,7 +43,7 @@ class HTTPConnection : private ConnectionContext {
   virtual void closeConnection();
   virtual bool isSecure();
 
-  void loop();
+  bool loop();
   bool isClosed();
   bool isError();
 

src/HTTPRequest.cpp

@@ -28,7 +28,7 @@ HTTPRequest::HTTPRequest(
 }
 
 HTTPRequest::~HTTPRequest() {
-  _headers->clearAll();
+  if (_headers) _headers->clearAll();
 }
 
 

src/HTTPResponse.cpp

@@ -13,16 +13,14 @@ HTTPResponse::HTTPResponse(ConnectionContext * con):
   _statusText = "OK";
   _headerWritten = false;
   _isError = false;
+  _setLength = 0;
+  _sentBytesCount = 0;
 
   _responseCacheSize = con->getCacheSize();
   _responseCachePointer = 0;
-  if (_responseCacheSize > 0) {
-    HTTPS_LOGD("Creating buffered response, size: %d", _responseCacheSize);
-    _responseCache = new byte[_responseCacheSize];
-  } else {
-    HTTPS_LOGD("Creating non-buffered response");
-    _responseCache = NULL;
-  }
+  _responseCache = NULL;
+  // Don't create buffer response just yet, 
+  // wait and see if we receive Content-Length ...
 }
 
 HTTPResponse::~HTTPResponse() {
@@ -48,8 +46,26 @@ std::string HTTPResponse::getStatusText() {
   return _statusText;
 }
 
+void HTTPResponse::setContentLength(size_t size) {
+  if (isHeaderWritten()) {
+    HTTPS_LOGE("Setting Content-Lenght after headers sent!");
+    error();
+    return;
+  }
+  if ((_setLength > 0) && (size != _setLength)) {
+    HTTPS_LOGW("Setting Content-Lenght more than once!");
+  }
+  HTTPS_LOGD("Set Content-Lenght: %d", size);
+  _setLength = size;
+}
+
 void HTTPResponse::setHeader(std::string const &name, std::string const &value) {
   _headers.set(new HTTPHeader(name, value));
+  // Watch for "Content-Length" header
+  if (name.compare("Content-Length") == 0) {
+    setContentLength(parseUInt(value));
+    return;
+  }
 }
 
 bool HTTPResponse::isHeaderWritten() {
@@ -60,6 +76,14 @@ bool HTTPResponse::isResponseBuffered() {
   return _responseCache != NULL;
 }
 
+bool HTTPResponse::correctContentLength() {
+  if (_setLength > 0) {
+    if (_sentBytesCount == _setLength) return true;
+    HTTPS_LOGE("Content-Lenght (%u) and data sent (%u) mismatch!", _setLength,  _sentBytesCount);
+  }
+  return false;
+}
+
 void HTTPResponse::finalize() {
   if (isResponseBuffered()) {
     drainBuffer();
@@ -77,6 +101,22 @@ void HTTPResponse::printStd(const std::string &str) {
  * Writes bytes to the response. May be called several times.
  */
 size_t  HTTPResponse::write(const uint8_t *buffer, size_t size) {
+  if (_sentBytesCount < 1) {
+    if (_setLength > 0) {
+      HTTPS_LOGD("Streaming response directly, size: %d", _setLength);
+    } else if (size > 0) {
+      // Try buffering
+      if (_responseCacheSize > 0) {
+        _responseCache = new byte[_responseCacheSize];
+        HTTPS_LOGD("Content-Length not set. Creating buffered response, size: %d", _responseCacheSize);
+      } else {
+        // We'll have to tear down the connection to signal end of data
+        setHeader("Connection", "close");
+        HTTPS_LOGD("Content-Length not set. Creating non-buffered response");
+      }
+    }
+  }
+  _sentBytesCount += size;
   if(!isResponseBuffered()) {
     printHeader();
   }
@@ -87,11 +127,8 @@ size_t  HTTPResponse::write(const uint8_t *buffer, size_t size) {
  * Writes a single byte to the response.
  */
 size_t  HTTPResponse::write(uint8_t b) {
-  if(!isResponseBuffered()) {
-    printHeader();
-  }
   byte ba[] = {b};
-  return writeBytesInternal(ba, 1);
+  return write(ba, 1);
 }
 
 /**
@@ -168,8 +205,8 @@ void HTTPResponse::drainBuffer(bool onOverflow) {
     HTTPS_LOGD("Draining response buffer");
     // Check for 0 as it may be an overflow reaction without any data that has been written earlier
     if(_responseCachePointer > 0) {
-      // FIXME: Return value?
-      _con->writeBuffer((byte*)_responseCache, _responseCachePointer);
+      _setLength = _responseCachePointer;
+      _sentBytesCount = _con->writeBuffer((byte*)_responseCache, _responseCachePointer);
     }
     delete[] _responseCache;
     _responseCache = NULL;

src/HTTPResponse.hpp

@@ -42,7 +42,9 @@ class HTTPResponse : public Print {
 
   void error();
 
+  void setContentLength(size_t size);
   bool isResponseBuffered();
+  bool correctContentLength();
   void finalize();
 
   ConnectionContext * _con;
@@ -59,6 +61,10 @@ class HTTPResponse : public Print {
   bool _headerWritten;
   bool _isError;
 
+  // Response length
+  size_t _setLength;
+  size_t _sentBytesCount;
+
   // Response cache
   byte * _responseCache;
   size_t _responseCacheSize;

src/HTTPSConnection.cpp

@@ -105,19 +105,21 @@ void HTTPSConnection::closeConnection() {
 }
 
 size_t HTTPSConnection::writeBuffer(byte* buffer, size_t length) {
-  return SSL_write(_ssl, buffer, length);
+  if (_ssl != NULL) return SSL_write(_ssl, buffer, length);
+  return 0;
 }
 
 size_t HTTPSConnection::readBytesToBuffer(byte* buffer, size_t length) {
-  return SSL_read(_ssl, buffer, length);
+  if (_ssl != NULL) return SSL_read(_ssl, buffer, length);
+  return 0;
 }
 
 size_t HTTPSConnection::pendingByteCount() {
-  return SSL_pending(_ssl);
+  return (_ssl != NULL) && SSL_pending(_ssl);
 }
 
 bool HTTPSConnection::canReadData() {
-  return HTTPConnection::canReadData() || (SSL_pending(_ssl) > 0);
+  return HTTPConnection::canReadData() || ((_ssl != NULL) && (SSL_pending(_ssl) > 0));
 }
 
 } /* namespace httpsserver */

src/HTTPSServerConstants.hpp

@@ -42,6 +42,13 @@
   #define HTTPS_LOGD(...) do {} while (0)
 #endif
 
+#if HTTPS_LOGLEVEL > 4
+  #define HTTPS_LOGV(...) HTTPS_LOGTAG("D");Serial.printf(__VA_ARGS__);Serial.println()
+#else
+  #define HTTPS_LOGV(...) {}
+#endif
+
+
 // The following lines define limits of the protocol. Exceeding these limits will lead to a 500 error
 
 // Maximum of header lines that are parsed