bugfixes

Author: BioRyajenka

TODO.txt

@@ -4,12 +4,9 @@ TODO2:
 15) static struct;
 5) static_assert?
 11) -rdynamic?
-16) = default
 17) public, virtual in inheritance?
 
 9) http cashing (including partial GET methods cashing)
 3) rewrite Log::print using variadic templates
 
-15) does I really need global_socket_mutex?
-
 19) to update lenovo yoga keyboard driver

buffer.cpp

@@ -48,7 +48,7 @@ void buffer::set(const char *const data) {
 }
 
 bool buffer::empty() {
-    return data.empty();
+    return length() == 0;
 }
 
 int buffer::length() {

buffer.o

@@ -9,11 +9,17 @@
 
 class file_descriptor {
 public:
-    file_descriptor(const file_descriptor&) = delete;
+    static int const INVALID_FD = -1;
 
+    file_descriptor(const file_descriptor&) = delete;
+    file_descriptor(file_descriptor&& other)
+        : fd(other.fd)
+    {
+        other.fd = INVALID_FD;
+    }
     file_descriptor(int fd) : fd(fd) { }
 
-    file_descriptor() : fd(0) { }
+    file_descriptor() : fd(INVALID_FD) { }
 
     /*file_descriptor(file_descriptor &&rhs) {
         fd = rhs.fd;
@@ -22,7 +28,7 @@ class file_descriptor {
 
     ~file_descriptor() {
         Log::d("Closing fd(" + inttostr(fd) + ")");
-        if (fd)
+        if (fd != INVALID_FD)
             close(fd);
         Log::d("closed");
     }

file_descriptor.h

@@ -63,9 +63,9 @@ bool client_handler::read_message(handler *h, buffer &buf) {
 
     if (message_type == VIA_TRANSFER_ENCODING) {
         while (buf.length() > message_len) {
-            Log::d("kek is  " + inttostr((int) buf.string_data()[message_len - 1]) + " " +
+            /*Log::d("kek is  " + inttostr((int) buf.string_data()[message_len - 1]) + " " +
                    inttostr((int) buf.string_data()[message_len]) + " " +
-                   inttostr((int) buf.string_data()[message_len + 1]));
+                   inttostr((int) buf.string_data()[message_len + 1]));*/
             if (buf.string_data()[message_len] == '0') {
                 return true;
             }
@@ -74,6 +74,8 @@ bool client_handler::read_message(handler *h, buffer &buf) {
                 std::string chunklen = buf.string_data().substr((size_t) message_len, linebreak - message_len);
                 Log::d("Next chunk len is " + chunklen);
                 message_len += chunklen.length() + hextoint(chunklen) + 4;
+            } else {
+                break;
             }
         }
         return false;
@@ -155,13 +157,11 @@ void client_handler::resolve_host_ip(std::string hostname, uint flags) {
 }
 
 void client_handler::client_request_handler::handle(const epoll_event &e) {
-    if (!deleteme) {
+    if (!(e.events & EPOLLOUT) || (e.events & EPOLLIN) || !clh->input_buffer.empty()) {
         Log::d("Client request handler: " + eetostr(e) + ", inputbuffer: " +
                (clh->input_buffer.empty() ? "empty" : "not empty"));
-        deleteme = true;
     }
     if (e.events & EPOLLOUT) {
-        if (!clh->input_buffer.empty()) deleteme = false;
         if (serv->write_chunk(this, clh->input_buffer) && clh->message_type != HTTPS_MODE) {
             Log::d("Finished resending query to host");
             serv->modify_handler(this, EPOLLIN);
@@ -173,7 +173,6 @@ void client_handler::client_request_handler::handle(const epoll_event &e) {
     }
 
     if (e.events & EPOLLIN) {
-        deleteme = false;
         if (clh->read_message(this, clh->output_buffer) && clh->message_type != HTTPS_MODE) {
             Log::d("It seems that all message was received.");
             serv->modify_handler(clh.get(), EPOLLOUT);

handler.cpp

@@ -142,8 +142,6 @@ class client_handler : public handler {
 
     private:
         std::shared_ptr<client_handler> clh;
-
-        bool deleteme = false;
     };
 };
 

handler.h

@@ -12,36 +12,34 @@
 
 class hostname_resolver {
 public:
-    hostname_resolver() {}
+    ~hostname_resolver() {
+        Log::d("releasing waiters");
+        queue.release_waiters();
+
+        for (auto &w : workers) {
+            w->join();
+        }
+    }
 
     hostname_resolver(int threads) {
         for (int i = 0; i < threads; i++) {
-            workers.push_back(std::make_shared<worker>(this));
+            workers.push_back(std::make_unique<worker>(this));
         }
     }
 
-    void add_task(std::string hostname, std::function<void(my_addrinfo *)> task, std::function<void()> on_fail) {
+    void add_task(std::string hostname, std::function<void(std::shared_ptr<my_addrinfo>)> task, std::function<void()> on_fail) {
         queue.push(resolver_task(hostname, task, on_fail));
     }
 
-    void terminate() {
-        Log::d("releasing waiters");
-        queue.release_waiters();
-
-        for (auto &w : workers) {
-            w->join();
-        }
-    }
-
 private:
     struct resolver_task {
         resolver_task() { }
 
-        resolver_task(std::string hostname, std::function<void(my_addrinfo *)> task, std::function<void()> on_fail)
+        resolver_task(std::string hostname, std::function<void(std::shared_ptr<my_addrinfo>)> task, std::function<void()> on_fail)
                 : hostname(hostname), task(task), on_fail(on_fail) { }
 
         std::string hostname;
-        std::function<void(my_addrinfo *)> task;
+        std::function<void(std::shared_ptr<my_addrinfo>)> task;
         std::function<void()> on_fail;
     };
 
@@ -50,20 +48,20 @@ class hostname_resolver {
         //worker &operator=(const worker &) = delete;
 
         hostname_resolver *resolver;
-        std::shared_ptr<std::thread> thread;
+        std::unique_ptr<std::thread> thread;
 
     public:
 
         worker(hostname_resolver *_resolver) : resolver(_resolver) {
-            thread = std::make_shared<std::thread>((std::function<void()>) ([this] {
+            thread = std::make_unique<std::thread>((std::function<void()>) ([this] {
                 Log::d("RESOLVER: resolver thread id: " + inttostr((int) pthread_self()));
                 while (1) {
                     resolver_task task;
                     if (!resolver->queue.pop(task)) {
                         return;
                     }
-                    my_addrinfo *addrinfo;
-                    if (resolve_hostname(task.hostname, &addrinfo)) {
+                    std::shared_ptr<my_addrinfo> addrinfo;
+                    if (resolve_hostname(task.hostname, addrinfo)) {
                         task.task(addrinfo);
                     } else {
                         task.on_fail();
@@ -83,7 +81,7 @@ class hostname_resolver {
             thread->join();
         }
 
-        bool resolve_hostname(std::string hostname, my_addrinfo **result) {
+        bool resolve_hostname(std::string hostname, std::shared_ptr<my_addrinfo> &result) {
             Log::d("RESOLVER: \tResolving hostname \"" + hostname + "\"");
             uint16_t port = 80;
 
@@ -95,10 +93,10 @@ class hostname_resolver {
 
             Log::d("RESOLVER: \thostname is " + new_hostname + ", port is " + inttostr(port));
 
-            auto it = resolver->cashed_hostnames.find(new_hostname);
+            auto it = resolver->cashed_hostnames.find(hostname);
             if (it != resolver->cashed_hostnames.end()) {
                 Log::d("RESOLVER: taking " + new_hostname + " from cash");
-                *result = &it->second;
+                result = it->second;
                 return true;
             }
 
@@ -110,29 +108,35 @@ class hostname_resolver {
             hints.ai_socktype = SOCK_STREAM;
 
             if (getaddrinfo(new_hostname.c_str(), inttostr(port).c_str(), &hints, &_servinfo) != 0) {
+                Log::e("RESOLVER: getaddrinfo error");
+                perror("getaddrinfo");
                 return false;
             }
 
             std::unique_lock<std::mutex> lock(resolver->cashing_mutex);
-            it = resolver->cashed_hostnames.find(new_hostname);
+            it = resolver->cashed_hostnames.find(hostname);
             if (it == resolver->cashed_hostnames.end()) {
-                resolver->cashed_hostnames.insert(std::make_pair(new_hostname, my_addrinfo(_servinfo)));
+                Log::d("RESOLVER: ok, not found in cash");
+                result = std::make_shared<my_addrinfo>(_servinfo);
+                resolver->cashed_hostnames.insert(std::make_pair(hostname, result));
             } else {
+                Log::d("RESOLVER: suddenly found in cash");
                 freeaddrinfo(_servinfo);
+                result = it->second;
             }
-            *result = &it->second;
+            Log::d(std::string("RESOLVER: result->ptr is ") + (result->get_info() == nullptr ? "nullptr?!" : "not nullptr"));
             //*result = new my_addrinfo(_servinfo);
             return true;
         }
     };
 
     concurrent_queue<resolver_task> queue;
 
-    std::map<std::string, my_addrinfo> cashed_hostnames;
+    std::map<std::string, std::shared_ptr<my_addrinfo>> cashed_hostnames;
     std::mutex cashing_mutex;
 
     //just for cleaning memory up
-    std::vector<std::shared_ptr<worker>> workers;
+    std::vector<std::unique_ptr<worker>> workers;
 };
 
 #endif //KIMBERLY_HOSTNAME_RESOLVER_H

handler.o

@@ -6,7 +6,7 @@ std::shared_ptr<proxy_server> s;
 bool term = false;
 
 void signal_handler(int signum) {
-    std::cout << "[][][][][][]cout error code " << signum << std::endl;
+    //std::cout << "[][][][][][]cout error code " << signum << std::endl;
     Log::d("Error code: " + inttostr(signum));
     Log::print_stack_trace(6);
     if (term) {

hostname_resolver.h

@@ -11,11 +11,14 @@ class my_addrinfo {
     struct addrinfo *info;
 
 public:
+    my_addrinfo(const my_addrinfo &rhs) = delete;
+
     my_addrinfo() {
         info = nullptr;
     }
 
     my_addrinfo(my_addrinfo &&rhs) {
+        Log::d("my_addrinfo::move");
         info = rhs.info;
         rhs.info = nullptr;
     }