Some fix and change on curl adaptor and photon thread alloc/dealloc hook

common/callback.h

@@ -50,12 +50,12 @@ struct Delegate : public Delegate_Base
     template<typename U>    // Function with U* as the 1st argument
     using UFunc  = R (*)(U*, Ts...);
 
-    Delegate(void* obj, Func func)      { bind(obj, func); }
-    Delegate(Func func, void* obj)      { bind(obj, func); }
-    Delegate(Func0 func0)               { bind(func0); }
+    constexpr Delegate(void* obj, Func func) : _obj(obj), _func(func) {}
+    constexpr Delegate(Func func, void* obj) : _obj(obj), _func(func) {}
+    constexpr Delegate(Func0 func0) : _obj(nullptr), _func((Func&)func0) {}
 
     template<typename U>
-    Delegate(U* obj, UFunc<U> func)     { bind(obj, func); }
+    constexpr Delegate(U* obj, UFunc<U> func) : _obj(obj), _func((Func&)func) {}
 
     template<typename U>
     Delegate(U* obj, UMFunc<U> func)    { bind(obj, func); }

net/curl.cpp

@@ -109,7 +109,7 @@ static uint64_t on_timer(void* = nullptr) {
 }
 /* CURLMOPT_TIMERFUNCTION */
 static int timer_cb(CURLM*, long timeout_ms, void*) {
-    if (timeout_ms >= 0) {
+    if (timeout_ms >= 0 && cctx.g_timer) {
         cctx.g_timer->reset(timeout_ms * 1000UL);
     }
     return 0;
@@ -244,11 +244,11 @@ int libcurl_init(long flags, long pipelining, long maxconn) {
     return 0;
 }
 void libcurl_fini() {
+    delete cctx.g_timer;
+    cctx.g_timer = nullptr;
     cctx.g_loop->stop();
     delete cctx.g_loop;
     cctx.g_loop = nullptr;
-    delete cctx.g_timer;
-    cctx.g_timer = nullptr;
     delete cctx.g_poller;
     cctx.g_poller = nullptr;
     CURLMcode ret = curl_multi_cleanup(cctx.g_libcurl_multi);
@@ -262,5 +262,11 @@ std::string url_escape(const char* str) {
     DEFER(curl_free(s));
     return std::string(s);
 }
+
+std::string url_unescape(const char* str) {
+    auto s = curl_unescape(str, 0);
+    DEFER(curl_free(s));
+    return std::string(s);
+}
 }  // namespace net
 }

net/curl.h

@@ -43,6 +43,7 @@ int curl_perform(CURL* curl, uint64_t timeout);
 void libcurl_fini();
 
 std::string url_escape(const char*);
+std::string url_unescape(const char*);
 
 inline void convert(const std::string& v, uint64_t& value) {
     value = std::atoll(v.c_str());
@@ -291,6 +292,12 @@ class cURL {
         return setopt(CURLOPT_FOLLOWLOCATION, v),
                setopt(CURLOPT_MAXREDIRS, max_redir);
     }
+    cURL& set_proxy(const char* proxy) {
+        return setopt(CURLOPT_PROXY, proxy);
+    }
+    cURL& set_noproxy(const char* proxy) {
+        return setopt(CURLOPT_NOPROXY, proxy);
+    }
     template <typename T>
     cURL& set_header_container(T* stream) {
         return setopt(CURLOPT_HEADERDATA, (void*)stream),
@@ -332,6 +339,9 @@ class cURL {
         setopt(CURLOPT_HTTPGET, 1L);
         setopt(CURLOPT_URL, url);
         setopt(CURLOPT_HTTPHEADER, headers.list);
+#if LIBCURL_VERSION_MAJOR > 7 || LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR >= 37
+        setopt(CURLOPT_PROXYHEADER, proxy_headers.list);
+#endif
         set_write_stream(stream);
         ret = (CURLcode)net::curl_perform(m_curl, timeout);
         return get_response_code();
@@ -341,6 +351,9 @@ class cURL {
         setopt(CURLOPT_HTTPGET, 1L);
         setopt(CURLOPT_URL, url);
         setopt(CURLOPT_HTTPHEADER, headers.list);
+#if LIBCURL_VERSION_MAJOR > 7 || LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR >= 37
+        setopt(CURLOPT_PROXYHEADER, proxy_headers.list);
+#endif
         ret = (CURLcode)net::curl_perform(m_curl, timeout);
         return get_response_code();
     }
@@ -350,6 +363,9 @@ class cURL {
         setopt(CURLOPT_URL, url);
         setopt(CURLOPT_CUSTOMREQUEST, "HEAD");
         setopt(CURLOPT_HTTPHEADER, headers.list);
+#if LIBCURL_VERSION_MAJOR > 7 || LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR >= 37
+        setopt(CURLOPT_PROXYHEADER, proxy_headers.list);
+#endif
         set_write_stream(stream);
         ret = (CURLcode)net::curl_perform(m_curl, timeout);
         return get_response_code();
@@ -370,6 +386,9 @@ class cURL {
     long POST(const char* url, const char* post_fields, W* wstream,
               uint64_t timeout = -1) {
         setopt(CURLOPT_HTTPHEADER, headers.list);
+#if LIBCURL_VERSION_MAJOR > 7 || LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR >= 37
+        setopt(CURLOPT_PROXYHEADER, proxy_headers.list);
+#endif
         setopt(CURLOPT_POSTFIELDS, post_fields);
         return POST(url, wstream, timeout);
     }
@@ -380,6 +399,9 @@ class cURL {
         setopt(CURLOPT_URL, url);
         setopt(CURLOPT_POST, 1L);
         setopt(CURLOPT_HTTPHEADER, headers.list);
+#if LIBCURL_VERSION_MAJOR > 7 || LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR >= 37
+        setopt(CURLOPT_PROXYHEADER, proxy_headers.list);
+#endif
         ret = (CURLcode)net::curl_perform(m_curl, timeout);
         return get_response_code();
     }
@@ -392,6 +414,9 @@ class cURL {
         setopt(CURLOPT_PUT, 1L);
         setopt(CURLOPT_URL, url);
         setopt(CURLOPT_HTTPHEADER, headers.list);
+#if LIBCURL_VERSION_MAJOR > 7 || LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR >= 37
+        setopt(CURLOPT_PROXYHEADER, proxy_headers.list);
+#endif
         // setopt(CURLOPT_INFILESIZE_LARGE, (curl_off_t)file_info.st_size);
         ret = (CURLcode)net::curl_perform(m_curl, timeout);
         return get_response_code();
@@ -400,6 +425,9 @@ class cURL {
         setopt(CURLOPT_URL, url);
         setopt(CURLOPT_CUSTOMREQUEST, "DELETE");
         setopt(CURLOPT_HTTPHEADER, headers.list);
+#if LIBCURL_VERSION_MAJOR > 7 || LIBCURL_VERSION_MAJOR == 7 && LIBCURL_VERSION_MINOR >= 37
+        setopt(CURLOPT_PROXYHEADER, proxy_headers.list);
+#endif
         ret = (CURLcode)net::curl_perform(m_curl, timeout);
         return get_response_code();
     }
@@ -421,6 +449,16 @@ class cURL {
         return *this;
     }
 
+    cURL& append_proxy_header(const std::string& key, const std::string& val) {
+        proxy_headers.append(key + std::string(": ") + val);
+        return *this;
+    }
+
+    cURL& clear_proxy_header() {
+        proxy_headers.clear();
+        return *this;
+    }
+
     struct slist {
         struct curl_slist* list = nullptr;
         slist() = default;
@@ -447,7 +485,7 @@ class cURL {
     CURL* m_curl;
     char m_errmsg[CURL_ERROR_SIZE];
     CURLcode ret = CURLE_OK;
-    slist headers;
+    slist headers, proxy_headers;
     template <typename T>
     cURL& _setopt(CURLoption option, T arg) {
         if (ret != CURLE_OK) return *this;

thread/test/CMakeLists.txt

@@ -28,4 +28,8 @@ add_test(NAME test-tls-order-native COMMAND $<TARGET_FILE:test-tls-order-native>
 
 add_executable(test-tls-order-photon test-tls-order-photon.cpp)
 target_link_libraries(test-tls-order-photon PRIVATE photon_shared ${testing_libs})
-add_test(NAME test-tls-order-photon COMMAND $<TARGET_FILE:test-tls-order-photon>)
+add_test(NAME test-tls-order-photon COMMAND $<TARGET_FILE:test-tls-order-photon>)
+
+add_executable(test-lib-data test-lib-data.cpp)
+target_link_libraries(test-lib-data PRIVATE photon_shared ${testing_libs})
+add_test(NAME test-lib-data COMMAND $<TARGET_FILE:test-lib-data>)

thread/test/test-lib-data.cpp

@@ -0,0 +1,89 @@
+/*
+Copyright 2022 The Photon Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+#include <gtest/gtest.h>
+#include <libgen.h>
+#include <photon/common/utility.h>
+#include <photon/photon.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+bool popen_test(const std::string& cmd, int expect = 0) {
+    puts(cmd.c_str());
+    auto p = popen(cmd.c_str(), "r");
+    char buffer[4096];
+    while (fgets(buffer, sizeof(buffer), p) != NULL)
+        ;
+    auto r = pclose(p);
+    if (WIFEXITED(r)) return WEXITSTATUS(r) == expect;
+    puts("Not exit");
+    return false;
+}
+
+std::string popen_read(const std::string& cmd, int expect = 0) {
+    std::string ret;
+    puts(cmd.c_str());
+    auto p = popen(cmd.c_str(), "r");
+    char buffer[4096];
+    while (fgets(buffer, sizeof(buffer), p) != NULL) {
+        ret += buffer;
+        puts(buffer);
+    }
+    pclose(p);
+    return ret;
+}
+
+std::string libpath(uint64_t pid) {
+    auto path =
+        popen_read("cat /proc/" + std::to_string(pid) +
+                   "/maps | grep libphoton | tr -s ' ' | cut -f 6 -d ' '"
+                   " | head -n 1");
+    EXPECT_FALSE(path.empty());
+    char* tp = strdup(path.c_str());
+    path = dirname(tp);
+    puts(path.c_str());
+    free(tp);
+    return path;
+}
+
+TEST(static_lib, photon_thread_alloc) {
+#ifdef __linux__
+    auto pid = getpid();
+    auto p = libpath(pid) + "/libphoton.a";
+    EXPECT_TRUE(popen_test("objdump -tr \"" + p +
+                           "\" | grep photon_thread_allocE | grep .data"));
+    EXPECT_TRUE(popen_test("objdump -tr \"" + p +
+                           "\" | grep photon_thread_deallocE | grep .data"));
+#endif
+}
+
+TEST(shared_lib, photon_thread_alloc) {
+#ifdef __linux__
+    auto pid = getpid();
+    auto p = libpath(pid) + "/libphoton.so";
+    EXPECT_TRUE(popen_test("objdump -tr \"" + p +
+                           "\" | grep photon_thread_allocE | grep .data"));
+    EXPECT_TRUE(popen_test("objdump -tr \"" + p +
+                           "\" | grep photon_thread_deallocE | grep .data"));
+#endif
+}
+
+int main(int argc, char** argv) {
+    photon::init(photon::INIT_EVENT_NONE, 0);
+    DEFER(photon::fini());
+    ::testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
+}

thread/thread.cpp

@@ -130,17 +130,10 @@ namespace photon
         free(ptr);
     }
 
-    Delegate<void *, size_t> &photon_thread_alloc() {
-        static Delegate<void *, size_t> _photon_thread_alloc(
-            &default_photon_thread_stack_alloc, nullptr);
-        return _photon_thread_alloc;
-    }
-
-    Delegate<void, void *, size_t> &photon_thread_dealloc() {
-        static Delegate<void, void *, size_t> _photon_thread_dealloc(
-            &default_photon_thread_stack_dealloc, nullptr);
-        return _photon_thread_dealloc;
-    }
+    static Delegate<void*, size_t> photon_thread_alloc(
+        &default_photon_thread_stack_alloc, nullptr);
+    static Delegate<void, void*, size_t> photon_thread_dealloc(
+        &default_photon_thread_stack_dealloc, nullptr);
 
     struct vcpu_t;
     struct thread;
@@ -290,7 +283,7 @@ namespace photon
             assert(state == states::DONE);
             // `buf` and `stack_size` will always store on register
             // when calling deallocating.
-            photon_thread_dealloc()(buf, stack_size);
+            photon_thread_dealloc(buf, stack_size);
         }
     };
 
@@ -845,7 +838,7 @@ R"(
             LOG_ERROR_RETURN(ENOSYS, nullptr, "Photon not initialized in this vCPU (OS thread)");
         size_t randomizer = (rand() % 32) * (1024 + 8);
         stack_size = align_up(randomizer + stack_size + sizeof(thread), PAGE_SIZE);
-        char *ptr = (char *)photon_thread_alloc()(stack_size);
+        char* ptr = (char*)photon_thread_alloc(stack_size);
         auto p = ptr + stack_size - sizeof(thread) - randomizer;
         (uint64_t&)p &= ~63;
         auto th = new (p) thread;
@@ -1815,18 +1808,18 @@ R"(
         return --_n_vcpu;
     }
 
-    void set_photon_thread_stack_allocator(
-        Delegate<void *, size_t> _photon_thread_alloc,
-        Delegate<void, void *, size_t> _photon_thread_dealloc) {
-        photon_thread_alloc() = _photon_thread_alloc;
-        photon_thread_dealloc() = _photon_thread_dealloc;
-    }
-
     void* stackful_malloc(size_t size) {
         return CURRENT->stackful_malloc(size);
     }
 
     void stackful_free(void* ptr) {
         CURRENT->stackful_free(ptr);
     }
+
+    void set_photon_thread_stack_allocator(
+        Delegate<void *, size_t> _photon_thread_alloc,
+        Delegate<void, void *, size_t> _photon_thread_dealloc) {
+        photon_thread_alloc = _photon_thread_alloc;
+        photon_thread_dealloc = _photon_thread_dealloc;
+    }
 }