Browse Source

Correct indentation and remove unnecessary braces

0.15
Matthias Grundmann 8 years ago
parent
commit
31a14d4909
No known key found for this signature in database
GPG Key ID: 92E5A54A5A822119
  1. 98
      src/net.cpp
  2. 6
      src/net.h
  3. 158
      src/net_processing.cpp

98
src/net.cpp

@ -708,7 +708,7 @@ bool CNode::ReceiveMsgBytes(const char *pch, unsigned int nBytes, bool& complete
handled = msg.readData(pch, nBytes); handled = msg.readData(pch, nBytes);
if (handled < 0) if (handled < 0)
return false; return false;
if (msg.in_data && msg.hdr.nMessageSize > MAX_PROTOCOL_MESSAGE_LENGTH) { if (msg.in_data && msg.hdr.nMessageSize > MAX_PROTOCOL_MESSAGE_LENGTH) {
LogPrint(BCLog::NET, "Oversized message from peer=%i, disconnecting\n", GetId()); LogPrint(BCLog::NET, "Oversized message from peer=%i, disconnecting\n", GetId());
@ -786,7 +786,7 @@ int CNetMessage::readHeader(const char *pch, unsigned int nBytes)
// reject messages larger than MAX_SIZE // reject messages larger than MAX_SIZE
if (hdr.nMessageSize > MAX_SIZE) if (hdr.nMessageSize > MAX_SIZE)
return -1; return -1;
// switch state to reading message data // switch state to reading message data
in_data = true; in_data = true;
@ -1299,59 +1299,55 @@ void CConnman::ThreadSocketHandler()
} }
if (recvSet || errorSet) if (recvSet || errorSet)
{ {
// typical socket buffer is 8K-64K
char pchBuf[0x10000];
int nBytes = 0;
{ {
{ LOCK(pnode->cs_hSocket);
// typical socket buffer is 8K-64K if (pnode->hSocket == INVALID_SOCKET)
char pchBuf[0x10000]; continue;
int nBytes = 0; nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
{ }
LOCK(pnode->cs_hSocket); if (nBytes > 0)
if (pnode->hSocket == INVALID_SOCKET) {
continue; bool notify = false;
nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT); if (!pnode->ReceiveMsgBytes(pchBuf, nBytes, notify))
} pnode->CloseSocketDisconnect();
if (nBytes > 0) RecordBytesRecv(nBytes);
{ if (notify) {
bool notify = false; size_t nSizeAdded = 0;
if (!pnode->ReceiveMsgBytes(pchBuf, nBytes, notify)) auto it(pnode->vRecvMsg.begin());
pnode->CloseSocketDisconnect(); for (; it != pnode->vRecvMsg.end(); ++it) {
RecordBytesRecv(nBytes); if (!it->complete())
if (notify) { break;
size_t nSizeAdded = 0; nSizeAdded += it->vRecv.size() + CMessageHeader::HEADER_SIZE;
auto it(pnode->vRecvMsg.begin());
for (; it != pnode->vRecvMsg.end(); ++it) {
if (!it->complete())
break;
nSizeAdded += it->vRecv.size() + CMessageHeader::HEADER_SIZE;
}
{
LOCK(pnode->cs_vProcessMsg);
pnode->vProcessMsg.splice(pnode->vProcessMsg.end(), pnode->vRecvMsg, pnode->vRecvMsg.begin(), it);
pnode->nProcessQueueSize += nSizeAdded;
pnode->fPauseRecv = pnode->nProcessQueueSize > nReceiveFloodSize;
}
WakeMessageHandler();
}
}
else if (nBytes == 0)
{
// socket closed gracefully
if (!pnode->fDisconnect) {
LogPrint(BCLog::NET, "socket closed\n");
}
pnode->CloseSocketDisconnect();
} }
else if (nBytes < 0)
{ {
// error LOCK(pnode->cs_vProcessMsg);
int nErr = WSAGetLastError(); pnode->vProcessMsg.splice(pnode->vProcessMsg.end(), pnode->vRecvMsg, pnode->vRecvMsg.begin(), it);
if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS) pnode->nProcessQueueSize += nSizeAdded;
{ pnode->fPauseRecv = pnode->nProcessQueueSize > nReceiveFloodSize;
if (!pnode->fDisconnect)
LogPrintf("socket recv error %s\n", NetworkErrorString(nErr));
pnode->CloseSocketDisconnect();
}
} }
WakeMessageHandler();
}
}
else if (nBytes == 0)
{
// socket closed gracefully
if (!pnode->fDisconnect) {
LogPrint(BCLog::NET, "socket closed\n");
}
pnode->CloseSocketDisconnect();
}
else if (nBytes < 0)
{
// error
int nErr = WSAGetLastError();
if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
{
if (!pnode->fDisconnect)
LogPrintf("socket recv error %s\n", NetworkErrorString(nErr));
pnode->CloseSocketDisconnect();
} }
} }
} }

