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

Removed SocketCore::peekData()

pull/1/head
Tatsuhiro Tsujikawa 2011-01-16 17:41:17 +09:00
parent 629099d40d
commit e60181d1ad
2 changed files with 2 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

136
src/SocketCore.cc
View File

@ -158,17 +158,11 @@ void SocketCore::init()
#endif // HAVE_LIBSSL
#ifdef HAVE_LIBGNUTLS
sslSession_ = 0;
peekBufMax_ = 4096;
peekBuf_ = 0;
peekBufLength_ = 0;
#endif //HAVE_LIBGNUTLS
}
SocketCore::~SocketCore() {
closeConnection();
#ifdef HAVE_LIBGNUTLS
delete [] peekBuf_;
#endif // HAVE_LIBGNUTLS
}
void SocketCore::create(int family, int protocol)
@ -646,11 +640,6 @@ bool SocketCore::isWritable(time_t timeout)
bool SocketCore::isReadable(time_t timeout)
{
#ifdef HAVE_LIBGNUTLS
if(secure_ && peekBufLength_ > 0) {
return true;
}
#endif // HAVE_LIBGNUTLS
#ifdef HAVE_POLL
struct pollfd p;
p.fd = sockfd_;
@ -801,7 +790,8 @@ void SocketCore::readData(char* data, size_t& len)
}
#endif // HAVE_LIBSSL
#ifdef HAVE_LIBGNUTLS
ret = gnutlsRecv(data, len);
while((ret = gnutls_record_recv(sslSession_, data, len)) ==
GNUTLS_E_INTERRUPTED);
if(ret == GNUTLS_E_AGAIN) {
gnutlsRecordCheckDirection();
ret = 0;
@ -814,127 +804,6 @@ void SocketCore::readData(char* data, size_t& len)
len = ret;
}
void SocketCore::peekData(char* data, size_t& len)
{
ssize_t ret = 0;
wantRead_ = false;
wantWrite_ = false;
if(!secure_) {
while((ret = recv(sockfd_, data, len, MSG_PEEK)) == -1 &&
SOCKET_ERRNO == A2_EINTR);
int errNum = SOCKET_ERRNO;
if(ret == -1) {
if(A2_WOULDBLOCK(errNum)) {
wantRead_ = true;
ret = 0;
} else {
throw DL_RETRY_EX(fmt(EX_SOCKET_PEEK, errorMsg(errNum).c_str()));
}
}
} else {
#ifdef HAVE_LIBSSL
// for SSL
// TODO handling len == 0 case required
ret = SSL_peek(ssl, data, len);
if(ret < 0) {
ret = sslHandleEAGAIN(ret);
}
if(ret < 0) {
throw DL_RETRY_EX
(fmt(EX_SOCKET_PEEK,
ERR_error_string(SSL_get_error(ssl, ret), 0)));
}
#endif // HAVE_LIBSSL
#ifdef HAVE_LIBGNUTLS
ret = gnutlsPeek(data, len);
if(ret == GNUTLS_E_AGAIN) {
gnutlsRecordCheckDirection();
ret = 0;
} else if(ret < 0) {
throw DL_RETRY_EX(fmt(EX_SOCKET_PEEK, gnutls_strerror(ret)));
}
#endif // HAVE_LIBGNUTLS
}
len = ret;
}
#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;
return ret;
} else {
memcpy(data, peekBuf_, len);
peekBufLength_ -= len;
memmove(peekBuf_, peekBuf_+len, peekBufLength_);
return 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;
}
memcpy(peekBuf_+peekBufLength_, data, len);
peekBufLength_ += len;
}
static ssize_t GNUTLS_RECORD_RECV_NO_INTERRUPT
(gnutls_session_t sslSession, char* data, size_t len)
{
int ret;
while((ret = gnutls_record_recv(sslSession, data, len)) ==
GNUTLS_E_INTERRUPTED);
if(ret < 0 && ret != GNUTLS_E_AGAIN) {
throw DL_RETRY_EX(fmt(EX_SOCKET_RECV, gnutls_strerror(ret)));
}
return ret;
}
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);
if(ret == GNUTLS_E_AGAIN) {
return GNUTLS_E_AGAIN;
}
return plen+ret;
} else {
return plen;
}
}
ssize_t SocketCore::gnutlsPeek(char* data, size_t len)
{
if(peekBufLength_ >= len) {
memcpy(data, peekBuf_, len);
return len;
} else {
memcpy(data, peekBuf_, peekBufLength_);
ssize_t ret = GNUTLS_RECORD_RECV_NO_INTERRUPT
(sslSession_, data+peekBufLength_, len-peekBufLength_);
if(ret == GNUTLS_E_AGAIN) {
return GNUTLS_E_AGAIN;
}
addPeekData(data+peekBufLength_, ret);
return peekBufLength_;
}
}
#endif // HAVE_LIBGNUTLS
void SocketCore::prepareSecureConnection()
{
if(!secure_) {
@ -1136,7 +1005,6 @@ bool SocketCore::initiateSecureConnection(const std::string& hostname)
}
}
}
peekBuf_ = new char[peekBufMax_];
#endif // HAVE_LIBGNUTLS
secure_ = 2;
return true;

24
src/SocketCore.h
View File

@ -96,14 +96,6 @@ private:
#endif // HAVE_LIBSSL
#ifdef HAVE_LIBGNUTLS
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);
ssize_t gnutlsRecv(char* data, size_t len);
ssize_t gnutlsPeek(char* data, size_t len);
void gnutlsRecordCheckDirection();
#endif // HAVE_LIBGNUTLS
@ -294,22 +286,6 @@ public:
return readDataFrom(reinterpret_cast<char*>(data), len, sender);
}
/**
* Reads up to len bytes from this socket, but bytes are not removed from
* this socket.
* This method internally calls isReadable(). The parameter timeout is used
* for this method call.
* @param data holder to store data.
* @param len the maximum size data can store. This method assigns
* the number of bytes read to len.
*/
void peekData(char* data, size_t& len);
void peekData(unsigned char* data, size_t& len)
{
peekData(reinterpret_cast<char*>(data), len);
}
/**
* Makes this socket secure.
* If the system has not OpenSSL, then this method do nothing.