/**
** File ......... TcpSocket.cpp
** Published .... 2004-02-13
** Author ....... grymse@alhem.net
**/
/*
Copyright (C) 2004,2005 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 "SocketHandler.h"
#ifdef _WIN32
#pragma warning(disable:4786)
#define strcasecmp stricmp
#include <stdlib.h>
#else
#include <errno.h>
#endif
#include <stdio.h>
#include <fcntl.h>
#include <assert.h>
#include <stdarg.h>
#ifdef HAVE_OPENSSL
#include <openssl/rand.h>
#endif
#include "TcpSocket.h"
#include "PoolSocket.h"
#ifdef _DEBUG
#define DEB(x) x
#else
#define DEB(x)
#endif
#ifdef HAVE_OPENSSL
BIO *TcpSocket::bio_err = NULL;
std::string TcpSocket::m_password;
#endif
// thanks, q
#ifdef _WIN32
#pragma warning(disable:4355)
#endif
TcpSocket::TcpSocket(SocketHandler& h) : Socket(h)
,ibuf(*this, TCP_BUFSIZE_READ)
,obuf(*this, 32768)
,m_line("")
,m_socks4_state(0)
,m_resolver_id(0)
#ifdef HAVE_OPENSSL
,m_context(NULL)
,m_ssl(NULL)
,m_sbio(NULL)
#endif
{
}
#ifdef _WIN32
#pragma warning(default:4355)
#endif
#ifdef _WIN32
#pragma warning(disable:4355)
#endif
TcpSocket::TcpSocket(SocketHandler& h,size_t isize,size_t osize) : Socket(h)
,ibuf(*this, isize)
,obuf(*this, osize)
,m_line("")
,m_socks4_state(0)
,m_resolver_id(0)
#ifdef HAVE_OPENSSL
,m_context(NULL)
,m_ssl(NULL)
,m_sbio(NULL)
#endif
{
}
#ifdef _WIN32
#pragma warning(default:4355)
#endif
TcpSocket::~TcpSocket()
{
#ifdef HAVE_OPENSSL
if (m_ssl)
{
DEB( printf("SSL_free()\n");)
SSL_free(m_ssl);
}
if (m_context)
{
DEB( printf("SSL_CTX_free()\n");)
SSL_CTX_free(m_context);
}
#endif
}
bool TcpSocket::Open(ipaddr_t ip,port_t port,bool skip_socks)
{
SetConnecting(false);
SetSocks4(false);
// check for pooling
PoolSocket *pools = Handler().FindConnection(SOCK_STREAM, "tcp", ip, port);
if (pools)
{
CopyConnection( pools );
delete pools;
SetIsClient();
SetCallOnConnect(); // SocketHandler must call OnConnect
DEB(printf("Reusing connection\n");)
return true;
}
// if not, create new connection
SOCKET s = CreateSocket4(SOCK_STREAM, "tcp");
if (s == INVALID_SOCKET)
{
return false;
}
// socket must be nonblocking for async connect
if (!SetNonblocking(true, s))
{
closesocket(s);
return false;
}
SetIsClient(); // client because we connect
SetClientRemoteAddr(ip);
SetClientRemotePort(port);
struct sockaddr_in sa;
// size of sockaddr struct
socklen_t sa_len = sizeof(sa);
if (!skip_socks && GetSocks4Host() && GetSocks4Port())
{
memset(&sa, 0, sa_len);
sa.sin_family = AF_INET;
sa.sin_port = htons(GetSocks4Port());
ipaddr_t a = GetSocks4Host();
memcpy(&sa.sin_addr, &a, 4);
{
char slask[100];
sprintf(slask,"Connecting to socks4 server @ %08x:%d",GetSocks4Host(),GetSocks4Port());
Handler().LogError(this, "Open", 0, slask, LOG_LEVEL_INFO);
}
SetSocks4();
}
else
{
// setup sockaddr struct
memset(&sa,0,sa_len);
sa.sin_family = AF_INET; // hp -> h_addrtype;
sa.sin_port = htons( port );
memcpy(&sa.sin_addr,&ip,4);
}
// try connect
int n = connect(s, (struct sockaddr *)&sa, sa_len);
if (n == -1)
{
// check error code that means a connect is in progress
#ifdef _WIN32
if (Errno == WSAEWOULDBLOCK)
#else
if (Errno == EINPROGRESS)
#endif
{
SetConnecting( true ); // this flag will control fd_set's
}
else
if (Socks4() && Handler().Socks4TryDirect() ) // retry
{
closesocket(s);
return Open(ip, port, true);
}
else
{
Handler().LogError(this, "connect", Errno, StrError(Errno), LOG_LEVEL_FATAL);
closesocket(s);
return false;
}
}
else
{
SetCallOnConnect(); // SocketHandler must call OnConnect
}
SetRemoteAddress( (struct sockaddr *)&sa,sa_len);
Attach(s);
// 'true' means connected or connecting(not yet connected)
// 'false' means something failed
return true; //!Connecting();
}
bool TcpSocket::Open(const std::string &host,port_t port)
{
if (!Handler().ResolverEnabled() || isip(host) )
{
ipaddr_t l;
if (!u2ip(host,l))
{
return false;
}
return Open(l, port);
}
// resolve using async resolver thread
m_resolver_id = Resolve(host, port);
return true;
}
void TcpSocket::Resolved(int id,ipaddr_t a,port_t port)
{
if (id == m_resolver_id)
{
if (a && port)
{
Open(a, port);
if (!Handler().Valid(this))
{
Handler().Add(this);
}
return;
}
else
{
Handler().LogError(this, "Resolved", 0, "Resolver failed", LOG_LEVEL_FATAL);
}
}
else
{
Handler().LogError(this, "Resolved", id, "Resolver returned wrong job id", LOG_LEVEL_FATAL);
}
SetCloseAndDelete();
}
// halfbaked IPV6 code
#ifdef IPPROTO_IPV6
bool TcpSocket::Open6(const std::string &host,port_t port)
{
// check for pooling
// if not, create new connection
SOCKET s = CreateSocket6(SOCK_STREAM, "tcp");
if (s == INVALID_SOCKET)
{
return false;
}
struct in6_addr a;
if (u2ip(host,a))
{
struct sockaddr_in6 sa;
socklen_t sa_len = sizeof(sa);
memset(&sa,0,sizeof(sa));
sa.sin6_family = AF_INET6;
sa.sin6_port = htons( port );
sa.sin6_flowinfo = 0;
sa.sin6_scope_id = 0;
sa.sin6_addr = a;
if (!SetNonblocking(true, s))
{
closesocket(s);
return false;
}
int n = connect(s, (struct sockaddr *)&sa, sa_len);
if (n == -1)
{
#ifdef _WIN32
if (Errno != WSAEWOULDBLOCK)
#else
if (Errno != EINPROGRESS)
#endif
{
Handler().LogError(this, "connect", Errno, StrError(Errno), LOG_LEVEL_FATAL);
closesocket(s);
return false;
}
else
{
SetConnecting(true);
}
}
else
{
SetCallOnConnect(); // SocketHandler must call OnConnect
}
SetRemoteAddress((struct sockaddr *)&sa,sa_len);
Attach(s);
return true; //!Connecting();
}
return false; // u2ip failed
}
#endif
void TcpSocket::OnRead()
{
if (IsSSL())
{
#ifdef HAVE_OPENSSL
DEB( printf("TcpSocket(SSL)::OnRead()\n");)
if (!Ready())
return;
char buf[TCP_BUFSIZE_READ];
int n = SSL_read(m_ssl, buf, TCP_BUFSIZE_READ);
if (n == -1)
{
n = SSL_get_error(m_ssl, n);
switch (n)
{
case SSL_ERROR_NONE:
break;
case SSL_ERROR_ZERO_RETURN:
DEB( printf("SSL_read() returns zero - closing socket\n");)
SetCloseAndDelete(true);
break;
default:
DEB( printf("SSL read problem, errcode = %d\n",n);)
SetCloseAndDelete(true); // %!
}
}
else
if (!n)
{
SetCloseAndDelete(true);
DEB( printf("read() returns 0\n");)
}
else
{
DEB( printf("TcpSocket(SSL) OnRead read %d bytes\n",n);)
if (!ibuf.Write(buf,n))
{
// overflow
DEB( printf(" *** overflow ibuf Write\n");)
}
}
return;
#endif // HAVE_OPENSSL
}
DEB(printf("TcpSocket::OnRead()\n");)
int n = (int)ibuf.Space();
char buf[TCP_BUFSIZE_READ];
// if (!n)
// return; // bad
n = TCP_BUFSIZE_READ; // %! patch away
n = recv(GetSocket(),buf,(n < TCP_BUFSIZE_READ) ? n : TCP_BUFSIZE_READ,MSG_NOSIGNAL);
if (n == -1)
{
Handler().LogError(this, "read", Errno, StrError(Errno), LOG_LEVEL_FATAL);
SetCloseAndDelete(true); // %!
SetLost();
}
else
if (!n)
{
Handler().LogError(this, "read", 0, "read returns 0", LOG_LEVEL_FATAL);
SetCloseAndDelete(true);
SetLost();
}
else
{
OnRawData(buf,n);
if (!ibuf.Write(buf,n))
{
// overflow
Handler().LogError(this, "read", 0, "ibuf overflow", LOG_LEVEL_WARNING);
}
}
}
void TcpSocket::OnWrite()
{
if (IsSSL())
{
#ifdef HAVE_OPENSSL
/*
if (!Handler().Valid(this))
return;
if (!Ready())
return;
*/
DEB( printf("TcpSocket(SSL)::OnWrite()\n");)
// TODO: check MES buffer
int n = SSL_write(m_ssl,obuf.GetStart(),obuf.GetL());
DEB( printf("OnWrite: %d bytes sent\n",n);)
if (n == -1)
{
// check code
SetCloseAndDelete(true);
DEB( perror("write() error");)
}
else
if (!n)
{
SetCloseAndDelete(true);
DEB( printf("write() returns 0\n");)
}
else
{
DEB( printf(" %d bytes written\n",n);)
obuf.Remove(n);
}
{
bool br;
bool bw;
bool bx;
Handler().Get(GetSocket(), br, bw, bx);
if (obuf.GetLength())
Set(br, true);
else
Set(br, false);
}
return;
#endif // HAVE_OPENSSL
}
/*
assert(GetSocket() != INVALID_SOCKET);
if (obuf.GetL() <= 0)
{
printf("OnWrite abort because: nothing to write\n");
Set(true, false);
return;
}
assert(obuf.GetL() > 0);
if (!Handler().Valid(this))
{
printf("OnWrite abort because: not valid\n");
return;
}
if (!Ready())
{
printf("OnWrite abort because: not ready\n");
return;
}
*/
int n = send(GetSocket(),obuf.GetStart(),(int)obuf.GetL(),MSG_NOSIGNAL);
/*
When writing onto a connection-oriented socket that has been shut down (by the local
or the remote end) SIGPIPE is sent to the writing process and EPIPE is returned. The
signal is not sent when the write call specified the MSG_NOSIGNAL flag.
*/
if (n == -1)
{
// normal error codes:
// WSAEWOULDBLOCK
// EAGAIN or EWOULDBLOCK
#ifdef _WIN32
if (Errno != WSAEWOULDBLOCK)
#else
if (Errno != EWOULDBLOCK)
#endif
{
Handler().LogError(this, "write", Errno, StrError(Errno), LOG_LEVEL_FATAL);
SetCloseAndDelete(true); // %!
SetLost();
}
}
else
if (!n)
{
// SetCloseAndDelete(true);
}
else
{
obuf.Remove(n);
}
// check m_mes
while (obuf.Space() && m_mes.size())
{
ucharp_v::iterator it = m_mes.begin();
MES *p = *it; //m_mes[0];
if (obuf.Space() > p -> left())
{
obuf.Write(p -> curbuf(),p -> left());
delete p;
//printf("\n m_mes erase()\n");
m_mes.erase(m_mes.begin());
}
else
{
size_t sz = obuf.Space();
obuf.Write(p -> curbuf(),sz);
p -> ptr += sz;
}
}
{
bool br;
bool bw;
bool bx;
Handler().Get(GetSocket(), br, bw, bx);
if (obuf.GetLength())
Set(br, true);
else
{
Set(br, false);
// OnWriteComplete();
}
}
}
void TcpSocket::Send(const std::string &str)
{
SendBuf(str.c_str(),str.size());
}
void TcpSocket::SendBuf(const char *buf,size_t len)
{
int n = (int)obuf.GetLength();
if (!Ready())
{
Handler().LogError(this, "SendBuf", -1, "Attempt to write to a non-ready socket" ); // warning
// if (m_socket != INVALID_SOCKET && !Connecting() && !CloseAndDelete())
// Handler().LogError(this, "SendBuf: Data to Write", len, static_cast<std::string>(buf).substr(0,len).c_str(), LOG_LEVEL_INFO);
if (GetSocket() == INVALID_SOCKET)
Handler().LogError(this, "SendBuf", 0, " * GetSocket() == INVALID_SOCKET", LOG_LEVEL_INFO);
if (Connecting())
Handler().LogError(this, "SendBuf", 0, " * Connecting()", LOG_LEVEL_INFO);
if (CloseAndDelete())
Handler().LogError(this, "SendBuf", 0, " * CloseAndDelete()", LOG_LEVEL_INFO);
return;
}
//DEB( printf("trying to send %d bytes; buf before = %d bytes\n",len,n);)
if (m_mes.size() || len > obuf.Space())
{
MES *p = new MES(buf,len);
m_mes.push_back(p);
}
if (m_mes.size())
{
while (obuf.Space() && m_mes.size())
{
ucharp_v::iterator it = m_mes.begin();
MES *p = *it; //m_mes[0];
if (obuf.Space() > p -> left())
{
obuf.Write(p -> curbuf(),p -> left());
delete p;
m_mes.erase(m_mes.begin());
}
else
{
size_t sz = obuf.Space();
obuf.Write(p -> curbuf(),sz);
p -> ptr += sz;
}
}
}
else
{
if (!obuf.Write(buf,len))
{
Handler().LogError(this, "SendBuf", -1, "Send overflow" );
// overflow
}
}
if (!n)
{
OnWrite();
}
}
void TcpSocket::OnLine(const std::string& )
{
}
void TcpSocket::ReadLine()
{
if (ibuf.GetLength())
{
size_t x = 0;
size_t n = ibuf.GetLength();
char tmp[TCP_BUFSIZE_READ + 1];
n = (n >= TCP_BUFSIZE_READ) ? TCP_BUFSIZE_READ : n;
ibuf.Read(tmp,n);
tmp[n] = 0;
for (size_t i = 0; i < n; i++)
{
while (tmp[i] == 13 || tmp[i] == 10)
{
char c = tmp[i];
tmp[i] = 0;
if (tmp[x])
{
m_line += (tmp + x);
}
OnLine( m_line );
i++;
if (i < n && (tmp[i] == 13 || tmp[i] == 10) && tmp[i] != c)
{
i++;
}
x = i;
m_line = "";
}
}
if (tmp[x])
{
m_line += (tmp + x);
}
}
}
#ifdef _WIN32
#pragma warning(disable:4355)
#endif
TcpSocket::TcpSocket(const TcpSocket& s)
:Socket(s)
,ibuf(*this,0)
,obuf(*this,0)
{
}
#ifdef _WIN32
#pragma warning(default:4355)
#endif
void TcpSocket::OnSocks4Connect()
{
char request[1000];
request[0] = 4; // socks v4
request[1] = 1; // command code: CONNECT
unsigned short port = htons(GetClientRemotePort()); // send port in network byte order
memcpy(request + 2, &port, 2);
memcpy(request + 4, &GetClientRemoteAddr(), 4); // ipaddr_t is already in network byte order
strcpy(request + 8, GetSocks4Userid().c_str());
size_t length = GetSocks4Userid().size() + 8 + 1;
SendBuf(request, length);
m_socks4_state = 0;
}
void TcpSocket::OnSocks4ConnectFailed()
{
Handler().LogError(this,"OnSocks4ConnectFailed",0,"connection to socks4 server failed, trying direct connection",LOG_LEVEL_WARNING);
if (!Handler().Socks4TryDirect())
{
SetCloseAndDelete();
OnConnectFailed(); // just in case
}
else
{
closesocket(GetSocket());
Open(GetClientRemoteAddr(), GetClientRemotePort(), true); // open directly
}
}
bool TcpSocket::OnSocks4Read()
{
switch (m_socks4_state)
{
case 0:
ibuf.Read(&m_socks4_vn, 1);
m_socks4_state = 1;
break;
case 1:
ibuf.Read(&m_socks4_cd, 1);
m_socks4_state = 2;
break;
case 2:
if (GetInputLength() > 1)
{
ibuf.Read( (char *)&m_socks4_dstport, 2);
m_socks4_state = 3;
}
else
{
return true;
}
break;
case 3:
if (GetInputLength() > 3)
{
ibuf.Read( (char *)&m_socks4_dstip, 4);
SetSocks4(false);
switch (m_socks4_cd)
{
case 90:
OnConnect();
break;
case 91:
case 92:
case 93:
Handler().LogError(this,"OnSocks4Read",m_socks4_cd,"socks4 server reports connect failed",LOG_LEVEL_FATAL);
SetCloseAndDelete();
OnConnectFailed();
break;
default:
Handler().LogError(this,"OnSocks4Read",m_socks4_cd,"socks4 server unrecognized response",LOG_LEVEL_FATAL);
SetCloseAndDelete();
break;
}
}
else
{
return true;
}
break;
}
return false;
}
void TcpSocket::Sendf(char *format, ...)
{
va_list ap;
va_start(ap, format);
char slask[5000];
#ifdef _WIN32
vsprintf(slask, format, ap);
#else
vsnprintf(slask, 5000, format, ap);
#endif
va_end(ap);
Send( slask );
}
void TcpSocket::OnSSLConnect()
{
#ifdef HAVE_OPENSSL
DEB( printf("TcpSocket(SSL)::OnConnect()\n");)
SetNonblocking(true);
{
if (m_context)
{
DEB( printf("SSL Context already initialized - closing socket\n");)
SetCloseAndDelete(true);
return;
}
DEB( printf("InitSSLClient()\n");)
InitSSLClient();
}
if (m_context)
{
/* Connect the SSL socket */
m_ssl = SSL_new(m_context);
if (!m_ssl)
{
DEB( printf(" m_ssl is NULL\n");)
}
m_sbio = BIO_new_socket(GetSocket(), BIO_NOCLOSE);
if (!m_sbio)
{
DEB( printf(" m_sbio is NULL\n");)
}
SSL_set_bio(m_ssl, m_sbio, m_sbio);
if (!SSLNegotiate())
SetSSLNegotiate();
}
else
{
SetCloseAndDelete();
}
#endif
}
void TcpSocket::OnSSLAccept()
{
#ifdef HAVE_OPENSSL
DEB( printf("TcpSocket(SSL)::OnAccept()\n");)
SetNonblocking(true);
{
if (m_context)
{
DEB( printf("SSL Context already initialized - closing socket\n");)
SetCloseAndDelete(true);
return;
}
InitSSLServer();
SetSSLServer();
}
if (m_context)
{
m_ssl = SSL_new(m_context);
if (!m_ssl)
{
DEB( printf(" m_ssl is NULL\n");)
}
m_sbio = BIO_new_socket(GetSocket(), BIO_NOCLOSE);
if (!m_sbio)
{
DEB( printf(" m_sbio is NULL\n");)
}
SSL_set_bio(m_ssl, m_sbio, m_sbio);
if (!SSLNegotiate())
SetSSLNegotiate();
}
#endif
}
bool TcpSocket::SSLNegotiate()
{
#ifdef HAVE_OPENSSL
if (!IsSSLServer()) // client
{
DEB( printf("TcpSocket::SSLNegotiate() is_client\n");)
int r = SSL_connect(m_ssl);
DEB( printf(" SSLNegotiate is_client, SSL_connect returns %d\n",r);)
if (r > 0)
{
SetSSLNegotiate(false);
// TODO: resurrect certificate check... client
// CheckCertificateChain( "");//ServerHOST);
SetNonblocking(false);
DEB( printf("TcpSocket::SSLNegotiate() init OK\n");)
OnConnect();
return true;
}
else
if (!r)
{
SetSSLNegotiate(false);
SetCloseAndDelete();
}
else
{
r = SSL_get_error(m_ssl, r);
if (r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE)
{
DEB( printf("SSL_connect() failed - closing socket, return code: %d\n",r);)
SetSSLNegotiate(false);
SetCloseAndDelete(true);
}
}
}
else // server
{
DEB( printf("TcpSocket::SSLNegotiate() is_server\n");)
int r = SSL_accept(m_ssl);
DEB( printf(" SSLNegotiate is_server, SSL_accept returns %d\n",r);)
if (r > 0)
{
SetSSLNegotiate(false);
// TODO: resurrect certificate check... server
// CheckCertificateChain( "");//ClientHOST);
SetNonblocking(false);
DEB( printf("TcpSocket::SSLNegotiate() init OK\n");)
OnAccept();
return true;
}
else
if (!r)
{
SetSSLNegotiate(false);
SetCloseAndDelete();
}
else
{
r = SSL_get_error(m_ssl, r);
if (r != SSL_ERROR_WANT_READ && r != SSL_ERROR_WANT_WRITE)
{
DEB( printf("SSL_accept() failed - closing socket, return code: %d\n",r);)
SetSSLNegotiate(false);
SetCloseAndDelete(true);
}
}
}
#endif // HAVE_OPENSSL
return false;
}
void TcpSocket::InitSSLClient()
{
#ifdef HAVE_OPENSSL
// InitializeContext();
InitializeContext(SSLv23_method());
#endif
}
void TcpSocket::InitSSLServer()
{
}
#ifdef HAVE_OPENSSL
void TcpSocket::InitializeContext(SSL_METHOD *meth_in)
{
SSL_METHOD *meth;
if (!bio_err)
{
/* An error write context */
bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
/* Global system initialization*/
SSL_library_init();
SSL_load_error_strings();
OpenSSL_add_all_algorithms();
}
/* Create our context*/
meth = meth_in ? meth_in : SSLv3_method();
m_context = SSL_CTX_new(meth);
/* Load the CAs we trust*/
/*
if (!(SSL_CTX_load_verify_locations(m_context, CA_LIST, 0)))
{
DEB( printf("Couldn't read CA list\n");)
}
SSL_CTX_set_verify_depth(m_context, 1);
SSL_CTX_set_verify(m_context, SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT, verify_cb);
*/
/* Load randomness */
if (!(RAND_load_file(RANDOM, 1024*1024)))
{
DEB( printf("Couldn't load randomness\n");)
}
}
void TcpSocket::InitializeContext(const std::string& keyfile,const std::string& password,SSL_METHOD *meth_in)
{
SSL_METHOD *meth;
if (!bio_err)
{
/* An error write context */
bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
/* Global system initialization*/
SSL_library_init();
SSL_load_error_strings();
OpenSSL_add_all_algorithms();
}
/* Create our context*/
meth = meth_in ? meth_in : SSLv3_method();
m_context = SSL_CTX_new(meth);
/* Load our keys and certificates*/
if (!(SSL_CTX_use_certificate_file(m_context, keyfile.c_str(), SSL_FILETYPE_PEM)))
{
DEB( printf("Couldn't read certificate file\n");)
}
m_password = password;
SSL_CTX_set_default_passwd_cb(m_context, password_cb);
if (!(SSL_CTX_use_PrivateKey_file(m_context, keyfile.c_str(), SSL_FILETYPE_PEM)))
{
DEB( printf("Couldn't read key file\n");)
}
/* Load the CAs we trust*/
/*
if (!(SSL_CTX_load_verify_locations(m_context, CA_LIST, 0)))
{
DEB( printf("Couldn't read CA list\n");)
}
SSL_CTX_set_verify_depth(m_context, 1);
SSL_CTX_set_verify(m_context, SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT, verify_cb);
*/
/* Load randomness */
if (!(RAND_load_file(RANDOM, 1024*1024)))
{
DEB( printf("Couldn't load randomness\n");)
}
}
// static
int TcpSocket::password_cb(char *buf,int num,int rwflag,void *userdata)
{
if ( (size_t)num < m_password.size() + 1)
{
return 0;
}
strcpy(buf,m_password.c_str());
return m_password.size();
}
#endif // HAVE_OPENSSL
int TcpSocket::Close()
{
#ifdef HAVE_OPENSSL
if (IsSSL())
SSL_shutdown(m_ssl);
#endif
return Socket::Close();
}
#ifdef HAVE_OPENSSL
SSL_CTX *TcpSocket::GetSslContext()
{
if (!m_context)
Handler().LogError(this, "GetSslContext", 0, "SSL Context is NULL; check InitAsServer/InitAsClient", LOG_LEVEL_WARNING);
return m_context;
}
SSL *TcpSocket::GetSsl()
{
if (!m_ssl)
Handler().LogError(this, "GetSsl", 0, "SSL is NULL; check InitAsServer/InitAsClient", LOG_LEVEL_WARNING);
return m_ssl;
}
#endif
syntax highlighted by Code2HTML, v. 0.9.1