Moved some files to util/

util/LittleBigEndian.h

@@ -0,0 +1,242 @@
+// LittleBigEndian.h fixed for 64-bits added union
+//
+
+#ifndef LITTLEBIGENDIAN_H
+#define LITTLEBIGENDIAN_H
+
+// Determine Little-Endian or Big-Endian
+
+#define CURRENT_BYTE_ORDER       (*(int *)"\x01\x02\x03\x04")
+#define LITTLE_ENDIAN_BYTE_ORDER 0x04030201
+#define BIG_ENDIAN_BYTE_ORDER    0x01020304
+#define PDP_ENDIAN_BYTE_ORDER    0x02010403
+
+#define IS_LITTLE_ENDIAN (CURRENT_BYTE_ORDER == LITTLE_ENDIAN_BYTE_ORDER)
+#define IS_BIG_ENDIAN    (CURRENT_BYTE_ORDER == BIG_ENDIAN_BYTE_ORDER)
+#define IS_PDP_ENDIAN    (CURRENT_BYTE_ORDER == PDP_ENDIAN_BYTE_ORDER)
+
+// Forward declaration
+
+template<typename T>
+struct LittleEndian;
+
+template<typename T>
+struct BigEndian;
+
+// Little-Endian template
+
+#pragma pack(push,1)
+template<typename T>
+struct LittleEndian
+{
+    union
+    {
+        unsigned char bytes[sizeof(T)];
+        T raw_value;
+    };
+
+    LittleEndian(T t = T())
+    {
+        operator =(t);
+    }
+
+    LittleEndian(const LittleEndian<T> & t)
+    {
+        raw_value = t.raw_value;
+    }
+
+    LittleEndian(const BigEndian<T> & t)
+    {
+        for (unsigned i = 0; i < sizeof(T); i++)
+            bytes[i] = t.bytes[sizeof(T)-1-i];
+    }
+
+    operator const T() const
+    {
+        T t = T();
+        for (unsigned i = 0; i < sizeof(T); i++)
+            t |= T(bytes[i]) << (i << 3);
+        return t;
+    }
+
+    const T operator = (const T t)
+    {
+        for (unsigned i = 0; i < sizeof(T); i++)
+            bytes[sizeof(T)-1 - i] = static_cast<unsigned char>(t >> (i << 3));
+        return t;
+    }
+
+    // operators
+
+    const T operator += (const T t)
+    {
+        return (*this = *this + t);
+    }
+
+    const T operator -= (const T t)
+    {
+        return (*this = *this - t);
+    }
+
+    const T operator *= (const T t)
+    {
+        return (*this = *this * t);
+    }
+
+    const T operator /= (const T t)
+    {
+        return (*this = *this / t);
+    }
+
+    const T operator %= (const T t)
+    {
+        return (*this = *this % t);
+    }
+
+    LittleEndian<T> operator ++ (int)
+    {
+        LittleEndian<T> tmp(*this);
+        operator ++ ();
+        return tmp;
+    }
+
+    LittleEndian<T> & operator ++ ()
+    {
+        for (unsigned i = 0; i < sizeof(T); i++)
+        {
+            ++bytes[i];
+            if (bytes[i] != 0)
+                break;
+        }
+        return (*this);
+    }
+
+    LittleEndian<T> operator -- (int)
+    {
+        LittleEndian<T> tmp(*this);
+        operator -- ();
+        return tmp;
+    }
+
+    LittleEndian<T> & operator -- ()
+    {
+        for (unsigned i = 0; i < sizeof(T); i++)
+        {
+            --bytes[i];
+            if (bytes[i] != (T)(-1))
+                break;
+        }
+        return (*this);
+    }
+};
+#pragma pack(pop)
+
+// Big-Endian template
+
+#pragma pack(push,1)
+template<typename T>
+struct BigEndian
+{
+    union
+    {
+        unsigned char bytes[sizeof(T)];
+        T raw_value;
+    };
+
+    BigEndian(T t = T())
+    {
+        operator =(t);
+    }
+
+    BigEndian(const BigEndian<T> & t)
+    {
+        raw_value = t.raw_value;
+    }
+
+    BigEndian(const LittleEndian<T> & t)
+    {
+        for (unsigned i = 0; i < sizeof(T); i++)
+            bytes[i] = t.bytes[sizeof(T)-1-i];
+    }
+
+    operator const T() const
+    {
+        T t = T();
+        for (unsigned i = 0; i < sizeof(T); i++)
+            t |= T(bytes[sizeof(T) - 1 - i]) << (i << 3);
+        return t;
+    }
+
+    const T operator = (const T t)
+    {
+        for (unsigned i = 0; i < sizeof(T); i++)
+            bytes[sizeof(T) - 1 - i] = t >> (i << 3);
+        return t;
+    }
+
+    // operators
+
+    const T operator += (const T t)
+    {
+        return (*this = *this + t);
+    }
+
+    const T operator -= (const T t)
+    {
+        return (*this = *this - t);
+    }
+
+    const T operator *= (const T t)
+    {
+        return (*this = *this * t);
+    }
+
+    const T operator /= (const T t)
+    {
+        return (*this = *this / t);
+    }
+
+    const T operator %= (const T t)
+    {
+        return (*this = *this % t);
+    }
+
+    BigEndian<T> operator ++ (int)
+    {
+        BigEndian<T> tmp(*this);
+        operator ++ ();
+        return tmp;
+    }
+
+    BigEndian<T> & operator ++ ()
+    {
+        for (unsigned i = 0; i < sizeof(T); i++)
+        {
+            ++bytes[sizeof(T) - 1 - i];
+            if (bytes[sizeof(T) - 1 - i] != 0)
+                break;
+        }
+        return (*this);
+    }
+
+    BigEndian<T> operator -- (int)
+    {
+        BigEndian<T> tmp(*this);
+        operator -- ();
+        return tmp;
+    }
+
+    BigEndian<T> & operator -- ()
+    {
+        for (unsigned i = 0; i < sizeof(T); i++)
+        {
+            --bytes[sizeof(T) - 1 - i];
+            if (bytes[sizeof(T) - 1 - i] != (T)(-1))
+                break;
+        }
+        return (*this);
+    }
+};
+#pragma pack(pop)
+
+#endif // LITTLEBIGENDIAN_H

