BOOST_CHECK_EQUAL( v->type(), 0xabcd );
BOOST_CHECK( v.next().is<senf::DataPacket>() );
BOOST_CHECK_EQUAL( *v.next().data().begin(), 0xf0 );
+
+ std::ostringstream oss (std::ostringstream::out);
+ SENF_CHECK_NO_THROW( p.dump( oss));
}
SENF_AUTO_UNIT_TEST(ethernetPacket_create)
API. It however affects the semantics of the read and write
operations. On a datagram socket, each read() or write() call
we read or write a single datagram. Datagram boundaries are
- kept intact accross the network.
+ kept intact across the network.
*/
struct DatagramFramingPolicy : public FramingPolicyBase
{};
ConnectedRawV6SocketProtocol provides an internet protocol raw socket based on IPv6
addressing which is connected to certain peer. This socket will put data written to it onto
- the IPv6 layer: if you call writeto don't inlude the header! On the other hand `read` will
+ the IPv6 layer: if you call writeto don't include the header! On the other hand `read` will
return the packet data on top of the IPv6 layer, excluding the IP header. Note: This
behaviour is differs from the behaviour of IPv4 RAW sockets.
protocol like DNS or NIS
\throws AddressSyntaxException if the address cannot be
converted for some reason
+ \throws UnknownHostnameException if the hostname cannot
+ be resolved
\param[in] s Address literal or hostname */
template <class InputIterator>
*/
std::istream & operator>>(std::istream & os, INet4Address & addr);
- /** \brief CHeck INet4Address against a fixed network prefix
+ /** \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
<tr><td><tt>ff00::/8</tt></td> <td>Multicast</td> <td>RFC4291</td> <td></td></tr>
<tr><td><tt>ff00::/12</tt></td> <td>Globally allocated multicast</td> <td>RFC4291</td> <td></td></tr>
<tr><td><tt>ff10::/12</tt></td> <td>Locally allocated multicast</td> <td>RFC4291</td> <td></td></tr>
- <tr><td><tt>ff30::/12</tt></td> <td>Unicast prefic based multicast</td> <td>RFC3306</td> <td></td></tr>
+ <tr><td><tt>ff30::/12</tt></td> <td>Unicast prefix based multicast</td> <td>RFC3306</td> <td></td></tr>
<tr><td><tt>ff70::/12</tt></td> <td>Multicast address with embedded RP</td> <td>RFC3956</td> <td></td></tr>
</table>
\endhtmlonly
///< 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
+ \throws UnknownHostnameException if the hostname cannot
+ be resolved
\param[in] s Address literal or hostname
\param[in] resolve If this is set to \c ResolveINet4,
the call will additionally try to interpret \a s as
/**< This will construct a link local address of the form
<tt>fe80::xxxx:xxxx:xxxx:xxxx</tt>. */
- in6_addr toin6_addr() const; ///< get the linux in6_addr struct (convinience only)
+ in6_addr toin6_addr() const; ///< get the linux in6_addr struct (convenience only)
///@}
///////////////////////////////////////////////////////////////////////////
INet4SocketAddress
RawV4SocketProtocol provides an internet protocol raw socket based on IPv4 addressing.
- This socket will put data written to it onto the IPv4 layer: if you call writeto don't inlude the header!
+ This socket will put data written to it onto the IPv4 layer: if you call writeto don't include the header!
On the other hand `read` will return the packet data including the IP header.
This behaviour is strange and differs from the behaviour of IPv6 RAW sockets and should be changed in the future.
INet6Address
RawV6SocketProtocol provides an internet protocol raw socket based on IPv6 addressing.
- This socket will put data written to it onto the IPv6 layer: if you call writeto don't inlude the header!
+ This socket will put data written to it onto the IPv6 layer: if you call writeto don't include the header!
On the other hand `read` will return the packet data on top of the IPv6 layer, excluding the IP header.
Note: This behaviour is differs from the behaviour of IPv4 RAW sockets.
/// \addtogroup protocol_facets_group
/// @{
- /** \brief Protocol facat to support RAW operations upon IPv4/6
+ /** \brief Protocol facet to support RAW operations upon IPv4/6
This protocol facet provides all those protocol functions,
which are available on a PF_INET[6]/RAW socket.
/// \addtogroup protocol_facets_group
/// @{
- /** \brief Protocol facat to support TCP operations
+ /** \brief Protocol facet to support TCP operations
This protocol facet provides all those protocol functions,
which are available on any TCP socket.
/**< Enabling \c SO_NODELAY will disable the NAGLE
algorithm (which aggregates multiple writes into a
single network packet). Enabling nodelay() optimizes
- the repsonse time at the expense of the bandwidth
+ the response time at the expense of the bandwidth
efficiency.
\param[in] value \c SO_NODELAY state */
/// \addtogroup protocol_facets_group
/// @{
- /** \brief Protocol facat to support UDP operations
+ /** \brief Protocol facet to support UDP operations
This protocol facet provides all those protocol functions,
which are available on any UDP socket.
static EUI64 from_string(std::string const & s);
///< Construct EUI-64 from string representation
/**< The string representation consists of 8 octets in
- hexadecimal notation spearated by ':' or '-'
+ hexadecimal notation separated by ':' or '-'
\throws senf::AddressSyntaxException */
template <class InputIterator>
static EUI64 from_data(InputIterator i);
*/
bool group() const; ///< \c true if the \e group bit is set, \c false otherwise
/**< The \e group bit is the least significant bit of the
- first octed (bit 7 in standard RFC bit numbering). */
+ first octet (bit 7 in standard RFC bit numbering). */
bool boolean_test() const; ///< \c true, if EUI64 is != 0, \c false otherwise
boost::uint64_t uint64() const; ///< Return EUI64 as integer number
};
std::string interface() const; ///< Return interface name
unsigned protocol() const; ///< Return address protocol (ethertype)
- unsigned arptype() const; ///< Return the hatype field (ARP hardware type)
+ unsigned arptype() const; ///< Return the arptype field (ARP hardware type)
PktType pkttype() const; ///< Return type of packet
// The mutating interface is purposely restricted to allow only
metafunction which simplifies building SocketPolicy instantiations. It takes any number (ok, up
to a maximum of 6) of policy classes as an argument (in any order). It will sort these arguments
into the SocketPolicy template arguments. If for some axis no class is specified, it's slot will
- be filled with \c Unspecified \e Axis. Additionally, the first Argument may optionally be ab
+ be filled with \c Unspecified \e Axis. Additionally, the first Argument may optionally be an
arbitrary SocketPolicy. It will provide default values for unspecified axis</dd>
<dt>\c template \c SocketPolicyIsBaseOf < \e base, \e derived ></dt> <dd>This template
EXC
ExceptionMixin
ExtendedParser
+failbit
fbipList
FBIPList
fbips
HardwareWLANInterface
headport
Helvetica
+hexadecimal
hh
hideinitializer
Hmm
NyInputGroup
ob
ObjectDirectory
+octet
+octets
offene
ok
onChange
SizeParser
skipline
SNR
+sockaddr
SocketAddress
SocketHandle
SocketProtocol
strerror
struct
structors
+subnet
subsubsection
svn
svnbook
projects / senf.git / commitdiff