Socket/Protocols/Raw/LLAddressing.hh

   1 // $Id$
   2 //
   3 // Copyright (C) 2006
   4 // Fraunhofer Institute for Open Communication Systems (FOKUS)
   5 // Competence Center NETwork research (NET), St. Augustin, GERMANY
   6 //     Stefan Bund <g0dil@berlios.de>
   7 //
   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.
  12 //
  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.
  17 //
  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.
  22
  23 /** \file
  24     \brief LLSocketAddress and LLAddressingPolicy public header
  25  */
  26
  27 #ifndef HH_LLAddressing_
  28 #define HH_LLAddressing_ 1
  29
  30 // Custom includes
  31 #include <sys/socket.h>
  32 #include <netpacket/packet.h>
  33 #include "../../../Socket/SocketPolicy.hh"
  34 #include "../../../Socket/FileHandle.hh"
  35 #include "../../../Socket/Protocols/GenericAddressingPolicy.hh"
  36 #include "MACAddress.hh"
  37
  38 //#include "LLAddressing.mpp"
  39 //#include "LLAddressing.ih"
  40 ///////////////////////////////hh.p////////////////////////////////////////
  41
  42 namespace senf {
  43
  44     /// \addtogroup addr_group
  45     /// @{
  46
  47     /** \brief Link local address
  48
  49         LLSocketAddress wraps the standard sockaddr_ll data type. An LLSocketAddress provides quite
  50         some information, only part of which is necessary for sending packets. The LLSocketAddress
  51         class only allows changing those fields which need to be changed. The other fields are
  52         read-only. They are filled by the operating system when receiving a packet
  53
  54         \nosubgrouping
  55      */
  56     class LLSocketAddress
  57     {
  58     public:
  59         /** \brief Valid pkttype() values
  60
  61             These are the possible values returned by pkttype()
  62          */
  63         enum PktType { Undefined = 0
  64                      , Host      = PACKET_HOST      /**< Packet destined for this host */
  65                      , Broadcast = PACKET_BROADCAST /**< Packet sent to the broadcast address */
  66                      , Multicast = PACKET_MULTICAST /**< Packet sent to a (link local) multicast
  67                                                          address */
  68                      , OtherHost = PACKET_OTHERHOST /**< Packet sent to another host (promisc) */
  69                      , Outgoing  = PACKET_OUTGOING  /**< Packet sent out from this host */
  70         };
  71
  72         ///////////////////////////////////////////////////////////////////////////
  73         ///\name Structors and default members
  74         ///@{
  75
  76         LLSocketAddress();              ///< Create empty address
  77         explicit LLSocketAddress(unsigned proto, std::string const & iface="");
  78                                         ///< Create address for \c bind()
  79                                         /**< This constructs an LLSocketAddress valid for calling
  80                                              PacketSocketHandle::bind() with.
  81                                              \param[in] proto Protocol (Ethertype) to listen for
  82                                              \param[in] iface Interface name to bind to */
  83         explicit LLSocketAddress(std::string const &iface);
  84                                         ///< Create address for \c bind()
  85                                         /**< This constructs an LLSocketAddress valid for calling
  86                                              \c PacketSocketHandle::bind() with.
  87                                              \param[in] iface Interface name to bind to */
  88
  89         // This constructor is for sending packets
  90         explicit LLSocketAddress(MACAddress const & addr, std::string const & iface="");
  91                                         ///< Create address valid to send raw packets
  92                                         /**< Addresses created with this constructor are valid for
  93                                              use with \c PacketSocketHandle::sendto() on a \c
  94                                              SOCK_DGRAM packet socket.
  95                                              \param addr Address to send data to
  96                                              \param iface Interface to send packet from */
  97
  98         ///@}
  99         ///////////////////////////////////////////////////////////////////////////
 100
 101         void clear();                   ///< Clear the address
 102
 103         unsigned protocol() const;      ///< Return address protocol (ethertype)
 104         std::string interface() const;  ///< Return interface name
 105         unsigned arptype() const;       ///< Return the hatype field (ARP hardware type)
 106         PktType pkttype() const;        ///< Return type of packet
 107         MACAddress address() const;     ///< Return address
 108
 109         // The mutating interface is purposely restricted to allow only
 110         // changing those members, which are sensible to be changed.
 111
 112         void address(MACAddress const & addr); ///< Change address
 113         void interface(std::string const & iface); ///< Change interface
 114         void protocol(unsigned prot);   ///< Change protocol
 115
 116         ///\name Generic SocketAddress interface
 117         ///@{
 118
 119         struct sockaddr * sockaddr_p();
 120         struct sockaddr const * sockaddr_p() const;
 121         unsigned sockaddr_len() const;
 122
 123         ///@}
 124
 125     private:
 126         struct ::sockaddr_ll addr_;
 127     };
 128
 129     /** \brief Signal invalid link local address syntax
 130         \related LLSocketAddress
 131      */
 132     struct InvalidLLSocketAddressException : public std::exception
 133     { char const * what() const throw() { return "invalid ll address"; } };
 134
 135     /// @}
 136
 137     /// \addtogroup policy_impl_group
 138     /// @{
 139
 140     /** \brief Addressing policy supporting link-local addressing
 141
 142         \par Address Type:
 143             LLSocketAddress
 144
 145         This addressing policy implements generic link local
 146         addressing. The predominant type of link local addressing is
 147         Ethernet addressing.
 148
 149         Since the link layer does not support the notion of
 150         connections, link local addresses do not support the connect()
 151         or peer() members.
 152      */
 153     struct LLAddressingPolicy
 154         : public AddressingPolicyBase,
 155           private GenericAddressingPolicy<LLSocketAddress>
 156     {
 157         typedef LLSocketAddress Address;
 158
 159         using GenericAddressingPolicy<LLSocketAddress>::local;
 160         using GenericAddressingPolicy<LLSocketAddress>::bind;
 161     };
 162
 163     /// @}
 164 }
 165
 166 ///////////////////////////////hh.e////////////////////////////////////////
 167 #include "LLAddressing.cci"
 168 //#include "LLAddressing.ct"
 169 //#include "LLAddressing.cti"
 170 //#include "LLAddressing.mpp"
 171 #endif
 172
 173 \f
 174 // Local Variables:
 175 // mode: c++
 176 // fill-column: 100
 177 // c-file-style: "senf"
 178 // indent-tabs-mode: nil
 179 // ispell-local-dictionary: "american"
 180 // compile-command: "scons -u test"
 181 // comment-column: 40
 182 // End: