init

ClientContext.cpp

@@ -303,7 +303,7 @@ namespace client
 						LogPrint (eLogError, "Clients: I2P client tunnel with port ", port, " already exists");
 					numClientTunnels++;
 				}
-				else if (type == I2P_TUNNELS_SECTION_TYPE_SERVER || type == I2P_TUNNELS_SECTION_TYPE_HTTP)
+				else if (type == I2P_TUNNELS_SECTION_TYPE_SERVER || type == I2P_TUNNELS_SECTION_TYPE_HTTP || type == I2P_TUNNELS_SECTION_TYPE_IRC)
 				{	
 					// mandatory params
 					std::string host = section.second.get<std::string> (I2P_SERVER_TUNNEL_HOST);
@@ -324,9 +324,16 @@ namespace client
 					localDestination = FindLocalDestination (k.GetPublic ()->GetIdentHash ());
 					if (!localDestination)		
 						localDestination = CreateNewLocalDestination (k, true, &options);
-					I2PServerTunnel * serverTunnel = (type == I2P_TUNNELS_SECTION_TYPE_HTTP) ? 
-						new I2PServerTunnelHTTP (name, host, port, localDestination, hostOverride, inPort) : 
-						new I2PServerTunnel (name, host, port, localDestination, inPort);
+
+					I2PServerTunnel * serverTunnel;
+					if (type == I2P_TUNNELS_SECTION_TYPE_HTTP) {
+                        serverTunnel = new I2PServerTunnelHTTP (name, host, port, localDestination, inPort);
+               		} else if (type == I2P_TUNNELS_SECTION_TYPE_SERVER) {
+                       	serverTunnel = new I2PServerTunnel (name, host, port, localDestination, inPort);
+               		} else if (type == I2P_TUNNELS_SECTION_TYPE_IRC) {
+                       	serverTunnel = new I2PServerTunnelIRC (name, host, port, localDestination, inPort);
+               		}
+
 					if (accessList.length () > 0)
 					{
 						std::set<i2p::data::IdentHash> idents;

ClientContext.h

@@ -21,6 +21,7 @@ namespace client
 	const char I2P_TUNNELS_SECTION_TYPE_CLIENT[] = "client";
 	const char I2P_TUNNELS_SECTION_TYPE_SERVER[] = "server";
 	const char I2P_TUNNELS_SECTION_TYPE_HTTP[] = "http";
+	const char I2P_TUNNELS_SECTION_TYPE_IRC[] = "irc";
 	const char I2P_CLIENT_TUNNEL_PORT[] = "port";
 	const char I2P_CLIENT_TUNNEL_ADDRESS[] = "address";
 	const char I2P_CLIENT_TUNNEL_DESTINATION[] = "destination";

I2PTunnel.cpp

@@ -234,6 +234,44 @@ namespace client
 		}	
 	}
 
+	I2PTunnelConnectionIRC::I2PTunnelConnectionIRC (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
+        std::shared_ptr<boost::asio::ip::tcp::socket> socket, 
+       	const boost::asio::ip::tcp::endpoint& target, const std::string& host):
+        I2PTunnelConnection (owner, stream, socket, target), m_Host (host), m_From (stream->GetRemoteIdentity ())
+    {
+    }
+
+    void I2PTunnelConnectionIRC::Write (const uint8_t * buf, size_t len)
+    {
+        std::string line;
+        m_OutPacket.str ("");
+        m_InPacket.write ((const char *)buf, len);
+
+        while (!m_InPacket.eof () && !m_InPacket.fail ())
+        {
+                std::getline (m_InPacket, line);
+                auto pos = line.find ("USER");
+                if (pos != std::string::npos && pos == 0)
+                {
+                        pos = line.find (" ");
+                        pos++;
+                        pos = line.find (" ", pos);
+                        pos++;
+                        pos = line.find (" ", pos);
+                        pos++;
+                        auto nextpos = line.find (" ", pos);
+
+                        m_OutPacket << line.substr (0, pos);
+                        m_OutPacket << context.GetAddressBook ().ToAddress (m_From->GetIdentHash ());
+                        m_OutPacket << line.substr (nextpos) << '\n';
+                } else {
+                        m_OutPacket << line << '\n';
+                }
+        }
+        I2PTunnelConnection::Write ((uint8_t *)m_OutPacket.str ().c_str (), m_OutPacket.str ().length ());
+    }
+
+
 	/* This handler tries to stablish a connection with the desired server and dies if it fails to do so */
 	class I2PClientTunnelHandler: public I2PServiceHandler, public std::enable_shared_from_this<I2PClientTunnelHandler>
 	{
@@ -436,5 +474,18 @@ namespace client
 		AddHandler (conn);
 		conn->Connect ();
 	}
+
+    I2PServerTunnelIRC::I2PServerTunnelIRC (const std::string& name, const std::string& address, 
+        int port, std::shared_ptr<ClientDestination> localDestination, int inport):
+            I2PServerTunnel (name, address, port, localDestination, inport)
+    {
+    }
+
+    void I2PServerTunnelIRC::CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream)
+    {
+            auto conn = std::make_shared<I2PTunnelConnectionIRC> (this, stream, std::make_shared<boost::asio::ip::tcp::socket> (GetService ()), GetEndpoint (), GetAddress ());
+            AddHandler (conn);
+            conn->Connect ();
+    }
 }		
 }	

I2PTunnel.h

@@ -80,6 +80,26 @@ namespace client
 			std::shared_ptr<const i2p::data::IdentityEx> m_From;
 	};
 
+	class I2PTunnelConnectionIRC: public I2PTunnelConnection
+    {
+        public:
+
+            I2PTunnelConnectionIRC (I2PService * owner, std::shared_ptr<i2p::stream::Stream> stream,
+                std::shared_ptr<boost::asio::ip::tcp::socket> socket, 
+                const boost::asio::ip::tcp::endpoint& target, const std::string& host); 
+
+        protected:
+
+            void Write (const uint8_t * buf, size_t len);
+
+        private:
+
+            std::string m_Host;
+            std::shared_ptr<const i2p::data::IdentityEx> m_From;
+            std::stringstream m_OutPacket, m_InPacket;
+    };
+
+
 	class I2PClientTunnel: public TCPIPAcceptor
 	{
 		protected:
@@ -163,6 +183,19 @@ namespace client
 
 			std::string m_Host;
 	};
+
+    class I2PServerTunnelIRC: public I2PServerTunnel
+    {
+        public:
+
+            I2PServerTunnelIRC (const std::string& name, const std::string& address, int port, 
+                std::shared_ptr<ClientDestination> localDestination, int inport = 0);   
+
+        private:
+
+            void CreateI2PConnection (std::shared_ptr<i2p::stream::Stream> stream); 
+    };
+
 }
 }