internal void SetFlag(MetadataFlags flag, bool value)
{
Debug.Assert(
flag == MetadataFlags.Readonly ||
(flag & MetadataFlags.Readonly) != MetadataFlags.Readonly,
"SetFlag() invoked with Readonly and additional flags.");
var spinWait = new SpinWait();
do
{
var oldFlags = _flags;
var newFlags = value ? (oldFlags | (int)flag) : (oldFlags & ~(int)flag);
if (((MetadataFlags)oldFlags & MetadataFlags.Readonly) == MetadataFlags.Readonly)
{
if ((flag & MetadataFlags.Readonly) == MetadataFlags.Readonly)
{
return;
}
throw new InvalidOperationException(Strings.OperationOnReadOnlyItem);
}
if (oldFlags == Interlocked.CompareExchange(ref _flags, newFlags, oldFlags))
{
return;
}
spinWait.SpinOnce();
}while (true);
}
public Metadata RetrieveMetadata(MetadataFlags flags)
{
object[] results = this.Invoke("RetrieveMetadata", new object[] {
flags
});
return((Metadata)(results[0]));
}
internal void SetFlag(MetadataFlags flag, bool value)
{
if ((flag & MetadataFlags.Readonly) == MetadataFlags.Readonly)
{
Debug.Assert(System.Convert.ToInt32(flag & ~MetadataFlags.Readonly, CultureInfo.InvariantCulture) == 0,
"SetFlag() invoked with Readonly and additional flags.");
}
lock (_flagsLock)
{
// an attempt to set the ReadOnly flag on a MetadataItem that is already read-only
// is a no-op
//
if (IsReadOnly && ((flag & MetadataFlags.Readonly) == MetadataFlags.Readonly))
{
return;
}
Util.ThrowIfReadOnly(this);
if (value)
{
_flags |= flag;
}
else
{
_flags &= ~flag;
}
}
}
protected static IColumnSpec[] ReadResultMetadata(IFrameReader frameReader)
{
Stream stream = frameReader.ReadOnlyStream;
MetadataFlags flags = (MetadataFlags)stream.ReadInt();
int colCount = stream.ReadInt();
bool globalTablesSpec = 0 != (flags & MetadataFlags.GlobalTablesSpec);
bool hasMorePages = 0 != (flags & MetadataFlags.HasMorePages);
bool noMetadata = 0 != (flags & MetadataFlags.NoMetadata);
string keyspace = null;
string table = null;
if (globalTablesSpec && !noMetadata)
{
keyspace = stream.ReadString();
table = stream.ReadString();
}
if (hasMorePages)
{
var pagingState = stream.ReadBytesArray();
}
if (noMetadata)
{
return(null);
}
var columnSpecs = ReadColumnSpecs(colCount, keyspace, table, globalTablesSpec, stream);
return(columnSpecs);
}
private static string ReadComment(Core.Utility.BinaryReader reader, MetadataFlags flags, ref int bytesRead)
{
string comment = null;
if (flags.HasFlag(MetadataFlags.Comment))
{
comment = ReadNullTerminatedString(reader, ref bytesRead);
}
return(comment);
}
/// <remarks/>
public void RetrieveMetadataAsync(MetadataFlags flags, object userState)
{
if ((this.RetrieveMetadataOperationCompleted == null))
{
this.RetrieveMetadataOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRetrieveMetadataOperationCompleted);
}
this.InvokeAsync("RetrieveMetadata", new object[] {
flags
}, this.RetrieveMetadataOperationCompleted, userState);
}
[FriendAccessAllowed] // Built into Base, also used by Core and Framework.
internal void WriteFlag(MetadataFlags id, bool value)
{
if (value)
{
_flags |= id;
}
else
{
_flags &= (~id);
}
}
private static ushort ReadCrc16(Core.Utility.BinaryReader reader, MetadataFlags flags, ref int bytesRead)
{
ushort crc16 = 0;
if (flags.HasFlag(MetadataFlags.Crc16Present))
{
crc16 = reader.ReadUInt16();
bytesRead += sizeof(ushort);
}
return(crc16);
}
protected static IColumnSpec[] ReadColumnSpec(IFrameReader frameReader)
{
Stream stream = frameReader.ReadOnlyStream;
MetadataFlags flags = (MetadataFlags)stream.ReadInt();
bool globalTablesSpec = 0 != (flags & MetadataFlags.GlobalTablesSpec);
int colCount = stream.ReadInt();
string keyspace = null;
string table = null;
if (globalTablesSpec)
{
keyspace = stream.ReadString();
table = stream.ReadString();
}
IColumnSpec[] columnSpecs = new IColumnSpec[colCount];
for (int colIdx = 0; colIdx < colCount; ++colIdx)
{
string colKeyspace = keyspace;
string colTable = table;
if (!globalTablesSpec)
{
colKeyspace = stream.ReadString();
colTable = stream.ReadString();
}
string colName = stream.ReadString();
ColumnType colType = (ColumnType)stream.ReadUShort();
string colCustom = null;
ColumnType colKeyType = ColumnType.Custom;
ColumnType colValueType = ColumnType.Custom;
switch (colType)
{
case ColumnType.Custom:
colCustom = stream.ReadString();
break;
case ColumnType.List:
case ColumnType.Set:
colValueType = (ColumnType)stream.ReadUShort();
break;
case ColumnType.Map:
colKeyType = (ColumnType)stream.ReadUShort();
colValueType = (ColumnType)stream.ReadUShort();
break;
}
columnSpecs[colIdx] = new ColumnSpec(colIdx, colKeyspace, colTable, colName, colType, colCustom, colKeyType, colValueType);
}
return(columnSpecs);
}
private static string ReadFileName(Core.Utility.BinaryReader reader, MetadataFlags flags, ref int bytesRead)
{
string name = null;
if (flags.HasFlag(MetadataFlags.FileName))
{
name = ReadNullTerminatedString(reader, ref bytesRead);
}
else
{
name = GetDefaultEntryName(reader.BaseStream);
}
return(name);
}
private static SubfieldId ReadExtraFields(Core.Utility.BinaryReader reader, MetadataFlags flags, ref int bytesRead)
{
var subfieldIdentifier = SubfieldId.None;
if (flags.HasFlag(MetadataFlags.ExtraFieldsPresent))
{
subfieldIdentifier = (SubfieldId)reader.ReadUInt16();
bytesRead += sizeof(SubfieldId);
var subfieldDataLength = reader.ReadUInt16(); // little-endian
bytesRead += sizeof(ushort);
reader.BaseStream.Seek(subfieldDataLength, SeekOrigin.Current); // just skip
}
return(subfieldIdentifier);
}
public void Save(string newFilename, MetadataFlags mdFlags, IModuleWriterListener writerListener)
{
if (module.IsILOnly)
{
var writerOptions = new ModuleWriterOptions(module);
writerOptions.WriterEvent += (s, e) => writerListener?.OnWriterEvent(e.Writer, e.Event);
writerOptions.MetadataOptions.Flags |= mdFlags;
writerOptions.Logger = Logger.Instance;
module.Write(newFilename, writerOptions);
}
else
{
var writerOptions = new NativeModuleWriterOptions(module, optimizeImageSize: true);
writerOptions.WriterEvent += (s, e) => writerListener?.OnWriterEvent(e.Writer, e.Event);
writerOptions.MetadataOptions.Flags |= mdFlags;
writerOptions.Logger = Logger.Instance;
writerOptions.KeepExtraPEData = true;
writerOptions.KeepWin32Resources = true;
module.NativeWrite(newFilename, writerOptions);
}
}
public void Bytes_WhenFinIsTrue_ReturnsExpectedResult()
{
// arrange
// 00000000 00000000 00000000 10000000
BitArray ba = new BitArray(
new bool[] {
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
false, false, false, false, false, false, false, false,
true, false, false, false, false, false, false, false
});
byte[] expected = new byte[4];
ba.CopyTo(expected, 0);
var expectedBytesString = HelperMethods.ToBitString(expected);
// act
var flags = new MetadataFlags();
flags.Fin = true;
// assert
Assert.AreEqual(expectedBytesString, HelperMethods.ToBitString(flags.Bytes));
}
internal MetadataItem(MetadataFlags flags)
{
_flags = flags;
_annotations = new AnnotationCollection(this);
}
private bool IsModified(MetadataFlags id) { return (id & _flags) != 0; }
private void prepareReplace()
{
MetadataFlags AllFlags = MetadataFlags.PreserveAll | MetadataFlags.KeepOldMaxStack
| MetadataFlags.AlwaysCreateGuidHeap | MetadataFlags.RoslynSortInterfaceImpl;
try
{
bool isBlockGood = checkBlocks();
if (!isBlockGood)
{
return;
}
if (!module.IsILOnly)
{
writeStatus("Info: The Assembly maybe contains unmanaged code");
Thread.Sleep(2000);
}
writeStatus("Processing: " + moduleName);
ReplaceInstructions();
string newName = string.Format("{0}_ILR{1}",
Path.GetFileNameWithoutExtension(moduleName),
Path.GetExtension(moduleName));
if (ReplacedBlocks > 0)
{
if (module.IsILOnly)
{
var ManagedOptions = new ModuleWriterOptions(module);
if (PreserveAllFlags)
{
ManagedOptions.MetadataOptions.Flags = AllFlags;
}
module.Write(Path.GetDirectoryName(moduleName) + "\\" + newName, ManagedOptions);
}
else
{
var UnmanagedOptions = new NativeModuleWriterOptions(module, true);
if (PreserveAllFlags)
{
UnmanagedOptions.MetadataOptions.Flags = AllFlags;
}
module.NativeWrite(newName, UnmanagedOptions);
}
if (ShowLogs)
{
writeStatus(string.Format(
"Done: Saved as {0} || Replaced {1} Blocks Instructions in {2} Methods",
newName, ReplacedBlocks, EditedMethodsCount));
showFormLog(logInfo);
}
}
else
{
writeStatus("Info: No Block Instructions Replaced!");
}
//MessageBox.Show("File Saved as:\r\n" + newName, "Replaces Done",
// MessageBoxButtons.OK, MessageBoxIcon.Information);
if (module != null)
{
module.Dispose();
}
enableControl(true);
isRunning = false;
}
catch (Exception ex)
{
if (module != null)
{
module.Dispose();
}
isRunning = false;
if (ex.Message.Contains("Error calculating max stack"))
{
writeStatus("Error calculating max stack value..., try Check \"Preserve All Metadata\"");
}
else
{
if (ex.Message.Length > 100)
{
showFormLog(ex.Message);
}
else
{
writeStatus("Error: " + ex.Message.Trim());
}
}
enableControl(true);
}
}
internal MappingBase(MetadataFlags flags)
: base(flags)
{
}
internal bool GetFlag(MetadataFlags flag)
{
return(flag == (_flags & flag));
}
internal MetadataItem(MetadataFlags flags)
{
_flags = flags;
}
internal MetadataItem(MetadataFlags flags)
{
_flags = flags;
}
internal void SetDataSpace(DataSpace space)
{
_flags = (_flags & ~MetadataFlags.DataSpace) | (MetadataFlags.DataSpace & Convert(space));
}
internal void SetDataSpace(DataSpace space)
{
_flags = (_flags & ~MetadataFlags.DataSpace) | (MetadataFlags.DataSpace & Convert(space));
}
internal void SetParameterMode(ParameterMode mode)
{
_flags = (_flags & ~MetadataFlags.ParameterMode) | (MetadataFlags.ParameterMode & Convert(mode));
}
internal static extern byte tsk_fs_meta_walk(FileSystemHandle fs, long start_address, long end_address, MetadataFlags walk_flags, MetaWalkDelegate callback, IntPtr a_ptr);
[FriendAccessAllowed] // Built into Base, also used by Core and Framework.
internal bool ReadFlag(MetadataFlags id)
{
return((id & _flags) != 0);
}
internal Map(MetadataFlags flags)
: base(flags)
{
}
[FriendAccessAllowed] // Built into Base, also used by Core and Framework.
internal void WriteFlag(MetadataFlags id, bool value)
{
if (value)
{
_flags |= id;
}
else
{
_flags &= (~id);
}
}
internal void SetModified(MetadataFlags id) { WriteFlag(id, true); }
[FriendAccessAllowed] // Built into Base, also used by Core and Framework.
internal bool ReadFlag(MetadataFlags id) { return (id & _flags) != 0; }
/// <summary>
/// Walks metadata structures of the file system
/// </summary>
/// <param name="mwd">Meta Walk Delegate</param>
/// <param name="flags">Meta data Flags</param>
/// <returns>returns a byte value</returns>
public bool WalkMetadata(MetaWalkDelegate mwd, MetadataFlags flags = MetadataFlags.Allocated)
{
var ret = NativeMethods.tsk_fs_meta_walk(this._handle, this._struct.first_inum, this._struct.last_inum, flags, mwd, IntPtr.Zero);
return(ret == 0);
}
internal void SetParameterMode(ParameterMode mode)
{
_flags = (_flags & ~MetadataFlags.ParameterMode) | (MetadataFlags.ParameterMode & Convert(mode));
}
internal void SetModified(MetadataFlags id)
{
WriteFlag(id, true);
}
private bool IsModified(MetadataFlags id)
{
return((id & _flags) != 0);
}
private void SetModified(MetadataFlags id)
{
_flags |= id;
}
internal GlobalItem(MetadataFlags flags)
: base(flags)
{
}
internal MappingBase(MetadataFlags flags)
: base(flags)
{
}
internal GlobalItem(MetadataFlags flags)
: base(flags)
{
}
private void SetModified(MetadataFlags id) { _flags |= id; }
internal bool IsModified(MetadataFlags id)
{
return(ReadFlag(id));
}
internal void SetFlag(MetadataFlags flag, bool value)
{
Debug.Assert(
flag == MetadataFlags.Readonly
|| (flag & MetadataFlags.Readonly) != MetadataFlags.Readonly,
"SetFlag() invoked with Readonly and additional flags.");
var spinWait = new SpinWait();
do
{
var oldFlags = _flags;
var newFlags = value ? (oldFlags | (int)flag) : (oldFlags & ~(int)flag);
if (((MetadataFlags)oldFlags & MetadataFlags.Readonly) == MetadataFlags.Readonly)
{
if ((flag & MetadataFlags.Readonly) == MetadataFlags.Readonly)
{
return;
}
throw new InvalidOperationException(Strings.OperationOnReadOnlyItem);
}
if (oldFlags == Interlocked.CompareExchange(ref _flags, newFlags, oldFlags))
{
return;
}
spinWait.SpinOnce();
}
while (true);
}
internal bool GetFlag(MetadataFlags flag)
{
return (flag == (_flags & flag));
}
/// <remarks/>
public void RetrieveMetadataAsync(MetadataFlags flags)
{
this.RetrieveMetadataAsync(flags, null);
}
internal bool IsModified(MetadataFlags id) { return ReadFlag(id); }
internal void SetFlag(MetadataFlags flag, bool value)
{
if ((flag & MetadataFlags.Readonly)
== MetadataFlags.Readonly)
{
Debug.Assert(
System.Convert.ToInt32(flag & ~MetadataFlags.Readonly, CultureInfo.InvariantCulture) == 0,
"SetFlag() invoked with Readonly and additional flags.");
}
lock (_flagsLock)
{
// an attempt to set the ReadOnly flag on a MetadataItem that is already read-only
// is a no-op
//
if (IsReadOnly && ((flag & MetadataFlags.Readonly) == MetadataFlags.Readonly))
{
return;
}
Util.ThrowIfReadOnly(this);
if (value)
{
_flags |= flag;
}
else
{
_flags &= ~flag;
}
}
}
