private void GetInfoAboutFiles()
{
try
{
SocketHandler sh = new SocketHandler();
sh.sendData("213");
sh.getMsgCode();
int amount = int.Parse(sh.recvDataWithSize());
for (int i = 0; i < amount; i++)
{
int length = sh.getDataLen(3);
string fileName = sh.recvDataWithGivenSize(length);
length = sh.getDataLen(2);
string fileType = sh.recvDataWithGivenSize(length);
length = sh.getDataLen(2);
string fileSize = sh.recvDataWithGivenSize(length);
length = sh.getDataLen(2);
string fileLoc = sh.recvDataWithGivenSize(length);
int isEncrypted = int.Parse(sh.recvDataWithGivenSize(1));
AddRowToGrid(fileName, fileType, fileLoc, fileSize, isEncrypted);
}
}
catch (SocketException ex)
{
Notifier n = AsyncBlockingSocket.initNotifier();
n.ShowError(ex.ToString());
}
catch (Exception ex)
{
Notifier n = AsyncBlockingSocket.initNotifier();
n.ShowError(ex.ToString());
}
}
private void loginBtn_Click(object sender, RoutedEventArgs e)
{
if (usernameBox.Text == "" || passwordBox.Password == "")
{
Notifier n = new Notifier(cfg =>
{
cfg.PositionProvider = new WindowPositionProvider(
parentWindow: this,
corner: Corner.BottomRight,
offsetX: 10,
offsetY: 10);
cfg.LifetimeSupervisor = new TimeAndCountBasedLifetimeSupervisor(
notificationLifetime: TimeSpan.FromSeconds(2),
maximumNotificationCount: MaximumNotificationCount.FromCount(1));
cfg.Dispatcher = Application.Current.Dispatcher;
});
n.ShowWarning("Please fill all required values.");
}
else
{
string hashPassword = ComputeHash(passwordBox.Password, new MD5CryptoServiceProvider());
string data = "200";
data += usernameBox.Text.Length.ToString().PadLeft(2, '0');
data += SocketHandler.Encipher(usernameBox.Text, "cipher");
data += hashPassword.Length.ToString().PadLeft(2, '0');
data += SocketHandler.Encipher(hashPassword, "cipher");
SocketHandler sh = new SocketHandler();
try
{
sh.sendData(data);
string result = sh.recvData();
if (result.Equals("1000"))
{
LoadingPage app = new LoadingPage();
this.Close();
app.Show();
}
else
{
Notifier n = AsyncBlockingSocket.initNotifier();
n.ShowWarning("Wrong username or password");
}
}
catch (SocketException ex)
{
Notifier n = AsyncBlockingSocket.initNotifier();
n.ShowError(ex.Message);
}
catch (Exception ex)
{
Notifier n = AsyncBlockingSocket.initNotifier();
n.ShowError(ex.Message);
}
}
}
} // btn_sendMsg_Click
/// <summary>
/// 群聊通信
/// </summary>
private void sendData()
{
User currentUser = User.GetInstance();
try
{
string finalStr = BuildMsg.buildSendMsg("group", userName, currentUser.socket.LocalEndPoint.ToString(), destName, str_Send);
byte[] msg = Encoding.UTF8.GetBytes(finalStr);
//始化需要传入的参数
SendCallBackParam sendCallBackParam = new SendCallBackParam(
str_Send,
lstBox_recMsg,
appendString);
// 定制并实例化回调方法
AsyncCallback callBack = new AsyncCallback(CallBackFunc.sendCallBack);
// 开始异步发送数据
currentUser.socket.BeginSend(msg, 0, msg.Length, SocketFlags.None, callBack, sendCallBackParam);
} // try
catch (System.Exception ex)
{
SocketHandler.ShutDownConn(currentUser.socket);
lstBox_recMsg.Invoke(appendString, lstBox_recMsg, "服务器断开了TCP连接");
} // catch
} // sendData
private bool isUserConntected(string username)
{
List <string> users = new List <string>();
try
{
SocketHandler sh = new SocketHandler();
sh.sendData("210");
sh.getMsgCode();
int amount = int.Parse(sh.recvDataWithSize());
for (int i = 0; i < amount; i++)
{
string connectedUser = sh.recvDataWithSize();
users.Add(connectedUser);
}
}
catch (SocketException ex)
{
Notifier n = AsyncBlockingSocket.initNotifier();
n.ShowError(ex.ToString());
}
catch (Exception ex)
{
Notifier n = AsyncBlockingSocket.initNotifier();
n.ShowError(ex.ToString());
}
if (users.Contains(username))
{
return(true);
}
return(false);
}
private void F_FormClosing(object sender, System.Windows.Forms.FormClosingEventArgs e)
{
e.Cancel = true;
Logger.WriteLine("Exiting");
SocketHandler.Stop();
Exit();
}
static void Main()
{
UserInput userInput = new UserInput();
if (userInput.Error != UserInputError.None)
{
userInput.PrintErrorMessage();
return;
}
SocketHandler socketHandler = new SocketHandler(userInput);
if (userInput.AppType == "1") // Server
{
socketHandler.RunServer();
}
else // Client
{
socketHandler.RunClient();
}
if (socketHandler.WasSuccessful)
{
Console.WriteLine("Program Was Successful!");
}
else
{
Console.WriteLine("Program Failed!");
}
Console.Write("Press Enter To Continue...");
Console.Read();
}
public override void Update()
{
if (!started)
{
try
{
var data = SocketHandler.GetData();
if (data.BaseStream.Length == 8)
{
gamelist = new GameList(Vector2.Zero, 5, true, 0, data.ReadSingle(), data.ReadSingle());
Objects.Add(gamelist);
started = true;
}
SocketHandler.SendMessage(PacketTypes.MOUSE, Mouse.Position.X, Mouse.Position.Y, Mouse.AverageMovement().X, Mouse.AverageMovement().Y);
}
catch
{
}
}
else
{
if (gamelist.speed == 0)
{
SocketHandler.SendMessage(PacketTypes.MOUSE, Mouse.Position.X + 0.5f, Mouse.Position.Y + 0.1f + (gamelist.bottompanel / 10f), Mouse.AverageMovement().X, Mouse.AverageMovement().Y);
}
else
{
SocketHandler.SendMessage(PacketTypes.MOUSE, Mouse.Position.X, Mouse.Position.Y, Mouse.AverageMovement().X, Mouse.AverageMovement().Y);
}
}
}
public override void Update()
{
Graphics.ApplyChanges();
if (triedlogin == false)
{
SocketHandler.SetHandler(PacketTypes.LOGINSESSID, LoggedIn);
if (!SocketHandler.Connected)
{
if (File.Exists(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "/Kakoi/token"))
{
try
{
TextBoxUUID.Text = File.ReadAllText(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "/Kakoi/token");
if (TextBoxUUID.Text.Length == 32)
{
SocketHandler.Connect(TextBoxUUID.Text, TextBoxIP.Text);
}
}
catch (IOException)
{ mplog += "Kon sessid bestand niet uitlezen!\n"; }
}
}
triedlogin = true;
}
}
public override void Update()
{
foreach (Message message in messages)
{
if (!message.Handled)
{
message.Text = font.WrapText(message.Text, 1890 - font.MeasureString(message.Sender).X).Trim();
if (message.Text.Length > 0)
{
if (message.Text[0] == '\n')
{
message.Text = message.Text.Substring(1);
}
}
message.Handled = true;
}
}
if (Keyboard.CheckPressed(Microsoft.Xna.Framework.Input.Keys.A))
{
var s = new MemoryStream();
var m = new StreamWriter(s);
m.Flush();
SocketHandler.SendMessage(PacketTypes.CHAT, "Hallo allemaal");
}
}
public static int Main(String[] args)
{
SocketHandler handler = new SocketHandler();
handler.StartListening("172.20.17.129");
return(0);
}
private async void SubscribeUser(SocketHandler socketHandler, ChatObject e)
{
var dbUser = await _usermanager.FindByNameAsync(e.SenderName);
if (dbUser == null)
{
SendServerResponse(socketHandler, MessageType.LoginFailed, e, "No User");
}
else
{
var token = HttpUtility.UrlDecode(e.Message);
var verify = await _usermanager.VerifyUserTokenAsync(dbUser, "Default", "Chat", token);
if (verify)
{
if (AllSocketInstances.ContainsKey(dbUser.UserName))
{
AllSocketInstances[dbUser.UserName].Add(socketHandler);
}
else
{
AllSocketInstances[dbUser.UserName] = new List <SocketHandler> {
socketHandler
};
}
SendServerResponse(socketHandler, MessageType.LoginSuccess, e);
}
else
{
SendServerResponse(socketHandler, MessageType.LoginFailed, e, "Login unsuccessfull");
}
}
}
protected override void OpenBlocking(Stream stream, Socket socket)
{
_socket = socket;
_stream = stream;
_writer = new WebSocketFrameWriter(stream);
PerformHandshake(stream);
_isOpen = true;
OnConnectionOpened();
if (_socket.Connected)
{
if (ChannelParameters.TimeOut > 0)
{
_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.SendTimeout, ChannelParameters.TimeOut);
_socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReceiveTimeout, ChannelParameters.TimeOut);
}
_socketHandler = new SocketHandler(_socket, ChannelParameters.BufferSize);
_socketHandler.Received += sh_received;
_socketHandler.Disconnected += sh_disconnected;
_socketHandler.ConnectionId = ConnectionId;
_frameBuilder.ConnectionId = ConnectionId;
_socketHandler.Start();
}
}
internal void Send(byte[] p)
{
if (this.m_connObj != null && this.m_connObj.Connected)
{
SocketHandler.Send(this.m_connObj, p);
}
}
private void Form1_Load(object sender, EventArgs e)
{
connection = new SocketHandler();
connection.Connect("localhost", 12345);
connection.PacketReceiveEvent += HandlePacket;
}
public void DrawRoom(Vector2 position, string name, int players, string owner, bool locked, int id)
{
Rectangle bounds = new Rectangle(position.ToPoint() + new Point(0, 140), new Point(1400, 100));
Color oldColor = View.DrawColor;
View.DrawColor = bounds.Contains(Mouse.Position) && Mouse.Position.Y > 140 ? Color.White : Color.LightGray;
float opacity = bounds.Contains(Mouse.Position) && Mouse.Position.Y > 140 ? 0.25f : 0.2f;
opacity = bounds.Contains(Mouse.Position) && Mouse.Check(MouseButtons.Left) && Mouse.Position.Y > 140 ? 0.3f: opacity;
View.DrawRectangle(position, new Vector2(1400, 100), false, new Color(Color.Black, opacity));
View.DrawText(Arial24, name, position + new Vector2(20, 20));
View.DrawText(Arial16, "By " + owner, position + new Vector2(20, 60));
float numWidth = Arial24.MeasureString(players + "/4").X;
View.DrawText(Arial24, players + "/4", position + new Vector2(1380 - numWidth, 20), Color.LightGray);
if (locked)
{
View.DrawTexture(LockSmall, position + new Vector2(1359, 60));
}
View.DrawColor = oldColor;
if (Mouse.CheckReleased(MouseButtons.Left) && bounds.Contains(Mouse.Position) && Mouse.Position.Y > 140)
{
SocketHandler.SendMessage(PacketTypes.JOINROOM, id);
}
}
public FileTransferringSocketReciever(SocketHandler socketHandler, FileSystem fileSystem)
{
_socketHandler = socketHandler;
_fileSystem = fileSystem;
_out = socketHandler.GetOutputStream();
_in = socketHandler.GetInputStream();
}
private void deleteBtn_Click(object sender, RoutedEventArgs e)
{
Button btn = sender as Button;
string username = btn.DataContext as string;
string groupName = groupNameLbl.Content.ToString();
string data = "212";
data += username.Length.ToString().PadLeft(2, '0');
data += SocketHandler.Encipher(username, "cipher");;
data += groupName.Length.ToString().PadLeft(2, '0');
data += SocketHandler.Encipher(groupName, "cipher");;
SocketHandler sh = new SocketHandler();
try
{
sh.sendData(data);
}
catch (SocketException ex)
{
Notifier n = AsyncBlockingSocket.initNotifier();
n.ShowError(ex.ToString());
}
catch (Exception ex)
{
Notifier n = AsyncBlockingSocket.initNotifier();
n.ShowError(ex.ToString());
}
GetInfoAboutGroups();
updateView(groupName);
}
public override void Draw()
{
foreach (var position in positions)
{
View.DrawSprite(fly, 0, position.Value);
}
List <Player> players = SocketHandler.GetPlayers();
int mynum = 0;
foreach (Player player in players)
{
if (player.Id != SocketHandler.UserId)
{
View.DrawSprite(meppers, player.NumInRoom % 4, new Vector2(player.X, player.Y));
View.DrawText(Arial, player.Name, new Vector2(player.X, player.Y));
}
else
{
mynum = player.NumInRoom % 4;
}
}
View.DrawSprite(meppers, mynum, Mouse.Position);
if (Timer < 5000)
{
View.DrawText(Arial, 5 - Timer / 1000, new Vector2(Graphics.PreferredBackBufferWidth / 2f, Graphics.PreferredBackBufferHeight / 2f) - Arial.MeasureString((5 - Timer / 10000).ToString()) * 0.5f);
}
}
public void StartServer()
{
tcpListener.Start();
while (true)
{
TcpClient tcpClient = tcpListener.AcceptTcpClient();
// Add connect client IP to list
IPEndPoint ipEndpoint = tcpClient.Client.RemoteEndPoint as IPEndPoint;
string connectMessage = "Client ip = " + ipEndpoint.Address.ToString() + " connected to server.";
if (mainWindow.listBoxClient.InvokeRequired)
{
mainWindow.Invoke(new MethodInvoker(delegate()
{ mainWindow.listBoxClient.Items.Add(connectMessage); }));
}
else
{
mainWindow.listBoxClient.Items.Add(connectMessage);
}
// Create socket handler for dealing client request
SocketHandler socketHandler = new SocketHandler(tcpClient);
Thread t1 = new Thread(socketHandler.ProcessSocketRequest);
t1.IsBackground = true;
t1.Start();
}
}
public static DistCacheClient Create(DistCacheClientConfig config)
{
TcpClient tcp = null;
IPEndPoint toTry;
Dictionary <IPEndPoint, bool> invalidEndPoints = new Dictionary <IPEndPoint, bool>();
while ((toTry = config.GetOrderedServerIpEndPoint().FirstOrDefault(i => !invalidEndPoints.ContainsKey(i))) != null)
{
try
{
tcp = SocketHandler.CreateSocket(toTry, config);
}
catch (Exception ex)
{
tcp = null;
invalidEndPoints[toTry] = true;
}
if (tcp != null)
{
break;
}
}
if (tcp != null)
{
return(new DistCacheClient(tcp, config));
}
throw new Exception("could not connect to any node");
}
public IInputHandler GetNetworkPlayer()
{
SocketHandler socketHandler = clients[counter];
counter++;
return(socketHandler);
}
private async void SendEndToEndMessage(SocketHandler socketHandler, ChatObject e)
{
var receiverInstances = new List <SocketHandler>();
if (AllSocketInstances.ContainsKey(e.ReceiverName))
{
var rInstances = AllSocketInstances[e.ReceiverName];
receiverInstances.AddRange(rInstances);
}
if (AllSocketInstances.ContainsKey(e.SenderName))
{
var sInstances = AllSocketInstances[e.SenderName]
.Where(x => x.Id != socketHandler.Id);
receiverInstances.AddRange(sInstances);
}
foreach (var item in receiverInstances.Where(m => m.IsActive))
{
try
{
await item.SendMessage(e);
e.Delivered = true;
}
catch (Exception ex)
{
LogEngine.Error(ex);
}
}
_localDB.Add(e);
await _localDB.SaveChangesAsync();
}
private void HandleData(SocketHandler topLevelSocketHandler)
{
int dataSize = _in.ReadInt32();
var type = _in.ReadJavaUTF();
var compressed = _in.ReadBoolean();
var bytes = _in.ReadBytes(dataSize);
if (compressed)
{
bytes = new Decompressor().Uncompress(bytes);
}
try
{
var handlerType = MessageHandler <SocketHandler, Object> .Get(type);
var method = handlerType.GetMethod("Handle");
var ins = Activator.CreateInstance(handlerType);
method.Invoke(ins, new Object[] { topLevelSocketHandler, bytes });
}
catch (KeyNotFoundException ex)
{
throw new Exception("No such protocol: " + type);
}
}
public override void Awake()
{
var monitorManager = (IMonitorManager)_serviceProvider.GetService(typeof(IMonitorManager));
_monitorUnit = new MonitorUnit(monitorManager);
_socketHandler = new SocketHandler(SocketConnectedCallback, _monitorUnit);
}
protected override void Send(GameObject target)
{
var toMovePlanes = new List <int>();
for (var i = 0; i < Island.transform.childCount; ++i)
{
var ship = Island.transform.GetChild(i).gameObject;
var shipData = ship.GetComponent <ShipData>(); // possibly cachable
if (shipData == null)
{
continue; // skip non ship gameobjects
}
if (shipData.PlayerData.uid == Game.Shared.ClientUid)
{
toMovePlanes.Add(shipData.uid);
}
}
;
Deselect();
Debug.Log("request move-units: " + PackageFactory.CreateMoveUnitMessage(target.GetComponent <IslandData>().Uid, toMovePlanes.ToArray()));
var json = PackageFactory.CreateMoveUnitMessage(target.GetComponent <IslandData>().Uid, toMovePlanes.ToArray());
SocketHandler.EmitNow("move-unit", json);
Move(json);
}
public MainViewModel()
{
serverSocket = new ServerSocket();
mainModel = new MainModel();
socketHandler = SocketHandler.GetInstance;
mySqlUser = MySqlUser.GetInstance;
mainModel.LaberText = "停止";
mainModel.ButtonText = "启动";
startCommand = new CommandBase();
startCommand.DoExecute = new Action <object>((o) => {
if (MainModel.status == 0)
{
MainModel.status = 1;
mainModel.LaberText = "运行中";
mainModel.ButtonText = "停止";
serverSocket.Start(mainModel.Port);
}
else
{
MainModel.status = 0;
mainModel.LaberText = "停止";
mainModel.ButtonText = "启动";
serverSocket.Close();
}
});
startCommand.DoCanExecute = new Func <object, bool>((o) => { return(true); });
}
internal int ConnectToServer()
{
int result = 0;
if (this.m_connObj == null)
{
Debug.WriteLine("SessionController - ConnterToServer - ConObj is null, making a new one");
this.m_connObj = new ConnObj(this.m_SessionData.ConnectionInfo.IpA, this.m_SessionData.ConnectionInfo.Port);
result = 1;
}
if (SocketHandler.Connect(this.m_connObj))
{
this.m_decoder = new MMudTerm_Protocols.AnsiProtocolCmds.AnsiProtocolDecoder();
this.m_connObj.Rcvr += new RcvMsgCallback(ConnHandler_Rcvr);
this.m_connObj.Disconnected += new EventHandler(ConnHandler_Disconnected);
result = 2;
}
else
{
this.m_connObj.mySocket.Close();
this.m_connObj = null;
result = 3;
}
return(result);
}
internal int DisconnectFromServer()
{
int result = 0;
if (this.m_connObj == null && this.m_currentSessionState.State == SessionStates.OFFLINE)
{
result = 1;
}
else if (this.m_connObj != null && this.m_currentSessionState.State != SessionStates.OFFLINE)
{
result = 2;
}
else
{
throw new Exception("Invalid coonObj state and session state!");
}
if (result == 2)
{
SocketHandler.Disconnect(this.m_connObj);
this.m_connObj = null;
SetState(SessionStates.OFFLINE);
result = 1;
}
return(result);
}
private void button1_Click(object sender, RoutedEventArgs e)
{
Returnable returnable = ConfigReader.readPortsFromConfig("managementConfigFile.xml");
List <int> portList = returnable.portList;
clientList = new List <Router>();
availableConteners = returnable.contenerList;
availableModules = returnable.moduleList;
routerList = new List <Router>();
if (portList == null)
{
appendConsole("Błąd odczytu pliku konfiguracyjnego, spróbuj ponownie.", null, null);
return;
}
appendConsole("Obsługiwany moduł w sieci: " + availableModules[0], null, null);
appendConsole("Obsługiwane kontenery:", null, null);
foreach (string s in availableConteners)
{
appendConsole(s, null, null);
}
socketHandler = new SocketHandler(portList, this, availableModules, availableConteners);
actionBox.IsEnabled = true;
nodeBox.IsEnabled = true;
selectionBox.IsEnabled = true;
button1.IsEnabled = false;
button2.IsEnabled = true;
addNewButton.IsEnabled = true;
initialised = true;
Load_All.IsEnabled = true;
}
public void ListenerThread()
{
tcpListener = new TcpListener(IPAddress.Any, 8080);
tcpListener.Server.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, 1);
tcpListener.Start();
try
{
Socket handlerSocket = tcpListener.AcceptSocket();
if (handlerSocket.Connected)
{
tcpListener.Stop();
SocketHandler.setSocket(handlerSocket);
clientIp = (IPAddress.Parse(((IPEndPoint)handlerSocket.RemoteEndPoint).Address.ToString())).ToString();
// Send acknowledgement to client
NetworkStream networkStream = new NetworkStream(handlerSocket);
StreamWriter writer = new StreamWriter(networkStream);
writer.Write(Environment.MachineName + ": Connection accepted." + Environment.NewLine);
writer.Flush();
Console.WriteLine("Accepting connection from " + clientIp);
// Receive acknowledgement from client
StreamReader sr = new StreamReader(networkStream);
bool acknowledged = false;
while (!acknowledged)
{
if (sr.Peek() > 0)
{
String s = sr.ReadLine();
int separatorIndex = s.IndexOf(':');
if (separatorIndex != -1)
{
clientName = s.Substring(0, separatorIndex);
}
Console.WriteLine("Recevied: " + s);
acknowledged = true;
}
}
// Change window
Application.Current.Dispatcher.Invoke(new Action(() =>
{
connectedWindow = new ConnectedWindow(clientName);
this.Close();
connectedWindow.ShowDialog();
}));
}
}
catch (SocketException e)
{
if ((e.SocketErrorCode == SocketError.Interrupted))
{
Console.WriteLine("Socket interupted");
}
}
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
//Application.Run(new ClientForm());
SocketHandler sh = new SocketHandler();
sh.DataArrive += new EventHandler<DataArriveEventArgs>(sh_DataArrive);
Socket s = sh.Connect("127.0.0.1");
sh.SendPacket(s, new OperatorServiceInterface.LoginAction("111"));
while (true)
{
Thread.Sleep(1000);
}
}
protected virtual void OnMessageReceived(SocketHandler handler, ISocketMessage message)
{
trace.TraceEvent(TraceEventType.Verbose, 0, $"Received { message.MessageTypeId } ({ message.MessageLength } bytes): {message.GetType()}");
this.MessageReceived?.Invoke(this, new SocketMessageEventArgs(message, handler));
}
/// <summary>
/// Initialize the appender based on the options set.
/// </summary>
/// <remarks>
/// <para>
/// This is part of the <see cref="IOptionHandler"/> delayed object
/// activation scheme. The <see cref="ActivateOptions"/> method must
/// be called on this object after the configuration properties have
/// been set. Until <see cref="ActivateOptions"/> is called this
/// object is in an undefined state and must not be used.
/// </para>
/// <para>
/// If any of the configuration properties are modified then
/// <see cref="ActivateOptions"/> must be called again.
/// </para>
/// <para>
/// Create the socket handler and wait for connections
/// </para>
/// </remarks>
public override void ActivateOptions()
{
base.ActivateOptions();
try
{
LogLog.Debug(declaringType, "Creating SocketHandler to listen on port ["+m_listeningPort+"]");
m_handler = new SocketHandler(m_listeningPort);
}
catch(Exception ex)
{
LogLog.Error(declaringType, "Failed to create SocketHandler", ex);
throw;
}
}
/// <summary>
/// Overrides the parent method to close the socket handler
/// </summary>
/// <remarks>
/// <para>
/// Closes all the outstanding connections.
/// </para>
/// </remarks>
protected override void OnClose()
{
base.OnClose();
if (m_handler != null)
{
m_handler.Dispose();
m_handler = null;
}
}
private int _bytesLeft; // bytes left to read
internal TcpFixedLengthReadingStream(SocketHandler inputStream,
int contentLength)
{
_inputStream = inputStream;
_bytesLeft = contentLength;
} // TcpFixedLengthReadingStream
private byte[] _byteBuffer = new byte[1]; // buffer for reading bytes
internal TcpChunkedReadingStream(SocketHandler inputStream)
{
_inputStream = inputStream;
_bytesLeft = 0;
} // HttpChunkedRequestStream
/// <summary>
/// Called when a client has connected, in order to accept the connection
/// </summary>
private void OnAcceptClient(IAsyncResult result)
{
var listener = (TcpListener)result.AsyncState;
TcpClient client;
try
{
client = listener.EndAcceptTcpClient(result);
}
catch (ObjectDisposedException)
{
this.trace.TraceEvent(TraceEventType.Warning, 0, "ObjectDisposedException encountered, listener could be in an exiting state. Not listening for any more clients");
this.isRunning = false;
return;
}
trace.TraceEvent(TraceEventType.Information, 0, $"Accepted client from {client.Client.RemoteEndPoint}");
if (!this.isRunning)
return;
// Process the client
ThreadPool.QueueUserWorkItem(state =>
{
trace.TraceEvent(TraceEventType.Verbose, 0, "Starting client processor thread");
using (var handler = new SocketHandler(client))
{
handler.MessageReceived += (s, a) =>
{
this.OnMessageReceived(handler, a.Message);
};
this.handlers.Add(handler);
handler.Receive(cancelToken: new CancelToken());
trace.TraceEvent(TraceEventType.Information, 0, "Connection to client closed");
}
});
if (this.isRunning)
{
trace.TraceEvent(TraceEventType.Information, 0, "Waiting for more clients");
listener.BeginAcceptTcpClient(this.OnAcceptClient, listener);
}
}
