NSIS-ka
A free C++ implementation of NSIS protocols

Changeset 4142


Ignore:
Timestamp:
Jul 17, 2009, 2:13:44 PM (8 years ago)
Author:
bless
Message:
  • merged in changes from current trunk up to r4107
  • had to revert changes from r3185, removed commented XXXMOB parts because we need the interface identifier/index for multicast!
  • added the setting of a source address to the trunk src/cmsghdr_util
  • optional TP::send() argument of local_addr moved to the end of the method parameters
Location:
protlib/branches/20081127-merge-mobility-mk3
Files:
27 edited
10 copied

Legend:

Unmodified
Added
Removed
  • protlib/branches/20081127-merge-mobility-mk3

  • protlib/branches/20081127-merge-mobility-mk3/include/address.h

    r3701 r4142  
    3838#include "ie.h"
    3939
     40#include <list>
    4041#include <ext/hash_map>
    4142#include <netinet/in.h>
     
    176177        /// match against network prefix
    177178        virtual int match_against(const netaddress& na) const;
     179        /// return true if address is a multicast address
     180        virtual bool is_multicast() const;
    178181protected:
    179182        /// IPv4 flag
     
    225228{ set_subtype(false); }
    226229
     230
     231typedef list<hostaddress> hostaddresslist_t;
    227232
    228233/// ========================================================
     
    356361        }
    357362       
     363        /// set outgoing Interface index
     364        inline
     365        void set_if_index(uint16 value) {
     366        if_index = value;
     367        }
     368       
     369        /// get outgoing Interface index
     370        inline
     371        uint16 get_if_index() const {
     372            return if_index;
     373        }
     374       
     375        /// unset outgoing Interface index
     376        inline
     377        void unset_if_index() {
     378            if_index = 0;
     379        }
     380       
     381
     382
     383
    358384
    359385    private:
     
    365391        uint16 ip_ttl;
    366392        bool rao_presence;
     393        uint16 if_index;
    367394       
    368395    }; // end appladdress
     
    371398inline
    372399appladdress::appladdress(const sockaddr_in6& sockaddr, protocol_t prot)
    373     : hostaddress(sockaddr.sin6_addr), proto(prot), port(ntohs(sockaddr.sin6_port)), rao(0), ip_ttl(0), rao_presence(false)
     400    : hostaddress(sockaddr.sin6_addr), proto(prot), port(ntohs(sockaddr.sin6_port)), rao(0), ip_ttl(0), rao_presence(false), if_index(0)
    374401{
    375402  //Log(DEBUG_LOG,LOG_NORMAL,"address","address constructor called for sockaddr_in6");
     
    384411                             rao(0),
    385412                             ip_ttl(0),
    386                              rao_presence(false)
     413                             rao_presence(false),
     414                             if_index(0)
    387415                             
    388416{
     
    398426                                                   rao(app.rao),
    399427                                                   ip_ttl(app.ip_ttl),
    400                                                    rao_presence(app.rao_presence)
     428                                                   rao_presence(app.rao_presence),
     429                                                   if_index(app.if_index)
    401430   
    402431{
    403432    //Log(DEBUG_LOG,LOG_NORMAL,"appladdress", "Copy address constructor called for appladdress& app:" << app);
    404433    //DLog("appladdress", "UDSsocket copied: " << uds_socket);
    405   //DLog("appladdress", "ip_ttl: " << ip_ttl);
     434  //DLog("appladdress", "ip_ttl: " << ip_ttl << " if_index: " << if_index);
    406435
    407436
     
    418447      rao(0),
    419448      ip_ttl(0),
    420       rao_presence(false)
     449      rao_presence(false),
     450      if_index(0)
    421451{
    422452  //Log(DEBUG_LOG,LOG_NORMAL,"address","address constructor called for (const hostaddress& h, protocol_t prot, port_t p)");
     
    436466    rao(0),
    437467    ip_ttl(0),
    438     rao_presence(false)
     468    rao_presence(false),
     469    if_index(0)
    439470
    440471{
     
    456487    rao(0),
    457488    ip_ttl(0),
    458     rao_presence(false)
     489    rao_presence(false),
     490    if_index(0)
    459491{
    460492    set_subtype(ipv4flag);
     
    473505    rao(0),
    474506    ip_ttl(0),
    475     rao_presence(false)
     507    rao_presence(false),
     508    if_index(0)
    476509{
    477510  //Log(DEBUG_LOG,LOG_NORMAL,"address","address constructor called for (const char* str, const char* pname, port_t p, bool *res)");
     
    495528      rao(0),
    496529      ip_ttl(0),
    497       rao_presence(false)
     530      rao_presence(false),
     531      if_index(0)
    498532{
    499533  //Log(DEBUG_LOG,LOG_NORMAL,"address","address constructor called for (const char* str, const char* pname, const char* portname, bool *res)");
     
    520554        rao_presence = app.rao_presence;
    521555        rao = app.rao;
     556        if_index = app.if_index;
    522557        return *this;
    523558} // end operator=
     
    665700     return out << addr.get_ip_str() << "/" << (int)addr.get_pref_len();
    666701}
     702
     703istream& operator>>(istream& inputstream, list<hostaddress>& halist);
    667704
    668705/// Unix Domain Socket Address
     
    727764/** Get Socket Number */
    728765inline
    729 const int get_socknum() const {
     766int get_socknum() const {
    730767    return socknum;
    731768} // end get_socknum
     
    10951132
    10961133
     1134ostream& operator<<(ostream& outstream, const list<hostaddress>& addresslist);
     1135
    10971136/*
    10981137 * AddressList
     
    13321371} // end get_host_name
    13331372
     1373
     1374istream& operator>>(istream& inputstream, hostaddress& ha);
     1375
     1376
    13341377/***** inherited from hostaddress *****/
    13351378
     
    13731416    return out << "[Unix Domain Socket]: " << addr.get_udssocket();
    13741417}
    1375 
    1376 
    1377 
    1378 
    13791418
    13801419
  • protlib/branches/20081127-merge-mobility-mk3/include/network_message.h

    r3701 r4142  
    8686        /// destructor
    8787        ~NetMsg();
     88        /// buffer
    8889        /// get buffer size
    8990        uint32 get_size() const;
     
    167168        uchar *pos;
    168169        /// buffer end
    169         /** Ponter to the last byte of the buffer. */   
     170        /** Pointer to the last byte of the buffer. */ 
    170171        uchar *buf_end;
     172
     173        /// true if copied, used in destructor
     174        bool allocated;
    171175};
    172176
  • protlib/branches/20081127-merge-mobility-mk3/include/protlib_types.h

    r3701 r4142  
    9595  protected:
    9696        ProtLibException() throw() { }
    97         ProtLibException(std::string msg) throw() : error_msg(msg) { }
     97        ProtLibException(const std::string& msg) throw() : error_msg(msg) { }
    9898
    9999        std::string error_msg;
  • protlib/branches/20081127-merge-mobility-mk3/include/tp.h

    r3701 r4142  
    8181        /// use_existing_connection indicates whether a new connection will be established
    8282        /// if required (true means that no connection will be set up if none exists yet)
    83         virtual void send(NetMsg* msg, const address& addr, const address *local_addr = NULL, bool use_existing_connection= false) = 0;
     83        virtual void send(NetMsg* msg, const address& addr, bool use_existing_connection= false, const address *local_addr = NULL) = 0;
    8484
    8585        /// terminates an existing signaling association/connection
     
    144144public:
    145145    /// constructor
    146     TPMsg(NetMsg* m = NULL, address* peer = NULL, address* ownaddr = NULL, TPError* e = NULL);
     146    TPMsg(NetMsg* m = NULL, address* peer = NULL, address* ownaddr = NULL, TPError* e = NULL, uint16 oif = 0);
    147147    /// destructor
    148148    virtual ~TPMsg();
     
    163163    /// set TP error
    164164    TPError* set_error(TPError* e);
     165    /// set Outgoing Interface
     166    void set_oif(uint16 iface) { oif=iface; }
     167    /// get Outgoing Interface
     168    uint16 get_oif() { return oif; }
    165169
    166170private:
     
    172176    NetMsg* msg;
    173177    TPError* err;
     178    /// outgoing interface index
     179    uint16 oif;
    174180}; // end class TPMsg
    175181
     
    194200/** Initialize and set message type and source to 'transport'. */
    195201inline
    196 TPMsg::TPMsg(NetMsg* m, address* p, address* o, TPError* e)
     202TPMsg::TPMsg(NetMsg* m, address* p, address* o, TPError* e, uint16 oif)
    197203  : message(type_transport,qaddr_transport),
    198204    peeraddr(p),
    199205    ownaddr(o),
    200206    msg(m),
    201     err(e)
     207    err(e),
     208    oif(oif)
    202209{} // end constructor TPMsg
    203210
  • protlib/branches/20081127-merge-mobility-mk3/include/tp_over_sctp.h

    r3207 r4142  
    9999{
    100100        // inherited from TP
    101         public:
    102                 virtual void send(NetMsg *msg, const address &addr, const address *local_addr, bool use_existing_connection);
    103                 virtual void terminate(const address &addr);
     101        public:
     102                virtual void send(NetMsg *msg, const address &addr, bool use_existing_connection, const address *local_addr);
     103                virtual void terminate(const address &addr);
    104104
    105105        // inherited from Thread
  • protlib/branches/20081127-merge-mobility-mk3/include/tp_over_tcp.h

    r3701 r4142  
    103103public:
    104104  /// sends a network message, spawns receiver thread if necessary
    105   virtual void send(NetMsg* msg, const address& addr, const address *local_addr, bool use_existing_connection) { send_cb(msg,addr,use_existing_connection); }
     105  virtual void send(NetMsg* msg, const address& addr, bool use_existing_connection, const address *local_addr) { send_cb(msg,addr,use_existing_connection); }
    106106  virtual void terminate(const address& addr);
    107107 
  • protlib/branches/20081127-merge-mobility-mk3/include/tp_over_udp.h

    r3701 r4142  
    106106public:
    107107  /// sends a network message, spawns receiver thread if necessary
    108   virtual void send(NetMsg* msg, const address& addr, const address *local_addr, bool use_existing_connection);
     108  virtual void send(NetMsg* msg, const address& addr, bool use_existing_connection, const address *local_addr= NULL);
    109109  virtual void terminate(const address& addr);
    110110 
  • protlib/branches/20081127-merge-mobility-mk3/include/tp_queryencap.h

    r3207 r4142  
    5353  * @param raovec               - vector of router alert option values that should be intercepted
    5454  * @param tpoverudp            - pointer to UDP send/recv module (required to get source port for sending packets)
     55  * @param strict_rao           - if set an RAO is strictly required for interception, otherwise the magic number suffices
    5556  * @param magic_number         - GIST magic number (first 32 bit of UDP payload) in host byte order, only checked if != 0
    5657  * @param sleep                - time (in ms) that listener and receiver wait at a poll() call
     
    6768      vector<uint32>& raovec,
    6869      const TPoverUDP* tpoverudp,
     70      const bool &strict_rao,
    6971      uint32 GIST_magic_num= 0,
    7072      uint32 sleep = ThreadParam::default_sleep_time,
     
    8082      dest(dest),
    8183      common_header_length(common_header_length),
     84      strict_rao(strict_rao),
    8285      magic_number(GIST_magic_num),
    8386      getmsglength(getmsglength),
     
    9699    /// what is the length of the common header
    97100    const unsigned short common_header_length;
     101    /// RAO required for interception? (read-only)
     102    const bool &strict_rao;
    98103    /// GIST magic number that should be verified (must be given in host order)
    99104    const uint32 magic_number;
     105
    100106    /// function pointer to a function that figures out the msg length in number of 4 byte words
    101107    /// it returns false if error occured (e.g., malformed header), result is returned in variable clen_words
     
    120126public:
    121127  virtual void terminate(const address& addr) {};
    122   virtual void send(protlib::NetMsg* msg_to_send, const protlib::address& destaddr, const  protlib::address *local_addr, bool use_existing_conn);
     128  virtual void send(protlib::NetMsg* msg_to_send, const protlib::address& destaddr, bool use_existing_conn, const  protlib::address *local_addr);
    123129  /***** inherited from Thread *****/
    124130public:
     
    179185  void setup_socket_ipv4(int sockfd, int hop_limit, int rao);
    180186  void setup_socket_ipv6(int sockfd, int hop_limit, int rao);
    181   void set_ancillary_data(struct msghdr *msg, int rao, const hostaddress *own_addr);
    182187 
    183188  /// ConnectionMap instance for keeping track of all existing connections
  • protlib/branches/20081127-merge-mobility-mk3/src/Makefile

    r3746 r4142  
    105105TP_QUERY_ENCAP_OBJ= tp_queryencap.o
    106106
    107 PROTLIB_OBJS    = address.o ie.o tp.o tp_over_tcp.o \
    108                   tp_over_tls_tcp.o tp_over_udp.o $(TP_QUERY_ENCAP_OBJ) tp_over_uds.o \
     107PROTLIB_OBJS    = address.o ie.o tp.o tp_over_tcp.o tp_over_tls_tcp.o \
     108                  cmsghdr_util.o tp_over_udp.o $(TP_QUERY_ENCAP_OBJ) tp_over_uds.o \
    109109                  $(TP_SCTPOBJ) connectionmap.o connectionmap_uds.o queuemanager.o fqueue.o \
    110110                  timer.o timer_module.o logfile.o fqueue.o protlib_types.o threads.o \
    111111                  threadsafe_db.o setuid.o messages.o network_message.o \
    112                   configuration.o
     112                  configuration.o configpar.o configpar_repository.o configfile.o
    113113
    114114ALLSOURCES        := $(wildcard *.cpp)
     
    246246#compile rules
    247247
     248cmsghdr_util.o: cmsghdr_util.cpp cmsghdr_util.h
     249        $(RM) $@
     250        $(CPP) $(PROTLIB_CXXFLAGS) $(CFLAGS) $(CLINK) $@ $(INCLUDE) $<
     251
    248252%.o:            %.cpp
    249253                $(RM) $@
  • protlib/branches/20081127-merge-mobility-mk3/src/address.cpp

    r3861 r4142  
    9191        if (haddr) {
    9292#ifdef DEBUG_HARD
    93           Log(DEBUG_LOG,LOG_NORMAL,"hostaddress","::operator==()" << haddr->get_ip_str()<<"=="<<this->get_ip_str());
     93          Log(DEBUG_LOG,LOG_NORMAL,"hostaddress","::operator==(), v4=" << haddr->get_ip_str()<<"=="<<this->get_ip_str());
    9494          if (!ipv4flag)
    9595            Log(DEBUG_LOG,LOG_NORMAL,"hostaddress","::operator==(), v6=" << IN6_ARE_ADDR_EQUAL(ipv6addr.s6_addr, haddr->ipv6addr.s6_addr));
     
    134134void hostaddress::set_ip(const struct in_addr &in) {
    135135        clear_ip();
    136         ipv4addr = in; 
     136        ipv4addr.s_addr = in.s_addr;
    137137        // set subtype to IPv4
    138138        set_subtype(true);
     
    254254  if (ipv4flag)
    255255  { // IPv4
    256     if ( IN_MULTICAST(ipv4addr.s_addr) ||
    257          ipv4addr.s_addr == INADDR_LOOPBACK  ||
    258          ipv4addr.s_addr == INADDR_ANY ||
    259          ipv4addr.s_addr == INADDR_BROADCAST
     256    if ( IN_MULTICAST(ntohl(ipv4addr.s_addr)) ||
     257         ipv4addr.s_addr == htonl(INADDR_LOOPBACK)  ||
     258         ipv4addr.s_addr == htonl(INADDR_ANY) ||
     259         ipv4addr.s_addr == htonl(INADDR_BROADCAST)
    260260       )
    261261    {
     
    265265  else
    266266  { // IPv6
    267     if ( ipv6addr.s6_addr == in6addr_any.s6_addr ||
    268          ipv6addr.s6_addr == in6addr_loopback.s6_addr )
    269       return true;
     267          if ( IN6_ARE_ADDR_EQUAL(ipv6addr.s6_addr,in6addr_any.s6_addr) ||
     268               IN6_ARE_ADDR_EQUAL(ipv6addr.s6_addr,in6addr_loopback.s6_addr) )
     269                  return true;
    270270  }
    271271
     
    342342} // end clear_ip
    343343
     344
     345istream& operator>>(istream& inputstream, hostaddress& ha)
     346{
     347  string inputstr;
     348 
     349  inputstream >> inputstr;
     350 
     351  if (ha.set_ipv6(inputstr.c_str()) == false)
     352  { // conversion to ipv6 address failed, try ipv4 instead
     353    ha.set_ipv4(inputstr.c_str());
     354  }
     355
     356  return inputstream;
     357}
     358
     359
     360istream& operator>>(istream& inputstream, list<hostaddress>& halist)
     361{
     362  while ( inputstream ) {
     363    std::string token;
     364    inputstream >> token;
     365   
     366    bool success;
     367    hostaddress addr(token.c_str(), &success);
     368   
     369    if ( success )
     370      halist.push_back(addr);
     371  }
     372
     373  return inputstream;
     374}
     375
     376
     377ostream& operator<<(ostream& outstream, const list<hostaddress>& addresslist)
     378{
     379  // algo?  foreach...
     380  list<hostaddress>::const_iterator haddr_citer= addresslist.begin();
     381  while ( haddr_citer != addresslist.end() )
     382  {
     383    // write address
     384    outstream << *haddr_citer;
     385    haddr_citer++;
     386    // if not the last element, write separating space
     387    if (haddr_citer != addresslist.end())
     388      outstream << ' ';
     389  }
     390  return outstream;
     391}
    344392
    345393/** Match this IP address against another IP address.
     
    410458} // end match_against
    411459
     460/** Check whether this IP address is a multicast address.
     461 * @return true if it is a multicast address, otherwise false
     462 */
     463bool hostaddress::is_multicast() const {
     464        if (ipv4flag)
     465        { // IPv4
     466                if (IN_MULTICAST(ntohl(ipv4addr.s_addr)))
     467                {
     468                        return true;
     469                }
     470        } else { // IPv6
     471                if (ipv6addr.s6_addr[0] == 0xff)
     472                        return true;
     473        }
     474        return false;
     475}
     476
    412477/***** class appladdress *****/
    413478
     
    433498                // Otherwise they are not equal.
    434499                if (hostaddress::operator==(ie)) {
    435                     if (proto!=app->proto) cout << "protocols not matching" << endl;
    436                     if (port !=app->port) cout << "ports not matching" << endl;
     500                        //if (proto!=app->proto) cout << "protocols not matching" << endl;
     501                        //if (port !=app->port) cout << "ports not matching" << endl;
    437502
    438503                    return ((proto==app->proto) && (port==app->port));
     
    465530                // Otherwise they are not equal.
    466531                if (hostaddress::operator==(ie)) {
    467                     if (prefix_length!=na->prefix_length) cout << "Prefix length not matching" << endl;
     532                        //if (prefix_length!=na->prefix_length) cout << "Prefix length not matching" << endl;
    468533                    return (prefix_length==na->prefix_length);
    469534                } else return false;
     
    10751140        netaddress na;
    10761141
    1077         // according to IANA Tue Apr 17 09:14:31 PDT 2007
     1142        // according to http://www.cymru.com/Documents/bogon-list.html
     1143        // 4.8 (30 Apr 2009)
    10781144        na.set_ip("0.0.0.0");na.set_pref_len(7);
    10791145        ignore(na);
     
    10821148        na.set_ip("5.0.0.0");na.set_pref_len(8);
    10831149        ignore(na);
    1084         na.set_ip("7.0.0.0");na.set_pref_len(8);
     1150        na.set_ip("10.0.0.0");na.set_pref_len(8);
     1151        ignore(na);
     1152        na.set_ip("14.0.0.0");na.set_pref_len(8);
    10851153        ignore(na);
    10861154        na.set_ip("23.0.0.0");na.set_pref_len(8);
     
    10961164        na.set_ip("42.0.0.0");na.set_pref_len(8);
    10971165        ignore(na);
     1166        na.set_ip("46.0.0.0");na.set_pref_len(8);
     1167        ignore(na);
    10981168        na.set_ip("49.0.0.0");na.set_pref_len(8);
    10991169        ignore(na);
    11001170        na.set_ip("50.0.0.0");na.set_pref_len(8);
    11011171        ignore(na);
    1102         na.set_ip("94.0.0.0");na.set_pref_len(7);
    1103         ignore(na);
    11041172        na.set_ip("100.0.0.0");na.set_pref_len(6);
    11051173        ignore(na);
    11061174        na.set_ip("104.0.0.0");na.set_pref_len(5);
    11071175        ignore(na);
    1108         na.set_ip("112.0.0.0");na.set_pref_len(6);
    1109         ignore(na);
    11101176        na.set_ip("169.254.0.0");na.set_pref_len(16);
    11111177        ignore(na);
    1112         na.set_ip("173.0.0.0");na.set_pref_len(8);
    1113         ignore(na);
    1114         na.set_ip("174.0.0.0");na.set_pref_len(7);
     1178        na.set_ip("175.0.0.0");na.set_pref_len(7);
    11151179        ignore(na);
    11161180        na.set_ip("176.0.0.0");na.set_pref_len(5);
    11171181        ignore(na);
    1118         na.set_ip("184.0.0.0");na.set_pref_len(6);
     1182        na.set_ip("179.0.0.0");na.set_pref_len(5);
     1183        ignore(na);
     1184        na.set_ip("181.0.0.0");na.set_pref_len(6);
     1185        ignore(na);
     1186        na.set_ip("182.0.0.0");na.set_pref_len(6);
     1187        ignore(na);
     1188        na.set_ip("185.0.0.0");na.set_pref_len(6);
    11191189        ignore(na);
    11201190        na.set_ip("191.0.0.0");na.set_pref_len(8);
     
    11301200        na.set_ip("240.0.0.0");na.set_pref_len(4);
    11311201        ignore(na);
    1132         // according to http://www.cymru.com/Documents/bogonv6-list.html#agg
    1133         na.set_ip("0000::");na.set_pref_len(8);
    1134         ignore(na);
    1135         na.set_ip("0100::");na.set_pref_len(8);
    1136         ignore(na);
    1137         na.set_ip("0200::");na.set_pref_len(7);
    1138         ignore(na);
    1139         na.set_ip("0400::");na.set_pref_len(7);
    1140         ignore(na);
    1141         na.set_ip("0600::");na.set_pref_len(7);
    1142         ignore(na);
    1143         na.set_ip("0800::");na.set_pref_len(5);
    1144         ignore(na);
    1145         na.set_ip("1000::");na.set_pref_len(4);
     1202        // according to http://www.cymru.com/Bogons/v6bogon.html (2008-05-20)
     1203        na.set_ip("2001:db8::");na.set_pref_len(32);
     1204        ignore(na);
     1205        na.set_ip("0000::");na.set_pref_len(3);
    11461206        ignore(na);
    11471207        na.set_ip("2000::");na.set_pref_len(16);
    11481208        ignore(na);
     1209        na.set_ip("2001:1::");na.set_pref_len(32);
     1210        ignore(na);
     1211        na.set_ip("2001:2::");na.set_pref_len(31);
     1212        ignore(na);
     1213        na.set_ip("2001:4::");na.set_pref_len(30);
     1214        ignore(na);
     1215        na.set_ip("2001:8::");na.set_pref_len(29);
     1216        ignore(na);
     1217        na.set_ip("2001:10::");na.set_pref_len(28);
     1218        ignore(na);
     1219        na.set_ip("2001:20::");na.set_pref_len(27);
     1220        ignore(na);
     1221        na.set_ip("2001:40::");na.set_pref_len(26);
     1222        ignore(na);
     1223        na.set_ip("2001:80::");na.set_pref_len(25);
     1224        ignore(na);
     1225        na.set_ip("2001:100::");na.set_pref_len(24);
     1226        ignore(na);
    11491227        na.set_ip("2001:1000::");na.set_pref_len(23);
    11501228        ignore(na);
    1151         na.set_ip("2001:1600::");na.set_pref_len(23);
    1152         ignore(na);
    1153         na.set_ip("2001:2000::");na.set_pref_len(20);
    1154         ignore(na);
    1155         na.set_ip("2001:3000::");na.set_pref_len(20);
    1156         ignore(na);
    1157         na.set_ip("2001:4000::");na.set_pref_len(20);
    1158         ignore(na);
    1159         na.set_ip("2001:5000::");na.set_pref_len(20);
    1160         ignore(na);
    1161         na.set_ip("2001:6000::");na.set_pref_len(20);
    1162         ignore(na);
    1163         na.set_ip("2001:7000::");na.set_pref_len(20);
    1164         ignore(na);
    1165         na.set_ip("2001:8000::");na.set_pref_len(20);
    1166         ignore(na);
    1167         na.set_ip("2001:9000::");na.set_pref_len(20);
    1168         ignore(na);
    1169         na.set_ip("2001:A000::");na.set_pref_len(20);
    1170         ignore(na);
    1171         na.set_ip("2001:B000::");na.set_pref_len(20);
    1172         ignore(na);
    1173         na.set_ip("2001:C000::");na.set_pref_len(20);
    1174         ignore(na);
    1175         na.set_ip("2001:D000::");na.set_pref_len(20);
    1176         ignore(na);
    1177         na.set_ip("2001:E000::");na.set_pref_len(20);
    1178         ignore(na);
    1179         na.set_ip("2001:F000::");na.set_pref_len(20);
    1180         ignore(na);
    1181         na.set_ip("3FFF::");na.set_pref_len(16);
    1182         ignore(na);
    1183         na.set_ip("4000::");na.set_pref_len(3);
    1184         ignore(na);
    1185         na.set_ip("6000::");na.set_pref_len(3);
    1186         ignore(na);
    1187         na.set_ip("8000::");na.set_pref_len(3);
    1188         ignore(na);
    1189         na.set_ip("A000::");na.set_pref_len(3);
    1190         ignore(na);
    1191         na.set_ip("C000::");na.set_pref_len(3);
    1192         ignore(na);
    1193         na.set_ip("E000::");na.set_pref_len(4);
     1229        na.set_ip("2001:4e00::");na.set_pref_len(23);
     1230        ignore(na);
     1231        na.set_ip("2001:6000::");na.set_pref_len(19);
     1232        ignore(na);
     1233        na.set_ip("2001:c000::");na.set_pref_len(18);
     1234        ignore(na);
     1235        na.set_ip("2003:4000::");na.set_pref_len(18);
     1236        ignore(na);
     1237        na.set_ip("2003:8000::");na.set_pref_len(17);
     1238        ignore(na);
     1239        na.set_ip("2004::");na.set_pref_len(14);
     1240        ignore(na);
     1241        na.set_ip("2008::");na.set_pref_len(13);
     1242        ignore(na);
     1243        na.set_ip("2010::");na.set_pref_len(12);
     1244        ignore(na);
     1245        na.set_ip("2020::");na.set_pref_len(11);
     1246        ignore(na);
     1247        na.set_ip("2040::");na.set_pref_len(10);
     1248        ignore(na);
     1249        na.set_ip("2080::");na.set_pref_len(9);
     1250        ignore(na);
     1251        na.set_ip("2100::");na.set_pref_len(8);
     1252        ignore(na);
     1253        na.set_ip("2200::");na.set_pref_len(7);
     1254        ignore(na);
     1255        na.set_ip("2410::");na.set_pref_len(12);
     1256        ignore(na);
     1257        na.set_ip("2420::");na.set_pref_len(11);
     1258        ignore(na);
     1259        na.set_ip("2440::");na.set_pref_len(10);
     1260        ignore(na);
     1261        na.set_ip("2480::");na.set_pref_len(9);
     1262        ignore(na);
     1263        na.set_ip("2500::");na.set_pref_len(8);
     1264        ignore(na);
     1265        na.set_ip("2610:200::");na.set_pref_len(23);
     1266        ignore(na);
     1267        na.set_ip("2610:400::");na.set_pref_len(22);
     1268        ignore(na);
     1269        na.set_ip("2610:800::");na.set_pref_len(21);
     1270        ignore(na);
     1271        na.set_ip("2610:1000::");na.set_pref_len(20);
     1272        ignore(na);
     1273        na.set_ip("2610:2000::");na.set_pref_len(19);
     1274        ignore(na);
     1275        na.set_ip("2610:4000::");na.set_pref_len(18);
     1276        ignore(na);
     1277        na.set_ip("2610:8000::");na.set_pref_len(17);
     1278        ignore(na);
     1279        na.set_ip("2611::");na.set_pref_len(16);
     1280        ignore(na);
     1281        na.set_ip("2612::");na.set_pref_len(15);
     1282        ignore(na);
     1283        na.set_ip("2614::");na.set_pref_len(14);
     1284        ignore(na);
     1285        na.set_ip("2618::");na.set_pref_len(13);
     1286        ignore(na);
     1287        na.set_ip("2620:200::");na.set_pref_len(23);
     1288        ignore(na);
     1289        na.set_ip("2620:400::");na.set_pref_len(22);
     1290        ignore(na);
     1291        na.set_ip("2620:800::");na.set_pref_len(21);
     1292        ignore(na);
     1293        na.set_ip("2620:1000::");na.set_pref_len(20);
     1294        ignore(na);
     1295        na.set_ip("2620:2000::");na.set_pref_len(19);
     1296        ignore(na);
     1297        na.set_ip("2620:4000::");na.set_pref_len(18);
     1298        ignore(na);
     1299        na.set_ip("2620:8000::");na.set_pref_len(17);
     1300        ignore(na);
     1301        na.set_ip("2621::");na.set_pref_len(16);
     1302        ignore(na);
     1303        na.set_ip("2622::");na.set_pref_len(15);
     1304        ignore(na);
     1305        na.set_ip("2624::");na.set_pref_len(14);
     1306        ignore(na);
     1307        na.set_ip("2628::");na.set_pref_len(13);
     1308        ignore(na);
     1309        na.set_ip("2630::");na.set_pref_len(12);
     1310        ignore(na);
     1311        na.set_ip("2640::");na.set_pref_len(10);
     1312        ignore(na);
     1313        na.set_ip("2680::");na.set_pref_len(9);
     1314        ignore(na);
     1315        na.set_ip("2700::");na.set_pref_len(8);
     1316        ignore(na);
     1317        na.set_ip("2810::");na.set_pref_len(12);
     1318        ignore(na);
     1319        na.set_ip("2820::");na.set_pref_len(11);
     1320        ignore(na);
     1321        na.set_ip("2840::");na.set_pref_len(10);
     1322        ignore(na);
     1323        na.set_ip("2880::");na.set_pref_len(9);
     1324        ignore(na);
     1325        na.set_ip("2900::");na.set_pref_len(8);
     1326        ignore(na);
     1327        na.set_ip("2a10::");na.set_pref_len(8);
     1328        ignore(na);
     1329        na.set_ip("2a20::");na.set_pref_len(8);
     1330        ignore(na);
     1331        na.set_ip("2a40::");na.set_pref_len(8);
     1332        ignore(na);
     1333        na.set_ip("2a80::");na.set_pref_len(8);
     1334        ignore(na);
     1335        na.set_ip("2b00::");na.set_pref_len(8);
     1336        ignore(na);
     1337        na.set_ip("2c10::");na.set_pref_len(12);
     1338        ignore(na);
     1339        na.set_ip("2c20::");na.set_pref_len(11);
     1340        ignore(na);
     1341        na.set_ip("2c40::");na.set_pref_len(10);
     1342        ignore(na);
     1343        na.set_ip("2c80::");na.set_pref_len(9);
     1344        ignore(na);
     1345        na.set_ip("2d00::");na.set_pref_len(8);
     1346        ignore(na);
     1347        na.set_ip("2e00::");na.set_pref_len(7);
     1348        ignore(na);
     1349        na.set_ip("3000::");na.set_pref_len(4);
     1350        ignore(na);
     1351        na.set_ip("4000::");na.set_pref_len(2);
     1352        ignore(na);
     1353        na.set_ip("8000::");na.set_pref_len(1);
    11941354        ignore(na);
    11951355        na.set_ip("F000::");na.set_pref_len(5);
  • protlib/branches/20081127-merge-mobility-mk3/src/cmsghdr_util.cpp

    • Property svn:keywords set to Id HeadURL Rev
    r4140 r4142  
    198198}
    199199
    200 /** Adds the outgoing interface index to a msghdr
    201  *
    202  * This function adds a pkt_info for setting the outgoing interface to the
     200/** Adds the outgoing interface index or outgoing address to a msghdr
     201 *
     202 * This function adds a pkt_info for setting the outgoing interface/address to the
    203203 * msg_control member of the given msghdr.  For this purpose it writes a
    204204 * cmsghdr struct to pointer cmsg, which MUST point to the memory area
     
    211211 * @param cmsg  the location where the cmsghdr structure for the hop limit
    212212 *              should be written to
    213  * @oif         the desired outgoing interface index
     213 * @param oif   the desired outgoing interface index, may be 0 if unset (usually if outgoing_address is given)
     214 * @param outgoing_address  the ip source address, may be NULL if unset (usually if oif is given)
    214215 * @return      zero on success, -1 on error
    215216 */
    216217int
    217 cmsghdr_build_oif(msghdr *msg, cmsghdr *cmsg, uint16_t oif)
     218cmsghdr_build_oif(msghdr *msg, cmsghdr *cmsg, const hostaddress* outgoing_address, uint16_t oif)
    218219{
    219220    assert(msg);
    220221    assert(cmsg != NULL);
    221     assert(oif > 0);
    222222
    223223    in6_pktinfo pktinfo;
     
    226226      return -1;
    227227
    228     pktinfo.ipi6_addr = in6addr_any;
     228    if (outgoing_address)
     229            outgoing_address->get_ip(pktinfo.ipi6_addr);
     230    else
     231            pktinfo.ipi6_addr = in6addr_any;
     232
    229233    pktinfo.ipi6_ifindex = oif;
    230234
     
    236240}
    237241
     242
     243
    238244/** Set ancillary data to configure Routing Alert Option, outgoing interface and IP hop limit
    239245 *
     
    256262 *              be set for
    257263 * @param rao   The desired Router Alert Option value (or -1 if none wanted)
     264 * @param outgoing_address The desired outgoing address
     265 *              (or NULL if the kernel should choose the outgoing address)
    258266 * @param oif   The desired outgoing interface index (> 0)
    259267 *              (or zero if the kernel should choose the outgoing interface)
     
    262270 */
    263271void
    264 set_ancillary_data(struct msghdr *msg, int rao, uint16_t oif, int hlim)
     272set_ancillary_data(struct msghdr *msg, int rao, const hostaddress* outgoing_address, uint16_t oif, int hlim)
    265273{
    266274  const char *const methodname= "protlib::util::set_ancillary_data()";
     
    332340    cmsgptr = CMSG_NXTHDR(msg, cmsgptr);
    333341  }
    334   if (oif > 0)
     342  if (oif > 0 || outgoing_address != NULL)
    335343  {
    336     DLog(methodname, "Adding IP outgoing interface " << oif);
    337     int rv = cmsghdr_build_oif(msg, cmsgptr, oif);
     344    if (oif > 0)
     345            DLog(methodname, "Adding IP outgoing interface " << oif);
     346    if (outgoing_address != NULL)
     347            DLog(methodname, "Adding outgoing IP address " << *outgoing_address);
     348
     349    int rv = cmsghdr_build_oif(msg, cmsgptr, outgoing_address, oif);
    338350    if (rv != 0) {
    339351    }
    340352    cmsgptr = CMSG_NXTHDR(msg, cmsgptr);
    341353  }
     354
    342355#ifdef DEBUG_HARD
    343356  dump_cmsghdr(msg); // for debugging purposes (declaration see below)
  • protlib/branches/20081127-merge-mobility-mk3/src/cmsghdr_util.h

    • Property svn:keywords set to Id HeadURL Rev
    r4140 r4142  
    3333
    3434#include <sys/socket.h> /* msghdr */
     35#include <address.h>
    3536
    3637namespace protlib {
     
    7980
    8081// Builds a cmsghdr data structure for a pkt_info
    81 // with unspecified IP address and the outgoing
     82// with specified optional IP address and/or the outgoing
    8283// interface index set to oif.
    8384// This function respects msg->msg_controllen.
     
    8586
    8687int
    87 cmsghdr_build_oif(msghdr *msg, cmsghdr *cmsg, uint16_t oif);
     88cmsghdr_build_oif(msghdr *msg, cmsghdr *cmsg, const hostaddress *own_addr, uint16_t oif);
    8889
    8990void
    90 set_ancillary_data(struct msghdr *msg, int rao, uint16_t oif = 0, int hlim = 0);
     91set_ancillary_data(struct msghdr *msg, int rao, const hostaddress *own_addr= NULL, uint16_t oif = 0, int hlim = 0);
    9192
    9293void
  • protlib/branches/20081127-merge-mobility-mk3/src/network_message.cpp

    r3701 r4142  
    7777 * @param s buffer size.
    7878 */
    79 NetMsg::NetMsg(uint32 s) {
     79NetMsg::NetMsg(uint32 s) : buf(NULL), buf_len(0), pos(NULL), buf_end(NULL), allocated(true) {
    8080  if (s>max_size) throw NetMsgError(NetMsgError::ERROR_TOO_LONG);
    8181  if (s==0) throw NetMsgError(NetMsgError::ERROR_INVALID_BUFSIZE);
     
    9393 * @param copy copy the buffer or use the buffer without copying.
    9494 */
    95 NetMsg::NetMsg(uchar *b, uint32 s, bool copy) {
     95NetMsg::NetMsg(uchar *b, uint32 s, bool copy) : buf(NULL), buf_len(0), pos(NULL), buf_end(NULL), allocated(false) {
    9696  if (s>max_size) throw NetMsgError(NetMsgError::ERROR_TOO_LONG);
    9797  if (s==0) throw NetMsgError(NetMsgError::ERROR_INVALID_BUFSIZE);
     
    9999    buf = new(nothrow) uchar[s];
    100100    if (!buf) throw NetMsgError(NetMsgError::ERROR_NO_MEM);
     101    allocated= true;
    101102    memcpy(buf,b,s);
    102103  } else {
     
    109110} // end constructor
    110111
    111 NetMsg::NetMsg(const NetMsg& n) {
    112   buf_len = n.buf_len;
    113   if (buf_len == 0)
    114     throw NetMsgError(NetMsgError::ERROR_INVALID_BUFSIZE);
    115 
    116   buf = new(nothrow) uchar[buf_len];
    117   if (!buf) throw NetMsgError(NetMsgError::ERROR_NO_MEM);
    118   memcpy(buf,n.buf,buf_len);
    119   pos = buf+(n.pos-n.buf);
    120   buf_end = buf+(buf_len-1);
     112
     113// copy constructor
     114NetMsg::NetMsg(const NetMsg& n) : buf(NULL), buf_len(n.buf_len), pos(NULL), buf_end(NULL), allocated(false) {
     115  // only copy a buffer of length > 0, otherwise we initialize as empty buffer
     116  if (buf_len)
     117  {
     118          buf = new(nothrow) uchar[buf_len];
     119          if (!buf) throw NetMsgError(NetMsgError::ERROR_NO_MEM);
     120          allocated= true;
     121          memcpy(buf,n.buf,buf_len);
     122          pos = buf+(n.pos-n.buf);
     123          buf_end = buf+(buf_len-1);
     124  }
    121125} // end copy constructor
    122126
    123 /** Frees the message buffer. */
     127
     128/** Frees the message buffer if memory was actually allocated. */
    124129NetMsg::~NetMsg() {
    125   if (buf) { delete[] buf; buf= 0; }
     130  if (buf && allocated) { delete[] buf; buf= 0; }
    126131} // end destructor
    127132
  • protlib/branches/20081127-merge-mobility-mk3/src/tp_over_sctp.cpp

    r3701 r4142  
    7171// inherited from TP
    7272void
    73 TPoverSCTP::send(NetMsg *msg, const address &in_addr, const address *local_addr, bool use_existing_connection)
     73TPoverSCTP::send(NetMsg *msg, const address &in_addr, bool use_existing_connection, const address *local_addr)
    7474{
    7575        if (msg == NULL) {
  • protlib/branches/20081127-merge-mobility-mk3/src/tp_over_tcp.cpp

    r3701 r4142  
    266266
    267267 if (!addr) return;
     268 // since tpsend() converts to canonical format, we must do the same here
     269 addr->convert_to_ipv6();
    268270
    269271  // Create a new AssocData-pointer
     
    342344    return;
    343345  }
     346  addr->convert_to_ipv6();
    344347
    345348  // lock due to sendermap access
     
    438441  // throws an error if something is not right
    439442  if (addr) {
     443    // convert to canonical IPv6 address format
    440444    addr->convert_to_ipv6();
    441445    check_send_args(*netmsg,*addr);
  • protlib/branches/20081127-merge-mobility-mk3/src/tp_over_udp.cpp

    r3701 r4142  
    5555#include "setuid.h"
    5656#include "logfile.h"
     57#include "cmsghdr_util.h"
    5758#include "linux/netfilter.h"
    5859
     
    8384
    8485/** generates an internal TPoverUDP message to send a NetMsg to the network
     86 * @param netmsg    the message buffer that should be sent
     87 * @param in_addr   destination address
     88 * @param use_exisiting_connection whether establishing a new connection is allowed (not applicable here)
     89 * @param local_addr source address to use
    8590 *
    8691 *  - the sending thread will call TPoverUDP::udpsend()
     
    8893 *  @note the netmsg is deleted by the send() method when it is not used anymore
    8994 */
    90 void TPoverUDP::send (NetMsg * netmsg, const address & in_addr, const address *local_addr, bool use_existing_connection)
     95void
     96TPoverUDP::send (NetMsg * netmsg, const address & in_addr, bool use_existing_connection, const address *local_addr)
    9197{
    9298
     
    147153  struct msghdr header;
    148154
    149   // pointer for ancillary data
    150   struct cmsghdr *ancillary = NULL;
    151          
    152155  // iovec for sendmsg
    153156  struct iovec iov;
     
    163166  dest_address.sin6_scope_id = 0;
    164167
     168  // control options for sendmsg
     169  int hop_limit = ( addr->get_ip_ttl() ? addr->get_ip_ttl() : -1 );
     170  if ( hop_limit != -1 )
     171    DLog(tpparam.name, "Setting IP hop limit to " << hop_limit);
     172
     173  int rao = ( addr->rao_present() ? addr->get_rao() : -1 );
     174  if ( rao != -1 )
     175    DLog(tpparam.name, "Setting IP RAO to " << rao);
     176
     177  uint16_t oif = addr->get_if_index();
     178  if ( oif != 0 )
     179    DLog(tpparam.name, "Setting outgoing interface index to " << oif);
     180
    165181  // fill msghdr
    166182  header.msg_iov = &iov;
     
    171187  header.msg_controllen=0;
    172188
    173 
    174   // pktinfo
    175   in6_pktinfo pktinfo;
    176 
    177   // we have to add up to 2 ancillary data objects (for interface and hop limit)
    178 
    179   uint32 buflength = 0;
    180 
    181   if (local_addr) {
    182     buflength = CMSG_SPACE(sizeof(pktinfo));
    183     //cout << "PKTINFO data object, total buffer size: " << buflength << "byte" << endl;
    184   }
    185 
    186   int hlim = addr->get_ip_ttl();
    187 
    188   if (hlim) {
    189     buflength = buflength + CMSG_SPACE(sizeof(int));
    190     //cout << "HOPLIMIT data object, total buffer size: " << buflength << "byte" << endl;
    191   }
    192   // create the buffer
    193   if (local_addr || hlim) {
    194     header.msg_control = malloc(buflength);
    195     if (header.msg_control == 0)
    196       ERRCLog(tpparam.name, thisproc << " malloc failed for ancillary data of size " << buflength);
    197   }
    198 
    199   // are we to set the outgoing address?
    200   if (local_addr) {
    201 
    202     DLog(tpparam.name, thisproc << " UDP send from source addr " << local_addr << " requested.");
    203 
    204     // first cmsghdr at beginning of buffer
    205     ancillary = (cmsghdr*) header.msg_control;
    206          
    207     ancillary->cmsg_level=IPPROTO_IPV6;
    208     ancillary->cmsg_type=IPV6_PKTINFO;
    209     ancillary->cmsg_len=CMSG_LEN(sizeof(pktinfo));
    210          
    211     //cout << "Set up properties of ancillary data object 1" << endl;
    212 
    213     local_addr->get_ip(pktinfo.ipi6_addr);
    214     pktinfo.ipi6_ifindex = 0;
    215 
    216     memcpy (CMSG_DATA(ancillary), &pktinfo, sizeof(pktinfo));
    217  
    218     //cout << "Set up data of ancillary data object 1" << endl;
    219 
    220     // update msghdr controllen
    221     header.msg_controllen = CMSG_SPACE(sizeof(pktinfo));
    222          
    223   }
    224 
    225   // should we set an explicit Hop Limit?
    226   if (hlim) {
    227     DLog(tpparam.name, thisproc << " UDP send with IP TTL of " << hlim << " requested.");
    228 
    229     // second cmsghdr after first one
    230     cmsghdr* ancillary2 = NULL;
    231 
    232     if (ancillary) {
    233       ancillary2 = (cmsghdr*) ((caddr_t)ancillary + CMSG_SPACE(sizeof(pktinfo)));
    234     } else {
    235       ancillary2 = (cmsghdr*) header.msg_control;
    236     }
    237 
    238     ancillary2->cmsg_level=IPPROTO_IPV6;
    239     ancillary2->cmsg_type=IPV6_HOPLIMIT;
    240     ancillary2->cmsg_len = CMSG_LEN(sizeof(int));
    241 
    242     memcpy(CMSG_DATA(ancillary2), &hlim, sizeof(int));
    243  
    244     // update msghdr controllen
    245     header.msg_controllen = header.msg_controllen + ancillary2->cmsg_len;
    246 
    247   }
     189  // fill msghdr.msg_control
     190  util::set_ancillary_data(&header, rao, local_addr, oif, hop_limit);
    248191
    249192#ifndef _NO_LOGGING
     
    270213  DLog(tpparam.name, "SEND to " << *addr);
    271214  ret= sendmsg(master_listener_socket,&header,MSG_DONTWAIT); 
     215
     216  // free ancilliary data allocated by protlib::util::set_ancillary_data()
     217  free(header.msg_control);
     218  header.msg_control = NULL; // ... just in case
    272219
    273220  if (ret<0)
  • protlib/branches/20081127-merge-mobility-mk3/src/tp_over_uds.cpp

    r3207 r4142  
    300300 */
    301301void
    302 TPoverUDS::send(NetMsg* netmsg, const address& in_addr, const address *local_addr, bool use_existing_connection)
     302TPoverUDS::send(NetMsg* netmsg, const address& in_addr, bool use_existing_connection, const address *local_addr)
    303303{
    304304    if (netmsg == NULL) {
  • protlib/branches/20081127-merge-mobility-mk3/src/tp_queryencap.cpp

    r3543 r4142  
    5858#include "queuemanager.h"
    5959#include "logfile.h"
     60#include "cmsghdr_util.h"
    6061#include "linux/netfilter.h"
    6162
     
    8788
    8889void
    89 TPqueryEncap::send (NetMsg * netmsg, const address & addr_in, const address *local_addr, bool use_existing_connection)
     90TPqueryEncap::send (NetMsg * netmsg, const address & addr_in, bool use_existing_connection, const address *local_addr)
    9091{
    9192  appladdress* addr = NULL;
     
    184185         * This setting works with kernel 2.6.15.
    185186         */
    186         if ( rao != -1 ) {
     187        if ( hop_limit != -1 ) {
    187188                int ret = setsockopt(sockfd, SOL_IPV6, IPV6_UNICAST_HOPS,
    188189                                        &hop_limit, sizeof hop_limit);
     
    190191                        ERRLog(tpparam.name, "setting IPv6 hop limit failed");
    191192        }
    192 }
    193 
    194 
    195 
    196 /*
    197  * Definitions for the IPv6 Router Alert Option, see RFC-2711.
    198  */
    199 static const uint8_t IP6_RAO_OPT_TYPE           = 0x05; // hop-by-hop opt. type
    200 static const uint8_t IP6_RAO_OPT_LEN            = 2;
    201 static const uint8_t IP6_RAO_OPT_ALIGN          = 2;    // 2n + 0 alignment
    202 
    203 #ifdef HAS_RFC2292
    204 static const uint8_t IP6_RAO_OPT_MULTX          = 2;    // 2n + 0 alignment
    205 static const uint8_t IP6_RAO_OPT_OFFSETY        = 0;
    206 #endif
    207 
    208 struct ip6_rao_opt {
    209         uint8_t         ip6_rao_opt_type;
    210         uint8_t         ip6_rao_opt_len;
    211         uint16_t        ip6_rao_opt_val;
    212 };
    213 
    214 
    215 /**
    216  * Activate the router alert option in the given msghdr structure.
    217  *
    218  * This sets the msg_control and msg_controllen fields of the msghdr structure.
    219  * Note that the msg_control member points to allocated memory which you have
    220  * to free yourself.
    221  *
    222  * @param msg the msghdr structure for sendmsg(2)
    223  * @param rao the RAO in host byte order (a 16 bit value, or -1)
    224  */
    225 void
    226 TPqueryEncap::set_ancillary_data(struct msghdr *msg, int rao, const hostaddress *own_addr) {
    227   const char *const methodname= "TPqueryEncap::set_ancillary_data()";
    228 
    229   struct cmsghdr *cmsgptr= NULL;
    230 
    231 #ifdef HAS_RFC2292
    232         struct ip6_rao_opt opt_rao;
    233 #else
    234         int currentlen, cmsgspace;
    235         socklen_t extlen, extlen1;
    236         uint16_t val;
    237         void *databuf, *extbuf;
    238 #endif
    239 
    240         assert( msg->msg_control == NULL );
    241         assert( msg->msg_controllen == 0 );
    242 
    243         if (rao == -1)
    244                 return;
    245 
    246 #ifdef HAS_RFC2292
    247         /* We have to free this later! */
    248         msg->msg_control = malloc( inet6_option_space(sizeof opt_rao) );
    249         assert( msg->msg_control != NULL );
    250 
    251         inet6_option_init(msg->msg_control, &cmsgptr, IPV6_HOPOPTS);
    252 
    253         opt_rao.ip6_rao_opt_type = IP6_RAO_OPT_TYPE;
    254         opt_rao.ip6_rao_opt_len = IP6_RAO_OPT_LEN;
    255         opt_rao.ip6_rao_opt_val = htons(rao);
    256 
    257         inet6_option_append(cmsgptr, &opt_rao.ip6_rao_opt_type,
    258                                 IP6_RAO_OPT_MULTX, IP6_RAO_OPT_OFFSETY);
    259 
    260         msg->msg_controllen = cmsgptr->cmsg_len;
    261 #else
    262 
    263         /* Quote from RFC 3542:
    264          * All the Hop-by-Hop options must be specified by a single ancillary
    265          * data object.  The cmsg_level member is set to IPPROTO_IPV6 and the
    266          * cmsg_type member is set to IPV6_HOPOPTS.  The option is normally
    267          * constructed using the inet6_opt_init(), inet6_opt_append(),
    268          * inet6_opt_finish(), and inet6_opt_set_val() functions, described in
    269          * Section 10.
    270          */
    271 
    272 
    273         // Calculate the required memory space first
    274         currentlen = inet6_opt_init(NULL, 0);
    275         if (currentlen == -1)
    276         {
    277           ERRCLog(methodname, "Failure while calculating Hop-by-Hop Router Alert Option, inet6_opt_init()");
    278           return;
    279         }
    280         // RFC 2711:
    281         //    The router alert option has the following format:
    282         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    283         // |0 0 0|0 0 1 0 1|0 0 0 0 0 0 1 0|        Value (2 octets)       |
    284         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    285         //                  length = 2
    286         //
    287         // Alignment requirement: 2n+0
    288         //
    289         // Hbh-Extension Header for Router Alert should look like this:
    290         //
    291         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    292         // |Next Header=UDP| Hdr Ext Len=0 | Option Type=5 |Opt Data Len=2 |
    293         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    294         // |        Value (2 octets)       | Option Type=1 |Opt Data Len=0 | (PadN, 2 bytes)
    295         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    296         // in Hex: 0x11 00 05 02 XX XX 01 00 (if next header is UDP)
    297         //
    298         // or like this:
    299         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    300         // |Next Header=UDP| Hdr Ext Len=0 | Option Type=1 |Opt Data Len=0 | (PadN, 2 bytes)
    301         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    302         // | Option Type=1 |Opt Data Len=0 |      Value (2 octets)         |
    303         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    304         // in Hex: 0x11 00 01 00 05 02 XX XX (if next header is UDP)
    305 
    306         currentlen = inet6_opt_append(NULL, 0, currentlen,
    307                                       IP6_RAO_OPT_TYPE,
    308                                       IP6_RAO_OPT_LEN,
    309                                       IP6_RAO_OPT_ALIGN, NULL);
    310         if (currentlen == -1)
    311         {
    312           ERRCLog(methodname, "Failure while calculating Hop-by-Hop Router Alert Option, does not fit into extension header");
    313           return;
    314         }
    315         currentlen = inet6_opt_finish(NULL, 0, currentlen);
    316         if (currentlen == -1)
    317         {
    318           ERRCLog(methodname, "Failure while calculating Hop-by-Hop Router Alert Option, inet6_opt_finish()");
    319           return;
    320         }
    321 
    322         // now allocate the csmg stuff
    323         // extlen is the length of the header extension in bytes
    324         extlen = currentlen;
    325 
    326         // if source selection is requested we need to add packet info
    327         if (own_addr) {
    328                 extlen1 = sizeof(in6_pktinfo);
    329         }
    330         // allocate space for the ancillary data structure
    331         cmsgspace = CMSG_SPACE(extlen) + (own_addr ? CMSG_SPACE(extlen1) : 0);
    332         cmsgptr= static_cast<cmsghdr*>( malloc(cmsgspace) );
    333         memset(cmsgptr, 0, cmsgspace);
    334 
    335         assert(cmsgptr != NULL);
    336 
    337         cmsgptr->cmsg_level = IPPROTO_IPV6;
    338         cmsgptr->cmsg_type = IPV6_HOPOPTS;
    339         cmsgptr->cmsg_len = CMSG_LEN(extlen);
    340         extbuf = CMSG_DATA(cmsgptr);
    341 
    342         assert(extbuf != NULL);
    343 
    344         //DLog(methodname, "Hop-by-Hop Router Alert Option, BufferSize: " << extlen);
    345 
    346         // Quoting RFC 2460:
    347         // Hdr Ext Len          8-bit unsigned integer.  Length of the Hop-by-
    348         //                      Hop Options header in 8-octet units, not
    349         //                      including the first 8 octets.
    350 
    351         currentlen = inet6_opt_init(extbuf, extlen);
    352         if (currentlen == -1) {
    353           ERRCLog(methodname, "Failure while setting Hop-by-Hop Router Alert Option, inet6_opt_init()");
    354           free(extbuf);
    355           return;
    356         }
    357         // inet6_opt_init initializes the value wrongly (glibc2.6.1):
    358         // it divides extlen by 8, but passsing an extlen of 0 is not possible
    359         // so we must fix the setting now
    360         struct ip6_hbh *extp = reinterpret_cast<struct ip6_hbh *>(extbuf);
    361         // inet6_opt_init did already some sanity checks (extlen is multiple of 8)
    362         extp->ip6h_len= (extlen / 8) - 1; // should be zero then, indicating a length of 8 bytes
    363 
    364         currentlen = inet6_opt_append(extbuf, extlen, currentlen,
    365             IP6_RAO_OPT_TYPE, IP6_RAO_OPT_LEN, IP6_RAO_OPT_ALIGN,
    366             &databuf);
    367         if (currentlen == -1) {
    368           ERRCLog(methodname, "Failure while setting Hop-by-Hop Router Alert Option, does not fit into extension header");
    369           free(extbuf);
    370           return;
    371         }
    372 
    373         val = htons(rao);
    374         (void)inet6_opt_set_val(databuf, 0, &val, sizeof(val));
    375 
    376         currentlen = inet6_opt_finish(extbuf, extlen, currentlen);
    377         if (currentlen == -1) {
    378           ERRCLog(methodname, "Failure while setting Hop-by-Hop Router Alert Option, inet6_opt_finish()");
    379           free(extbuf);
    380           return;
    381         }
    382 
    383         msg->msg_control = cmsgptr;
    384         msg->msg_controllen = cmsgspace;
    385 
    386         if (own_addr) {
    387                 cmsgptr = (cmsghdr*)((caddr_t)cmsgptr + CMSG_SPACE(extlen));
    388                 cout << cmsgptr << endl;
    389 
    390                 cmsgptr->cmsg_level=IPPROTO_IPV6;
    391                 cmsgptr->cmsg_type=IPV6_PKTINFO;
    392                 cmsgptr->cmsg_len=CMSG_LEN(extlen1);
    393 
    394                 in6_pktinfo *pktinfo = reinterpret_cast<in6_pktinfo *>(CMSG_DATA(cmsgptr));
    395          
    396                 own_addr->get_ip(pktinfo->ipi6_addr);
    397                 pktinfo->ipi6_ifindex = 0;
    398         }
    399 
    400 #endif
    401 
    402         NetMsg tmpmsg( (uchar*) msg->msg_control, (uint32) msg->msg_controllen, true );
    403 
    404         //ostringstream out;
    405         //tmpmsg.hexdump(out);
    406         //DLog(methodname, "Hop-by-Hop Router Alert Option, Cmsg Space:" << msg->msg_controllen << " cmsglen:" << cmsgptr->cmsg_len << " Buffer Contents: " << out.str());
    407 
    408193}
    409194
     
    440225    DLog(tpparam.name, "Setting IP RAO to " << rao);
    441226
     227  uint16_t oif = addr->get_if_index();
     228  if ( oif != 0 )
     229    DLog(tpparam.name, "Setting outgoing interface index to " << oif);
     230
    442231  try {
    443232    check_send_args(*netmsg, *addr);
     
    497286
    498287  // this sets msg.msg_control and msg.msg_controllen
    499   set_ancillary_data(&msg, rao, own_addr);
     288  util::set_ancillary_data(&msg, rao, own_addr, oif, hop_limit);
    500289
    501290  /*
     
    503292   * so we can finally send the message.
    504293   */
    505 
    506   // TODO: Setting the outgoing interface is currently unimplemented,
    507   //       but I don't think it worked with r1816 or earlier.
    508 
    509294
    510295  // return code will be checked below
     
    662447
    663448  // if we set this var to "1" the packet will be taken, if we set it to "0", we don't take it
    664   int intercept=0;
     449  bool intercept= false;
    665450
    666451  TPMsg *tpmsg = 0;
     
    699484          ipq_packet_msg_t *m = ipq_get_packet (buf);
    700485          struct ip6_hdr *ip = (struct ip6_hdr *) m->payload;
    701 
     486          uint8 next_header= ip->ip6_nxt;
    702487          uint8 ip_ttl = ip->ip6_hlim;
     488          const uint8 ip6_headerlen= 40;
    703489
    704490          // this is the IPv6 capturer, we have got a handle to the IPv6 Queue, so we can be sure to receive only IPv6 packets
     
    706492          // We have to check, if Hop-By-Hop Option Header is present. If it is, it is the first extension header
    707493          // with code "0" in ip6_next of base header
    708           if (ip->ip6_nxt == 0) intercept= 1;
     494          if (next_header == 0) intercept= true;
    709495             
    710496          // We have to look for RAO option in Hop-by-Hop extension header, if it is NOT set to a value we look for, don't intercept
    711           if (intercept == 1)
     497          if (intercept)
    712498          {
    713             struct ip6_hbh *optheader = (struct ip6_hbh *) (m->payload + 40);
    714             Log (DEBUG_LOG, LOG_NORMAL, tpparam.name, "[IPv6catcher] - IPv6 Packet with HbH-option header received, inspecting it");
    715             intercept=0;
     499            struct ip6_hbh *optheader = (struct ip6_hbh *) (m->payload + ip6_headerlen);
     500            DLog(tpparam.name, "[IPv6catcher] - IPv6 Packet with HbH-option header received, inspecting it");
     501            intercept= false;
    716502             
    717503            int i = 0;
    718             option = (ip_opt *) (m->payload +42);
     504            option = (ip_opt *) (m->payload + ip6_headerlen + 2);
    719505           
    720506            if (option->opt1 == IP6_RAO_OPT_TYPE) {
    721               intercept = 1;
     507              intercept = true;
    722508            }
    723509            else
     
    729515                {
    730516                  i++;
    731                   option = (ip_opt *) (m->payload +42 +i);
     517                  option = (ip_opt *) (m->payload + ip6_headerlen + 2 +i);
    732518                }
    733519                // No PADDING! We have hit an option and its not Router alert! We must move "LENGTH+2" right!
    734520                if ((option->opt1 != 0)&(option->opt1 != IP6_RAO_OPT_TYPE)) i = option->opt2+2;
    735                 option = (ip_opt *) (m->payload + 42 + i);
     521                option = (ip_opt *) (m->payload + ip6_headerlen + 2 + i);
    736522                // We have hit Router Alert! Break loop, leave it alone!
    737                 if (option->opt1 == IP6_RAO_OPT_TYPE) { intercept=1; break; }
     523                if (option->opt1 == IP6_RAO_OPT_TYPE) { intercept= true; break; }
    738524              }
    739525              while (i <= optheader->ip6h_len); // don't overrun end of ip hop-by-hop options header!
     
    750536            }
    751537               
    752             Log (DEBUG_LOG, LOG_NORMAL, tpparam.name, "[IPv6catcher] - Listening for RAOs: " << os.str().c_str());
    753             Log (DEBUG_LOG, LOG_NORMAL, tpparam.name, "[IPv6catcher] - Inspecting RAO value of: " << ntohs(option->opt3));
    754 
    755             intercept = 0;
     538            DLog(tpparam.name, "[IPv6catcher] - Listening for RAOs: " << os.str().c_str());
     539            DLog(tpparam.name, "[IPv6catcher] - Inspecting RAO value of: " << ntohs(option->opt3));
     540
     541            intercept = false;
    756542            // inspect RAO vector
    757543            for (unsigned int i = 0; i < tpparam.raovec.size(); i++) {
    758               if (tpparam.raovec[i] == ntohs(option->opt3)) intercept = 1;
    759             }
    760           }
    761 
    762           // if intercept is 0, RAO value did not match
    763           if (intercept == 0)
     544              if (tpparam.raovec[i] == ntohs(option->opt3)) intercept= true;
     545            } // end for
     546          } // end if intercept
     547
     548          // if intercept is false, RAO value did not match, stop here if strict RAO matching is required
     549          if (intercept == false && tpparam.strict_rao)
    764550          {
    765551            // we don't care about this packet, let it pass the firewall
     
    769555            //Log (DEBUG_LOG, LOG_NORMAL, tpparam.name, "[IPv6catcher] - I let a packet without RAO set pass");
    770556          }
    771 
    772           int offset = 40; // will point to IP payload, initially size of IPv6 header
    773           // one RAO value matched, now check for magic number
    774           if (intercept == 1)
     557          else
    775558          {
    776             // so far the RAO instructs us to intercept this packet, but we still have to check for the magic number
    777             Log (DEBUG_LOG, LOG_NORMAL, tpparam.name, "[IPv6catcher] - I am instructed to intercept this RAO");
    778            
     559            if (intercept)
     560            {
     561              // so far the RAO instructs us to intercept this packet, but we still have to check for the magic number
     562              DLog(tpparam.name, "[IPv6catcher] - I am instructed to intercept this RAO");
     563            }
     564            else
     565            {
     566              DLog(tpparam.name, "[IPv6catcher] - Checking for interception even if no RAO used");
     567              intercept= true;
     568            }
     569          }
     570
     571          int offset = ip6_headerlen; // will point to IP payload, initially size of IPv6 header
     572
     573          // one RAO value matched (or we do not require strict RAO checking), now check for magic number
     574          if (intercept)
     575          {         
    779576            peer_addr = new appladdress();
    780577            own_addr = new appladdress();
    781578                         
    782579            // Now to do: iterate over extension headers to find the start of the UDP header
    783 
    784             // the first extension header is the hop-by-hop options header and it IS present
     580            // the first extension header is the hop-by-hop options header and it is present
     581            // if RAO was used
    785582            struct ip6_ext *extheader = (struct ip6_ext *) (m->payload + offset);
    786583                 
    787584            // if the 2nd extension header is upper layer header, we found the UDP offset
    788             if (extheader->ip6e_nxt == IPPROTO_UDP)
     585            if (next_header == IPPROTO_UDP)
    789586            {
    790587              DLog(tpparam.name, "[IPv6catcher] - Instantly found UDP header, do not loop over headers");
    791588            }
    792             else 
     589            else
    793590            {
     591              // assume that some extension header is present
     592              next_header= extheader->ip6e_nxt;
    794593              // iterate if next header is not UDP
    795               while (extheader->ip6e_nxt != IPPROTO_UDP)
     594              while (next_header != IPPROTO_UDP)
    796595              {
    797596                // advance to next extension header
     
    805604                }
    806605                extheader = (struct ip6_ext *) (m->payload + offset);
     606                next_header= extheader->ip6e_nxt;
    807607              } // end while
     608              // set offset to next header following the last extension header that we saw
     609              offset = offset + 8 + (extheader->ip6e_len * 8);
    808610            }
    809611            // set offset to next header following the last extension header that we saw
     
    824626                  die (h);
    825627                // stop interception
    826                 intercept= 0;
     628                intercept= false;
    827629              }
    828630              else
     631              {
    829632                DLog(tpparam.name, "[IPv6catcher] - " << color[green] << "magic number matched" << color[off]);
     633                uint32 *common_header_word2= reinterpret_cast<uint32 *>(m->payload + offset + udp_header_size + 8);
     634                if ( !tpparam.strict_rao && (ntohl(*common_header_word2) & 0x8000)==0 )
     635                {
     636                  DLog(tpparam.name, "[IPv6catcher] - C-Flag not set - will not intercept");
     637                  intercept= false;
     638                }
     639              }
    830640
    831641            } // endif magic number given
     
    833643
    834644          // packet passed all checks, so this packet is to be processed by this node
    835           if (intercept == 1)
     645          if (intercept)
    836646          {
    837647            // we let the firewall stop it and process it further in userspace
     
    858668            peer_addr->set_ip_ttl(ip_ttl);
    859669           
    860 // XXXMOB: if_index is not helpful, is own_addr meaningful here?
    861 //
    862 //          // register incoming interface of query, this may be carried in the responder cookie later
    863 //          peer_addr->set_if_index(if_nametoindex (m->indev_name));
    864 //
    865 //          DLog(tpparam.name, "[IPv6catcher] - Incoming interface: " << m->indev_name << ", if_index:" << peer_addr->get_if_index());     
     670            // register incoming interface of query, this may be carried in the responder cookie later
     671            // please note that interface index is still too coarse in case of mobility if you have
     672            // different and changing addresses (Care-of addresses) at the same interface
     673            peer_addr->set_if_index(if_nametoindex (m->indev_name));
     674
     675            DLog(tpparam.name, "[IPv6catcher] - Incoming interface: " << m->indev_name << ", if_index:" << peer_addr->get_if_index());     
    866676                 
    867677            // copy payload to netmsg buffer (including magic number)
     
    918728    // get new thread state
    919729    currstate = get_state ();
    920     intercept = 0;
     730    intercept= false;
    921731  } // end while(!terminate)
    922732   
     
    987797
    988798
    989     //if we set this var to "1" the packet will be taken, if we set it to "0", we don't take it
     799    // if we set this var to "1" the packet will be punted, if we set it to "0", we don't punt it
    990800    bool intercept= false;
    991801   
     
    1040850            // We have to check if Option field is present, packets without options will be allowed to pass netfilter
    1041851            // Packets with Options set will be stopped at firewall and the copies processed
    1042            
    1043852            if ((ip->ihl) > 5)
    1044853            {
     
    1096905                  }
    1097906                } // end for
    1098                      
    1099                 // magic number is only checked for if not zero
    1100                 if (tpparam.magic_number != 0)
    1101                 {
    1102                   uint32 *magic_number_field= reinterpret_cast<uint32 *>(m->payload + 4 * (ip->ihl) + udp_header_size);
    1103                   // now check for magic number in UDP payload
    1104                   if (tpparam.magic_number != ntohl(*magic_number_field))
    1105                   { // magic_number does not fit -> do not intercept the packet
    1106                     // we don't care about this packet, let it pass the firewall
    1107                     WLog(tpparam.name, "[IPv4catcher] - magic number mismatch, read: 0x" << hex << ntohl(*magic_number_field) << dec);
    1108                     // do not intercept
    1109                     intercept= false;
    1110                   }
    1111                   else
    1112                     DLog(tpparam.name, "[IPv4catcher] - " << color[green] << "magic number matched" << color[off]);
    1113 
    1114                 } // endif magic number given
    1115      
     907
     908                if (intercept)
     909                  DLog(tpparam.name, "[IPv4catcher] - I am instructed to intercept packages with this RAO (" << (int) rao << ")");
    1116910              } // opt 148
    1117911              else
     
    1127921                     
    1128922              //DLog("[IPv4catcher]" , "Let a Packet pass");
    1129               intercept= false;
     923              if (tpparam.strict_rao)
     924                intercept= false;
     925              else // let the magic number decide
     926              {
     927                DLog(tpparam.name, "[IPv4catcher] - Checking for interception even if no RAO used");
     928                intercept= true;
     929              }
    1130930            }
    1131931
     932            // magic number is only checked for if not zero
     933            if (intercept && tpparam.magic_number != 0)
     934            {
     935              uint32 *magic_number_field= reinterpret_cast<uint32 *>(m->payload + 4 * (ip->ihl) + udp_header_size);
     936              // now check for magic number in UDP payload
     937              if (tpparam.magic_number != ntohl(*magic_number_field))
     938                { // magic_number does not fit -> do not intercept the packet
     939                  // we don't care about this packet, let it pass the firewall
     940                  WLog(tpparam.name, "[IPv4catcher] - magic number mismatch, read: 0x" << hex << ntohl(*magic_number_field) << dec);
     941                  // do not intercept
     942                  intercept= false;
     943                }
     944              else
     945              {
     946                DLog(tpparam.name, "[IPv4catcher] - " << color[green] << "magic number matched" << color[off]);
     947                uint32 *common_header_word2= reinterpret_cast<uint32 *>(m->payload + 4 * (ip->ihl) + udp_header_size + 8);
     948                if ( !tpparam.strict_rao && (ntohl(*common_header_word2) & 0x8000)==0 )
     949                {
     950                  DLog(tpparam.name, "[IPv4catcher] - C-Flag not set - will not intercept");
     951                  intercept= false;
     952                }
     953              }
     954             
     955            } // endif magic number given
     956           
    1132957            // if intercept is still true, we really will intercept it now
    1133958            if (intercept == true)
    1134959            {
    1135               DLog(tpparam.name, "[IPv4catcher] - I am instructed to intercept packages with this RAO");
    1136960
    1137961              status = ipq_set_verdict (h, m->packet_id,
     
    1161985              peer_addr->set_ip_ttl(ip->ttl);
    1162986
    1163 // XXXMOB: if_index is not helpful, is own_addr meaningful here?
    1164 //
    1165 //            // register incoming interface of query, this may be carried in the responder cookie later
    1166 //            peer_addr->set_if_index(if_nametoindex (m->indev_name));
    1167 //           
    1168 //            // fill own addr
    1169 //            DLog(tpparam.name, "[IPv4catcher] - Incoming interface: " << m->indev_name << ", if_index:" << peer_addr->get_if_index());
     987              // register incoming interface of query, this may be carried in the responder cookie later
     988              // please note that interface index is still too coarse in case of mobility if you have
     989              // different and changing addresses (Care-of addresses) at the same interface
     990              peer_addr->set_if_index(if_nametoindex (m->indev_name));
     991             
     992              // fill own addr
     993              DLog(tpparam.name, "[IPv4catcher] - Incoming interface: " << m->indev_name << ", if_index:" << peer_addr->get_if_index());
    1170994             
    1171995              // fill own addr
  • protlib/branches/20081127-merge-mobility-mk3/test/basic.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/branches/20081127-merge-mobility-mk3/test/fqueue.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/branches/20081127-merge-mobility-mk3/test/netmsg.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/branches/20081127-merge-mobility-mk3/test/queue_manager.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/branches/20081127-merge-mobility-mk3/test/test_address.cpp

    • Property svn:keywords set to Id HeadURL Rev
    r3177 r4142  
    22// test_address.cpp - Test the address class.
    33// ----------------------------------------------------------
    4 // $Id: mri_pc.cpp 2862 2008-02-15 23:25:27Z bless $
    5 // $HeadURL: https://svn.ipv6.tm.uka.de/nsis/ntlp/trunk/test/mri_pc.cpp $
     4// $Id$
     5// $HeadURL$
    66// ==========================================================
    77//                     
     
    4040  CPPUNIT_TEST( test_constructors_hostaddress );
    4141  CPPUNIT_TEST( test_copy_operator );
    42   //CPPUNIT_TEST( test_setters );
    43   //CPPUNIT_TEST( test_equals );
    44   //CPPUNIT_TEST( test_basics );
    45   //CPPUNIT_TEST( test_direction );
     42  CPPUNIT_TEST( test_setters );
     43  CPPUNIT_TEST( test_equals );
     44  CPPUNIT_TEST( test_bogus_sources );
    4645  // Add more tests here.
    4746
     47  CPPUNIT_TEST( test_multicast_hostaddress );
    4848  CPPUNIT_TEST_SUITE_END();
    4949
     
    155155          CPPUNIT_ASSERT( source == dest );
    156156
    157           struct in_addr myinaddr= { INADDR_LOOPBACK };
    158           /// set IPv4 from inaddr
     157          struct in_addr myinaddr= { htonl(INADDR_LOOPBACK) };
     158          // set IPv4 from inaddr
    159159          source.set_ip(myinaddr);
    160160          dest.set_ipv4("127.0.0.1");
    161161
     162          CPPUNIT_ASSERT( source.is_ipv4() );
     163          CPPUNIT_ASSERT( dest.is_ipv4() );
     164
    162165          CPPUNIT_ASSERT( source == dest );
    163           const struct in6_addr insixaddr=in6addr_any;
     166
     167          CPPUNIT_ASSERT( source.is_bogus_source() );
     168
     169          const struct in6_addr insixaddr=in6addr_loopback;
    164170          hostaddress v6src(insixaddr);
    165171
    166172          dest.set_ip(insixaddr);
     173
     174          CPPUNIT_ASSERT( dest.is_ipv6() );
    167175          CPPUNIT_ASSERT( dest == v6src);
     176
     177          CPPUNIT_ASSERT( v6src.is_bogus_source() );
    168178                 
    169179        }
    170180
    171 #ifdef GAGA
    172         // Check if the == operator works. Required for test_basics() below.
     181
     182        // Check if the == operator works.
    173183        void test_equals() {
    174                 mri_pathcoupled mri1;
    175                 CPPUNIT_ASSERT( mri1 == mri1 );
    176 
    177                 mri_pathcoupled mri2(
    178                         hostaddress("10.0.0.1"), 32, 1234,
    179                         hostaddress("10.0.0.2"), 32, 5678,
    180                         "tcp", 0, 0, 0, true
    181                 );
    182                 CPPUNIT_ASSERT( mri2 == mri2 );
    183                 CPPUNIT_ASSERT( mri1 != mri2 );
    184 
    185                 // UDP != TCP
    186                 mri_pathcoupled mri3(
    187                         hostaddress("10.0.0.1"), 32, 1234,
    188                         hostaddress("10.0.0.2"), 32, 5678,
    189                         "udp", 0, 0, 0, true
    190                 );
    191                 CPPUNIT_ASSERT( mri3.get_protocol() != mri2.get_protocol() );
    192                 CPPUNIT_ASSERT( mri1 != mri3 );
    193                 CPPUNIT_ASSERT( mri2 != mri3 );
    194         }
    195 
    196         void test_basics() {
    197                 ;
    198                 ASSERT_BASICS_WORK( mri1 ); // should this work?
    199 
    200                 mri_pathcoupled mri2(
    201                         hostaddress("10.0.0.1"), 32, 1234,
    202                         hostaddress("10.0.0.2"), 32, 5678,
    203                         "tcp", 0, 0, 0, true
    204                 );
    205                 ASSERT_BASICS_WORK( mri2 );
    206 
    207                 // UDP != TCP
    208                 mri_pathcoupled mri3(
    209                         hostaddress("10.0.0.1"), 32, 1234,
    210                         hostaddress("10.0.0.2"), 32, 5678,
    211                         "udp", 0, 0, 0, true
    212                 );
    213                 ASSERT_BASICS_WORK( mri3 );
    214 
    215                 // IPv6 addresses and a flow label
    216                 mri_pathcoupled mri4(
    217                         hostaddress("fe80::20e:cff:fe22:57e3"), 32, 1234,
    218                         hostaddress("fe80::20e:cff:fe22:574d"), 32, 5678,
    219                         "tcp", 0xfab, 0, 0, true
    220                 );
    221                 ASSERT_BASICS_WORK( mri4 );
    222 
    223         }
    224 
    225         void test_direction() {
    226                 mri_pathcoupled mri1(
    227                         hostaddress("10.0.0.1"), 32, 1234,      // source
    228                         hostaddress("10.0.0.2"), 32, 5678,      // dest
    229                         "tcp", 0, 0, 0, true                    // downstream
    230                 );
    231 
    232                 appladdress *final_hop1 = mri1.determine_dest_address();
    233                 CPPUNIT_ASSERT( final_hop1 != NULL );
    234                 // Note: Comparison only works this way round because
    235                 //       appladdress is a subclass of hostaddress!
    236                 CPPUNIT_ASSERT( hostaddress("10.0.0.2") == *final_hop1 );
    237 
    238                 mri1.invertDirection();
    239                 appladdress *final_hop2 = mri1.determine_dest_address();
    240                 CPPUNIT_ASSERT( final_hop2 != NULL );
    241                 CPPUNIT_ASSERT( hostaddress("10.0.0.1") == *final_hop2 );
    242 
    243                 delete final_hop1;
    244                 delete final_hop2;
    245         }
    246 #endif
     184          hostaddress sourceipv4("10.0.0.1");
     185          hostaddress destipv4("10.0.0.2");
     186          hostaddress same;
     187         
     188          CPPUNIT_ASSERT( sourceipv4.match_against(sourceipv4) == 32 );
     189          CPPUNIT_ASSERT( sourceipv4.match_against(destipv4) == -1 );
     190
     191          CPPUNIT_ASSERT( sourceipv4 == sourceipv4 );
     192         
     193          same= sourceipv4;
     194          CPPUNIT_ASSERT( sourceipv4 == same );
     195          CPPUNIT_ASSERT( sourceipv4 != destipv4 );
     196         
     197          same= destipv4;
     198          CPPUNIT_ASSERT( destipv4 == same );
     199
     200          hostaddress sourceipv6("fe80::20e:cff:fe22:57e3");
     201          hostaddress destipv6("fe80::20e:bad:c0:ffee");
     202          same= sourceipv6;
     203
     204          CPPUNIT_ASSERT( sourceipv6.match_against(sourceipv6) == 128 );
     205          CPPUNIT_ASSERT( sourceipv6.match_against(destipv6) == -1 );
     206
     207          CPPUNIT_ASSERT( sourceipv6 == same );
     208          CPPUNIT_ASSERT( sourceipv6 != destipv6 );
     209
     210          CPPUNIT_ASSERT( sourceipv4 != sourceipv6 );
     211        }
     212
     213        // test bogus source addresses
     214        void test_bogus_sources() {
     215          struct in_addr myinaddr= { htonl(INADDR_LOOPBACK) };
     216          // set IPv4 from inaddr
     217          hostaddress source;
     218
     219          source.set_ip(myinaddr);
     220          CPPUNIT_ASSERT( source.is_bogus_source() );
     221
     222          myinaddr.s_addr= htonl(INADDR_ANY);
     223          source.set_ip(myinaddr);
     224          CPPUNIT_ASSERT( source.is_bogus_source() );
     225
     226          myinaddr.s_addr= htonl(INADDR_BROADCAST);
     227          source.set_ip(myinaddr);
     228          CPPUNIT_ASSERT( source.is_bogus_source() );
     229         
     230          source.set_ip("224.0.0.1");
     231          source.set_ip(myinaddr);
     232          CPPUNIT_ASSERT( source.is_bogus_source() );
     233
     234          hostaddress v6src("::1");
     235          CPPUNIT_ASSERT( v6src.is_bogus_source() );
     236
     237          v6src.set_ipv6("::");
     238          CPPUNIT_ASSERT( v6src.is_bogus_source() );
     239         
     240        }
     241
     242        void test_multicast_hostaddress() {
     243                hostaddress ta; // testaddress
     244
     245                // Test IPv4 addresses
     246                ta.set_ipv4("127.0.0.1");
     247                CPPUNIT_ASSERT( !ta.is_multicast() );
     248
     249                ta.set_ipv4("224.0.0.0");
     250                CPPUNIT_ASSERT( ta.is_multicast() );
     251
     252                // Test IPv6 addresses
     253                ta.set_ip("2001:638:204:1:230:48ff:fec4:813a");
     254                CPPUNIT_ASSERT( !ta.is_multicast() );
     255                ta.set_ip("FF01:0:0:0:0:0:0:1");
     256                CPPUNIT_ASSERT( ta.is_multicast() );
     257        }
    247258};
    248259
  • protlib/branches/20081127-merge-mobility-mk3/test/test_runner.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/branches/20081127-merge-mobility-mk3/test/test_template.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/branches/20081127-merge-mobility-mk3/test/test_tp_over_xyz.cpp

    r3701 r4142  
    296296
    297297            // invoke send method on TP thread
    298             tpthread.get_thread_object()->send(datamsg, destinationaddr, false);
     298            tpthread.get_thread_object()->send(datamsg, destinationaddr, NULL, false);
    299299
    300300            EVLog(methodname, "message sent");
  • protlib/branches/20081127-merge-mobility-mk3/test/test_types.cpp

    • Property svn:keywords set to Id HeadURL Rev
    r3177 r4142  
    22 * This file is a template which can be copied to create a new test case file.
    33 *
    4  * $Id: test_template.cpp 2262 2006-10-30 11:54:45Z stud-matfried $
    5  * $HeadURL: https://svn.ipv6.tm.uka.de/nsis/protlib/trunk/test/test_template.cpp $
     4 * $Id$
     5 * $HeadURL$
    66 */
    77#include <cppunit/TestCase.h>
  • protlib/branches/20081127-merge-mobility-mk3/test/timer_module.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
Note: See TracChangeset for help on using the changeset viewer.