public ForwardingConfiguration(String addressToBind,
    int portToBind) 
{
        this(addressToBind + ":" + String.valueOf(portToBind), addressToBind,
            portToBind, "[Specified by connecting computer]", -1);
}

Creates a new ForwardingConfiguration object.

Parameters:

addressToBind -

portToBind -

 public ForwardingConfiguration(String name,
    String addressToBind,
    int portToBind,
    String hostToConnect,
    int portToConnect) 
{
                        
        this.addressToBind = addressToBind;
        this.portToBind = portToBind;
        this.name = name;
        this.hostToConnect = hostToConnect;
        this.portToConnect = portToConnect;
}

Creates a new ForwardingConfiguration object.

Parameters:

name -

addressToBind -

portToBind -

hostToConnect -

portToConnect -

 public  void addForwardingConfigurationListener(ForwardingConfigurationListener l) 
{
        listenerList.add(ForwardingConfigurationListener.class, l);
}

 public ForwardingBindingChannel createForwardingBindingChannel(String type,
    String hostToConnect,
    int portToConnect,
    String originatingHost,
    int originatingPort) throws ForwardingConfigurationException 
{
        if (state.getValue() == StartStopState.STOPPED) {
            throw new ForwardingConfigurationException(
                "The forwarding has been stopped");
        }
        if (!type.equals(ForwardingChannel.LOCAL_FORWARDING_CHANNEL) &&
                !type.equals(ForwardingChannel.REMOTE_FORWARDING_CHANNEL) &&
                !type.equals(ForwardingChannel.X11_FORWARDING_CHANNEL)) {
            throw new ForwardingConfigurationException(
                "The channel type must either be " +
                "ForwardingSocketChannel.LOCAL_FORWARDING_CHANNEL_TYPE or " +
                "ForwardingSocketChannel.REMOTE_FORWARDING_CHANNEL_TYPE");
        }
        ForwardingBindingChannel channel;
        if (type.equals(ForwardingChannel.LOCAL_FORWARDING_CHANNEL)) {
            channel = new ForwardingBindingChannel(type, name,
                    getHostToConnect(), getPortToConnect(), originatingHost,
                    originatingPort);
        } else {
            channel = new ForwardingBindingChannel(type, name,
                    getAddressToBind(), getPortToBind(), originatingHost,
                    originatingPort);
        }
        channel.addEventListener(monitor);
        return channel;
}

 public ForwardingIOChannel createForwardingIOChannel(String type,
    String hostToConnect,
    int portToConnect,
    String originatingHost,
    int originatingPort) throws ForwardingConfigurationException 
{
        if (state.getValue() == StartStopState.STOPPED) {
            throw new ForwardingConfigurationException(
                "The forwarding has been stopped");
        }
        if (!type.equals(ForwardingChannel.LOCAL_FORWARDING_CHANNEL) &&
                !type.equals(ForwardingChannel.REMOTE_FORWARDING_CHANNEL) &&
                !type.equals(ForwardingChannel.X11_FORWARDING_CHANNEL)) {
            throw new ForwardingConfigurationException(
                "The channel type must either be " +
                "ForwardingSocketChannel.LOCAL_FORWARDING_CHANNEL_TYPE or " +
                "ForwardingSocketChannel.REMOTE_FORWARDING_CHANNEL_TYPE");
        }
        ForwardingIOChannel channel;
        if (type.equals(ForwardingChannel.LOCAL_FORWARDING_CHANNEL)) {
            channel = new ForwardingIOChannel(type, name, getHostToConnect(),
                    getPortToConnect(), originatingHost, originatingPort);
        } else {
            channel = new ForwardingIOChannel(type, name, getAddressToBind(),
                    getPortToBind(), originatingHost, originatingPort);
        }
        channel.addEventListener(monitor);
        return channel;
}

 public ForwardingSocketChannel createForwardingSocketChannel(String type,
    String hostToConnect,
    int portToConnect,
    String originatingHost,
    int originatingPort) throws ForwardingConfigurationException 
{
        if (state.getValue() == StartStopState.STOPPED) {
            throw new ForwardingConfigurationException(
                "The forwarding has been stopped");
        }
        if (!type.equals(ForwardingChannel.LOCAL_FORWARDING_CHANNEL) &&
                !type.equals(ForwardingChannel.REMOTE_FORWARDING_CHANNEL) &&
                !type.equals(ForwardingChannel.X11_FORWARDING_CHANNEL)) {
            throw new ForwardingConfigurationException(
                "The channel type must either be " +
                "ForwardingSocketChannel.LOCAL_FORWARDING_CHANNEL_TYPE or " +
                "ForwardingSocketChannel.REMOTE_FORWARDING_CHANNEL_TYPE");
        }
        ForwardingSocketChannel channel;
        if (type.equals(ForwardingChannel.LOCAL_FORWARDING_CHANNEL)) {
            channel = new ForwardingSocketChannel(type, name, hostToConnect,
                    portToConnect, originatingHost, originatingPort);
        } else {
            channel = new ForwardingSocketChannel(type, name,
                    getAddressToBind(), getPortToBind(), originatingHost,
                    originatingPort);
        }
        channel.addEventListener(monitor);
        return channel;
}

 public List getActiveForwardingSocketChannels() 
{
        return activeForwardings;
}

 public String getAddressToBind() 
{
        return addressToBind;
}

 public String getHostToConnect() 
{
        return hostToConnect;
}

 public String getName() 
{
        return name;
}

 public int getPortToBind() 
{
        return portToBind;
}

 public int getPortToConnect() 
{
        return portToConnect;
}

 public StartStopState getState() 
{
        return state;
}

 public boolean isForwarding() 
{
        return state.getValue() == StartStopState.STARTED;
}

 public  void removeForwardingConfigurationListener(ForwardingConfigurationListener l) 
{
        listenerList.remove(ForwardingConfigurationListener.class, l);
}

 public  void start() throws IOException 
{
        state.setValue(StartStopState.STARTED);
}

 public  void stop() 
{
        state.setValue(StartStopState.STOPPED);
}