4 // Fraunhofer Institut fuer offene Kommunikationssysteme (FOKUS)
5 // Kompetenzzentrum fuer Satelitenkommunikation (SatCom)
6 // Stefan Bund <stefan.bund@fokus.fraunhofer.de>
8 // This program is free software; you can redistribute it and/or modify
9 // it under the terms of the GNU General Public License as published by
10 // the Free Software Foundation; either version 2 of the License, or
11 // (at your option) any later version.
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU General Public License for more details.
18 // You should have received a copy of the GNU General Public License
19 // along with this program; if not, write to the
20 // Free Software Foundation, Inc.,
21 // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
24 \brief INet[46]Address and INet[46]AddressingPolicy public header
27 #ifndef HH_INetAddressing_
28 #define HH_INetAddressing_ 1
33 #include <netinet/in.h>
34 #include <boost/operators.hpp>
35 #include "Socket/SocketPolicy.hh"
36 #include "Socket/ClientSocketHandle.hh"
37 #include "Socket/CommunicationPolicy.hh"
38 #include "Socket/Protocols/GenericAddressingPolicy.hh"
39 #include "INet4Address.hh"
40 #include "INet6Address.hh"
42 //#include "INetAddressing.mpp"
43 ///////////////////////////////hh.p////////////////////////////////////////
47 /// \addtogroup addr_group
50 /** \brief IPv4 socket address
52 INet4Address wraps the standard sockaddr_in datatype. It provides simple accessor methods
53 to access the host and port. It does \e not integrate \c gethostbyname or DNS lookup.
55 \implementation This implementation is based on sockaddr_in, which is needed since it needs
56 to provide a non-const struct sockaddr * for legacy compatibility.
58 class INet4SocketAddress
59 : public boost::equality_comparable<INet4SocketAddress>,
60 public senf::ComparableSafeBool<INet4SocketAddress>
64 explicit INet4SocketAddress(std::string const & address); ///< Set address and port
65 /**< This constructor expects a string of the form
66 'host:port'. The constructor will use this value to
67 initialize the host and port members. Since it uses the
68 INet4Address::from_string constructor, this call may
69 block while waiting for the resolver.
70 \throws SyntaxException if the 'host:port' syntax is
72 \throws INet4Address::SyntaxException if the host part
73 cannot be converted to an IP address. */
75 INet4SocketAddress(INet4Address const & addr, unsigned port);
76 ///< Set address and port explicitly
77 /**< \param[in] addr IP address
78 \param[in] port port number */
80 bool operator==(INet4SocketAddress const & other) const;
81 ///< Check INet4SocketAddress for equality
83 INet4Address address() const; ///< Return address
84 unsigned port() const; ///< Return port number
86 bool boolean_test() const; ///< \c true, if address is empty (i.e. 0.0.0.0:0)
88 void clear(); ///< Clear address/port to 0.0.0.0:0
90 void address(INet4Address const & addr); ///< Set address
91 void port(unsigned p); ///< Set port number
93 /// \name Generic Address Interface
96 struct sockaddr * sockaddr_p();
97 struct sockaddr const * sockaddr_p() const;
98 unsigned sockaddr_len() const;
102 struct SyntaxException : public std::exception
103 { virtual char const * what() const throw()
104 { return "Invalid IpV4 socket address syntax"; } };
107 struct ::sockaddr_in addr_;
110 /** \brief Write address and port to os
112 \related INet4SocketAddress
114 std::ostream & operator<<(std::ostream & os, INet4SocketAddress const & addr);
116 /** \brief IPv6 socket address
118 This class wraps the standard \c sockaddr_in6 structure. INet6SocketAddress provides access
119 to all members of the sockaddr_in6 structure. Additionally, INet6SocketAddress supports the
120 string representation
122 \par "" <tt>[</tt> <i>address</i> [ <tt>\@</tt> <i>interface</i> ] <tt>]:</tt> <i>port</i>
124 Where \e address is an arbitrary numeric IPv6 address, \e interface is an optional network
125 interface name and \e port is the port number. The interface specification is only valid if
126 \e address is link-local address. The URL representation of an IPv6 address is as above
127 without the optional interface spec.
129 INet6SocketAddress supports conversion constructors from it's string
130 representation. Therefore, wherever a INet6SocketAddress instance is expected, a string may
133 \implementation The sockaddr_in6 structure has an sin6_flowinfo member. However RFC3493 does
134 not give the use of this field and specifies, that the field should be ignored ... so
135 that's what we do. Furthermore, the GNU libc reference states, that this field is not
136 implemented in the library.
138 \implementation We need to return the address in host() by value since we need to return a
139 INet6Address. However, sockaddr_in6 does not have one ...
141 \implementation The <tt>char const *</tt> constructor overload is needed to support
142 string-literals where an INet6SocketAddress is expected (the C++ standard does not allow
143 chaining conversion constructors like <tt>char const *</tt> -> \c std::string -> \c
146 \idea Implement a INet6Address_ref class which has an interface identical to INet6Address
147 and is convertible to INet6Address (the latter has a conversion constructor taking the
148 former as arg). This class however references an external in6_addr instead of containing one
149 itself. This can be used in INet6SocketAddress to increase the performance of some
152 class INet6SocketAddress
155 ///////////////////////////////////////////////////////////////////////////
158 ///////////////////////////////////////////////////////////////////////////
159 ///\name Structors and default members
162 INet6SocketAddress(); ///< Create empty instance
163 INet6SocketAddress(std::string const & addr);
164 ///< Initialize/convert from string representation
165 INet6SocketAddress(char const * addr); ///< Same as above to support string literals
166 INet6SocketAddress(INet6Address const & addr, unsigned port);
167 ///< Initialize from address and port
168 INet6SocketAddress(INet6Address const & addr, unsigned port, std::string const & iface);
169 ///< Initialize explicitly from given parameters
170 INet6SocketAddress(std::string const & addr, std::string const & iface);
171 ///< Initialize from URL representation and explit interface
174 ///////////////////////////////////////////////////////////////////////////
176 bool operator==(INet6SocketAddress const & other) const; ///< Check addresses for equality
177 bool operator!=(INet6SocketAddress const & other) const; ///< Inverse of above
179 void clear(); ///< Clear socket address
181 std::string address() const; ///< Get printable address representation
183 INet6Address host() const; ///< Get address
184 void host(INet6Address const & addr); ///< Change address
186 unsigned port() const; ///< Get port number
187 void port(unsigned poirt); ///< Change port number
189 std::string iface() const; ///< Get interface name
190 void iface(std::string const & iface); ///< Change interface
192 ///\name Generic SocketAddress interface
195 struct sockaddr * sockaddr_p();
196 struct sockaddr const * sockaddr_p() const;
197 unsigned sockaddr_len() const;
201 struct SyntaxException : public std::exception
202 { virtual char const * what() const throw()
203 { return "Invalid IpV6 socket address syntax"; } };
208 void assignAddr(std::string const & addr);
209 void assignIface(std::string const & iface);
211 struct sockaddr_in6 sockaddr_;
214 /** \brief Output INet6SocketAddress instance as it's string representation
216 std::ostream & operator<<(std::ostream & os, INet6SocketAddress const & addr);
220 /// \addtogroup policy_impl_group
223 /** \brief Addressing policy supporting IPv4 addressing
228 This addressing policy implements addressing using Internet V4
231 The various members are directly imported from
232 GenericAddressingPolicy which see for a detailed
235 struct INet4AddressingPolicy
236 : public AddressingPolicyBase,
237 private GenericAddressingPolicy<INet4SocketAddress>
239 typedef INet4SocketAddress Address;
241 using GenericAddressingPolicy<INet4SocketAddress>::peer;
242 using GenericAddressingPolicy<INet4SocketAddress>::local;
243 using GenericAddressingPolicy<INet4SocketAddress>::connect;
244 using GenericAddressingPolicy<INet4SocketAddress>::bind;
247 /** \brief Addressing policy supporting IPv6 addressing
252 This addressing policy implements addressing using Internet V6
255 The various members are directly imported from
256 GenericAddressingPolicy which see for a detailed
259 struct INet6AddressingPolicy
260 : public AddressingPolicyBase,
261 private GenericAddressingPolicy<INet6SocketAddress>
263 typedef INet6SocketAddress Address;
265 using GenericAddressingPolicy<INet6SocketAddress>::peer;
266 using GenericAddressingPolicy<INet6SocketAddress>::local;
267 using GenericAddressingPolicy<INet6SocketAddress>::connect;
268 using GenericAddressingPolicy<INet6SocketAddress>::bind;
275 ///////////////////////////////hh.e////////////////////////////////////////
276 #include "INetAddressing.cci"
277 //#include "INetAddressing.ct"
278 //#include "INetAddressing.cti"
279 //#include "INetAddressing.mpp"
286 // c-file-style: "senf"
287 // indent-tabs-mode: nil
288 // ispell-local-dictionary: "american"
289 // compile-command: "scons -u test"
290 // comment-column: 40