public async Task Connect_DnsEndPoint_Success(int mode)
{
using (TcpClient client = new TcpClient())
{
Assert.False(client.Connected);
string host = HttpTestServers.Host;
const int port = 80;
if (mode == 0)
{
await client.ConnectAsync(host, port);
}
else
{
IPAddress[] addresses = await Dns.GetHostAddressesAsync(host);
await (mode == 1 ?
client.ConnectAsync(addresses[0], port) :
client.ConnectAsync(addresses, port));
}
Assert.True(client.Connected);
Assert.NotNull(client.Client);
Assert.Same(client.Client, client.Client);
using (NetworkStream s = client.GetStream())
{
byte[] getRequest = Encoding.ASCII.GetBytes("GET / HTTP/1.1\r\n\r\n");
await s.WriteAsync(getRequest, 0, getRequest.Length);
Assert.NotEqual(-1, s.ReadByte()); // just verify we successfully get any data back
}
}
}
public static void Main()
{
while (true)
{
try
{
IP = null;
Application.Run(new InputIp());
tcpclnt = new TcpClient();
if (IP == null)
return;
Console.WriteLine(IP);
tcpclnt.Connect(IP, 8001);
Console.WriteLine("Connection established");
gui = new MinesweeperGUI();
Application.Run(gui);
break;
}
catch (Exception e)
{
MessageBox.Show("Could not establish a connection with the server: " + e.Message);
}
}
}
private void btnConnect_Click(object sender, EventArgs e)
{
try
{
client = new TcpClient("127.0.0.1", 2000);
ns = client.GetStream();
sr = new StreamReader(ns);
sw = new StreamWriter(ns);
String response = sr.ReadLine();
DelegateResponse dr = writeResponse;
dr(response);
// rawdata = imei@lat@lng@timestamp
string rawData = imei.ToString();
rawData += "@" + randomCoordinates();
rawData +="@"+ ConvertToTimestamp(DateTime.Now).ToString();
String data = stringToHexa(rawData);
sw.WriteLine(data);
sw.Flush();
}
catch (Exception err)
{
Console.WriteLine(err.ToString());
// throw;
}
}
public void HandleInvoke(TcpClient client, string values) {
SplitData data = values.GetFirst();
switch (data.CommandType) {
case "StartGame":
Debug.Log("TODO: Add game start");
break;
case "CreateUnit":
CreateUnit(data.Values);
break;
case "SplitUnit":
SplitUnit(data.Values);
break;
case "MoveToEmpty":
Move(_invoke.MoveToEmpty, data.Values);
break;
case "MoveToMerge":
Move(_invoke.MoveToMerge, data.Values);
break;
case "MoveToAttack":
Move(_invoke.MoveToAttack, data.Values);
break;
case "CashChanged":
CashChanged(data.Values);
break;
default:
Debug.LogError("Invalid message send to Invokable\n" + values);
break;
}
}
private void btnConnect_Click(object sender, EventArgs e)
{
try
{
client = new TcpClient("127.0.0.1", 2000);
ns = client.GetStream();
sr = new StreamReader(ns);
sw = new StreamWriter(ns);
String response = sr.ReadLine();
DelegateResponse dr = writeResponse;
dr(response);
randomCoordinates();
string rawData = "Hola mundo";
String data = stringToHexa(rawData);
//Console.WriteLine(data);
sw.WriteLine(data);
sw.Flush();
}
catch (Exception err)
{
Console.WriteLine(err.ToString());
throw;
}
}
static void Main (string [] args)
{
int i = 0;
while (args [i].StartsWith ("-")){
if (args [i] == "-debug")
debug = true;
if (args [i] == "-headers")
headers = true;
if (args [i] == "-header")
header = args [++i];
i++;
}
c = new TcpClient (args [i], Int32.Parse (args [i+1]));
c.ReceiveTimeout = 1000;
ns = c.GetStream ();
sw = new StreamWriter (ns);
sr = new StreamReader (ns);
string host = args [i];
if (args [i+1] != "80")
host += ":" + args [i+1];
send (String.Format ("GET {0} HTTP/1.1\r\nHost: {1}\r\n\r\n", args [i+2], host));
MemoryStream ms = new MemoryStream ();
try {
byte [] buf = new byte [1024];
int n;
while ((n = ns.Read (buf, 0, 1024)) != 0){
ms.Write (buf, 0, n);
}
} catch {}
ms.Position = 0;
sr = new StreamReader (ms);
string s;
while ((s = sr.ReadLine ()) != null){
if (s == ""){
if (headers)
return;
string x = sr.ReadToEnd ();
Console.Write (x);
break;
} else {
if (debug || headers)
Console.WriteLine (s);
if (header != null && s.StartsWith (header)){
Console.WriteLine (s);
return;
}
}
}
}
void LookingForServer()
{
while(mConnected == false)
{
Thread.Sleep(500);
try {
TcpClient tcpclnt = new TcpClient();
Debug.Log("Connecting.....");
//tcpclnt.Connect("192.168.13.113",8001);
tcpclnt.Connect(Config.ip,8001);
// use the ipaddress as in the server program
mConnected =true;
mServerStream = tcpclnt.GetStream();
ThreadStart ts = new ThreadStart(ListenServer);
mThreadListen = new Thread(ts);
mThreadListen.Start();
}
catch (Exception e) {
Debug.Log("Error..... " + e.StackTrace);
}
}
mSynchronizing = false;
}
public void AddPlayer(TcpClient client)
{
//Caso já se tenha 02 jogadores, não pode mais entrar no servidor.
if (ready)
DisconnectPlayer(client);
//Identificador do cliente
int id = NextID();
Console.WriteLine("Novo cliente entrou: " + id);
//Cria Thread para cuidar do cliente.
players[id] = new ClientProcessor(this, id, client);
Thread thread = new Thread(players[id].Run);
thread.Start();
if (id + 1 >= MAX_PLAYERS)
{
ready = true;
//Cria o contorno da parede e envia aos clientes.
matrizJogo = wall.CreateWallPhase01(matrizJogo);
wall.SendToCLient(players, matrizJogo);
// Cria a 1ª posicao da comida e envia ao cliente.
matrizJogo = food.NewPosition(matrizJogo);
food.SendToClient(matrizJogo, players);
}
}
public void HandShake()
{
try
{
client = new TcpClient(server, port);
string hello = "HELLO";
data = System.Text.Encoding.ASCII.GetBytes(hello);
stream = client.GetStream();
stream.Write(data, 0, data.Length);
int i = stream.Read(bytes, 0, bytes.Length);
string Data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
if (Data == "HI")
{
//MessageBox.Show("Підключення з сервером встановлено успішно.");
isConnected = true;
toolStripMenuItem3.Enabled = true;
toolStripMenuItem1.Enabled = false;
}
else
{
MessageBox.Show("Невдалось підключитись до сервера. Спробуйте пізніше.\n");
}
}
catch (Exception ex)
{
MessageBox.Show("Невдалось підключитись до сервера. Спробуйте пізніше.\n\n" + ex.ToString());
}
}
public void Execute()
{
// throw new Exception("aasd");
var tcpClient = new TcpClient(ServerLocation, ServerPort);
var skynet = new SkynetClient("Client", tcpClient, null);
skynet.Connect(true, false, TimeSpan.FromSeconds(60));
try
{
var assembly = Assembly.LoadFrom(File);
assembly.EntryPoint.Invoke(null, new object[] { new string[] { "args" } });
new ManualResetEvent(false).WaitOne(1000);
}
catch (Exception ex)
{
log.Error("Failed to start process", ex);
Environment.Exit(0);
}
// runner.Start("");
Environment.Exit(1);
}
public void ConnectWithV4AndV6_Success()
{
int port;
TcpListener listener = SocketTestExtensions.CreateAndStartTcpListenerOnAnonymousPort(out port);
IAsyncResult asyncResult = listener.BeginAcceptTcpClient(null, null);
TcpClient v6Client = new TcpClient(AddressFamily.InterNetworkV6);
v6Client.Connect(new IPEndPoint(IPAddress.IPv6Loopback, port));
TcpClient acceptedV6Client = listener.EndAcceptTcpClient(asyncResult);
Assert.Equal(AddressFamily.InterNetworkV6, acceptedV6Client.Client.RemoteEndPoint.AddressFamily);
Assert.Equal(AddressFamily.InterNetworkV6, v6Client.Client.RemoteEndPoint.AddressFamily);
asyncResult = listener.BeginAcceptTcpClient(null, null);
TcpClient v4Client = new TcpClient(AddressFamily.InterNetwork);
v4Client.Connect(new IPEndPoint(IPAddress.Loopback, port));
TcpClient acceptedV4Client = listener.EndAcceptTcpClient(asyncResult);
Assert.Equal(AddressFamily.InterNetworkV6, acceptedV4Client.Client.RemoteEndPoint.AddressFamily);
Assert.Equal(AddressFamily.InterNetwork, v4Client.Client.RemoteEndPoint.AddressFamily);
v6Client.Dispose();
acceptedV6Client.Dispose();
v4Client.Dispose();
acceptedV4Client.Dispose();
listener.Stop();
}
private void ThreadListener()
{
client = new TcpClient();
try
{
client.Connect(host, port);
ns = client.GetStream();
write("READY");
running = true;
while (running)
{
threadUpdate();
}
}
catch (SocketException e)
{
Debug.LogException(e, this);
if (!running)
{
//tenta conectar novamente
ThreadListener();
}
else
{
GameController.gameState = GameController.GameState.EXIT;
}
}
}
public void connect()
{
client = new TcpClient();
Console.WriteLine("Connecting to Hyperwall Proxy Server...");
// use the ipaddress as in the server program
try
{
client.Connect(serverIP, serverPort);
networkStream = client.GetStream();
writer = new StreamWriter(networkStream);
reader = new StreamReader(networkStream);
Console.WriteLine("Sending: STATUS_CONNECT");
sendSingleCommand(STATUS_CONNECT);
getServerReply();
}
catch (SocketException e)
{
Console.WriteLine("Unable to connect to server");
Console.WriteLine(e.ToString());
return;
}
Console.WriteLine("Connected");
}
public static bool Connect(IPEndPoint remoteEndPoint, int timeoutMSec)
{
TimeoutObject.Reset();
socketexception = null;
string serverip = Convert.ToString(remoteEndPoint.Address);
int serverport = remoteEndPoint.Port;
TcpClient tcpclient = new TcpClient();
tcpclient.BeginConnect(serverip, serverport, new AsyncCallback(CallBackMethod), tcpclient);
if (TimeoutObject.WaitOne(timeoutMSec, false))
{
if (IsConnectionSuccessful)
{
tcpclient.Close();
return true;
}
else
{
tcpclient.Close();
return false;
}
}
else
{
tcpclient.Close();
return false;
}
}
void SSLAuthenticateTest()
{
var client = new TcpClient ();
String hosturl = "115.239.211.112";//www.baidu.com;
client.Connect (hosturl, 443);
using (var stream = client.GetStream ())
{
Debug.Log("CONNECTING ");
var ostream = stream as Stream;
if (true)
{
ostream = new SslStream (stream, false, new RemoteCertificateValidationCallback (ValidateServerCertificate));
try
{
var ssl = ostream as SslStream;
ssl.AuthenticateAsClient (hosturl);
}
catch (Exception e)
{
Debug.Log ("Exception: " + e.Message);
}
}
}
}
void LEDSingleSwitch()
{
//IPアドレスとポート番号を指定
//string型とint型なのが不思議
//勿論送信先のIPアドレスとポート番号です
string ipAddress = "172.20.11.68";
int port = 14649;
//IPアドレスとポート番号を渡してサーバ側へ接続
TcpClient client = new TcpClient(ipAddress, port);
//表示するのは「Hello! C#」
//これを送信用にbyte型へ直します
string str = "SET_SINGLE " +number+ " " +single+ "," +single+ "," +single+ "," +single+ ",\nUPDATE\nUPDATE\n";
byte[] tmp = Encoding.UTF8.GetBytes(str);
//NWのデータを扱うストリームを作成
NetworkStream stream = client.GetStream();
//送信
//引数は（データ , データ書き込み開始位置 , 書き込むバイト数）
//だそうです
stream.Write(tmp, 0, tmp.Length);
//サーバとの接続を終了
client.Close();
}
public void Connect()
{
if (connected)
return;
username = usernameField.text.ToLower();
oauthToken = oauthField.text;
channel = "#" + username;
if (username == "")
{
errorMessage.text = "please enter a username";
return;
}
if(oauthToken == "")
{
errorMessage.text = "please enter your oauth token";
return;
}
try
{
tcpClient = new TcpClient(SERVER, PORT);
}
catch (SocketException e)
{
errorMessage.text = "network error: " + e.Message;
}
nStream = tcpClient.GetStream();
sReader = new StreamReader(nStream);
sWriter = new StreamWriter(nStream);
Write("USER " + username + "tmi twitch :" + username);
Write("PASS " + oauthToken);
Write("NICK " + username);
}
public static void connect()
{
TcpClient tcpclnt = new TcpClient();
//Console.WriteLine("Connecting.....");
tcpclnt.Connect("161.115.86.57", 8001);
}
public static void Main()
{
try {
TcpClient tcpclnt = new TcpClient();
//Console.WriteLine("Connecting.....");
tcpclnt.Connect("161.115.86.57",8001);
// use the ipaddress as in the server program
//Console.WriteLine("Connected");
//Console.Write("Enter the string to be transmitted : ");
String sendString = Console.ReadLine();
Stream serverSendStream = tcpclnt.GetStream();
ASCIIEncoding asen = new ASCIIEncoding();
byte[] bytesInSend = asen.GetBytes(sendString);
//Console.WriteLine("Transmitting.....");
// send length then string to read to length+1
serverSendStream.Write(bytesInSend, 0, bytesInSend.Length);
byte[] bytesToRead = new byte[100];
int numberOfBytesRead = serverSendStream.Read(bytesToRead, 0, bytesToRead.Length);
for (int i = 0; i < numberOfBytesRead; i++)
Console.Write(Convert.ToChar(bytesToRead[i]));
tcpclnt.Close();
}
catch (Exception e) {
Console.WriteLine("Error..... " + e.StackTrace);
}
}
public void Connect(){
TcpClient client;
YourName = InputName.GetComponent<InputField> ().text.Replace (" ", "_");
if (YourName.Length == 0) {
YourName = "Player";
}
try{
String[] ip = InputIP.GetComponent<InputField> ().text.Split(':');
client = new TcpClient(ip[0], Int32.Parse(ip[1]));
Stream s = client.GetStream();
sr = new StreamReader(s);
sw = new StreamWriter(s);
sw.AutoFlush = true;
sw.WriteLine("READY " + YourName);
new Thread(() => {
while(client.Connected){
String str = sr.ReadLine();
msgs.Enqueue(str);
}
}).Start();
ControlPanel.SetActive(true);
ConnectPanel.SetActive(false);
}catch(IndexOutOfRangeException){
ShowPopup ("Wrong IP address. (IP_address:port)");
}catch(Exception e){
ShowPopup ("Cannot connect to server: " + e.Message);
}
}
public static TcpClient Connect( string ip, ushort port, int timeoutMSec)
{
TimeoutObject.Reset(); // 이벤트 상태를 초기화
socketexception = null; // 예외발생
string serverip = ip; // IP
int serverport = port;
TcpClient tcpclient = new TcpClient();
// 비동기 접속, CallBackMethod
tcpclient.BeginConnect( serverip, serverport, new AsyncCallback( CallBackMethod), tcpclient);
if ( TimeoutObject.WaitOne( timeoutMSec, false)) // 동기화시킨다. timeoutMSec 동안 기다린다.
{
if ( IsConnectionSuccessful) // 접속되는 소켓을
return tcpclient;
else
throw socketexception; // 안되면, 안된 예외를
}
else // 시간이 초과되면
{
tcpclient.Close();
throw new TimeoutException( "TimeOut Exception");
}
}
public void connect()
{
if(tcpClient == null) {
tcpClient = new TcpClient(host, port);
Debug.Log("Connected to socket " + host + ":" + port);
}
}
public void Connect()
{
while(true){
try {
if(isConnected){
if(!IsConnected()){
Close();
}
}
else{
Log.AddToLog("Trying to Connect...");
TcpClient client = new TcpClient(host, port);
Log.AddToLog("Connected");
socket = client.Client;
writeThread = new Thread(Send_Threaded);
writeThread.Start();
readThread = new Thread(Read_Threaded);
readThread.Start();
isConnected = true;
}
mainWaitInLine.WaitOne(2000);
}
catch (Exception e) {
Log.AddToDebug("setupSocket: " + e.ToString());
lastError = e.ToString();
isConnected = false;
}
}
}
public ConnectionHandler(Client mainForm)
{
this.mainForm = mainForm;
ServerSocket = new TcpClient();
messageHandler = new MessageHandler();
PacketManager.DefineOpcodeHandlers();
}
public string sendPacket(string packet)
{
try
{
TcpClient client = new TcpClient(ipAddress, port);
Byte[] data = System.Text.Encoding.ASCII.GetBytes(packet);
NetworkStream stream = client.GetStream();
stream.Write(data, 0, data.Length);
data = new Byte[256];
String responseData = String.Empty;
Int32 bytes = stream.Read(data, 0, data.Length);
responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
stream.Close();
client.Close();
return responseData;
}
catch (ArgumentNullException e)
{
return(e.ToString());
}
catch (SocketException e)
{
return (e.ToString());
}
}
public override void Initialize(IEventSource eventSource)
{
try
{
this.InitializeParameters();
this.SubscribeToEvents(eventSource);
log.Info("Initialize MS Build Logger!");
string ipStr = GetParameterValue("ip");
IPAddress ipServer = IPAddress.Parse(ipStr);
int port = int.Parse(GetParameterValue("port"));
log.InfoFormat("MS Build Logger port to write {0}", port);
clientSocketWriter = new System.Net.Sockets.TcpClient();
clientSocketWriter.Connect(ipServer, port);
networkStream = clientSocketWriter.GetStream();
Thread.Sleep(1000);
}
catch(Exception ex)
{
log.Error("Exception in MS Build logger", ex);
}
}
private static async void StartAttend(int sessionId, TcpClient session)
{
Console.WriteLine("++ [S{0}:T{1}] connection from {2}",
sessionId,
Thread.CurrentThread.ManagedThreadId,
session.Client.RemoteEndPoint
);
NetworkStream stream = session.GetStream();
int nb;
byte[] buffer = new byte[8];
for (;;) {
nb = await stream.ReadAsync(buffer, 0, buffer.Length);
if (nb == 0) {
Console.WriteLine("++ [S{0}:T{1}] end of session",
sessionId,
Thread.CurrentThread.ManagedThreadId
);
session.Close();
return;
}
Console.WriteLine("++ [S{0}:T{1}] processing {2} byte(s)",
sessionId,
Thread.CurrentThread.ManagedThreadId,
nb
);
Pause(500);
stream.Write(buffer, 0, nb);
}
}
public string fnConnectResult(string sNetIP, int iPORT_NUM,string sUserName)
{
try
{
// GET LOCAL IP ADDRESS
/*
string strHostName = "";
strHostName = System.Net.Dns.GetHostName();
IPHostEntry ipEntry = System.Net.Dns.GetHostEntry(strHostName);
IPAddress[] addr = ipEntry.AddressList;
Debug.Log( addr[addr.Length-1].ToString() );
sNetIP = addr[addr.Length-1].ToString();
*/
sNetIP = "localhost";
// SET UP NEW TCP CLIENT AND CONNECT
client = new TcpClient(sNetIP, PORT_NUM);
client.GetStream().BeginRead(readBuffer, 0, READ_BUFFER_SIZE, new AsyncCallback(DoRead), null);
Debug.Log("Connection Succeeded");
//SendData("test");
return "Connection Succeeded";
}
catch(Exception ex)
{
return "Server is not active. Please start server and try again. " + ex.ToString();
}
}
public static void Main() {
try {
TcpClient tcpclnt = new TcpClient();
Console.WriteLine("Connecting.....");
tcpclnt.Connect("172.21.5.99",8001); // use the ipaddress as in the server program
Console.WriteLine("Connected");
Console.Write("Enter the string to be transmitted : ");
String str=Console.ReadLine();
Stream stm = tcpclnt.GetStream();
ASCIIEncoding asen= new ASCIIEncoding();
byte[] ba=asen.GetBytes(str);
Console.WriteLine("Transmitting.....");
stm.Write(ba,0,ba.Length);
byte[] bb=new byte[100];
int k=stm.Read(bb,0,100);
for (int i=0;i<k;i++)
Console.Write(Convert.ToChar(bb[i]));
tcpclnt.Close();
}
catch (Exception e) {
Console.WriteLine("Error..... " + e.StackTrace);
}
}
public HproseTcpListenerContext(TcpClient client)
{
this.client = client;
}
public static void Main(string[] args)
{
TcpListener server = null;
try
{
// Set the TcpListener on port 13000.
IPAddress localAddr = IPAddress.Parse(args[0]);
Int32 port = Convert.ToInt32(args[1]);
// TcpListener server = new TcpListener(port);
server = new TcpListener(localAddr, port);
// Start listening for client requests.
server.Start();
// String data = null;
// Enter the listening loop.
while (true)
{
Console.Write("Waiting for a connection... ");
TcpClient client1 = server.AcceptTcpClient();
Console.WriteLine("Connected!");
NetworkStream stream1 = client1.GetStream();
// StreamReader reader1 = new StreamReader(stream1);
// StreamWriter writer1 = new StreamWriter(stream1);
Console.Write("Waiting for a connection... ");
TcpClient client2 = server.AcceptTcpClient();
Console.WriteLine("Connected!");
NetworkStream stream2 = client2.GetStream();
// StreamReader reader2 = new StreamReader(stream2);
// StreamWriter writer2 = new StreamWriter(stream2);
TicTac tictac = new TicTac();
tictac.Play(stream1, stream2);
// data = null;
///////////// Get a stream object for reading and writing
// NetworkStream stream1 = client1.GetStream();
// StreamReader reader1 = new StreamReader(stream1);
// StreamWriter writer1 = new StreamWriter(stream1);
// NetworkStream stream2 = client2.GetStream();
// StreamReader reader2 = new StreamReader(stream2);
// StreamWriter writer2 = new StreamWriter(stream2);
// writer.AutoFlush = true;
// Loop to receive all the data sent by the client.
// while ((data = reader.ReadLine()) != null)
// {
// Console.WriteLine("Received: {0}", data);
// // Process the data sent by the client.
// String response = data.ToUpper();
// // Send back a response.
// writer.WriteLine(response);
// writer.Flush();
// Console.WriteLine("Sent: {0}", response);
// }
// Shutdown and end connection
client1.Close();
}
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
finally
{
// Stop listening for new clients.
server.Stop();
}
Console.WriteLine("\nHit enter to continue...");
Console.Read();
}
public static short BadSource()
{
short data;
if (CWE197_Numeric_Truncation_Error__short_connect_tcp_22a.badPublicStatic)
{
data = short.MinValue; /* Initialize data */
/* Read data using an outbound tcp connection */
{
TcpClient tcpConn = null;
StreamReader sr = null;
try
{
/* Read data using an outbound tcp connection */
tcpConn = new TcpClient("host.example.org", 39544);
/* read input from socket */
sr = new StreamReader(tcpConn.GetStream());
/* FLAW: Read data using an outbound tcp connection */
string stringNumber = sr.ReadLine();
if (stringNumber != null) /* avoid NPD incidental warnings */
{
try
{
data = short.Parse(stringNumber.Trim());
}
catch (FormatException exceptNumberFormat)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string");
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
finally
{
/* clean up stream reading objects */
try
{
if (sr != null)
{
sr.Close();
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing InputStreamReader");
}
/* clean up socket objects */
try
{
if (tcpConn != null)
{
tcpConn.Close();
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing Socket");
}
}
}
}
else
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run
* but ensure data is inititialized before the Sink to avoid compiler errors */
data = 0;
}
return(data);
}
/* uses badsource and badsink */
public override void Bad()
{
string data;
if (IO.staticFive == 5)
{
data = ""; /* Initialize data */
/* Read data using an outbound tcp connection */
{
try
{
/* Read data using an outbound tcp connection */
using (TcpClient tcpConn = new TcpClient("host.example.org", 39544))
{
/* read input from socket */
using (StreamReader sr = new StreamReader(tcpConn.GetStream()))
{
/* POTENTIAL FLAW: Read data using an outbound tcp connection */
data = sr.ReadLine();
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
}
}
else
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run
* but ensure data is inititialized before the Sink to avoid compiler errors */
data = null;
}
SqlConnection dbConnection = null;
try
{
dbConnection = IO.GetDBConnection();
/* POTENTIAL FLAW: Set the database user name with the value of data
* allowing unauthorized access to a portion of the DB */
dbConnection.ConnectionString = @"Data Source=" + "" + ";Initial Catalog=" + "" + ";User ID=" + data + ";Password="******"";
dbConnection.Open();
}
catch (SqlException exceptSql)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptSql, "Error getting database connection");
}
finally
{
try
{
if (dbConnection != null)
{
dbConnection.Close();
}
}
catch (SqlException exceptSql)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptSql, "Error closing Connection");
}
}
}
public Controller(string host, int port)
{
this.mHost = host;
this.mPort = port;
this.mTcpClient = new TcpClient(this.mHost, this.mPort);
}
static void Main(string[] args)
{
n = Int32.Parse(args[0]);
try
{
byte[][] X = new byte[n + 1][];
string[] X0 = new string[n + 1];
Random rnd = new Random();
for (int i = 0; i < n + 1; ++i)
{
UTF8Encoding utf8enc = new UTF8Encoding();
X0[i] = rnd.Next().ToString();
X[i] = utf8enc.GetBytes(X0[i]);
}
RsaKeyParameters[] P = new RsaKeyParameters[n + 1];
for (int i = 0; i < n; ++i)
{
RsaKeyPairGenerator rsaKeyPairGnr = new RsaKeyPairGenerator();
rsaKeyPairGnr.Init(new Org.BouncyCastle.Crypto.KeyGenerationParameters(new SecureRandom(), 512));
Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair keyPair = rsaKeyPairGnr.GenerateKeyPair();
RsaKeyParameters publicKey = (RsaKeyParameters)keyPair.Public;
IAsymmetricBlockCipher cipher = new RsaEngine();
P[i + 1] = publicKey;
}
RsaKeyPairGenerator rsaKeyPairGnr_s = new RsaKeyPairGenerator();
rsaKeyPairGnr_s.Init(new Org.BouncyCastle.Crypto.KeyGenerationParameters(new SecureRandom(), 512));
Org.BouncyCastle.Crypto.AsymmetricCipherKeyPair keyPair_s = rsaKeyPairGnr_s.GenerateKeyPair();
P[0] = (RsaKeyParameters)keyPair_s.Public;
RsaKeyParameters Ks = (RsaKeyParameters)keyPair_s.Private;
string server = "127.0.0.1";
Int32 port = 13000;
TcpClient client = new TcpClient(server, port);
//Time start
DateTime now = DateTime.Now;
Console.WriteLine("Strat Second: {0}", now.Millisecond);
NetworkStream stream = client.GetStream();
byte[] bytes;
string response;
bytes = new byte[64];
stream.Read(bytes, 0, bytes.Length);
response = System.Text.Encoding.ASCII.GetString(bytes, 0, bytes.Length);
string N = response;
string m = N;
byte[] v = ring_sign(P, m, Ks, X);
stream.Write(v);
Console.WriteLine(v.Length);
string x = "";
for (int i = 0; i < n + 1; ++i)
{
x += P[i].Exponent + "|";
}
string M = "";
for (int i = 0; i < n + 1; ++i)
{
M += P[i].Modulus + "|";
}
string X0_str = "";
for (int i = 0; i < n + 1; ++i)
{
X0_str += X0[i] + "|";
}
bytes = Encoding.UTF8.GetBytes(x + M + X0_str);
stream.Write(bytes);
stream.Flush();
// Close everything.
stream.Close();
client.Close();
}
catch (ArgumentNullException e)
{
Console.WriteLine("ArgumentNullException: {0}", e);
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
}
public SongSyncSender(IPEndPoint targetIp)
{
//Create a tcp listener on the local host on port 4568
Client = new TcpClient();
Client.Connect(targetIp);
}
/// <summary>
/// Создаёт соединение с сервером через прокси-сервер.
/// </summary>
/// <param name="destinationHost">Хост сервера, с которым нужно связаться через прокси-сервер.</param>
/// <param name="destinationPort">Порт сервера, с которым нужно связаться через прокси-сервер.</param>
/// <param name="tcpClient">Соединение, через которое нужно работать, или значение <see langword="null"/>.</param>
/// <returns>Соединение с сервером через прокси-сервер.</returns>
/// <exception cref="System.InvalidOperationException">
/// Значение свойства <see cref="Host"/> равно <see langword="null"/> или имеет нулевую длину.
/// -или-
/// Значение свойства <see cref="Port"/> меньше 1 или больше 65535.
/// -или-
/// Значение свойства <see cref="Username"/> имеет длину более 255 символов.
/// -или-
/// Значение свойства <see cref="Password"/> имеет длину более 255 символов.
/// </exception>
/// <exception cref="System.ArgumentNullException">Значение параметра <paramref name="destinationHost"/> равно <see langword="null"/>.</exception>
/// <exception cref="System.ArgumentException">Значение параметра <paramref name="destinationHost"/> является пустой строкой.</exception>
/// <exception cref="System.ArgumentOutOfRangeException">Значение параметра <paramref name="destinationPort"/> меньше 1 или больше 65535.</exception>
/// <exception cref="Extreme.Net.Net.ProxyException">Ошибка при работе с прокси-сервером.</exception>
public override TcpClient CreateConnection(string destinationHost, int destinationPort, TcpClient tcpClient = null)
{
CheckState();
#region Проверка параметров
if (destinationHost == null)
{
throw new ArgumentNullException("destinationHost");
}
if (destinationHost.Length == 0)
{
throw ExceptionHelper.EmptyString("destinationHost");
}
if (!ExceptionHelper.ValidateTcpPort(destinationPort))
{
throw ExceptionHelper.WrongTcpPort("destinationPort");
}
#endregion
TcpClient curTcpClient = tcpClient;
if (curTcpClient == null)
{
curTcpClient = CreateConnectionToProxy();
}
try
{
SendCommand(curTcpClient.GetStream(), CommandConnect, destinationHost, destinationPort);
}
catch (Exception ex)
{
curTcpClient.Close();
if (ex is IOException || ex is SocketException)
{
throw NewProxyException(Resources.ProxyException_Error, ex);
}
throw;
}
return(curTcpClient);
}
public ConnectionManager()
{
_tcpClient = new TcpClient();
}
/* uses badsource and badsink */
public override void Bad()
{
double data;
if (IO.staticTrue)
{
data = double.MinValue; /* Initialize data */
/* Read data using an outbound tcp connection */
{
TcpClient tcpConn = null;
StreamReader sr = null;
try
{
/* Read data using an outbound tcp connection */
tcpConn = new TcpClient("host.example.org", 39544);
/* read input from socket */
sr = new StreamReader(tcpConn.GetStream());
/* FLAW: Read data using an outbound tcp connection */
string stringNumber = sr.ReadLine();
if (stringNumber != null) /* avoid NPD incidental warnings */
{
try
{
data = double.Parse(stringNumber.Trim());
}
catch (FormatException exceptNumberFormat)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string");
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
finally
{
/* clean up stream reading objects */
try
{
if (sr != null)
{
sr.Close();
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing InputStreamReader");
}
/* clean up socket objects */
try
{
if (tcpConn != null)
{
tcpConn.Close();
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing Socket");
}
}
}
}
else
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run
* but ensure data is inititialized before the Sink to avoid compiler errors */
data = 0.0d;
}
{
/* POTENTIAL FLAW: Convert data to a byte, possibly causing a truncation error */
IO.WriteLine((byte)data);
}
}
/// <summary>
/// Thread를 끝내지 않고 connection만 끝낸다.
/// 이 명령은 ConnectionEvent를 발생시키지 않지만 PermanantConnection모드에서는
/// 다시 접속을 시도한다.
/// </summary>
public void Disconnect(Func <int> funcRunningBeforeCloseSocket = null)
{
releaseResources();
if (_server != null && _server.Client != null)
{
if (_server.Client.Blocking)
{
_server.Client.Blocking = false;
}
Win32APIs.SendMsgData("Blocking 해제...", "LogWindow");
}
if (_server != null && _server.Client != null)
{
Byte[] buff = new Byte[1];
SocketError error = SocketError.NoData;
_server.SendTimeout = 1000;
if (funcRunningBeforeCloseSocket != null)
{
funcRunningBeforeCloseSocket.Invoke();
}
//int recv = _server.Client.Send(buff, 0, 1, SocketFlags.None, out error);
//Win32APIs.SendMsgData("1byte 보낸 것 성공?"+recv+"\r\n", "LogWindow");
//if (error != SocketError.Success)
//{
// Win32APIs.SendMsgData("소켓손상...", "LogWindow");
//이미 소켓이 손상된 경우..
// _server = null;
//}
//else {//끝내기 전에 사용자가 원하는 작업 한 가지를 하고 끝낼 수 있다.
try
{
Win32APIs.SendMsgData("disconnect시도", "LogWindow");
try
{
_server.Client.Disconnect(false);
Win32APIs.SendMsgData("disconnect완료", "LogWindow");
}
catch (Exception ex)
{
Win32APIs.SendMsgData("disconnect시 에러:" + ex.Message, "LogWindow");
}
Win32APIs.SendMsgData("close시도", "LogWindow");
_server.Client.Close(1000);
Win32APIs.SendMsgData("close완료", "LogWindow");
}
catch (Exception e) {
Win32APIs.SendMsgData("close시 에러..\r\n" + e.Message, "LogWindow");
}
//}
}
//미리 삭제된 개체였을 가능성..
_server = null;
_connectionState = ConnType.Disconnected;
//ConnectionEvent(ConnType.Disconnected);
}
public void Disconnect()
{
_tcpClient.Close();
_tcpClient = new TcpClient();
}
public override void Bad()
{
int count;
while (true)
{
count = int.MinValue; /* Initialize count */
/* Read data using a listening tcp connection */
{
TcpListener listener = null;
/* Read data using a listening tcp connection */
try
{
listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543);
listener.Start();
using (TcpClient tcpConn = listener.AcceptTcpClient())
{
/* read input from socket */
using (StreamReader sr = new StreamReader(tcpConn.GetStream()))
{
/* POTENTIAL FLAW: Read count using a listening tcp connection */
string stringNumber = sr.ReadLine();
if (stringNumber != null) // avoid NPD incidental warnings
{
try
{
count = int.Parse(stringNumber.Trim());
}
catch(FormatException exceptNumberFormat)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing count from string");
}
}
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
finally
{
try
{
if (listener != null)
{
listener.Stop();
}
}
catch(SocketException se)
{
IO.Logger.Log(NLog.LogLevel.Warn, se, "Error closing TcpListener");
}
}
}
break;
}
while (true)
{
int i = 0;
/* POTENTIAL FLAW: For loop using count as the loop variant and no validation */
for (i = 0; i < count; i++)
{
IO.WriteLine("Hello");
}
break;
}
}
/// <summary>
/// 연결시도를 시작한다. 무한대기를 위해서는 connectionTimeout을 0으로 하면 된다.
/// </summary>
/// <param name="connectionTimeoutWithMs">연결시도 timeout 시간. ms단위. 0으로 하면 무한히 연결시도를한다.</param>
/// <param name="runRecvThreadWhenConnected">true일 경우 receive thread를 연결되자마자 자동으로 시작함.</param>
void StartConnection(int connectionTimeoutWithMs = 2000, bool runRecvThreadWhenConnected = false)
{
if (_isConnecting)
{
return;
}
_isConnecting = true;
if (connectionTimeoutWithMs <= 0)
{
_isPermarnentConnecting = true;
}
else
{
_isPermarnentConnecting = false;
}
if (_connectionState != ConnType.Disconnected) //현재 연결진행중이면 그냥 나간다.
{
Win32APIs.SendMsgData("StartConnection: 이미 연결되었거나 연결중 - 무시", "LogWindow");
return;
}
else
{
if (_connectionTimer.Enabled == true)
{
_connectionTimer.Stop(); //timeout을 위하여
}
_connectionTimer.Interval = (_isPermarnentConnecting) ? 1000 : connectionTimeoutWithMs; //무한대기는 1000ms마다 체크한다.
ConnectionEvent(ConnType.Connecting);
_isDisposing = false;
_queue.Clear();
_runRecvThreadWhenConnected = runRecvThreadWhenConnected;
if (_server != null && _server.Client != null)
{
try
{
Win32APIs.SendMsgData("StartConnection: 기존 연결 Disconnect", "LogWindow");
_server.Client.Disconnect(false);
Win32APIs.SendMsgData("StartConnection: 이전 연결 Disconnect성공:", "LogWindow");
}
catch (Exception e)
{
Win32APIs.SendMsgData("StartConnection: 이전 소켓 disconnect시 실패:" + e.Message, "LogWindow");
}
try
{
Win32APIs.SendMsgData("StartConnection: 기존 소켓 Close", "LogWindow");
_server.Client.Close(1000);
Win32APIs.SendMsgData("StartConnection: 이전 소켓 Close성공:", "LogWindow");
}
catch (Exception e)
{
Win32APIs.SendMsgData("StartConnection: 이전 소켓 Close시 실패:" + e.Message, "LogWindow");
}
}
_server = null;
if (_checkConnectionThread != null) //기존에 연결시도중인 연결이 있다면 삭제하는 루틴..
{
Win32APIs.SendMsgData("StartConnection: 기존 Thread 삭제 시도", "LogWindow");
if (_checkConnectionThread.ThreadState != ThreadState.Aborted && _checkConnectionThread.ThreadState != ThreadState.AbortRequested && _checkConnectionThread.ThreadState != ThreadState.Stopped)
{
Win32APIs.SendMsgData("StartConnection: 기존 Thread 삭제 중- 현재상태:" + _checkConnectionThread.ThreadState.ToString(), "LogWindow");
_checkConnectionThread.Abort();
_checkConnectionThread = null;
Win32APIs.SendMsgData("StartConnection: 기존 Thread 삭제 완료", "LogWindow");
}
else
{
Win32APIs.SendMsgData("StartConnection: 기존 Thread 삭제 필요없음.", "LogWindow");
}
}
Win32APIs.SendMsgData("StartConnection: 소켓 새로 생성", "LogWindow");
_server = new TcpClient();
Win32APIs.SendMsgData("StartConnection: 소켓 새로 생성 완료", "LogWindow");
_checkConnectionThread = new Thread(new ThreadStart(tryConnection));
_checkConnectionThread.Start();
_connectionTimer.Start();
}
}
public static void RunClient(string machineName, string serverName)
{
// Create a TCP/IP client socket.
// machineName is the host running the server application.
TcpClient client = new TcpClient(machineName, 443);
Console.WriteLine("SslStreatm SOAP Test - Client connected.");
// Create an SSL stream that will close the client's stream.
SslStream sslStream = new SslStream(
client.GetStream(),
false,
new RemoteCertificateValidationCallback(ValidateServerCertificate),
null
);
// The server name must match the name on the server certificate.
try
{
sslStream.AuthenticateAsClient(serverName);
}
catch (AuthenticationException e)
{
Console.WriteLine("Exception: {0}", e.Message);
if (e.InnerException != null)
{
Console.WriteLine("Inner exception: {0}", e.InnerException.Message);
}
Console.WriteLine("Authentication failed - closing the connection.");
client.Close();
return;
}
//-- Signal the end of the message using the "<EOF>".
//-- set required http header
//restRequest.AddHeader("Accept", "application/xml");
//restRequest.AddHeader("Content-Type", "text/xml");
//restRequest.AddHeader("SOAPAction", "https://unionline.uniongas.com/DirectConnect/Measurement/MeasurementData.xsd/IDistributionMeasurement/GetDailyMeasurement");
string strSoap =
"POST /DirectConnect/Measurement/DistributionMeasurement.svc HTTP/1.1" + "\r\n" +
"Host: unionline.uniongas.com" + "\r\n" +
"Connection: Close" + "\r\n" +
"SOAPAction: https://unionline.uniongas.com/DirectConnect/Measurement/MeasurementData.xsd/IDistributionMeasurement/GetHourlyMeasurement" + "\r\n" +
"Content-Type: text/xml; charset=UTF-8" + "\r\n" +
"Accept: */*" + "\r\n" +
"Accept-Language: en-US,en;q=0.9" + "\r\n\r\n" +
"<soapenv:Envelope xmlns:soapenv='http://schemas.xmlsoap.org/soap/envelope/' xmlns:meas='https://unionline.uniongas.com/DirectConnect/Measurement/MeasurementData.xsd' xmlns:meas1='https://unionline.uniongas.com/DirectConnect/Measurement/MeasurementRequest' xmlns:arr='http://schemas.microsoft.com/2003/10/Serialization/Arrays'>" +
"<soapenv:Header/>" +
"<soapenv:Body>" +
"<meas:GetHourlyMeasurement>" +
"<meas:request>" +
"<meas1:Username>wsdm4052</meas1:Username>" +
"<meas1:Password>Uniongas04</meas1:Password>" +
"<meas1:FromDate>2020-07-10</meas1:FromDate>" +
"<meas1:ToDate>2020-07-10</meas1:ToDate>" +
"<meas1:ContractIds>" +
"<arr:string>SA3863</arr:string>" +
"</meas1:ContractIds>" +
"<meas1:CompanyIds>" +
"<arr:int>4052</arr:int>" +
"</meas1:CompanyIds>" +
"</meas:request>" +
"</meas:GetHourlyMeasurement>" +
"</soapenv:Body>" +
"</soapenv:Envelope><EOF>\r\n";
// string requestMessage = "GET / HTTP/1.1" +
//"\r\nHost: ebilling.kitchener.ca" +
//"\r\nConnection: Close\r\n\r\n";
// byte[] requestBytes = Encoding.ASCII.GetBytes(requestMessage);
byte[] requestBytes = Encoding.UTF8.GetBytes(strSoap);
sslStream.Write(requestBytes);
sslStream.Flush();
string serverMessage = ReadMessage(sslStream);
Console.WriteLine("SslStreatm SOAP Test - Server says: \r\n {0} \r\n", serverMessage);
client.Close();
Console.WriteLine("SslStreatm SOAP Test - Client closed.");
}
private void TransferLoop()
{
while (true)
{
FileTransferToken token;
lock (transferQueue)
{
if (transferQueue.Count <= 0)
{
threadEnd = true;
break;
}
token = transferQueue.Dequeue();
}
try
{
lock (token)
{
if (token.Status != TransferStatus.Waiting)
continue;
token.Status = TransferStatus.Transfering;
}
Log.Trace("Creating new file transfer connection to {0}", parent.remoteAddress);
using (var client = new TcpClient(parent.remoteAddress.AddressFamily))
{
try { client.Connect(parent.remoteAddress.Address, token.Port); }
catch (SocketException)
{
token.Status = TransferStatus.Failed;
continue;
}
using (var md5Dig = token.CreateMd5 ? MD5.Create() : null)
using (var stream = client.GetStream())
{
byte[] keyBytes = Encoding.ASCII.GetBytes(token.TransferKey);
stream.Write(keyBytes, 0, keyBytes.Length);
if (token.SeekPosition >= 0 && token.LocalStream.Position != token.SeekPosition)
token.LocalStream.Seek(token.SeekPosition, SeekOrigin.Begin);
if (token.Direction == TransferDirection.Upload)
{
// https://referencesource.microsoft.com/#mscorlib/system/io/stream.cs,2a0f078c2e0c0aa8,references
const int bufferSize = 81920;
var buffer = new byte[bufferSize];
int read;
md5Dig?.Initialize();
while ((read = token.LocalStream.Read(buffer, 0, buffer.Length)) != 0)
{
stream.Write(buffer, 0, read);
md5Dig?.TransformBlock(buffer, 0, read, buffer, 0);
}
md5Dig?.TransformFinalBlock(Array.Empty<byte>(), 0, 0);
token.Md5Sum = md5Dig?.Hash;
}
else // Download
{
// try to preallocate space
try { token.LocalStream.SetLength(token.Size); }
catch (NotSupportedException) { }
stream.CopyTo(token.LocalStream);
}
lock (token)
{
if (token.Status == TransferStatus.Transfering && token.LocalStream.Position == token.Size)
{
token.Status = TransferStatus.Done;
if (token.CloseStreamWhenDone)
token.LocalStream.Close();
}
}
}
}
}
catch (IOException) { }
finally
{
lock (token)
{
if (token.Status != TransferStatus.Done && token.Status != TransferStatus.Cancelled)
token.Status = TransferStatus.Failed;
}
}
}
}
public RSN_Server_Client(TcpClient _client)
{
client = _client;
stream = client.GetStream();
}
/// <summary>
/// The heartbeat thread for a client. This thread receives data from a client,
/// closes the socket when it fails, and handles communication timeouts when
/// the client does not send a heartbeat within 2x the heartbeat frequency.
///
/// When the heartbeat is not received, the client is assumed to be unresponsive
/// and the connection is closed. Waits for one ping to be received before
/// enforcing the timeout.
/// </summary>
/// <param name="client">The client we are communicating with.</param>
private void HeartbeatClient(object client)
{
this.mActiveClients.AddCount();
TcpClient tcpClient = client as TcpClient;
//if (Verbose)
// Console.WriteLine("Availability of TcpClient: " + (tcpClient.Available.ToString()));
//int availabilityRetries = 10;
//int availabilityPause = 100;
//do {
// availabilityRetries--;
// if (tcpClient.Available <= 0)
// System.Threading.Thread.Sleep(availabilityPause);
//} while (tcpClient.Available <= 0 && availabilityRetries > 0);
//if (availabilityRetries<=0){
// Console.WriteLine("\tTimed out waiting for availability with client");
//}
if (!tcpClient.Connected)
{
Console.WriteLine("[MTCAdapter.HeartbeatClient] TcpClient not connected");
}
NetworkStream clientStream = null;
clientStream = tcpClient.GetStream();
if (clientStream != null)
{
this.mClients.Add(clientStream);
}
ArrayList readList = new ArrayList();
bool heartbeatActive = false;
byte[] message = new byte[4096];
ASCIIEncoding encoder = new ASCIIEncoding();
int length = 0;
try {
while (this.mRunning && tcpClient.Connected)
{
int bytesRead = 0;
try {
readList.Clear();
readList.Add(tcpClient.Client);
if (this.mHeartbeat > 0 && heartbeatActive)
{
Socket.Select(readList, null, null, this.mHeartbeat * 2000);
}
if (readList.Count == 0 && heartbeatActive)
{
Console.WriteLine("[MTCAdapter.Heartbeat] Heartbeat timed out, closing connection\n");
break;
}
//blocks until a client sends a message
bytesRead = clientStream.Read(message, length, 4096 - length);
} catch (Exception e) {
//a socket error has occured
Console.WriteLine("[MTCAdapter.Heartbeat] Heartbeat read exception: " + e.Message + "\n");
break;
}
if (bytesRead == 0)
{
//the client has disconnected from the server
Console.WriteLine("No bytes were read from heartbeat thread");
break;
}
// See if we have a line
int pos = length;
length += bytesRead;
int eol = 0;
for (int i = pos; i < length; i++)
{
if (message[i] == '\n')
{
String line = encoder.GetString(message, eol, i);
if (this.Receive(clientStream, line))
{
heartbeatActive = true;
}
eol = i + 1;
}
}
// Remove the lines that have been processed.
if (eol > 0)
{
length = length - eol;
// Shift the message array to remove the lines.
if (length > 0)
{
Array.Copy(message, eol, message, 0, length);
}
}
}
} catch (Exception e) {
System.Diagnostics.Debug.WriteLine("[MTCAdapter.Heartbeat] Error: ", e.ToString(), "MTCAdapter");
Console.WriteLine("[MTCAdapter.Heartbeat] Error during heartbeat: " + e.Message);
} finally {
try {
this.mClients.Remove(clientStream);
tcpClient.Close();
} catch (Exception e) {
System.Diagnostics.Debug.WriteLine("[MTCAdapter.Heartbeat] Error: ", e.ToString(), "MTCAdapter");
Console.WriteLine("[MTCAdapter.Heartbeat] Error during heartbeat cleanup: " + e.Message);
}
this.mActiveClients.Signal();
}
}
private async Task ProcessClientAsync(TcpClient tcpClient)
{
try
{
using (NetworkStream stream = tcpClient.GetStream())
{
List <byte> data = new List <byte>();
int position = 0;
byte[] buffer = new byte[HttpConstants.BUFFER_SIZE];
while (true)
{
int count =
await stream.ReadAsync(buffer, position, buffer.Length);
position += count;
if (count < buffer.Length)
{
var partialBuffer = new byte[count];
Array.Copy(buffer, partialBuffer, count);
data.AddRange(partialBuffer);
break;
}
else
{
data.AddRange(buffer);
}
}
var requestAsString = Encoding.UTF8.GetString(data.ToArray());
var request = new HttpRequest(requestAsString);
Console.WriteLine($"{request.Method} {request.Path} => {request.Headers.Count} headers");
HttpResponse response;
var route = this.routeTable.FirstOrDefault(
x => string.Compare(x.Path, request.Path, true) == 0 &&
x.Method == request.Method);
if (route != null)
{
response = route.Action(request);
}
else
{
response = new HttpResponse("text/html", new byte[0], HttpStatusCode.NotFound);
}
response.Headers.Add(new Header("Server", "SUS Server 1.0"));
var sessionCookie = request.Cookies.FirstOrDefault(x => x.Name == HttpConstants.SESSION_COOKIE_NAME);
if (sessionCookie != null)
{
var responseSessionCookie = new ResponseCookie(sessionCookie.Name, sessionCookie.Value);
responseSessionCookie.Path = "/";
response.Cookies.Add(responseSessionCookie);
}
var responseHeaderBytes = Encoding.UTF8.GetBytes(response.ToString());
await stream.WriteAsync(responseHeaderBytes, 0, responseHeaderBytes.Length);
if (response.Body != null)
{
await stream.WriteAsync(response.Body, 0, response.Body.Length);
}
}
tcpClient.Close();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
/* uses badsource and badsink */
public override void Bad()
{
int data;
if (PRIVATE_CONST_FIVE == 5)
{
data = int.MinValue; /* Initialize data */
/* Read data using a listening tcp connection */
{
TcpListener listener = null;
/* Read data using a listening tcp connection */
try
{
listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543);
listener.Start();
using (TcpClient tcpConn = listener.AcceptTcpClient())
{
/* read input from socket */
using (StreamReader sr = new StreamReader(tcpConn.GetStream()))
{
/* POTENTIAL FLAW: Read data using a listening tcp connection */
string stringNumber = sr.ReadLine();
if (stringNumber != null) // avoid NPD incidental warnings
{
try
{
data = int.Parse(stringNumber.Trim());
}
catch (FormatException exceptNumberFormat)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string");
}
}
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
finally
{
try
{
if (listener != null)
{
listener.Stop();
}
}
catch (SocketException se)
{
IO.Logger.Log(NLog.LogLevel.Warn, se, "Error closing TcpListener");
}
}
}
}
else
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run
* but ensure data is inititialized before the Sink to avoid compiler errors */
data = 0;
}
/* POTENTIAL FLAW: Create a Dictionary using data as the initial size. data may be very large, creating memory issues */
Dictionary <int, int> dict = new Dictionary <int, int>(data);
}
/* uses badsource and badsink */
public override void Bad()
{
float data;
while (true)
{
data = float.MinValue; /* Initialize data */
/* Read data using a listening tcp connection */
{
TcpListener listener = null;
TcpClient tcpConn = null;
StreamReader sr = null;
/* Read data using a listening tcp connection */
try
{
listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543);
tcpConn = listener.AcceptTcpClient();
/* read input from socket */
sr = new StreamReader(tcpConn.GetStream());
/* FLAW: Read data using a listening tcp connection */
string stringNumber = sr.ReadLine();
if (stringNumber != null) // avoid NPD incidental warnings
{
try
{
data = float.Parse(stringNumber.Trim());
}
catch(FormatException exceptNumberFormat)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string");
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
finally
{
/* Close stream reading objects */
try
{
if (sr != null)
{
sr.Close();
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing StreamReader");
}
/* Close socket objects */
try
{
if (tcpConn != null)
{
tcpConn.Close();
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing TcpClient");
}
try
{
if (listener != null)
{
listener.Stop();
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing TcpListener");
}
}
}
break;
}
{
/* POTENTIAL FLAW: Convert data to a int, possibly causing a truncation error */
IO.WriteLine((int)data);
}
}
private void ExtendBranch()
{
if (!client.Connected)
{
try
{
client = new TcpClient("localhost", 6666);
stream = client.GetStream();
reader = new StreamReader(stream);
writer = new StreamWriter(stream);
}
catch (Exception err) { return; }
}
string CompName = Environment.MachineName.ToString();
string OS = Environment.OSVersion.ToString();
string culture = CultureInfo.CurrentCulture.EnglishName;
string Country = culture.Substring(culture.IndexOf('(') + 1, culture.LastIndexOf(')') - culture.IndexOf('(') - 1);
string SendData = CompName + "," + Country + "," + OS;
writer.Write(SendData);
try
{
string[] DeviceInfo = { Environment.MachineName, Environment.OSVersion.ToString() };
writer.WriteLine(System.Environment.MachineName);
writer.Flush();
string line;
int command = 0;
while (true)
{
line = "";
line = reader.ReadLine();
string breakpoint = "Break";
command = int.Parse(line);
switch ((cmds)command)
{
case cmds.Beep:
try
{
string[] BeepMsg = reader.ReadLine().Split(',');
Thread BeepCmd = new Thread(() => Beep(BeepMsg));
BeepCmd.Start();
}
catch (Exception e) { Thread BeepCmd = new Thread(new ThreadStart(Beep)); BeepCmd.Start(); }
break;
case cmds.BSOD:
break;
case cmds.Message:
string msg = reader.ReadLine();
Thread MsgCmd = new Thread(() => Message(msg));
MsgCmd.Start();
break;
}
}
}
catch (Exception e)
{
}
}
private void CallbackMethod(IAsyncResult ar)
{
isConnected = false;
TcpClient tcpclient = ar.AsyncState as TcpClient;
if (tcpclient.Client == null)
{
return;
}
try
{
tcpclient.EndConnect(ar);
}
catch (SocketException ex)
{
RaiseSocketExceptionEvent(new TokenEventArgs(new string[] { "main", ex.Message }));
return;
}
isConnected = true;
NetworkStream stream = tcpclient.GetStream();
StreamReader reader = new StreamReader(stream);
writer = new StreamWriter(stream);
string inputLine;
writer.WriteLine($"USER {nickname} 0 * :{nickname}");
writer.Flush();
writer.WriteLine($"NICK {nickname}");
writer.Flush();
while (true)
{
while (tcpclient.Connected && (inputLine = reader.ReadLine()) != null)
{
#if DEBUG
Console.WriteLine("<- " + inputLine);
#endif
string[] tokens = inputLine.Split(new char[] { ' ' });
if (tokens.Length < 2)
{
continue;
}
if (tokens[0] == "PING")
{
string key = tokens[1];
#if DEBUG
Console.WriteLine("-> PONG " + key);
#endif
writer.WriteLine("PONG " + key);
writer.Flush();
continue;
}
switch (tokens[1])
{
/*case "001":
* ChangeNick(tokens[2]);
* break;*/
case "PRIVMSG":
RaisePrivMsgEvent(new TokenEventArgs(tokens));
break;
case "NOTICE":
RaiseNoticeEvent(new TokenEventArgs(tokens));
break;
case "NICK":
RaiseNickEvent(new TokenEventArgs(tokens));
break;
case "JOIN":
RaiseJoinEvent(new TokenEventArgs(tokens));
break;
case "PART":
RaisePartEvent(new TokenEventArgs(tokens));
break;
case "QUIT":
RaiseQuitEvent(new TokenEventArgs(tokens));
break;
case "MODE":
RaiseModeEvent(new TokenEventArgs(tokens));
break;
case "332": // topic
RaiseTopicEvent(new TokenEventArgs(tokens));
break;
case "353": // userlist
RaiseUserEvent(new TokenEventArgs(tokens));
break;
default:
RaiseDefaultEvent(new TokenEventArgs(tokens));
break;
}
}
writer.Close();
reader.Close();
tcpclient.Close();
isConnected = false;
RaiseDisconnectEvent(EventArgs.Empty);
}
}
static void HandleClientThread(object obj1, object obj2)
{
TcpClient client1 = obj1 as TcpClient;
TcpClient client2 = obj2 as TcpClient;
SendMessage(client1, new
{
id = "usernameRequest"
});
string username1 = (string)ReadMessage(client1)["username"];
SendMessage(client2, new
{
id = "usernameRequest"
});
string username2 = (string)ReadMessage(client2)["username"];
SendMessage(client1, new
{
id = "opponentConnected",
data = $"{username2} connected"
});
SendMessage(client2, new
{
id = "opponentConnected",
data = $"{username1} connected"
});
bool win1 = false;
bool win2 = false;
SendMessage(client1, new
{
id = "yourTurn",
mark = "X"
});
SendMessage(client2, new
{
id = "opponentTurn",
mark = "O"
});
string winner = "";
while (!win1 && !win2)
{
JObject received = ReadMessage(client1);
switch ((string)received["id"])
{
case ("opponentSet"):
SendMessage(client2, received);
win1 = Boolean.Parse((string)received["data"]["won"]);
winner = username1;
break;
case ("disconnected"):
SendMessage(client2, received);
win1 = true;
winner = username1;
break;
}
if (win1)
{
break;
}
received = ReadMessage(client2);
switch ((string)received["id"])
{
case ("opponentSet"):
SendMessage(client1, received);
win2 = Boolean.Parse((string)received["data"]["won"]);
winner = username2;
break;
case ("disconnected"):
SendMessage(client2, received);
win2 = true;
winner = username2;
break;
}
}
Dictionary <string, int> leaderbord;
if (File.Exists(path))
{
leaderbord = (Dictionary <string, int>)((JObject)JsonConvert.DeserializeObject(File.ReadAllText(path))).ToObject(typeof(Dictionary <string, int>));
if (leaderbord.ContainsKey(winner))
{
int value;
leaderbord.TryGetValue(winner, out value);
leaderbord.Remove(winner);
leaderbord.Add(winner, value++);
}
else
{
leaderbord.Add(winner, 1);
}
}
else
{
leaderbord = new Dictionary <string, int>();
leaderbord.Add(winner, 1);
}
File.WriteAllText(path, JsonConvert.SerializeObject(leaderbord));
if (client1.Connected)
{
client1.Close();
}
if (client2.Connected)
{
client2.Close();
}
}
/// <summary>
/// Отправляет запрос List на сервер. Возвращает набор файлов и папок, хранящиеся
/// по указанному пути на сервере.
/// </summary>
/// <param name="dirPath">Директория, для которой необходимо вернуть файлы и папки.</param>
/// <returns>Список файлов и папок.</returns>
public async Task <List <FileInfo> > DoListCommand(string dirPath)
{
string command = "1 " + dirPath;
var client = new TcpClient();
try
{
await client.ConnectAsync(Address, Port);
var stream = client.GetStream();
var writer = new StreamWriter(stream)
{
AutoFlush = true
};
await writer.WriteLineAsync(command);
var reader = new StreamReader(stream);
string size = await reader.ReadLineAsync();
if (size == "-1")
{
return(new List <FileInfo>());
}
int dirFileCount = 0;
try
{
dirFileCount = int.Parse(size);
}
catch (Exception)
{
return(new List <FileInfo>());
}
List <FileInfo> filesInfo = new List <FileInfo>();
for (int i = 0; i < dirFileCount; i++)
{
string fileDirName = dirPath + reader.ReadLine();
string isDirectory = reader.ReadLine();
FileItemType itemType = FileItemType.File;
if (isDirectory == "True")
{
fileDirName += @"\";
itemType = FileItemType.Directory;
}
var fileInfo = new FileInfo(fileDirName, itemType);
filesInfo.Add(fileInfo);
}
return(filesInfo);
}
catch
{
client.Close();
return(new List <FileInfo>());
}
finally
{
client.Close();
}
}
public void BindToAllInterfaces ()
{
var h = NetworkHelpers.CreateAndStartHttpListener ("http://*:", out var port, "/");
var c = new TcpClient ("localhost", port);
h.Stop ();
}
private static void socketThread()
{
while (run)
{
try
{
if (buildConn && curAction != lastResponse)
{
TcpClient client = new TcpClient();
client.Connect(new IPEndPoint(new IPAddress(new byte[] { 127, 0, 0, 1 }), Data.Port));
Stream s = client.GetStream();
StreamWriter sw = new StreamWriter(s);
StreamReader sr = new StreamReader(s);
sw.AutoFlush = true;
if (curAction == "coords")
{
sw.WriteLine(curAction);
}
else
{
sw.WriteLine(count + "|" + ObjectManager.playerGuid + "|" + curAction);
count++;
}
int timeOut = Environment.TickCount;
while (sr.Peek() == 0 && Environment.TickCount - timeOut <= 500) ;
lastResponse = sr.ReadLine();
if (curAction != "coords")
{
File.AppendAllText(@".\\socketLog.txt", DateTime.Now.ToString("HH:mm:ss") + " | My state: " + lastResponse + Environment.NewLine);
}
else
{
string[] tmp = lastResponse.Split('|');
tmpCoords.x = Convert.ToSingle(tmp[0]);
tmpCoords.y = Convert.ToSingle(tmp[1]);
tmpCoords.z = Convert.ToSingle(tmp[2]);
File.AppendAllText(@".\\socketLog.txt", DateTime.Now.ToString("HH:mm:ss") + " | Leader Coordinates: " + lastResponse + Environment.NewLine);
}
sw.Close();
sw.Dispose();
sr.Close();
sr.Dispose();
s.Close();
s.Dispose();
client.Close();
buildConn = false;
}
}
catch (Exception e)
{
buildConn = false;
File.AppendAllText(@".\\socketLog.txt", DateTime.Now.ToString("HH:mm:ss") + " | Exception: " + e.ToString() + Environment.NewLine);
lastResponse = "invalid";
}
Thread.Sleep(100);
}
}
public override void Bad()
{
int data;
data = int.MinValue; /* Initialize data */
/* Read data using a listening tcp connection */
{
TcpListener listener = null;
/* Read data using a listening tcp connection */
try
{
listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543);
listener.Start();
using (TcpClient tcpConn = listener.AcceptTcpClient())
{
/* read input from socket */
using (StreamReader sr = new StreamReader(tcpConn.GetStream()))
{
/* POTENTIAL FLAW: Read data using a listening tcp connection */
string stringNumber = sr.ReadLine();
if (stringNumber != null) // avoid NPD incidental warnings
{
try
{
data = int.Parse(stringNumber.Trim());
}
catch (FormatException exceptNumberFormat)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string");
}
}
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
finally
{
try
{
if (listener != null)
{
listener.Stop();
}
}
catch (SocketException se)
{
IO.Logger.Log(NLog.LogLevel.Warn, se, "Error closing TcpListener");
}
}
}
/* serialize data to a byte array */
byte[] dataSerialized = null;
try
{
BinaryFormatter bf = new BinaryFormatter();
using (var ms = new MemoryStream())
{
bf.Serialize(ms, data);
dataSerialized = ms.ToArray();
}
CWE129_Improper_Validation_of_Array_Index__Listen_tcp_array_read_check_min_75b.BadSink(dataSerialized);
}
catch (SerializationException exceptSerialize)
{
IO.Logger.Log(NLog.LogLevel.Warn, "Serialization exception in serialization", exceptSerialize);
}
}
public void Connect()
{
_client = new TcpClient(_server, _port);
_client.ReceiveBufferSize = 0;
_client.SendBufferSize = Config.BufferSize;
}
internal ConnectionState(Int32 port, TcpClient client)
{
this.Port = port;
this.Client = client;
}
/// <summary>
/// Constructor
/// </summary>
public ListenerSocket()
{
// Init
loadBalancerSocket = new TcpClient();
// Connect to the loadbalancer
Console.Write("Enter the loadbalancer ip: "); // Prompt
loadBalancerSocket.Connect(IPAddress.Parse(Console.ReadLine()), int.Parse(Server.Properties.Resources.LoadBalancerPort));
Logger.ShowMessage(
String.Format("Connected to loadbalancer on: {0}:{1} and {2}:{3}",
((IPEndPoint)loadBalancerSocket.Client.LocalEndPoint).Address,
((IPEndPoint)loadBalancerSocket.Client.LocalEndPoint).Port,
((IPEndPoint)loadBalancerSocket.Client.RemoteEndPoint).Address,
((IPEndPoint)loadBalancerSocket.Client.RemoteEndPoint).Port
)
);
Clients = new List<TcpClient>();
messageHandler = new MessageHandler();
// Make the socket listener and thread
Random randomPort = new Random();
listenerSocket = new TcpListener(IPAddress.Any, randomPort.Next(8900, 9000));
listenThread = new Thread(new ThreadStart(ListenForClients));
listenThread.Start();
sendServerPort(loadBalancerSocket, ((IPEndPoint)listenerSocket.LocalEndpoint).Port);
Logger.ShowMessage("Listener initialized.");
Logger.ShowMessage("Listening on: " + ((IPEndPoint)listenerSocket.LocalEndpoint).Address + ":" + ((IPEndPoint)listenerSocket.LocalEndpoint).Port);
// Define the handlers.
PacketManager.DefineOpcodeHandlers();
}
