/// <summary>
/// Open a TCPIP forwarding channel to the remote computer. If successful the remote computer will open
/// a socket to the host/port specified and return a channel which can be used to forward TCPIP data
/// from the local computer to the remotley connected socket.<br/>
/// <br/>
/// It should be noted that this is a low level API method and it does not connect the transport to the
/// channel. Future versions of this API will provide a ForwardingClient to automate transfer between
/// the tunnel and a local listening Socket.
/// </summary>
/// <param name="hostname"></param>
/// <param name="port"></param>
/// <param name="listeningAddress"></param>
/// <param name="listeningPort"></param>
/// <param name="originatingHost"></param>
/// <param name="originatingPort"></param>
/// <param name="transport"></param>
/// <param name="listener"></param>
/// <returns></returns>
public SSHTunnel OpenForwardingChannel(System.String hostname,
int port,
System.String listeningAddress,
int listeningPort,
System.String originatingHost,
int originatingPort,
Object transport,
ChannelStateListener listener)
{
try
{
SSH2ForwardingChannel tunnel = new SSH2ForwardingChannel(
SSH2ForwardingChannel.LOCAL_FORWARDING_CHANNEL,
131072,
32768,
hostname,
port,
listeningAddress,
listeningPort,
originatingHost,
originatingPort,
transport,
true);
ByteBuffer request = new ByteBuffer();
request.WriteString(hostname);
request.WriteUINT32(port);
request.WriteString(originatingHost);
request.WriteUINT32(originatingPort);
if (listener != null)
{
tunnel.StateChange += listener;
}
OpenChannel(tunnel, request.ToByteArray());
tunnel.ResumeWindow();
return(tunnel);
}
catch (System.IO.IOException ex)
{
throw new SSHException(ex.Message, SSHException.INTERNAL_ERROR);
}
}
public SSH2Channel CreateChannel(String channeltype, byte[] requestdata)
{
if (channeltype.Equals(SSH2ForwardingChannel.REMOTE_FORWARDING_CHANNEL))
{
try
{
ByteBuffer bar = new ByteBuffer(requestdata);
System.String address = bar.ReadString();
int port = (int)bar.ReadUINT32();
System.String originatorIP = bar.ReadString();
int originatorPort = (int)bar.ReadUINT32();
System.String key = address + ":" + port.ToString();
if (enclosingInstance.forwardingListeners.ContainsKey(key))
{
ForwardingRequestListener listener = (ForwardingRequestListener)enclosingInstance.forwardingListeners[key];
String destination = (System.String)enclosingInstance.forwardingDestinations[key];
String hostToConnect = destination.Substring(0, (destination.IndexOf((System.Char) ':')) - (0));
int portToConnect = System.Int32.Parse(destination.Substring(destination.IndexOf((System.Char) ':') + 1));
SSH2ForwardingChannel channel = new SSH2ForwardingChannel(SSH2ForwardingChannel.REMOTE_FORWARDING_CHANNEL,
32768,
32768,
hostToConnect,
portToConnect,
address,
port,
originatorIP,
originatorPort,
listener.CreateConnection(hostToConnect, portToConnect, address, port),
false);
listener.InitializeTunnel(channel);
return(channel);
}
else
{
throw new ChannelOpenException("Forwarding had not previously been requested",
ChannelOpenException.ADMINISTRATIVIVELY_PROHIBITED);
}
}
catch (System.IO.IOException ex)
{
throw new ChannelOpenException(ex.Message, ChannelOpenException.RESOURCE_SHORTAGE);
}
catch (SSHException ex)
{
throw new ChannelOpenException(ex.Message, ChannelOpenException.CONNECT_FAILED);
}
}
else if (channeltype.Equals("x11"))
{
if (!enclosingInstance.isXForwarding)
{
throw new ChannelOpenException("X Forwarding had not previously been requested",
ChannelOpenException.ADMINISTRATIVIVELY_PROHIBITED);
}
try
{
ByteBuffer bar = new ByteBuffer(requestdata);
System.String originatorIP = bar.ReadString();
int originatorPort = (int)bar.ReadUINT32();
System.String display = enclosingInstance.connection.Context.X11Display;
int i = display.IndexOf(":");
System.String targetAddr;
int targetPort;
int displ = 0;
int screen = 0;
String tmp;
if (i != -1)
{
targetAddr = display.Substring(0, (i) - (0));
tmp = display.Substring(i + 1);
}
else
{
targetAddr = "localhost";
tmp = display;
}
i = tmp.IndexOf(".");
if (i != -1)
{
displ = Int32.Parse(tmp.Substring(0, i));
screen = Int32.Parse(tmp.Substring(i + 1));
}
else
{
displ = Int32.Parse(tmp);
}
targetPort = displ;
if (targetPort < 64)
{
targetPort += 6000;
}
ForwardingRequestListener listener = enclosingInstance.connection.Context.X11RequestListener;
SSH2ForwardingChannel channel = new SSH2ForwardingChannel(SSH2ForwardingChannel.X11_FORWARDING_CHANNEL,
32768,
32768,
targetAddr,
targetPort,
targetAddr,
6000 + displ,
originatorIP,
originatorPort,
listener.CreateConnection(targetAddr, targetPort, originatorIP, originatorPort),
false);
listener.InitializeTunnel(channel);
return(channel);
}
catch (System.Exception ex)
{
throw new ChannelOpenException(ex.Message, ChannelOpenException.CONNECT_FAILED);
}
}
throw new ChannelOpenException(channeltype + " is not supported", ChannelOpenException.UNKNOWN_CHANNEL_TYPE);
}
