feat: I2P integration (process-based) + updated icons + Qt UI for I2P address display
This commit is contained in:
+68
@@ -0,0 +1,68 @@
|
||||
# I2P support (SAM v3)
|
||||
|
||||
Triangles runs over I2P in addition to Tor, giving the wallet a second
|
||||
anonymous network and a `.b32.i2p` address shown directly above the `.onion`
|
||||
address in the status bar.
|
||||
|
||||
I2P is **on by default** and works the same way as the embedded Tor: the wallet
|
||||
auto-launches a bundled **i2pd** router as a managed child process, enables its
|
||||
SAM bridge, and connects to it. The user does not have to install or configure
|
||||
anything — provided the i2pd binary ships with the wallet.
|
||||
|
||||
## Shipping the i2pd binary
|
||||
|
||||
Like `tor.exe`, the wallet looks for an `i2pd` executable in several places and
|
||||
launches the first one it finds:
|
||||
|
||||
1. Next to the wallet executable (recommended): `i2pd.exe` (Windows) / `i2pd`
|
||||
(Linux/macOS), or in an `i2pd/` subfolder beside it.
|
||||
2. In the data directory (or its `i2pd/` subfolder).
|
||||
3. Common system locations (`/usr/bin/i2pd`, Homebrew, `C:\i2pd\…`, etc.).
|
||||
|
||||
Get i2pd from https://i2pd.website/ (or your package manager) and place the
|
||||
binary next to the wallet in your build/packaging step. That's the only manual
|
||||
part, and it's a packaging concern, not something the end user does.
|
||||
|
||||
If no i2pd binary is found, the wallet logs a notice and continues with **Tor
|
||||
only** — I2P is strictly additive and never blocks start-up.
|
||||
|
||||
## What happens at start-up
|
||||
|
||||
1. If a SAM bridge is already listening on `127.0.0.1:7656` (e.g. you run your
|
||||
own router), the wallet uses it and does **not** launch its own.
|
||||
2. Otherwise it writes `i2pd.conf` into `<datadir>/i2pd/` (SAM enabled, other
|
||||
services off), launches i2pd, and waits for the SAM bridge to come up.
|
||||
3. The SAM client then loads/creates a persistent destination
|
||||
(`<datadir>/i2p_private_key`), opens a STREAM session, derives the
|
||||
`.b32.i2p` address (`base32(SHA-256(destination))`), accepts inbound I2P
|
||||
streams, and dials outbound `.b32.i2p` peers.
|
||||
4. On wallet exit, the SAM session is closed and the i2pd child process is
|
||||
terminated (an external router you started yourself is left running).
|
||||
|
||||
The first session takes a little longer while i2pd builds tunnels; the address
|
||||
appears once the bridge is ready.
|
||||
|
||||
## Options
|
||||
|
||||
```
|
||||
-i2p Enable I2P; auto-launches bundled i2pd (default: 1; -i2p=0 to disable)
|
||||
-i2psam=<ip:port> SAM bridge address (default: 127.0.0.1:7656).
|
||||
A non-loopback address disables the bundled router and
|
||||
connects to that external bridge instead.
|
||||
```
|
||||
|
||||
## Checking it
|
||||
|
||||
* GUI: the `.b32.i2p` address sits on top of the `.onion` in the status bar;
|
||||
click either to copy.
|
||||
* RPC: `getinfo` shows `toraddress` and `i2paddress`; `getnetworkinfo` shows
|
||||
`toraddress` and an `i2p` object (`enabled`, `active`, `address`, `peers`).
|
||||
|
||||
## Notes / limitations
|
||||
|
||||
* The address serialization format carries a flag for I2P addresses, so **all
|
||||
nodes must run this build** to exchange I2P peers; an old `peers.dat` is
|
||||
discarded.
|
||||
* `i2p_private_key` is your stable I2P identity — back it up, don't delete it.
|
||||
* This was implemented without a build/CI environment here; build and test
|
||||
against a real i2pd before relying on it.
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 8.2 KiB After Width: | Height: | Size: 17 KiB |
@@ -53,6 +53,8 @@ set(CORE_SOURCES
|
||||
net.cpp
|
||||
net_bootstrap.cpp
|
||||
netbase.cpp
|
||||
i2p.cpp
|
||||
i2p_process.cpp
|
||||
protocol.cpp
|
||||
script.cpp
|
||||
sync.cpp
|
||||
|
||||
+466
@@ -0,0 +1,466 @@
|
||||
// Copyright (c) 2024 Triangles developers
|
||||
// I2P (SAM v3) transport support
|
||||
// Distributed under the MIT/X11 software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#include "i2p.h"
|
||||
|
||||
#include "util.h"
|
||||
#include "netbase.h"
|
||||
#include "protocol.h" // CAddress
|
||||
#include "net.h" // AddI2PInboundNode(), GetListenPort()
|
||||
|
||||
#include <openssl/sha.h>
|
||||
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
#ifdef WIN32
|
||||
#include <winsock2.h>
|
||||
#include <ws2tcpip.h>
|
||||
#else
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <unistd.h>
|
||||
#ifndef closesocket
|
||||
#define closesocket close
|
||||
#endif
|
||||
#endif
|
||||
|
||||
// I2P uses a base64 variant where '+' -> '-' and '/' -> '~'.
|
||||
static const char* pI2PBase64 =
|
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-~";
|
||||
|
||||
static std::vector<unsigned char> DecodeI2PBase64(const std::string& str)
|
||||
{
|
||||
int table[256];
|
||||
for (int i = 0; i < 256; i++) table[i] = -1;
|
||||
for (int i = 0; i < 64; i++) table[(unsigned char)pI2PBase64[i]] = i;
|
||||
|
||||
std::vector<unsigned char> out;
|
||||
int bits = 0; uint32_t buf = 0;
|
||||
for (char c : str) {
|
||||
if (c == '=' || c == '\r' || c == '\n') continue;
|
||||
int v = table[(unsigned char)c];
|
||||
if (v < 0) continue; // skip anything unexpected
|
||||
buf = (buf << 6) | v;
|
||||
bits += 6;
|
||||
if (bits >= 8) {
|
||||
bits -= 8;
|
||||
out.push_back((unsigned char)((buf >> bits) & 0xFF));
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
CI2PSession* CI2PSession::GetInstance()
|
||||
{
|
||||
static CI2PSession instance;
|
||||
return &instance;
|
||||
}
|
||||
|
||||
CI2PSession::CI2PSession()
|
||||
: samHost(I2P_DEFAULT_SAM_HOST), samPort(I2P_DEFAULT_SAM_PORT),
|
||||
hSession(INVALID_SOCKET), fEnabled(false), fActive(false), fShutdown(false)
|
||||
{
|
||||
}
|
||||
|
||||
CI2PSession::~CI2PSession()
|
||||
{
|
||||
Stop();
|
||||
}
|
||||
|
||||
std::string CI2PSession::GetB32Address()
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(cs);
|
||||
return b32Address;
|
||||
}
|
||||
|
||||
// --- low level SAM helpers -------------------------------------------------
|
||||
|
||||
bool CI2PSession::SamConnect(SOCKET& hSocketRet)
|
||||
{
|
||||
SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
if (hSocket == INVALID_SOCKET)
|
||||
return false;
|
||||
|
||||
struct sockaddr_in addr;
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sin_family = AF_INET;
|
||||
addr.sin_port = htons((unsigned short)samPort);
|
||||
addr.sin_addr.s_addr = inet_addr(samHost.c_str());
|
||||
|
||||
if (connect(hSocket, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
|
||||
closesocket(hSocket);
|
||||
return false;
|
||||
}
|
||||
|
||||
hSocketRet = hSocket;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CI2PSession::SamSendLine(SOCKET hSocket, const std::string& strLine)
|
||||
{
|
||||
std::string out = strLine + "\n";
|
||||
const char* p = out.c_str();
|
||||
size_t left = out.size();
|
||||
while (left > 0) {
|
||||
int n = send(hSocket, p, (int)left, MSG_NOSIGNAL);
|
||||
if (n <= 0)
|
||||
return false;
|
||||
p += n;
|
||||
left -= n;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CI2PSession::SamRecvLine(SOCKET hSocket, std::string& strLineRet)
|
||||
{
|
||||
strLineRet.clear();
|
||||
char c;
|
||||
// SAM replies are newline terminated; read one byte at a time so we stop
|
||||
// exactly at the boundary and leave any following stream data untouched.
|
||||
for (int i = 0; i < 16384; i++) {
|
||||
int n = recv(hSocket, &c, 1, 0);
|
||||
if (n <= 0)
|
||||
return false;
|
||||
if (c == '\n')
|
||||
return true;
|
||||
if (c != '\r')
|
||||
strLineRet += c;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string CI2PSession::SamGetValue(const std::string& strReply, const std::string& strKey)
|
||||
{
|
||||
// Tokens are space separated KEY=VALUE pairs. VALUE runs to the next space.
|
||||
std::string needle = strKey + "=";
|
||||
size_t pos = strReply.find(needle);
|
||||
if (pos == std::string::npos)
|
||||
return "";
|
||||
pos += needle.size();
|
||||
size_t end = strReply.find(' ', pos);
|
||||
if (end == std::string::npos)
|
||||
end = strReply.size();
|
||||
return strReply.substr(pos, end - pos);
|
||||
}
|
||||
|
||||
bool CI2PSession::SamHandshake(SOCKET hSocket)
|
||||
{
|
||||
if (!SamSendLine(hSocket, "HELLO VERSION MIN=3.1 MAX=3.3"))
|
||||
return false;
|
||||
std::string reply;
|
||||
if (!SamRecvLine(hSocket, reply))
|
||||
return false;
|
||||
if (SamGetValue(reply, "RESULT") != "OK") {
|
||||
printf("I2P: SAM handshake failed: %s\n", reply.c_str());
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
std::string CI2PSession::DestToB32(const std::string& strB64Dest)
|
||||
{
|
||||
std::vector<unsigned char> dest = DecodeI2PBase64(strB64Dest);
|
||||
if (dest.empty())
|
||||
return "";
|
||||
unsigned char hash[SHA256_DIGEST_LENGTH];
|
||||
SHA256(dest.data(), dest.size(), hash);
|
||||
std::string b32 = EncodeBase32(hash, SHA256_DIGEST_LENGTH);
|
||||
// I2P b32 addresses are unpadded.
|
||||
while (!b32.empty() && b32[b32.size() - 1] == '=')
|
||||
b32.erase(b32.size() - 1);
|
||||
return b32 + ".b32.i2p";
|
||||
}
|
||||
|
||||
// --- session bring-up ------------------------------------------------------
|
||||
|
||||
bool CI2PSession::LoadOrCreateDestination(std::string& strPrivKeyRet)
|
||||
{
|
||||
fs::path keyPath = GetDataDir() / "i2p_private_key";
|
||||
|
||||
// Reuse an existing persistent destination if we have one.
|
||||
{
|
||||
std::ifstream f(keyPath.string().c_str());
|
||||
if (f.is_open()) {
|
||||
std::string line;
|
||||
std::getline(f, line);
|
||||
while (!line.empty() &&
|
||||
(line[line.size() - 1] == '\r' || line[line.size() - 1] == '\n'))
|
||||
line.erase(line.size() - 1);
|
||||
if (!line.empty()) {
|
||||
strPrivKeyRet = line;
|
||||
printf("I2P: loaded persistent destination from %s\n",
|
||||
keyPath.string().c_str());
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Generate a fresh destination via the bridge (Ed25519, SIGNATURE_TYPE=7).
|
||||
SOCKET hSocket = INVALID_SOCKET;
|
||||
if (!SamConnect(hSocket) || !SamHandshake(hSocket)) {
|
||||
if (hSocket != INVALID_SOCKET) closesocket(hSocket);
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ok = false;
|
||||
if (SamSendLine(hSocket, "DEST GENERATE SIGNATURE_TYPE=7")) {
|
||||
std::string reply;
|
||||
if (SamRecvLine(hSocket, reply)) {
|
||||
std::string priv = SamGetValue(reply, "PRIV");
|
||||
if (!priv.empty()) {
|
||||
strPrivKeyRet = priv;
|
||||
std::ofstream out(keyPath.string().c_str(), std::ios::trunc);
|
||||
if (out.is_open()) {
|
||||
out << priv << std::endl;
|
||||
out.close();
|
||||
printf("I2P: generated and saved new persistent destination\n");
|
||||
ok = true;
|
||||
} else {
|
||||
printf("I2P: WARNING could not write %s\n", keyPath.string().c_str());
|
||||
ok = true; // still usable for this run
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
closesocket(hSocket);
|
||||
return ok;
|
||||
}
|
||||
|
||||
bool CI2PSession::CreateSession()
|
||||
{
|
||||
if (!SamConnect(hSession))
|
||||
return false;
|
||||
if (!SamHandshake(hSession))
|
||||
return false;
|
||||
|
||||
std::ostringstream id;
|
||||
id << "triangles-" << (uint64_t)GetTime() << "-" << (uint64_t)(GetRand(1000000));
|
||||
sessionId = id.str();
|
||||
|
||||
std::string cmd = "SESSION CREATE STYLE=STREAM ID=" + sessionId +
|
||||
" DESTINATION=" + privateKey + " SIGNATURE_TYPE=7";
|
||||
if (!SamSendLine(hSession, cmd))
|
||||
return false;
|
||||
|
||||
std::string reply;
|
||||
if (!SamRecvLine(hSession, reply))
|
||||
return false;
|
||||
|
||||
if (SamGetValue(reply, "RESULT") != "OK") {
|
||||
printf("I2P: SESSION CREATE failed: %s\n", reply.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
// The bridge echoes the (possibly newly assigned) private key back.
|
||||
std::string echoed = SamGetValue(reply, "DESTINATION");
|
||||
if (!echoed.empty())
|
||||
privateKey = echoed;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CI2PSession::ResolveMyB32()
|
||||
{
|
||||
SOCKET hSocket = INVALID_SOCKET;
|
||||
if (!SamConnect(hSocket) || !SamHandshake(hSocket)) {
|
||||
if (hSocket != INVALID_SOCKET) closesocket(hSocket);
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ok = false;
|
||||
if (SamSendLine(hSocket, "NAMING LOOKUP NAME=ME")) {
|
||||
std::string reply;
|
||||
if (SamRecvLine(hSocket, reply) && SamGetValue(reply, "RESULT") == "OK") {
|
||||
std::string dest = SamGetValue(reply, "VALUE");
|
||||
std::string b32 = DestToB32(dest);
|
||||
if (!b32.empty()) {
|
||||
std::lock_guard<std::mutex> lock(cs);
|
||||
b32Address = b32;
|
||||
ok = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
closesocket(hSocket);
|
||||
return ok;
|
||||
}
|
||||
|
||||
bool CI2PSession::Start()
|
||||
{
|
||||
if (!GetBoolArg("-i2p", true)) {
|
||||
printf("I2P: disabled (-i2p=0)\n");
|
||||
return false;
|
||||
}
|
||||
fEnabled.store(true);
|
||||
|
||||
// -i2psam=host:port overrides the default SAM bridge endpoint.
|
||||
std::string sam = GetArg("-i2psam", "");
|
||||
if (!sam.empty()) {
|
||||
int port = I2P_DEFAULT_SAM_PORT;
|
||||
std::string host;
|
||||
SplitHostPort(sam, port, host);
|
||||
if (!host.empty()) samHost = host;
|
||||
if (port > 0) samPort = port;
|
||||
}
|
||||
|
||||
printf("I2P: connecting to SAM bridge at %s:%d\n", samHost.c_str(), samPort);
|
||||
|
||||
if (!LoadOrCreateDestination(privateKey)) {
|
||||
printf("I2P: ERROR could not obtain a destination. Is an I2P router with "
|
||||
"the SAM bridge enabled running at %s:%d?\n", samHost.c_str(), samPort);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!CreateSession()) {
|
||||
printf("I2P: ERROR failed to create SAM STREAM session\n");
|
||||
if (hSession != INVALID_SOCKET) { closesocket(hSession); hSession = INVALID_SOCKET; }
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!ResolveMyB32())
|
||||
printf("I2P: WARNING could not resolve our own .b32.i2p address yet\n");
|
||||
|
||||
fActive.store(true);
|
||||
fShutdown.store(false);
|
||||
|
||||
printf("I2P: session active. Our address: %s\n", GetB32Address().c_str());
|
||||
|
||||
// Register our I2P address as a local address so peers can learn it.
|
||||
CService meI2P;
|
||||
if (!b32Address.empty() && meI2P.SetSpecial(b32Address)) {
|
||||
meI2P.SetPort((unsigned short)GetListenPort());
|
||||
AddLocal(meI2P, LOCAL_MANUAL);
|
||||
}
|
||||
|
||||
acceptThread = std::thread(&CI2PSession::AcceptLoop, this);
|
||||
return true;
|
||||
}
|
||||
|
||||
void CI2PSession::Stop()
|
||||
{
|
||||
if (!fEnabled.load())
|
||||
return;
|
||||
fShutdown.store(true);
|
||||
fActive.store(false);
|
||||
|
||||
if (hSession != INVALID_SOCKET) {
|
||||
closesocket(hSession);
|
||||
hSession = INVALID_SOCKET;
|
||||
}
|
||||
if (acceptThread.joinable())
|
||||
acceptThread.join();
|
||||
fEnabled.store(false);
|
||||
printf("I2P: session stopped\n");
|
||||
}
|
||||
|
||||
// --- inbound ---------------------------------------------------------------
|
||||
|
||||
void CI2PSession::AcceptLoop()
|
||||
{
|
||||
while (!fShutdown.load()) {
|
||||
SOCKET hSocket = INVALID_SOCKET;
|
||||
if (!SamConnect(hSocket) || !SamHandshake(hSocket)) {
|
||||
if (hSocket != INVALID_SOCKET) closesocket(hSocket);
|
||||
if (fShutdown.load()) break;
|
||||
MilliSleep(2000);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Block here until a peer dials us; the router then streams the remote
|
||||
// destination on its own line, after which the socket carries data.
|
||||
if (!SamSendLine(hSocket, "STREAM ACCEPT ID=" + sessionId + " SILENT=false")) {
|
||||
closesocket(hSocket);
|
||||
MilliSleep(1000);
|
||||
continue;
|
||||
}
|
||||
|
||||
std::string status;
|
||||
if (!SamRecvLine(hSocket, status) || SamGetValue(status, "RESULT") != "OK") {
|
||||
if (!fShutdown.load())
|
||||
printf("I2P: STREAM ACCEPT rejected: %s\n", status.c_str());
|
||||
closesocket(hSocket);
|
||||
MilliSleep(1000);
|
||||
continue;
|
||||
}
|
||||
|
||||
std::string remoteDest;
|
||||
if (!SamRecvLine(hSocket, remoteDest)) {
|
||||
closesocket(hSocket);
|
||||
continue;
|
||||
}
|
||||
if (fShutdown.load()) {
|
||||
closesocket(hSocket);
|
||||
break;
|
||||
}
|
||||
|
||||
// The first token is the remote full destination (base64).
|
||||
std::string destTok = remoteDest;
|
||||
size_t sp = destTok.find(' ');
|
||||
if (sp != std::string::npos)
|
||||
destTok = destTok.substr(0, sp);
|
||||
|
||||
std::string b32 = DestToB32(destTok);
|
||||
CAddress addr;
|
||||
if (b32.empty() || !addr.SetSpecial(b32)) {
|
||||
printf("I2P: could not parse inbound remote destination\n");
|
||||
closesocket(hSocket);
|
||||
continue;
|
||||
}
|
||||
addr.nServices = 0;
|
||||
addr.nTime = GetTime();
|
||||
|
||||
// Hand the live data socket to the net layer as an inbound peer.
|
||||
printf("I2P: inbound connection from %s\n", b32.c_str());
|
||||
AddI2PInboundNode(hSocket, addr);
|
||||
}
|
||||
}
|
||||
|
||||
// --- outbound --------------------------------------------------------------
|
||||
|
||||
bool CI2PSession::Connect(const std::string& strDest, SOCKET& hSocketRet)
|
||||
{
|
||||
if (!fActive.load())
|
||||
return false;
|
||||
|
||||
SOCKET hSocket = INVALID_SOCKET;
|
||||
if (!SamConnect(hSocket) || !SamHandshake(hSocket)) {
|
||||
if (hSocket != INVALID_SOCKET) closesocket(hSocket);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!SamSendLine(hSocket, "STREAM CONNECT ID=" + sessionId +
|
||||
" DESTINATION=" + strDest + " SILENT=false")) {
|
||||
closesocket(hSocket);
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string status;
|
||||
if (!SamRecvLine(hSocket, status) || SamGetValue(status, "RESULT") != "OK") {
|
||||
printf("I2P: STREAM CONNECT to %s failed: %s\n", strDest.c_str(), status.c_str());
|
||||
closesocket(hSocket);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Socket is now a bidirectional stream to the peer.
|
||||
hSocketRet = hSocket;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool StartI2P()
|
||||
{
|
||||
return CI2PSession::GetInstance()->Start();
|
||||
}
|
||||
|
||||
void StopI2P()
|
||||
{
|
||||
CI2PSession::GetInstance()->Stop();
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
// Copyright (c) 2024 Triangles developers
|
||||
// I2P (SAM v3) transport support
|
||||
// Distributed under the MIT/X11 software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
//
|
||||
// This module gives Triangles real I2P connectivity that mirrors the existing
|
||||
// embedded-Tor design: instead of a SOCKS proxy it talks the SAM v3 protocol
|
||||
// to a locally running I2P router (i2pd or Java I2P) and obtains a persistent
|
||||
// I2P destination whose ".b32.i2p" address is shown alongside the .onion
|
||||
// address. The wallet:
|
||||
// * creates / loads a persistent destination (i2p_private_key in datadir),
|
||||
// * runs a STREAM session so peers can dial us,
|
||||
// * accepts inbound I2P streams and feeds them to the net layer,
|
||||
// * dials outbound ".b32.i2p" peers through the same session.
|
||||
//
|
||||
// A running I2P router with its SAM bridge enabled (default 127.0.0.1:7656) is
|
||||
// required; nothing is bundled. Enable with -i2p and optionally -i2psam=host:port.
|
||||
|
||||
#ifndef TRIANGLES_I2P_H
|
||||
#define TRIANGLES_I2P_H
|
||||
|
||||
#include <atomic>
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
|
||||
#include "compat.h" // SOCKET / INVALID_SOCKET
|
||||
|
||||
// Default SAM bridge endpoint exposed by i2pd / Java I2P.
|
||||
#define I2P_DEFAULT_SAM_HOST "127.0.0.1"
|
||||
#define I2P_DEFAULT_SAM_PORT 7656
|
||||
|
||||
// Manages a single persistent I2P STREAM session over SAM v3.
|
||||
class CI2PSession
|
||||
{
|
||||
public:
|
||||
static CI2PSession* GetInstance();
|
||||
|
||||
// Bring the session up: connect to the SAM bridge, load/generate the
|
||||
// persistent destination and start accepting inbound streams.
|
||||
// Returns false (and logs) if no router/SAM bridge is reachable.
|
||||
bool Start();
|
||||
|
||||
// Tear the session down and stop the accept loop.
|
||||
void Stop();
|
||||
|
||||
bool IsEnabled() const { return fEnabled.load(); }
|
||||
bool IsActive() const { return fActive.load(); }
|
||||
|
||||
// Our own ".b32.i2p" address (empty until the session is up).
|
||||
std::string GetB32Address();
|
||||
|
||||
// Dial a remote ".b32.i2p" (or full base64 destination) through the
|
||||
// session. On success hSocketRet is a connected, blocking data socket the
|
||||
// caller can hand to a CNode. The caller takes ownership of the socket.
|
||||
bool Connect(const std::string& strDest, SOCKET& hSocketRet);
|
||||
|
||||
private:
|
||||
CI2PSession();
|
||||
~CI2PSession();
|
||||
|
||||
// --- low level SAM helpers ---
|
||||
bool SamConnect(SOCKET& hSocketRet); // raw TCP to the bridge
|
||||
bool SamHandshake(SOCKET hSocket); // HELLO VERSION
|
||||
bool SamSendLine(SOCKET hSocket, const std::string& strLine);
|
||||
bool SamRecvLine(SOCKET hSocket, std::string& strLineRet);
|
||||
static std::string SamGetValue(const std::string& strReply, const std::string& strKey);
|
||||
|
||||
bool LoadOrCreateDestination(std::string& strPrivKeyRet);
|
||||
bool CreateSession(); // SESSION CREATE
|
||||
bool ResolveMyB32(); // NAMING LOOKUP ME
|
||||
void AcceptLoop(); // inbound STREAM ACCEPT
|
||||
|
||||
// Compute the ".b32.i2p" address from a base64 (I2P alphabet) destination.
|
||||
static std::string DestToB32(const std::string& strB64Dest);
|
||||
|
||||
std::string samHost;
|
||||
int samPort;
|
||||
std::string sessionId;
|
||||
std::string privateKey; // persistent destination private key (base64)
|
||||
std::string b32Address; // our own .b32.i2p
|
||||
SOCKET hSession; // long-lived control socket owning the session
|
||||
|
||||
std::atomic<bool> fEnabled;
|
||||
std::atomic<bool> fActive;
|
||||
std::atomic<bool> fShutdown;
|
||||
std::thread acceptThread;
|
||||
std::mutex cs;
|
||||
};
|
||||
|
||||
// Convenience: start/stop from init.cpp.
|
||||
bool StartI2P();
|
||||
void StopI2P();
|
||||
|
||||
#endif // TRIANGLES_I2P_H
|
||||
@@ -0,0 +1,368 @@
|
||||
// Copyright (c) 2024 Triangles developers
|
||||
// I2P Router Process Manager - launches and manages a bundled i2pd binary
|
||||
// Distributed under the MIT/X11 software license
|
||||
|
||||
#ifdef WIN32
|
||||
#define NOMINMAX
|
||||
#ifndef WIN32_LEAN_AND_MEAN
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#endif
|
||||
#ifndef _WIN32_WINNT
|
||||
#define _WIN32_WINNT 0x0600
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include "i2p_process.h"
|
||||
#include "util.h"
|
||||
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
#include <vector>
|
||||
|
||||
#ifdef WIN32
|
||||
#include <winsock2.h>
|
||||
#include <ws2tcpip.h>
|
||||
#include <tlhelp32.h>
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <signal.h>
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
static CI2PProcess* i2pProcessInstance = nullptr;
|
||||
|
||||
CI2PProcess* CI2PProcess::GetInstance()
|
||||
{
|
||||
if (!i2pProcessInstance)
|
||||
i2pProcessInstance = new CI2PProcess();
|
||||
return i2pProcessInstance;
|
||||
}
|
||||
|
||||
CI2PProcess::CI2PProcess()
|
||||
: samPort(7656)
|
||||
, running(false)
|
||||
, fExternal(false)
|
||||
#ifdef WIN32
|
||||
, hProcess(nullptr)
|
||||
, hJob(nullptr)
|
||||
, processId(0)
|
||||
#else
|
||||
, processId(0)
|
||||
#endif
|
||||
{
|
||||
}
|
||||
|
||||
CI2PProcess::~CI2PProcess()
|
||||
{
|
||||
Stop();
|
||||
}
|
||||
|
||||
// Try a quick TCP connect; success means something is already listening
|
||||
// (e.g. the SAM bridge is up, or an external router is running).
|
||||
bool CI2PProcess::CanConnect(const std::string& host, int port)
|
||||
{
|
||||
#ifdef WIN32
|
||||
SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
if (s == INVALID_SOCKET) return false;
|
||||
#else
|
||||
int s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
||||
if (s < 0) return false;
|
||||
#endif
|
||||
struct sockaddr_in addr;
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sin_family = AF_INET;
|
||||
addr.sin_port = htons((unsigned short)port);
|
||||
addr.sin_addr.s_addr = inet_addr(host.c_str());
|
||||
bool ok = (connect(s, (struct sockaddr*)&addr, sizeof(addr)) == 0);
|
||||
#ifdef WIN32
|
||||
closesocket(s);
|
||||
#else
|
||||
close(s);
|
||||
#endif
|
||||
return ok;
|
||||
}
|
||||
|
||||
std::string CI2PProcess::FindI2pdBinary()
|
||||
{
|
||||
std::vector<std::string> candidates;
|
||||
|
||||
#ifdef WIN32
|
||||
const char* exeName = "i2pd.exe";
|
||||
#else
|
||||
const char* exeName = "i2pd";
|
||||
#endif
|
||||
|
||||
// 1. Next to the wallet executable (this is how tor.exe is shipped).
|
||||
try {
|
||||
fs::path exeDir;
|
||||
#ifdef WIN32
|
||||
char buf[MAX_PATH];
|
||||
if (GetModuleFileNameA(nullptr, buf, MAX_PATH) > 0)
|
||||
exeDir = fs::path(buf).parent_path();
|
||||
#else
|
||||
exeDir = fs::current_path();
|
||||
#endif
|
||||
if (!exeDir.empty()) {
|
||||
candidates.push_back((exeDir / exeName).string());
|
||||
candidates.push_back((exeDir / "i2pd" / exeName).string());
|
||||
candidates.push_back((exeDir / "I2P" / exeName).string());
|
||||
}
|
||||
} catch (...) {}
|
||||
|
||||
// 2. In / next to the data directory.
|
||||
candidates.push_back((GetDataDir() / exeName).string());
|
||||
candidates.push_back((GetDataDir() / "i2pd" / exeName).string());
|
||||
|
||||
// 3. Common system locations.
|
||||
#ifdef WIN32
|
||||
if (const char* pf = getenv("ProgramFiles"))
|
||||
candidates.push_back(std::string(pf) + "\\i2pd\\" + exeName);
|
||||
if (const char* pfx = getenv("ProgramFiles(x86)"))
|
||||
candidates.push_back(std::string(pfx) + "\\i2pd\\" + exeName);
|
||||
candidates.push_back(std::string("C:\\i2pd\\") + exeName);
|
||||
#else
|
||||
candidates.push_back("/usr/bin/i2pd");
|
||||
candidates.push_back("/usr/local/bin/i2pd");
|
||||
candidates.push_back("/opt/i2pd/bin/i2pd");
|
||||
candidates.push_back("/opt/homebrew/bin/i2pd");
|
||||
candidates.push_back("/usr/local/opt/i2pd/bin/i2pd");
|
||||
#endif
|
||||
|
||||
for (const std::string& c : candidates) {
|
||||
try {
|
||||
if (fs::exists(c) && fs::is_regular_file(c)) {
|
||||
printf("I2P: found i2pd binary at %s\n", c.c_str());
|
||||
return c;
|
||||
}
|
||||
} catch (...) {}
|
||||
}
|
||||
|
||||
return "";
|
||||
}
|
||||
|
||||
bool CI2PProcess::WriteConfig()
|
||||
{
|
||||
fs::path dir(dataDir);
|
||||
try {
|
||||
fs::create_directories(dir);
|
||||
} catch (const std::exception& e) {
|
||||
lastError = std::string("Cannot create i2pd data directory: ") + e.what();
|
||||
return false;
|
||||
}
|
||||
|
||||
confPath = (dir / "i2pd.conf").string();
|
||||
fs::path logPath = dir / "i2pd.log";
|
||||
|
||||
std::ofstream conf(confPath.c_str(), std::ios::trunc);
|
||||
if (!conf.is_open()) {
|
||||
lastError = "Cannot write i2pd.conf to " + confPath;
|
||||
return false;
|
||||
}
|
||||
|
||||
conf << "# Triangles Wallet I2P configuration (auto-generated)\n";
|
||||
conf << "# Do not edit - this file is overwritten on startup\n\n";
|
||||
conf << "daemon = false\n";
|
||||
conf << "log = file\n";
|
||||
conf << "logfile = " << logPath.string() << "\n";
|
||||
conf << "datadir = " << dir.string() << "\n\n";
|
||||
|
||||
// The bridge our SAM client talks to.
|
||||
conf << "[sam]\n";
|
||||
conf << "enabled = true\n";
|
||||
conf << "address = 127.0.0.1\n";
|
||||
conf << "port = " << samPort << "\n\n";
|
||||
|
||||
// We only need SAM; keep everything else off to minimise footprint.
|
||||
conf << "[httpproxy]\nenabled = false\n\n";
|
||||
conf << "[socksproxy]\nenabled = false\n\n";
|
||||
conf << "[http]\nenabled = false\n\n";
|
||||
conf << "[i2pcontrol]\nenabled = false\n";
|
||||
|
||||
conf.close();
|
||||
printf("I2P: wrote i2pd config to %s (SAM port %d)\n", confPath.c_str(), samPort);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool CI2PProcess::Start(const std::string& dataDirIn, int samPortIn)
|
||||
{
|
||||
dataDir = dataDirIn;
|
||||
samPort = samPortIn;
|
||||
fExternal = false;
|
||||
lastError.clear();
|
||||
|
||||
// If a SAM bridge is already up, use it instead of launching our own.
|
||||
if (CanConnect("127.0.0.1", samPort)) {
|
||||
printf("I2P: detected an I2P router already listening on SAM port %d; using it\n", samPort);
|
||||
fExternal = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
binaryPath = FindI2pdBinary();
|
||||
if (binaryPath.empty()) {
|
||||
lastError = "No i2pd binary found (ship i2pd alongside the wallet, like tor)";
|
||||
printf("I2P: %s\n", lastError.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!WriteConfig())
|
||||
return false;
|
||||
|
||||
printf("I2P: starting i2pd: %s --conf %s\n", binaryPath.c_str(), confPath.c_str());
|
||||
|
||||
#ifdef WIN32
|
||||
STARTUPINFOA si;
|
||||
PROCESS_INFORMATION pi;
|
||||
ZeroMemory(&si, sizeof(si));
|
||||
si.cb = sizeof(si);
|
||||
si.dwFlags = STARTF_USESHOWWINDOW;
|
||||
si.wShowWindow = SW_HIDE;
|
||||
ZeroMemory(&pi, sizeof(pi));
|
||||
|
||||
std::string cmdLine = "\"" + binaryPath + "\" --conf \"" + confPath + "\"";
|
||||
|
||||
if (!CreateProcessA(nullptr, (LPSTR)cmdLine.c_str(), nullptr, nullptr,
|
||||
FALSE, CREATE_NO_WINDOW, nullptr, nullptr, &si, &pi)) {
|
||||
DWORD err = ::GetLastError();
|
||||
lastError = strprintf("CreateProcess failed for i2pd '%s' (Windows error %lu)", binaryPath.c_str(), err);
|
||||
printf("I2P: ERROR %s\n", lastError.c_str());
|
||||
return false;
|
||||
}
|
||||
|
||||
hProcess = pi.hProcess;
|
||||
processId = pi.dwProcessId;
|
||||
CloseHandle(pi.hThread);
|
||||
|
||||
// Kill i2pd if the wallet dies (matches the embedded Tor behaviour).
|
||||
hJob = CreateJobObject(nullptr, nullptr);
|
||||
if (hJob) {
|
||||
JOBOBJECT_EXTENDED_LIMIT_INFORMATION jobInfo = {};
|
||||
jobInfo.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
|
||||
SetInformationJobObject(hJob, JobObjectExtendedLimitInformation, &jobInfo, sizeof(jobInfo));
|
||||
if (!AssignProcessToJobObject(hJob, hProcess))
|
||||
printf("I2P: WARNING could not assign i2pd to Job Object (error %lu)\n", GetLastError());
|
||||
}
|
||||
|
||||
printf("I2P: i2pd started (PID %lu)\n", processId);
|
||||
#else
|
||||
pid_t pid = fork();
|
||||
if (pid < 0) {
|
||||
lastError = "Failed to fork for i2pd process";
|
||||
printf("I2P: ERROR %s\n", lastError.c_str());
|
||||
return false;
|
||||
}
|
||||
if (pid == 0) {
|
||||
freopen("/dev/null", "w", stdout);
|
||||
freopen("/dev/null", "w", stderr);
|
||||
execl(binaryPath.c_str(), binaryPath.c_str(),
|
||||
"--conf", confPath.c_str(), (char*)nullptr);
|
||||
_exit(1);
|
||||
}
|
||||
processId = pid;
|
||||
printf("I2P: i2pd started (PID %d)\n", processId);
|
||||
#endif
|
||||
|
||||
running = true;
|
||||
|
||||
// Wait for the SAM bridge to come up. The bridge opens quickly; tunnel
|
||||
// build (needed for actual connectivity) continues in the background.
|
||||
printf("I2P: waiting for SAM bridge on port %d...\n", samPort);
|
||||
for (int i = 0; i < 45; i++) {
|
||||
MilliSleep(1000);
|
||||
if (fShutdown) {
|
||||
Stop();
|
||||
return false;
|
||||
}
|
||||
if (CanConnect("127.0.0.1", samPort)) {
|
||||
printf("I2P: SAM bridge ready on port %d (took %ds)\n", samPort, i + 1);
|
||||
return true;
|
||||
}
|
||||
if (!IsRunning()) {
|
||||
lastError = "i2pd exited during start-up before the SAM bridge became ready";
|
||||
printf("I2P: ERROR %s\n", lastError.c_str());
|
||||
running = false;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
lastError = strprintf("i2pd started but SAM port %d not ready after 45s", samPort);
|
||||
printf("I2P: WARNING %s (it may still be building tunnels)\n", lastError.c_str());
|
||||
return true;
|
||||
}
|
||||
|
||||
void CI2PProcess::Stop()
|
||||
{
|
||||
if (fExternal) {
|
||||
// We never launched it; leave the user's router running.
|
||||
running = false;
|
||||
return;
|
||||
}
|
||||
if (!running) return;
|
||||
|
||||
#ifdef WIN32
|
||||
if (hProcess != nullptr) {
|
||||
printf("I2P: stopping i2pd (PID %lu)...\n", processId);
|
||||
TerminateProcess(hProcess, 0);
|
||||
WaitForSingleObject(hProcess, 5000);
|
||||
CloseHandle(hProcess);
|
||||
hProcess = nullptr;
|
||||
}
|
||||
if (hJob != nullptr) {
|
||||
CloseHandle(hJob);
|
||||
hJob = nullptr;
|
||||
}
|
||||
#else
|
||||
if (processId > 0) {
|
||||
printf("I2P: stopping i2pd (PID %d)...\n", processId);
|
||||
kill(processId, SIGTERM);
|
||||
for (int i = 0; i < 50; i++) {
|
||||
int status;
|
||||
pid_t result = waitpid(processId, &status, WNOHANG);
|
||||
if (result != 0) break;
|
||||
MilliSleep(100);
|
||||
}
|
||||
kill(processId, SIGKILL);
|
||||
waitpid(processId, nullptr, 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
processId = 0;
|
||||
running = false;
|
||||
printf("I2P: i2pd stopped\n");
|
||||
}
|
||||
|
||||
bool CI2PProcess::IsRunning()
|
||||
{
|
||||
if (fExternal) return true;
|
||||
if (!running) return false;
|
||||
|
||||
#ifdef WIN32
|
||||
if (hProcess == nullptr) return false;
|
||||
DWORD exitCode;
|
||||
if (GetExitCodeProcess(hProcess, &exitCode))
|
||||
return (exitCode == STILL_ACTIVE);
|
||||
return false;
|
||||
#else
|
||||
if (processId <= 0) return false;
|
||||
int status;
|
||||
pid_t result = waitpid(processId, &status, WNOHANG);
|
||||
return (result == 0); // 0 => still running
|
||||
#endif
|
||||
}
|
||||
|
||||
bool StartEmbeddedI2P(const std::string& dataDir, int samPort)
|
||||
{
|
||||
return CI2PProcess::GetInstance()->Start(dataDir, samPort);
|
||||
}
|
||||
|
||||
void StopEmbeddedI2P()
|
||||
{
|
||||
CI2PProcess::GetInstance()->Stop();
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
// Copyright (c) 2024 Triangles developers
|
||||
// I2P Router Process Manager - launches and manages a bundled i2pd binary
|
||||
// Distributed under the MIT/X11 software license
|
||||
//
|
||||
// Mirrors tor_process.cpp: locate an i2pd executable shipped alongside the
|
||||
// wallet (or installed on the system), write an auto-generated config that
|
||||
// enables the SAM bridge, launch it as a managed child process, and shut it
|
||||
// down when the wallet exits. The SAM session in i2p.cpp then connects to it,
|
||||
// so the user does not have to install or run a separate I2P router.
|
||||
|
||||
#ifndef TRIANGLES_I2P_PROCESS_H
|
||||
#define TRIANGLES_I2P_PROCESS_H
|
||||
|
||||
#include <string>
|
||||
|
||||
#ifdef WIN32
|
||||
#ifndef NOMINMAX
|
||||
#define NOMINMAX
|
||||
#endif
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
class CI2PProcess
|
||||
{
|
||||
public:
|
||||
static CI2PProcess* GetInstance();
|
||||
|
||||
CI2PProcess();
|
||||
~CI2PProcess();
|
||||
|
||||
// Bring up the router. If something is already listening on the SAM port we
|
||||
// assume an external router and do not launch our own (fExternal=true).
|
||||
// Returns true if a SAM bridge is (or will shortly be) reachable.
|
||||
bool Start(const std::string& dataDir, int samPort = 7656);
|
||||
|
||||
// Terminate the launched router (no-op for an external one).
|
||||
void Stop();
|
||||
|
||||
bool IsRunning();
|
||||
bool IsExternal() const { return fExternal; }
|
||||
std::string GetLastError() const { return lastError; }
|
||||
std::string GetBinaryPath() const { return binaryPath; }
|
||||
|
||||
private:
|
||||
std::string FindI2pdBinary();
|
||||
bool WriteConfig();
|
||||
static bool CanConnect(const std::string& host, int port);
|
||||
|
||||
int samPort;
|
||||
bool running;
|
||||
bool fExternal;
|
||||
std::string dataDir;
|
||||
std::string binaryPath;
|
||||
std::string confPath;
|
||||
std::string lastError;
|
||||
|
||||
#ifdef WIN32
|
||||
HANDLE hProcess;
|
||||
HANDLE hJob;
|
||||
DWORD processId;
|
||||
#else
|
||||
int processId;
|
||||
#endif
|
||||
};
|
||||
|
||||
// Convenience wrappers for init.cpp.
|
||||
bool StartEmbeddedI2P(const std::string& dataDir, int samPort);
|
||||
void StopEmbeddedI2P();
|
||||
|
||||
#endif // TRIANGLES_I2P_PROCESS_H
|
||||
@@ -19,6 +19,8 @@
|
||||
#include "tor/tor_embedded.h"
|
||||
#include "tor/onion_v3.h"
|
||||
#include "tor/tor_process.h"
|
||||
#include "i2p.h"
|
||||
#include "i2p_process.h"
|
||||
#ifdef ENABLE_ZMQ
|
||||
#include "zmqpublishnotifier.h"
|
||||
#endif
|
||||
@@ -241,6 +243,10 @@ void Shutdown(void* parg)
|
||||
pScriptCheckQueue.reset();
|
||||
}
|
||||
|
||||
// Stop the I2P SAM session and its accept loop, then the i2pd router.
|
||||
StopI2P();
|
||||
StopEmbeddedI2P();
|
||||
|
||||
// NOW safe to destroy Tor state - all threads have stopped
|
||||
ShutdownTorV3();
|
||||
StopEmbeddedTor();
|
||||
@@ -421,6 +427,8 @@ std::string HelpMessage()
|
||||
" -torsocks=<port> " + _("Set embedded or managed Tor SOCKS proxy port (default: 19099)") + "\n" +
|
||||
" -torhiddenservice " + _("Enable the managed Tor hidden service (default: 1)") + "\n" +
|
||||
" -torhsport=<port> " + _("Set embedded or managed Tor hidden service port (default: wallet listen port)") + "\n" +
|
||||
" -i2p " + _("Enable I2P connectivity; auto-launches a bundled i2pd router (default: 1)") + "\n" +
|
||||
" -i2psam=<ip:port> " + _("I2P SAM bridge address; non-loopback disables the bundled router (default: 127.0.0.1:7656)") + "\n" +
|
||||
//" -dns " + _("Allow DNS lookups for -addnode, -seednode and -connect") + "\n" +
|
||||
" -port=<port> " + _("Listen for connections on <port> (default: 24112 or testnet: 24111)") + "\n" +
|
||||
" -maxconnections=<n> " + _("Maintain at most <n> connections to peers (default: 125)") + "\n" +
|
||||
@@ -1437,6 +1445,45 @@ bool AppInit2()
|
||||
if (!NewThread(ThreadTorMaintenance, nullptr))
|
||||
printf("Warning: ThreadTorMaintenance could not be started\n");
|
||||
}
|
||||
|
||||
// Bring up I2P (SAM) transport alongside Tor so the wallet has both a
|
||||
// .onion and a .b32.i2p address. On by default; disable with -i2p=0.
|
||||
// A bundled i2pd router is launched automatically (mirroring embedded
|
||||
// Tor); if -i2psam points at a non-loopback bridge, or a router is
|
||||
// already running, we use that instead.
|
||||
if (GetBoolArg("-i2p", true)) {
|
||||
int64_t nI2PStart = GetTimeMillis();
|
||||
|
||||
// Resolve the SAM endpoint (default 127.0.0.1:7656).
|
||||
std::string sam = GetArg("-i2psam", "127.0.0.1:7656");
|
||||
int samPort = I2P_DEFAULT_SAM_PORT;
|
||||
std::string samHost = "127.0.0.1";
|
||||
SplitHostPort(sam, samPort, samHost);
|
||||
if (samPort <= 0) samPort = I2P_DEFAULT_SAM_PORT;
|
||||
bool loopback = samHost.empty() || samHost == "127.0.0.1" || samHost == "localhost";
|
||||
|
||||
// Auto-launch our own i2pd only when the bridge is local.
|
||||
if (loopback) {
|
||||
uiInterface.InitMessage(_("Starting the I2P router..."));
|
||||
if (!StartEmbeddedI2P((GetDataDir() / "i2pd").string(), samPort)) {
|
||||
printf("NOTICE: bundled I2P router unavailable (%s).\n",
|
||||
CI2PProcess::GetInstance()->GetLastError().c_str());
|
||||
printf(" I2P will use an external router if one is running on %s.\n", sam.c_str());
|
||||
}
|
||||
}
|
||||
|
||||
uiInterface.InitMessage(_("Connecting to the I2P network..."));
|
||||
bool i2pStarted = StartI2P();
|
||||
StartupPerfLog("i2p_start", GetTimeMillis() - nI2PStart, strprintf("started=%d", i2pStarted));
|
||||
if (i2pStarted) {
|
||||
SetReachable(NET_I2P, true);
|
||||
std::string i2pAddr = CI2PSession::GetInstance()->GetB32Address();
|
||||
printf("I2P network enabled. Our address: %s\n", i2pAddr.c_str());
|
||||
} else {
|
||||
printf("NOTICE: I2P not available this session; continuing with Tor only\n");
|
||||
StopEmbeddedI2P();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ********************************************************* Step 9: import blocks
|
||||
|
||||
@@ -3831,6 +3831,18 @@ bool FastImportBlockFile()
|
||||
int nApplied = 0;
|
||||
for (CBlockIndex* pindex : vMain)
|
||||
{
|
||||
// Genesis (height 0) is a hardcoded special block that is not
|
||||
// re-read from disk this way; it contributes nothing to supply
|
||||
// and the genesis-walk audit skips it identically. Carry the
|
||||
// running supply (0) forward and move on.
|
||||
if (pindex->nHeight == 0)
|
||||
{
|
||||
pindex->nMint = 0;
|
||||
pindex->nMoneySupply = nRunningSupply; // still 0 here
|
||||
txdb.WriteBlockIndex(CDiskBlockIndex(pindex));
|
||||
continue;
|
||||
}
|
||||
|
||||
CBlock blockMain;
|
||||
if (!blockMain.ReadFromDisk(pindex))
|
||||
return error("FastImportBlockFile: ReadFromDisk failed at height %d", pindex->nHeight);
|
||||
|
||||
+85
-7
@@ -11,6 +11,7 @@
|
||||
#include "addrman.h"
|
||||
#include "ui_interface.h"
|
||||
#include "onionseed.h"
|
||||
#include "i2p.h"
|
||||
|
||||
#include <openssl/ssl.h>
|
||||
#include <openssl/err.h>
|
||||
@@ -494,14 +495,26 @@ CNode* FindNode(const CService& addr)
|
||||
|
||||
CNode* ConnectNode(CAddress addrConnect, const char *pszDest)
|
||||
{
|
||||
// TOR-NATIVE: Reject all non-.onion addresses
|
||||
// PRIVACY-NATIVE: only anonymous networks are allowed. Accept Tor (.onion)
|
||||
// and I2P (.i2p / .b32.i2p); reject everything else (clearnet).
|
||||
std::string addrStr = pszDest ? std::string(pszDest) : addrConnect.ToStringIP();
|
||||
if (addrStr.find(".onion") == std::string::npos) {
|
||||
bool fI2P = (addrStr.find(".i2p") != std::string::npos);
|
||||
if (!fI2P && addrStr.find(".onion") == std::string::npos) {
|
||||
if (fDebug)
|
||||
printf("ConnectNode(): REJECTED non-onion address: %s (Tor-native mode)\n", addrStr.c_str());
|
||||
printf("ConnectNode(): REJECTED non-anonymous address: %s (privacy-native mode)\n", addrStr.c_str());
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// For I2P make sure addrConnect carries the destination so the resulting
|
||||
// CNode is labelled correctly even when we were given a bare pszDest.
|
||||
if (fI2P && !addrConnect.IsI2P()) {
|
||||
std::string i2pHost = addrStr;
|
||||
size_t i2pEnd = i2pHost.find(".i2p");
|
||||
if (i2pEnd != std::string::npos)
|
||||
i2pHost = i2pHost.substr(0, i2pEnd + 4);
|
||||
addrConnect.SetSpecial(i2pHost);
|
||||
}
|
||||
|
||||
if (pszDest == nullptr) {
|
||||
if (IsLocal(addrConnect))
|
||||
return nullptr;
|
||||
@@ -525,8 +538,20 @@ CNode* ConnectNode(CAddress addrConnect, const char *pszDest)
|
||||
pszDest ? 0 : (double)(GetAdjustedTime() - addrConnect.nTime)/3600.0);
|
||||
|
||||
// Connect
|
||||
SOCKET hSocket;
|
||||
if (pszDest ? ConnectSocketByName(addrConnect, hSocket, pszDest, GetDefaultPort()) : ConnectSocket(addrConnect, hSocket))
|
||||
SOCKET hSocket = INVALID_SOCKET;
|
||||
bool fConnected;
|
||||
if (fI2P) {
|
||||
// Route through the I2P SAM session. Strip any :port suffix; I2P peers
|
||||
// are reached purely by destination.
|
||||
std::string i2pDest = addrStr;
|
||||
size_t i2pEnd = i2pDest.find(".i2p");
|
||||
if (i2pEnd != std::string::npos)
|
||||
i2pDest = i2pDest.substr(0, i2pEnd + 4);
|
||||
fConnected = CI2PSession::GetInstance()->Connect(i2pDest, hSocket);
|
||||
} else {
|
||||
fConnected = pszDest ? ConnectSocketByName(addrConnect, hSocket, pszDest, GetDefaultPort()) : ConnectSocket(addrConnect, hSocket);
|
||||
}
|
||||
if (fConnected)
|
||||
{
|
||||
addrman.Attempt(addrConnect);
|
||||
|
||||
@@ -561,6 +586,54 @@ CNode* ConnectNode(CAddress addrConnect, const char *pszDest)
|
||||
}
|
||||
}
|
||||
|
||||
// Adopt a connected I2P SAM data socket (from the accept loop in i2p.cpp) as an
|
||||
// inbound peer. The socket arrives in blocking mode; switch it to non-blocking
|
||||
// to match the rest of the socket handler, then register the node.
|
||||
void AddI2PInboundNode(SOCKET hSocket, const CAddress& addr)
|
||||
{
|
||||
if (hSocket == INVALID_SOCKET)
|
||||
return;
|
||||
|
||||
if (CNode::IsBanned(addr)) {
|
||||
printf("I2P inbound from %s dropped (banned)\n", addr.ToString().c_str());
|
||||
closesocket(hSocket);
|
||||
return;
|
||||
}
|
||||
|
||||
// Honour the inbound connection limit.
|
||||
int nInbound = 0;
|
||||
{
|
||||
LOCK(cs_vNodes);
|
||||
for (CNode* pnode : vNodes)
|
||||
if (pnode->fInbound)
|
||||
nInbound++;
|
||||
}
|
||||
int nMaxInbound = GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS;
|
||||
if (nInbound >= nMaxInbound) {
|
||||
printf("I2P inbound from %s dropped (too many inbound)\n", addr.ToString().c_str());
|
||||
closesocket(hSocket);
|
||||
return;
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
u_long nOne = 1;
|
||||
if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
|
||||
printf("AddI2PInboundNode() : ioctlsocket non-blocking setting failed, error %d\n", WSAGetLastError());
|
||||
#else
|
||||
if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
|
||||
printf("AddI2PInboundNode() : fcntl non-blocking setting failed, error %d\n", errno);
|
||||
#endif
|
||||
|
||||
printf("accepted I2P connection %s\n", addr.ToString().c_str());
|
||||
CNode* pnode = new CNode(hSocket, addr, "", true);
|
||||
pnode->AddRef();
|
||||
pnode->nTimeConnected = GetTime();
|
||||
{
|
||||
LOCK(cs_vNodes);
|
||||
vNodes.push_back(pnode);
|
||||
}
|
||||
}
|
||||
|
||||
void CNode::CloseSocketDisconnect()
|
||||
{
|
||||
fDisconnect = true;
|
||||
@@ -1726,11 +1799,16 @@ bool ThreadHTTPSeedFetch2(void* parg)
|
||||
|
||||
// For .onion addresses, the last colon before port is after ".onion"
|
||||
size_t onionPos = addrStr.find(".onion:");
|
||||
size_t i2pPos = addrStr.find(".b32.i2p:");
|
||||
if (onionPos != std::string::npos) {
|
||||
port = atoi(addrStr.substr(onionPos + 7).c_str());
|
||||
addrStr = addrStr.substr(0, onionPos + 6); // keep ".onion"
|
||||
} else if (addrStr.find(".onion") == std::string::npos) {
|
||||
// Tor-native: skip non-.onion addresses
|
||||
} else if (i2pPos != std::string::npos) {
|
||||
port = atoi(addrStr.substr(i2pPos + 9).c_str());
|
||||
addrStr = addrStr.substr(0, i2pPos + 8); // keep ".b32.i2p"
|
||||
} else if (addrStr.find(".onion") == std::string::npos &&
|
||||
addrStr.find(".i2p") == std::string::npos) {
|
||||
// Privacy-native: skip clearnet addresses
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
@@ -35,6 +35,8 @@ void AddressCurrentlyConnected(const CService& addr);
|
||||
CNode* FindNode(const CNetAddr& ip);
|
||||
CNode* FindNode(const CService& ip);
|
||||
CNode* ConnectNode(CAddress addrConnect, const char *strDest = nullptr);
|
||||
// Adopt a connected I2P SAM data socket as an inbound peer (called from i2p.cpp).
|
||||
void AddI2PInboundNode(SOCKET hSocket, const CAddress& addr);
|
||||
void MapPort();
|
||||
unsigned short GetListenPort();
|
||||
bool BindListenPort(const CService &bindAddr, std::string& strError=REF(std::string()));
|
||||
|
||||
+45
-3
@@ -600,6 +600,7 @@ void CNetAddr::Init()
|
||||
memset(ip, 0, sizeof(ip));
|
||||
memset(tor_v3_pubkey, 0, sizeof(tor_v3_pubkey));
|
||||
m_is_tor_v3 = false;
|
||||
m_is_i2p = false;
|
||||
}
|
||||
|
||||
void CNetAddr::SetIP(const CNetAddr& ipIn)
|
||||
@@ -607,6 +608,7 @@ void CNetAddr::SetIP(const CNetAddr& ipIn)
|
||||
memcpy(ip, ipIn.ip, sizeof(ip));
|
||||
memcpy(tor_v3_pubkey, ipIn.tor_v3_pubkey, sizeof(tor_v3_pubkey));
|
||||
m_is_tor_v3 = ipIn.m_is_tor_v3;
|
||||
m_is_i2p = ipIn.m_is_i2p;
|
||||
}
|
||||
|
||||
static const unsigned char pchOnionCat[] = {0xFD,0x87,0xD8,0x7E,0xEB,0x43};
|
||||
@@ -650,6 +652,22 @@ bool CNetAddr::SetSpecial(const std::string &strName)
|
||||
ip[i + sizeof(pchGarliCat)] = vchAddr[i];
|
||||
return true;
|
||||
}
|
||||
// Modern I2P base32 address: 52 base32 chars = SHA-256(destination) (32 bytes)
|
||||
// rendered as "<b32>.b32.i2p". Store the hash and flag this as an I2P address.
|
||||
if (strName.size()>8 && strName.substr(strName.size() - 8, 8) == ".b32.i2p") {
|
||||
std::string addrPart = strName.substr(0, strName.size() - 8);
|
||||
std::vector<unsigned char> vchAddr = DecodeBase32(addrPart.c_str());
|
||||
if (vchAddr.size() != 32)
|
||||
return false;
|
||||
// Keep the GarliCat prefix in ip[] so legacy reachability checks that
|
||||
// look for unique-local space still treat this as a routable overlay.
|
||||
memcpy(ip, pchGarliCat, sizeof(pchGarliCat));
|
||||
memset(ip + sizeof(pchGarliCat), 0, 16 - sizeof(pchGarliCat));
|
||||
memcpy(tor_v3_pubkey, vchAddr.data(), 32);
|
||||
m_is_i2p = true;
|
||||
m_is_tor_v3 = false;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -772,7 +790,7 @@ bool CNetAddr::IsTorV3() const
|
||||
|
||||
bool CNetAddr::IsI2P() const
|
||||
{
|
||||
return (memcmp(ip, pchGarliCat, sizeof(pchGarliCat)) == 0);
|
||||
return m_is_i2p || (memcmp(ip, pchGarliCat, sizeof(pchGarliCat)) == 0);
|
||||
}
|
||||
|
||||
bool CNetAddr::IsLocal() const
|
||||
@@ -878,6 +896,13 @@ std::string CNetAddr::ToStringIP() const
|
||||
}
|
||||
if (IsTor())
|
||||
return EncodeBase32(&ip[6], 10) + ".onion";
|
||||
if (m_is_i2p) {
|
||||
// Modern I2P: base32 of the 32-byte destination hash, unpadded.
|
||||
std::string b32 = EncodeBase32(tor_v3_pubkey, 32);
|
||||
while (!b32.empty() && b32[b32.size() - 1] == '=')
|
||||
b32.erase(b32.size() - 1);
|
||||
return b32 + ".b32.i2p";
|
||||
}
|
||||
if (IsI2P())
|
||||
return EncodeBase32(&ip[6], 10) + ".oc.b32.i2p";
|
||||
CService serv(*this, 0);
|
||||
@@ -911,12 +936,14 @@ bool operator==(const CNetAddr& a, const CNetAddr& b)
|
||||
{
|
||||
if (a.m_is_tor_v3 || b.m_is_tor_v3)
|
||||
return a.m_is_tor_v3 == b.m_is_tor_v3 && memcmp(a.tor_v3_pubkey, b.tor_v3_pubkey, 32) == 0;
|
||||
if (a.m_is_i2p || b.m_is_i2p)
|
||||
return a.m_is_i2p == b.m_is_i2p && memcmp(a.tor_v3_pubkey, b.tor_v3_pubkey, 32) == 0;
|
||||
return (memcmp(a.ip, b.ip, 16) == 0);
|
||||
}
|
||||
|
||||
bool operator!=(const CNetAddr& a, const CNetAddr& b)
|
||||
{
|
||||
return (memcmp(a.ip, b.ip, 16) != 0);
|
||||
return !(a == b);
|
||||
}
|
||||
|
||||
bool operator<(const CNetAddr& a, const CNetAddr& b)
|
||||
@@ -925,6 +952,10 @@ bool operator<(const CNetAddr& a, const CNetAddr& b)
|
||||
return !a.m_is_tor_v3; // non-v3 sorts before v3
|
||||
if (a.m_is_tor_v3)
|
||||
return memcmp(a.tor_v3_pubkey, b.tor_v3_pubkey, 32) < 0;
|
||||
if (a.m_is_i2p != b.m_is_i2p)
|
||||
return !a.m_is_i2p; // non-i2p sorts before i2p
|
||||
if (a.m_is_i2p)
|
||||
return memcmp(a.tor_v3_pubkey, b.tor_v3_pubkey, 32) < 0;
|
||||
return (memcmp(a.ip, b.ip, 16) < 0);
|
||||
}
|
||||
|
||||
@@ -948,6 +979,17 @@ bool CNetAddr::GetIn6Addr(struct in6_addr* pipv6Addr) const
|
||||
// no two connections will be attempted to addresses with the same group
|
||||
std::vector<unsigned char> CNetAddr::GetGroup() const
|
||||
{
|
||||
// Modern I2P addresses keep their identifying bytes in the 32-byte
|
||||
// destination-hash field (ip[] only holds the overlay prefix), so derive
|
||||
// the group from the hash to keep peers in distinct groups.
|
||||
if (m_is_i2p) {
|
||||
std::vector<unsigned char> vch;
|
||||
vch.push_back(NET_I2P);
|
||||
vch.push_back(tor_v3_pubkey[0]);
|
||||
vch.push_back(tor_v3_pubkey[1]);
|
||||
return vch;
|
||||
}
|
||||
|
||||
std::vector<unsigned char> vchRet;
|
||||
int nClass = NET_IPV6;
|
||||
int nStartByte = 0;
|
||||
@@ -1022,7 +1064,7 @@ std::vector<unsigned char> CNetAddr::GetGroup() const
|
||||
uint64_t CNetAddr::GetHash() const
|
||||
{
|
||||
uint256 hash;
|
||||
if (m_is_tor_v3)
|
||||
if (m_is_tor_v3 || m_is_i2p)
|
||||
hash = Hash(&tor_v3_pubkey[0], &tor_v3_pubkey[32]);
|
||||
else
|
||||
hash = Hash(&ip[0], &ip[16]);
|
||||
|
||||
+7
-1
@@ -36,8 +36,12 @@ class CNetAddr
|
||||
{
|
||||
protected:
|
||||
unsigned char ip[16]; // in network byte order
|
||||
unsigned char tor_v3_pubkey[32]; // Ed25519 public key for Tor v3 onion addresses
|
||||
// For Tor v3 this holds the 32-byte Ed25519 public key. When m_is_i2p is
|
||||
// set it instead holds the 32-byte SHA-256 of the I2P destination (the
|
||||
// value rendered as the ".b32.i2p" address). A CNetAddr is never both.
|
||||
unsigned char tor_v3_pubkey[32];
|
||||
bool m_is_tor_v3;
|
||||
bool m_is_i2p;
|
||||
|
||||
public:
|
||||
CNetAddr();
|
||||
@@ -90,6 +94,7 @@ class CNetAddr
|
||||
READWRITE(FLATDATA(ip));
|
||||
READWRITE(FLATDATA(tor_v3_pubkey));
|
||||
READWRITE(m_is_tor_v3);
|
||||
READWRITE(m_is_i2p);
|
||||
)
|
||||
};
|
||||
|
||||
@@ -133,6 +138,7 @@ class CService : public CNetAddr
|
||||
READWRITE(FLATDATA(ip));
|
||||
READWRITE(FLATDATA(tor_v3_pubkey));
|
||||
READWRITE(m_is_tor_v3);
|
||||
READWRITE(m_is_i2p);
|
||||
unsigned short portN = htons(port);
|
||||
READWRITE(portN);
|
||||
if (fRead)
|
||||
|
||||
@@ -1412,6 +1412,34 @@ QLabel {
|
||||
</property>
|
||||
</spacer>
|
||||
</item>
|
||||
<item>
|
||||
<layout class="QVBoxLayout" name="verticalLayout_anon_addr">
|
||||
<property name="spacing">
|
||||
<number>0</number>
|
||||
</property>
|
||||
<item>
|
||||
<widget class="QLabel" name="label_i2p">
|
||||
<property name="font">
|
||||
<font>
|
||||
<pointsize>8</pointsize>
|
||||
<weight>75</weight>
|
||||
<bold>true</bold>
|
||||
</font>
|
||||
</property>
|
||||
<property name="cursor">
|
||||
<cursorShape>PointingHandCursor</cursorShape>
|
||||
</property>
|
||||
<property name="toolTip">
|
||||
<string>Click to copy .b32.i2p address</string>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string notr="true"/>
|
||||
</property>
|
||||
<property name="textInteractionFlags">
|
||||
<set>Qt::NoTextInteraction</set>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item>
|
||||
<widget class="QLabel" name="label_onion">
|
||||
<property name="font">
|
||||
@@ -1435,6 +1463,8 @@ QLabel {
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
</layout>
|
||||
</item>
|
||||
<item>
|
||||
<spacer name="horizontalSpacer_onion">
|
||||
<property name="orientation">
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 477 B After Width: | Height: | Size: 844 B |
Binary file not shown.
|
Before Width: | Height: | Size: 3.6 KiB After Width: | Height: | Size: 7.6 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 477 B After Width: | Height: | Size: 844 B |
Binary file not shown.
|
Before Width: | Height: | Size: 795 B After Width: | Height: | Size: 1.5 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 115 KiB After Width: | Height: | Size: 117 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 20 KiB After Width: | Height: | Size: 17 KiB |
@@ -43,6 +43,7 @@
|
||||
#include "wallet.h"
|
||||
#include "tor/tor_embedded.h"
|
||||
#include "tor/onion_v3.h"
|
||||
#include "i2p.h"
|
||||
|
||||
#ifdef Q_OS_MAC
|
||||
#include "macdockiconhandler.h"
|
||||
@@ -348,6 +349,12 @@ TrianglesGUI::TrianglesGUI(bool fIsTestnet, QWidget *parent):
|
||||
labelOnionAddress->setCursor(Qt::PointingHandCursor);
|
||||
labelOnionAddress->installEventFilter(this);
|
||||
|
||||
// I2P address, stacked directly above the .onion address (click to copy)
|
||||
labelI2PAddress = ui->label_i2p;
|
||||
labelI2PAddress->setVisible(false);
|
||||
labelI2PAddress->setCursor(Qt::PointingHandCursor);
|
||||
labelI2PAddress->installEventFilter(this);
|
||||
|
||||
// V3 indicator next to staking icon (hidden until onion is active)
|
||||
labelV3Icon = ui->label_v3;
|
||||
labelV3Icon->setVisible(false);
|
||||
@@ -357,6 +364,11 @@ TrianglesGUI::TrianglesGUI(bool fIsTestnet, QWidget *parent):
|
||||
timerOnion->start(5000);
|
||||
updateOnionAddress();
|
||||
|
||||
QTimer *timerI2P = new QTimer(this);
|
||||
connect(timerI2P, SIGNAL(timeout()), this, SLOT(updateI2PAddress()));
|
||||
timerI2P->start(5000);
|
||||
updateI2PAddress();
|
||||
|
||||
QTimer *timerShutdown = new QTimer(this);
|
||||
connect(timerShutdown, SIGNAL(timeout()), this, SLOT(detectShutdown()));
|
||||
timerShutdown->start(200);
|
||||
@@ -1327,6 +1339,16 @@ bool TrianglesGUI::eventFilter(QObject *object, QEvent *event)
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (object == labelI2PAddress && event->type() == QEvent::MouseButtonPress)
|
||||
{
|
||||
QString addr = labelI2PAddress->text();
|
||||
if (!addr.isEmpty())
|
||||
{
|
||||
QApplication::clipboard()->setText(addr);
|
||||
QToolTip::showText(QCursor::pos(), tr("Copied!"), labelI2PAddress);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return QMainWindow::eventFilter(object, event);
|
||||
}
|
||||
|
||||
@@ -1453,6 +1475,7 @@ void TrianglesGUI::menuOperationsRequested()
|
||||
QAction* unlockWalletStaking = menu.addAction(QIcon(":/menu_16/unlock"), tr("&Unlock Wallet...").remove('&').remove("..."));
|
||||
QAction* lockWallet = menu.addAction(QIcon(":/menu_16/lock"), tr("&Lock Wallet...").remove('&').remove("..."));
|
||||
QAction* changePassword = menu.addAction(QIcon(":/menu_16/passphrase"), tr("&Change Passphrase...").remove('&').remove("..."));
|
||||
QAction* hdSeed = menu.addAction(QIcon(":/menu_16/passphrase"), tr("Seed Phrase (HD Backup)..."));
|
||||
QAction* signMessage = menu.addAction(QIcon(":/menu_16/sign"), tr("Sign &message...").remove('&').remove("..."));
|
||||
QAction* verifySignature = menu.addAction(QIcon(":/menu_16/verify"), tr("&Verify message...").remove('&').remove("..."));
|
||||
|
||||
@@ -1513,6 +1536,10 @@ void TrianglesGUI::menuOperationsRequested()
|
||||
if (walletModel->getEncryptionStatus() == WalletModel::Unlocked || walletModel->getEncryptionStatus() == WalletModel::Locked)
|
||||
changePassphrase();
|
||||
}
|
||||
else if (selected == hdSeed)
|
||||
{
|
||||
hdSeedManager();
|
||||
}
|
||||
else if (selected == signMessage)
|
||||
{
|
||||
gotoSignMessageTab();
|
||||
@@ -1798,6 +1825,32 @@ void TrianglesGUI::updateOnionAddress()
|
||||
labelOnionAddress->setVisible(true);
|
||||
}
|
||||
|
||||
void TrianglesGUI::updateI2PAddress()
|
||||
{
|
||||
if (!labelI2PAddress)
|
||||
return;
|
||||
|
||||
std::string i2pAddress;
|
||||
if (CI2PSession::GetInstance()->IsActive())
|
||||
i2pAddress = CI2PSession::GetInstance()->GetB32Address();
|
||||
|
||||
// Respect the same visibility preference as the onion address.
|
||||
if (clientModel && clientModel->getOptionsModel() &&
|
||||
!clientModel->getOptionsModel()->getShowOnionAddress()) {
|
||||
labelI2PAddress->setVisible(false);
|
||||
return;
|
||||
}
|
||||
|
||||
if (i2pAddress.empty()) {
|
||||
labelI2PAddress->setVisible(false);
|
||||
return;
|
||||
}
|
||||
|
||||
labelI2PAddress->setText(QString::fromStdString(i2pAddress));
|
||||
labelI2PAddress->setToolTip(tr("This wallet's I2P .b32.i2p address. Selectable — right-click to copy."));
|
||||
labelI2PAddress->setVisible(true);
|
||||
}
|
||||
|
||||
|
||||
void TrianglesGUI::on_bHelp_clicked()
|
||||
{
|
||||
|
||||
@@ -110,6 +110,7 @@ private:
|
||||
QLabel *labelConnectionsIcon;
|
||||
QLabel *labelBlocksIcon;
|
||||
QLabel *labelOnionAddress;
|
||||
QLabel *labelI2PAddress;
|
||||
QLabel *labelV3Icon;
|
||||
QLabel *progressBarLabel;
|
||||
QProgressBar *progressBar;
|
||||
@@ -178,6 +179,7 @@ public slots:
|
||||
void setWalletTransactionSyncState(bool syncing);
|
||||
void setWalletTransactionSyncProgress(bool syncing, int pendingNotifications);
|
||||
void updateOnionAddress();
|
||||
void updateI2PAddress();
|
||||
|
||||
/** Notify the user of an error in the network or transaction handling code. */
|
||||
void error(const QString &title, const QString &message, bool modal);
|
||||
|
||||
@@ -10,6 +10,9 @@
|
||||
#include "db.h"
|
||||
#include "walletdb.h"
|
||||
#include "net_bootstrap.h"
|
||||
#include "i2p.h"
|
||||
#include "tor/onion_v3.h"
|
||||
#include "tor/tor_embedded.h"
|
||||
|
||||
using namespace json_spirit;
|
||||
using namespace std;
|
||||
@@ -34,12 +37,34 @@ Value getnetworkinfo(const Array& params, bool fHelp)
|
||||
healthObj.push_back(Pair("lastblocktime", static_cast<int64_t>(health.lastBlockTime)));
|
||||
healthObj.push_back(Pair("networkmode", "tor_native"));
|
||||
|
||||
// Tor .onion address (wallet hidden service).
|
||||
std::string onionAddress = CTorV3Manager::GetInstance()->GetWalletOnionAddress();
|
||||
if (onionAddress.empty())
|
||||
onionAddress = CTorEmbedded::GetInstance()->GetOnionAddress();
|
||||
|
||||
// I2P session state and .b32.i2p address.
|
||||
CI2PSession* i2p = CI2PSession::GetInstance();
|
||||
int nI2PPeers = 0;
|
||||
{
|
||||
LOCK(cs_vNodes);
|
||||
for (CNode* pnode : vNodes)
|
||||
if (pnode->addr.IsI2P())
|
||||
nI2PPeers++;
|
||||
}
|
||||
Object i2pObj;
|
||||
i2pObj.push_back(Pair("enabled", i2p->IsEnabled()));
|
||||
i2pObj.push_back(Pair("active", i2p->IsActive()));
|
||||
i2pObj.push_back(Pair("address", i2p->GetB32Address()));
|
||||
i2pObj.push_back(Pair("peers", nI2PPeers));
|
||||
|
||||
Object obj;
|
||||
obj.push_back(Pair("version", FormatFullVersion()));
|
||||
obj.push_back(Pair("protocolversion", (int)PROTOCOL_VERSION));
|
||||
obj.push_back(Pair("connections", (int)vNodes.size()));
|
||||
obj.push_back(Pair("proxy", (proxy.first.IsValid() ? proxy.first.ToStringIPPort() : string())));
|
||||
obj.push_back(Pair("ip", addrSeenByPeer.ToStringIP()));
|
||||
obj.push_back(Pair("toraddress", onionAddress));
|
||||
obj.push_back(Pair("i2p", i2pObj));
|
||||
obj.push_back(Pair("localservices", strprintf("%016"PRIx64, nLocalServices)));
|
||||
obj.push_back(Pair("testnet", fTestNet));
|
||||
obj.push_back(Pair("networkhealth", healthObj));
|
||||
|
||||
@@ -9,6 +9,9 @@
|
||||
#include "init.h"
|
||||
#include "base58.h"
|
||||
#include "smessage.h"
|
||||
#include "i2p.h"
|
||||
#include "tor/onion_v3.h"
|
||||
#include "tor/tor_embedded.h"
|
||||
|
||||
using namespace json_spirit;
|
||||
using namespace std;
|
||||
@@ -100,6 +103,13 @@ Value getinfo(const Array& params, bool fHelp)
|
||||
obj.push_back(Pair("proxy", (proxy.first.IsValid() ? proxy.first.ToStringIPPort() : string())));
|
||||
obj.push_back(Pair("ip", addrSeenByPeer.ToStringIP()));
|
||||
|
||||
// Anonymous network identities.
|
||||
std::string onionAddress = CTorV3Manager::GetInstance()->GetWalletOnionAddress();
|
||||
if (onionAddress.empty())
|
||||
onionAddress = CTorEmbedded::GetInstance()->GetOnionAddress();
|
||||
obj.push_back(Pair("toraddress", onionAddress));
|
||||
obj.push_back(Pair("i2paddress", CI2PSession::GetInstance()->GetB32Address()));
|
||||
|
||||
diff.push_back(Pair("proof-of-work", GetDifficulty()));
|
||||
diff.push_back(Pair("proof-of-stake", GetDifficulty(GetLastBlockIndex(pindexBest, true))));
|
||||
obj.push_back(Pair("difficulty", diff));
|
||||
|
||||
Reference in New Issue
Block a user