Support query /etc/hosts (swoole#4341)

* Support query /etc/hosts

* Change NULL to nullptr

Author: zmyWL

.github/workflows/lib.yml

@@ -34,7 +34,8 @@ jobs:
            sudo make install
 
     - name: make test
-      run: cd core-tests && ./run.sh
+      run: 
+        cd core-tests && ./run.sh
 
     - name: run coverage
       shell: bash

core-tests/src/network/dns.cpp

@@ -97,3 +97,11 @@ TEST(dns, load_resolv_conf) {
     ASSERT_FALSE(dns_server.first.empty());
     ASSERT_NE(dns_server.second, 0);
 }
+
+TEST(dns, gethosts) {
+    std::string ip = swoole::coroutine::get_ip_by_hosts("localhost");
+    ASSERT_EQ(ip, "127.0.0.1");
+
+    ip = swoole::coroutine::get_ip_by_hosts("non.exist.com");
+    ASSERT_EQ(ip, "");
+}

include/swoole_coroutine_socket.h

@@ -596,6 +596,7 @@ std::vector<std::string> dns_lookup_impl_with_socket(const char *domain, int fam
 #ifdef SW_USE_CARES
 std::vector<std::string> dns_lookup_impl_with_cares(const char *domain, int family, double timeout);
 #endif
+std::string get_ip_by_hosts(std::string domain);
 //-------------------------------------------------------------------------------
 }  // namespace coroutine
 }  // namespace swoole

include/swoole_socket.h

@@ -595,3 +595,4 @@ network::Socket *make_server_socket(enum swSocket_type socket_type,
                                     int backlog = SW_BACKLOG);
 bool verify_ip(int __af, const std::string &str);
 }  // namespace swoole
+

src/network/dns.cc

@@ -16,11 +16,14 @@
 
 #include "swoole.h"
 #include "swoole_coroutine_socket.h"
+#include "swoole_util.h"
 
 #include <string>
 #include <iostream>
 #include <vector>
 
+#define SW_PATH_HOSTS "/etc/hosts"
+
 #ifdef SW_USE_CARES
 #include <ares.h>
 #endif
@@ -103,6 +106,162 @@ static int domain_encode(const char *src, int n, char *dest);
 static void domain_decode(char *str);
 static std::string parse_ip_address(void *vaddr, int type);
 
+static int read_line(FILE *fp, char **buf, size_t *bufsize) {
+    char *newbuf;
+    size_t offset = 0;
+    size_t len;
+
+    if (*buf == nullptr) {
+        *buf = (char *) malloc(128);
+        if (!*buf) {
+            return SW_ERR;
+        }
+        *bufsize = 128;
+    }
+
+    for (;;) {
+        int bytestoread = *bufsize - offset;
+        if (!fgets(*buf + offset, bytestoread, fp)) {
+            return SW_ERR;
+        }
+
+        len = offset + strlen(*buf + offset);
+        if ((*buf)[len - 1] == '\n') {
+            (*buf)[len - 1] = 0;
+            break;
+        }
+        offset = len;
+        if (len < *bufsize - 1) {
+            continue;
+        }
+        newbuf = (char *) realloc(*buf, *bufsize * 2);
+        if (!newbuf) {
+            free(*buf);
+            *buf = nullptr;
+            return SW_ERR;
+        }
+        *buf = newbuf;
+        *bufsize *= 2;
+    }
+
+    return SW_OK;
+}
+
+static std::pair<std::string, std::string> get_hostent(FILE *fp) {
+    char *line = nullptr, *p, *q;
+    char *txtaddr, *txthost, *txtalias;
+    int status;
+    size_t linesize, naliases;
+
+    std::pair<std::string, std::string> result{};
+
+    while ((status = read_line(fp, &line, &linesize)) == SW_OK) {
+        p = line;
+        while (*p && (*p != '#')) {
+            p++;
+        }
+        *p = '\0';
+
+        q = p - 1;
+        while ((q >= line) && isspace(*q)) {
+            q--;
+        }
+        *++q = '\0';
+
+        p = line;
+        while (*p && isspace(*q)) {
+            q--;
+        }
+        if (!*p) {
+            continue;
+        }
+
+        txtaddr = p;
+
+        while (*p && !isspace(*p)) {
+            p++;
+        }
+        if (!*p) {
+            continue;
+        }
+
+        *p = '\0';
+
+        p++;
+        while (*p && isspace(*p)) {
+            p++;
+        }
+        if (!*p) {
+            continue;
+        }
+
+        txthost = p;
+
+        while (*p && !isspace(*p)) {
+            p++;
+        }
+
+        txtalias = nullptr;
+        if (*p) {
+            q = p + 1;
+            while (*q && isspace(*q)) {
+                q++;
+            }
+            if (*q) {
+                txtalias = q;
+            }
+        }
+
+        *p = '\0';
+
+        naliases = 0;
+        if (txtalias) {
+            p = txtalias;
+            while (*p) {
+                while (*p && !isspace(*p)) {
+                    p++;
+                }
+                while (*p && isspace(*p)) {
+                    p++;
+                }
+                naliases++;
+            }
+        }
+
+        result.first = txthost;
+        result.second = txtaddr;
+
+        free(line);
+
+        return result;
+    }
+
+    if (line) free(line);
+
+    return result;
+}
+
+std::string get_ip_by_hosts(std::string domain) {
+    std::unordered_map<std::string, std::string> _map;
+    auto fp = fopen(SW_PATH_HOSTS, "r");
+    if (fp == nullptr) {
+        return "";
+    }
+    ON_SCOPE_EXIT {
+        fclose(fp);
+    };
+    while (1) {
+        auto result = get_hostent(fp);
+        if (result.first == "") {
+            break;
+        }
+        if (result.first == domain) {
+            return result.second;
+        }
+    }
+    return "";
+}
+
 static std::string parse_ip_address(void *vaddr, int type) {
     auto addr = reinterpret_cast<unsigned char *>(vaddr);
     std::string ip_addr;
@@ -199,7 +358,7 @@ std::vector<std::string> dns_lookup_impl_with_socket(const char *domain, int fam
 
     auto ret = _sock.recv(packet, sizeof(packet) - 1);
     if (ret <= 0) {
-        swoole_set_last_error(_sock.errCode == ECANCELED ? SW_ERROR_CO_CANCELED: SW_ERROR_DNSLOOKUP_RESOLVE_FAILED);
+        swoole_set_last_error(_sock.errCode == ECANCELED ? SW_ERROR_CO_CANCELED : SW_ERROR_DNSLOOKUP_RESOLVE_FAILED);
         return result;
     }
 

tests/swoole_coroutine/dnslookup_query_hosts.phpt

@@ -0,0 +1,18 @@
+--TEST--
+swoole_coroutine: dnslookup query hosts
+--SKIPIF--
+<?php require __DIR__ . '/../include/skipif.inc'; ?>
+--FILE--
+<?php
+require __DIR__ . '/../include/bootstrap.php';
+
+use Swoole\Coroutine;
+use Swoole\Coroutine\System;
+use function Swoole\Coroutine\run;
+
+run(function () {
+    Assert::eq(System::dnsLookup('localhost', 3, AF_INET), '127.0.0.1');
+});
+
+?>
+--EXPECT--