// $Id$
//
// Copyright (C) 2006
-// Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
-// Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
-// Stefan Bund <stefan.bund@fokus.fraunhofer.de>
+// Fraunhofer Institute for Open Communication Systems (FOKUS)
+// Competence Center NETwork research (NET), St. Augustin, GERMANY
+// Stefan Bund <g0dil@berlios.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
#include <sys/socket.h>
#include <net/if.h>
#include <boost/lexical_cast.hpp>
-#include <boost/tokenizer.hpp>
-#include <boost/range.hpp>
+#include <boost/regex.hpp>
+#include "../../../Utils/senfassert.hh"
//#include "INetAddressing.mpp"
#define prefix_
///////////////////////////////cc.p////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
-// senf::INet4Address
+// senf::INet4SocketAddress
-prefix_ senf::INet4SocketAddress::INet4SocketAddress(std::string const & host, unsigned port)
+prefix_ senf::INet4SocketAddress::INet4SocketAddress(std::string const & addr)
{
clear();
- /** \todo gethostbyname support */
- if (::inet_aton(host.c_str(), &addr_.sin_addr) == 0)
- throw InvalidINetAddressException();
- addr_.sin_port = htons(port);
+ unsigned i = addr.find(':');
+ if (i == std::string::npos)
+ throw SyntaxException();
+ try {
+ port(boost::lexical_cast< ::u_int16_t >(std::string(addr,i+1)));
+ }
+ catch (boost::bad_lexical_cast const &) {
+ throw SyntaxException();
+ }
+ try {
+ address(INet4Address::from_string(std::string(addr,0,i)));
+ }
+ catch (INet4Address::SyntaxException const &) {
+ throw SyntaxException();
+ }
}
-prefix_ std::string senf::INet4SocketAddress::str()
- const
+prefix_ senf::INet4SocketAddress::INet4SocketAddress(INet4Address const & addr, unsigned p)
{
- std::stringstream s;
- s << host() << ':' << port();
- return s.str();
+ clear();
+ address(addr);
+ port(p);
}
prefix_ void senf::INet4SocketAddress::clear()
addr_.sin_family = AF_INET;
}
-prefix_ void senf::INet4SocketAddress::assignString(std::string const & address)
-{
- clear();
- unsigned i = address.find(':');
- if (i == std::string::npos)
- throw InvalidINetAddressException();
- // The temporary string in the next expr is guaranteed to live
- // until end-of-statement
- if (::inet_aton(std::string(address,0,i).c_str(), &addr_.sin_addr) == 0)
- throw InvalidINetAddressException();
- try {
- // Replace lexical_cast with strtoul ?
- addr_.sin_port = htons(boost::lexical_cast< ::u_int16_t >(std::string(address,i+1)));
- }
- catch (boost::bad_lexical_cast const &) {
- throw InvalidINetAddressException();
- }
-}
-
///////////////////////////////////////////////////////////////////////////
-// senf::INet6Address
+// senf::INet6SocketAddress
-prefix_ senf::INet6Address::INet6Address(std::string const & addr)
+prefix_ senf::INet6SocketAddress::INet6SocketAddress(std::string const & addr,
+ INet6Address::Resolve_t resolve)
{
- if (inet_pton(AF_INET6,addr.c_str(),&addr_) <= 0)
- throw InvalidINetAddressException();
-}
+ clear();
-prefix_ senf::INet6Address::INet6Address(char const * addr)
-{
- if (inet_pton(AF_INET6,addr,&addr_) <= 0)
- throw InvalidINetAddressException();
-}
+ // Format of addr: "[" address [ "%" interface ] "]" ":" port
+ // or: host ":" port
-prefix_ void senf::INet6Address::clear()
-{
- ::memset(&addr_,0,sizeof(addr_));
-}
+ static boost::regex const addressRx ("(?:\\[([a-f0-9A-F:]+)(?:%(.+))?\\]|(.+)):([0-9]+)");
+ // Subexpression numbers:
+ enum { NumericAddr = 1,
+ ZoneId = 2,
+ Hostname = 3,
+ Port = 4 };
+
+ boost::smatch match;
+ if (! regex_match(addr, match, addressRx))
+ throw SyntaxException();
-prefix_ std::string senf::INet6Address::address()
- const
-{
- char buffer[8*5];
- BOOST_ASSERT( inet_ntop(AF_INET6, &addr_, buffer, sizeof(buffer)) );
- return std::string(buffer);
-}
+ if (match[ZoneId].matched)
+ assignIface(match[ZoneId]);
-prefix_ bool senf::INet6Address::operator==(INet6Address const & other)
- const
-{
- return ::memcmp(&addr_,&other.addr_,sizeof(addr_))==0;
-}
+ sockaddr_.sin6_port = htons(boost::lexical_cast<boost::uint16_t>(match[Port]));
-prefix_ bool senf::INet6Address::operator!=(INet6Address const & other)
- const
-{
- return !operator==(other);
+ try {
+ INet6Address a (INet6Address::from_string(
+ match[NumericAddr].matched ? match[NumericAddr] : match[Hostname],
+ resolve));
+ std::copy(a.begin(), a.end(), &sockaddr_.sin6_addr.s6_addr[0]);
+ } catch (INet6Address::SyntaxException const &) {
+ throw SyntaxException();
+ }
}
-///////////////////////////////////////////////////////////////////////////
-// senf::INet6SocketAddress
-
prefix_ bool senf::INet6SocketAddress::operator==(INet6SocketAddress const & other)
const
{
sockaddr_.sin6_family = AF_INET6;
}
-prefix_ std::string senf::INet6SocketAddress::address()
- const
-{
- std::stringstream ss;
- ss << '[' << host();
- if (sockaddr_.sin6_scope_id != 0)
- ss << '@' << iface()
- << "]:" << port();
- return ss.str();
-}
-
prefix_ std::string senf::INet6SocketAddress::iface()
const
{
if (sockaddr_.sin6_scope_id == 0)
return "";
char buffer[IFNAMSIZ];
- BOOST_ASSERT( if_indextoname(sockaddr_.sin6_scope_id,buffer) );
+#ifndef SENF_NO_DEBUG
+ SENF_ASSERT( if_indextoname(sockaddr_.sin6_scope_id,buffer) );
+#else
+ if_indextoname(sockaddr_.sin6_scope_id,buffer);
+#endif
return std::string(buffer);
}
-prefix_ void senf::INet6SocketAddress::assignAddr(std::string const & addr)
-{
- // Format of addr: "[" address [ "@" interface ] "]" ":" port
- typedef boost::char_separator<char> separator;
- typedef boost::tokenizer<separator> tokenizer;
- // we don't add ':' to the list of separators since that would give as the IPv6 address
- // as a list of tokens. We just strip the : from the port number manually
- separator sep ("", "@[]");
- tokenizer tokens (addr, sep);
- tokenizer::iterator token (tokens.begin());
- if (token == tokens.end()
- || *token != "["
- || ++token == tokens.end()
- || inet_pton(AF_INET6, std::string(boost::begin(*token),boost::end(*token)).c_str(),
- &sockaddr_.sin6_addr) <= 0
- || ++token == tokens.end())
- throw InvalidINetAddressException();
- if (*token == "@") {
- if (++token == tokens.end())
- throw InvalidINetAddressException();
- assignIface(std::string(boost::begin(*token),boost::end(*token)));
- if (++token == tokens.end()
- || *token != "]")
- throw InvalidINetAddressException();
- } else if (*token != "]")
- throw InvalidINetAddressException();
- if (++token == tokens.end()
- || *boost::begin(*token) != ':')
- throw InvalidINetAddressException();
- try {
- sockaddr_.sin6_port = htons(
- boost::lexical_cast<unsigned>(std::string(boost::next(boost::begin(*token)),
- boost::end(*token))));
- } catch(boost::bad_lexical_cast const &) {
- throw InvalidINetAddressException();
- }
- if (++token != tokens.end())
- throw InvalidINetAddressException();
-}
-
prefix_ void senf::INet6SocketAddress::assignIface(std::string const & iface)
{
if (iface.empty())
else {
sockaddr_.sin6_scope_id = if_nametoindex(iface.c_str());
if (sockaddr_.sin6_scope_id == 0)
- throw InvalidINetAddressException();
+ throw SyntaxException();
}
}
projects / senf.git / blobdiff