private void ProcessReceivedMessage(SocketAsyncEventArgs e)
{
var token = (HostAsyncUserToken)e.UserToken;
Message message = WoxalizerAdapter.DeserializeFromXml(token.MsgData, TypeResolving.AssemblyResolveHandler);
//// TODO: why do not write: "if (message is RequestMessage)" ... - so we don't need MessageType!
////switch ((EMessageType)message.MessageType)
////{
//// case EMessageType.Request:
//// ProcessReceivedMessageRequest(e, (RequestMessage)message);
//// break;
//// case EMessageType.Response:
//// ProcessReceivedMessageResponse(e, (ResponseMessage)message);
//// break;
//// default:
//// throw new ApplicationException();
////}
if (message is RequestMessage)
{
ProcessReceivedMessageRequest(e, (RequestMessage)message);
}
else if (message is ResponseMessage)
{
ProcessReceivedMessageResponse(e, (ResponseMessage)message);
}
else
{
throw new ArgumentException("Cannot determinate Message type!");
}
}
// Deserialize received message and invoke callback that should process the message
protected override void ProcessReceivedMessage(SocketAsyncEventArgs e)
{
var token = (HostAsyncUserToken)e.UserToken;
// decrypt message data
var decryptedMsgData = EncryptionAdapter.Decrypt(token.RecievedMsgData);
Logger.WriteStr(" Dectypted message: " + utf8.GetString(decryptedMsgData));
// deserialize to object
Message message = null;
try
{
message = WoxalizerAdapter.DeserializeFromXml(decryptedMsgData);
}
catch (Exception ex)
{
// it can be garbage or DoS attack, so better to close connection
Logger.WriteStr("ERROR: Cannot deserialize recieved message (" + ex.Message + "). Aborting connection.");
CloseConnection(e);
return;
}
var args = new HostCustomEventArgs(e.SocketError, message)
{
Token = token
};
if (token.Callback != null)
{
token.Callback.Invoke(args);
}
}
// Called when a ConnectAsync operation completes
private void ProcessConnect(SocketAsyncEventArgs e)
{
if (e.SocketError == SocketError.Success)
{
Logger.WriteStr("Successfully connected to the server on " + ((AgentAsyncUserToken)(e.UserToken)).Socket.LocalEndPoint.ToString());
retryIntervalCurrent = retryIntervalInitial; // set it to initial value
//Send authorization info about this client as soon as connection established
var idata = new IdentificationData();
OpProcessor.GetInfo(idata); // fill required data
var message = new ResponseMessage {
Response = idata
};
SendMessage(e, WoxalizerAdapter.SerializeToXml(message, TypeResolving.AssemblyResolveHandler));
}
else
{
int ex = (int)e.SocketError;
Console.WriteLine("Cannot connect to server " + e.RemoteEndPoint.ToString() + ". Will try again in " + retryIntervalCurrent + " seconds");
Logger.WriteStr("Cannot connect to server " + e.RemoteEndPoint.ToString() + ". Will try again in " + retryIntervalCurrent + " seconds");
Logger.WriteStr(" (Exception: " + ex.ToString() + ")");
Thread.Sleep(retryIntervalCurrent * 1000);
if (retryIntervalCurrent < retryIntervalMaximum) //increase interval between reconnects up to retryIntervalMaximum value.
{
retryIntervalCurrent += 5;
}
e.SocketError = 0; //clear Error info and try to connect again
((AgentAsyncUserToken)e.UserToken).Socket.ConnectAsync(e);
return;
}
}
protected override void ProcessReceivedMessage(SocketAsyncEventArgs e)
{
var token = (AsyncUserTokenBase)e.UserToken;
// decrypt message data
var decryptedMsgData = EncryptionAdapter.Decrypt(token.RecievedMsgData);
Logger.WriteStr(" Recieved message was decrypted as xml: " + utf8.GetString(decryptedMsgData));
// deserialize to object
Message message = null;
try
{
message = WoxalizerAdapter.DeserializeFromXml(decryptedMsgData);
}
catch (Exception ex)
{
Logger.WriteStr("ERROR: Cannot deserialize recieved message (" + ex.Message + "). Aborting connection.");
CloseConnection(e);
}
if (message is RequestMessage)
{
ProcessReceivedMessageRequest(e, (RequestMessage)message);
}
else if (message is ResponseMessage)
{
ProcessReceivedMessageResponse(e, (ResponseMessage)message);
}
else
{
throw new ArgumentException("Cannot determinate Message type!");
}
}
// Start sending single message to client which token belongs to.
public void Send(Message message, HostAsyncUserToken token)
{
byte[] messageToSend = WoxalizerAdapter.SerializeToXml(message);
Logger.WriteStr(" The message to be send: " + utf8.GetString(messageToSend));
// encrypt message
byte[] encryptedMsgData = EncryptionAdapter.Encrypt(messageToSend);
SendMessage(token, encryptedMsgData);
}
public void Send(Message message, Action <CustomEventArgs> callback)
{
if (!_isConnected)
{
return;
}
//TODO: check if exception needed: throw new SocketException((int)SocketError.NotConnected);
_userToken.Callback = callback;
byte[] messageToSend = WoxalizerAdapter.SerializeToXml(message);
Logger.WriteStr(" The message (xml) to be sent: " + utf8.GetString(messageToSend));
// encrypt message
byte[] encryptedMsgData = EncryptionAdapter.Encrypt(messageToSend);
SendMessage(_userToken, encryptedMsgData);
}
private void LoadAgentsList()
{
var agentlist = (List <Agent>)WoxalizerAdapter.LoadFromFile(AgentsFile);
if (agentlist != null)
{
Logger.WriteStr("Loaded known agents:");
foreach (Agent agent in agentlist)
{
// change status to Offline
agent.Status = (int)EAgentStatus.Offline;
//add to List
var token = new HostAsyncUserToken();
token.Agent = agent;
_agents.Add(agent.ID, token);
Logger.WriteStr(" < #" + agent.ID + ": " + agent.Name + " >");
}
}
}
// Saves all agents db to file on disk
private void SaveAgentsListThread()
{
//wait few seconds to let agent send all it's base data to the server
Thread.Sleep(5000);
lock (AutoSaveLock)
{
var agentlist = new List <Agent>();
lock (AgentListLock)
{
for (var i = 0; i < _agents.Count; i++)
{
agentlist.Add(_agents[i].Agent);
}
}
WoxalizerAdapter.SaveToFile(agentlist, AgentsFile);
}
}
protected override void ProcessReceivedMessageRequest(SocketAsyncEventArgs e, RequestMessage message)
{
var token = (AgentAsyncUserToken)e.UserToken;
ResponseMessage responseMsg;
switch (message.OpCode)
{
case (int)EOpCode.IpConfigData:
var ipdata = new IpConfigData();
OpProcessor.GetInfo(ipdata, ((IPEndPoint)token.Socket.LocalEndPoint).Address.ToString()); // fill required data
responseMsg = new ResponseMessage {
Response = ipdata
};
SendMessage(e, WoxalizerAdapter.SerializeToXml(responseMsg, TypeResolving.AssemblyResolveHandler));
break;
case (int)EOpCode.RunProcess:
RunCompletedStatus result = OpProcessor.StartProcess((RunProcess)message.Request);
responseMsg = new ResponseMessage {
Response = result
};
SendMessage(e, WoxalizerAdapter.SerializeToXml(responseMsg, TypeResolving.AssemblyResolveHandler));
break;
case (int)EOpCode.OsInfo:
var os = new OsInfo();
OpProcessor.GetInfo(os);
break;
// //TODO: Add all OpCodes...
break;
default:
throw new ArgumentException("WARNING: Got unknown operation code request!");
}
}
protected override void ProcessReceivedMessage(SocketAsyncEventArgs e)
{
// decrypt message
byte[] decryptedMsgData = EncryptionAdapter.Decrypt(_userToken.RecievedMsgData);
Logger.WriteStr(" Recieved message was decrypted as xml: " + utf8.GetString(decryptedMsgData));
// deserialize to object
Message message = null;
try
{
message = WoxalizerAdapter.DeserializeFromXml(decryptedMsgData);
}
catch (Exception ex)
{
Logger.WriteStr("ERROR: Cannot deserialize recieved message (" + ex.Message + "). Aborting connection.");
CloseConnection(e);
}
if (_userToken.Callback != null)
{
_userToken.Callback.Invoke(new CustomEventArgs(e.SocketError, message));
}
}
private void ProcessReceivedMessageResponse(SocketAsyncEventArgs e, ResponseMessage message)
{
var token = (HostAsyncUserToken)e.UserToken;
if (message.Response is IdentificationData)
{
var idata = (IdentificationData)message.Response;
Logger.WriteStr(" * New client has connected: " + idata.deviceName);
// ...create ClientData (if does not exist already) and add to token
//...
//TODO: for testing only:
//Get IP information
var msg = new RequestMessage {
OpCode = (int)EOpCode.IpConfigData
};
SendMessage(e, WoxalizerAdapter.SerializeToXml(msg, TypeResolving.AssemblyResolveHandler));
}
else if (message.Response is IpConfigData)
{
var ipConf = (IpConfigData)message.Response;
token.Data.IpConfig = ipConf; //store in "database"
//TODO: move to another place
var msg = new RequestMessage {
OpCode = (int)EOpCode.RunProcess
};
var exec = new RunProcess
{
RunId = HostAsyncUserToken.RunId,
Cmd = "notepad.exe",
Args = "",
WorkDir = "c:\\",
TimeOut = 180000, //ms
Hidden = true
};
msg.Request = exec;
SendMessage(e, WoxalizerAdapter.SerializeToXml(msg, TypeResolving.AssemblyResolveHandler));
}
else if (message.Response is RunCompletedStatus)
{
var status = (RunCompletedStatus)message.Response;
if (status.ExitCode == 0)
{
Logger.WriteStr("Remote successfully executed");
}
else if (status.ExitCode > 0)
{
Logger.WriteStr("Remote program executed with exit code: " + status.ExitCode +
"and error message: \"" + status.ErrorMessage + "\"");
}
else
{
throw new ArgumentException("Invalid exit code of remote execution (" + status.ExitCode + ")");
}
//...
}
else
{
Logger.WriteStr("WARNING: Recieved unkown response from " + token.Socket.RemoteEndPoint.ToString() + "!");
}
}
