Package net.i2p.i2ptunnel

Class I2PTunnel

  • All Implemented Interfaces:
    Logging, EventDispatcher
    public class I2PTunnel
extends EventDispatcherImpl
implements Logging
    An I2PTunnel tracks one or more I2PTunnelTasks and one or more I2PSessions. Usually one of each. TODO: Most events are not listened to elsewhere, so error propagation is poor

    • Field Detail

      • ownDest

        public boolean ownDest

      • port

        public String port
        the I2CP port, non-null

      • host

        public String host
        the I2CP host, non-null

      • listenHost

        public String listenHost
        the listen-on host. Sadly the listen-on port does not have a field.

      • readTimeout

        public long readTimeout

      • filterDefinition

        public String filterDefinition
        Absolute path to filter definition file
        Since:
        0.9.40

    • Method Detail

      • main

        public static void main​(String[] args)

      • getSessions

        List<I2PSession> getSessions()
        Returns:
        A copy, unmodifiable, non-null

      • addSession

        void addSession​(I2PSession session)
        Parameters:
        session - null ok

      • removeSession

        void removeSession​(I2PSession session)
        Parameters:
        session - null ok

      • getClientOptions

        public Properties getClientOptions()
        Generic options used for clients and servers. NOT a copy, Do NOT modify for per-connection options, make a copy.
        Returns:
        non-null, NOT a copy, do NOT modify for per-connection options

      • getController

        TunnelController getController()
        TunnelController that constructed this, or null.
        Returns:
        controller or null
        Since:
        0.9.48

      • runCommand

        public void runCommand​(String cmd,
                       Logging l)

      • runClientOptions

        public void runClientOptions​(String[] args,
                             Logging l)
        Configure the extra I2CP options to use in any subsequent I2CP sessions. Generic options used for clients and servers Usage: "clientoptions[ key=value]*" . Sets the event "clientoptions_onResult" = "ok" after completion. Deprecated To be made private, use setClientOptions(). This does NOT update a running TunnelTask.
        Parameters:
        args - each args[i] is a key=value pair to add to the options
        l - logger to receive events and output

      • setClientOptions

        public void setClientOptions​(Properties opts)
        Generic options used for clients and servers. This DOES update a running TunnelTask, but NOT the session. A more efficient runClientOptions(). Defaults in opts properties are not recommended, they may or may not be honored.
        Parameters:
        opts - non-null
        Since:
        0.9.1

      • runServer

        public void runServer​(String[] args,
                      Logging l)
        Run the server pointing at the host and port specified using the private i2p destination loaded from the specified file.

        Sets the event "serverTaskId" = Integer(taskId) after the tunnel has been started (or -1 on error) Also sets the event "openServerResult" = "ok" or "error" (displaying "Ready!" on the logger after 'ok'). So, success = serverTaskId != -1 and openServerResult = ok.

        Parameters:
        args - {hostname, portNumber, privKeyFilename}
        l - logger to receive events and output
        Throws:
        IllegalArgumentException - on config problem

      • runIrcServer

        public void runIrcServer​(String[] args,
                         Logging l)
        Same args as runServer (we should stop duplicating all this code...)
        Throws:
        IllegalArgumentException - on config problem

      • runHttpServer

        public void runHttpServer​(String[] args,
                          Logging l)
        Run the HTTP server pointing at the host and port specified using the private i2p destination loaded from the specified file, replacing the HTTP headers so that the Host: specified is the one spoofed.

        Sets the event "serverTaskId" = Integer(taskId) after the tunnel has been started (or -1 on error) Also sets the event "openServerResult" = "ok" or "error" (displaying "Ready!" on the logger after 'ok'). So, success = serverTaskId != -1 and openServerResult = ok.

        Parameters:
        args - {hostname, portNumber, spoofedHost, privKeyFilename}
        l - logger to receive events and output
        Throws:
        IllegalArgumentException - on config problem

      • runHttpBidirServer

        public void runHttpBidirServer​(String[] args,
                               Logging l)
        Run the HTTP server pointing at the host and port specified using the private i2p destination loaded from the specified file, replacing the HTTP headers so that the Host: specified is the one spoofed. Also runs an HTTP proxy for bidirectional communications on the same tunnel destination.

        Sets the event "serverTaskId" = Integer(taskId) after the tunnel has been started (or -1 on error) Also sets the event "openServerResult" = "ok" or "error" (displaying "Ready!" on the logger after 'ok'). So, success = serverTaskId != -1 and openServerResult = ok.

        Parameters:
        args - {hostname, portNumber, proxyPortNumber, spoofedHost, privKeyFilename}
        l - logger to receive events and output
        Throws:
        IllegalArgumentException - on config problem

      • runTextServer

        public void runTextServer​(String[] args,
                          Logging l)
        Run the server pointing at the host and port specified using the private i2p destination loaded from the given base64 stream.

        Deprecated? Why run a server with a private destination? Not available from the war GUI Sets the event "serverTaskId" = Integer(taskId) after the tunnel has been started (or -1 on error) Also sets the event "openServerResult" = "ok" or "error" (displaying "Ready!" on the logger after 'ok'). So, success = serverTaskId != -1 and openServerResult = ok.

        Parameters:
        args - {hostname, portNumber, privKeyBase64}
        l - logger to receive events and output
        Throws:
        IllegalArgumentException - on config problem

      • runClient

        public void runClient​(String[] args,
                      Logging l)
        Run the client on the given port number pointing at the specified destination (either the base64 of the destination or file:fileNameContainingDestination). Sets the event "clientTaskId" = Integer(taskId) after the tunnel has been started (or -1 on error) Also sets the event "openClientResult" = "error" or "ok" (before setting the value to "ok" it also adds "Ready! Port #" to the logger as well). In addition, it will also set "clientLocalPort" = Integer port number if the client is listening sharedClient parameter is a String "true" or "false"
        Parameters:
        args - {portNumber, destinationBase64 or "file:filename"[, sharedClient [, privKeyFile]]}
        l - logger to receive events and output
        Throws:
        IllegalArgumentException - on config problem

      • runHttpClient

        public void runHttpClient​(String[] args,
                          Logging l)
        Run an HTTP client on the given port number Sets the event "httpclientTaskId" = Integer(taskId) after the tunnel has been started (or -1 on error). Also sets "httpclientStatus" = "ok" or "error" after the client tunnel has started. parameter sharedClient is a String, either "true" or "false"
        Parameters:
        args - {portNumber[, sharedClient][, proxy to be used for the WWW]}
        l - logger to receive events and output
        Throws:
        IllegalArgumentException - on config problem

      • runConnectClient

        public void runConnectClient​(String[] args,
                             Logging l)
        Run a CONNECT client on the given port number
        Parameters:
        args - {portNumber[, sharedClient][, proxy to be used for the WWW]}
        l - logger to receive events and output
        Throws:
        IllegalArgumentException - on config problem

      • runIrcClient

        public void runIrcClient​(String[] args,
                         Logging l)
        Run an IRC client on the given port number Sets the event "ircclientTaskId" = Integer(taskId) after the tunnel has been started (or -1 on error). Also sets "ircclientStatus" = "ok" or "error" after the client tunnel has started. parameter sharedClient is a String, either "true" or "false"
        Parameters:
        args - {portNumber,destinationBase64 or "file:filename" [, sharedClient [, privKeyFile]]}
        l - logger to receive events and output
        Throws:
        IllegalArgumentException - on config problem

      • runSOCKSTunnel

        public void runSOCKSTunnel​(String[] args,
                           Logging l)
        Run an SOCKS tunnel on the given port number Sets the event "sockstunnelTaskId" = Integer(taskId) after the tunnel has been started (or -1 on error). Also sets "openSOCKSTunnelResult" = "ok" or "error" after the client tunnel has started.
        Parameters:
        args - {portNumber [, sharedClient]} or (portNumber, ignored (false), privKeyFile)
        l - logger to receive events and output
        Throws:
        IllegalArgumentException - on config problem

      • runSOCKSIRCTunnel

        public void runSOCKSIRCTunnel​(String[] args,
                              Logging l)
        Run an SOCKS IRC tunnel on the given port number
        Parameters:
        args - {portNumber [, sharedClient]} or (portNumber, ignored (false), privKeyFile)
        Throws:
        IllegalArgumentException - on config problem
        Since:
        0.7.12

      • runStreamrClient

        public void runStreamrClient​(String[] args,
                             Logging l)
        Streamr client
        Parameters:
        args - {targethost, targetport, destinationString}
        l - logger to receive events and output
        Throws:
        IllegalArgumentException - on config problem

      • runStreamrServer

        public void runStreamrServer​(String[] args,
                             Logging l)
        Streamr server
        Parameters:
        args - {port, privkeyfile}
        l - logger to receive events and output
        Throws:
        IllegalArgumentException - on config problem

      • runListenOn

        public void runListenOn​(String[] args,
                        Logging l)
        Specify the hostname / IP address of the interface that the tunnels should bind to Sets the event "listen_onResult" = "ok" or "error" after the interface has been specified
        Parameters:
        args - {hostname}
        l - logger to receive events and output

      • runReadTimeout

        public void runReadTimeout​(String[] args,
                           Logging l)
        Specify the read timeout going to be used for newly-created I2PSockets Sets the event "read_timeoutResult" = "ok" or "error" after the interface has been specified
        Parameters:
        args - {hostname}
        l - logger to receive events and output

      • runClose

        public void runClose​(String[] args,
                     Logging l)
        Close the given task (or all tasks), optionally forcing them to die a hard death Sets the event "closeResult" = "ok" after the closing is complete
        Parameters:
        args - {jobNumber}, {"forced", jobNumber}, {"forced", "all"}, {"destroy", jobNumber}, {"destroy", "all"}
        l - logger to receive events and output

      • log

        public void log​(String s)
        Log the given message (using both the logging subsystem and standard output...)
        Specified by:
        log in interface Logging

      • destFromName

        @Deprecated
public static Destination destFromName​(String name)
                                throws DataFormatException
        Deprecated.
        Don't use i2ptunnel for lookup! Use I2PAppContext.getGlobalContext().namingService().lookup(name) from i2p.jar
        Generates a Destination from a name. Now only supports base64 names - may support naming servers later. "file:<filename>" is also supported, where filename is a file that either contains a binary Destination structure or the Base64 encoding of that structure. Since file:<filename> isn't really used, this method is deprecated, just call context.namingService.lookup() directly.
        Throws:
        DataFormatException

      • routerDisconnected

        void routerDisconnected()
        Call this whenever we lose touch with the router involuntarily (aka the router is off / crashed / etc)