util/Queue.h

@@ -0,0 +1,169 @@
+#ifndef QUEUE_H__
+#define QUEUE_H__
+
+#include <queue>
+#include <vector>
+#include <mutex>
+#include <thread>
+#include <condition_variable>
+#include <functional>
+
+namespace i2p
+{
+namespace util
+{
+    template<typename Element>
+    class Queue
+    {   
+        public:
+
+            void Put (Element e)
+            {
+                std::unique_lock<std::mutex>  l(m_QueueMutex);
+                m_Queue.push (e);   
+                m_NonEmpty.notify_one ();
+            }
+
+            void Put (const std::vector<Element>& vec)
+            {
+                if (!vec.empty ())
+                {   
+                    std::unique_lock<std::mutex>  l(m_QueueMutex);
+                    for (auto it: vec)
+                        m_Queue.push (it);  
+                    m_NonEmpty.notify_one ();
+                }   
+            }
+            
+            Element GetNext ()
+            {
+                std::unique_lock<std::mutex> l(m_QueueMutex);
+                auto el = GetNonThreadSafe ();
+                if (!el)
+                {
+                    m_NonEmpty.wait (l);
+                    el = GetNonThreadSafe ();
+                }   
+                return el;
+            }
+
+            Element GetNextWithTimeout (int usec)
+            {
+                std::unique_lock<std::mutex> l(m_QueueMutex);
+                auto el = GetNonThreadSafe ();
+                if (!el)
+                {
+                    m_NonEmpty.wait_for (l, std::chrono::milliseconds (usec));
+                    el = GetNonThreadSafe ();
+                }   
+                return el;
+            }
+
+            void Wait ()
+            {
+                std::unique_lock<std::mutex> l(m_QueueMutex);
+                m_NonEmpty.wait (l);
+            }
+
+            bool Wait (int sec, int usec)
+            {
+                std::unique_lock<std::mutex> l(m_QueueMutex);
+                return m_NonEmpty.wait_for (l, std::chrono::seconds (sec) + std::chrono::milliseconds (usec)) != std::cv_status::timeout;
+            }
+
+            bool IsEmpty () 
+            {   
+                std::unique_lock<std::mutex> l(m_QueueMutex);
+                return m_Queue.empty ();
+            }
+
+            int GetSize () 
+            {
+                std::unique_lock<std::mutex> l(m_QueueMutex);
+                return m_Queue.size ();
+            }           
+
+            void WakeUp () { m_NonEmpty.notify_all (); };
+
+            Element Get ()
+            {
+                std::unique_lock<std::mutex> l(m_QueueMutex);
+                return GetNonThreadSafe ();
+            }   
+
+            Element Peek ()
+            {
+                std::unique_lock<std::mutex> l(m_QueueMutex);
+                return GetNonThreadSafe (true);
+            }   
+            
+        private:
+
+            Element GetNonThreadSafe (bool peek = false)
+            {
+                if (!m_Queue.empty ())
+                {
+                    auto el = m_Queue.front ();
+                    if (!peek)
+                        m_Queue.pop ();
+                    return el;
+                }               
+                return nullptr;
+            }   
+            
+        private:
+
+            std::queue<Element> m_Queue;
+            std::mutex m_QueueMutex;
+            std::condition_variable m_NonEmpty;
+    };  
+
+    template<class Msg>
+    class MsgQueue: public Queue<Msg *>
+    {
+        public:
+
+            typedef std::function<void()> OnEmpty;
+
+            MsgQueue (): m_IsRunning (true), m_Thread (std::bind (&MsgQueue<Msg>::Run, this))  {};
+            ~MsgQueue () { Stop (); };
+            void Stop()
+            {
+                if (m_IsRunning)
+                {
+                    m_IsRunning = false;
+                    Queue<Msg *>::WakeUp ();                    
+                    m_Thread.join();
+                }
+            }
+
+            void SetOnEmpty (OnEmpty const & e) { m_OnEmpty = e; };
+
+        private:
+
+            void Run ()
+            {
+                while (m_IsRunning)
+                {
+                    while (auto msg = Queue<Msg *>::Get ())
+                    {
+                        msg->Process ();
+                        delete msg;
+                    }
+                    if (m_OnEmpty != nullptr)
+                        m_OnEmpty ();
+                    if (m_IsRunning)
+                        Queue<Msg *>::Wait ();
+                }   
+            }   
+            
+        private:
+            
+            volatile bool m_IsRunning;
+            OnEmpty m_OnEmpty;
+            std::thread m_Thread;   
+    };  
+}       
+}   
+
+#endif

