static void Main(string[] arg)
{
SecurePlugin.Factory factory = new SecurePlugin.Factory ("test-pub-priv-key.snk");
SecurePlugin.IDPair pair = factory.BuildSecurePlugin (arg[0]);
SecurePlugin.DataBase db = new SecurePlugin.DataBase();
db.Insert (pair.license_id, pair.plugin_id);
db.Print();
TcpClient client = null;
TcpListener server = null;
try
{
server = new TcpListener (IPAddress.Parse ("127.0.0.1"), 6969);
server.Start();
while (true)
ThreadPool.QueueUserWorkItem
(new LicenseHandler (server.AcceptTcpClient (), db).Start);
}
catch (SocketException e)
{
Console.WriteLine ("SocketException: {0}", e);
}
finally
{
server.Stop();
}
}
public int Start ()
{
bool processed;
Console.WriteLine ("Touch.Unit Simple Server listening on: {0}:{1}", Address, Port);
server = new TcpListener (Address, Port);
try {
server.Start ();
do {
using (TcpClient client = server.AcceptTcpClient ()) {
processed = Processing (client);
}
} while (!AutoExit || !processed);
}
catch (Exception e) {
Console.WriteLine ("[{0}] : {1}", DateTime.Now, e);
return 1;
}
finally {
server.Stop ();
}
return 0;
}
protected override void Execute()
{
TcpListener server = null;
NetworkStream stream = null;
TcpClient client = null;
server = new TcpListener(8080);
server.Start();
byte[] buffer = new byte[150 * 1024];
int i = 0;
logger.Log("Thread Start");
for(;;){
client = server.AcceptTcpClient();
stream = client.GetStream();
while ((i = stream.Read(buffer, 0, buffer.Length)) != 0){
retrievedPacket(i, buffer);
i = 0;
if(terminate) break;
}
client.Close();
Thread.Sleep(1000 / 30);
if(terminate) break;
}
server.Stop();
logger.Log("Thread Stop");
}
public static void Main(String[] args)
{
TcpListener server = new TcpListener(int.Parse(args[0]));
server.Start();
TcpClient client = server.AcceptTcpClient();
NetworkStream stream = client.GetStream();
StreamReader reader = new StreamReader(stream);
String s = reader.ReadLine();
String[] strings = s.Split();
StreamWriter writer;
if (strings[0] != "GET") {
writer = new StreamWriter(stream);
writer.WriteLine
("HTTP/1.0 501 Not Implemented");
writer.WriteLine();
} else {
String filename = strings[1];
while(reader.ReadLine() != "");
writer = new StreamWriter(stream);
writer.WriteLine("HTTP/1.0 200 OK");
writer.WriteLine("Content-type: text/plain");
writer.WriteLine();
StreamReader file = new StreamReader(filename);
String z = file.ReadToEnd();
writer.WriteLine(z);
writer.Flush();
writer.Close();
file.Close();
}
client.Close();
stream.Close();
reader.Close();
writer.Close();
server.Stop();
}
public static void Main(String[] args)
{
TcpListener server=null;
try {
//Echo servers listen on port 7
int portNumber = 7;
//Echo server first binds to port 7
server = new TcpListener(portNumber);
//Server starts listening
server.Start();
//Echo server loops forever, listening for clients
for(;;) {
//Accept the pending client connection and return a client
//initialized for communication
//This method will block until a connection is made
EchoServer es = new EchoServer(server.AcceptTcpClient());
//Allow this conversation to run in a new thread
Thread serverThread = new Thread(
new ThreadStart(es.Conversation));
serverThread.Start();
//Loop back up and wait for another client
//Another thread is servicing this client
}
} catch (Exception e) {
Console.WriteLine(e+" "+e.StackTrace);
} finally {
//Release the port and stop the server
server.Stop();
}
}
public static void Run()
{
var listener = new TcpListener(IPAddress.Loopback, 8181);
listener.Start();
using (var client = listener.AcceptTcpClient())
using (var stream = client.GetStream())
using (var reader = new StreamReader(stream))
using (var writer = new StreamWriter(stream))
{
Console.WriteLine(reader.ReadLine());
Console.WriteLine(reader.ReadLine());
Console.WriteLine(reader.ReadLine());
Console.WriteLine(reader.ReadLine());
Console.WriteLine(reader.ReadLine());
Console.WriteLine(reader.ReadLine());
writer.WriteLine("HTTP/1.1 101 Web Socket Protocol Handshake");
writer.WriteLine("Upgrade: WebSocket");
writer.WriteLine("Connection: Upgrade");
writer.WriteLine("WebSocket-Origin: http://localhost:8080");
writer.WriteLine("WebSocket-Location: ws://localhost:8181/websession");
writer.WriteLine("");
}
listener.Stop();
}
public static void start(int listenPort, System.Action<StreamWriter, string> handleRequest)
{
var server = new TcpListener(IPAddress.Parse("127.0.0.1"), listenPort);
server.Start();
Debug.Log("Start server");
while (Working) {
try {
Thread.Sleep(0);
if (!server.Pending())
continue;
using (var client = server.AcceptTcpClient())
using (var stream = client.GetStream())
using (var reader = new StreamReader(stream, Encoding.UTF8))
using (var writer = new StreamWriter(stream, new UTF8Encoding(false)))
{
Debug.Log("Server Connected");
while (!reader.EndOfStream) {
var line = reader.ReadLine();
handleRequest(writer, line);
}
}
} catch (System.Exception e) {
Debug.Log("RPCServer exception " + e);
}
}
}
private static void ClientConnectionSync(TcpListener server)
{
using (TcpClient client = server.AcceptTcpClient()) {
using (Stream stream = client.GetStream()) {
Byte[] inputData = new Byte[1];
Int32 numBytesRead = stream.Read(inputData, 0, 1);
if (numBytesRead == 0) {
// Client closed connection; abandon this client request
inputData = null;
} else {
// Resize the array to 1 bytes (for length) + the size of the data
Array.Resize(ref inputData, 1 + inputData[0]);
// Read in all the data (after the length byte)
for (Int32 bytesReadSoFar = 0; bytesReadSoFar < inputData.Length - 1; ) {
Int32 bytesReadThisTime = stream.Read(inputData, 1 + bytesReadSoFar,
inputData.Length - (bytesReadSoFar + 1));
if (bytesReadThisTime == 0) {
// Client closed connection; abandon this client request
inputData = null;
break;
}
bytesReadSoFar += bytesReadThisTime;
}
// Process the data and return the result
Byte[] outputData = ProcessData(inputData);
stream.Write(outputData, 0, outputData.Length);
}
}
}
}
public static void Main() {
IPAddress addr = IPAddress.Parse("0.0.0.0");
int port = 8888;
TcpListener listener = new TcpListener(addr, port);
listener.Start();
for (;;) {
TcpClient connection = listener.AcceptTcpClient();
ThreadPool.QueueUserWorkItem((_) => {
NetworkStream stream = connection.GetStream();
byte[] data = new byte[256];
int len;
while ((len = stream.Read(data, 0, data.Length)) != 0) {
stream.Write(data, 0, len);
}
stream.Close();
connection.Close();
});
}
}
static void Main(string[] args)
{
if (args.Length != 1) // Test for correct # of args
throw new ArgumentException("Parameters: <Port>");
int port = Int32.Parse(args[0]);
// Create a TCPListener to accept client connections
TcpListener listener = new TcpListener(IPAddress.Any, port);
listener.Start();
TcpClient client = listener.AcceptTcpClient(); // Get client connection
// Receive text-encoded quote
ItemQuoteDecoder decoder = new ItemQuoteDecoderText();
ItemQuote quote = decoder.decode(client.GetStream());
Console.WriteLine("Received Text-Encoded Quote:");
Console.WriteLine(quote);
// Repeat quote with binary-encoding, adding 10 cents to the price
ItemQuoteEncoder encoder = new ItemQuoteEncoderBin();
quote.unitPrice += 10; // Add 10 cents to unit price
Console.WriteLine("Sending (binary)...");
byte[] bytesToSend = encoder.encode(quote);
client.GetStream().Write(bytesToSend, 0 , bytesToSend.Length);
client.Close();
listener.Stop();
}
public async void Listen()
{
try
{
_tcpListener?.Start();
while (true)
{
var tcpClient = _tcpListener?.AcceptTcpClient();
var interaction = new ClientProtocol(tcpClient);
interaction.ExcecuteCommand = ReadCommand;
await interaction.StartAsync();
}
}
catch (Exception ex)
{
_logger.LogError($"{ex}");
}
finally
{
_tcpListener?.Stop();
}
}
public static void Main(String[] args)
{
TcpListener server = new TcpListener(int.Parse(args[0]));
server.Start();
while(true) {
TcpClient client = server.AcceptTcpClient();
new ClientThread(client);
}
}
public void TcpServerRun(){
tcpListener = new TcpListener (IPAddress.Any, 30000);
tcpListener.Start ();
while(true){
TcpClient client = tcpListener.AcceptTcpClient();
Thread tcpHandlerThread = new Thread(new ParameterizedThreadStart(tcpHandler));
tcpHandlerThread.Start(client);
}
}
public static void Main(String[] args)
{
StreamReader sr=null;
StreamWriter sw=null;
TcpClient client=null;
TcpListener server=null;
try {
//Echo servers listen on port 7
int portNumber = 7;
//Echo server first binds to port 7
server = new TcpListener(portNumber);
//Server starts listening
server.Start();
//Echo server loops forever, listening for clients
for(;;) {
Console.WriteLine("Waiting for a connection....");
//Accept the pending client connection and return a client
//initialized for communication
//This method will block until a connection is made
client = server.AcceptTcpClient();
Console.WriteLine("Connection accepted.");
//Make a user-friendly StreamReader from the stream
sr=new StreamReader(client.GetStream());
//Make a user-friendly StreamWriter from the stream
sw=new StreamWriter(client.GetStream());
String incoming=sr.ReadLine();
while (incoming!=".") {
Console.WriteLine("Message received: "+incoming);
sw.WriteLine(incoming);
sw.Flush();
Console.WriteLine("Message Sent back: " + incoming);
incoming=sr.ReadLine();
}
Console.WriteLine("Client sent '.': closing connection.");
sr.Close();
sw.Close();
client.Close();
}
} catch (Exception e) {
Console.WriteLine(e+" "+e.StackTrace);
} finally {
if (sr!=null) sr.Close();//check if the stream reader is present - if it is, close it
if (sw!=null) sw.Close();//check if the stream writer is present - if it is, close it
if (client!=null) client.Close();
//Release the port and stop the server
server.Stop();
}
}
public static void Main()
{
TcpListener server=null;
try
{
IPHostEntry iph = Dns.GetHostEntry(Dns.GetHostName());
server = new TcpListener(iph.AddressList[1], 13000);
server.Start();
Console.WriteLine("Server Started at {0}",iph.AddressList[1]);
while (true)
{
TcpClient Client = server.AcceptTcpClient();
client cl = new client();
IPEndPoint IPend = (IPEndPoint)Client.Client.RemoteEndPoint;
cl.ip = IPend.Address.ToString();
StreamReader sr = new StreamReader(Client.GetStream());
char[] data = new char[20];
sr.Read(data, 0, data.Length);
cl.name = new string(data);
cl.name=cl.name.Substring(0,cl.name.IndexOf('\0'));
Console.WriteLine(cl.name+" "+cl.ip);
StreamWriter sw = new StreamWriter(Client.GetStream());
sw.AutoFlush = true;
StringBuilder names = new StringBuilder();
StringBuilder ips = new StringBuilder();
foreach (client c in clients)
{
names.Append(c.name + "*");
ips.Append(c.ip + "*");
}
string write = names + "&" + ips;
if (clients.Count == 0)
write = "No One Available*&";
sw.Write(write.ToCharArray());
clients.Add(cl);
}
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
Console.Read();
}
finally
{
server.Stop();
}
}
public static void Main()
{
TcpListener server = null;
try
{
Int32 port = 777;
IPAddress localAddr = IPAddress.Parse("127.0.0.1");
server = new TcpListener(localAddr, port);
server.Start();
Byte[] bytes = new Byte[256];
String data = null;
bool running = true;
while (running)
{
Console.Write("Waiting for a connection... ");
TcpClient client = server.AcceptTcpClient();
Console.WriteLine("Connected!");
data = null;
NetworkStream stream = client.GetStream();
int i;
while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
Console.WriteLine("Received: {0}", data);
data = data.ToUpper();
byte[] msg = System.Text.Encoding.ASCII.GetBytes(data);
stream.Write(msg, 0, msg.Length);
Console.WriteLine("Sent: {0}", data);
}
client.Close();
if (data == "EXIT") running = false;
}
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
finally
{
server.Stop();
}
}
public static void StartListening()
{
ClientService ClientTask ;
// Client Connections Pool
ClientConnectionPool ConnectionPool = new ClientConnectionPool() ;
// Client Task to handle client requests
ClientTask = new ClientService(ConnectionPool) ;
ClientTask.Start() ;
TcpListener listener = new TcpListener(portNum);
try
{
listener.Start();
int TestingCycle = 3 ; // Number of testing cycles
int ClientNbr = 0 ;
// Start listening for connections.
Console.WriteLine("Waiting for a connection...");
while ( TestingCycle > 0 )
{
TcpClient handler = listener.AcceptTcpClient();
if ( handler != null)
{
Console.WriteLine("Client#{0} accepted!", ++ClientNbr) ;
// An incoming connection needs to be processed.
ConnectionPool.Enqueue( new ClientHandler(handler) ) ;
//--TestingCycle ;
}
else
break;
}
listener.Stop();
// Stop client requests handling
ClientTask.Stop() ;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
Console.WriteLine("\nHit enter to continue...");
Console.Read();
}
public static void Main(String[] args)
{
TcpListener server=null;
try {
//Daytime servers listen on standard port 13
int portNumber = 13;
//Daytime server first binds to port 13
//The server will be of type TcpListener;
//an object which accepts TCP connections
server = new TcpListener(portNumber);
//Server starts listening on specified port
server.Start();
//Daytime server loops forever, listening for clients
for(;;) {
Console.WriteLine("Waiting for a connection....");
//Accept the pending client connection and return a client
//initialized for communication.
//This method will BLOCK until a connection is made
TcpClient client = server.AcceptTcpClient();
Console.WriteLine("Connection accepted.");
//Prepare response - note there is no particular 'format' in the daytime protocol!
//The DateTime class gets the current time
String responseString = DateTime.Now.ToString();
//Make a user-friendly StreamWriter from the stream
//client.GetStream() is how we get the data stream to the client
//Note that 'streams' only make sense in the context of protocols like TCP
//There would be no such thing as a UDP stream, for example
StreamWriter sw=new StreamWriter(client.GetStream());
//Send the message
sw.WriteLine(responseString);
Console.WriteLine("Message Sent: " + responseString);
//Close the StreamWriter, then the stream & connection
//and in that order...
sw.Close();
client.Close();
}
} catch (Exception e) {
//A catch-all exception handler
//Just display the entire stack trace
Console.WriteLine(e+" "+e.StackTrace);
} finally {
//Release the port and stop the server
//finally is ALWAYS the last thing to run in a try...catch
server.Stop();
}
}
public static void Run()
{
TcpListener server = new TcpListener(IPAddress.Loopback, 8181);
server.Start();
using (TcpClient client = server.AcceptTcpClient())
using (NetworkStream clientStream = client.GetStream())
using (StreamReader sr = new StreamReader(clientStream))
using (StreamWriter sw = new StreamWriter(clientStream))
{
Console.WriteLine(sr.ReadLine());
Console.WriteLine(sr.ReadLine());
Console.WriteLine(sr.ReadLine());
Console.WriteLine(sr.ReadLine());
Console.WriteLine(sr.ReadLine());
Console.WriteLine(sr.ReadLine());
sw.WriteLine("HTTP/1.1 101 Web Socket Protocol Handshake");
sw.WriteLine("Upgrade: WebSocket");
sw.WriteLine("Connection: Upgrade");
sw.WriteLine("WebSocket-Origin: http://localhost:8080");
sw.WriteLine("WebSocket-Location: ws://localhost:8181/websession");
sw.WriteLine("");
sw.Flush();
// Accept send
while (true)
{
// read type byte
byte type = (byte)clientStream.ReadByte();
if (type != 0x00) { Console.Error.WriteLine("Erro no protocolo: The type byte was not 0x00"); break; }
byte[] sendData = new byte[1024];
byte sendDataByte; int sendDataIdx = 0;
while ((sendDataByte = (byte)clientStream.ReadByte()) != 0xFF)
{
sendData[sendDataIdx++] = sendDataByte;
}
String text = System.Text.ASCIIEncoding.Default.GetString(sendData, 0, sendDataIdx);
Console.WriteLine("LINE: " + text);
// Write down message ECHO
clientStream.WriteByte(0x00);
sw.Write(text.ToUpper());
sw.Flush();
clientStream.WriteByte(0xFF);
}
}
server.Stop();
}
private void btnServidor_Click(object sender, EventArgs e)
{
TcpListener newSock = new TcpListener(IPAddress.Any, 2000);
newSock.Start();
Console.WriteLine("Esperando por cliente");
while (true)
{
TcpClient cliente = newSock.AcceptTcpClient();
Thread t = new Thread(() => this.handleClient(cliente));
t.IsBackground = true;
t.Start();
}
}
static void Main()
{
Console.WriteLine(".NET Core Micro-Server");
var address = new IPAddress(new byte[] {127, 0, 0, 1});
var listener = new TcpListener(address, 8080);
listener.Start();
while (receiveRequests)
{
TcpClient client = listener.AcceptTcpClient();
Task.Run(() => { ProcessRequest(client); });
}
listener.Stop();
}
public static void Main()
{
TcpListener server = new TcpListener(IPAddress.Any, 8888);
server.Start();
Console.WriteLine(":: EchoServer running ::");
for (;;) {
TcpClient session = server.AcceptTcpClient();
int sessionId = ++SessionCount;
Attend(sessionId, session);
}
}
static void Main ()
{
TcpListener listener = new TcpListener (IPAddress.Loopback, 8001);
listener.Start ();
TcpClient client = listener.AcceptTcpClient ();
NetworkStream s = client.GetStream ();
byte [] buff = new byte [1024];
do {
s.Read (buff, 0, buff.Length);
} while (s.DataAvailable);
string payload = @"<?xml version=""1.0"" encoding=""UTF-8""?>
<soapenv:Envelope xmlns:soapenc=""http://schemas.xmlsoap.org/soap/encoding/"" xmlns:soapenv=""http://schemas.xmlsoap.org/soap/envelope/"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
<soapenv:Body>
<RetrievePropertiesResponseResponse xmlns=""urn:internalvim25"">
<RetrievePropertiesResponseResult>
<RetrievePropertiesResponse xmlns='urn:internalvim25'>
<returnval xmlns=""urn:internalvim25"">
<obj type=""Folder"">group-d1</obj>
<propSet>
<name>childEntity</name>
<val xsi:type=""ArrayOfManagedObjectReference"">
<ManagedObjectReference type=""Folder"" xsi:type=""ManagedObjectReference"">group-d33</ManagedObjectReference>
<ManagedObjectReference type=""Folder"" xsi:type=""ManagedObjectReference"">group-d36</ManagedObjectReference>
<ManagedObjectReference type=""Folder"" xsi:type=""ManagedObjectReference"">group-d2</ManagedObjectReference>
<ManagedObjectReference type=""Datacenter"" xsi:type=""ManagedObjectReference"">datacenter-3</ManagedObjectReference>
</val>
</propSet>
</returnval>
</RetrievePropertiesResponse>
</RetrievePropertiesResponseResult>
</RetrievePropertiesResponseResponse>
</soapenv:Body>
</soapenv:Envelope>";
string response = string.Format (CultureInfo.InvariantCulture,
"HTTP/1.1 200 OK{0}" +
"Date: Wed, 21 May 2008 22:17:55 GMT{0}" +
"Cache-Control: no-cache{0}" +
"Content-Type: text/xml; charset=utf-8{0}" +
"Content-Length: {1}{0}" +
"{0}" +
"{2}", "\r\n", payload.Length, payload);
Byte [] bytes = Encoding.ASCII.GetBytes (response);
s.Write (bytes, 0, bytes.Length);
s.Flush ();
}
/// <summary>
/// 等待客戶端的連線
/// </summary>
public void ListenToConnection()
{
//取得本機名稱
string hostName = Dns.GetHostName();
Debug.Log("伺服器名稱=" + hostName);
//取得本機IP
IPAddress[] ipa = Dns.GetHostAddresses(hostName);
for (int i = 0; i < ipa.Length; i++)
{
Debug.Log("伺服器IP[" + i + "]=" + ipa[i].ToString());
}
//建立本機端的IPEndPoint物件
IPEndPoint ipe = new IPEndPoint(ipa[0], 1234);
//建立TcpListener物件
TcpListener tcpListener = new TcpListener(ipe);
//開始監聽port
tcpListener.Start();
Debug.Log("伺服器等待客戶端連線中...");
TcpClient tmpTcpClient;
int numberOfClients = 0;
while (true)
{
try
{
//建立與客戶端的連線
tmpTcpClient = tcpListener.AcceptTcpClient();
if (tmpTcpClient.Connected)
{
Debug.Log("伺服器與客戶端連線成功!");
HandleClient handleClient = new HandleClient(tmpTcpClient);
Thread myThread = new Thread(new ThreadStart(handleClient.Communicate));
numberOfClients += 1;
myThread.IsBackground = true;
myThread.Start();
myThread.Name = tmpTcpClient.Client.RemoteEndPoint.ToString();
}
}
catch (Exception ex)
{
Debug.Log(ex.Message);
}
} // end while
}
private void Connect()
{
lock (this)
{
if (this.clientsocket == null || !this.clientsocket.Connected)
{
TcpListener serverSocket = new TcpListener(IPAddress.Parse("0.0.0.0"), 9001);
TcpClient clientSocket = default(TcpClient);
serverSocket.Start();
clientSocket = serverSocket.AcceptTcpClient();
serverSocket.Stop();
this.clientsocket = clientSocket.Client;
}
}
}
static void SyncMain(string[] args)
{
var anyErrors = false;
var socket = new TcpListener(IPAddress.Loopback, 10003);
var requestCount = 0;
socket.Start();
var t = new Thread(new ThreadStart(() =>
{
while (true)
{
var client = socket.AcceptTcpClient();
requestCount = requestCount + 1;
if (requestCount % 100 == 0)
{
System.Console.WriteLine("{0} accepted...", requestCount);
}
var t1 = new Thread(new ThreadStart(() =>
{
try
{
using (var _holder = client)
{
ServiceClient(client);
}
}
catch (Exception e)
{
if (!anyErrors)
{
anyErrors = true;
System.Console.WriteLine("server ERROR");
}
throw;
}
}));
t1.IsBackground = true;
t1.Start();
}
}));
t.IsBackground = true;
t.Start();
while (true)
{
Thread.Sleep(1000);
var count = Interlocked.Exchange(ref numWritten, 0);
System.Console.WriteLine("QUOTES PER SECOND: {0}", count);
}
}
public static void startServer(int port)
{
try {
TcpListener listener = new TcpListener(IPAddress.Any, port);
listener.Start();
while(true) {
TcpClient client = listener.AcceptTcpClient();
ClientRequest cr = new ClientRequest(client);
ThreadPool.QueueUserWorkItem(cr.GetClientInput);
}
} catch(SocketException e) {
Console.WriteLine("SocketException: {0}", e);
}
}
static void Main()
{
Win32API.HandlerRoutine ctrl_c_handler = new Win32API.HandlerRoutine(CtrlCHandler);
Win32API.SetConsoleCtrlHandler(ctrl_c_handler, true);
//
// Create a listen socket bound to the server port.
//
server = new TcpListener(IPAddress.Parse("127.0.0.1"), SERVER_PORT); // socket() + bind()
//
// Start listening for client requests.
//
server.Start(); //listen()
//
// Enter the listening loop.
//
do {
Console.Write("---Waiting for a new connection... ");
try {
TcpClient conn = server.AcceptTcpClient();
Console.WriteLine();
//Console.WriteLine("\n---connected, process request!");
ProcessConnection(conn);
/*
new Thread(delegate(object _conn) {
ProcessConnection((TcpClient)_conn);
}).Start(conn);
*/
/*
ThreadPool.QueueUserWorkItem(delegate (object _conn) {
ProcessConnection((TcpClient)_conn);
}, conn);
*/
} catch (Exception) {
break;
}
} while (true);
GC.KeepAlive(ctrl_c_handler);
}
// Connects to the windows form and loops to wait for actions from the user
void GetDataFromClient()
{
try {
int port = 1234;
serverListener = new TcpListener(port);
serverListener.Start();
print("Server started..");
data = "";
byte[] bytesFromClient = new byte[1024];
print(dataPath);
// calling to open application (client)
System.Diagnostics.Process.Start(dataPath + "/TheraMem.exe");
client = serverListener.AcceptTcpClient();
clientConnected = true;
print("Client Connected!");
while (clientConnected) {
NetworkStream clientStream = client.GetStream();
Int32 i;
while ((i = clientStream.Read(bytesFromClient, 0, bytesFromClient.Length)) != 0) {
data = Encoding.ASCII.GetString(bytesFromClient, 0, i);
}
if (data == "1$shutdown") {
clientConnected = false;
client.Close();
serverListener.Stop();
}
}
} catch (ThreadAbortException e) {
print(e.Message);
}
finally {
client.Close();
serverListener.Stop();
}
}
public void Run ()
{
listener = new TcpListener (IPAddress.Loopback, 9999);
listener.Start ();
try {
TcpClient client = listener.AcceptTcpClient ();
NetworkStream stream = client.GetStream ();
stream.WriteByte (0x00);
stream.WriteByte (0x00);
client.Close ();
} finally {
listener.Stop ();
}
}
private IEnumerator listen(IPAddress listen_ip, int port)
{
TcpListener listener = new TcpListener( listen_ip, port );
listener.Start();
while(gameObject.activeSelf){
if(listener.Pending()){
TcpClient s = listener.AcceptTcpClient();
//Debug.Log("got a client! create a HttpProcessor for him and start the process coroutine");
HttpProcessor processor = new HttpProcessor(s, this);
StartCoroutine(processor.process());
}
yield return wait;
//yield return new WaitForSeconds(ListenDelay);
}
}
public BaseServer(IPAddress address, int port)
{
if (IsInitialized)
{
return;
}
Listener = new TcpListener(address, port);
Listener.Start();
ListenThread = new Thread(() =>
{
while (IsInitialized)
{
HandleNewClient(Listener?.AcceptTcpClient());
}
});
ListenThread.Start();
}
public void StartListening()
{
try
{
while (listener != null)
{
var client = listener?.AcceptTcpClient();
if (listener == null)
{
return;
}
if (Log.IsDebugEnabled)
{
Log.Debug("Waiting for connection");
}
var id = Interlocked.Increment(ref connections);
var remoteEndPoint = (IPEndPoint)client.Client.RemoteEndPoint;
var remoteIp = remoteEndPoint.Address + ":" + remoteEndPoint.Port;
if (Log.IsDebugEnabled)
{
Log.Debug($"#{id} client connected from {remoteIp}!");
}
var thread = new Thread(() => HandleConnection(client, id, remoteIp))
{
IsBackground = true
};
thread.Start();
}
}
catch (Exception ex)
{
Log.Error($"{nameof(LispReplTcpServer)} TcpListener error: {ex.Message}", ex);
}
finally
{
Stop();
}
}
startListening()
{
Action action = () =>
{
try
{
listener?.Start();
while (listener != null)
{
TcpClient client = null;
try
{
client = listener?.AcceptTcpClient();
}
catch (Exception)
{
break;
}
NetServerClient netClient = new NetServerClient(client,
onClientDataReceived,
onClientDisconnected);
clients.Add(netClient);
}
}
finally
{
stop();
}
};
Thread thread = new Thread(() => action.Invoke());
thread.Start();
}
public override void Bad()
{
float data;
if (IO.STATIC_READONLY_TRUE)
{
data = -1.0f; /* 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);
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
{
listener.Stop();
}
catch (SocketException se)
{
IO.Logger.Log(NLog.LogLevel.Warn, se, "Problem 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.0f;
}
if (IO.STATIC_READONLY_TRUE)
{
/* POTENTIAL FLAW: Possibly modulo by zero */
int result = (int)(100.0 % data);
IO.WriteLine(result);
}
}
// the listener thread's listen function
// note: no maxConnections parameter. high level API should handle that.
// (Transport can't send a 'too full' message anyway)
void Listen(int port)
{
// absolutely must wrap with try/catch, otherwise thread
// exceptions are silent
try
{
// start listener on all IPv4 and IPv6 address via .Create
listener = TcpListener.Create(port);
listener.Server.NoDelay = NoDelay;
listener.Server.SendTimeout = SendTimeout;
listener.Start();
Logger.Log("Server: listening port=" + port);
// keep accepting new clients
while (true)
{
// wait and accept new client
// note: 'using' sucks here because it will try to
// dispose after thread was started but we still need it
// in the thread
TcpClient client = listener.AcceptTcpClient();
// set socket options
client.NoDelay = NoDelay;
client.SendTimeout = SendTimeout;
// generate the next connection id (thread safely)
int connectionId = NextConnectionId();
// add to dict immediately
ClientToken token = new ClientToken(client);
clients[connectionId] = token;
// spawn a send thread for each client
Thread sendThread = new Thread(() =>
{
// wrap in try-catch, otherwise Thread exceptions
// are silent
try
{
// run the send loop
SendLoop(connectionId, client, token.sendQueue, token.sendPending);
}
catch (ThreadAbortException)
{
// happens on stop. don't log anything.
// (we catch it in SendLoop too, but it still gets
// through to here when aborting. don't show an
// error.)
}
catch (Exception exception)
{
Logger.LogError("Server send thread exception: " + exception);
}
});
sendThread.IsBackground = true;
sendThread.Start();
// spawn a receive thread for each client
Thread receiveThread = new Thread(() =>
{
// wrap in try-catch, otherwise Thread exceptions
// are silent
try
{
// run the receive loop
ReceiveLoop(connectionId, client, receiveQueue, MaxMessageSize);
// remove client from clients dict afterwards
clients.TryRemove(connectionId, out ClientToken _);
// sendthread might be waiting on ManualResetEvent,
// so let's make sure to end it if the connection
// closed.
// otherwise the send thread would only end if it's
// actually sending data while the connection is
// closed.
// => AbortAndJoin is the safest way and avoids race conditions!
sendThread.AbortAndJoin();
}
catch (Exception exception)
{
Logger.LogError("Server client thread exception: " + exception);
}
});
receiveThread.IsBackground = true;
receiveThread.Start();
}
}
catch (ThreadAbortException exception)
{
// UnityEditor causes AbortException if thread is still
// running when we press Play again next time. that's okay.
Logger.Log("Server thread aborted. That's okay. " + exception);
}
catch (SocketException exception)
{
// calling StopServer will interrupt this thread with a
// 'SocketException: interrupted'. that's okay.
Logger.Log("Server Thread stopped. That's okay. " + exception);
}
catch (Exception exception)
{
// something went wrong. probably important.
Logger.LogError("Server Exception: " + exception);
}
}
public void StartUpServer()
{
TcpListener server = new TcpListener(IPAddress.Parse("127.0.0.1"), 8080);
server.Start();
Dispatcher.Invoke(() => {
Output.Text = String.Format("Server has started on 127.0.0.1:8080.{0}Waiting for a connection...", Environment.NewLine);
});
TcpClient client = null;
while (true)
{
client = server.AcceptTcpClient();
clients.Add(client);
Dispatcher.Invoke(() => {
Output.Text = ("A client connected.");
ReadyButton.IsEnabled = true;
});
stream = client.GetStream();
//enter to an infinite cycle to be able to handle every change in stream
while (!stream.DataAvailable)
{
;
}
Byte[] bytes = new Byte[client.Available];
stream.Read(bytes, 0, bytes.Length);
//translate bytes of request to string
String data = Encoding.UTF8.GetString(bytes);
//if (Regex.IsMatch(data, "^GET"))
//{
//}
if (new Regex("^GET").IsMatch(data))
{
//Console.WriteLine("New connection established");
Byte[] response = Encoding.UTF8.GetBytes("HTTP/1.1 101 Switching Protocols" + Environment.NewLine
+ "Connection: Upgrade" + Environment.NewLine
+ "Upgrade: websocket" + Environment.NewLine
+ "Sec-WebSocket-Accept: " + Convert.ToBase64String(
SHA1.Create().ComputeHash(
Encoding.UTF8.GetBytes(
new Regex("Sec-WebSocket-Key: (.*)").Match(data).Groups[1].Value.Trim() + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
)
)
) + Environment.NewLine
+ Environment.NewLine);
stream.Write(response, 0, response.Length); //Avsluta handskakningen
Task task = new Task(() => { FromClient(client); });
task.Start();
}
else
{
}
}
}
public override void Bad()
{
string data;
if (PrivateReturnsTrue())
{
data = ""; /* Initialize data */
/* Read data using a listening tcp connection */
{
TcpListener listener = null;
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 */
data = sr.ReadLine();
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
finally
{
if (listener != null)
{
try
{
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 = null;
}
if (PrivateReturnsTrue())
{
using (SecureString secureData = new SecureString())
{
for (int i = 0; i < data.Length; i++)
{
secureData.AppendChar(data[i]);
}
/* POTENTIAL FLAW: Store data directly in a file */
File.WriteAllText(@"C:\Users\Public\WriteText.txt", secureData.ToString());
}
}
}
/* uses badsource and badsink */
public override void Bad(HttpRequest req, HttpResponse resp)
{
string data;
if (PRIVATE_CONST_TRUE)
{
data = ""; /* Initialize data */
/* Read data using a listening tcp connection */
{
TcpListener listener = null;
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 */
data = sr.ReadLine();
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
finally
{
if (listener != null)
{
try
{
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 = null;
}
if (data != null)
{
/* This prevents \r\n (and other chars) and should prevent incidentals such
* as HTTP Response Splitting and HTTP Header Injection.
*/
Uri uri;
try
{
uri = new Uri(data);
}
catch (UriFormatException exceptURISyntax)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptURISyntax, "Invalid redirect URL");
resp.Write("Invalid redirect URL");
return;
}
/* POTENTIAL FLAW: redirect is sent verbatim; escape the string to prevent ancillary issues like XSS, Response splitting etc */
resp.Redirect(data);
return;
}
}
public void iniciaColeta(String ip)
{
string mac = "5C:F3:FC:FD:E1:F5";
textBoxMac.Text = mac;
string ipToshiba = ip;
int porta = 120;
IPAddress local = IPAddress.Parse(ip);
////FLAG - READ
vetorRequisicao[0] = 0x30;
vetorRequisicao[1] = 0x32;
//CMD - MOLDING CONDITION REQUEST
vetorRequisicao[2] = 0x30;
vetorRequisicao[3] = 0x30;
vetorRequisicao[4] = 0x30;
vetorRequisicao[5] = 0x31;
////LEN - 4 BYTES
vetorRequisicao[6] = 0x30;
vetorRequisicao[7] = 0x30;
vetorRequisicao[8] = 0x30;
vetorRequisicao[9] = 0x30;
vetorRequisicao[10] = 0x30;
vetorRequisicao[11] = 0x30;
vetorRequisicao[12] = 0x30;
vetorRequisicao[13] = 0x34;
////DATA
vetorRequisicao[14] = 0x0;
vetorRequisicao[15] = 0x0;
int data = Int32.Parse(textBoxMac.Text);
byte number = Convert.ToByte(data);
vetorRequisicao[16] = 0x0;
vetorRequisicao[17] = 0x97;
serverTcp = new TcpListener(local, porta);
serverTcp.Start();
try
{
bool isConectado = true;
while (isConectado)
{
try
{
//tc.Connect(ipToshiba, 139);
//isConectado = false;
Console.WriteLine("Esperando por conexão");
TcpClient client = serverTcp.AcceptTcpClient();
Console.WriteLine("Conectado");
Thread t = new Thread(new ParameterizedThreadStart(HandleClient));
t.Start(client);
}
catch (Exception exc)
{
Console.WriteLine(exc.ToString());
serverTcp.Stop();
}
}
Console.WriteLine("Abri a conexão. IP: " + ipToshiba);
Console.WriteLine("Request:");
Console.WriteLine(vetorRequisicao[0]);
Console.WriteLine(vetorRequisicao[1]);
Console.WriteLine(vetorRequisicao[2]);
Console.WriteLine(vetorRequisicao[3]);
Console.WriteLine(vetorRequisicao[4]);
Console.WriteLine(vetorRequisicao[5]);
Console.WriteLine(vetorRequisicao[6]);
Console.WriteLine(vetorRequisicao[7]);
Console.WriteLine(vetorRequisicao[8]);
Console.WriteLine(vetorRequisicao[9]);
Console.WriteLine(vetorRequisicao[10]);
Console.WriteLine(vetorRequisicao[11]);
Console.WriteLine(vetorRequisicao[12]);
Console.WriteLine(vetorRequisicao[13]);
Console.WriteLine(vetorRequisicao[14]);
Console.WriteLine(vetorRequisicao[15]);
Console.WriteLine(vetorRequisicao[16]);
Console.WriteLine(vetorRequisicao[17]);
Console.WriteLine("Data read:");
ns = tc.GetStream();
if (ns.CanWrite)
{
ns.Write(vetorRequisicao, 0, 30);
}
int count = 0;
while (count < 50)
{
count++;
if (ns.DataAvailable)
{
Console.WriteLine(ns.ReadByte());
}
}
ns.Close();
tc.Close();
}
catch (Exception exc)
{
Console.WriteLine(exc.ToString());
}
}
/* goodB2G1() - use badsource and goodsink by changing second IO.STATIC_READONLY_FIVE==5 to IO.STATIC_READONLY_FIVE!=5 */
private void GoodB2G1()
{
float data;
if (IO.STATIC_READONLY_FIVE == 5)
{
data = -1.0f; /* 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);
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
{
listener.Stop();
}
catch (SocketException se)
{
IO.Logger.Log(NLog.LogLevel.Warn, se, "Problem 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.0f;
}
if (IO.STATIC_READONLY_FIVE != 5)
{
/* INCIDENTAL: CWE 561 Dead Code, the code below will never run */
IO.WriteLine("Benign, fixed string");
}
else
{
/* FIX: Check for value of or near zero before dividing */
if (Math.Abs(data) > 0.000001)
{
int result = (int)(100.0 / data);
IO.WriteLine(result);
}
else
{
IO.WriteLine("This would result in a divide by zero");
}
}
}
IEnumerator StartServer()
{
_server = new TcpListener(IPAddress.Any, 7777);
_server.Start();
bool connected = false;
Thread connectThread = new Thread(() =>
{
_connectedClient = _server.AcceptTcpClient();
_networkStream = _connectedClient.GetStream();
connected = true;
});
connectThread.Start();
while (connected == false)
{
yield return(null);
}
Debug.Log("connected!");
_networkListening = true;
ReadClientMessagesAsync();
NetworkMessage message = new NetworkMessage();
message.type = NetworkMessage.Type.Chat;
message.chat.message = "hello!";
SendNetworkMessage(message);
message.type = NetworkMessage.Type.InitializeClient;
message.initializeClient.playerID = 2;
_playerID = 1;
SendNetworkMessage(message);
message.type = NetworkMessage.Type.DiskSpawn;
for (int i = 0; i < _diskJsons.Length; i++)
{
int player = (i % 2) + 1;
DiskJson disk = _diskJsons[i];
SpawnDisk(disk.name, player);
message.diskSpawn.player = player;
message.diskSpawn.diskName = disk.name;
SendNetworkMessage(message);
}
_currentPlayer = 1;
_currentPlayerDisplay.text = _currentPlayer == _playerID
? "It's your turn!"
: $"Player {_currentPlayer}'s turn";
if (_currentPlayer == _playerID)
{
_diskGhost.SetActive(true);
}
message.type = NetworkMessage.Type.PlayerTurnUpdateMessage;
message.playerTurnUpdate.currentPlayer = _currentPlayer;
SendNetworkMessage(message);
_endTurnButton.onClick.AddListener(EndTurnServer);
}
public void TcpServerStart(string serverIp, int portNo)
{
TcpListener server = null;
try
{
// Set the TcpListener on port 13000.
Int32 port = 13000;
IPAddress localAddr = IPAddress.Parse("127.0.0.1");
// TcpListener server = new TcpListener(port);
server = new TcpListener(localAddr, port);
// Start listening for client requests.
server.Start();
// Buffer for reading data
Byte[] bytes = new Byte[512];
String data = null;
// Enter the listening loop.
while (true)
{
// Perform a blocking call to accept requests.
// You could also use server.AcceptSocket() here.
System.Net.Sockets.TcpClient client = server.AcceptTcpClient();
data = null;
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
int i;
// Loop to receive all the data sent by the client.
while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
// Translate data bytes to a ASCII string.
data = System.Text.Encoding.UTF8.GetString(bytes, 0, i);
MessageReceived?.Invoke(this, data);
// Process the data sent by the client.
data = data.ToUpper();
byte[] msg = Encoding.UTF8.GetBytes(data);
// Send back a response.
stream.Write(msg, 0, msg.Length);
}
// Shutdown and end connection
client.Close();
}
}
catch (SocketException e)
{
MessageBox.Show($"{e}");
}
finally
{
// Stop listening for new clients.
server.Stop();
}
}
public void Listen(Rabbit mq)
{
// Buffer for reading data
Byte[] bytes = new Byte[256];
int i;
string header_text;
string response;
byte[] hdr;
Rabbit.Response msg = null;
string json = null;
string old_json;
JavaScriptSerializer jsSerializer = new JavaScriptSerializer();
Dictionary <string, Func <string, Dictionary <string, string>, Dictionary <string, string>, Rabbit.Response> > functions = new Dictionary <string, Func <string, Dictionary <string, string>, Dictionary <string, string>, Rabbit.Response> >();
functions["POST_entities"] = mq.Post_Entity;
functions["PUT_entities"] = mq.Put_Entity;
functions["GET_entities"] = mq.Get_Entity;
functions["DELETE_entities"] = mq.Delete_Entity;
functions["POST_webhooks"] = mq.Post_Webhook;
functions["PUT_webhooks"] = mq.Put_Webhook;
functions["GET_webhooks"] = mq.Get_Webhook;
functions["DELETE_webhooks"] = mq.Delete_Webhook;
functions["POST_subscriptions"] = mq.Post_Subscription;
functions["PUT_subscriptions"] = mq.Put_Subscription;
functions["GET_subscriptions"] = mq.Get_Subscription;
functions["DELETE_subscriptions"] = mq.Delete_Subscription;
functions["POST_events"] = mq.Post_Event;
functions["PUT_events"] = mq.Put_Event;
functions["GET_events"] = mq.Get_Event;
functions["DELETE_events"] = mq.Delete_Event;
// Enter the listening loop.
while (true)
{
Console.Write("Waiting for Connection...");
// Perform a blocking call to accept requests.
// You could also user server.AcceptSocket() here.
TcpClient client = _server.AcceptTcpClient();
Console.WriteLine("Connected! " + DateTime.Now.ToString());
json = null;
old_json = "";
StringBuilder data = new StringBuilder("");
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
// Loop to receive all the data sent by the client.
do
{
try
{
i = stream.Read(bytes, 0, bytes.Length);
// Translate data bytes to a ASCII string.
data.Append(System.Text.Encoding.ASCII.GetString(bytes, 0, i));
}
catch (Exception x)
{
Console.WriteLine("PROBLEM WITH READ");
i = 0;
}
} while (i == 256);
if (i == 0)
{
Console.WriteLine("PINGED");
client.Close();
continue;
}
//Console.WriteLine("DATA=" + data.ToString());
try
{
int payload_start = data.ToString().IndexOf("\r\n\r\n");
//Console.WriteLine("PAYLOAD START AT:" + payload_start.ToString());
if (payload_start == -1)
{
header_text = data.ToString();
}
else
{
header_text = data.ToString().Substring(0, payload_start);
}
string[] lines = header_text.Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
Dictionary <string, string> headers = new Dictionary <string, string>();
Dictionary <string, string> parameters = new Dictionary <string, string>();
foreach (string s in lines)
{
if (s == null || s == "" || (int)s[0] == 13)
{
break;
}
string str = s.Replace("\r", "").Replace("\n", "");
char[] separator1 = new char[] { ':' };
char[] separator2 = new char[] { '&' };
char[] separator3 = new char[] { '/' };
try
{
string[] header = str.Split(separator1, 2, StringSplitOptions.RemoveEmptyEntries);
switch (header.Length)
{
case 1:
string[] request = str.Split(' ');
headers.Add("Method", request[0]);
headers.Add("Protocol", request[2]);
int query = request[1].IndexOf("?");
if (query != -1)
{
headers.Add("Path", request[1].Substring(0, query));
string p = request[1].Substring(query + 1);
string[] parms = p.Split(separator2, StringSplitOptions.RemoveEmptyEntries);
foreach (string st in parms)
{
string[] parm = st.Split('=');
parameters.Add(parm[0], parm[1]);
}
}
else
{
string[] parms = request[1].Substring(1).Split(separator3, StringSplitOptions.RemoveEmptyEntries);
headers.Add("Path", "/" + parms[0]);
for (int j = 1; j < parms.Length; j++)
{
parameters.Add(j.ToString(), HttpUtility.UrlDecode(parms[j]));
}
}
break;
case 2:
if (header[1][0] == ' ')
{
header[1] = header[1].Substring(1);
}
headers.Add(header[0], header[1]);
break;
default:
break;
}
}
catch (Exception x)
{
}
}
Console.WriteLine("REQUEST:" + headers["Method"] + " " + headers["Path"]);
try
{
JWT jwt = new JWT(headers["X-JWT-Assertion"]);
if (jwt.isValid)
{
headers.Add("Entity", jwt.entity);
headers.Add("Queue", jwt.queue);
}
else
{
throw new Exception("401 Not Authorized");
}
}
catch (Exception x)
{
if (payload_start != 999999)
{
throw new Exception("401 Not Authorized");
}
else
{
// headers.Add("Entity", "PRO");
// headers.Add("Queue", "415212202");
headers.Add("Entity", "Hannig");
headers.Add("Queue", "389206472");
}
}
try
{
if (headers["Transfer-Encoding"].Equals("chunked"))
{
json = "";
int length;
payload_start += 2;
do
{
string size = data.ToString().Substring(payload_start + 2);
size = size.Substring(0, size.IndexOf("\r\n"));
Int32.TryParse(size, NumberStyles.HexNumber, CultureInfo.CurrentCulture, out length);
//Console.WriteLine("CHUNK SIZE=" + length.ToString());
if (length > 0)
{
payload_start += size.Length + 4;
json += data.ToString().Substring(payload_start, length);
payload_start += length;
}
//Console.WriteLine("REMAINING LENGTH:" + length.ToString());
} while (length > 0);
}
}
catch (Exception x)
{
//Console.WriteLine("NOT CHUNKED");
}
if (json == null)
{
if (payload_start > 1)
{
json = data.ToString().Substring(payload_start + 4);
if (json.Length == 0)
{
json = null;
}
else if (json.Length != Int32.Parse(headers["Content-Length"]))
{
throw new Exception("400 Bad Request");
}
}
//Console.WriteLine("PAYLOAD:\r\n" + json);
}
if (json != null)
{
if (json.Length == 0)
{
json = null;
}
else
{
try
{
if (!headers["Content-Type"].Contains("json"))
{
throw new Exception("400 Bad Request");
}
}
catch (Exception x)
{
throw new Exception("400 Bad Request");
}
}
}
old_json = json;
string function = headers["Method"] + headers["Path"].Replace("/", "_");
Console.WriteLine("DEBUG 4.1[" + function + "]");
if (!functions.ContainsKey(function))
{
Console.WriteLine("DEBUG 4.2 Function Not Found");
throw new Exception("404 Not Found");
}
Console.Write("TESTING FUNCTION " + function);
msg = functions[function](json, headers, parameters);
Console.WriteLine(" ....DONE");
string reply;
if (msg.json == null)
{
reply = string.Format("HTTP/1.1 {0}\n\n", msg.code);
}
else
{
reply = string.Format("HTTP/1.1 {0}\nContent-Type: application/json; charset=UTF-8\nContent-Length:{1}\n\n", msg.code, msg.json.Length);
}
Console.WriteLine("RESPONSE-" + reply);
hdr = System.Text.Encoding.ASCII.GetBytes(reply);
stream.Write(hdr, 0, hdr.Length);
if (msg.json != null)
{
stream.Write(System.Text.Encoding.ASCII.GetBytes(msg.json), 0, msg.json.Length);
}
}
catch (Exception x)
{
Console.WriteLine("ERROR:" + x.Message);
Console.WriteLine("JSON=\r\n" + old_json);
response = string.Format("HTTP/1.1 {0}\nDate: {1}\n\n", x.Message, DateTime.Now.ToString());
hdr = System.Text.Encoding.ASCII.GetBytes(response);
stream.Write(hdr, 0, hdr.Length);
}
// Shutdown and end connection
client.Close();
}
}
bool GameInit()
{
if (isHost)
{
Debug.Log("waiting for the player");
listener = new TcpListener(IPAddress.Any, 8888);
listener.Start();
Thread acceptor = new Thread(() => { client = listener.AcceptTcpClient(); });
acceptor.Start();
while (client == null)
{
b = false;
while (!keyPresseed)
{
if (client != null)
{
b = true;
break;
}
}
if (b)
{
break;
}
if (QPressed)
{
return(false);
}
}
Debug.Log("Player appeared");
GetStream(client);
}
else
{
bool accept = true;
Thread acceptor = new Thread(() =>
{
try
{
client = new TcpClient(ip, 8888);
accept = true;
}
catch
{
ErrorHappened = true;
accept = false;
}
});
acceptor.Start();
while (client == null)
{
b = false;
while (!keyPresseed)
{
if (!accept)
{
return(false);
}
if (client != null)
{
b = true;
break;
}
}
if (b)
{
break;
}
if (QPressed)
{
return(false);
}
}
GetStream(client);
}
return(true);
}
public ITcpClient AcceptTcpClient()
{
var impl = _impl.AcceptTcpClient();
return(new TcpClientImpl(impl));
}
public override void Bad()
{
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");
}
}
}
CWE197_Numeric_Truncation_Error__float_listen_tcp_to_int_68b.BadSink();
}
public String getASTMStream()
{
TcpClient client = server.AcceptTcpClient();
var stream = client.GetStream();
Boolean transmisson = false;
Boolean checksum_block = false;
Boolean message_block = false;
// Byte ACK = Encoding.ASCII.GetString(6,0,bytes.Length);
BinaryWriter writer = new BinaryWriter(client.GetStream(), Encoding.ASCII, true);
ASCIIEncoding ascii = new ASCIIEncoding();
Byte[] ACK = ascii.GetBytes("\06");
string data = null;
Byte[] bytes = new byte[1];
int i;
StringBuilder message = new StringBuilder();
StringBuilder checksum = new StringBuilder();
try
{
while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
data = Encoding.ASCII.GetString(bytes, 0, i);
// Console.WriteLine(data.ToCharArray()[0]);
if (data.ToCharArray()[0] == ENQ)
{
writer.Write(ACK);
transmisson = true;
Console.WriteLine("Übertragung startet!");
}
else if (data.ToCharArray()[0] == EOT)
{
transmisson = false;
Console.WriteLine("Übertragung beendet!" + message);
return(message.ToString());
}
if (transmisson == true && data.ToCharArray()[0] == STX)
{
message_block = true;
Console.WriteLine("Daten kommen!");
}
if (data.ToCharArray()[0] == ETX)
{
message_block = false;
checksum_block = true;
Console.WriteLine("Ende der Nachricht!");
}
if (message_block == true && data.ToCharArray()[0] == CR)
{
}
else if (checksum_block == true && data.ToCharArray()[0] == CR)
{
checksum_block = false;
}
if (checksum_block == false && data.ToCharArray()[0] == CR)
{
message.Append(data.ToCharArray()[0]);
}
if (checksum_block == false && data.ToCharArray()[0] == LF)
{
message.Append(data.ToCharArray()[0]);
}
if (message_block == true)
{
message.Append(data.ToCharArray()[0]);
}
else if (checksum_block == true)
{
checksum.Append(data.ToCharArray()[0]);
}
}
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e.ToString());
client.Close();
}
return(message.ToString());
}
/// <summary>
/// Difunde el mensaje de un usuario a todos los usuarios conectados a la sala.
/// </summary>
/// <param name="mensaje">Mensaje del Usuario</param>
/// <param name="nombre">Nombre del usuario</param>
/// <param name="flag">Bandera que se utiliza para determinar si se agrega el texto
/// "dice" al mensaje enviado por el usuario</param>
///
public void iniciarServidor()
{
try
{
//Inicalizamos nuestro hashtable
clientes_conectados = new Hashtable();
//Inicializamos un nuevo servidor en la IP y puerto seleccionado.
servidor = new TcpListener(IPAddress.Parse(txtIP.Text), int.Parse(txtPuerto.Text));
//Iniciamos el servidor
servidor.Start();
//Indicamos que el servidor esta listo para aceptar peticiones de los clientes
mensajeChat = "Ha iniciado el Servidor";
Mensaje();
//definimos la variable de acepcacion de clientes
TcpClient cliente;
//Sólo aceptaremos mensajes de máximo 256 caracteres
Byte[] bytesCliente = new Byte[256];
NetworkStream streamCliente;
Chat chat;
while (true)
{
//Acepta la petición de un cliente
cliente = servidor.AcceptTcpClient();
//Leemos el mensaje del cliente
streamCliente = cliente.GetStream();
//bytesCliente sólo acepta mensajes de máximo 160 caracteres
streamCliente.Read(bytesCliente, 0, bytesCliente.Length);
//Traducimos el stream de bytes a un string en codificación ASCII
mensajeCliente = Encoding.ASCII.GetString(bytesCliente, 0, bytesCliente.Length);
mensajeCliente = mensajeCliente.Substring(0, mensajeCliente.IndexOf("$"));
//Verificamos si ya existe ese nombre de usuario.
while (clientes_conectados.ContainsKey(mensajeCliente))
{
Byte[] bytes = Encoding.ASCII.GetBytes("/*usuario duplicado*/");
//transmitimos el mensaje
streamCliente.Write(bytes, 0, bytes.Length);
streamCliente.Flush();
mensajeCliente = mensajeCliente + "1";
}
//Realmente no hacemos ninguna validación posterior ni se manda un mensaje al
//usuario pero por funcionalidad agregaremos esta condición.
clientes_conectados.Add(mensajeCliente, cliente);
try
{
switch (mensajeCliente.Substring(0, (mensajeCliente.IndexOf(" "))))
{
case "Amistad":
contadorAmistad++;
break;
case "Amor":
contadorAmor++;
break;
case "Culinaria":
contadorCulinaria++;
break;
case "Conocimiento":
contadorConocimiento++;
break;
}
}catch (Exception ex)
{}
mensajeChat = string.Format("{0} se ha unido al servidor", mensajeCliente);
Mensaje();
//Mandamos el mensaje a todos los clientes el mensaje
DifundirATodos(mensajeCliente, mensajeCliente, false);
//Ciclamos el proceso para que se quede el servidor en espera de nuevas conexiones o mensajes
chat = new Chat(cliente, mensajeCliente);
}
}
catch (Exception ex)
{
}
finally
{
if (servidor != null)
{
servidor.Stop();
}
}
}
protected void функция_потока()
{
TcpListener listner = null;
try
{
listner = new TcpListener(5595);
listner.Start();
byte[] data = new byte[512];
string str;
PrintMsg("Wait client");
while (true)
{
if (listner.Pending())
{
str = null;
TcpClient client = listner.AcceptTcpClient();
PrintMsg("Connected");
NetworkStream stream = client.GetStream();
int i;
byte[] msgbyte = new byte[512];
while ((i = stream.Read(data, 0, data.Length)) != 0)
{
for (int j = 0; j < i; j++)
{
if (data[j] == 1)
{
str += 1;
}
else
{
str += 0;
}
}
}
PrintMsg("Полученное закодированное сообщение в двоичном формате :\n" + str);
byte[] vec = new byte[str.Length];
for (int j = 0; j < str.Length; j++)
{
if (str[j] == '1')
{
vec[j] = 1;
}
else
{
vec[j] = 0;
}
}
Hamming_Decoder hd = new Hamming_Decoder(vec);
hd.добавитьОшибку();
byte[] vec2 = hd.вернутьДанныеБезДекодирования();
PrintMsg("Полученное закодированное сообщение в двоичном формате с ошибкой:\n" + вСтроку(vec2));
vec2 = hd.декодировать(0);
PrintMsg("Разкодированное сообщение с ошибкой:\n" + конвертировать(vec2));
//PrintMsg();
vec = hd.декодировать(1);
PrintMsg("Разкодированное сообщение с исправленной ошибкой:\n" + конвертировать(vec));
client.Close();
PrintMsg("Wait client");
}
}
}
catch (SocketException e) { PrintMsg(e.Message); }
finally { listner.Stop(); }
}
public static void Main()
{
TcpListener server = null;
try
{
// Getting Key Via User Input
Console.WriteLine("Enter Your Encryption Key: ");
string key = Console.ReadLine();
BigInteger keyNumber = BigInteger.Parse(key.Replace("~", "84").Replace("`", "83").Replace("?", "82").Replace("/", "81").Replace("=", "80").Replace("+", "79").Replace("_", "78").Replace("-", "77").Replace(")", "76").Replace("(", "75").Replace("*", "74").Replace("&", "73").Replace("^", "72").Replace("%", "71").Replace("$", "70").Replace("#", "69").Replace("@", "68").Replace("!", "67").Replace(";", "66").Replace(",", "65").Replace(".", "64").Replace("Z", "63").Replace("Y", "62").Replace("X", "61").Replace("W", "60").Replace("V", "59").Replace("U", "58").Replace("T", "57").Replace("S", "56").Replace("R", "55").Replace("Q", "54").Replace("P", "53").Replace("O", "52").Replace("N", "51").Replace("M", "50").Replace("L", "49").Replace("K", "48").Replace("J", "47").Replace("I", "46").Replace("H", "45").Replace("G", "44").Replace("F", "43").Replace("E", "42").Replace("D", "41").Replace("C", "40").Replace("B", "39").Replace("A", "38").Replace(" ", "37").Replace("a", "11").Replace("b", "12").Replace("c", "13").Replace("d", "14").Replace("e", "15").Replace("f", "16").Replace("g", "17").Replace("h", "18").Replace("i", "19").Replace("j", "20").Replace("k", "21").Replace("l", "22").Replace("m", "23").Replace("n", "24").Replace("o", "25").Replace("p", "26").Replace("q", "27").Replace("r", "28").Replace("s", "29").Replace("t", "30").Replace("u", "31").Replace("v", "32").Replace("w", "33").Replace("x", "34").Replace("y", "35").Replace("z", "36"));
// Set the TcpListener on port 53.
Int32 port = 53;
IPAddress localAddr = IPAddress.Parse("127.0.0.1");
// TcpListener server = new TcpListener(port);
server = new TcpListener(localAddr, port);
// Start listening for client requests.
server.Start();
// Buffer for reading data
Byte[] bytes = new Byte[256];
String data = null;
// Enter the listening loop.
while (true)
{
Console.Write("Waiting for a connection... ");
// Perform a blocking call to accept requests.
// You could also use server.AcceptSocket() here.
TcpClient client = server.AcceptTcpClient();
Console.WriteLine("Connected!");
data = null;
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
int i;
// Loop to receive all the data sent by the client.
while ((i = stream.Read(bytes, 0, bytes.Length)) != 0)
{
// Translate data bytes to a ASCII string.
data = System.Text.Encoding.ASCII.GetString(bytes, 0, i);
Console.WriteLine("Received: {0}", data);
// Process the data sent by the client.
data = data.ToUpper();
byte[] msg = System.Text.Encoding.ASCII.GetBytes(data);
result += System.Text.Encoding.UTF8.GetString(msg);
}
Console.WriteLine("\nDecrypted Message: " + Decrypt(result, keyNumber) + "\n");
// Shutdown and end connection
client.Close();
}
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
// Stop listening for new clients.
server.Stop();
}
Console.WriteLine("\nHit enter to continue...");
Console.Read();
}
public static void Main()
{
TcpListener server = null;
try
{
// Listening on port 8080
Int32 port = 8080;
IPAddress localAddr = IPAddress.Parse("127.0.0.1");
// TcpListener server = new TcpListener(port);
server = new TcpListener(localAddr, port);
// Start listening for client requests.
server.Start();
// Enter the listening loop.
while (true)
{
Console.Write("Waiting for a connection... ");
// Perform a blocking call to accept requests.
// You could also user server.AcceptSocket() here.
TcpClient client = server.AcceptTcpClient();
Console.WriteLine("Connected!");
// Get a stream object for reading and writing
NetworkStream stream = client.GetStream();
// Making a stream reader to read lines
StreamReader reader = new StreamReader(stream);
StreamWriter writer = new StreamWriter(stream);
Console.WriteLine("\n>>> Request:\n");
bool HeadersReceived = false;
string page = "aie";
page = reader.ReadLine().Split(' ')[1];
// Loop to receive all the data sent by the client.
while (!HeadersReceived && client.Connected)
{
string line = reader.ReadLine();
if (line != null)
{
line = line.Trim();
// Translate data bytes to a ASCII string.
Console.WriteLine("{0}", line);
if (line == "")
{
HeadersReceived = true;
}
}
}
// Responding
if (client.Connected)
{
Console.WriteLine(">>> Response:\n");
// Building the response
string response = "";
response += "HTTP/1.1 200 OK\r\n";
response += "Content-type: text/html\r\n";
response += "\r\n";
if (page == "/test")
{
response += "<h1>Page test </h1>";
}
else if (page == "/formulaire")
{
response += "<form method=\"get\"> Nombre 1: <input type=\"text\" name=\"n1\" /><br /> Nombre 2: <input type=\"text\" name=\"n2\" /><br /> <input type=\"submit\" value=\"Additioner!\" /> </form>";
}
else
{
response += "<h1>Hello, time is " + DateTime.Now.ToString("H:m:s") + "!</h1>";
}
Console.Write(response);
writer.Write(response);
writer.Flush();
// Sending the response and closing the client connection
}
// Shutdown and end connection
client.Close();
Console.WriteLine("\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
}
}
catch (SocketException e)
{
Console.WriteLine("SocketException: {0}", e);
}
finally
{
// Stop listening for new clients.
server.Stop();
}
Console.WriteLine("\nHit enter to continue...");
Console.Read();
}
/* goodB2G2() - use badsource and goodsink by reversing statements in second if */
private void GoodB2G2()
{
int data;
if (IO.STATIC_READONLY_TRUE)
{
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;
}
if (IO.STATIC_READONLY_TRUE)
{
/* FIX: Add a check to prevent an overflow from occurring */
if (Math.Abs((long)data) <= (long)Math.Sqrt(int.MaxValue))
{
int result = (int)(data * data);
IO.WriteLine("result: " + result);
}
else
{
IO.WriteLine("data value is too large to perform squaring.");
}
}
}
static void Main(string[] args)
{
if (args.Length == 0 || !int.TryParse(args[0], out listenPort))
{
listenPort = 12345;
}
TcpListener management = new TcpListener(IPAddress.Any, listenPort);
management.Start();
Console.WriteLine("Press escape to end program.");
Console.WriteLine("Listening for connections on port {0}", listenPort);
bool exitProgram = false;
while (!exitProgram)
{
if (Console.KeyAvailable)
{
if (Console.ReadKey(true).Key == ConsoleKey.Escape)
{
exitProgram = true;
}
}
if (management.Pending())
{
TcpClient conn = management.AcceptTcpClient();
Console.WriteLine("Connection from {0}", conn.Client.RemoteEndPoint.ToString());
conn.ReceiveBufferSize = 65536;
conn.SendBufferSize = 65536;
NetworkStream ns = conn.GetStream();
StreamReader nsIn = new StreamReader(ns, Encoding.ASCII);
string cmd = nsIn.ReadLine();
Console.WriteLine("received: {0}", cmd ?? "null");
if (cmd == null || cmd.Length == 0)
{
break;
}
if (cmd[0] == '?')
{
sendIqpList(conn);
}
else if (cmd[0] == '@')
{
openSerialPort(conn, cmd.Substring(1));
}
else if (cmd[0] == '*')
{
listOpenPorts(conn);
}
}
}
foreach (var devThreadInfo in deviceThreads.Values)
{
devThreadInfo.Item2.Cancel();
devThreadInfo.Item1.Join();
}
management.Stop();
}
void Worker_DoWork(object sender, DoWorkEventArgs e)
{
bool connection_open = true;
int progress = 0;
try
{
listener = new TcpListener(portNum);
listener.Start();
(sender as BackgroundWorker).ReportProgress(progress, "Waiting for connection...");
// if (Worker.CancellationPending)
// connection_open = false;
// if (!listener.Pending())
// {
// Console.WriteLine("Sorry, no connection requests have arrived");
// }
client = listener.AcceptTcpClient();
(sender as BackgroundWorker).ReportProgress(progress, "Connection accepted.");
ns = client.GetStream();
byte[] bytes = new byte[1024];
int bytesRead;
string EncodedMessage;
// int max = (int)e.Argument;
// int result = 0;
while (connection_open)
{
if (ns.DataAvailable)
{
try
{
bytesRead = ns.Read(bytes, 0, bytes.Length);
EncodedMessage = Encoding.ASCII.GetString(bytes, 0, bytesRead);
if (EncodedMessage == "Close Connection")
{
connection_open = false;
}
else
{
EncodedMessage = "Client(Ktos): " + EncodedMessage;
}
(sender as BackgroundWorker).ReportProgress(progress, EncodedMessage);
}
catch (Exception ex)
{
(sender as BackgroundWorker).ReportProgress(progress, ex.ToString());
}
}
if (Worker.CancellationPending)
{
e.Cancel = true;
connection_open = false;
}
}
//e.Result = result;
}
catch (Exception ex)
{
(sender as BackgroundWorker).ReportProgress(progress, ex.ToString());
}
}
public override void Bad()
{
string data;
if (IO.StaticReturnsTrue())
{
data = ""; /* Initialize data */
/* Read data using a listening tcp connection */
{
TcpListener listener = null;
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 */
data = sr.ReadLine();
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
finally
{
if (listener != null)
{
try
{
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 = null;
}
if (IO.StaticReturnsTrue())
{
StringBuilder sourceCode = new StringBuilder("");
sourceCode.Append("public class Calculator \n{\n");
sourceCode.Append("\tpublic int Sum()\n\t{\n");
sourceCode.Append("\t\treturn (10 + " + data.ToString() + ");\n");
sourceCode.Append("\t}\n");
sourceCode.Append("}\n");
/* POTENTIAL FLAW: Compile sourceCode containing unvalidated user input */
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters cp = new CompilerParameters();
CompilerResults cr = provider.CompileAssemblyFromSource(cp, sourceCode.ToString());
Assembly a = cr.CompiledAssembly;
object calculator = a.CreateInstance("Calculator");
Type calculatorType = calculator.GetType();
MethodInfo mi = calculatorType.GetMethod("Sum");
int s = (int)mi.Invoke(calculator, new object[] {});
IO.WriteLine("Result: " + s.ToString());
}
}
/* goodB2G2() - use badsource and goodsink by reversing statements in second if */
private void GoodB2G2()
{
string data;
if (PrivateReturnsTrue())
{
data = ""; /* Initialize data */
/* Read data using a listening tcp connection */
{
TcpListener listener = null;
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 */
data = sr.ReadLine();
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
finally
{
if (listener != null)
{
try
{
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 = null;
}
if (PrivateReturnsTrue())
{
/* FIX: Hash data before storing in a file */
{
string salt = "ThisIsMySalt";
using (SHA512CryptoServiceProvider sha512 = new SHA512CryptoServiceProvider())
{
byte[] buffer = Encoding.UTF8.GetBytes(string.Concat(salt, data));
byte[] hashedCredsAsBytes = sha512.ComputeHash(buffer);
data = IO.ToHex(hashedCredsAsBytes);
}
}
using (SecureString secureData = new SecureString())
{
for (int i = 0; i < data.Length; i++)
{
secureData.AppendChar(data[i]);
}
File.WriteAllText(@"C:\Users\Public\WriteText.txt", secureData.ToString());
}
}
}
public Server()
{
logger = new Logger(programName: "B_Server", outputToFile: true);
TcpListener server = new TcpListener(IPAddress.Any, Networking.PORT);
var controller = new Dictionary <byte, Action <byte[], TcpClient, uint> >()
{
{ Networking.PROTOCOL_SUBMIT, HandleSubmit },
{ Networking.PROTOCOL_QUERY, HandleQuery },
{ Networking.PROTOCOL_DELETE, HandleDelete },
{ Networking.PROTOCOL_HELLO, HandleHello }
};
server.Start(); // this will start the server
logger.Info("Broadcast ready - Port " + Networking.PORT + " - Version " + VERSION);
while (true) //we wait for a connection
{
TcpClient client = server.AcceptTcpClient(); //if a connection exists, the server will accept it
uint clientId = (uint)new Random().Next(int.MaxValue);
logger.Info("Client [" + clientId + "] just connected (ENTER)");
new Task(delegate {
NetworkStream ns = client.GetStream();
ns.ReadTimeout = SECONDS_BEFORE_EMPTY_READ * 1000;
while (client.Connected) //while the client is connected, we look for incoming messages
{
try {
// BLOCKing
var msgBuffer = ns.Read();
if (client.Available <= 0 && msgBuffer.Length == 0)
{
break;
}
var messageType = msgBuffer[0];
byte[] deserializable = new byte[msgBuffer.Length - 1];
Array.Copy(msgBuffer, 1, deserializable, 0, deserializable.Length);
if (controller.ContainsKey(messageType))
{
logger.Trace("Client [{0}] sent (MessageType:{1}) [Length: {2} bytes]", clientId, messageType, deserializable.Length);
controller[messageType](deserializable, client, clientId);
}
else
{
// ???
logger.Warn("Client [" + clientId + "] sent an unknown message type: (MessageType:" + messageType + ") is not implemented in this broadcast version");
}
}
catch (IOException e) {
logger.Info("Client [" + clientId + "] had an IOException (see debug)");
logger.Debug(e.ToString());
break;
}
catch (SocketException e) {
logger.Info("Client [" + clientId + "] had an SocketException (see debug)");
logger.Debug(e.ToString());
break;
}
catch (TaskCanceledException e) {
logger.Trace("Caught a task cancellation - probably normal, going to rethrow the cancellation to end the task. Trace below:\n" + e.ToString());
throw new TaskCanceledException(e.ToString()); // Passthrough
}
catch (Exception e) {
logger.Error("UNCAUGHT EXCEPTION IN CLIENT TASK for Client [{0}] ! Ending the task. Trace below:".Format(clientId));
logger.Error(e.ToString());
throw new TaskCanceledException();
}
}
ns.Dispose();
client.Close();
logger.Info("Client [" + clientId + "] is no longer connected (EXIT)");
}).Start();
CleanLobbies();
}
}
public static void Main()
{
TcpListener tcpListener = new TcpListener(IPAddress.Any, PortNumber);
tcpListener.Start();
Console.WriteLine($"Listening on port {PortNumber}...");
Console.WriteLine($"The local End point is : {tcpListener.LocalEndpoint}");
Console.WriteLine("Waiting for connection...");
while (true)
{
using (NetworkStream networkStream = tcpListener.AcceptTcpClient().GetStream())
{
var request = new byte[4096];
var readBytes = networkStream.Read(request, 0, request.Length);
var reqData = Encoding.UTF8.GetString(request, 0, readBytes).Replace("\\", "/");
Console.WriteLine(reqData);
if (!string.IsNullOrEmpty(reqData))
{
var file = string.Empty;
var reqFirstLine = reqData.Substring(0, reqData.IndexOf(Environment.NewLine)).Split();
var url = reqFirstLine[1];
var statusLine = $"{reqFirstLine[2]} 200 OK"; // First line of the response Header
if (url == "/")
{
file = $"{SourcePath}/index.html";
}
else
{
var reqFile = $"{SourcePath}{url.Substring(url.IndexOf('/'))}";
if (!reqFile.EndsWith(".html"))
{
reqFile += ".html";
}
if (File.Exists(reqFile))
{
file = reqFile;
}
else
{
file = ErrorPath;
statusLine = "HTTP/1.0 404 Not Found";
}
}
// Build Response Header
var responseHeader = new StringBuilder();
responseHeader.Append($"{statusLine}{Environment.NewLine}");
responseHeader.Append($"Accept-Ranges: bytes{Environment.NewLine}");
// Build Response message
var response = new StringBuilder();
using (var reader = new StreamReader(file))
{
var line = reader.ReadLine();
while (line != null)
{
response.Append(line);
line = reader.ReadLine();
}
}
if (file.EndsWith("info.html"))
{
response
.Replace("{0}", DateTime.Now.ToString("dd MMM yyyy hh:mm:ss", new CultureInfo("en-EN")))
.Replace("{1}", Environment.ProcessorCount.ToString());
}
// Complete response Headder
var contentLingth = Encoding.UTF8.GetBytes(response.ToString()).Length;
responseHeader.Append($"ContentLength: {contentLingth}{Environment.NewLine}");
responseHeader.Append($"Connection: close{Environment.NewLine}");
responseHeader.Append($"Content-Type: text/html{Environment.NewLine}");
responseHeader.Append(Environment.NewLine);
// Gather together Header and Message for the response
response.Insert(0, responseHeader);
// Convert response to bytes
byte[] responseBytes = Encoding.UTF8.GetBytes(response.ToString());
// Send Rresponse to the Browser
networkStream.Write(responseBytes, 0, responseBytes.Length);
}
}
}
}
public override void Bad()
{
string data;
if (IO.StaticReturnsTrueOrFalse())
{
data = ""; /* Initialize data */
/* Read data using a listening tcp connection */
{
TcpListener listener = null;
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 */
data = sr.ReadLine();
}
}
}
catch (IOException exceptIO)
{
IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading");
}
finally
{
if (listener != null)
{
try
{
listener.Stop();
}
catch (SocketException se)
{
IO.Logger.Log(NLog.LogLevel.Warn, se, "Error closing TcpListener");
}
}
}
}
}
else
{
/* FIX: Use a hardcoded int as a string */
data = "5";
}
if (IO.StaticReturnsTrueOrFalse())
{
int numberOfLoops;
try
{
numberOfLoops = int.Parse(data);
}
catch (FormatException exceptNumberFormat)
{
IO.WriteLine("Invalid response. Numeric input expected. Assuming 1.");
IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Invalid response. Numeric input expected. Assuming 1.");
numberOfLoops = 1;
}
for (int i = 0; i < numberOfLoops; i++)
{
/* POTENTIAL FLAW: user supplied input used for loop counter test */
IO.WriteLine("hello world");
}
}
else
{
int numberOfLoops;
try
{
numberOfLoops = int.Parse(data);
}
catch (FormatException exceptNumberFormat)
{
IO.WriteLine("Invalid response. Numeric input expected. Assuming 1.");
IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Invalid response. Numeric input expected. Assuming 1.");
numberOfLoops = 1;
}
/* FIX: loop number thresholds validated */
if (numberOfLoops >= 0 && numberOfLoops <= 5)
{
for (int i = 0; i < numberOfLoops; i++)
{
IO.WriteLine("hello world");
}
}
}
}
