root/lang/c/kazuhiki/trunk/kazuhiki/network_impl.h @ 20958

/*
 * Kazuhiki
 *
 * Copyright (C) 2007-2008 FURUHASHI Sadayuki
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#ifndef KAZUHIKI_NETWORK_IMPL_H__
#define KAZUHIKI_NETWORK_IMPL_H__

#include <arpa/inet.h>
#include <netdb.h>
#ifndef DISABLE_IFADDRS
#include <ifaddrs.h>
#endif

namespace Kazuhiki {
namespace Accept {

namespace detail {

template <typename Address>
bool ConvertHostNameIMPL(const char* arg, Address& addr, bool resolve,
                int family, int flags)
{
        Address v;
        memset(&v, 0, sizeof(v));
        if( !resolve ) {
#ifndef DISABLE_IPV6
                if( family == AF_UNSPEC ) {
                        if( inet_pton(AF_INET,  arg, &((struct sockaddr_in* )&v)->sin_addr) > 0 ){
                                ((struct sockaddr_in*)&v)->sin_family = AF_INET;
                                //((struct sockaddr_in*)&v)->sin_len = sizeof(struct sockaddr_in);
                        } else if( inet_pton(AF_INET6, arg, &((struct sockaddr_in6*)&v)->sin6_addr) > 0 ) {
                                ((struct sockaddr_in6*)&v)->sin6_family = AF_INET6;
                                //((struct sockaddr_in6*)&v)->sin6_len = sizeof(struct sockaddr_in6);
                        } else {
                                return false;
                        }
                } else if( family == AF_INET ) {
                        if( inet_pton(AF_INET,  arg, &((struct sockaddr_in* )&v)->sin_addr) > 0 ){
                                ((struct sockaddr_in*)&v)->sin_family = AF_INET;
                                //((struct sockaddr_in*)&v)->sin_len = sizeof(struct sockaddr_in);
                        } else {
                                return false;
                        }
                } else {  // family == AF_INET6
                        if( inet_pton(AF_INET6, arg, &((struct sockaddr_in6*)&v)->sin6_addr) > 0 ) {
                                ((struct sockaddr_in6*)&v)->sin6_family = AF_INET6;
                                //((struct sockaddr_in6*)&v)->sin6_len = sizeof(struct sockaddr_in6);
                        } else {
                                return false;
                        }
                }
#else
                return inet_aton(arg, &v.sin_addr);
#endif
        } else {
#ifndef DISABLE_GETADDRINFO
                struct addrinfo hints;
                memset(&hints, 0, sizeof(hints));
                hints.ai_family = family;
                hints.ai_socktype = SOCK_STREAM;    // TODO: 指定する？
                hints.ai_flags = flags;
                struct addrinfo *res = NULL;
                int err;
                if( (err=getaddrinfo(arg, NULL, &hints, &res)) != 0 ) {
                        return false;
                }
                struct addrinfo* rp(res);  // 最初の一つを使う
                memcpy(&v, rp->ai_addr, rp->ai_addrlen);
                freeaddrinfo(res);
#else
                struct hostent* ent = gethostbyname(arg);
                if(!ent) { return false; }
                ((struct sockaddr_in*)&v)->sin_family = AF_INET;
                memcpy(&((struct sockaddr_in*)&v)->sin_addr, ent->h_addr_list[0], ent->h_length); // 最初の一つを使う
#endif
        }
        addr = v;
        return true;
}

inline bool ConvertHostName(const char* arg, struct sockaddr_in& addr, bool resolve = true)
{
        return ConvertHostNameIMPL(arg, addr, resolve, AF_INET, 0);
}
#ifndef DISABLE_IPV6
inline bool ConvertHostName(const char* arg, struct sockaddr_in6& addr, bool resolve = true)
{
        return ConvertHostNameIMPL(arg, addr, resolve, AF_INET6, 0);
}
inline bool ConvertHostName(const char* arg, struct sockaddr_storage& addr, bool resolve = true)
{
        return ConvertHostNameIMPL(arg, addr, resolve, AF_UNSPEC, AI_ADDRCONFIG);
}
#endif


inline bool ConvertAnyAddress(struct sockaddr_in& addr, unsigned short port) {
        memset(&addr, 0, sizeof(addr));
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = INADDR_ANY;
        return true;
}
#ifndef DISABLE_IPV6
inline bool ConvertAnyAddress(struct sockaddr_in6& addr, unsigned short port) {
        memset(&addr, 0, sizeof(addr));
        addr.sin6_family = AF_INET6;
        addr.sin6_port = htons(port);
        addr.sin6_addr = in6addr_any;
        return true;
}
inline bool ConvertAnyAddress(struct sockaddr_storage& addr, unsigned short port) {
        memset(&addr, 0, sizeof(addr));
        addr.ss_family = AF_INET6;
        ((struct sockaddr_in6*)&addr)->sin6_port = htons(port);
        ((struct sockaddr_in6*)&addr)->sin6_addr = in6addr_any;
        return true;
}
#endif


#ifndef DISABLE_IFADDRS
template <typename Address>
bool ConvertNetworkInterfaceIMPL(const char* str, Address& addr,
                int family, unsigned short port)
{
        struct ifaddrs* ifap;
        if( getifaddrs(&ifap) ) {
                return false;
        }
        for(struct ifaddrs* i(ifap); i != NULL; i = i->ifa_next) {
                if( i->ifa_addr == NULL) { continue; }
                if( strcmp(str, i->ifa_name) != 0 ) { continue; }
                if( family == AF_UNSPEC || i->ifa_addr->sa_family == family ) {
                        memcpy(&addr, i->ifa_addr, sizeof(addr));
                        ((struct sockaddr_in*)&addr)->sin_port = htons(port);
                        freeifaddrs(ifap);
                        return true;
                }
        }
        freeifaddrs(ifap);
        return false;
}
inline bool ConvertNetworkInterface(const char* str, struct sockaddr_in& addr,
                unsigned short port)
{
        return ConvertNetworkInterfaceIMPL(str, addr, AF_INET, port);
}
#ifndef DISABLE_IPV6
inline bool ConvertNetworkInterface(const char* str, struct sockaddr_in6& addr,
                unsigned short port)
{
        return ConvertNetworkInterfaceIMPL(str, addr, AF_INET6, port);
}
inline bool ConvertNetworkInterface(const char* str, struct sockaddr_storage& addr,
                unsigned short port)
{
        return ConvertNetworkInterfaceIMPL(str, addr, AF_UNSPEC, port);
}
#endif
#endif

}  // namespace detail


template <typename Address>
unsigned int HostNameTMPL<Address>::operator() (int argc, const char* argv[])
{
        if( argc < 1 ) { throw LackOfArgumentsError("Host name is required"); }
        if( !detail::ConvertHostName(argv[0], data, true) ) {
                throw InvalidArgumentError("Invalid host name");
        }
        return 1;
}


template <typename Address>
unsigned int IPAddressTMPL<Address>::operator() (int argc, const char* argv[])
{
        if( argc < 1 ) { throw LackOfArgumentsError("IP address is required"); }
        if( !detail::ConvertHostName(argv[0], data, false) ) {
                throw InvalidArgumentError("Invalid address");
        }
        return 1;
}


// 1. interface:port
// 2. ip.add.re.ss:port
// 3. [ip:add::re:ss]:port   (ipv6)
// 4. :port
// 5. port
// 6. interface      (default port)
// 7. ip.add.re.ss   (default port)
// 8. ip::add::re:ss  (default port, ipv6)
template <typename Address>
unsigned int ListenAddressTMPL<Address>::operator() (int argc, const char* argv[])
{
        if( argc < 1 ) { throw LackOfArgumentsError("Network interface name or address:port is required"); }
        if( !parse(argv[0]) ) {
                throw InvalidArgumentError("Network interface name or address:port is required");
        }
        return 1;
}

template <typename Address>
bool ListenAddressTMPL<Address>::parse(const std::string& str)
{
        std::string::size_type posc;
        if( (posc = str.rfind(':')) != std::string::npos ) {
                // 1 .. 4, 8
                if( str.find(':') != posc ) {
                        // 3, 8
                        if( posc != 0 && str[posc-1] == ']' && str[0] == '[' ) {
                                // 3
                                std::string host( str.substr(1,posc-2) );
                                std::string port( str.substr(posc+1) );
                                return resolve_addr(host.c_str(), port.c_str());
                        } else {
                                // 8
                                return resolve_addr(str.c_str(), NULL);
                        }
                } else {
                        // 1, 2, 4
                        std::string host( str.substr(0,posc) );
                        std::string port( str.substr(posc+1) );
                        if( host.empty() ) {
                                // 4
                                return resolve_any(port.c_str());
                        } else if( resolve_addr(host.c_str(), port.c_str()) ) {
                                // 2
                                return true;
                        } else {
                                // 1
#ifndef DISABLE_IFADDRS
                                return resolve_netif(host.c_str(), port.c_str());
#else
                                return false;
#endif
                        }
                }
        } else {
                // 5 .. 7
                uint16_t p;
                if( detail::ConvertNumeric(str.c_str(), p) ) {
                        // 5
                        return resolve_any(str.c_str());
#ifndef DISABLE_IFADDRS
                } else if( resolve_netif(str.c_str(), NULL) ) {
                        // 6
                        return true;
#endif
                } else {
                        // 6
                        return resolve_addr(str.c_str(), NULL);
                }
        }
}

template <typename Address>
bool ListenAddressTMPL<Address>::resolve_addr(const char* addr, const char* port)
{
        unsigned short p = dport;
        if( port && !detail::ConvertNumeric(port, p) ) {
                return false;
        }
        if( !detail::ConvertHostName(addr, raddr, do_resolve) ) {
                return false;
        }
        ((struct sockaddr_in*)&raddr)->sin_port = htons(p);
        return true;
}

#ifndef DISABLE_IFADDRS
template <typename Address>
bool ListenAddressTMPL<Address>::resolve_netif(const char* netif, const char* port)
{
        unsigned short p = dport;
        if( port && !detail::ConvertNumeric(port, p) ) {
                return false;
        }
        if( !detail::ConvertNetworkInterface(netif, raddr, p) ) {
                return false;
        }
        ((struct sockaddr_in*)&raddr)->sin_port = htons(p);
        return true;
}
#endif

template <typename Address>
bool ListenAddressTMPL<Address>::resolve_any(const char* port)
{
        // FIXME
        unsigned short p = dport;
        if( port && !detail::ConvertNumeric(port, p) ) {
                return false;
        }
        if( !detail::ConvertAnyAddress(raddr, p) ) {
                return false;
        }
        ((struct sockaddr_in*)&raddr)->sin_port = htons(p);
        return true;
}


// 1. host:port
// 2. ip.add.re.ss:port
// 3. [ip:add::re:ss]:port   (ipv6)
// 4. host           (default port)
// 5. ip.add.re.ss   (default port)
// 6. ip:add::re:ss  (default port, ipv6)
template <typename Address>
unsigned int ConnectAddressTMPL<Address>::operator() (int argc, const char* argv[])
{
        if( argc < 1 ) { throw LackOfArgumentsError("Host name is required"); }
        if( !parse(argv[0]) ) {
                throw InvalidArgumentError("Host name is required");
        }
        return 1;
}

template <typename Address>
bool ConnectAddressTMPL<Address>::parse(const std::string& str)
{
        std::string::size_type posc;
        if( (posc = str.rfind(':')) != std::string::npos ) {
                // 1 .. 3, 6
                if( str.find(':') != posc ) {
                        // 3, 6
                        if( posc != 0 && str[posc-1] == ']' && str[0] == '[' ) {
                                // 3
                                std::string host( str.substr(1,posc-2) );
                                std::string port( str.substr(posc+1) );
                                return resolve_addr(host.c_str(), port.c_str());
                        } else {
                                // 6
                                return resolve_addr(str.c_str(), NULL);
                        }
                } else {
                        // 1, 2
                        // 1と2は区別しない
                        std::string host( str.substr(0,posc) );
                        std::string port( str.substr(posc+1) );
                        return resolve_addr(host.c_str(), port.c_str());
                }
        } else {
                // 4, 5
                // 4と5は区別しない
                return resolve_addr(str.c_str(), NULL);
        }
}

template <typename Address>
bool ConnectAddressTMPL<Address>::resolve_addr(const char* addr, const char* port)
{
        unsigned short p = dport;
        if( port && !detail::ConvertNumeric(port, p) ) {
                return false;
        }
        if( !detail::ConvertHostName(addr, raddr, do_resolve) ) {
                return false;
        }
        ((struct sockaddr_in*)&raddr)->sin_port = htons(p);
        return true;
}


template <typename Address>
unsigned int NetworkInterfaceTMPL<Address>::operator() (int argc, const char* argv[])
{
        if( argc < 1 ) { throw LackOfArgumentsError("Host name is required"); }
        if( !detail::ConvertNetworkInterface(argv[0], raddr, dport) ) {
                throw InvalidArgumentError("Invalid host name");
        }
        return 1;
}


}  // namespace Accept
}  // namespace Kazuhiki

#endif /* kazuhiki/network_impl.h */