public bool ProcessUniversalPacketCommand(UniversalPacket universalPacket, ClientWorkObject client, AsynchronousSocketListener server)
{
bool sentClientData = false;
string[] commandArgs = ((string[])JsonConvert.DeserializeObject <string[]>(universalPacket.MessageData.Data));
//Process plugins
UniversalPlugin plugin = server.GetPlugin(commandArgs[0]);
if (plugin != null)
{
sentClientData = plugin.core.Invoke(client, commandArgs);
server.serverPluginLogger.AddToLog(ILogger.Levels.INFO, "Client [" + client.clientTracker.userID + "] has used command [" + plugin.core.Name + ".");
}
//Processes default commands
if (!sentClientData)
{
foreach (IUniversalCommand universalCommand in UniversalCommand.GetDefaultCommands())
{
if (universalCommand.GetNamespace().ToLower() == commandArgs[0].ToLower())
{
bool tmpbool = universalCommand.Invoke(commandArgs, universalPacket, client);
server.serverPluginLogger.AddToLog(ILogger.Levels.INFO, "Client [" + client.clientTracker.userID + "] has used command [" + universalCommand.GetNamespace() + ".");
if (tmpbool == true)
{
sentClientData = true; return(tmpbool);
}
}
}
}
return(sentClientData);
}
static async Task Main(string[] args)
{
UniversalClient _client = GetUniversalClient();
string valueTitle = "VermeerVersion";
UniversalPacket getValueCommand = new UniversalPacket(
new Header()
{
status = UniversalPacket.HTTPSTATUS.GET
},
new Message()
{
Data = JsonConvert.SerializeObject(new string[] { "userdatabase", "getvalue", valueTitle }), IsEncrypted = true
},
_client.GetSignature);
UniversalServerPacket serverReturn = _client.SendMessage(getValueCommand);
switch (serverReturn.Message.ToUpper())
{
case "UNAUTHORIZED":
break;
case "UNKNOWNCOMMAND":
break;
case "USRDBS_GETVALUE_VALUEEXIST":
break;
default:
break;
}
}
public async Task <UniversalServerPacket> SendMessageAsync(UniversalPacket packet)
{
await Task.Run(() =>
{
string s = packet.ToString() + "<EOF>";
byte[] BytesToSend = Encoding.UTF8.GetBytes(packet.ToString() + "<EOF>");
Client.Client.BeginSend(BytesToSend, 0, BytesToSend.Length, 0, new AsyncCallback(SendCallBack), Client);
});
return(await WaitForResultAsync());
}
public async Task ConnectToRemoteServerAsync(string ServerIP, int ServerPort)
{
if (Client == null)
{
return;
}
await Client.ConnectAsync(ServerIP, ServerPort);
if (Client.Connected)
{
UniversalPacket getServerPublicKeyRequest = new UniversalPacket(
new Header {
status = UniversalPacket.HTTPSTATUS.GET
},
new Message {
Data = JsonConvert.SerializeObject(new string[] { "serverrequest.encryption.getserverpublickey" }), IsEncrypted = false
},
clientSignature);
Task <UniversalServerPacket> sendMessageTask = SendMessageAsync(getServerPublicKeyRequest);
UniversalServerPacket s = await sendMessageTask;
this.Encryption.SetServerPublicKey(s.Message);
UniversalPacket sendClientPublicKey = new UniversalPacket(
new Header {
status = UniversalPacket.HTTPSTATUS.POST
},
new Message
{
Data = JsonConvert.SerializeObject(new string[] { "serverrequest.encryption.setclientpublickey",
Encryption.GetClientPublicKey() }, Formatting.None),
IsEncrypted = true
},
clientSignature);
Task <UniversalServerPacket> sendClientPublicKeyTask = SendMessageAsync(sendClientPublicKey);
UniversalServerPacket bs = await sendClientPublicKeyTask;
UniversalPacket sendClientPrivateKey = new UniversalPacket(
new Header {
status = UniversalPacket.HTTPSTATUS.POST
},
new Message
{
Data = JsonConvert.SerializeObject(new string[] { "serverrequest.encryption.setclientprivatekey",
Encryption.GetClientPrivateKey(), Encryption.GetServerPublicKey() }, Formatting.None),
IsEncrypted = true
},
clientSignature);
Task <UniversalServerPacket> sendClientPrivateKeyTask = SendMessageAsync(sendClientPrivateKey);
UniversalServerPacket bs2 = await sendClientPrivateKeyTask;
}
}
public bool Invoke(string[] CommandArgs, UniversalPacket universalPacket, ClientWorkObject client)
{
if (universalPacket.MessageHeader.status == UniversalPacket.HTTPSTATUS.POST)
{
client.Encryption.SetClientPrivateKey(CommandArgs[1]);
client.serverSocket.Send(client, true.ToString());
}
else
{
client.serverSocket.Send(client, Messages.PostStatusCodeRequiredErrorMessage);
}
return(true);
}
public UniversalServerPacket SendMessage(UniversalPacket packet)
{
if (packet.MessageData.IsEncrypted)
{
packet.MessageData.Data = this.Encrypt(packet.MessageData.Data);
}
string s = packet.ToString() + "<EOF>";
byte[] BytesToSend = Encoding.UTF8.GetBytes(packet.ToString() + "<EOF>");
Client.Client.BeginSend(BytesToSend, 0, BytesToSend.Length, 0, new AsyncCallback(SendCallBack), Client);
return(WaitForResult());
}
private void postProcessUniversalPacket(ClientWorkObject workObject, IUniversalPacket universalPacket)
{
UniversalPacket clientPacket = (UniversalPacket)universalPacket;
//Checks if the user ID is registered (IsLoggedIn)
//If the ID is not stored then stores the ID and
//the IP of the client for logging reasons.
if (!workObject.clientTracker.IsLoggedIn)
{
workObject.clientTracker.SetID(clientPacket.MessageSignature.clientId,
((IPEndPoint)workObject.clientSocket.RemoteEndPoint).Address.ToString(),
clientPacket.MessageSignature.clientIp);
}
clientPacket.MessageHeader.dateTime = DateTime.Now; //Sets the datetime if its null
string s = workObject.Encryption.GetServerPrivateKey();
//Decrypts the information
if (clientPacket.MessageData.IsEncrypted)
{
clientPacket.MessageData.Data = workObject.Encryption.Decrypt(clientPacket.MessageData.Data, workObject.Encryption.GetServerPrivateKey());
}
OnBeforeClientRequestEventArgs onBeforeRequest = new OnBeforeClientRequestEventArgs {
RawData = clientPacket.MessageData.Data, Client = workObject
};
parent.GetEventTracker().OnBeforeClientRequest(this, onBeforeRequest);
//Processes the command
bool sentClientData = false;
if (onBeforeRequest.CancelRequest == Model.Utility.MoonbyteCancelRequest.Continue)
{
using (CommandManager commandManager = new CommandManager(parent))
{
sentClientData = commandManager.ProcessUniversalPacketCommand(clientPacket, workObject, workObject.serverSocket);
}
}
else
{
workObject.serverSocket.Send(workObject, "Unauthorized", false);
}
//Sends data to client if false
if (!sentClientData)
{
workObject.serverSocket.Send(workObject, "UnknownCommand", false);
}
}
private void postProcessUniversalPacket(ClientWorkObject workObject, IUniversalPacket universalPacket)
{
if (universalPacket.GetType() == typeof(UniversalGetPacket))
{
UniversalGetPacket packet = (UniversalGetPacket)universalPacket;
packet.ToString();
}
else if (universalPacket.GetType() == typeof(UniversalPacket))
{
UniversalPacket packet = (UniversalPacket)universalPacket;
}
else
{
//returns error
}
}
public bool Invoke(string[] commandArgs, UniversalPacket universalPacket, ClientWorkObject client)
{
client.serverSocket.Send(client, client.Encryption.GetServerPublicKey(), false);
return(true);
}
