} // end method DisplayMessage
// accepts connections from 2 players
public void SetUp()
{
DisplayMessage("Waiting for players...\r\n");
// set up Socket
listener =
new TcpListener(IPAddress.Parse("127.0.0.1"), 50000);
listener.Start();
// accept first player and start a player thread
players[0] = new Player(listener.AcceptSocket(), this, 0);
playerThreads[0] =
new Thread(new ThreadStart(players[0].Run));
playerThreads[0].Start();
// accept second player and start another player thread
players[1] = new Player(listener.AcceptSocket(), this, 1);
playerThreads[1] =
new Thread(new ThreadStart(players[1].Run));
playerThreads[1].Start();
// let the first player know that the other player has connected
lock (players[0])
{
players[0].threadSuspended = false;
Monitor.Pulse(players[0]);
} // end lock
} // end method SetUp
static void Main(string[] args)
{
DateTime now = DateTime.Now;
Console.WriteLine("[" + now.ToString("tthh:mm:ss") + "]");
TcpListener listener = null;
bool Start_Service = false;
try
{
//IPAddress ipAddress = Dns.GetHostEntry("localhost").AddressList[0];
//IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
IPAddress ipAddress = IPAddress.Any;
listener = new TcpListener(ipAddress, 3000);
listener.Start();
Console.WriteLine("** ChatServer **");
Console.WriteLine("1. 대기중입니다.");
while (!Start_Service)
{
Socket socket = listener.AcceptSocket();
Console.WriteLine("[+접속클라이언트]:" + socket.RemoteEndPoint);
if (socket.Connected)
{
//ChatSupporter 스레드 생성
ChatSupporter cs = new ChatSupporter(socket);
//ChatSupporter room에 저장
room.AddChatSupporter(cs);
}
}
}
catch
{
Console.WriteLine("서버 생성 도중 에러");
return;
}
}
public static void Main()
{
TcpListener tcpListener = new TcpListener(10);
tcpListener.Start();
Socket socketForClient = tcpListener.AcceptSocket();
if (socketForClient.Connected)
{
Console.WriteLine("Client connected");
NetworkStream networkStream = new NetworkStream(socketForClient);
System.IO.StreamWriter streamWriter =
new System.IO.StreamWriter(networkStream);
System.IO.StreamReader streamReader =
new System.IO.StreamReader(networkStream);
string theString = "Sending";
streamWriter.WriteLine(theString);
Console.WriteLine(theString);
streamWriter.Flush();
theString = streamReader.ReadLine();
Console.WriteLine(theString);
streamReader.Close();
networkStream.Close();
streamWriter.Close();
}
socketForClient.Close();
Console.WriteLine("Exiting...");
}
static void Main(string[] args)
{
String n="", horariosOut="";
IPAddress ip = IPAddress.Parse("127.0.0.1");
TcpListener tcpListener = new TcpListener(ip, 5050);
tcpListener.Start();
Socket serverSock = tcpListener.AcceptSocket();
if (serverSock.Connected)
{
NetworkStream con = new NetworkStream(serverSock);
//Archivo local en servidor, el cual se activará para mandar un correo
StreamWriter crearArchivoLocal = new StreamWriter("C:/Users/Dell/Documents/datoAdjunto.txt");
StreamWriter enviarDatos = new StreamWriter(con);
StreamReader recibirDatos = new StreamReader(con);
if(recibirDatos.ReadLine()!=""){
horariosOut = "Horarios disponibles: 1) 9:00 am 2) 12:00 pm 3) 3:00pm 4) 5:00 pm 5) 12:00 am. Seleccione alguna opción indicando con un numero";
enviarDatos.WriteLine(horariosOut);
enviarDatos.Flush();
}
if(recibirDatos.ReadLine().Equals("2")){
n = (recibirDatos.ReadLine() );
crearArchivoLocal.WriteLine(n);
}
if(recibirDatos.ReadLine().Equals("3")){
EnviarEmail enviarCorreo = new EnviarEmail();
bool exito = enviarCorreo.EnviarMail(recibirDatos.ReadLine(), "Datos de reservación", n, "AerolinasMisael", "*****@*****.**", "josueupbc");
if (exito == true)
{
enviarDatos.WriteLine(n + " El correo fue enviado exitosamente");
Console.WriteLine("El correo ha sido enviado exitosamente");
}
else
Console.Error.WriteLine("No fue posible enviar el correo");
enviarDatos.Flush();
}
recibirDatos.Close();
crearArchivoLocal.Close();
enviarDatos.Close();
con.Close();
serverSock.Close();
}
else
Console.WriteLine("Fallo en la conexion");
Console.ReadKey();
}
private NetworkStream serverStream; //Stream - incoming
#endregion Fields
#region Methods
//listening to the server
public void Listen()
{
System.Net.IPAddress remoteIPAddress = System.Net.IPAddress.Parse(m_IPAdress);
bool errorOcurred = false;
Socket connection = null; //The socket that is listened to
try
{
//Creating listening Socket
this.listener = new TcpListener(remoteIPAddress, inPort);
//Starts listening
this.listener.Start();
Debug.Log("listening...");
//Establish connection upon client request
while (!navigator.gameInstance.GameFinished)
{
//connection is connected socket
connection = listener.AcceptSocket();
if (connection.Connected)
{
//To read from socket create NetworkStream object associated with socket
this.serverStream = new NetworkStream(connection);
List<Byte> inputStr = new List<byte>();
int asw = 0;
while (asw != -1)
{
asw = this.serverStream.ReadByte();
inputStr.Add((Byte)asw);
}
reply = Encoding.UTF8.GetString(inputStr.ToArray());
this.serverStream.Close();
ThreadPool.QueueUserWorkItem(new WaitCallback(navigator.gameInstance.Resolve), (object)reply); //parse the message from the
}
}
}
catch (Exception e)
{
Debug.Log("RECEIVING Failed! \n " + e.Message);
errorOcurred = true;
}
finally
{
if (connection != null)
if (connection.Connected)
connection.Close();
if (errorOcurred)
Debug.Log("Error occured while listening! \n ");
//this.Listen();
}
}
void ts()
{
try {
IPAddress ipAd = IPAddress.Parse("127.0.0.1"); //use local address
TcpListener listener=new TcpListener(ipAd,801);
listener.Start(); // Listen for connections
Debug.Log("The local End point is: " + listener.LocalEndpoint );
Debug.Log("Waiting for a connection.....");
System.Diagnostics.Process process= new System.Diagnostics.Process();
process.StartInfo.FileName = flashCamPath;
process.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Minimized;
process.Start(); // Start the air webcam app
Socket s = listener.AcceptSocket(); // Accept incomming connection
Debug.Log("Connection accepted from "+s.RemoteEndPoint);
byte[] b=new byte[sizeof(int)];
s.Receive(b); // Receive what we expect to be an integer
Console.WriteLine("Recieved...");
camWidth = BitConverter.ToInt32(b, 0); // Set the width of the image
Debug.Log("Image width: " + camWidth);
s.Receive(b); // Receive what we expect to be another integer
camHeight = BitConverter.ToInt32(b, 0); // Set the height
Debug.Log("Image height: " + camHeight);
c = new Color[camWidth*camHeight]; // Create a new Color object
byte[] img=new byte[camWidth * camHeight * RGBA]; // Create a byte array
Debug.Log("Ready to receive webcam stream");
while (receiveData) { // loop around this until we kill the thread
ASCIIEncoding asen=new ASCIIEncoding();
s.Send(asen.GetBytes("ready")); // Tell the client we are ready
s.Receive(img); // Receive the pixel buffer
// Convert the pixel buffer into the color object. I'm too lazy to explain this in detail.
for (int i = 0; i < camHeight; ++i) {
for (int j = 0; j < camWidth * RGBA; j += RGBA) {
c[(i*camWidth) + (j/RGBA)].a = img[(i*camWidth*RGBA) + j] / 255f;
c[(i*camWidth) + (j/RGBA)].r = img[(i*camWidth*RGBA) + j +1] / 255f;
c[(i*camWidth) + (j/RGBA)].g = img[(i*camWidth*RGBA) + j + 2] / 255f;
c[(i*camWidth) + (j/RGBA)].b = img[(i*camWidth*RGBA) + j + 3] / 255f;
}
}
Thread.Sleep(100); // Make sure the thread has a short nap
}
s.Close(); // When we exeit the loop, close the connection
listener.Stop(); // Stop listeneing
process.Kill(); // Kill the flash app
} catch (Exception e) {
Debug.Log("Error..... " + e.StackTrace);
}
}
public static void Main()
{
try
{
bool status = true ;
string servermessage = "" ;
string clientmessage = "" ;
TcpListener tcpListener = new TcpListener(8100) ;
tcpListener.Start() ;
Console.WriteLine("Server Started") ;
Socket socketForClient = tcpListener.AcceptSocket() ;
Console.WriteLine("Client Connected") ;
NetworkStream networkStream = new NetworkStream(socketForClient) ;
StreamWriter streamwriter = new StreamWriter(networkStream) ;
StreamReader streamreader = new StreamReader(networkStream) ;
while(status)
{
if(socketForClient.Connected)
{
servermessage = streamreader.ReadLine() ;
Console.WriteLine("Client:"+servermessage) ;
if((servermessage== "bye" ))
{
status = false ;
streamreader.Close() ;
networkStream.Close() ;
streamwriter.Close() ;
return ;
}
Console.Write("Server:") ;
clientmessage = Console.ReadLine() ;
streamwriter.WriteLine(clientmessage) ;
streamwriter.Flush() ;
}
}
streamreader.Close() ;
networkStream.Close() ;
streamwriter.Close() ;
socketForClient.Close() ;
Console.WriteLine("Exiting") ;
}
catch(Exception e)
{
Console.WriteLine(e.ToString()) ;
}
}
private void Run()
{
_log.info("ConsorsGate::Run", "starting TCP listener on port 65000.");
TcpListener tcpl=new TcpListener(65000);
tcpl.Start();
while(!_quit){
Socket socket=tcpl.AcceptSocket();
if(socket.Connected){
_log.info("ConsorsGate::Run", "new socket connected.");
ConsorsGateHandler cgh=new ConsorsGateHandler(_log, socket);
_sm.add(cgh);
}
}
_log.info("ConsorsGate::Run", "Leaving now.");
}
void Update()
{
tcpListener = new TcpListener(5555);
tcpListener.Start();
serverSocket = tcpListener.AcceptSocket();
try
{
if (serverSocket.Connected)
{
Debug.Log("Connect");
while (true)
{
networkStream = new NetworkStream(serverSocket);
streamWriter = new StreamWriter(networkStream);
streamReader = new StreamReader(networkStream);
//MemoryStream stream1 = new MemoryStream();
//DeSerealizaton();
//MyNameSpace.Player Player = new MyNameSpace.Player {X = GameObject.Find("Player").transform.position.x,Y = GameObject.Find("Player").transform.position.y, Z = GameObject.Find("Player").transform.position.z};
//MyNameSpace.SomeContainer someContainer = new MyNameSpace.SomeContainer {Player = Player};
//MyNameSpace.SomeContainer desSomeObject = JsonConvert.DeserializeObject<MyNameSpace.SomeContainer>(jsonString);
jsonString = streamReader.ReadLine();
Debug.Log(jsonString);
MyNameSpace.Player Player = new MyNameSpace.Player {X = GameObject.Find("Player").transform.position.x,Y = GameObject.Find("Player").transform.position.y, Z = GameObject.Find("Player").transform.position.z};
MyNameSpace.SomeContainer someContainer = new MyNameSpace.SomeContainer {Player = Player};
MyNameSpace.SomeContainer desSomeObject = JsonConvert.DeserializeObject<MyNameSpace.SomeContainer>(jsonString);
//stream1.Position = 0;
x = desSomeObject.Player.X;
y = desSomeObject.Player.Y;
z = desSomeObject.Player.Z;
GameObject.Find("Player").transform.position = new Vector3(x,y,z);
}
}
if (serverSocket.Connected)
{
serverSocket.Close();
}
}
catch (SocketException ex)
{
Debug.Log(ex);
}
}
public static void acceptconnection(out TcpListener Listener, out Socket client_socket)
{
// Use any IP
IPAddress ipAdd = IPAddress.Any;
//Start listening
Listener = new TcpListener(ipAdd, 8001);
//Wait for connection
Listener.Start();
Console.WriteLine("The server is running at port 8001...");
Console.WriteLine("The local End point is :" +
Listener.LocalEndpoint);
Console.WriteLine("Waiting for a connection.....");
client_socket = Listener.AcceptSocket();
Console.WriteLine("Connection accepted from " + client_socket.RemoteEndPoint);
}
public void startDispatching(TcpListener listener, ILogger logger,
IProtocolFactory protoFactory)
{
// Run forever, accepting and spawning threads to service each connection
for (;;) {
try {
listener.Start();
Socket clntSock = listener.AcceptSocket(); // Block waiting for connection
IProtocol protocol = protoFactory.createProtocol(clntSock, logger);
Thread thread = new Thread(new ThreadStart(protocol.handleclient));
thread.Start();
logger.writeEntry("Created and started Thread = " + thread.GetHashCode());
} catch (System.IO.IOException e) {
logger.writeEntry("Exception = " + e.Message);
}
}
/* NOT REACHED */
}
public void RunServerImpl()
{
//yield return null;
TcpListener tcpListener = null;
try
{
//ip주소를 나타내는 객체 생성. TcpListener생성시 인자로 사용
IPAddress ipAd = IPAddress.Parse("127.0.0.1");
//TcpListener class를 이용하여 클라이언트 연결 받아 들임
tcpListener = new TcpListener(ipAd, TestServer.PORT);
tcpListener.Start();
//Console.WriteLine("멀티스레드 Test 창 :Waiting for connections...");
Debug.Log("S: Waiting for connections.. \n");
while (true)
{
//accepting the connection
Socket client = tcpListener.AcceptSocket();
Debug.Log(string.Format("S: Accepted socket {0} \n", client.Connected));
ClientHandler cHandler = new ClientHandler();
//passing calue to the thread class
cHandler.clientSocket = client;
//creating a new thread for the client
Thread clientThread = new Thread(new ThreadStart(cHandler.runClient));
clientThread.Start();
}
}
catch (Exception exp)
{
//Console.WriteLine("Exception :" + exp);
Debug.Log("S: Exception :" + exp);
}
finally
{
tcpListener.Stop();
}
}
public static void acceptconnection(out TcpListener myList, out Socket s)
{
IPAddress ipAd = IPAddress.Parse("161.115.86.57");
//use local m/c IP address, and
//use the same in the client
/* Initializes the Listener */
myList = new TcpListener(ipAd, 8001);
/* Start Listeneting at the specified port */
myList.Start();
Console.WriteLine("The server is running at port 8001...");
Console.WriteLine("The local End point is :" +
myList.LocalEndpoint);
Console.WriteLine("Waiting for a connection.....");
s = myList.AcceptSocket();
Console.WriteLine("Connection accepted from " + s.RemoteEndPoint);
}
public static void Main()
{
try
{
IPAddress ipAd = IPAddress.Parse("10.2.20.29");
// use local m/c IP address, and
// use the same in the client
/* Initializes the Listener */
TcpListener myList = new TcpListener(ipAd, 8001);
/* Start Listeneting at the specified port */
myList.Start();
Console.WriteLine("The server is running at port 8001...");
Console.WriteLine("The local End point is :" +
myList.LocalEndpoint);
Console.WriteLine("Waiting for a connection.....");
Socket s = myList.AcceptSocket();
Console.WriteLine("Connection accepted from " + s.RemoteEndPoint);
byte[] b = new byte[100];
int k = s.Receive(b);
Console.WriteLine("Recieved...");
for (int i = 0; i < k; i++)
Console.Write(Convert.ToChar(b[i]));
ASCIIEncoding asen = new ASCIIEncoding();
s.Send(asen.GetBytes("The string was recieved by the server."));
Console.WriteLine("\nSent Acknowledgement");
/* clean up */
s.Close();
myList.Stop();
}
catch (Exception e)
{
Console.WriteLine("Error..... " + e.StackTrace);
}
}
public static void Main()
{
try
{
IPAddress ipAd=IPAddress.Parse("127.0.0.1");
TcpListener myList=new TcpListener(ipAd,8001);
myList.Start();
Console.WriteLine("��8001�˿��������...");
Console.WriteLine("���ؽڵ�Ϊ��"+myList.LocalEndpoint);
Console.WriteLine("�ȴ�����...");
Socket s=myList.AcceptSocket();
Console.WriteLine("�������� "+s.RemoteEndPoint);
byte[] b=new byte[100];
int k=s.Receive(b);
Console.WriteLine("�ѽ���...");
for(int i=0;i<k;i++)
{
Console.Write(Convert.ToChar(b[i]));
}
ASCIIEncoding asen=new ASCIIEncoding();
s.Send(asen.GetBytes("The string was recieved by the server."));
Console.WriteLine("\n �ѷ��ͻ�Ӧ��Ϣ");
s.Close();
myList.Stop();
}
catch (Exception e)
{
Console.WriteLine("Error..... " + e.StackTrace);
}
Console.ReadKey();
}
public static void Main()
{
// TcpListener�����˿�1234
TcpListener tcpListener = new TcpListener(1234);
tcpListener.Start();
Console.WriteLine("Server Started") ;
// �����µ�����
Socket socketForClient = tcpListener.AcceptSocket();
try
{
if (socketForClient.Connected)
{
while(true)
{
// ��StreamWriter��StreamReader���������
// ��������ȡ�ͻ��˷��͵���Ϣ��������ɴ�д��ʽ��Ӧ���ͻ���
Console.WriteLine("Client connected");
NetworkStream networkStream = new NetworkStream(socketForClient);
StreamWriter streamWriter = new StreamWriter(networkStream);
StreamReader streamReader = new StreamReader(networkStream);
string line = streamReader.ReadLine();
Console.WriteLine("Read:" +line);
line=line.ToUpper()+ "!";
streamWriter.WriteLine(line);
Console.WriteLine("Wrote:"+line);
streamWriter.Flush() ;
}
}
socketForClient.Close();
Console.WriteLine("Exiting...");
}
catch(Exception e)
{
Console.WriteLine(e.ToString()) ;
}
}
public static void Main()
{
IPAddress ipAddress = IPAddress.Any;
TcpListener listener = new TcpListener(ipAddress, port);
listener.Start();
Console.WriteLine("Server is running");
Console.WriteLine("Listening on port " + port);
Console.WriteLine("Waiting for connections...");
while (true)
{
Socket s = listener.AcceptSocket();
Console.WriteLine("Connection accepted from " + s.RemoteEndPoint);
byte[] b = new byte[65535];
int k = s.Receive(b);
Console.WriteLine("Received:");
for (int i = 0; i < k; i++)
Console.Write(Convert.ToChar(b[i]));
ASCIIEncoding enc = new ASCIIEncoding();
s.Send(enc.GetBytes("Server responded"));
Console.WriteLine("\nSent Response");
s.Close();
}
}
//entry point of main method....
public static void Main()
{
//TcpListener is listening on the given port... {
TcpListener tcpListener = new TcpListener(1234);
tcpListener.Start();
Console.WriteLine("Server Started");
//Accepts a new connection...
Socket socketForClient = tcpListener.AcceptSocket();
//StreamWriter and StreamReader Classes for reading and writing the data to and fro.
//The server reads the meassage sent by the Client ,converts it to upper case and sends it back to the client.
//Lastly close all the streams.
try
{
if (socketForClient.Connected)
{
while (true)
{
Console.WriteLine("Client connected");
NetworkStream networkStream = new NetworkStream(socketForClient);
StreamWriter streamWriter = new StreamWriter(networkStream);
StreamReader streamReader = new StreamReader(networkStream);
string line = streamReader.ReadLine();
Console.WriteLine("Read:" + line);
line = line.ToUpper() + "!";
streamWriter.WriteLine(line);
Console.WriteLine("Wrote:" + line);
streamWriter.Flush();
}
}
socketForClient.Close();
Console.WriteLine("Exiting...");
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
void SyncSearch()
{
while(true)
{
try {
IPAddress ipAd = IPAddress.Parse(Config.ip);
Debug.Log("Looking For New Client");
TcpListener myList=new TcpListener(ipAd,8001);
myList.Start();
Socket s=myList.AcceptSocket();
Debug.Log("Find Client");
mListClient.Add(new TcpPlayer(s , getId() , PlayerType.Gobelin));
mSynchronizing = false;
myList.Stop();
}
catch (Exception e) {
mSynchronizing = false;
Debug.Log("Error..... " + e.StackTrace);
}
}
}
public static void Service()
{
while (gEnable_Remote_Service)
{
Socket soc = listener.AcceptSocket();
try
{
string[] delimeter = new string[64];
string[] tokens = new string[64];
delimeter[0] = "<=";
delimeter[1] = "//";
delimeter[2] = ";";
delimeter[3] = "=";
delimeter[4] = "set ";
delimeter[5] = "dec";
delimeter[6] = "0x";
delimeter[7] = "(";
delimeter[8] = ")";
delimeter[9] = " ";
Stream s = new NetworkStream(soc);
StreamReader sr = new StreamReader(s);
StreamWriter sw = new StreamWriter(s);
sw.AutoFlush = true; // enable automatic flushing
string RCcmd = "";
sw.WriteLine("Hello NIU!");
while (RCcmd != "quit")
{
RCcmd = sr.ReadLine();
RCcmd = RCcmd.Trim().ToLower();
//sw.WriteLine("ok, I hear you.");
//crappy short cuts
if (RCcmd == "hello")
{
WC_client.FakeSpill(); sw.WriteLine("GO");
}
if (RCcmd == "done")
{
WC_client.FakeSpill(); sw.WriteLine("GO");
}
if (RCcmd == "help")
{
sw.WriteLine("I know nothing!");
}
if (RCcmd == "disarm")
{
DisArmAll(); sw.WriteLine(RCcmd);
}
if (RCcmd == "clear")
{
ClearAll(); sw.WriteLine(RCcmd);
}
if (RCcmd == "status")
{
string m = ReportStatus(); sw.WriteLine(m);
}
if (RCcmd.Contains("maxtrig"))
{
int val = 1000;
string[] tok = RCcmd.Split(delimeter, StringSplitOptions.None);
if (tok.Length > 1)
{
try
{
val = Convert.ToInt32(tok[1]);
if (val < 1)
{
val = 1;
}
if (val > 1000)
{
val = 1000;
}
}
catch
{ val = 1000; }
g_commanded_max_trig = val;
}
}
if (RCcmd.Contains("read"))
{
string[] tok = RCcmd.Split(delimeter, StringSplitOptions.None);
if (tok.Length > 1)
{
if (tok[1].Contains("all"))
{
ReadAll();
sw.WriteLine(RCcmd);
}
else
{
}
}
}
}
s.Close();
}
catch (Exception e)
{
if (PP.glbDebug)
{
Console.WriteLine("oops, connection lost");
}
}
soc.Close();
}
}
public void TestInitialize()
{
result = null;
// Create Mock object to mock implementation of T by new Mock<T>();
_mockSparkCLRProxy = new Mock <ISparkCLRProxy>();
_mockSparkContextProxy = new Mock <ISparkContextProxy>();
_mockStreamingContextProxy = new Mock <IStreamingContextProxy>();
_mockRddProxy = new Mock <IRDDProxy>();
SparkCLREnvironment.SparkCLRProxy = _mockSparkCLRProxy.Object;
// Mock method of T by Mock<T>.Setup(). For method with parameters, you can mock different method implementation for different method parameters.
// e.g., if you want to mock a method regardless of what values the method parameters are, you can use It.IsAny<T>() for each parameter; if you want
// to mock the method for certain criteria, use It.Is<T>(Func<T, bool>) can. You can mock the same method multiple times for different criteria of
// method parameters.
// If the method to mock has return value and you want to mock the return value only, Use Returns(TReturnValue); if you want to add logics and return,
// use Returns<T1, T2, ...>(Func<T1, T2, ..., TReturnValue>). If method is void, use CallBack<T1, T2, ...>(Action<T1, T2, ...>)
// for more info please visit https://github.com/Moq/moq4/wiki/Quickstart
_mockSparkCLRProxy.Setup(m => m.CreateSparkConf(It.IsAny <bool>())).Returns(new MockSparkConfProxy()); // some of mocks which rarely change can be kept
_mockSparkCLRProxy.Setup(m => m.CreateSparkContext(It.IsAny <ISparkConfProxy>())).Returns(_mockSparkContextProxy.Object);
_mockSparkCLRProxy.Setup(m => m.CreateStreamingContext(It.IsAny <SparkContext>(), It.IsAny <long>())).Returns(_mockStreamingContextProxy.Object);
_mockRddProxy.Setup(m => m.CollectAndServe()).Returns(() =>
{
TcpListener listener = new TcpListener(IPAddress.Loopback, 0);
listener.Start();
Task.Run(() =>
{
using (Socket socket = listener.AcceptSocket())
using (Stream ns = new NetworkStream(socket))
{
foreach (var item in result)
{
var ms = new MemoryStream();
new BinaryFormatter().Serialize(ms, item);
byte[] buffer = ms.ToArray();
SerDe.Write(ns, buffer.Length);
SerDe.Write(ns, buffer);
}
}
});
return((listener.LocalEndpoint as IPEndPoint).Port);
});
_mockRddProxy.Setup(m => m.RDDCollector).Returns(new RDDCollector());
_mockSparkContextProxy.Setup(m => m.CreateCSharpRdd(It.IsAny <IRDDProxy>(), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >(),
It.IsAny <List <string> >(), It.IsAny <bool>(), It.IsAny <List <Broadcast> >(), It.IsAny <List <byte[]> >()))
.Returns <IRDDProxy, byte[], Dictionary <string, string>, List <string>, bool, List <Broadcast>, List <byte[]> >(
(prefvJavaRddReference, command, environmentVariables, cSharpIncludes, preservePartitioning, broadcastVariables, accumulator) =>
{
IEnumerable <dynamic> input = result ?? (new[] {
"The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog",
"The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog",
"The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog",
"The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog",
"The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog The quick brown fox jumps over the lazy dog",
"The quick brown fox jumps over the lazy dog",
"The quick brown fox jumps over the lazy dog",
"The quick brown fox jumps over the lazy dog",
"The quick brown fox jumps over the lazy dog",
"The quick brown fox jumps over the lazy dog",
"The dog lazy"
}).AsEnumerable();
var formatter = new BinaryFormatter();
using (MemoryStream s = new MemoryStream(command))
{
int rddId = SerDe.ReadInt(s);
int stageId = SerDe.ReadInt(s);
int partitionId = SerDe.ReadInt(s);
SerDe.ReadString(s);
SerDe.ReadString(s);
CSharpWorkerFunc workerFunc = (CSharpWorkerFunc)formatter.Deserialize(new MemoryStream(SerDe.ReadBytes(s)));
var func = workerFunc.Func;
result = func(default(int), input);
}
if (result.FirstOrDefault() is byte[] && (result.First() as byte[]).Length == 8)
{
result = result.Where(e => (e as byte[]).Length != 8).Select(e => formatter.Deserialize(new MemoryStream(e as byte[])));
}
return(_mockRddProxy.Object);
});
_streamingContext = new StreamingContext(new SparkContext("", ""), 1000);
}
public void Accept()
{
Console.WriteLine("Waiting for MotionBuilder...");
Socket sock = l.AcceptSocket();
lock (streamLock)
{
s = new NetworkStream(sock);
}
Console.WriteLine("Connected to MotionBuilder.");
try
{
while (true)
{
// All MotionBuilder OR plugin client commands are 4-byte packets.
byte[] packet = new byte[4];
s.Read(packet, 0, 4);
if (packet[0] != ORProtocol.BYTE_HEADER || packet[3] != ORProtocol.BYTE_TRAILER)
{
throw new InvalidOperationException("The client has closed the connection.");
}
switch (packet[1])
{
case ORProtocol.BYTE_STREAM_STOP:
Console.WriteLine("Client requested stream stop.");
lock (streamLock)
{
if (streaming)
{
streaming = false;
Console.WriteLine("--> Stream stopped.");
}
else
{
Console.WriteLine("--> Stream already stopped.");
}
}
break;
case ORProtocol.BYTE_STREAM_START:
Console.WriteLine("Client requested stream start.");
lock (streamLock)
{
if (!streaming)
{
streaming = true;
Console.WriteLine("--> Stream started.");
}
else
{
Console.WriteLine("--> Stream already started.");
}
}
break;
case ORProtocol.BYTE_INFO_PACKET:
Console.WriteLine("Client requested server info.");
// Write back a 4-byte packet.
byte[] response = new byte[] { ORProtocol.BYTE_HEADER,
ORProtocol.BYTE_INFO_PACKET,
0x0,
ORProtocol.BYTE_TRAILER };
s.Write(response, 0, 4);
Console.WriteLine("--> Response sent.");
break;
default:
throw new Exception();
}
}
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
catch (Exception e)
{
Console.WriteLine("There was a fatal error, and the socket must be closed: " + e.Message);
}
lock (streamLock)
{
streaming = false;
s.Close();
s = null;
sock.Close();
}
}
public void Start()
{
listener.Start();
status = StatusEnum.Connected;
Message message = null;
Console.WriteLine("Start SMTP Server");
try
{
socket = listener.AcceptSocket();
networkStream = new NetworkStream(socket, FileAccess.ReadWrite, true);
WriteLine(string.Format("220 Welcome {0}, SMTP Server.", ((IPEndPoint)socket.RemoteEndPoint).Address));
while (socket.Connected)
{
string data = this.Read(lineTerminator);
if (data == null)
{
break;
}
else
{
if (data.StartsWith("QUIT", StringComparison.InvariantCultureIgnoreCase))
{
WriteLine("221 Good bye");
throw new Exception("Restart SMTP Server");
}
else if (data.StartsWith("EHLO", StringComparison.InvariantCultureIgnoreCase) || data.StartsWith("HELO", StringComparison.InvariantCultureIgnoreCase))
{
this.WriteGreeting(data.Substring(4).Trim());
status = StatusEnum.Identified;
}
else if (status < StatusEnum.Identified)
{
this.WriteError(ErrorEnum.BadCommandSequence, "Expected HELO <Your Name>");
}
else
{
if (data.StartsWith("MAIL", StringComparison.InvariantCultureIgnoreCase))
{
if (status != StatusEnum.Identified && status != StatusEnum.Data)
{
this.WriteError(ErrorEnum.BadCommandSequence, "Command out of sequence");
}
else
{
// create a new message
message = new Message();
message.From = TextFunctions.Tail(data, ":");
status = StatusEnum.Mail;
this.WriteOk();
}
}
else if (data.StartsWith("RCPT", StringComparison.InvariantCultureIgnoreCase))
{
if (status != StatusEnum.Mail && status != StatusEnum.Recipient)
{
this.WriteError(ErrorEnum.BadCommandSequence, "Command out of sequence");
}
else
{
message.To.Add(TextFunctions.Tail(data, ":"));
status = StatusEnum.Recipient;
this.WriteOk();
}
}
else if (data.StartsWith("DATA", StringComparison.InvariantCultureIgnoreCase))
{
// request data
this.WriteSendData();
message.Data = this.Read(dataTerminator);
// Remove message end tag
message.Data = message.Data.Replace(dataTerminator, string.Empty);
SaveMessage(message);
message = null;
status = StatusEnum.Data;
this.WriteOk();
}
else
{
this.WriteError(ErrorEnum.CommandNotImplemented, "Command not implemented");
}
}
}
}
}
catch (Exception e)
{
Debug(e.Message);
Dispose();
Start();
}
}
static void Main(string[] args)
{
string output;
System.IO.Ports.SerialPort serialPort1;
try
{
//Program p = new Program();
//p.establishConnection();
String s1 = Dns.GetHostEntry(Dns.GetHostName()).AddressList.FirstOrDefault(ip => ip.AddressFamily == AddressFamily.InterNetwork).ToString();
IPAddress ipAd = IPAddress.Parse(s1);
// use local m/c IP address, and
// use the same in the client
/* Initializes the Listener */
TcpListener myList = new TcpListener(ipAd, 4444);
/* Start Listeneting at the specified port */
myList.Start();
Console.WriteLine("The server is running at port 4444...");
Console.WriteLine("The local End point is :" +
myList.LocalEndpoint);
Console.WriteLine("Waiting for a connection.....");
m:
Socket s = myList.AcceptSocket();
Console.WriteLine("Connection accepted from " + s.RemoteEndPoint);
byte[] b = new byte[100];
int k = s.Receive(b);
char cc = ' ';
string test = null;
Console.WriteLine("Recieved...");
for (int i = 0; i < k - 1; i++)
{
//Console.Write(Convert.ToChar(b[i]));
cc = Convert.ToChar(b[i]);
test += cc.ToString();
Console.Write(cc.ToString());
}
//switch (test)
//{
// case "1":
// break;
//}
Program p = new Program();
p.establishConnection(test);
switch ("df")
{
case "Lock_all": Console.WriteLine("\ncaught Hey");
//Program p = new Program();
p.establishConnection("l");
break;
case "lock_selec":
//Program p = new Program();
p.establishConnection("u");
break;
default:
Console.WriteLine("\ncaught something else");
//Process cmd = new Process();
//cmd.StartInfo.FileName = "cmd.exe";
//cmd.StartInfo.RedirectStandardInput = true;
//cmd.StartInfo.RedirectStandardOutput = true;
//cmd.StartInfo.CreateNoWindow = true;
//cmd.StartInfo.UseShellExecute = false;
//cmd.Start();
//cmd.StandardInput.WriteLine("py ball_tracking.py");
//cmd.StandardInput.Flush();
//string output = cmd.StandardOutput.ReadToEnd();
//cmd.StandardInput.Close();
//cmd.WaitForExit();
//Console.Write("hey");
//Console.WriteLine(cmd.StandardOutput.ReadToEnd());
// Console.WriteLine("got you");
//System.Diagnostics.Process process = new System.Diagnostics.Process();
//process.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal;
//process.StartInfo.FileName = "cmd.exe";
//process.StartInfo.Arguments = "/c py ball_tracking.py";
//process.Start();
//output = process.StandardOutput.ToString();
break;
}
ASCIIEncoding asen = new ASCIIEncoding();
//Console.WriteLine(output);
//if(output=="ball")
//{
// s.Send(asen.GetBytes("threat"));
// Console.WriteLine("\nSent Acknowledgement");
// p.establishConnection("l");
//}
s.Close();
/* clean up */
goto m;
s.Close();
myList.Stop();
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine("Error..... " + e.StackTrace);
}
}
private bool ProcessClientPackets()
{
bool received = false;
lock (listenerLockObj)
{
Buffer buffer;
time = DateTime.UtcNow.Ticks / 10000;
// Stop the listener if the port is 0 (MakePrivate() was called)
if (listenerPort == 0)
{
if (listener != null)
{
listener.Stop();
listener = null;
}
}
else
{
// Add all pending connections
while (listener != null && listener.Pending())
{
AddClient(listener.AcceptSocket());
}
}
#if DEBUG
Debug.Log("[Listener] - Running ThreadProcessClientPackets. Clients: " + clients.size);
#endif
// Process player connections next
for (int i = 0; i < clients.size;)
{
TcpProtocol client = clients[i];
// Process up to 100 packets at a time
for (int b = 0; b < 100 && client.ReceivePacket(out buffer); ++b)
{
if (buffer.size > 0)
{
if (multiThreaded)
{
try
{
if (ProcessClientPacket(buffer, client))
{
received = true;
}
}
catch (Exception ex)
{
Debug.LogException(ex);
Error("(Listener ThreadFunction Process) " + ex.Message + "\n" + ex.StackTrace);
RemoveClient(client);
}
}
else
{
if (ProcessClientPacket(buffer, client))
{
received = true;
}
}
}
buffer.Recycle();
}
// Time out -- disconnect this player
// if (client.Status == ConnectionStatus.Connected)
// {
// // If the player doesn't send any packets in a while, disconnect him
// if (client.TimeoutTime > 0 && client.LastReceivedTime + client.TimeoutTime < time)
// {
//#if DEBUG
// UnityEngine.Debug.LogWarning("[TcpProtocol:StopListener()] - Client " + client.IpAddress + " has timed out");
//#endif
// RemoveClient(client);
// continue;
// }
// }
// else if (client.LastReceivedTime + 2000 < time)
// {
//#if DEBUG
// UnityEngine.Debug.LogWarning("[TcpProtocol:StopListener()] - Client " + client.IpAddress + " has timed out");
//#endif
// RemoveClient(client);
// continue;
// }
++i;
}
}
return(received);
}
public static void RunSocketServer()
{
servidor.Start();
while (true)
{
Socket conexao = servidor.AcceptSocket();
socketStream = new NetworkStream(conexao);
escreve = new BinaryWriter(socketStream);
ler = new BinaryReader(socketStream);
StringBuilder stringBuilder = new StringBuilder();
while (true)
{
try
{
byte[] message = ler.ReadBytes(1);
Console.Write($"{System.Text.Encoding.Default.GetString(message)}");
stringBuilder.Append(System.Text.Encoding.Default.GetString(message));
if (BitConverter.ToString(message) == "0A")
{
string msg = stringBuilder.ToString();
stringBuilder.Clear();
Console.Write($"msg = {msg}");
if (msg.StartsWith("WX,ProgramNo="))
{
System.Threading.Thread.Sleep(500);
byte[] bytes = Encoding.ASCII.GetBytes("WX,OK\r");
escreve.Write(bytes);
}
else if (msg.StartsWith("WX,PRG="))
{
System.Threading.Thread.Sleep(500);
byte[] bytes = Encoding.ASCII.GetBytes("WX,OK\r");
escreve.Write(bytes);
}
else if (msg.StartsWith("WX,StartMarking"))
{
System.Threading.Thread.Sleep(3000);
byte[] bytes = Encoding.ASCII.GetBytes("WX,OK\r");
escreve.Write(bytes);
}
else if (msg.StartsWith("WX,ErrorClear"))
{
System.Threading.Thread.Sleep(1000);
byte[] bytes = Encoding.ASCII.GetBytes("WX,OK\r");
escreve.Write(bytes);
}
else if (msg.StartsWith("RX,PRG="))
{
countRX++;
System.Threading.Thread.Sleep(100);
byte[] bytes = Encoding.ASCII.GetBytes($"RX,OK,Title {countRX}\r");
escreve.Write(bytes);
}
escreve.Close();
ler.Close();
socketStream.Close();
conexao.Close();
break;
}
}
catch (Exception ex)
{
Console.WriteLine($"ex.Message = {ex.Message}");
//break;
escreve.Close();
ler.Close();
socketStream.Close();
conexao.Close();
break;
}
//System.Threading.Thread.Sleep(100);
}
}
}
private void EventText(TcpListener e)
{
int x = GetSocket();
if (x >= 0)
{
Socs[x] = new HttpConnection()
{
Soc = e.AcceptTcpClient(),
Index = x,
_Request = "",
_Headers = null,
};
List <string> Headers = new List <string>();
using (StreamReader R = new StreamReader(Socs[x].Soc.GetStream()))
{
while (Socs[x].Soc.Available > 0)
{
string Line = R.ReadLine();
if (Line.StartsWith("GET ") || Line.StartsWith("POST ") || Line.StartsWith("HEAD ") ||
Line.StartsWith("PUT ") || Line.StartsWith("DELETE ") || Line.StartsWith("CONNECT ") ||
Line.StartsWith("OPTIONS ") || Line.StartsWith("TRACE "))
{
Socs[x]._Request = Line;
}
else
{
Headers.Add(Line);
}
}
}
//read request
Socs[x]._Headers = Headers.ToArray();
Headers = null;//move Headers to Socs then remove unnecessary data
if (StringHelpers.IsWhiteSpaceOrNull(Socs[x]._Request))
{
if (Socs[x].Soc.Connected)
{
Socs[x].Soc.Client.Send(ResponseEncoding.GetBytes(
$"HTTP/1.1 400 Bad Request/Invalid Request Format\r\nDate: {DateTime.Today}\r\nContent-Length: 0\r\nContent-Type: text/html\r\nConnection: Closed\r\n\r\n"));
}
Socs[x].Soc.Close();
Socs[x]._Request = null;
Socs[x]._Headers = null;//cleanup
Socs[x].Index = 0;
Socs[x].Soc = null;
}
else
{
RequestEvent.Invoke(this, Socs[x]);
}
if (AutoClose && Socs[x].Soc.Connected)
{
Close(Socs[x]);
}
}
else
{
e.AcceptSocket().Disconnect(false);//auto close conn
}
//becuse max connections has been reached
}
private void FileRecive()
{
//Создаем Listener на порт "по умолчанию"
TcpListener Listen = new TcpListener(1572);
//Начинаем прослушку
Listen.Start();
//и заведем заранее сокет
Socket ReceiveSocket;
while (true)
{
try
{
string name;
//Пришло сообщение
ReceiveSocket = Listen.AcceptSocket();
Byte[] Receive = new Byte[256];
//Читать сообщение будем в поток
using (MemoryStream MessageR = new MemoryStream())
{
//Количество считанных байт
Int32 ReceivedBytes;
Int32 Firest256Bytes = 0;
String FilePath = "";
do
{//Собственно читаем
ReceivedBytes = ReceiveSocket.Receive(Receive, Receive.Length, 0);
//Разбираем первые 256 байт
if (Firest256Bytes < 256)
{
Firest256Bytes += ReceivedBytes;
Byte[] ToStr = Receive;
//Учтем, что может возникнуть ситуация, когда они не могу передаться "сразу" все
if (Firest256Bytes > 256)
{
Int32 Start = Firest256Bytes - ReceivedBytes;
Int32 CountToGet = 256 - Start;
Firest256Bytes = 256;
//В случае если было принято >256 байт (двумя сообщениями к примеру)
//Остаток (до 256) записываем в "путь файла"
ToStr = Receive.Take(CountToGet).ToArray();
//А остальную часть - в будующий файл
Receive = Receive.Skip(CountToGet).ToArray();
MessageR.Write(Receive, 0, ReceivedBytes);
}
//Накапливаем имя файла
FilePath += Encoding.Default.GetString(ToStr);
}
else
{
//и записываем в поток
MessageR.Write(Receive, 0, ReceivedBytes);
}
//Читаем до тех пор, пока в очереди не останется данных
} while (ReceivedBytes == Receive.Length);
//Убираем лишние байты
String resFilePath = FilePath.Substring(0, FilePath.IndexOf('\0'));
MessageBox.Show(resFilePath);
using (var File = new FileStream(resFilePath, FileMode.Create))
{//Записываем в файл
File.Write(MessageR.ToArray(), 0, MessageR.ToArray().Length);
}//Уведомим пользователя
//ChatBox.BeginInvoke(AcceptDelegate, new object[] { "Получено: " + resFilePath, ChatBox });
name = resFilePath;
}
}
catch (System.Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
public void StartServer()
{
try
{
IPAddress ipAd = System.Net.IPAddress.Parse(IPAddress);
Console.WriteLine("Marvellous Web : Server started ... ");
listener = new TcpListener(ipAd, PortNumber);
listener.Start();
Console.WriteLine("Marvellous Web : Server started at port : " + PortNumber);
Console.WriteLine("Marvellous Web : The local End point is :" + listener.LocalEndpoint);
while (true)
{
// Accepts the pending client connection and returns a socket for communciation.
Console.WriteLine("Marvellous Web : Server Waiting for a connection ....");
socket = listener.AcceptSocket();
Console.WriteLine("Marvellous Web : Connection Established with client....");
Console.WriteLine("Marvellous Web : Connection accepted from " + socket.RemoteEndPoint);
bool connection = true;
while (connection)
{
string receiveMsg = ReceiveMessage();
switch (receiveMsg)
{
case "LOGIN":
LoginProcess();
break;
case "ROOT_FOLDER":
SendRootFolders();
break;
case "GET_FOLDER_CONTAIN":
SendFolderContain();
break;
case "BACK":
DisplayParentContent();
break;
case "SEARCH":
SearchFile();
break;
case "SEND_CUR_PATH":
SendCurrentPath();
break;
case "CREATE_FOLDER":
CreateFolderInCurrentDirectory();
break;
case "UPLOAD":
ReceiveFile();
break;
case "DOWNLOAD":
SendFile();
break;
case "EXIT":
connection = false;
socket.Close();
break;
default:
break;
}
}
}
}
catch (Exception e)
{
Console.WriteLine("Marvellous Web : Exception - " + e.StackTrace);
SendMessage("EXIT");
}
finally
{
Console.WriteLine("\nMarvellous Web : Deallocating all resources ...");
if (socket != null)
{
socket.Close();
}
if (listener != null)
{
listener.Stop();
}
}
}
//This method Accepts new connection and
//First it receives the welcome massage from the client,
//Then it sends the Current date time to the Client.
public void StartListen()
{
int iStartPos = 0;
String sRequest;
String sDirName;
String sRequestedFile;
String sErrorMessage;
String sLocalDir;
String sMyWebServerRoot = "C:\\MyWebServerRoot\\";
String sPhysicalFilePath = "";
String sFormattedMessage = "";
String sResponse = "";
while (true)
{
//Accept a new connection
Socket mySocket = myListener.AcceptSocket();
Console.WriteLine("Socket Type " + mySocket.SocketType);
if (mySocket.Connected)
{
Console.WriteLine("\nClient Connected!!\n==================\nCLient IP {0}\n",
mySocket.RemoteEndPoint);
//make a byte array and receive data from the client
Byte[] bReceive = new Byte[1024];
int i = mySocket.Receive(bReceive, bReceive.Length, 0);
//Convert Byte to String
string sBuffer = Encoding.ASCII.GetString(bReceive);
//At present we will only deal with GET type
if (sBuffer.Substring(0, 3) != "GET")
{
Console.WriteLine("Only Get Method is supported..");
mySocket.Close();
return;
}
// Look for HTTP request
iStartPos = sBuffer.IndexOf("HTTP", 1);
// Get the HTTP text and version e.g. it will return "HTTP/1.1"
string sHttpVersion = sBuffer.Substring(iStartPos, 8);
// Extract the Requested Type and Requested file/directory
sRequest = sBuffer.Substring(0, iStartPos - 1);
//Replace backslash with Forward Slash, if Any
sRequest.Replace("\\", "/");
//If file name is not supplied add forward slash to indicate
//that it is a directory and then we will look for the
//default file name..
if ((sRequest.IndexOf(".") < 1) && (!sRequest.EndsWith("/")))
{
sRequest = sRequest + "/";
}
//Extract the requested file name
iStartPos = sRequest.LastIndexOf("/") + 1;
sRequestedFile = sRequest.Substring(iStartPos);
//Extract The directory Name
sDirName = sRequest.Substring(sRequest.IndexOf("/"), sRequest.LastIndexOf("/") - 3);
/////////////////////////////////////////////////////////////////////
// Identify the Physical Directory
/////////////////////////////////////////////////////////////////////
if (sDirName == "/")
{
sLocalDir = sMyWebServerRoot;
}
else
{
//Get the Virtual Directory
sLocalDir = GetLocalPath(sMyWebServerRoot, sDirName);
}
Console.WriteLine("Directory Requested : " + sLocalDir);
//If the physical directory does not exists then
// dispaly the error message
if (sLocalDir.Length == 0)
{
sErrorMessage = "<H2>Error!! Requested Directory does not exists</H2><Br>";
//sErrorMessage = sErrorMessage + "Please check data\\Vdirs.Dat";
//Format The Message
SendHeader(sHttpVersion, "", sErrorMessage.Length, " 404 Not Found", ref mySocket);
//Send to the browser
SendToBrowser(sErrorMessage, ref mySocket);
mySocket.Close();
continue;
}
/////////////////////////////////////////////////////////////////////
// Identify the File Name
/////////////////////////////////////////////////////////////////////
//If The file name is not supplied then look in the default file list
if (sRequestedFile.Length == 0)
{
// Get the default filename
sRequestedFile = GetTheDefaultFileName(sLocalDir);
if (sRequestedFile == "")
{
sErrorMessage = "<H2>Error!! No Default File Name Specified</H2>";
SendHeader(sHttpVersion, "", sErrorMessage.Length, " 404 Not Found", ref mySocket);
SendToBrowser(sErrorMessage, ref mySocket);
mySocket.Close();
return;
}
}
/////////////////////////////////////////////////////////////////////
// Get TheMime Type
/////////////////////////////////////////////////////////////////////
String sMimeType = GetMimeType(sRequestedFile);
//Build the physical path
sPhysicalFilePath = sLocalDir + sRequestedFile;
Console.WriteLine("File Requested : " + sPhysicalFilePath);
if (File.Exists(sPhysicalFilePath) == false)
{
sErrorMessage = "<H2>404 Error! File Does Not Exists...</H2>";
SendHeader(sHttpVersion, "", sErrorMessage.Length, " 404 Not Found", ref mySocket);
SendToBrowser(sErrorMessage, ref mySocket);
Console.WriteLine(sFormattedMessage);
}
else
{
int iTotBytes = 0;
sResponse = "";
FileStream fs = new FileStream(sPhysicalFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
// Create a reader that can read bytes from the FileStream.
BinaryReader reader = new BinaryReader(fs);
byte[] bytes = new byte[fs.Length];
int read;
while ((read = reader.Read(bytes, 0, bytes.Length)) != 0)
{
// Read from the file and write the data to the network
sResponse = sResponse + Encoding.ASCII.GetString(bytes, 0, read);
iTotBytes = iTotBytes + read;
}
reader.Close();
fs.Close();
SendHeader(sHttpVersion, sMimeType, iTotBytes, " 200 OK", ref mySocket);
SendToBrowser(bytes, ref mySocket);
//mySocket.Send(bytes, bytes.Length,0);
}
mySocket.Close();
}
}
}
static void Main(string[] args)
{
int points;
double fx;
string entrada, lgr, cubic, result;
string[] array1;
List<double> x = new List<double>();
List<double> y = new List<double>();
IPAddress ip = IPAddress.Parse("127.0.0.1");
TcpListener tcpListener = new TcpListener(ip, 5050);
tcpListener.Start();
Socket serverSock = tcpListener.AcceptSocket();
if (serverSock.Connected)
{
NetworkStream con = new NetworkStream(serverSock);
StreamWriter wr = new StreamWriter(con);
StreamReader rd = new StreamReader(con);
entrada = (rd.ReadLine()); // lagrange|cubic|4|5|1|4|7|8|4|7|1|9| FORMATO DE ENTRADA
array1= entrada.Split('|'); // llamando metodo split
List<string> list = new List<string>(array1); // Constructor de listas
result = Convert.ToString(list.Count());
lgr = list[0];
cubic = list[1];
points = int.Parse(list[2]);
fx = double.Parse(list[3]);
for (int i = 4; i < (points + 4); i++)
{
x.Add(double.Parse(list[i]));
}
for (int i = (4 + points); i < (4 + (points * 2)); i++)
{
y.Add(double.Parse(list[i]));
}
list.Clear();
if (lgr == "lagrange")
{
Lagrange lg = new Lagrange();
list.Add(Convert.ToString(lg.lagrange_metodo(fx, x, y)));
}
else
list.Add("N/A");
if (cubic=="cubic")
{
CS_Spline spl = new CS_Spline();
list.Add(Convert.ToString(spl.Cubic_Spline(fx, x, y)));
list.Add(spl.formula);
}
else
{
list.Add("N/A");
list.Add("N/A");
}
StringBuilder builder = new StringBuilder();
foreach (string value in list) // Loop through all strings
{
builder.Append(value).Append("|"); // Append string to StringBuilder
}
result = builder.ToString();
Console.WriteLine(result);
wr.WriteLine(result);
wr.Flush();
rd.Close();
wr.Close();
con.Close();
serverSock.Close();
}
else
{
Console.WriteLine("Fallo en la conexion");
}
}
public void StartListen()
{
int iStartPos = 0;
String sRequest;
String sDirName;
String sRequestedFile;
String sErrorMessage;
String sLocalDir;
String sMyWebServerRoot = "C:\\scoreboard\\";
String sPhysicalFilePath = "";
String sResponse = "";
get_spreadsheet();
while (true)
{
//Accept a new connection
Socket mySocket = myListener.AcceptSocket();
if (mySocket.Connected)
{
//make a byte array and receive data from the client
Byte[] bReceive = new Byte[1024];
int i = mySocket.Receive(bReceive, bReceive.Length, SocketFlags.None);
int headlength;
Dictionary <string, string> postpairs = new Dictionary <string, string>();
//Convert Byte to String
string sBuffer = Encoding.ASCII.GetString(bReceive);
//At present we will only deal with GET type
if (sBuffer.Substring(0, 3) != "GET" && sBuffer.Substring(0, 4) != "POST")
{
log("Only Get and Post Method is supported, instead I got this:");
log(sBuffer);
mySocket.Close();
return;
}
if (sBuffer.Substring(0, 4) == "POST")
{
headlength = post;
// create dictionary of POST pairs
int start = sBuffer.Length - 1;
while (sBuffer[start] != '\n')
{
start--;
}
start++;
string[] pairs = sBuffer.Substring(start).Split('&');
foreach (string pairfound in pairs)
{
string[] splits = pairfound.Split('=');
postpairs.Add(splits[0], splits[1]);
}
foreach (KeyValuePair <string, string> kvp in postpairs)
{
log("got pair: " + kvp.Key + " = " + kvp.Value);
}
}
else
{
headlength = get;
}
// Look for HTTP request
iStartPos = sBuffer.IndexOf("HTTP", 1);
// Get the HTTP text and version e.g. it will return "HTTP/1.1"
string sHttpVersion = sBuffer.Substring(iStartPos, 8);
// Extract the Requested Type and Requested file/directory
sRequest = sBuffer.Substring(0, iStartPos - 1);
//Replace backslash with Forward Slash, if Any
sRequest.Replace("\\", "/");
//If file name is not supplied add forward slash to indicate
//that it is a directory and then we will look for the
//default file name..
if ((sRequest.IndexOf(".") < 1) && (!sRequest.EndsWith("/")))
{
sRequest = sRequest + "/";
}
//Extract the requested file name
iStartPos = sRequest.LastIndexOf("/") + 1;
sRequestedFile = sRequest.Substring(iStartPos);
//Extract The directory Name
sDirName = sRequest.Substring(sRequest.IndexOf("/"), sRequest.LastIndexOf("/") - headlength);
// do something fancy if the requested file is important
if (sRequestedFile.Equals("login.dpi"))
{
if (parse_login(postpairs))
{
sRequestedFile = "choose.dpi";
}
}
if (sRequestedFile.Equals("display.dpi"))
{
sRequestedFile = postpairs["choice"] + ".dpi";
log(postpairs["choice"] + " has joined");
}
if (sRequestedFile.Equals("judge.dpi"))
{
sRequestedFile = calculate_result(postpairs);
}
if (sRequestedFile.Equals("screen.dpi"))
{
postpairs = show_results();
headlength = post;
}
/////////////////////////////////////////////////////////////////////
// Identify the Physical Directory
/////////////////////////////////////////////////////////////////////
if (sDirName == "/")
{
sLocalDir = sMyWebServerRoot;
}
else
{
//Get the Virtual Directory
sLocalDir = GetLocalPath(sMyWebServerRoot, sDirName);
}
//If the physical directory does not exists then
// dispaly the error message
if (sLocalDir.Length == 0)
{
sErrorMessage = "<H2>Error!! Requested Directory does not exists</H2><Br>";
//sErrorMessage = sErrorMessage + "Please check data\\Vdirs.Dat";
//Format The Message
SendHeader(sHttpVersion, "", sErrorMessage.Length, " 404 Not Found", ref mySocket);
//Send to the browser
SendToBrowser(sErrorMessage, ref mySocket);
mySocket.Close();
continue;
}
/////////////////////////////////////////////////////////////////////
// Identify the File Name
/////////////////////////////////////////////////////////////////////
//If The file name is not supplied then look in the default file list
if (sRequestedFile.Length == 0)
{
// Get the default filename
sRequestedFile = GetTheDefaultFileName(sLocalDir);
if (sRequestedFile == "")
{
sErrorMessage = "<H2>Error!! No Default File Name Specified</H2>";
SendHeader(sHttpVersion, "", sErrorMessage.Length, " 404 Not Found", ref mySocket);
SendToBrowser(sErrorMessage, ref mySocket);
mySocket.Close();
return;
}
}
//////////////////////////////////////////////////
// Get TheMime Type
//////////////////////////////////////////////////
String sMimeType = GetMimeType(sRequestedFile);
//Build the physical path
sPhysicalFilePath = sLocalDir + sRequestedFile;
if (File.Exists(sPhysicalFilePath) == false)
{
sErrorMessage = "<H2>404 Error! File Does Not Exists...</H2>";
SendHeader(sHttpVersion, "", sErrorMessage.Length, " 404 Not Found", ref mySocket);
SendToBrowser(sErrorMessage, ref mySocket);
}
else
{
int iTotBytes = 0;
sResponse = "";
// open the file
FileStream fs = new FileStream(sPhysicalFilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
// Create a reader that can read bytes from the FileStream
BinaryReader reader = new BinaryReader(fs);
byte[] bytes = new byte[fs.Length];
int read;
// Read from the file and write the data to the network
while ((read = reader.Read(bytes, 0, bytes.Length)) != 0)
{
sResponse += Encoding.ASCII.GetString(bytes, 0, read);
iTotBytes += read;
}
reader.Close();
fs.Close();
// parse the file if post
if (headlength == post)
{
string body = sResponse;
foreach (KeyValuePair <string, string> kvp in postpairs)
{
if (kvp.Value.Length > 0)
{
body = body.Replace("#" + kvp.Key + "#", kvp.Value);
}
}
byte[] newbytes = new byte[body.Length * sizeof(char)];
newbytes = Encoding.ASCII.GetBytes(body);
bytes = newbytes;
iTotBytes = newbytes.Length;
}
SendHeader(sHttpVersion, sMimeType, iTotBytes, " 200 OK", ref mySocket);
SendToBrowser(bytes, ref mySocket);
}
mySocket.Close();
}
}
}
// set up connection for client to play Hangman
public void GetGuesses()
{
// start listening for connections
IPAddress local = IPAddress.Parse( "127.0.0.1" );
TcpListener listener = new TcpListener( local, 50000 );
listener.Start();
// accept client connection and get NetworkStream to communicate with client
Socket connection = listener.AcceptSocket();
DisplayMessage( "Connection received\r\n" );
NetworkStream socketStream = new NetworkStream( connection );
// create reader and writer for client
BinaryWriter writer = new BinaryWriter( socketStream );
BinaryReader reader = new BinaryReader( socketStream );
Random randomWord = new Random();
int wordNumber = randomWord.Next(297);
string word = "";
StreamReader wordReader = new StreamReader("words.txt");
for (int i = 0; i <= wordNumber; i++)
word = wordReader.ReadLine();
DisplayMessage("The secret word is: " + word + "\r\n");
writer.Write(word.Length);
int numberWrong = 0;
int numberLettersLeft = word.Length;
int numberCharsInWord = 0;
char guess;
while (numberLettersLeft > 0 && numberWrong < 5)
{
numberCharsInWord = 0;
guess = reader.ReadChar();
DisplayMessage("The User guessed " + guess + "\r\n");
for (int i = 0; i < word.Length; i++)
{
if (word[i] == guess)
{
numberCharsInWord++;
}
}
writer.Write(numberCharsInWord);
if (numberCharsInWord != 0)
{
for (int i = 0; i < word.Length; i++)
{
if (word[i] == guess)
{
writer.Write(i);
numberLettersLeft--;
}
}
}
else
{
numberWrong++;
}
}//endwhile
if (numberLettersLeft != 0 && numberWrong == 5)
{
writer.Write(word);
}
connection.Close();
socketStream.Close();
reader.Close();
writer.Close();
} // end method GetGuesses
public Socket GetClientSocket()
{
return(listener.AcceptSocket());
}
static void Main()
{
Console.WriteLine("Program Started");
TcpListener socket;
try
{
// Bind a interface to our socket
Int32 port = 6789;
IPAddress localAddr = IPAddress.Parse("127.0.0.1");
socket = new TcpListener(localAddr, port);
// Start listening for client requests
socket.Start(1);
Console.WriteLine($"Server is listening for requests at 127.0.0.1:6789");
while (true)
{
// Accept an incoming connection
Socket conn = socket.AcceptSocket();
Console.WriteLine("Incoming connection accepted.");
string next = "Enter a command: \n";
while (true)
{
// Send and receive data from the client
string response = SendReceive(conn, next);
// if the client says "STOP" close the connection
if (response == "STOP")
{
break;
}
// the args recieved
string[] args = response.Split(' ');
try
{
switch (args[0])
{
case "GET":
next = GET(args[1]);
break;
case "SET":
next = SET(args[1], args[2]);
break;
case "CLEAR":
next = CLEAR();
break;
default:
throw new IndexOutOfRangeException("command not found");
}
}
catch (IndexOutOfRangeException e)
{
string errormessage = (e.Message == "command not found" ? $"command '{args[0]}' not found" : "not enough arguments passed");
next = $"ERROR {errormessage}\n";
}
}
// Close the connection to the client
conn.Close();
}
}
catch (SocketException e)
{
Console.WriteLine($"Socket Exception: {e}");
}
}
private Socket GetDataSocket()
{
Socket DataSocket = null;
try
{
if (DataTransferEnabled)
{
int Count = 0;
while (!DataListener.Pending())
{
Thread.Sleep(1000);
Count++;
// Time out after 30 seconds
if (Count > 29)
{
SendMessage("425 Data Connection Timed out");
return(null);
}
}
DataSocket = DataListener.AcceptSocket();
SendMessage("125 Connected, Starting Data Transfer.");
}
else
{
SendMessage("150 Connecting.\r\n");
DataSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
bool suces = false;
for (int i = 0; i < ClientEndPoints.Length; i++)
{
try
{
DataSocket.Connect(ClientEndPoints[i]);
suces = true;
SendMessage("125 Connected, Starting Data Transfer.");
break;
}
catch { }
}
if (!suces)
{
throw new Exception();
}
}
}
catch
{
SendMessage("425 Can't open data connection.");
return(null);
}
finally
{
if (DataListener != null)
{
DataListener.Stop();
DataListener = null;
GC.Collect();
}
}
DataTransferEnabled = false;
return(DataSocket);
}
static void Main(string[] args)
{
string _ip = "127.0.0.1";
int _port = 6969;
if (!Directory.Exists("txt"))
{
Directory.CreateDirectory("txt");
}
try
{
IPAddress ipAddress = IPAddress.Parse(_ip);
TcpListener listener = new TcpListener(ipAddress, _port);
title = string.Format("TCP {0}:{1}", _ip, _port);
Console.Title = title;
listener.Start();
while (true)
{
Socket client = listener.AcceptSocket();
var childSocketThread = new Thread(new ParameterizedThreadStart((o) =>
{
int total = 0;
int k = 0;
int len = 0;
byte[] buffer = new byte[CHUNK_SIZE];
var socket = (Socket)o;
string file_name = "";
using (var stream = new MemoryStream())
{
byte[] actual;
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
while ((len = socket.Receive(buffer, buffer.Length, SocketFlags.None)) > 0)
{
total += len;
if (k == 0)
{
if (len < 255)
{
Console.WriteLine("Buffer invalid ...");
break;
}
file_name = Encoding.ASCII.GetString(buffer, 0, 255).Trim().ToUpper();
Console.WriteLine("-> " + file_name + " buffering ...");
actual = new byte[len - 255];
Buffer.BlockCopy(buffer, 255, actual, 0, len - 255);
}
else
{
actual = new byte[len];
Buffer.BlockCopy(buffer, 0, actual, 0, len);
}
if (k % 5 == 0)
{
Console.Title = String.Format("{0:N0} MB", total / _1MB);
}
stream.Write(actual, 0, actual.Length);
k++;
}
if (file_name.Length > 0)
{
string file = "txt\\" + file_name + ".txt";
if (File.Exists(file))
{
File.Delete(file);
}
//var fileStream = File.Create(file);
//stream.Seek(0, SeekOrigin.Begin);
//stream.CopyTo(fileStream);
//fileStream.Close();
int fileSize = (int)stream.Length;
using (FileStream fileStream = new FileStream(file, FileMode.Create, System.IO.FileAccess.Write))
{
stream.Seek(0, SeekOrigin.Begin);
byte[] bytes = new byte[fileSize];
stream.Read(bytes, 0, fileSize);
fileStream.Write(bytes, 0, fileSize);
stream.Close();
}
}
stopwatch.Stop();
TimeSpan ts = stopwatch.Elapsed;
string elapsedTime = String.Format(" | Duration: {0:00}:{1:00}:{2:00}.{3:00}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds / 10);
string s = string.Format("-> {0} OK = {1}", file_name, String.Format("{0:N0} MB", total / _1MB)) + elapsedTime;
Console.Title = string.Format("{0} -> {1}", title, s);
Console.WriteLine(s);
}
socket.Close();
}
));
childSocketThread.Start(client);
}
listener.Stop();
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.StackTrace);
Console.ReadLine();
}
}
public static void StartSocketServer()
{
NetworkStream stream = null;
TcpListener tcpListener = null;
StreamReader reader = null;
StreamWriter writer = null;
Socket clientsocket = null;
string inputFileName = "ABCDFILE.TXT";
string outputFileName = inputFileName;
string securityKey = "MYKEY";
string inputMode = "";
List <dataLine> dataLines = new List <dataLine>();
try
{
//IP주소를 나타내는 객체를 생성,TcpListener를 생성시 인자로 사용할려고
IPAddress ipAd = IPAddress.Parse("127.0.0.1");
//TcpListener Class를 이용하여 클라이언트의 연결을 받아 들인다.
tcpListener = new TcpListener(ipAd, 9876);
Debug.WriteLine("=============== start server \n ");
Debug.WriteLine("=============== wait for connection \n ");
tcpListener.Start();
//Client의 접속이 올때 까지 Block 되는 부분, 대개 이부분을 Thread로 만들어 보내 버린다.
//백그라운드 Thread에 처리를 맡긴다.
clientsocket = tcpListener.AcceptSocket();
//클라이언트의 데이터를 읽고, 쓰기 위한 스트림을 만든다.
stream = new NetworkStream(clientsocket);
// Encoding encode = System.Text.Encoding.GetEncoding("ks_c_5601-1987");
reader = new StreamReader(stream); //, encode);
writer = new StreamWriter(stream); //, encode);
Debug.WriteLine("client connected \n ");
byte[] myReadBuffer = new byte[1024];
StringBuilder myCompleteMessage = new StringBuilder();
int numberOfBytesRead = 0;
///// cmd 처리 위한 flags /////
bool startRequest = false;
int currentPosition = 0;
while (true)
{
do
{
numberOfBytesRead = stream.Read(myReadBuffer, 0, myReadBuffer.Length);
myCompleteMessage.AppendFormat("{0}", Encoding.ASCII.GetString(myReadBuffer, 0, numberOfBytesRead));
}while (stream.DataAvailable);
Debug.WriteLine(myCompleteMessage.ToString());
/////////// 인력받은 커맨드 파싱 /////////////
if (startRequest == false)
{
if (myCompleteMessage.ToString().Contains("#"))
{
string[] commands = myCompleteMessage.ToString().Split('#');
inputFileName = commands[0];
securityKey = commands[1];
}
// parsing cmd
getDataMain(inputFileName, inputMode, securityKey, ref dataLines, 0);
startRequest = true;
byte[] StrByte = Encoding.UTF8.GetBytes(dataLines[currentPosition].final_data);
stream.Write(StrByte, 0, StrByte.Length);
//writer.WriteLine(dataLines[currentPosition].final_data);
writer.Flush();
currentPosition++;
}
else
{
int line_number = 0;
if (myCompleteMessage.ToString().Equals("ACK"))
{
byte[] StrByte = Encoding.UTF8.GetBytes(dataLines[currentPosition].final_data);
stream.Write(StrByte, 0, StrByte.Length);
//writer.WriteLine(dataLines[currentPosition].final_data);
writer.Flush();
currentPosition++;
if (currentPosition >= dataLines.Count)
{
break;
}
}
else if (myCompleteMessage.ToString().Equals("ERR"))
{
currentPosition--; // 재송신
byte[] StrByte = Encoding.UTF8.GetBytes(dataLines[currentPosition].final_data);
stream.Write(StrByte, 0, StrByte.Length);
//writer.WriteLine(dataLines[currentPosition].final_data);
writer.Flush();
currentPosition++;
if (currentPosition >= dataLines.Count)
{
break;
}
}
else if (int.TryParse(myCompleteMessage.ToString(), out line_number))
{
Debug.WriteLine("=re parsing with new line:" + line_number);
// parsing cmd
dataLines.Clear();
currentPosition = 0;
getDataMain(inputFileName, inputMode, securityKey, ref dataLines, line_number - 1);
startRequest = true;
byte[] StrByte = Encoding.UTF8.GetBytes(dataLines[currentPosition].final_data);
stream.Write(StrByte, 0, StrByte.Length);
//writer.WriteLine(dataLines[currentPosition].final_data);
writer.Flush();
currentPosition++;
}
else
{
Debug.WriteLine("=Unknown cmd=");
}
}
myCompleteMessage.Clear(); // 버퍼클리어
// 다시 읽기 대기 모드 //
}
/*
* while (true)
* {
* writer.WriteLine("WELCOM");
* writer.Flush();
* string str = reader.ReadLine(); // 보내는 쪽에서 개행을 넣지 않으면 block 상태로 영영 돌아오지 않는다.
* Debug.WriteLine(str);
* //getDataMain(inputFileName, inputMode, securityKey, ref dataLines);
* writer.WriteLine(str);
* }
*/
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
}
finally
{
clientsocket.Close();
}
}
public static void RunServer()
{
_recolhimentoService = new RecolhimentoEntulhoService();
TcpListener listenerServidor;
Socket conexao;
NetworkStream socketStream;
BinaryWriter serverWrite;
BinaryReader serverRead;
int contadorConexoes = 1; //contaremos quantas conexões teremos
try
{
IPAddress ipAddress = ConnectionHelper.GetLocalIPAddress();
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, ConnectionHelper.GetDefaultPort());
listenerServidor = new TcpListener(localEndPoint);
listenerServidor.Start();
while (true) // aguardando até fechar a aplicação
{
Console.WriteLine($"Servidor aguardando conexão: IP: {ipAddress} porta: 9000");
conexao = listenerServidor.AcceptSocket();
socketStream = new NetworkStream(conexao);
serverWrite = new BinaryWriter(socketStream);
serverRead = new BinaryReader(socketStream);
Console.WriteLine($"Conexão iniciada n° {contadorConexoes} ");
string clientRequest = "";
try
{
clientRequest = serverRead.ReadString();
var requestObject = JsonSerializer.Deserialize <Request>(clientRequest);
Console.WriteLine($"Mensagem recebida {clientRequest} - " + DateTime.Now);
var response = new Response();
response.TipoRequisicao = requestObject.TipoRequisicao;
try
{
switch (requestObject.TipoRequisicao)
{
case TipoRequisicao.Incluir:
var dtoRecolhimentoInclusao = JsonSerializer.Deserialize <RecolhimentoDTO>(requestObject.JsonObject);
_recolhimentoService.CadastrarEntulhoParaRecolher(dtoRecolhimentoInclusao.Endereco, dtoRecolhimentoInclusao.Descricao);
break;
case TipoRequisicao.Consultar:
response.ObjectJsonResponse = JsonSerializer.Serialize(_recolhimentoService.ListarTodosRecolhimentos());
break;
case TipoRequisicao.Excluir:
_recolhimentoService.ExlcuirAtendimento(JsonSerializer.Deserialize <long>(requestObject.JsonObject));
break;
case TipoRequisicao.Iniciar:
_recolhimentoService.IniciarAtendimento(JsonSerializer.Deserialize <long>(requestObject.JsonObject));
break;
case TipoRequisicao.Finalizar:
_recolhimentoService.FinalizarAtendimento(JsonSerializer.Deserialize <long>(requestObject.JsonObject));
break;
default:
break;
}
}
catch (Exception ex)
{
response.Success = false;
if (ex is InvalidDataException || ex is ApplicationException || ex is ApplicationException)
{
response.Message = ex.Message;
}
else
{
Console.WriteLine($"Erro não tratado: {ex.Message}");
response.Message = "Ocorreu um erro não tratado, acione o suporte";
}
serverWrite.Write(JsonSerializer.Serialize(response));
}
serverWrite.Write(JsonSerializer.Serialize(response));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("Conexão Finalizada!");
//Thread.Sleep(3000); // 3 segundos para terminar de pegar a resposta.
serverWrite.Close();
serverRead.Close();
socketStream.Close();
conexao.Close();
++contadorConexoes;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public static void Main(string[] args)
{
IntPtr ctx;
IntPtr ssl;
Socket fd;
/* These paths should be changed for use */
string fileCert = @"server-cert.pem";
string fileKey = @"server-key.pem";
StringBuilder dhparam = new StringBuilder("dh2048.pem");
StringBuilder buff = new StringBuilder(1024);
StringBuilder reply = new StringBuilder("Hello, this is the wolfSSL C# wrapper");
//example of function used for setting logging
wolfssl.SetLogging(standard_log);
wolfssl.Init();
Console.WriteLine("Calling ctx Init from wolfSSL");
ctx = wolfssl.CTX_new(wolfssl.usev23_server());
if (ctx == IntPtr.Zero)
{
Console.WriteLine("Error in creating ctx structure");
return;
}
Console.WriteLine("Finished init of ctx .... now load in cert and key");
if (!File.Exists(fileCert) || !File.Exists(fileKey))
{
Console.WriteLine("Could not find cert or key file");
wolfssl.CTX_free(ctx);
return;
}
if (wolfssl.CTX_use_certificate_file(ctx, fileCert, wolfssl.SSL_FILETYPE_PEM) != wolfssl.SUCCESS)
{
Console.WriteLine("Error in setting cert file");
wolfssl.CTX_free(ctx);
return;
}
if (wolfssl.CTX_use_PrivateKey_file(ctx, fileKey, wolfssl.SSL_FILETYPE_PEM) != wolfssl.SUCCESS)
{
Console.WriteLine("Error in setting key file");
wolfssl.CTX_free(ctx);
return;
}
StringBuilder ciphers = new StringBuilder(new String(' ', 4096));
wolfssl.get_ciphers(ciphers, 4096);
Console.WriteLine("Ciphers : " + ciphers.ToString());
short minDhKey = 128;
wolfssl.CTX_SetMinDhKey_Sz(ctx, minDhKey);
/* set up TCP socket */
IPAddress ip = IPAddress.Parse("0.0.0.0"); //bind to any
TcpListener tcp = new TcpListener(ip, 11111);
tcp.Start();
Console.WriteLine("Started TCP and waiting for a connection");
fd = tcp.AcceptSocket();
ssl = wolfssl.new_ssl(ctx);
if (ssl == IntPtr.Zero)
{
Console.WriteLine("Error in creating ssl object");
wolfssl.CTX_free(ctx);
return;
}
Console.WriteLine("Connection made wolfSSL_accept ");
if (wolfssl.set_fd(ssl, fd) != wolfssl.SUCCESS)
{
/* get and print out the error */
Console.Write(wolfssl.get_error(ssl));
tcp.Stop();
clean(ssl, ctx);
return;
}
wolfssl.SetTmpDH_file(ssl, dhparam, wolfssl.SSL_FILETYPE_PEM);
if (wolfssl.accept(ssl) != wolfssl.SUCCESS)
{
/* get and print out the error */
Console.Write(wolfssl.get_error(ssl));
tcp.Stop();
clean(ssl, ctx);
return;
}
/* print out results of TLS/SSL accept */
Console.WriteLine("SSL version is " + wolfssl.get_version(ssl));
Console.WriteLine("SSL cipher suite is " + wolfssl.get_current_cipher(ssl));
/* read and print out the message then reply */
if (wolfssl.read(ssl, buff, 1023) < 0)
{
Console.WriteLine("Error in read");
tcp.Stop();
clean(ssl, ctx);
return;
}
Console.WriteLine(buff);
if (wolfssl.write(ssl, reply, reply.Length) != reply.Length)
{
Console.WriteLine("Error in write");
tcp.Stop();
clean(ssl, ctx);
return;
}
wolfssl.shutdown(ssl);
fd.Close();
tcp.Stop();
clean(ssl, ctx);
}
public static void Main(string[] args)
{
IntPtr ctx;
IntPtr ssl;
Socket fd;
wolfssl.psk_delegate psk_cb = new wolfssl.psk_delegate(my_psk_server_cb);
/* These paths should be changed according to use */
string fileCert = @"server-cert.pem";
string fileKey = @"server-key.pem";
StringBuilder dhparam = new StringBuilder("dh2048.pem");
StringBuilder buff = new StringBuilder(1024);
StringBuilder reply = new StringBuilder("Hello, this is the wolfSSL C# wrapper");
wolfssl.Init();
Console.WriteLine("Calling ctx Init from wolfSSL");
ctx = wolfssl.CTX_new(wolfssl.useTLSv1_2_server());
if (ctx == IntPtr.Zero)
{
Console.WriteLine("Error creating ctx structure");
return;
}
Console.WriteLine("Finished init of ctx .... now load in cert and key");
if (!File.Exists(fileCert) || !File.Exists(fileKey))
{
Console.WriteLine("Could not find cert or key file");
wolfssl.CTX_free(ctx);
return;
}
if (wolfssl.CTX_use_certificate_file(ctx, fileCert, wolfssl.SSL_FILETYPE_PEM) != wolfssl.SUCCESS)
{
Console.WriteLine("Error in setting cert file");
wolfssl.CTX_free(ctx);
return;
}
if (wolfssl.CTX_use_PrivateKey_file(ctx, fileKey, wolfssl.SSL_FILETYPE_PEM) != wolfssl.SUCCESS)
{
Console.WriteLine("Error in setting key file");
wolfssl.CTX_free(ctx);
return;
}
StringBuilder ciphers = new StringBuilder(new String(' ', 4096));
wolfssl.get_ciphers(ciphers, 4096);
Console.WriteLine("Ciphers : " + ciphers.ToString());
short minDhKey = 128;
wolfssl.CTX_SetMinDhKey_Sz(ctx, minDhKey);
Console.Write("Setting cipher suite to ");
/* In order to use static PSK build wolfSSL with the preprocessor flag WOLFSSL_STATIC_PSK */
StringBuilder set_cipher = new StringBuilder("DHE-PSK-AES128-CBC-SHA256");
Console.WriteLine(set_cipher);
if (wolfssl.CTX_set_cipher_list(ctx, set_cipher) != wolfssl.SUCCESS)
{
Console.WriteLine("Failed to set cipher suite");
return;
}
/* Test psk use with DHE */
StringBuilder hint = new StringBuilder("cyassl server");
if (wolfssl.CTX_use_psk_identity_hint(ctx, hint) != wolfssl.SUCCESS)
{
Console.WriteLine("Error setting hint");
wolfssl.CTX_free(ctx);
return;
}
wolfssl.CTX_set_psk_server_callback(ctx, psk_cb);
/* set up TCP socket */
IPAddress ip = IPAddress.Parse("0.0.0.0"); //bind to any
TcpListener tcp = new TcpListener(ip, 11111);
tcp.Start();
Console.WriteLine("Started TCP and waiting for a connection");
fd = tcp.AcceptSocket();
ssl = wolfssl.new_ssl(ctx);
if (ssl == IntPtr.Zero)
{
Console.WriteLine("Error creating ssl object");
tcp.Stop();
wolfssl.CTX_free(ctx);
return;
}
Console.WriteLine("Connection made wolfSSL_accept ");
if (wolfssl.set_fd(ssl, fd) != wolfssl.SUCCESS)
{
/* get and print out the error */
Console.WriteLine(wolfssl.get_error(ssl));
tcp.Stop();
clean(ssl, ctx);
return;
}
wolfssl.SetTmpDH_file(ssl, dhparam, wolfssl.SSL_FILETYPE_PEM);
if (wolfssl.accept(ssl) != wolfssl.SUCCESS)
{
/* get and print out the error */
Console.WriteLine(wolfssl.get_error(ssl));
tcp.Stop();
clean(ssl, ctx);
return;
}
/* print out results of TLS/SSL accept */
Console.WriteLine("SSL version is " + wolfssl.get_version(ssl));
Console.WriteLine("SSL cipher suite is " + wolfssl.get_current_cipher(ssl));
/* read and print out the message then reply */
if (wolfssl.read(ssl, buff, 1023) < 0)
{
Console.WriteLine("Error in read");
tcp.Stop();
clean(ssl, ctx);
return;
}
Console.WriteLine(buff);
if (wolfssl.write(ssl, reply, reply.Length) != reply.Length)
{
Console.WriteLine("Error in write");
tcp.Stop();
clean(ssl, ctx);
return;
}
wolfssl.shutdown(ssl);
fd.Close();
tcp.Stop();
clean(ssl, ctx);
}
/// <summary>
/// Запускаем прослушку
/// </summary>
private void StartListener()
{
try
{
IPAddress ipAd = Dns.GetHostByName(Dns.GetHostName()).AddressList[0];
Listener = new TcpListener(ipAd, 8001);
Listener.Start();
while (true)
{
Sock = Listener.AcceptSocket();
byte[] b = new byte[255];
int k = Sock.Receive(b);
string text = "";
for (int i = 0; i < k; i++)
text += Convert.ToChar(b[i]);
received.Enqueue(text);
if (text.Split('.').Length == 4)
{
try
{
IPAddress ip = IPAddress.Parse(text);
if (!listeners.Contains(ip)) listeners.Add(ip);
needUpdateTexture = true;
}
catch (Exception e)
{
}
}
ASCIIEncoding asen = new ASCIIEncoding();
Sock.Send(asen.GetBytes("ok"));
Sock.Close();
}
Listener.Stop();
}
catch(Exception e)
{
Debug.LogError(e.Message);
}
}
void Listen()
{
while (true)
{
#region Accept stream
Socket cli = host.AcceptSocket();
if (cli.SocketType != SocketType.Stream)
{
Console.WriteLine("Rejected socket type: " + cli.SocketType);
cli.Close();
continue;
}
string remote_address = ((System.Net.IPEndPoint)cli.RemoteEndPoint).Address.ToString();
if (remote_address != END_POINT.Address.ToString())
{
Console.WriteLine("Rejected external request: " + cli.RemoteEndPoint);
cli.Close();
continue;
}
if (!cli.Connected)
{
continue;
}
DateTime clock0 = DateTime.Now,
clock1;
#endregion
#region Parse FastCGI
byte[] buf = new byte[cli.ReceiveBufferSize];
cli.Receive(buf, 0, buf.Length, SocketFlags.None);
// Read CGI protocol information (partwise)
byte CGI_VER = buf[0],
CGI_TYP = buf[1];
ushort CGI_RID = (ushort)(buf[4] << 8 | buf[3]);
Dictionary <string, string> headers = new Dictionary <string, string>(),
head_GET = new Dictionary <string, string>(),
head_POST = new Dictionary <string, string>();
#region Read header fields
// Magical index where header fields start being sent
int offset = 24;
while (offset < buf.Length)
{
byte key_l = buf[offset],
value_l = buf[offset + 1];
offset += 2;
string key = ReadString(ref buf, ref offset, key_l),
value = ReadString(ref buf, ref offset, value_l);
if (key_l == 0)
{
break;
}
headers[key] = value;
}
#endregion
#region Get GET data
if (headers["QUERY_STRING"].Length > 0)
{
ParseGET(headers["QUERY_STRING"], ref head_GET);
}
#endregion
int old_offset = offset;
#region Get POST data
if (headers.ContainsKey("CONTENT_TYPE"))
{
offset += 15;
int data_length = buf[offset] << 8 | buf[offset + 1];
offset += 4;
string data = ReadString(ref buf, ref offset, data_length);
string content_type = headers["CONTENT_TYPE"];
if (content_type.StartsWith("multipart/form-data"))
{
// Encoded binary data
int boundary_start = content_type.IndexOf("boundary=", StringComparison.Ordinal);
string boundary = content_type.Remove(0, boundary_start + 9);
// TODO: Parse that data, splitting by '\n'
}
else
{
// GET-Like data
ParseGET(data, ref head_POST);
}
}
#endregion
buf = null;
#endregion
string path = headers["SCRIPT_FILENAME"].Replace('/', '\\');
Console.WriteLine("Loading file: " + path);
L.ResetLua();
L.RegisterLuaFunction(l_print, "print");
#region Global Lua tables
// HTTP Headers
L.CreateLuaTable("HEAD");
Lua.lua_getglobal(L.L, "HEAD");
foreach (KeyValuePair <string, string> e in headers)
{
L.SetTableField(e.Key, e.Value);
}
Lua.lua_pop(L.L, 1);
// GET data
L.CreateLuaTable("GET");
Lua.lua_getglobal(L.L, "GET");
foreach (KeyValuePair <string, string> e in head_GET)
{
L.SetTableField(e.Key, e.Value);
}
Lua.lua_pop(L.L, 1);
// POST data
L.CreateLuaTable("POST");
Lua.lua_getglobal(L.L, "POST");
foreach (KeyValuePair <string, string> e in head_POST)
{
L.SetTableField(e.Key, e.Value);
}
Lua.lua_pop(L.L, 1);
#endregion
packet = new StringBuilder(1024);
packet.Append("Connection: close\n");
packet.Append("Content-Type: text/html; charset=UTF-8\n\n");
packet_lock = false;
ParseHTML(path);
L.CloseLua();
byte[] content_l = enc.GetBytes(packet.ToString());
cli.Send(MakeHead(CGI_RID, content_l.Length));
cli.Send(content_l);
//L.LogError();
//foreach (string s in L.Errors)
// Console.WriteLine(s);
//System.Threading.Thread.Sleep(100);
cli.Close();
clock1 = DateTime.Now;
TimeSpan diff = clock1 - clock0;
Console.WriteLine("\tExecution took " + diff.Milliseconds + " ms");
}
}
public void Run()
{
// カレントディレクトリをexeと同じディレクトリパスへ変更。
Directory.SetCurrentDirectory(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location));
// ハンドルしていない例外をログ出力させる。
AppDomain.CurrentDomain.UnhandledException += this.Program_UnhandledException;
Thread.GetDomain().UnhandledException += this.Program_UnhandledException;
// コマンドライン引数を解析。
var options = CommandLine.Parser.Default.ParseArguments <AmoebaDaemonOptions>(Environment.GetCommandLineArgs())
.MapResult(
(AmoebaDaemonOptions x) => x,
errs => null);
if (options == null)
{
return;
}
// Tomlファイルを読み込み。
DaemonConfig config = null;
{
#if !DEBUG
if (File.Exists(options.ConfigFilePath))
{
var tomlSettings = TomlSettings.Create(builder => builder
.ConfigureType <Version>(type => type
.WithConversionFor <TomlString>(convert => convert
.ToToml(tt => tt.ToString())
.FromToml(ft => Version.Parse(ft.Value)))));
config = Toml.ReadFile <DaemonConfig>(options.ConfigFilePath, tomlSettings);
}
#else
var basePath = "../../";
config = new DaemonConfig(
new Version(0, 0, 0),
new DaemonConfig.CommunicationConfig("tcp:127.0.0.1:4040"),
new DaemonConfig.CacheConfig(Path.Combine("E:", "Test", "Cache.blocks")),
new DaemonConfig.PathsConfig(
Path.Combine(basePath, "Temp"),
Path.Combine(basePath, "Config", "Service"),
Path.Combine(basePath, "Log")));
#endif
}
if (config == null)
{
return;
}
// 既定のフォルダを作成する。
{
foreach (var propertyInfo in typeof(DaemonConfig.PathsConfig).GetProperties())
{
string path = propertyInfo.GetValue(config.Paths) as string;
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
}
}
// Tempフォルダを環境変数に登録。
{
// Tempフォルダ内を掃除。
try
{
foreach (string path in Directory.GetFiles(config.Paths.TempDirectoryPath, "*", SearchOption.AllDirectories))
{
File.Delete(path);
}
foreach (string path in Directory.GetDirectories(config.Paths.TempDirectoryPath, "*", SearchOption.AllDirectories))
{
Directory.Delete(path, true);
}
}
catch (Exception)
{
}
Environment.SetEnvironmentVariable("TMP", Path.GetFullPath(config.Paths.TempDirectoryPath), EnvironmentVariableTarget.Process);
Environment.SetEnvironmentVariable("TEMP", Path.GetFullPath(config.Paths.TempDirectoryPath), EnvironmentVariableTarget.Process);
}
// ログファイルを設定する。
this.Setting_Log(config);
_timer = new WatchTimer(() =>
{
GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect();
});
_timer.Start(new TimeSpan(0, 30, 0));
// サービス開始。
try
{
using (var bufferManager = new BufferManager(1024 * 1024 * 1024))
using (var serviceManager = new ServiceManager(config.Paths.ConfigDirectoryPath, config.Cache.BlocksFilePath, bufferManager))
{
IPEndPoint endpoint;
{
var info = UriUtils.Parse(config.Communication.ListenUri);
endpoint = new IPEndPoint(IPAddress.Parse(info.GetValue <string>("Address")), info.GetValue <int>("Port"));
}
var tcpListener = new TcpListener(endpoint);
tcpListener.Start();
using (var socket = tcpListener.AcceptSocket())
using (var server = new AmoebaDaemonManager <ServiceManager>(socket, serviceManager, bufferManager))
{
try
{
server.Watch();
}
catch (Exception e)
{
Log.Error(e);
Console.WriteLine(e.Message);
}
}
tcpListener.Stop();
tcpListener.Server.Dispose();
}
}
catch (Exception e)
{
Log.Error(e);
Console.WriteLine(e.Message);
}
}
void Update()
{
int tamanho = 0; //tamanho da mensagem recebida
if (server.Pending())
{
cliente = server.AcceptSocket(); //aceita conexao
cliente.Blocking = false;
byte[] mensagem = new byte[1024];
string strMessage = "";
while (!strMessage.Contains(";"))
{
try{ tamanho = cliente.Receive(mensagem);
strMessage = strMessage +
System.Text.Encoding.UTF8.GetString(mensagem); }catch (System.Exception e) {}
}
string comando = strMessage.Split(';')[0];
byte[] envioBuffer = new byte[4];
envioBuffer[0] = (byte)'a';
envioBuffer[1] = (byte)'c'; // mensagem a ser enviada ao cliente
envioBuffer[2] = (byte)'k';
envioBuffer[3] = 10;
Servo_Motor_Rotacao [] servos =
GameObject.FindObjectsOfType <Servo_Motor_Rotacao>();
if (strMessage.Contains("distancia"))
{
Sensor_Infra_Vermelho sensorIV =
GameObject.FindObjectOfType <Sensor_Infra_Vermelho>();
float distancia = sensorIV.GetDistancia();
envioBuffer[0] = (byte)distancia;
envioBuffer[1] = 10;
}
else
{
for (int i = 0; i < servos.Length; i++)
{
if (strMessage.Contains("frente"))
{
servos[i].velocidade = 150;
servos[i].direcao_rotacao = 1 - i;
}
else if (strMessage.Contains("tras"))
{
servos[i].velocidade = 150;
servos[i].direcao_rotacao = i;
}
else if (strMessage.Contains("direita"))
{
servos[i].velocidade = 150;
servos[i].direcao_rotacao = 0;
}
else if (strMessage.Contains("esquerda"))
{
servos[i].velocidade = 150;
servos[i].direcao_rotacao = 1;
}
else if (strMessage.Contains("parar"))
{
servos[i].velocidade = 0;
}
}
}
cliente.Send(envioBuffer);
}
}
public static void ServeOTAFiles(int port, ESP8266BinaryImage.ESP8266ImageHeader hdr, params string[] elfFiles)
{
TcpListener listener = new TcpListener(port);
byte[] buffer = new byte[1024];
OTAImage[] images = new OTAImage[2];
foreach (var fn in elfFiles)
{
if (fn != null)
{
using (var elfFile = new ELFFile(fn))
{
string status;
int appMode = ESP8266BinaryImage.DetectAppMode(elfFile, out status);
if (appMode == 0)
{
Console.WriteLine(fn + " is not an OTA ELF file. Skipping...");
continue;
}
var img = ESP8266BinaryImage.MakeBootloaderBasedImageFromELFFile(elfFile, hdr, appMode);
using (var ms = new MemoryStream())
{
img.Save(ms);
images[appMode - 1].Data = ms.ToArray();
images[appMode - 1].File = fn;
}
}
}
}
Console.WriteLine($"Ready to serve the following files:");
Console.WriteLine($"APP1: {images[0].File ?? "(none)"}");
Console.WriteLine($"APP2: {images[1].File ?? "(none)"}");
Console.WriteLine($"Waiting for connection on port {port}...");
listener.Start();
for (;;)
{
using (var sock = listener.AcceptSocket())
{
Console.WriteLine($"Incoming connection from {(sock.RemoteEndPoint as IPEndPoint).Address}");
StringBuilder requestBuilder = new StringBuilder();
while (!requestBuilder.ToString().Contains("\r\n\r"))
{
int done = sock.Receive(buffer);
requestBuilder.Append(Encoding.UTF8.GetString(buffer, 0, done));
}
string request = requestBuilder.ToString();
string[] parts = request.Split(' ');
if (parts.Length < 3)
{
throw new Exception("Invalid HTTP request: " + request);
}
string url = parts[1];
Console.WriteLine("Received request for " + url);
int otaIndex = (url.ToLower().Contains("user2") ? 1 : 0);
if (images[otaIndex].Data == null)
{
throw new Exception($"No OTA image for app{otaIndex + 1} is provided. Please check your linker scripts.");
}
string reply = string.Format("HTTP/1.0 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: {0}\r\n\r\n", images[otaIndex].Data.Length);
var r = Encoding.UTF8.GetBytes(reply);
sock.Send(r);
if (parts[0] == "GET")
{
Console.Write($"Serving {Path.GetFileName(images[otaIndex].File)}...\r\n");
using (var ms = new MemoryStream(images[otaIndex].Data))
{
int totalDone = 0;
for (;;)
{
int done = ms.Read(buffer, 0, buffer.Length);
if (done == 0)
{
break;
}
sock.Send(buffer, done, SocketFlags.None);
totalDone += done;
int percent = (int)((totalDone * 100) / ms.Length);
int progress = percent / 5;
Console.Write($"\r[{new string('#', progress).PadRight(20)}] {percent}%");
}
}
Console.WriteLine("\r\nFile sent successfully\n");
break;
}
}
}
listener.Stop();
}
} // end method inputTextBox_KeyDown
// allows a client to connect; displays text the client sends
public void RunServer()
{
TcpListener listener;
int counter = 1;
// wait for a client connection and display the text
// that the client sends
try
{
// Step 1: create TcpListener
IPAddress local = IPAddress.Parse( "127.0.0.1" );
listener = new TcpListener( local, 50000 );
// Step 2: TcpListener waits for connection request
listener.Start();
// Step 3: establish connection upon client request
while ( true )
{
DisplayMessage( "Waiting for connection\r\n" );
// accept an incoming connection
connection = listener.AcceptSocket();
// create NetworkStream object associated with socket
socketStream = new NetworkStream( connection );
// create objects for transferring data across stream
writer = new BinaryWriter( socketStream );
reader = new BinaryReader( socketStream );
DisplayMessage( "Connection " + counter + " received.\r\n" );
// inform client that connection was successfull
writer.Write( "SERVER>>> Connection successful" );
DisableInput( false ); // enable inputTextBox
string theReply = "";
// Step 4: read string data sent from client
do
{
try
{
// read the string sent to the server
theReply = reader.ReadString();
// display the message
DisplayMessage( "\r\n" + theReply );
} // end try
catch ( Exception )
{
// handle exception if error reading data
break;
} // end catch
} while ( theReply != "CLIENT>>> TERMINATE" &&
connection.Connected );
DisplayMessage( "\r\nUser terminated connection\r\n" );
// Step 5: close connection
writer.Close();
reader.Close();
socketStream.Close();
connection.Close();
DisableInput( true ); // disable InputTextBox
counter++;
} // end while
} // end try
catch ( Exception error )
{
MessageBox.Show( error.ToString() );
} // end catch
} // end method RunServer
//Method to turnoff PC when correct pass/command is given via telnet
static void ShutdownWithRemoteDevice()
{
Console.WriteLine("Enter IP yours remote device or leave empty to using any device: "); //Primitive protection from unauthorized connection (optional)
string ip = Console.ReadLine();
bool anyIp = false;
if (ip == "" || ip == null)
{
anyIp = true;
}
Console.WriteLine("You can give special password to shutdown PC (leave empty if nope): "); //Replace default command by custom password
password = Console.ReadLine();
TcpListener tcpListener = new TcpListener(IPAddress.Any, 12345);
tcpListener.Start();
//At the end of loop, disconnect client to slow down brute force method in "password case"
while (true)
{
Console.WriteLine("Waiting for connection request...");
Socket socket = tcpListener.AcceptSocket();
IPEndPoint clientIP = socket.RemoteEndPoint as IPEndPoint;
if (clientIP.Address.ToString() == ip || anyIp)
{
Console.WriteLine($"{clientIP.Address} is connected");
using (NetworkStream netStream = new NetworkStream(socket))
{
using (StreamReader streamReader = new StreamReader(netStream))
{
using (StreamWriter streamWriter = new StreamWriter(new NetworkStream(socket)))
{
streamWriter.WriteLine("You've connected to TOAD system, to turn off, give your pass or if it wasnt given, type \"init 0\"");
}
string msg = streamReader.ReadLine();
if (isPermitedToTurnOff(msg))
{
Console.WriteLine("DOWN!");
SysManagement.ShutDownNow();
break;
}
else
{
Console.WriteLine("WRONG command");
}
}
}
}
else
{
Console.WriteLine($"{clientIP.Address} is not allowed!");
}
Console.WriteLine($"{clientIP.Address} was disconnected");
socket.Disconnect(true);
}
}
public static void Main()
{
Console.WriteLine("Connecting...");
listener = new TcpListener(IPAddress.Parse( "0.0.0.0" ), 1337);
listener.Start();
Thread t;
connections[0] = new Connection(listener.AcceptSocket());
connections[0].Write("1");
connections[0].playerNumber = 1;
/*
t = new Thread(delegate() { exchangeData(connections[0]); });
t.Start();
*/
Console.WriteLine("Player 1 connected!");
connections[1] = new Connection(listener.AcceptSocket());
connections[1].Write("2");
connections[1].playerNumber = 2;
/*
t = new Thread(delegate() { exchangeData(connections[1]); });
t.Start();
*/
Console.WriteLine("Player 2 connected!");
while(true) {
foreach(Connection c in connections) {
string[] receivedData = c.Read().Split(',');
if(c.playerNumber == 1) {
paddle1.x = Convert.ToSingle(receivedData[0]);
paddle1.y = Convert.ToSingle(receivedData[1]);
}
if(c.playerNumber == 2) {
paddle2.x = Convert.ToSingle(receivedData[0]);
paddle2.y = Convert.ToSingle(receivedData[1]);
}
}
string data = null;
foreach(Connection c in connections) {
if(c.playerNumber == 1){
data = ball.x + "," + ball.y + ";" + paddle2.x + "," + paddle2.y + ";" + PlayerScore1 + "," + PlayerScore2;
Console.WriteLine("Sent data string:" + data + " to player 1");
}
else{
data = ball.x + "," + ball.y + ";" + paddle1.x + "," + paddle1.y + ";" + PlayerScore1 + "," + PlayerScore2;
Console.WriteLine("Sent data string:" + data + " to player 2");
}
c.Write(data);
}
update();
Thread.Sleep(1000/60);
}
}
public void RunServer( )
{
Socket connection;
TcpListener listener;
int counter = 1;
try
{
IPAddress local = IPAddress.Parse("127.0.0.1");
listener = new TcpListener(local , 50000);
listener.Start();
while(true)
{
DisplayMessage("Waiting for connection\r\n");
connection = listener.AcceptSocket();
DisplayMessage("Connection " + counter + " received.\r\n");
ThreadPool.QueueUserWorkItem(ProcessClient , connection);
counter++;
}
}
catch(Exception error)
{
MessageBox.Show(error.ToString());
}
}
/*
* do_server()
*/
private void do_server(int build_mode, string[] args)
{
int i = 1;
int port = 4433;
uint options = axtls.SSL_DISPLAY_CERTS;
bool quiet = false;
string password = null;
string private_key_file = null;
/* organise the cert/ca_cert lists */
int cert_size = SSLUtil.MaxCerts();
int ca_cert_size = SSLUtil.MaxCACerts();
string[] cert = new string[cert_size];
string[] ca_cert = new string[ca_cert_size];
int cert_index = 0;
int ca_cert_index = 0;
while (i < args.Length)
{
if (args[i] == "-accept")
{
if (i >= args.Length-1)
{
print_server_options(build_mode, args[i]);
}
port = Int32.Parse(args[++i]);
}
else if (args[i] == "-quiet")
{
quiet = true;
options &= ~(uint)axtls.SSL_DISPLAY_CERTS;
}
else if (build_mode >= axtls.SSL_BUILD_SERVER_ONLY)
{
if (args[i] == "-cert")
{
if (i >= args.Length-1 || cert_index >= cert_size)
{
print_server_options(build_mode, args[i]);
}
cert[cert_index++] = args[++i];
}
else if (args[i] == "-key")
{
if (i >= args.Length-1)
{
print_server_options(build_mode, args[i]);
}
private_key_file = args[++i];
options |= axtls.SSL_NO_DEFAULT_KEY;
}
else if (args[i] == "-pass")
{
if (i >= args.Length-1)
{
print_server_options(build_mode, args[i]);
}
password = args[++i];
}
else if (build_mode >= axtls.SSL_BUILD_ENABLE_VERIFICATION)
{
if (args[i] == "-verify")
{
options |= axtls.SSL_CLIENT_AUTHENTICATION;
}
else if (args[i] == "-CAfile")
{
if (i >= args.Length-1 || ca_cert_index >= ca_cert_size)
{
print_server_options(build_mode, args[i]);
}
ca_cert[ca_cert_index++] = args[++i];
}
else if (build_mode == axtls.SSL_BUILD_FULL_MODE)
{
if (args[i] == "-debug")
{
options |= axtls.SSL_DISPLAY_BYTES;
}
else if (args[i] == "-state")
{
options |= axtls.SSL_DISPLAY_STATES;
}
else if (args[i] == "-show-rsa")
{
options |= axtls.SSL_DISPLAY_RSA;
}
else
print_server_options(build_mode, args[i]);
}
else
print_server_options(build_mode, args[i]);
}
else
print_server_options(build_mode, args[i]);
}
else
print_server_options(build_mode, args[i]);
i++;
}
/* Create socket for incoming connections */
IPEndPoint ep = new IPEndPoint(IPAddress.Any, port);
TcpListener server_sock = new TcpListener(ep);
server_sock.Start();
/**********************************************************************
* This is where the interesting stuff happens. Up until now we've
* just been setting up sockets etc. Now we do the SSL handshake.
**********************************************************************/
SSLServer ssl_ctx = new SSLServer(
options, axtls.SSL_DEFAULT_SVR_SESS);
if (ssl_ctx == null)
{
Console.Error.WriteLine("Error: Server context is invalid");
Environment.Exit(1);
}
if (private_key_file != null)
{
int obj_type = axtls.SSL_OBJ_RSA_KEY;
if (private_key_file.EndsWith(".p8"))
obj_type = axtls.SSL_OBJ_PKCS8;
else if (private_key_file.EndsWith(".p12"))
obj_type = axtls.SSL_OBJ_PKCS12;
if (ssl_ctx.ObjLoad(obj_type,
private_key_file, password) != axtls.SSL_OK)
{
Console.Error.WriteLine("Private key '" + private_key_file +
"' is undefined.");
Environment.Exit(1);
}
}
for (i = 0; i < cert_index; i++)
{
if (ssl_ctx.ObjLoad(axtls.SSL_OBJ_X509_CERT,
cert[i], null) != axtls.SSL_OK)
{
Console.WriteLine("Certificate '" + cert[i] +
"' is undefined.");
Environment.Exit(1);
}
}
for (i = 0; i < ca_cert_index; i++)
{
if (ssl_ctx.ObjLoad(axtls.SSL_OBJ_X509_CACERT,
ca_cert[i], null) != axtls.SSL_OK)
{
Console.WriteLine("Certificate '" + cert[i] +
"' is undefined.");
Environment.Exit(1);
}
}
byte[] buf = null;
int res;
for (;;)
{
if (!quiet)
{
Console.WriteLine("ACCEPT");
}
Socket client_sock = server_sock.AcceptSocket();
SSL ssl = ssl_ctx.Connect(client_sock);
/* do the actual SSL handshake */
while ((res = ssl_ctx.Read(ssl, out buf)) == axtls.SSL_OK)
{
/* check when the connection has been established */
if (ssl.HandshakeStatus() == axtls.SSL_OK)
break;
/* could do something else here */
}
if (res == axtls.SSL_OK) /* connection established and ok */
{
if (!quiet)
{
display_session_id(ssl);
display_cipher(ssl);
}
/* now read (and display) whatever the client sends us */
for (;;)
{
/* keep reading until we get something interesting */
while ((res = ssl_ctx.Read(ssl, out buf)) == axtls.SSL_OK)
{
/* could do something else here */
}
if (res < axtls.SSL_OK)
{
if (!quiet)
{
Console.WriteLine("CONNECTION CLOSED");
}
break;
}
/* convert to string */
char[] str = new char[res];
for (i = 0; i < res; i++)
{
str[i] = (char)buf[i];
}
Console.Write(str);
}
}
else if (!quiet)
{
SSLUtil.DisplayError(res);
}
/* client was disconnected or the handshake failed. */
ssl.Dispose();
client_sock.Close();
}
/* ssl_ctx.Dispose(); */
}
/// <summary>
///
/// </summary>
/// <param name="tcplistener">Tiene que estar ecuchando</param>
/// <param name="readBuffer"></param>
/// <param name="recivedBytesBuffer"></param>
public ClienteWeb(TcpListener tcplistener, int readBuffer = 1024, int recivedBytesBuffer = 4096) : this(readBuffer, recivedBytesBuffer)
{
client = tcplistener.AcceptSocket();
}
/// <summary>
/// 监听
/// </summary>
public void Listen()
{
Console.WriteLine("ConsumerServerListener开始监听...");
while (true)
{
//获取连接过来的tcp请求，这里的AcceptSocket方法是阻塞式的，必须用线程异步去处理，否则就没办法处理其他连接过来的tcp请求了。
Socket consumerSocket = _tcpLisenter.AcceptSocket();
Console.WriteLine("ConsumerServerListener监听到有ConsumerClient连接...");
//将请求交给线程池来处理
ThreadPool.QueueUserWorkItem(o =>
{
//下面是处理当前tcp请求的逻辑，由于是tcp长连接请求，需要死循环不断监听推送过来的数据
Socket socket = (Socket)o;
string channelName = null;
while (true)
{
try
{
Channel channel = null;
//_channelName = "test";
//接收逻辑
int length = socket.Available;
if (channelName == null)
{
byte[] receiveData = new byte[length];
//开始接收数据，这里的Receive方法是阻塞式的
socket.Receive(receiveData);
if (receiveData.Length > 0)
{
string json = Encoding.UTF8.GetString(receiveData);
//将消息内容转Message
Message receiveMessage = JsonConvert.DeserializeObject <Message>(json);
channelName = receiveMessage.ChannelName;
Console.WriteLine(json);
}
}
if (channelName != null)
{
//发送逻辑
if (!Channel.Dictionary.ContainsKey(channelName))
{
//字典中不包含channelName则新建channel实例
channel = new Channel();
Channel.Dictionary.Add(channelName, channel);
}
else
{
//字典中包含channelName则获取channel实例
channel = Channel.Dictionary[channelName];
}
//从队列取出顶部Message，暂时不移除，因为可能会因客户端已断开连接而导致发送失败
Message sendMessage = channel.Peek();
if (sendMessage != null)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(JsonConvert.SerializeObject(sendMessage));
//添加消息分隔符，这样下游接收到多条记录可以用分隔符分割
stringBuilder.Append("$$$");
byte[] sendData = Encoding.UTF8.GetBytes(stringBuilder.ToString());
//发送消息（如果尝试发送给一个已经关闭的客户端，那么会报错）
try
{
socket.Send(sendData);
channel.Dequeue();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
break;
}
//Console.WriteLine(stringBuilder.ToString());
}
}
Thread.Sleep(100);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
break;
}
}
socket.Close();
Console.WriteLine("ConsumerServerListener监听到ConsumerClient已经关闭连接，因此ConsumerServerListener正在关闭当前Socket实例...");
}, consumerSocket);
}
}
public static void Main(string[] args)
{
String ip = "127.0.0.1";
if (args.Length > 0)
{
ip = args[0];
Console.WriteLine("Using command line ip address: " + ip);
}
else
{
Console.WriteLine("Using default ip address: " + ip);
}
IPAddress ipAd = IPAddress.Parse(ip);
// use local m/c IP address, and
// use the same in the client
/* Initializes the Listener */
TcpListener myList = new TcpListener(ipAd, 8001);
/* Start Listeneting at the specified port */
myList.Start();
Console.WriteLine("The server is running at port 8001...");
Console.WriteLine("The local End point is: " +
myList.LocalEndpoint);
Console.WriteLine("Waiting for a connection.....");
Socket s = myList.AcceptSocket();
Console.WriteLine("Connection accepted from " + s.RemoteEndPoint);
byte[] data = new byte[100];
while (true)
{
try
{
if (s.Connected == false)
{
break;
}
if (s.Available == 0)
{
System.Threading.Thread.Sleep(500);
continue;
}
}
catch (SocketException)
{
break;
}
int sz = s.Receive(data);
Trace.Assert(sz > 0);
Console.WriteLine($"Recieved {sz} bytes:");
string hex = BitConverter.ToString(data, 0, sz).Replace("-", " ");
Console.WriteLine(hex);
Trace.Assert(BitConverter.IsLittleEndian == true);
Int16 len = BitConverter.ToInt16(data, 0);
Int16 type = BitConverter.ToInt16(data, 2);
Int64 time = BitConverter.ToInt64(data, 4);
UInt32 ra_raw = BitConverter.ToUInt32(data, 12);
Int32 dec_raw = BitConverter.ToInt32(data, 16);
Console.WriteLine($"len:{len} type:{type} time:{time} ra:{ra_raw} dec:{dec_raw}");
Double ra = Convert.ToDouble(ra_raw) / 0x100000000 * 24;
Double dec = Convert.ToDouble(dec_raw) / 0x80000000 * 180;
Console.WriteLine($"ra:{ra}\ndec:{dec}");
Trace.Assert(type == 0);
Trace.Assert(len == sz);
}
Console.WriteLine("Connection closed.");
/* clean up */
s.Close();
myList.Stop();
}
static void Main(string[] args)
{
IntPtr ctx;
IntPtr ssl;
Socket fd;
wolfssl.psk_delegate psk_cb = new wolfssl.psk_delegate(my_psk_server_cb);
/* These paths should be changed according to use */
string fileCert = @"server-cert.pem";
string fileKey = @"server-key.pem";
StringBuilder buff = new StringBuilder(1024);
StringBuilder reply = new StringBuilder("Hello, this is the wolfSSL C# wrapper");
wolfssl.Init();
Console.WriteLine("Calling ctx Init from wolfSSL");
ctx = wolfssl.CTX_new(wolfssl.useTLSv1_2_server());
if (ctx == IntPtr.Zero)
{
Console.WriteLine("Error creating ctx structure");
return;
}
Console.WriteLine("Finished init of ctx .... now load in cert and key");
if (!File.Exists(fileCert) || !File.Exists(fileKey))
{
Console.WriteLine("Could not find cert or key file");
wolfssl.CTX_free(ctx);
return;
}
if (wolfssl.CTX_use_certificate_file(ctx, fileCert, wolfssl.SSL_FILETYPE_PEM) != wolfssl.SUCCESS)
{
Console.WriteLine("Error in setting cert file");
wolfssl.CTX_free(ctx);
return;
}
if (wolfssl.CTX_use_PrivateKey_file(ctx, fileKey, wolfssl.SSL_FILETYPE_PEM) != wolfssl.SUCCESS)
{
Console.WriteLine("Error in setting key file");
wolfssl.CTX_free(ctx);
return;
}
StringBuilder ciphers = new StringBuilder(new String(' ', 4096));
wolfssl.get_ciphers(ciphers, 4096);
Console.WriteLine("Ciphers : " + ciphers.ToString());
Console.Write("Setting cipher suite to ");
/* To use static PSK build wolfSSL with WOLFSSL_STATIC_PSK preprocessor flag */
StringBuilder set_cipher = new StringBuilder("PSK-AES128-CBC-SHA256");
Console.WriteLine(set_cipher);
if (wolfssl.CTX_set_cipher_list(ctx, set_cipher) != wolfssl.SUCCESS)
{
Console.WriteLine("Failed to set cipher suite");
Console.WriteLine("If using static PSK make sure wolfSSL was built with preprocessor flag WOLFSSL_STATIC_PSK");
wolfssl.CTX_free(ctx);
return;
}
/* Test psk use */
StringBuilder hint = new StringBuilder("cyassl server");
if (wolfssl.CTX_use_psk_identity_hint(ctx, hint) != wolfssl.SUCCESS)
{
Console.WriteLine("Error setting hint");
return;
}
wolfssl.CTX_set_psk_server_callback(ctx, psk_cb);
/* Set using custom IO callbacks
delegate memory is allocated when calling SetIO**** function and freed with ctx free
*/
wolfssl.SetIORecv(ctx, new wolfssl.CallbackIORecv_delegate(wolfSSLCbIORecv));
wolfssl.SetIOSend(ctx, new wolfssl.CallbackIOSend_delegate(wolfSSLCbIOSend));
/* set up TCP socket */
IPAddress ip = IPAddress.Parse("0.0.0.0"); //bind to any
TcpListener tcp = new TcpListener(ip, 11111);
tcp.Start();
Console.WriteLine("Started TCP and waiting for a connection");
fd = tcp.AcceptSocket();
ssl = wolfssl.new_ssl(ctx);
Console.WriteLine("Connection made wolfSSL_accept ");
if (wolfssl.set_fd(ssl, fd) != wolfssl.SUCCESS)
{
/* get and print out the error */
Console.Write(wolfssl.get_error(ssl));
tcp.Stop();
clean(ssl, ctx);
return;
}
if (wolfssl.accept(ssl) != wolfssl.SUCCESS)
{
/* get and print out the error */
Console.Write(wolfssl.get_error(ssl));
tcp.Stop();
clean(ssl, ctx);
return;
}
/* print out results of TLS/SSL accept */
Console.WriteLine("SSL version is " + wolfssl.get_version(ssl));
Console.WriteLine("SSL cipher suite is " + wolfssl.get_current_cipher(ssl));
/* read and print out the message then reply */
if (wolfssl.read(ssl, buff, 1023) < 0)
{
Console.WriteLine("Error in read");
tcp.Stop();
clean(ssl, ctx);
return;
}
Console.WriteLine(buff);
if (wolfssl.write(ssl, reply, reply.Length) != reply.Length)
{
Console.WriteLine("Error in write");
tcp.Stop();
clean(ssl, ctx);
return;
}
wolfssl.shutdown(ssl);
fd.Close();
tcp.Stop();
clean(ssl, ctx);
}
public static void TCPSocketServer()
{
string data = null;
// Data buffer for incoming data.
byte[] bytes = new Byte[1024];
int portNumber;
Configuration configManager = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
KeyValueConfigurationCollection confCollection = configManager.AppSettings.Settings;
if (!string.IsNullOrEmpty(confCollection["TCPPort"].Value))
{
Int32.TryParse(confCollection["TCPPort"].Value, out portNumber);
}
else
{
MessageBox.Show("TCPPort is not set in the config file!!!", "BuggerNET");
return;
}
// Establish the local endpoint for the socket.
// Dns.GetHostName returns the name of the
// host running the application.
IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
IPAddress ipAddress = ipHostInfo.AddressList[0];
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, portNumber);
TcpListener tcpListener = new TcpListener(localEndPoint);
// Bind the socket to the local endpoint and
// listen for incoming connections.
try
{
tcpListener.Start();
// Start listening for connections.
while (true)
{
//statRTB.AppendText("Waiting for a connection...\n");
while (!tcpListener.Pending())
{
System.Threading.Thread.Sleep(20);
}
// Program is suspended while waiting for an incoming connection.
Socket handler = tcpListener.AcceptSocket();
handler.Blocking = false;
data = null;
// An incoming connection needs to be processed.
int count = 0;
while (/*count < 100000 && !m_Stop.WaitOne(0)*/ true)
{
bytes = new byte[1024];
data = null;
SocketError socketError = SocketError.Success;
//try
//{
while (handler.Receive(bytes, 0, bytes.Length, SocketFlags.None, out socketError) <= 0)
{
//
//System.Threading.Thread.Sleep(20);
}
//}
//catch (Exception ex1)
//{
// string str = ex1.ToString();
//}
data = Encoding.ASCII.GetString(bytes, 0, bytes.Length);
//statRTB.AppendText(string.Format("Text received : {0}\n", data));
bytes = null;
count++;
}
handler.Shutdown(SocketShutdown.Both);
handler.Close();
}
}
catch (Exception ex)
{
statRTB.AppendText(ex.ToString());
}
}
public int StartCallback()
{
TcpListener callbackServer = new TcpListener(IPAddress.Parse("127.0.0.1"), 0);
callbackServer.Start();
Task.Run(() =>
{
try
{
using (Socket sock = callbackServer.AcceptSocket())
using (var s = new NetworkStream(sock))
{
while (true)
{
try
{
string cmd = SerDe.ReadString(s);
if (cmd == "close")
{
logger.LogInfo("receive close cmd from Scala side");
break;
}
else if (cmd == "callback")
{
int numRDDs = SerDe.ReadInt(s);
var jrdds = new List <JvmObjectReference>();
for (int i = 0; i < numRDDs; i++)
{
jrdds.Add(new JvmObjectReference(SerDe.ReadObjectId(s)));
}
double time = SerDe.ReadDouble(s);
IFormatter formatter = new BinaryFormatter();
object func = formatter.Deserialize(new MemoryStream(SerDe.ReadBytes(s)));
string deserializer = SerDe.ReadString(s);
RDD <dynamic> rdd = null;
if (jrdds[0].Id != null)
{
rdd = new RDD <dynamic>(new RDDIpcProxy(jrdds[0]), sparkContext, (SerializedMode)Enum.Parse(typeof(SerializedMode), deserializer));
}
if (func is Func <double, RDD <dynamic>, RDD <dynamic> > )
{
JvmObjectReference jrdd = (((Func <double, RDD <dynamic>, RDD <dynamic> >)func)(time, rdd).RddProxy as RDDIpcProxy).JvmRddReference;
SerDe.Write(s, (byte)'j');
SerDe.Write(s, jrdd.Id);
}
else if (func is Func <double, RDD <dynamic>, RDD <dynamic>, RDD <dynamic> > )
{
string deserializer2 = SerDe.ReadString(s);
RDD <dynamic> rdd2 = new RDD <dynamic>(new RDDIpcProxy(jrdds[1]), sparkContext, (SerializedMode)Enum.Parse(typeof(SerializedMode), deserializer2));
JvmObjectReference jrdd = (((Func <double, RDD <dynamic>, RDD <dynamic>, RDD <dynamic> >)func)(time, rdd, rdd2).RddProxy as RDDIpcProxy).JvmRddReference;
SerDe.Write(s, (byte)'j');
SerDe.Write(s, jrdd.Id);
}
else
{
((Action <double, RDD <dynamic> >)func)(time, rdd);
SerDe.Write(s, (byte)'n');
}
}
}
catch (Exception e)
{
//log exception only when callback socket is not shutdown explicitly
if (!callbackSocketShutdown)
{
logger.LogInfo(e.ToString());
}
}
}
}
}
catch (Exception e)
{
logger.LogInfo(e.ToString());
throw;
}
finally
{
if (callbackServer != null)
{
callbackServer.Stop();
}
}
});
return((callbackServer.LocalEndpoint as IPEndPoint).Port);
}
// -----
// http://www.c-sharpcorner.com/UploadFile/dottys/SocketProgDTRP11222005023030AM/SocketProgDTRP.aspx
// Socket Server
public string socketServer()
{
string theString = "Hello!";
//Creates an instance of the TcpListener class by providing a local port number.
IPHostEntry host= Dns.GetHostEntry("localhost");
TcpListener tcpListener = new TcpListener(host.AddressList[0], 10);
tcpListener.Start();
Socket socketForClient = tcpListener.AcceptSocket();
if (socketForClient.Connected)
{
NetworkStream networkStream = new NetworkStream(socketForClient);
System.IO.StreamWriter streamWriter =
new System.IO.StreamWriter(networkStream);
System.IO.StreamReader streamReader =
new System.IO.StreamReader(networkStream);
streamWriter.WriteLine(theString);
// textBox1.Text += theString + Environment.NewLine;
streamWriter.Flush();
while (theString != "quit")
{
theString = streamReader.ReadLine();
excuteCmd(theString);
streamWriter.WriteLine("Yes! My Lord!");
streamWriter.Flush();
}
// textBox1.Text += theString + Environment.NewLine;
streamReader.Close();
networkStream.Close();
streamWriter.Close();
}
socketForClient.Close();
//textBox1.Text += "Exiting..." + Environment.NewLine;
return theString;
}
private void StartServer(string ipAddress, int port)
{
IPAddress ip;
ASCIIEncoding ascii = new ASCIIEncoding();
bool res = IPAddress.TryParse(ipAddress, out ip);
if (!res)
{
ip = IPAddress.Loopback;
}
TcpListener myListener = new TcpListener(ip, port);
myListener.Start();
Socket s = myListener.AcceptSocket();
IPEndPoint remoteEndPoint = s.RemoteEndPoint as IPEndPoint;
string clientIP = remoteEndPoint.Address.ToString();
Messages[0] = new Message();
Messages[0].Text = _publicKey.ToString() + " " + _coPrimeNumber.ToString();
Messages[0].FromIP = ip.ToString();
Messages[0].ToIP = clientIP + " Client";
s.Send(ascii.GetBytes(_publicKey.ToString()));
s.Send(ascii.GetBytes(_coPrimeNumber.ToString()));
byte[] b = new byte[10000];
int i = s.Receive(b);
byte[] transfer = new byte[i];
for (int k = 0; k < i; k++)
{
transfer[k] = b[k];
}
_encryptedData = transfer;
string temp = "";
Byte[] bytes = new Byte[4];
for (int k = 0; k < i; k += 4)
{
temp += BitConverter.ToInt32(b, k).ToString() + " ";
}
Messages[1] = new Message();
Messages[1].Text = temp;
Messages[1].FromIP = ip.ToString() + " Client";
Messages[1].ToIP = clientIP;
_message = RSAEncryptor.Decrypt(b, _publicKey, _computedPrivateKey, i);
Messages[2] = new Message();
Messages[2].Text = _message;
Messages[2].FromIP = ip.ToString() + " Client";
Messages[2].ToIP = clientIP;
s.Close();
myListener.Stop();
}
} // end method DisplayMessage
// set up connection for client to play Hangman
public void GetGuesses()
{
// start listening for connections
IPAddress local = IPAddress.Parse( "127.0.0.1" );
TcpListener listener = new TcpListener( local, 50000 );
listener.Start();
// accept client connection and get NetworkStream to
// communicate with client
Socket connection = listener.AcceptSocket();
DisplayMessage( "Connection received\r\n" );
NetworkStream socketStream = new NetworkStream( connection );
// create reader and writer for client
BinaryWriter writer = new BinaryWriter( socketStream );
BinaryReader reader = new BinaryReader( socketStream );
// choose random word
Random randomWord = new Random();
int wordNumber = randomWord.Next( 25 );
string word = "";
// open word file
StreamReader wordReader = new StreamReader( "words.txt" );
// find word in file
for ( int i = 0; i <= wordNumber; i++ )
word = wordReader.ReadLine();
// display word and send length of word to client
DisplayMessage( "The secret word is: " + word + "\r\n" );
writer.Write( word.Length );
// initialize Hangman game variables
int numberWrong = 0, numberLettersLeft = word.Length,
numberCharsInWord = 0;
char guess;
// while entire word has not been guessed and
// user has not made 5 mistakes, process user guesses
while ( numberLettersLeft > 0 && numberWrong < 5 )
{
numberCharsInWord = 0;
// get guess
guess = reader.ReadChar();
DisplayMessage( "The user guessed: " + guess + "\r\n" );
// find out how many occurrences of letter in word
for ( int i = 0; i < word.Length; i++ )
if ( word[ i ] == guess )
numberCharsInWord++;
// send client number of occurrences
writer.Write( numberCharsInWord );
// if the character is present, send index values
// of each occurrence
if ( numberCharsInWord != 0 )
{
for ( int i = 0; i < word.Length; i++ )
{
if ( word[ i ] == guess )
{
writer.Write( i );
// decrement number of letters left to guess
numberLettersLeft--;
} // end if
} // end for
} // end if
else
numberWrong++; // user made mistake, add 1 to number wrong
} // end while
// if word not guessed and user made 5 mistakes,
// tell user the word
if ( numberLettersLeft != 0 && numberWrong == 5 )
writer.Write( word );
// close connections
connection.Close();
socketStream.Close();
reader.Close();
writer.Close();
} // end method GetGuesses
