/// <summary>
/// Locks, reads the usage count XML serialized file and decrypts it. If no data found, the lock is released
/// </summary>
/// <returns></returns>
public bool Read()
{
try
{
try
{
_memoryStream = Locker.ReadDecryptFile(ref _fileStream, _usageCountPath1, _decryptionPassword, false);
}
catch (InvalidOperationException) // other exception will be thrown to the caller
{
_memoryStream = Locker.ReadDecryptFile(ref _fileStream, _usageCountPath2, _decryptionPassword, false);
}
}
catch (Exception ex)
{
Locker.ClearFileStream(ref _fileStream);
throw ex;
}
if (_memoryStream == null)
{
Locker.ClearFileStream(ref _fileStream);
return(false);
}
return(true);
}
private void ReleaseAggregatedFiles()
{
Locker.ClearFileStream(ref _dateImpressionsPerAssetStream);
Locker.ClearFileStream(ref _dateClicksPerAssetStream);
Locker.ClearFileStream(ref _advertChannelImpressionProportionsStream);
Locker.ClearFileStream(ref _advertChannelClickProportionsStream);
}
/// <summary>
/// Locks and loads Aggregated file if it exists.
/// </summary>
/// <param name="path">Path to the aggregate file</param>
/// <param name="fs">FileStream reference</param>
/// <param name="decryptionPassword">password to use to decrypt the file</param>
/// <returns>a string with the flat aggragated logs if there are any or an empty string if there aren't</returns>
public static string LoadAggregatedLogFile(string path, ref FileStream fs, string decryptionPassword)
{
string existingLogs = "";
MemoryStream memoryStream = Locker.ReadDecryptFile(ref fs, path, decryptionPassword, false, true);
if (memoryStream != null)
{
try
{
existingLogs = GetExistingString(memoryStream);
}
catch (Exception ex)
{
Locker.ClearFileStream(ref fs);
throw ex;
}
finally
{
memoryStream.Close();
memoryStream.Dispose();
}
}
return(existingLogs);
}
private void ReleaseRawFiles()
{
Locker.ClearFileStream(ref _contentClickLogStream);
Locker.ClearFileStream(ref _advertClickLogStream);
Locker.ClearFileStream(ref _contentImpressionLogStream);
Locker.ClearFileStream(ref _advertImpressionLogStream);
}
private static Queue <string> ReadExistingLogs(ref FileStream fileStream,
string path1, string path2, string cryptPassword)
{
MemoryStream memoryStream = null;
try
{
try
{
memoryStream = Locker.ReadDecryptFile(ref fileStream, path1, cryptPassword, false, true);
}
catch (InvalidOperationException)
{
memoryStream = Locker.ReadDecryptFile(ref fileStream, path1, cryptPassword, false, true);
}
}
catch (Exception ex)
{
Locker.ClearFileStream(ref fileStream);
throw ex;
}
Queue <string> existingRawLogs = new Queue <string>();
// if memory stream is not null (i.e. log files already exist)
if (memoryStream != null)
{
StreamReader sr = new StreamReader(memoryStream);
while (sr.Peek() >= 0)
{
try
{
existingRawLogs.Enqueue(sr.ReadLine());
}
catch (Exception ex)
{
Locker.ClearFileStream(ref fileStream);
sr.Close();
sr.Dispose();
memoryStream.Close();
memoryStream.Dispose();
throw ex;
}
}
sr.Close();
sr.Dispose();
memoryStream.Close();
memoryStream.Dispose();
}
return(existingRawLogs);
}
private static string ReadExistingLogsString(ref FileStream fileStream,
string path1, string path2, string cryptPassword)
{
MemoryStream memoryStream = null;
try
{
try
{
memoryStream = Locker.ReadDecryptFile(ref fileStream, path1, cryptPassword, false, true);
}
catch (InvalidOperationException)
{
memoryStream = Locker.ReadDecryptFile(ref fileStream, path1, cryptPassword, false, true);
}
}
catch (Exception ex)
{
Locker.ClearFileStream(ref fileStream);
throw ex;
}
string decryptedLogs = "";
// if memory stream is not null (i.e. log files already exist)
if (memoryStream != null)
{
StreamReader sr = new StreamReader(memoryStream);
try
{
decryptedLogs = sr.ReadToEnd();
}
catch (Exception ex)
{
Locker.ClearFileStream(ref fileStream);
sr.Close();
sr.Dispose();
memoryStream.Close();
memoryStream.Dispose();
throw ex;
}
sr.Close();
sr.Dispose();
memoryStream.Close();
memoryStream.Dispose();
}
return(decryptedLogs);
}
private void btnDecrypt_Click(object sender, EventArgs e)
{
FileStream fileStream = null;
string existingLogs = ReadExistingLogs(ref fileStream, @"C:\OxigenData\SettingsData\ss_ad_c_1.dat",
@"C:\OxigenData\SettingsData\ss_ad_c_2.dat", "password");
Locker.ClearFileStream(ref fileStream);
MessageBox.Show(existingLogs);
}
// Uploads advert specific aggregated files to relay server. If an upload fails, the lock on the read file is released
private void UploadAdvertSpecificAggregatedFiles()
{
_bAdvertChannelClickProportionsUploaded = TryLockAndUploadStringFromFile(ref _advertChannelClickProportionsStream, _advertChannelClickProportionsPath, "", -1L);
if (!_bAdvertChannelClickProportionsUploaded)
{
Locker.ClearFileStream(ref _advertChannelClickProportionsStream);
}
_bAdvertChannelImpressionProportionsUploaded = TryLockAndUploadStringFromFile(ref _advertChannelImpressionProportionsStream, _advertChannelImpressionProportionsPath, "", -1L);
if (!_bAdvertChannelImpressionProportionsUploaded)
{
Locker.ClearFileStream(ref _advertChannelImpressionProportionsStream);
}
}
// Uploads non advert specific aggregated files to relay server. If an upload fails, the lock on the read file is released
private void UploadNonAdvertSpecificAggregatedFiles(long channelID)
{
_bDateClicksPerAssetUploaded = TryLockAndUploadStringFromFile(ref _dateClicksPerAssetStream, _dateClicksPerAssetPath, "", channelID);
if (!_bDateClicksPerAssetUploaded)
{
Locker.ClearFileStream(ref _dateClicksPerAssetStream);
}
_bDateImpressionsPerAssetUploaded = TryLockAndUploadStringFromFile(ref _dateImpressionsPerAssetStream, _dateImpressionsPerAssetPath, "", channelID);
if (!_bDateImpressionsPerAssetUploaded)
{
Locker.ClearFileStream(ref _dateImpressionsPerAssetStream);
}
}
private void TryUploadTruncateReleaseUsageCountFile(bool bRawLogsExist)
{
if (!bRawLogsExist)
{
return;
}
bool bUsageCountUploaded = TryLockAndUploadStringFromFile(ref _usageCountStream, _usageCountLogsPath1, _usageCountLogsPath2, -2L);
if (bUsageCountUploaded)
{
TryTruncate(_usageCountStream);
}
Locker.ClearFileStream(ref _usageCountStream);
}
/// <summary>
/// Decrypts (if encrypted) and deserializes an object from XML. Unlocks the file after operation.
/// Operation is expected to succeed, i.e. use this call for important serialized XML objects i.e. non-log files
/// </summary>
/// <param name="type">expected type of the deserialized object</param>
/// <param name="path">The path to load the xml file from</param>
/// <param name="password">password to decrypt the file</param>
/// <returns>the object to deserialize</returns>
/// <exception cref="SerializationException">thrown when an error occurs during the object's deserializaton</exception>
/// <exception cref="FileNotFoundException">thrown if XML serialized file not found</exception>
/// <exception cref="InvalidOperationException">thrown by XmlSerializer.Deserialize</exception>
/// <exception cref="IOException">thrown when there is an error during read</exception>
/// <exception cref="DirectoryNotFoundException">thrown when the directory is not found</exception>
/// <exception cref="CryptographicException">thrown when encrypted file is corrupted</exception>
public static object Deserialize(Type type, string path, string password)
{
FileStream fileStream = null;
object obj = null;
try
{
obj = Deserialize(type, path, password, ref fileStream, true, false);
}
finally
{
Locker.ClearFileStream(ref fileStream);
}
return(obj);
}
private void Save()
{
FileStream fs = new FileStream(Environment.GetFolderPath(Environment.SpecialFolder.Desktop) + "\\EncryptedText.dat", FileMode.Create);
try
{
Locker.WriteEncryptString(ref fs, textBox1.Text, "password");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
finally
{
Locker.ClearFileStream(ref fs);
}
MessageBox.Show("Encryption done. New file is on desktop.");
}
private void DecryptShow(string fileName)
{
FileStream fs = null;
string existingLogs = "";
try
{
existingLogs = ReadExistingLogsString(ref fs, fileName, fileName, "password");
}
catch (Exception eX)
{
textBox1.Text = eX.ToString();
return;
}
finally
{
Locker.ClearFileStream(ref fs);
}
textBox1.Text = existingLogs;
}
// this method locks the deserialized file and is the overload that should be used
// in release builds
private static object Deserialize(Type type, ref FileStream fileStream,
XmlSerializer xmlSerializer, string path, string password, bool bCritical, bool bKeepLock)
{
object obj = null;
MemoryStream decryptedDataStream = Locker.ReadDecryptFile(ref fileStream, path, password, bCritical, bKeepLock);
// if it is likely that object may not exist (i.e. non-important serialized object), do not throw an error but create a blank instance
if (decryptedDataStream == null && !bCritical)
{
obj = Activator.CreateInstance(type);
return(obj);
}
TextReader reader = new StreamReader(decryptedDataStream, Encoding.ASCII);
try
{
obj = xmlSerializer.Deserialize(reader);
}
catch (Exception ex) // this can happen if deserialized object obj is not of Type type
{
Locker.ClearFileStream(ref fileStream);
throw new InvalidOperationException("Type mismatch between parameter type " + type.ToString() + " and type as described in XML serialized object", ex);
}
finally
{
reader.Close();
reader.Dispose();
decryptedDataStream.Close();
decryptedDataStream.Dispose();
}
return(obj);
}
/// <summary>
/// Opens and locks a log file and returns a string with the decrypted logs if they exist.
/// If they dont exist, an empty string is returned.
/// </summary>
/// <param name="fileStream">FileStream to read and lock a log file</param>
/// <param name="path1">Path of first file to try</param>
/// <param name="path2">Path of second file to try if first file is locked</param>
/// <param name="cryptPassword">password to use for encryption/decryption</param>
/// <returns>a string with the decrypted logs or an empty string if logs don't exist</returns>
/// <param name="logger">the Logger object to use when debugging exceptions</param>
private static Queue <string> ReadExistingLogs(ref FileStream fileStream,
string path1, string path2, string cryptPassword, Logger logger)
{
MemoryStream memoryStream = null;
try
{
try
{
memoryStream = Locker.ReadDecryptFile(ref fileStream, path1, cryptPassword, false, true);
logger.WriteMessage(DateTime.Now.ToString() + " successfully read existing log from path 1.");
}
catch (IOException ex)
{
logger.WriteError(ex);
memoryStream = Locker.ReadDecryptFile(ref fileStream, path1, cryptPassword, false, true);
logger.WriteMessage(DateTime.Now.ToString() + " successfully read existing log from path 2.");
}
}
catch (CryptographicException ex) // file will be truncate in the case of a CryptographicException
{
logger.WriteError(ex);
}
catch (Exception ex)
{
Locker.ClearFileStream(ref fileStream);
logger.WriteMessage(DateTime.Now.ToString() + " successfully unlocked file. Please see below for error.");
throw ex;
}
Queue <string> existingRawLogs = new Queue <string>();
// if memory stream is not null (i.e. log files already exist)
if (memoryStream != null)
{
StreamReader sr = new StreamReader(memoryStream);
logger.WriteMessage(DateTime.Now.ToString() + " successfully created stream reader.");
while (sr.Peek() >= 0)
{
try
{
existingRawLogs.Enqueue(sr.ReadLine());
}
catch (Exception ex)
{
Locker.ClearFileStream(ref fileStream);
logger.WriteMessage(DateTime.Now.ToString() + " successfully unlocked file. Please see below for error.");
sr.Close();
sr.Dispose();
logger.WriteMessage(DateTime.Now.ToString() + " successfully disposed of StreamReader.");
memoryStream.Close();
memoryStream.Dispose();
logger.WriteMessage(DateTime.Now.ToString() + " successfully disposed of MemoryStream.");
throw ex;
}
}
sr.Close();
sr.Dispose();
logger.WriteMessage(DateTime.Now.ToString() + " successfully disposed of StreamReader.");
memoryStream.Close();
memoryStream.Dispose();
logger.WriteMessage(DateTime.Now.ToString() + " successfully disposed of MemoryStream.");
}
return(existingRawLogs);
}
/// <summary>
/// Serializes an object to XML and encrypts it to a file that has been locked from a previous operation.
/// The lock is then released.
/// </summary>
/// <param name="obj">The object to serialise</param>
/// <param name="password">The encryption password</param>
/// <param name="fileStream">the FileStream that has a lock on the file to serialize to</param>
/// <exception cref="SerializationException">thrown when an error occurs during the object's serializaton</exception>
/// <exception cref="InvalidOperationException">thrown when there is a problem in serializaton</exception>
/// <exception cref="IOException">thrown when there is an error writing the file to disk</exception>
/// <exception cref="NullReferenceException">the object to serialize is null</exception>
public static void Serialize(object obj, string password, ref FileStream fileStream)
{
if (obj == null)
{
Locker.ClearFileStream(ref fileStream);
throw new NullReferenceException("object is null");
}
XmlSerializer xmlSerializer = new XmlSerializer(obj.GetType());
MemoryStream stream = new MemoryStream();
StreamWriter encodingWriter = new StreamWriter(stream, Encoding.ASCII);
try
{
xmlSerializer.Serialize(encodingWriter, obj);
}
catch (InvalidOperationException ex)
{
stream.Close();
stream.Dispose();
encodingWriter.Close();
encodingWriter.Dispose();
Locker.ClearFileStream(ref fileStream);
throw new InvalidOperationException("Error serializing object of type " + obj.GetType(), ex);
}
catch (Exception ex)
{
stream.Close();
stream.Dispose();
encodingWriter.Close();
encodingWriter.Dispose();
Locker.ClearFileStream(ref fileStream);
throw ex;
}
stream.Position = 0;
byte[] dataToEncrypt = new byte[stream.Length + (16 - stream.Length % 16)];
stream.Read(dataToEncrypt, 0, dataToEncrypt.Length);
stream.Close();
stream.Dispose();
encodingWriter.Close();
encodingWriter.Dispose();
// Encrypt
byte[] encryptedData = Cryptography.Encrypt(dataToEncrypt, password);
int noBytes = encryptedData.Length;
fileStream.SetLength(0);
try
{
fileStream.Write(encryptedData, 0, noBytes);
}
finally
{
Locker.ClearFileStream(ref fileStream);
}
}