public L_ViewTestForm(UserSession currentUser)
{
InitializeComponent();
tsiTests.BackColor = Color.DarkRed;
this.currentUser = currentUser;
tsiAccount.Text = currentUser.Username;
//registers the Refresh() method to the event handler
cbxTests.SelectedIndexChanged += (object obj, EventArgs e) => { Refresh(); };
//load tests from database
try
{
tests = new DBControl().GetTests(currentUser);
foreach (Test test in tests)
{
cbxTests.Items.Add(test.TestName);
}
cbxTests.SelectedIndex = 0;//set as default selected
} catch (Exception ex)
{
StackLog.GetInstance().Log(ex.Message + "\n" + ex.StackTrace);
MessageBox.Show("Failed to load tests", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public S_StudentHome(UserSession currentUser)
{
InitializeComponent();
tsiHome.BackColor = Color.DarkRed;
this.currentUser = currentUser;
tsiAccount.Text = currentUser.Username;
int takenCount = 0, average = 0;
//load tests from database
try
{
tests = new DBControl().GetTests(currentUser);
}
catch (Exception ex)
{
StackLog.GetInstance().Log(ex.Message + "\n" + ex.StackTrace);
MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
foreach (Test test in tests)
{
if (test.AttemptsMade > 0)
{
takenCount++;
average += test.Percentage;
}
dataGridView1.Rows.Add(
test.TestName,
test.AttemptsMade + " of " + (test.AttemptsAllowed == -1 ? "unlimited" : test.AttemptsAllowed.ToString()),
test.AttemptsMade == 0 ? "--" : test.Mark.ToString() + " / " + test.Questions.Count.ToString(),
test.AttemptsMade == 0 ? "--" : test.Percentage.ToString() + "%");
}
//update UI with student data
lblTestsTaken.Text = takenCount.ToString();
lblTestTotalCount.Text = tests.Count.ToString();
if (takenCount > 0)
{
average /= takenCount;
lblAverage.Text = average.ToString();
}
else
{
lblAverage.Text = "--";
}
//add listner to datagrid view
dataGridView1.SelectionChanged += (object obj, EventArgs e) =>
{
if (dataGridView1.SelectedRows.Count > 0)
{
selectedTest = dataGridView1.SelectedRows[0].Index;
}
else if (dataGridView1.SelectedCells.Count > 0)
{
selectedTest = dataGridView1.SelectedCells[0].RowIndex;
}
};
}
public ClientBuilding(byte id, ClientPlayer owner, ClientTile tile) : base(id, owner)
{
var prefab = Resources.Load("prefabs/buildings/" + id);
StackLog.Debug("Instantiating BUILDING");
_gameObject = MainBehaviour.Instantiate(prefab, ((ClientChunk)tile.Chunk).GetGameObject().transform) as GameObject;
}
public static bool AddResponse(Message pRespMsg)
{
try
{
Thread vReqThread = null;
for (int t = 0; t <= 3; t++)
{
if (vResponseSessions.TryAdd(pRespMsg.SessionID, pRespMsg))
{
//Message StoreMsg = (Message)vResponseSessions[pRespMsg.SessionID];
//StackLog.Write2ErrorLog("ResponseWaiter.AddReponse", StoreMsg.ToString());
//if (StoreMsg.avps.Count == 0)
// StackLog.Write2ErrorLog("ResponseWaiter.AddResponse", "Response Msg has no AVP's for Session:" + StoreMsg.SessionID);
for (int tq = 0; tq <= 3; tq++)
{
if (vRequestSessions.TryRemove(pRespMsg.SessionID, out vReqThread))
{
//interrupting sessionid:
Common.StackLog.Write2TraceLog("ResponseWaiter.AddResponse() ", " Interrupting Session (ID: " + pRespMsg.SessionID + ") Thread: " + vReqThread.Name + " (" + vReqThread.ThreadState.ToString() + ")..\r\n");
vReqThread.Interrupt();
break;
}
}
return(true);
}
}
return(false);
}
catch (Exception ex)
{
StackLog.Write2ErrorLog("ResponseWaiter.AddResponse", "Exception :" + ex.Message);
return(false);
}
}
private void BtnSubmit_Click(object sender, EventArgs e)
{
bool submit = true;
//save current question answer
test.Questions[questionIndex].StudentAnswer = rbnAnswerA.Checked ? 'a' :
rbnAnswerB.Checked ? 'b' : rbnAnswerC.Checked ? 'c' : default(char);
foreach (Question question in test.Questions)
{
if (question.StudentAnswer == default(char))
{
DialogResult res = MessageBox.Show(
"You have not completed all the answers \nAre you sure you want to submit?",
"Incomplete Test",
MessageBoxButtons.YesNoCancel,
MessageBoxIcon.Warning);
if (res == DialogResult.No || res == DialogResult.Cancel)
{
submit = false;
break;
}
}
}
if (submit)
{
try
{
int mark = 0, percentage;
foreach (Question question in test.Questions)
{
if (question.CorrectAnswer == question.StudentAnswer)
{
mark++;
}
}
percentage = (int)((double)mark / (double)test.Questions.Count * 100.0);
test.Mark = mark;
test.Percentage = percentage;
test.AttemptsMade++;
bool subit = new DBControl().SubmitTest(currentUser, test);
if (subit)
{
MessageBox.Show("Test saved successfully", "Success");
}
new S_ViewMemoForm(currentUser, test).Show();
this.Hide();
}
catch (Exception ex)
{
StackLog.GetInstance().Log(ex.Message + "\n" + ex.StackTrace);
MessageBox.Show("Failed to submit test", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
private void BtnLogin_Click(object sender, EventArgs e)
{
Refresh();
bool isUsername = false;
bool isPassword = false;
if (tbxUsername.Text == "")
{
lblErrMsgUsername.Visible = true;
}
else
{
isUsername = true;
}
if (tbxPassword.Text == "")
{
lblErrMsgPassword.Visible = true;
}
else
{
isPassword = true;
}
if (isUsername && isPassword)
{
try
{
UserSession currentUser = new DBControl().LoginUser(tbxUsername.Text, tbxPassword.Text);
if (currentUser == null)
{
MessageBox.Show("Username or/and password is incorrect.",
"Invalid Credentials");
}
else
{
switch (currentUser.UserType)
{
case 's':
new S_StudentHome(currentUser).Show(); this.Hide();
break;
case 'l':
new L_ClassListForm(currentUser).Show(); this.Hide();
break;
case 'r':
new R_RegisterForm(currentUser).Show(); this.Hide();
break;
}
}
} catch (Exception ex)
{ StackLog.GetInstance().Log(ex.StackTrace); MessageBox.Show(ex.Message, "Error"); }
}
}
public override void Refresh()
{
base.Refresh();
//loads selected test
dgvTestQAndA.Rows.Clear();
int selectedTest = cbxTests.SelectedIndex;
foreach (Question question in tests[selectedTest].Questions)
{
int i = dgvTestQAndA.Rows.Add();
dgvTestQAndA.Rows[i].Cells[0].Value = question.QuestionNum + ". " + question.QuestionText;
char correctAnswer = question.CorrectAnswer;
i = dgvTestQAndA.Rows.Add();
dgvTestQAndA.Rows[i].Cells[0].Value = question.Answers['a'];
if (correctAnswer == 'a')
{
dgvTestQAndA.Rows[i].Cells[0].Style.BackColor = Color.DarkSeaGreen;
}
i = dgvTestQAndA.Rows.Add();
dgvTestQAndA.Rows[i].Cells[0].Value = question.Answers['b'];
if (correctAnswer == 'b')
{
dgvTestQAndA.Rows[i].Cells[0].Style.BackColor = Color.DarkSeaGreen;
}
i = dgvTestQAndA.Rows.Add();
dgvTestQAndA.Rows[i].Cells[0].Value = question.Answers['c'];
if (correctAnswer == 'c')
{
dgvTestQAndA.Rows[i].Cells[0].Style.BackColor = Color.DarkSeaGreen;
}
dgvTestQAndA.Rows.Add();
}
try
{
int average = new DBControl().GetTestAverage(tests[cbxTests.SelectedIndex].TestId);
if (average == -1)
{
lblAveragePercent.Text = "--";
}
else
{
lblAveragePercent.Text = average.ToString();
}
} catch (Exception ex) { StackLog.GetInstance().Log(ex.Message + "\n" + ex.StackTrace); }
}
public override Chunk GetTileChunk(int tileX, int tileY)
{
var chunk = base.GetTileChunk(tileX, tileY);
if (chunk == null)
{
int chunkX = tileX.ToChunkCoordinate();
var chunkY = tileY.ToChunkCoordinate();
chunk = new ClientChunk(this, chunkX, chunkY);
this.Add(chunk);
StackLog.Debug($"Created {chunk}");
}
return(chunk);
}
public void SetVisible(bool visible)
{
if (_gameObj == null)
{
return;
}
if (_gameObj.activeSelf == visible)
{
return;
}
StackLog.Debug($"Changing activaction of {this} to {visible}");
_gameObj.SetActive(visible);
}
private void BtnCreateText_Click(object sender, EventArgs e)
{
bool isValidTest = ValidateTest();
bool isValidQuestion = ValidateTestQuestion();
bool isConcent = false;
if (!isValidTest)
{
MessageBox.Show("Cannot save test without a name",
"Missing name",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
else
{
isConcent = ConsentUser(isValidQuestion);
if (isValidQuestion && isConcent)
{
//save question
int QIndex = dispQuestionIndex;
test.Questions[QIndex].QuestionNum = QIndex + 1;
test.Questions[QIndex].QuestionText = tbxQuestion.Text;
test.Questions[QIndex].CorrectAnswer = Convert.ToChar(cbxCorrectAnswer.SelectedItem.ToString());
test.Questions[QIndex].Answers['a'] = tbxAnswerA.Text;
test.Questions[QIndex].Answers['b'] = tbxAnswerB.Text;
test.Questions[QIndex].Answers['c'] = tbxAnswerC.Text;
}
else
{
test.Questions.RemoveAt(dispQuestionIndex);
}
try
{
test.TestName = tbxTestName.Text;
test.AttemptsAllowed = cbxAllowedAttempts.SelectedIndex == 3 ? -1 : cbxAllowedAttempts.SelectedIndex + 1;
new DBControl().SaveNewTest(currentUser, test);
MessageBox.Show("Test saved!", "Success");
new L_ViewTestForm(currentUser).Show();
this.Hide();
}
catch (Exception ex) { StackLog.GetInstance().Log(ex.StackTrace); MessageBox.Show(ex.Message); }
}
}
public override void SetSeenBy(ExploringEntity entity)
{
base.SetSeenBy(entity);
StackLog.Debug($"{entity} sees {this}");
if (entity.Owner == MainBehaviour.Player)
{
SetVisible(true);
foreach (var party in this.MovingEntities)
{
((ClientParty)party).GetGameObject().SetActive(true);
}
if (this.StaticEntity is IGameObject)
{
((IGameObject)this.StaticEntity).GetGameObject().SetActive(true);
}
}
}
public override Tile GetTile(int tileX, int tileY)
{
if (!ValidCoords(tileX, tileY))
{
StackLog.Debug($"Invalid coords {tileX}-{tileY}");
return(null);
}
var tile = base.GetTile(tileX, tileY);
if (tile == null)
{
StackLog.Debug($"Creating tile {tileX} {tileY}");
var chunk = base.GetTileChunk(tileX, tileY);
tile = new ClientTile((ClientChunk)chunk, tileX, tileY);
chunk.Tiles[tileX % GameWorld.CHUNK_SIZE, tileY % GameWorld.CHUNK_SIZE] = tile;
}
return(tile);
}
public bool Connect()
{
try
{
StateObject state = new StateObject();
if (stackContext.peers[0].PeerConnection == null || !(stackContext.peers[0].PeerConnection.Connected))
{
StackLog.Write2TraceLog("\r\n\nTransport.SendMessage()", "Establishing the Connection");
Common.StackLog.Write2TraceLog("Transport::SendMessage", "Connecting remote Peer[ " + stackContext.peers[0].PeerIPAddress + ":" + stackContext.peers[0].PeerPort + "]");
stackContext.peers[0].PeerConnection = new TcpClient(stackContext.peers[0].PeerIPAddress, stackContext.peers[0].PeerPort);
stackContext.peers[0].PeerConnection.ReceiveBufferSize = MAX_TCP_BUFF_SIZE;
Common.StackLog.Write2TraceLog("Transport::SendMessage() ", " Connection Established..");
//Update Peer Connection State
DiameterAAAStack.UpdateConnectionState(stackContext.peers[0], PeerState.OPEN);
Common.StackLog.Write2TraceLog("Transport::SendMessage() ", " Connection State Changed to OPEN..");
//Start Data Processing Thread
//pProcessDataThread = new Thread(processData);
//pProcessDataThread.Start();
//Start Receive CallBack
tcpClient = stackContext.peers[0].PeerConnection;
tcpClient.Client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
state.workSocket = tcpClient.Client;
}
}
catch (Exception e)
{
Common.StackLog.Write2ErrorLog("Connect", "Error Connecting:" + e.Message + " Stack:" + e.StackTrace);
return(false);
}
return(true);
}
public static Message GetResponse(string pReqKey)
{
try
{
Message vRespMsg = null;
bool vRespRemoved = false;
for (int t = 0; t <= 3; t++)
{
if (vResponseSessions.ContainsKey(pReqKey))
{
//for (int t = 0; t <= 3; t++)
//{
if (vResponseSessions.TryRemove(pReqKey, out vRespMsg))
{
vRespRemoved = true;
break;
}
//}
}
else
{
StackLog.Write2ErrorLog("ResponseWaiter.GetResponse", "Response Key not found for SessionID:" + pReqKey);
}
}
if (!vRespRemoved)
{
StackLog.Write2ErrorLog("ResponseWaiter.GetResponse", "Unable to remove Response for SessionID:" + pReqKey);
}
return(vRespMsg);
}
catch (Exception ex)
{
StackLog.Write2ErrorLog("ResponseWaiter.GetResponse", "Exception :" + ex.Message);
return(null);
}
}
public L_ClassListForm(UserSession currentUser)
{
InitializeComponent();
//initialize data
tsiClassList.BackColor = Color.DarkRed;
this.currentUser = currentUser;
tsiAccount.Text = currentUser.Username;
try {
tests = new DBControl().GetTests(currentUser);
}
catch (Exception ex) { StackLog.GetInstance().Log(ex.Message + "\n" + ex.StackTrace); MessageBox.Show(ex.Message, "Error"); }
cbxTestName.SelectedIndexChanged += (object obj, EventArgs e) => { LoadDataGrid(this, e); };
foreach (Test test in tests)
{
cbxTestName.Items.Add(test.TestName);
}
if (cbxTestName.Items.Count > 0)
{
cbxTestName.SelectedIndex = 0;
}
}
private void ReceiveCallback(IAsyncResult result)
{
int bytesRead;
StateObject state = (StateObject)result.AsyncState;
Socket client = state.workSocket;
try
{
// Retrieve the state object and the client socket
try
{
bytesRead = client.EndReceive(result);
}
catch (Exception e)
{
//An error has occured when reading
Common.StackLog.Write2ErrorLog("ReceiveCallBack", "Error:" + e.Message + " Stack:" + e.StackTrace);
Thread t = new Thread(new ParameterizedThreadStart(Reconnect));
t.Start(stackContext);
return;
}
if (bytesRead == 0)
{
//The connection has been closed.
//Reconnect
Common.StackLog.Write2ErrorLog("ReceiveCallBack", "Zero Bytes Read");
Thread t = new Thread(new ParameterizedThreadStart(Reconnect));
t.Start(stackContext);
return;
}
/// Begin processing Diameter messages , If new data is too large for buffer, reset the buffer and store new data
//StackLog.Write2TraceLog("ReceiveCallBack", "INIT:Bytesread=" + bytesRead + "\r\nINIT:mLen=" + mLen + "\r\nINIT:mPos=" + mPos);
if (mLen + bytesRead > MAX_BUFF_SIZE)
{
//StackLog.Write2ErrorLog("ReceiveCallBack", "RESET:mLen=" + mLen + "\r\nRESET:Bytesread=" + bytesRead);
if (mLen - mPos > 0)
{
byte[] tmpBuffer = new byte[mLen - mPos];
Array.Copy(responseBuffer, mPos, tmpBuffer, 0, mLen - mPos);
responseBuffer = new byte[MAX_BUFF_SIZE];
Array.Copy(tmpBuffer, 0, responseBuffer, 0, tmpBuffer.Length);
mLen = tmpBuffer.Length;
mPos = 0;
}
else
{
responseBuffer = new byte[MAX_BUFF_SIZE];
mPos = 0;
mLen = 0;
}
}
//Append new data into existing Message Buffer
try
{
//StackLog.Write2ErrorLog("ReceiveCallBack", "Copying Array: mLen: " + mLen + ", Bytesread: " + bytesRead + ", mPos: " + mPos + ", SrcArray len: " + state.buffer.Length + ", DstArray len: " + responseBuffer.Length);
Array.Copy(state.buffer, 0, responseBuffer, mLen, bytesRead);
mLen = mLen + bytesRead;
//StackLog.Write2ErrorLog("ReceiveCallBack", "Array Copied: mLen: " + mLen + ", Bytesread: " + bytesRead + ", mPos: " + mPos + ", SrcArray len: " + state.buffer.Length + ", DstArray len: " + responseBuffer.Length);
}
catch (Exception ex)
{
StackLog.Write2ErrorLog("ReceiveCallBack", " Length Error: " + ex.Message + " \nmLen: " + mLen + ", Bytesread: " + bytesRead + ", mPos: " + mPos + ", SrcArray len: " + state.buffer.Length + ", DstArray len: " + responseBuffer.Length);
//return;
throw ex;
}
processData();
if (client.Connected)
{
//Then start reading from the network again after Parsing recieved Message.
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
}
else
{
StackLog.Write2ErrorLog("ReceiveCallBack", " Socket disconnected, Reconnect Again!");
Thread t = new Thread(new ParameterizedThreadStart(Reconnect));
t.Start(stackContext);
}
}
catch (Exception e)
{
//Then start reading from the network again.
//state.workSocket.Connect(state.workSocket.RemoteEndPoint);
Common.StackLog.Write2ErrorLog("ReceiveCallBack", " ReceiveCallback Error:" + e.Message + " Stack:" + e.StackTrace);
if (client.Connected)
{
//Then start reading from the network again after Parsing recieved Message.
client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
}
else
{
StackLog.Write2ErrorLog("ReceiveCallBack", " Exception Socket disconnected, Reconnect Again!");
Thread t = new Thread(new ParameterizedThreadStart(Reconnect));
t.Start(stackContext);
}
}
}
private void BtnRegister_Click(object sender, EventArgs e)
{
Refresh();
bool isUsername = false, isName = false, isSurname = false, isPassword = false,
isUserType = false;
//validate inputs
if (tbxUsername.Text == "")
{
lblErrMsgUsername.Visible = true;
}
else
{
isUsername = true;
}
if (tbxName.Text == "")
{
lblErrMsgName.Visible = true;
}
else
{
isName = true;
}
if (tbxSurname.Text == "")
{
lblErrMsgSurname.Visible = true;
}
else
{
isSurname = true;
}
if (tbxPassword.Text == "")
{
lblErrMsgPassword.Visible = true;
}
else
{
isPassword = true;
}
if (cbxUserType.SelectedItem == null)
{
lblErrMsgUserType.Visible = true;
}
else
{
isUserType = true;
}
//register user if inputs valid
if (isUsername && isName && isSurname && isPassword && isUserType)
{
bool isRegistered = false;
try
{
char userType = cbxUserType.SelectedIndex == 0 ? 'r' : cbxUserType.SelectedIndex == 1 ? 's' : 'l';
isRegistered = new DBControl().RegisterUser(currentUser, tbxUsername.Text,
tbxName.Text, tbxSurname.Text, tbxPassword.Text, userType);
if (isRegistered)
{
MessageBox.Show("User successfully registered", "Success");
tbxName.Text = String.Empty;
tbxSurname.Text = String.Empty;
tbxPassword.Text = String.Empty;
tbxUsername.Text = String.Empty;
cbxUserType.SelectedIndex = -1;
}
else
{
MessageBox.Show("Failed to register user", "Failed");
}
}
catch (Exception ex)
{
StackLog.GetInstance().Log(ex.StackTrace); MessageBox.Show(ex.Message, "Error");
}
}
}
/// <summary>
///
/// </summary>
/// <param name="listenAddresses"></param>
public void StartListners(List <ListenAddress> listenAddresses, ref TcpListener listner)
{
byte[] responseBuffer = new byte[4000];
try
{
SocketAddress address = new SocketAddress(System.Net.Sockets.AddressFamily.InterNetwork);
foreach (ListenAddress socketAddr in listenAddresses)
{
Common.StackLog.Write2TraceLog("Transport::SendMessage", "Starting Listening on " + socketAddr.IPAddress.ToString() + " with Port: " + socketAddr.Port.ToString());
listner = new TcpListener(IPAddress.Parse(socketAddr.IPAddress), socketAddr.Port);
listner.Start();
Common.StackLog.Write2TraceLog("Transport::SendMessage", "Started Listening on " + listner.LocalEndpoint.ToString());
StackLog.Write2TraceLog("StartListners", "Started Listening on " + socketAddr.IPAddress + ":" + socketAddr.Port.ToString());
}
while (true)
{
//try
//{
if (listner.Pending())
{
Common.StackLog.Write2TraceLog("Transport::StartListener", "Listening for Peer Connections ");
Socket socket = listner.AcceptSocket();
Common.StackLog.Write2TraceLog("Transport::StartListener", "Recieved Message From [" + socket + " ]");
//Get the Message Length
Array.Clear(responseBuffer, 0, responseBuffer.Length);
int rcvdcount = socket.Receive(responseBuffer);
byte[] RcvdBytes = new byte[rcvdcount];
Buffer.BlockCopy(responseBuffer, 0, RcvdBytes, 0, rcvdcount);
//
IPEndPoint remotePeer = socket.RemoteEndPoint as IPEndPoint;
RecievedMessageInfo rcvdObject = new RecievedMessageInfo()
{
data = RcvdBytes, PeerIdentity = new URI("aaa://" + remotePeer.Address + ":" + remotePeer.Port + ";transport=tcp;protocol=diameter")
};
DiameterAAAStack.RaisePeerStateChangeEvent(PEER_STATE_EVENT.Rcv_Message, RcvdBytes);
Array.Clear(responseBuffer, 0, responseBuffer.Length);
}
//}
//catch (Exception ex)
//{
//}
}
}
catch (Exception exp)
{
//Write Log Here..
Common.StackLog.Write2ErrorLog("Transport::StartListners()", "Error:" + exp.Message + " Stack:" + exp.StackTrace);
//Shutdown and end connection
//listner.Stop();
//throw exp;
}
finally
{
listner.Stop();
}
}
/// <summary>
/// Send Message to the Diameter Peer
/// </summary>
/// <param name="MessageBytes"></param>
/// <param name="TransportType"></param>
/// <param name="remotePeer"></param>
public Message SendMessage(Message diameterRequest, Peer destPeer)
{
try
{
byte[] mgsBytesToSend = diameterRequest.GetBytes();
//Connect if not connected
if (stackContext.peers[0].PeerConnection == null || !stackContext.peers[0].PeerConnection.Connected)
{
if (diameterRequest.CommandCode != DiameterMessageCode.CAPABILITY_EXCHANGE)
{
Common.StackLog.Write2ErrorLog("Transport::SendMessage", "Connection Broken, calling Connect()");
}
//Connect Diameter Socket
Connect();
}
Thread pWaiterThread;
//Just Copy to localThreadWaiter Variable.
pWaiterThread = Thread.CurrentThread;
//CCRWaiter vRespWaiter = null;
//if Message is a CCR message, we need to wait for a response, so add Session to CCRSession
if (diameterRequest.CommandCode == DiameterMessageCode.CREDIT_CONTROL)
{
ResponseWaiter.AddRequest(diameterRequest.SessionID, pWaiterThread);
}
//CER Never Contains a Session ID
else if (diameterRequest.CommandCode == DiameterMessageCode.CAPABILITY_EXCHANGE)
{
ResponseWaiter.AddRequest("CEX", pWaiterThread);
diameterRequest.SessionID = "CEX";
}
else
{
StackLog.Write2TraceLog("Transport.SendMessage() ", "UnHandled Message Type:" + diameterRequest.CommandCode);
return(null);
}
//Record Time
TimeSpan STime = new TimeSpan(DateTime.Now.Ticks);
///////////////////////////////Send Message to the Remote Peer ////////////////////////////////
//StackLog.Write2TraceLog("\r\nSendMessage", diameterRequest.ToString());
msgLogger.Write2MessageLog(diameterRequest.ToString());
Common.StackLog.Write2TraceLog("Transport::SendMessage() ", " Sending Message " + DiameterMessageCode.GetMessageName(diameterRequest.CommandCode, true) + " (" + diameterRequest.SessionID + ") ..");
destPeer.PeerConnection.GetStream().Write(mgsBytesToSend, 0, mgsBytesToSend.Length);
//Wait for Response;
Common.StackLog.Write2TraceLog("Transport::SendMessage() ", " Message Sent, Waiting For Diameter Message Response of Session: " + diameterRequest.SessionID);
bool isInterrupted = false;
try
{
//Sleep for 3 Seconds Maximum until interrupted.
for (int i = 0; i <= stackContext.CCATimeout * 10; i++)
{
Thread.Sleep(100);
}
}
catch (ThreadInterruptedException ex)
{
isInterrupted = true;
//StackLog.Write2ErrorLog("SendMessage", "Thread Intrupted for for Response for the Session: " + diameterRequest.SessionID);
}
if (isInterrupted)
{
Common.StackLog.Write2TraceLog("Transport.SendMessage() ", " Waiter Thread Response Interrupted for Session: " + diameterRequest.SessionID);
}
else
{
Common.StackLog.Write2TraceLog("Transport.SendMessage() ", " Waiter Thread Response Timedout for Session: " + diameterRequest.SessionID);
}
//After Thread intrruption get the response here.
//CEX Dont have any session ID so validate here.
Message diameterResponse;
if (ResponseWaiter.ContainsResponse(diameterRequest.SessionID))
{
diameterResponse = ResponseWaiter.GetResponse(diameterRequest.SessionID);
}
else
{
Common.StackLog.Write2ErrorLog("Transport::SendMessage", "Response message not available for " + DiameterMessageCode.GetMessageName(diameterRequest.CommandCode, true) + " " + diameterRequest.SessionID);
return(null);
}
//Check the Recieved Response
if (diameterResponse != null)
{
Common.StackLog.Write2TraceLog("Transport.SendMessage() ", "Response Message " + DiameterMessageCode.GetMessageName(diameterResponse.CommandCode, false) + " of Request Session: " + diameterRequest.SessionID + " with Response of:" + diameterResponse.SessionID.ToString() + " Received..\r\n");
/*if (diameterResponse.avps.Count == 0)
* {
* StackLog.Write2ErrorLog("SendMessage", "Response Msg has no AVP's for Session:" + diameterResponse.SessionID);
* StackLog.Write2ErrorLog("SendMessage", diameterResponse.ToString());
* }*/
////Log Recieved Message
//StackLog.Write2MessageLog(diameterResponse.ToString());
msgLogger.Write2MessageLog(diameterResponse.ToString());
TimeSpan ETime = new TimeSpan(DateTime.Now.Ticks);
diameterResponse.ExecTime = ETime.Subtract(STime).Milliseconds;
//diameterResponse.PrintMessage();
}
else
{
Common.StackLog.Write2ErrorLog("Transport::SendMessage", "Unable to Receive Response message for " + DiameterMessageCode.GetMessageName(diameterRequest.CommandCode, true) + " " + diameterRequest.SessionID);
//Common.StackLog.Write2ErrorLog("Transport::SendMessage", diameterRequest.ToString());
}
return(diameterResponse);
}
catch (Exception exp)
{
StackLog.Write2ErrorLog("DiameterTransport:SendMessage()", "Error:" + exp.Message + " Stack:" + exp.StackTrace.ToString());
//throw exp;
return(null);
}
}
private void processData()
{
//Common.StackLog.Write2TraceLog("Transport.processData", "Starting processData Thread");
Message msg = null;
//while (!DiameterAAAStack.isStopping)
//{
while (true)
{
try
{
int msgBufLen = mLen - mPos;
if (msgBufLen <= 0)
{
//StackLog.Write2TraceLog("ReceiveCallBack", "buffer processed");
try
{
Thread.Sleep(10);
}
catch (ThreadInterruptedException)
{
}
break;
}
//StackLog.Write2TraceLog("ReceiveCallBack", "NEW:msgBufLen=" + msgBufLen);
byte[] msgBuffer = new byte[msgBufLen];
Array.Copy(responseBuffer, mPos, msgBuffer, 0, msgBufLen);
try
{
msg = new Message(stackContext, msgBuffer);
}
catch (Exception ex)
{
//Common.StackLog.Write2ErrorLog("Transport.processData", "Error: " + ex.Message + ", Stack: " + ex.StackTrace);
if (ex.Message.Equals("Invalid Protocol Version"))
{
StackLog.Write2ErrorLog("ReceiveCallBack", "Invalid Protocol Version mPos=" + mPos + ", mLen=" + mLen + ", mBufLen=" + msgBufLen);
mPos = mPos + 1;
continue;
}
if (ex.Message.Equals("Invalid Message Length"))
{
break;
}
else
{
throw ex;
}
}
//Set unprocessed message offset
mPos = mPos + msg.MessageLength;
//ProcessReceivedMsg
ProcessreceivedMsg(msg);
}
catch (Exception ex)
{
Common.StackLog.Write2ErrorLog("Transport.processData", "Error: " + ex.Message + ", Stack: " + ex.StackTrace);
break;
}
}
//}
//Common.StackLog.Write2TraceLog("Transport.processData", "processData Thread Stopped");
}