util/Timestamp.h

@@ -0,0 +1,32 @@
+#ifndef TIMESTAMP_H__
+#define TIMESTAMP_H__
+
+#include <inttypes.h>
+#include <chrono>
+
+namespace i2p
+{
+namespace util
+{
+    inline uint64_t GetMillisecondsSinceEpoch ()
+    {
+        return std::chrono::duration_cast<std::chrono::milliseconds>(
+                 std::chrono::system_clock::now().time_since_epoch()).count ();
+    }
+
+    inline uint32_t GetHoursSinceEpoch ()
+    {
+        return std::chrono::duration_cast<std::chrono::hours>(
+                 std::chrono::system_clock::now().time_since_epoch()).count ();
+    }
+
+    inline uint64_t GetSecondsSinceEpoch ()
+    {
+        return std::chrono::duration_cast<std::chrono::seconds>(
+                 std::chrono::system_clock::now().time_since_epoch()).count ();
+    }
+}
+}
+
+#endif
+

util/util.cpp

@@ -0,0 +1,667 @@
+#include <cstdlib>
+#include <string>
+#include <algorithm>
+#include <cctype>
+#include <functional>
+#include <fstream>
+#include <set>
+#include <boost/asio.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/program_options/detail/config_file.hpp>
+#include <boost/program_options/parsers.hpp>
+#include <boost/algorithm/string.hpp>
+#include "util.h"
+#include "Log.h"
+
+#if defined(__linux__) || defined(__FreeBSD_kernel__)
+#include <sys/types.h>
+#include <ifaddrs.h>
+#elif defined(WIN32)
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>    
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <iphlpapi.h>
+#include <shlobj.h>
+
+#pragma comment(lib, "IPHLPAPI.lib")
+
+#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
+#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))
+
+int inet_pton(int af, const char *src, void *dst)
+{ /* This function was written by Petar Korponai?. See
+http://stackoverflow.com/questions/15660203/inet-pton-identifier-not-found */
+    struct sockaddr_storage ss;
+    int size = sizeof (ss);
+    char src_copy[INET6_ADDRSTRLEN + 1];
+
+    ZeroMemory (&ss, sizeof (ss));
+    strncpy_s (src_copy, src, INET6_ADDRSTRLEN + 1);
+    src_copy[INET6_ADDRSTRLEN] = 0;
+
+    if (WSAStringToAddress (src_copy, af, NULL, (struct sockaddr *)&ss, &size) == 0)
+    {
+        switch (af)
+        {
+            case AF_INET:
+                *(struct in_addr *)dst = ((struct sockaddr_in *)&ss)->sin_addr;
+                return 1;
+            case AF_INET6:
+                *(struct in6_addr *)dst = ((struct sockaddr_in6 *)&ss)->sin6_addr;
+                return 1;
+        }
+    }
+    return 0;
+}
+#endif
+
+namespace i2p {
+namespace util {
+
+namespace config {
+    std::map<std::string, std::string> mapArgs;
+    std::map<std::string, std::vector<std::string> > mapMultiArgs;
+
+    void OptionParser(int argc, const char* const argv[])
+    {
+        mapArgs.clear();
+        mapMultiArgs.clear();
+        for(int i = 1; i < argc; ++i) {
+            std::string strKey (argv[i]);
+            std::string strValue;
+            size_t has_data = strKey.find('=');
+            if(has_data != std::string::npos) {
+                strValue = strKey.substr(has_data+1);
+                strKey = strKey.substr(0, has_data);
+            }
+
+#ifdef WIN32
+            boost::to_lower(strKey);
+            if(boost::algorithm::starts_with(strKey, "/"))
+                strKey = "-" + strKey.substr(1);
+#endif
+            if(strKey[0] != '-')
+                break;
+
+            mapArgs[strKey] = strValue;
+            mapMultiArgs[strKey].push_back(strValue);
+        }
+
+        for(auto& entry : mapArgs) {
+            std::string name = entry.first;
+
+            //  interpret --foo as -foo (as long as both are not set)
+            if (name.find("--") == 0) {
+                std::string singleDash(name.begin()+1, name.end());
+                if (mapArgs.count(singleDash) == 0)
+                    mapArgs[singleDash] = entry.second;
+                name = singleDash;
+            }
+        }
+    }
+
+    const char* GetCharArg(const std::string& strArg, const std::string& nDefault)
+    {
+        if(mapArgs.count(strArg))
+            return mapArgs[strArg].c_str();
+        return nDefault.c_str();
+    }
+
+    std::string GetArg(const std::string& strArg, const std::string& strDefault)
+    {
+        if(mapArgs.count(strArg))
+            return mapArgs[strArg];
+        return strDefault;
+    }
+
+    int GetArg(const std::string& strArg, int nDefault)
+    {
+        if(mapArgs.count(strArg))
+            return stoi(mapArgs[strArg]);
+        return nDefault;
+    }
+
+}
+
+namespace filesystem
+{
+    std::string appName("i2pd");
+
+    void SetAppName(const std::string& name)
+    {
+        appName = name;
+    }
+
+    std::string GetAppName()
+    {
+        return appName;
+    }
+
+    const boost::filesystem::path& GetDataDir()
+    {
+        static boost::filesystem::path path;
+
+        // TODO: datadir parameter is useless because GetDataDir is called before OptionParser
+        // and mapArgs is not initialized yet
+        /*if (i2p::util::config::mapArgs.count("-datadir")) 
+            path = boost::filesystem::system_complete(i2p::util::config::mapArgs["-datadir"]);
+        else */
+        path = GetDefaultDataDir();
+
+        if(!boost::filesystem::exists(path)) {
+            // Create data directory
+            if(!boost::filesystem::create_directory(path)) {
+                LogPrint("Failed to create data directory!");
+                path = "";
+                return path;
+            }
+        }
+        if(!boost::filesystem::is_directory(path)) 
+            path = GetDefaultDataDir();
+        return path;
+    }
+
+    std::string GetFullPath(const std::string& filename)
+    {
+        std::string fullPath = GetDataDir().string();
+#ifndef _WIN32
+        fullPath.append("/");
+#else
+        fullPath.append("\\");
+#endif
+        fullPath.append(filename);
+        return fullPath;
+    }       
+
+    boost::filesystem::path GetConfigFile()
+    {
+        boost::filesystem::path pathConfigFile(i2p::util::config::GetArg("-conf", "i2p.conf"));
+        if(!pathConfigFile.is_complete())
+            pathConfigFile = GetDataDir() / pathConfigFile;
+        return pathConfigFile;
+    }
+
+    boost::filesystem::path GetDefaultDataDir()
+    {
+        // Windows < Vista: C:\Documents and Settings\Username\Application Data\i2pd
+        // Windows >= Vista: C:\Users\Username\AppData\Roaming\i2pd
+        // Mac: ~/Library/Application Support/i2pd
+        // Unix: ~/.i2pd or /var/lib/i2pd is system=1
+
+#ifdef WIN32
+        // Windows
+        char localAppData[MAX_PATH];
+        SHGetFolderPath(NULL, CSIDL_APPDATA, 0, NULL, localAppData);
+        return boost::filesystem::path(std::string(localAppData) + "\\" + appName);
+#else
+        if(i2p::util::config::GetArg("-service", 0)) // use system folder
+            return boost::filesystem::path(std::string ("/var/lib/") + appName);
+        boost::filesystem::path pathRet;
+        char* pszHome = getenv("HOME");
+        if(pszHome == NULL || strlen(pszHome) == 0)
+            pathRet = boost::filesystem::path("/");
+        else
+            pathRet = boost::filesystem::path(pszHome);
+#ifdef MAC_OSX
+        // Mac
+        pathRet /= "Library/Application Support";
+        boost::filesystem::create_directory(pathRet);
+        return pathRet / appName;
+#else
+        // Unix
+        return pathRet / (std::string (".") + appName);
+#endif
+#endif
+    }
+
+    void ReadConfigFile(std::map<std::string, std::string>& mapSettingsRet,
+                        std::map<std::string, std::vector<std::string> >& mapMultiSettingsRet)
+    {
+        boost::filesystem::ifstream streamConfig(GetConfigFile());
+        if(!streamConfig.good())
+            return; // No i2pd.conf file is OK
+
+        std::set<std::string> setOptions;
+        setOptions.insert("*");
+
+        for(boost::program_options::detail::config_file_iterator it(streamConfig, setOptions), end;
+          it != end; ++it) {
+            // Don't overwrite existing settings so command line settings override i2pd.conf
+            std::string strKey = std::string("-") + it->string_key;
+            if(mapSettingsRet.count(strKey) == 0) {
+                mapSettingsRet[strKey] = it->value[0];
+            }
+            mapMultiSettingsRet[strKey].push_back(it->value[0]);
+        }
+    }
+
+    boost::filesystem::path GetCertificatesDir()
+    {
+        return GetDataDir () / "certificates";
+    }
+}
+
+namespace http
+{
+    std::string httpRequest(const std::string& address)
+    {
+        try {
+            i2p::util::http::url u(address);
+            boost::asio::ip::tcp::iostream site;
+            // please don't uncomment following line because it's not compatible with boost 1.46
+            // 1.46 is default boost for Ubuntu 12.04 LTS
+            //site.expires_from_now (boost::posix_time::seconds(30));
+            if(u.port_ == 80)
+                site.connect(u.host_, "http");
+            else {
+                std::stringstream ss; ss << u.port_;
+                site.connect(u.host_, ss.str());
+            }
+            if(site) {
+                // User-Agent is needed to get the server list routerInfo files.
+                site << "GET " << u.path_ << " HTTP/1.1\r\nHost: " << u.host_
+                     << "\r\nAccept: */*\r\n" << "User-Agent: Wget/1.11.4\r\n"
+                     << "Connection: close\r\n\r\n";
+                // read response and extract content                
+                return GetHttpContent(site);
+            } else {
+                LogPrint("Can't connect to ", address);
+                return "";
+            }
+        } catch(const std::exception& ex) {
+            LogPrint("Failed to download ", address, " : ", ex.what());
+            return "";
+        }
+    }
+
+    std::string GetHttpContent (std::istream& response)
+    {
+        std::string version, statusMessage;
+        response >> version; // HTTP version
+        int status;
+        response >> status; // status
+        std::getline (response, statusMessage);
+        if(status == 200) { // OK
+            bool isChunked = false;
+            std::string header;
+            while(!response.eof() && header != "\r") {
+                std::getline(response, header);
+                auto colon = header.find (':');
+                if(colon != std::string::npos) {
+                    std::string field = header.substr (0, colon);
+                    if(field == i2p::util::http::TRANSFER_ENCODING)
+                        isChunked = (header.find("chunked", colon + 1) != std::string::npos);
+                }
+            }
+
+            std::stringstream ss;
+            if(isChunked)
+                MergeChunkedResponse(response, ss);
+            else    
+                ss << response.rdbuf();
+
+            return ss.str();
+        } else {
+            LogPrint("HTTP response ", status);
+            return "";
+        }
+    }
+
+    void MergeChunkedResponse(std::istream& response, std::ostream& merged)
+    {
+        while(!response.eof()) {   
+            std::string hexLen;
+            int len;
+            std::getline(response, hexLen);
+            std::istringstream iss(hexLen);
+            iss >> std::hex >> len;
+            if(!len)
+                break;
+            char* buf = new char[len];
+            response.read(buf, len);
+            merged.write(buf, len);
+            delete[] buf;
+            std::getline(response, hexLen); // read \r\n after chunk
+        }
+    }   
+    
+    int httpRequestViaI2pProxy(const std::string& address, std::string &content)
+    {
+        content = "";
+        try {
+            boost::asio::ip::tcp::iostream site;
+            // please don't uncomment following line because it's not compatible with boost 1.46
+            // 1.46 is default boost for Ubuntu 12.04 LTS
+            //site.expires_from_now (boost::posix_time::seconds(30));
+            {
+                std::stringstream ss; ss << i2p::util::config::GetArg("-httpproxyport", 4446);
+                site.connect("127.0.0.1", ss.str());
+            }
+            if(site) {
+                i2p::util::http::url u(address);
+                std::stringstream ss;
+                ss << "GET " << address << " HTTP/1.0" << std::endl;
+                ss << "Host: " << u.host_ << std::endl;
+                ss << "Accept: */*" << std::endl;
+                ss << "User - Agent: Wget / 1.11.4" << std::endl;
+                ss << "Connection: close" << std::endl;
+                ss << std::endl;
+                site << ss.str();
+
+                // read response
+                std::string version, statusMessage;
+                site >> version; // HTTP version
+                int status;
+                site >> status; // status
+                std::getline(site, statusMessage);
+                if(status == 200) { // OK
+                    std::string header;
+                    while(std::getline(site, header) && header != "\r"){}
+                    std::stringstream ss;
+                    ss << site.rdbuf();
+                    content = ss.str();
+                    return status;
+                } else {
+                    LogPrint("HTTP response ", status);
+                    return status;
+                }
+            } else {
+                LogPrint("Can't connect to proxy");
+                return 408;
+            }
+        } catch (std::exception& ex) {
+            LogPrint("Failed to download ", address, " : ", ex.what());
+            return 408;
+        }
+    }
+    
+    url::url(const std::string& url_s)
+    {
+        portstr_ = "80";
+        port_ = 80;
+        user_ = "";
+        pass_ = "";
+
+        parse(url_s);
+    }
+
+
+    void url::parse(const std::string& url_s)
+    {
+        const std::string prot_end("://");
+        std::string::const_iterator prot_i = search(
+            url_s.begin(), url_s.end(), prot_end.begin(), prot_end.end()
+        );
+        protocol_.reserve(distance(url_s.begin(), prot_i));
+        // Make portocol lowercase
+        transform(
+            url_s.begin(), prot_i, back_inserter(protocol_), std::ptr_fun<int, int>(std::tolower)
+        ); 
+        if(prot_i == url_s.end())
+            return;
+        advance(prot_i, prot_end.length());
+        std::string::const_iterator path_i = find(prot_i, url_s.end(), '/');
+        host_.reserve(distance(prot_i, path_i));
+        // Make host lowerase
+        transform(prot_i, path_i, back_inserter(host_), std::ptr_fun<int, int>(std::tolower));
+
+        // parse user/password
+        auto user_pass_i = find(host_.begin(), host_.end(), '@');
+        if(user_pass_i != host_.end()) {
+            std::string user_pass = std::string(host_.begin(), user_pass_i);
+            auto pass_i = find(user_pass.begin(), user_pass.end(), ':');
+            if (pass_i != user_pass.end()) {
+                user_ = std::string(user_pass.begin(), pass_i);
+                pass_ = std::string(pass_i + 1, user_pass.end());
+            } else
+                user_ = user_pass;
+
+            host_.assign(user_pass_i + 1, host_.end());
+        }
+
+        // parse port
+        auto port_i = find(host_.begin(), host_.end(), ':');
+        if(port_i != host_.end()) {
+            portstr_ = std::string(port_i + 1, host_.end());
+            host_.assign(host_.begin(), port_i);
+            try {
+                port_ = boost::lexical_cast<decltype(port_)>(portstr_);
+            } catch(const std::exception& e) {
+                port_ = 80;
+            }
+        }
+
+        std::string::const_iterator query_i = find(path_i, url_s.end(), '?');
+        path_.assign(path_i, query_i);
+        if( query_i != url_s.end() )
+            ++query_i;
+        query_.assign(query_i, url_s.end());
+    }
+
+    std::string urlDecode(const std::string& data)
+    {
+        std::string res(data);
+        for(size_t pos = res.find('%'); pos != std::string::npos; pos = res.find('%', pos + 1)) {
+            const char c = strtol(res.substr(pos + 1, 2).c_str(), NULL, 16);
+            res.replace(pos, 3, 1, c);
+        }
+        return res;
+    }
+} 
+
+namespace net {
+
+#if defined(__linux__) || defined(__FreeBSD_kernel__)   
+    
+    int GetMTUUnix(const boost::asio::ip::address& localAddress, int fallback)
+    {
+        ifaddrs* ifaddr, *ifa = nullptr;
+        if(getifaddrs(&ifaddr) == -1) {
+            LogPrint(eLogError, "Can't excute getifaddrs");
+            return fallback;
+        }
+
+        int family = 0;
+        // look for interface matching local address   
+        for(ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next) {
+            if(!ifa->ifa_addr)
+                continue;
+
+            family = ifa->ifa_addr->sa_family;
+            if(family == AF_INET && localAddress.is_v4()) {
+                sockaddr_in* sa = (sockaddr_in*) ifa->ifa_addr;
+                if(!memcmp(&sa->sin_addr, localAddress.to_v4().to_bytes().data(), 4))
+                    break; // address matches
+            } else if(family == AF_INET6 && localAddress.is_v6()) {
+                sockaddr_in6* sa = (sockaddr_in6*) ifa->ifa_addr;
+                if(!memcmp(&sa->sin6_addr, localAddress.to_v6().to_bytes().data(), 16))
+                    break; // address matches
+            }
+        }
+        int mtu = fallback;
+        if(ifa && family) { // interface found?
+            int fd = socket(family, SOCK_DGRAM, 0);
+            if(fd > 0) {
+                ifreq ifr;
+                strncpy(ifr.ifr_name, ifa->ifa_name, IFNAMSIZ); // set interface for query
+                if(ioctl(fd, SIOCGIFMTU, &ifr) >= 0)  
+                    mtu = ifr.ifr_mtu; // MTU
+                else
+                    LogPrint (eLogError, "Failed to run ioctl");            
+                close(fd);
+            } else
+                LogPrint(eLogError, "Failed to create datagram socket");   
+        } else {
+            LogPrint(
+                eLogWarning, "Interface for local address",
+                localAddress.to_string(), " not found"
+            );
+        }
+
+        freeifaddrs(ifaddr);
+
+        return mtu;
+    }
+
+#elif defined(WIN32)
+    int GetMTUWindowsIpv4(sockaddr_in inputAddress, int fallback)
+    {
+        ULONG outBufLen = 0;
+        PIP_ADAPTER_ADDRESSES pAddresses = nullptr;
+        PIP_ADAPTER_ADDRESSES pCurrAddresses = nullptr;
+        PIP_ADAPTER_UNICAST_ADDRESS pUnicast = nullptr;
+
+
+        if(GetAdaptersAddresses(AF_INET, GAA_FLAG_INCLUDE_PREFIX, nullptr, pAddresses, &outBufLen)
+          == ERROR_BUFFER_OVERFLOW) {
+            FREE(pAddresses);
+            pAddresses = (IP_ADAPTER_ADDRESSES*) MALLOC(outBufLen);
+        }
+
+        DWORD dwRetVal = GetAdaptersAddresses(
+            AF_INET, GAA_FLAG_INCLUDE_PREFIX, nullptr, pAddresses, &outBufLen
+        );
+
+        if(dwRetVal != NO_ERROR) {
+            LogPrint(
+                eLogError, "GetMTU() has failed: enclosed GetAdaptersAddresses() call has failed"
+            );
+            FREE(pAddresses);
+            return fallback;
+        }
+
+        pCurrAddresses = pAddresses;
+        while(pCurrAddresses) {
+            PIP_ADAPTER_UNICAST_ADDRESS firstUnicastAddress = pCurrAddresses->FirstUnicastAddress;
+
+            pUnicast = pCurrAddresses->FirstUnicastAddress;
+            if(pUnicast == nullptr) {
+                LogPrint(
+                    eLogError, "GetMTU() has failed: not a unicast ipv4 address, this is not supported"
+                );
+            }
+            for(int i = 0; pUnicast != nullptr; ++i) {
+                LPSOCKADDR lpAddr = pUnicast->Address.lpSockaddr;
+                sockaddr_in* localInterfaceAddress = (sockaddr_in*) lpAddr;
+                if(localInterfaceAddress->sin_addr.S_un.S_addr == inputAddress.sin_addr.S_un.S_addr) {
+                    result = pAddresses->Mtu;
+                    FREE(pAddresses);
+                    return result;
+                }
+                pUnicast = pUnicast->Next;
+            }
+            pCurrAddresses = pCurrAddresses->Next;
+        }
+
+        LogPrint(eLogError, "GetMTU() error: no usable unicast ipv4 addresses found");
+        FREE(pAddresses);
+        return fallback;
+    }
+
+    int GetMTUWindowsIpv6(sockaddr_in6 inputAddress, int fallback)
+    {
+        ULONG outBufLen = 0;
+        PIP_ADAPTER_ADDRESSES pAddresses = nullptr;
+        PIP_ADAPTER_ADDRESSES pCurrAddresses = nullptr;
+        PIP_ADAPTER_UNICAST_ADDRESS pUnicast = nullptr;
+
+        if(GetAdaptersAddresses(AF_INET6, GAA_FLAG_INCLUDE_PREFIX, nullptr, pAddresses, &outBufLen)
+          == ERROR_BUFFER_OVERFLOW) {
+            FREE(pAddresses);
+            pAddresses = (IP_ADAPTER_ADDRESSES*) MALLOC(outBufLen);
+        }
+
+        DWORD dwRetVal = GetAdaptersAddresses(
+            AF_INET6, GAA_FLAG_INCLUDE_PREFIX, nullptr, pAddresses, &outBufLen
+        );
+
+        if(dwRetVal != NO_ERROR) {
+            LogPrint(
+                eLogError,
+                "GetMTU() has failed: enclosed GetAdaptersAddresses() call has failed"
+            );
+            FREE(pAddresses);
+            return fallback;
+        }
+
+        bool found_address = false;
+        pCurrAddresses = pAddresses;
+        while(pCurrAddresses) {
+            PIP_ADAPTER_UNICAST_ADDRESS firstUnicastAddress = pCurrAddresses->FirstUnicastAddress;
+            pUnicast = pCurrAddresses->FirstUnicastAddress;
+            if(pUnicast == nullptr) {
+                LogPrint(
+                    eLogError,
+                    "GetMTU() has failed: not a unicast ipv6 address, this is not supported"
+                );
+            }
+            for(int i = 0; pUnicast != nullptr; ++i) {
+                LPSOCKADDR lpAddr = pUnicast->Address.lpSockaddr;
+                sockaddr_in6 *localInterfaceAddress = (sockaddr_in6*) lpAddr;
+
+                for (int j = 0; j != 8; ++j) {
+                    if (localInterfaceAddress->sin6_addr.u.Word[j] != inputAddress.sin6_addr.u.Word[j]) {
+                        break;
+                    } else {
+                        found_address = true;
+                    }
+                } if (found_address) {
+                    result = pAddresses->Mtu;
+                    FREE(pAddresses);
+                    pAddresses = nullptr;
+                    return result;
+                }
+                pUnicast = pUnicast->Next;
+            }
+
+            pCurrAddresses = pCurrAddresses->Next;
+        }
+
+        LogPrint(eLogError, "GetMTU() error: no usable unicast ipv6 addresses found");
+        FREE(pAddresses);
+        return fallback;
+    }
+
+    int GetMTUWindows(const boost::asio::ip::address& localAddress, int fallback)
+    { 
+#ifdef UNICODE
+        string localAddress_temporary = localAddress.to_string();
+        wstring localAddressUniversal(localAddress_temporary.begin(), localAddress_temporary.end());
+#else
+        std::string localAddressUniversal = localAddress.to_string();
+#endif
+
+        if(localAddress.is_v4()) {
+            sockaddr_in inputAddress;
+            inet_pton(AF_INET, localAddressUniversal.c_str(), &(inputAddress.sin_addr));
+            return GetMTUWindowsIpv4(inputAddress, fallback);
+        } else if(localAddress.is_v6()) {
+            sockaddr_in6 inputAddress;
+            inet_pton(AF_INET6, localAddressUniversal.c_str(), &(inputAddress.sin6_addr)); 
+            return GetMTUWindowsIpv6(inputAddress, fallback);
+        } else {
+            LogPrint(eLogError, "GetMTU() has failed: address family is not supported");
+            return fallback;
+        }
+
+    }
+#endif // WIN32
+
+    int GetMTU(const boost::asio::ip::address& localAddress)
+    {
+        const int fallback = 576; // fallback MTU
+
+#if defined(__linux__) || defined(__FreeBSD_kernel__)
+        return GetMTUUnix(localAddress, fallback);
+#elif defined(WIN32)
+        return GetMTUWindows(localAddress, fallback);
+#endif
+    }
+} 
+
+} // util
+} // i2p

