public Task <Message> CreateMessageAsync(HttpContext http, BindingContext binding)
{
var encoder = GetMessageEncoderFactory(binding).Encoder;
var request = http.Request;
var message = null as Message;
if (request.ContentLength != null && request.ContentLength > 0)
{
message = encoder.ReadMessage(request.Body, int.MaxValue);
}
else
{
message = new NullMessage();
}
if (message.Headers.To == null)
{
message.Headers.To = request.GetRequestUri();
}
if (message.Properties.Via == null)
{
message.Properties.Via = request.GetRequestUri();
}
if (message.Headers.Action == null)
{
message.Headers.Action = request.Headers["SOAPAction"].Select(s => s.Trim('"')).FirstOrDefault();
}
return(Task.FromResult(message));
}
private async Task SendMessage(CancellationToken token, VerifiedMessage message, UnidentifiedAccessPair?unidentifiedAccessPair)
{
byte[] nullMessageBody = new DataMessage()
{
Body = Base64.EncodeBytes(Util.GetRandomLengthBytes(140))
}.ToByteArray();
NullMessage nullMessage = new NullMessage()
{
Padding = ByteString.CopyFrom(nullMessageBody)
};
byte[] content = new Content()
{
NullMessage = nullMessage
}.ToByteArray();
SendMessageResult result = await SendMessage(token, new SignalServiceAddress(message.Destination), unidentifiedAccessPair?.TargetUnidentifiedAccess, message.Timestamp, content);
if (result.Success.NeedsSync)
{
byte[] syncMessage = CreateMultiDeviceVerifiedContent(message, nullMessage.ToByteArray());
await SendMessage(token, LocalAddress, unidentifiedAccessPair?.SelfUnidentifiedAccess, message.Timestamp, syncMessage);
}
}
private async Task SendMessage(CancellationToken token, VerifiedMessage message)
{
byte[] nullMessageBody = new DataMessage()
{
Body = Base64.EncodeBytes(Util.GetRandomLengthBytes(140))
}.ToByteArray();
NullMessage nullMessage = new NullMessage()
{
Padding = ByteString.CopyFrom(nullMessageBody)
};
byte[] content = new Content()
{
NullMessage = nullMessage
}.ToByteArray();
SendMessageResponse response = await SendMessage(token, new SignalServiceAddress(message.Destination), message.Timestamp, content, false);
if (response != null && response.NeedsSync)
{
byte[] syncMessage = CreateMultiDeviceVerifiedContent(message, nullMessage.ToByteArray());
await SendMessage(token, localAddress, message.Timestamp, syncMessage, false);
}
}
public void JoinRoom(GameClientPeer peer, string userName)
{
if (!userNames.Contains(userName))
{
return;
}
userNames.Remove(userName);
RoomClient client = new RoomClient();
client.peer = peer;
client.userNamae = userName;
roomClients.Add(client);
if (userNames.Count <= 0 && maxClient == roomClients.Count)
{
for (int i = 0; i < roomClients.Count; ++i)
{
RoomClient roomClient = roomClients[i];
NullMessage message = new NullMessage();
roomClient.peer.SendEvent(OperationCode.JoinRoom, message);
}
}
}
private void setChain()
{
Chain = new ErrorMessageLogging();
WarningMessageLogging Chain2 = new WarningMessageLogging();
InfoMessageLogging Chain3 = new InfoMessageLogging();
NullMessage Chain4 = new NullMessage();
Chain.setNextChain(Chain2);
Chain2.setNextChain(Chain3);
Chain3.setNextChain(Chain4);
}
private void Update()
{
if (Time != null)
{
Time.Update();
}
if (!handshake)
{
OperationResponse response = new OperationResponse((byte)OperationCode.HandShake);
NullMessage nullMsg = new NullMessage();
PackageHelper.SetData(response, PackageHelper.Serialize <NullMessage>(nullMsg));
this.SendOperationResponse(response, new SendParameters());
handshake = true;
}
}
public void AddSRM()
{
IMessage msg = new NullMessage();
SRMFactory factory = SRMFactory.GetInstance();
models = new List <SRMModel>();
if (SRMList.IsBasic)
{
models.Add(new EMSRMModel(factory.CreateSRM(OriginalSRMModel.EXP), msg));
models.Add(new EMSRMModel(factory.CreateSRM(OriginalSRMModel.GAMMA), msg));
models.Add(new EMSRMModel(factory.CreateSRM(OriginalSRMModel.PARETO), msg));
models.Add(new EMSRMModel(factory.CreateSRM(OriginalSRMModel.TNORM), msg));
models.Add(new EMSRMModel(factory.CreateSRM(OriginalSRMModel.LNORM), msg));
models.Add(new EMSRMModel(factory.CreateSRM(OriginalSRMModel.TLOGIS), msg));
models.Add(new EMSRMModel(factory.CreateSRM(OriginalSRMModel.LLOGIS), msg));
models.Add(new EMSRMModel(factory.CreateSRM(OriginalSRMModel.TXVMAX), msg));
models.Add(new EMSRMModel(factory.CreateSRM(OriginalSRMModel.TXVMIN), msg));
models.Add(new EMSRMModel(factory.CreateSRM(OriginalSRMModel.LXVMAX), msg));
models.Add(new EMSRMModel(factory.CreateSRM(OriginalSRMModel.LXVMIN), msg));
}
if (SRMList.IsCPH)
{
foreach (int k in SRMList.CPH)
{
models.Add(new EMSRMModel(factory.CreateCPHSRM(k), msg));
}
}
if (SRMList.IsHEr)
{
foreach (int k in SRMList.HEr)
{
models.Add(new HErSRMModel(factory.CreateHErSRM(k), msg));
}
}
NotifyModel();
}
protected IMessage ProcessData(Connection connection, BinaryReader reader)
{
IMessage result = new NullMessage();
IMessage currentMessage = MessageFactory.FromStream(reader);
switch (currentMessage.MessageId)
{
case MessageIdentifier.FileChanged:
{
if (ClientHasBeenValidated == true)
{
FileChangedMessage message = currentMessage as FileChangedMessage;
string filePath = Path.Join(connection.LocalSyncPath, message.FileData.Path);
FileInfo localFile = new FileInfo(filePath);
//we only need the file data when a file on the client was changed and that file is newer than our local copy
if (message.FileData.OperationType == WatcherChangeTypes.Changed || message.FileData.OperationType == WatcherChangeTypes.Created)
{
if (localFile.Exists == false || localFile.LastWriteTimeUtc < message.FileData.LastWriteTimeUtc)
{
FileMetaData = message.FileData;
result = new FileRequestMessage(message.FileData);
}
else
{
result = new NullMessage();
}
}
else
{
if (message.FileData.OperationType == WatcherChangeTypes.Renamed)
{
string oldFilePath = Path.Join(connection.LocalSyncPath, message.FileData.OldPath);
if (File.Exists(oldFilePath))
{
File.Move(oldFilePath, filePath);
}
}
if (message.FileData.OperationType == WatcherChangeTypes.Deleted)
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
}
result = new NullMessage();
}
}
break;
}
case MessageIdentifier.FileData:
{
if (ClientHasBeenValidated == true && FileMetaData != null)
{
FileDataMessage message = currentMessage as FileDataMessage;
message.FilePath = Path.Join(connection.LocalSyncPath, FileMetaData.Path);
ReceiveBegin(this, new ServerEventArgs()
{
FileData = FileMetaData, FullLocalPath = message.FilePath
});
try
{
message.FromBinaryStream(reader);
//change last write to match client file
File.SetLastWriteTimeUtc(message.FilePath, FileMetaData.LastWriteTimeUtc);
File.SetLastAccessTimeUtc(message.FilePath, FileMetaData.LastAccessTimeUtc);
File.SetCreationTimeUtc(message.FilePath, FileMetaData.CreateTimeUtc);
ReceiveEnd(this, new ServerEventArgs()
{
FileData = FileMetaData, FullLocalPath = message.FilePath, Success = true
});
}
catch (Exception ex)
{
Logger.Log(LogPriority.High, "Server #{0} error writing file: {1}", ServerId, message.FilePath);
ReceiveEnd(this, new ServerEventArgs()
{
FileData = FileMetaData, FullLocalPath = message.FilePath, Success = false
});
}
}
break;
}
case MessageIdentifier.Verification:
{
VerificationMessage message = currentMessage as VerificationMessage;
if (message != null)
{
if (message.Key == connection.LocalAccessKey)
{
result = new VerificationMessage(connection.RemoteAccessKey, NetworkResponse.Valid);
//store validation result for later use
ClientHasBeenValidated = true;
}
}
break;
}
}
return(result);
}
static NullMessage()
{
Instance = new NullMessage();
}
