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)); }