public void SendMessage(Socket handler, string rec, Header type, RSAParameters key)
{
switch (type)
{
case Header.Login:
JMessage jmess = JMessage.Deserialize(rec);
KeyValuePair <string, string> kv = jmess.ToValue <KeyValuePair <string, string> >();
string answ = ResolveLogin(kv.Key, kv.Value);
Send(handler, answ, key);
break;
case Header.Message:
jmess = JMessage.Deserialize(rec);
//Console.WriteLine(Convert.FromBase64String(rec));
Message message = jmess.ToValue <Message>();
ServerApp.Messages.AddMessage(message);
Send(handler, JMessage.Serialize(JMessage.FromValue <IList <CommonApp.Model.Message> >(ServerApp.Messages.GetMessagesOfUser(message.UserNameFrom), Header.Message)), key);
break;
case Header.Messages:
string user = JMessage.Deserialize(rec).ToValue <string>();
Send(handler, JMessage.Serialize(JMessage.FromValue <IList <CommonApp.Model.Message> >(ServerApp.Messages.GetMessagesOfUser(user), Header.Messages)), key);
break;
case Header.Users:
jmess = JMessage.FromValue <Dictionary <string, string> >(ServerApp.Users.UsersDict, Header.Users);
Send(handler, JMessage.Serialize(jmess), key);
break;
}
}
void OnAnswer(Button button)
{
if (!IsFirstTeamPicked)
{
SendMessage("FirstAnsweringTeam", SelectedTeam.Number);
IsFirstTeamPicked = true;
JMessage jMessage = ReadMessage();
if (jMessage.MessageType != "Confirm")
{
throw new Exception("Wrong message type. Expected: 'Confirm' got: '" + jMessage.MessageType + "'");
}
}
Answer answer = button.BindingContext as Answer;
CurrentQuestion.Answers.Remove(answer);
if (CurrentQuestion.Answers.Count == 0)
{
SetStartProperties();
}
SendMessage("CorrectAnswer", answer);
if (IsRoundOn)
{
JMessage msg = ReadMessage();
IsRoundOn = JMessage.Deserialize <bool>(msg.ObjectJson);
}
}
private void HandleMessage(string msgString)
{
JMessage msg = JMessage.Deserialize(msgString);
if (msg.MessageType == "RandQuestion")
{
Question q = RandQuestion();
SendMessage("RandQuestion", q);
_currentQuestion = q;
}
else if (msg.MessageType == "SubmitQuestion")
{
NewQuestion(_currentQuestion);
}
else if (msg.MessageType == "FirstAnsweringTeam")
{
_currentAnsweringTeam = (Team)JMessage.Deserialize <int>(msg.ObjectJson);
SendMessage("Confirm", null);
}
else if (msg.MessageType == "CorrectAnswer")
{
Answer answer = JMessage.Deserialize <Answer>(msg.ObjectJson);
ProceedCorrectAnswer(GetAnswerNumber(answer));
}
else if (msg.MessageType == "IncorrectAnswer")
{
ProceedUncorrectAnswer();
}
}
public IList <Message> SendMessage(string UsernameTo, string message, DateTime time)
{
Message m = new Message(this.Username, UsernameTo, message, time);
string messages = this.SendAndReceiveMessage(m, Header.Message);
return(JMessage.Deserialize(messages).ToValue <IList <Message> >());
}
public override IList <Message> SendMessage(string user, string writeTo, string text, DateTime now)
{
Message m = new Message(user, writeTo, text, now);
string messages = this.SendAndReceiveMessage(m, Header.Message);
return(JMessage.Deserialize(messages).ToValue <IList <Message> >());
}
public void UnpackAndSend(Socket handler, string message, Header type)
{
JMessage jmess = JMessage.Deserialize(message);
KeyValuePair <string, string> keyValuePair = jmess.ToValue <KeyValuePair <string, string> >();
RSAParameters param = (RSAParameters)ServerApp.Users.GetUserKeys()[keyValuePair.Key];
SendMessage(handler, keyValuePair.Value, type, param);
}
public void NewKey()
{
string msg = this.SendAndReceiveMessage("", Header.Handshake);
KeyValuePair <byte[], byte[]> pair = JMessage.Deserialize(msg).ToValue <KeyValuePair <byte[], byte[]> >();
Key = pair.Key;
IV = pair.Value;
}
public void GetKey()
{
KeyValuePair <string, RSAParameters> toSend = new KeyValuePair <string, RSAParameters> (this.Username, RSA.ExportParameters(false));
string msg = this.SendAndReceiveMessage <KeyValuePair <string, RSAParameters> >(toSend, Header.ExchangePKs);
RSAParameters ret = JMessage.Deserialize(msg).ToValue <RSAParameters>();
SynchronousSocketClient2.ServerPublicKey = ret;
}
void OnRandQuestion()
{
SendMessage("RandQuestion", null);
JMessage msg = ReadMessage();
CurrentQuestion = JMessage.Deserialize <Question>(msg.ObjectJson);
IsSubmitQuestionEnabled = true;
}
private JMessage ReadMessage()
{
Stream stream = _tcpClient.GetStream();
byte[] bb = new byte[1000];
int k = stream.Read(bb, 0, 1000);
string msgString = System.Text.Encoding.UTF8.GetString(bb, 0, k);
return(JMessage.Deserialize(msgString));
}
public void SendUnencrypted(Socket handler, string rec)
{
JMessage des = JMessage.Deserialize(rec);
KeyValuePair <string, RSAParameters> kv2 = des.ToValue <KeyValuePair <string, RSAParameters> >();
ServerApp.Users.SetUserKey(kv2.Key, kv2.Value);
JMessage jmess;
jmess = JMessage.FromValue <RSAParameters>(_RSA.ExportParameters(false), Header.ExchangePKs);
handler.Send(Encoding.ASCII.GetBytes(JMessage.Serialize(jmess)));
}
public override void NewKey()
{
RSA = new RSACryptoServiceProvider(8192);
KeyValuePair <string, RSAParameters> toSend = new KeyValuePair <string, RSAParameters>(this._username, RSA.ExportParameters(false));
if (_username == null)
{
throw new Exception("username null");
}
string msg = this.SendAndReceiveMessage <KeyValuePair <string, RSAParameters> >(toSend, Header.ExchangePKs);
RSAParameters ret = JMessage.Deserialize(msg).ToValue <RSAParameters>();
SynchronousSocketClientAsym.ServerPublicKey = ret;
}
private void tdwRunWorkerCompleted(object sender, System.ComponentModel.RunWorkerCompletedEventArgs e)
{
if (tweenData.Contains("LiveTween"))
{
JMessage message = JMessage.Deserialize(tweenData);
if (message.Type == typeof(Tween))
{
tween = message.Value.ToObject <Tween>();
durationField.Text = tween.Duration.ToString();
easeTypeField.SelectedItem = tween.EasingType;
}
else
{
throw new Exception();
}
}
}
void OnIncorrectAnswer()
{
if (!IsFirstTeamPicked)
{
SendMessage("FirstAnsweringTeam", SelectedTeam.Number);
IsFirstTeamPicked = true;
JMessage jMessage = ReadMessage();
if (jMessage.MessageType != "Confirm")
{
throw new Exception("Wrong message type. Expected: 'Confirm' got: '" + jMessage.MessageType + "'");
}
}
SendMessage("IncorrectAnswer", null);
JMessage msg = ReadMessage();
IsRoundOn = JMessage.Deserialize <bool>(msg.ObjectJson);
}
private void ListenThread(Object client)
{
TcpClient clienttmp = (TcpClient)client;
BinaryReader reader = new BinaryReader(clienttmp.GetStream());
writer = new BinaryWriter(clienttmp.GetStream());
LRM.writer = new BinaryWriter(clienttmp.GetStream());
try
{
while (true)
{
string received_data = reader.ReadString();
//Console.WriteLine(received_data);
JMessage received_object = JMessage.Deserialize(received_data);
if (received_object.Type == typeof(Signal))
{
Signal received_signal = received_object.Value.ToObject <Signal>();
if (received_signal.stm1 != null)
{
this.pathList = received_signal.path;
STM1 frame = received_signal.stm1;
int virtPort = received_signal.port;
consoleWriter("received signal on port: " + virtPort);
toVirtualPort(virtPort, frame);
//Console.WriteLine(received_data);
}
else if (received_signal.lrmProtocol != null)
{
string lrmProtocol = received_signal.lrmProtocol;
int port = received_signal.port;
this.lrm.receivedMessage(lrmProtocol, port);
//Console.WriteLine(received_data);
}
}
}
}
catch (Exception e)
{
log("\nError sending signal: " + e.Message, ConsoleColor.Red);
Thread.Sleep(2000);
Environment.Exit(1);
}
}
public T GetMessage <T>(string message)
{
JMessage mess = JMessage.Deserialize(message);
return(mess.ToValue <T>());
}
public IList <Message> GetMessages()
{
return(JMessage.Deserialize(this.SendAndReceiveMessage <object>(this.Username, Header.Messages)).ToValue <IList <Message> >());
}
public Dictionary <string, string> GetUsers()
{
string users = this.SendAndReceiveMessage <object>("users", Header.Users);
return(JMessage.Deserialize(users).ToValue <Dictionary <string, string> >());
}
private void ListenThread(Object client)
{
TcpClient clienttmp = (TcpClient)client;
BinaryReader reader = new BinaryReader(clienttmp.GetStream());
writer = new BinaryWriter(clienttmp.GetStream());
while (true)
{
try
{
string received_data = reader.ReadString();
JMessage received_object = JMessage.Deserialize(received_data);
if (received_object.Type == typeof(ControlPacket))
{
ControlPacket packet = received_object.Value.ToObject <ControlPacket>();
if (packet.virtualInterface == ControlInterface.CALL_REQUEST)
{
//request service cpcc
int requestID = handlerNCC.generateRequestID();
handlerNCC.addCpccRequest(requestID, myServiceID);
handlerNCC.consoleWriter("[NCC <- CPCC] Receive Call Request for " + packet.destinationIdentifier);
handlerNCC.consoleWriter("[NCC -> DIRECTORY] Send Directory Request");
if (handlerNCC.checkIfInDirectory(packet.destinationIdentifier))
{
handlerNCC.consoleWriter("[NCC <- DIRECTORY] Receive Local Name");
handlerNCC.consoleWriter("[NCC -> POLICY] Send Policy Out");
handlerNCC.consoleWriter("[NCC <- POLICY] Call Accept");
ControlPacket packetToCPCC = new ControlPacket(ControlInterface.CALL_INDICATION_CPCC, packet.state, packet.speed, packet.destinationIdentifier, packet.originIdentifier, requestID);
packetToCPCC.Vc11 = 1;
packetToCPCC.Vc12 = 1;
packetToCPCC.Vc13 = 1;
ControlConnectionService cpccService = handlerNCC.getCpccServiceByAddr(packet.destinationIdentifier);
cpccService.send(packetToCPCC);
handlerNCC.consoleWriter("[NCC -> CPCC] Send Call Indication");
}
else
{
handlerNCC.consoleWriter("[NCC <- DIRECTORY] Directory Request Reject");
Address address = new Address(packet.destinationIdentifier);
ControlConnectionService serviceToNCC = handlerNCC.getService(address.domain);
handlerNCC.addCNAddressesForInterdomainCalls(requestID, packet.originIdentifier);
Address addressFromOtherDomain = new Address(packet.destinationIdentifier);
List <string> borderGWAddresses = new List <string>();
borderGWAddresses = handlerNCC.returnBorderGateway(addressFromOtherDomain.domain);
string borderGWAddress = borderGWAddresses.First();
handlerNCC.initInterdomanCallTask(requestID, borderGWAddress);
ControlPacket packetToNCC = new ControlPacket(ControlInterface.CALL_INDICATION, ControlPacket.IN_PROGRESS, packet.speed, packet.destinationIdentifier, borderGWAddress, requestID);
packetToNCC.domain = handlerNCC.domainNumber;
packetToNCC.Vc11 = 1;
packetToNCC.Vc12 = 1;
packetToNCC.Vc13 = 1;
serviceToNCC.send(packetToNCC);
handlerNCC.consoleWriter("[NCC -> NCC]Send Call Coordination: " + packet.destinationIdentifier + " origin(BG address): " + borderGWAddress);
}
}
else if (packet.virtualInterface == ControlInterface.INIT_CPCC_CONNECTION)
{
handlerNCC.addService(packet.RequestID, this);
this.myServiceID = packet.RequestID;
ControlPacket packetToCpcc = new ControlPacket(ControlInterface.INIT_CPCC_CONNECTION_CONFIRM, 0, 0, "", "", 0);
send(packetToCpcc);
}
else if (packet.virtualInterface == ControlInterface.CALL_RELEASE_IN)
{
//RELEASE
int id = packet.RequestID;
handlerNCC.consoleWriter("[NCC <- CPCC] Call release id: " + id);
if (!handlerNCC.checkIfInterdomainRequest(id))
{
handlerNCC.consoleWriter("[NCC -> CC]Send connection release");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_RELEASE_WITH_ID;
packetToCC.RequestID = packet.RequestID;
ControlConnectionService CCService = this.handlerNCC.getCCService();
CCService.sendCCRequest(packetToCC);
}
else
{
handlerNCC.consoleWriter("[NCC -> CC]Send connection release");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_RELEASE_WITH_ID;
packetToCC.RequestID = packet.RequestID;
ControlConnectionService CCService = this.handlerNCC.getCCService();
CCService.sendCCRequest(packetToCC);
}
}
else if (packet.virtualInterface == ControlInterface.NETWORK_CALL_COORDINATION_IN)
{
handlerNCC.consoleWriter("[NCC <- NCC] Receive NCC invitation from NCC in domain" + packet.RequestID);
handlerNCC.addService(packet.RequestID, this);
ControlPacket packetToNCCResponse = new ControlPacket(ControlInterface.NETWORK_CALL_COORDINATION_OUT, ControlPacket.IN_PROGRESS, 0, "", "", handlerNCC.domainNumber);
send(packetToNCCResponse);
handlerNCC.consoleWriter("[NCC -> NCC] Send invitation response to NCC in domain" + packetToNCCResponse.RequestID);
}
else if (packet.virtualInterface == ControlInterface.NETWORK_CALL_COORDINATION_OUT)
{
handlerNCC.consoleWriter("[NCC <- NCC] NCC handshake completed with NCC in doman" + packet.RequestID);
handlerNCC.addService(packet.RequestID, this);
}
else if (packet.virtualInterface == ControlInterface.CALL_INDICATION)
{
if (packet.state == ControlPacket.IN_PROGRESS)
{
handlerNCC.consoleWriter("[NCC <- NCC] Recived Call Coordination " + packet.originIdentifier + " to: " + packet.destinationIdentifier);
if (handlerNCC.interdomainRequests.ContainsKey(packet.RequestID))
{
//Console.WriteLine("KOLEJNA PROBA Z INNYM GW: " + packet.originIdentifier);
}
else
{
handlerNCC.addInterdomainRequest(packet.RequestID, packet.domain);
}
// ZAKLADAMY TU ZE KAZDE NCC MA HANDLER NA INNE, INACZEJ SPRAWDZ DOMENE CZY TWOJA, NIE TO SLIJ DALEJ
handlerNCC.consoleWriter("[NCC -> DIRECTORY] Send Directory Request");
handlerNCC.consoleWriter("[NCC <- DIRECTORY] Receive Local Name");
handlerNCC.consoleWriter("[NCC -> POLICY] Send Policy Out");
handlerNCC.consoleWriter("[NCC <- POLICY] Call Accept");
ControlPacket packetToCPCC = new ControlPacket(ControlInterface.CALL_INDICATION_CPCC, packet.state, packet.speed, packet.destinationIdentifier, packet.originIdentifier, packet.RequestID);
packetToCPCC.Vc11 = packet.Vc11;
packetToCPCC.Vc12 = packet.Vc12;
packetToCPCC.Vc13 = packet.Vc13;
ControlConnectionService cpccService = handlerNCC.getCpccServiceByAddr(packet.destinationIdentifier);
cpccService.send(packetToCPCC);
handlerNCC.consoleWriter("[NCC -> CPCC] Send Call Indication");
}
else if (packet.state == ControlPacket.REJECT)
{
handlerNCC.consoleWriter("[NCC <- NCC] Receive Call Release, from previous NCC");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_RELEASE_WITH_ID;
packetToCC.RequestID = packet.RequestID;
ControlConnectionService CCService = handlerNCC.getCCService();
CCService.sendCCRequest(packetToCC);
}
}
else if (packet.virtualInterface == ControlInterface.CALL_INDICATION_CPCC_ACCEPT)
{
handlerNCC.consoleWriter("[NCC <- CPCC] Call Indication Confirmed");
handlerNCC.consoleWriter("[NCC -> CC]Send Connection Request");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_SET_CONNECTION;
packetToCC.NodeFrom = packet.originIdentifier;
packetToCC.NodeTo = packet.destinationIdentifier;
handlerNCC.rejectedDestinations.Add(packet.RequestID, packet.destinationIdentifier);
packetToCC.Rate = packet.speed;
packetToCC.RequestID = packet.RequestID;
packetToCC.Vc11 = packet.Vc11;
packetToCC.Vc12 = packet.Vc12;
packetToCC.Vc13 = packet.Vc13;
ControlConnectionService CCService = this.handlerNCC.getCCService();
CCService.sendCCRequest(packetToCC);
}
else if (packet.virtualInterface == ControlInterface.CALL_REQUEST_ACCEPT)
{
// ZAKLADAMY TU ZE KAZDE NCC MA HANDLER NA INNE, INACZEJ SPRAWDZ DOMENE CZY TWOJA, NIE TO ODESLIJ DALEJ
if (packet.state == ControlPacket.ACCEPT)
{
handlerNCC.consoleWriter("[NCC <- NCC] Call Coordination Accept");
CCtoNCCSingallingMessage packetToCC = new CCtoNCCSingallingMessage();
packetToCC.State = CCtoNCCSingallingMessage.NCC_SET_CONNECTION;
packetToCC.NodeFrom = handlerNCC.getCNAddressesForInterdomainCalls(packet.RequestID);
packetToCC.NodeTo = packet.destinationIdentifier;
handlerNCC.consoleWriter("[NCC->CC]Send Connection Request, from: " + packetToCC.NodeFrom + " to: " + packetToCC.NodeTo);
packetToCC.Rate = packet.speed;
packetToCC.RequestID = packet.RequestID;
packetToCC.Vc11 = packet.Vc11;
packetToCC.Vc12 = packet.Vc12;
packetToCC.Vc13 = packet.Vc13;
ControlConnectionService CCService = this.handlerNCC.getCCService();
CCService.sendCCRequest(packetToCC);
}
else
{
//counter--;
//if (counter < 0)
// break;
handlerNCC.consoleWriter("[NCC <- NCC] Call Coordination Rejected");
// handlerNCC.showInterdomainAttemptsForRequestID(packet.RequestID);
// Console.WriteLine("Szukam borderow dla ip: " + packet.destinationIdentifier);
String anotherBorderGWAddress = handlerNCC.getAnotherBorderGatewayAddress(packet.RequestID, packet.originIdentifier);
//Console.WriteLine("Znaleziony border GW: " + anotherBorderGWAddress);
if (anotherBorderGWAddress == null)
{
//wez service odpowiedni
ControlConnectionService cpccCallService = handlerNCC.getService(handlerNCC.getCpccService(packet.RequestID));
ControlPacket packetToCPCC = new ControlPacket(ControlInterface.CALL_ACCEPT, ControlPacket.REJECT, packet.speed, packet.originIdentifier, handlerNCC.getCNAddressesForInterdomainCalls(packet.RequestID), packet.RequestID);
cpccCallService.send(packetToCPCC);
handlerNCC.consoleWriter("[NCC -> CPCC] Call Request Reject");
handlerNCC.clearCNAddressesForInterdomainCalls(packet.RequestID);
handlerNCC.clearInterdomainCallAttempt(packet.RequestID);
handlerNCC.removeCpccRequest(packet.RequestID);
//NIE UDALO SIE U NAS, WYSLAC DO TAMTEGO NCC NIECH ROZLACZY JEDNAK
//W DOMAIN Z TMATEGO NCC JEGO DOMAIN, ZEBY ODESLAC MU NIECH ROZLACZY
// ControlConnectionService nccCallService = handlerNCC.getService(packet.domain);
// ControlPacket packetToNCC = new ControlPacket(ControlInterface.CALL_INDICATION, ControlPacket.REJECT, packet.speed, "BORDER_GATEWAY", packet.destinationIdentifier, packet.RequestID);
//nccCallService.send(packetToNCC);
}
else
{
//Console.WriteLine("Znalazłem nowy border wyjsciowy: " + anotherBorderGWAddress);
handlerNCC.addIntrerdomainCallsAttempts(packet.RequestID, anotherBorderGWAddress);
Address address = new Address(packet.originIdentifier);
ControlConnectionService serviceToNCC = handlerNCC.getService(address.domain);
ControlPacket packetToNCC = new ControlPacket(ControlInterface.CALL_INDICATION, ControlPacket.IN_PROGRESS, packet.speed, packet.originIdentifier, anotherBorderGWAddress, packet.RequestID);
packetToNCC.domain = handlerNCC.domainNumber;
packetToNCC.Vc11 = 1;
packetToNCC.Vc12 = 1;
packetToNCC.Vc13 = 1;
packetToNCC.speed = packet.speed;
handlerNCC.consoleWriter("[NCC -> NCC] Send Call Coordination with another border GW, destination: " + packetToNCC.destinationIdentifier + " borderGW: " + anotherBorderGWAddress);
serviceToNCC.send(packetToNCC);
}
}
}
}
else if (received_object.Type == typeof(CCtoNCCSingallingMessage))
{
CCtoNCCSingallingMessage packet = received_object.Value.ToObject <CCtoNCCSingallingMessage>();
if (packet.State == CCtoNCCSingallingMessage.INIT_FROM_CC)
{
handlerNCC.consoleWriter("[NCC <- CC]Connection established");
handlerNCC.setCCService(this);
}
else if (packet.State == CCtoNCCSingallingMessage.CC_CONFIRM)
{
handlerNCC.consoleWriter("[NCC <- CC] Receive Connection Request Confirm");
if (handlerNCC.rejectedDestinations.ContainsKey(packet.RequestID))
{
handlerNCC.rejectedDestinations.Remove(packet.RequestID);
}
if (handlerNCC.checkIfInterdomainRequest(packet.RequestID))
{
ControlConnectionService NCCService = handlerNCC.getService(handlerNCC.getDomainService(packet.RequestID));
//Console.WriteLine("[CC]Border gateway to previous ncc: " + packet.NodeTo);
//Nodeto GW, NodeFrom CN in other domain address
ControlPacket packetToNCC = new ControlPacket(ControlInterface.CALL_REQUEST_ACCEPT, ControlPacket.ACCEPT, packet.Rate, packet.NodeTo, packet.NodeFrom, packet.RequestID);
packetToNCC.domain = handlerNCC.domainNumber;
packetToNCC.Vc11 = packet.Vc11;
packetToNCC.Vc12 = packet.Vc12;
packetToNCC.Vc13 = packet.Vc13;
NCCService.send(packetToNCC);
handlerNCC.clearCNAddressesForInterdomainCalls(packet.RequestID);
handlerNCC.consoleWriter("[NCC -> NCC] Send Call Coordination Confirm");
}
else
{
ControlConnectionService cpccCallService = handlerNCC.getService(handlerNCC.getCpccService(packet.RequestID));
ControlPacket packetToCPCC = new ControlPacket(ControlInterface.CALL_ACCEPT, ControlPacket.ACCEPT, packet.Rate, packet.NodeTo, packet.NodeTo, packet.RequestID);
List <int> slots = new List <int>();
if (packet.Vc11 != 0)
{
packetToCPCC.Vc11 = 1;
slots.Add(11);
}
if (packet.Vc12 != 0)
{
packetToCPCC.Vc12 = 1;
slots.Add(12);
}
if (packet.Vc13 != 0)
{
packetToCPCC.Vc13 = 1;
slots.Add(13);
}
cpccCallService.send(packetToCPCC);
handlerNCC.management.send(packet.RequestID, packet.NodeTo);
handlerNCC.consoleWriter("[NCC -> CPCC] Send Call Request Accept");
}
}
else if (packet.State == CCtoNCCSingallingMessage.CC_REJECT)
{
handlerNCC.consoleWriter("[NCC <- CC] Receive Connection Request Reject");
if (handlerNCC.checkIfInterdomainRequest(packet.RequestID))
{
ControlConnectionService NCCService = handlerNCC.getService(handlerNCC.getDomainService(packet.RequestID));
//Nodeto GW, NodeFrom CN in other domain address
// Console.WriteLine("[CC]Destination node to previous ncc: " + handlerNCC.rejectedDestinations[packet.RequestID]);
ControlPacket packetToNCC = new ControlPacket(ControlInterface.CALL_REQUEST_ACCEPT, ControlPacket.REJECT, packet.Rate, packet.NodeTo, handlerNCC.rejectedDestinations[packet.RequestID], packet.RequestID);
packetToNCC.domain = handlerNCC.domainNumber;
NCCService.send(packetToNCC);
handlerNCC.rejectedDestinations.Remove(packet.RequestID);
handlerNCC.consoleWriter("[NCC -> NCC] Send Call Coordination Reject");
}
else
{
ControlConnectionService cpccCallService = handlerNCC.getService(handlerNCC.getCpccService(packet.RequestID));
ControlPacket packetToCPCC = new ControlPacket(ControlInterface.CALL_ACCEPT, ControlPacket.REJECT, packet.Rate, packet.NodeTo, packet.NodeTo, packet.RequestID);
handlerNCC.consoleWriter("[NCC -> CPCC] Send Call Request Reject");
cpccCallService.send(packetToCPCC);
}
}
else if (packet.State == CCtoNCCSingallingMessage.BORDER_NODE)
{
handlerNCC.consoleWriter("[NCC <- CC]Get border node address: " + packet.BorderNode + " to domain: " + packet.BorderDomain);
handlerNCC.addBorderGateway(packet.BorderDomain, packet.BorderNode);
}
}
else
{
handlerNCC.consoleWriter("Wrong control packet format");
}
}
catch (IOException e)
{
handlerNCC.consoleWriter("Connection closed");
break;
}
}
}
