/// <summary>
/// Connect a stream according to the settings provided.
/// </summary>
/// <param name="settings">Network settings to use to connect the stream</param>
/// <returns>A <see cref="CStreamClientIO"/> object is evrything went fine, null otherwise</returns>
public static CStreamClientIO Connect(CStreamClientSettings settings)
{
CStreamClientIO stream = null;
try
{
// determine whether v4 or v6 IP addresse
IPAddress ip = IPAddress.Parse(settings.IP);
bool v6 = AddressFamily.InterNetworkV6 == ip.AddressFamily;
TcpClient tcpclient = new TcpClient(v6 ? AddressFamily.InterNetworkV6 : AddressFamily.InterNetwork);
try
{
CLog.DEBUG($"{MethodBase.GetCurrentMethod().Module.Name}.{MethodBase.GetCurrentMethod().DeclaringType.Name}.{MethodBase.GetCurrentMethod().Name}", $"About to connect to {settings.FullIP}");
tcpclient.Connect(settings.Address, (int)settings.Port);
tcpclient.SendBufferSize = (tcpclient.SendBufferSize >= settings.SendBufferSize ? tcpclient.SendBufferSize : settings.SendBufferSize + 1);
tcpclient.ReceiveBufferSize = (tcpclient.ReceiveBufferSize >= settings.ReceiveBufferSize ? tcpclient.SendBufferSize : settings.ReceiveBufferSize);
tcpclient.SendTimeout = settings.SendTimeout * CStreamSettings.ONESECOND;
tcpclient.ReceiveTimeout = settings.ReceiveTimeout * CStreamSettings.ONESECOND;
// Create an SSL stream that will close the client's stream.
stream = new CStreamClientIO(tcpclient, settings);
}
catch (Exception ex)
{
CLog.AddException($"{MethodBase.GetCurrentMethod().Module.Name}.{MethodBase.GetCurrentMethod().DeclaringType.Name}.{MethodBase.GetCurrentMethod().Name}", ex);
tcpclient.Close();
}
}
catch (Exception ex)
{
CLog.AddException($"{MethodBase.GetCurrentMethod().Module.Name}.{MethodBase.GetCurrentMethod().DeclaringType.Name}.{MethodBase.GetCurrentMethod().Name}", ex);
}
return(stream);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
bool TestConnect(char c)
{
StartServer(c);
CStreamClientSettings settings = new CStreamClientSettings()
{
AllowedSslErrors = SslPolicyErrors.RemoteCertificateNotAvailable | SslPolicyErrors.RemoteCertificateNameMismatch | SslPolicyErrors.RemoteCertificateChainErrors,
//IP = CStream.Localhost(),
IP = "127.0.0.1",
Port = Port,
ServerName = UseSSL ? "hello world" : null,
};
CStreamClientIO clientIO = CStream.Connect(settings);
if (null != clientIO)
{
clientIO.Send("hello");
Console.ReadKey();
Console.WriteLine($"Client connected: {clientIO.Connected}");
Console.ReadKey();
StopServer(c);
Console.ReadKey();
Console.WriteLine($"Client connected: {clientIO.Connected}");
clientIO.Close();
}
return(true);
}
/// <summary>
/// This function prevents using any size header, using CR+LF as an EOT
/// </summary>
/// <param name="settings"></param>
/// <param name="request"></param>
/// <param name="EOT"></param>
/// <returns></returns>
public static bool ConnectSendLine(CStreamClientSettings settings, string request, string EOT = CStreamIO.CRLF)
{
if (string.IsNullOrEmpty(request))
{
return(false);
}
CStreamClientIO stream = ConnectToSend(settings, request);
if (null != stream)
{
bool fOK = SendLine(stream, request, EOT);
Disconnect(stream);
return(fOK);
}
return(false);
}
/// <summary>
/// Connect (<see cref="Connect(CStreamClientSettings)"/>) and send data (<see cref="Send(CStreamIO, byte[], bool)"/> and <see cref="Send(CStreamIO, string)"/>).
/// </summary>
/// <param name="settings">The settings to use for sending data</param>
/// <param name="request">A array of bytes to send</param>
/// <param name="addSizeHeader">Indicates whether a buffer size block must be added before the buffer to send</param>
/// <returns>An arry of bytes received in response or if an error occured. In case of a client only request, the function returns the request, as no reply can be returned, if everything went right</returns>
public static bool ConnectSend(CStreamClientSettings settings, byte[] request, bool addSizeHeader)
{
if (null == request || 0 == request.Length)
{
return(false);
}
CStreamClientIO stream = ConnectToSend(settings, request, addSizeHeader);
if (null != stream)
{
bool fOK = Send(stream, request, addSizeHeader);
Disconnect(stream);
return(fOK);
}
return(false);
}
/// <summary>
/// This function prevents using any size header, using CR+LF as an EOT
/// </summary>
/// <param name="settings"></param>
/// <param name="request"></param>
/// <param name="error"></param>
/// <param name="EOT"></param>
/// <returns></returns>
public static string ConnectSendReceiveLine(CStreamClientSettings settings, string request, out bool error, string EOT = CStreamIO.CRLF)
{
error = false;
if (string.IsNullOrEmpty(request))
{
return(null);
}
CStreamClientIO stream = ConnectToSend(settings, request);
if (null != stream)
{
string reply = SendReceiveLine(stream, request, out error, EOT);
Disconnect(stream);
return(reply);
}
return(null);
}
/// <summary>
/// Connect (<see cref="Connect(CStreamClientSettings)"/>), send (<see cref="Send(CStreamIO, byte[], bool)"/> and <see cref="Send(CStreamIO, string)"/>) and receive (<see cref="Receive(CStreamIO, out int, out bool, bool)"/> and <see cref="Receive(CStreamIO, out int, out bool)"/>) data.
/// </summary>
/// <param name="settings">The settings to use for sending data</param>
/// <param name="request">A array of bytes to send</param>
/// <param name="addSizeHeader">Indicates whether a buffer size block must be added before the buffer to send</param>
/// <param name="announcedSize">The size of the reply as announced by the sender</param>
/// <param name="error">True indicates the function ended up with a error, false otherwise</param>
/// <returns>An arry of bytes received in response or if an error occured. In case of a client only request, the function returns the request, as no reply can be returned, if everything went right</returns>
public static byte[] ConnectSendReceive(CStreamClientSettings settings, byte[] request, bool addSizeHeader, out int announcedSize, out bool error)
{
byte[] reply = null;
error = false;
announcedSize = 0;
if (null == request || 0 == request.Length)
{
return(null);
}
CStreamClientIO stream = ConnectToSend(settings, request, addSizeHeader);
if (null != stream)
{
if (Send(stream, request, addSizeHeader))
{
reply = Receive(stream, out announcedSize, out error, addSizeHeader);
}
Disconnect(stream);
}
return(reply);
}
/// <summary>
///
/// </summary>
/// <param name="menu"></param>
/// <param name="entry"></param>
/// <param name="option"></param>
/// <param name="o"></param>
/// <returns></returns>
static bool TestListener(MenuList menu, CMenu entry, char option, object o)
{
TestListenerType type = (TestListenerType)o;
type.FileToUse = Input("File to use", LISTENER_TEST_FILE, out bool isdef);
if (string.IsNullOrEmpty(type.FileToUse))
{
Console.WriteLine("Invalid test file");
return(true);
}
type.IP = Input("Listener IP", CStream.Localhost(), out isdef);
if (string.IsNullOrEmpty(type.IP))
{
Console.WriteLine("Invalid IP");
return(true);
}
string sport = Input("Listener port to reach", type.Port.ToString(), out isdef);
if (string.IsNullOrEmpty(sport))
{
return(true);
}
try
{
type.Port = uint.Parse(sport);
}
catch (Exception)
{
Console.WriteLine("Invalid port number");
return(true);
}
//var json = new CJson<CListenerRequest>(fileToUse);
//var request = json.ReadSettings(out bool except);
//if (null != request)
//{
// var sreply = CStream.ConnectSendReceive(new CStreamClientSettings() { IP = ip, Port = port }, CJson<CListenerRequest>.Serialize(request), out int size, out bool error);
// if (!string.IsNullOrEmpty(sreply))
// {
// CLogger.Add(sreply);
// var reply = CJson<CListenerReply>.Deserialize(sreply, out except);
// CLogger.Add(reply.ToString());
// }
// else
// CLogger.Add("No reply has been received");
//}
var json = new CJson <CListenerRequest>(type.FileToUse);
var request = json.ReadSettings(out bool except);
if (null != request)
{
CStreamClientIO streamIO = CStream.Connect(new CStreamClientSettings()
{
IP = type.IP, Port = type.Port
});
if (null != streamIO)
{
if (CStream.Send(streamIO, CJson <CListenerRequest> .Serialize(request)))
{
string sreply;
while (!string.IsNullOrEmpty(sreply = CStream.Receive(streamIO, out int announcedSize, out bool error)))
{
var reply = CJson <CListenerReply> .Deserialize(sreply, out except);
CLogger.Add($"{reply.ToString()} (received message)");
if (!reply.Notification)
{
break;
}
}
}
}
}
return(true);
}
