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

Changeset 4107


Ignore:
Timestamp:
Jul 16, 2009, 3:49:52 PM (8 years ago)
Author:
bless
Message:
Location:
protlib/trunk
Files:
20 edited
10 copied

Legend:

Unmodified
Added
Removed
  • protlib/trunk

  • protlib/trunk/include/address.h

    r4044 r4107  
    3838#include "ie.h"
    3939
     40#include <list>
    4041#include <ext/hash_map>
    4142#include <netinet/in.h>
     
    212213
    213214
     215typedef list<hostaddress> hostaddresslist_t;
     216
    214217/// ========================================================
    215218/// IP Application Address
     
    681684     return out << addr.get_ip_str() << "/" << (int)addr.get_pref_len();
    682685}
     686
     687istream& operator>>(istream& inputstream, list<hostaddress>& halist);
    683688
    684689/// Unix Domain Socket Address
     
    743748/** Get Socket Number */
    744749inline
    745 const int get_socknum() const {
     750int get_socknum() const {
    746751    return socknum;
    747752} // end get_socknum
     
    11111116
    11121117
     1118ostream& operator<<(ostream& outstream, const list<hostaddress>& addresslist);
     1119
    11131120/*
    11141121 * AddressList
     
    13441351} // end get_host_name
    13451352
     1353
     1354istream& operator>>(istream& inputstream, hostaddress& ha);
     1355
     1356
    13461357/***** inherited from hostaddress *****/
    13471358
     
    13851396    return out << "[Unix Domain Socket]: " << addr.get_udssocket();
    13861397}
    1387 
    1388 
    1389 
    1390 
    13911398
    13921399
  • protlib/trunk/include/network_message.h

    r3247 r4107  
    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/trunk/include/protlib_types.h

    r3599 r4107  
    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/trunk/include/tp_queryencap.h

    r3675 r4107  
    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
     
    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);
    182187 
    183188  /// ConnectionMap instance for keeping track of all existing connections
  • protlib/trunk/src/Makefile

    r3675 r4107  
    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)
     
    242242#compile rules
    243243
     244cmsghdr_util.o: cmsghdr_util.cpp cmsghdr_util.h
     245        $(RM) $@
     246        $(CPP) $(PROTLIB_CXXFLAGS) $(CFLAGS) $(CLINK) $@ $(INCLUDE) $<
     247
    244248%.o:            %.cpp
    245249                $(RM) $@
  • protlib/trunk/src/address.cpp

    r4044 r4107  
    8989        if (haddr) {
    9090#ifdef DEBUG_HARD
    91           Log(DEBUG_LOG,LOG_NORMAL,"hostaddress","::operator==()" << haddr->get_ip_str()<<"=="<<this->get_ip_str());
     91          Log(DEBUG_LOG,LOG_NORMAL,"hostaddress","::operator==(), v4=" << haddr->get_ip_str()<<"=="<<this->get_ip_str());
    9292          if (!ipv4flag)
    9393            Log(DEBUG_LOG,LOG_NORMAL,"hostaddress","::operator==(), v6=" << IN6_ARE_ADDR_EQUAL(ipv6addr.s6_addr, haddr->ipv6addr.s6_addr));
     
    132132void hostaddress::set_ip(const struct in_addr &in) {
    133133        clear_ip();
    134         ipv4addr = in; 
     134        ipv4addr.s_addr = in.s_addr;
    135135        // set subtype to IPv4
    136136        set_subtype(true);
     
    253253  { // IPv4
    254254    if ( IN_MULTICAST(ntohl(ipv4addr.s_addr)) ||
    255          ipv4addr.s_addr == INADDR_LOOPBACK  ||
    256          ipv4addr.s_addr == INADDR_ANY ||
    257          ipv4addr.s_addr == INADDR_BROADCAST
     255         ipv4addr.s_addr == htonl(INADDR_LOOPBACK)  ||
     256         ipv4addr.s_addr == htonl(INADDR_ANY) ||
     257         ipv4addr.s_addr == htonl(INADDR_BROADCAST)
    258258       )
    259259    {
     
    263263  else
    264264  { // IPv6
    265     if ( ipv6addr.s6_addr == in6addr_any.s6_addr ||
    266          ipv6addr.s6_addr == in6addr_loopback.s6_addr )
    267       return true;
     265          if ( IN6_ARE_ADDR_EQUAL(ipv6addr.s6_addr,in6addr_any.s6_addr) ||
     266               IN6_ARE_ADDR_EQUAL(ipv6addr.s6_addr,in6addr_loopback.s6_addr) )
     267                  return true;
    268268  }
    269269
     
    340340} // end clear_ip
    341341
     342
     343istream& operator>>(istream& inputstream, hostaddress& ha)
     344{
     345  string inputstr;
     346 
     347  inputstream >> inputstr;
     348 
     349  if (ha.set_ipv6(inputstr.c_str()) == false)
     350  { // conversion to ipv6 address failed, try ipv4 instead
     351    ha.set_ipv4(inputstr.c_str());
     352  }
     353
     354  return inputstream;
     355}
     356
     357
     358istream& operator>>(istream& inputstream, list<hostaddress>& halist)
     359{
     360  while ( inputstream ) {
     361    std::string token;
     362    inputstream >> token;
     363   
     364    bool success;
     365    hostaddress addr(token.c_str(), &success);
     366   
     367    if ( success )
     368      halist.push_back(addr);
     369  }
     370
     371  return inputstream;
     372}
     373
     374
     375ostream& operator<<(ostream& outstream, const list<hostaddress>& addresslist)
     376{
     377  // algo?  foreach...
     378  list<hostaddress>::const_iterator haddr_citer= addresslist.begin();
     379  while ( haddr_citer != addresslist.end() )
     380  {
     381    // write address
     382    outstream << *haddr_citer;
     383    haddr_citer++;
     384    // if not the last element, write separating space
     385    if (haddr_citer != addresslist.end())
     386      outstream << ' ';
     387  }
     388  return outstream;
     389}
    342390
    343391/** Match this IP address against another IP address.
     
    448496                // Otherwise they are not equal.
    449497                if (hostaddress::operator==(ie)) {
    450                     if (proto!=app->proto) cout << "protocols not matching" << endl;
    451                     if (port !=app->port) cout << "ports not matching" << endl;
     498                        //if (proto!=app->proto) cout << "protocols not matching" << endl;
     499                        //if (port !=app->port) cout << "ports not matching" << endl;
    452500
    453501                    return ((proto==app->proto) && (port==app->port));
     
    480528                // Otherwise they are not equal.
    481529                if (hostaddress::operator==(ie)) {
    482                     if (prefix_length!=na->prefix_length) cout << "Prefix length not matching" << endl;
     530                        //if (prefix_length!=na->prefix_length) cout << "Prefix length not matching" << endl;
    483531                    return (prefix_length==na->prefix_length);
    484532                } else return false;
     
    10771125        netaddress na;
    10781126
    1079         // according to IANA Tue Apr 17 09:14:31 PDT 2007
     1127        // according to http://www.cymru.com/Documents/bogon-list.html
     1128        // 4.8 (30 Apr 2009)
    10801129        na.set_ip("0.0.0.0");na.set_pref_len(7);
    10811130        ignore(na);
     
    10841133        na.set_ip("5.0.0.0");na.set_pref_len(8);
    10851134        ignore(na);
    1086         na.set_ip("7.0.0.0");na.set_pref_len(8);
     1135        na.set_ip("10.0.0.0");na.set_pref_len(8);
     1136        ignore(na);
     1137        na.set_ip("14.0.0.0");na.set_pref_len(8);
    10871138        ignore(na);
    10881139        na.set_ip("23.0.0.0");na.set_pref_len(8);
     
    10981149        na.set_ip("42.0.0.0");na.set_pref_len(8);
    10991150        ignore(na);
     1151        na.set_ip("46.0.0.0");na.set_pref_len(8);
     1152        ignore(na);
    11001153        na.set_ip("49.0.0.0");na.set_pref_len(8);
    11011154        ignore(na);
    11021155        na.set_ip("50.0.0.0");na.set_pref_len(8);
    11031156        ignore(na);
    1104         na.set_ip("94.0.0.0");na.set_pref_len(7);
    1105         ignore(na);
    11061157        na.set_ip("100.0.0.0");na.set_pref_len(6);
    11071158        ignore(na);
    11081159        na.set_ip("104.0.0.0");na.set_pref_len(5);
    11091160        ignore(na);
    1110         na.set_ip("112.0.0.0");na.set_pref_len(6);
    1111         ignore(na);
    11121161        na.set_ip("169.254.0.0");na.set_pref_len(16);
    11131162        ignore(na);
    1114         na.set_ip("173.0.0.0");na.set_pref_len(8);
    1115         ignore(na);
    1116         na.set_ip("174.0.0.0");na.set_pref_len(7);
     1163        na.set_ip("175.0.0.0");na.set_pref_len(7);
    11171164        ignore(na);
    11181165        na.set_ip("176.0.0.0");na.set_pref_len(5);
    11191166        ignore(na);
    1120         na.set_ip("184.0.0.0");na.set_pref_len(6);
     1167        na.set_ip("179.0.0.0");na.set_pref_len(5);
     1168        ignore(na);
     1169        na.set_ip("181.0.0.0");na.set_pref_len(6);
     1170        ignore(na);
     1171        na.set_ip("182.0.0.0");na.set_pref_len(6);
     1172        ignore(na);
     1173        na.set_ip("185.0.0.0");na.set_pref_len(6);
    11211174        ignore(na);
    11221175        na.set_ip("191.0.0.0");na.set_pref_len(8);
     
    11321185        na.set_ip("240.0.0.0");na.set_pref_len(4);
    11331186        ignore(na);
    1134         // according to http://www.cymru.com/Documents/bogonv6-list.html#agg
    1135         na.set_ip("0000::");na.set_pref_len(8);
    1136         ignore(na);
    1137         na.set_ip("0100::");na.set_pref_len(8);
    1138         ignore(na);
    1139         na.set_ip("0200::");na.set_pref_len(7);
    1140         ignore(na);
    1141         na.set_ip("0400::");na.set_pref_len(7);
    1142         ignore(na);
    1143         na.set_ip("0600::");na.set_pref_len(7);
    1144         ignore(na);
    1145         na.set_ip("0800::");na.set_pref_len(5);
    1146         ignore(na);
    1147         na.set_ip("1000::");na.set_pref_len(4);
     1187        // according to http://www.cymru.com/Bogons/v6bogon.html (2008-05-20)
     1188        na.set_ip("2001:db8::");na.set_pref_len(32);
     1189        ignore(na);
     1190        na.set_ip("0000::");na.set_pref_len(3);
    11481191        ignore(na);
    11491192        na.set_ip("2000::");na.set_pref_len(16);
    11501193        ignore(na);
     1194        na.set_ip("2001:1::");na.set_pref_len(32);
     1195        ignore(na);
     1196        na.set_ip("2001:2::");na.set_pref_len(31);
     1197        ignore(na);
     1198        na.set_ip("2001:4::");na.set_pref_len(30);
     1199        ignore(na);
     1200        na.set_ip("2001:8::");na.set_pref_len(29);
     1201        ignore(na);
     1202        na.set_ip("2001:10::");na.set_pref_len(28);
     1203        ignore(na);
     1204        na.set_ip("2001:20::");na.set_pref_len(27);
     1205        ignore(na);
     1206        na.set_ip("2001:40::");na.set_pref_len(26);
     1207        ignore(na);
     1208        na.set_ip("2001:80::");na.set_pref_len(25);
     1209        ignore(na);
     1210        na.set_ip("2001:100::");na.set_pref_len(24);
     1211        ignore(na);
    11511212        na.set_ip("2001:1000::");na.set_pref_len(23);
    11521213        ignore(na);
    1153         na.set_ip("2001:1600::");na.set_pref_len(23);
    1154         ignore(na);
    1155         na.set_ip("2001:2000::");na.set_pref_len(20);
    1156         ignore(na);
    1157         na.set_ip("2001:3000::");na.set_pref_len(20);
    1158         ignore(na);
    1159         na.set_ip("2001:4000::");na.set_pref_len(20);
    1160         ignore(na);
    1161         na.set_ip("2001:5000::");na.set_pref_len(20);
    1162         ignore(na);
    1163         na.set_ip("2001:6000::");na.set_pref_len(20);
    1164         ignore(na);
    1165         na.set_ip("2001:7000::");na.set_pref_len(20);
    1166         ignore(na);
    1167         na.set_ip("2001:8000::");na.set_pref_len(20);
    1168         ignore(na);
    1169         na.set_ip("2001:9000::");na.set_pref_len(20);
    1170         ignore(na);
    1171         na.set_ip("2001:A000::");na.set_pref_len(20);
    1172         ignore(na);
    1173         na.set_ip("2001:B000::");na.set_pref_len(20);
    1174         ignore(na);
    1175         na.set_ip("2001:C000::");na.set_pref_len(20);
    1176         ignore(na);
    1177         na.set_ip("2001:D000::");na.set_pref_len(20);
    1178         ignore(na);
    1179         na.set_ip("2001:E000::");na.set_pref_len(20);
    1180         ignore(na);
    1181         na.set_ip("2001:F000::");na.set_pref_len(20);
    1182         ignore(na);
    1183         na.set_ip("3FFF::");na.set_pref_len(16);
    1184         ignore(na);
    1185         na.set_ip("4000::");na.set_pref_len(3);
    1186         ignore(na);
    1187         na.set_ip("6000::");na.set_pref_len(3);
    1188         ignore(na);
    1189         na.set_ip("8000::");na.set_pref_len(3);
    1190         ignore(na);
    1191         na.set_ip("A000::");na.set_pref_len(3);
    1192         ignore(na);
    1193         na.set_ip("C000::");na.set_pref_len(3);
    1194         ignore(na);
    1195         na.set_ip("E000::");na.set_pref_len(4);
     1214        na.set_ip("2001:4e00::");na.set_pref_len(23);
     1215        ignore(na);
     1216        na.set_ip("2001:6000::");na.set_pref_len(19);
     1217        ignore(na);
     1218        na.set_ip("2001:c000::");na.set_pref_len(18);
     1219        ignore(na);
     1220        na.set_ip("2003:4000::");na.set_pref_len(18);
     1221        ignore(na);
     1222        na.set_ip("2003:8000::");na.set_pref_len(17);
     1223        ignore(na);
     1224        na.set_ip("2004::");na.set_pref_len(14);
     1225        ignore(na);
     1226        na.set_ip("2008::");na.set_pref_len(13);
     1227        ignore(na);
     1228        na.set_ip("2010::");na.set_pref_len(12);
     1229        ignore(na);
     1230        na.set_ip("2020::");na.set_pref_len(11);
     1231        ignore(na);
     1232        na.set_ip("2040::");na.set_pref_len(10);
     1233        ignore(na);
     1234        na.set_ip("2080::");na.set_pref_len(9);
     1235        ignore(na);
     1236        na.set_ip("2100::");na.set_pref_len(8);
     1237        ignore(na);
     1238        na.set_ip("2200::");na.set_pref_len(7);
     1239        ignore(na);
     1240        na.set_ip("2410::");na.set_pref_len(12);
     1241        ignore(na);
     1242        na.set_ip("2420::");na.set_pref_len(11);
     1243        ignore(na);
     1244        na.set_ip("2440::");na.set_pref_len(10);
     1245        ignore(na);
     1246        na.set_ip("2480::");na.set_pref_len(9);
     1247        ignore(na);
     1248        na.set_ip("2500::");na.set_pref_len(8);
     1249        ignore(na);
     1250        na.set_ip("2610:200::");na.set_pref_len(23);
     1251        ignore(na);
     1252        na.set_ip("2610:400::");na.set_pref_len(22);
     1253        ignore(na);
     1254        na.set_ip("2610:800::");na.set_pref_len(21);
     1255        ignore(na);
     1256        na.set_ip("2610:1000::");na.set_pref_len(20);
     1257        ignore(na);
     1258        na.set_ip("2610:2000::");na.set_pref_len(19);
     1259        ignore(na);
     1260        na.set_ip("2610:4000::");na.set_pref_len(18);
     1261        ignore(na);
     1262        na.set_ip("2610:8000::");na.set_pref_len(17);
     1263        ignore(na);
     1264        na.set_ip("2611::");na.set_pref_len(16);
     1265        ignore(na);
     1266        na.set_ip("2612::");na.set_pref_len(15);
     1267        ignore(na);
     1268        na.set_ip("2614::");na.set_pref_len(14);
     1269        ignore(na);
     1270        na.set_ip("2618::");na.set_pref_len(13);
     1271        ignore(na);
     1272        na.set_ip("2620:200::");na.set_pref_len(23);
     1273        ignore(na);
     1274        na.set_ip("2620:400::");na.set_pref_len(22);
     1275        ignore(na);
     1276        na.set_ip("2620:800::");na.set_pref_len(21);
     1277        ignore(na);
     1278        na.set_ip("2620:1000::");na.set_pref_len(20);
     1279        ignore(na);
     1280        na.set_ip("2620:2000::");na.set_pref_len(19);
     1281        ignore(na);
     1282        na.set_ip("2620:4000::");na.set_pref_len(18);
     1283        ignore(na);
     1284        na.set_ip("2620:8000::");na.set_pref_len(17);
     1285        ignore(na);
     1286        na.set_ip("2621::");na.set_pref_len(16);
     1287        ignore(na);
     1288        na.set_ip("2622::");na.set_pref_len(15);
     1289        ignore(na);
     1290        na.set_ip("2624::");na.set_pref_len(14);
     1291        ignore(na);
     1292        na.set_ip("2628::");na.set_pref_len(13);
     1293        ignore(na);
     1294        na.set_ip("2630::");na.set_pref_len(12);
     1295        ignore(na);
     1296        na.set_ip("2640::");na.set_pref_len(10);
     1297        ignore(na);
     1298        na.set_ip("2680::");na.set_pref_len(9);
     1299        ignore(na);
     1300        na.set_ip("2700::");na.set_pref_len(8);
     1301        ignore(na);
     1302        na.set_ip("2810::");na.set_pref_len(12);
     1303        ignore(na);
     1304        na.set_ip("2820::");na.set_pref_len(11);
     1305        ignore(na);
     1306        na.set_ip("2840::");na.set_pref_len(10);
     1307        ignore(na);
     1308        na.set_ip("2880::");na.set_pref_len(9);
     1309        ignore(na);
     1310        na.set_ip("2900::");na.set_pref_len(8);
     1311        ignore(na);
     1312        na.set_ip("2a10::");na.set_pref_len(8);
     1313        ignore(na);
     1314        na.set_ip("2a20::");na.set_pref_len(8);
     1315        ignore(na);
     1316        na.set_ip("2a40::");na.set_pref_len(8);
     1317        ignore(na);
     1318        na.set_ip("2a80::");na.set_pref_len(8);
     1319        ignore(na);
     1320        na.set_ip("2b00::");na.set_pref_len(8);
     1321        ignore(na);
     1322        na.set_ip("2c10::");na.set_pref_len(12);
     1323        ignore(na);
     1324        na.set_ip("2c20::");na.set_pref_len(11);
     1325        ignore(na);
     1326        na.set_ip("2c40::");na.set_pref_len(10);
     1327        ignore(na);
     1328        na.set_ip("2c80::");na.set_pref_len(9);
     1329        ignore(na);
     1330        na.set_ip("2d00::");na.set_pref_len(8);
     1331        ignore(na);
     1332        na.set_ip("2e00::");na.set_pref_len(7);
     1333        ignore(na);
     1334        na.set_ip("3000::");na.set_pref_len(4);
     1335        ignore(na);
     1336        na.set_ip("4000::");na.set_pref_len(2);
     1337        ignore(na);
     1338        na.set_ip("8000::");na.set_pref_len(1);
    11961339        ignore(na);
    11971340        na.set_ip("F000::");na.set_pref_len(5);
  • protlib/trunk/src/network_message.cpp

    r3519 r4107  
    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/trunk/src/tp_over_tcp.cpp

    r3675 r4107  
    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/trunk/src/tp_over_udp.cpp

    r3675 r4107  
    5555#include "setuid.h"
    5656#include "logfile.h"
     57#include "cmsghdr_util.h"
    5758#include "linux/netfilter.h"
    5859
     
    144145  struct msghdr header;
    145146
    146   // pointer for ancillary data
    147   struct cmsghdr *ancillary = NULL;
    148          
    149147  // iovec for sendmsg
    150148  struct iovec iov;
     
    160158  dest_address.sin6_scope_id = 0;
    161159
     160  // control options for sendmsg
     161  int hop_limit = ( addr->get_ip_ttl() ? addr->get_ip_ttl() : -1 );
     162  if ( hop_limit != -1 )
     163    DLog(tpparam.name, "Setting IP hop limit to " << hop_limit);
     164
     165  int rao = ( addr->rao_present() ? addr->get_rao() : -1 );
     166  if ( rao != -1 )
     167    DLog(tpparam.name, "Setting IP RAO to " << rao);
     168
     169  uint16_t oif = addr->get_if_index();
     170  if ( oif != 0 )
     171    DLog(tpparam.name, "Setting outgoing interface index to " << oif);
     172
    162173  // fill msghdr
    163174  header.msg_iov = &iov;
     
    168179  header.msg_controllen=0;
    169180
    170 
    171   // pktinfo
    172   in6_pktinfo pktinfo;
    173 
    174   //addr->set_if_index(1);
    175 
    176 
    177   // we have to add up to 2 ancillary data objects (for interface and hop limit)
    178 
    179   uint32 buflength = 0;
    180   if (addr->get_if_index()) {
    181     buflength = CMSG_SPACE(sizeof(pktinfo));
    182     //cout << "PKTINFO data object, total buffer size: " << buflength << "byte" << endl;
    183   }
    184 
    185   int hlim = addr->get_ip_ttl();
    186 
    187   if (hlim) {
    188     buflength = buflength + CMSG_SPACE(sizeof(int));
    189     //cout << "HOPLIMIT data object, total buffer size: " << buflength << "byte" << endl;
    190   }
    191   // create the buffer
    192   if ((addr->get_if_index()) || hlim) {
    193     header.msg_control = malloc(buflength);
    194     if (header.msg_control == 0)
    195       ERRCLog(tpparam.name, thisproc << " malloc failed for ancillary data of size " << buflength);
    196   }
    197 
    198   // are we to set the outgoing interface?
    199   if (addr->get_if_index()) {
    200 
    201     DLog(tpparam.name, thisproc << " UDP send via Interface " << addr->get_if_index() << " requested.");
    202 
    203     // first cmsghdr at beginning of buffer
    204     ancillary = (cmsghdr*) header.msg_control;
    205          
    206     ancillary->cmsg_level=IPPROTO_IPV6;
    207     ancillary->cmsg_type=IPV6_PKTINFO;
    208     ancillary->cmsg_len=CMSG_LEN(sizeof(pktinfo));
    209          
    210     //cout << "Set up properties of ancillary data object 1" << endl;
    211 
    212     pktinfo.ipi6_addr = in6addr_any;
    213     pktinfo.ipi6_ifindex = addr->get_if_index();
    214 
    215     memcpy (CMSG_DATA(ancillary), &pktinfo, sizeof(pktinfo));
    216  
    217     //cout << "Set up data of ancillary data object 1" << endl;
    218 
    219     // update msghdr controllen
    220     header.msg_controllen = CMSG_SPACE(sizeof(pktinfo));
    221          
    222   }
    223 
    224   // should we set an explicit Hop Limit?
    225   if (hlim) {
    226     DLog(tpparam.name, thisproc << " UDP send with IP TTL of " << hlim << " requested.");
    227 
    228     // second cmsghdr after first one
    229     cmsghdr* ancillary2 = NULL;
    230 
    231     if (ancillary) {
    232       ancillary2 = (cmsghdr*) (ancillary + CMSG_SPACE(sizeof(pktinfo)));
    233     } else {
    234       ancillary2 = (cmsghdr*) header.msg_control;
    235     }
    236 
    237     ancillary2->cmsg_level=IPPROTO_IPV6;
    238     ancillary2->cmsg_type=IPV6_HOPLIMIT;
    239     ancillary2->cmsg_len = CMSG_LEN(sizeof(int));
    240 
    241     memcpy(CMSG_DATA(ancillary2), &hlim, sizeof(int));
    242  
    243     // update msghdr controllen
    244     header.msg_controllen = header.msg_controllen + ancillary2->cmsg_len;
    245 
    246   }
     181  // fill msghdr.msg_control
     182  util::set_ancillary_data(&header, rao, oif, hop_limit);
    247183
    248184#ifndef _NO_LOGGING
     
    269205  DLog(tpparam.name, "SEND to " << *addr);
    270206  ret= sendmsg(master_listener_socket,&header,MSG_DONTWAIT); 
     207
     208  // free ancilliary data allocated by protlib::util::set_ancillary_data()
     209  free(header.msg_control);
     210  header.msg_control = NULL; // ... just in case
    271211
    272212  if (ret<0)
  • protlib/trunk/src/tp_queryencap.cpp

    r3675 r4107  
    5858#include "queuemanager.h"
    5959#include "logfile.h"
     60#include "cmsghdr_util.h"
    6061#include "linux/netfilter.h"
    6162
     
    181182         * This setting works with kernel 2.6.15.
    182183         */
    183         if ( rao != -1 ) {
     184        if ( hop_limit != -1 ) {
    184185                int ret = setsockopt(sockfd, SOL_IPV6, IPV6_UNICAST_HOPS,
    185186                                        &hop_limit, sizeof hop_limit);
     
    187188                        ERRLog(tpparam.name, "setting IPv6 hop limit failed");
    188189        }
    189 }
    190 
    191 
    192 
    193 /*
    194  * Definitions for the IPv6 Router Alert Option, see RFC-2711.
    195  */
    196 static const uint8_t IP6_RAO_OPT_TYPE           = 0x05; // hop-by-hop opt. type
    197 static const uint8_t IP6_RAO_OPT_LEN            = 2;
    198 static const uint8_t IP6_RAO_OPT_ALIGN          = 2;    // 2n + 0 alignment
    199 
    200 #ifdef HAS_RFC2292
    201 static const uint8_t IP6_RAO_OPT_MULTX          = 2;    // 2n + 0 alignment
    202 static const uint8_t IP6_RAO_OPT_OFFSETY        = 0;
    203 #endif
    204 
    205 struct ip6_rao_opt {
    206         uint8_t         ip6_rao_opt_type;
    207         uint8_t         ip6_rao_opt_len;
    208         uint16_t        ip6_rao_opt_val;
    209 };
    210 
    211 
    212 /**
    213  * Activate the router alert option in the given msghdr structure.
    214  *
    215  * This sets the msg_control and msg_controllen fields of the msghdr structure.
    216  * Note that the msg_control member points to allocated memory which you have
    217  * to free yourself.
    218  *
    219  * @param msg the msghdr structure for sendmsg(2)
    220  * @param rao the RAO in host byte order (a 16 bit value, or -1)
    221  */
    222 void
    223 TPqueryEncap::set_ancillary_data(struct msghdr *msg, int rao) {
    224   const char *const methodname= "TPqueryEncap::set_ancillary_data()";
    225 
    226   struct cmsghdr *cmsgptr= NULL;
    227 
    228 #ifdef HAS_RFC2292
    229         struct ip6_rao_opt opt_rao;
    230 #else
    231         int currentlen;
    232         socklen_t extlen;
    233         uint16_t val;
    234         void *databuf, *extbuf;
    235 #endif
    236 
    237         assert( msg->msg_control == NULL );
    238         assert( msg->msg_controllen == 0 );
    239 
    240         if (rao == -1)
    241                 return;
    242 
    243 #ifdef HAS_RFC2292
    244         /* We have to free this later! */
    245         msg->msg_control = malloc( inet6_option_space(sizeof opt_rao) );
    246         assert( msg->msg_control != NULL );
    247 
    248         inet6_option_init(msg->msg_control, &cmsgptr, IPV6_HOPOPTS);
    249 
    250         opt_rao.ip6_rao_opt_type = IP6_RAO_OPT_TYPE;
    251         opt_rao.ip6_rao_opt_len = IP6_RAO_OPT_LEN;
    252         opt_rao.ip6_rao_opt_val = htons(rao);
    253 
    254         inet6_option_append(cmsgptr, &opt_rao.ip6_rao_opt_type,
    255                                 IP6_RAO_OPT_MULTX, IP6_RAO_OPT_OFFSETY);
    256 
    257         msg->msg_controllen = cmsgptr->cmsg_len;
    258 #else
    259 
    260         /* Quote from RFC 3542:
    261          * All the Hop-by-Hop options must be specified by a single ancillary
    262          * data object.  The cmsg_level member is set to IPPROTO_IPV6 and the
    263          * cmsg_type member is set to IPV6_HOPOPTS.  The option is normally
    264          * constructed using the inet6_opt_init(), inet6_opt_append(),
    265          * inet6_opt_finish(), and inet6_opt_set_val() functions, described in
    266          * Section 10.
    267          */
    268 
    269 
    270         // Calculate the required memory space first
    271         currentlen = inet6_opt_init(NULL, 0);
    272         if (currentlen == -1)
    273         {
    274           ERRCLog(methodname, "Failure while calculating Hop-by-Hop Router Alert Option, inet6_opt_init()");
    275           return;
    276         }
    277         // RFC 2711:
    278         //    The router alert option has the following format:
    279         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    280         // |0 0 0|0 0 1 0 1|0 0 0 0 0 0 1 0|        Value (2 octets)       |
    281         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    282         //                  length = 2
    283         //
    284         // Alignment requirement: 2n+0
    285         //
    286         // Hbh-Extension Header for Router Alert should look like this:
    287         //
    288         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    289         // |Next Header=UDP| Hdr Ext Len=0 | Option Type=5 |Opt Data Len=2 |
    290         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    291         // |        Value (2 octets)       | Option Type=1 |Opt Data Len=0 | (PadN, 2 bytes)
    292         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    293         // in Hex: 0x11 00 05 02 XX XX 01 00 (if next header is UDP)
    294         //
    295         // or like this:
    296         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    297         // |Next Header=UDP| Hdr Ext Len=0 | Option Type=1 |Opt Data Len=0 | (PadN, 2 bytes)
    298         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    299         // | Option Type=1 |Opt Data Len=0 |      Value (2 octets)         |
    300         // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
    301         // in Hex: 0x11 00 01 00 05 02 XX XX (if next header is UDP)
    302 
    303         currentlen = inet6_opt_append(NULL, 0, currentlen,
    304                                       IP6_RAO_OPT_TYPE,
    305                                       IP6_RAO_OPT_LEN,
    306                                       IP6_RAO_OPT_ALIGN, NULL);
    307         if (currentlen == -1)
    308         {
    309           ERRCLog(methodname, "Failure while calculating Hop-by-Hop Router Alert Option, does not fit into extension header");
    310           return;
    311         }
    312         currentlen = inet6_opt_finish(NULL, 0, currentlen);
    313         if (currentlen == -1)
    314         {
    315           ERRCLog(methodname, "Failure while calculating Hop-by-Hop Router Alert Option, inet6_opt_finish()");
    316           return;
    317         }
    318 
    319         // now allocate the csmg stuff
    320         // extlen is the length of the header extension in bytes
    321         extlen = currentlen;
    322         // allocate space for the ancillary data structure
    323         int cmsgspace= CMSG_SPACE(extlen);
    324         cmsgptr= static_cast<cmsghdr*>( malloc(cmsgspace) );
    325         memset(cmsgptr, 0, cmsgspace);
    326 
    327         assert(cmsgptr != NULL);
    328 
    329         cmsgptr->cmsg_level = IPPROTO_IPV6;
    330         cmsgptr->cmsg_type = IPV6_HOPOPTS;
    331         cmsgptr->cmsg_len = CMSG_LEN(extlen);
    332         extbuf = CMSG_DATA(cmsgptr);
    333 
    334         assert(extbuf != NULL);
    335 
    336         //DLog(methodname, "Hop-by-Hop Router Alert Option, BufferSize: " << extlen);
    337 
    338         // Quoting RFC 2460:
    339         // Hdr Ext Len          8-bit unsigned integer.  Length of the Hop-by-
    340         //                      Hop Options header in 8-octet units, not
    341         //                      including the first 8 octets.
    342 
    343         currentlen = inet6_opt_init(extbuf, extlen);
    344         if (currentlen == -1) {
    345           ERRCLog(methodname, "Failure while setting Hop-by-Hop Router Alert Option, inet6_opt_init()");
    346           free(extbuf);
    347           return;
    348         }
    349         // inet6_opt_init initializes the value wrongly (glibc2.6.1):
    350         // it divides extlen by 8, but passsing an extlen of 0 is not possible
    351         // so we must fix the setting now
    352         struct ip6_hbh *extp = reinterpret_cast<struct ip6_hbh *>(extbuf);
    353         // inet6_opt_init did already some sanity checks (extlen is multiple of 8)
    354         extp->ip6h_len= (extlen / 8) - 1; // should be zero then, indicating a length of 8 bytes
    355 
    356         currentlen = inet6_opt_append(extbuf, extlen, currentlen,
    357             IP6_RAO_OPT_TYPE, IP6_RAO_OPT_LEN, IP6_RAO_OPT_ALIGN,
    358             &databuf);
    359         if (currentlen == -1) {
    360           ERRCLog(methodname, "Failure while setting Hop-by-Hop Router Alert Option, does not fit into extension header");
    361           free(extbuf);
    362           return;
    363         }
    364 
    365         val = htons(rao);
    366         (void)inet6_opt_set_val(databuf, 0, &val, sizeof(val));
    367 
    368         currentlen = inet6_opt_finish(extbuf, extlen, currentlen);
    369         if (currentlen == -1) {
    370           ERRCLog(methodname, "Failure while setting Hop-by-Hop Router Alert Option, inet6_opt_finish()");
    371           free(extbuf);
    372           return;
    373         }
    374        
    375         msg->msg_control = cmsgptr;
    376         msg->msg_controllen = cmsgspace;
    377 #endif
    378 
    379         NetMsg tmpmsg( (uchar*) msg->msg_control, (uint32) msg->msg_controllen, true );
    380 
    381         //ostringstream out;
    382         //tmpmsg.hexdump(out);
    383         //DLog(methodname, "Hop-by-Hop Router Alert Option, Cmsg Space:" << msg->msg_controllen << " cmsglen:" << cmsgptr->cmsg_len << " Buffer Contents: " << out.str());
    384 
    385190}
    386191
     
    417222    DLog(tpparam.name, "Setting IP RAO to " << rao);
    418223
     224  uint16_t oif = addr->get_if_index();
     225  if ( oif != 0 )
     226    DLog(tpparam.name, "Setting outgoing interface index to " << oif);
     227
    419228  try {
    420229    check_send_args(*netmsg, *addr);
     
    474283
    475284  // this sets msg.msg_control and msg.msg_controllen
    476   set_ancillary_data(&msg, rao);
     285  util::set_ancillary_data(&msg, rao, oif, hop_limit);
    477286
    478287  /*
     
    480289   * so we can finally send the message.
    481290   */
    482 
    483   // TODO: Setting the outgoing interface is currently unimplemented,
    484   //       but I don't think it worked with r1816 or earlier.
    485 
    486291
    487292  // return code will be checked below
     
    639444
    640445  // if we set this var to "1" the packet will be taken, if we set it to "0", we don't take it
    641   int intercept=0;
     446  bool intercept= false;
    642447
    643448  TPMsg *tpmsg = 0;
     
    676481          ipq_packet_msg_t *m = ipq_get_packet (buf);
    677482          struct ip6_hdr *ip = (struct ip6_hdr *) m->payload;
    678 
     483          uint8 next_header= ip->ip6_nxt;
    679484          uint8 ip_ttl = ip->ip6_hlim;
     485          const uint8 ip6_headerlen= 40;
    680486
    681487          // this is the IPv6 capturer, we have got a handle to the IPv6 Queue, so we can be sure to receive only IPv6 packets
     
    683489          // We have to check, if Hop-By-Hop Option Header is present. If it is, it is the first extension header
    684490          // with code "0" in ip6_next of base header
    685           if (ip->ip6_nxt == 0) intercept= 1;
     491          if (next_header == 0) intercept= true;
    686492             
    687493          // 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
    688           if (intercept == 1)
     494          if (intercept)
    689495          {
    690             struct ip6_hbh *optheader = (struct ip6_hbh *) (m->payload + 40);
    691             Log (DEBUG_LOG, LOG_NORMAL, tpparam.name, "[IPv6catcher] - IPv6 Packet with HbH-option header received, inspecting it");
    692             intercept=0;
     496            struct ip6_hbh *optheader = (struct ip6_hbh *) (m->payload + ip6_headerlen);
     497            DLog(tpparam.name, "[IPv6catcher] - IPv6 Packet with HbH-option header received, inspecting it");
     498            intercept= false;
    693499             
    694500            int i = 0;
    695             option = (ip_opt *) (m->payload +42);
     501            option = (ip_opt *) (m->payload + ip6_headerlen + 2);
    696502           
    697503            if (option->opt1 == IP6_RAO_OPT_TYPE) {
    698               intercept = 1;
     504              intercept = true;
    699505            }
    700506            else
     
    706512                {
    707513                  i++;
    708                   option = (ip_opt *) (m->payload +42 +i);
     514                  option = (ip_opt *) (m->payload + ip6_headerlen + 2 +i);
    709515                }
    710516                // No PADDING! We have hit an option and its not Router alert! We must move "LENGTH+2" right!
    711517                if ((option->opt1 != 0)&(option->opt1 != IP6_RAO_OPT_TYPE)) i = option->opt2+2;
    712                 option = (ip_opt *) (m->payload + 42 + i);
     518                option = (ip_opt *) (m->payload + ip6_headerlen + 2 + i);
    713519                // We have hit Router Alert! Break loop, leave it alone!
    714                 if (option->opt1 == IP6_RAO_OPT_TYPE) { intercept=1; break; }
     520                if (option->opt1 == IP6_RAO_OPT_TYPE) { intercept= true; break; }
    715521              }
    716522              while (i <= optheader->ip6h_len); // don't overrun end of ip hop-by-hop options header!
     
    727533            }
    728534               
    729             Log (DEBUG_LOG, LOG_NORMAL, tpparam.name, "[IPv6catcher] - Listening for RAOs: " << os.str().c_str());
    730             Log (DEBUG_LOG, LOG_NORMAL, tpparam.name, "[IPv6catcher] - Inspecting RAO value of: " << ntohs(option->opt3));
    731 
    732             intercept = 0;
     535            DLog(tpparam.name, "[IPv6catcher] - Listening for RAOs: " << os.str().c_str());
     536            DLog(tpparam.name, "[IPv6catcher] - Inspecting RAO value of: " << ntohs(option->opt3));
     537
     538            intercept = false;
    733539            // inspect RAO vector
    734540            for (unsigned int i = 0; i < tpparam.raovec.size(); i++) {
    735               if (tpparam.raovec[i] == ntohs(option->opt3)) intercept = 1;
    736             }
    737           }
    738 
    739           // if intercept is 0, RAO value did not match
    740           if (intercept == 0)
     541              if (tpparam.raovec[i] == ntohs(option->opt3)) intercept= true;
     542            } // end for
     543          } // end if intercept
     544
     545          // if intercept is false, RAO value did not match, stop here if strict RAO matching is required
     546          if (intercept == false && tpparam.strict_rao)
    741547          {
    742548            // we don't care about this packet, let it pass the firewall
     
    746552            //Log (DEBUG_LOG, LOG_NORMAL, tpparam.name, "[IPv6catcher] - I let a packet without RAO set pass");
    747553          }
    748 
    749           int offset = 40; // will point to IP payload, initially size of IPv6 header
    750           // one RAO value matched, now check for magic number
    751           if (intercept == 1)
     554          else
    752555          {
    753             // so far the RAO instructs us to intercept this packet, but we still have to check for the magic number
    754             Log (DEBUG_LOG, LOG_NORMAL, tpparam.name, "[IPv6catcher] - I am instructed to intercept this RAO");
    755            
     556            if (intercept)
     557            {
     558              // so far the RAO instructs us to intercept this packet, but we still have to check for the magic number
     559              DLog(tpparam.name, "[IPv6catcher] - I am instructed to intercept this RAO");
     560            }
     561            else
     562            {
     563              DLog(tpparam.name, "[IPv6catcher] - Checking for interception even if no RAO used");
     564              intercept= true;
     565            }
     566          }
     567
     568          int offset = ip6_headerlen; // will point to IP payload, initially size of IPv6 header
     569
     570          // one RAO value matched (or we do not require strict RAO checking), now check for magic number
     571          if (intercept)
     572          {         
    756573            peer_addr = new appladdress();
    757574            own_addr = new appladdress();
    758575                         
    759576            // Now to do: iterate over extension headers to find the start of the UDP header
    760 
    761             // the first extension header is the hop-by-hop options header and it IS present
     577            // the first extension header is the hop-by-hop options header and it is present
     578            // if RAO was used
    762579            struct ip6_ext *extheader = (struct ip6_ext *) (m->payload + offset);
    763580                 
    764581            // if the 2nd extension header is upper layer header, we found the UDP offset
    765             if (extheader->ip6e_nxt == IPPROTO_UDP)
     582            if (next_header == IPPROTO_UDP)
    766583            {
    767584              DLog(tpparam.name, "[IPv6catcher] - Instantly found UDP header, do not loop over headers");
    768585            }
    769             else 
     586            else
    770587            {
     588              // assume that some extension header is present
     589              next_header= extheader->ip6e_nxt;
    771590              // iterate if next header is not UDP
    772               while (extheader->ip6e_nxt != IPPROTO_UDP)
     591              while (next_header != IPPROTO_UDP)
    773592              {
    774593                // advance to next extension header
     
    782601                }
    783602                extheader = (struct ip6_ext *) (m->payload + offset);
     603                next_header= extheader->ip6e_nxt;
    784604              } // end while
     605              // set offset to next header following the last extension header that we saw
     606              offset = offset + 8 + (extheader->ip6e_len * 8);
    785607            }
    786608            // set offset to next header following the last extension header that we saw
     
    801623                  die (h);
    802624                // stop interception
    803                 intercept= 0;
     625                intercept= false;
    804626              }
    805627              else
     628              {
    806629                DLog(tpparam.name, "[IPv6catcher] - " << color[green] << "magic number matched" << color[off]);
     630                uint32 *common_header_word2= reinterpret_cast<uint32 *>(m->payload + offset + udp_header_size + 8);
     631                if ( !tpparam.strict_rao && (ntohl(*common_header_word2) & 0x8000)==0 )
     632                {
     633                  DLog(tpparam.name, "[IPv6catcher] - C-Flag not set - will not intercept");
     634                  intercept= false;
     635                }
     636              }
    807637
    808638            } // endif magic number given
     
    810640
    811641          // packet passed all checks, so this packet is to be processed by this node
    812           if (intercept == 1)
     642          if (intercept)
    813643          {
    814644            // we let the firewall stop it and process it further in userspace
     
    893723    // get new thread state
    894724    currstate = get_state ();
    895     intercept = 0;
     725    intercept= false;
    896726  } // end while(!terminate)
    897727   
     
    962792
    963793
    964     //if we set this var to "1" the packet will be taken, if we set it to "0", we don't take it
     794    // if we set this var to "1" the packet will be punted, if we set it to "0", we don't punt it
    965795    bool intercept= false;
    966796   
     
    1015845            // We have to check if Option field is present, packets without options will be allowed to pass netfilter
    1016846            // Packets with Options set will be stopped at firewall and the copies processed
    1017            
    1018847            if ((ip->ihl) > 5)
    1019848            {
     
    1071900                  }
    1072901                } // end for
    1073                      
    1074                 // magic number is only checked for if not zero
    1075                 if (tpparam.magic_number != 0)
    1076                 {
    1077                   uint32 *magic_number_field= reinterpret_cast<uint32 *>(m->payload + 4 * (ip->ihl) + udp_header_size);
    1078                   // now check for magic number in UDP payload
    1079                   if (tpparam.magic_number != ntohl(*magic_number_field))
    1080                   { // magic_number does not fit -> do not intercept the packet
    1081                     // we don't care about this packet, let it pass the firewall
    1082                     WLog(tpparam.name, "[IPv4catcher] - magic number mismatch, read: 0x" << hex << ntohl(*magic_number_field) << dec);
    1083                     // do not intercept
    1084                     intercept= false;
    1085                   }
    1086                   else
    1087                     DLog(tpparam.name, "[IPv4catcher] - " << color[green] << "magic number matched" << color[off]);
    1088 
    1089                 } // endif magic number given
    1090      
     902
     903                if (intercept)
     904                  DLog(tpparam.name, "[IPv4catcher] - I am instructed to intercept packages with this RAO (" << (int) rao << ")");
    1091905              } // opt 148
    1092906              else
     
    1102916                     
    1103917              //DLog("[IPv4catcher]" , "Let a Packet pass");
    1104               intercept= false;
     918              if (tpparam.strict_rao)
     919                intercept= false;
     920              else // let the magic number decide
     921              {
     922                DLog(tpparam.name, "[IPv4catcher] - Checking for interception even if no RAO used");
     923                intercept= true;
     924              }
    1105925            }
    1106926
     927            // magic number is only checked for if not zero
     928            if (intercept && tpparam.magic_number != 0)
     929            {
     930              uint32 *magic_number_field= reinterpret_cast<uint32 *>(m->payload + 4 * (ip->ihl) + udp_header_size);
     931              // now check for magic number in UDP payload
     932              if (tpparam.magic_number != ntohl(*magic_number_field))
     933                { // magic_number does not fit -> do not intercept the packet
     934                  // we don't care about this packet, let it pass the firewall
     935                  WLog(tpparam.name, "[IPv4catcher] - magic number mismatch, read: 0x" << hex << ntohl(*magic_number_field) << dec);
     936                  // do not intercept
     937                  intercept= false;
     938                }
     939              else
     940              {
     941                DLog(tpparam.name, "[IPv4catcher] - " << color[green] << "magic number matched" << color[off]);
     942                uint32 *common_header_word2= reinterpret_cast<uint32 *>(m->payload + 4 * (ip->ihl) + udp_header_size + 8);
     943                if ( !tpparam.strict_rao && (ntohl(*common_header_word2) & 0x8000)==0 )
     944                {
     945                  DLog(tpparam.name, "[IPv4catcher] - C-Flag not set - will not intercept");
     946                  intercept= false;
     947                }
     948              }
     949             
     950            } // endif magic number given
     951           
    1107952            // if intercept is still true, we really will intercept it now
    1108953            if (intercept == true)
    1109954            {
    1110               DLog(tpparam.name, "[IPv4catcher] - I am instructed to intercept packages with this RAO");
    1111955
    1112956              status = ipq_set_verdict (h, m->packet_id,
  • protlib/trunk/test/basic.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/trunk/test/fqueue.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/trunk/test/netmsg.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/trunk/test/queue_manager.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/trunk/test/test_address.cpp

    • Property svn:keywords set to Id HeadURL Rev
    r4044 r4107  
    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
     
    156155          CPPUNIT_ASSERT( source == dest );
    157156
    158           struct in_addr myinaddr= { INADDR_LOOPBACK };
    159           /// set IPv4 from inaddr
     157          struct in_addr myinaddr= { htonl(INADDR_LOOPBACK) };
     158          // set IPv4 from inaddr
    160159          source.set_ip(myinaddr);
    161160          dest.set_ipv4("127.0.0.1");
    162161
     162          CPPUNIT_ASSERT( source.is_ipv4() );
     163          CPPUNIT_ASSERT( dest.is_ipv4() );
     164
    163165          CPPUNIT_ASSERT( source == dest );
    164           const struct in6_addr insixaddr=in6addr_any;
     166
     167          CPPUNIT_ASSERT( source.is_bogus_source() );
     168
     169          const struct in6_addr insixaddr=in6addr_loopback;
    165170          hostaddress v6src(insixaddr);
    166171
    167172          dest.set_ip(insixaddr);
     173
     174          CPPUNIT_ASSERT( dest.is_ipv6() );
    168175          CPPUNIT_ASSERT( dest == v6src);
     176
     177          CPPUNIT_ASSERT( v6src.is_bogus_source() );
    169178                 
    170179        }
    171180
    172 #ifdef GAGA
    173         // Check if the == operator works. Required for test_basics() below.
     181
     182        // Check if the == operator works.
    174183        void test_equals() {
    175                 mri_pathcoupled mri1;
    176                 CPPUNIT_ASSERT( mri1 == mri1 );
    177 
    178                 mri_pathcoupled mri2(
    179                         hostaddress("10.0.0.1"), 32, 1234,
    180                         hostaddress("10.0.0.2"), 32, 5678,
    181                         "tcp", 0, 0, 0, true
    182                 );
    183                 CPPUNIT_ASSERT( mri2 == mri2 );
    184                 CPPUNIT_ASSERT( mri1 != mri2 );
    185 
    186                 // UDP != TCP
    187                 mri_pathcoupled mri3(
    188                         hostaddress("10.0.0.1"), 32, 1234,
    189                         hostaddress("10.0.0.2"), 32, 5678,
    190                         "udp", 0, 0, 0, true
    191                 );
    192                 CPPUNIT_ASSERT( mri3.get_protocol() != mri2.get_protocol() );
    193                 CPPUNIT_ASSERT( mri1 != mri3 );
    194                 CPPUNIT_ASSERT( mri2 != mri3 );
    195         }
    196 
    197         void test_basics() {
    198                 ;
    199                 ASSERT_BASICS_WORK( mri1 ); // should this work?
    200 
    201                 mri_pathcoupled mri2(
    202                         hostaddress("10.0.0.1"), 32, 1234,
    203                         hostaddress("10.0.0.2"), 32, 5678,
    204                         "tcp", 0, 0, 0, true
    205                 );
    206                 ASSERT_BASICS_WORK( mri2 );
    207 
    208                 // UDP != TCP
    209                 mri_pathcoupled mri3(
    210                         hostaddress("10.0.0.1"), 32, 1234,
    211                         hostaddress("10.0.0.2"), 32, 5678,
    212                         "udp", 0, 0, 0, true
    213                 );
    214                 ASSERT_BASICS_WORK( mri3 );
    215 
    216                 // IPv6 addresses and a flow label
    217                 mri_pathcoupled mri4(
    218                         hostaddress("fe80::20e:cff:fe22:57e3"), 32, 1234,
    219                         hostaddress("fe80::20e:cff:fe22:574d"), 32, 5678,
    220                         "tcp", 0xfab, 0, 0, true
    221                 );
    222                 ASSERT_BASICS_WORK( mri4 );
    223 
    224         }
    225 
    226         void test_direction() {
    227                 mri_pathcoupled mri1(
    228                         hostaddress("10.0.0.1"), 32, 1234,      // source
    229                         hostaddress("10.0.0.2"), 32, 5678,      // dest
    230                         "tcp", 0, 0, 0, true                    // downstream
    231                 );
    232 
    233                 appladdress *final_hop1 = mri1.determine_dest_address();
    234                 CPPUNIT_ASSERT( final_hop1 != NULL );
    235                 // Note: Comparison only works this way round because
    236                 //       appladdress is a subclass of hostaddress!
    237                 CPPUNIT_ASSERT( hostaddress("10.0.0.2") == *final_hop1 );
    238 
    239                 mri1.invertDirection();
    240                 appladdress *final_hop2 = mri1.determine_dest_address();
    241                 CPPUNIT_ASSERT( final_hop2 != NULL );
    242                 CPPUNIT_ASSERT( hostaddress("10.0.0.1") == *final_hop2 );
    243 
    244                 delete final_hop1;
    245                 delete final_hop2;
    246         }
    247 #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
    248242        void test_multicast_hostaddress() {
    249243                hostaddress ta; // testaddress
     
    262256                CPPUNIT_ASSERT( ta.is_multicast() );
    263257        }
     258        void test_multicast_hostaddress() {
     259                hostaddress ta; // testaddress
     260
     261                // Test IPv4 addresses
     262                ta.set_ipv4("127.0.0.1");
     263                CPPUNIT_ASSERT( !ta.is_multicast() );
     264
     265                ta.set_ipv4("224.0.0.0");
     266                CPPUNIT_ASSERT( ta.is_multicast() );
     267
     268                // Test IPv6 addresses
     269                ta.set_ip("2001:638:204:1:230:48ff:fec4:813a");
     270                CPPUNIT_ASSERT( !ta.is_multicast() );
     271                ta.set_ip("FF01:0:0:0:0:0:0:1");
     272                CPPUNIT_ASSERT( ta.is_multicast() );
     273        }
    264274};
    265275
  • protlib/trunk/test/test_runner.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/trunk/test/test_template.cpp

    • Property svn:keywords changed from Id HeadURL to Id HeadURL Rev
  • protlib/trunk/test/test_types.cpp

    • Property svn:keywords set to Id HeadURL Rev
    r3062 r4107  
    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/trunk/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.