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

	Renamed member variables.
	* src/PeerConnection.cc
	* src/PeerConnection.h

1 files changed, 66 insertions, 64 deletions

diff --git a/src/PeerConnection.cc b/src/PeerConnection.cc
index c66ba9ab..16b4f8ec 100644
--- a/src/PeerConnection.cc
+++ b/src/PeerConnection.cc
@@ -54,13 +54,13 @@ namespace aria2 {
 
 PeerConnection::PeerConnection(cuid_t cuid, const SocketHandle& socket)
 
-  :cuid(cuid),
-   socket(socket),
-   logger(LogFactory::getInstance()),
-   resbuf(new unsigned char[MAX_PAYLOAD_LEN]),
-   resbufLength(0),
-   currentPayloadLength(0),
-   lenbufLength(0),
+  :_cuid(cuid),
+   _socket(socket),
+   _logger(LogFactory::getInstance()),
+   _resbuf(new unsigned char[MAX_PAYLOAD_LEN]),
+   _resbufLength(0),
+   _currentPayloadLength(0),
+   _lenbufLength(0),
    _socketBuffer(socket),
    _encryptionEnabled(false),
    _prevPeek(false)
@@ -68,7 +68,7 @@ PeerConnection::PeerConnection(cuid_t cuid, const SocketHandle& socket)
 
 PeerConnection::~PeerConnection()
 {
-  delete [] resbuf;
+  delete [] _resbuf;
 }
 
 void PeerConnection::pushStr(const std::string& data)
@@ -108,141 +108,143 @@ void PeerConnection::pushBytes(unsigned char* data, size_t len)
 }
 
 bool PeerConnection::receiveMessage(unsigned char* data, size_t& dataLength) {
-  if(resbufLength == 0 && 4 > lenbufLength) {
-    if(!socket->isReadable(0)) {
+  if(_resbufLength == 0 && 4 > _lenbufLength) {
+    if(!_socket->isReadable(0)) {
       return false;
     }
     // read payload size, 32bit unsigned integer
-    size_t remaining = 4-lenbufLength;
+    size_t remaining = 4-_lenbufLength;
     size_t temp = remaining;
-    readData(lenbuf+lenbufLength, remaining, _encryptionEnabled);
+    readData(_lenbuf+_lenbufLength, remaining, _encryptionEnabled);
     if(remaining == 0) {
-      if(socket->wantRead() || socket->wantWrite()) {
+      if(_socket->wantRead() || _socket->wantWrite()) {
         return false;
       }
       // we got EOF
-      if(logger->debug()) {
-        logger->debug("CUID#%s - In PeerConnection::receiveMessage(),"
-                      " remain=%lu",
-                      util::itos(cuid).c_str(),
-                      static_cast<unsigned long>(temp));
+      if(_logger->debug()) {
+        _logger->debug("CUID#%s - In PeerConnection::receiveMessage(),"
+                       " remain=%lu",
+                       util::itos(_cuid).c_str(),
+                       static_cast<unsigned long>(temp));
       }
       throw DL_ABORT_EX(EX_EOF_FROM_PEER);
     }
-    lenbufLength += remaining;
-    if(4 > lenbufLength) {
-      // still 4-lenbufLength bytes to go
+    _lenbufLength += remaining;
+    if(4 > _lenbufLength) {
+      // still 4-_lenbufLength bytes to go
       return false;
     }
     uint32_t payloadLength;
-    memcpy(&payloadLength, lenbuf, sizeof(payloadLength));
+    memcpy(&payloadLength, _lenbuf, sizeof(payloadLength));
     payloadLength = ntohl(payloadLength);
     if(payloadLength > MAX_PAYLOAD_LEN) {
       throw DL_ABORT_EX(StringFormat(EX_TOO_LONG_PAYLOAD, payloadLength).str());
     }
-    currentPayloadLength = payloadLength;
+    _currentPayloadLength = payloadLength;
   }
-  if(!socket->isReadable(0)) {
+  if(!_socket->isReadable(0)) {
     return false;
   }
   // we have currentPayloadLen-resbufLen bytes to read
-  size_t remaining = currentPayloadLength-resbufLength;
+  size_t remaining = _currentPayloadLength-_resbufLength;
   size_t temp = remaining;
   if(remaining > 0) {
-    readData(resbuf+resbufLength, remaining, _encryptionEnabled);
+    readData(_resbuf+_resbufLength, remaining, _encryptionEnabled);
     if(remaining == 0) {
-      if(socket->wantRead() || socket->wantWrite()) {
+      if(_socket->wantRead() || _socket->wantWrite()) {
         return false;
       }
       // we got EOF
-      if(logger->debug()) {
-        logger->debug("CUID#%s - In PeerConnection::receiveMessage(),"
-                      " payloadlen=%lu, remaining=%lu",
-                      util::itos(cuid).c_str(),
-                      static_cast<unsigned long>(currentPayloadLength),
-                      static_cast<unsigned long>(temp));
+      if(_logger->debug()) {
+        _logger->debug("CUID#%s - In PeerConnection::receiveMessage(),"
+                       " payloadlen=%lu, remaining=%lu",
+                       util::itos(_cuid).c_str(),
+                       static_cast<unsigned long>(_currentPayloadLength),
+                       static_cast<unsigned long>(temp));
       }
       throw DL_ABORT_EX(EX_EOF_FROM_PEER);
     }
-    resbufLength += remaining;
-    if(currentPayloadLength > resbufLength) {
+    _resbufLength += remaining;
+    if(_currentPayloadLength > _resbufLength) {
       return false;
     }
   }
   // we got whole payload.
-  resbufLength = 0;
-  lenbufLength = 0;
+  _resbufLength = 0;
+  _lenbufLength = 0;
   if(data) {
-    memcpy(data, resbuf, currentPayloadLength);
+    memcpy(data, _resbuf, _currentPayloadLength);
   }
-  dataLength = currentPayloadLength;
+  dataLength = _currentPayloadLength;
   return true;
 }
 
 bool PeerConnection::receiveHandshake(unsigned char* data, size_t& dataLength,
                                       bool peek) {
-  assert(BtHandshakeMessage::MESSAGE_LENGTH >= resbufLength);
+  assert(BtHandshakeMessage::MESSAGE_LENGTH >= _resbufLength);
   bool retval = true;
-  if(_prevPeek && !peek && resbufLength) {
+  if(_prevPeek && !peek && _resbufLength) {
     // We have data in previous peek.
     // There is a chance that socket is readable because of EOF, for example,
     // official bttrack shutdowns socket after sending first 48 bytes of
     // handshake in its NAT checking.
-    // So if there are data in resbuf, return it without checking socket
+    // So if there are data in _resbuf, return it without checking socket
     // status.
     _prevPeek = false;
-    retval = BtHandshakeMessage::MESSAGE_LENGTH <= resbufLength;
+    retval = BtHandshakeMessage::MESSAGE_LENGTH <= _resbufLength;
   } else {
     _prevPeek = peek;
-    size_t remaining = BtHandshakeMessage::MESSAGE_LENGTH-resbufLength;
-    if(remaining > 0 && !socket->isReadable(0)) {
+    size_t remaining = BtHandshakeMessage::MESSAGE_LENGTH-_resbufLength;
+    if(remaining > 0 && !_socket->isReadable(0)) {
       dataLength = 0;
       return false;
     }
     if(remaining > 0) {
       size_t temp = remaining;
-      readData(resbuf+resbufLength, remaining, _encryptionEnabled);
+      readData(_resbuf+_resbufLength, remaining, _encryptionEnabled);
       if(remaining == 0) {
-        if(socket->wantRead() || socket->wantWrite()) {
+        if(_socket->wantRead() || _socket->wantWrite()) {
           return false;
         }
         // we got EOF
-        if(logger->debug()) {
-          logger->debug
+        if(_logger->debug()) {
+          _logger->debug
             ("CUID#%s - In PeerConnection::receiveHandshake(), remain=%lu",
-             util::itos(cuid).c_str(), static_cast<unsigned long>(temp));
+             util::itos(_cuid).c_str(), static_cast<unsigned long>(temp));
         }
         throw DL_ABORT_EX(EX_EOF_FROM_PEER);
       }
-      resbufLength += remaining;
-      if(BtHandshakeMessage::MESSAGE_LENGTH > resbufLength) {
+      _resbufLength += remaining;
+      if(BtHandshakeMessage::MESSAGE_LENGTH > _resbufLength) {
         retval = false;
       }
     }
   }
-  size_t writeLength = std::min(resbufLength, dataLength);
-  memcpy(data, resbuf, writeLength);
+  size_t writeLength = std::min(_resbufLength, dataLength);
+  memcpy(data, _resbuf, writeLength);
   dataLength = writeLength;
   if(retval && !peek) {
-    resbufLength = 0;
+    _resbufLength = 0;
   }
   return retval;
 }
 
-void PeerConnection::readData(unsigned char* data, size_t& length, bool encryption)
+void PeerConnection::readData
+(unsigned char* data, size_t& length, bool encryption)
 {
   if(encryption) {
     unsigned char temp[MAX_PAYLOAD_LEN];
     assert(MAX_PAYLOAD_LEN >= length);
-    socket->readData(temp, length);
+    _socket->readData(temp, length);
     _decryptor->decrypt(data, length, temp, length);
   } else {
-    socket->readData(data, length);
+    _socket->readData(data, length);
   }
 }
 
-void PeerConnection::enableEncryption(const SharedHandle<ARC4Encryptor>& encryptor,
-                                      const SharedHandle<ARC4Decryptor>& decryptor)
+void PeerConnection::enableEncryption
+(const SharedHandle<ARC4Encryptor>& encryptor,
+ const SharedHandle<ARC4Decryptor>& decryptor)
 {
   _encryptor = encryptor;
   _decryptor = decryptor;
@@ -253,8 +255,8 @@ void PeerConnection::enableEncryption(const SharedHandle<ARC4Encryptor>& encrypt
 void PeerConnection::presetBuffer(const unsigned char* data, size_t length)
 {
   size_t nwrite = std::min((size_t)MAX_PAYLOAD_LEN, length);
-  memcpy(resbuf, data, nwrite);
-  resbufLength = length;
+  memcpy(_resbuf, data, nwrite);
+  _resbufLength = length;
 }
 
 bool PeerConnection::sendBufferIsEmpty() const
@@ -265,8 +267,8 @@ bool PeerConnection::sendBufferIsEmpty() const
 ssize_t PeerConnection::sendPendingData()
 {
   ssize_t writtenLength = _socketBuffer.send();
-  if(logger->debug()) {
-    logger->debug("sent %d byte(s).", writtenLength);
+  if(_logger->debug()) {
+    _logger->debug("sent %d byte(s).", writtenLength);
   }
   return writtenLength;
 }