public override void Insert(Person person)
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(IPAddress.Parse("127.0.0.1"), 3180);
NetworkStream networkStream = new NetworkStream(socket);
string dataSend = extension + "|" + "Insert|" + person.ToXML();
byte[] bytes = Encoding.UTF8.GetBytes(dataSend);
networkStream.Write(bytes, 0, bytes.Length);
bool isWork = true;
while (isWork)
{
if (networkStream.DataAvailable)
{
isWork = false;
byte[] buffer = new byte[socket.Available];
networkStream.Read(buffer, 0, buffer.Length);
string result = Encoding.UTF8.GetString(buffer);
}
}
networkStream.Flush();
networkStream.Close();
socket.Close();
}
static void Main(string[] args)
{
var m_Config = new ServerConfig
{
Port = 911,
Ip = "Any",
MaxConnectionNumber = 1000,
Mode = SocketMode.Tcp,
Name = "CustomProtocolServer"
};
var m_Server = new CustomProtocolServer();
m_Server.Setup(m_Config, logFactory: new ConsoleLogFactory());
m_Server.Start();
EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
{
socket.Connect(serverAddress);
var socketStream = new NetworkStream(socket);
var reader = new StreamReader(socketStream, Encoding.ASCII, false);
string charSource = Guid.NewGuid().ToString().Replace("-", string.Empty)
+ Guid.NewGuid().ToString().Replace("-", string.Empty)
+ Guid.NewGuid().ToString().Replace("-", string.Empty);
Random rd = new Random();
var watch = Stopwatch.StartNew();
for (int i = 0; i < 10; i++)
{
int startPos = rd.Next(0, charSource.Length - 2);
int endPos = rd.Next(startPos + 1, charSource.Length - 1);
var currentMessage = charSource.Substring(startPos, endPos - startPos + 1);
byte[] requestNameData = Encoding.ASCII.GetBytes("ECHO");
socketStream.Write(requestNameData, 0, requestNameData.Length);
var data = Encoding.ASCII.GetBytes(currentMessage);
socketStream.Write(new byte[] { (byte)(data.Length / 256), (byte)(data.Length % 256) }, 0, 2);
socketStream.Write(data, 0, data.Length);
socketStream.Flush();
// Console.WriteLine("Sent: " + currentMessage);
var line = reader.ReadLine();
//Console.WriteLine("Received: " + line);
//Assert.AreEqual(currentMessage, line);
}
watch.Stop();
Console.WriteLine(watch.ElapsedMilliseconds);
}
Console.ReadLine();
}
public static void Run()
{
int serverPort = 8080;
IPAddress serverIp = IPAddress.Parse("10.25.232.214"); //IPAdress
Console.WriteLine("Server IP: {0}", serverIp);
Socket echoSocket = new Socket(
serverIp.AddressFamily,
SocketType.Stream,
ProtocolType.Tcp);
echoSocket.Connect(serverIp, serverPort);
using (Stream echoServiceStream = new NetworkStream(echoSocket, true))
{
string msg = "Hello world";
Byte[] msgByte = encodeString(msg);
//Gets the length of the message in bytes
Byte[] msgByteLength = BitConverter.GetBytes(msg.Length);
//Sends the length of the message in bytes
echoServiceStream.Write(msgByteLength, 0, msgByteLength.Length);
echoServiceStream.Flush();
//Sends the message
echoServiceStream.Write(msgByte, 0, msgByte.Length);
//writer.Write(msg.Length);
// writer.WriteLine(msg);
echoServiceStream.Flush();
}
}
private void bbt_register_Click(object sender, EventArgs e)
{
if (txt_password.Text != txt_confirm.Text)
{
MessageBox.Show("Mật khẩu xác nhận không đúng", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
try
{
NetworkStream stream = new NetworkStream(socket);
byte[] buffer = new byte[4];
//sen command type
buffer = BitConverter.GetBytes((int)CommandType_.Register);
stream.Write(buffer, 0, 4);
stream.Flush();
//send username
buffer = BitConverter.GetBytes(txt_username.Text.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
byte[] data = new byte[txt_username.Text.Length];
data = Encoding.ASCII.GetBytes(txt_username.Text);
stream.Write(data, 0, txt_username.Text.Length);
stream.Flush();
//send account
buffer = BitConverter.GetBytes(txt_account.Text.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = new byte[txt_account.Text.Length];
data = Encoding.ASCII.GetBytes(txt_account.Text);
stream.Write(data, 0, txt_account.Text.Length);
stream.Flush();
//send password
buffer = BitConverter.GetBytes(txt_password.Text.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = new byte[txt_password.Text.Length];
data = Encoding.ASCII.GetBytes(txt_password.Text);
stream.Write(data, 0, txt_password.Text.Length);
stream.Flush();
//sen email
buffer = BitConverter.GetBytes(txt_email.Text.Length);
stream.Write(buffer, 0, 4);
stream.Flush();
data = new byte[txt_email.Text.Length];
data = Encoding.ASCII.GetBytes(txt_email.Text);
stream.Write(data, 0, txt_email.Text.Length);
stream.Flush();
}
catch
{
MessageBox.Show("Server đang bảo trì,không thể đăng kí!", "Thông báo", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
private void btnOK_Click(object sender, EventArgs e)
{
try
{
int selected = comboColor.SelectedIndex;
//color = Color.FromName("Red");
// ip = IPAddress.Parse(txtIP.Text);
color = Color.FromName(comboColor.Items[selected].ToString());
// MessageBox.Show(color.Name);
ClassPlayer.Player newPlayer = new Player(command.connect, txtName.Text, comboMap.SelectedIndex+1, ip, new Point(50, 50), color);
client = new TcpClient();
client.Connect(new IPEndPoint(IPAddress.Parse(txtIP.Text), 777));
clientStream = client.GetStream();
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(clientStream, newPlayer);
clientStream.Flush();
NetGame ng = new NetGame(newPlayer);
ng.BackColor = Color.Gold;
ng.ShowDialog();
// Application.Run(ng);
this.Close();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public void Connect()
{
while (!connected)
{
tcpClient = new TcpClient();
try
{
tcpClient.Connect(trackerEndpoint);
clientStream = tcpClient.GetStream();
byte[] buffer = encoder.GetBytes("Hello Server");
clientStream.Write(buffer, 0, buffer.Length);
clientStream.Flush();
connected = true;
}
catch(Exception e)
{
string ex = e.StackTrace;
System.Diagnostics.Debug.WriteLine(ex);
continue;
}
}
}
private void SendRequest(NetworkStream clientStream)
{
byte[] buffer = Helper.SdoSerializeClientData(ReadClientData());
clientStream.Write(buffer, 0, buffer.Length);
clientStream.Flush();
}
public bool connect(string srvIP, int srvPort, string n)
{
serverIP = srvIP;
serverPort = srvPort;
string nick = n;
string xmlReadyNick = n.Trim(new char[]{'$'});
for(;;)
try
{
clientSocket.Connect(srvIP, srvPort);
serverStream = clientSocket.GetStream();
byte[] outStream = System.Text.Encoding.ASCII.GetBytes(nick);
serverStream.Write(outStream, 0, outStream.Length);
serverStream.Flush();
ctThread = new Thread(getMessage);
ctThread.Start();
readData = "Conected to Chat Server!";
form.msg(readData);
xms = new xmlMessageSender(xmlReadyNick);
return true;
}
catch (System.Net.Sockets.SocketException err)
{
MessageBox.Show("Error connecting to server\n" + err);
return false;
}
}
public void leer()
{
networkStream = clientSocket.GetStream();
if (networkStream.CanRead == true)
{
conectado = true;
byte[] bytesFrom = new byte[10025];
networkStream.Read(bytesFrom, 0, (int)clientSocket.ReceiveBufferSize);
paquete = System.Text.Encoding.ASCII.GetString(bytesFrom);
paquete = paquete.Substring(0, paquete.IndexOf("\0"));
if (paquete == "Comando::Cerrar")
{
conectado = false;
}
}
else
{
Console.WriteLine("No se puede leer");
}
networkStream.Flush();
}
public void getConnect()
{
Console.WriteLine("Trying to connect to the game server");
try
{
clientSocket.Connect(IPAddress.Parse("127.0.0.1"), 6000);
stream = clientSocket.GetStream();
byte[] messsage = Encoding.ASCII.GetBytes(common.parameters.JOIN);
for (int i = 0; i < messsage.Length; i++)
{
Console.WriteLine(messsage[i]);
}
stream.Write(messsage, 0, messsage.Length);
stream.Flush(); //flush the stream
}
catch (Exception e)
{
Console.WriteLine("Initial connect to the server is Failed! Server is not started or connection is not stable");
getConnect();
}
finally
{
if (stream != null && writer != null) {
stream.Close(); //close stream
writer.Close();
}
}
}
public string Connect(string ipString, string jsonInfo)
{
IPAddress ip = IPAddress.Parse(ipString);
ClientSocket.Connect(ip, 8888);
ServerStream = ClientSocket.GetStream();
// Send name initially
byte[] outStream = System.Text.Encoding.ASCII.GetBytes(jsonInfo + "$");
ServerStream.Write(outStream, 0, outStream.Length);
ServerStream.Flush();
// Receive Map
int buffSize = ClientSocket.ReceiveBufferSize;
Console.WriteLine("BUffer sIZE {0}", buffSize);
byte[] inStream = new byte[buffSize];
int i = 1;
string jsonMap = "";
while (!jsonMap.Contains("$"))
{
Console.WriteLine("Reading map " + i++);
Console.WriteLine("Data Size: {0}", jsonMap.Length);
ServerStream.Read(inStream, 0, buffSize);
jsonMap += System.Text.Encoding.ASCII.GetString(inStream);
}
if (!jsonMap.Contains("$"))
{
Console.WriteLine("Received bad data from server");
Console.WriteLine(jsonMap);
return "";
}
string shortData = jsonMap.Substring(0, jsonMap.IndexOf("$"));
return "" + shortData;
}
/// <summary>
/// 此方法负责发送请求列举所有进程命令
/// </summary>
public void Send_Order(NetworkStream Ns)
{
//得到目标主机注册表根键命令 原型 ：$$ActiveDos||
String Get_Register_Root_Order = "$ActiveDos||";
//尝试发送请求
Ns.Write(Encoding.Default.GetBytes(Get_Register_Root_Order), 0, Encoding.Default.GetBytes(Get_Register_Root_Order).Length);
Ns.Flush();
}
/*private void WriteMessage(string msg)
{
if (this.rtbServer.InvokeRequired)
{
WriteMessageDelegate d = new WriteMessageDelegate(WriteMessage);
this.rtbServer.Invoke(d, new object[] { msg });
}
else
{
this.rtbServer.AppendText(msg + Environment.NewLine);
}
}*/
/// <summary>
/// Echo the message back to the sending client
/// </summary>
/// <param name="msg">
/// String: The Message to send back
/// </param>
/// <param name="encoder">
/// Our ASCIIEncoder
/// </param>
/// <param name="clientStream">
/// The Client to communicate to
/// </param>
private void Echo(string msg, ASCIIEncoding encoder, NetworkStream clientStream)
{
// Now Echo the message back
byte[] buffer = encoder.GetBytes(msg);
clientStream.Write(buffer, 0, buffer.Length);
clientStream.Flush();
}
/// <summary>
/// 此方法负责发送请求列举所有进程命令
/// </summary>
public void Send_Order(NetworkStream Ns , String Reg_Path)
{
//得到目标主机注册表根键命令 原型 ：$GetRegisterRoot|| [路径]
String Get_Register_Root_Order = "$GetRegisterRoot||" + Reg_Path;
//尝试发送请求
Ns.Write(Encoding.Default.GetBytes(Get_Register_Root_Order), 0, Encoding.Default.GetBytes(Get_Register_Root_Order).Length);
Ns.Flush();
}
private void btnConnect_Click(object sender, EventArgs e)
{
string IpAddress = null;
if (txtIp.Text == "Default")
{
IpAddress = "127.0.0.1";
}
else
{
System.Net.IPAddress ParseIpAddress = null;
bool IsValid = System.Net.IPAddress.TryParse(txtIp.Text, out ParseIpAddress);
if (IsValid == true)
{
if (ParseIpAddress.AddressFamily == AddressFamily.InterNetwork)
{
IpAddress = ParseIpAddress.ToString();
}
else
{
MessageBox.Show("Your ip is invalid , please enter a valid IPv4 ");
}
}
else
{
MessageBox.Show("Your ip is invalid , please enter a valid IPv4 ");
}
}
try
{
clientSideSocket = new System.Net.Sockets.TcpClient();
clientSideSocket.Connect(IpAddress, 1337);
}
catch (SocketException ex)
{
MessageBox.Show(" Make sure that the server is working properly for more details please check " + ex);
return;
}
readData = "Conected to Chat Server ...";
DisplayMessage();
networkStream = clientSideSocket.GetStream();
byte[] SendMessage = Encoding.ASCII.GetBytes(txtName.Text + "Cool");
networkStream.Write(SendMessage, 0, SendMessage.Length);
networkStream.Flush();
txtName.Enabled = false;
btnConnect.Enabled = false;
btnDisconnect.Enabled = true;
Thread messageThread = new Thread(receiveMessage);
messageThread.Start();
}
public override void Flush()
{
if (!IsConnected)
{
throw new InvalidOperationException("The FtpSocketStream object is not connected.");
}
NetworkStream?.Flush();
}
public int serverHandshake(NetworkStream ns, Encoding enc)
{
byte[] buffer = enc.GetBytes(userName);
ns.Write(buffer, 0, buffer.Length);
ns.Flush();
byte[] uID = new byte[4];
int byteCout = ns.Read(uID, 0, uID.Length);
return BitConverter.ToInt32(uID, 0);
}
public void Start() {
channel = "#" + username;
loginstring = "PASS "+pass+"\r\nNICK "+username+"\r\n";
client = new TcpClient(hostname, port);
stream = client.GetStream();
Byte[] login = System.Text.Encoding.ASCII.GetBytes(loginstring);
stream.Write(login, 0, login.Length);
//Debug.Log("Sent login.\r\n");
//Debug.Log(loginstring);
// Receive the TcpServer.response.
// Buffer to store the response bytes.
data = new Byte[512];
string responseData = String.Empty;
Int32 bytes = stream.Read(data, 0, data.Length);
responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
//Debug.Log("Received WELCOME: \r\n\r\n{0}"+ responseData);
// send message to join channel
string joinstring = "JOIN " + channel + "\r\n";
Byte[] join = System.Text.Encoding.ASCII.GetBytes(joinstring);
//Debug.Log("can write: "+ stream.CanWrite);
stream.Write(join, 0, join.Length);
stream.Flush();
//Debug.Log("Sent channel join.\r\n");
//Debug.Log(joinstring);
// PMs the channel to announce that it's joined and listening
// These three lines are the example for how to send something to the channel
string announcestring = ":" + username + "!" + username + "@" + username + ".tmi.twitch.tv PRIVMSG " + channel + " : GAME STARTED !\r\n";
Byte[] announce = System.Text.Encoding.ASCII.GetBytes(announcestring);
stream.Write(announce, 0, announce.Length);
stream.Flush();
// Lets you know its working
//Debug.Log("TWITCH CHAT HAS BEGUN.\r\n\r\nr.");
//Debug.Log("\r\nBE CAREFUL.");
StartCoroutine(messages());
}
private void SendToClient(string message)
{
if (!message.EndsWith(Environment.NewLine))
{
message += Environment.NewLine;
}
var sendBytes = Encoding.ASCII.GetBytes(message);
_networkStream?.Write(sendBytes, 0, sendBytes.Length);
_networkStream?.Flush();
}
public void Connect()
{
client = new TcpClient();
ip = "127.0.0.1";
port = 12345;
client.Connect(ip, port);
serverStream = client.GetStream();
byte[] outStream = System.Text.Encoding.ASCII.GetBytes("Evan$");
serverStream.Write(outStream, 0, outStream.Length);
serverStream.Flush();
}
/// <summary>
/// 此方法负责发送请求列举所有进程命令
/// </summary>
public void Send_Order(NetworkStream Ns)
{
if (Ns != null)
{
//列举进程命令原型 ： $GetService||
Ns.Write(Encoding.Default.GetBytes("$GetService||"), 0, Encoding.Default.GetBytes("$GetService||").Length);
Ns.Flush();
//如果发送请求成功则开启线程负责接收结果
Thread thread = new Thread(new ThreadStart(this.Get_Result));
thread.Start();
}
}
static void Main (string [] args)
{
certfile = (args.Length > 1) ? args [0] : "ssl.cer";
keyfile = (args.Length > 1) ? args [1] : "ssl.pvk";
Socket listenSocket = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint localEndPoint = new IPEndPoint (IPAddress.Any, 4433);
Socket requestSocket;
listenSocket.Bind (localEndPoint);
listenSocket.Listen (10);
while (true) {
try {
requestSocket = listenSocket.Accept ();
using (NetworkStream ns = new NetworkStream (requestSocket, FileAccess.ReadWrite, true)) {
using (SslServerStream s = new SslServerStream (ns, Certificate, false, false)) {
s.PrivateKeyCertSelectionDelegate += new PrivateKeySelectionCallback (GetPrivateKey);
s.ClientCertValidationDelegate += new CertificateValidationCallback (VerifyClientCertificate);
StreamReader reader = new StreamReader (s);
StreamWriter writer = new StreamWriter (s, Encoding.ASCII);
string line;
// Read request header
do {
line = reader.ReadLine ();
if (line != null)
Console.WriteLine (line);
}
while (line != null && line.Length > 0);
string answer = String.Format ("HTTP/1.0 200{0}Connection: close{0}" +
"Content-Type: text/html{0}Content-Encoding: {1}{0}{0}" +
"<html><body><h1>Hello {2}!</h1></body></html>{0}",
"\r\n", Encoding.ASCII.WebName,
s.ClientCertificate == null ? "World" : s.ClientCertificate.GetName ());
// Send response
writer.Write (answer);
writer.Flush ();
s.Flush ();
ns.Flush ();
}
}
}
catch (Exception ex) {
Console.WriteLine ("---------------------------------------------------------");
Console.WriteLine (ex.ToString ());
}
}
}
/// <summary>
/// Sends a message across the NetworkStream
/// </summary>
/// <param name="clientStream">The stream to send the message down</param>
/// <param name="message">The message to send</param>
public void SendMessage(NetworkStream clientStream, string message)
{
var buffer = new ASCIIEncoding().GetBytes(message);
try
{
clientStream.Write(buffer, 0, buffer.Length);
clientStream.Flush();
}
catch (IOException e)
{
Debug.WriteLine("IOException: " + e.Message);
}
}
public void TestAccumulatorInWorker()
{
StringBuilder output = new StringBuilder();
Process worker;
TcpListener CSharpRDD_SocketServer = CreateServer(output, out worker);
using (var serverSocket = CSharpRDD_SocketServer.AcceptSocket())
using (var s = new NetworkStream(serverSocket))
{
WritePayloadHeaderToWorker(s);
const int accumulatorId = 1001;
var accumulator = new Accumulator<int>(accumulatorId, 0);
byte[] command = SparkContext.BuildCommand(new CSharpWorkerFunc(new AccumulatorHelper(accumulator).Execute),
SerializedMode.String, SerializedMode.String);
SerDe.Write(s, command.Length);
SerDe.Write(s, command);
const int expectedCount = 100;
for (int i = 0; i < expectedCount; i++)
{
SerDe.Write(s, i.ToString());
}
SerDe.Write(s, (int)SpecialLengths.END_OF_DATA_SECTION);
SerDe.Write(s, (int)SpecialLengths.END_OF_STREAM);
s.Flush();
int count = 0;
foreach (var bytes in ReadDataSection(s))
{
Assert.AreEqual(count++.ToString(), Encoding.UTF8.GetString(bytes));
}
Assert.AreEqual(expectedCount, count);
// read accumulator
int accumulatorsCount = SerDe.ReadInt(s);
Assert.IsTrue(accumulatorsCount == 1);
var accumulatorFromWorker = ReadAccumulator(s, accumulatorsCount).First();
Assert.AreEqual(accumulatorId, accumulatorFromWorker.Key);
Assert.AreEqual(expectedCount, accumulatorFromWorker.Value);
SerDe.ReadInt(s);
}
AssertWorker(worker, output);
CSharpRDD_SocketServer.Stop();
}
//receive streams from socket connection
public void getStreams()
{
try
{
output = socket.GetStream();
input = socket.GetStream();//get input stream from connection
output.Flush(); //flush output stream
input.Flush();
}
catch (Exception ex) //if streams were not received
{
throw ex;
}
}
public void Start2()
{
ReadData = "Connecting to Chat Server...";
UpdateMainWindow();
ClientSocket.Connect(UserSettings.ip_address, UserSettings.port_number);
ServerStream = ClientSocket.GetStream();
byte[] outStream = System.Text.Encoding.ASCII.GetBytes(MessageTextBox.Text + "$"); //txt box
ServerStream.Write(outStream, 0, outStream.Length);
ServerStream.Flush();
Thread ctThread = new Thread(getMessage);
ctThread.Start();
}
public int BytesToRead => _tcpClient?.Available ?? 0;// _networkStream?.DataAvailable == true ? 1 : 0;
//public bool CanRead => _networkStream.CanRead;
protected internal void SetSocket(Socket socket)
{
this.Close();
this.Dispose();
_tcpClient = socket;
_tcpClient.ReceiveTimeout = DefaultTimeoutMs;
_tcpClient.SendTimeout = DefaultTimeoutMs;
// My observation on the Raspberry Pi was, that the serial port (Arduino connected on /dev/ttyUSB0) already had data
// in its buffer, even though the connected Arduino hadn't sent anything.
// The data in the buffer appeared to be from a previous run of the program.
// So apparently the buffer is remembered even across consecutive runs of the program and after the serial port is closed.
// This means that the serial port OS driver is at fault here, as imo it should have cleared
// its buffer after a Close or directly when Opened.
// NOPE: RawDump on Rpi shows that data is correctly received, so no buffers are "remembered".
_networkStream?.Flush();
_networkStream = new NetworkStream(_tcpClient);
_task = System.Threading.Tasks.Task.Run(() =>
{
while (_tcpClient.Connected /* && _tcpClient.Poll(-1, SelectMode.SelectRead)*/)
{
try
{
OnTcpDataReceived();
}
catch (Exception)
{
break;
}
}
});
}
public void TestAccumuatorSuccess()
{
var sc = new SparkContext(null);
Accumulator<int> accumulator = sc.Accumulator<int>(0);
// get accumulator server port and connect to accumuator server
int serverPort = (sc.SparkContextProxy as MockSparkContextProxy).AccumulatorServerPort;
var sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
sock.Connect(IPAddress.Loopback, serverPort);
using (var s = new NetworkStream(sock))
{
// write numUpdates
int numUpdates = 1;
SerDe.Write(s, numUpdates);
// write update
int key = 0;
int value = 100;
KeyValuePair<int, dynamic> update = new KeyValuePair<int, dynamic>(key, value);
var ms = new MemoryStream();
var formatter = new BinaryFormatter();
formatter.Serialize(ms, update);
byte[] sendBuffer = ms.ToArray();
SerDe.Write(s, sendBuffer.Length);
SerDe.Write(s, sendBuffer);
s.Flush();
byte[] receiveBuffer = new byte[1];
s.Read(receiveBuffer, 0, 1);
Assert.AreEqual(accumulator.Value, value);
// try to let service side to close gracefully
sc.Stop();
try
{
numUpdates = 0;
SerDe.Write(s, numUpdates);
}
catch
{
// do nothing here
}
}
sock.Close();
}
// Update is called once per frame
void Update()
{
// Test = new VerificaConexao(listener.GetStream());
client = listener.GetStream();
data = new byte[1024];
if(client.DataAvailable){
int recv = client.Read(data, 0, data.Length);
string stringData = Encoding.ASCII.GetString(data, 0, recv);
print (stringData);
client.Write(Encoding.ASCII.GetBytes(stringData), 0, stringData.Length);
client.Flush();
}
if(Test.IsConnected)
{
print("ok");
}
}
public static void Connect()
{
//connecting to server socket with port 6000
clientSocket.Connect(IPAddress.Parse("127.0.0.1"), 6000);
stream = clientSocket.GetStream();
//joining message to server
byte[] ba = Encoding.ASCII.GetBytes(Constant.C2S_INITIALREQUEST);
for (int x = 0; x < ba.Length; x++)
{
Console.WriteLine(ba[x]);
}
stream.Write(ba, 0, ba.Length); //send join# to server
stream.Flush();
stream.Close(); //close network stream
}
public static void Close(TcpClient socket)
{
if (socket == null)
{
return;
}
try
{
NetworkStream networkStream = socket.GetStream();
try
{
networkStream?.Flush();
}
catch (SocketException)
{
}
finally
{
try
{
networkStream?.Close();
}
catch (SocketException)
{
}
}
}
catch (SocketException)
{
}
catch (InvalidOperationException)
{
}
try
{
socket.Close();
}
catch (SocketException)
{
}
}
public void EnviarDatos(Usuario cliente)
{
//serializa la clase usuario para poder ser mandada a traves de TCP
clientStream = client.GetStream();
MemoryStream ms = new MemoryStream();
IFormatter bf = new BinaryFormatter();
bf.Serialize(ms, cliente);
//Coge el buffer de la clase serializada
data = ms.GetBuffer();
//Envia los datos al servidor
clientStream.Write(data, 0, data.Length);
clientStream.Flush();
clientStream.Close();
ms.Close();
}
void init()
{
channel = "#" + username;
loginstring = "PASS " + pass + "\r\nNICK " + username + "\r\n";
client = new TcpClient(hostname, port);
stream = client.GetStream();
Byte[] login = System.Text.Encoding.ASCII.GetBytes(loginstring);
stream.Write(login, 0, login.Length);
data = new Byte[512];
string responseData = String.Empty;
Int32 bytes = stream.Read(data, 0, data.Length);
responseData = System.Text.Encoding.ASCII.GetString(data, 0, bytes);
string joinstring = "JOIN " + channel + "\r\n";
Byte[] join = System.Text.Encoding.ASCII.GetBytes(joinstring);
stream.Write(join, 0, join.Length);
stream.Flush();
}
/// <summary>
/// Sends a message to the server
/// </summary>
/// <param name="message">The message to send</param>
public void SendMessage(string message)
{
//If the server is no longer connected tell the Communication Manager that it should stop sending sendmessage requests and disconnect
if (!IsConnected)
{
CommunicationManager.Instance.Disconnect();
return;
}
ASCIIEncoding encoder = new ASCIIEncoding();
NetworkStream serverStream = null;
try
{
//Attempt to send the message
serverStream = serverClient.GetStream();
byte[] buffer = encoder.GetBytes(message);
serverStream.Write(buffer, 0, buffer.Length);
}
catch (IOException ex)
{
//There was an error reading/writing to the stream (usually occurs when the server has disconnected)
MessageBox.Show(ex.ToString(), "Error");
}
catch (InvalidOperationException ex)
{
//There was an error performing something, can also occur on a disconnect
MessageBox.Show(ex.ToString(), "Error");
}
catch (Exception ex)
{
//Unexpected error occured
MessageBox.Show(ex.ToString(), "Error");
throw;
}
finally
{
//Make sure we always flush the stream if its there
serverStream?.Flush();
}
}
public void TestCustomProtocol()
{
EndPoint serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), m_Config.Port);
using (Socket socket = new Socket(serverAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp))
{
socket.Connect(serverAddress);
var socketStream = new NetworkStream(socket);
var reader = new StreamReader(socketStream, Encoding.ASCII, false);
string charSource = Guid.NewGuid().ToString().Replace("-", string.Empty)
+ Guid.NewGuid().ToString().Replace("-", string.Empty)
+ Guid.NewGuid().ToString().Replace("-", string.Empty);
Random rd = new Random();
for (int i = 0; i < 10; i++)
{
int startPos = rd.Next(0, charSource.Length - 2);
int endPos = rd.Next(startPos + 1, charSource.Length - 1);
var currentMessage = charSource.Substring(startPos, endPos - startPos + 1);
byte[] requestNameData = Encoding.ASCII.GetBytes("ECHO");
socketStream.Write(requestNameData, 0, requestNameData.Length);
var data = Encoding.ASCII.GetBytes(currentMessage);
socketStream.Write(new byte[] { (byte)(data.Length / 256), (byte)(data.Length % 256) }, 0, 2);
socketStream.Write(data, 0, data.Length);
socketStream.Flush();
Console.WriteLine("Sent: " + currentMessage);
var line = reader.ReadLine();
Console.WriteLine("Received: " + line);
Assert.AreEqual(currentMessage, line);
}
}
}
public void Disconnect()
{
terminated = true;
IsConnected = false;
try
{
writer?.Flush();
writer?.Close();
writer = null;
reader?.Close();
reader = null;
networkStream?.Flush();
networkStream?.Close();
networkStream = null;
Handler?.Shutdown(SocketShutdown.Both);
}
catch { }
finally
{
Handler?.Close();
Handler = null;
OnDisconnect?.Invoke(this, EventArgs.Empty);
}
}
public static void Main(string[] args)
{
if (args.Length != 7)
{
// LUCENENET specific - our wrapper console shows the correct usage
throw new ArgumentException();
//Console.WriteLine("Usage: java Lucene.Net.Store.LockStressTest myID verifierHost verifierPort lockFactoryClassName lockDirName sleepTimeMS count\n" +
// "\n" +
// " myID = int from 0 .. 255 (should be unique for test process)\n" +
// " verifierHost = hostname that LockVerifyServer is listening on\n" +
// " verifierPort = port that LockVerifyServer is listening on\n" +
// " lockFactoryClassName = primary LockFactory class that we will use\n" +
// " lockDirName = path to the lock directory (only set for Simple/NativeFSLockFactory\n" +
// " sleepTimeMS = milliseconds to pause betweeen each lock obtain/release\n" +
// " count = number of locking tries\n" +
// "\n" +
// "You should run multiple instances of this process, each with its own\n" +
// "unique ID, and each pointing to the same lock directory, to verify\n" +
// "that locking is working correctly.\n" +
// "\n" +
// "Make sure you are first running LockVerifyServer.");
//Environment.FailFast("1");
}
int arg = 0;
int myID = Convert.ToInt32(args[arg++]);
if (myID < 0 || myID > 255)
{
throw new ArgumentException("ID must be a unique int 0..255");
//Console.WriteLine("myID must be a unique int 0..255");
//Environment.Exit(1);
}
string verifierHost = args[arg++];
int verifierPort = Convert.ToInt32(args[arg++]);
string lockFactoryClassName = args[arg++];
string lockDirName = args[arg++];
int sleepTimeMS = Convert.ToInt32(args[arg++]);
int count = Convert.ToInt32(args[arg++]);
IPAddress[] addresses = Dns.GetHostAddressesAsync(verifierHost).Result;
IPAddress addr = addresses.FirstOrDefault();
Type c;
try
{
c = Type.GetType(lockFactoryClassName);
if (c == null)
{
// LUCENENET: try again, this time with the Store namespace
c = Type.GetType("Lucene.Net.Store." + lockFactoryClassName);
}
}
catch (Exception)
{
throw new IOException("unable to find LockClass " + lockFactoryClassName);
}
LockFactory lockFactory;
try
{
lockFactory = (LockFactory)Activator.CreateInstance(c);
}
catch (UnauthorizedAccessException e)
{
throw new IOException("Cannot instantiate lock factory " + lockFactoryClassName, e);
}
catch (InvalidCastException e)
{
throw new IOException("unable to cast LockClass " + lockFactoryClassName + " instance to a LockFactory", e);
}
catch (Exception e)
{
throw new IOException("InstantiationException when instantiating LockClass " + lockFactoryClassName, e);
}
DirectoryInfo lockDir = new DirectoryInfo(lockDirName);
if (lockFactory is FSLockFactory)
{
((FSLockFactory)lockFactory).SetLockDir(lockDir);
}
Console.WriteLine("Connecting to server " + addr + " and registering as client " + myID + "...");
using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
socket.Connect(verifierHost, verifierPort);
using (Stream @out = new NetworkStream(socket), @in = new NetworkStream(socket))
{
BinaryReader intReader = new BinaryReader(@in);
BinaryWriter intWriter = new BinaryWriter(@out);
intWriter.Write(myID);
@out.Flush();
lockFactory.LockPrefix = "test";
LockFactory verifyLF = new VerifyingLockFactory(lockFactory, @in, @out);
Lock l = verifyLF.MakeLock("test.lock");
Random rnd = new Random();
// wait for starting gun
if (intReader.ReadInt32() != 43)
{
throw new IOException("Protocol violation");
}
for (int i = 0; i < count; i++)
{
bool obtained = false;
try
{
obtained = l.Obtain(rnd.Next(100) + 10);
}
#pragma warning disable 168
catch (LockObtainFailedException e)
#pragma warning restore 168
{
}
if (obtained)
{
Thread.Sleep(sleepTimeMS);
l.Dispose();
}
if (i % 500 == 0)
{
Console.WriteLine((i * 100.0 / count) + "% done.");
}
Thread.Sleep(sleepTimeMS);
}
}
}
Console.WriteLine("Finished " + count + " tries.");
}
/// <summary>
/// Sends a given String to the socket connection.
/// </summary>
/// <param name="msg">the String to send.</param>
/// <throws> IOException if the String cannot be sent, maybe because the </throws>
/// <summary>connection has already been closed.</summary>
public void WriteEx(string msg)
{
byte[] data = encoding.GetBytes(msg);
networkStream.BeginWrite(data, 0, data.Length, onWriteFinished, networkStream);
networkStream.Flush();
}
private void sendResponse(Response response)
{
Console.WriteLine("Sending response " + response);
formatter.Serialize(stream, response);
stream.Flush();
}
protected void chat()
{
bool roomGone = true;
string outRooms = "";
string chosenRoom = "";
//server prepares and sends a list of all rooms separated by ":"
foreach (Room room in roomList)
{
outRooms += room.ToString() + ":";
}
NetworkStream roomStream = clientSocket.GetStream();
byte[] roomBytes = Encoding.Unicode.GetBytes("I:" + outRooms + "$");
roomStream.Write(roomBytes, 0, roomBytes.Length);
roomStream.Flush();
byte[] bytesReceived = new byte[10025];
NetworkStream networkStream = clientSocket.GetStream();
networkStream.Read(bytesReceived, 0, bytesReceived.Length);
chosenRoom = Encoding.Unicode.GetString(bytesReceived);
chosenRoom = chosenRoom.Substring(0, chosenRoom.IndexOf("$"));
chosenRoom = chosenRoom.Substring(2, chosenRoom.Length - 2);
//handled the case when client got closed and room wasn't chosen
if (chosenRoom != "NOPE")
{
foreach (Room room in roomList)
{
if (room.ToString() == chosenRoom)
{
this.room = room;
room.AddUser(username, clientSocket);
Console.WriteLine(" >> " + username + " joined the room " + chosenRoom);
roomGone = false;
roomStream = clientSocket.GetStream();
roomBytes = Encoding.Unicode.GetBytes("I:UrOK$");
roomStream.Write(roomBytes, 0, roomBytes.Length);
roomStream.Flush();
}
}
}
//handled the case when client got closed and room wasn't chosen
else
{
clientsList.Remove(username);
Thread.CurrentThread.Abort();
}
//handled the case when the room chosen is already removed
if (roomGone)
{
roomStream = clientSocket.GetStream();
roomBytes = Encoding.Unicode.GetBytes("I:RoomGone$");
roomStream.Write(roomBytes, 0, roomBytes.Length);
roomStream.Flush();
clientsList.Remove(username);
Thread.CurrentThread.Abort();
}
//"welcoming" the new user to the room
room.Broadcast("[INFO] " + username + " joined", username, true, room.insideList);
bool stop = false;
bytesReceived = new byte[10025];
string dataFromClient = "";
//while loop handling the communication with the client from now on
while (!stop)
{
if (dying)
{
sendInfo(clientSocket, "shutdown");
networkStream.Dispose();
clientSocket.Close();
break;
}
try
{
networkStream = clientSocket.GetStream();
networkStream.Read(bytesReceived, 0, bytesReceived.Length);
dataFromClient = Encoding.Unicode.GetString(bytesReceived);
dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf("$"));
if (dataFromClient.StartsWith("I:"))
{
//ending the communication with a client, ending thread
dataFromClient = dataFromClient.Substring(2, dataFromClient.Length - 2);
if (dataFromClient.Equals("dying"))
{
networkStream.Dispose();
clientSocket.Close();
clientsList.Remove(username);
room.RemoveUser(username);
room.Broadcast("[INFO] " + username + " disconnected", username, true, room.insideList);
Console.WriteLine(" >> " + username + " disconnected");
stop = true;
}
}
if (dataFromClient.StartsWith("M:"))
{
dataFromClient = dataFromClient.Substring(2, dataFromClient.Length - 2);
//forwarding the message to the room
if (!dataFromClient.Equals(""))
{
Console.WriteLine(username + " says : " + dataFromClient);
room.Broadcast(dataFromClient, username, false, room.insideList);
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
internal void SendReal(byte[] wire)
{
NetworkStream.Write(wire, 0, wire.Length);
NetworkStream.Flush();
}
private void RealTimeWork(object sender, DoWorkEventArgs e)
{
Tuple <TcpClient, NetworkStream, bool, int> arg = (Tuple <TcpClient, NetworkStream, bool, int>)e.Argument;
TcpClient tcpClnt = arg.Item1;
NetworkStream stream = arg.Item2;
bool isConnect = arg.Item3;
int RTT_Version = arg.Item4;
IsCanLoad = true;
string serverResponse = "";
DateTime timeStampLastQuery = new DateTime(), serverRecponceLastTime = DateTime.Now;
while (!Vars.IsAppClosed && IsCanLoad)
{
try {
if (tcpClnt == null)
{
tcpClnt = Connect();
if (tcpClnt == null)
{
Thread.Sleep(500);
continue;
}
stream = tcpClnt.GetStream();
string sendMessage;
if (isConnect)//если список инструментов с сервера мы уже получили
{
sendMessage = "Reconnect;" + Vars.login + "," + Vars.pass + ";\n";
}
else//если список инструментов с сервера мы ещё не получали
{
sendMessage = "Connect;" + Vars.login + "," + Vars.pass + ";\n";
}
if (!WriteMessage(sendMessage, stream))
{
tcpClnt.Close();
tcpClnt = null;
continue;
}
int n = 0;
while (!stream.DataAvailable && n < 50)
{
Thread.Sleep(200);
n++;
}
if (!stream.DataAvailable)
{
tcpClnt.Close();
tcpClnt = null;
continue;
}
string message = ReadMessage(stream);
if (message == "Error")
{
tcpClnt.Close();
tcpClnt = null;
continue;
}
string[] messageSplit = message.Split(';');
if (messageSplit[0] == "WrongLogin")
{
tcpClnt.Close();
tcpClnt = null;//после обрыва цыкла на сервер не нужно отправлять "Disconnect", т.к. на сервере TcpClient уже закрыт
serverResponse = "WrongLogin";
break;
}
if (!isConnect)//если список инструментов с сервера мы ещё не получали
{
if (messageSplit[0] == "LoginOK" && messageSplit.Length > 1 && messageSplit[1] != "")
{
int currentRttVersion = Convert.ToInt32(messageSplit[1]);
if (currentRttVersion > RTT_Version)
{
serverResponse = "NeedUpdate";
break;//после обрыва цыкла на сервер отправиться "Disconnect"
}
else if (messageSplit.Length == 4 && ParseSymbolsContracts(messageSplit[2], false) == "LoginOK")
{
if (Vars.InstrumentsInfoDictionary.Count == 0)
{
serverResponse = "NeedUpdate";
break;//после обрыва цыкла на сервер отправиться "Disconnect"
}
else
{
isConnect = true;//идентифицируем что список инструментов с сервера мы уже получили
}
}
else
{
tcpClnt.Close();
tcpClnt = null;
continue;
}
}
else//messageSplit[0] == "ServerError"
{
tcpClnt.Close();
tcpClnt = null;
continue;
}
}
//else isConnect == true, значит на сервер отправляли запрос "Reconnect", значит messageSplit[0] по-любому == "LoginOK"
serverRecponceLastTime = DateTime.Now;
timeStampLastQuery = new DateTime();
}
string serverQuery = "";
if ((DateTime.Now - timeStampLastQuery).TotalSeconds >= 30)
{
serverQuery = "T;\n";
timeStampLastQuery = DateTime.Now;
}
serverQuery += GetServerQueryes();
if (serverQuery == "")
{
Thread.Sleep(500);
continue;
}
serverQuery += "!!EndMsg!!\n";
stream.Flush();
if (!WriteMessage(serverQuery, stream))
{
tcpClnt.Close();
tcpClnt = null;
continue;
}
int i = 0;
string brokenLine = "";
start:
while (!stream.DataAvailable && i < 50)
{
Thread.Sleep(200);
i++;
}
if (!stream.DataAvailable)
{
tcpClnt.Close();
tcpClnt = null;
continue;
}
string incomeMessage = ReadDecoder(stream);
if (incomeMessage != "" && incomeMessage != "Error")
{
bool isEndMsg = ProcessReceive(incomeMessage, brokenLine, tcpClnt, out brokenLine, out serverResponse);
serverRecponceLastTime = DateTime.Now;
if (!isEndMsg)
{
i = 35;
goto start;
}
}
else if (incomeMessage == "Error" || (DateTime.Now - serverRecponceLastTime).TotalSeconds > 60)
{
tcpClnt.Close();
tcpClnt = null;
}
}
catch {
tcpClnt.Close();
tcpClnt = null;
}
}
if (tcpClnt != null)
{
WriteMessage("Disconnect;" + Vars.login + ";\n!!EndMsg!!\n", stream);
tcpClnt.Close();
tcpClnt = null;
}
IsCanLoad = false;
e.Result = serverResponse;
}
private void Listening()
{
byte[] bytesFrom = new byte[2048];
while (abortListener)
{
try
{
using (System.Net.Sockets.TcpClient client = server.AcceptTcpClient())
{
Logger.I("New request");
using (NetworkStream stream = client.GetStream())
{
stream.Read(bytesFrom, 0, bytesFrom.Length);
try
{
String strdata = Encoding.GetEncoding("Windows-1254").GetString(bytesFrom);
if (strdata != null)
{
Logger.I(string.Concat("Command:", strdata));
string[] strarr = strdata.Split('|');
if (strarr != null && strarr.Length > 1)
{
if (stream.CanWrite)
{
if (_kameralar != null && _kameralar.Count > 0)
{
long id = 0;
if (long.TryParse(strarr[1], out id))
{
List <byte[]> images = new List <byte[]>();
for (int loop = 0; loop < _kameralar.Count; loop++)
{
if (_kameralar[loop].CaptureImage != null)
{
byte[] byteimage = _kameralar[loop].CaptureImage.ToArray();
images.Add(byteimage);
}
}
Task.Run(() => AddImage(Convert.ToInt64(strarr[1]), images));
}
else
{
Logger.E("Gelen bilgiler hatalı (seq)!");
}
byte[] nullbyt = new byte[512];
stream.Write(nullbyt, 0, nullbyt.Length);
stream.Flush();
stream.Close();
}
else
{
byte[] resp = new byte[1024];
stream.Write(resp, 0, resp.Length);
stream.Flush();
stream.Close();
}
}
client.Close();
Logger.I("Socket closed");
}
}
}
catch (IOException ioex)
{
Logger.E(ioex);
}
catch (Exception e1)
{
Logger.E(e1);
}
}
}
}
catch (Exception ex)
{
Logger.E(ex);
}
}
Logger.E(" >> exit");
}
private void Query(Uri uri, string method, Dictionary <string, string> headers, string body)
{
//build the request string we'll be sending to the server
string request = string.Format("{0} {1} HTTP/1.1\r\n", method.ToUpper(), uri.PathAndQuery);
if (headers == null)
{
headers = new Dictionary <string, string>();
}
if (body == null)
{
body = "";
}
if (!headers.ContainsKey("Host"))
{
request += string.Format("Host: {0}:{1}\r\n", uri.Host, uri.Port);
}
foreach (KeyValuePair <string, string> header in headers)
{
if (header.Key.Contains(":"))
{
throw new Exception("headers cannot contain ':'");
}
request += string.Format("{0}: {1}\r\n", header.Key, header.Value);
}
// we don't support persistant connections yet, so tell the server to close the connection
request += "Connection: close\r\n";
//add content length if it's not in the header collection
if (!headers.ContainsKey("Content-Length") && body.Length != 0)
{
request += string.Format("Content-Length: {1}\r\n", body.Length);
}
request += "\r\n";
request += body;
//open a socket connection to the host and port in the uri
TcpClient clientSocket = new TcpClient();
clientSocket.Connect(uri.Host, uri.Port);
//send the request we built to the server
NetworkStream serverStream = clientSocket.GetStream();
byte[] outStream = Encoding.ASCII.GetBytes(request);
serverStream.Write(outStream, 0, outStream.Length);
serverStream.Flush();
//get the response a string
StreamReader reader = new StreamReader(serverStream);
string response = reader.ReadToEnd();
if (!response.StartsWith("HTTP"))
{
throw new Exception("server did not respond with a proper http response: " + response);
}
//parse the response from the server
string[] responseSplit = response.Split(new string[] { "\r\n\r\n" }, 2, StringSplitOptions.None);
if (responseSplit.Length != 2)
{
throw new Exception("server did not give a proper Http response: " + response);
}
string[] headerSplit = responseSplit[0].Split(new string[] { "\r\n" }, StringSplitOptions.None);
ResponseHeaders = new Dictionary <string, string>();
string responseStatusLine = headerSplit[0];
string[] statusLineSplit = responseStatusLine.Split(new char[] { ' ' }, 3);
HttpVersion = statusLineSplit[0];
StatusCode = Convert.ToInt32(statusLineSplit[1]);
StatusMessage = statusLineSplit[2];
for (int c = 1; c < headerSplit.Length; c++)
{
string[] headerKvp = headerSplit[c].Split(new char[] { ':' }, 2, StringSplitOptions.None);
ResponseHeaders.Add(headerKvp[0].Trim(), headerKvp[1].Trim());
}
ResponseBody = responseSplit[1];
}
public void ServerRequest(ClientCallback callback, int mtype, string req)
{
IPAddress ad = Dns.GetHostAddresses("dankdankdank.ddns.net")[0];
MessageConstants.InitValues();
TcpClient client = new TcpClient();
IPEndPoint serverEndPoint = new IPEndPoint(ad, 42666);
client.Connect(serverEndPoint);
NetworkStream clientStream = client.GetStream();
ASCIIEncoding encoder = new ASCIIEncoding();
byte[] buffer = encoder.GetBytes(MessageConstants.MessageTypes[mtype] + req + MessageConstants.completeToken);
clientStream.Write(buffer, 0, buffer.Length);
clientStream.Flush();
TcpClient tcpClient = (TcpClient)client;
clientStream = tcpClient.GetStream();
byte[] message = new byte[4096];
int bytesRead;
string reply = "";
bytesRead = 0;
try
{
//blocks until a client sends a message
bytesRead = clientStream.Read(message, 0, 4096);
//keep reading until the message is done;
while (bytesRead != 0)
{
//message has successfully been received
encoder = new ASCIIEncoding();
reply += encoder.GetString(message, 0, bytesRead);
if (reply.Substring(reply.Length - MessageConstants.completeToken.Length, MessageConstants.completeToken.Length) == MessageConstants.completeToken)
{
break;
}
if (bytesRead < 4096)
{
// break;
}
bytesRead = clientStream.Read(message, 0, 4096);
}
}
catch
{
//a socket error has occured
return;
}
if (bytesRead == 0)
{
//the client has disconnected from the server
return;
}
List <List <string> > transmission = Decodetransmission(reply);
if (transmission[0][0] == MessageConstants.MessageTypes[mtype])
{
callback(transmission);
}
}
private void sendmsg_KeyUp(object sender, KeyEventArgs e)
{
Random random = new Random();
if (e.KeyCode == Keys.Enter)
{
byte[] bByte = new byte[Marshal.SizeOf(__user)];
try
{
if (connect_flag)
{
if (sendmsg.Text != string.Empty)
{
byte[] test_byte = new byte[30];
MemoryStream m = new MemoryStream(test_byte);
BinaryWriter bw = new BinaryWriter(m);
switch (sendmsg.Text)
{
case "up":
__user.p_h = (ushort)e_Packet_header.P_MOVE_POS;
__user.p_h_sec = (ushort)e_Packet_move_pos.P_S_MOVE_UP;
break;
case "down":
__user.p_h = (ushort)e_Packet_header.P_MOVE_POS;
__user.p_h_sec = (ushort)e_Packet_move_pos.P_S_MOVE_DOWN;
break;
case "left":
__user.p_h = (ushort)e_Packet_header.P_MOVE_POS;
__user.p_h_sec = (ushort)e_Packet_move_pos.P_S_MOVE_LEFT;
break;
case "right":
__user.p_h = (ushort)e_Packet_header.P_MOVE_POS;
__user.p_h_sec = (ushort)e_Packet_move_pos.P_S_MOVE_RIGHT;
break;
case "rand":
__user.p_h = (ushort)e_Packet_header.P_MOVE_POS;
__user.p_h_sec = (ushort)e_Packet_move_pos.P_S_MOVE_RAND_TELEPORT;
break;
case "rmsg":
__user.p_h = (ushort)e_Packet_header.P_SEND_MSG;
break;
default:
__user.p_h = (ushort)e_Packet_header.P_MOVE_POS;
__user.p_h_sec = (ushort)e_Packet_move_pos.P_S_MOVE_NONE;
break;
}
/* Attack Command to monster */
if (sendmsg.Text.Contains("attack") == true)
{
__user.msg = sendmsg.Text.ToString();
string str_monster_idx;
int int_monster_idx;
str_monster_idx = sendmsg.Text.Substring(7);
__user.p_h = (ushort)e_Packet_header.P_USER_ACTIVITY;
__user.p_h_sec = (ushort)e_Packet_user_activity_pos.P_S_ACTIVITY_ATTACK_TO_MONSTER;
bw.Write(__user.p_h);
bw.Write(__user.p_h_sec);
bool result = Int32.TryParse(str_monster_idx, out int_monster_idx);
if (result == false)
{
sendmsg.Text = "";
return;
}
bw.Write(int_monster_idx);
bw.Close();
ns.Write(test_byte
, 0
, 30);
ns.Flush();
}
/* Attack Command to other user */
if (sendmsg.Text.Contains("atp") == true)
{
__user.msg = sendmsg.Text.ToString();
string str_other_player_idx;
int int_other_player_idx;
str_other_player_idx = sendmsg.Text.Substring(4);
__user.p_h = (ushort)e_Packet_header.P_USER_ACTIVITY;
__user.p_h_sec = (ushort)e_Packet_user_activity_pos.P_S_ACTIVITY_ATTACK_TO_PLAYER;
bw.Write(__user.p_h);
bw.Write(__user.p_h_sec);
bool result = Int32.TryParse(str_other_player_idx, out int_other_player_idx);
if (result == false)
{
sendmsg.Text = "";
return;
}
bw.Write(int_other_player_idx);
bw.Close();
ns.Write(test_byte
, 0
, 30);
ns.Flush();
}
if (sendmsg.Text.Contains("sk") == true)
{
__user.msg = sendmsg.Text.ToString();
__user.p_h = (ushort)e_Packet_header.P_USER_ACTIVITY;
__user.p_h_sec = (ushort)e_Packet_user_activity_pos.P_S_ACTIVITY_SKILL;
bw.Write(__user.p_h);
bw.Write(__user.p_h_sec);
bw.Write(__user.state.level);
bw.Write(__user.state.hp);
bw.Close();
ns.Write(test_byte
, 0
, 30);
ns.Flush();
}
if (__user.p_h == (ushort)e_Packet_header.P_MOVE_POS)
{
__user.msg = sendmsg.Text.ToString();
bw.Write(__user.p_h);
bw.Write(__user.p_h_sec);
bw.Write(__user.x);
bw.Write(__user.y);
bw.Write(__user.zone);
bw.Close();
ns.Write(test_byte
, 0
, 30);
ns.Flush();
}
else if (__user.p_h == (ushort)e_Packet_header.P_SEND_MSG)
{
__user.msg = sendmsg.Text.ToString();
bw.Write(__user.p_h);
bw.Write(__user.msg);
bw.Close();
ns.Write(test_byte
, 0
, 30);
ns.Flush();
}
else
{
}
sendmsg.Text = "";
#if false
IntPtr Ptr = Marshal.AllocHGlobal(Marshal.SizeOf(__user));
Marshal.StructureToPtr(__user, Ptr, false);
Marshal.Copy(Ptr, bByte, 0, Marshal.SizeOf(__user));
ns.Write(bByte
, 0
, Marshal.SizeOf(typeof(_User)));
ns.Flush();
sendmsg.Text = "";
#endif
}
}
}
catch (Exception ex)
{
connect_flag = false;
MessageBox.Show(ex.ToString());
}
}
}
public void sendData(string data)
{
try
{
byte[] outStream;
byte[] inStream;
string returndata = "";
serverStream = clientSocket.GetStream();
outStream = System.Text.Encoding.ASCII.GetBytes(data + "<EOF>");
serverStream.Write(outStream, 0, outStream.Length);
serverStream.Flush();
inStream = new byte[transferDataSize];
serverStream.Read(inStream, 0, transferDataSize);
returndata = System.Text.Encoding.ASCII.GetString(inStream);
returndata = returndata.Substring(0, returndata.IndexOf("<EOF>"));
if (returndata.IndexOf("*signupsucceed*") > -1)
{
signedUp = true;
GameController.currentState = GameController.GameState.GAME_PLAY;
thSendStatus.Start();
}
else if (returndata.IndexOf("*loginsucceed*") > -1)
{
loggedIn = true;
string posX;
string posY;
string savedScore;
float xInit;
float yInit;
int subStartIndex = returndata.IndexOf("posX:") + "posX:".Length;
posX = returndata.Substring(subStartIndex);
posX = posX.Substring(0, posX.IndexOf("posY:"));
xInit = float.Parse(posX, CultureInfo.InvariantCulture);
subStartIndex = returndata.IndexOf("posY:") + "posY:".Length;
posY = returndata.Substring(subStartIndex);
posY = posY.Substring(0, posY.IndexOf("score:"));
yInit = float.Parse(posY, CultureInfo.InvariantCulture);
subStartIndex = returndata.IndexOf("score:") + "score:".Length;
savedScore = returndata.Substring(subStartIndex);
GameController.score = int.Parse(savedScore);
Debug.Log("1: " + xInit + " 2: " + yInit + " 3: " + GameController.score);
InputController.userPosX = xInit;
InputController.userPosY = yInit;
GameController.currentState = GameController.GameState.GAME_PLAY;
thSendStatus.Start();
}
else if (returndata.IndexOf("*signupfailed*") > -1)
{
GameController.currentState = GameController.GameState.SIGN_UP;
}
else if (returndata.IndexOf("*loginfailed*") > -1)
{
GameController.currentState = GameController.GameState.LOG_IN;
}
else if (returndata.IndexOf("*others*") > -1)
{
parseOthersInfos(returndata);
}
}
catch (Exception e)
{
Debug.Log(e.Message);
clientSocket.Close();
ClientController.disconnected();
}
}
public void Close()
{
stream.Flush();
stream.Close();
}
/// <summary>
/// 读取一个数据表,出错返回ErrorClient：或ErrorServer：
/// </summary>
internal DataTable TCPDataTable(string strIn, ref string strError)
{
byte[] btArr = null;//返回的数
IPEndPoint ipep = new IPEndPoint(IPAddress.Parse(ipaddr), port);
Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, iTimeOut);
server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, iTimeOut);
try
{
server.Connect(ipep); //试着连接服务器
NetworkStream ns = new NetworkStream(server);
StreamReader sr = new StreamReader(ns);
StreamWriter sw = new StreamWriter(ns);
sw.WriteLine(strIn);
sw.Flush();
btArr = new byte[LCache];
int length = ns.Read(btArr, 0, btArr.Length);
ns.Flush();
string strinfo = Encoding.Default.GetString(btArr, 0, ((length < 50) ? length : 50));
if (strinfo.Trim().StartsWith("ErrorServer:"))
{
strError = Encoding.Default.GetString(btArr, 0, length);
btArr = null;
}
if (strinfo.StartsWith("ErrorBig"))//缓冲区长度不够//重设长度//回"ErrorOK:"//重新接收
{
int serverleng = Convert.ToInt32(strinfo.Substring(strinfo.IndexOf(":") + 1).Trim());
sw.WriteLine("ErrorOK:");
sw.Flush();
//服务器有可能没有输入流，要等一等
btArr = new byte[serverleng];
int iHas = 0;
while (iHas < serverleng)
{
int L = ns.Read(btArr, iHas, serverleng - iHas);
iHas += L;
}
}
sr.Close();
sw.Close();
ns.Close();
server.Shutdown(SocketShutdown.Both);
server.Close();
}
catch (Exception e)
{
strError = "ErrorClient:" + e.Message;
}
if (server.Connected)
{
server.Shutdown(SocketShutdown.Both);
server.Close();
}
DataTable dt = new DataTable();
if (btArr != null && strError.Length == 0)
{
dt = (DataTable)this.Ser.deSerialize(btArr);
}
return(dt);
}
static void Main(string[] args)
{
TcpListener serverSocket = new TcpListener(8888);
int requestCount = 0;
TcpClient clientSocket = default(TcpClient);
serverSocket.Start();
Console.WriteLine(" >> Server Started");
clientSocket = serverSocket.AcceptTcpClient();
Console.WriteLine(" >> Accept connection from client");
requestCount = 0;
while ((true))
{
try
{
requestCount = requestCount + 1;
NetworkStream networkStream = clientSocket.GetStream();
byte[] bytesFrom = new byte[10025];
try
{
if (!clientSocket.Connected)
{
Console.WriteLine("Client is not Online!");
break;
}
networkStream.Read(bytesFrom, 0, (int)clientSocket.ReceiveBufferSize);
}
catch (Exception)
{
Console.WriteLine("Client is not Online!");
break;
}
string dataFromClient = System.Text.Encoding.ASCII.GetString(bytesFrom);
dataFromClient = dataFromClient.Substring(0, dataFromClient.IndexOf("$"));
Console.WriteLine(" >> Data from client - " + dataFromClient);
string mesg, rev = "";
mesg = dataFromClient;
int len = mesg.Length - 1;
for (; len >= 0; len--)
{
rev = rev + mesg[len];
}
string serverResponse = "Last Message from client:- " + rev;
Byte[] sendBytes = Encoding.ASCII.GetBytes(serverResponse);
networkStream.Write(sendBytes, 0, sendBytes.Length);
networkStream.Flush();
Console.WriteLine(" >> " + serverResponse);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
clientSocket.Close();
serverSocket.Stop();
Console.WriteLine(" >> exit");
Console.ReadLine();
}
public static string download(BackgroundWorker worker, PendingResponse pr, DownloadProgress dp, long startByte)
{
TcpClient tcpClient = new TcpClient();
NetworkStream clientStream = null;
try
{
tcpClient.Connect(pr.uploaderIP, 8002);
clientStream = tcpClient.GetStream();
Utils.writeLog("download: Sending download instruction to peer " + pr.uploaderIP + "...");
//Format: fileHash | transfer ID | transfer-type
Utils.writeLog("tid is " + pr.transferID);
ASCIIEncoding encoder = new ASCIIEncoding();
byte[] buffer = encoder.GetBytes(pr.fileHash + "|" + pr.transferID + "|" + pr.type + "|" + startByte);
clientStream.Write(buffer, 0, buffer.Length);
clientStream.Flush();
Utils.writeLog("download: Download started.");
}
catch (Exception e)
{
Utils.writeLog("download: Could not establish connection. Error : " + e);
dp.isFailed = true;
return(postDownload(dp, pr, worker));
}
// Begin file transfer
FileStream strLocal = null;
Downloads.currentDownloads.Add(dp);
// Add the download to the gridview
worker.ReportProgress(0, dp);
#region initvars
long bytesDownloaded = startByte; //Total bytes downloaded for the file
int bytesSize; //Number of bytes read by the stream reader
int tempTransferRate = 0; //Instantaneous (for 1 refresh cycle) download rate
long downloadedInCycle = 0; //Total bytes downloaded in the last refresh cycle
int percentComplete = 0;
DateTime startTime = DateTime.Now; //To track total download time
DateTime refresh = DateTime.Now; //To track time since last refresh
byte[] downBuffer = new byte[4096];
bool appendToExistingFile = false;
// Find a free filename
if (File.Exists(dp.downloadedFilePath))
{
long existingFileLength = new FileInfo(dp.downloadedFilePath).Length;
// First file found should be appended to
if (startByte > 0 && startByte == existingFileLength)
{
appendToExistingFile = true;
}
else
{
String candidatePath = "";
for (int i = 2; i < 100; i++) // 100 here is arbitrary, just want to make sure it doesnt loop forever
{
candidatePath = dp.downloadedFilePath.Substring(0, dp.downloadedFilePath.LastIndexOf('.'));
candidatePath += " (" + i + ")";
candidatePath += dp.downloadedFilePath.Substring(dp.downloadedFilePath.LastIndexOf('.'));
if (!File.Exists(candidatePath))
{
Utils.writeLog("download: Found free file path " + candidatePath);
dp.downloadedFilePath = candidatePath;
dp.fileName = dp.downloadedFilePath.Substring(dp.downloadedFilePath.LastIndexOf(@"\") + 1);
break;
}
else
{
existingFileLength = new FileInfo(candidatePath).Length;
if (startByte > 0 && startByte == existingFileLength)
{
dp.downloadedFilePath = candidatePath;
appendToExistingFile = true;
break;
}
}
}
}
}
try
{
if (appendToExistingFile)
{
strLocal = new FileStream(dp.downloadedFilePath,
FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
}
else
{
strLocal = new FileStream(dp.downloadedFilePath,
FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
}
}
catch (Exception e)
{
Utils.writeLog("download: Error creating file : " + e);
// Attempt to recover from error that download folder doesn't exist.
String filePath = dp.downloadedFilePath;
String folderPath = filePath.Substring(0, filePath.LastIndexOf("\\"));
try
{
System.IO.Directory.CreateDirectory(folderPath);
strLocal = new FileStream(dp.downloadedFilePath,
FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
}
catch (Exception e2)
{
Utils.writeLog("download: Unrecoverable error while creating folder to hold file");
MessageBox.Show("Could not download file as the download folder could not be found or created",
"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(null);
}
}
Settings.Default.partiallyDownloadedFiles = dp.downloadedFilePath + "; " +
Settings.Default.partiallyDownloadedFiles;
#endregion
try
{
// Perform file transfer.
clientStream.ReadTimeout = 6000; // Need to timeout now to prevent stalled appearance in UI
while ((bytesSize = clientStream.Read(downBuffer, 0, downBuffer.Length)) > 0)
{
// In case user cancels download
if (pendingToDownload[pr] == null || worker.CancellationPending)
{
throw new DownloadCanceledException("Download canceled");
}
downloadedInCycle += bytesSize;
bytesDownloaded = bytesDownloaded + bytesSize;
dp.bytesDownloaded = bytesDownloaded;
strLocal.Write(downBuffer, 0, bytesSize);
if (pr.fileSize != 0)
{
percentComplete = (int)(100 * bytesDownloaded / pr.fileSize);
}
// Report progress to UI at intervals
double msElapsedSinceRefresh = (DateTime.Now - refresh).TotalMilliseconds;
if (msElapsedSinceRefresh > 1000)
{
tempTransferRate = (int)((downloadedInCycle / 1024.0) / (DateTime.Now - refresh).TotalSeconds);
dp.status = "Downloading";
// Initialize download speed
if (dp.averageTransferRate == 0)
{
dp.averageTransferRate = tempTransferRate;
}
// Compute download speed with smoothing factor
dp.transferRate = tempTransferRate;
dp.averageTransferRate = (0.01) * tempTransferRate + (0.99) * dp.averageTransferRate;
worker.ReportProgress(percentComplete, dp);
refresh = DateTime.Now;
downloadedInCycle = 0;
}
}
dp.bytesDownloaded = bytesDownloaded;
dp.transferRate = tempTransferRate;
worker.ReportProgress(100, dp);
Utils.writeLog("download: Completed download of " + pr.fileName +
" (" + dp.fileSize + ") Type:" + dp.type);
dp.status = "Checking file..";
}
catch (DownloadCanceledException dce) // Occurs when user cancels
{
Utils.writeLog("download: Canceled by user");
dp.status = "Canceled";
dp.isCanceled = true;
}
catch (Exception e) // Should only occur due to poor network/peer going offline
{
Utils.writeLog("download: Error:" + e.ToString());
dp.status = "Failed";
dp.isFailed = true;
}
finally
{
worker.ReportProgress(percentComplete, dp);
strLocal.Close();
clientStream.Close();
}
return(postDownload(dp, pr, worker));
}
public void Dispose()
{
stream?.Flush();
stream?.Dispose();
stream = null;
}
// Resposnd the requests made
protected void RequestResponse()
{
Encoding ASCII = Encoding.ASCII;
NetworkStream DataStream = new NetworkStream(newSock);
try
{
Byte[] readBytes = new Byte[1024], read = new Byte[1024];
string[] ChatInfo;
int bytes = 0, UploadDownloadPrint;
bool responseWritten = false;
FileStream fs1 = null;
// read what the browser wrote on its stream and
bytes = DataStream.Read(read, 0, read.Length);
// make a temporary file
FileStream fs = new FileStream(Application.StartupPath + "\\Temp.xml", FileMode.OpenOrCreate);
// to store that data to
BinaryWriter w = new BinaryWriter(fs);
w.Write(read, 0, bytes);
w.Close();
fs.Close();
// then read file and detrmine the kind of request
xmlCreater = new XMLCreater(Application.StartupPath + "\\Temp1.xml", Application.StartupPath + "\\Share.ini");
string DnLoadFile = xmlCreater.DetermineRequestType(Application.StartupPath + "\\Temp.xml", out UploadDownloadPrint, out ChatInfo);
// if it's download/upload request make file object for
// the file browser has requested to upload to
// or download from his comp
if (UploadDownloadPrint == 4) // this represents a chat request
{
frmChat oChatFrm = new frmChat(ChatInfo, newSock, LoginName, Application.StartupPath + "\\ChatLog.log", ++ChatWindowCount);
oChatFrm.ShowDialog();
File.Delete(Application.StartupPath + "\\Temp.xml");
bDownLoading = false;
return;
}
if (DnLoadFile.Length != 0)
{
if (UploadDownloadPrint == 1)
{
fs1 = new FileStream(DnLoadFile, FileMode.CreateNew);
DnLoadFile.EndsWith("mp3");
}
else if (UploadDownloadPrint == 2)
{
fs1 = new FileStream(DnLoadFile, FileMode.Open);
}
else if (UploadDownloadPrint == 3)
{
ShellExecute(0, "print", DnLoadFile, "", "", 1);
File.Delete(Application.StartupPath + "\\Temp.xml");
DataStream.Flush();
newSock.Close();
bDownLoading = false;
return;
}
if (UploadDownloadPrint == 5) // this represents a chat request
{
StreamIt streamDlg = new StreamIt(DnLoadFile, new StreamingCallBackDeligates(StreamingCallBack));
streamDlg.ShowDialog();
intStreamingThreadIndex = ThreadCount;
bDownLoading = false;
return;
}
}
else
{
// else make a file object for responding in xml formate
fs1 = new FileStream(Application.StartupPath + "\\Temp1.xml", FileMode.Open);
responseWritten = true;
}
// write resoponse
if (UploadDownloadPrint == 1)
{
bDownLoading = true;
// if it was upload request
BinaryWriter wr = new BinaryWriter(fs1);
int nreadBytes;
// read network stream and write data to a loacal file
while ((nreadBytes = DataStream.Read(readBytes, 0, readBytes.Length)) > 0)
{
wr.Write(readBytes, 0, nreadBytes);
}
wr.Close();
fs1.Close();
}
else
{
// write the response or file requested for download
// in browsers stream
BinaryReader r = new BinaryReader(fs1);
int nreadBytes;
// write upon the network stream
while ((nreadBytes = r.Read(readBytes, 0, readBytes.Length)) > 0)
{
DataStream.Write(readBytes, 0, nreadBytes);
}
r.Close();
fs1.Close();
}
// delete all temporary files
if (responseWritten)
{
File.Delete(Application.StartupPath + "\\Temp1.xml");
}
File.Delete(Application.StartupPath + "\\Temp.xml");
DataStream.Flush();
newSock.Close();
bDownLoading = false;
}
catch (SocketException e) { WriteErrorLog("Responding Browser", e.Message); }
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="bytes">待发送的字节数组</param>
/// <param name="callback">回调函数</param>
public void Send(byte[] bytes, SendCallback callback = null)
{
// 发送信息
_stream.Write(bytes, 0, bytes.Length);
_stream.Flush();
// 当设置了回调后，开始等待接收数据
if (callback != null)
{
// 结束和超时标志
bool isEnd = false;
// 设置回车标志
bool r = false;
// 设置字节列表
_command = new List <byte>();
// 设置当未满足结束和未超时时进行循环
while (!isEnd)
{
// 根据当前模式读取数据
if (this.DataMode)
{
#region [=====数据模式=====]
// 根据缓存大小读取数据
int len = _stream.Read(_buffer, _offset, _buffer.Length - _offset);
// 增加数据偏移
_offset += len;
// 判断数据是否读取完毕,如已读取完毕，则开始处理业务
if (_offset >= _buffer.Length)
{
// 获取数据字符串
string data = System.Text.Encoding.UTF8.GetString(_buffer);
// 执行业务调用
using (ClientHostRecieveEventArgs e = new ClientHostRecieveEventArgs()) {
e.Client = this;
e.Content = data;
//执行宿主事件
_host.OnRecieve(e);
if (e.Result == HostEventResults.Finished)
{
// 设置回调
callback(e.ResultData);
// 设置结束标志
isEnd = true;
}
}
// 设置为命令模式
SetCommandMode();
}
#endregion
}
else
{
#region [=====命令模式=====]
//命令模式,判断换行标志提取命令
// 读取一个字节
int bs = _stream.ReadByte();
if (bs >= 0)
{
// 读入正常数据后进行数据解析
switch (bs)
{
case 13: //回车(\r)
// 出现两个连续的回车标志则视为非常规
if (r)
{
//调试输出错误信息
Debug.WriteLine("-> Error:规则外的回车符");
}
r = true;
break;
case 10: //换行(\n)
if (r)
{
//获取行命令并重置回车标志
string cmd = System.Text.Encoding.UTF8.GetString(_command.ToArray());
r = false;
//执行业务调用
using (ClientHostRecieveEventArgs e = new ClientHostRecieveEventArgs()) {
e.Client = this;
e.Content = cmd;
//执行宿主事件
_host.OnRecieve(e);
if (e.Result == HostEventResults.Finished)
{
// 设置回调
callback(e.ResultData);
// 设置结束标志
isEnd = true;
}
}
}
else
{
//调试输出错误信息
Debug.WriteLine("-> Error:规则外的换行符");
}
// 清除命令字节列表
_command.Clear();
break;
default:
// 正常情况下，不应该在此处出现回车标志
if (r)
{
//调试输出错误信息
Debug.WriteLine("-> Error:规则外的换行符");
// 清除命令字节列表并重置回车标志
_command.Clear();
r = false;
}
// 将命令字符加入命令字节列表中
_command.Add((byte)bs);
break;
}
}
else
{
// 未读取数据，则线程等待毫秒，防止线程阻塞
System.Threading.Thread.Sleep(10);
}
#endregion
}
}
}
}
void metadataAction()
{
var metadataReq = TopicMetadataRequest.Create(null, 0, 0, this.config.ConsumerId);
var sendBytes = metadataReq.Serialize();
var bk = sockets.First();
var bid = bk.Key;
var socket = bk.Value;
IEnumerable <TopicMetadataResponseTopicInfo> response = null;
DateTime startUtc = DateTime.UtcNow;
logger.Debug("metadataAction => lock on socket wait for " + bid);
lock (socket)
{
logger.Debug("metadataAction => lock on socket acquired " + bid + " in " +
TimeSpan.FromTicks(DateTime.UtcNow.Ticks - startUtc.Ticks).TotalSeconds + " seconds");
if (!socket.Connected)
{
socket.Connect(socket.RemoteEndPoint);
}
NetworkStream stream = new NetworkStream(socket)
{
ReadTimeout = this.config.ReceiveTimeout,
WriteTimeout = this.config.SendTimeout
};
stream.Write(sendBytes, 0, sendBytes.Length);
stream.Flush();
var reader = new KafkaBinaryReader(stream);
// parse data
response = TopicMetadataRequest.ParseFrom(reader).TopicMetadatas;
}
if (response == null)
{
throw new Exception("[UNHANDLED-EXCEPTION] null MetadataResponse");
}
logger.Debug("metadataAction => metadata response from broker " + bid + " received in " +
TimeSpan.FromTicks(DateTime.UtcNow.Ticks - startUtc.Ticks).TotalSeconds + " seconds");
brokerOrderedMetadatas.Clear();
foreach (var metadata in response)
{
foreach (var p in metadata.PartitionsMetadata)
{
logger.Debug("metadataAction => topic:" + metadata.Topic + ",partition:" + p.PartitionId + ",leader" +
p.Leader.Id);
if (!brokerOrderedMetadatas.ContainsKey(p.Leader.Id))
{
brokerOrderedMetadatas.Add(p.Leader.Id,
new Dictionary <string, List <TopicMetadataResponsePartitionInfo> >());
}
if (!brokerOrderedMetadatas[p.Leader.Id].ContainsKey(metadata.Topic))
{
brokerOrderedMetadatas[p.Leader.Id].Add(metadata.Topic, new List <TopicMetadataResponsePartitionInfo>());
}
brokerOrderedMetadatas[p.Leader.Id][metadata.Topic].Add(p);
}
}
}
public BlindPacket CryptoReceive(bool isRecieving = false)
{
byte[] data = new byte[BlindNetConst.MINIPACKSIZE];
int rcvNum = 0;
byte[] decrypted = null;
BlindMiniPacket miniPacket = new BlindMiniPacket();
if (!isRecieving)
{
rcvNum = socket.Receive(data, BlindNetConst.MINIPACKSIZE, SocketFlags.None);
using (NetworkStream stream = new NetworkStream(socket))
stream.Flush();
if (rcvNum == 0)
{
BlindPacket end;
end.data = null;
end.header = PacketType.Disconnect;
return(end);
}
byte[] temp = new byte[BlindNetConst.MINIPACKSIZE];
temp[0] = (byte)PacketType.OK;
socket.Send(temp, BlindNetConst.MINIPACKSIZE, SocketFlags.None);
decrypted = aes.Decryption(data);
miniPacket = BlindNetUtil.ByteToStruct <BlindMiniPacket>(decrypted);
}
if (isRecieving || miniPacket.header == PacketType.MSG)
{
data = new byte[0];
while (true)
{
byte[] tmp = new byte[BlindNetConst.PACKSIZE];
rcvNum = socket.Receive(tmp, BlindNetConst.PACKSIZE - data.Length, SocketFlags.None);
using (NetworkStream stream = new NetworkStream(socket))
stream.Flush();
#if DEBUG
if (tmp[tmp.Length - 1] == 0)
{
Console.WriteLine("Received less bytes");
}
#endif
if (rcvNum == 0)
{
BlindPacket end;
end.data = null;
end.header = PacketType.Disconnect;
return(end);
}
data = BlindNetUtil.MergeArray <byte>(data, BlindNetUtil.ByteTrimEndNull(tmp));
if (data.Length == BlindNetConst.PACKSIZE)
{
byte[] temp = new byte[BlindNetConst.MINIPACKSIZE];
temp[0] = (byte)PacketType.OK;
socket.Send(temp, BlindNetConst.MINIPACKSIZE, SocketFlags.None);
using (NetworkStream stream = new NetworkStream(socket))
stream.Flush();
break;
}
#if DEBUG
else
{
Console.WriteLine("Data is {0} bytes", data.Length);
}
#endif
}
#if DEBUG
Console.WriteLine("Total received {0} bytes", data.Length);
#endif
decrypted = aes.Decryption(data);
}
return(BlindNetUtil.ByteToStruct <BlindPacket>(decrypted));
}
public override void Flush()
{
baseStream.Flush();
}
private void MainPanel_DragDrop(object sender, DragEventArgs e)
{
var data = e.Data.GetData(DataFormats.FileDrop);
if (data != null)
{
var fileNames = data as string[];
if (fileNames.Length > 0)
{
String selected_file = fileNames[0];
String file_name = Path.GetFileName(selected_file);
FileStream fs = new FileStream(selected_file, FileMode.Open);
TcpClient tc = new TcpClient(serverIP, FTPort);
NetworkStream ns = tc.GetStream();
byte[] data_tosend = CreateDataPacket(Encoding.UTF8.GetBytes("125"), Encoding.UTF8.GetBytes(file_name));
ns.Write(data_tosend, 0, data_tosend.Length);
ns.Flush();
Boolean loop_break = false;
//SendExtension();
while (true)
{
if (ns.ReadByte() == 2)
{
byte[] cmd_buff = new byte[3];
ns.Read(cmd_buff, 0, cmd_buff.Length);
byte[] recv_data = ReadStream(ns);
switch (Convert.ToInt32(Encoding.UTF8.GetString(cmd_buff)))
{
case 126:
long recv_file_pointer = long.Parse(Encoding.UTF8.GetString(recv_data));
if (recv_file_pointer != fs.Length)
{
//int SendProcess = (int)Math.Ceiling((double)recv_file_pointer / (double)fs.Length * 100);
//CreateSendProps(fileNames[0], SendProcess);
fs.Seek(recv_file_pointer, SeekOrigin.Begin);
int temp_buff_length = (int)(fs.Length - recv_file_pointer < 20000 ? fs.Length - recv_file_pointer : 20000);
byte[] temp_buff = new byte[temp_buff_length];
fs.Read(temp_buff, 0, temp_buff.Length);
byte[] data_to_send = CreateDataPacket(Encoding.UTF8.GetBytes("127"), temp_buff);
ns.Write(data_to_send, 0, data_to_send.Length);
ns.Flush();
int SendProcess = (int)Math.Ceiling((double)recv_file_pointer / (double)fs.Length * 100);
CreateSendProps(fileNames[0], SendProcess);
}
else
{
byte[] data_to_send = CreateDataPacket(Encoding.UTF8.GetBytes("128"), Encoding.UTF8.GetBytes("Close"));
ns.Write(data_to_send, 0, data_to_send.Length);
ns.Flush();
fs.Close();
loop_break = true;
}
break;
default:
break;
}
}
if (loop_break == true)
{
ns.Close();
break;
}
}
}
}
}
/// <summary>
/// Receive and process message
/// </summary>
protected virtual void OnReceiveMessage(object client)
{
TcpClient tcpClient = client as TcpClient;
NetworkStream stream = tcpClient.GetStream();
try
{
// Now read to a string
NHapi.Base.Parser.PipeParser parser = new NHapi.Base.Parser.PipeParser();
DateTime lastReceive = DateTime.Now;
while (this.m_timeout == TimeSpan.Zero || DateTime.Now.Subtract(lastReceive) < this.m_timeout)
{
if (!stream.DataAvailable)
{
Thread.Sleep(10);
continue;
}
// Read LLP head byte
int llpByte = stream.ReadByte();
if (llpByte != START_TX) // first byte must be HT
{
throw new InvalidOperationException("Invalid LLP First Byte");
}
// Standard stream stuff, read until the stream is exhausted
StringBuilder messageData = new StringBuilder();
byte[] buffer = new byte[1024];
bool receivedEOF = false, scanForCr = false;
while (!receivedEOF)
{
if (DateTime.Now.Subtract(lastReceive) > this.m_timeout)
{
throw new TimeoutException("Data not received in the specified amount of time. Increase the timeout or check the network connection");
}
if (!stream.DataAvailable)
{
Thread.Sleep(10);
continue;
}
int br = stream.Read(buffer, 0, 1024);
messageData.Append(System.Text.Encoding.UTF8.GetString(buffer, 0, br));
// Need to check for CR?
if (scanForCr)
{
receivedEOF = buffer[0] == END_TXNL;
}
else
{
// Look for FS
int fsPos = Array.IndexOf(buffer, (byte)END_TX);
if (fsPos == -1) // not found
{
continue;
}
else if (fsPos < buffer.Length - 1) // more room to read
{
receivedEOF = buffer[fsPos + 1] == END_TXNL;
}
else
{
scanForCr = true; // Cannot check the end of message for CR because there is no more room in the message buffer
}
// so need to check on the next loop
}
}
// Use the nHAPI parser to process the data
Hl7MessageReceivedEventArgs messageArgs = null;
try
{
// Setup local and remote receive endpoint data for auditing
var localEp = tcpClient.Client.LocalEndPoint as IPEndPoint;
var remoteEp = tcpClient.Client.RemoteEndPoint as IPEndPoint;
Uri localEndpoint = new Uri(String.Format("llp://{0}:{1}", localEp.Address, localEp.Port));
Uri remoteEndpoint = new Uri(String.Format("llp://{0}:{1}", remoteEp.Address, remoteEp.Port));
#if DEBUG
Trace.TraceInformation("Received message from llp://{0}:{1} : {2}", remoteEp.Address, remoteEp.Port, messageData);
#endif
// HACK: nHAPI doesn't like URLs ... Will fix this later
string messageString = messageData.ToString().Replace("|URL|", "|ST|");
var message = parser.Parse(messageString);
messageArgs = new Hl7MessageReceivedEventArgs(message, localEndpoint, remoteEndpoint, DateTime.Now);
// Call any bound event handlers that there is a message available
OnMessageReceived(messageArgs);
}
finally
{
// Send the response back
using (MemoryStream memoryWriter = new MemoryStream())
{
using (StreamWriter streamWriter = new StreamWriter(memoryWriter))
{
memoryWriter.Write(new byte[] { START_TX }, 0, 1); // header
if (messageArgs != null && messageArgs.Response != null)
{
var strMessage = parser.Encode(messageArgs.Response);
#if DEBUG
Trace.TraceInformation("Sending message to llp://{0} : {1}", tcpClient.Client.RemoteEndPoint, strMessage);
#endif
// Since nHAPI only emits a string we just send that along the stream
streamWriter.Write(strMessage);
streamWriter.Flush();
}
memoryWriter.Write(new byte[] { END_TX, END_TXNL }, 0, 2); // Finish the stream with FSCR
stream.Write(memoryWriter.ToArray(), 0, (int)memoryWriter.Position);
stream.Flush();
}
}
lastReceive = DateTime.Now; // Update the last receive time so the timeout function works
}
if (this.m_timeout == TimeSpan.Zero)
{
break;
}
}
}
catch (Exception e)
{
Trace.TraceError(e.ToString());
}
finally
{
stream.Close();
tcpClient.Close();
}
}
/* Método que gerencia o processo de monitoramento da porta de
* comunicação. É recomendado que este método seja executado em uma
* thread exclusiva.
* Além de iniciar o processo de escuta de uma porta, este método
* recebe as requisições das aplicações clientes, encaminha ao
* servidor de jogos (referenciado pela variável server) e envia
* a resposta das mensagens aos clientes.
*/
public void startTCPServer()
{
Console.WriteLine("Starting TCP echo at ip: " + ip + " port: " + port);
listener = new TcpListener(IPAddress.Parse(ip), port);
listener.Start();
TcpClient ourTCP_Client = null;
NetworkStream ourStream = null;
while (!ended)
{
string message = "";
string answer_message = "";
byte[] response = new byte[65530];
try
{
ourTCP_Client = listener.AcceptTcpClient();
ourStream = ourTCP_Client.GetStream();
byte[] data = new byte[ourTCP_Client.ReceiveBufferSize];
int bytesRead = ourStream.Read(data, 0, System.Convert.ToInt32(ourTCP_Client.ReceiveBufferSize));
// echo the data we got to the console until the newline, and delay closing our window.
message = Encoding.ASCII.GetString(data, 0, bytesRead);
Console.WriteLine("Received: '" + message + "'");
AddressPort ClientAddress = new AddressPort(IPAddress.Parse("127.0.0.1"), 50027);
RequestMessage req_message = new RequestMessage(message, ClientAddress);
AnswerMessage am = GameServer.executeRequest(req_message);
if (am.GID >= 0)
{
am.GAME_GENERAL_STATUS = GameServer.gameGeneralStatus(am.GID, req_message.PLAYER);
}
else
{
am.GAME_GENERAL_STATUS = AnswerMessage.GGS_NOTHING_TO_BE_DONE;
}
answer_message = am.message2string();
response = Encoding.ASCII.GetBytes(answer_message);
}
catch (Exception e)
{
if (System.Type.Equals(new SocketException().GetType(), e.GetType()))
{
ended = true;
if (ourTCP_Client != null)
{
ourStream.Flush();
ourStream.Close();
ourTCP_Client.Close();
}
listener.Stop();
return;
}
else
{
Console.Error.WriteLine("ERROR: " + message + " " + e.Message);
answer_message = new AnswerMessage(false, AnswerMessage.UNKNOWN_ERROR, "", -1).message2string();
response = Encoding.ASCII.GetBytes(answer_message);
}
}
if (!ended)
{
server.insertLogMessage("INPUT", message);
server.insertLogMessage("OUTPUT", answer_message);
Console.WriteLine("Sending: " + answer_message);
ourStream.Write(response, 0, response.Length);
ourStream.Flush();
ourTCP_Client.Close();
}
}
return;
}