util/util.h

@@ -0,0 +1,157 @@
+#ifndef UTIL_H
+#define UTIL_H
+
+#include <map>
+#include <string>
+#include <iostream>
+#include <boost/asio.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+
+#define PAIRTYPE(t1, t2)    std::pair<t1, t2>
+
+namespace i2p
+{
+namespace util
+{
+    namespace config
+    {
+        extern std::map<std::string, std::string> mapArgs;
+        extern std::map<std::string, std::vector<std::string> > mapMultiArgs;
+
+        /**
+         * Parses command line arguments, i.e. stores them in config::mapArgs.
+         */
+        void OptionParser(int argc, const char* const argv[]);
+
+        /**
+         * @return a command line argument from config::mapArgs as an int
+         * @param nDefault the default value to be returned
+         */
+        int GetArg(const std::string& strArg, int nDefault);
+
+        /**
+         * @return a command line argument from config::mapArgs as a std::string
+         * @param strDefault the default value to be returned
+         */
+        std::string GetArg(const std::string& strArg, const std::string& strDefault);
+
+        /**
+         * @return a command line argument from config::mapArgs as a C-style string
+         * @param nDefault the default value to be returned
+         */
+        const char* GetCharArg(const std::string& strArg, const std::string& nDefault);
+    }
+
+    namespace filesystem
+    {
+        /**
+         * Change the application name.
+         */
+        void SetAppName(const std::string& name);
+
+        /**
+         * @return the application name.
+         */
+        std::string GetAppName();
+
+        /**
+         * @return the path of the i2pd directory
+         */
+        const boost::filesystem::path& GetDataDir();
+
+        /**
+         * @return the full path of a file within the i2pd directory
+         */
+        std::string GetFullPath(const std::string& filename);
+
+        /**
+         * @return the path of the configuration file
+         */
+        boost::filesystem::path GetConfigFile();
+
+        /**
+         * @return the default directory for i2pd data
+         */
+        boost::filesystem::path GetDefaultDataDir();
+
+        
+        /**
+         * Read a configuration file and store its contents in the given maps.
+         */
+        void ReadConfigFile(std::map<std::string, std::string>& mapSettingsRet,
+                std::map<std::string, std::vector<std::string> >& mapMultiSettingsRet);
+
+        /**
+         * @return the path of the certificates directory
+         */
+        boost::filesystem::path GetCertificatesDir();
+    }
+
+    namespace http
+    {
+        const char ETAG[] = "ETag";
+        const char IF_NONE_MATCH[] = "If-None-Match";
+        const char IF_MODIFIED_SINCE[] = "If-Modified-Since";
+        const char LAST_MODIFIED[] = "Last-Modified";
+        const char TRANSFER_ENCODING[] = "Transfer-Encoding";
+
+        /**
+         * Perform an HTTP request.
+         * @return the result of the request, or an empty string if it fails
+         */
+        std::string httpRequest(const std::string& address);
+
+        /**
+         * @return the content of the given HTTP stream without headers
+         */
+        std::string GetHttpContent(std::istream& response);
+
+        /**
+         * Merge chunks of a HTTP response into the gien std:ostream object.
+         */
+        void MergeChunkedResponse(std::istream& response, std::ostream& merged);
+
+        /**
+         * Send an HTTP request through the i2p proxy.
+         * @return the HTTP status code 
+         */
+        int httpRequestViaI2pProxy(const std::string& address, std::string &content);
+
+
+        /**
+         * @return the decoded url
+         */
+        std::string urlDecode(const std::string& data);
+        
+        /**
+         * Provides functionality for parsing URLs.
+         */
+        struct url {
+            /**
+             * Parse a url given as a string.
+             */
+            url(const std::string& url_s);
+        private:
+            void parse(const std::string& url_s);
+        public:
+            std::string protocol_, host_, path_, query_;
+            std::string portstr_;
+            unsigned int port_;
+            std::string user_;
+            std::string pass_;
+        };
+    }
+
+    namespace net
+    {
+        /**
+         * @return the maximum transmission unit, or 576 on failure
+         */
+        int GetMTU(const boost::asio::ip::address& localAddress);
+    }
+}
+}
+
+
+#endif