X-Git-Url: https://git.syn-net.org/debian/?a=blobdiff_plain;f=src%2FconnectionList.cpp;h=c13e23a5d18a9172d63448ffb9b492665922cff3;hb=ad05e83616ca7c348db398c0fd6d5c4acce49fae;hp=64027110df663a727943703acc8a95b830c96b9e;hpb=058ae090a970436caec3b3059e9e18b310dd6b0d;p=anytun.git diff --git a/src/connectionList.cpp b/src/connectionList.cpp index 6402711..c13e23a 100644 --- a/src/connectionList.cpp +++ b/src/connectionList.cpp @@ -6,19 +6,20 @@ * tunnel endpoints. It has less protocol overhead than IPSec in Tunnel * mode and allows tunneling of every ETHER TYPE protocol (e.g. * ethernet, ip, arp ...). satp directly includes cryptography and - * message authentication based on the methodes used by SRTP. It is + * message authentication based on the methods used by SRTP. It is * intended to deliver a generic, scaleable and secure solution for * tunneling and relaying of packets of any protocol. * * - * Copyright (C) 2007-2008 Othmar Gsenger, Erwin Nindl, + * Copyright (C) 2007-2014 Markus Grüneis, Othmar Gsenger, Erwin Nindl, * Christian Pointner * * This file is part of Anytun. * * Anytun is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 3 as - * published by the Free Software Foundation. + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * any later version. * * Anytun is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -26,7 +27,20 @@ * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License - * along with anytun. If not, see . + * along with Anytun. If not, see . + * + * In addition, as a special exception, the copyright holders give + * permission to link the code of portions of this program with the + * OpenSSL library under certain conditions as described in each + * individual source file, and distribute linked combinations + * including the two. + * You must obey the GNU General Public License in all respects + * for all of the code used other than OpenSSL. If you modify + * file(s) with this exception, you may extend this exception to your + * version of the file(s), but you are not obligated to do so. If you + * do not wish to do so, delete this exception statement from your + * version. If you delete this exception statement from all source + * files in the program, then also delete it here. */ #include "threadUtils.hpp" @@ -37,19 +51,12 @@ #include "connectionList.h" -ConnectionList* ConnectionList::inst = NULL; -Mutex ConnectionList::instMutex; ConnectionList& gConnectionList = ConnectionList::instance(); - ConnectionList& ConnectionList::instance() { - Lock lock(instMutex); - static instanceCleaner c; - if(!inst) - inst = new ConnectionList(); - - return *inst; + static ConnectionList instance; + return instance; } ConnectionList::ConnectionList() @@ -58,22 +65,21 @@ ConnectionList::ConnectionList() ConnectionList::~ConnectionList() { -// TODO: comment this in as soon as threads @ main get cleaned up properly -// Lock lock(mutex_); -// ConnectionMap::iterator it; -// for(it = connections_.begin(); it != connections_.end(); ++it) { -// delete &it->second.kd_; -// delete &it->second.seq_window_; -// } -} - -void ConnectionList::addConnection(ConnectionParam &conn, u_int16_t mux ) + // TODO: comment this in as soon as threads @ main get cleaned up properly + // Lock lock(mutex_); + // ConnectionMap::iterator it; + // for(it = connections_.begin(); it != connections_.end(); ++it) { + // delete &it->second.kd_; + // delete &it->second.seq_window_; + // } +} + +void ConnectionList::addConnection(ConnectionParam& conn, uint16_t mux) { Lock lock(mutex_); std::pair ret = connections_.insert(ConnectionMap::value_type(mux, conn)); - if(!ret.second) - { + if(!ret.second) { connections_.erase(ret.first); connections_.insert(ConnectionMap::value_type(mux, conn)); } @@ -81,8 +87,8 @@ void ConnectionList::addConnection(ConnectionParam &conn, u_int16_t mux ) const ConnectionMap::iterator ConnectionList::getEnd() { - Lock lock(mutex_); - return connections_.end(); + Lock lock(mutex_); + return connections_.end(); } ConnectionMap::iterator ConnectionList::getBeginUnlocked() @@ -102,50 +108,51 @@ ConnectionMap::iterator ConnectionList::getEndUnlocked() return connections_.end(); } -const ConnectionMap::iterator ConnectionList::getConnection(u_int16_t mux) +const ConnectionMap::iterator ConnectionList::getConnection(uint16_t mux) { - Lock lock(mutex_); - ConnectionMap::iterator it = connections_.find(mux); - return it; + Lock lock(mutex_); + ConnectionMap::iterator it = connections_.find(mux); + return it; } -ConnectionParam & ConnectionList::getOrNewConnectionUnlocked(u_int16_t mux) +ConnectionParam& ConnectionList::getOrNewConnectionUnlocked(uint16_t mux) { - ConnectionMap::iterator it = connections_.find(mux); - if(it!=connections_.end()) - return it->second; + ConnectionMap::iterator it = connections_.find(mux); + if(it!=connections_.end()) { + return it->second; + } - u_int8_t key[] = { - 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', - 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p' + uint8_t key[] = { + 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', + 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p' }; - - u_int8_t salt[] = { - 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', - 'i', 'j', 'k', 'l', 'm', 'n' + + uint8_t salt[] = { + 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', + 'i', 'j', 'k', 'l', 'm', 'n' }; - SeqWindow * seq= new SeqWindow(0); + SeqWindow* seq= new SeqWindow(0); seq_nr_t seq_nr_=0; - KeyDerivation * kd = KeyDerivationFactory::create(gOpt.getKdPrf()); + KeyDerivation* kd = KeyDerivationFactory::create(gOpt.getKdPrf()); kd->init(Buffer(key, sizeof(key)), Buffer(salt, sizeof(salt))); - ConnectionParam conn ((*kd), (*seq), seq_nr_, PacketSourceEndpoint()); - connections_.insert(ConnectionMap::value_type(mux, conn)); - it = connections_.find(mux); - return it->second; + ConnectionParam conn((*kd), (*seq), seq_nr_, PacketSourceEndpoint()); + connections_.insert(ConnectionMap::value_type(mux, conn)); + it = connections_.find(mux); + return it->second; } void ConnectionList::clear() { Lock lock(mutex_); - connections_.clear(); + connections_.clear(); } bool ConnectionList::empty() { Lock lock(mutex_); - return connections_.empty(); + return connections_.empty(); } Mutex& ConnectionList::getMutex()