6
src/net.h

@ -701,15 +701,15 @@ private:
public: public:
NodeId GetId() const { NodeId GetId() const {
return id; return id;
} }
uint64_t GetLocalNonce() const { uint64_t GetLocalNonce() const {
return nLocalHostNonce; return nLocalHostNonce;
} }
int GetMyStartingHeight() const { int GetMyStartingHeight() const {
return nMyStartingHeight; return nMyStartingHeight;
} }
int GetRefCount() int GetRefCount()

158
src/net_processing.cpp

@ -2661,100 +2661,100 @@ bool ProcessMessages(CNode* pfrom, CConnman& connman, const std::atomic<bool>& i
// this maintains the order of responses // this maintains the order of responses
if (!pfrom->vRecvGetData.empty()) return true; if (!pfrom->vRecvGetData.empty()) return true;
// Don't bother if send buffer is too full to respond anyway // Don't bother if send buffer is too full to respond anyway
if (pfrom->fPauseSend) if (pfrom->fPauseSend)
return false; return false;
std::list<CNetMessage> msgs; std::list<CNetMessage> msgs;
{ {
LOCK(pfrom->cs_vProcessMsg); LOCK(pfrom->cs_vProcessMsg);
if (pfrom->vProcessMsg.empty()) if (pfrom->vProcessMsg.empty())
return false;
// Just take one message
msgs.splice(msgs.begin(), pfrom->vProcessMsg, pfrom->vProcessMsg.begin());
pfrom->nProcessQueueSize -= msgs.front().vRecv.size() + CMessageHeader::HEADER_SIZE;
pfrom->fPauseRecv = pfrom->nProcessQueueSize > connman.GetReceiveFloodSize();
fMoreWork = !pfrom->vProcessMsg.empty();
}
CNetMessage& msg(msgs.front());
msg.SetVersion(pfrom->GetRecvVersion());
// Scan for message start
if (memcmp(msg.hdr.pchMessageStart, chainparams.MessageStart(), CMessageHeader::MESSAGE_START_SIZE) != 0) {
LogPrintf("PROCESSMESSAGE: INVALID MESSAGESTART %s peer=%d\n", SanitizeString(msg.hdr.GetCommand()), pfrom->id);
pfrom->fDisconnect = true;
return false; return false;
} // Just take one message
msgs.splice(msgs.begin(), pfrom->vProcessMsg, pfrom->vProcessMsg.begin());
pfrom->nProcessQueueSize -= msgs.front().vRecv.size() + CMessageHeader::HEADER_SIZE;
pfrom->fPauseRecv = pfrom->nProcessQueueSize > connman.GetReceiveFloodSize();
fMoreWork = !pfrom->vProcessMsg.empty();
}
CNetMessage& msg(msgs.front());
msg.SetVersion(pfrom->GetRecvVersion());
// Scan for message start
if (memcmp(msg.hdr.pchMessageStart, chainparams.MessageStart(), CMessageHeader::MESSAGE_START_SIZE) != 0) {
LogPrintf("PROCESSMESSAGE: INVALID MESSAGESTART %s peer=%d\n", SanitizeString(msg.hdr.GetCommand()), pfrom->id);
pfrom->fDisconnect = true;
return false;
}
// Read header // Read header
CMessageHeader& hdr = msg.hdr; CMessageHeader& hdr = msg.hdr;
if (!hdr.IsValid(chainparams.MessageStart())) if (!hdr.IsValid(chainparams.MessageStart()))
{ {
LogPrintf("PROCESSMESSAGE: ERRORS IN HEADER %s peer=%d\n", SanitizeString(hdr.GetCommand()), pfrom->id); LogPrintf("PROCESSMESSAGE: ERRORS IN HEADER %s peer=%d\n", SanitizeString(hdr.GetCommand()), pfrom->id);
return fMoreWork; return fMoreWork;
} }
std::string strCommand = hdr.GetCommand(); std::string strCommand = hdr.GetCommand();
// Message size
unsigned int nMessageSize = hdr.nMessageSize;
// Message size // Checksum
unsigned int nMessageSize = hdr.nMessageSize; CDataStream& vRecv = msg.vRecv;
const uint256& hash = msg.GetMessageHash();
if (memcmp(hash.begin(), hdr.pchChecksum, CMessageHeader::CHECKSUM_SIZE) != 0)
{
LogPrintf("%s(%s, %u bytes): CHECKSUM ERROR expected %s was %s\n", __func__,
SanitizeString(strCommand), nMessageSize,
HexStr(hash.begin(), hash.begin()+CMessageHeader::CHECKSUM_SIZE),
HexStr(hdr.pchChecksum, hdr.pchChecksum+CMessageHeader::CHECKSUM_SIZE));
return fMoreWork;
}
// Checksum // Process message
CDataStream& vRecv = msg.vRecv; bool fRet = false;
const uint256& hash = msg.GetMessageHash(); try
if (memcmp(hash.begin(), hdr.pchChecksum, CMessageHeader::CHECKSUM_SIZE) != 0) {
fRet = ProcessMessage(pfrom, strCommand, vRecv, msg.nTime, chainparams, connman, interruptMsgProc);
if (interruptMsgProc)
return false;
if (!pfrom->vRecvGetData.empty())
fMoreWork = true;
}
catch (const std::ios_base::failure& e)
{
connman.PushMessage(pfrom, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::REJECT, strCommand, REJECT_MALFORMED, std::string("error parsing message")));
if (strstr(e.what(), "end of data"))
{ {
LogPrintf("%s(%s, %u bytes): CHECKSUM ERROR expected %s was %s\n", __func__, // Allow exceptions from under-length message on vRecv
SanitizeString(strCommand), nMessageSize, LogPrintf("%s(%s, %u bytes): Exception '%s' caught, normally caused by a message being shorter than its stated length\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
HexStr(hash.begin(), hash.begin()+CMessageHeader::CHECKSUM_SIZE),
HexStr(hdr.pchChecksum, hdr.pchChecksum+CMessageHeader::CHECKSUM_SIZE));
return fMoreWork;
} }
else if (strstr(e.what(), "size too large"))
// Process message
bool fRet = false;
try
{ {
fRet = ProcessMessage(pfrom, strCommand, vRecv, msg.nTime, chainparams, connman, interruptMsgProc); // Allow exceptions from over-long size
if (interruptMsgProc) LogPrintf("%s(%s, %u bytes): Exception '%s' caught\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
return false;
if (!pfrom->vRecvGetData.empty())
fMoreWork = true;
} }
catch (const std::ios_base::failure& e) else if (strstr(e.what(), "non-canonical ReadCompactSize()"))
{ {
connman.PushMessage(pfrom, CNetMsgMaker(INIT_PROTO_VERSION).Make(NetMsgType::REJECT, strCommand, REJECT_MALFORMED, std::string("error parsing message"))); // Allow exceptions from non-canonical encoding
if (strstr(e.what(), "end of data")) LogPrintf("%s(%s, %u bytes): Exception '%s' caught\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
{
// Allow exceptions from under-length message on vRecv
LogPrintf("%s(%s, %u bytes): Exception '%s' caught, normally caused by a message being shorter than its stated length\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
}
else if (strstr(e.what(), "size too large"))
{
// Allow exceptions from over-long size
LogPrintf("%s(%s, %u bytes): Exception '%s' caught\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
}
else if (strstr(e.what(), "non-canonical ReadCompactSize()"))
{
// Allow exceptions from non-canonical encoding
LogPrintf("%s(%s, %u bytes): Exception '%s' caught\n", __func__, SanitizeString(strCommand), nMessageSize, e.what());
}
else
{
PrintExceptionContinue(&e, "ProcessMessages()");
}
} }
catch (const std::exception& e) { else
{
PrintExceptionContinue(&e, "ProcessMessages()"); PrintExceptionContinue(&e, "ProcessMessages()");
} catch (...) {
PrintExceptionContinue(NULL, "ProcessMessages()");
} }
}
catch (const std::exception& e) {
PrintExceptionContinue(&e, "ProcessMessages()");
} catch (...) {
PrintExceptionContinue(NULL, "ProcessMessages()");
}
if (!fRet) { if (!fRet) {
LogPrintf("%s(%s, %u bytes) FAILED peer=%d\n", __func__, SanitizeString(strCommand), nMessageSize, pfrom->id); LogPrintf("%s(%s, %u bytes) FAILED peer=%d\n", __func__, SanitizeString(strCommand), nMessageSize, pfrom->id);
} }
LOCK(cs_main); LOCK(cs_main);
SendRejectsAndCheckIfBanned(pfrom, connman); SendRejectsAndCheckIfBanned(pfrom, connman);
return fMoreWork; return fMoreWork;
} }

Loading…
Cancel
Save