开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 文件操作 > 查看源码
FILEMON.C
资源名称：filesrc.zip　[点击查看]
上传用户：hmgghm
上传日期：2007-01-07
资源大小：335k
文件大小：48k
源码类别：

文件操作

开发平台：

Visual C++

FILEMON.C：源码内容
  1. //======================================================================
  2. //
  3. // FILEMON.c - main module for VxD FILEMON
  4. //
  5. // By Mark Russinovich and Bryce Cogswell
  6. //
  7. //======================================================================
  8. #define   DEVICE_MAIN
  9. #include  <vtoolsc.h>
  10. #include  "..guiioctlcmd.h"
  11. #include  "filemon.h"
  12. #undef    DEVICE_MAIN
  14. #if DEBUG
  15. #define dprint(arg) dprintf arg
  16. #else
  17. #define dprint(arg)
  18. #endif
  20. //----------------------------------------------------------------------
  21. //                     G L O B A L   D A T A 
  22. //----------------------------------------------------------------------
  24. //
  25. // Indicates if the GUI wants activity to be logged
  26. //
  27. BOOLEAN                 FilterOn = FALSE;
  29. //
  30. // Global filter (sent to us by the GUI)
  31. //
  32. FILTER                  FilterDef;
  34. //
  35. // Array of process and path filters 
  36. //
  37. ULONG                   NumIncludeFilters = 0;
  38. PCHAR                   IncludeFilters[MAXFILTERS];
  39. ULONG                   NumExcludeFilters = 0;
  40. PCHAR                   ExcludeFilters[MAXFILTERS];
  42. //
  43. // Real service pointers with the hook thunks
  44. //
  45. ppIFSFileHookFunc       PrevIFSHookProc;
  47. //
  48. // Hash table data 
  49. //
  50. PHASH_ENTRY         HashTable[NUMHASH];
  52. //
  53. // List of freed entries (to save some allocation calls)
  54. //
  55. PHASH_ENTRY         FreeEntries = NULL;
  57. //
  58. // Buffer data
  59. //
  60. PSTORE_BUF         Store  = NULL;
  61. ULONG         Sequence  = 0;
  63. //
  64. // Maximum amount of buffers we will grab for buffered unread data
  65. //
  66. ULONG         NumStore  = 0;
  67. ULONG         MaxStore  = 5;
  69. //
  70. // Semaphore for critical sections
  71. //
  72. SEMHANDLE               StoreMutex, HashMutex, FilterMutex;
  74. //
  75. // Unknown error string
  76. //
  77. CHAR                    errstring[32];
  79. //
  80. // Measuring duration or absolute time
  81. //
  82. BOOLEAN                 TimeIsDuration = TRUE;
  85. //----------------------------------------------------------------------
  86. //                   V X D  C O N T R O L
  87. //----------------------------------------------------------------------
  89. //
  90. // Device declaration
  91. //
  92. Declare_Virtual_Device(FILEMON)
  94. //
  95. // Message handlers - we only care about dynamic loading and unloading
  96. //
  97.     DefineControlHandler(SYS_DYNAMIC_DEVICE_INIT, OnSysDynamicDeviceInit);
  98.     DefineControlHandler(SYS_DYNAMIC_DEVICE_EXIT, OnSysDynamicDeviceExit);
  99.     DefineControlHandler(W32_DEVICEIOCONTROL, OnW32Deviceiocontrol);
  101. //----------------------------------------------------------------------
  102. // 
  103. // ControlDispatcher
  104. //
  105. // Multiplexes incoming VxD messages from Windows to their handlers.
  106. //
  107. //----------------------------------------------------------------------
  108.     BOOL __cdecl ControlDispatcher(
  109.         DWORD dwControlMessage,
  110.         DWORD EBX,
  111.         DWORD EDX,
  112.         DWORD ESI,
  113.         DWORD EDI,
  114.         DWORD ECX)
  115. {
  116.     START_CONTROL_DISPATCH
  118.         ON_SYS_DYNAMIC_DEVICE_INIT(OnSysDynamicDeviceInit);
  119.     ON_SYS_DYNAMIC_DEVICE_EXIT(OnSysDynamicDeviceExit);
  120.     ON_W32_DEVICEIOCONTROL(OnW32Deviceiocontrol);
  122.     END_CONTROL_DISPATCH
  124.         return TRUE;
  125. }
  127. //----------------------------------------------------------------------
  128. //      P A T T E R N   M A T C H I N G   R O U T I N E S
  129. //----------------------------------------------------------------------
  132. //----------------------------------------------------------------------
  133. //
  134. // MatchOkay
  135. //
  136. // Only thing left after compare is more mask. This routine makes
  137. // sure that its a valid wild card ending so that its really a match.
  138. //
  139. //----------------------------------------------------------------------
  140. BOOLEAN MatchOkay( PCHAR Pattern )
  141. {
  142.     //
  143.     // If pattern isn't empty, it must be a wildcard
  144.     //
  145.     if( *Pattern && *Pattern != '*' ) {
  146.  
  147.         return FALSE;
  148.     }
  150.     //
  151.     // Matched
  152.     //
  153.     return TRUE;
  154. }
  157. //----------------------------------------------------------------------
  158. //
  159. // MatchWithPattern
  160. //
  161. // Performs nifty wildcard comparison.
  162. //
  163. //----------------------------------------------------------------------
  164. BOOLEAN MatchWithPattern( PCHAR Pattern, PCHAR Name )
  165. {
  166.     CHAR   upcase;
  168.     //
  169.     // End of pattern?
  170.     //
  171.     if( !*Pattern ) {
  173.         return FALSE;
  174.     }
  176.     //
  177.     // If we hit a wild card, do recursion
  178.     //
  179.     if( *Pattern == '*' ) {
  181.         Pattern++;
  183.         while( *Name && *Pattern ) {
  185.             if( *Name >= 'a' && *Name <= 'z' )
  186.                 upcase = *Name - 'a' + 'A';
  187.             else
  188.                 upcase = *Name;
  190.             //
  191.             // See if this substring matches
  192.             //
  193.             if( *Pattern == upcase || *Name == '*' ) {
  195.                 if( MatchWithPattern( Pattern+1, Name+1 )) {
  197.                     return TRUE;
  198.                 }
  199.             }
  201.             //
  202.             // Try the next substring
  203.             //
  204.             Name++;
  205.         }
  207.         //
  208.         // See if match condition was met
  209.         //
  210.         return MatchOkay( Pattern );
  211.     } 
  213.     //
  214.     // Do straight compare until we hit a wild card
  215.     //
  216.     while( *Name && *Pattern != '*' ) {
  218.         if( *Name >= 'a' && *Name <= 'z' )
  219.             upcase = *Name - 'a' + 'A';
  220.         else
  221.             upcase = *Name;
  223.         if( *Pattern == upcase ) {
  225.             Pattern++;
  226.             Name++;
  228.         } else {
  230.             return FALSE;
  231.         }
  232.     }
  234.     //
  235.     // If not done, recurse
  236.     //
  237.     if( *Name ) {
  239.         return MatchWithPattern( Pattern, Name );
  240.     }
  242.     //
  243.     // Make sure its a match
  244.     //
  245.     return MatchOkay( Pattern );
  246. }
  248. //----------------------------------------------------------------------
  249. //            B U F F E R   M A N A G E M E N T
  250. //----------------------------------------------------------------------
  252. //----------------------------------------------------------------------
  253. //
  254. // FilemonFreeStore
  255. //
  256. // Frees all the data output buffers that we have currently allocated.
  257. //
  258. //----------------------------------------------------------------------
  259. VOID FilemonFreeStore()
  260. {
  261.     PSTORE_BUF  prev;
  262.     
  263.     //
  264.     // Just traverse the list of allocated output buffers
  265.     //
  266.     while( Store ) {
  268.         prev = Store->Next;
  269.         PageFree( (MEMHANDLE) Store, 0 );
  270.         Store = prev;
  271.     }
  272. }
  275. //----------------------------------------------------------------------
  276. //
  277. // FilemonNewStore
  278. //
  279. // Called when the current buffer has filled up. This moves us to the
  280. // pre-allocated buffer and then allocates another buffer.
  281. //
  282. // Returns FALSE if another thread is already allocating a buffer.
  283. //
  284. //----------------------------------------------------------------------
  285. BOOLEAN FilemonNewStore( void )
  286. {
  287.     PSTORE_BUF prev = Store, newstore;
  288.     static busyAllocating = FALSE;
  290.     //
  291.     // If we have maxed out or haven't accessed the current store
  292.     // just return.
  293.     //
  294.     if( MaxStore == NumStore ) {
  296.         Store->Len = 0;
  297.         return TRUE;
  298.     }
  300.     //
  301.     // If the output buffer we currently are using is empty, just
  302.     // use it, or if we are busy already allocating a buffer, return
  303.     //
  304.     if( !Store->Len || busyAllocating ) 
  305.         return !busyAllocating;
  307.     //
  308.     // Allocate a new output buffer. Release lock to prevent deadlock
  309.     // on reentrance (allocating memory can result in file I/O
  310.     //
  311.     busyAllocating = TRUE;
  312.     Signal_Semaphore( StoreMutex );
  314.     PageAllocate(STORESIZE, PG_SYS, 0, 0, 0, 0, NULL, PAGELOCKED, 
  315.                  (PMEMHANDLE) &newstore, (PVOID) &newstore );
  317.     Wait_Semaphore( StoreMutex, BLOCK_SVC_INTS );
  318.     busyAllocating = FALSE;
  320.     if( newstore ) { 
  322.         //
  323.         // Allocation was successful so add the buffer to the list
  324.         // of allocated buffers and increment the buffer count.
  325.         //
  326.         Store   = newstore;
  327.         Store->Len  = 0;
  328.         Store->Next = prev;
  329.         NumStore++;
  331.     } else {
  333.         //
  334.         // The allocation failed - just reuse the current buffer
  335.         //
  336.         Store->Len = 0;
  337.     }
  338.     Signal_Semaphore( StoreMutex );
  339.     return TRUE;
  340. }
  343. //----------------------------------------------------------------------
  344. //
  345. // FilemonOldestStore
  346. //
  347. // Goes through the linked list of storage buffers and returns the 
  348. // oldest one.
  349. //
  350. //----------------------------------------------------------------------
  351. PSTORE_BUF FilemonOldestStore( void )
  352. {
  353.     PSTORE_BUF  ptr = Store, prev = NULL;
  355.     //
  356.     // Traverse the list
  357.     //    
  358.     while ( ptr->Next ) {
  360.         ptr = (prev = ptr)->Next;
  361.     }
  363.     //
  364.     // Remove the buffer from the list
  365.     //
  366.     if ( prev ) {
  368.         prev->Next = NULL;    
  369.     }
  370.     NumStore--;
  371.     return ptr;
  372. }
  375. //----------------------------------------------------------------------
  376. //
  377. // FilemonResetStore
  378. //
  379. // When a GUI is no longer communicating with us, but we can't unload,
  380. // we reset the storage buffers.
  381. //
  382. //----------------------------------------------------------------------
  383. VOID FilemonResetStore()
  384. {
  385.     PSTORE_BUF  current, next;
  387.     //
  388.     // Traverse the list of output buffers
  389.     //
  390.     current = Store->Next;
  391.     while( current ) {
  393.         //
  394.         // Free the buffer
  395.         //
  396.         next = current->Next;
  398.         PageFree( (MEMHANDLE) current, 0 );
  400.         current = next;
  401.     }
  403.     // 
  404.     // Move the output pointer in the buffer that's being kept
  405.     // the start of the buffer.
  406.     // 
  407.     Store->Len = 0;
  408.     Store->Next = NULL;
  409. }
  412. //----------------------------------------------------------------------
  413. //
  414. // UpdateStore
  415. //
  416. // Add a new string to Store, if it fits.
  417. //
  418. //----------------------------------------------------------------------
  419. void UpdateStore( ULONG seq, ULONG time, const char * format, ... )
  420. {
  421.     PENTRY Entry;
  422.     ULONG len;
  423.     va_list arg_ptr;
  424.     CHAR        text[MAXPATHLEN];
  426.     //
  427.     // If no filtering is desired, don't bother
  428.     //
  429.     if( !FilterOn ) {
  430.  
  431.         return;
  432.     }
  434.     //
  435.     // Lock the output buffer.
  436.     //
  437.     Wait_Semaphore( StoreMutex, BLOCK_SVC_INTS );
  439.     //
  440.     // Vsprintf to determine length of the buffer
  441.     //
  442.     _asm cld;
  443.     va_start( arg_ptr, format );
  444.     len = vsprintf( text, format, arg_ptr );
  445.     va_end( arg_ptr );
  447.     //
  448.     // If the current output buffer is near capacity, move to a new
  449.     // output buffer
  450.     //
  451.     if( (ULONG) (Store->Len + len + sizeof(ENTRY) +1) >= MAX_STORE ) {
  453.         if( !FilemonNewStore() ) {
  454.   
  455.             //
  456.             // Just return if a thread is in the process
  457.             // of allocating a buffer.
  458.             //
  459.             Signal_Semaphore( StoreMutex );
  460.             return;
  461.         }
  462.     } 
  464.     //
  465.     // Extract the sequence number and store it
  466.     //
  467.     Entry = (void *)(Store->Data+Store->Len);
  468.     Entry->seq = seq;
  469.     Entry->time.u.LowPart = time;
  470.     Entry->time.u.HighPart = 0;
  471.     _asm cld;
  472.     memcpy( Entry->text, text, len + 1 );
  473.  
  474.     //
  475.     // Store the length of the string, plus 1 for the terminating
  476.     // NULL  
  477.     //   
  478.     Store->Len += (Entry->text - (PCHAR) Entry) + len + 1;
  479.  
  480.     //
  481.     // Release the output buffer lock
  482.     //
  483.     Signal_Semaphore( StoreMutex );
  484. }
  486. //----------------------------------------------------------------------
  487. //       H A S H   T A B L E   M A N A G E M E N T
  488. //----------------------------------------------------------------------
  490. //----------------------------------------------------------------------
  491. //
  492. // FilemonHashCleanup
  493. //
  494. // Called when we are unloading to free any memory that we have 
  495. // in our possession.
  496. //
  497. //----------------------------------------------------------------------
  498. VOID FilemonHashCleanup()
  499. {
  500.     PHASH_ENTRY hashEntry, nextEntry;
  501.     ULONG i;
  502.   
  503.     //
  504.     // First, free the hash table entries
  505.     //
  506.     for( i = 0; i < NUMHASH; i++ ) {
  508.         hashEntry = HashTable[i];
  510.         while( hashEntry ) {
  511.             nextEntry = hashEntry->Next;
  512.             HeapFree( hashEntry->FullName, 0 );
  513.             HeapFree( hashEntry, 0 );
  514.             hashEntry = nextEntry;
  515.         }
  516.     }
  518.     //
  519.     // Now, free structures on our free list
  520.     //
  521.     while( FreeEntries ) {
  522.         nextEntry = FreeEntries->Next;
  523.         HeapFree( FreeEntries, 0 );
  524.         FreeEntries = nextEntry;
  525.     }
  526. }
  528. //----------------------------------------------------------------------
  529. //
  530. // FilemonStoreHash
  531. //
  532. // Stores the key and associated fullpath in the hash table.
  533. //
  534. //----------------------------------------------------------------------
  535. VOID FilemonStoreHash( sfn_t filenumber, PCHAR fullname )
  536. {
  537.     PHASH_ENTRY     newEntry;
  539.     Wait_Semaphore( HashMutex, BLOCK_SVC_INTS );
  541.     //
  542.     // Find or allocate an entry to use.
  543.     //
  544.     if( FreeEntries ) {
  546.         newEntry    = FreeEntries;
  547.         FreeEntries = FreeEntries->Next;
  548.         Signal_Semaphore( HashMutex );
  550.     } else {
  551.     
  552.         //
  553.         // Have to release the lock, because memory allocation can 
  554.         // cause re-entrancy.
  555.         //
  556.         Signal_Semaphore( HashMutex );
  557.         newEntry = HeapAllocate( sizeof(HASH_ENTRY), 0 );
  559.         //
  560.         // Is there memory for the allocation?
  561.         //
  562.         if( !newEntry ) return;
  563.     }
  565.     //
  566.     // Initialize the new entry.
  567.     //
  568.     newEntry->filenumber          = filenumber;
  569.     newEntry->FullName            = HeapAllocate( strlen(fullname)+1, 0);
  571.     //
  572.     // Make sure the allocation succeeded.
  573.     //
  574.     if( !newEntry->FullName ) {
  576.         HeapFree( newEntry, 0 );
  577.         return;
  578.     }
  579.     strcpy( newEntry->FullName, fullname );
  581.     //
  582.     // Lock the hash table and insert the new entry.
  583.     //
  584.     Wait_Semaphore( HashMutex, BLOCK_SVC_INTS );
  585.     newEntry->Next = HashTable[ HASHOBJECT(filenumber) ];
  586.     HashTable[ HASHOBJECT(filenumber) ] = newEntry;
  587.     Signal_Semaphore( HashMutex );
  588. }
  590. //----------------------------------------------------------------------
  591. //
  592. // FilemonFreeHashEntry
  593. //
  594. // When we see a file close, we can free the string we had associated
  595. // with the fileobject being closed since we know it won't be used
  596. // again.
  597. //
  598. //----------------------------------------------------------------------
  599. VOID FilemonFreeHashEntry( sfn_t filenumber )
  600. {
  601.     PHASH_ENTRY hashEntry, prevEntry;
  603.     Wait_Semaphore( HashMutex, BLOCK_SVC_INTS );
  605.     //
  606.     // Look-up the entry.
  607.     //
  608.     hashEntry = HashTable[ HASHOBJECT( filenumber ) ];
  609.     prevEntry = NULL;
  611.     while( hashEntry && hashEntry->filenumber != filenumber ) {
  613.         prevEntry = hashEntry;
  614.         hashEntry = hashEntry->Next;
  615.     }
  617.     //  
  618.     // If we fall of the hash list without finding what we're looking
  619.     // for, just return.
  620.     //
  621.     if( !hashEntry ) {
  623.         Signal_Semaphore( HashMutex );
  624.         return;
  625.     }
  627.     //
  628.     // Got it! Remove it from the list
  629.     //
  630.     if( prevEntry ) {
  632.         prevEntry->Next = hashEntry->Next;
  633.     } else {
  635.         HashTable[ HASHOBJECT( filenumber )] = hashEntry->Next;
  636.     }
  638.     //
  639.     // Free the memory associated with the name of the free entry.
  640.     //
  641.     hashEntry->Next  = FreeEntries;
  642.     FreeEntries  = hashEntry;
  644.     Signal_Semaphore( HashMutex );
  646.     //
  647.     // Free the memory associated with it
  648.     //
  649.     HeapFree( hashEntry->FullName, 0 );
  650. }
  652. //----------------------------------------------------------------------
  653. //       P A T H  A N D  P R O C E S S  N A M E  R O U T I N E S
  654. //----------------------------------------------------------------------
  656. //----------------------------------------------------------------------
  657. //
  658. // ErrorString
  659. //
  660. // Returns the string form of an error code.
  661. //
  662. //----------------------------------------------------------------------
  663. PCHAR ErrorString( DWORD retval )
  664. {
  665.     switch( retval ) {
  666.     case ERROR_INVALID_FUNCTION:
  667.         return "INVALIDFUNC"; 
  668.     case ERROR_SUCCESS:
  669.         return "SUCCESS";
  670.     case ERROR_OUTOFMEMORY:
  671.         return "OUTOFMEM";
  672.     case ERROR_ACCESS_DENIED:
  673.         return "ACCDENIED";
  674.     case ERROR_PATH_NOT_FOUND:
  675.         return "NOTFOUND";
  676.     case ERROR_TOO_MANY_OPEN_FILES:
  677.         return "TOOMANYOPEN";
  678.     case ERROR_FILE_NOT_FOUND:
  679.         return "NOTFOUND";
  680.     case ERROR_NO_MORE_ITEMS:
  681.         return "NOMORE";
  682.     case ERROR_GEN_FAILURE:
  683.         return "GENFAILURE";
  684.     case ERROR_MORE_DATA:
  685.         return "MOREDATA";
  686.     case ERROR_INVALID_DRIVE:
  687.         return "INVALIDDRIVE";
  688.     case ERROR_NOT_SAME_DEVICE:
  689.         return "DIFFERENTDEVICE";
  690.     case ERROR_WRITE_PROTECT:
  691.         return "WRITEPROTECTED";
  692.     case ERROR_SHARING_VIOLATION:
  693.         return "SHARING";
  694.     case ERROR_BAD_UNIT:
  695.         return "BADUNIT";
  696.     case ERROR_NOT_READY:
  697.         return "NOTREADY";
  698.     case ERROR_NO_MORE_FILES:
  699.         return "NOMORE";
  700.     case ERROR_BAD_COMMAND:
  701.         return "BADCOMMAND";
  702.     default:
  703.         sprintf(errstring, "0x%x", retval );
  704.         return errstring;
  705.     }
  706. }
  709. //----------------------------------------------------------------------
  710. //
  711. // FilemonFreeFilters
  712. //
  713. // Fress storage we allocated for filter strings.
  714. //
  715. //----------------------------------------------------------------------
  716. VOID FilemonFreeFilters()
  717. {
  718.     ULONG   i;
  721.     for( i = 0; i < NumIncludeFilters; i++ ) {
  723.         HeapFree( IncludeFilters[i], 0 );
  724.     }
  725.     for( i = 0; i < NumExcludeFilters; i++ ) {
  727.         HeapFree( ExcludeFilters[i], 0 );
  728.     }
  729.     NumIncludeFilters = 0;
  730.     NumExcludeFilters = 0;
  731. }
  733. //----------------------------------------------------------------------
  734. //
  735. // MakeFilterArray
  736. //
  737. // Takes a filter string and splits into components (a component
  738. // is seperated with a ';')
  739. //
  740. //----------------------------------------------------------------------
  741. VOID MakeFilterArray( PCHAR FilterString,
  742.                       PCHAR FilterArray[],
  743.                       PULONG NumFilters )
  744. {
  745.     PCHAR filterStart;
  746.     ULONG filterLength;
  748.     //
  749.     // Scan through the process filters
  750.     //
  751.     filterStart = FilterString;
  752.     while( *filterStart ) {
  754.         filterLength = 0;
  755.         while( filterStart[filterLength] &&
  756.                filterStart[filterLength] != ';' ) {
  758.             filterLength++;
  759.         }
  761.         //
  762.         // Ignore zero-length components
  763.         //
  764.         if( filterLength ) {
  766.             FilterArray[ *NumFilters ] = 
  767.                 HeapAllocate( filterLength + 1, 0 );
  768.             strncpy( FilterArray[ *NumFilters ],
  769.                      filterStart, filterLength );
  770.             FilterArray[ *NumFilters ][filterLength] = 0;
  771.             (*NumFilters)++;
  772.         }
  773.     
  774.         //
  775.         // Are we done?
  776.         //
  777.         if( !filterStart[filterLength] ) break;
  779.         //
  780.         // Move to the next component (skip over ';')
  781.         //
  782.         filterStart += filterLength + 1;
  783.     }
  784. }
  787. //----------------------------------------------------------------------
  788. //
  789. // FilemonUpdateFilters
  790. //
  791. // Takes a new filter specification and updates the filter
  792. // arrays with them.
  793. //
  794. //----------------------------------------------------------------------
  795. VOID FilemonUpdateFilters()
  796. {
  797.     //
  798.     // Free old filters (if any)
  799.     //
  800.     Wait_Semaphore( FilterMutex, BLOCK_SVC_INTS );
  801.     FilemonFreeFilters();
  803.     //
  804.     // Create new filter arrays
  805.     //
  806.     MakeFilterArray( FilterDef.includefilter,
  807.                      IncludeFilters, &NumIncludeFilters );
  808.     MakeFilterArray( FilterDef.excludefilter,
  809.                      ExcludeFilters, &NumExcludeFilters );
  810.     Signal_Semaphore( FilterMutex );
  811. }
  814. //----------------------------------------------------------------------
  815. //
  816. // wstrlen
  817. //
  818. // Determine the length of a wide-character string.
  819. //
  820. //----------------------------------------------------------------------
  821. int wstrlen( unsigned short *unistring )
  822. {
  823.     int i = 0;
  824.     int len = 0;
  825.   
  826.     while( unistring[i++] != 0 ) len+=2;
  827.     return len;
  828. }
  831. //----------------------------------------------------------------------
  832. //
  833. // FilmonGetProcess
  834. //
  835. // Retrieves the process name.
  836. //
  837. //----------------------------------------------------------------------
  838. FILTERSTATUS FilemonGetProcess( PCHAR ProcessName )
  839. {
  840.     PVOID       CurProc;
  841.     PVOID       ring3proc;
  842.     char        *name;
  843.     ULONG       i;
  845.     //
  846.     // Get the ring0 process pointer.
  847.     //
  848.     CurProc = VWIN32_GetCurrentProcessHandle();
  849.   
  850.     //
  851.     // Now, map the ring3 PCB 
  852.     //
  853.     ring3proc = (PVOID) SelectorMapFlat( Get_Sys_VM_Handle(), 
  854.                                          (DWORD) (*(PDWORD) ((char *) CurProc + 0x38)) | 0x7, 0 );
  856.     if( ring3proc == (PVOID) -1 ) {
  857.         strcpy( ProcessName, "???");
  858.     } else {
  860.         //
  861.         // copy out the process name (max 8 characters)
  862.         //
  863.         name = ((char *)ring3proc) + 0xF2;
  864.         if( name[0] >= 'A' && name[0] < 'z' ) {
  866.             strcpy( ProcessName, name );
  867.             ProcessName[8] = 0;
  868.         } else {
  870.             strcpy( ProcessName, "???" );
  871.         }
  872.     }
  874.     //
  875.     // Ignore filemon-generated output
  876.     //
  877.     if( !stricmp( ProcessName, "Filemon" )) return FILTERFAIL;
  879.     //
  880.     // Apply process name filters
  881.     //
  882.     Wait_Semaphore( FilterMutex, BLOCK_SVC_INTS );
  883.     for( i = 0; i < NumExcludeFilters; i++ ) {
  885.         if( MatchWithPattern( ExcludeFilters[i], ProcessName )) {
  887.             Signal_Semaphore( FilterMutex );
  888.             return FILTERFAIL;
  889.         }
  890.     }
  891.     for( i = 0; i < NumIncludeFilters; i++ ) {
  893.         if( MatchWithPattern( IncludeFilters[i], ProcessName ) ) {
  895.             Signal_Semaphore( FilterMutex );
  896.             return FILTERPASS;
  897.         }
  898.     }
  899.     Signal_Semaphore( FilterMutex );
  900.     return FILTERNOMATCH;
  901. }
  904. //----------------------------------------------------------------------
  905. //
  906. // ApplyNameFilter
  907. //
  908. // If the name matches the exclusion mask, we do not log it. Else if
  909. // it doesn't match the inclusion mask we do not log it. 
  910. //
  911. //----------------------------------------------------------------------
  912. FILTERSTATUS ApplyNameFilter( PCHAR fullname )
  913. {
  914.     ULONG    i;
  916.     //   
  917.     // If it matches the exclusion string, do not log it
  918.     //
  919.     Wait_Semaphore( FilterMutex, BLOCK_SVC_INTS );
  920.     for( i = 0; i < NumExcludeFilters; i++ ) {
  922.         if( MatchWithPattern( ExcludeFilters[i], fullname ) ) {
  924.             Signal_Semaphore( FilterMutex );
  925.             return FILTERFAIL;
  926.         }
  927.     }
  928.  
  929.     //
  930.     // If it matches an include filter then log it
  931.     //
  932.     for( i = 0; i < NumIncludeFilters; i++ ) {
  934.         if( MatchWithPattern( IncludeFilters[i], fullname )) {
  936.             Signal_Semaphore( FilterMutex );
  937.             return FILTERPASS;
  938.         }
  939.     }
  941.     //
  942.     // It didn't match any include filters so don't log
  943.     //
  944.     Signal_Semaphore( FilterMutex );
  945.     return FILTERNOMATCH;
  946. }
  949. //----------------------------------------------------------------------
  950. //
  951. // ApplyFilters
  952. //
  953. // Gets the process name and then performs filtering logic.
  954. //
  955. //----------------------------------------------------------------------
  956. BOOLEAN ApplyFilters( PCHAR ProcessName, PCHAR FullName )
  957. {
  958.     FILTERSTATUS   filterStatus, nameFilterStatus;
  960.     //
  961.     // Try the process filter
  962.     //
  963.     filterStatus = FilemonGetProcess( ProcessName );
  964.     if( filterStatus == FILTERPASS ||
  965. filterStatus == FILTERNOMATCH ) {
  967.         //
  968.         // Try the path filter
  969.         //
  970.         nameFilterStatus = ApplyNameFilter( FullName );
  972.         if( (filterStatus == FILTERPASS && nameFilterStatus != FILTERFAIL) ||
  973.             nameFilterStatus == FILTERPASS ) {
  974.             
  975.             return TRUE;
  976.         }
  977.     } 
  978.     return FALSE;
  979. }
  982. //----------------------------------------------------------------------
  983. //
  984. // FilemonConvertPath
  985. //
  986. // Converts a unicode path name to ANSI.
  987. //
  988. //----------------------------------------------------------------------
  989. PCHAR FilemonConvertPath( int drive, path_t ppath, PCHAR fullpathname )
  990. {
  991.     int  i = 0;
  992.     _QWORD  result;
  994.     //
  995.     // Stick on the drive letter if we know it.
  996.     //
  997.     if( drive != 0xFF ) {
  998.  
  999.         fullpathname[0] = drive+'A'-1;
  1000.         fullpathname[1] = ':';
  1001.         i = 2;
  1002.     } 
  1003.     UniToBCSPath( &fullpathname[i], ppath->pp_elements, MAXPATHLEN, BCS_WANSI, &result );
  1004.     return( fullpathname );
  1005. }
  1008. //----------------------------------------------------------------------
  1009. //
  1010. // FilemonGetFullPath
  1011. //
  1012. // Returns the full pathname of a file, if we can obtain one, else
  1013. // returns a handle.
  1014. //
  1015. //----------------------------------------------------------------------
  1016. PCHAR FilemonGetFullPath(  sfn_t filenumber, PCHAR fullname,
  1017.                            int Drive, int ResType, int CodePage, pioreq pir )
  1018. {
  1019.     PHASH_ENTRY hashEntry;
  1020.     pIFSFunc        enumFunc;
  1021.     ifsreq          ifsr;
  1022.     path_t          uniFullName;
  1023.     int             retval;
  1025.     //
  1026.     // See if we find the key in the hash table.
  1027.     //
  1028.     Wait_Semaphore( HashMutex, BLOCK_SVC_INTS );
  1030.     hashEntry = HashTable[ HASHOBJECT( filenumber ) ];
  1032.     while( hashEntry && hashEntry->filenumber != filenumber ) {
  1034.         hashEntry = hashEntry->Next;
  1035.     }
  1037.     Signal_Semaphore( HashMutex );
  1039.     fullname[0] = 0;
  1040.     if( hashEntry ) {
  1042.         strcpy( fullname, hashEntry->FullName );
  1044.     } else {
  1046.         //
  1047.         // File name isn't in the table, so ask the
  1048.         // underlying file system
  1049.         //
  1050.         sprintf( fullname, "0x%X", filenumber );
  1052.         uniFullName = IFSMgr_GetHeap( MAXPATHLEN );
  1053.         if( uniFullName ) {
  1054.             
  1055.             //
  1056.             // Send a query file name request
  1057.             //
  1058.             memcpy( &ifsr, pir, sizeof( ifsreq ));
  1059.             ifsr.ifsir.ir_flags = ENUMH_GETFILENAME;
  1060.             ifsr.ifsir.ir_ppath = uniFullName;
  1061.             enumFunc = ifsr.ifs_hndl->hf_misc->hm_func[HM_ENUMHANDLE];
  1063.             retval = (*PrevIFSHookProc)(enumFunc, IFSFN_ENUMHANDLE, 
  1064.                                         Drive, ResType, CodePage, 
  1065.                                         (pioreq) &ifsr);
  1067.             if( retval == ERROR_SUCCESS ) {
  1068.                 
  1069.                 FilemonConvertPath( Drive, uniFullName, fullname );
  1070.                 FilemonStoreHash( filenumber, fullname );
  1071.             }
  1072.             IFSMgr_RetHeap( (void *) uniFullName );
  1073.         } 
  1074.     }
  1075.     return fullname;
  1076. }
  1079. //----------------------------------------------------------------------
  1080. //
  1081. // FilemonHookProc
  1082. //
  1083. // All (most) IFS functions come through this routine for us to look
  1084. // at.
  1085. //
  1086. //----------------------------------------------------------------------
  1087. #pragma optimize("", off)
  1088. int _cdecl FilemonHookProc(pIFSFunc pfn, int fn, int Drive, int ResType,
  1089.                            int CodePage, pioreq pir)
  1090. {
  1091.     int                retval;
  1092.     char               fullpathname[MAXPATHLEN];
  1093.     char               processname[64];
  1094.     char               data[256];
  1095.     char               drivestring[4];
  1096.     ioreq              origir;
  1097.     _WIN32_FIND_DATA   *finddata;
  1098.     struct srch_entry  *search;
  1099.     BOOLEAN            log;
  1100.     _QWORD             result;
  1101.     DWORD              timelo, timehi;
  1102.     DWORD              timelo1, timehi1;
  1103.     int                i, j;
  1105.     // 
  1106.     // Inititlize default data.
  1107.     //
  1108.     data[0] = 0;
  1110.     //
  1111.     // Save original iorequest because some entries get modified.
  1112.     //
  1113.     origir = *pir;
  1115.     //
  1116.     // Get the current process name.
  1117.     //
  1118.     FilemonGetProcess( processname );
  1120.     //
  1121.     // Get the time
  1122.     //
  1123.     if( TimeIsDuration ) {
  1125.         VTD_Get_Real_Time( &timehi, &timelo );
  1127.     } else {
  1129.         timelo = IFSMgr_Get_DOSTime( &timehi );
  1130.     }       
  1132.     //
  1133.     // Call the previous hooker first, to get the return code.
  1134.     //
  1135.     retval = (*PrevIFSHookProc)(pfn, fn, Drive, ResType, CodePage, pir);
  1137.     //
  1138.     // Now extract parameters based on the function type.
  1139.     //
  1140.     switch( fn ) {
  1142.     case IFSFN_OPEN:
  1144.         FilemonConvertPath( Drive, pir->ir_ppath, fullpathname );
  1145.         if( ApplyFilters( processname, fullpathname )) {
  1147.             if( TimeIsDuration ) {
  1148.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1149.                 timelo = timelo1 - timelo;
  1150.             }
  1151.             sprintf(data,"");
  1152.             if( origir.ir_options & ACTION_CREATENEW ) strcat(data,"CREATENEW ");
  1153.             if( origir.ir_options & ACTION_OPENEXISTING ) strcat(data,"OPENEXISTING ");
  1154.             if( origir.ir_options & ACTION_REPLACEEXISTING ) strcat(data,"REPLACEEXISTING ");
  1155.             switch (origir.ir_flags & ACCESS_MODE_MASK) {
  1157.             case ACCESS_READONLY:
  1158.                 strcat(data,"READONLY ");
  1159.                 break;
  1160.             case ACCESS_WRITEONLY:
  1161.                 strcat(data,"WRITEONLY ");
  1162.                 break;
  1163.             case ACCESS_READWRITE:
  1164.                 strcat(data,"READWRITE ");
  1165.                 break;
  1166.             case ACCESS_EXECUTE:
  1167.                 strcat(data,"EXECUTE ");
  1168.                 break;
  1169.             default:
  1170.                 break;
  1171.             }
  1172.             switch (origir.ir_flags & SHARE_MODE_MASK) {
  1173.             case SHARE_COMPATIBILITY:
  1174.                 strcat(data,"COMPATIBILITY ");
  1175.                 break;
  1176.             case SHARE_DENYREADWRITE:
  1177.                 strcat(data,"DENYREADWRITE ");
  1178.                 break;
  1179.             case SHARE_DENYWRITE:
  1180.                 strcat(data,"DENYWRITE ");
  1181.                 break;
  1182.             case SHARE_DENYREAD:
  1183.                 strcat(data,"DENYREAD ");
  1184.                 break;
  1185.             case SHARE_DENYNONE:
  1186.                 strcat(data,"DENYNONE ");
  1187.                 break;
  1188.             default:
  1189.                 break;
  1190.             }
  1191.             UpdateStore( Sequence++, timelo, "%stOpent%st%st%s", 
  1192.                          processname, fullpathname,
  1193.                          data, ErrorString( retval ));
  1194.         }
  1195.         FilemonStoreHash( pir->ir_sfn, fullpathname );
  1196.         break;
  1198.     case IFSFN_READ:
  1199.     case IFSFN_WRITE:
  1200.         FilemonGetFullPath( pir->ir_sfn, fullpathname, Drive, ResType, CodePage, pir );
  1201.         if( ((fn == IFSFN_READ && FilterDef.logreads ) ||
  1202.              (fn == IFSFN_WRITE && FilterDef.logwrites )) &&
  1203.             ApplyFilters( processname, fullpathname )) {
  1204.             if( TimeIsDuration ) {
  1205.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1206.                 timelo = timelo1 - timelo;
  1207.             }
  1208.             sprintf( data, "Offset: %ld Length: %ld", origir.ir_pos, origir.ir_length );
  1209.             UpdateStore( Sequence++, timelo, "%st%st%st%st%s", 
  1210.                          processname, fn == IFSFN_READ? "Read" : "Write", 
  1211.                          fullpathname,
  1212.                          data, ErrorString( retval ));
  1213.         }
  1214.         break;
  1216.     case IFSFN_CLOSE:
  1217.         FilemonGetFullPath( pir->ir_sfn, fullpathname, Drive, ResType, CodePage, pir );
  1218.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logreads ) {
  1219.             if( TimeIsDuration ) {
  1220.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1221.                 timelo = timelo1 - timelo;
  1222.             }
  1223.             switch( origir.ir_flags ) {
  1224.             case CLOSE_HANDLE:      sprintf(data, "CLOSE_HANDLE");      break;
  1225.             case CLOSE_FOR_PROCESS: sprintf(data, "CLOSE_FOR_PROCESS"); break;
  1226.             case CLOSE_FINAL:       sprintf(data, "CLOSE_FINAL");       break;
  1227.             default: sprintf(data,"0x%02X",origir.ir_flags);            break;
  1228.             }
  1229.             UpdateStore( Sequence++, timelo, "%stCloset%st%st%s", processname, 
  1230.                          fullpathname, data, ErrorString( retval ));
  1231.         }
  1232.         if ( origir.ir_flags == CLOSE_FINAL ) FilemonFreeHashEntry( origir.ir_sfn );
  1233.         break;
  1235.     case IFSFN_DIR:
  1236.         FilemonConvertPath( Drive, pir->ir_ppath, fullpathname );
  1237.         if( ApplyFilters( processname, fullpathname )) {
  1239.             if( TimeIsDuration ) {
  1240.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1241.                 timelo = timelo1 - timelo;
  1242.             }
  1243.             log = FALSE;
  1244.             switch( pir->ir_flags ) {
  1245.             case CREATE_DIR:
  1246.                 sprintf(data, "CREATE");
  1247.                 if( FilterDef.logwrites ) log = TRUE;
  1248.                 break;
  1249.             case DELETE_DIR:
  1250.                 sprintf(data,"DELETE");
  1251.                 if( FilterDef.logwrites ) log = TRUE;
  1252.                 break;
  1253.             case CHECK_DIR:
  1254.                 sprintf(data,"CHECK");
  1255.                 if( FilterDef.logreads ) log = TRUE;
  1256.                 break;
  1257.             default:
  1258.                 sprintf(data,"QUERY");
  1259.                 if( FilterDef.logreads ) log = TRUE;
  1260.                 break;
  1261.             }
  1262.             if( log ) {
  1263.                 UpdateStore( Sequence++, timelo, "%stDirectoryt%st%st%s", 
  1264.                              processname, 
  1265.                              fullpathname,
  1266.                              data, ErrorString( retval ));
  1267.             }
  1268.         }
  1269.         break;
  1271.     case IFSFN_SEEK:
  1272.         FilemonGetFullPath( pir->ir_sfn, fullpathname, Drive, ResType, CodePage, pir );
  1273.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logreads) {
  1275.             if( TimeIsDuration ) {
  1276.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1277.                 timelo = timelo1 - timelo;
  1278.             }
  1279.             sprintf(data, "%s Offset: %ld",
  1280.                     pir->ir_flags == FILE_BEGIN ? "Beginning" : "End",
  1281.                     origir.ir_pos );
  1282.             UpdateStore( Sequence++, timelo, "%stSeekt%st%st%s", 
  1283.                          processname, fullpathname,
  1284.                          data, ErrorString( retval ));
  1285.         }
  1286.         break;
  1288.     case IFSFN_COMMIT:
  1289.         FilemonGetFullPath( pir->ir_sfn, fullpathname, Drive, ResType, CodePage, pir );
  1290.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logwrites) {
  1292.             if( TimeIsDuration ) {
  1293.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1294.                 timelo = timelo1 - timelo;
  1295.             }
  1296.             sprintf(data, "%s", pir->ir_options == FILE_COMMIT_ASYNC ? 
  1297.                     "ASYNC" : "NOACCESSUPDATE" );
  1298.             UpdateStore( Sequence++, timelo, "%stCommitt%st%st%s", 
  1299.                          processname, fullpathname,
  1300.                          data, ErrorString( retval ));
  1301.         }
  1302.         break;
  1304.     case IFSFN_FILELOCKS:
  1305.         FilemonGetFullPath( pir->ir_sfn, fullpathname, Drive, ResType, CodePage, pir );
  1306.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logreads) {
  1307.             if( TimeIsDuration ) {
  1308.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1309.                 timelo = timelo1 - timelo;
  1310.             }
  1311.             sprintf(data, "Offset: %ld Length:%ld", origir.ir_pos, origir.ir_locklen );
  1312.             UpdateStore( Sequence++, timelo, "%st%st%st%st%s", 
  1313.                          processname, origir.ir_flags == LOCK_REGION ? "Lock" : "Unlock",
  1314.                          fullpathname,
  1315.                          data, ErrorString( retval ));
  1316.         }
  1317.         break;
  1319.     case IFSFN_FINDOPEN:
  1321.         FilemonConvertPath( Drive, pir->ir_ppath, fullpathname ); 
  1322.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logreads) {
  1324.             if( TimeIsDuration ) {
  1325.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1326.                 timelo = timelo1 - timelo;
  1327.             }
  1328.             if( !retval ) {
  1330.                 finddata = (_WIN32_FIND_DATA *) pir->ir_data;
  1331.                 UniToBCS( data, finddata->cFileName, MAXPATHLEN, wstrlen(finddata->cFileName),BCS_WANSI, &result );
  1332.                 data[wstrlen(finddata->cFileName)/2] = 0;
  1333.             }
  1334.             UpdateStore( Sequence++, timelo, "%stFindOpent%st%st%s", 
  1335.                          processname, fullpathname,
  1336.                          data, ErrorString( retval ));
  1337.         }
  1338.         FilemonStoreHash( pir->ir_sfn, fullpathname );
  1339.         break;
  1341.     case IFSFN_FINDNEXT:
  1342.         FilemonGetFullPath( pir->ir_sfn, fullpathname, Drive, ResType, CodePage, pir );
  1343.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logreads) {
  1344.             if( TimeIsDuration ) {
  1345.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1346.                 timelo = timelo1 - timelo;
  1347.             }
  1348.             if( !retval ) {
  1349.                 finddata = (_WIN32_FIND_DATA *) pir->ir_data;
  1350.                 UniToBCS( data, finddata->cFileName, MAXPATHLEN, wstrlen(finddata->cFileName),BCS_WANSI, &result );
  1351.                 data[wstrlen(finddata->cFileName)/2] = 0;
  1352.             }
  1354.             UpdateStore( Sequence++, timelo, "%stFindNextt%st%st%s", 
  1355.                          processname, fullpathname,
  1356.                          data, ErrorString( retval ));
  1357.         }
  1358.         break;
  1360.     case IFSFN_FINDCLOSE:
  1361.         FilemonGetFullPath( pir->ir_sfn, fullpathname, Drive, ResType, CodePage, pir );
  1362.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logreads) {
  1363.             if( TimeIsDuration ) {
  1364.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1365.                 timelo = timelo1 - timelo;
  1366.             }
  1367.             UpdateStore( Sequence++, timelo, "%stFindCloset%stt%s", 
  1368.                          processname, fullpathname,
  1369.                          ErrorString( retval ));
  1370.         }
  1371.         FilemonFreeHashEntry( pir->ir_sfn );
  1372.         break;
  1374.     case IFSFN_FILEATTRIB:
  1375.         FilemonConvertPath( Drive, pir->ir_ppath, fullpathname );
  1376.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logreads) {    
  1377.             if( TimeIsDuration ) {
  1378.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1379.                 timelo = timelo1 - timelo;
  1380.             }
  1381.             switch(origir.ir_flags ) {
  1382.             case GET_ATTRIBUTES:
  1383.                 sprintf(data,"GetAttributes");
  1384.                 break;
  1385.             case SET_ATTRIBUTES:
  1386.                 sprintf(data, "SetAttributes" );
  1387.                 break;
  1388.             case GET_ATTRIB_COMP_FILESIZE:
  1389.                 sprintf(data, "GET_ATTRIB_COMP_FILESIZE" );
  1390.                 break;
  1391.             case SET_ATTRIB_MODIFY_DATETIME:
  1392.                 sprintf(data, "SET_ATTRIB_MODIFY_DATETIME");
  1393.                 break;
  1394.             case SET_ATTRIB_LAST_ACCESS_DATETIME:
  1395.                 sprintf(data, "SET_ATTRIB_LAST_ACCESS_DATETIME");
  1396.                 break;
  1397.             case GET_ATTRIB_LAST_ACCESS_DATETIME:
  1398.                 sprintf(data, "GET_ATTRIB_LAST_ACCESS_DATETIME");
  1399.                 break;
  1400.             case SET_ATTRIB_CREATION_DATETIME:
  1401.                 sprintf(data, "SET_ATTRIB_CREATION_DATETIME");
  1402.                 break;
  1403.             case GET_ATTRIB_CREATION_DATETIME:
  1404.                 sprintf(data, "GET_ATTRIB_CREATION_DATETIME");
  1405.                 break;
  1406.             }
  1407.             UpdateStore( Sequence++, timelo, "%stAttributest%st%st%s", 
  1408.                          processname, fullpathname,
  1409.                          data, ErrorString( retval ));
  1410.         }
  1411.         break;
  1413.     case IFSFN_FILETIMES:
  1414.         FilemonGetFullPath( pir->ir_sfn, fullpathname, Drive, ResType, CodePage, pir );
  1415.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logreads) {
  1416.             if( TimeIsDuration ) {
  1417.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1418.                 timelo = timelo1 - timelo;
  1419.             }
  1420.             switch( pir->ir_flags ) {
  1421.             case GET_MODIFY_DATETIME:
  1422.                 sprintf(data, "Get Modify");
  1423.                 break;
  1424.             case SET_MODIFY_DATETIME:
  1425.                 sprintf(data, "Set Modify");
  1426.                 break;
  1427.             case GET_LAST_ACCESS_DATETIME:
  1428.                 sprintf(data, "Get Access");
  1429.                 break;
  1430.             case SET_LAST_ACCESS_DATETIME:
  1431.                 sprintf(data, "Set Access");
  1432.                 break;
  1433.             case GET_CREATION_DATETIME:
  1434.                 sprintf(data, "Get Creation");
  1435.                 break;
  1436.             case SET_CREATION_DATETIME:
  1437.                 sprintf(data, "Set Creation");
  1438.                 break;
  1439.             }
  1440.             UpdateStore( Sequence++, timelo, "%stAttributest%st%st%s", 
  1441.                          processname, fullpathname,
  1442.                          data, ErrorString( retval ));
  1443.         }
  1444.         break;
  1446.     case IFSFN_FLUSH:
  1447.         if( FilemonGetProcess(processname) == FILTERPASS && FilterDef.logwrites) {
  1448.             if( TimeIsDuration ) {
  1449.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1450.                 timelo = timelo1 - timelo;
  1451.             }
  1452.             UpdateStore( Sequence++, timelo, "%stFlushVolumettt%s",
  1453.                          processname, ErrorString( retval ));
  1454.         }
  1455.         break;
  1457.     case IFSFN_DELETE:
  1458.         FilemonConvertPath( Drive, pir->ir_ppath, fullpathname );
  1459.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logwrites) {    
  1460.             if( TimeIsDuration ) {
  1461.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1462.                 timelo = timelo1 - timelo;
  1463.             }
  1464.             UpdateStore( Sequence++, timelo, "%stDeletet%stt%s", 
  1465.                          processname, fullpathname,
  1466.                          ErrorString( retval ));
  1467.         }
  1468.         FilemonFreeHashEntry( pir->ir_sfn );
  1469.         break;
  1471.     case IFSFN_SEARCH:
  1472.         if( pir->ir_flags == SEARCH_FIRST ) 
  1473.             FilemonConvertPath( Drive, pir->ir_ppath, fullpathname );
  1474.         else
  1475.             sprintf(fullpathname, "SearchNext" );
  1476.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logreads ) {
  1477.             if( TimeIsDuration ) {
  1478.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1479.                 timelo = timelo1 - timelo;
  1480.             }
  1481.             if( !retval ) {
  1482.                 j = 0;
  1483.                 if( origir.ir_attr & FILE_ATTRIBUTE_LABEL ) {
  1484.                     sprintf(data, "VolumeLabel: " );
  1485.                     j = strlen( data );
  1486.                 }
  1487.                 search = (struct srch_entry *) origir.ir_data;
  1488.                 for( i = 0; i < 13; i++ ) 
  1489.                     if( search->se_name[i] != ' ' ) data[j++] = search->se_name[i];
  1490.                 data[j] = 0;
  1491.             }
  1492.             UpdateStore( Sequence++, timelo, "%stSearcht%st%st%s", 
  1493.                          processname, fullpathname, data, ErrorString( retval ));    
  1494.         }
  1495.         break;
  1496.     
  1497.     case IFSFN_GETDISKINFO:
  1499.         if( FilemonGetProcess( processname ) == FILTERPASS && FilterDef.logreads ) {
  1500.             if( TimeIsDuration ) {
  1501.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1502.                 timelo = timelo1 - timelo;
  1503.             }
  1504.             if( !retval ) sprintf(data, "Free Space");
  1505.             drivestring[0] = Drive+'A'-1;
  1506.             drivestring[1] = ':';
  1507.             drivestring[2] = 0;
  1508.             UpdateStore( Sequence++, timelo, "%stGetDiskInfot%st%st%s",
  1509.                          processname, drivestring, data, ErrorString( retval ));
  1510.         }
  1511.         break;
  1513.     case IFSFN_RENAME:
  1514.         FilemonConvertPath( Drive, pir->ir_ppath, fullpathname );
  1515.         if( ApplyFilters( processname, fullpathname ) && FilterDef.logwrites) {          
  1516.             if( TimeIsDuration ) {
  1517.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1518.                 timelo = timelo1 - timelo;
  1519.             }
  1520.             UpdateStore( Sequence++, timelo, "%stRenamet%st%st%s",
  1521.                          processname, fullpathname,
  1522.                          FilemonConvertPath( Drive, pir->ir_ppath2, data ),
  1523.                          ErrorString( retval ));  
  1524.         }
  1525.         break;
  1526.     case IFSFN_IOCTL16DRIVE:
  1527.         if( FilemonGetProcess( processname ) == FILTERPASS && (FilterDef.logreads || FilterDef.logwrites)) {
  1528.             if( TimeIsDuration ) {
  1529.                 VTD_Get_Real_Time( &timehi1, &timelo1 );
  1530.                 timelo = timelo1 - timelo;
  1531.             }
  1532.             sprintf(data, "Subfunction: %02Xh", pir->ir_flags );
  1533.             drivestring[0] = Drive+'A'-1;
  1534.             drivestring[1] = ':';
  1535.             drivestring[2] = 0;
  1536.             UpdateStore( Sequence++, timelo, "%stIoctlt%st%st%s",
  1537.                          processname, drivestring, data, ErrorString( retval ));
  1538.         }
  1539.         break;
  1540.     }
  1541.     dprintf("==>%dn", fn );
  1542.     return retval;
  1543. }
  1544. #pragma optimize("", on)
  1546. //----------------------------------------------------------------------
  1547. //
  1548. // OnSysDynamicDeviceInit
  1549. //
  1550. // Dynamic init. Hook all registry related VxD APIs.
  1551. //
  1552. //----------------------------------------------------------------------
  1553. BOOL OnSysDynamicDeviceInit()
  1554. {
  1555.     int i;
  1557.     //
  1558.     // Initialize the locks.
  1559.     //
  1560.     StoreMutex = Create_Semaphore(1);
  1561.     HashMutex  = Create_Semaphore(1);
  1562.     FilterMutex  = Create_Semaphore(1);
  1564.     // 
  1565.     // Zero hash table.
  1566.     //
  1567.     for(i = 0; i < NUMHASH; i++ ) HashTable[i] = NULL;
  1569.     //
  1570.     // Allocate the initial output buffer.
  1571.     //
  1572.     PageAllocate(STORESIZE, PG_SYS, 0, 0, 0, 0, NULL, PAGELOCKED, 
  1573.                  (PMEMHANDLE) &Store, (PVOID) &Store );
  1574.     Store->Len = 0;
  1575.     Store->Next = NULL;
  1576.     NumStore = 1;
  1578.     //
  1579.     // Hook IFS functions.
  1580.     //
  1581.     PrevIFSHookProc = IFSMgr_InstallFileSystemApiHook(FilemonHookProc);
  1583.     return TRUE;
  1584. }
  1586. //----------------------------------------------------------------------
  1587. //
  1588. // OnSysDynamicDeviceExit
  1589. //
  1590. // Dynamic exit. Unhook everything.
  1591. //
  1592. //----------------------------------------------------------------------
  1593. BOOL OnSysDynamicDeviceExit()
  1594. {
  1595.     //
  1596.     // Unhook IFS functions.
  1597.     //
  1598.     IFSMgr_RemoveFileSystemApiHook(FilemonHookProc);
  1600.     //
  1601.     // Free all memory.
  1602.     //
  1603.     FilemonHashCleanup();
  1604.     FilemonFreeStore();
  1605.     FilemonFreeFilters();
  1606.     return TRUE;
  1607. }
  1609. //----------------------------------------------------------------------
  1610. //
  1611. // OnW32Deviceiocontrol
  1612. //
  1613. // Interface with the GUI.
  1614. //
  1615. //----------------------------------------------------------------------
  1616. DWORD OnW32Deviceiocontrol(PIOCTLPARAMS p)
  1617. {
  1618.     PSTORE_BUF      old;
  1620.     switch( p->dioc_IOCtlCode ) {
  1621.     case 0:
  1622.         return 0;
  1624.     case IOCTL_FILEMON_ZEROSTATS:
  1626.         Wait_Semaphore( StoreMutex, BLOCK_SVC_INTS );
  1627.         while ( Store->Next )  {
  1628.  
  1629.             //
  1630.             // Release the next entry.
  1631.             //
  1632.             old = Store->Next;
  1633.             Store->Next = old->Next;
  1634.             Signal_Semaphore( StoreMutex );
  1635.             PageFree( (MEMHANDLE) old, 0 );
  1636.             Wait_Semaphore( StoreMutex, BLOCK_SVC_INTS );
  1637.             NumStore--;
  1638.         }
  1639.         Store->Len = 0;
  1640.         Signal_Semaphore( StoreMutex );
  1641.         Sequence = 0;
  1642.         return 0;
  1644.     case IOCTL_FILEMON_GETSTATS:
  1646.         //
  1647.         // Copy buffer into user space.
  1648.         Wait_Semaphore( StoreMutex, BLOCK_SVC_INTS );
  1649.         if ( MAX_STORE > p->dioc_cbOutBuf ) {
  1651.             //
  1652.             // Buffer is too small. Return error.
  1653.             //
  1654.             Signal_Semaphore( StoreMutex );
  1656.             return 1;
  1658.         } else if ( Store->Len  ||  Store->Next ) {
  1660.             //
  1661.             // Switch to a new buffer.
  1662.             //
  1663.             FilemonNewStore();
  1665.             //
  1666.             // Fetch the oldest buffer to give to caller.
  1667.             //
  1668.             old = FilemonOldestStore();
  1669.             Signal_Semaphore( StoreMutex );
  1671.             //
  1672.             // Copy it into the caller's buffer.
  1673.             //
  1674.             memcpy( p->dioc_OutBuf, old->Data, old->Len );
  1676.             //
  1677.             // Return length of copied info.
  1678.             //
  1679.             *p->dioc_bytesret = old->Len;
  1681.             //   
  1682.             // Deallocate the buffer.
  1683.             //
  1684.             PageFree( (MEMHANDLE) old, 0 );
  1686.         } else {
  1688.             //
  1689.             // There is no unread data.
  1690.             //
  1691.             Signal_Semaphore( StoreMutex );
  1692.             *p->dioc_bytesret = 0;
  1693.         }
  1694.         return 0;
  1696.     case IOCTL_FILEMON_STOPFILTER:
  1698.         FilterOn = FALSE;
  1699.         return 0;
  1701.     case IOCTL_FILEMON_STARTFILTER:
  1703.         FilterOn = TRUE;
  1704.         return 0;
  1706.     case IOCTL_FILEMON_SETFILTER:
  1708.         FilterDef = * (PFILTER) p->dioc_InBuf;
  1709.         FilemonUpdateFilters();
  1710.         return 0;
  1712.     case IOCTL_FILEMON_TIMETYPE:
  1714.         TimeIsDuration = * (PBOOLEAN) p->dioc_InBuf;
  1715.         return 0;
  1717.     default:
  1718.         return 1;
  1719.     }
  1720. }