github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

2010-06-12 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net> 

Renamed member variables
	* src/SocketCore.cc
	* src/SocketCore.h
pull/1/head
Tatsuhiro Tsujikawa 2010-06-12 14:57:38 +00:00
parent 8d1da8bd3e
commit 6b2eeaa9e1
3 changed files with 116 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,3 +1,9 @@
2010-06-12 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Renamed member variables
* src/SocketCore.cc
* src/SocketCore.h
2010-06-12 Tatsuhiro Tsujikawa <t-tujikawa@users.sourceforge.net>
Made public member variable in Metalinker private

201
src/SocketCore.cc
View File

@ -132,18 +132,18 @@ void SocketCore::setTLSContext(const SharedHandle<TLSContext>& tlsContext)
}
#endif // ENABLE_SSL
SocketCore::SocketCore(int sockType):_sockType(sockType), sockfd(-1) {
SocketCore::SocketCore(int sockType):_sockType(sockType), _sockfd(-1) {
init();
}
SocketCore::SocketCore(sock_t sockfd, int sockType):_sockType(sockType), sockfd(sockfd) {
SocketCore::SocketCore(sock_t sockfd, int sockType):_sockType(sockType), _sockfd(sockfd) {
init();
}
void SocketCore::init()
{
blocking = true;
secure = 0;
_blocking = true;
_secure = 0;
_wantRead = false;
_wantWrite = false;
@ -153,17 +153,17 @@ void SocketCore::init()
ssl = NULL;
#endif // HAVE_LIBSSL
#ifdef HAVE_LIBGNUTLS
sslSession = NULL;
peekBufMax = 4096;
peekBuf = 0;
peekBufLength = 0;
_sslSession = 0;
_peekBufMax = 4096;
_peekBuf = 0;
_peekBufLength = 0;
#endif //HAVE_LIBGNUTLS
}
SocketCore::~SocketCore() {
closeConnection();
#ifdef HAVE_LIBGNUTLS
delete [] peekBuf;
delete [] _peekBuf;
#endif // HAVE_LIBGNUTLS
}
@ -198,7 +198,7 @@ void SocketCore::create(int family, int protocol)
throw DL_ABORT_EX
(StringFormat("Failed to create socket. Cause:%s", errorMsg()).str());
}
sockfd = fd;
_sockfd = fd;
}
static sock_t bindInternal(int family, int socktype, int protocol,
@ -254,7 +254,7 @@ void SocketCore::bindWithFamily(uint16_t port, int family, int flags)
if(fd == (sock_t) -1) {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_BIND, error.c_str()).str());
} else {
sockfd = fd;
_sockfd = fd;
}
}
@ -267,7 +267,7 @@ void SocketCore::bind(const std::string& addr, uint16_t port, int flags)
if(fd == (sock_t)-1) {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_BIND, error.c_str()).str());
} else {
sockfd = fd;
_sockfd = fd;
}
}
@ -278,7 +278,7 @@ void SocketCore::bind(uint16_t port, int flags)
if(!(flags&AI_PASSIVE) || _bindAddrs.empty()) {
sock_t fd = bindTo(0, port, _protocolFamily, _sockType, flags, error);
if(fd != (sock_t) -1) {
sockfd = fd;
_sockfd = fd;
}
} else {
for(std::vector<std::pair<struct sockaddr_storage, socklen_t> >::
@ -296,12 +296,12 @@ void SocketCore::bind(uint16_t port, int flags)
}
sock_t fd = bindTo(host, port, _protocolFamily, _sockType, flags, error);
if(fd != (sock_t)-1) {
sockfd = fd;
_sockfd = fd;
break;
}
}
}
if(sockfd == (sock_t) -1) {
if(_sockfd == (sock_t) -1) {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_BIND, error.c_str()).str());
}
}
@ -312,7 +312,7 @@ void SocketCore::bind(const struct sockaddr* addr, socklen_t addrlen)
std::string error;
sock_t fd = bindInternal(addr->sa_family, _sockType, 0, addr, addrlen, error);
if(fd != (sock_t)-1) {
sockfd = fd;
_sockfd = fd;
} else {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_BIND, error.c_str()).str());
}
@ -320,7 +320,7 @@ void SocketCore::bind(const struct sockaddr* addr, socklen_t addrlen)
void SocketCore::beginListen()
{
if(listen(sockfd, 1) == -1) {
if(listen(_sockfd, 1) == -1) {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_LISTEN, errorMsg()).str());
}
}
@ -330,7 +330,7 @@ SocketCore* SocketCore::acceptConnection() const
struct sockaddr_storage sockaddr;
socklen_t len = sizeof(sockaddr);
sock_t fd;
while((fd = accept(sockfd, reinterpret_cast<struct sockaddr*>(&sockaddr), &len)) == (sock_t) -1 && SOCKET_ERRNO == A2_EINTR);
while((fd = accept(_sockfd, reinterpret_cast<struct sockaddr*>(&sockaddr), &len)) == (sock_t) -1 && SOCKET_ERRNO == A2_EINTR);
if(fd == (sock_t) -1) {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_ACCEPT, errorMsg()).str());
}
@ -342,7 +342,7 @@ void SocketCore::getAddrInfo(std::pair<std::string, uint16_t>& addrinfo) const
struct sockaddr_storage sockaddr;
socklen_t len = sizeof(sockaddr);
struct sockaddr* addrp = reinterpret_cast<struct sockaddr*>(&sockaddr);
if(getsockname(sockfd, addrp, &len) == -1) {
if(getsockname(_sockfd, addrp, &len) == -1) {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_GET_NAME, errorMsg()).str());
}
addrinfo = util::getNumericNameInfo(addrp, len);
@ -353,7 +353,7 @@ void SocketCore::getPeerInfo(std::pair<std::string, uint16_t>& peerinfo) const
struct sockaddr_storage sockaddr;
socklen_t len = sizeof(sockaddr);
struct sockaddr* addrp = reinterpret_cast<struct sockaddr*>(&sockaddr);
if(getpeername(sockfd, addrp, &len) == -1) {
if(getpeername(_sockfd, addrp, &len) == -1) {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_GET_NAME, errorMsg()).str());
}
peerinfo = util::getNumericNameInfo(addrp, len);
@ -407,21 +407,21 @@ void SocketCore::establishConnection(const std::string& host, uint16_t port)
}
}
sockfd = fd;
_sockfd = fd;
// make socket non-blocking mode
setNonBlockingMode();
if(connect(fd, rp->ai_addr, rp->ai_addrlen) == -1 &&
SOCKET_ERRNO != A2_EINPROGRESS) {
error = errorMsg();
CLOSE(sockfd);
sockfd = (sock_t) -1;
CLOSE(_sockfd);
_sockfd = (sock_t) -1;
continue;
}
// TODO at this point, connection may not be established and it may fail
// later. In such case, next ai_addr should be tried.
break;
}
if(sockfd == (sock_t) -1) {
if(_sockfd == (sock_t) -1) {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_CONNECT, host.c_str(),
error.c_str()).str());
}
@ -430,7 +430,7 @@ void SocketCore::establishConnection(const std::string& host, uint16_t port)
void SocketCore::setSockOpt
(int level, int optname, void* optval, socklen_t optlen)
{
if(setsockopt(sockfd, level, optname, (a2_sockopt_t)optval, optlen) < 0) {
if(setsockopt(_sockfd, level, optname, (a2_sockopt_t)optval, optlen) < 0) {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_SET_OPT, errorMsg()).str());
}
}
@ -488,60 +488,60 @@ void SocketCore::setNonBlockingMode()
{
#ifdef __MINGW32__
static u_long flag = 1;
if (::ioctlsocket(sockfd, FIONBIO, &flag) == -1) {
if (::ioctlsocket(_sockfd, FIONBIO, &flag) == -1) {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_NONBLOCKING, errorMsg()).str());
}
#else
int flags;
while((flags = fcntl(sockfd, F_GETFL, 0)) == -1 && errno == EINTR);
while((flags = fcntl(_sockfd, F_GETFL, 0)) == -1 && errno == EINTR);
// TODO add error handling
while(fcntl(sockfd, F_SETFL, flags|O_NONBLOCK) == -1 && errno == EINTR);
while(fcntl(_sockfd, F_SETFL, flags|O_NONBLOCK) == -1 && errno == EINTR);
#endif // __MINGW32__
blocking = false;
_blocking = false;
}
void SocketCore::setBlockingMode()
{
#ifdef __MINGW32__
static u_long flag = 0;
if (::ioctlsocket(sockfd, FIONBIO, &flag) == -1) {
if (::ioctlsocket(_sockfd, FIONBIO, &flag) == -1) {
throw DL_ABORT_EX(StringFormat(EX_SOCKET_BLOCKING, errorMsg()).str());
}
#else
int flags;
while((flags = fcntl(sockfd, F_GETFL, 0)) == -1 && errno == EINTR);
while((flags = fcntl(_sockfd, F_GETFL, 0)) == -1 && errno == EINTR);
// TODO add error handling
while(fcntl(sockfd, F_SETFL, flags&(~O_NONBLOCK)) == -1 && errno == EINTR);
while(fcntl(_sockfd, F_SETFL, flags&(~O_NONBLOCK)) == -1 && errno == EINTR);
#endif // __MINGW32__
blocking = true;
_blocking = true;
}
void SocketCore::closeConnection()
{
#ifdef HAVE_LIBSSL
// for SSL
if(secure) {
if(_secure) {
SSL_shutdown(ssl);
}
#endif // HAVE_LIBSSL
#ifdef HAVE_LIBGNUTLS
if(secure) {
gnutls_bye(sslSession, GNUTLS_SHUT_RDWR);
if(_secure) {
gnutls_bye(_sslSession, GNUTLS_SHUT_RDWR);
}
#endif // HAVE_LIBGNUTLS
if(sockfd != (sock_t) -1) {
CLOSE(sockfd);
sockfd = -1;
if(_sockfd != (sock_t) -1) {
CLOSE(_sockfd);
_sockfd = -1;
}
#ifdef HAVE_LIBSSL
// for SSL
if(secure) {
if(_secure) {
SSL_free(ssl);
}
#endif // HAVE_LIBSSL
#ifdef HAVE_LIBGNUTLS
if(secure) {
gnutls_deinit(sslSession);
if(_secure) {
gnutls_deinit(_sslSession);
}
#endif // HAVE_LIBGNUTLS
}
@ -559,7 +559,7 @@ bool SocketCore::isWritable(time_t timeout)
{
#ifdef HAVE_POLL
struct pollfd p;
p.fd = sockfd;
p.fd = _sockfd;
p.events = POLLOUT;
int r;
while((r = poll(&p, 1, timeout*1000)) == -1 && errno == EINTR);
@ -573,17 +573,17 @@ bool SocketCore::isWritable(time_t timeout)
}
#else // !HAVE_POLL
# ifndef __MINGW32__
CHECK_FD(sockfd);
CHECK_FD(_sockfd);
# endif // !__MINGW32__
fd_set fds;
FD_ZERO(&fds);
FD_SET(sockfd, &fds);
FD_SET(_sockfd, &fds);
struct timeval tv;
tv.tv_sec = timeout;
tv.tv_usec = 0;
int r = select(sockfd+1, NULL, &fds, NULL, &tv);
int r = select(_sockfd+1, NULL, &fds, NULL, &tv);
if(r == 1) {
return true;
} else if(r == 0) {
@ -603,13 +603,13 @@ bool SocketCore::isWritable(time_t timeout)
bool SocketCore::isReadable(time_t timeout)
{
#ifdef HAVE_LIBGNUTLS
if(secure && peekBufLength > 0) {
if(_secure && _peekBufLength > 0) {
return true;
}
#endif // HAVE_LIBGNUTLS
#ifdef HAVE_POLL
struct pollfd p;
p.fd = sockfd;
p.fd = _sockfd;
p.events = POLLIN;
int r;
while((r = poll(&p, 1, timeout*1000)) == -1 && errno == EINTR);
@ -623,17 +623,17 @@ bool SocketCore::isReadable(time_t timeout)
}
#else // !HAVE_POLL
# ifndef __MINGW32__
CHECK_FD(sockfd);
CHECK_FD(_sockfd);
# endif // !__MINGW32__
fd_set fds;
FD_ZERO(&fds);
FD_SET(sockfd, &fds);
FD_SET(_sockfd, &fds);
struct timeval tv;
tv.tv_sec = timeout;
tv.tv_usec = 0;
int r = select(sockfd+1, &fds, NULL, NULL, &tv);
int r = select(_sockfd+1, &fds, NULL, NULL, &tv);
if(r == 1) {
return true;
} else if(r == 0) {
@ -669,7 +669,7 @@ int SocketCore::sslHandleEAGAIN(int ret)
#ifdef HAVE_LIBGNUTLS
void SocketCore::gnutlsRecordCheckDirection()
{
int direction = gnutls_record_get_direction(sslSession);
int direction = gnutls_record_get_direction(_sslSession);
if(direction == 0) {
_wantRead = true;
} else { // if(direction == 1) {
@ -684,8 +684,8 @@ ssize_t SocketCore::writeData(const char* data, size_t len)
_wantRead = false;
_wantWrite = false;
if(!secure) {
while((ret = send(sockfd, data, len, 0)) == -1 && SOCKET_ERRNO == A2_EINTR);
if(!_secure) {
while((ret = send(_sockfd, data, len, 0)) == -1 && SOCKET_ERRNO == A2_EINTR);
if(ret == -1) {
if(A2_WOULDBLOCK(SOCKET_ERRNO)) {
_wantWrite = true;
@ -707,7 +707,7 @@ ssize_t SocketCore::writeData(const char* data, size_t len)
}
#endif // HAVE_LIBSSL
#ifdef HAVE_LIBGNUTLS
while((ret = gnutls_record_send(sslSession, data, len)) ==
while((ret = gnutls_record_send(_sslSession, data, len)) ==
GNUTLS_E_INTERRUPTED);
if(ret == GNUTLS_E_AGAIN) {
gnutlsRecordCheckDirection();
@ -727,8 +727,8 @@ void SocketCore::readData(char* data, size_t& len)
_wantRead = false;
_wantWrite = false;
if(!secure) {
while((ret = recv(sockfd, data, len, 0)) == -1 && SOCKET_ERRNO == A2_EINTR);
if(!_secure) {
while((ret = recv(_sockfd, data, len, 0)) == -1 && SOCKET_ERRNO == A2_EINTR);
if(ret == -1) {
if(A2_WOULDBLOCK(SOCKET_ERRNO)) {
@ -773,8 +773,8 @@ void SocketCore::peekData(char* data, size_t& len)
_wantRead = false;
_wantWrite = false;
if(!secure) {
while((ret = recv(sockfd, data, len, MSG_PEEK)) == -1 &&
if(!_secure) {
while((ret = recv(_sockfd, data, len, MSG_PEEK)) == -1 &&
SOCKET_ERRNO == A2_EINTR);
if(ret == -1) {
if(A2_WOULDBLOCK(SOCKET_ERRNO)) {
@ -816,18 +816,15 @@ void SocketCore::peekData(char* data, size_t& len)
#ifdef HAVE_LIBGNUTLS
size_t SocketCore::shiftPeekData(char* data, size_t len)
{
if(peekBufLength <= len) {
memcpy(data, peekBuf, peekBufLength);
size_t ret = peekBufLength;
peekBufLength = 0;
if(_peekBufLength <= len) {
memcpy(data, _peekBuf, _peekBufLength);
size_t ret = _peekBufLength;
_peekBufLength = 0;
return ret;
} else {
memcpy(data, peekBuf, len);
char* temp = new char[peekBufMax];
memcpy(temp, peekBuf+len, peekBufLength-len);
delete [] peekBuf;
peekBuf = temp;
peekBufLength -= len;
memcpy(data, _peekBuf, len);
_peekBufLength -= len;
memmove(_peekBuf, _peekBuf+len, _peekBufLength);
return len;
}
@ -835,15 +832,15 @@ size_t SocketCore::shiftPeekData(char* data, size_t len)
void SocketCore::addPeekData(char* data, size_t len)
{
if(peekBufLength+len > peekBufMax) {
char* temp = new char[peekBufMax+len];
memcpy(temp, peekBuf, peekBufLength);
delete [] peekBuf;
peekBuf = temp;
peekBufMax = peekBufLength+len;
if(_peekBufLength+len > _peekBufMax) {
char* temp = new char[_peekBufMax+len];
memcpy(temp, _peekBuf, _peekBufLength);
delete [] _peekBuf;
_peekBuf = temp;
_peekBufMax = _peekBufLength+len;
}
memcpy(peekBuf+peekBufLength, data, len);
peekBufLength += len;
memcpy(_peekBuf+_peekBufLength, data, len);
_peekBufLength += len;
}
static ssize_t GNUTLS_RECORD_RECV_NO_INTERRUPT
@ -864,7 +861,7 @@ ssize_t SocketCore::gnutlsRecv(char* data, size_t len)
size_t plen = shiftPeekData(data, len);
if(plen < len) {
ssize_t ret = GNUTLS_RECORD_RECV_NO_INTERRUPT
(sslSession, data+plen, len-plen);
(_sslSession, data+plen, len-plen);
if(ret == GNUTLS_E_AGAIN) {
return GNUTLS_E_AGAIN;
}
@ -876,25 +873,25 @@ ssize_t SocketCore::gnutlsRecv(char* data, size_t len)
ssize_t SocketCore::gnutlsPeek(char* data, size_t len)
{
if(peekBufLength >= len) {
memcpy(data, peekBuf, len);
if(_peekBufLength >= len) {
memcpy(data, _peekBuf, len);
return len;
} else {
memcpy(data, peekBuf, peekBufLength);
memcpy(data, _peekBuf, _peekBufLength);
ssize_t ret = GNUTLS_RECORD_RECV_NO_INTERRUPT
(sslSession, data+peekBufLength, len-peekBufLength);
(_sslSession, data+_peekBufLength, len-_peekBufLength);
if(ret == GNUTLS_E_AGAIN) {
return GNUTLS_E_AGAIN;
}
addPeekData(data+peekBufLength, ret);
return peekBufLength;
addPeekData(data+_peekBufLength, ret);
return _peekBufLength;
}
}
#endif // HAVE_LIBGNUTLS
void SocketCore::prepareSecureConnection()
{
if(!secure) {
if(!_secure) {
#ifdef HAVE_LIBSSL
// for SSL
ssl = SSL_new(_tlsContext->getSSLCtx());
@ -903,7 +900,7 @@ void SocketCore::prepareSecureConnection()
(StringFormat(EX_SSL_INIT_FAILURE,
ERR_error_string(ERR_get_error(), 0)).str());
}
if(SSL_set_fd(ssl, sockfd) == 0) {
if(SSL_set_fd(ssl, _sockfd) == 0) {
throw DL_ABORT_EX
(StringFormat(EX_SSL_INIT_FAILURE,
ERR_error_string(ERR_get_error(), 0)).str());
@ -911,29 +908,29 @@ void SocketCore::prepareSecureConnection()
#endif // HAVE_LIBSSL
#ifdef HAVE_LIBGNUTLS
int r;
gnutls_init(&sslSession, GNUTLS_CLIENT);
gnutls_init(&_sslSession, GNUTLS_CLIENT);
// It seems err is not error message, but the argument string
// which causes syntax error.
const char* err;
// Disables TLS1.1 here because there are servers that don't
// understand TLS1.1.
r = gnutls_priority_set_direct(sslSession, "NORMAL:!VERS-TLS1.1", &err);
r = gnutls_priority_set_direct(_sslSession, "NORMAL:!VERS-TLS1.1", &err);
if(r != GNUTLS_E_SUCCESS) {
throw DL_ABORT_EX
(StringFormat(EX_SSL_INIT_FAILURE, gnutls_strerror(r)).str());
}
// put the x509 credentials to the current session
gnutls_credentials_set(sslSession, GNUTLS_CRD_CERTIFICATE,
gnutls_credentials_set(_sslSession, GNUTLS_CRD_CERTIFICATE,
_tlsContext->getCertCred());
gnutls_transport_set_ptr(sslSession, (gnutls_transport_ptr_t)sockfd);
gnutls_transport_set_ptr(_sslSession, (gnutls_transport_ptr_t)_sockfd);
#endif // HAVE_LIBGNUTLS
secure = 1;
_secure = 1;
}
}
bool SocketCore::initiateSecureConnection(const std::string& hostname)
{
if(secure == 1) {
if(_secure == 1) {
_wantRead = false;
_wantWrite = false;
#ifdef HAVE_LIBSSL
@ -953,7 +950,7 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
return false;
case SSL_ERROR_WANT_X509_LOOKUP:
case SSL_ERROR_ZERO_RETURN:
if (blocking) {
if (_blocking) {
throw DL_ABORT_EX
(StringFormat(EX_SSL_CONNECT_ERROR, ssl_error).str());
}
@ -1015,7 +1012,7 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
}
#endif // HAVE_LIBSSL
#ifdef HAVE_LIBGNUTLS
int ret = gnutls_handshake(sslSession);
int ret = gnutls_handshake(_sslSession);
if(ret == GNUTLS_E_AGAIN) {
gnutlsRecordCheckDirection();
return false;
@ -1027,7 +1024,7 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
if(_tlsContext->peerVerificationEnabled()) {
// verify peer
unsigned int status;
ret = gnutls_certificate_verify_peers2(sslSession, &status);
ret = gnutls_certificate_verify_peers2(_sslSession, &status);
if(ret < 0) {
throw DL_ABORT_EX
(StringFormat("gnutls_certificate_verify_peer2() failed. Cause: %s",
@ -1050,13 +1047,13 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
}
}
// certificate type: only X509 is allowed.
if(gnutls_certificate_type_get(sslSession) != GNUTLS_CRT_X509) {
if(gnutls_certificate_type_get(_sslSession) != GNUTLS_CRT_X509) {
throw DL_ABORT_EX("Certificate type is not X509.");
}
unsigned int peerCertsLength;
const gnutls_datum_t* peerCerts = gnutls_certificate_get_peers
(sslSession, &peerCertsLength);
(_sslSession, &peerCertsLength);
if(!peerCerts) {
throw DL_ABORT_EX(MSG_NO_CERT_FOUND);
}
@ -1098,9 +1095,9 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
}
}
}
peekBuf = new char[peekBufMax];
_peekBuf = new char[_peekBufMax];
#endif // HAVE_LIBGNUTLS
secure = 2;
_secure = 2;
return true;
} else {
return true;
@ -1124,7 +1121,7 @@ ssize_t SocketCore::writeData(const char* data, size_t len,
struct addrinfo* rp;
ssize_t r = -1;
for(rp = res; rp; rp = rp->ai_next) {
while((r = sendto(sockfd, data, len, 0, rp->ai_addr, rp->ai_addrlen)) == -1
while((r = sendto(_sockfd, data, len, 0, rp->ai_addr, rp->ai_addrlen)) == -1
&& A2_EINTR == SOCKET_ERRNO);
if(r == static_cast<ssize_t>(len)) {
break;
@ -1151,7 +1148,7 @@ ssize_t SocketCore::readDataFrom(char* data, size_t len,
socklen_t sockaddrlen = sizeof(struct sockaddr_storage);
struct sockaddr* addrp = reinterpret_cast<struct sockaddr*>(&sockaddr);
ssize_t r;
while((r = recvfrom(sockfd, data, len, 0, addrp, &sockaddrlen)) == -1 &&
while((r = recvfrom(_sockfd, data, len, 0, addrp, &sockaddrlen)) == -1 &&
A2_EINTR == SOCKET_ERRNO);
if(r == -1) {
if(A2_WOULDBLOCK(SOCKET_ERRNO)) {
@ -1172,7 +1169,7 @@ std::string SocketCore::getSocketError() const
int error;
socklen_t optlen = sizeof(error);
if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, (a2_sockopt_t) &error, &optlen) == -1) {
if(getsockopt(_sockfd, SOL_SOCKET, SO_ERROR, (a2_sockopt_t) &error, &optlen) == -1) {
throw DL_ABORT_EX(StringFormat("Failed to get socket error: %s",
errorMsg()).str());
}

22
src/SocketCore.h
View File

@ -72,14 +72,14 @@ private:
// socket type defined in <sys/socket.h>
int _sockType;
// socket endpoint descriptor
sock_t sockfd;
sock_t _sockfd;
static int _protocolFamily;
static std::vector<std::pair<struct sockaddr_storage, socklen_t> > _bindAddrs;
bool blocking;
int secure;
bool _blocking;
int _secure;
bool _wantRead;
bool _wantWrite;
@ -95,10 +95,10 @@ private:
int sslHandleEAGAIN(int ret);
#endif // HAVE_LIBSSL
#ifdef HAVE_LIBGNUTLS
gnutls_session_t sslSession;
char* peekBuf;
size_t peekBufLength;
size_t peekBufMax;
gnutls_session_t _sslSession;
char* _peekBuf;
size_t _peekBufLength;
size_t _peekBufMax;
size_t shiftPeekData(char* data, size_t len);
void addPeekData(char* data, size_t len);
@ -119,9 +119,9 @@ public:
SocketCore(int sockType = SOCK_STREAM);
~SocketCore();
sock_t getSockfd() const { return sockfd; }
sock_t getSockfd() const { return _sockfd; }
bool isOpen() const { return sockfd != (sock_t) -1; }
bool isOpen() const { return _sockfd != (sock_t) -1; }
void setMulticastInterface(const std::string& localAddr);
@ -306,7 +306,7 @@ public:
void prepareSecureConnection();
bool operator==(const SocketCore& s) {
return sockfd == s.sockfd;
return _sockfd == s._sockfd;
}
bool operator!=(const SocketCore& s) {
@ -314,7 +314,7 @@ public:
}
bool operator<(const SocketCore& s) {
return sockfd < s.sockfd;
return _sockfd < s._sockfd;
}
std::string getSocketError() const;