Refactor getBestPublicIp for all valid ips

include/server.h

@@ -21,6 +21,7 @@
 #define KIWIX_SERVER_H
 
 #include <string>
+#include <vector>
 #include <memory>
 #include "common.h"
 
@@ -52,7 +53,7 @@ namespace kiwix
        void stop();
 
        void setRoot(const std::string& root);
-       void setAddress(const std::string& addr) { m_addr = addr; }
+       void setAddress(const std::vector<std::string>& addr) { m_addr = addr; }
        void setPort(int port) { m_port = port; }
        void setNbThreads(int threads) { m_nbThreads = threads; }
        void setMultiZimSearchLimit(unsigned int limit) { m_multizimSearchLimit = limit; }
@@ -65,14 +66,14 @@ namespace kiwix
         { m_blockExternalLinks = blockExternalLinks; }
        void setIpMode(IpMode mode) { m_ipMode = mode; }
        int getPort();
-       std::string getAddress();
+       std::vector<std::string> getAddresses();
        IpMode getIpMode() const;
 
      protected:
        std::shared_ptr<Library> mp_library;
        std::shared_ptr<NameMapper> mp_nameMapper;
        std::string m_root = "";
-       std::string m_addr = "";
+       std::vector<std::string> m_addr;
        std::string m_indexTemplateString = "";
        int m_port = 80;
        int m_nbThreads = 1;

include/tools.h

@@ -24,6 +24,7 @@
 #include <vector>
 #include <map>
 #include <cstdint>
+#include "common.h"
 
 namespace kiwix
 {
@@ -216,13 +217,13 @@ std::map<std::string, std::string> getNetworkInterfaces();
 /** Provides the best IP address
  * This function provides the best IP address from the list given by getNetworkInterfacesIPv4Or6()
  */
-std::string getBestPublicIp(bool ipv6);
+std::vector<std::string> getBestPublicIps(IpMode mode);
 
 /** Provides the best IPv4 adddress
  * Equivalent to getBestPublicIp(false). Provided for backward compatibility
  * with libkiwix v13.1.0.
  */
-std::string getBestPublicIp();
+std::vector<std::string> getBestPublicIps();
 
 /** Converts file size to human readable format.
  *

src/server.cpp

@@ -80,9 +80,9 @@ int Server::getPort()
   return mp_server->getPort();
 }
 
-std::string Server::getAddress()
+std::vector<std::string> Server::getAddresses()
 {
-  return mp_server->getAddress();
+  return mp_server->getAddresses();
 }
 
 IpMode Server::getIpMode() const

src/server/internalServer.cpp

@@ -407,7 +407,7 @@ class InternalServer::CustomizedResources : public std::map<std::string, Customi
 
 InternalServer::InternalServer(LibraryPtr library,
                                std::shared_ptr<NameMapper> nameMapper,
-                               std::string addr,
+                               std::vector<std::string> addr,
                                int port,
                                std::string root,
                                int nbThreads,
@@ -419,7 +419,7 @@ InternalServer::InternalServer(LibraryPtr library,
                                IpMode ipMode,
                                std::string indexTemplateString,
                                int ipConnectionLimit) :
-  m_addr(addr),
+  m_addr{addr},
   m_port(port),
   m_root(normalizeRootUrl(root)),
   m_rootPrefixOfDecodedURL(m_root),
@@ -462,18 +462,19 @@ bool InternalServer::start() {
   sockAddr6.sin6_port = htons(m_port);
 
   if (m_addr.empty()) {
-    if (0 != INADDR_ANY) {
+    if (0 != INADDR_ANY) { // what is the purpose of this? INADDR_ANY is always 0. Refer: http://www.castaglia.org/proftpd/doc/devel-guide/src/include/inet.h.html
       sockAddr6.sin6_addr = in6addr_any;
       sockAddr4.sin_addr.s_addr = htonl(INADDR_ANY);
     }
-    m_addr = kiwix::getBestPublicIp(m_ipMode == IpMode::ipv6 || m_ipMode == IpMode::all);
+    m_addr = kiwix::getBestPublicIps(m_ipMode);
   } else {
-    bool ipv6 = inet_pton(AF_INET6, m_addr.c_str(), &(sockAddr6.sin6_addr.s6_addr)) == 1;
-    bool ipv4 = inet_pton(AF_INET, m_addr.c_str(), &(sockAddr4.sin_addr.s_addr)) == 1;
+    // TODO: Needs more work
+    bool ipv6 = inet_pton(AF_INET6, m_addr[0].c_str(), &(sockAddr6.sin6_addr.s6_addr)) == 1;
+    bool ipv4 = inet_pton(AF_INET, m_addr[0].c_str(), &(sockAddr4.sin_addr.s_addr)) == 1;
     if (ipv6){
        m_ipMode = IpMode::all;
     } else if (!ipv4) {
-      std::cerr << "Ip address " << m_addr << "  is not a valid ip address" << std::endl;
+      std::cerr << "Ip address " << m_addr[0] << "  is not a valid ip address" << std::endl;
       return false;
     }
   }

src/server/internalServer.h

@@ -94,7 +94,7 @@ class InternalServer {
   public:
     InternalServer(LibraryPtr library,
                    std::shared_ptr<NameMapper> nameMapper,
-                   std::string addr,
+                   std::vector<std::string> addr,
                    int port,
                    std::string root,
                    int nbThreads,
@@ -117,7 +117,7 @@ class InternalServer {
                                void** cont_cls);
     bool start();
     void stop();
-    std::string getAddress() { return m_addr; }
+    std::vector<std::string> getAddresses() { return m_addr; }
     int getPort() { return m_port; }
     IpMode getIpMode() const { return m_ipMode; }
 
@@ -166,7 +166,7 @@ class InternalServer {
     typedef ConcurrentCache<std::string, std::shared_ptr<LockableSuggestionSearcher>> SuggestionSearcherCache;
 
   private: // data
-    std::string m_addr;
+    std::vector<std::string> m_addr;
     int m_port;
     std::string m_root;                   // URI-encoded
     std::string m_rootPrefixOfDecodedURL; // URI-decoded

src/tools/networkTools.cpp

@@ -212,39 +212,42 @@ std::map<std::string, std::string> getNetworkInterfaces() {
 }
 
 
-std::string getBestPublicIp(bool ipv6) {
-  IpAddress bestPublicIp = IpAddress{"127.0.0.1","::1"};
+std::vector<std::string> getBestPublicIps(IpMode mode) {
+  std::string bestIpv4, bestIpv6;
   std::map<std::string, IpAddress> interfaces = getNetworkInterfacesIPv4Or6();
 
 #ifndef _WIN32
   const char* const prioritizedNames[] =
       { "eth0", "eth1", "wlan0", "wlan1", "en0", "en1" };
   for(auto name: prioritizedNames) {
     auto it=interfaces.find(name);
-    if(it != interfaces.end() && !(ipv6 && (*it).second.addr6.empty())) {
-      bestPublicIp = (*it).second;
-      break;
+    if (it != interfaces.end()) {
+      if (it->second.addr.find(':') == std::string::npos) bestIpv4 = it->second.addr;
+      else bestIpv6 = it->second.addr6;
     }
   }
 #endif
 
   const char* const prefixes[] = { "192.168", "172.16.", "10.0" };
   for(auto prefix : prefixes){
     for(auto& itr : interfaces) {
-      std::string interfaceIp(itr.second.addr);
-      if (interfaceIp.find(prefix) == 0 && !(ipv6 && itr.second.addr6.empty())) {
-        bestPublicIp = itr.second;
-        break;
-      }
+      if (itr.second.addr.find(':') == std::string::npos && itr.second.addr.find(prefix) == 0)
+          bestIpv4 = itr.second.addr;
+      if (itr.second.addr6.find(':') != std::string::npos)
+          bestIpv6 = itr.second.addr6;
     }
   }
-  return ipv6 ? bestPublicIp.addr6 : bestPublicIp.addr;
-}
 
+  std::vector<std::string> bestIps;
+  if (mode == IpMode::ipv4 || mode == IpMode::all) bestIps.push_back(bestIpv4);
+  if (mode == IpMode::ipv6 || mode == IpMode::all) bestIps.push_back(bestIpv6);
+
+  return bestIps;
+}
 
-std::string getBestPublicIp()
+std::vector<std::string> getBestPublicIps()
 {
-  return getBestPublicIp(false);
+  return getBestPublicIps(IpMode::ipv4);
 }
 
 } // namespace kiwix

test/otherTools.cpp

@@ -18,6 +18,7 @@
  */
 
 #include "gtest/gtest.h"
+#include "../include/common.h"
 #include "../src/tools/otherTools.h"
 #include "zim/suggestion_iterator.h"
 #include "../src/server/i18n_utils.h"
@@ -252,11 +253,22 @@ TEST(networkTools, getNetworkInterfaces)
   }
 }
 
