kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Correct indentation and remove unnecessary braces

0.15
Matthias Grundmann 8 years ago
parent
12af74b289
commit
31a14d4909
No known key found for this signature in database
GPG Key ID: 92E5A54A5A822119
3 changed files with 129 additions and 133 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 98
      src/net.cpp
  2. 6
      src/net.h
  3. 158
      src/net_processing.cpp

98
src/net.cpp
Unescape View File

@ -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
Unescape View File

@ -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
Unescape View File

@ -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;
} }

Write Preview
Loading…
Cancel
Save