Add Host and User-Agent header in HTTP / Webdav responses

luc-github · luc-github · commit 4ecf0dcd8f6d · 2023-11-03T10:15:10.000+08:00
Update API doc
diff --git a/docs/WebDavService.md b/docs/WebDavService.md
@@ -16,6 +16,10 @@ The allow header will be set to GET, HEAD, PUT, DELETE, OPTIONS, PROPFIND, MKCOL
 The time format used is the local time with the timezone offset:
 YYYY-MM-DDThh:mm:ssTZD (e.g. 1997-07-16T19:20:30+01:00)
 
+## Host / User-Agent
+User-Agent: ESP3D-TFT-HttpdavServer/1.0 (ESP32S3; Firmware/1.0.0; Platform/RTOS; Embedded; http://www.esp3d.io)
+Host: http://192.168.0.1/webdav
+
 ## GET method
 The GET method is used to retrieve information about the resource identified by the Request-URI. And the content of the resource is returned as the response body.
 The necessary headers in response are:
diff --git a/main/modules/http/esp3d_http_service.cpp b/main/modules/http/esp3d_http_service.cpp
@@ -26,6 +26,7 @@
 #include "esp3d_log.h"
 #include "esp3d_settings.h"
 #include "esp3d_string.h"
+#include "esp3d_version.h"
 #include "esp_tls_crypto.h"
 #include "esp_wifi.h"
 #include "filesystem/esp3d_globalfs.h"
@@ -220,10 +221,9 @@ bool ESP3DHttpService::begin() {
     return true;
   }
   httpd_config_t config = HTTPD_DEFAULT_CONFIG();
-  uint32_t intValue =
-      esp3dTftsettings.readUint32(ESP3DSettingIndex::esp3d_http_port);
+  _port = esp3dTftsettings.readUint32(ESP3DSettingIndex::esp3d_http_port);
   // HTTP port
-  config.server_port = intValue;
+  config.server_port = _port;
   // Http server core
   config.core_id = 0;
   // stack size (default 4096)
@@ -997,6 +997,37 @@ ESP3DAuthenticationLevel ESP3DHttpService::getAuthenticationLevel(
   return ESP3DAuthenticationLevel::admin;
 #endif  // #if ESP3D_AUTHENTICATION_FEATURE
 }
+
+esp_err_t ESP3DHttpService::httpd_resp_set_http_hdr(httpd_req_t *req) {
+  esp_err_t err = ESP_OK;
+
+  err = httpd_resp_set_hdr(req, "User-Agent",
+                           "ESP3D-TFT-HttpServer/1.0 (" CONFIG_IDF_TARGET
+                           "; Firmware/" ESP3D_TFT_VERSION
+                           "; Platform/RTOS; Embedded; http://www.esp3d.io)");
+  if (err != ESP_OK) {
+    esp3d_log_e("httpd_resp_set_hdr failed for User-Agent");
+    return err;
+  }
+
+  static std::string host = "";
+  if (host.empty()) {
+    host = "http://";
+    host += esp3dNetwork.getLocalIpString();
+    if (esp3dHttpService.getPort() != 80) {
+      host += ":";
+      host += esp3dHttpService.getPort();
+    }
+  }
+
+  err = httpd_resp_set_hdr(req, "Host", host.c_str());
+  if (err != ESP_OK) {
+    esp3d_log_e("httpd_resp_set_hdr failed for Host");
+    return err;
+  }
+  return err;
+}
+
 esp_err_t ESP3DHttpService::streamFile(const char *path, httpd_req_t *req) {
   esp_err_t res = ESP_OK;
   if (!_started || !_server) {
diff --git a/main/modules/http/esp3d_http_service.h b/main/modules/http/esp3d_http_service.h
@@ -110,6 +110,7 @@ class ESP3DHttpService final {
   static char *generate_http_auth_basic_digest(const char *username,
                                                const char *password);
 #endif  // #if ESP3D_AUTHENTICATION_FEATURE
+  static esp_err_t httpd_resp_set_http_hdr(httpd_req_t *req);
   static ESP3DAuthenticationLevel getAuthenticationLevel(httpd_req_t *req);
   static esp_err_t root_get_handler(httpd_req_t *req);
   static esp_err_t command_handler(httpd_req_t *req);
@@ -178,11 +179,13 @@ class ESP3DHttpService final {
   void pop(esp3dSocketType socketType, int socketFd);
 
   const char *getArg(httpd_req_t *req, const char *argname);
+  uint32_t getPort() { return _port; };
 
  private:
   static char _chunk[CHUNK_BUFFER_SIZE];
   bool _started;
   httpd_handle_t _server;
+  uint32_t _port;
   const char *getBoundaryString(httpd_req_t *req);
   // it is based on : `only one post is supported at once`
   static PostUploadContext _post_files_upload_ctx;
diff --git a/main/modules/http/handlers/esp3d_command.cpp b/main/modules/http/handlers/esp3d_command.cpp
@@ -30,6 +30,8 @@
 esp_err_t ESP3DHttpService::command_handler(httpd_req_t *req) {
   // TODO: check authentication level
   ESP3DAuthenticationLevel authentication_level = getAuthenticationLevel(req);
+  // Send httpd header
+  httpd_resp_set_http_hdr(req);
 #if ESP3D_AUTHENTICATION_FEATURE
   if (authentication_level == ESP3DAuthenticationLevel::guest) {
     // send 401
diff --git a/main/modules/http/handlers/esp3d_config.cpp b/main/modules/http/handlers/esp3d_config.cpp
@@ -26,6 +26,8 @@
 esp_err_t ESP3DHttpService::config_handler(httpd_req_t *req) {
   esp3d_log("Uri: %s", req->uri);
   ESP3DAuthenticationLevel authentication_level = getAuthenticationLevel(req);
+  // Send httpd header
+  httpd_resp_set_http_hdr(req);
 #if ESP3D_AUTHENTICATION_FEATURE
   if (authentication_level == ESP3DAuthenticationLevel::guest) {
     // send 401
diff --git a/main/modules/http/handlers/esp3d_favicon_ico.cpp b/main/modules/http/handlers/esp3d_favicon_ico.cpp
@@ -24,6 +24,8 @@
 esp_err_t ESP3DHttpService::favicon_ico_handler(httpd_req_t *req) {
   // No authentication for this URL
   esp3d_log("Uri: %s", req->uri);
+  // Send httpd header
+  httpd_resp_set_http_hdr(req);
   esp_err_t err = esp3dHttpService.streamFile("/fs/favicon.ico", req);
   if (err == ESP_ERR_NOT_FOUND) {
     esp3d_log("Use embedded favicon.ico.gz");
diff --git a/main/modules/http/handlers/esp3d_file_not_found.cpp b/main/modules/http/handlers/esp3d_file_not_found.cpp
@@ -28,6 +28,8 @@
 
 esp_err_t ESP3DHttpService::file_not_found_handler(httpd_req_t *req,
                                                    httpd_err_code_t err) {
+  // Send httpd header
+  httpd_resp_set_http_hdr(req);
 #if ESP3D_AUTHENTICATION_FEATURE
   ESP3DAuthenticationLevel authentication_level = getAuthenticationLevel(req);
   if (authentication_level == ESP3DAuthenticationLevel::guest) {
diff --git a/main/modules/http/handlers/esp3d_files.cpp b/main/modules/http/handlers/esp3d_files.cpp
@@ -30,6 +30,8 @@
 #include "authentication/esp3d_authentication.h"
 
 esp_err_t ESP3DHttpService::files_handler(httpd_req_t *req) {
+  // Send httpd header
+  httpd_resp_set_http_hdr(req);
 #if ESP3D_AUTHENTICATION_FEATURE
   ESP3DAuthenticationLevel authentication_level = getAuthenticationLevel(req);
   if (authentication_level == ESP3DAuthenticationLevel::guest) {
diff --git a/main/modules/http/handlers/esp3d_login.cpp b/main/modules/http/handlers/esp3d_login.cpp
@@ -30,6 +30,8 @@
 
 esp_err_t ESP3DHttpService::login_handler(httpd_req_t *req) {
   esp3d_log("Uri: %s", req->uri);
+  // Send httpd header
+  httpd_resp_set_http_hdr(req);
 #if ESP3D_AUTHENTICATION_FEATURE
   std::string tmpstr;
   if (esp3dHttpService.hasArg(req, "DISCONNECT")) {
diff --git a/main/modules/http/handlers/esp3d_not_authenticated.cpp b/main/modules/http/handlers/esp3d_not_authenticated.cpp
@@ -32,6 +32,8 @@ esp_err_t ESP3DHttpService::not_authenticated_handler(httpd_req_t *req) {
   int socketId = httpd_req_to_sockfd(req);
   esp3d_log("Uri: %s, socket: %d", req->uri, socketId);
   esp3dHttpService.onClose(socketId);
+  // Send httpd header
+  httpd_resp_set_http_hdr(req);
   httpd_resp_set_hdr(req, "Set-Cookie", "ESPSESSIONID=0");
   httpd_resp_set_hdr(req, "Cache-Control", "no-cache");
   httpd_resp_set_type(req, "application/json");
diff --git a/main/modules/http/handlers/esp3d_root_get.cpp b/main/modules/http/handlers/esp3d_root_get.cpp
@@ -28,7 +28,8 @@ esp_err_t ESP3DHttpService::root_get_handler(httpd_req_t *req) {
   esp3d_log("Uri: %s, %d", req->uri, static_cast<uint8_t>(level));
   (void)level;
 #endif  // ESP3D_AUTHENTICATION_FEATURE
-
+  // Send httpd header
+  httpd_resp_set_http_hdr(req);
   bool forcefallback = false;
   size_t buf_len = httpd_req_get_url_query_len(req);
   if (buf_len > 0) {
diff --git a/main/modules/http/handlers/sd/esp3d_sdfiles.cpp b/main/modules/http/handlers/sd/esp3d_sdfiles.cpp
@@ -30,6 +30,8 @@
 #include "authentication/esp3d_authentication.h"
 
 esp_err_t ESP3DHttpService::sdfiles_handler(httpd_req_t *req) {
+  // Send httpd header
+  httpd_resp_set_http_hdr(req);
 #if ESP3D_AUTHENTICATION_FEATURE
   ESP3DAuthenticationLevel authentication_level = getAuthenticationLevel(req);
   if (authentication_level == ESP3DAuthenticationLevel::guest) {
diff --git a/main/modules/http/handlers/ssdp/esp3d_description_xml.cpp b/main/modules/http/handlers/ssdp/esp3d_description_xml.cpp
@@ -29,9 +29,10 @@
 
 esp_err_t ESP3DHttpService::description_xml_handler(httpd_req_t *req) {
   // No authentication for this URL
+  // Send httpd header
+  httpd_resp_set_http_hdr(req);
   esp3d_log("Uri: %s", req->uri);
   httpd_resp_set_type(req, "text/xml");
   const char *response = esp3d_ssdp_service.get_schema();
   return httpd_resp_send(req, response, strlen(response));
 }
-
diff --git a/main/modules/http/handlers/update/esp3d_updatefw.cpp b/main/modules/http/handlers/update/esp3d_updatefw.cpp
@@ -26,9 +26,10 @@
 esp_err_t ESP3DHttpService::updatefw_handler(httpd_req_t *req) {
   // No need Authentication as already handled in multipart_parser
   esp3d_log("Uri: %s", req->uri);
+  // Send httpd header
+  httpd_resp_set_http_hdr(req);
   httpd_resp_sendstr(req, "Update firmware done restarting");
   vTaskDelay(pdMS_TO_TICKS(1000));
   esp_restart();
   return ESP_OK;
 }
-
diff --git a/main/modules/time/esp3d_time_service.cpp b/main/modules/time/esp3d_time_service.cpp
@@ -158,7 +158,7 @@ bool TimeService::updateTimeZone(bool fromsettings) {
                                            out_str, SIZE_OF_TIMEZONE);
   if (!esp3dTftsettings.isValidStringSetting(
           _time_zone.c_str(), ESP3DSettingIndex::esp3d_timezone)) {
-    esp3d_log("Invalid time zone %s", _time_zone.c_str());
+    esp3d_log_e("Invalid time zone %s", _time_zone.c_str());
     _time_zone = "+00:00";
   }
   std::string stmp = _time_zone;
@@ -220,7 +220,7 @@ bool TimeService::setTime(const char* stime) {
     return false;
   }
   return true;
-};
+}
 
 bool TimeService::started() { return _started; }
 
diff --git a/main/modules/webdav/esp3d_webdav_service.cpp b/main/modules/webdav/esp3d_webdav_service.cpp
@@ -21,44 +21,63 @@
 
 #include "esp3d_log.h"
 #include "esp3d_string.h"
+#include "esp3d_version.h"
+#include "http/esp3d_http_service.h"
+#include "network/esp3d_network.h"
+#include "sdkconfig.h"
 
-esp_err_t httpd_resp_set_webdav_hdr(httpd_req_t *req, bool is_chunk) {
+esp_err_t httpd_resp_set_webdav_hdr(httpd_req_t *req) {
   esp_err_t err = ESP_OK;
-  if (!is_chunk) {
-    err = httpd_resp_set_hdr(req, "DAV", ESP3D_WEBDAV_HEADER);
-    if (err != ESP_OK) {
-      esp3d_log_e("httpd_resp_set_hdr failed for DAV");
-      return err;
-    }
 
-    err = httpd_resp_set_hdr(req, "Cache-Control", "no-cache");
-    if (err != ESP_OK) {
-      esp3d_log_e("httpd_resp_set_hdr failed for cache-control");
-      return err;
-    }
+  err = httpd_resp_set_hdr(req, "DAV", ESP3D_WEBDAV_HEADER);
+  if (err != ESP_OK) {
+    esp3d_log_e("httpd_resp_set_hdr failed for DAV");
+    return err;
+  }
 
-    err = httpd_resp_set_hdr(req, "Allow", ESP3D_WEBDAV_METHODS);
-    if (err != ESP_OK) {
-      esp3d_log_e("httpd_resp_set_hdr failed for Allow");
-      return err;
-    }
+  err = httpd_resp_set_hdr(req, "User-Agent",
+                           "ESP3D-TFT-WebdavServer/1.0 (" CONFIG_IDF_TARGET
+                           "; Firmware/" ESP3D_TFT_VERSION
+                           "; Platform/RTOS; Embedded; http://www.esp3d.io)");
+  if (err != ESP_OK) {
+    esp3d_log_e("httpd_resp_set_hdr failed for User-Agent");
+    return err;
+  }
 
-    err = httpd_resp_set_hdr(req, "Connection", "close");
-    if (err != ESP_OK) {
-      esp3d_log_e("httpd_resp_set_hdr failed for Connection");
-      return err;
-    }
-  } else {
-    std::string chunked =
-        "DAV: " ESP3D_WEBDAV_HEADER
-        "\r\nCache-Control: no-cache\r\nAllow: " ESP3D_WEBDAV_METHODS
-        "\r\nConnection: close\r\n";
-    err = httpd_resp_send_chunk(req, chunked.c_str(), chunked.length());
-    if (err != ESP_OK) {
-      esp3d_log_e("httpd_resp_send_chunk failed for DAV");
-      return err;
+  static std::string host = "";
+  if (host.empty()) {
+    host = "http://";
+    host += esp3dNetwork.getLocalIpString();
+    if (esp3dHttpService.getPort() != 80) {
+      host += ":";
+      host += esp3dHttpService.getPort();
     }
-    esp3d_log("%s", chunked.c_str());
+    host += "/";
+    host += ESP3D_WEBDAV_ROOT;
+  }
+
+  err = httpd_resp_set_hdr(req, "Host", host.c_str());
+  if (err != ESP_OK) {
+    esp3d_log_e("httpd_resp_set_hdr failed for Host");
+    return err;
+  }
+
+  err = httpd_resp_set_hdr(req, "Cache-Control", "no-cache");
+  if (err != ESP_OK) {
+    esp3d_log_e("httpd_resp_set_hdr failed for cache-control");
+    return err;
+  }
+
+  err = httpd_resp_set_hdr(req, "Allow", ESP3D_WEBDAV_METHODS);
+  if (err != ESP_OK) {
+    esp3d_log_e("httpd_resp_set_hdr failed for Allow");
+    return err;
+  }
+
+  err = httpd_resp_set_hdr(req, "Connection", "close");
+  if (err != ESP_OK) {
+    esp3d_log_e("httpd_resp_set_hdr failed for Connection");
+    return err;
   }
 
   return err;
diff --git a/main/modules/webdav/esp3d_webdav_service.h b/main/modules/webdav/esp3d_webdav_service.h
@@ -33,5 +33,4 @@
   " DELETE, COPY, MOVE,"     \
   " PROPFIND, MKCOL, OPTIONS"
 
-extern esp_err_t httpd_resp_set_webdav_hdr(httpd_req_t *req,
-                                           bool ischunk = false);
+extern esp_err_t httpd_resp_set_webdav_hdr(httpd_req_t *req);
