public static ResponsePacket CreateGroup(string login, string pass, string leaderID)
{
ResponsePacket packet = new ResponsePacket();
if (CheckExists("Groups", "login", login))
{
Server.PrintMessage($"{leaderID} id failed to create group {login}. Login already exists", ConsoleColor.Yellow);
packet.Code = ResponseCode.GroupCreate_Fail_LoginExists;
return(packet);
}
else
{
try
{
string query = $"INSERT INTO Groups(login, password, leader_id) VALUES('{login}', '{pass}', {leaderID})";
command = new SQLiteCommand(query, connection);
command.ExecuteNonQuery();
query = $"SELECT id FROM Groups WHERE login='******' AND leader_id={leaderID}";
command = new SQLiteCommand(query, connection);
SQLiteDataReader reader = command.ExecuteReader();
int groupID = 0;
while (reader.Read())
{
groupID = reader.GetInt32(0);
}
query = $"INSERT INTO GroupMembers(group_id, account_id) VALUES({groupID}, {leaderID})";
command = new SQLiteCommand(query, connection);
command.ExecuteNonQuery();
}
catch (Exception ex)
{
Server.PrintMessage($"{leaderID} id ERROR CREATE GROUP\n{ex.Message}", ConsoleColor.Red);
packet.Code = ResponseCode.GroupCreate_Fail_Unknown;
return(packet);
}
Server.PrintMessage($"{leaderID} id has created group {login}", ConsoleColor.White);
packet.Code = ResponseCode.GroupCreate_Success;
return(packet);
}
}
private async Task <bool> GetTasks()
{
RequestPacket requestPacket = new RequestPacket()
{
DateTimeStamp = DateTime.Now, Code = REQUEST_CODES.GET_TASK, Node = NodeName
};
ResponsePacket responsePacket = await SendRequesPacketAsync(requestPacket);
if (!responsePacket.Errored)
{
lock (taskQueue)
{
taskQueue.Enqueue(responsePacket.Task);
}
return(true);
}
return(false);
}
private void OnProjectReceived(ResponsePacket p)
{
this.Hierarchy.UnblockRequestChannel(this.GetHashCode());
if (p.CheckPacketStatus() == true)
{
ServerSendProjectPacket packet = p as ServerSendProjectPacket;
this.projectAssets = packet.assets;
this.root = new Folder(null, "Assets");
for (int i = 0; i < this.projectAssets.Length; i++)
{
this.GeneratePath(this.projectAssets[i]);
}
this.Repaint();
}
}
/// <summary>
/// Calls to server to get provider directory to view in textUI
/// </summary>
/// <returns>True, unless exceptions are thrown</returns>
protected bool ViewProviderDirectoryUpdate()
{
tui.WriteLine("ADD INVOICE", TextUI.TextUIJustify.CENTER);
ResponsePacket responsePacket = server.ProcessAction(new BasePacket("VIEW_PROVIDER_DIRECTORY", sessionID));
// View the response from the server.
WriteResponse(responsePacket);
// Now view the provider directory file.
string [] contents = System.IO.File.ReadAllLines("ProviderDirectory.txt");
// View the contents of the provider directory with the given group size paramter.
tui.WriteList(contents, 15);
currentState = TerminalState.MENU;
return(true);
}
/// <summary>
/// Acknowledges the event.
/// </summary>
private void AckEvent(ConnectedClient client, DataPacket request, out ResponsePacket response)
{
byte[] buffer = request.Buffer;
int index = ArgumentIndex;
EventAck eventAck = new EventAck
{
EventID = GetInt64(buffer, ref index),
Timestamp = GetTime(buffer, ref index),
UserID = GetInt32(buffer, ref index)
};
if (eventAck.UserID <= 0)
{
eventAck.UserID = client.UserID;
}
coreLogic.AckEvent(eventAck);
response = new ResponsePacket(request, client.OutBuf);
}
public ResponsePacket OnConnectionRequest(RequestPacket requestPacket)
{
int id = requestPacket.Id;
string src = requestPacket.SrcPort;
string dst = requestPacket.DstPort;
int sl = requestPacket.SlotsNumber;
RequestPacket.Est est = requestPacket.Establish;
LOG.Info($"Received CC::ConnectionRequest_req(id = {id}, src = {src}, dst = {dst}, sl = {sl}, teardown = {est})");
LOG.Info($"Send CC::ConnectionRequest_req(id = {id}, src = {src}, dst = {dst}, sl = {sl}, teardown = {est})");
var connectionRequestResponse = _ccConnectionRequestClients[GetCcName(src)].Get(new RequestPacket.Builder()
.SetEst(est)
.SetId(id)
.SetSrcPort(src)
.SetDstPort(dst)
.SetSlotsNumber(sl)
.Build());
var res = connectionRequestResponse.Res;
if (res == ResponsePacket.ResponseType.ResourcesProblem)
{
LOG.Info("Send CC:ConnectionRequest_res(res = ResourcesProblem)");
return(new ResponsePacket.Builder().SetRes(ResponsePacket.ResponseType.ResourcesProblem).Build());
}
(int, int)slots = connectionRequestResponse.Slots;
LOG.Info($"Received CC::ConnectionRequest_res({ResponsePacket.ResponseTypeToString(res)}, slots = {slots}, nextZonePort = NULL)");
if (res == ResponsePacket.ResponseType.Ok)
{
LOG.Info($"Send CC::ConnectionRequest_res(res = OK)");
return(new ResponsePacket.Builder().SetRes(ResponsePacket.ResponseType.Ok).SetSlots(slots).Build());
}
LOG.Info($"Send CC::ConnectionRequest_res(res = Refused)");
return(new ResponsePacket.Builder().SetRes(ResponsePacket.ResponseType.Refused).Build());
}
/// <summary>
/// Gets the available timestamps.
/// </summary>
protected void GetTimestamps(ConnectedClient client, DataPacket request, out ResponsePacket response)
{
byte[] buffer = request.Buffer;
int index = ArgumentIndex;
TimeRange timeRange = GetTimeRange(buffer, ref index);
int archiveBit = GetByte(buffer, ref index);
List <DateTime> timestamps = archiveHolder.GetTimestamps(timeRange, archiveBit);
buffer = client.OutBuf;
response = new ResponsePacket(request, buffer);
index = ArgumentIndex;
CopyInt32(timestamps.Count, buffer, ref index);
foreach (DateTime timestamp in timestamps)
{
CopyTime(timestamp, buffer, ref index);
}
response.BufferLength = index;
}
/// <summary>
/// Performs a login function.
/// </summary>
protected void Login(ConnectedClient client, DataPacket request, out ResponsePacket response)
{
byte[] buffer = client.InBuf;
int index = ArgumentIndex;
string username = GetString(buffer, ref index);
string encryptedPassword = GetString(buffer, ref index);
string instance = GetString(buffer, ref index);
string password = DecryptPassword(encryptedPassword, client.SessionID, listenerOptions.SecretKey);
buffer = client.OutBuf;
response = new ResponsePacket(request, buffer);
index = ArgumentIndex;
if (ProtectBruteForce(out string errMsg) &&
ValidateUser(client, username, password, instance, out int userID, out int roleID, out errMsg))
{
CopyBool(true, buffer, ref index);
CopyInt32(userID, buffer, ref index);
CopyInt32(roleID, buffer, ref index);
CopyString("", buffer, ref index);
}
private ResponsePacket ParseResponse(string response)
{
ResponsePacket packet = new ResponsePacket();
XDocument xml = XDocument.Parse(response);
packet.Result = xml.Element("result");
packet.Method = packet.Result.Attribute("method").Value;
packet.Status = packet.Result.Attribute("status").Value;
packet.Error = packet.Status == "fail";
if (packet.Error)
{
XElement error = packet.Result.Element("error");
packet.ErrorCode = error.Attribute("code").Value;
packet.ErrorText = error.Attribute("text").Value;
Errors.Add(string.Format("Code: {0}, Method: {1}\r\nText: {2}", packet.ErrorCode, packet.Method, packet.ErrorText));
}
return packet;
}
/// <summary>
/// Execute the Process command.
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public SpamAssassinProcessResult ExecuteProcess(
SpamAssassinProcessArgs e)
{
string requestMessage = PrepareCheckRequestMessage(e);
// --
ResponsePacket responsePacket = SendMessageEx(SpamAssassinCommands.Process, requestMessage);
CheckThrowResponsePacket(responsePacket);
// --
string[] lines = SplitLines(responsePacket.Message);
lines = RemoveLine(lines, 0);
SpamAssassinProcessResult result = new SpamAssassinProcessResult();
result.ProcessedMessage = JoinLines(lines);
return(result);
}
/// <summary>
/// Execute the Ping command.
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public SpamAssassinPingResult ExecutePing(
SpamAssassinPingArgs e)
{
ResponsePacket responsePacket =
SendMessageEx(SpamAssassinCommands.Ping, string.Empty);
CheckThrowResponsePacket(responsePacket);
if (string.Compare(responsePacket.ResponseMessage, "PONG", true) != 0)
{
throw new SpamAssassinException(
string.Format(
"The PING response from SPAMD was '{0}' but is expected to be 'PONG'.",
responsePacket.ResponseMessage));
}
else
{
SpamAssassinPingResult result = new SpamAssassinPingResult();
return(result);
}
}
private void StoreResult(RequestPacket requestPacket, HttpListenerResponse response)
{
bool errored = false;
if (nodeList.ContainsValue(requestPacket.Node))
{
resultStore.Add(requestPacket.Result.TaskId, requestPacket.Result.ResultData);
}
else
{
errored = true;
}
ResponsePacket resPacket = new ResponsePacket()
{
DateTimeStamp = DateTime.Now,
Code = RESPONSE_CODES.SUBMIT_RESULT_ACK,
Errored = errored
};
_Common.WriteResPacketToResponse(resPacket, response);
}
private void AssemblyTrackerUpdate(RequestPacket requestPacket, HttpListenerResponse response)
{
bool errored = false;
if (nodeList.ContainsValue(requestPacket.Node))
{
assemblyTracker.Add(requestPacket.Node, (HashSet <string>)requestPacket.Result.ResultData);
}
else
{
errored = true;
}
ResponsePacket resPacket = new ResponsePacket()
{
DateTimeStamp = DateTime.Now,
Code = RESPONSE_CODES.ASSEMBLY_TRACK_ACK,
Errored = errored
};
_Common.WriteResPacketToResponse(resPacket, response);
}
private ResponsePacket ParseResponse(string response)
{
ResponsePacket packet = new ResponsePacket();
XDocument xml = XDocument.Parse(response);
packet.Result = xml.Element("result");
packet.Method = packet.Result.Attribute("method").Value;
packet.Status = packet.Result.Attribute("status").Value;
packet.Error = packet.Status == "fail";
if (packet.Error)
{
XElement error = packet.Result.Element("error");
packet.ErrorCode = error.Attribute("code").Value;
packet.ErrorText = error.Attribute("text").Value;
Errors.Add(string.Format("Code: {0}, Method: {1}\r\nText: {2}", packet.ErrorCode, packet.Method, packet.ErrorText));
}
return(packet);
}
public ResponsePacket GetRandomAvailableResponse()
{
if (_availableResponses == null || _availableResponses.Count == 0)
{
Debug.LogError("Requested Response but none available");
return(null);
}
int randomIndex = UnityEngine.Random.Range(0, _availableResponses.Count);
var randomResponse = _availableResponses[randomIndex];
_availableResponses.Remove(randomResponse);
Color color = GetColorForResponse(randomResponse);
ResponsePacket packetInstance = ObjectPoolService.Instance.AcquireInstance <ResponsePacket>(_responsePacketPrefab.gameObject);
packetInstance.Response = randomResponse;
packetInstance.Color = color;
return(packetInstance);
}
public static ResponsePacket RegisterAccount(string username, string email, string pass, string ip)
{
ResponsePacket packet = new ResponsePacket();
string query = "INSERT INTO Accounts(username, email, password, reg_date, reg_ip) " +
$"VALUES ('{username}', '{email}', '{pass}', '{DateTime.Now.ToString()}', '{ip}')";
command = new SQLiteCommand(query, connection);
try
{
int result = command.ExecuteNonQuery();
}
catch (SQLiteException ex)
{
Console.WriteLine(ex.Message);
if (ex.Message.Contains("UNIQUE"))
{
if (ex.Message.Contains("Accounts.email"))
{
packet.Code = ResponseCode.Register_Fail_EmailExists;
}
else if (ex.Message.Contains("Accounts.username"))
{
packet.Code = ResponseCode.Register_Fail_UsernameExists;
}
return(packet);
}
else
{
Server.PrintMessage($"REGISTER ERROR FROM {username}({ip})\n{ex.Message}", ConsoleColor.Red);
packet.Code = ResponseCode.Register_Fail_Unknown;
return(packet);
}
}
Server.PrintMessage($"{username} registered with email {email} FROM {ip}", ConsoleColor.White);
packet.Code = ResponseCode.Register_Success;
return(packet);
}
/// <summary>
/// Writes the current data.
/// </summary>
private void WriteCurrentData(ConnectedClient client, DataPacket request, out ResponsePacket response)
{
byte[] buffer = request.Buffer;
int index = ArgumentIndex;
DateTime timestamp = GetTime(buffer, ref index);
int cnlCnt = GetInt32(buffer, ref index);
Slice slice = new Slice(timestamp, cnlCnt);
for (int i = 0, idx1 = index, idx2 = idx1 + cnlCnt * 4; i < cnlCnt; i++)
{
slice.CnlNums[i] = GetInt32(buffer, ref idx1);
slice.CnlData[i] = GetCnlData(buffer, ref idx2);
}
index += cnlCnt * 14;
int deviceNum = GetInt32(buffer, ref index);
WriteFlags writeFlags = (WriteFlags)buffer[index];
coreLogic.WriteCurrentData(slice, deviceNum, writeFlags);
response = new ResponsePacket(request, client.OutBuf);
}
private void SendTask(RequestPacket requestPacket, HttpListenerResponse response)
{
bool errored = false;
Task task = new Task();
string taskId = string.Empty;
lock (taskStore)
{
if (taskStore.Any()) //x => x.Value.RequestingNode != requestPacket.Node
{
taskId = taskStore.First().Key; //x => x.Value.RequestingNode != requestPacket.Node
task = taskStore[taskId];
if (assemblyTracker.ContainsKey(requestPacket.Node) && !assemblyTracker[requestPacket.Node]
.Contains(requestPacket.Task.AssemblyDetails.AssemblyName))
{
task.AssemblyDetails.AssemblyCode = codeLoader.codeDictionary.ReadAssembly(task.AssemblyDetails.AssemblyName);
}
}
else
{
errored = true;
}
ResponsePacket resPacket = new ResponsePacket()
{
DateTimeStamp = DateTime.Now,
Code = RESPONSE_CODES.GET_TASK_ACK,
Task = task,
Errored = errored
};
_Common.WriteResPacketToResponse(resPacket, response);
if (taskId != string.Empty)
{
taskStore.Remove(taskId);
}
}
}
/// <summary>
/// Writes the current data.
/// </summary>
protected void WriteCurrentData(ConnectedClient client, DataPacket request, out ResponsePacket response)
{
byte[] buffer = request.Buffer;
int index = ArgumentIndex;
int deviceNum = GetInt32(buffer, ref index);
int cnlCnt = GetInt32(buffer, ref index);
int[] cnlNums = new int[cnlCnt];
CnlData[] cnlData = new CnlData[cnlCnt];
for (int i = 0, idx1 = index, idx2 = idx1 + cnlCnt * 4; i < cnlCnt; i++)
{
cnlNums[i] = GetInt32(buffer, ref idx1);
cnlData[i] = GetCnlData(buffer, ref idx2);
}
index += cnlCnt * 14;
bool applyFormulas = buffer[index] > 0;
coreLogic.WriteCurrentData(deviceNum, cnlNums, cnlData, applyFormulas);
response = new ResponsePacket(request, client.OutBuf);
}
protected ResponsePacket ProcessInboundSemanticType(Session session, Dictionary <string, object> parms)
{
string json = parms["Data"].ToString();
JObject jobj = JObject.Parse(json);
string type = jobj["_type_"].ToString();
// strip off the _type_ so we can then instantiate the semantic type.
json = "{" + json.RightOf(',');
// Requires that the namespace also matches the remote's namespace.
Type ttarget = Type.GetType(type);
ISemanticType target = (ISemanticType)Activator.CreateInstance(ttarget);
JsonConvert.PopulateObject(json, target);
sp.ProcessInstance <DistributedProcessMembrane>(target);
ResponsePacket ret = new ResponsePacket()
{
Data = Encoding.UTF8.GetBytes("OK"), ContentType = "text"
};
return(ret);
}
private void Serializes_ErrorResponseData(ISerializer serializer)
{
var error = new ErrorResponseData(ErrorResponseCodes.UnauthorizedRequest, "crap", true);
var pack = new ResponsePacket(error);
using (var ms = new MemoryStream())
using (var writer = new BinaryWriter(ms))
using (var reader = new BinaryReader(ms)) {
pack.Serialize(writer, serializer);
ms.Position = 0;
var p2 = new TestDataPacket();
p2.Deserialize(reader, serializer);
Assert.AreEqual(error.Code, p2.As <ErrorResponseData>().Code);
Assert.AreEqual(error.Message, p2.As <ErrorResponseData>().Message);
Assert.AreEqual(error.IsCritical, p2.As <ErrorResponseData>().IsCritical);
Assert.AreEqual(error.GetType(), p2.Data.GetType());
Assert.AreEqual(typeof(ErrorResponseData).AssemblyQualifiedName, p2.DataType);
}
}
/// <summary>
/// Obtains the information needed to perform an upload.
/// http://www.sendspace.com/dev_method.html?method=upload.getInfo
/// </summary>
/// <param name="sessionKey">Received from auth.login</param>
/// <returns>URL to upload the file to, progress_url for real-time progress information, max_file_size for max size current user can upload, upload_identifier & extra_info to be passed with the upload form</returns>
public UploadInfo UploadGetInfo(string sessionKey)
{
Dictionary <string, string> args = new Dictionary <string, string>();
args.Add("method", "upload.getInfo");
args.Add("session_key", sessionKey);
args.Add("speed_limit", SpeedLimit.ToString());
string response = SendRequest(HttpMethod.GET, APIURL, args);
if (!string.IsNullOrEmpty(response))
{
ResponsePacket packet = ParseResponse(response);
if (!packet.Error)
{
UploadInfo uploadInfo = new UploadInfo(packet.Result);
return(uploadInfo);
}
}
return(null);
}
/// <summary>
/// Writes the historical data.
/// </summary>
protected void WriteHistoricalData(ConnectedClient client, DataPacket request, out ResponsePacket response)
{
byte[] buffer = request.Buffer;
int index = ArgumentIndex;
int deviceNum = GetInt32(buffer, ref index);
DateTime timestamp = GetTime(buffer, ref index);
int cnlCnt = GetInt32(buffer, ref index);
Slice slice = new Slice(timestamp, cnlCnt);
for (int i = 0, idx1 = index, idx2 = idx1 + cnlCnt * 4; i < cnlCnt; i++)
{
slice.CnlNums[i] = GetInt32(buffer, ref idx1);
slice.CnlData[i] = GetCnlData(buffer, ref idx2);
}
index += cnlCnt * 14;
int archiveMask = GetInt32(buffer, ref index);
bool applyFormulas = buffer[index] > 0;
coreLogic.WriteHistoricalData(deviceNum, slice, archiveMask, applyFormulas);
response = new ResponsePacket(request, client.OutBuf);
}
private void OnGameObjectDataReceived(ResponsePacket p)
{
if (p.CheckPacketStatus() == true)
{
ServerSendGameObjectDataPacket packet = p as ServerSendGameObjectDataPacket;
if (packet.gameObjectData.Length == 1)
{
this.tag = packet.gameObjectData[0].tag;
this.layer = packet.gameObjectData[0].layer;
this.isStatic = packet.gameObjectData[0].isStatic;
if (this.components == null)
{
this.components = new List <ClientComponent>();
}
else
{
this.components.Clear();
}
for (int j = 0; j < packet.gameObjectData[0].components.Length; j++)
{
this.components.Add(new ClientComponent(this, packet.gameObjectData[0].components[j], this.unityData));
}
}
else
{
InternalNGDebug.Log(Errors.Scene_GameObjectNotFound, "GameObject (" + this.instanceID + ") was not found. Failed to update its data.");
}
}
if (this.gameObjectDataReceivedCallback != null)
{
this.gameObjectDataReceivedCallback(this);
}
}
public async Task <string> SubmitTask(string assemblyName, byte[] assemblyBytes, object param)
{
if (assemblyBytes == null)
{
assemblyBytes = codeLoader.codeDictionary.ReadAssembly(assemblyName);
}
if (assemblyBytes == null)
{
return(string.Empty);
}
else
{
codeLoader.codeDictionary.WriteAssembly(assemblyName, assemblyBytes);
}
RequestPacket request = new RequestPacket()
{
DateTimeStamp = DateTime.Now,
Node = NodeName,
Code = REQUEST_CODES.SUBMIT_TASK,
Task = new _Common.Task()
{
AssemblyDetails = new Assembly()
{
AssemblyName = assemblyName, AssemblyCode = assemblyBytes,
}, Params = param, RequestingNode = NodeName
}
};
ResponsePacket response = await SendRequesPacketAsync(request);
string taskId = (response.Errored) ? string.Empty : response.Task.TaskId;
return(taskId);
}
/// <summary>
/// Execute the Check command.
/// </summary>
/// <param name="e"></param>
/// <returns></returns>
public SpamAssassinCheckResult ExecuteCheck(
SpamAssassinCheckArgs e)
{
string requestMessage = PrepareCheckRequestMessage(e);
// --
ResponsePacket responsePacket =
SendMessageEx(SpamAssassinCommands.Check, requestMessage);
CheckThrowResponsePacket(responsePacket);
// --
string[] additionalLines;
SpamAssassinCheckResult result = new SpamAssassinCheckResult();
InterpretCheckResponseMessage(
responsePacket.Message,
out additionalLines,
result);
return(result);
}
/// <summary>
/// Performs a login function.
/// </summary>
protected void Login(ConnectedClient client, DataPacket request, out ResponsePacket response)
{
byte[] buffer = client.InBuf;
int index = ArgumentIndex;
string username = GetString(buffer, ref index);
string encryptedPassword = GetString(buffer, ref index);
string instance = GetString(buffer, ref index);
int clientMode = GetInt32(buffer, ref index);
buffer = client.OutBuf;
response = new ResponsePacket(request, buffer);
index = ArgumentIndex;
if (!protector.IsBlocked(out string errMsg) &&
DecryptPassword(encryptedPassword, client, out string password, out errMsg) &&
ValidateUser(client, username, password, instance, out int userID, out int roleID, out errMsg))
{
CopyBool(true, buffer, ref index);
CopyInt32(userID, buffer, ref index);
CopyInt32(roleID, buffer, ref index);
CopyString("", buffer, ref index);
UpdateClientMode(client, clientMode);
}
/// <summary>
/// Obtains a new and random token per session. Required for login.
/// http://www.sendspace.com/dev_method.html?method=auth.createToken
/// </summary>
/// <returns>A token to be used with the auth.login method</returns>
public string AuthCreateToken()
{
Dictionary <string, string> args = new Dictionary <string, string>();
args.Add("method", "auth.createToken");
args.Add("api_key", APIKey); // Received from sendspace
args.Add("api_version", APIVersion); // Value must be: 1.0
args.Add("app_version", AppVersion); // Application specific, formatting / style is up to you
args.Add("response_format", "xml"); // Value must be: XML
string response = SendRequest(HttpMethod.POST, APIURL, args);
if (!string.IsNullOrEmpty(response))
{
ResponsePacket packet = ParseResponse(response);
if (!packet.Error)
{
return(packet.Result.GetElementValue("token"));
}
}
return(null);
}
public ResponsePacket OnConnectionRequest(RequestPacket requestPacket)
{
int id = requestPacket.Id;
string src = requestPacket.SrcPort;
string dst = requestPacket.DstPort;
int sl = requestPacket.SlotsNumber;
RequestPacket.Est est = requestPacket.Establish;
LOG.Info($"Received CC::ConnectionRequest_req(id = {id}, src = {src}, dst = {dst}, sl = {sl}, teardown = {est})");
LOG.Info($"Send RC::RouteTableQuery_req(id = {id}, src = {src}, dst = {dst}, sl = {sl}, teardown = {est})");
ResponsePacket routeTableQueryResponse = _rcRouteTableQueryClient.Get(new RequestPacket.Builder()
.SetId(id)
.SetSrcPort(src)
.SetDstPort(dst)
.SetSlotsNumber(sl)
.SetEst(est)
.Build());
if (routeTableQueryResponse.Res == ResponsePacket.ResponseType.ResourcesProblem)
{
LOG.Info("Received RC::RouteTableQuery_res(res = ResourcesProblem)");
LOG.Info("Send ConnectionRequest_res(res = ResourcesProblem)");
return(new ResponsePacket.Builder()
.SetRes(ResponsePacket.ResponseType.ResourcesProblem)
.Build());
}
int rtqrId = routeTableQueryResponse.Id;
string rtqrGateway = routeTableQueryResponse.Gateway;
(int, int)rtqrSlots = routeTableQueryResponse.Slots;
string dstZone = routeTableQueryResponse.DstZone;
string gatewayOrEnd = rtqrGateway;
LOG.Info($"Received RC::RouteTableQuery_res(id = {rtqrId}, gateway = {rtqrGateway}, slots = {rtqrSlots}, dstZone = {dstZone})");
if (dst != rtqrGateway)
{
string allocDealloc = est == RequestPacket.Est.Establish ? "allocate" : "deallocate";
LOG.Info($"Send LRM::LinkConnectionRequest_req(slots = {rtqrSlots}, {allocDealloc}, who = CC)");
ResponsePacket linkConnectionRequestResponse = _lrmLinkConnectionRequestClients[rtqrGateway].Get(
new RequestPacket.Builder()
.SetEst(est)
.SetSlots(rtqrSlots)
.SetShouldAllocate(true)
.SetWhoRequests(RequestPacket.Who.Cc)
.Build());
if (linkConnectionRequestResponse.Res == ResponsePacket.ResponseType.Refused)
{
LOG.Info($"Received LRM::LinkConnectionRequest_res(res = Refused)");
LOG.Info($"Send CC::ConnectionRequest_res(res = Refused)");
return(new ResponsePacket.Builder()
.SetRes(ResponsePacket.ResponseType.Refused)
.Build());
}
gatewayOrEnd = linkConnectionRequestResponse.End;
LOG.Info($"Received LRM::LinkConnectionRequest_res(end = {gatewayOrEnd})");
}
else
{
LOG.Debug("Dst == Gateway, LRM will be handled by the layers above");
LOG.Info($"Send CC::ConnectionRequest_req(id = {rtqrId}, src = {src}, dst = {rtqrGateway}, sl = {sl}, teardown = {est})");
ResponsePacket connectionRequestResponseDst = _ccConnectionRequestClients[GetCcName(src)].Get(new RequestPacket.Builder()
.SetEst(est)
.SetId(id)
.SetSrcPort(src)
.SetDstPort(rtqrGateway)
.SetSlotsNumber(sl)
.SetSlots(rtqrSlots)
.Build());
LOG.Info($"Received CC::ConnectionRequest_res({ResponsePacket.ResponseTypeToString(connectionRequestResponseDst.Res)})");
if (connectionRequestResponseDst.Res == ResponsePacket.ResponseType.Ok)
{
LOG.Info($"Send CC::ConnectionRequest_res({ResponsePacket.ResponseTypeToString(connectionRequestResponseDst.Res)}, slots = {rtqrSlots})");
return(new ResponsePacket.Builder().SetRes(ResponsePacket.ResponseType.Ok).SetSlots(rtqrSlots).Build());
}
}
// gateway == dstZone && dstZone != dst -- TODO Not implemented
LOG.Info($"Send CC::ConnectionRequest_req(id = {rtqrId}, src = {src}, dst = {rtqrGateway}, sl = {sl}, teardown = {est})");
ResponsePacket connectionRequestResponse = _ccConnectionRequestClients[GetCcName(src)].Get(new RequestPacket.Builder()
.SetEst(est)
.SetId(id)
.SetSrcPort(src)
.SetDstPort(rtqrGateway)
.SetSlotsNumber(sl)
.Build());
LOG.Info($"Received CC::ConnectionRequest_res({ResponsePacket.ResponseTypeToString(connectionRequestResponse.Res)})");
ResponsePacket.ResponseType res = connectionRequestResponse.Res;
if (res == ResponsePacket.ResponseType.Ok)
{
LOG.Info($"Send CC::PeerCoordination_req(id = {id}, src = {gatewayOrEnd}, dst = {dst}, slots = {rtqrSlots}, teardown = {est})");
ResponsePacket peerCoordinationResponse = _ccPeerCoordinationClients[GetCcName(gatewayOrEnd)].Get(new RequestPacket.Builder()
.SetEst(est)
.SetId(id)
.SetSrcPort(gatewayOrEnd)
.SetDstPort(dst)
.SetSlots(rtqrSlots)
.Build());
LOG.Info($"Received CC::PeerCoordination_res(res = {ResponsePacket.ResponseTypeToString(peerCoordinationResponse.Res)})");
if (peerCoordinationResponse.Res == ResponsePacket.ResponseType.Ok)
{
LOG.Info($"Send CC::ConnectionRequest_res(res = OK, nextZonePort = NULL, slots = {rtqrSlots})");
return(new ResponsePacket.Builder()
.SetRes(ResponsePacket.ResponseType.Ok)
.SetNextZonePort("")
.SetSlots(rtqrSlots)
.Build());
}
// else
LOG.Info($"Send CC::ConnectionRequest_res(res = Refused, nextZonePort = NULL, slots = {rtqrSlots})");
return(new ResponsePacket.Builder()
.SetRes(ResponsePacket.ResponseType.Refused)
.SetNextZonePort("")
.SetSlots(rtqrSlots)
.Build());
}
LOG.Info($"Send CC::ConnectionRequest_res(res = Refused)");
// else
return(new ResponsePacket.Builder()
.SetRes(ResponsePacket.ResponseType.Refused)
.Build());
}
/// <summary>
/// Sends the response.
/// </summary>
public void SendResponse(ResponsePacket response)
{
response.Encode();
NetStream.Write(response.Buffer, 0, response.BufferLength);
}
static public ResponsePacket Create(char command, byte[] data)
{
var response = new ResponsePacket
{
zero = 0,
prefix = 0xeeeeeeee,
commandType = command,
dataSize = (byte)data.Length,
data = data,
reserved = 0,
crc14 = 0,
};
response.CalcCRC();
return response;
}a
public void BuildFromProcessingResult(ProcessingResult result)
{
ResponsePacket response = new ResponsePacket
{
ResponseTo = result.PacketId,
ResultCode = result.Result
};
foreach (ProcessingResult.RecordResult recResult in result.RecResults)
{
// subrecord data
SubrecordResponse subrecord = new SubrecordResponse
{
ConfirmedRecord = recResult.Record.RecordNumber,
Result = (byte)recResult.Result
};
// record data
ServiceDataSubrecord recordData = new ServiceDataSubrecord
{
Data = subrecord,
Length = (ushort)subrecord.GetBytes().Length,
Type = SubrecordType.EGTS_SR_RECORD_RESPONSE
};
// Record
ServiceDataRecord record = new ServiceDataRecord
{
EventFieldExists = false,
ObjectFieldExists = recResult.Record.ObjectFieldExists,
ObjectID = recResult.Record.ObjectID,
ProcessingPriority = recResult.Record.ProcessingPriority,
RecipientService = recResult.Record.SourceService,
RecipientServiceOnDevice = recResult.Record.SourceServiceOnDevice,
RecordNumber = recResult.Record.RecordNumber,
SourceService = recResult.Record.RecipientService,
SourceServiceOnDevice = recResult.Record.RecipientServiceOnDevice,
TimeFieldExists = false,
RecordLength = (ushort)recordData.GetBytes().Length, // only one subrecord ib RecordData
};
record.RecordData.Add(recordData);
response.ServiceDataRecords.Add(record);
}
TransportHeader header = new TransportHeader
{
Compressed = false,
HeaderEncoding = 0,
PID = result.PacketId,
Prefix = 0,
Priority = Priority.Highest,
ProtocolVersion = 1,
Route = false,
SecurityKeyId = 0,
Type = PacketType.EGTS_PT_RESPONSE,
FrameDataLength = (ushort)response.GetBytes().Length,
HeaderLength = 11 // TODO: calculate HeaderLength
};
header.CRC = Validator.GetCrc8(header.GetBytes(), (ushort)(header.HeaderLength - 1));
Packet = new EgtsPacket
{
Header = header,
ServiceFrameData = response,
CRC = Validator.GetCrc16(response.GetBytes(), 0, header.FrameDataLength)
};
}
/// <summary>
/// Throws an exception if a code!=0 is returned
/// </summary>
private static void CheckThrowResponsePacket(ResponsePacket responsePacket)
{
if (responsePacket.ResponseCode != 0)
throw new SpamAssassinException(String.Format("{0} ({1})", responsePacket.ResponseMessage, responsePacket.ResponseCode));
}
