public IHttpActionResult VerifyFacebookWebhookRegistration(VerificationMessage msg)
{
if (msg.VerifyToken == "fr8facebookeventverification")
{
return(Ok(msg.Challenge));
}
return(Ok("Unknown verification call"));
}
public IVerificationMessage Convert(VerificationMessage verificationMessage)
{
using (var convertedMessage = DomainLocator.GetVerificationMessage())
{
convertedMessage.Object.MessageContent = verificationMessage.MessageContent;
convertedMessage.Object.Status = (BO.VerificationStatus)verificationMessage.Status;
return(convertedMessage.Object);
}
}
public VerificationMessage Convert(IVerificationMessage verificationMessageBO)
{
var verificationMessage = new VerificationMessage
{
MessageContent = verificationMessageBO.MessageContent,
Status = (WEB.VerificationStatus)verificationMessageBO.Status
};
return(verificationMessage);
}
private byte[] ComputeHash(ProfileMessage profileMessage, OmniAgreementPublicKey agreementPublicKey, HashAlgorithmType hashAlgorithm)
{
var verificationMessage = new VerificationMessage(profileMessage, agreementPublicKey);
if (hashAlgorithm == HashAlgorithmType.Sha2_256)
{
using var bytesPipe = new BytesPipe();
verificationMessage.Export(bytesPipe.Writer, _bytesPool);
return(Sha2_256.ComputeHash(bytesPipe.Reader.GetSequence()));
}
throw new NotSupportedException(nameof(hashAlgorithm));
}
public HttpResponseMessage ConfirmSubscription(VerificationMessage msg)
{
HttpClient client = new HttpClient();
HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.OK);
if (msg.VerifyToken == "fr8instagrameventverification")
{
response.Content = new StringContent(msg.Challenge, Encoding.UTF8, "application/json");
}
else
{
response.Content = new StringContent("Unknown verification call", Encoding.UTF8, "application/json");
}
return(response);
}
private bool Handshake(BinaryReader reader, BinaryWriter writer)
{
IMessage toServer = new VerificationMessage(_connection.RemoteAccessKey);
byte[] introBytes = toServer.ToBytes();
writer.Write(introBytes);
//get server response
VerificationMessage serverIntroResponse = MessageFactory.FromStream(reader) as VerificationMessage;
if (serverIntroResponse.Response == NetworkResponse.Valid && serverIntroResponse.Key == _connection.LocalAccessKey)
{
return(true);
}
return(false);
}
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);
}
public async Task InvokeVerificationMessageAsync(VerificationProcess process, SocketMessage msg) => await VerificationMessage.Invoke(process, msg).ConfigureAwait(false);
