scripted-diff: Replace error() with LogError()

MarcoFalke · MarcoFalke · commit fad033551709 · 2024-03-11T13:49:37.000+01:00
This fixes the log output when -logsourcelocations is used.

Also, instead of 'ERROR:', the log will now say '[error]', like other
errors logged with LogError.

-BEGIN VERIFY SCRIPT-
 sed -i --regexp-extended 's!  error\("([^"]+)"!  LogError("\1\\n"!g' $( git grep -l '  error(' ./src/ )
-END VERIFY SCRIPT-
diff --git a/src/addrdb.cpp b/src/addrdb.cpp
@@ -44,7 +44,7 @@ bool SerializeDB(Stream& stream, const Data& data)
         hashwriter << Params().MessageStart() << data;
         stream << hashwriter.GetHash();
     } catch (const std::exception& e) {
-        error("%s: Serialize or I/O error - %s", __func__, e.what());
+        LogError("%s: Serialize or I/O error - %s\n", __func__, e.what());
         return false;
     }
 
@@ -65,7 +65,7 @@ bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data
     if (fileout.IsNull()) {
         fileout.fclose();
         remove(pathTmp);
-        error("%s: Failed to open file %s", __func__, fs::PathToString(pathTmp));
+        LogError("%s: Failed to open file %s\n", __func__, fs::PathToString(pathTmp));
         return false;
     }
 
@@ -78,15 +78,15 @@ bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data
     if (!FileCommit(fileout.Get())) {
         fileout.fclose();
         remove(pathTmp);
-        error("%s: Failed to flush file %s", __func__, fs::PathToString(pathTmp));
+        LogError("%s: Failed to flush file %s\n", __func__, fs::PathToString(pathTmp));
         return false;
     }
     fileout.fclose();
 
     // replace existing file, if any, with new file
     if (!RenameOver(pathTmp, path)) {
         remove(pathTmp);
-        error("%s: Rename-into-place failed", __func__);
+        LogError("%s: Rename-into-place failed\n", __func__);
         return false;
     }
 
@@ -144,7 +144,7 @@ bool CBanDB::Write(const banmap_t& banSet)
     }
 
     for (const auto& err : errors) {
-        error("%s", err);
+        LogError("%s\n", err);
     }
     return false;
 }
diff --git a/src/flatfile.cpp b/src/flatfile.cpp
@@ -82,17 +82,17 @@ bool FlatFileSeq::Flush(const FlatFilePos& pos, bool finalize)
 {
     FILE* file = Open(FlatFilePos(pos.nFile, 0)); // Avoid fseek to nPos
     if (!file) {
-        error("%s: failed to open file %d", __func__, pos.nFile);
+        LogError("%s: failed to open file %d\n", __func__, pos.nFile);
         return false;
     }
     if (finalize && !TruncateFile(file, pos.nPos)) {
         fclose(file);
-        error("%s: failed to truncate file %d", __func__, pos.nFile);
+        LogError("%s: failed to truncate file %d\n", __func__, pos.nFile);
         return false;
     }
     if (!FileCommit(file)) {
         fclose(file);
-        error("%s: failed to commit file %d", __func__, pos.nFile);
+        LogError("%s: failed to commit file %d\n", __func__, pos.nFile);
         return false;
     }
     DirectoryCommit(m_dir);
diff --git a/src/index/base.cpp b/src/index/base.cpp
@@ -229,7 +229,7 @@ bool BaseIndex::Commit()
         }
     }
     if (!ok) {
-        error("%s: Failed to commit latest %s state", __func__, GetName());
+        LogError("%s: Failed to commit latest %s state\n", __func__, GetName());
         return false;
     }
     return true;
