Esempio n. 1
0
        unsafe public static bool QueryUSNJournal(IntPtr pVolume, out PInvokeWin32.USN_JOURNAL_DATA ujd, out uint bytesReturned)
        {
            bool bOK = PInvokeWin32.DeviceIoControl(
                pVolume, PInvokeWin32.FSCTL_QUERY_USN_JOURNAL,
                IntPtr.Zero,
                0,
                out ujd,
                sizeof(PInvokeWin32.USN_JOURNAL_DATA),
                out bytesReturned,
                IntPtr.Zero
                );

            return(bOK);
        }
Esempio n. 2
0
        unsafe private static void EnumerateFiles(string volumeName, IntPtr pVolume, IntPtr medBuffer, ref List <MyEverythingRecord> files, ref List <MyEverythingRecord> folders)
        {
            IntPtr pData = Marshal.AllocHGlobal(sizeof(UInt64) + 0x10000);

            PInvokeWin32.ZeroMemory(pData, sizeof(UInt64) + 0x10000);
            uint outBytesReturned = 0;

            while (false != PInvokeWin32.DeviceIoControl(pVolume, PInvokeWin32.FSCTL_ENUM_USN_DATA, medBuffer,
                                                         sizeof(PInvokeWin32.MFT_ENUM_DATA), pData, sizeof(UInt64) + 0x10000, out outBytesReturned,
                                                         IntPtr.Zero))
            {
                IntPtr pUsnRecord = new IntPtr(pData.ToInt32() + sizeof(Int64));
                while (outBytesReturned > 60)
                {
                    PInvokeWin32.USN_RECORD usn = new PInvokeWin32.USN_RECORD(pUsnRecord);

                    if (usn.IsFolder)
                    {
                        folders.Add(new MyEverythingRecord {
                            Name      = usn.FileName,
                            ParentFrn = usn.ParentFRN,
                            FRN       = usn.FRN,
                            IsFolder  = true, VolumeName = volumeName
                        });
                    }
                    else
                    {
                        files.Add(new MyEverythingRecord {
                            Name      = usn.FileName,
                            ParentFrn = usn.ParentFRN,
                            FRN       = usn.FRN,
                            IsFolder  = false, VolumeName = volumeName
                        });
                    }

                    pUsnRecord        = new IntPtr(pUsnRecord.ToInt32() + usn.RecordLength);
                    outBytesReturned -= usn.RecordLength;
                }
                Marshal.WriteInt64(medBuffer, Marshal.ReadInt64(pData, 0));
            }
            Marshal.FreeHGlobal(pData);
        }
Esempio n. 3
0
        private void MonitorThread(object param)
        {
            MyEverythingDB db      = (param as Dictionary <string, object>)["MyEverythingDB"] as MyEverythingDB;
            string         volume  = (param as Dictionary <string, object>)["Volume"] as string;
            IntPtr         pbuffer = Marshal.AllocHGlobal(0x1000);                                    // 构建输出参数

            PInvokeWin32.READ_USN_JOURNAL_DATA rujd = SetupInputData4JournalRead(volume, 0xFFFFFFFF); // 对所有类型的reason都监听
            UInt32 cbRead;                                                                            // 用来存储实际输出的字节数
            IntPtr prujd;                                                                             // 指向输入参数结构体的指针

            while (true)
            {
                // 构建输入参数的指针
                prujd = Marshal.AllocHGlobal(Marshal.SizeOf(rujd));
                PInvokeWin32.ZeroMemory(prujd, Marshal.SizeOf(rujd));
                Marshal.StructureToPtr(rujd, prujd, true);

                Debug.WriteLine(string.Format("\nMoniting on {0}......", volume));
                IntPtr pVolume = MyEverything.GetVolumeJournalHandle(volume);

                bool fok = PInvokeWin32.DeviceIoControl(pVolume,
                                                        PInvokeWin32.FSCTL_READ_USN_JOURNAL,
                                                        prujd, Marshal.SizeOf(typeof(PInvokeWin32.READ_USN_JOURNAL_DATA)),
                                                        pbuffer, 0x1000, out cbRead, IntPtr.Zero);

                IntPtr pRealData = new IntPtr(pbuffer.ToInt32() + Marshal.SizeOf(typeof(Int64)));                 // 返回的内存块头上的8个字节是一个usn_id, 从第9个字节开始才是record.
                uint   offset    = 0;

                if (fok)
                {
                    while (offset + Marshal.SizeOf(typeof(Int64)) < cbRead)                       // record可能有多个!
                    {
                        PInvokeWin32.USN_RECORD usn = new PInvokeWin32.USN_RECORD(new IntPtr(pRealData.ToInt32() + (int)offset));
                        ProcessUSN(usn, volume, db);
                        offset += usn.RecordLength;
                    }
                }

                Marshal.FreeHGlobal(prujd);
                rujd.StartUsn = Marshal.ReadInt64(pbuffer);                 // 返回的内存块头上的8个字节就是用来在进行下一次查询的
            }
        }
Esempio n. 4
0
        unsafe public static void EnableVomuleJournal(IntPtr pVolume)
        {
            UInt64 MaximumSize     = 0x800000;
            UInt64 AllocationDelta = 0x100000;
            UInt32 cb;

            PInvokeWin32.CREATE_USN_JOURNAL_DATA cujd;
            cujd.MaximumSize     = MaximumSize;
            cujd.AllocationDelta = AllocationDelta;

            int    sizeCujd   = Marshal.SizeOf(cujd);
            IntPtr cujdBuffer = Marshal.AllocHGlobal(sizeCujd);

            PInvokeWin32.ZeroMemory(cujdBuffer, sizeCujd);
            Marshal.StructureToPtr(cujd, cujdBuffer, true);

            bool fOk = PInvokeWin32.DeviceIoControl(pVolume, PInvokeWin32.FSCTL_CREATE_USN_JOURNAL,
                                                    cujdBuffer, sizeCujd, IntPtr.Zero, 0, out cb, IntPtr.Zero);

            if (!fOk)
            {
                throw new IOException("DeviceIoControl() returned false", new Win32Exception(Marshal.GetLastWin32Error()));
            }
        }