/// <summary>
/// Converts string array to message
/// </summary>
/// <param name="charArray"></param>
/// <returns></returns>
public static Message StringArrayToMessage(char[] charArray)
{
#if DEBUG
EventLog.Debug("Message.cs " + System.Reflection.MethodBase.GetCurrentMethod().Name);
#endif
try
{
MessageType type = CharToMessageType(charArray[0]);
string msgArray = new string(charArray);
int sepCharsTitle = msgArray.IndexOf("#A!");
int sepCharsClientID = msgArray.IndexOf("#B!");
string title = msgArray.Substring(1, sepCharsTitle - 1);
string clientID = msgArray.Substring(sepCharsTitle + 3, sepCharsClientID - 3 - sepCharsTitle);
string contents = msgArray.Substring(sepCharsClientID + 3).TrimEnd('\0');
Message Result = new Message(title.Trim(), contents.Trim(), type);
Result.SetClientID(clientID);
return(Result);
}
catch (Exception err)
{
#if DEBUG
EventLog.Debug(err);
EventLog.Debug("Message.cs " + System.Reflection.MethodBase.GetCurrentMethod().Name);
#endif
EventLog.Add(err);
return(new Message("Error", err.Message, MessageType.Error));
}
}
/// <summary>
/// Sends the message to the server
/// </summary>
/// <param name="message">Message to be sent</param>
internal void sendMessage(Message message)
{
#if DEBUG
EventLog.Debug(String.Format("{0} - {1}", message.Title, message.Contents));
EventLog.Debug("MessageClient.cs " + System.Reflection.MethodBase.GetCurrentMethod().Name);
#endif
try
{
if (_tcpClient != null && _tcpClient.Connected)
{
message.SetClientID(_clientID);
if (String.IsNullOrEmpty(message.ClientID))
{
message.SetClientID("SERVER");
}
char[] characters = Message.MessageToStringArray(message);
byte[] toSend = System.Text.Encoding.UTF8.GetBytes(characters, 0, characters.Length);
_tcpClient.GetStream().Write(toSend, 0, toSend.Length);
}
}
catch (Exception err)
{
#if DEBUG
EventLog.Debug(err);
EventLog.Debug("MessageClient.cs " + System.Reflection.MethodBase.GetCurrentMethod().Name);
#endif
if (!HandleClientException(err))
{
throw;
}
}
}
protected override bool Run(object parameters)
{
#if DEBUG
EventLog.Debug("MessageClient.cs " + System.Reflection.MethodBase.GetCurrentMethod().Name);
#endif
byte brokenMessageCount = 0;
try
{
while (_parentMessageClient.IsRunning)
{
// Block until an instance Message is received
byte[] bytes = new byte[(int)_parentMessageClient.BufferSize];
// Read can return anything from 0 to numBytesToRead.
// This method blocks until at least one byte is read.
do
{
int bytesRead = _parentMessageClient._tcpClient.GetStream().Read(bytes, 0, bytes.Length);
_completeMessage.AppendFormat("{0}", Encoding.UTF8.GetString(bytes, 0, bytesRead));
} while (_parentMessageClient._tcpClient.GetStream().DataAvailable);
//if we haven't got the complete message, keep going until it's here
if (!_completeMessage.ToString().EndsWith("#END#") && brokenMessageCount < 100)
{
brokenMessageCount++;
continue;
}
brokenMessageCount = 0;
string[] messages = _completeMessage.ToString().Split(new string[] { "#END#" }, StringSplitOptions.None);
_completeMessage.Clear();
foreach (string msg in messages)
{
if (String.IsNullOrEmpty(msg.Trim()))
{
continue;
}
Message message = Message.StringToMessage(msg);
#if DEBUG
EventLog.Debug("MessageClient.cs " + System.Reflection.MethodBase.GetCurrentMethod().Name);
#endif
//have we stopped running?
if (!_parentMessageClient.IsRunning)
{
return(false);
}
if (MessageReceived != null && message != null)
{
switch (message.Type)
{
case MessageType.Command:
//some command messages are handled internally
switch (message.Title)
{
case "NEWCLIENTID":
_parentMessageClient.ClientID = message.Contents;
_parentMessageClient.RaiseClientIDChanged();
break;
case "SERVERSTOPPING":
_parentMessageClient.StopListening();
break;
case "LOGIN_REQUIRED":
string loginDetails = _parentMessageClient.RaiseLoginRequired(message.Contents);
_parentMessageClient.sendMessage(new Message("LOGIN", loginDetails, MessageType.Command));
break;
case "LOGIN_FAILED":
_parentMessageClient.StopListening();
_parentMessageClient.RaiseLoginFailed();
break;
case "LOGGED_IN":
_parentMessageClient.RaiseLoggedIn();
break;
case "TIMEOUT":
_parentMessageClient.TimeOut = true;
break;
case "CONNECTION_REFUSED":
_parentMessageClient.RaiseConnectionRefused();
break;
default: //not an internal message process as normal
message.SetClientID(_parentMessageClient.ClientID);
MessageReceived(this, message);
break;
}
break;
case MessageType.File:
string newFileName = _parentMessageClient.RaiseFileReceive(message.Title);
//FileTransfer transfer = new FileTransfer();
//transfer.FileReceived += RaiseFileReceived;
//transfer.ProcessClientFiles(this, message);
byte[] rebin = Convert.FromBase64String(message.Contents);
using (FileStream fs = new FileStream(newFileName, FileMode.Create))
{
using (BinaryWriter bw = new BinaryWriter(fs))
bw.Write(rebin);
}
_parentMessageClient.RaiseFileReceived(this, new TransferFileEventArgs(newFileName));
MessageReceived(this, message);
continue;
default:
// any other message forward onto event handler
message.SetClientID(_parentMessageClient.ClientID);
MessageReceived(this, message);
break;
}
}
}
}
}
catch
#if DEBUG
(ObjectDisposedException errDisposed)
#else
(ObjectDisposedException)
#endif
{
#if DEBUG
EventLog.Debug(errDisposed);
EventLog.Debug("MessageClient.cs ObjectDisposedException " +
System.Reflection.MethodBase.GetCurrentMethod().Name);
#endif
return(false);
}
catch (Exception err)
{
#if DEBUG
EventLog.Debug(err);
EventLog.Debug("MessageClient.cs Exception " +
System.Reflection.MethodBase.GetCurrentMethod().Name);
#endif
if (!_parentMessageClient.HandleClientException(err))
{
throw;
}
}
return(!HasCancelled());
}