diff --git a/src/index/blockfilterindex.cpp b/src/index/blockfilterindex.cpp
@@ -119,7 +119,7 @@ bool BlockFilterIndex::CustomInit(const std::optional<interfaces::BlockKey>& blo
         // indicate database corruption or a disk failure, and starting the index would cause
         // further corruption.
         if (m_db->Exists(DB_FILTER_POS)) {
-            error("%s: Cannot read current %s state; index may be corrupted",
+            LogError("%s: Cannot read current %s state; index may be corrupted\n",
                          __func__, GetName());
             return false;
         }
@@ -138,11 +138,11 @@ bool BlockFilterIndex::CustomCommit(CDBBatch& batch)
     // Flush current filter file to disk.
     AutoFile file{m_filter_fileseq->Open(pos)};
     if (file.IsNull()) {
-        error("%s: Failed to open filter file %d", __func__, pos.nFile);
+        LogError("%s: Failed to open filter file %d\n", __func__, pos.nFile);
         return false;
     }
     if (!FileCommit(file.Get())) {
-        error("%s: Failed to commit filter file %d", __func__, pos.nFile);
+        LogError("%s: Failed to commit filter file %d\n", __func__, pos.nFile);
         return false;
     }
 
@@ -163,13 +163,13 @@ bool BlockFilterIndex::ReadFilterFromDisk(const FlatFilePos& pos, const uint256&
     try {
         filein >> block_hash >> encoded_filter;
         if (Hash(encoded_filter) != hash) {
-            error("Checksum mismatch in filter decode.");
+            LogError("Checksum mismatch in filter decode.\n");
             return false;
         }
         filter = BlockFilter(GetFilterType(), block_hash, std::move(encoded_filter), /*skip_decode_check=*/true);
     }
     catch (const std::exception& e) {
-        error("%s: Failed to deserialize block filter from disk: %s", __func__, e.what());
+        LogError("%s: Failed to deserialize block filter from disk: %s\n", __func__, e.what());
         return false;
     }
 
@@ -242,7 +242,7 @@ bool BlockFilterIndex::CustomAppend(const interfaces::BlockInfo& block)
 
         uint256 expected_block_hash = *Assert(block.prev_hash);
         if (read_out.first != expected_block_hash) {
-            error("%s: previous block header belongs to unexpected block %s; expected %s",
+            LogError("%s: previous block header belongs to unexpected block %s; expected %s\n",
                          __func__, read_out.first.ToString(), expected_block_hash.ToString());
             return false;
         }
@@ -278,14 +278,14 @@ bool BlockFilterIndex::CustomAppend(const interfaces::BlockInfo& block)
 
     for (int height = start_height; height <= stop_height; ++height) {
         if (!db_it.GetKey(key) || key.height != height) {
-            error("%s: unexpected key in %s: expected (%c, %d)",
+            LogError("%s: unexpected key in %s: expected (%c, %d)\n",
                          __func__, index_name, DB_BLOCK_HEIGHT, height);
             return false;
         }
 
         std::pair<uint256, DBVal> value;
         if (!db_it.GetValue(value)) {
-            error("%s: unable to read value in %s at key (%c, %d)",
+            LogError("%s: unable to read value in %s at key (%c, %d)\n",
                          __func__, index_name, DB_BLOCK_HEIGHT, height);
             return false;
         }
@@ -340,11 +340,11 @@ static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start
                         const CBlockIndex* stop_index, std::vector<DBVal>& results)
 {
     if (start_height < 0) {
-        error("%s: start height (%d) is negative", __func__, start_height);
+        LogError("%s: start height (%d) is negative\n", __func__, start_height);
         return false;
     }
     if (start_height > stop_index->nHeight) {
-        error("%s: start height (%d) is greater than stop height (%d)",
+        LogError("%s: start height (%d) is greater than stop height (%d)\n",
                      __func__, start_height, stop_index->nHeight);
         return false;
     }
@@ -362,7 +362,7 @@ static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start
 
         size_t i = static_cast<size_t>(height - start_height);
         if (!db_it->GetValue(values[i])) {
-            error("%s: unable to read value in %s at key (%c, %d)",
+            LogError("%s: unable to read value in %s at key (%c, %d)\n",
                          __func__, index_name, DB_BLOCK_HEIGHT, height);
             return false;
         }
@@ -386,7 +386,7 @@ static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start
         }
 
         if (!db.Read(DBHashKey(block_hash), results[i])) {
-            error("%s: unable to read value in %s at key (%c, %s)",
+            LogError("%s: unable to read value in %s at key (%c, %s)\n",
                          __func__, index_name, DB_BLOCK_HASH, block_hash.ToString());
             return false;
         }
diff --git a/src/index/coinstatsindex.cpp b/src/index/coinstatsindex.cpp
@@ -138,7 +138,7 @@ bool CoinStatsIndex::CustomAppend(const interfaces::BlockInfo& block)
                       read_out.first.ToString(), expected_block_hash.ToString());
 
             if (!m_db->Read(DBHashKey(expected_block_hash), read_out)) {
-                error("%s: previous block header not found; expected %s",
+                LogError("%s: previous block header not found; expected %s\n",
                              __func__, expected_block_hash.ToString());
                 return false;
             }
@@ -246,14 +246,14 @@ bool CoinStatsIndex::CustomAppend(const interfaces::BlockInfo& block)
 
     for (int height = start_height; height <= stop_height; ++height) {
         if (!db_it.GetKey(key) || key.height != height) {
-            error("%s: unexpected key in %s: expected (%c, %d)",
+            LogError("%s: unexpected key in %s: expected (%c, %d)\n",
                          __func__, index_name, DB_BLOCK_HEIGHT, height);
             return false;
         }
 
         std::pair<uint256, DBVal> value;
         if (!db_it.GetValue(value)) {
-            error("%s: unable to read value in %s at key (%c, %d)",
+            LogError("%s: unable to read value in %s at key (%c, %d)\n",
                          __func__, index_name, DB_BLOCK_HEIGHT, height);
             return false;
         }
@@ -288,7 +288,7 @@ bool CoinStatsIndex::CustomRewind(const interfaces::BlockKey& current_tip, const
             CBlock block;
 
             if (!m_chainstate->m_blockman.ReadBlockFromDisk(block, *iter_tip)) {
-                error("%s: Failed to read block %s from disk",
+                LogError("%s: Failed to read block %s from disk\n",
                              __func__, iter_tip->GetBlockHash().ToString());
                 return false;
             }
@@ -357,7 +357,7 @@ bool CoinStatsIndex::CustomInit(const std::optional<interfaces::BlockKey>& block
         // exist. Any other errors indicate database corruption or a disk
         // failure, and starting the index would cause further corruption.
         if (m_db->Exists(DB_MUHASH)) {
-            error("%s: Cannot read current %s state; index may be corrupted",
+            LogError("%s: Cannot read current %s state; index may be corrupted\n",
                          __func__, GetName());
             return false;
         }
@@ -366,15 +366,15 @@ bool CoinStatsIndex::CustomInit(const std::optional<interfaces::BlockKey>& block
     if (block) {
         DBVal entry;
         if (!LookUpOne(*m_db, *block, entry)) {
-            error("%s: Cannot read current %s state; index may be corrupted",
+            LogError("%s: Cannot read current %s state; index may be corrupted\n",
                          __func__, GetName());
             return false;
         }
 
         uint256 out;
         m_muhash.Finalize(out);
         if (entry.muhash != out) {
-            error("%s: Cannot read current %s state; index may be corrupted",
+            LogError("%s: Cannot read current %s state; index may be corrupted\n",
                          __func__, GetName());
             return false;
         }
@@ -429,7 +429,7 @@ bool CoinStatsIndex::ReverseBlock(const CBlock& block, const CBlockIndex* pindex
                       read_out.first.ToString(), expected_block_hash.ToString());
 
             if (!m_db->Read(DBHashKey(expected_block_hash), read_out)) {
-                error("%s: previous block header not found; expected %s",
+                LogError("%s: previous block header not found; expected %s\n",
                              __func__, expected_block_hash.ToString());
                 return false;
             }
diff --git a/src/index/txindex.cpp b/src/index/txindex.cpp
@@ -81,23 +81,23 @@ bool TxIndex::FindTx(const uint256& tx_hash, uint256& block_hash, CTransactionRe
 
     AutoFile file{m_chainstate->m_blockman.OpenBlockFile(postx, true)};
     if (file.IsNull()) {
-        error("%s: OpenBlockFile failed", __func__);
+        LogError("%s: OpenBlockFile failed\n", __func__);
         return false;
     }
     CBlockHeader header;
     try {
         file >> header;
         if (fseek(file.Get(), postx.nTxOffset, SEEK_CUR)) {
-            error("%s: fseek(...) failed", __func__);
+            LogError("%s: fseek(...) failed\n", __func__);
             return false;
         }
         file >> TX_WITH_WITNESS(tx);
     } catch (const std::exception& e) {
-        error("%s: Deserialize or I/O error - %s", __func__, e.what());
+        LogError("%s: Deserialize or I/O error - %s\n", __func__, e.what());
         return false;
     }
     if (tx->GetHash() != tx_hash) {
-        error("%s: txid mismatch", __func__);
+        LogError("%s: txid mismatch\n", __func__);
         return false;
     }
     block_hash = header.GetHash();
diff --git a/src/kernel/coinstats.cpp b/src/kernel/coinstats.cpp
@@ -134,7 +134,7 @@ static bool ComputeUTXOStats(CCoinsView* view, CCoinsStats& stats, T hash_obj, c
             outputs[key.n] = std::move(coin);
             stats.coins_count++;
         } else {
-            error("%s: unable to read value", __func__);
+            LogError("%s: unable to read value\n", __func__);
             return false;
         }
         pcursor->Next();
diff --git a/src/net.cpp b/src/net.cpp
@@ -575,7 +575,7 @@ void CNode::SetAddrLocal(const CService& addrLocalIn) {
     AssertLockNotHeld(m_addr_local_mutex);
     LOCK(m_addr_local_mutex);
     if (addrLocal.IsValid()) {
-        error("Addr local already set for node: %i. Refusing to change from %s to %s", id, addrLocal.ToStringAddrPort(), addrLocalIn.ToStringAddrPort());
+        LogError("Addr local already set for node: %i. Refusing to change from %s to %s\n", id, addrLocal.ToStringAddrPort(), addrLocalIn.ToStringAddrPort());
     } else {
         addrLocal = addrLocalIn;
     }
diff --git a/src/netbase.cpp b/src/netbase.cpp
@@ -338,7 +338,7 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a
         IntrRecvError recvr;
         LogPrint(BCLog::NET, "SOCKS5 connecting %s\n", strDest);
         if (strDest.size() > 255) {
-            error("Hostname too long");
+            LogError("Hostname too long\n");
             return false;
         }
         // Construct the version identifier/method selection message
@@ -359,15 +359,15 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a
             return false;
         }
         if (pchRet1[0] != SOCKSVersion::SOCKS5) {
-            error("Proxy failed to initialize");
+            LogError("Proxy failed to initialize\n");
             return false;
         }
         if (pchRet1[1] == SOCKS5Method::USER_PASS && auth) {
             // Perform username/password authentication (as described in RFC1929)
             std::vector<uint8_t> vAuth;
             vAuth.push_back(0x01); // Current (and only) version of user/pass subnegotiation
             if (auth->username.size() > 255 || auth->password.size() > 255) {
-                error("Proxy username or password too long");
+                LogError("Proxy username or password too long\n");
                 return false;
             }
             vAuth.push_back(auth->username.size());
@@ -378,17 +378,17 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a
             LogPrint(BCLog::PROXY, "SOCKS5 sending proxy authentication %s:%s\n", auth->username, auth->password);
             uint8_t pchRetA[2];
             if (InterruptibleRecv(pchRetA, 2, g_socks5_recv_timeout, sock) != IntrRecvError::OK) {
-                error("Error reading proxy authentication response");
+                LogError("Error reading proxy authentication response\n");
                 return false;
             }
             if (pchRetA[0] != 0x01 || pchRetA[1] != 0x00) {
-                error("Proxy authentication unsuccessful");
+                LogError("Proxy authentication unsuccessful\n");
                 return false;
             }
         } else if (pchRet1[1] == SOCKS5Method::NOAUTH) {
             // Perform no authentication
         } else {
-            error("Proxy requested wrong authentication method %02x", pchRet1[1]);
+            LogError("Proxy requested wrong authentication method %02x\n", pchRet1[1]);
             return false;
         }
         std::vector<uint8_t> vSocks5;
@@ -409,12 +409,12 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a
                  * error message. */
                 return false;
             } else {
-                error("Error while reading proxy response");
+                LogError("Error while reading proxy response\n");
                 return false;
             }
         }
         if (pchRet2[0] != SOCKSVersion::SOCKS5) {
-            error("Proxy failed to accept request");
+            LogError("Proxy failed to accept request\n");
             return false;
         }
         if (pchRet2[1] != SOCKS5Reply::SUCCEEDED) {
@@ -423,7 +423,7 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a
             return false;
         }
         if (pchRet2[2] != 0x00) { // Reserved field must be 0
-            error("Error: malformed proxy response");
+            LogError("Error: malformed proxy response\n");
             return false;
         }
         uint8_t pchRet3[256];
@@ -433,30 +433,30 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a
         case SOCKS5Atyp::DOMAINNAME: {
             recvr = InterruptibleRecv(pchRet3, 1, g_socks5_recv_timeout, sock);
             if (recvr != IntrRecvError::OK) {
-                error("Error reading from proxy");
+                LogError("Error reading from proxy\n");
                 return false;
             }
             int nRecv = pchRet3[0];
             recvr = InterruptibleRecv(pchRet3, nRecv, g_socks5_recv_timeout, sock);
             break;
         }
         default: {
-            error("Error: malformed proxy response");
+            LogError("Error: malformed proxy response\n");
             return false;
         }
         }
         if (recvr != IntrRecvError::OK) {
-            error("Error reading from proxy");
+            LogError("Error reading from proxy\n");
             return false;
         }
         if (InterruptibleRecv(pchRet3, 2, g_socks5_recv_timeout, sock) != IntrRecvError::OK) {
-            error("Error reading from proxy");
+            LogError("Error reading from proxy\n");
             return false;
         }
         LogPrint(BCLog::NET, "SOCKS5 connected %s\n", strDest);
         return true;
     } catch (const std::runtime_error& e) {
-        error("Error during SOCKS5 proxy handshake: %s", e.what());
+        LogError("Error during SOCKS5 proxy handshake: %s\n", e.what());
         return false;
     }
 }
diff --git a/src/node/blockstorage.cpp b/src/node/blockstorage.cpp
diff --git a/src/script/signingprovider.cpp b/src/script/signingprovider.cpp
diff --git a/src/util/fs_helpers.cpp b/src/util/fs_helpers.cpp
diff --git a/src/validation.cpp b/src/validation.cpp

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ bool SerializeDB(Stream& stream, const Data& data)`
`44`	`44`	`hashwriter << Params().MessageStart() << data;`
`45`	`45`	`stream << hashwriter.GetHash();`
`46`	`46`	`} catch (const std::exception& e) {`
`47`		`- error("%s: Serialize or I/O error - %s", __func__, e.what());`
	`47`	`+ LogError("%s: Serialize or I/O error - %s\n", __func__, e.what());`
`48`	`48`	`return false;`
`49`	`49`	`}`
`50`	`50`
`@@ -65,7 +65,7 @@ bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data`
`65`	`65`	`if (fileout.IsNull()) {`
`66`	`66`	`fileout.fclose();`
`67`	`67`	`remove(pathTmp);`
`68`		`- error("%s: Failed to open file %s", __func__, fs::PathToString(pathTmp));`
	`68`	`+ LogError("%s: Failed to open file %s\n", __func__, fs::PathToString(pathTmp));`
`69`	`69`	`return false;`
`70`	`70`	`}`
`71`	`71`
`@@ -78,15 +78,15 @@ bool SerializeFileDB(const std::string& prefix, const fs::path& path, const Data`
`78`	`78`	`if (!FileCommit(fileout.Get())) {`
`79`	`79`	`fileout.fclose();`
`80`	`80`	`remove(pathTmp);`
`81`		`- error("%s: Failed to flush file %s", __func__, fs::PathToString(pathTmp));`
	`81`	`+ LogError("%s: Failed to flush file %s\n", __func__, fs::PathToString(pathTmp));`
`82`	`82`	`return false;`
`83`	`83`	`}`
`84`	`84`	`fileout.fclose();`
`85`	`85`
`86`	`86`	`// replace existing file, if any, with new file`
`87`	`87`	`if (!RenameOver(pathTmp, path)) {`
`88`	`88`	`remove(pathTmp);`
`89`		`- error("%s: Rename-into-place failed", __func__);`
	`89`	`+ LogError("%s: Rename-into-place failed\n", __func__);`
`90`	`90`	`return false;`
`91`	`91`	`}`
`92`	`92`
`@@ -144,7 +144,7 @@ bool CBanDB::Write(const banmap_t& banSet)`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`for (const auto& err : errors) {`
`147`		`- error("%s", err);`
	`147`	`+ LogError("%s\n", err);`
`148`	`148`	`}`
`149`	`149`	`return false;`
`150`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,17 +82,17 @@ bool FlatFileSeq::Flush(const FlatFilePos& pos, bool finalize)`
`82`	`82`	`{`
`83`	`83`	`FILE* file = Open(FlatFilePos(pos.nFile, 0)); // Avoid fseek to nPos`
`84`	`84`	`if (!file) {`
`85`		`- error("%s: failed to open file %d", __func__, pos.nFile);`
	`85`	`+ LogError("%s: failed to open file %d\n", __func__, pos.nFile);`
`86`	`86`	`return false;`
`87`	`87`	`}`
`88`	`88`	`if (finalize && !TruncateFile(file, pos.nPos)) {`
`89`	`89`	`fclose(file);`
`90`		`- error("%s: failed to truncate file %d", __func__, pos.nFile);`
	`90`	`+ LogError("%s: failed to truncate file %d\n", __func__, pos.nFile);`
`91`	`91`	`return false;`
`92`	`92`	`}`
`93`	`93`	`if (!FileCommit(file)) {`
`94`	`94`	`fclose(file);`
`95`		`- error("%s: failed to commit file %d", __func__, pos.nFile);`
	`95`	`+ LogError("%s: failed to commit file %d\n", __func__, pos.nFile);`
`96`	`96`	`return false;`
`97`	`97`	`}`
`98`	`98`	`DirectoryCommit(m_dir);`
Original file line number	Diff line number	Diff line change
`@@ -229,7 +229,7 @@ bool BaseIndex::Commit()`
`229`	`229`	`}`
`230`	`230`	`}`
`231`	`231`	`if (!ok) {`
`232`		`- error("%s: Failed to commit latest %s state", __func__, GetName());`
	`232`	`+ LogError("%s: Failed to commit latest %s state\n", __func__, GetName());`
`233`	`233`	`return false;`
`234`	`234`	`}`
`235`	`235`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -134,7 +134,7 @@ static bool ComputeUTXOStats(CCoinsView* view, CCoinsStats& stats, T hash_obj, c`
`134`	`134`	`outputs[key.n] = std::move(coin);`
`135`	`135`	`stats.coins_count++;`
`136`	`136`	`} else {`
`137`		`- error("%s: unable to read value", __func__);`
	`137`	`+ LogError("%s: unable to read value\n", __func__);`
`138`	`138`	`return false;`
`139`	`139`	`}`
`140`	`140`	`pcursor->Next();`
Original file line number	Diff line number	Diff line change
`@@ -575,7 +575,7 @@ void CNode::SetAddrLocal(const CService& addrLocalIn) {`
`575`	`575`	`AssertLockNotHeld(m_addr_local_mutex);`
`576`	`576`	`LOCK(m_addr_local_mutex);`
`577`	`577`	`if (addrLocal.IsValid()) {`
`578`		`- error("Addr local already set for node: %i. Refusing to change from %s to %s", id, addrLocal.ToStringAddrPort(), addrLocalIn.ToStringAddrPort());`
	`578`	`+ LogError("Addr local already set for node: %i. Refusing to change from %s to %s\n", id, addrLocal.ToStringAddrPort(), addrLocalIn.ToStringAddrPort());`
`579`	`579`	`} else {`
`580`	`580`	`addrLocal = addrLocalIn;`
`581`	`581`	`}`
Original file line number	Diff line number	Diff line change
`@@ -338,7 +338,7 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a`
`338`	`338`	`IntrRecvError recvr;`
`339`	`339`	`LogPrint(BCLog::NET, "SOCKS5 connecting %s\n", strDest);`
`340`	`340`	`if (strDest.size() > 255) {`
`341`		`- error("Hostname too long");`
	`341`	`+ LogError("Hostname too long\n");`
`342`	`342`	`return false;`
`343`	`343`	`}`
`344`	`344`	`// Construct the version identifier/method selection message`
`@@ -359,15 +359,15 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a`
`359`	`359`	`return false;`
`360`	`360`	`}`
`361`	`361`	`if (pchRet1[0] != SOCKSVersion::SOCKS5) {`
`362`		`- error("Proxy failed to initialize");`
	`362`	`+ LogError("Proxy failed to initialize\n");`
`363`	`363`	`return false;`
`364`	`364`	`}`
`365`	`365`	`if (pchRet1[1] == SOCKS5Method::USER_PASS && auth) {`
`366`	`366`	`// Perform username/password authentication (as described in RFC1929)`
`367`	`367`	`std::vector<uint8_t> vAuth;`
`368`	`368`	`vAuth.push_back(0x01); // Current (and only) version of user/pass subnegotiation`
`369`	`369`	`if (auth->username.size() > 255 \|\| auth->password.size() > 255) {`
`370`		`- error("Proxy username or password too long");`
	`370`	`+ LogError("Proxy username or password too long\n");`
`371`	`371`	`return false;`
`372`	`372`	`}`
`373`	`373`	`vAuth.push_back(auth->username.size());`
`@@ -378,17 +378,17 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a`
`378`	`378`	`LogPrint(BCLog::PROXY, "SOCKS5 sending proxy authentication %s:%s\n", auth->username, auth->password);`
`379`	`379`	`uint8_t pchRetA[2];`
`380`	`380`	`if (InterruptibleRecv(pchRetA, 2, g_socks5_recv_timeout, sock) != IntrRecvError::OK) {`
`381`		`- error("Error reading proxy authentication response");`
	`381`	`+ LogError("Error reading proxy authentication response\n");`
`382`	`382`	`return false;`
`383`	`383`	`}`
`384`	`384`	`if (pchRetA[0] != 0x01 \|\| pchRetA[1] != 0x00) {`
`385`		`- error("Proxy authentication unsuccessful");`
	`385`	`+ LogError("Proxy authentication unsuccessful\n");`
`386`	`386`	`return false;`
`387`	`387`	`}`
`388`	`388`	`} else if (pchRet1[1] == SOCKS5Method::NOAUTH) {`
`389`	`389`	`// Perform no authentication`
`390`	`390`	`} else {`
`391`		`- error("Proxy requested wrong authentication method %02x", pchRet1[1]);`
	`391`	`+ LogError("Proxy requested wrong authentication method %02x\n", pchRet1[1]);`
`392`	`392`	`return false;`
`393`	`393`	`}`
`394`	`394`	`std::vector<uint8_t> vSocks5;`
`@@ -409,12 +409,12 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a`
`409`	`409`	`* error message. */`
`410`	`410`	`return false;`
`411`	`411`	`} else {`
`412`		`- error("Error while reading proxy response");`
	`412`	`+ LogError("Error while reading proxy response\n");`
`413`	`413`	`return false;`
`414`	`414`	`}`
`415`	`415`	`}`
`416`	`416`	`if (pchRet2[0] != SOCKSVersion::SOCKS5) {`
`417`		`- error("Proxy failed to accept request");`
	`417`	`+ LogError("Proxy failed to accept request\n");`
`418`	`418`	`return false;`
`419`	`419`	`}`
`420`	`420`	`if (pchRet2[1] != SOCKS5Reply::SUCCEEDED) {`
`@@ -423,7 +423,7 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a`
`423`	`423`	`return false;`
`424`	`424`	`}`
`425`	`425`	`if (pchRet2[2] != 0x00) { // Reserved field must be 0`
`426`		`- error("Error: malformed proxy response");`
	`426`	`+ LogError("Error: malformed proxy response\n");`
`427`	`427`	`return false;`
`428`	`428`	`}`
`429`	`429`	`uint8_t pchRet3[256];`
`@@ -433,30 +433,30 @@ bool Socks5(const std::string& strDest, uint16_t port, const ProxyCredentials* a`
`433`	`433`	`case SOCKS5Atyp::DOMAINNAME: {`
`434`	`434`	`recvr = InterruptibleRecv(pchRet3, 1, g_socks5_recv_timeout, sock);`
`435`	`435`	`if (recvr != IntrRecvError::OK) {`
`436`		`- error("Error reading from proxy");`
	`436`	`+ LogError("Error reading from proxy\n");`
`437`	`437`	`return false;`
`438`	`438`	`}`
`439`	`439`	`int nRecv = pchRet3[0];`
`440`	`440`	`recvr = InterruptibleRecv(pchRet3, nRecv, g_socks5_recv_timeout, sock);`
`441`	`441`	`break;`
`442`	`442`	`}`
`443`	`443`	`default: {`
`444`		`- error("Error: malformed proxy response");`
	`444`	`+ LogError("Error: malformed proxy response\n");`
`445`	`445`	`return false;`
`446`	`446`	`}`
`447`	`447`	`}`
`448`	`448`	`if (recvr != IntrRecvError::OK) {`
`449`		`- error("Error reading from proxy");`
	`449`	`+ LogError("Error reading from proxy\n");`
`450`	`450`	`return false;`
`451`	`451`	`}`
`452`	`452`	`if (InterruptibleRecv(pchRet3, 2, g_socks5_recv_timeout, sock) != IntrRecvError::OK) {`
`453`		`- error("Error reading from proxy");`
	`453`	`+ LogError("Error reading from proxy\n");`
`454`	`454`	`return false;`
`455`	`455`	`}`
`456`	`456`	`LogPrint(BCLog::NET, "SOCKS5 connected %s\n", strDest);`
`457`	`457`	`return true;`
`458`	`458`	`} catch (const std::runtime_error& e) {`
`459`		`- error("Error during SOCKS5 proxy handshake: %s", e.what());`
	`459`	`+ LogError("Error during SOCKS5 proxy handshake: %s\n", e.what());`
`460`	`460`	`return false;`
`461`	`461`	`}`
`462`	`462`	`}`