From fffd213c8cba2135afda493d797c41c10354770e Mon Sep 17 00:00:00 2001 From: Othmar Gsenger Date: Sat, 12 Apr 2008 11:38:42 +0000 Subject: big svn cleanup --- src/Sockets/SctpSocket.cpp | 496 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 496 insertions(+) create mode 100644 src/Sockets/SctpSocket.cpp (limited to 'src/Sockets/SctpSocket.cpp') diff --git a/src/Sockets/SctpSocket.cpp b/src/Sockets/SctpSocket.cpp new file mode 100644 index 0000000..2267086 --- /dev/null +++ b/src/Sockets/SctpSocket.cpp @@ -0,0 +1,496 @@ +/** + ** \file SctpSocket.cpp + ** \date 2006-09-04 + ** \author grymse@alhem.net +**/ +/* +Copyright (C) 2007 Anders Hedstrom + +This program is free software; you can redistribute it and/or +modify it under the terms of the GNU General Public License +as published by the Free Software Foundation; either version 2 +of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +*/ +#include "SctpSocket.h" +#ifdef USE_SCTP +#include "Utility.h" +#include "ISocketHandler.h" +#include +#include "Ipv4Address.h" +#include "Ipv6Address.h" +#ifdef ENABLE_EXCEPTIONS +#include "Exception.h" +#endif + +#ifdef SOCKETS_NAMESPACE +namespace SOCKETS_NAMESPACE +{ +#endif + + +SctpSocket::SctpSocket(ISocketHandler& h,int type) : StreamSocket(h) +,m_type(type) +,m_buf(new char[SCTP_BUFSIZE_READ]) +{ + if (type != SOCK_STREAM && type != SOCK_SEQPACKET) + { + } +} + + +SctpSocket::~SctpSocket() +{ + delete[] m_buf; +} + + +int SctpSocket::Bind(const std::string& a,port_t p) +{ +#ifdef ENABLE_IPV6 +#ifdef IPPROTO_IPV6 + if (IsIpv6()) + { + Ipv6Address ad(a, p); + return Bind(ad); + } +#endif +#endif + Ipv4Address ad(a, p); + return Bind(ad); +} + + +int SctpSocket::Bind(SocketAddress& ad) +{ + if (!ad.IsValid()) + { + Handler().LogError(this, "SctpSocket", -1, "invalid address", LOG_LEVEL_ERROR); + return -1; + } + if (GetSocket() == INVALID_SOCKET) + { + Attach(CreateSocket(ad.GetFamily(), m_type, "sctp")); + } + if (GetSocket() != INVALID_SOCKET) + { + int n = bind(GetSocket(), ad, ad); + if (n == -1) + { + Handler().LogError(this, "SctpSocket", -1, "bind() failed", LOG_LEVEL_ERROR); +#ifdef ENABLE_EXCEPTIONS + throw Exception("bind() failed for SctpSocket, port: " + Utility::l2string(ad.GetPort())); +#endif + } + return n; + } + return -1; +} + + +int SctpSocket::AddAddress(const std::string& a,port_t p) +{ +#ifdef ENABLE_IPV6 +#ifdef IPPROTO_IPV6 + if (IsIpv6()) + { + Ipv6Address ad(a, p); + return AddAddress(ad); + } +#endif +#endif + Ipv4Address ad(a, p); + return AddAddress(ad); +} + + +int SctpSocket::AddAddress(SocketAddress& ad) +{ + if (!ad.IsValid()) + { + Handler().LogError(this, "SctpSocket", -1, "invalid address", LOG_LEVEL_ERROR); + return -1; + } + if (GetSocket() == INVALID_SOCKET) + { + Handler().LogError(this, "SctpSocket", -1, "AddAddress called with invalid file descriptor", LOG_LEVEL_ERROR); + return -1; + } + int n = sctp_bindx(GetSocket(), ad, ad, SCTP_BINDX_ADD_ADDR); + if (n == -1) + { + Handler().LogError(this, "SctpSocket", -1, "sctp_bindx() failed", LOG_LEVEL_ERROR); + } + return n; +} + + +int SctpSocket::RemoveAddress(const std::string& a,port_t p) +{ +#ifdef ENABLE_IPV6 +#ifdef IPPROTO_IPV6 + if (IsIpv6()) + { + Ipv6Address ad(a, p); + return RemoveAddress(ad); + } +#endif +#endif + Ipv4Address ad(a, p); + return RemoveAddress(ad); +} + + +int SctpSocket::RemoveAddress(SocketAddress& ad) +{ + if (!ad.IsValid()) + { + Handler().LogError(this, "SctpSocket", -1, "invalid address", LOG_LEVEL_ERROR); + return -1; + } + if (GetSocket() == INVALID_SOCKET) + { + Handler().LogError(this, "SctpSocket", -1, "RemoveAddress called with invalid file descriptor", LOG_LEVEL_ERROR); + return -1; + } + int n = sctp_bindx(GetSocket(), ad, ad, SCTP_BINDX_REM_ADDR); + if (n == -1) + { + Handler().LogError(this, "SctpSocket", -1, "sctp_bindx() failed", LOG_LEVEL_ERROR); + } + return n; +} + + +int SctpSocket::Open(const std::string& a,port_t p) +{ +#ifdef ENABLE_IPV6 +#ifdef IPPROTO_IPV6 + if (IsIpv6()) + { + Ipv6Address ad(a, p); + return Open(ad); + } +#endif +#endif + Ipv4Address ad(a, p); + return Open(ad); +} + + +int SctpSocket::Open(SocketAddress& ad) +{ + if (!ad.IsValid()) + { + Handler().LogError(this, "SctpSocket", -1, "invalid address", LOG_LEVEL_ERROR); + return -1; + } + if (GetSocket() == INVALID_SOCKET) + { + Attach(CreateSocket(ad.GetFamily(), m_type, "sctp")); + } + if (GetSocket() != INVALID_SOCKET) + { + if (!SetNonblocking(true)) + { + return -1; + } + int n = connect(GetSocket(), ad, ad); + if (n == -1) + { + // check error code that means a connect is in progress +#ifdef _WIN32 + if (Errno == WSAEWOULDBLOCK) +#else + if (Errno == EINPROGRESS) +#endif + { + Handler().LogError(this, "connect: connection pending", Errno, StrError(Errno), LOG_LEVEL_INFO); + SetConnecting( true ); // this flag will control fd_set's + } + else + { + Handler().LogError(this, "SctpSocket", -1, "connect() failed", LOG_LEVEL_ERROR); + } + } + return n; + } + return -1; +} + + +#ifndef SOLARIS +int SctpSocket::AddConnection(const std::string& a,port_t p) +{ +#ifdef ENABLE_IPV6 +#ifdef IPPROTO_IPV6 + if (IsIpv6()) + { + Ipv6Address ad(a, p); + return AddConnection(ad); + } +#endif +#endif + Ipv4Address ad(a, p); + return AddConnection(ad); +} + + +int SctpSocket::AddConnection(SocketAddress& ad) +{ + if (!ad.IsValid()) + { + Handler().LogError(this, "SctpSocket", -1, "invalid address", LOG_LEVEL_ERROR); + return -1; + } + if (GetSocket() == INVALID_SOCKET) + { + Handler().LogError(this, "SctpSocket", -1, "AddConnection called with invalid file descriptor", LOG_LEVEL_ERROR); + return -1; + } + int n = sctp_connectx(GetSocket(), ad, ad); + if (n == -1) + { + Handler().LogError(this, "SctpSocket", -1, "sctp_connectx() failed", LOG_LEVEL_ERROR); + } + else + { + SetConnecting(); + } + return n; +} +#endif + + +int SctpSocket::getpaddrs(sctp_assoc_t id,std::list& vec) +{ + struct sockaddr *p = NULL; + int n = sctp_getpaddrs(GetSocket(), id, &p); + if (!n || n == -1) + { + Handler().LogError(this, "SctpSocket", -1, "sctp_getpaddrs failed", LOG_LEVEL_WARNING); + return n; + } + for (int i = 0; i < n; i++) + { + vec.push_back(Utility::Sa2String(&p[i])); + } + sctp_freepaddrs(p); + return n; +} + + +int SctpSocket::getladdrs(sctp_assoc_t id,std::list& vec) +{ + struct sockaddr *p = NULL; + int n = sctp_getladdrs(GetSocket(), id, &p); + if (!n || n == -1) + { + Handler().LogError(this, "SctpSocket", -1, "sctp_getladdrs failed", LOG_LEVEL_WARNING); + return n; + } + for (int i = 0; i < n; i++) + { + vec.push_back(Utility::Sa2String(&p[i])); + } + sctp_freeladdrs(p); + return n; +} + + +int SctpSocket::PeelOff(sctp_assoc_t id) +{ + int n = sctp_peeloff(GetSocket(), id); + if (n == -1) + { + Handler().LogError(this, "SctpSocket", -1, "PeelOff failed", LOG_LEVEL_WARNING); + return -1; + } + Socket *p = Create(); + p -> Attach(n); + p -> SetDeleteByHandler(); + Handler().Add(p); + return n; +} + + +void SctpSocket::OnRead() +{ +/* + int sctp_recvmsg(int sd, void * msg, size_t * len, + struct sockaddr * from, socklen_t * fromlen, + struct sctp_sndrcvinfo * sinfo, int * msg_flags); + + DESCRIPTION + sctp_recvmsg is a wrapper library function that can be used to receive a message from a socket while using the advanced + features of SCTP. sd is the socket descriptor on which the message pointed to by msg of length len is received. + + If from is not NULL, the source address of the message is filled in. The argument fromlen is a value-result parameter. + initialized to the size of the buffer associated with from , and modified on return to indicate the actual size of the + address stored. + + sinfo is a pointer to a sctp_sndrcvinfo structure to be filled upon receipt of the message. msg_flags is a pointer to a + integer that is filled with any message flags like MSG_NOTIFICATION or MSG_EOR. + +*/ + struct sockaddr sa; + socklen_t sa_len = 0; + struct sctp_sndrcvinfo sinfo; + int flags = 0; + int n = sctp_recvmsg(GetSocket(), m_buf, SCTP_BUFSIZE_READ, &sa, &sa_len, &sinfo, &flags); + if (n == -1) + { + Handler().LogError(this, "SctpSocket", Errno, StrError(Errno), LOG_LEVEL_FATAL); + SetCloseAndDelete(); + } + else + { + OnReceiveMessage(m_buf, n, &sa, sa_len, &sinfo, flags); + } +} + + +void SctpSocket::OnReceiveMessage(const char *buf,size_t sz,struct sockaddr *sa,socklen_t sa_len,struct sctp_sndrcvinfo *sinfo,int msg_flags) +{ +} + + +void SctpSocket::OnWrite() +{ + if (Connecting()) + { + int err = SoError(); + + // don't reset connecting flag on error here, we want the OnConnectFailed timeout later on + /// \todo add to read fd_set here + if (!err) // ok + { + Set(!IsDisableRead(), false); + SetConnecting(false); + SetCallOnConnect(); + return; + } + Handler().LogError(this, "sctp: connect failed", err, StrError(err), LOG_LEVEL_FATAL); + Set(false, false); // no more monitoring because connection failed + + // failed +#ifdef ENABLE_SOCKS4 + if (Socks4()) + { + OnSocks4ConnectFailed(); + return; + } +#endif + if (GetConnectionRetry() == -1 || + (GetConnectionRetry() && GetConnectionRetries() < GetConnectionRetry()) ) + { + // even though the connection failed at once, only retry after + // the connection timeout. + // should we even try to connect again, when CheckConnect returns + // false it's because of a connection error - not a timeout... + return; + } + SetConnecting(false); + SetCloseAndDelete( true ); + /// \todo state reason why connect failed + OnConnectFailed(); + return; + } +} + + +void SctpSocket::OnConnectTimeout() +{ + Handler().LogError(this, "connect", -1, "connect timeout", LOG_LEVEL_FATAL); +#ifdef ENABLE_SOCKS4 + if (Socks4()) + { + OnSocks4ConnectFailed(); + // retry direct connection + } + else +#endif + if (GetConnectionRetry() == -1 || + (GetConnectionRetry() && GetConnectionRetries() < GetConnectionRetry()) ) + { + IncreaseConnectionRetries(); + // ask socket via OnConnectRetry callback if we should continue trying + if (OnConnectRetry()) + { + SetRetryClientConnect(); + } + else + { + SetCloseAndDelete( true ); + /// \todo state reason why connect failed + OnConnectFailed(); + } + } + else + { + SetCloseAndDelete(true); + /// \todo state reason why connect failed + OnConnectFailed(); + } + // + SetConnecting(false); +} + + +#ifdef _WIN32 +void SctpSocket::OnException() +{ + if (Connecting()) + { +#ifdef ENABLE_SOCKS4 + if (Socks4()) + OnSocks4ConnectFailed(); + else +#endif + if (GetConnectionRetry() == -1 || + (GetConnectionRetry() && + GetConnectionRetries() < GetConnectionRetry() )) + { + // even though the connection failed at once, only retry after + // the connection timeout + // should we even try to connect again, when CheckConnect returns + // false it's because of a connection error - not a timeout... + } + else + { + SetConnecting(false); // tnx snibbe + SetCloseAndDelete(); + OnConnectFailed(); + } + return; + } + // %! exception doesn't always mean something bad happened, this code should be reworked + // errno valid here? + int err = SoError(); + Handler().LogError(this, "exception on select", err, StrError(err), LOG_LEVEL_FATAL); + SetCloseAndDelete(); +} +#endif // _WIN32 + + +int SctpSocket::Protocol() +{ + return IPPROTO_SCTP; +} + + +#ifdef SOCKETS_NAMESPACE +} // namespace SOCKETS_NAMESPACE +#endif + + +#endif // USE_SCTP + -- cgit v1.2.3