/** \file
\brief INet4Address public header */
-#ifndef HH_INet4Address_
-#define HH_INet4Address_ 1
+#ifndef HH_SENF_Socket_Protocols_INet_INet4Address_
+#define HH_SENF_Socket_Protocols_INet_INet4Address_ 1
// Custom includes
#include <iostream>
///////////////////////////////hh.p////////////////////////////////////////
namespace senf {
-
+
/** \brief IPv4 Internet address
-
+
INet4Address represents a simple IP address. It is modelled as a fixed-size
container/sequence of 4 bytes.
+ The following statements all create the same INet4 address <code>211.194.177.160</code>
+ \code
+ // Used to construct constant INet4 addresses
+ INet4Address(0xD3C2B1A0)
+
+ // Construct an INet4 address from it's string representation. All the standard address
+ // representations are supported
+ INet4Address::from_string("211.194.177.160")
+ INet4Address::from_string("211.12759456")
+
+ // Construct an INet4 address from raw data. 'from_data' takes an arbitrary iterator (e.g. a
+ // pointer) as argument. Here we use a fixed array but normally you will need this to build
+ // an INet4 address in a packet parser
+ char rawBytes[] = { 0xD3, 0xC2, 0xB1, 0xA0 };
+ INet4Address::from_data(rawBytes)
+
+ // Construct an INet4 address from the standard POSIX representation: a 32-bit integer in
+ // network byte oder. This is used to interface with POSIX routines
+ struct sockaddr_in saddr = ...;
+ INet4Address::from_inaddr(saddr.sin_addr.s_addr)
+ \endcode
+
+ Since INet4Address is based on \c boost::array, you can access the raw data bytes of the
+ address (in network byte order) using \c begin(), \c end() or \c operator[]
+ \code
+ INet4Address ina = ...;
+ Packet::iterator i = ...;
+ std::copy(ina.begin(), ina.end(), i); // Copies 4 bytes
+ \endcode
+
\see CheckINet4Network \n INet4Network
\implementation We awkwardly need to use static named constructors (<tt>from_</tt> members)
\ingroup addr_group
*/
class INet4Address
- : public boost::array<boost::uint8_t,4>,
+ : public boost::array<boost::uint8_t,4>,
public comparable_safe_bool<INet4Address>
{
public:
///////////////////////////////////////////////////////////////////////////
// Types
-
+
typedef uint32_t address_type; ///< Address representation as number in host byte order
typedef uint32_t inaddr_type; ///< Legacy address representation in network byte order
///< Convert string to address
/**< This member will try to convert the given string into
an IP address. from_string() supports all standard IP
- literal representations as well es hostnames.
+ literal representations as well as hostnames.
\attention This call may block if \a s represents a
hostname which must be looked up via some network
protocol like DNS or NIS
\throws AddressSyntaxException if the address cannot be
converted for some reason
\param[in] s Address literal or hostname */
-
- template <class InputIterator>
+
+ template <class InputIterator>
static INet4Address from_data(InputIterator i);
///< Construct address from 4 bytes of raw data
/**< from_data will build an address from 4 bytes of raw
bool boolean_test() const; ///< \c true, if address is non-empty (!= 0.0.0.0)
inaddr_type inaddr() const; ///< Return the raw network byte order address
- /**< This member is used to interact with legacy code.
+ /**< This member is used to interact with legacy code.
\return */
address_type address() const; ///< Return address represented as integer number
/**< This member returns the address as an integer number in
host byte order. This representation allows simple
network math operations. */
-
////@}
private:
*/
std::ostream & operator<<(std::ostream & os, INet4Address const & addr);
+ /** \brief Initialize INet4Address instance from a string representation
+ sets std::ios::failbit on the stream if an error occurred
+ \see INet4Address from_string()
+ \related INet4Address
+ */
+ std::istream & operator>>(std::istream & os, INet4Address & addr);
+
/** \brief CHeck INet4Address against a fixed network prefix
This helper allows to easily and efficiently check an INet4Address against an arbitrary but
constant network prefix. The network prefix is represented by
-
+
\par ""
<tt>senf::CheckINet4Network<</tt> <i>addr</i> <tt>,</tt> <i>prefix-len</i> <tt>></tt>
-
+
Where \a addr is the v4 Internet address as a 32-bit unsigned integer number in host byte
order and \a prefix_len is the length of the network prefix. The class exposes a single
static member <tt>match(</tt> <i>addr</i> <tt>)</tt> which matches the INet4Address \a addr
/** \brief IPv4 network prefix
- This class represents an IPv4 network prefix in CIDR notation.
+ This class represents an IPv4 network prefix in CIDR notation.
*/
class INet4Network
- : public boost::equality_comparable<INet4Network>,
+ : public boost::equality_comparable<INet4Network>,
public comparable_safe_bool<INet4Network>
{
public:
///@{
INet4Network(); ///< Construct empty (0.0.0.0/0) network
- INet4Network(INet4Address address, unsigned prefix_len);
+ INet4Network(INet4Address const & address, unsigned prefix_len);
///< Construct network from given address and prefix length
- explicit INet4Network(std::string s); ///< Construct network from CIDR notation
+ explicit INet4Network(std::string const & s); ///< Construct network from CIDR notation
///@}
///////////////////////////////////////////////////////////////////////////
bool boolean_test() const; ///< \c true, if INet4Network is non-empty
bool operator==(INet4Network const & other) const;
///< Compare to networks for equality
-
- bool match(INet4Address addr) const; ///< \c true, if the network includes \a addr
- bool match(INet4Network net) const; ///< \c true, if the network includes \a net
+
+ bool match(INet4Address const & addr) const; ///< \c true, if the network includes \a addr
+ bool match(INet4Network const & net) const; ///< \c true, if the network includes \a net
/**< The is true, if \a net is sub-network (or the same as)
\c this. */
\code
INet4Network("192.168.0.0/16").subnet(111u,24u) == INet4Network("192.168.111.0/24")
INet4Network("192.168.111.0/24").subnet(1u,28u) == INet4Network("192.168.111.16/28")
- \endcode
+ \endcode
\param[in] net network number
\param[in] prefix_len length of subnet prefix */
\related INet4Network
*/
std::ostream & operator<<(std::ostream & os, INet4Network const & addr);
-
+
+ /** \brief Initialize INet4Address instance from a string representation
+ sets std::ios::failbit on the stream if an error occurred
+ \see INet4Address from_string()
+ \related INet4Network
+ */
+ std::istream & operator>>(std::istream & is, INet4Network & addr);
+
}
///////////////////////////////hh.e////////////////////////////////////////
#include "INet4Address.cti"
#endif
-\f
+
// Local Variables:
// mode: c++
// fill-column: 100
projects / senf.git / blobdiff