public TelnetConnection(SSHConnectionParameter param, ISSHConnectionEventReceiver r, StreamSocket s)
{
_param = (SSHConnectionParameter)param.Clone();
_eventReceiver = r;
_autoDisconnect = true;
socket = s;
}
protected SSHConnection(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver)
{
_param = (SSHConnectionParameter)param.Clone();
_eventReceiver = receiver;
_channel_entries = new ArrayList(16);
_autoDisconnect = true;
}
private void ProcessPortforwardingRequest(ISSHConnectionEventReceiver receiver, SSH1DataReader reader)
{
int server_channel = reader.ReadInt32();
string host = Encoding.ASCII.GetString(reader.ReadString());
int port = reader.ReadInt32();
SSH1DataWriter writer = new SSH1DataWriter();
PortForwardingCheckResult result = receiver.CheckPortForwardingRequest(host, port, "", 0);
if (result.allowed)
{
int local_id = _channel_collection.RegisterChannelEventReceiver(null, result.channel).LocalID;
_eventReceiver.EstablishPortforwarding(result.channel, new SSH1Channel(this, ChannelType.ForwardedRemoteToLocal, local_id, server_channel));
writer.WriteInt32(server_channel);
writer.WriteInt32(local_id);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION, writer.ToByteArray());
p.WriteTo(_stream, _tCipher);
}
else
{
writer.WriteInt32(server_channel);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE, writer.ToByteArray());
p.WriteTo(_stream, _tCipher);
}
}
public TelnetConnection(SSHConnectionParameter param, ISSHConnectionEventReceiver r, StreamSocket s)
{
_param = (SSHConnectionParameter)param.Clone();
_eventReceiver = r;
_autoDisconnect = true;
socket = s;
}
private static SSHConnection ConnectMain(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, ProtocolNegotiationHandler pnh, AbstractSocket s)
{
pnh.Wait();
if (pnh.State != ReceiverState.Ready)
{
throw new SSHException(pnh.ErrorMessage);
}
string sv = pnh.ServerVersion;
SSHConnection con = null;
if (param.Protocol == SSHProtocol.SSH1)
{
con = new SSH1Connection(param, receiver, sv, SSHUtil.ClientVersionString(param.Protocol));
}
else
{
con = new SSH2Connection(param, receiver, sv, SSHUtil.ClientVersionString(param.Protocol));
}
s.SetHandler(con.PacketBuilder);
SendMyVersion(s, param);
if (con.Connect(s) != AuthenticationResult.Failure)
{
return(con);
}
else
{
s.Close();
return(null);
}
}
private static SSHConnection ConnectMain(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, VersionExchangeHandler pnh, AbstractGranadosSocket s)
{
DataFragment data = pnh.WaitResponse();
string sv = pnh.ServerVersion;
SSHConnection con = null;
if (param.Protocol == SSHProtocol.SSH1)
{
con = new SSH1Connection(param, s, receiver, sv, SSHUtil.ClientVersionString(param.Protocol));
}
else
{
con = new SSH2Connection(param, s, receiver, sv, SSHUtil.ClientVersionString(param.Protocol));
}
con.TraceReceptionEvent("server version-string", sv.Trim());
pnh.Close();
s.SetHandler(con.PacketBuilder);
con.SendMyVersion(param);
if (con.Connect() != AuthenticationResult.Failure)
{
return(con);
}
else
{
s.Close();
return(null);
}
}
public SSH1Connection(SSHConnectionParameter param, ISSHConnectionEventReceiver er, string serverversion, string clientversion) : base(param, er)
{
_cInfo = new SSH1ConnectionInfo();
_cInfo._serverVersionString = serverversion;
_cInfo._clientVersionString = clientversion;
_shellID = -1;
_packetBuilder = new SSH1PacketBuilder(new SynchronizedSSH1PacketHandler());
}
private Cipher _tCipher; //cipher for transmission
// exec command for SCP
//private bool _executingExecCmd = false;
public SSH1Connection(SSHConnectionParameter param, AbstractGranadosSocket s, ISSHConnectionEventReceiver er, string serverversion, string clientversion) : base(param, s, er) {
_cInfo = new SSH1ConnectionInfo();
_cInfo._serverVersionString = serverversion;
_cInfo._clientVersionString = clientversion;
_shellID = -1;
_packetReceiver = new SynchronizedPacketReceiver(this);
_packetBuilder = new SSH1PacketBuilder(_packetReceiver);
}
private readonly object _transmitSync = new object(); // for keeping correct packet order
internal SSH2Connection(SSHConnectionParameter param, AbstractGranadosSocket strm, ISSHConnectionEventReceiver r, string serverversion, string clientversion)
: base(param, strm, r) {
_cInfo = new SSH2ConnectionInfo();
_cInfo._serverVersionString = serverversion;
_cInfo._clientVersionString = clientversion;
_packetReceiver = new SynchronizedPacketReceiver(this);
_packetBuilder = new SSH2PacketBuilder(_packetReceiver);
}
protected bool _execCmdWaitFlag; // wait response flag for sending exec command to server
protected SSHConnection(SSHConnectionParameter param, AbstractGranadosSocket strm, ISSHConnectionEventReceiver receiver) {
_param = (SSHConnectionParameter)param.Clone();
_stream = strm;
_eventReceiver = receiver;
_channel_collection = new ChannelCollection();
_autoDisconnect = true;
_execCmd = null;
_execCmdWaitFlag = true;
}
protected bool _execCmdWaitFlag; // wait response flag for sending exec command to server
protected SSHConnection(SSHConnectionParameter param, AbstractGranadosSocket strm, ISSHConnectionEventReceiver receiver)
{
_param = (SSHConnectionParameter)param.Clone();
_stream = strm;
_eventReceiver = receiver;
_channel_collection = new ChannelCollection();
_autoDisconnect = true;
_execCmd = null;
_execCmdWaitFlag = true;
}
public SSH1Connection(SSHConnectionParameter param, ISSHConnectionEventReceiver er, string serverversion, string clientversion)
{
_param = (SSHConnectionParameter)param.Clone();
_eventReceiver = er;
_channel_entries = new List <object>(16);
_autoDisconnect = true;
_cInfo = new SSH1ConnectionInfo();
_cInfo._serverVersionString = serverversion;
_cInfo._clientVersionString = clientversion;
_shellID = -1;
_packetBuilder = new SSH1PacketBuilder(new SynchronizedSSH1PacketHandler());
}
public SSH2Connection(SSHConnectionParameter param, ISSHConnectionEventReceiver r, string serverversion, string clientversion)
{
_param = (SSHConnectionParameter)param.Clone();
_eventReceiver = r;
_channel_entries = new List<object>(16);
_autoDisconnect = true;
_cInfo = new SSH2ConnectionInfo();
_cInfo._serverVersionString = serverversion;
_cInfo._clientVersionString = clientversion;
_packetBuilder = new SSH2PacketBuilder(new SynchronizedSSH2PacketHandler());
}
internal static SSHConnection Connect(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, ProtocolNegotiationHandler pnh, AbstractSocket s)
{
if (param.UserName == null)
{
throw new InvalidOperationException("UserName property is not set");
}
if (param.Password == null)
{
throw new InvalidOperationException("Password property is not set");
}
return(ConnectMain(param, receiver, pnh, s));
}
//establishes a SSH connection in subject to ConnectionParameter
public static SSHConnection Connect(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, Socket underlying_socket)
{
if (param.UserName == null)
{
throw new InvalidOperationException("UserName property is not set");
}
if (param.Password == null)
{
throw new InvalidOperationException("Password property is not set");
}
ProtocolNegotiationHandler pnh = new ProtocolNegotiationHandler(param);
PlainSocket s = new PlainSocket(underlying_socket, pnh);
s.RepeatAsyncRead();
return(ConnectMain(param, receiver, pnh, s));
}
/**
* open a new SSH connection via the .NET socket
*/
public static SSHConnection Connect(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, Socket underlying_socket)
{
if (param.UserName == null)
{
throw new InvalidOperationException("UserName property is not set");
}
if (param.AuthenticationType != AuthenticationType.KeyboardInteractive && param.Password == null)
{
throw new InvalidOperationException("Password property is not set");
}
PlainSocket s = new PlainSocket(underlying_socket, null);
VersionExchangeHandler pnh = new VersionExchangeHandler(param, s);
s.SetHandler(pnh);
s.RepeatAsyncRead();
return(ConnectMain(param, receiver, pnh, s));
}
public SSH2Connection(SSHConnectionParameter param, ISSHConnectionEventReceiver r, string serverversion, string clientversion)
: base(param, r)
{
_cInfo = new SSH2ConnectionInfo();
_cInfo._serverVersionString = serverversion;
_cInfo._clientVersionString = clientversion;
_packetBuilder = new SSH2PacketBuilder(new SynchronizedSSH2PacketHandler());
}
private static SSHConnection ConnectMain(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, ProtocolNegotiationHandler pnh, AbstractSocket s)
{
pnh.Wait();
if(pnh.State!=ReceiverState.Ready) throw new SSHException(pnh.ErrorMessage);
string sv = pnh.ServerVersion;
SSHConnection con = null;
if(param.Protocol==SSHProtocol.SSH1)
con = new SSH1Connection(param, receiver, sv, SSHUtil.ClientVersionString(param.Protocol));
else
con = new SSH2Connection(param, receiver, sv, SSHUtil.ClientVersionString(param.Protocol));
s.SetHandler(con.PacketBuilder);
SendMyVersion(s, param);
if(con.Connect(s)!=AuthenticationResult.Failure)
return con;
else {
s.Close();
return null;
}
}
internal static SSHConnection Connect(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, ProtocolNegotiationHandler pnh, AbstractSocket s)
{
if(param.UserName==null) throw new InvalidOperationException("UserName property is not set");
if(param.Password==null) throw new InvalidOperationException("Password property is not set");
return ConnectMain(param, receiver, pnh, s);
}
/**
* opens another SSH connection via port-forwarded connection
*/
public SSHConnection OpenPortForwardedAnotherConnection(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, string host, int port)
{
ProtocolNegotiationHandler pnh = new ProtocolNegotiationHandler(param);
ChannelSocket s = new ChannelSocket(pnh);
SSHChannel ch = ForwardPort(s, host, port, "localhost", 0);
s.SSHChennal = ch;
return SSHConnection.Connect(param, receiver, pnh, s);
}
/**
* opens another SSH connection via port-forwarded connection
*/
public SSHConnection OpenPortForwardedAnotherConnection(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, string host, int port)
{
ChannelSocket s = new ChannelSocket(null);
SSHChannel ch = ForwardPort(s, host, port, "localhost", 0);
s.SSHChennal = ch;
VersionExchangeHandler pnh = new VersionExchangeHandler(param, s);
s.SetHandler(pnh);
return(ConnectMain(param, receiver, pnh, s));
}
private void ProcessPortforwardingRequest(ISSHConnectionEventReceiver receiver, SSH1DataReader reader)
{
int server_channel = reader.ReadInt32();
string host = reader.ReadString();
int port = reader.ReadInt32();
PortForwardingCheckResult result = receiver.CheckPortForwardingRequest(host, port, "", 0);
if (result.allowed) {
int local_id = _channel_collection.RegisterChannelEventReceiver(null, result.channel).LocalID;
_eventReceiver.EstablishPortforwarding(result.channel, new SSH1Channel(this, ChannelType.ForwardedRemoteToLocal, local_id, server_channel));
Transmit(
new SSH1Packet(SSH1PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION)
.WriteInt32(server_channel)
.WriteInt32(local_id)
);
}
else {
Transmit(
new SSH1Packet(SSH1PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE)
.WriteInt32(server_channel)
);
}
}
private static SSHConnection ConnectMain(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, VersionExchangeHandler pnh, AbstractGranadosSocket s) {
DataFragment data = pnh.WaitResponse();
string sv = pnh.ServerVersion;
SSHConnection con = null;
if (param.Protocol == SSHProtocol.SSH1)
throw new SSHException("SSH1 is not supported");
else
con = new SSH2Connection(param, s, receiver, sv, SSHUtil.ClientVersionString(param.Protocol));
con.TraceReceptionEvent("server version-string", sv.Trim());
pnh.Close();
s.SetHandler(con.PacketBuilder);
con.SendMyVersion(param);
if (con.Connect() != AuthenticationResult.Failure) {
return con;
}
else {
s.Close();
return null;
}
}
/**
* open a new SSH connection via the .NET socket
*/
public static SSHConnection Connect(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, Socket underlying_socket) {
if (param.UserName == null)
throw new InvalidOperationException("UserName property is not set");
if (param.AuthenticationType != AuthenticationType.KeyboardInteractive && param.Password == null)
throw new InvalidOperationException("Password property is not set");
PlainSocket s = new PlainSocket(underlying_socket, null);
VersionExchangeHandler pnh = new VersionExchangeHandler(param, s);
s.SetHandler(pnh);
s.RepeatAsyncRead();
return ConnectMain(param, receiver, pnh, s);
}
public static TelnetConnection Connect(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, StreamSocket underlying_socket)
{
return(new TelnetConnection(param, receiver, underlying_socket));
}
private void ProcessPortforwardingRequest(ISSHConnectionEventReceiver receiver, SSH1DataReader reader)
{
int server_channel = reader.ReadInt32();
string host = Encoding.ASCII.GetString(reader.ReadString());
int port = reader.ReadInt32();
SSH1DataWriter writer = new SSH1DataWriter();
PortForwardingCheckResult result = receiver.CheckPortForwardingRequest(host, port, "", 0);
if (result.allowed) {
int local_id = _channel_collection.RegisterChannelEventReceiver(null, result.channel).LocalID;
_eventReceiver.EstablishPortforwarding(result.channel, new SSH1Channel(this, ChannelType.ForwardedRemoteToLocal, local_id, server_channel));
writer.WriteInt32(server_channel);
writer.WriteInt32(local_id);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION, writer.ToByteArray());
p.WriteTo(_stream, _tCipher);
}
else {
writer.WriteInt32(server_channel);
SSH1Packet p = SSH1Packet.FromPlainPayload(PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE, writer.ToByteArray());
p.WriteTo(_stream, _tCipher);
}
}
private void ProcessAgentForwardRequest(ISSHConnectionEventReceiver receiver, SSH2DataReader reader) {
int remote_channel = reader.ReadInt32();
int window_size = reader.ReadInt32(); //skip initial window size
int servermaxpacketsize = reader.ReadInt32();
TraceReceptionEvent("agent forward request", "");
SSH2DataWriter wr = new SSH2DataWriter();
IAgentForward af = _param.AgentForward;
if(_agentForwardConfirmed && af!=null && af.CanAcceptForwarding()) {
//send OPEN_CONFIRMATION
AgentForwardingChannel ch = new AgentForwardingChannel(af);
SSH2Channel channel = new SSH2Channel(this, ChannelType.AgentForward, this.ChannelCollection.RegisterChannelEventReceiver(null, ch).LocalID, remote_channel, servermaxpacketsize);
ch.SetChannel(channel);
wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION);
wr.Write(remote_channel);
wr.Write(channel.LocalChannelID);
wr.Write(_param.WindowSize); //initial window size
wr.Write(_param.MaxPacketSize); //max packet size
TraceTransmissionEvent("granados confirmed agent-forwarding request", "");
}
else {
wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE);
wr.Write(remote_channel);
wr.Write(0);
wr.Write("reject");
wr.Write(""); //lang tag
TraceTransmissionEvent("granados rejected agent-forwarding request", "");
}
TransmitRawPayload(wr.ToByteArray());
}
private void ProcessPortforwardingRequest(ISSHConnectionEventReceiver receiver, SSH2DataReader reader) {
int remote_channel = reader.ReadInt32();
int window_size = reader.ReadInt32(); //skip initial window size
int servermaxpacketsize = reader.ReadInt32();
string host = Encoding.ASCII.GetString(reader.ReadString());
int port = reader.ReadInt32();
string originator_ip = Encoding.ASCII.GetString(reader.ReadString());
int originator_port = reader.ReadInt32();
TraceReceptionEvent("port forwarding request", String.Format("host={0} port={1} originator-ip={2} originator-port={3}", host, port, originator_ip, originator_port));
PortForwardingCheckResult r = receiver.CheckPortForwardingRequest(host,port,originator_ip,originator_port);
SSH2DataWriter wr = new SSH2DataWriter();
if(r.allowed) {
//send OPEN_CONFIRMATION
SSH2Channel channel = new SSH2Channel(this, ChannelType.ForwardedRemoteToLocal, this.ChannelCollection.RegisterChannelEventReceiver(null, r.channel).LocalID, remote_channel, servermaxpacketsize);
wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION);
wr.Write(remote_channel);
wr.Write(channel.LocalChannelID);
wr.Write(_param.WindowSize); //initial window size
wr.Write(_param.MaxPacketSize); //max packet size
receiver.EstablishPortforwarding(r.channel, channel);
TraceTransmissionEvent("port-forwarding request is confirmed", "host={0} port={1} originator-ip={2} originator-port={3}", host, port, originator_ip, originator_port);
}
else {
wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE);
wr.Write(remote_channel);
wr.Write(r.reason_code);
wr.Write(r.reason_message);
wr.Write(""); //lang tag
TraceTransmissionEvent("port-forwarding request is rejected", "host={0} port={1} originator-ip={2} originator-port={3}", host, port, originator_ip, originator_port);
}
TransmitRawPayload(wr.ToByteArray());
}
/**
* open a new SSH connection via the .NET socket
*/
public static SSHConnection Connect(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, Socket underlying_socket)
{
if (param.UserName == null)
throw new InvalidOperationException("UserName property is not set");
if (param.AuthenticationType != AuthenticationType.KeyboardInteractive && param.Password == null)
throw new InvalidOperationException("Password property is not set");
PlainSocket s = new PlainSocket(underlying_socket, null);
try {
SSHProtocolVersionReceiver protoVerReceiver = new SSHProtocolVersionReceiver();
protoVerReceiver.Receive(s, 5000);
protoVerReceiver.Verify(param.Protocol);
SSHConnection con;
if (param.Protocol == SSHProtocol.SSH1)
con = new SSH1Connection(param, s, receiver, protoVerReceiver.ServerVersion, SSHUtil.ClientVersionString(param.Protocol));
else
con = new SSH2Connection(param, s, receiver, protoVerReceiver.ServerVersion, SSHUtil.ClientVersionString(param.Protocol));
s.SetHandler(con.Packetizer);
s.RepeatAsyncRead();
con.SendMyVersion(param);
if (con.Connect() == AuthenticationResult.Failure) {
s.Close();
return null;
}
return con;
}
catch (Exception) {
s.Close();
throw;
}
}
private void ProcessPortforwardingRequest(ISSHConnectionEventReceiver receiver, SSH2DataReader reader)
{
string method = Encoding.ASCII.GetString(reader.ReadString());
int remote_channel = reader.ReadInt32();
int window_size = reader.ReadInt32(); //skip initial window size
int servermaxpacketsize = reader.ReadInt32();
string host = Encoding.ASCII.GetString(reader.ReadString());
int port = reader.ReadInt32();
string originator_ip = Encoding.ASCII.GetString(reader.ReadString());
int originator_port = reader.ReadInt32();
PortForwardingCheckResult r = receiver.CheckPortForwardingRequest(host,port,originator_ip,originator_port);
SSH2DataWriter wr = new SSH2DataWriter();
if(r.allowed) {
//send OPEN_CONFIRMATION
SSH2Channel channel = new SSH2Channel(this, ChannelType.ForwardedRemoteToLocal, RegisterChannelEventReceiver(null, r.channel)._localID, remote_channel, servermaxpacketsize);
wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_OPEN_CONFIRMATION);
wr.Write(remote_channel);
wr.Write(channel.LocalChannelID);
wr.Write(_param.WindowSize); //initial window size
wr.Write(_param.MaxPacketSize); //max packet size
receiver.EstablishPortforwarding(r.channel, channel);
}
else {
wr.WritePacketType(PacketType.SSH_MSG_CHANNEL_OPEN_FAILURE);
wr.Write(remote_channel);
wr.Write(r.reason_code);
wr.Write(r.reason_message);
wr.Write(""); //lang tag
}
TransmitPacket(wr.ToByteArray());
}
// exec command for SCP
//private bool _executingExecCmd = false;
public SSH1Connection(SSHConnectionParameter param, IGranadosSocket s, ISSHConnectionEventReceiver er, string serverVersion, string clientVersion)
: base(param, s, er)
{
_cInfo = new SSH1ConnectionInfo(param.HostName, param.PortNumber, serverVersion, clientVersion);
_shellID = -1;
_packetReceiver = new SynchronizedPacketReceiver(this);
_packetizer = new SSH1Packetizer(_packetReceiver);
}
internal DummySSHConnection(SSHConnectionParameter param, AbstractGranadosSocket strm, ISSHConnectionEventReceiver receiver)
: base(param, strm, receiver)
{
}
/**
* opens another SSH connection via port-forwarded connection
*/
public SSHConnection OpenPortForwardedAnotherConnection(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, string host, int port)
{
ProtocolNegotiationHandler pnh = new ProtocolNegotiationHandler(param);
ChannelSocket s = new ChannelSocket(pnh);
SSHChannel ch = ForwardPort(s, host, port, "localhost", 0);
s.SSHChennal = ch;
return(SSHConnection.Connect(param, receiver, pnh, s));
}
protected SSHConnection(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver)
{
_param = (SSHConnectionParameter)param.Clone();
_eventReceiver = receiver;
_channel_entries = new ArrayList(16);
_autoDisconnect = true;
}
private Cipher _tCipher; //cipher for transmission
// exec command for SCP
//private bool _executingExecCmd = false;
public SSH1Connection(SSHConnectionParameter param, AbstractGranadosSocket s, ISSHConnectionEventReceiver er, string serverversion, string clientversion)
: base(param, s, er)
{
_cInfo = new SSH1ConnectionInfo();
_cInfo._serverVersionString = serverversion;
_cInfo._clientVersionString = clientversion;
_shellID = -1;
_packetReceiver = new SynchronizedPacketReceiver(this);
_packetBuilder = new SSH1PacketBuilder(_packetReceiver);
}
//establishes a SSH connection in subject to ConnectionParameter
public static SSHConnection Connect(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, Socket underlying_socket)
{
if(param.UserName==null) throw new InvalidOperationException("UserName property is not set");
if(param.Password==null) throw new InvalidOperationException("Password property is not set");
ProtocolNegotiationHandler pnh = new ProtocolNegotiationHandler(param);
PlainSocket s = new PlainSocket(underlying_socket, pnh);
s.RepeatAsyncRead();
return ConnectMain(param, receiver, pnh, s);
}
internal DummySSHConnection(SSHConnectionParameter param, AbstractGranadosSocket strm, ISSHConnectionEventReceiver receiver)
: base(param, strm, receiver)
{
}
public static TelnetConnection Connect(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, StreamSocket underlying_socket)
{
return new TelnetConnection(param, receiver, underlying_socket);
}
/**
* opens another SSH connection via port-forwarded connection
*/
public SSHConnection OpenPortForwardedAnotherConnection(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, string host, int port) {
ChannelSocket s = new ChannelSocket(null);
SSHChannel ch = ForwardPort(s, host, port, "localhost", 0);
s.SSHChennal = ch;
VersionExchangeHandler pnh = new VersionExchangeHandler(param, s);
s.SetHandler(pnh);
return ConnectMain(param, receiver, pnh, s);
}
public static SSHConnection Connect(SSHConnectionParameter param, ISSHConnectionEventReceiver receiver, ProtocolNegotiationHandler pnh, AbstractSocket s)
{
if (param.UserName == null) throw new InvalidOperationException(resLoader.GetString("UsernameUnset"));
if (param.Password == null) throw new InvalidOperationException(resLoader.GetString("PasswordUnset"));
return ConnectMain(param, receiver, pnh, s);
}
