Auto PR from release/0.6 to release/0.7

fs/httpfs/httpfs.h

@@ -26,6 +26,12 @@ limitations under the License.
 #include <photon/fs/filesystem.h>
 
 namespace photon {
+namespace net {
+namespace http {
+class Client;
+}
+}
+
 namespace fs {
 enum HTTPFileFlags {
     HTTP_HEADER = 0xF01,  // (const char*, const char*) ... for header
@@ -68,7 +74,9 @@ IFile* new_httpfile(const char* url, IFileSystem* httpfs = nullptr,
 
 IFileSystem* new_httpfs_v2(bool default_https = false,
                            uint64_t conn_timeout = -1UL,
-                           uint64_t stat_expire = -1UL);
+                           uint64_t stat_expire = -1UL,
+                           net::http::Client* client = nullptr,
+                           bool client_ownership = false);
 
 IFile* new_httpfile_v2(const char* url, IFileSystem* httpfs = nullptr,
                        uint64_t conn_timeout = -1UL,

fs/httpfs/httpfs_v2.cpp

@@ -45,16 +45,24 @@ class HttpFs_v2 : public fs::IFileSystem {
     uint64_t m_stat_timeout;
 
     net::http::Client *m_client;
+    bool m_client_ownership;
 
 public:
-    HttpFs_v2(bool default_https, uint64_t conn_timeout, uint64_t stat_timeout)
-        : m_default_https(default_https),
-          m_conn_timeout(conn_timeout),
+    HttpFs_v2(bool default_https, uint64_t conn_timeout, uint64_t stat_timeout,
+              net::http::Client* client, bool client_ownership)
+        : m_default_https(default_https), m_conn_timeout(conn_timeout),
           m_stat_timeout(stat_timeout) {
-              m_client = net::http::new_http_client();
-          }
+        if (client == nullptr) {
+            m_client = net::http::new_http_client();
+            m_client_ownership = true;
+        } else {
+            m_client = client;
+            m_client_ownership = client_ownership;
+        }
+    }
     ~HttpFs_v2() {
-        delete m_client;
+        if (m_client_ownership)
+            delete m_client;
     }
     net::http::Client* get_client() { return m_client; }
     IFile* open(const char* pathname, int flags) override;
@@ -265,8 +273,10 @@ IFile* HttpFs_v2::open(const char* pathname, int flags) {
 }
 
 IFileSystem* new_httpfs_v2(bool default_https, uint64_t conn_timeout,
-                        uint64_t stat_timeout) {
-    return new HttpFs_v2(default_https, conn_timeout, stat_timeout);
+                           uint64_t stat_timeout, net::http::Client* client,
+                           bool client_ownership) {
+    return new HttpFs_v2(default_https, conn_timeout, stat_timeout,
+                         client, client_ownership);
 }
 
 IFile* new_httpfile_v2(const char* url, HttpFs_v2* httpfs, uint64_t conn_timeout,

net/http/message.cpp

@@ -334,7 +334,7 @@ int Request::redirect(Verb v, estring_view location, bool enable_proxy) {
     else
         new_request_line_size += u.target().size();
 
-    auto delta = new_request_line_size - m_buf_size;
+    int delta = (int)new_request_line_size - m_buf_size;
     LOG_DEBUG(VALUE(delta));
     if (headers.reset_host(delta, u.host_port()) < 0)
         LOG_ERROR_RETURN(0, -1, "failed to move header data");

net/http/test/client_function_test.cpp

@@ -120,6 +120,13 @@ TEST(http_client, get) {
     resp_body_buf[10] = '\0';
     LOG_DEBUG(resp_body_buf);
     EXPECT_EQ(0, strcmp("http_clien", resp_body_buf));
+
+    static const char target_tb[] = "http://www.taobao.com?x";
+    auto op5 = client->new_operation(Verb::GET, target_tb);
+    DEFER(delete op5);
+    op5->req.headers.content_length(0);
+    op5->call();
+    EXPECT_EQ(op5->resp.status_code(), 200);
 }
 
 int body_check_handler(void*, Request &req, Response &resp, std::string_view) {
@@ -517,6 +524,26 @@ TEST(url, url_escape_unescape) {
     );
 }
 
+TEST(url, path_fix) {
+    static const char url0[] = "http://xxx.com/yyy?a=b&c=d";
+    URL u0(url0);
+    EXPECT_EQ(u0.target(), "/yyy?a=b&c=d");
+    EXPECT_EQ(u0.path(), "/yyy");
+    EXPECT_EQ(u0.query(), "a=b&c=d");
+
+    static const char url1[] = "http://xxx.com";
+    URL u1(url1);
+    EXPECT_EQ(u1.target(), "/");
+    EXPECT_EQ(u1.path(), "/");
+    EXPECT_EQ(u1.query(), "");
+
+    static const char url2[] = "http://xxx.com?a=b";
+    URL u2(url2);
+    EXPECT_EQ(u2.target(), "/?a=b");
+    EXPECT_EQ(u2.path(), "/");
+    EXPECT_EQ(u2.query(), "a=b");
+}
+
 // Only for manual test
 // TEST(http_client, proxy) {
 //     auto client = new_http_client();

net/http/url.cpp

@@ -22,7 +22,23 @@ namespace photon {
 namespace net {
 namespace http {
 
+void URL::fix_target() {
+    auto t = (m_url | m_target);
+    if (m_target.size() == 0 || t.front() != '/') {
+        m_tmp_target = (char*)malloc(m_target.size() + 1);
+        m_tmp_target[0] = '/';
+        strncpy(m_tmp_target+1, t.data(), t.size());
+        m_target = rstring_view16(0, m_target.size()+1);
+        m_path = rstring_view16(0, m_path.size()+1);
+    }
+}
+
 void URL::from_string(std::string_view url) {
+    DEFER(fix_target(););
+    if (m_tmp_target) {
+        free((void*)m_tmp_target);
+        m_tmp_target = nullptr;
+    }
     m_url = url.begin();
     size_t pos = 0;
     LOG_DEBUG(VALUE(url));

net/http/url.h

@@ -48,9 +48,13 @@ class URL {
     rstring_view16 m_fragment;
     uint16_t m_port = 0;
     bool m_secure;
+    char *m_tmp_target = nullptr;
 public:
     URL() = default;
     URL(std::string_view url) { from_string(url); }
+    ~URL() {
+        free((void*)m_tmp_target);
+    }
 
     std::string to_string() {
         return m_url;
@@ -61,15 +65,19 @@ class URL {
     }
 
     void from_string(std::string_view url);
+    void fix_target();
     std::string_view query() const { return m_url | m_query; }
 
     std::string_view path() const {
-        return m_url | m_path;
+        if (m_tmp_target != nullptr)
+            return (m_tmp_target | m_path);
+        return (m_url | m_path);
     }
 
     std::string_view target() const {
-        return m_target.size() == 0 ?
-            std::string_view("/") : (m_url | m_target);
+        if (m_tmp_target != nullptr)
+            return (m_tmp_target | m_target);
+        return (m_url | m_target);
     }
 
     std::string_view host() const { return m_url | m_host; }