我需要一种方法将一些文件簇插入文件中间以插入一些数据。
通常情况下，我只是读取整个文件并将其重新写回来，但文件的大小是几千兆字节，只需要30分钟读取文件并再次将其写回。
群集大小不会打扰我;我基本上可以在插入的簇的末尾写出零，它仍然可以使用这种文件格式。
如何使用Windows文件API（或其他一些机制）修改文件的文件分配表，在文件中间的指定位置插入一个或多个未使用的群集？
答案 0 :(得分：24)
[编辑：
Blah - 我要说“这是不可行的，至少不是通过MFT修改，没有很多痛苦”;首先，NTFS MFT结构本身并非100％“开放”，所以我开始钻研逆向工程领域，这有法律上的影响，我没心情去处理。此外，在.NET中执行此操作是基于大量猜测的映射和编组结构的繁琐过程（并且不要让我开始研究大多数MFT结构以奇怪方式压缩的事实）。简短的故事，虽然我确实学到了很多关于NTFS“如何工作”的知识，但我并没有更接近解决这个问题的方法。[/编辑]
呃...太多编组胡说八道......
这让我感到“有趣”，因此我被迫在这个问题上蠢蠢欲动......它仍然是一个“正在进行中的答案”，但是想要发布我所有必须帮助其他人的事情。有点东西。 ：）
另外，我粗略地认为在FAT32上这会更容易，但鉴于我只有NTFS可以使用......
所以 - 很多的排骨和编组，所以让我们从那里开始向后工作：
正如人们可能猜到的那样，标准的.NET File / IO apis在这里对你没什么帮助 - 我们需要设备级访问：
[DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
static extern SafeFileHandle CreateFile(
string lpFileName,
[MarshalAs(UnmanagedType.U4)] FileAccess dwDesiredAccess,
[MarshalAs(UnmanagedType.U4)] FileShare dwShareMode,
IntPtr lpSecurityAttributes,
[MarshalAs(UnmanagedType.U4)] FileMode dwCreationDisposition,
[MarshalAs(UnmanagedType.U4)] FileAttributes dwFlagsAndAttributes,
IntPtr hTemplateFile);
[DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern bool ReadFile(
SafeFileHandle hFile, // handle to file
byte[] pBuffer, // data buffer, should be fixed
int NumberOfBytesToRead, // number of bytes to read
IntPtr pNumberOfBytesRead, // number of bytes read, provide NULL here
ref NativeOverlapped lpOverlapped // should be fixed, if not null
);
[DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
public static extern bool SetFilePointerEx(
SafeFileHandle hFile,
long liDistanceToMove,
out long lpNewFilePointer,
SeekOrigin dwMoveMethod);
我们将使用这些令人讨厌的win32野兽：
// To the metal, baby!
using (var fileHandle = NativeMethods.CreateFile(
// Magic "give me the device" syntax
@"\\.\c:",
// MUST explicitly provide both of these, not ReadWrite
FileAccess.Read | FileAccess.Write,
// MUST explicitly provide both of these, not ReadWrite
FileShare.Write | FileShare.Read,
IntPtr.Zero,
FileMode.Open,
FileAttributes.Normal,
IntPtr.Zero))
{
if (fileHandle.IsInvalid)
{
// Doh!
throw new Win32Exception();
}
else
{
// Boot sector ~ 512 bytes long
byte[] buffer = new byte[512];
NativeOverlapped overlapped = new NativeOverlapped();
NativeMethods.ReadFile(fileHandle, buffer, buffer.Length, IntPtr.Zero, ref overlapped);
// Pin it so we can transmogrify it into a FAT structure
var handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
try
{
// note, I've got an NTFS drive, change yours to suit
var bootSector = (BootSector_NTFS)Marshal.PtrToStructure(
handle.AddrOfPinnedObject(),
typeof(BootSector_NTFS));
哇，哇哇 - 什么是BootSector_NTFS？它是一个字节映射的struct，尽可能接近NTFS结构的样子（包括FAT32）：
[StructLayout(LayoutKind.Sequential, CharSet=CharSet.Ansi, Pack=0)]
public struct JumpBoot
{
[MarshalAs(UnmanagedType.ByValArray, ArraySubType=UnmanagedType.U1, SizeConst=3)]
public byte[] BS_jmpBoot;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst=8)]
public string BS_OEMName;
}
[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Ansi, Pack = 0, Size = 90)]
public struct BootSector_NTFS
{
[FieldOffset(0)]
public JumpBoot JumpBoot;
[FieldOffset(0xb)]
public short BytesPerSector;
[FieldOffset(0xd)]
public byte SectorsPerCluster;
[FieldOffset(0xe)]
public short ReservedSectorCount;
[FieldOffset(0x10)]
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)]
public byte[] Reserved0_MUSTBEZEROs;
[FieldOffset(0x15)]
public byte BPB_Media;
[FieldOffset(0x16)]
public short Reserved1_MUSTBEZERO;
[FieldOffset(0x18)]
public short SectorsPerTrack;
[FieldOffset(0x1A)]
public short HeadCount;
[FieldOffset(0x1c)]
public int HiddenSectorCount;
[FieldOffset(0x20)]
public int LargeSectors;
[FieldOffset(0x24)]
public int Reserved6;
[FieldOffset(0x28)]
public long TotalSectors;
[FieldOffset(0x30)]
public long MftClusterNumber;
[FieldOffset(0x38)]
public long MftMirrorClusterNumber;
[FieldOffset(0x40)]
public byte ClustersPerMftRecord;
[FieldOffset(0x41)]
public byte Reserved7;
[FieldOffset(0x42)]
public short Reserved8;
[FieldOffset(0x44)]
public byte ClustersPerIndexBuffer;
[FieldOffset(0x45)]
public byte Reserved9;
[FieldOffset(0x46)]
public short ReservedA;
[FieldOffset(0x48)]
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 8)]
public byte[] SerialNumber;
[FieldOffset(0x50)]
public int Checksum;
[FieldOffset(0x54)]
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 0x1AA)]
public byte[] BootupCode;
[FieldOffset(0x1FE)]
public ushort EndOfSectorMarker;
public long GetMftAbsoluteIndex(int recordIndex = 0)
{
return (BytesPerSector * SectorsPerCluster * MftClusterNumber) + (GetMftEntrySize() * recordIndex);
}
public long GetMftEntrySize()
{
return (BytesPerSector * SectorsPerCluster * ClustersPerMftRecord);
}
}
// Note: dont have fat32, so can't verify all these...they *should* work, tho
// refs:
// http://www.pjrc.com/tech/8051/ide/fat32.html
// http://msdn.microsoft.com/en-US/windows/hardware/gg463084
[StructLayout(LayoutKind.Explicit, CharSet=CharSet.Auto, Pack=0, Size=90)]
public struct BootSector_FAT32
{
[FieldOffset(0)]
public JumpBoot JumpBoot;
[FieldOffset(11)]
public short BPB_BytsPerSec;
[FieldOffset(13)]
public byte BPB_SecPerClus;
[FieldOffset(14)]
public short BPB_RsvdSecCnt;
[FieldOffset(16)]
public byte BPB_NumFATs;
[FieldOffset(17)]
public short BPB_RootEntCnt;
[FieldOffset(19)]
public short BPB_TotSec16;
[FieldOffset(21)]
public byte BPB_Media;
[FieldOffset(22)]
public short BPB_FATSz16;
[FieldOffset(24)]
public short BPB_SecPerTrk;
[FieldOffset(26)]
public short BPB_NumHeads;
[FieldOffset(28)]
public int BPB_HiddSec;
[FieldOffset(32)]
public int BPB_TotSec32;
[FieldOffset(36)]
public FAT32 FAT;
}
[StructLayout(LayoutKind.Sequential)]
public struct FAT32
{
public int BPB_FATSz32;
public short BPB_ExtFlags;
public short BPB_FSVer;
public int BPB_RootClus;
public short BPB_FSInfo;
public short BPB_BkBootSec;
[MarshalAs(UnmanagedType.ByValArray, SizeConst=12)]
public byte[] BPB_Reserved;
public byte BS_DrvNum;
public byte BS_Reserved1;
public byte BS_BootSig;
public int BS_VolID;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst=11)]
public string BS_VolLab;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst=8)]
public string BS_FilSysType;
}
所以现在我们可以把整个乱七八糟的字节映射回这个结构：
// Pin it so we can transmogrify it into a FAT structure
var handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
try
{
// note, I've got an NTFS drive, change yours to suit
var bootSector = (BootSector_NTFS)Marshal.PtrToStructure(
handle.AddrOfPinnedObject(),
typeof(BootSector_NTFS));
Console.WriteLine(
"I think that the Master File Table is at absolute position:{0}, sector:{1}",
bootSector.GetMftAbsoluteIndex(),
bootSector.GetMftAbsoluteIndex() / bootSector.BytesPerSector);
此时输出：
I think that the Master File Table is at
absolute position:3221225472, sector:6291456
让我们确认快速使用OEM支持工具nfi.exe：
C:\tools\OEMTools\nfi>nfi c:
NTFS File Sector Information Utility.
Copyright (C) Microsoft Corporation 1999. All rights reserved.
File 0
Master File Table ($Mft)
$STANDARD_INFORMATION (resident)
$FILE_NAME (resident)
$DATA (nonresident)
logical sectors 6291456-6487039 (0x600000-0x62fbff)
logical sectors 366267960-369153591 (0x15d4ce38-0x1600d637)
$BITMAP (nonresident)
logical sectors 6291448-6291455 (0x5ffff8-0x5fffff)
logical sectors 7273984-7274367 (0x6efe00-0x6eff7f)
很酷，看起来我们正走在正确的轨道上......前进！
// If you've got LinqPad, uncomment this to look at boot sector
bootSector.Dump();
Console.WriteLine("Jumping to Master File Table...");
long lpNewFilePointer;
if (!NativeMethods.SetFilePointerEx(
fileHandle,
bootSector.GetMftAbsoluteIndex(),
out lpNewFilePointer,
SeekOrigin.Begin))
{
throw new Win32Exception();
}
Console.WriteLine("Position now: {0}", lpNewFilePointer);
// Read in one MFT entry
byte[] mft_buffer = new byte[bootSector.GetMftEntrySize()];
Console.WriteLine("Reading $MFT entry...calculated size: 0x{0}",
bootSector.GetMftEntrySize().ToString("X"));
var seekIndex = bootSector.GetMftAbsoluteIndex();
overlapped.OffsetHigh = (int)(seekIndex >> 32);
overlapped.OffsetLow = (int)seekIndex;
NativeMethods.ReadFile(
fileHandle,
mft_buffer,
mft_buffer.Length,
IntPtr.Zero,
ref overlapped);
// Pin it for transmogrification
var mft_handle = GCHandle.Alloc(mft_buffer, GCHandleType.Pinned);
try
{
var mftRecords = (MFTSystemRecords)Marshal.PtrToStructure(
mft_handle.AddrOfPinnedObject(),
typeof(MFTSystemRecords));
mftRecords.Dump();
}
finally
{
// make sure we clean up
mft_handle.Free();
}
}
finally
{
// make sure we clean up
handle.Free();
}
Argh，更多本土结构要讨论 - 因此MFT的排列方式使得前16个条目“固定”：
[StructLayout(LayoutKind.Sequential)]
public struct MFTSystemRecords
{
public MFTRecord Mft;
public MFTRecord MftMirror;
public MFTRecord LogFile;
public MFTRecord Volume;
public MFTRecord AttributeDefs;
public MFTRecord RootFile;
public MFTRecord ClusterBitmap;
public MFTRecord BootSector;
public MFTRecord BadClusterFile;
public MFTRecord SecurityFile;
public MFTRecord UpcaseTable;
public MFTRecord ExtensionFile;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
public MFTRecord[] MftReserved;
public MFTRecord MftFileExt;
}
MFTRecord的位置：
[StructLayout(LayoutKind.Sequential, Size = 1024)]
public struct MFTRecord
{
const int BASE_RECORD_SIZE = 48;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 4)]
public string Type;
public short UsaOffset;
public short UsaCount;
public long Lsn; /* $LogFile sequence number for this record. Changed every time the record is modified. */
public short SequenceNumber; /* # of times this record has been reused */
public short LinkCount; /* Number of hard links, i.e. the number of directory entries referencing this record. */
public short AttributeOffset; /* Byte offset to the first attribute in this mft record from the start of the mft record. */
public short MftRecordFlags;
public int BytesInUse;
public int BytesAllocated;
public long BaseFileRecord;
public short NextAttributeNumber;
public short Reserved;
public int MftRecordNumber;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 976)]
public byte[] Data;
public byte[] SetData
{
get
{
return this.Data
.Skip(AttributeOffset - BASE_RECORD_SIZE)
.Take(BytesInUse - BASE_RECORD_SIZE)
.ToArray();
}
}
public MftAttribute[] Attributes
{
get
{
var idx = 0;
var ret = new List<MftAttribute>();
while (idx < SetData.Length)
{
var attr = MftAttribute.FromBytes(SetData.Skip(idx).ToArray());
ret.Add(attr);
idx += attr.Attribute.Length;
// A special "END" attribute denotes the end of the list
if (attr.Attribute.AttributeType == MftAttributeType.AT_END) break;
}
return ret.ToArray();
}
}
}
而且......这就是我现在要去的地方;主要是因为我想吃晚餐等。不过我会回到这里来的！
参考文献（部分用于我自己的记忆，部分用于协助其他研究者）
完整代码转储a'以下：
我上面给出的所有本机映射（由于帖子大小限制，而不是完整的重新映射）：
public enum MftRecordFlags : ushort
{
MFT_RECORD_IN_USE = 0x0001,
MFT_RECORD_IS_DIRECTORY = 0x0002,
MFT_RECORD_IN_EXTEND = 0x0004,
MFT_RECORD_IS_VIEW_INDEX = 0x0008,
MFT_REC_SPACE_FILLER = 0xffff
}
public enum MftAttributeType : uint
{
AT_UNUSED = 0,
AT_STANDARD_INFORMATION = 0x10,
AT_ATTRIBUTE_LIST = 0x20,
AT_FILENAME = 0x30,
AT_OBJECT_ID = 0x40,
AT_SECURITY_DESCRIPTOR = 0x50,
AT_VOLUME_NAME = 0x60,
AT_VOLUME_INFORMATION = 0x70,
AT_DATA = 0x80,
AT_INDEX_ROOT = 0x90,
AT_INDEX_ALLOCATION = 0xa0,
AT_BITMAP = 0xb0,
AT_REPARSE_POINT = 0xc0,
AT_EA_INFORMATION = 0xd0,
AT_EA = 0xe0,
AT_PROPERTY_SET = 0xf0,
AT_LOGGED_UTILITY_STREAM = 0x100,
AT_FIRST_USER_DEFINED_ATTRIBUTE = 0x1000,
AT_END = 0xffffffff
}
public enum MftAttributeDefFlags : byte
{
ATTR_DEF_INDEXABLE = 0x02, /* Attribute can be indexed. */
ATTR_DEF_MULTIPLE = 0x04, /* Attribute type can be present multiple times in the mft records of an inode. */
ATTR_DEF_NOT_ZERO = 0x08, /* Attribute value must contain at least one non-zero byte. */
ATTR_DEF_INDEXED_UNIQUE = 0x10, /* Attribute must be indexed and the attribute value must be unique for the attribute type in all of the mft records of an inode. */
ATTR_DEF_NAMED_UNIQUE = 0x20, /* Attribute must be named and the name must be unique for the attribute type in all of the mft records of an inode. */
ATTR_DEF_RESIDENT = 0x40, /* Attribute must be resident. */
ATTR_DEF_ALWAYS_LOG = 0x80, /* Always log modifications to this attribute, regardless of whether it is resident or
non-resident. Without this, only log modifications if the attribute is resident. */
}
[StructLayout(LayoutKind.Explicit)]
public struct MftInternalAttribute
{
[FieldOffset(0)]
public MftAttributeType AttributeType;
[FieldOffset(4)]
public int Length;
[FieldOffset(8)]
[MarshalAs(UnmanagedType.Bool)]
public bool NonResident;
[FieldOffset(9)]
public byte NameLength;
[FieldOffset(10)]
public short NameOffset;
[FieldOffset(12)]
public int AttributeFlags;
[FieldOffset(14)]
public short Instance;
[FieldOffset(16)]
public ResidentAttribute ResidentAttribute;
[FieldOffset(16)]
public NonResidentAttribute NonResidentAttribute;
}
[StructLayout(LayoutKind.Sequential)]
public struct ResidentAttribute
{
public int ValueLength;
public short ValueOffset;
public byte ResidentAttributeFlags;
public byte Reserved;
public override string ToString()
{
return string.Format("{0}:{1}:{2}:{3}", ValueLength, ValueOffset, ResidentAttributeFlags, Reserved);
}
}
[StructLayout(LayoutKind.Sequential)]
public struct NonResidentAttribute
{
public long LowestVcn;
public long HighestVcn;
public short MappingPairsOffset;
public byte CompressionUnit;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)]
public byte[] Reserved;
public long AllocatedSize;
public long DataSize;
public long InitializedSize;
public long CompressedSize;
public override string ToString()
{
return string.Format("{0}:{1}:{2}:{3}:{4}:{5}:{6}:{7}", LowestVcn, HighestVcn, MappingPairsOffset, CompressionUnit, AllocatedSize, DataSize, InitializedSize, CompressedSize);
}
}
public struct MftAttribute
{
public MftInternalAttribute Attribute;
[field: NonSerialized]
public string Name;
[field: NonSerialized]
public byte[] Data;
[field: NonSerialized]
public object Payload;
public static MftAttribute FromBytes(byte[] buffer)
{
var hnd = GCHandle.Alloc(buffer, GCHandleType.Pinned);
try
{
var attr = (MftInternalAttribute)Marshal.PtrToStructure(hnd.AddrOfPinnedObject(), typeof(MftInternalAttribute));
var ret = new MftAttribute() { Attribute = attr };
ret.Data = buffer.Skip(Marshal.SizeOf(attr)).Take(attr.Length).ToArray();
if (ret.Attribute.AttributeType == MftAttributeType.AT_STANDARD_INFORMATION)
{
var payloadHnd = GCHandle.Alloc(ret.Data, GCHandleType.Pinned);
try
{
var payload = (MftStandardInformation)Marshal.PtrToStructure(payloadHnd.AddrOfPinnedObject(), typeof(MftStandardInformation));
ret.Payload = payload;
}
finally
{
payloadHnd.Free();
}
}
return ret;
}
finally
{
hnd.Free();
}
}
}
[StructLayout(LayoutKind.Sequential)]
public struct MftStandardInformation
{
public ulong CreationTime;
public ulong LastDataChangeTime;
public ulong LastMftChangeTime;
public ulong LastAccessTime;
public int FileAttributes;
public int MaximumVersions;
public int VersionNumber;
public int ClassId;
public int OwnerId;
public int SecurityId;
public long QuotaChanged;
public long Usn;
}
// Note: dont have fat32, so can't verify all these...they *should* work, tho
// refs:
// http://www.pjrc.com/tech/8051/ide/fat32.html
// http://msdn.microsoft.com/en-US/windows/hardware/gg463084
[StructLayout(LayoutKind.Explicit, CharSet = CharSet.Auto, Pack = 0, Size = 90)]
public struct BootSector_FAT32
{
[FieldOffset(0)]
public JumpBoot JumpBoot;
[FieldOffset(11)]
public short BPB_BytsPerSec;
[FieldOffset(13)]
public byte BPB_SecPerClus;
[FieldOffset(14)]
public short BPB_RsvdSecCnt;
[FieldOffset(16)]
public byte BPB_NumFATs;
[FieldOffset(17)]
public short BPB_RootEntCnt;
[FieldOffset(19)]
public short BPB_TotSec16;
[FieldOffset(21)]
public byte BPB_Media;
[FieldOffset(22)]
public short BPB_FATSz16;
[FieldOffset(24)]
public short BPB_SecPerTrk;
[FieldOffset(26)]
public short BPB_NumHeads;
[FieldOffset(28)]
public int BPB_HiddSec;
[FieldOffset(32)]
public int BPB_TotSec32;
[FieldOffset(36)]
public FAT32 FAT;
}
[StructLayout(LayoutKind.Sequential)]
public struct FAT32
{
public int BPB_FATSz32;
public short BPB_ExtFlags;
public short BPB_FSVer;
public int BPB_RootClus;
public short BPB_FSInfo;
public short BPB_BkBootSec;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 12)]
public byte[] BPB_Reserved;
public byte BS_DrvNum;
public byte BS_Reserved1;
public byte BS_BootSig;
public int BS_VolID;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 11)]
public string BS_VolLab;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
public string BS_FilSysType;
}
测试工具：
class Program
{
static void Main(string[] args)
{
// To the metal, baby!
using (var fileHandle = NativeMethods.CreateFile(
// Magic "give me the device" syntax
@"\\.\c:",
// MUST explicitly provide both of these, not ReadWrite
FileAccess.Read | FileAccess.Write,
// MUST explicitly provide both of these, not ReadWrite
FileShare.Write | FileShare.Read,
IntPtr.Zero,
FileMode.Open,
FileAttributes.Normal,
IntPtr.Zero))
{
if (fileHandle.IsInvalid)
{
// Doh!
throw new Win32Exception();
}
else
{
// Boot sector ~ 512 bytes long
byte[] buffer = new byte[512];
NativeOverlapped overlapped = new NativeOverlapped();
NativeMethods.ReadFile(fileHandle, buffer, buffer.Length, IntPtr.Zero, ref overlapped);
// Pin it so we can transmogrify it into a FAT structure
var handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
try
{
// note, I've got an NTFS drive, change yours to suit
var bootSector = (BootSector_NTFS)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(BootSector_NTFS));
Console.WriteLine(
"I think that the Master File Table is at absolute position:{0}, sector:{1}",
bootSector.GetMftAbsoluteIndex(),
bootSector.GetMftAbsoluteIndex() / bootSector.BytesPerSector);
Console.WriteLine("MFT record size:{0}", bootSector.ClustersPerMftRecord * bootSector.SectorsPerCluster * bootSector.BytesPerSector);
// If you've got LinqPad, uncomment this to look at boot sector
bootSector.DumpToHtmlString();
Pause();
Console.WriteLine("Jumping to Master File Table...");
long lpNewFilePointer;
if (!NativeMethods.SetFilePointerEx(fileHandle, bootSector.GetMftAbsoluteIndex(), out lpNewFilePointer, SeekOrigin.Begin))
{
throw new Win32Exception();
}
Console.WriteLine("Position now: {0}", lpNewFilePointer);
// Read in one MFT entry
byte[] mft_buffer = new byte[bootSector.GetMftEntrySize()];
Console.WriteLine("Reading $MFT entry...calculated size: 0x{0}", bootSector.GetMftEntrySize().ToString("X"));
var seekIndex = bootSector.GetMftAbsoluteIndex();
overlapped.OffsetHigh = (int)(seekIndex >> 32);
overlapped.OffsetLow = (int)seekIndex;
NativeMethods.ReadFile(fileHandle, mft_buffer, mft_buffer.Length, IntPtr.Zero, ref overlapped);
// Pin it for transmogrification
var mft_handle = GCHandle.Alloc(mft_buffer, GCHandleType.Pinned);
try
{
var mftRecords = (MFTSystemRecords)Marshal.PtrToStructure(mft_handle.AddrOfPinnedObject(), typeof(MFTSystemRecords));
mftRecords.DumpToHtmlString();
}
finally
{
// make sure we clean up
mft_handle.Free();
}
}
finally
{
// make sure we clean up
handle.Free();
}
}
}
Pause();
}
private static void Pause()
{
Console.WriteLine("Press enter to continue...");
Console.ReadLine();
}
}
public static class Dumper
{
public static string DumpToHtmlString<T>(this T objectToSerialize)
{
string strHTML = "";
try
{
var writer = LINQPad.Util.CreateXhtmlWriter(true);
writer.Write(objectToSerialize);
strHTML = writer.ToString();
}
catch (Exception exc)
{
Debug.Assert(false, "Investigate why ?" + exc);
}
var shower = new Thread(
() =>
{
var dumpWin = new Window();
var browser = new WebBrowser();
dumpWin.Content = browser;
browser.NavigateToString(strHTML);
dumpWin.ShowDialog();
});
shower.SetApartmentState(ApartmentState.STA);
shower.Start();
return strHTML;
}
public static string Dump(this object value)
{
return JsonConvert.SerializeObject(value, Formatting.Indented);
}
}
答案 1 :(得分：7)
但如果你需要这样做，我想我可以给你一张“餐巾背面的草图”来帮助你开始：
您可以利用NTFS的“稀疏文件”支持，通过调整LCN / VCN映射来简单地添加“间隙”。完成后，只需打开文件，寻找新位置并写入数据。 NTFS将透明地分配空间并在文件中间写入数据，在那里您创建了一个洞。
有关更多信息，请查看此页面中有关NTFS中defragmentation support的内容，以获取有关如何稍微操作并允许您在文件中间插入群集的提示。至少通过使用受制裁的API进行此类操作，您不太可能破坏文件系统而无法修复，尽管您仍然可能会严重阻塞文件，我想。
获取所需文件的检索指针，将它们拆分到所需位置，添加所需的额外空间，然后移动文件。在Russinovich / Ionescu“Windows Internals”一书（http://www.amazon.com/Windows%C2%AE-Internals-Including-Windows-Developer/dp/0735625301）中有一个关于此类事情的有趣章节
答案 2 :(得分：2)
抽象问题，抽象答案：
当然可以在FAT中执行此操作，并且可能在大多数其他FS中，您实际上是将文件分段，而不是更常见的碎片整理过程。
FAT是围绕群集指针组织的，它产生一组存储数据的簇编号，第一个链接索引与文件记录一起存储，第二个链接索引存储在索引[第一个链接的编号]的分配表中只要您插入的数据在群集的边界处结束，就可以在链中的任何位置插入另一个链接。
通过查找open source library，您可以更轻松地在C中执行此操作 。虽然可能在C＃中使用PInvoke来实现这一点，但是你找不到任何好的示例代码可供你开始使用。
我怀疑你无法控制文件格式（视频文件？），如果你这样做，设计数据存储会更容易，以避免问题。
答案 3 :(得分：2)
您不需要（也可能不会）修改文件访问表。您可以使用过滤器驱动程序或可堆叠FS来实现相同的功能。让我们考虑4K的簇大小。我只是因为我最后解释的原因而写出设计。
创建新文件将在标题中显示文件的布局图。标题将提及条目数和条目列表。标头的大小将与群集的大小相同。为简单起见，让标题具有4K条目的固定大小。例如，假设有一个说20KB的文件，标题可能会提到：[DWORD：5] [DWORD：1] [DWORD：2] [DWORD：3] [DWORD：4] [DWORD：5]。此文件目前没有插入。
假设有人在扇区3之后插入一个簇。您可以将它添加到文件末尾并将布局图更改为：[5] [1] [2] [3] [5] [6 ] [4]
假设某人需要寻求群集4.您需要访问布局图并计算偏移量然后寻找它。它将在前5个集群之后，因此将从16K开始。
假设有人以串行方式读取或写入文件。读取和写入必须以相同的方式映射。
假设标题只剩下一个条目：我们需要通过使用与上面其他指针相同的格式指向文件末尾的新簇来扩展它。要知道我们有多个集群，我们需要做的就是查看项目数量并计算存储它所需的集群数量。
您可以在Windows上使用过滤器驱动程序或在Linux上使用可堆叠文件系统（LKM）实现上述所有操作。实现基本功能水平是一个难度很高的研究生迷你项目。将其作为商业文件系统工作可能非常具有挑战性，尤其是因为您不希望影响IO速度。
请注意，上述过滤器不会受到磁盘布局/碎片整理等任何更改的影响。如果您认为自己的文件有用，也可以对其进行碎片整理。
答案 4 :(得分：2)
没有。您在Windows中无法直接询问的内容。
这是因为在Windows中，文件是逻辑上连续的字节集合，如果不覆盖，则无法在文件中间插入字节。
为了理解原因，让我们进行一次思考实验，看看它是否可能意味着什么。
首先，内存映射文件会突然变得复杂得多。如果我们将文件映射到特定地址，然后在其中间添加一些额外的字节，这对于内存映射意味着什么？内存映射现在突然移动了吗？如果是这样，该程序会发生什么，并不期望它呢？
其次，让我们考虑如果两个句柄对同一个文件打开，GetFilePointer会发生什么，并且在该文件的中间插入一个额外的字节。假设进程A打开文件进行读取，进程B打开它进行读写。
进程A想要在执行一些读取时保存它的位置，因此它会编写一些代码，如
DWORD DoAndThenRewind(HANDLE hFile, FARPROC fp){
DWORD result;
LARGEINTEGER zero = { 0 };
LARGEINTEGER li;
SetFilePointer(hFile, zero, &li, FILE_CURRENT);
result = fp();
SetFilePointer(hFile, &li, &li, FILE_BEGIN);
return result;
}
现在，如果进程B想在文件中插入一些额外的字节，该函数会发生什么？好吧，如果我们在当前进程A之后添加字节，一切都很好 - 文件指针（从文件开头起的线性地址）前后保持不变，一切都很好。
但是如果我们在之前在中添加额外的字节，那么突然我们捕获的文件指针都会错位，并且会发生不好的事情。
或者换句话说，在文件中间添加字节意味着我们突然需要发明更聪明的方法来描述我们在文件中的位置以进行倒带，因为文件不再是逻辑上连续的选择字节。
所以到目前为止我们已经讨论过为什么Windows暴露这种功能可能是一个坏主意;但这并没有真正回答“它实际上是否可能”的问题。这里的答案仍然是否定的。这是不可能的。
为什么呢？因为没有这样的功能暴露给用户模式程序来执行此操作。作为用户模式程序，您有一种获取文件句柄的机制（NtCreateFile / NtOpenFile），您可以通过NtReadFile / NtWriteFile读取和写入它，您可以通过NtSetFileInformation查找并重命名并删除它，然后您可以通过NtClose释放句柄引用。
即使在内核模式下，您也没有更多选项。文件系统API是从您身上抽象出来的，文件系统将文件视为逻辑上连续的字节集合，而不是字节范围的链接列表或任何可以轻松公开方法以便在中间插入非重写字节的方法。一个文件。
这并不是说 per-se 是不可能的。正如其他人所提到的，您可以打开磁盘本身，假装是NTFS并直接更改分配给特定FCB的磁盘集群。但这样做是勇敢的。 NTFS几乎没有文档记录，很复杂，可能会发生变化，即使操作系统没有安装它也很难修改，更不用说它是什么时候。
所以答案是，我害怕是没有。通过普通的安全Windows机制无法将额外的字节作为插入而不是作为覆盖操作添加到文件的中间。
相反，请考虑查看您的问题，看看是否适合将文件分块为较小的文件并具有索引文件。这样您就可以修改索引文件以插入额外的块。通过打破对需要驻留在一个文件中的数据的依赖，您会发现更容易避免文件系统要求文件是逻辑上连续的字节集合。然后，您就可以修改索引文件，为“pseduofile”添加额外的块，而无需将整个伪文件读入内存。
答案 5 :(得分：1)
您是否了解在非对齐位置插入非对齐数据几乎99.99％？ （也许可以使用基于压缩的一些黑客。）我认为你这样做。
“最简单”的解决方案是创建稀疏运行记录，然后写入稀疏范围。
答案 6 :(得分：1)
这一切都取决于原始问题是什么，这就是你想要实现的目标。修改FAT / NTFS表不是问题，它可以解决您的问题 - 可能是优雅和高效的，但更可能是非常危险和不合适的。你提到你无法控制用户＆＃39;它将被使用的系统，因此大概至少其中一些管理员会反对入侵文件系统内部。
无论如何，让我们回到这个问题。鉴于信息不完整，可能会想到几个用例，根据用例的不同，解决方案将变得容易或困难。
如果您知道编辑后文件不再需要一段时间，那么在半秒内保存编辑很容易 - 只需关闭窗口并让应用程序完成保存即可背景，即使需要半个小时。我知道这听起来很愚蠢，但这是一个常见的用例 - 一旦你完成了文件的编辑，就可以保存它，关闭程序，而且你不再需要那个文件很久了。
除非你这样做。也许用户决定再编辑一些，或者可能是另一个用户。在这两种情况下，您的应用程序都可以轻松检测到文件正在保存到硬盘中（例如，在保存主文件时，您可能有一个隐藏的保护文件）。在这种情况下，您将按原样打开文件（部分保存），但向用户显示文件的自定义视图，使其看起来好像文件处于最终状态。毕竟，您拥有关于哪些文件块必须移动到哪里的所有信息。
除非用户需要立即在另一个编辑器中打开文件（这不是一个非常常见的情况，特别是对于非常专业的文件格式，但是谁知道）。如果是这样，您是否可以访问该其他编辑器的源代码？或者你可以和那个其他编辑器的开发人员交谈，并说服他们将未完成保存的文件当作最终状态处理（它并不那么难 - 只需从中读取偏移信息即可警卫文件）。我认为其他编辑的开发人员同样对长时间保存感到沮丧，并乐意接受您的解决方案，因为它可以帮助他们的产品。
我们还能拥有什么？也许用户想要立即将文件复制或移动到其他地方。微软可能不会为了您的利益而改变Windows资源管理器。在这种情况下，您需要实现UMDF驱动程序，或明确禁止用户这样做（例如重命名原始文件并隐藏它，在其位置留下一个空白占位符;当用户尝试至少复制文件时他知道出了什么问题。
如果您事先知道 将编辑哪些文件，则会出现另一种不适合上述层次结构1-4的可能性。在这种情况下，您可以预先稀疏＆＃34;文件沿文件卷均匀插入随机间隙。这是由于您提到的文件格式的特殊性质：如果链接正确指向下一个数据块，则可能存在无数据缺口。如果您知道哪些文件将被编辑（不是不合理的假设 - 您的硬盘驱动器周围有多少个10Gb文件？）您＆＃34;膨胀＆＃34;用户开始编辑之前的文件（比如前一天晚上），然后在需要插入新数据时移动这些较小的数据块。这当然也依赖于你不必插入TOO的假设。
在任何情况下，根据用户的实际需求，总会有多个答案。但我的建议来自设计师的观点，而非来自程序员的观点。
答案 7 :(得分：0)
还有一种可能。
创建一个用户模式文件系统，例如使用 FUSE 或 Dokan，并且您设计来保存单个文件。从那里，您可以使用任何您想要的解决方案，包括将多个文件的片段连接在一起，使某些内容看起来好像是一个大文件。
然后创建指向该文件的符号链接。
答案 8 :(得分：-1)
已编辑 - 另一种方法 - 如何切换到Mac执行此任务？它们具有卓越的编辑功能和自动化功能！
已编辑 - 原始规格表明文件正在被修改很多，而是被修改一次。建议其他人指出在后台进行操作：复制到新文件，删除旧文件，将新文件重命名为旧文件。
我会放弃这种做法。您正在寻找数据库./YR