public static void GenerateLoad(int packetsPerBurst, int sleepMilliseconds)
{
IPAddress address = (from a in Dns.GetHostAddresses(Environment.MachineName)
where a.AddressFamily == AddressFamily.InterNetwork
select a).FirstOrDefault();
Console.WriteLine("IP Address is: {0}", address.ToString());
Socket listenSocket = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
listenSocket.Bind(new IPEndPoint(address, Port));
listenSocket.Listen(10);
Socket sendSocket = new Socket(address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
sendSocket.Connect(new IPEndPoint(address, Port));
NetworkStream writeStream = new NetworkStream(sendSocket, true);
Socket receiveSocket = listenSocket.Accept();
NetworkStream readStream = new NetworkStream(receiveSocket, true);
BinaryReader reader = new BinaryReader(readStream);
byte[] buffer = new byte[PacketSize];
while (!Console.KeyAvailable)
{
for (int i=0; i<packetsPerBurst; i++)
{
writeStream.Write(buffer, 0, buffer.Length);
readStream.Read(buffer, 0, buffer.Length);
}
if (sleepMilliseconds > 0)
{
Thread.Sleep(sleepMilliseconds);
}
}
Console.ReadKey();
writeStream.Dispose();
readStream.Dispose();
listenSocket.Dispose();
}
private void receiveDataAsync(NetworkStream readStream)
{
bool continueFlag = true;
while (continueFlag)
{
byte[] buffer = new byte[1024];
int readCount = readStream.Read(buffer, 0, 1024);
byte[] recvBuffer = buffer.ToList().GetRange(0, readCount).ToArray();
string receivedMessage = System.Text.Encoding.ASCII.GetString(recvBuffer);
Console.WriteLine("ServerReceived: " + System.Text.Encoding.ASCII.GetString(recvBuffer));
if (receivedMessage.Equals("END"))
{
continueFlag = false;
} // end if
} // end while
readStream.Dispose();
}
public void joinGame()
{
try
{
this.clientSocket.Connect(serverIP, serverPortNumber);
this.clientStream = this.clientSocket.GetStream();
byte[] outStream = System.Text.Encoding.ASCII.GetBytes(Util.Constants.JoinRequest);
clientStream.Write(outStream, 0, outStream.Length);
clientStream.Dispose();
clientStream.Flush();
launched = true;
this.receiveData();
}
catch (Exception ex)
{
DialogResult dr = MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
if (dr == DialogResult.OK)
Application.Exit();
launched = false;
}
}
public void Listen()
{
string msg= "";
IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9050);
Socket newsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
newsock.Bind(ipEndPoint);
newsock.Listen(10);
Socket client = newsock.Accept();
using (NetworkStream stream = new NetworkStream(client))
{
StreamReader streamReader = new StreamReader(stream);
msg = streamReader.ReadLine();
ServerParser serverParser = new ServerParser();
string res = serverParser.Decode(msg);
using (StreamWriter streamWriter = new StreamWriter(stream))
{
streamWriter.WriteLine(res);
}
stream.Dispose();
}
newsock.Close();
}
/// <summary>
/// Отправляет файл по указанному адресу.
/// </summary>
/// <param name="ip">Удаленный IP-адрес.</param>
/// <param name="port"></param>
/// <param name="file_name">Удаленный порт.</param>
/// <param name="exec_proc">Будет ли вызвано выполнение подпрограммы на принимающей стороне.</param>
/// <param name="is_delete_file"></param>
public static void SendFile(IPAddress ip, int port, string file_name, bool exec_proc = false, bool is_delete_file = false)
{
FileInfo file = new FileInfo(file_name);
if (FileSize.HasValue)
{
FileSize = file.Length;
}
// Устанавливаем соединение через сокет.
Socket socket = new Socket(ip.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
socket.Connect(new IPEndPoint(ip, port));
var ns = new NetworkStream(socket);
var fs = new FileStream(file_name, FileMode.Open, FileAccess.Read, FileShare.Read);
ns.WriteByte((byte)(exec_proc ? MesasageType.ReveiveFileAndExecProc : MesasageType.ReceiveFile));
fs.CopyToAsync(ns).ContinueWith((ar) =>
{
fs.Close();
fs.Dispose();
socket.Shutdown(SocketShutdown.Both);
socket.Close();
ns.Close();
ns.Dispose();
if (is_delete_file)
{
File.Delete(file_name);
}
});
}
public virtual bool SetupServerSocket()
#endif
{
try
{
//keep
bool isSecured = false;
string sslProtocol = "";
//check packer
if (SupportedChannelSerializationModes.HasFlag(ChannelSerializationMode.MessagePack))
DebugEx.Assert(MsgPack != null, "MessagePack serializer not provided");
//create network stream
#if NETFX
//Stream _netstream = new BufferedStream(new NetworkStream(base._sock, true));
Stream _netstream = new NetworkStream(base._sock, true);
//Wrap with a secure stream?
if (Server.Certificate != null)
{
var sslstream = new SslStream(_netstream, false);
try
{
//try authenticate
sslstream.AuthenticateAsServer(Server.Certificate, false, SslProtocols.Tls | SslProtocols.Tls12 | SslProtocols.Tls11, true);
//checks
if (!sslstream.IsAuthenticated)
{
DebugEx.Assert("Not authenticated");
throw new Exception("Not authenticated");
}
if (!sslstream.IsEncrypted)
{
DebugEx.Assert("No encryption");
throw new Exception("Not encryption");
}
//get info
isSecured = true;
sslProtocol = sslstream.SslProtocol.ToStringInvariant();
//use this stream from now on
_netstream = sslstream;
}
catch (Exception ex)
{
var msg = ex.Message;
if (ex.InnerException != null && ex.InnerException.Message != ex.Message)
msg += " (inner msg=" + ex.InnerException.Message + ")";
DebugEx.TraceError("Certificate not accepted, " + msg);
try { Close("Certificate not accepted, " + msg); } catch { }
try { sslstream.Close(); base._sock.Dispose(); } catch { }
try { _netstream.Close(); _netstream.Dispose(); } catch { }
try { _sock.Close(); _sock.Dispose(); } catch { }
return false; //failed
}
}
#endif
//read clients packers
var clientPackers = ChannelSerializationMode.Unkown;
var clientPreferredPackers = ChannelSerializationMode.Unkown;
#if NETFX
clientPackers = (ChannelSerializationMode)_netstream.ReadByte();
clientPreferredPackers = (ChannelSerializationMode)_netstream.ReadByte();
#elif UNIVERSAL
clientPackers = (ChannelSerializationMode)_sock.InputStream.AsStreamForRead().ReadByte();
clientPreferredPackers = (ChannelSerializationMode)_sock.InputStream.AsStreamForRead().ReadByte();
#endif
//filter packers
clientPackers = clientPackers & SupportedChannelSerializationModes;
clientPreferredPackers = clientPackers & clientPreferredPackers;
var serverPreferredPackers = clientPackers & PreferredChannelSerializationModes;
var commonPreferredPackers = clientPreferredPackers & serverPreferredPackers;
//choose packer
if ((_ChannelSerializationMode = _choosePacker(commonPreferredPackers)) == ChannelSerializationMode.Unkown &&
(_ChannelSerializationMode = _choosePacker(clientPreferredPackers)) == ChannelSerializationMode.Unkown &&
(_ChannelSerializationMode = _choosePacker(serverPreferredPackers)) == ChannelSerializationMode.Unkown &&
(_ChannelSerializationMode = _choosePacker(clientPackers)) == ChannelSerializationMode.Unkown)
{
DebugEx.TraceError("Could not decide on packer.");
try { Close("Could not decide on packer."); } catch { }
#if NETFX
try { _netstream?.Close(); _netstream?.Dispose(); } catch { }
try { _sock?.Close(); _sock?.Dispose(); } catch { }
#elif UNIVERSAL
try { _sock?.Dispose(); } catch { }
#endif
return false; //failed
}
//write packer
#if NETFX
var _nodelay = _sock.NoDelay;
_sock.NoDelay = true; //Disable the Nagle Algorithm
_netstream.WriteByte((byte)_ChannelSerializationMode);
_sock.NoDelay = _nodelay; //Restore (default:enable) the Nagle Algorithm
#elif UNIVERSAL
{
var wStream = _sock.OutputStream.AsStreamForWrite();
wStream.WriteByte((byte)_ChannelSerializationMode);
wStream.Flush();
}
#endif
//setup info
try
{
#if NETFX
this.LocalHost = base._sock.LocalEndPoint.GetIPAddress().ToString();
this.RemotePort = _sock.LocalEndPoint.GetPort().ToStringInvariant();
#elif UNIVERSAL
this.LocalHost = _sock.Information.LocalAddress.ToString();
this.RemotePort = _sock.Information.LocalPort;
#endif
}
catch { }
//setup info
#if NETFX
this.RemoteHost = base._sock.RemoteEndPoint.GetIPAddress().ToString();
this.RemotePort = _sock.RemoteEndPoint.GetPort().ToStringInvariant();
#elif UNIVERSAL
this.LocalHost = _sock.Information.RemoteAddress.ToString();
this.RemotePort = _sock.Information.RemotePort;
#endif
//log
DebugEx.TraceLog("YPServer (socks) new connection from " + RemoteHost + ":" + RemotePort + " (Secure=" + isSecured + ",SSL=" + sslProtocol + ")");
//setup stream
#if NETFX
SetupStream(_netstream);
#elif UNIVERSAL
SetupStream();
#endif
//all ok
return true;
}
catch (Exception ex)
{
DebugEx.TraceError(ex, "Unhandled exception caught");
return false;
}
}
public void transfer_file(string filename, string ip_addr)
{
Thread.Sleep(1000);
try
{
Console.WriteLine("transfering file to :" + ip_addr);
TcpClient tcpClient = new TcpClient(ip_addr, 7890);
nStream = tcpClient.GetStream();
writeImageData = new StreamWriter(nStream);
//Change the filename here. If you change the file type,
//you must change it on the Server Project too.
FileStream fs = File.OpenRead(filename);
byte[] ImageData = new byte[fs.Length];
fs.Read(ImageData, 0, ImageData.Length);
Base64ImageData = Convert.ToBase64String(ImageData);
int startIndex = 0;
Console.WriteLine("Transfering Data...");
while (Done == false)
{
while (startIndex < Base64ImageData.Length)
{
try
{
BlockData = Base64ImageData.Substring(startIndex, 100);
writeImageData.WriteLine(BlockData);
writeImageData.Flush();
startIndex += 100;
}
catch (Exception)
{
RemainingStringLength = Base64ImageData.Length - startIndex;
BlockData = Base64ImageData.Substring(startIndex, RemainingStringLength);
writeImageData.WriteLine(BlockData);
writeImageData.Flush();
Done = true;
break;
}
}
}
writeImageData.Close();
tcpClient.Close();
fs.Close();
fs.Dispose();
nStream.Close();
nStream.Dispose();
nStream = null;
tcpClient.Close();
ImageData = null;
Base64ImageData = null;
Console.WriteLine("Transfer Complete");
MessageBox.Show("File Transfer to " + ip_addr +" is Completed");
}
catch (Exception er)
{
Console.WriteLine("Unable to connect to server");
MessageBox.Show("Unable to connect to server");
Console.WriteLine(er.Message);
}
}
private async void Listen()
{
_socket.Listen(backlog: 2);
while (!_disposed)
{
Http2ServerSession session = null;
Socket clientSocket = null;
Stream stream = null;
try
{
clientSocket = await Task.Factory.FromAsync(_socket.BeginAccept, (Func<IAsyncResult, Socket>)_socket.EndAccept, null);
stream = new NetworkStream(clientSocket, ownsSocket: true);
X509Certificate clientCert = null;
if (_enableSsl)
{
SslStream sslStream = new SslStream(stream);
await sslStream.AuthenticateAsServerAsync(_serverCert, clientCertificateRequired: false, enabledSslProtocols: _sslProtocols, checkCertificateRevocation: false);
clientCert = sslStream.RemoteCertificate;
stream = sslStream;
}
// TODO: At this point we could read the first bit of the first byte received on this connection to determine if it is a HTTP/1.1 or 2.0 request.
IPEndPoint localEndPoint = (IPEndPoint)clientSocket.LocalEndPoint;
IPEndPoint remoteEndPoint = (IPEndPoint)clientSocket.RemoteEndPoint;
TransportInformation transportInfo = new TransportInformation()
{
ClientCertificate = clientCert,
LocalPort = localEndPoint.Port.ToString(CultureInfo.InvariantCulture),
RemotePort = remoteEndPoint.Port.ToString(CultureInfo.InvariantCulture),
};
// Side effect of using dual mode sockets, the IPv4 addresses look like 0::ffff:127.0.0.1.
if (localEndPoint.Address.IsIPv4MappedToIPv6)
{
transportInfo.LocalIpAddress = localEndPoint.Address.MapToIPv4().ToString();
}
else
{
transportInfo.LocalIpAddress = localEndPoint.Address.ToString();
}
if (remoteEndPoint.Address.IsIPv4MappedToIPv6)
{
transportInfo.RemoteIpAddress = remoteEndPoint.Address.MapToIPv4().ToString();
}
else
{
transportInfo.RemoteIpAddress = remoteEndPoint.Address.ToString();
}
session = new Http2ServerSession(_next, transportInfo);
// TODO: awaiting here will only let us accept the next connection/session after the current one finishes.
await session.Start(stream, CancellationToken.None);
}
catch (ProtocolViolationException)
{
// Handshake failure, most likely do to receiving a HTTP/1.1 text request.
}
catch (SocketException)
{
// Disconnect?
}
catch (ObjectDisposedException)
{
Dispose();
}
catch (Exception)
{
Dispose();
throw;
}
finally
{
if (session != null)
{
session.Dispose();
}
if (stream != null)
{
stream.Dispose();
}
if (clientSocket != null)
{
clientSocket.Dispose();
}
}
}
}
private void AcceptTcpConnection()
{
Socket socket1 = null;
try
{
Encoding encoding1 = Encoding.GetEncoding(0x6faf);
string text1;
while (true)
{
socket1 = localListen.AcceptSocket();
byte[] buffer1 = new byte[0x43];
if ((socket1 != null) && socket1.Connected)
{
NetworkStream stream1 = new NetworkStream(socket1);
stream1.ReadTimeout = 0x3e8;
try
{
stream1.Read(buffer1, 0, buffer1.Length);
}
catch (Exception)
{
}
text1 = encoding1.GetString(buffer1, 0, buffer1.Length);
if ((text1.IndexOf("BitTorrent protocol") >= 0) && (text1.IndexOf(encoding1.GetString(this.currentTorrentFile.InfoHash)) >= 0))
{
byte[] buffer2 = createHandshakeResponse();
stream1.Write(buffer2, 0, buffer2.Length);
}
socket1.Close();
stream1.Close();
stream1.Dispose();
}
}
}
catch (Exception exception1)
{
AddLogLine("Error in AcceptTcpConnection(): " + exception1.Message);
return;
}
finally
{
if (socket1 != null)
{
socket1.Close();
AddLogLine("Closed socket");
}
CloseTcpListener();
}
}
private void connectionThread()
{
try{
Console.WriteLine("Connecting to: "+Host+":"+Port);
client.ConnectAsync(Host, Port);
while(Timeout>0)
{
if(client.Connected) break;
Timeout--;
Thread.Sleep(1);
}
if(!client.Connected) {
throw new Exception("Cant connect to: "+Host+":"+Port+" Timeout");
}
Console.WriteLine("Connected to: "+Host+":"+Port);
stream = client.GetStream();
if(stream == null) throw new Exception("Cant get stream for: "+Host+":"+Port+" ");
if(OnConnectEvent!=null) OnConnectEvent(this,new EventArgs());
while(run)
{
//Tutaj tylko testujemy
if (!client.Connected) {
//Jakis ewvent
run = false;
}
Thread.Sleep(1000);
}
} catch(Exception e) {
Console.WriteLine ("Error: "+e.Message);
return;
}
Console.WriteLine("Disconecting: "+Host+":"+Port);
if (client.Connected) {
if (stream != null) {
stream.Close ();
stream.Dispose ();
stream = null;
}
client.Close ();
client = null;
}
Console.WriteLine("Disconected: "+Host+":"+Port);
if(OnDisconnectEvent!=null) OnDisconnectEvent(this,new EventArgs());
}
private void receive_file_tcp(String devicename, String ipadd, int port)
{
try
{
_buffer = new byte[63 * 1024];
_tcplistener = new TcpListener(IPAddress.Any, port);
_tcplistener.Start();
_tcpclient = _tcplistener.AcceptTcpClient();
_netstream = _tcpclient.GetStream();
_filestream = new FileStream(this.filepath, FileMode.Create, FileAccess.ReadWrite);
while ((_length = _netstream.Read(_buffer, 0, _buffer.Length)) != 0)
{
_filestream.Write(_buffer, 0, _length);
}
_filestream.Dispose();
_filestream.Close();
_netstream.Dispose();
_netstream.Close();
_tcpclient.Close();
_tcplistener.Stop();
System.Threading.Thread.Sleep(1000);
_message = format_message(_stopwatch.Elapsed, "File Transfer", "OK", this.filepath);
this.callback.on_file_received(_message, this.results);
this.main_view.text_to_logs(_message);
}
catch (Exception e)
{
append_error_tolog(e, _stopwatch.Elapsed, devicename);
}
}
private static bool ActiveWebProbeRaw()
{
using (var clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
try
{
var remoteHost = new IPEndPoint(Dns.GetHostEntry(ActiveWebProbeHost).AddressList[0], 80);
bool result = Connect(clientSocket, remoteHost, 5000);
if (result == false)
{
clientSocket.Close();
return false;
}
_netStream = new NetworkStream(clientSocket, true);
var sb = new StringBuilder();
sb.Append("GET http://");
sb.Append(ActiveWebProbeHost);
sb.Append("/");
sb.Append(ActiveWebProbePath);
sb.AppendLine(" HTTP/1.1");
sb.Append("Host: ");
sb.AppendLine(ActiveWebProbeHost);
sb.AppendLine("Connection: close");
sb.AppendLine();
byte[] buffer = Encoding.UTF8.GetBytes(sb.ToString());
_netStream.Write(buffer, 0, buffer.Length);
buffer = GetResponse(clientSocket);
var response = new string(Encoding.UTF8.GetChars(buffer));
return EndsWith(response, ActiveWebProbeContent);
}
catch (SocketException socketException)
{
if (socketException.ErrorCode == 10060)
{
Log.WriteString(LogMessageType.Warning, "No internet connection. (www.msftncsi.com unreachable)");
}
}
catch (Exception exception)
{
Log.WriteException(exception, "");
}
finally
{
if (_netStream != null)
{
_netStream.Close();
_netStream.Dispose();
}
clientSocket.Close();
}
}
return false;
}
public override void receive_file(String devicename, String bluid, int not)
{
try
{
_stopwatch.Start();
scan_transfer_speed();
_bluetooth_guid = Guid.Parse(bluid);
_bluetooth_listener = new BluetoothListener(_bluetooth_guid);
_bluetooth_listener.Start();
_bluetooth_client = _bluetooth_listener.AcceptBluetoothClient();
_netstream = _bluetooth_client.GetStream();
_filestream = new FileStream(this.filepath, FileMode.Create, FileAccess.ReadWrite);
int length;
_buffer = new byte[65000];
while ((length = _netstream.Read(_buffer, 0, _buffer.Length)) != 0)
{
while (_writing) { }
_count_received_bytes += length;
_filestream.Write(_buffer, 0, length);
}
_timer_ts.Close();
_stopwatch.Stop();
int _transferspeed = _count_received_bytes / 1024;
_message = format_message(_stopwatch.Elapsed, "Transferspeed", _transferspeed.ToString(), "kB/s");
this.callback.on_transfer_speed_change(_message, this.results);
this.main_view.text_to_logs(_message);
_filestream.Dispose();
_filestream.Close();
_netstream.Dispose();
_netstream.Close();
_bluetooth_client.Dispose();
_bluetooth_client.Close();
_bluetooth_listener.Stop();
_message = format_message(_stopwatch.Elapsed, "File Transfer", "OK", this.filepath);
this.callback.on_file_received(_message, this.results);
this.main_view.text_to_logs(_message);
}
catch (Exception e)
{
append_error_tolog(e, _stopwatch.Elapsed, devicename);
}
}
private void Close(NetworkStream ns)
{
try
{
if (ns != null)
{
ns.Close();
ns.Dispose();
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ex.StackTrace);
}
if (IsServer)
lock (syncobj)
{
for (int i = 0; i < members.Count;)
{
if (members [i].Connection == ns || members [i].Connection == null ||
!members [i].Connection.CanRead || !members [i].Connection.CanWrite)
{
SendLeave(members [i].ID);
members.RemoveAt(i);
}
else
i++;
}
}
}
/// <summary>
/// Callback method for asynchronous accept operation.
/// </summary>
private void ProcessAccept(SocketAsyncEventArgs acceptArgs)
{
TransportProvider<Socket> client = new TransportProvider<Socket>();
SocketAsyncEventArgs receiveArgs = null;
WindowsPrincipal clientPrincipal = null;
TcpClientInfo clientInfo;
try
{
if (CurrentState == ServerState.NotRunning)
return;
// If acceptArgs was disposed, m_acceptArgs will either
// be null or another instance of SocketAsyncEventArgs.
// This check will tell us whether it's been disposed.
if ((object)acceptArgs != m_acceptArgs)
return;
if (acceptArgs.SocketError != SocketError.Success)
{
// Error is unrecoverable.
// We need to make sure to restart the
// server before we throw the error.
SocketError error = acceptArgs.SocketError;
ThreadPool.QueueUserWorkItem(state => ReStart());
throw new SocketException((int)error);
}
// Process the newly connected client.
client.Provider = acceptArgs.AcceptSocket;
client.Provider.ReceiveBufferSize = ReceiveBufferSize;
// Set up SocketAsyncEventArgs for receive operations.
receiveArgs = FastObjectFactory<SocketAsyncEventArgs>.CreateObjectFunction();
receiveArgs.Completed += ReceiveHandler;
// Return to accepting new connections.
acceptArgs.AcceptSocket = null;
if (!m_tcpServer.AcceptAsync(acceptArgs))
{
ThreadPool.QueueUserWorkItem(state => ProcessAccept(acceptArgs));
}
#if !MONO
// Authenticate the connected client Windows credentials.
if (m_integratedSecurity)
{
NetworkStream socketStream = null;
NegotiateStream authenticationStream = null;
try
{
socketStream = new NetworkStream(client.Provider);
authenticationStream = new NegotiateStream(socketStream);
authenticationStream.AuthenticateAsServer();
if (authenticationStream.RemoteIdentity is WindowsIdentity)
clientPrincipal = new WindowsPrincipal((WindowsIdentity)authenticationStream.RemoteIdentity);
}
catch (InvalidCredentialException)
{
if (!m_ignoreInvalidCredentials)
throw;
}
finally
{
if (socketStream != null)
socketStream.Dispose();
if (authenticationStream != null)
authenticationStream.Dispose();
}
}
#endif
if (MaxClientConnections != -1 && ClientIDs.Length >= MaxClientConnections)
{
// Reject client connection since limit has been reached.
TerminateConnection(client, receiveArgs, false);
}
else
{
// We can proceed further with receiving data from the client.
clientInfo = new TcpClientInfo
{
Client = client,
SendArgs = FastObjectFactory<SocketAsyncEventArgs>.CreateObjectFunction(),
SendLock = new object(),
SendQueue = new ConcurrentQueue<TcpServerPayload>(),
ClientPrincipal = clientPrincipal
};
// Create operation to dump send queue payloads when the queue grows too large.
clientInfo.DumpPayloadsOperation = new ShortSynchronizedOperation(() =>
{
TcpServerPayload payload;
// Check to see if the client has reached the maximum send queue size.
if (m_maxSendQueueSize > 0 && clientInfo.SendQueue.Count >= m_maxSendQueueSize)
{
for (int i = 0; i < m_maxSendQueueSize; i++)
{
if (clientInfo.SendQueue.TryDequeue(out payload))
{
payload.WaitHandle.Set();
payload.WaitHandle.Dispose();
payload.WaitHandle = null;
}
}
throw new InvalidOperationException(string.Format("Client {0} connected to TCP server reached maximum send queue size. {1} payloads dumped from the queue.", clientInfo.Client.ID, m_maxSendQueueSize));
}
}, ex => OnSendClientDataException(clientInfo.Client.ID, ex));
// Set up socket args.
client.SetSendBuffer(SendBufferSize);
clientInfo.SendArgs.Completed += m_sendHandler;
clientInfo.SendArgs.SetBuffer(client.SendBuffer, 0, client.SendBufferSize);
m_clientInfoLookup.TryAdd(client.ID, clientInfo);
OnClientConnected(client.ID);
if (!m_payloadAware)
{
receiveArgs.UserToken = client;
}
else
{
EventArgs<TransportProvider<Socket>, bool> userToken = FastObjectFactory<EventArgs<TransportProvider<Socket>, bool>>.CreateObjectFunction();
userToken.Argument1 = client;
receiveArgs.UserToken = userToken;
}
ReceivePayloadAsync(client, receiveArgs);
}
}
catch (ObjectDisposedException)
{
// m_acceptArgs may be disposed while in the middle of accepting a connection
}
catch (Exception ex)
{
// Notify of the exception.
if ((object)client.Provider != null && (object)client.Provider.RemoteEndPoint != null)
{
string clientAddress = ((IPEndPoint)client.Provider.RemoteEndPoint).Address.ToString();
string errorMessage = string.Format("Unable to accept connection to client [{0}]: {1}", clientAddress, ex.Message);
OnClientConnectingException(new Exception(errorMessage, ex));
}
else
{
string errorMessage = string.Format("Unable to accept connection to client [unknown]: {0}", ex.Message);
OnClientConnectingException(new Exception(errorMessage, ex));
}
if ((object)receiveArgs != null)
{
TerminateConnection(client, receiveArgs, false);
}
}
}
private void Update()
{
try
{
while (_Connected)
{
_Connected = _AttachedSocket.Client.Connected;
lock (_PacketsToProcess)
{
if (_AttachedSocket.Available > 0)
{
Byte[] datapulled = new Byte[_AttachedSocket.Available];
_AttachedSocket.GetStream().Read(datapulled, 0, datapulled.Length);
Array.Copy(datapulled, 0, _ByteBuffer, _ByteBufferCount, datapulled.Length);
_ByteBufferCount += datapulled.Length;
}
Boolean finding = _ByteBufferCount > 11;
while (finding)
{
Boolean packetStartPresent = true;
for (Int32 x = 0; x < 4; x++)
{
if (_ByteBuffer[x] == Packet.PacketStart[x]) continue;
packetStartPresent = false;
break;
}
if (packetStartPresent)
{
Int32 size = BitConverter.ToInt32(_ByteBuffer, 6);
if (_ByteBufferCount >= size)
{
Byte[] packet = new Byte[size];
Array.Copy(_ByteBuffer, 0, packet, 0, size);
Array.Copy(_ByteBuffer, size, _ByteBuffer, 0, _ByteBufferCount - size);
_ByteBufferCount -= size;
_PacketsToProcess.Add(Packet.FromByteArray(packet));
}
else
{
finding = false;
}
}
else
{
Int32 offset = -1;
for (Int32 x = 0; x < _ByteBufferCount; x++)
{
if (_ByteBuffer[x] == Packet.PacketStart[x]) offset = x;
}
if (offset != -1)
{
Array.Copy(_ByteBuffer, offset, _ByteBuffer, 0, _ByteBufferCount - offset);
_ByteBufferCount -= offset;
}
else
{
_ByteBufferCount = 0;
}
}
if (_ByteBufferCount < 12) finding = false;
}
}
lock (_PacketsToSend)
{
if (_PacketsToSend.Count > 0)
{
_TempPacketList.AddRange(_PacketsToSend);
_PacketsToSend.Clear();
}
}
if (_TempPacketList.Count > 0)
{
_NetStream = new NetworkStream(_AttachedSocket.Client);
foreach (Byte[] data in _TempPacketList.Select(p => p.ToByteArray()))
{
_NetStream.Write(data, 0, data.Length);
}
_NetStream.Close();
_NetStream.Dispose();
_NetStream = null;
foreach (Packet p in _TempPacketList) p.Dispose();
}
_TempPacketList.Clear();
if (DateTime.Now - _LastClientUpdate > _ClientUpdateInterval)
{
_LastClientUpdate += _ClientUpdateInterval;
ClientUpdateLogic();
}
Thread.Sleep(4);
}
if (_AttachedSocket != null)
{
if (_AttachedSocket.Connected)
{
_AttachedSocket.Close();
_AttachedSocket.Client.Dispose();
}
}
_Connected = false;
OnDisconnect();
Dispose();
}
catch (Exception e)
{
HandelException(e);
}
}
/// <summary>
/// Callback method for asynchronous accept operation.
/// </summary>
private void ProcessAccept()
{
TransportProvider<Socket> client = new TransportProvider<Socket>();
SocketAsyncEventArgs receiveArgs = null;
TcpClientInfo clientInfo;
try
{
if (CurrentState == ServerState.NotRunning)
return;
if (m_acceptArgs.SocketError != SocketError.Success)
{
// Error is unrecoverable.
// We need to make sure to restart the
// server before we throw the error.
SocketError error = m_acceptArgs.SocketError;
ThreadPool.QueueUserWorkItem(state => ReStart());
throw new SocketException((int)error);
}
// Process the newly connected client.
client.Provider = m_acceptArgs.AcceptSocket;
// Set up SocketAsyncEventArgs for receive operations.
receiveArgs = FastObjectFactory<SocketAsyncEventArgs>.CreateObjectFunction();
receiveArgs.Completed += ReceiveHandler;
// Return to accepting new connections.
m_acceptArgs.AcceptSocket = null;
if (!m_tcpServer.AcceptAsync(m_acceptArgs))
{
ThreadPool.QueueUserWorkItem(state => ProcessAccept());
}
#if !MONO
// Authenticate the connected client Windows credentials.
if (m_integratedSecurity)
{
NetworkStream socketStream = null;
NegotiateStream authenticationStream = null;
try
{
socketStream = new NetworkStream(client.Provider);
authenticationStream = new NegotiateStream(socketStream);
authenticationStream.AuthenticateAsServer();
if (authenticationStream.RemoteIdentity is WindowsIdentity)
Thread.CurrentPrincipal = new WindowsPrincipal((WindowsIdentity)authenticationStream.RemoteIdentity);
}
finally
{
if (socketStream != null)
socketStream.Dispose();
if (authenticationStream != null)
authenticationStream.Dispose();
}
}
#endif
if (MaxClientConnections != -1 && ClientIDs.Length >= MaxClientConnections)
{
// Reject client connection since limit has been reached.
TerminateConnection(client, receiveArgs, false);
}
else
{
// We can proceed further with receiving data from the client.
clientInfo = new TcpClientInfo()
{
Client = client,
SendArgs = FastObjectFactory<SocketAsyncEventArgs>.CreateObjectFunction(),
SendLock = new SpinLock(),
SendQueue = new ConcurrentQueue<TcpServerPayload>()
};
// Set up socket args.
client.SetSendBuffer(SendBufferSize);
clientInfo.SendArgs.Completed += m_sendHandler;
clientInfo.SendArgs.SetBuffer(client.SendBuffer, 0, client.SendBufferSize);
m_clientInfoLookup.TryAdd(client.ID, clientInfo);
OnClientConnected(client.ID);
if (!m_payloadAware)
{
receiveArgs.UserToken = client;
}
else
{
EventArgs<TransportProvider<Socket>, bool> userToken = ReusableObjectPool<EventArgs<TransportProvider<Socket>, bool>>.Default.TakeObject();
userToken.Argument1 = client;
receiveArgs.UserToken = userToken;
}
ReceivePayloadAsync(client, receiveArgs);
}
}
catch (Exception ex)
{
// Notify of the exception.
if ((object)client.Provider != null)
{
string clientAddress = ((IPEndPoint)client.Provider.RemoteEndPoint).Address.ToString();
string errorMessage = string.Format("Unable to accept connection to client [{0}]: {1}", clientAddress, ex.Message);
OnClientConnectingException(new Exception(errorMessage, ex));
}
if ((object)receiveArgs != null)
{
TerminateConnection(client, receiveArgs, false);
}
}
}
private void send_file_tcp(String ipadd, int port)
{
try
{
_tcpclient.Connect(IPAddress.Parse(ipadd), port);
_netstream = _tcpclient.GetStream();
_filestream = File.OpenRead(this.filepath);
_tosend = new byte[63 * 1024];
while ((_length = _filestream.Read(_tosend, 0, 63 * 1024)) != 0)
{
_netstream.Write(_tosend, 0, _length);
}
_netstream.Dispose();
_netstream.Close();
_tcpclient.Close();
System.Threading.Thread.Sleep(1000);
_message = format_message(_stopwatch.Elapsed, "File Transfer", "OK", this.filepath);
this.callback.on_file_received(_message, this.results);
this.main_view.text_to_logs(_message);
}
catch (Exception e)
{
append_error_tolog(e, _stopwatch.Elapsed, "");
}
}
public void ServeCfg(Player p, byte[] buffer)
{
var stream = new NetworkStream(p.socket);
using (var reader = new StreamReader(stream))
{
using (var textWriter = new StreamWriter(stream, Encoding.ASCII))
{
string firstLine = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
var match = HttpFirstLine.Match(firstLine);
if (match.Success)
{
}
else
textWriter.WriteLine("HTTP/1.1 400 Bad Request");
p.dontmindme = true;
}
}
stream.Close();
stream.Dispose();
p.socket.Close();
p.disconnected = true;
}
public Response GetHttpData(IPEndPoint address, byte[] headersData)
{
Response response = null;
Console.WriteLine(1);
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
socket.ReceiveTimeout = receiveTimeout;
socket.SendTimeout = sendTimeout;
socket.ReceiveBufferSize = this.bufferSize;
socket.SendBufferSize = this.bufferSize;
socket.Connect(address.Address, address.Port);
Console.WriteLine(2);
if (socket.Connected)
{
socket.Send(headersData);
using (NetworkStream netStream = new NetworkStream(socket, FileAccess.ReadWrite))
{
/*
if (netStream.CanWrite)
{
netStream.Write(headersData, 0, headersData.Length);
netStream.Flush();
}
*/
Console.WriteLine(3);
if (netStream.CanRead)
{
response = new Response();
using (BinaryReader reader = new BinaryReader(netStream))
{
Console.WriteLine(4);
//解析出头数据
using (MemoryStream headerStream = new MemoryStream())
{
byte[] stopSign = Encoding.ASCII.GetBytes("\r\n\r\n");
int stopSignSize = stopSign.Length;
int signSize = stopSignSize * 2;
int byteIndex = stopSignSize - 1;
byte[] sign = new byte[signSize];
int n = 0;
while (true)
{
//Console.WriteLine(4);
byte b = reader.ReadByte();
for (int i = 0; i < signSize - 1; i++)
{
sign[i] = sign[i + 1];
}
sign[signSize - 1] = b;
n++;
if (n > stopSignSize)
{
headerStream.WriteByte(sign[byteIndex]);
}
if (HasSign(sign, stopSign))
{
break;
}
}
Console.WriteLine(5);
headerStream.Seek(0, SeekOrigin.Begin);
using (StreamReader streamReader = new StreamReader(headerStream, true))
{
bool firstLine = true;
while (true)
{
string line = streamReader.ReadLine();
if (string.IsNullOrEmpty(line))
{
break;
}
if (!firstLine)
{
int signIndex = line.IndexOf(HEADER_SPLIT_SIGN);
int valueIndex = signIndex + HEADER_SPLIT_SIGN.Length;
if (signIndex > 0 && valueIndex < line.Length)
{
string key = line.Substring(0, signIndex);
string value = line.Substring(valueIndex);
response.Headers[key] = value;
}
}
else
{
if (!string.IsNullOrEmpty(line))
{
int inx_space1 = line.IndexOf(' ');
int inx_space2 = line.IndexOf(' ', inx_space1 + 1);
if (inx_space2 > inx_space1 && inx_space1 > 0)
{
string codeString = line.Substring(inx_space1 + 1, inx_space2 - inx_space1);
int code = 0;
if (int.TryParse(codeString, out code))
{
response.StatusCode = code;
}
response.Scheme = line.Substring(0, inx_space1);
response.StatusDescription = line.Substring(inx_space2 + 1);
}
}
firstLine = false;
}
}
streamReader.Close();
streamReader.Dispose();
}
Console.WriteLine(6);
headerStream.Close();
headerStream.Dispose();
}
Console.WriteLine(7);
//解析Body 数据
if (response.Headers["Content-Length"] != null)
{
int contentLength = int.Parse(response.Headers["Content-Length"]);
using (var bodyStream = new MemoryStream(contentLength))
{
byte[] buffer = new byte[this.bufferSize];
int readCount;
while ((readCount = netStream.Read(buffer, 0, this.bufferSize)) != 0)
{
bodyStream.Write(buffer, 0, readCount);
}
response.BodyData = bodyStream.ToArray();
bodyStream.Close();
bodyStream.Dispose();
}
}
else if (response.Headers["Transfer-Encoding"] == "chunked")
{
using (var bodyStream = new MemoryStream())
{
byte[] stopSign = Encoding.ASCII.GetBytes("\r\n");
int stopSignSize = stopSign.Length;
int signSize = stopSignSize * 2;
int byteIndex = stopSignSize - 1;
int chunkedLenth = 0;
StringBuilder __sb = new StringBuilder();
while (netStream.DataAvailable)
{
/*
* 5353 rn
*
* 00 05 1
* 00 53 2
* 05 35 3
* 53 53 4
* 35 3r 5
* 53 rn 6
*/
byte[] sign = new byte[signSize];
List<byte> bytes = new List<byte>();
int n = 0;
while (netStream.DataAvailable)
{
byte b = reader.ReadByte();
__sb.Append(b);
for (int i = 0; i < signSize - 1; i++)
{
sign[i] = sign[i + 1];
}
sign[signSize - 1] = b;
n++;
if (n > stopSignSize)
{
bytes.Add(sign[byteIndex]);
}
if (HasSign(sign, stopSign))
{
break;
}
}
if (bytes.Count == 0)
{
break;
}
try
{
string hexString = Encoding.ASCII.GetString(bytes.ToArray());
chunkedLenth = Convert.ToInt32(hexString, 16);
if (chunkedLenth == 0)
{
break;
}
else
{
int totalCount = 0;
byte[] buffer = new byte[bufferSize];
while (totalCount < chunkedLenth && netStream.DataAvailable)
{
int readCount = reader.Read(buffer, 0, bufferSize);
if (readCount != 0)
{
__sb.Append(buffer);
totalCount += readCount;
bodyStream.Write(buffer, 0, readCount);
}
else
{
break;
}
}
}
response.BodyData = bodyStream.ToArray();
}
catch (Exception exs)
{
Console.WriteLine(__sb.ToString());
throw exs;
}
}
Console.WriteLine(8);
bodyStream.Close();
bodyStream.Dispose();
}
}
else
{
Console.WriteLine(9);
using (var bodyStream = new MemoryStream())
{
byte[] buffer = new byte[this.bufferSize];
int readCount;
while ((readCount = reader.Read(buffer, 0, this.bufferSize)) != 0)
{
bodyStream.Write(buffer, 0, readCount);
}
response.BodyData = bodyStream.ToArray();
bodyStream.Close();
bodyStream.Dispose();
}
}
reader.Close();
reader.Dispose();
}
}
netStream.Close();
netStream.Dispose();
}
}
if (socket != null)
{
Console.WriteLine(10);
// socket.Disconnect(true);
socket.Close();
socket.Dispose();
}
Console.WriteLine(11);
/*
try
{
}
catch (Exception ex)
{
}
finally
{
}
*/
return response;
}
public void recieve_file(string path)
{
string host = Dns.GetHostName();
Console.WriteLine("Host Name = " + host);
IPHostEntry localip = Dns.GetHostByName(host);
Console.WriteLine("IPAddress = " + localip.AddressList[0].ToString());
IPAddress ipAddress = localip.AddressList[0];
TcpListener tcpListener = new TcpListener(ipAddress, 7890);
tcpListener.Start();
Console.WriteLine("Waiting for resposne . . .");
TcpClient tcpClient = null;
while (tcpClient == null)
{
tcpClient = tcpListener.AcceptTcpClient();
}
Console.WriteLine("Connection Made");
nStream = tcpClient.GetStream();
readImageData = new StreamReader(nStream);
string data;
while (Done == false)
{
while ((data = readImageData.ReadLine()) != null)
{
BlockData.Append(data);
}
Done = true;
}
byte[] byte_image = Convert.FromBase64String(BlockData.ToString());
Console.WriteLine("->"+path + "<--");
//path = "new.png";
// Change File Name Here
if (File.Exists(path))
{
File.Delete(path);
}
FileStream fs = new FileStream(path, FileMode.Create);
fs.Write(byte_image, 0, byte_image.Length);
fs.Flush();
fs.Close();
fs.Dispose();
fs = null;
Console.WriteLine("File has been recieved!");
MessageBox.Show("Connection Made\n" + path + "\nFile has been recieved!");
//System.Diagnostics.Process.Start("run.exe");
readImageData.Close();
tcpClient.Close();
nStream.Dispose();
tcpListener.Stop();
}
/// <summary>
/// Callback method for asynchronous connect operation.
/// </summary>
private void ProcessConnect()
{
try
{
// Perform post-connect operations.
m_connectionAttempts++;
if (m_connectArgs.SocketError != SocketError.Success)
throw new SocketException((int)m_connectArgs.SocketError);
#if !MONO
// Send current Windows credentials for authentication.
if (m_integratedSecurity)
{
NetworkStream socketStream = null;
NegotiateStream authenticationStream = null;
try
{
socketStream = new NetworkStream(m_tcpClient.Provider);
authenticationStream = new NegotiateStream(socketStream);
authenticationStream.AuthenticateAsClient();
}
finally
{
if (socketStream != null)
socketStream.Dispose();
if (authenticationStream != null)
authenticationStream.Dispose();
}
}
#endif
// Set up send and receive args.
using (SocketAsyncEventArgs sendArgs = m_sendArgs, receiveArgs = m_receiveArgs)
{
m_sendArgs = FastObjectFactory<SocketAsyncEventArgs>.CreateObjectFunction();
m_receiveArgs = FastObjectFactory<SocketAsyncEventArgs>.CreateObjectFunction();
}
m_tcpClient.SetSendBuffer(SendBufferSize);
m_sendArgs.SetBuffer(m_tcpClient.SendBuffer, 0, m_tcpClient.SendBufferSize);
m_sendArgs.Completed += m_sendHandler;
m_receiveArgs.Completed += ReceiveHandler;
// Notify user of established connection.
m_connectWaitHandle.Set();
OnConnectionEstablished();
// Set up send buffer and begin receiving.
ReceivePayloadAsync();
}
catch (SocketException ex)
{
OnConnectionException(ex);
if (ex.SocketErrorCode == SocketError.ConnectionRefused &&
(MaxConnectionAttempts == -1 || m_connectionAttempts < MaxConnectionAttempts))
{
// Server is unavailable, so keep retrying connection to the server.
try
{
ConnectAsync();
}
catch
{
TerminateConnection();
}
}
else
{
// For any other reason, clean-up as if the client was disconnected.
TerminateConnection();
}
}
catch (Exception ex)
{
// This is highly unlikely, but we must handle this situation just-in-case.
OnConnectionException(ex);
TerminateConnection();
}
}
public void StartAccepting()
{
while (!_needToStop)
{
if (!_listener.Pending())
{
Thread.Sleep(10);
continue;
}
Socket socket=_listener.AcceptSocket();
NetworkStream ns = new NetworkStream(socket);
StreamReader reader = new StreamReader(ns);
StreamWriter writer = new StreamWriter(ns);
string httpRequest=reader.ReadLine();
if (httpRequest != null)
{
string[] p = httpRequest.Split(' ');
string request = p[1];
//skip header
while (true)
{
String l = reader.ReadLine();
if (l != null && l.Trim() == "")
break;
}
writer.WriteLine("HTTP/1.0 200 Ok");
writer.WriteLine("Server: Amleto 3.1");
writer.WriteLine("Content-type: text/html");
writer.WriteLine("Expires: now");
writer.WriteLine("");
writer.WriteLine("<HTML><HEAD><TITLE>Amleto 3.1</TITLE></HEAD>");
writer.WriteLine("<style type='text/css'>");
writer.WriteLine("<!--");
writer.WriteLine("td { font-family: Arial, Helvetica, sans-serif; font-size: 9pt}");
writer.WriteLine("body { font-family: Arial, Helvetica, sans-serif; font-size: 9pt}");
writer.WriteLine("h2 { font-family: Arial, Helvetica, sans-serif; font-size: 14pt; font-weight: bold}");
writer.WriteLine("h3 { font-family: Arial, Helvetica, sans-serif; font-size: 12pt; font-weight: bold}");
writer.WriteLine("h4 { font-family: Arial, Helvetica, sans-serif; font-size: 9pt; font-weight: bold}");
writer.WriteLine("h1 { font-family: Arial, Helvetica, sans-serif; font-size: 14pt; font-weight: bold}");
writer.WriteLine("a { font-family: Arial, Helvetica, sans-serif; font-size: 9pt; text-decoration: none}");
writer.WriteLine("th { font-family: Arial, Helvetica, sans-serif; font-size: 12pt; font-weight: bold}");
writer.WriteLine("ul { font-family: Arial, Helvetica, sans-serif; font-size: 10pt}");
writer.WriteLine("-->");
writer.WriteLine("</style>");
writer.WriteLine("<BODY BGCOLOR=#FFFFFF>");
if (request.StartsWith("/messages"))
ShowMessages(writer);
else
ShowNodesProjects(writer);
}
writer.Close();
writer.Dispose();
reader.Close();
reader.Dispose();
ns.Close();
ns.Dispose();
socket.Disconnect(false);
}
}
/// <summary>
/// Приём файла.
/// </summary>
/// <param name="socket">Сокет.</param>
private void ReceiveFile(Socket socket)
{
// Генерируем уникальное имя для файла.
var tmp_file_name = string.Format("{0}_{1}", DateTime.Now.Ticks, _fileCount);
_fileCount++;
var ns = new NetworkStream(socket);
var remote_address = (socket.RemoteEndPoint as IPEndPoint).Address.ToString();
var message_type = (MesasageType)ns.ReadByte();
if (message_type == MesasageType.Text)
{
byte[] buffer = new byte[256];
socket.Receive(buffer);
Console.WriteLine("Принято сообщение: {0}", Encoding.Unicode.GetString(buffer));
return;
}
var fs = new FileStream(tmp_file_name, FileMode.CreateNew);
ns.CopyToAsync(fs).ContinueWith((ar) =>
{
fs.Close();
fs.Dispose();
ns.Close();
ns.Dispose();
FileInfo file = new FileInfo(tmp_file_name);
if (FileSize.HasValue)
{
if (FileSize == file.Length)
{
ReceviceFileCount++;
}
else
{
Console.WriteLine("Размер принятого файла не соответствует отправленному ({0} != {1}).", FileSize, file.Length);
}
}
Console.WriteLine("Получен файл");
if (message_type == MesasageType.ReveiveFileAndExecProc)
{
ExecProcAndSendFile(tmp_file_name, remote_address, _remotePort);
}
else
{
if (IsDeleteFiles)
{
File.Delete(tmp_file_name);
}
}
});
}
public void Handshake()
{
if (this.BridgeSocket == null)
{
TcpClient tcp = new TcpClient(this.BridgeHost, this.BridgePort);
this.BridgeSocket = tcp.Client;
tcp.Client = null;
tcp.Close();
}
NetworkStream stream = null;
SamV3BridgeCommunicator bridge = null;
try
{
stream = new NetworkStream(this.BridgeSocket);
bridge = new SamV3BridgeCommunicator(stream);
stream = null;
string version = this.BridgeProtocolVersion;
string protocolVersion = bridge.HelloVersion(version, version);
if (protocolVersion != version)
throw new SamException();
this.Bridge = bridge;
bridge = null;
}
catch (Exception)
{
if (stream != null)
stream.Dispose();
if (bridge != null)
bridge.Dispose();
throw;
}
}
public virtual void ProcessCommands(NetworkStream nstm)
{
//nstm = new XNetworkStream(sock);
int x;
this.nstm = nstm;
try
{
for (; ; )
{
x = nstm.ReadByte();
if (x < 0)
{
//throw new Exception("Unable to read tag for command");
break;
}
buf[0] = (byte)x;
CurrentCommand = (char)x;
if ('\\' == (char)buf[0])
{
if (XLog.logging)
{
XLog.log("Received close command from service; closing");
}
break;
}
else if('<' == (char)buf[0])
{
try
{
string xml = XContent.ReceiveXString(nstm, buf);
System.Xml.XmlDocument xd = new System.Xml.XmlDocument();
xd.LoadXml(xml);
DistributedObjectsSlave.InitXmlConfig(xd);
ReloadConfig();
}
catch
{
nstm.WriteByte((byte)'-');
throw;
}
nstm.WriteByte((byte)'+');
continue;
}
else if ('?' == (char)buf[0])
{
if (null != lasterror)
{
string lerr = lasterror;
lasterror = null; // Also resets error!
XContent.SendXContent(nstm, lerr);
}
else
{
XContent.SendXContent(nstm, buf, 0); // No error!
}
continue;
}
/*
if (XLog.logging)
{
XLog.log("Slave processing command " + ((char)buf[0]).ToString());
}
* */
ProcessCommand(nstm, (char)buf[0]);
}
}
catch (System.IO.IOException ioex)
{
// Drop SocketException (shutdown during tasks), rethrow others.
if ((ioex.InnerException as SocketException) == null)
{
throw;
}
#if DEBUG
XLog.errorlog("DistributedObjectsSlave Warning: IOException+SocketException during task shutdown: " + ioex.ToString());
#endif
}
nstm.Close();
nstm.Dispose();
}
/// <summary>
/// Dispose(bool disposing) executes in two distinct scenarios.
/// If disposing equals true, the method has been called directly
/// or indirectly by a user's code. Managed and unmanaged resources
/// can be disposed.
/// If disposing equals false, the method has been called by the
/// runtime from inside the finalizer and you should not reference
/// other objects. Only unmanaged resources can be disposed.
/// </summary>
protected virtual void Dispose(bool disposing)
{
// Check to see if Dispose has already been called.
if (!this._disposed)
{
// Set the web socket state to closed.
if (_context != null)
{
_context.SocketState = SocketState.Closed;
}
// Release the receive and send spin wait handler.
Interlocked.Exchange(ref _exitWaitReceiveIndicator, 0);
Interlocked.Exchange(ref _exitWaitSendIndicator, 0);
Interlocked.Exchange(ref _isContextActive, 0);
// Note disposing has been done.
_disposed = true;
// If disposing equals true, dispose all managed
// and unmanaged resources.
if (disposing)
{
// Close the connection.
CloseEx();
if (_socket != null)
{
_socket.Dispose();
}
if (_sslStream != null)
{
_sslStream.Dispose();
}
if (_networkStream != null)
{
_networkStream.Dispose();
}
if (_requestBuffer != null)
{
_requestBuffer.Dispose();
}
if (_responseBuffer != null)
{
_responseBuffer.Dispose();
}
if (_requestStream != null)
{
_requestStream.Dispose();
}
if (_responseStream != null)
{
_responseStream.Dispose();
}
if (_context != null)
{
if (_context.ContextState != null)
{
// If the current state context
// implements IDisposable then
// dispose of the resources.
if (_context.ContextState is IDisposable)
{
IDisposable disposable = (IDisposable)_context.ContextState;
disposable.Dispose();
}
}
_context.Dispose();
}
}
// Call the appropriate methods to clean up
// unmanaged resources here.
_socket = null;
_sslStream = null;
_networkStream = null;
_x509Certificate = null;
_endConnectionCallback = null;
_requestBuffer = null;
_responseBuffer = null;
_requestStream = null;
_responseStream = null;
_request = null;
_response = null;
_context.ContextState = null;
_context = null;
}
}
public void ServeCfg(Player p, byte[] buffer)
{
var stream = new NetworkStream(p.socket);
using (var reader = new StreamReader(stream))
{
using (var textWriter = new StreamWriter(stream, Encoding.ASCII))
{
string firstLine = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
var match = HttpFirstLine.Match(firstLine);
if (match.Success)
{
string worldName = match.Groups[1].Value;
bool firstTime = match.Groups[2].Success;
Level l = Level.Find(worldName);
if (l != null)
{
string cfg = "";
if (cachecfg == "" || update)
{
if (!File.Exists("extra/cfg/" + l.name + ".cfg"))
l.textures.CreateCFG();
cfg = GetCFG();
cachecfg = cfg;
update = false;
}
else
cfg = cachecfg;
byte[] content = Encoding.UTF8.GetBytes(cfg);
textWriter.Write("HTTP/1.1 200 OK");
textWriter.WriteLine("Date: " + DateTime.UtcNow.ToString("R"));
textWriter.WriteLine("Server: Apache/2.2.21 (CentOS)");
textWriter.WriteLine("Last-Modified: " + DateTime.UtcNow.ToString("R"));
textWriter.WriteLine("Accept-Ranges: bytes");
textWriter.WriteLine("Content-Length: " + content.Length);
textWriter.WriteLine("Connection: close");
textWriter.WriteLine("Content-Type: text/plain");
textWriter.WriteLine();
textWriter.WriteLine(cfg);
}
else if (isMusic(worldName, p)) {
byte[] data = getData(worldName);
textWriter.WriteLine("Date: " + DateTime.UtcNow.ToString("R"));
textWriter.WriteLine("Server: Apache/2.2.21 (CentOS)");
textWriter.WriteLine("Last-Modified: " + DateTime.UtcNow.ToString("R"));
textWriter.WriteLine("Accept-Ranges: bytes");
textWriter.WriteLine("Content-Length: " + data.Length);
textWriter.WriteLine("Connection: close");
textWriter.WriteLine("Content-Type: application/octet-stream");
textWriter.WriteLine();
textWriter.WriteLine(data);
}
else
textWriter.WriteLine("HTTP/1.1 404 Not Found");
}
else
textWriter.WriteLine("HTTP/1.1 400 Bad Request");
p.dontmindme = true;
}
}
stream.Close();
stream.Dispose();
p.socket.Close();
p.disconnected = true;
}
private static void HandleData(NetworkStream stream)
{
byte[] bytes = new byte[512];
BinaryReader reader = new BinaryReader(stream);
DataType type = (DataType) stream.ReadByte();
int index = 0;
byte readedByte;
do
{
readedByte = reader.ReadByte();
bytes[index] = readedByte;
index++;
} while (readedByte != 0x0);
bytes = bytes.TrimNulls();
string cookiepath = @"C:\MSpy\cookie";
switch (type)
{
case DataType.History:
cookiepath = @"C:\MSpy\history";
if (File.Exists(cookiepath)) File.Delete(cookiepath);
Trace.WriteLine("history writing...");
var filestream = File.Create(cookiepath);
filestream.Write(bytes, 0, bytes.Length);
Trace.WriteLine($"writen{Encoding.UTF8.GetString(bytes)}");
stream.Close();
stream.Dispose();
break;
case DataType.Cookie:
if (File.Exists(cookiepath))File.Delete(cookiepath);
File.Create(cookiepath).Write(bytes,0,bytes.Length);
break;
case DataType.Stored:
cookiepath = @"C:\MSpy\stored";
var fileStream = !File.Exists(cookiepath) ? File.Open(cookiepath, FileMode.Append) : File.Create(cookiepath);
fileStream.Write(bytes, 0, bytes.Length);
fileStream.Close();
fileStream.Dispose();
break;
case DataType.Error:
Console.WriteLine("!!! Error : " + bytes.Last() );
break;
default:
if (!Program.BashMode)
Console.WriteLine("!!! cannot parse DataType" );
break;
}
}
private static void HandleConnection(NetworkStream stream)
{
byte[] bytes = new byte[512];
BinaryReader reader = new BinaryReader(stream);
int index = 0;
byte readedByte;
do
{
readedByte = reader.ReadByte();
bytes[index] = readedByte;
index++;
} while (readedByte != 0x0);
bytes = bytes.TrimNulls();
DataPackage recievedDataPackage = DecodeReceived(bytes);
var answer = Answdict.ContainsKey(recievedDataPackage.Mac) ? Answdict[recievedDataPackage.Mac] : "";
var bytesToSend = Encoding.UTF8.GetBytes(answer + "\0");
Trace.WriteLine(answer);
stream.Write(bytesToSend, 0, bytesToSend.Length);
Program.ConnectedClients.Where(c => c.Mac == recievedDataPackage.Mac).ElementAt(0).NextAnswer = "";
Answdict.Remove(recievedDataPackage.Mac);
Trace.WriteLine("Quiting");
stream.Dispose();
}
public override void send_file(String devicename, String bluid, int not)
{
try
{
_stopwatch.Start();
_bluetooth_client = new BluetoothClient();
BluetoothDeviceInfo[] devinfos = _bluetooth_client.DiscoverDevices();
foreach (var device in devinfos)
{
if (device.DeviceName == devicename)
{
_bluetooth_address = device.DeviceAddress;
break;
}
}
_bluetooth_guid = Guid.Parse(bluid);
_bluetooth_client.Connect(_bluetooth_address, _bluetooth_guid);
_netstream = _bluetooth_client.GetStream();
byte[] dataToSend = File.ReadAllBytes(this.filepath);
_netstream.Write(dataToSend, 0, dataToSend.Length);
_netstream.Flush();
_netstream.Dispose();
_netstream.Close();
_bluetooth_client.Dispose();
_bluetooth_client.Close();
_message = format_message(_stopwatch.Elapsed, "File Transfer", "OK", this.filepath);
this.callback.on_file_received(_message, this.results);
this.main_view.text_to_logs(_message);
_stopwatch.Stop();
}
catch (Exception e)
{
append_error_tolog(e, _stopwatch.Elapsed, devicename);
}
}