-TEST(networkTools, getBestPublicIp)
+TEST(networkTools, getBestPublicIps)
 {
-  using kiwix::getBestPublicIp;
+  using kiwix::getBestPublicIps;
 
-  std::cout << "getBestPublicIp(true)  " << getBestPublicIp(true)  << std::endl;
-  std::cout << "getBestPublicIp(false) " << getBestPublicIp(false) << std::endl;
-  std::cout << "getBestPublicIp()      " << getBestPublicIp()      << std::endl;
+  std::vector<std::string> allIps = getBestPublicIps(kiwix::IpMode::all);
+  std::cout << "getBestPublicIps(IpMode::all): [ ";
+  for (const std::string ip : allIps) std::cout << ip << " ";
+  std::cout << "]" << std::endl;
+
+  std::vector<std::string> ipv4Ips = getBestPublicIps(kiwix::IpMode::ipv4);
+  std::cout << "getBestPublicIps(IpMode::ipv4): [ ";
+  for (const std::string ip : ipv4Ips) std::cout << ip << " ";
+  std::cout << "]" << std::endl;
+
+  std::vector<std::string> ipv6Ips = getBestPublicIps(kiwix::IpMode::ipv6);
+  std::cout << "getBestPublicIps(IpMode::ipv6): [ ";
+  for (const std::string ip : ipv6Ips) std::cout << ip << " ";
+  std::cout << "]" << std::endl;
 }

test/server_testing_tools.h

@@ -142,7 +142,7 @@ void ZimFileServer::run(int serverPort, std::string indexTemplateString)
   }
   server.reset(new kiwix::Server(library, nameMapper));
   server->setRoot(cfg.root);
-  server->setAddress(address);
+  server->setAddress({address});
   server->setPort(serverPort);
   server->setNbThreads(2);
   server->setVerbose(false);