i2pd/Daemon.cpp

357 lines
11 KiB
C++
Raw Normal View History

#include <thread>
2015-11-03 14:15:49 +00:00
#include <memory>
2014-04-20 01:54:34 +00:00
#include "Daemon.h"
2016-01-20 00:00:00 +00:00
#include "Config.h"
2014-04-20 01:54:34 +00:00
#include "Log.h"
#include "FS.h"
2015-11-03 14:15:49 +00:00
#include "Base.h"
2014-10-17 15:42:05 +00:00
#include "version.h"
2014-04-20 01:54:34 +00:00
#include "Transports.h"
#include "NTCPSession.h"
#include "RouterInfo.h"
#include "RouterContext.h"
#include "Tunnel.h"
#include "HTTP.h"
2014-04-20 01:54:34 +00:00
#include "NetDb.h"
#include "Garlic.h"
#include "Streaming.h"
#include "Destination.h"
#include "HTTPServer.h"
2015-11-03 14:15:49 +00:00
#include "I2PControl.h"
2014-10-16 00:52:17 +00:00
#include "ClientContext.h"
2015-12-31 21:02:10 +00:00
#include "Crypto.h"
2015-11-03 14:15:49 +00:00
#include "UPnP.h"
#include "util.h"
2015-11-03 14:15:49 +00:00
2016-10-20 13:12:15 +00:00
#include "Event.h"
#include "Websocket.h"
2014-04-20 01:54:34 +00:00
namespace i2p
{
namespace util
{
class Daemon_Singleton::Daemon_Singleton_Private
2014-04-20 01:54:34 +00:00
{
public:
2015-11-03 14:15:49 +00:00
Daemon_Singleton_Private() {};
~Daemon_Singleton_Private() {};
2016-04-27 00:00:00 +00:00
std::unique_ptr<i2p::http::HTTPServer> httpServer;
2015-11-03 14:15:49 +00:00
std::unique_ptr<i2p::client::I2PControlService> m_I2PControlService;
std::unique_ptr<i2p::transport::UPnP> UPnP;
#ifdef WITH_EVENTS
2016-10-20 13:12:15 +00:00
std::unique_ptr<i2p::event::WebsocketServer> m_WebsocketServer;
#endif
};
2016-06-01 00:00:00 +00:00
Daemon_Singleton::Daemon_Singleton() : isDaemon(false), running(true), d(*new Daemon_Singleton_Private()) {}
Daemon_Singleton::~Daemon_Singleton() {
delete &d;
2016-06-01 00:00:00 +00:00
}
2014-10-17 13:55:41 +00:00
bool Daemon_Singleton::IsService () const
{
2016-01-20 00:00:00 +00:00
bool service = false;
2014-10-17 13:55:41 +00:00
#ifndef _WIN32
2016-01-20 00:00:00 +00:00
i2p::config::GetOption("service", service);
2014-10-17 13:55:41 +00:00
#endif
2016-01-20 00:00:00 +00:00
return service;
2014-10-17 13:55:41 +00:00
}
bool Daemon_Singleton::init(int argc, char* argv[])
{
i2p::config::Init();
i2p::config::ParseCmdline(argc, argv);
std::string config; i2p::config::GetOption("conf", config);
std::string datadir; i2p::config::GetOption("datadir", datadir);
i2p::fs::DetectDataDir(datadir, IsService());
i2p::fs::Init();
datadir = i2p::fs::GetDataDir();
// TODO: drop old name detection in v2.8.0
if (config == "")
2016-02-22 20:17:58 +00:00
{
config = i2p::fs::DataDirPath("i2p.conf");
if (i2p::fs::Exists (config)) {
LogPrint(eLogWarning, "Daemon: please rename i2p.conf to i2pd.conf here: ", config);
} else {
config = i2p::fs::DataDirPath("i2pd.conf");
if (!i2p::fs::Exists (config)) {
// use i2pd.conf only if exists
config = ""; /* reset */
}
}
2016-02-22 20:17:58 +00:00
}
i2p::config::ParseConfig(config);
2016-01-20 00:00:00 +00:00
i2p::config::Finalize();
i2p::config::GetOption("daemon", isDaemon);
2016-03-27 00:17:29 +00:00
std::string logs = ""; i2p::config::GetOption("log", logs);
std::string logfile = ""; i2p::config::GetOption("logfile", logfile);
std::string loglevel = ""; i2p::config::GetOption("loglevel", loglevel);
/* setup logging */
if (isDaemon && (logs == "" || logs == "stdout"))
logs = "file";
i2p::log::Logger().SetLogLevel(loglevel);
if (logs == "file") {
if (logfile == "")
logfile = i2p::fs::DataDirPath("i2pd.log");
LogPrint(eLogInfo, "Log: will send messages to ", logfile);
i2p::log::Logger().SendTo (logfile);
#ifndef _WIN32
} else if (logs == "syslog") {
LogPrint(eLogInfo, "Log: will send messages to syslog");
i2p::log::Logger().SendTo("i2pd", LOG_DAEMON);
#endif
} else {
// use stdout -- default
}
2016-03-28 14:00:00 +00:00
i2p::log::Logger().Ready();
2016-06-29 15:06:51 +00:00
LogPrint(eLogInfo, "i2pd v", VERSION, " starting");
LogPrint(eLogDebug, "FS: main config file: ", config);
LogPrint(eLogDebug, "FS: data directory: ", datadir);
2014-04-20 01:54:34 +00:00
bool precomputation; i2p::config::GetOption("precomputation.elgamal", precomputation);
i2p::crypto::InitCrypto (precomputation);
2016-03-27 00:17:29 +00:00
i2p::context.Init ();
2016-06-29 15:06:51 +00:00
bool ipv6; i2p::config::GetOption("ipv6", ipv6);
bool ipv4; i2p::config::GetOption("ipv4", ipv4);
#ifdef MESHNET
// manual override for meshnet
ipv4 = false;
ipv6 = true;
#endif
2016-06-29 15:59:43 +00:00
uint16_t port; i2p::config::GetOption("port", port);
if (!i2p::config::IsDefault("port"))
{
2016-06-29 15:59:43 +00:00
LogPrint(eLogInfo, "Daemon: accepting incoming connections at port ", port);
i2p::context.UpdatePort (port);
}
2016-03-24 22:44:41 +00:00
i2p::context.SetSupportsV6 (ipv6);
i2p::context.SetSupportsV4 (ipv4);
bool transit; i2p::config::GetOption("notransit", transit);
2016-01-20 00:00:00 +00:00
i2p::context.SetAcceptsTunnels (!transit);
2016-04-20 18:53:50 +00:00
uint16_t transitTunnels; i2p::config::GetOption("limits.transittunnels", transitTunnels);
SetMaxNumTransitTunnels (transitTunnels);
2016-01-20 00:00:00 +00:00
2016-10-24 14:33:46 +00:00
int netID; i2p::config::GetOption("netid", netID);
i2p::context.SetNetID (netID);
2016-01-20 00:00:00 +00:00
bool isFloodfill; i2p::config::GetOption("floodfill", isFloodfill);
2016-03-31 00:00:00 +00:00
if (isFloodfill) {
2016-02-01 23:10:45 +00:00
LogPrint(eLogInfo, "Daemon: router will be floodfill");
i2p::context.SetFloodfill (true);
2016-03-31 00:00:00 +00:00
} else {
2016-02-11 12:50:29 +00:00
i2p::context.SetFloodfill (false);
2016-02-21 01:20:19 +00:00
}
2016-03-31 00:00:00 +00:00
/* this section also honors 'floodfill' flag, if set above */
std::string bandwidth; i2p::config::GetOption("bandwidth", bandwidth);
2016-03-31 01:31:17 +00:00
if (bandwidth.length () > 0)
{
if (bandwidth[0] >= 'K' && bandwidth[0] <= 'X')
{
i2p::context.SetBandwidth (bandwidth[0]);
LogPrint(eLogInfo, "Daemon: bandwidth set to ", i2p::context.GetBandwidthLimit (), "KBps");
}
else
{
auto value = std::atoi(bandwidth.c_str());
if (value > 0)
{
i2p::context.SetBandwidth (value);
LogPrint(eLogInfo, "Daemon: bandwidth set to ", i2p::context.GetBandwidthLimit (), " KBps");
}
else
{
LogPrint(eLogInfo, "Daemon: unexpected bandwidth ", bandwidth, ". Set to 'low'");
i2p::context.SetBandwidth (i2p::data::CAPS_FLAG_LOW_BANDWIDTH2);
}
}
}
else if (isFloodfill)
{
LogPrint(eLogInfo, "Daemon: floodfill bandwidth set to 'extra'");
i2p::context.SetBandwidth (i2p::data::CAPS_FLAG_EXTRA_BANDWIDTH1);
}
else
{
LogPrint(eLogInfo, "Daemon: bandwidth set to 'low'");
i2p::context.SetBandwidth (i2p::data::CAPS_FLAG_LOW_BANDWIDTH2);
}
2014-07-02 17:48:45 +00:00
2016-02-21 01:20:19 +00:00
std::string family; i2p::config::GetOption("family", family);
i2p::context.SetFamily (family);
if (family.length () > 0)
LogPrint(eLogInfo, "Daemon: family set to ", family);
2016-06-17 15:03:33 +00:00
bool trust; i2p::config::GetOption("trust.enabled", trust);
if (trust)
{
LogPrint(eLogInfo, "Daemon: explicit trust enabled");
std::string fam; i2p::config::GetOption("trust.family", fam);
std::string routers; i2p::config::GetOption("trust.routers", routers);
bool restricted = false;
2016-06-17 15:03:33 +00:00
if (fam.length() > 0)
{
std::set<std::string> fams;
size_t pos = 0, comma;
do
{
comma = fam.find (',', pos);
fams.insert (fam.substr (pos, comma != std::string::npos ? comma - pos : std::string::npos));
pos = comma + 1;
}
while (comma != std::string::npos);
i2p::transport::transports.RestrictRoutesToFamilies(fams);
restricted = fams.size() > 0;
}
if (routers.length() > 0) {
std::set<i2p::data::IdentHash> idents;
size_t pos = 0, comma;
do
{
comma = routers.find (',', pos);
i2p::data::IdentHash ident;
ident.FromBase64 (routers.substr (pos, comma != std::string::npos ? comma - pos : std::string::npos));
idents.insert (ident);
pos = comma + 1;
}
while (comma != std::string::npos);
LogPrint(eLogInfo, "Daemon: setting restricted routes to use ", idents.size(), " trusted routesrs");
i2p::transport::transports.RestrictRoutesToRouters(idents);
restricted = idents.size() > 0;
}
if(!restricted)
LogPrint(eLogError, "Daemon: no trusted routers of families specififed");
}
bool hidden; i2p::config::GetOption("trust.hidden", hidden);
if (hidden)
{
LogPrint(eLogInfo, "Daemon: using hidden mode");
i2p::data::netdb.SetHidden(true);
2016-06-17 15:03:33 +00:00
}
return true;
2014-07-02 17:48:45 +00:00
}
bool Daemon_Singleton::start()
{
2015-12-18 12:21:37 +00:00
LogPrint(eLogInfo, "Daemon: starting NetDB");
2014-04-20 01:54:34 +00:00
i2p::data::netdb.Start();
2015-12-18 12:21:37 +00:00
bool upnp; i2p::config::GetOption("upnp.enabled", upnp);
if (upnp) {
d.UPnP = std::unique_ptr<i2p::transport::UPnP>(new i2p::transport::UPnP);
d.UPnP->Start ();
}
2016-06-30 18:24:55 +00:00
bool ntcp; i2p::config::GetOption("ntcp", ntcp);
bool ssu; i2p::config::GetOption("ssu", ssu);
2015-12-18 12:21:37 +00:00
LogPrint(eLogInfo, "Daemon: starting Transports");
if(!ssu) LogPrint(eLogInfo, "Daemon: ssu disabled");
if(!ntcp) LogPrint(eLogInfo, "Daemon: ntcp disabled");
2016-06-17 13:02:12 +00:00
i2p::transport::transports.Start(ntcp, ssu);
2016-06-13 15:34:44 +00:00
if (i2p::transport::transports.IsBoundNTCP() || i2p::transport::transports.IsBoundSSU()) {
LogPrint(eLogInfo, "Daemon: Transports started");
} else {
LogPrint(eLogError, "Daemon: failed to start Transports");
/** shut down netdb right away */
i2p::transport::transports.Stop();
2016-06-13 15:34:44 +00:00
i2p::data::netdb.Stop();
return false;
}
bool http; i2p::config::GetOption("http.enabled", http);
if (http) {
std::string httpAddr; i2p::config::GetOption("http.address", httpAddr);
uint16_t httpPort; i2p::config::GetOption("http.port", httpPort);
LogPrint(eLogInfo, "Daemon: starting HTTP Server at ", httpAddr, ":", httpPort);
d.httpServer = std::unique_ptr<i2p::http::HTTPServer>(new i2p::http::HTTPServer(httpAddr, httpPort));
d.httpServer->Start();
}
2015-12-18 12:21:37 +00:00
2016-06-13 15:34:44 +00:00
2015-12-18 12:21:37 +00:00
LogPrint(eLogInfo, "Daemon: starting Tunnels");
2014-04-20 01:54:34 +00:00
i2p::tunnel::tunnels.Start();
2015-12-18 12:21:37 +00:00
LogPrint(eLogInfo, "Daemon: starting Client");
2014-10-16 00:52:17 +00:00
i2p::client::context.Start ();
2015-12-18 12:21:37 +00:00
// I2P Control Protocol
2016-01-20 00:00:00 +00:00
bool i2pcontrol; i2p::config::GetOption("i2pcontrol.enabled", i2pcontrol);
if (i2pcontrol) {
std::string i2pcpAddr; i2p::config::GetOption("i2pcontrol.address", i2pcpAddr);
uint16_t i2pcpPort; i2p::config::GetOption("i2pcontrol.port", i2pcpPort);
LogPrint(eLogInfo, "Daemon: starting I2PControl at ", i2pcpAddr, ":", i2pcpPort);
d.m_I2PControlService = std::unique_ptr<i2p::client::I2PControlService>(new i2p::client::I2PControlService (i2pcpAddr, i2pcpPort));
2015-11-03 14:15:49 +00:00
d.m_I2PControlService->Start ();
}
#ifdef WITH_EVENTS
2016-06-13 15:34:44 +00:00
2016-10-20 13:12:15 +00:00
bool websocket; i2p::config::GetOption("websockets.enabled", websocket);
if(websocket) {
std::string websocketAddr; i2p::config::GetOption("websockets.address", websocketAddr);
uint16_t websocketPort; i2p::config::GetOption("websockets.port", websocketPort);
LogPrint(eLogInfo, "Daemon: starting Websocket server at ", websocketAddr, ":", websocketPort);
d.m_WebsocketServer = std::unique_ptr<i2p::event::WebsocketServer>(new i2p::event::WebsocketServer (websocketAddr, websocketPort));
d.m_WebsocketServer->Start();
i2p::event::core.SetListener(d.m_WebsocketServer->ToListener());
}
#endif
2014-04-20 01:54:34 +00:00
return true;
}
bool Daemon_Singleton::stop()
{
2016-10-20 13:12:15 +00:00
i2p::event::core.SetListener(nullptr);
2015-12-18 12:21:37 +00:00
LogPrint(eLogInfo, "Daemon: shutting down");
LogPrint(eLogInfo, "Daemon: stopping Client");
2014-10-16 00:52:17 +00:00
i2p::client::context.Stop();
2015-12-18 12:21:37 +00:00
LogPrint(eLogInfo, "Daemon: stopping Tunnels");
2014-04-20 01:54:34 +00:00
i2p::tunnel::tunnels.Stop();
if (d.UPnP) {
d.UPnP->Stop ();
d.UPnP = nullptr;
}
2015-12-18 12:21:37 +00:00
LogPrint(eLogInfo, "Daemon: stopping Transports");
i2p::transport::transports.Stop();
2015-12-18 12:21:37 +00:00
LogPrint(eLogInfo, "Daemon: stopping NetDB");
2014-04-20 01:54:34 +00:00
i2p::data::netdb.Stop();
if (d.httpServer) {
LogPrint(eLogInfo, "Daemon: stopping HTTP Server");
d.httpServer->Stop();
d.httpServer = nullptr;
}
2015-11-03 14:15:49 +00:00
if (d.m_I2PControlService)
{
2015-12-18 12:21:37 +00:00
LogPrint(eLogInfo, "Daemon: stopping I2PControl");
2015-11-03 14:15:49 +00:00
d.m_I2PControlService->Stop ();
d.m_I2PControlService = nullptr;
2016-10-20 13:12:15 +00:00
}
#ifdef WITH_EVENTS
2016-10-20 13:12:15 +00:00
if (d.m_WebsocketServer) {
LogPrint(eLogInfo, "Daemon: stopping Websocket server");
d.m_WebsocketServer->Stop();
d.m_WebsocketServer = nullptr;
}
#endif
2015-12-31 21:02:10 +00:00
i2p::crypto::TerminateCrypto ();
2014-08-14 14:20:22 +00:00
2014-04-20 01:54:34 +00:00
return true;
}
}
2014-04-22 22:37:24 +00:00
}