public ResidentAttributeRecord(AttributeType type, string name, ushort id, bool indexed, AttributeFlags flags)
: base(type, name, id, flags)
{
_nonResidentFlag = 0;
_indexedFlag = (byte)(indexed ? 1 : 0);
_memoryBuffer = new SparseMemoryBuffer(1024);
}
public static AttributeFlags AttributeBreakdown(FileAttributes flags)
{
AttributeFlags attributes = new AttributeFlags();
if (flags.HasFlag(FileAttributes.Normal))
attributes.Normal = true;
if (flags.HasFlag(FileAttributes.Archive))
attributes.Archive = true;
if (flags.HasFlag(FileAttributes.Compressed))
attributes.Compressed = true;
if (flags.HasFlag(FileAttributes.Device))
attributes.Device = true;
if (flags.HasFlag(FileAttributes.Directory))
attributes.Directory = true;
if (flags.HasFlag(FileAttributes.Encrypted))
attributes.Encrypted = true;
if (flags.HasFlag(FileAttributes.Hidden))
attributes.Hidden = true;
if (flags.HasFlag(FileAttributes.IntegrityStream))
attributes.IntegrityStream = true;
if (flags.HasFlag(FileAttributes.NoScrubData))
attributes.NoScrubData = true;
if (flags.HasFlag(FileAttributes.NotContentIndexed))
attributes.NotContentIndexed = true;
if (flags.HasFlag(FileAttributes.Offline))
attributes.Offline = true;
if (flags.HasFlag(FileAttributes.ReadOnly))
attributes.ReadOnly = true;
if (flags.HasFlag(FileAttributes.ReparsePoint))
attributes.ReparsePoint = true;
if (flags.HasFlag(FileAttributes.SparseFile))
attributes.SparseFile = true;
if (flags.HasFlag(FileAttributes.System))
attributes.System = true;
if (flags.HasFlag(FileAttributes.Temporary))
attributes.Temporary = true;
return attributes;
}
/// <summary>
/// Creates a new attribute at a fixed cluster.
/// </summary>
/// <param name="type">The type of the new attribute.</param>
/// <param name="name">The name of the new attribute.</param>
/// <param name="flags">The flags of the new attribute.</param>
/// <param name="firstCluster">The first cluster to assign to the attribute.</param>
/// <param name="numClusters">The number of sequential clusters to assign to the attribute.</param>
/// <param name="bytesPerCluster">The number of bytes in each cluster.</param>
/// <returns>The new attribute.</returns>
private NtfsAttribute CreateAttribute(AttributeType type, string name, AttributeFlags flags, long firstCluster, ulong numClusters, uint bytesPerCluster)
{
bool indexed = _context.AttributeDefinitions.IsIndexed(type);
ushort id = _records[0].CreateNonResidentAttribute(type, name, flags, firstCluster, numClusters, bytesPerCluster);
AttributeRecord newAttrRecord = _records[0].GetAttribute(id);
NtfsAttribute newAttr = NtfsAttribute.FromRecord(this, MftReference, newAttrRecord);
_attributes.Add(newAttr);
UpdateAttributeList();
MarkMftRecordDirty();
return(newAttr);
}
public LuaDocumentStatement(string triviaText)
{
var items = triviaText.Replace("///", string.Empty)
.Split(new string[] { "\r\n", "\n", "\r" }, StringSplitOptions.RemoveEmptyEntries)
.Select(i => i.Trim()).ToList();
int curIndex = 0;
while (curIndex < items.Count)
{
int beginIndex = items.FindIndex(curIndex, i => i == Tokens.OpenSummary);
if (beginIndex != -1)
{
AddLineText(items, curIndex, beginIndex);
int endIndex = items.FindIndex(beginIndex + 1, it => it == Tokens.CloseSummary);
if (endIndex != -1)
{
LuaSummaryDocumentStatement summary = new LuaSummaryDocumentStatement();
bool hasAttr = false;
for (int i = beginIndex + 1; i < endIndex; ++i)
{
string text = items[i];
if (IsAttribute(text, out AttributeFlags arrt))
{
attr_ |= arrt;
hasAttr = true;
}
else
{
summary.Texts.Add(text);
}
}
if (summary.Texts.Count > 0 || !hasAttr)
{
Statements.Add(summary);
}
curIndex = endIndex + 1;
}
else
{
AddLineText(items, curIndex, items.Count);
curIndex = items.Count;
}
}
else
{
AddLineText(items, curIndex, items.Count);
curIndex = items.Count;
}
}
}
/// <summary>
/// Creates a new attribute.
/// </summary>
/// <param name="type">The type of the new attribute.</param>
/// <param name="name">The name of the new attribute.</param>
/// <param name="indexed">Whether the attribute is marked as indexed.</param>
/// <param name="flags">Flags for the new attribute.</param>
/// <returns>The id of the new attribute.</returns>
public ushort CreateAttribute(AttributeType type, string name, bool indexed, AttributeFlags flags)
{
ushort id = NextAttributeId++;
Attributes.Add(
new ResidentAttributeRecord(
type,
name,
id,
indexed,
flags));
Attributes.Sort();
return(id);
}
/// <summary>
/// Creates a new non-resident attribute.
/// </summary>
/// <param name="type">The type of the new attribute</param>
/// <param name="name">The name of the new attribute</param>
/// <param name="flags">Flags for the new attribute</param>
internal ushort CreateNonResidentAttribute(AttributeType type, string name, AttributeFlags flags)
{
ushort id = _nextAttributeId++;
_attributes.Add(
new NonResidentAttributeRecord(
type,
name,
id,
flags,
new List <CookedDataRun>())
);
_attributes.Sort();
return(id);
}
private static NtResult <NtKey> OpenKey(string name, NtObject root, bool open_link, bool open_for_backup)
{
AttributeFlags flags = AttributeFlags.CaseInsensitive;
if (open_link)
{
flags |= AttributeFlags.OpenLink;
}
using (ObjectAttributes obja = new ObjectAttributes(name,
flags, root))
{
return(NtKey.Open(obja, KeyAccessRights.MaximumAllowed, open_for_backup ? KeyCreateOptions.BackupRestore : KeyCreateOptions.NonVolatile, false));
}
}
/// <summary>
/// Creates a new non-resident attribute.
/// </summary>
/// <param name="type">The type of the new attribute.</param>
/// <param name="name">The name of the new attribute.</param>
/// <param name="flags">Flags for the new attribute.</param>
/// <returns>The id of the new attribute.</returns>
public ushort CreateNonResidentAttribute(AttributeType type, string name, AttributeFlags flags)
{
ushort id = NextAttributeId++;
Attributes.Add(
new NonResidentAttributeRecord(
type,
name,
id,
flags,
0,
new List <DataRun>()));
Attributes.Sort();
return(id);
}
/// <summary>
/// Creates a new attribute.
/// </summary>
/// <param name="type">The type of the new attribute</param>
/// <param name="name">The name of the new attribute</param>
/// <param name="flags">The flags of the new attribute</param>
/// <returns>The new attribute</returns>
private NtfsAttribute CreateAttribute(AttributeType type, string name, AttributeFlags flags)
{
bool indexed = _context.AttributeDefinitions.IsIndexed(type);
ushort id = _records[0].CreateAttribute(type, name, indexed, flags);
AttributeRecord newAttrRecord = _records[0].GetAttribute(id);
NtfsAttribute newAttr = NtfsAttribute.FromRecord(this, MftReference, newAttrRecord);
_attributes.Add(newAttr);
UpdateAttributeList();
MarkMftRecordDirty();
return(newAttr);
}
protected AttributeRecord(byte[] buffer, int offset)
{
m_attribueType = (AttributeType)LittleEndianConverter.ToUInt32(buffer, offset + 0x00);
m_recordLengthOnDisk = LittleEndianConverter.ToUInt32(buffer, offset + 0x04);
m_attributeForm = (AttributeForm)ByteReader.ReadByte(buffer, offset + 0x08);
m_nameLength = ByteReader.ReadByte(buffer, offset + 0x09);
ushort nameOffset = LittleEndianConverter.ToUInt16(buffer, offset + 0x0A);
Flags = (AttributeFlags)LittleEndianConverter.ToUInt16(buffer, offset + 0x0C);
m_instance = LittleEndianConverter.ToUInt16(buffer, offset + 0x0E);
if (m_nameLength > 0)
{
m_name = ByteReader.ReadUTF16String(buffer, offset + nameOffset, m_nameLength);
}
}
public static SafeFileHandle OpenFile(string name, FileAccessRights DesiredAccess, ShareMode ShareAccess, FileOpenOptions OpenOptions, bool inherit)
{
AttributeFlags flags = AttributeFlags.CaseInsensitive;
if (inherit)
{
flags |= AttributeFlags.Inherit;
}
using (ObjectAttributes obja = new ObjectAttributes(name, flags))
{
IntPtr handle;
IoStatusBlock iostatus = new IoStatusBlock();
StatusToNtException(NtOpenFile(out handle, DesiredAccess, obja, iostatus, ShareAccess, OpenOptions));
return(new SafeFileHandle(handle, true));
}
}
/// <summary>
/// Creates a new attribute.
/// </summary>
/// <param name="type">The type of the new attribute</param>
/// <param name="name">The name of the new attribute</param>
/// <param name="flags">Flags for the new attribute</param>
/// <param name="firstCluster">The first cluster to assign to the attribute</param>
/// <param name="numClusters">The number of sequential clusters to assign to the attribute</param>
/// <param name="bytesPerCluster">The number of bytes in each cluster</param>
/// <returns>The id of the new attribute</returns>
public ushort CreateNonResidentAttribute(AttributeType type, string name, AttributeFlags flags, long firstCluster, ulong numClusters, uint bytesPerCluster)
{
ushort id = _nextAttributeId++;
_attributes.Add(
new NonResidentAttributeRecord(
type,
name,
id,
flags,
firstCluster,
numClusters,
bytesPerCluster));
_attributes.Sort();
return(id);
}
public NonResidentAttributeRecord(AttributeType type, string name, ushort id, AttributeFlags flags, long firstCluster, ulong numClusters, uint bytesPerCluster)
: base(type, name, id, flags)
{
_nonResidentFlag = 1;
_dataRuns = new List<DataRun>();
_dataRuns.Add(new DataRun(firstCluster, (long)numClusters, false));
_lastVCN = numClusters - 1;
_dataAllocatedSize = bytesPerCluster * numClusters;
_dataRealSize = bytesPerCluster * numClusters;
_initializedDataSize = bytesPerCluster * numClusters;
if ((flags & (AttributeFlags.Compressed | AttributeFlags.Sparse)) != 0)
{
_compressionUnitSize = DefaultCompressionUnitSize;
}
}
/// <summary>
/// Determines whether the specified Object is equal to the current Object.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (Object.ReferenceEquals(this, obj))
{
return(true);
}
if (this.GetType() != obj.GetType())
{
return(false);
}
var other = (VLQuestionColumn)obj;
//reference types
if (!Object.Equals(ColumnText, other.ColumnText))
{
return(false);
}
//value types
if (!Survey.Equals(other.Survey))
{
return(false);
}
if (!Question.Equals(other.Question))
{
return(false);
}
if (!ColumnId.Equals(other.ColumnId))
{
return(false);
}
if (!DisplayOrder.Equals(other.DisplayOrder))
{
return(false);
}
if (!AttributeFlags.Equals(other.AttributeFlags))
{
return(false);
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <c>AttributeDefiniton</c> class.
/// </summary>
/// <param name="tag">Attribute identifier, the parameter <c>id</c> string cannot contain spaces.</param>
/// <param name="textHeight">Height of the attribute definition text.</param>
/// <param name="style">Attribute <see cref="TextStyle">text style</see>.</param>
public AttributeDefinition(string tag, double textHeight, TextStyle style)
: base(DxfObjectCode.AttributeDefinition)
{
if (string.IsNullOrEmpty(tag))
{
throw new ArgumentNullException(nameof(tag));
}
if (tag.Contains(" "))
{
throw new ArgumentException("The tag string cannot contain spaces.", nameof(tag));
}
this.tag = tag;
this.flags = AttributeFlags.Visible;
this.prompt = string.Empty;
this.attValue = null;
this.position = Vector3.Zero;
if (style == null)
{
throw new ArgumentNullException(nameof(style));
}
this.style = style;
if (textHeight <= 0.0)
{
throw new ArgumentOutOfRangeException(nameof(textHeight), this.attValue, "The attribute definition text height must be greater than zero.");
}
this.height = textHeight;
this.width = 1.0;
this.widthFactor = style.WidthFactor;
this.obliqueAngle = style.ObliqueAngle;
this.rotation = 0.0;
this.alignment = TextAlignment.BaselineLeft;
this.isBackward = false;
this.isUpsideDown = false;
this.color = AciColor.ByLayer;
this.layer = Layer.Default;
this.linetype = Linetype.ByLayer;
this.lineweight = Lineweight.ByLayer;
this.transparency = Transparency.ByLayer;
this.linetypeScale = 1.0;
this.isVisible = true;
this.normal = Vector3.UnitZ;
this.xData = new XDataDictionary();
this.xData.AddAppReg += this.XData_AddAppReg;
this.xData.RemoveAppReg += this.XData_RemoveAppReg;
}
private ObjectAttributes GetObjectAttributes()
{
AttributeFlags flags = AttributeFlags.CaseInsensitive;
if (OpenLink)
{
flags |= AttributeFlags.OpenLink;
}
if (Win32Path)
{
return(new ObjectAttributes(NtKeyUtils.Win32KeyNameToNt(Path), flags));
}
else
{
return(new ObjectAttributes(Path, flags, Root));
}
}
/// <summary>
/// Intitializes a new instance of the <c>AttributeDefiniton</c> class.
/// </summary>
/// <param name="id">Attribute identifier, the parameter <c>id</c> string cannot contain spaces.</param>
/// <param name="style">Attribute <see cref="TextStyle">text style</see>.</param>
public AttributeDefinition(string id, TextStyle style)
: base(EntityType.AttributeDefinition, DxfObjectCode.AttributeDefinition)
{
if (id.Contains(" "))
{
throw new ArgumentException("The id string cannot contain spaces", "id");
}
this.id = id;
this.flags = AttributeFlags.Visible;
this.text = string.Empty;
this.value = null;
this.position = Vector3.Zero;
this.style = style;
this.height = MathHelper.IsZero(this.style.Height) ? 1.0 : style.Height;
this.widthFactor = style.WidthFactor;
this.rotation = 0.0;
this.alignment = TextAlignment.BaselineLeft;
}
/// <summary>
/// Intitializes a new instance of the <c>Attribute</c> class.
/// </summary>
/// <param name="definition"><see cref="AttributeDefinition">Attribute definition</see>.</param>
/// <param name="value">Attribute value.</param>
public Attribute(AttributeDefinition definition, object value)
: base(EntityType.Attribute, DxfObjectCode.Attribute)
{
if (definition == null)
{
throw new ArgumentNullException("definition");
}
this.definition = definition;
this.id = definition.Id;
this.value = value;
this.style = definition.Style;
this.position = definition.Position;
this.flags = definition.Flags;
this.height = definition.Height;
this.widthFactor = definition.WidthFactor;
this.rotation = definition.Rotation;
this.alignment = definition.Alignment;
}
/// <summary>
/// Try and open the directory entry and return an actual NtObject handle.
/// </summary>
/// <param name="throw_on_error">True to throw on error.</param>
/// <returns>The object opened.</returns>
/// <exception cref="System.ArgumentException">Thrown if invalid typename.</exception>
public virtual NtResult <NtObject> ToObject(bool throw_on_error)
{
AttributeFlags flags = AttributeFlags.CaseInsensitive;
if (TypeName.Equals("key", StringComparison.OrdinalIgnoreCase))
{
flags |= AttributeFlags.OpenLink;
}
if (_root.FullPath == @"\" && RelativePath.StartsWith(@"??\"))
{
return(NtObject.OpenWithType(TypeName, @"\" + RelativePath, null,
flags, GenericAccessRights.MaximumAllowed, null, throw_on_error));
}
return(NtObject.OpenWithType(TypeName, RelativePath, _root,
flags, GenericAccessRights.MaximumAllowed, null, throw_on_error));
}
/// <summary>
/// If the read-only property is not asserted, check the write-enabled status of the watch variable and set/clear the <c>WriteEnabled</c> property accordingly.
/// The current state is determined by the specified <paramref name="attributeFlags"/> and <paramref name="securityLevel"/> parameters. True, indicates that the
/// watch variable is currently write enabled; false, indicates that the watch variable is currently read-only.
/// </summary>
/// <param name="attributeFlags">The attribute flags associated with the watch variable.</param>
/// <param name="securityLevel">The current security level.</param>
private void CheckWriteEnabledStatus(AttributeFlags attributeFlags, SecurityLevel securityLevel)
{
// Local flag used to determine if the watch variable is currently write enabled.
bool writeEnabled;
// Check whether the ReadOnly property is asserted.
if (ReadOnly == true)
{
// Yes - Force the user control to be read-only.
writeEnabled = false;
}
else
{
// Check whether the read-only attribute is set.
if ((attributeFlags & AttributeFlags.PTUD_READONLY) == AttributeFlags.PTUD_READONLY)
{
// Read-only watch variable.
writeEnabled = false;
}
else
{
// Check whether the current security level is below that required to modify the watch variable.
if (((attributeFlags & AttributeFlags.PTUD_PSSWD1) == AttributeFlags.PTUD_PSSWD1) && (securityLevel < SecurityLevel.Level1))
{
// Read-only - security level is too low.
writeEnabled = false;
}
else if (((attributeFlags & AttributeFlags.PTUD_PSSWD2) == AttributeFlags.PTUD_PSSWD2) && (securityLevel < SecurityLevel.Level2))
{
// Read-only - security level is too low.
writeEnabled = false;
}
else
{
// Write enabled - display value using bold text.
m_LabelValueField.Font = new Font(ClientForm.Font, FontStyle.Bold);
writeEnabled = true;
}
}
}
SetWriteEnabledProperty(writeEnabled);
}
private static bool IsAttribute(string text, out AttributeFlags attr)
{
attr = AttributeFlags.None;
int index = text.IndexOf(kAttributePrefix);
if (index != -1)
{
string s = text.Substring(index + kAttributePrefix.Length);
if (Enum.TryParse(s, out attr))
{
return(true);
}
else
{
throw new CompilationErrorException($"{s} is not define attribute");
}
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="flags"></param>
/// <returns></returns>
private string CreateQuery(AttributeFlags flags)
{
string query = string.Empty;
query += $"?network={flags.HasFlag(AttributeFlags.NETWORK).ToString().ToLower()}";
query += $"&endpoint={flags.HasFlag(AttributeFlags.ENDPOINT).ToString().ToLower()}";
query += $"&clusterEndpoint={flags.HasFlag(AttributeFlags.CLUSTERENDPOINT).ToString().ToLower()}";
query += $"&definition={flags.HasFlag(AttributeFlags.DEFINITION).ToString().ToLower()}";
query += $"&config={flags.HasFlag(AttributeFlags.CONFIG).ToString().ToLower()}";
query += $"&room={flags.HasFlag(AttributeFlags.ROOM).ToString().ToLower()}";
query += $"&icons={flags.HasFlag(AttributeFlags.ICONS).ToString().ToLower()}";
query += $"&value={flags.HasFlag(AttributeFlags.VALUE).ToString().ToLower()}";
query += $"&parent={flags.HasFlag(AttributeFlags.PARENT).ToString().ToLower()}";
query += $"&children={flags.HasFlag(AttributeFlags.CHILDREN).ToString().ToLower()}";
query += $"&full={flags.HasFlag(AttributeFlags.FULL).ToString().ToLower()}";
query += $"&type={flags.HasFlag(AttributeFlags.TYPE).ToString().ToLower()}";
return(query);
}
/// <summary>
/// Initializes a new instance of the <c>AttributeDefiniton</c> class.
/// </summary>
/// <param name="tag">Attribute identifier, the parameter <c>id</c> string cannot contain spaces.</param>
/// <param name="style">Attribute <see cref="TextStyle">text style</see>.</param>
public AttributeDefinition(string tag, TextStyle style)
: base(EntityType.AttributeDefinition, DxfObjectCode.AttributeDefinition)
{
if (tag.Contains(" "))
{
throw new ArgumentException("The tag string cannot contain spaces.", nameof(tag));
}
this.tag = tag;
this.flags = AttributeFlags.Visible;
this.prompt = string.Empty;
this.value = null;
this.position = Vector3.Zero;
this.style = style;
this.height = MathHelper.IsZero(this.style.Height) ? 1.0 : style.Height;
this.widthFactor = style.WidthFactor;
this.obliqueAngle = style.ObliqueAngle;
this.rotation = 0.0;
this.alignment = TextAlignment.BaselineLeft;
}
/// <summary>
/// Initializes a new instance of the <c>AttributeDefiniton</c> class.
/// </summary>
/// <param name="tag">Attribute identifier.</param>
/// <param name="style">Attribute <see cref="TextStyle">text style</see>.</param>
public AttributeDefinition(string tag, TextStyle style)
: base(EntityType.AttributeDefinition, DxfObjectCode.AttributeDefinition)
{
if (string.IsNullOrEmpty(tag))
throw new ArgumentNullException(nameof(tag));
this.tag = tag;
this.flags = AttributeFlags.Visible;
this.prompt = string.Empty;
this.value = null;
this.position = Vector3.Zero;
if (style == null)
throw new ArgumentNullException(nameof(style));
this.style = style;
this.height = MathHelper.IsZero(style.Height) ? 1.0 : style.Height;
this.widthFactor = style.WidthFactor;
this.obliqueAngle = style.ObliqueAngle;
this.rotation = 0.0;
this.alignment = TextAlignment.BaselineLeft;
}
protected AttributeRecord(byte[] buffer, int offset)
{
m_attribueType = (AttributeType)LittleEndianConverter.ToUInt32(buffer, offset + 0x00);
m_recordLengthOnDisk = LittleEndianConverter.ToUInt32(buffer, offset + 0x04);
m_attributeForm = (AttributeForm)ByteReader.ReadByte(buffer, offset + 0x08);
m_nameLength = ByteReader.ReadByte(buffer, offset + 0x09);
ushort nameOffset = LittleEndianConverter.ToUInt16(buffer, offset + 0x0A);
Flags = (AttributeFlags)LittleEndianConverter.ToUInt16(buffer, offset + 0x0C);
Instance = LittleEndianConverter.ToUInt16(buffer, offset + 0x0E);
if (m_nameLength > 0)
{
m_name = ByteReader.ReadUTF16String(buffer, offset + nameOffset, m_nameLength);
}
if (m_recordLengthOnDisk % 8 > 0)
{
throw new InvalidDataException("Corrupt attribute, record not aligned to 8-byte boundary");
}
}
protected virtual void Read(byte[] buffer, int offset, out int length)
{
_type = (AttributeType)Utilities.ToUInt32LittleEndian(buffer, offset + 0x00);
length = Utilities.ToInt32LittleEndian(buffer, offset + 0x04);
_nonResidentFlag = buffer[offset + 0x08];
byte nameLength = buffer[offset + 0x09];
ushort nameOffset = Utilities.ToUInt16LittleEndian(buffer, offset + 0x0A);
_flags = (AttributeFlags)Utilities.ToUInt16LittleEndian(buffer, offset + 0x0C);
_attributeId = Utilities.ToUInt16LittleEndian(buffer, offset + 0x0E);
if (nameLength != 0x00)
{
if (nameLength + nameOffset > length)
{
throw new IOException("Corrupt attribute, name outside of attribute");
}
_name = Encoding.Unicode.GetString(buffer, offset + nameOffset, nameLength * 2);
}
}
/// <summary>
/// Intitializes a new instance of the <c>AttributeDefiniton</c> class.
/// </summary>
/// <param name="id">Attribute identifier, the parameter <c>id</c> string cannot contain spaces.</param>
public AttributeDefinition(string id)
: base(DxfObjectCode.AttributeDefinition)
{
if (id.Contains(" "))
{
throw new ArgumentException("The id string cannot contain spaces", "id");
}
this.id = id;
this.flags = AttributeFlags.Visible;
this.text = string.Empty;
this.value = null;
this.basePoint = Vector3.Zero;
this.layer = Layer.Default;
this.color = AciColor.ByLayer;
this.lineType = LineType.ByLayer;
this.style = TextStyle.Default;
this.alignment = TextAlignment.BaselineLeft;
this.height = MathHelper.IsZero(this.style.Height) ? 1.0f : this.style.Height;
this.widthFactor = this.style.WidthFactor;
this.rotation = 0.0f;
this.normal = Vector3.UnitZ;
}
public NonResidentAttributeRecord(AttributeType type, string name, ushort id, AttributeFlags flags, long startVcn, List<DataRun> dataRuns)
: base(type, name, id, flags)
{
_nonResidentFlag = 1;
_dataRuns = dataRuns;
_startingVCN = (ulong)startVcn;
if ((flags & (AttributeFlags.Compressed | AttributeFlags.Sparse)) != 0)
{
_compressionUnitSize = DefaultCompressionUnitSize;
}
if (dataRuns != null && dataRuns.Count != 0)
{
_lastVCN = _startingVCN;
foreach (var run in dataRuns)
{
_lastVCN += (ulong)run.RunLength;
}
_lastVCN -= 1;
}
}
private ObjectAttributes(SafeBuffer object_name, AttributeFlags attributes, SafeKernelObjectHandle root,
SecurityQualityOfService sqos, SecurityDescriptor security_descriptor)
{
try
{
if (root == null)
{
throw new ArgumentNullException(nameof(root), "Use SafeKernelObjectHandle.Null for a null handle");
}
Length = Marshal.SizeOf(this);
ObjectName = object_name;
Attributes = attributes;
if (sqos != null)
{
SecurityQualityOfService = sqos.ToBuffer();
}
else
{
SecurityQualityOfService = SafeHGlobalBuffer.Null;
}
RootDirectory = !root.IsInvalid ? NtObject.DuplicateHandle(root) : SafeKernelObjectHandle.Null;
if (security_descriptor != null)
{
SecurityDescriptor = security_descriptor.ToSafeBuffer();
}
else
{
SecurityDescriptor = SafeHGlobalBuffer.Null;
}
}
catch
{
Dispose();
throw;
}
}
/// <summary>
/// Initializes a new instance of the <c>AttributeDefiniton</c> class.
/// </summary>
/// <param name="tag">Attribute identifier.</param>
/// <param name="style">Attribute <see cref="TextStyle">text style</see>.</param>
public AttributeDefinition(string tag, TextStyle style)
: base(EntityType.AttributeDefinition, DxfObjectCode.AttributeDefinition)
{
if (string.IsNullOrEmpty(tag))
{
throw new ArgumentNullException(nameof(tag));
}
this.tag = tag;
this.flags = AttributeFlags.Visible;
this.prompt = string.Empty;
this.attValue = null;
this.position = Vector3.Zero;
if (style == null)
{
throw new ArgumentNullException(nameof(style));
}
this.style = style;
this.height = MathHelper.IsZero(style.Height) ? 1.0 : style.Height;
this.widthFactor = style.WidthFactor;
this.obliqueAngle = style.ObliqueAngle;
this.rotation = 0.0;
this.alignment = TextAlignment.BaselineLeft;
}
public ObjectAttributes(string object_name, AttributeFlags attributes, SafeKernelObjectHandle root, SecurityQualityOfService sqos, GenericSecurityDescriptor security_descriptor)
{
Length = Marshal.SizeOf(this);
if (object_name != null)
{
ObjectName = AllocStruct(new UnicodeString(object_name));
}
Attributes = attributes;
if (sqos != null)
{
SecurityQualityOfService = AllocStruct(sqos);
}
if (root != null)
{
RootDirectory = root.DangerousGetHandle();
}
if (security_descriptor != null)
{
byte[] sd_binary = new byte[security_descriptor.BinaryLength];
security_descriptor.GetBinaryForm(sd_binary, 0);
SecurityDescriptor = Marshal.AllocHGlobal(sd_binary.Length);
Marshal.Copy(sd_binary, 0, SecurityDescriptor, sd_binary.Length);
}
}
public LuaDocumentStatement(string triviaText)
{
var items = triviaText.Replace("///", string.Empty)
.Split(new string[] { "\r\n", "\n", "\r" }, StringSplitOptions.RemoveEmptyEntries)
.Select(i => i.Trim()).ToList();
var document = new LuaSummaryDocumentStatement();
foreach (var item in items)
{
if (IsAttribute(item, out AttributeFlags arrt))
{
attr_ |= arrt;
}
else
{
document.Texts.Add(item);
}
}
if (document.Texts.Count > 0)
{
Statements.Add(document);
}
}
/// <summary>
/// Open an NT object with a specified type.
/// </summary>
/// <param name="typename">The name of the type to open (e.g. Event). If null the method will try and lookup the appropriate type.</param>
/// <param name="path">The path to the object to open.</param>
/// <param name="root">A root directory to open from.</param>
/// <param name="access">Generic access rights to the object.</param>
/// <param name="attributes">Attributes to open the object.</param>
/// <param name="security_quality_of_service">Security quality of service.</param>
/// <param name="throw_on_error">True to throw on error.</param>
/// <returns>The opened object.</returns>
/// <exception cref="NtException">Thrown if an error occurred opening the object.</exception>
public static NtResult <NtObject> OpenWithType(string typename, string path, NtObject root,
AttributeFlags attributes, AccessMask access, SecurityQualityOfService security_quality_of_service, bool throw_on_error)
{
using (var obj_attr = new ObjectAttributes(path, attributes, root, security_quality_of_service, null))
{
if (typename == null)
{
typename = NtDirectory.GetDirectoryEntryType(path, root);
}
// Brute force the open.
if (typename == null)
{
foreach (var nttype in NtType.GetTypes().Where(t => t.CanOpen))
{
var result = nttype.Open(obj_attr, access, false);
if (result.IsSuccess)
{
return(result);
}
}
return(NtStatus.STATUS_OBJECT_TYPE_MISMATCH.CreateResultFromError <NtObject>(true));
}
NtType type = NtType.GetTypeByName(typename, false);
if (type != null && type.CanOpen)
{
return(type.Open(obj_attr, access, throw_on_error));
}
else
{
return(NtStatus.STATUS_OBJECT_TYPE_MISMATCH.CreateResultFromError <NtObject>(true));
}
}
}
/// <summary>
/// Initializes a new instance of the <c>Attribute</c> class.
/// </summary>
/// <param name="definition"><see cref="AttributeDefinition">Attribute definition</see>.</param>
/// <remarks>
/// Although the attribute entity could override values defined in its definition for simplicity the implementation has restricted this possibility.
/// </remarks>
public Attribute(AttributeDefinition definition)
: base(DxfObjectCode.Attribute)
{
if (definition == null)
throw new ArgumentNullException("definition");
//EntityObject properties
this.color = definition.Color;
this.layer = definition.Layer;
this.lineType = definition.LineType;
this.lineweight = definition.Lineweight;
this.lineTypeScale = definition.LineTypeScale;
this.transparency = definition.Transparency;
this.isVisible = definition.IsVisible;
this.normal = definition.Normal;
//Attribute definition properties
this.definition = definition;
this.tag = definition.Tag;
this.value = definition.Value;
this.style = definition.Style;
this.position = definition.Position;
this.flags = definition.Flags;
this.height = definition.Height;
this.widthFactor = definition.WidthFactor;
this.obliqueAngle = definition.ObliqueAngle;
this.rotation = definition.Rotation;
this.alignment = definition.Alignment;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="object_name">The name of the object</param>
/// <param name="attributes">Attribute flags</param>
public ObjectAttributes(string object_name, AttributeFlags attributes)
: this(object_name, attributes, SafeKernelObjectHandle.Null, null, null)
{
}
/// <summary>
/// Creates a new attribute.
/// </summary>
/// <param name="type">The type of the new attribute</param>
/// <param name="name">The name of the new attribute</param>
/// <param name="flags">Flags for the new attribute</param>
/// <param name="firstCluster">The first cluster to assign to the attribute</param>
/// <param name="numClusters">The number of sequential clusters to assign to the attribute</param>
/// <param name="bytesPerCluster">The number of bytes in each cluster</param>
/// <returns>The id of the new attribute</returns>
public ushort CreateNonResidentAttribute(AttributeType type, string name, AttributeFlags flags, long firstCluster, ulong numClusters, uint bytesPerCluster)
{
ushort id = _nextAttributeId++;
_attributes.Add(
new NonResidentAttributeRecord(
type,
name,
id,
flags,
firstCluster,
numClusters,
bytesPerCluster));
_attributes.Sort();
return id;
}
public static extern NtStatus NtOpenProcessTokenEx(
SafeKernelObjectHandle ProcessHandle,
TokenAccessRights DesiredAccess,
AttributeFlags HandleAttributes,
out SafeKernelObjectHandle TokenHandle);
// Name: clearFlag
// Description: Unsets the bit designated by an AttributesFlag flag
// Parameters: AttributesFlags flag , the flag to unset
public void clearFlag(AttributeFlags flag)
{
// NOTing the flag, then ANDing it into the bitfield will always
// unset the bit:
// 0000010 <-- Flag
// 1111101 <-- NOT Flag
//
// 0100101
// & 1111101 <-- NOT Flag
// -------
// 0100101 <-- Bit unset
// or, alternatively;
// 0100111
// & 1111101 <-- NOT Flag
// -------
// 0100101 <-- Bit unset
attributes &= ~flag;
}
public static extern int NtOpenProcessTokenEx(
IntPtr ProcessHandle,
GenericAccessRights DesiredAccess,
AttributeFlags HandleAttributes,
out IntPtr TokenHandle);
// Bitfield attribute accessors and mutators
// Name: setFlag
// Description: Sets the bit in the bitfield with the given flag
// Parameters: AttributeFlags flag , the flag being set
public void setFlag(AttributeFlags flag)
{
// ORing the flag into the bitfield will always set the flag:
// 0100101
// | 0000010 <-- Flag
// -------
// 0100111 <-- Bit is set
// or, alternatively;
// 0100111
// | 0000010 <-- Flag
// -------
// 0100111 <-- Bit is set
attributes |= flag;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="object_name">The object name, can be null.</param>
/// <param name="attributes">The object attribute flags.</param>
/// <param name="root">An optional root handle, can be SafeKernelObjectHandle.Null. Will duplicate the handle.</param>
/// <param name="sqos">An optional security quality of service.</param>
/// <param name="security_descriptor">An optional security descriptor.</param>
public ObjectAttributes(string object_name, AttributeFlags attributes, SafeKernelObjectHandle root,
SecurityQualityOfService sqos, SecurityDescriptor security_descriptor)
{
Length = Marshal.SizeOf(this);
if (object_name != null)
{
ObjectName = new UnicodeString(object_name).ToBuffer();
}
else
{
ObjectName = SafeHGlobalBuffer.Null;
}
Attributes = attributes;
if (sqos != null)
{
SecurityQualityOfService = sqos.ToBuffer();
}
else
{
SecurityQualityOfService = SafeHGlobalBuffer.Null;
}
RootDirectory = !root.IsInvalid ? NtObject.DuplicateHandle(root) : SafeKernelObjectHandle.Null;
if (security_descriptor != null)
{
SecurityDescriptor = security_descriptor.ToSafeBuffer();
}
else
{
SecurityDescriptor = SafeHGlobalBuffer.Null;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="attributes">Attribute flags</param>
public ObjectAttributes(AttributeFlags attributes)
: this(null, attributes, SafeKernelObjectHandle.Null, null, null)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="object_name">The object name, can be null.</param>
/// <param name="attributes">The object attribute flags.</param>
/// <param name="root">An optional root handle, can be SafeKernelObjectHandle.Null. Will duplicate the handle.</param>
/// <param name="sqos">An optional security quality of service.</param>
/// <param name="security_descriptor">An optional security descriptor.</param>
public ObjectAttributes(string object_name, AttributeFlags attributes, NtObject root,
SecurityQualityOfService sqos, SecurityDescriptor security_descriptor)
: this(object_name, attributes, root != null ? root.Handle : SafeKernelObjectHandle.Null, sqos, security_descriptor)
{
}
/// <summary>
/// If the read-only property is not asserted, check the write-enabled status of the watch variable and set/clear the <c>WriteEnabled</c> property accordingly.
/// The current state is determined by the specified <paramref name="attributeFlags"/> and <paramref name="securityLevel"/> parameters. True, indicates that the
/// watch variable is currently write enabled; false, indicates that the watch variable is currently read-only.
/// </summary>
/// <param name="attributeFlags">The attribute flags associated with the watch variable.</param>
/// <param name="securityLevel">The current security level.</param>
private void CheckWriteEnabledStatus(AttributeFlags attributeFlags, SecurityLevel securityLevel)
{
// Local flag used to determine if the watch variable is currently write enabled.
bool writeEnabled;
// Check whether the ReadOnly property is asserted.
if (ReadOnly == true)
{
// Yes - Force the user control to be read-only.
writeEnabled = false;
}
else
{
// Check whether the read-only attribute is set.
if ((attributeFlags & AttributeFlags.PTUD_READONLY) == AttributeFlags.PTUD_READONLY)
{
// Read-only watch variable.
writeEnabled = false;
}
else
{
// Check whether the current security level is below that required to modify the watch variable.
if (((attributeFlags & AttributeFlags.PTUD_PSSWD1) == AttributeFlags.PTUD_PSSWD1) && (securityLevel < SecurityLevel.Level1))
{
// Read-only - security level is too low.
writeEnabled = false;
}
else if (((attributeFlags & AttributeFlags.PTUD_PSSWD2) == AttributeFlags.PTUD_PSSWD2) && (securityLevel < SecurityLevel.Level2))
{
// Read-only - security level is too low.
writeEnabled = false;
}
else
{
// Write enabled - display value using bold text.
m_LabelValueField.Font = new Font(ClientForm.Font, FontStyle.Bold);
writeEnabled = true;
}
}
}
SetWriteEnabledProperty(writeEnabled);
}
/// <summary>
/// Creates a new attribute.
/// </summary>
/// <param name="type">The type of the new attribute</param>
/// <param name="name">The name of the new attribute</param>
/// <param name="indexed">Whether the attribute is marked as indexed</param>
/// <param name="flags">Flags for the new attribute</param>
/// <returns>The id of the new attribute</returns>
public ushort CreateAttribute(AttributeType type, string name, bool indexed, AttributeFlags flags)
{
ushort id = _nextAttributeId++;
_attributes.Add(
new ResidentAttributeRecord(
type,
name,
id,
indexed,
flags));
_attributes.Sort();
return id;
}
/// <summary>
/// Intitializes a new instance of the <c>AttributeDefiniton</c> class.
/// </summary>
/// <param name="id">Attribute identifier, the parameter <c>id</c> string cannot contain spaces.</param>
public AttributeDefinition(string id)
: base(DxfObjectCode.AttributeDefinition)
{
if (id.Contains(" "))
throw new ArgumentException("The id string cannot contain spaces", "id");
this.id = id;
this.flags = AttributeFlags.Visible;
this.text = string.Empty;
this.value = null;
this.basePoint = Vector3f.Zero;
this.layer = Layer.Default;
this.color = AciColor.ByLayer;
this.lineType = LineType.ByLayer;
this.style = TextStyle.Default;
this.alignment = TextAlignment.BaselineLeft;
this.height = this.style.Height == 0 ? 1.0f : this.style.Height;
this.widthFactor = this.style.WidthFactor;
this.rotation = 0.0f;
this.normal = Vector3f.UnitZ;
}
public ObjectAttributes(string object_name)
{
Length = Marshal.SizeOf(this);
if (object_name != null)
{
ObjectName = AllocStruct(new UnicodeString(object_name));
}
Attributes = AttributeFlags.None;
}
public static FileAttributes AttributesFromBools(AttributeFlags attributes)
{
FileAttributes flags = new FileAttributes();
if (attributes.Normal)
flags |= FileAttributes.Normal;
if (attributes.Archive)
flags |= FileAttributes.Archive;
if (attributes.Compressed)
flags |= FileAttributes.Compressed;
if (attributes.Device)
flags |= FileAttributes.Device;
if (attributes.Directory)
flags |= FileAttributes.Directory;
if (attributes.Encrypted)
flags |= FileAttributes.Encrypted;
if (attributes.Hidden)
flags |= FileAttributes.Hidden;
if (attributes.IntegrityStream)
flags |= FileAttributes.IntegrityStream;
if (attributes.NoScrubData)
flags |= FileAttributes.NoScrubData;
if (attributes.NotContentIndexed)
flags |= FileAttributes.NotContentIndexed;
if (attributes.Offline)
flags |= FileAttributes.Offline;
if (attributes.ReadOnly)
flags |= FileAttributes.ReadOnly;
if (attributes.ReparsePoint)
flags |= FileAttributes.ReparsePoint;
if (attributes.SparseFile)
flags |= FileAttributes.SparseFile;
if (attributes.System)
flags |= FileAttributes.System;
if (attributes.Temporary)
flags |= FileAttributes.Temporary;
return flags;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="object_name">The name of the object</param>
/// <param name="attributes">Attribute flags</param>
/// <param name="root">A root object to lookup a relative path</param>
public ObjectAttributes(string object_name, AttributeFlags attributes, NtObject root)
: this(object_name, attributes, root, null, null)
{
}
// Name: isFlagSet
// Description: Checks to see if the given flag is set in attributes
// Parameters: AttributeFlags flag , the flag being checked
// Returns: bool , whether the flag is set
public bool isFlagSet(AttributeFlags flag)
{
// If the bit for the given flag is set, ANDing the flag into the
// bitfield should yield the flag, otherwise the AND will not yield
// the flag:
// 0100101
// & 0000010 <-- Flag
// -------
// 0000000 != 0000010 <-- Bit was not set
// Or, alternatively;
// 0100111
// & 0000010 <-- Flag
// -------
// 0000010 == 0000010 <-- Bit was set
return (attributes & flag) == flag;
}
/// <summary>
/// Creates a new attribute at a fixed cluster.
/// </summary>
/// <param name="type">The type of the new attribute.</param>
/// <param name="name">The name of the new attribute.</param>
/// <param name="flags">The flags of the new attribute.</param>
/// <param name="firstCluster">The first cluster to assign to the attribute.</param>
/// <param name="numClusters">The number of sequential clusters to assign to the attribute.</param>
/// <param name="bytesPerCluster">The number of bytes in each cluster.</param>
/// <returns>The new attribute.</returns>
private NtfsAttribute CreateAttribute(AttributeType type, string name, AttributeFlags flags, long firstCluster, ulong numClusters, uint bytesPerCluster)
{
bool indexed = _context.AttributeDefinitions.IsIndexed(type);
ushort id = _records[0].CreateNonResidentAttribute(type, name, flags, firstCluster, numClusters, bytesPerCluster);
AttributeRecord newAttrRecord = _records[0].GetAttribute(id);
NtfsAttribute newAttr = NtfsAttribute.FromRecord(this, MftReference, newAttrRecord);
_attributes.Add(newAttr);
UpdateAttributeList();
MarkMftRecordDirty();
return newAttr;
}
/// <summary>
/// Initializes a new instance of the <c>AttributeDefiniton</c> class.
/// </summary>
/// <param name="tag">Attribute identifier, the parameter <c>id</c> string cannot contain spaces.</param>
/// <param name="textHeight">Height of the attribute definition text.</param>
/// <param name="style">Attribute <see cref="TextStyle">text style</see>.</param>
public AttributeDefinition(string tag, double textHeight, TextStyle style)
: base(EntityType.AttributeDefinition, DxfObjectCode.AttributeDefinition)
{
if (string.IsNullOrEmpty(tag))
throw new ArgumentNullException(nameof(tag));
if (tag.Contains(" "))
throw new ArgumentException("The tag string cannot contain spaces.", nameof(tag));
this.tag = tag;
this.flags = AttributeFlags.Visible;
this.prompt = string.Empty;
this.value = null;
this.position = Vector3.Zero;
if (style == null)
throw new ArgumentNullException(nameof(style));
this.style = style;
if (textHeight <= 0.0)
throw new ArgumentOutOfRangeException(nameof(textHeight), this.value, "The attribute definition text height must be greater than zero.");
this.height = textHeight;
this.widthFactor = style.WidthFactor;
this.obliqueAngle = style.ObliqueAngle;
this.rotation = 0.0;
this.alignment = TextAlignment.BaselineLeft;
}
/// <summary>
/// Creates a new unnamed attribute.
/// </summary>
/// <param name="type">The type of the new attribute.</param>
/// <param name="flags">The flags of the new attribute.</param>
/// <returns>The new attribute.</returns>
private NtfsAttribute CreateAttribute(AttributeType type, AttributeFlags flags)
{
return CreateAttribute(type, null, flags);
}
/// <summary>
/// Duplicate object.
/// </summary>
/// <param name="access_rights">Access rights to duplicate with.</param>
/// <param name="flags">Attribute flags.</param>
/// <param name="options">Duplicate options</param>
/// <returns>The duplicated object.</returns>
public NtObject DuplicateObject(AccessMask access_rights, AttributeFlags flags, DuplicateObjectOptions options)
{
return(DuplicateObject(access_rights, flags, options, true).Result);
}
/// <summary>
/// Creates a new attribute.
/// </summary>
/// <param name="type">The type of the new attribute.</param>
/// <param name="name">The name of the new attribute.</param>
/// <param name="flags">The flags of the new attribute.</param>
/// <returns>The new attribute.</returns>
private NtfsAttribute CreateAttribute(AttributeType type, string name, AttributeFlags flags)
{
bool indexed = _context.AttributeDefinitions.IsIndexed(type);
ushort id = _records[0].CreateAttribute(type, name, indexed, flags);
AttributeRecord newAttrRecord = _records[0].GetAttribute(id);
NtfsAttribute newAttr = NtfsAttribute.FromRecord(this, MftReference, newAttrRecord);
_attributes.Add(newAttr);
UpdateAttributeList();
MarkMftRecordDirty();
return newAttr;
}
public ObjectAttributes(string object_name, AttributeFlags flags, IntPtr root)
{
Length = Marshal.SizeOf(this);
if (object_name != null)
{
ObjectName = AllocStruct(new UnicodeString(object_name));
}
Attributes = flags;
RootDirectory = root;
}
/// <summary>
/// Creates a new non-resident attribute.
/// </summary>
/// <param name="type">The type of the new attribute</param>
/// <param name="name">The name of the new attribute</param>
/// <param name="flags">Flags for the new attribute</param>
/// <returns>The id of the new attribute</returns>
public ushort CreateNonResidentAttribute(AttributeType type, string name, AttributeFlags flags)
{
ushort id = _nextAttributeId++;
_attributes.Add(
new NonResidentAttributeRecord(
type,
name,
id,
flags,
0,
new List<DataRun>()));
_attributes.Sort();
return id;
}