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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 系统编程 > 查看源码
REGMON.C
资源名称：regmonsrc.zip　[点击查看]
上传用户：kevenhsn
上传日期：2007-01-03
资源大小：251k
文件大小：50k
源码类别：

系统编程

开发平台：

Visual C++

REGMON.C：源码内容
  1. //======================================================================
  2. //
  3. // REGMON.c - main module for VxD REGMON
  4. //
  5. // Copyright(C) 1996-1999 Mark Russinovich and Bryce Cogswell
  6. // Systems Internals - http://www.sysinternals.com
  7. //
  8. //======================================================================
  9. #define   DEVICE_MAIN
  10. #include  <vtoolsc.h>
  11. #include  "..guiioctlcmd.h"
  12. #include  "regmon.h"
  13. #undef    DEVICE_MAIN
  15. #if DEBUG
  16. #define dprint(arg) dprintf arg
  17. #else
  18. #define dprint(arg)
  19. #endif
  21. //----------------------------------------------------------------------
  22. //                     G L O B A L   D A T A 
  23. //----------------------------------------------------------------------
  25. //
  26. // Real service pointers with the hook thunks
  27. //
  28. HDSC_Thunk ROKThunk;
  29. LONG (*RealRegOpenKey)(HKEY, PCHAR, PHKEY );
  30. HDSC_Thunk RCKThunk;
  31. LONG (*RealRegCloseKey)(HKEY );
  32. HDSC_Thunk RFKThunk;
  33. LONG (*RealRegFlushKey)(HKEY );
  34. HDSC_Thunk RCRKThunk;
  35. LONG (*RealRegCreateKey)(HKEY, PCHAR, PHKEY );
  36. HDSC_Thunk RDKThunk;
  37. LONG (*RealRegDeleteKey)(HKEY, PCHAR );
  38. HDSC_Thunk RDVThunk;
  39. LONG (*RealRegDeleteValue)(HKEY, PCHAR );
  40. HDSC_Thunk REKThunk;
  41. LONG (*RealRegEnumKey)(HKEY, DWORD, PCHAR, DWORD );
  42. HDSC_Thunk REVThunk;
  43. LONG (*RealRegEnumValue)(HKEY, DWORD, PCHAR, PDWORD, PDWORD, PDWORD,
  44.                          PBYTE, PDWORD );
  45. HDSC_Thunk RQIKThunk;
  46. LONG (*RealRegQueryInfoKey)(HKEY, PCHAR, PDWORD, DWORD, PDWORD, PDWORD,
  47.                             PDWORD, PDWORD, PDWORD, PDWORD, PDWORD, 
  48.                             PFILETIME );
  49. LONG (__stdcall *RealWin32RegQueryInfoKey)(PCLIENT_STRUCT, DWORD, 
  50.                                            HKEY, PDWORD, PDWORD, PDWORD, 
  51.                                            PDWORD, PDWORD );
  52. HDSC_Thunk RQVThunk;
  53. LONG (*RealRegQueryValue)( HKEY, PCHAR, PCHAR, PLONG );
  54. HDSC_Thunk RQVEThunk;
  55. LONG (*RealRegQueryValueEx)(HKEY, PCHAR, PDWORD, PDWORD, PBYTE, PDWORD );
  56. HDSC_Thunk RSVThunk;
  57. LONG (*RealRegSetValue)( HKEY, PCHAR, DWORD, PCHAR, DWORD );
  58. HDSC_Thunk RSVEThunk;
  59. LONG (*RealRegSetValueEx)(HKEY, PCHAR, DWORD, DWORD, PBYTE, DWORD );
  60. HDSC_Thunk RRPDKThunk;
  61. LONG (*RealRegRemapPreDefKey)(HKEY, HKEY );
  62. HDSC_Thunk RQMVThunk;
  63. LONG (*RealRegQueryMultipleValues)(HKEY, PVALENT, DWORD, PCHAR, PDWORD );
  64. HDSC_Thunk RCDKThunk;
  65. LONG (*RealRegCreateDynKey)( PCHAR, PVOID, PVOID, PVOID, DWORD, PVMMHKEY);
  67. //
  68. // Indicates if the GUI wants activity to be logged
  69. //
  70. BOOLEAN                 FilterOn = FALSE;
  72. //
  73. // Global filter (sent to us by the GUI)
  74. //
  75. FILTER                  FilterDef;
  77. //
  78. // Array of process and path filters 
  79. //
  80. ULONG                   NumProcessFilters = 0;
  81. PCHAR                   ProcessFilters[MAXFILTERS];
  82. ULONG                   NumProcessExcludeFilters = 0;
  83. PCHAR                   ProcessExcludeFilters[MAXFILTERS];
  84. ULONG                   NumPathIncludeFilters = 0;
  85. PCHAR                   PathIncludeFilters[MAXFILTERS];
  86. ULONG                   NumPathExcludeFilters = 0;
  87. PCHAR                   PathExcludeFilters[MAXFILTERS];
  89. //
  90. // Hash table data 
  91. //
  92. PHASH_ENTRY HashTable[NUMHASH];
  94. //
  95. // List of freed entries (to save some allocation calls)
  96. //
  97. PHASH_ENTRY FreeEntries = NULL;
  99. //
  100. // Buffer data
  101. //
  102. PSTORE_BUF Store  = NULL;
  103. ULONG Sequence  = 0;
  105. //
  106. // Maximum amount of buffers we will grab for buffered unread data
  107. //
  108. ULONG NumStore  = 0;
  109. ULONG MaxStore  = 5;
  111. //
  112. // Semaphore for critical sections
  113. //
  114. SEMHANDLE               StoreMutex, HashMutex, FilterMutex;
  116. //
  117. // Unknown error string
  118. //
  119. CHAR                    errstring[32];
  121. //
  122. // VMM's Win32 service table (at least one Win32 registry
  123. // call gets routed through here, bypassing the
  124. // standard VMM VxD service entry points!)
  125. //
  126. PDWORD                  VMMWin32ServiceTable;
  129. //----------------------------------------------------------------------
  130. //                   V X D  C O N T R O L
  131. //----------------------------------------------------------------------
  133. //
  134. // Device declaration
  135. //
  136. Declare_Virtual_Device(REGMON)
  138. //
  139. // Message handlers - we only care about dynamic loading and unloading
  140. //
  141.     DefineControlHandler(SYS_DYNAMIC_DEVICE_INIT, OnSysDynamicDeviceInit);
  142.     DefineControlHandler(SYS_DYNAMIC_DEVICE_EXIT, OnSysDynamicDeviceExit);
  143.     DefineControlHandler(W32_DEVICEIOCONTROL, OnW32Deviceiocontrol);
  145. //----------------------------------------------------------------------
  146. // 
  147. // ControlDispatcher
  148. //
  149. // Multiplexes incoming VxD messages from Windows to their handlers.
  150. //
  151. //----------------------------------------------------------------------
  152.     BOOL __cdecl ControlDispatcher(
  153.         DWORD dwControlMessage,
  154.         DWORD EBX,
  155.         DWORD EDX,
  156.         DWORD ESI,
  157.         DWORD EDI,
  158.         DWORD ECX)
  159. {
  160.     START_CONTROL_DISPATCH
  162.         ON_SYS_DYNAMIC_DEVICE_INIT(OnSysDynamicDeviceInit);
  163.     ON_SYS_DYNAMIC_DEVICE_EXIT(OnSysDynamicDeviceExit);
  164.     ON_W32_DEVICEIOCONTROL(OnW32Deviceiocontrol);
  166.     END_CONTROL_DISPATCH
  168.         return TRUE;
  169. }
  172. //----------------------------------------------------------------------
  173. //      P A T T E R N   M A T C H I N G   R O U T I N E S
  174. //----------------------------------------------------------------------
  177. //----------------------------------------------------------------------
  178. //
  179. // MatchOkay
  180. //
  181. // Only thing left after compare is more mask. This routine makes
  182. // sure that its a valid wild card ending so that its really a match.
  183. //
  184. //----------------------------------------------------------------------
  185. BOOLEAN MatchOkay( PCHAR Pattern )
  186. {
  187.     //
  188.     // If pattern isn't empty, it must be a wildcard
  189.     //
  190.     if( *Pattern && *Pattern != '*' ) {
  191.  
  192.         return FALSE;
  193.     }
  195.     //
  196.     // Matched
  197.     //
  198.     return TRUE;
  199. }
  202. //----------------------------------------------------------------------
  203. //
  204. // MatchWithPattern
  205. //
  206. // Performs nifty wildcard comparison.
  207. //
  208. //----------------------------------------------------------------------
  209. BOOLEAN MatchWithPattern( PCHAR Pattern, PCHAR Name )
  210. {
  211.     CHAR   upcase;
  213.     //
  214.     // End of pattern?
  215.     //
  216.     if( !*Pattern ) {
  218.         return FALSE;
  219.     }
  221.     //
  222.     // If we hit a wild card, do recursion
  223.     //
  224.     if( *Pattern == '*' ) {
  226.         Pattern++;
  228.         while( *Name && *Pattern ) {
  230.             if( *Name >= 'a' && *Name <= 'z' )
  231.                 upcase = *Name - 'a' + 'A';
  232.             else
  233.                 upcase = *Name;
  235.             //
  236.             // See if this substring matches
  237.             //
  238.             if( *Pattern == upcase || *Name == '*' ) {
  240.                 if( MatchWithPattern( Pattern+1, Name+1 )) {
  242.                     return TRUE;
  243.                 }
  244.             }
  246.             //
  247.             // Try the next substring
  248.             //
  249.             Name++;
  250.         }
  252.         //
  253.         // See if match condition was met
  254.         //
  255.         return MatchOkay( Pattern );
  256.     } 
  258.     //
  259.     // Do straight compare until we hit a wild card
  260.     //
  261.     while( *Name && *Pattern != '*' ) {
  263.         if( *Name >= 'a' && *Name <= 'z' )
  264.             upcase = *Name - 'a' + 'A';
  265.         else
  266.             upcase = *Name;
  268.         if( *Pattern == upcase ) {
  270.             Pattern++;
  271.             Name++;
  273.         } else {
  275.             return FALSE;
  276.         }
  277.     }
  279.     //
  280.     // If not done, recurse
  281.     //
  282.     if( *Name ) {
  284.         return MatchWithPattern( Pattern, Name );
  285.     }
  287.     //
  288.     // Make sure its a match
  289.     //
  290.     return MatchOkay( Pattern );
  291. }
  294. //----------------------------------------------------------------------
  295. // B U F F E R  M A N A G E M E N T  A N D  P R I N T  R O U T I N E S
  296. //----------------------------------------------------------------------
  299. //----------------------------------------------------------------------
  300. //
  301. // RegmonFreeStore
  302. //
  303. // Frees all the data output buffers that we have currently allocated.
  304. //
  305. //----------------------------------------------------------------------
  306. VOID RegmonFreeStore()
  307. {
  308.     PSTORE_BUF  prev;
  309.     
  310.     //
  311.     // Just traverse the list of allocated output buffers
  312.     //
  313.     while( Store ) {
  315.         prev = Store->Next;
  316.         PageFree( (MEMHANDLE) Store, 0 );
  317.         Store = prev;
  318.     }
  319. }
  322. //----------------------------------------------------------------------
  323. //
  324. // RegmonNewStore
  325. //
  326. // Called when the current buffer has filled up. This moves us to the
  327. // pre-allocated buffer and then allocates another buffer.
  328. //
  329. //----------------------------------------------------------------------
  330. void RegmonNewStore( void )
  331. {
  332.     PSTORE_BUF prev = Store, newstore;
  334.     //
  335.     // If we have maxed out or haven't accessed the current store
  336.     // just return.
  337.     //
  338.     if( MaxStore == NumStore ) {
  340.         Store->Len = 0;
  341.         return;
  342.     }
  344.     //
  345.     // If the output buffer we currently are using is empty, just
  346.     // use it.
  347.     //
  348.     if( !Store->Len ) 
  349.         return;
  351.     //
  352.     // Allocate a new output buffer
  353.     //
  354.     PageAllocate(STORESIZE, PG_SYS, 0, 0, 0, 0, NULL, PAGELOCKED, 
  355.                  (PMEMHANDLE) &newstore, (PVOID) &newstore );
  356.     if( newstore ) { 
  358.         //
  359.         // Allocation was successful so add the buffer to the list
  360.         // of allocated buffers and increment the buffer count.
  361.         //
  362.         Store   = newstore;
  363.         Store->Len  = 0;
  364.         Store->Next = prev;
  365.         NumStore++;
  367.     } else {
  369.         //
  370.         // The allocation failed - just reuse the current buffer
  371.         //
  372.         Store->Len = 0;
  373.     }
  374. }
  377. //----------------------------------------------------------------------
  378. //
  379. // RegmonOldestStore
  380. //
  381. // Goes through the linked list of storage buffers and returns the 
  382. // oldest one.
  383. //
  384. //----------------------------------------------------------------------
  385. PSTORE_BUF RegmonOldestStore( void )
  386. {
  387.     PSTORE_BUF  ptr = Store, prev = NULL;
  389.     //
  390.     // Traverse the list
  391.     //    
  392.     while ( ptr->Next ) {
  394.         ptr = (prev = ptr)->Next;
  395.     }
  397.     //
  398.     // Remove the buffer from the list
  399.     //
  400.     if ( prev ) {
  402.         prev->Next = NULL;    
  403.     }
  404.     NumStore--;
  405.     return ptr;
  406. }
  409. //----------------------------------------------------------------------
  410. //
  411. // RegmonResetStore
  412. //
  413. // When a GUI is no longer communicating with us, but we can't unload,
  414. // we reset the storage buffers.
  415. //
  416. //----------------------------------------------------------------------
  417. VOID RegmonResetStore()
  418. {
  419.     PSTORE_BUF  current, next;
  421.     //
  422.     // Traverse the list of output buffers
  423.     //
  424.     current = Store->Next;
  425.     while( current ) {
  427.         //
  428.         // Free the buffer
  429.         //
  430.         next = current->Next;
  432.         PageFree( (MEMHANDLE) current, 0 );
  434.         current = next;
  435.     }
  437.     // 
  438.     // Move the output pointer in the buffer that's being kept
  439.     // the start of the buffer.
  440.     // 
  441.     Store->Len = 0;
  442.     Store->Next = NULL;
  443. }
  446. //----------------------------------------------------------------------
  447. //
  448. // UpdateStore
  449. //
  450. // Add a new string to Store, if it fits.
  451. //
  452. //----------------------------------------------------------------------
  453. void UpdateStore( ULONG seq, const char * format, ... )
  454. {
  455.     PENTRY Entry;
  456.     ULONG len;
  457.     va_list arg_ptr;
  458.     static CHAR text[MAXPATHLEN];
  460.     //
  461.     // If no filtering is desired, don't bother
  462.     //
  463.     if( !FilterOn ) {
  464.  
  465.         return;
  466.     }
  468.     //
  469.     // Lock the output buffer.
  470.     //
  471.     Wait_Semaphore( StoreMutex, BLOCK_SVC_INTS );
  473.     //
  474.     // Vsprintf to determine length of the buffer
  475.     //
  476.     _asm cld;
  477.     va_start( arg_ptr, format );
  478.     len = vsprintf( text, format, arg_ptr );
  479.     va_end( arg_ptr );
  481.     //
  482.     // If the current output buffer is near capacity, move to a new
  483.     // output buffer
  484.     //
  485.     if( (ULONG) (Store->Len + len + sizeof(ENTRY) +1) >= MAX_STORE ) {
  487.         RegmonNewStore();
  488.     }
  490.     //
  491.     // Extract the sequence number and store it
  492.     //
  493.     Entry = (void *)(Store->Data+Store->Len);
  494.     Entry->seq = seq;
  495.     _asm cld;
  496.     memcpy( Entry->text, text, len+1 );
  497.  
  498.     //
  499.     // Store the length of the string, plus 1 for the terminating
  500.     // NULL  
  501.     //   
  502.     Store->Len += sizeof(Entry->seq)+len+1;
  504.     //
  505.     // Release the output buffer lock
  506.     //
  507.     Signal_Semaphore( StoreMutex );
  508. }
  510. //----------------------------------------------------------------------
  511. //       H A S H   T A B L E   M A N A G E M E N T
  512. //----------------------------------------------------------------------
  515. //----------------------------------------------------------------------
  516. //
  517. // RegmonHashCleanup
  518. //
  519. // Called when we are unloading to free any memory that we have 
  520. // in our possession.
  521. //
  522. //----------------------------------------------------------------------
  523. VOID RegmonHashCleanup()
  524. {
  525.     PHASH_ENTRY hashEntry, nextEntry;
  526.     ULONG i;
  527.   
  528.     //
  529.     // First, free the hash table entries
  530.     //
  531.     for( i = 0; i < NUMHASH; i++ ) {
  533.         hashEntry = HashTable[i];
  535.         while( hashEntry ) {
  536.             nextEntry = hashEntry->Next;
  537.             HeapFree( hashEntry->FullName, 0 );
  538.             HeapFree( hashEntry, 0 );
  539.             hashEntry = nextEntry;
  540.         }
  541.     }
  543.     //
  544.     // Now, free structures on our free list
  545.     //
  546.     while( FreeEntries ) {
  547.         nextEntry = FreeEntries->Next;
  548.         HeapFree( FreeEntries, 0 );
  549.         FreeEntries = nextEntry;
  550.     }
  551. }
  553. //----------------------------------------------------------------------
  554. //
  555. // RegmonStoreHash
  556. //
  557. // Stores the key and associated fullpath in the hash table.
  558. //
  559. //----------------------------------------------------------------------
  560. VOID RegmonStoreHash( HKEY hkey, PCHAR fullname )
  561. {
  562.     PHASH_ENTRY     newEntry;
  564.     Wait_Semaphore( HashMutex, BLOCK_SVC_INTS );
  566.     //
  567.     // Find or allocate an entry to use
  568.     //
  569.     if( FreeEntries ) {
  571.         newEntry    = FreeEntries;
  572.         FreeEntries = FreeEntries->Next;
  574.     } else {
  576.         newEntry = HeapAllocate( sizeof(HASH_ENTRY), 0 );
  577.     }
  579.     //
  580.     // Initialize the new entry.
  581.     //
  582.     newEntry->hkey             = hkey;
  583.     newEntry->FullName          = HeapAllocate( strlen(fullname)+1, 0);
  584.     newEntry->Next = HashTable[ HASHOBJECT(hkey) ];
  585.     HashTable[ HASHOBJECT(hkey) ] = newEntry;
  586.     strcpy( newEntry->FullName, fullname );
  588.     Signal_Semaphore( HashMutex );
  589. }
  591. //----------------------------------------------------------------------
  592. //
  593. // RegmonFreeHashEntry
  594. //
  595. // When we see a file close, we can free the string we had associated
  596. // with the fileobject being closed since we know it won't be used
  597. // again.
  598. //
  599. //----------------------------------------------------------------------
  600. VOID RegmonFreeHashEntry( HKEY hkey )
  601. {
  602.     PHASH_ENTRY hashEntry, prevEntry;
  604.     Wait_Semaphore( HashMutex, BLOCK_SVC_INTS );
  606.     //
  607.     // Look-up the entry.
  608.     //
  609.     hashEntry = HashTable[ HASHOBJECT( hkey ) ];
  610.     prevEntry = NULL;
  612.     while( hashEntry && hashEntry->hkey != hkey ) {
  614.         prevEntry = hashEntry;
  615.         hashEntry = hashEntry->Next;
  616.     }
  617.   
  618.     //  
  619.     // If we fall of the hash list without finding what we're looking
  620.     // for, just return.
  621.     //
  622.     if( !hashEntry ) {
  624.         Signal_Semaphore( HashMutex );
  625.         return;
  626.     }
  628.     //
  629.     // Got it! Remove it from the list
  630.     //
  631.     if( prevEntry ) {
  633.         prevEntry->Next = hashEntry->Next;
  635.     } else {
  637.         HashTable[ HASHOBJECT( hkey )] = hashEntry->Next;
  638.     }
  640.     //
  641.     // Free the memory associated with it
  642.     //
  643.     HeapFree( hashEntry->FullName, 0 );
  645.     //
  646.     // Put it on our free list  
  647.     //
  648.     hashEntry->Next  = FreeEntries;
  649.     FreeEntries  = hashEntry;
  651.     Signal_Semaphore( HashMutex );
  652. }
  654. //----------------------------------------------------------------------
  655. //       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
  656. //----------------------------------------------------------------------
  658. //----------------------------------------------------------------------
  659. //
  660. // ErrorString
  661. //
  662. // Returns the string form of an error code.
  663. //
  664. //----------------------------------------------------------------------
  665. PCHAR ErrorString( DWORD retval )
  666. {
  667.     //
  668.     // Before transating, apply error filter
  669.     //
  670.     if( retval == ERROR_SUCCESS && !FilterDef.logsuccess ) return NULL;
  671.     if( retval != ERROR_SUCCESS && !FilterDef.logerror   ) return NULL;
  673.     //
  674.     // Passed filter, so log it
  675.     //
  676.     switch( retval ) {
  677.     case ERROR_SUCCESS:
  678.         return "SUCCESS";
  679.     case ERROR_KEY_DELETED:
  680.         return "KEYDELETED";
  681.     case ERROR_BADKEY:
  682.         return "BADKEY";
  683.     case ERROR_REGISTRY_IO_FAILED:
  684.         return "IOFAILED";
  685.     case ERROR_REGISTRY_CORRUPT:
  686.         return "CORRUPT";
  687.     case ERROR_BADDB:
  688.         return "BADDB";
  689.     case ERROR_OUTOFMEMORY:
  690.         return "OUTOFMEM";
  691.     case ERROR_ACCESS_DENIED:
  692.         return "ACCDENIED";
  693.     case ERROR_FILE_NOT_FOUND:
  694.         return "NOTFOUND";
  695.     case ERROR_NO_MORE_ITEMS:
  696.         return "NOMORE";
  697.     case ERROR_MORE_DATA:
  698.         return "MOREDATA";
  699.     default:
  700.         sprintf(errstring, "%xn", retval );
  701.         return errstring;
  702.     }
  703. }
  705. //----------------------------------------------------------------------
  706. //
  707. // RegmonFreeFilters
  708. //
  709. // Fress storage we allocated for filter strings.
  710. //
  711. //----------------------------------------------------------------------
  712. VOID RegmonFreeFilters()
  713. {
  714.     ULONG   i;
  716.     for( i = 0; i < NumProcessFilters; i++ ) {
  718.         HeapFree( ProcessFilters[i], 0 );
  719.     }
  720.     for( i = 0; i < NumProcessExcludeFilters; i++ ) {
  722.         HeapFree( ProcessExcludeFilters[i], 0 );
  723.     }
  724.     for( i = 0; i < NumPathIncludeFilters; i++ ) {
  726.         HeapFree( PathIncludeFilters[i], 0 );
  727.     }
  728.     for( i = 0; i < NumPathExcludeFilters; i++ ) {
  730.         HeapFree( PathExcludeFilters[i], 0 );
  731.     }
  732.     NumProcessFilters = 0;
  733.     NumProcessExcludeFilters = 0;
  734.     NumPathIncludeFilters = 0;
  735.     NumPathExcludeFilters = 0;
  736. }
  738. //----------------------------------------------------------------------
  739. //
  740. // MakeFilterArray
  741. //
  742. // Takes a filter string and splits into components (a component
  743. // is seperated with a ';')
  744. //
  745. //----------------------------------------------------------------------
  746. VOID MakeFilterArray( PCHAR FilterString,
  747.                       PCHAR FilterArray[],
  748.                       PULONG NumFilters )
  749. {
  750.     PCHAR filterStart;
  751.     ULONG filterLength;
  753.     //
  754.     // Scan through the process filters
  755.     //
  756.     filterStart = FilterString;
  757.     while( *filterStart ) {
  759.         filterLength = 0;
  760.         while( filterStart[filterLength] &&
  761.                filterStart[filterLength] != ';' ) {
  763.             filterLength++;
  764.         }
  766.         //
  767.         // Ignore zero-length components
  768.         //
  769.         if( filterLength ) {
  771.             FilterArray[ *NumFilters ] = 
  772.                 HeapAllocate( filterLength + 1, 0 );
  773.             strncpy( FilterArray[ *NumFilters ],
  774.                      filterStart, filterLength );
  775.             FilterArray[ *NumFilters ][filterLength] = 0;
  776.             (*NumFilters)++;
  777.         }
  778.     
  779.         //
  780.         // Are we done?
  781.         //
  782.         if( !filterStart[filterLength] ) break;
  784.         //
  785.         // Move to the next component (skip over ';')
  786.         //
  787.         filterStart += filterLength + 1;
  788.     }
  789. }
  791. //----------------------------------------------------------------------
  792. //
  793. // RegmonUpdateFilters
  794. //
  795. // Takes a new filter specification and updates the filter
  796. // arrays with them.
  797. //
  798. //----------------------------------------------------------------------
  799. VOID RegmonUpdateFilters()
  800. {
  801.     //
  802.     // Free old filters (if any)
  803.     //
  804.     Wait_Semaphore( FilterMutex, BLOCK_SVC_INTS );
  806.     RegmonFreeFilters();
  808.     //
  809.     // Create new filter arrays
  810.     //
  811.     MakeFilterArray( FilterDef.processfilter,
  812.                      ProcessFilters, &NumProcessFilters );
  813.     MakeFilterArray( FilterDef.processexclude,
  814.                      ProcessExcludeFilters, &NumProcessExcludeFilters );
  815.     MakeFilterArray( FilterDef.pathfilter,
  816.                      PathIncludeFilters, &NumPathIncludeFilters );
  817.     MakeFilterArray( FilterDef.excludefilter,
  818.                      PathExcludeFilters, &NumPathExcludeFilters );    
  820.     Signal_Semaphore( FilterMutex );
  821. }
  824. //----------------------------------------------------------------------
  825. //
  826. // GetProcess
  827. //
  828. // Retrieves the process name.
  829. //
  830. //----------------------------------------------------------------------
  831. PCHAR GetProcess( PCHAR ProcessName )
  832. {
  833.     PVOID       CurProc;
  834.     PVOID       ring3proc;
  835.     char        *name;
  836.     ULONG       i;
  838.     //
  839.     // Get the ring0 process pointer.
  840.     //
  841.     CurProc = VWIN32_GetCurrentProcessHandle();
  842.   
  843.     //
  844.     // Now, map the ring3 PCB 
  845.     //
  846.     ring3proc = (PVOID) SelectorMapFlat( Get_Sys_VM_Handle(), 
  847.                                          (DWORD) (*(PDWORD) ((char *) CurProc + 0x38)) | 0x7, 0 );
  849.     if( ring3proc == (PVOID) -1 ) {
  850.         strcpy( ProcessName, "???");
  851.         return ProcessName;
  852.     }
  854.     //
  855.     // copy out the process name (max 8 characters)
  856.     //
  857.     name = ((char *)ring3proc) + 0xF2;
  858.     if( name[0] >= 'A' && name[0] < 'z' ) {
  860.         strcpy( ProcessName, name );
  861.         ProcessName[8] = 0;
  862.     } else {
  864.         strcpy( ProcessName, "???" );
  865.     }
  867.     //
  868.     // Apply process name filters
  869.     //
  870.     Wait_Semaphore( FilterMutex, BLOCK_SVC_INTS );
  871.     for( i = 0; i < NumProcessExcludeFilters; i++ ) {
  873.         if( MatchWithPattern( ProcessExcludeFilters[i], ProcessName )) {
  875.             Signal_Semaphore( FilterMutex );
  876.             return NULL;
  877.         }
  878.     }
  879.     for( i = 0; i < NumProcessFilters; i++ ) {
  881.         if( MatchWithPattern( ProcessFilters[i], ProcessName ) ) {
  883.             Signal_Semaphore( FilterMutex );
  884.             return ProcessName;
  885.         }
  886.     }
  887.     Signal_Semaphore( FilterMutex );
  888.     return NULL;
  889. }
  891. //----------------------------------------------------------------------
  892. //
  893. // ApplyNameFilter
  894. //
  895. // If the name matches the exclusion mask, we do not log it. Else if
  896. // it doesn't match the inclusion mask we do not log it. 
  897. //
  898. //----------------------------------------------------------------------
  899. BOOLEAN ApplyNameFilter( PCHAR fullname )
  900. {
  901.     ULONG    i;
  903.     //   
  904.     // If it matches the exclusion string, do not log it
  905.     //
  906.     Wait_Semaphore( FilterMutex, BLOCK_SVC_INTS );
  907.     for( i = 0; i < NumPathExcludeFilters; i++ ) {
  909.         if( MatchWithPattern( PathExcludeFilters[i], fullname ) ) {
  911.             Signal_Semaphore( FilterMutex );
  912.             return FALSE;
  913.         }
  914.     }
  915.  
  916.     //
  917.     // If it matches an include filter then log it
  918.     //
  919.     for( i = 0; i < NumPathIncludeFilters; i++ ) {
  921.         if( MatchWithPattern( PathIncludeFilters[i], fullname )) {
  923.             Signal_Semaphore( FilterMutex );
  924.             return TRUE;
  925.         }
  926.     }
  928.     //
  929.     // It didn't match any include filters so don't log
  930.     //
  931.     Signal_Semaphore( FilterMutex );
  932.     return FALSE;
  933. }
  936. //----------------------------------------------------------------------
  937. //
  938. // GetFullName
  939. //
  940. // Returns the full pathname of a key, if we can obtain one, else
  941. // returns a handle.
  942. //
  943. //----------------------------------------------------------------------
  944. void GetFullName( HKEY hKey, PCHAR lpszSubKey, PCHAR lpszValue, 
  945.                   PCHAR fullname )
  946. {
  947.     PHASH_ENTRY hashEntry;
  948.     CHAR                tmpkey[16];
  950.     //
  951.     // See if we find the key in the hash table
  952.     //
  953.     fullname[0] = 0;
  954.     Wait_Semaphore( HashMutex, BLOCK_SVC_INTS );
  956.     hashEntry = HashTable[ HASHOBJECT( hKey ) ];
  957.     while( hashEntry && hashEntry->hkey != hKey ) {
  959.         hashEntry = hashEntry->Next;
  960.     }
  962.     Signal_Semaphore( HashMutex );
  964.     if( hashEntry ) {
  966.         strcpy( fullname, hashEntry->FullName );
  968.     } else {
  970.         //
  971.         // Okay, make a name
  972.         //
  973.         switch( hKey ) {
  975.         case HKEY_CLASSES_ROOT:
  976.             strcat(fullname, "HKCR");
  977.             break;
  979.         case HKEY_CURRENT_USER:
  980.             strcat(fullname, "HKCU");
  981.             break;
  983.         case HKEY_LOCAL_MACHINE:
  984.             strcat(fullname, "HKLM");
  985.             break;
  987.         case HKEY_USERS:
  988.             strcat(fullname, "HKU");
  989.             break;
  991.         case HKEY_CURRENT_CONFIG:
  992.             strcat(fullname, "HKCC");
  993.             break;
  995.         case HKEY_DYN_DATA:
  996.             strcat(fullname, "HKDD");
  997.             break;
  999.         default:
  1001.             //
  1002.             // We will only get here if key was created before we loaded
  1003.             //
  1004.             sprintf( tmpkey, "0x%X", hKey );
  1005.             strcat(fullname, tmpkey );
  1006.             break;
  1007.         }
  1008.     }
  1010.     //
  1011.     // Append subkey and value, if they are there
  1012.     //
  1013.     if( lpszSubKey ) {
  1015.         if( lpszSubKey[0] ) {
  1017.             strcat( fullname, "\" );
  1018.             strcat( fullname, lpszSubKey );
  1019.         }
  1020.     }
  1022.     if( lpszValue ) {
  1024.         if( lpszValue[0] ) {
  1026.             strcat( fullname, "\" );
  1027.             strcat( fullname, lpszValue );
  1028.         }
  1029.     }
  1030. }
  1032. //----------------------------------------------------------------------
  1033. // REGISTRY HOOKS
  1034. //
  1035. // All these hooks do essentially the same thing: dump API-specific
  1036. // info into the data buffer, call the original handler, and then
  1037. // dump any return information.
  1038. //----------------------------------------------------------------------
  1039. LONG HookRegOpenKey( HKEY hkey, PCHAR lpszSubKey, PHKEY phkResult) {
  1040.     LONG     retval;
  1041.     CHAR     fullname[NAMELEN], data[DATASIZE], process[PROCESSLEN];
  1043.     GetFullName( hkey, lpszSubKey, NULL, fullname );
  1044.     retval = RealRegOpenKey( hkey, lpszSubKey, phkResult );
  1045.     data[0] = 0;
  1046.     if( retval == ERROR_SUCCESS ) {
  1048.         RegmonFreeHashEntry( *phkResult );
  1049.         RegmonStoreHash( *phkResult, fullname );
  1050.         sprintf(data,"hKey: 0x%X", *phkResult );
  1051.     }  
  1052.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1053.         FilterDef.logreads ) {
  1055.         UpdateStore( Sequence++, "%stOpenKeyt%st%st%s", 
  1056.                      process, fullname, ErrorString( retval ), data);
  1057.     }
  1058.     return retval;
  1059. }
  1061. LONG HookRegCreateKey( HKEY hkey, PCHAR lpszSubKey, PHKEY phkResult) {
  1062.     LONG      retval;
  1063.     CHAR      fullname[NAMELEN], data[DATASIZE], process[PROCESSLEN];
  1065.     GetFullName( hkey, lpszSubKey, NULL, fullname );
  1066.     retval = RealRegCreateKey( hkey, lpszSubKey, phkResult );
  1067.     data[0] = 0;
  1068.     if( retval == ERROR_SUCCESS ) {
  1070.         RegmonFreeHashEntry( *phkResult );
  1071.         RegmonStoreHash( *phkResult, fullname );
  1072.         sprintf(data,"hKey: 0x%X", *phkResult );
  1073.     }
  1075.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1076.         FilterDef.logwrites ) {
  1078.         UpdateStore( Sequence++, "%stCreateKeyt%st%st%s", 
  1079.                      process, fullname, ErrorString( retval ), data);
  1080.     }
  1081.     return retval;
  1082. }
  1084. LONG HookRegDeleteKey( HKEY hkey, PCHAR lpszSubKey ) {
  1085.     LONG      retval;
  1086.     CHAR      fullname[NAMELEN], process[PROCESSLEN];
  1088.     GetFullName( hkey, lpszSubKey, NULL, fullname );  
  1089.     retval = RealRegDeleteKey( hkey, lpszSubKey );
  1091.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1092.         FilterDef.logwrites ) {
  1094.         UpdateStore( Sequence++, "%stDeleteKeyt%st%s", 
  1095.                      process, fullname, ErrorString( retval ));
  1096.     }
  1097.     return retval;
  1098. }
  1100. LONG HookRegDeleteValue( HKEY hkey, PCHAR lpszSubKey ) {
  1101.     LONG      retval;
  1102.     CHAR      fullname[NAMELEN], process[PROCESSLEN];
  1104.     GetFullName( hkey, lpszSubKey, NULL, fullname );  
  1105.     retval = RealRegDeleteValue( hkey, lpszSubKey );
  1107.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1108.         FilterDef.logwrites ) {
  1110.         UpdateStore( Sequence++, "%stDeleteValuet%st%s", 
  1111.                      process, fullname, ErrorString( retval ));
  1112.     }
  1113.     return retval;
  1114. }
  1116. LONG HookRegCloseKey(HKEY hkey) {
  1117.     LONG      retval;
  1118.     CHAR      fullname[NAMELEN], process[PROCESSLEN];
  1120.     GetFullName( hkey, NULL, NULL, fullname );  
  1121.     retval = RealRegCloseKey( hkey );
  1123.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1124.         FilterDef.logreads ) {
  1126.         UpdateStore( Sequence++, "%stCloseKeyt%st%s", 
  1127.                      process, fullname, ErrorString( retval ));
  1128.     }
  1129.     RegmonFreeHashEntry( hkey );
  1130.     return retval;
  1131. }
  1133. LONG HookRegFlushKey( HKEY hkey ) {
  1134.     LONG      retval;
  1135.     CHAR      fullname[NAMELEN], process[PROCESSLEN];
  1137.     GetFullName( hkey, NULL, NULL, fullname );  
  1138.     retval = RealRegFlushKey( hkey );
  1140.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1141.         FilterDef.logwrites ) {
  1143.         UpdateStore( Sequence++, "%stFlushKeyt%st%s", 
  1144.                      process, fullname, ErrorString( retval ));
  1145.     }
  1146.     return retval;
  1147. }
  1149. LONG HookRegEnumKey(HKEY hkey, DWORD iSubKey, PCHAR lpszName, DWORD cchName) {
  1150.     LONG      retval;
  1151.     CHAR      fullname[NAMELEN], process[PROCESSLEN];
  1152.   
  1153.     GetFullName( hkey, NULL, NULL, fullname );
  1154.     retval = RealRegEnumKey( hkey, iSubKey, lpszName, cchName );
  1156.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1157.         FilterDef.logreads ) {
  1158.   
  1159.         UpdateStore( Sequence++, "%stEnumKeyt%st%st%s", 
  1160.                      process, fullname, 
  1161.                      ErrorString( retval ),
  1162.                      retval == ERROR_SUCCESS ? lpszName : "");  
  1163.     }
  1164.     return retval;
  1165. }
  1167. LONG HookRegEnumValue(HKEY hkey, DWORD iValue, PCHAR lpszValue, 
  1168.                       PDWORD lpcchValue, PDWORD lpdwReserved, 
  1169.                       PDWORD lpdwType, PBYTE lpbData, PDWORD lpcbData) {
  1170.     LONG      retval;
  1171.     int       i, len;
  1172.     CHAR      fullname[NAMELEN], data[DATASIZE], tmp[2*BINARYLEN], process[PROCESSLEN];
  1174.     GetFullName( hkey, NULL, NULL, fullname );
  1175.     retval = RealRegEnumValue( hkey, iValue, lpszValue, lpcchValue,
  1176.                                lpdwReserved, lpdwType, lpbData, lpcbData );
  1177.     data[0] = 0;
  1178.     if( retval == ERROR_SUCCESS && lpbData && *lpcbData ) {
  1180.         strcat( data, lpszValue );
  1181.         strcat( data, ": ");
  1182.         if( !lpdwType || *lpdwType == REG_BINARY ) {
  1184.             if( *lpcbData > BINARYLEN ) len = BINARYLEN;
  1185.             else len = *lpcbData;
  1187.             for( i = 0; i < len; i++ ) {
  1189.                 sprintf( tmp, "%X ", lpbData[i]);
  1190.                 strcat( data, tmp );
  1191.             }
  1193.             if( *lpcbData > BINARYLEN) strcat( data, "...");
  1195.         } else if( *lpdwType == REG_SZ ) {
  1197.             strcat( data, """);
  1198.             strncat( data, lpbData, STRINGLEN );
  1199.             strcat( data, """);
  1201.         } else if( *lpdwType == REG_DWORD ) {
  1203.             sprintf( tmp, "0x%X", *(PDWORD) lpbData );
  1204.             strcat( data, tmp );
  1205.         }
  1206.     }
  1208.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1209.         FilterDef.logreads ) {
  1211.         UpdateStore( Sequence++, "%stEnumValuet%st%st%s", 
  1212.                      process, fullname, ErrorString( retval ),
  1213.                      data ); 
  1214.     }
  1215.     return retval;
  1216. }
  1218. LONG HookRegQueryInfoKey( HKEY hKey, PCHAR lpszClass, PDWORD lpcchClass,  
  1219.                           DWORD lpdwReserved, PDWORD lpcSubKeys, 
  1220.                           PDWORD lpcchMaxSubKey, PDWORD  pcchMaxClass, 
  1221.                           PDWORD lpcValues, PDWORD lpcchMaxValueName, 
  1222.                           PDWORD lpcbMaxValueData, 
  1223.                           PDWORD lpcbSecurityDescriptor, 
  1224.                           PFILETIME lpftLastWriteTime) {
  1225.     LONG      retval;
  1226.     CHAR      fullname[NAMELEN], process[PROCESSLEN];
  1228.     GetFullName( hKey, NULL, NULL, fullname );
  1229.     retval = RealRegQueryInfoKey( hKey, lpszClass, lpcchClass, lpdwReserved, 
  1230.                                   lpcSubKeys, lpcchMaxSubKey, pcchMaxClass,
  1231.                                   lpcValues, lpcchMaxValueName,
  1232.                                   lpcbMaxValueData,
  1233.                                   lpcbSecurityDescriptor,
  1234.                                   lpftLastWriteTime );
  1235.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1236.         FilterDef.logreads ) {
  1238.         if( retval == ERROR_SUCCESS && lpcSubKeys && lpcValues ) 
  1239.             UpdateStore( Sequence++, "%stQueryKeyt%st%stKeys: %d Values: %d", 
  1240.                          process, fullname, ErrorString( retval ), *lpcSubKeys, *lpcValues );
  1241.         else
  1242.             UpdateStore( Sequence++, "%stQueryKeyt%st%s", 
  1243.                          process, fullname, ErrorString( retval ));  
  1244.     }
  1245.     return retval;
  1246. }
  1248. LONG HookRegQueryValue( HKEY hkey, PCHAR lpszSubKey, PCHAR lpszValue, 
  1249.                         PLONG pcbValue ) {
  1250.     LONG      retval;
  1251.     CHAR      fullname[NAMELEN], data[DATASIZE], process[PROCESSLEN];
  1253.     GetFullName( hkey, lpszSubKey, "(Default)", fullname );
  1254.     retval = RealRegQueryValue( hkey, lpszSubKey, lpszValue, pcbValue );
  1255.     data[0] = 0;
  1256.     if( retval == ERROR_SUCCESS && lpszValue && *pcbValue ) {
  1258.         strcpy( data, """);
  1259.         strncat( data, lpszValue, STRINGLEN );
  1260.         if( strlen( lpszValue ) > STRINGLEN ) 
  1261.             strcat( data, "..." );
  1262.         strcat( data, """);
  1263.     }
  1264.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1265.         FilterDef.logreads ) {
  1267.         UpdateStore( Sequence++, "%stQueryValuet%st%st%s", 
  1268.                      process, fullname, ErrorString( retval ), data);
  1269.     }
  1270.     return retval;
  1271. }
  1273. LONG HookRegQueryValueEx( HKEY hkey, PCHAR lpszValueName, 
  1274.                           PDWORD lpdwReserved, PDWORD lpdwType, 
  1275.                           PBYTE lpbData, PDWORD lpcbData ) {
  1276.     LONG      retval;
  1277.     int       i, len;
  1278.     CHAR      fullname[NAMELEN], data[DATASIZE], tmp[2*BINARYLEN], process[PROCESSLEN];
  1279.   
  1280.     GetFullName( hkey, NULL, lpszValueName, fullname );
  1281.     retval = RealRegQueryValueEx( hkey, lpszValueName, lpdwReserved, 
  1282.                                   lpdwType, lpbData, lpcbData );
  1283.     data[0] = 0;
  1284.     if( retval == ERROR_SUCCESS && lpbData ) {
  1286.         if( !lpdwType || *lpdwType == REG_BINARY ) {
  1288.             if( *lpcbData > BINARYLEN ) len = BINARYLEN;
  1289.             else len = *lpcbData;
  1291.             for( i = 0; i < len; i++ ) {
  1293.                 sprintf( tmp, "%X ", lpbData[i]);
  1294.                 strcat( data, tmp );
  1295.             }
  1297.             if( *lpcbData > BINARYLEN) strcat( data, "...");
  1299.         } else if( *lpdwType == REG_SZ ) {
  1301.             strcpy( data, """);
  1302.             strncat( data, lpbData, STRINGLEN );
  1303.             if( strlen( lpbData ) > STRINGLEN ) 
  1304.                 strcat( data, "..." );
  1305.             strcat( data, """);
  1307.         } else if( *lpdwType == REG_DWORD ) {
  1309.             sprintf( data, "0x%X", *(PDWORD) lpbData );
  1310.         }
  1311.     } 
  1313.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1314.         FilterDef.logreads) {
  1316.         UpdateStore( Sequence++, "%stQueryValueExt%st%st%s", 
  1317.                      process, fullname, ErrorString( retval ), data);  
  1318.     }
  1319.     return retval;
  1320. }
  1322. LONG HookRegSetValue( HKEY hkey, PCHAR lpszSubKey, DWORD fdwType, 
  1323.                       PCHAR lpszData, DWORD cbData ) {
  1324.     LONG      retval;
  1325.     CHAR      fullname[NAMELEN], data[DATASIZE], process[PROCESSLEN];
  1326.   
  1327.     GetFullName( hkey, lpszSubKey, "(Default)", fullname );
  1328.     retval = RealRegSetValue( hkey, lpszSubKey, fdwType, lpszData, cbData );
  1329.     data[0] = 0;
  1330.     if( lpszData ) {
  1332.         strcpy( data,""");
  1333.         strncat(data, lpszData, STRINGLEN );
  1334.         if( strlen( lpszData ) > STRINGLEN ) 
  1335.             strcat( data, "..." );
  1336.         strcat( data, """);
  1337.     }
  1338.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1339.         FilterDef.logwrites) {
  1341.         UpdateStore( Sequence++, "%stSetValuet%st%st%s", 
  1342.                      process, fullname, ErrorString( retval ), data );  
  1343.     }
  1344.     return retval;
  1345. }
  1347. LONG HookRegSetValueEx( HKEY hkey, PCHAR lpszValueName, 
  1348.                         DWORD lpdwReserved, DWORD fdwType, 
  1349.                         PBYTE lpbData, DWORD lpcbData ) {
  1350.     LONG      retval;
  1351.     int       i, len;
  1352.     CHAR      fullname[NAMELEN], data[DATASIZE], tmp[2*BINARYLEN], process[PROCESSLEN];
  1353.   
  1354.     GetFullName( hkey, NULL, lpszValueName, fullname );
  1355.     retval = RealRegSetValueEx( hkey, lpszValueName, lpdwReserved, 
  1356.                                 fdwType, lpbData, lpcbData );
  1357.     data[0] = 0;
  1358.     if( fdwType == REG_SZ ) {
  1360.         strcpy( data, """);
  1361.         strncat( data, lpbData, STRINGLEN );
  1362.         if( strlen( lpbData ) > STRINGLEN ) 
  1363.             strcat( data, "..." );
  1364.         strcat( data, """);
  1366.     } else if( fdwType == REG_BINARY ) {
  1368.         if( lpcbData > BINARYLEN ) len = BINARYLEN;
  1369.         else len = lpcbData;
  1371.         for( i = 0; i < len; i++ ) {
  1373.             sprintf( tmp, "%X ", lpbData[i]);
  1374.             strcat( data, tmp );
  1375.         }
  1377.         if( lpcbData > BINARYLEN) strcat( data, "...");
  1379.     } else if( fdwType == REG_DWORD ) {
  1381.         sprintf( data, "0x%X", *(PDWORD) lpbData );
  1382.     }
  1384.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1385.         FilterDef.logwrites) {
  1387.         UpdateStore( Sequence++, "%stSetValueExt%st%st%s", 
  1388.                      process, fullname, ErrorString( retval ), data );  
  1389.     }
  1390.     return retval;
  1391. }
  1393. LONG HookRegRemapPreDefKey( HKEY hkey, HKEY hRootKey ) {
  1394.     LONG      retval;
  1395.     CHAR      fullname[NAMELEN], process[PROCESSLEN];
  1397.     GetFullName( hkey, NULL, NULL, fullname );
  1398.     retval = RealRegRemapPreDefKey( hkey, hRootKey );
  1400.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval )) {
  1402.         UpdateStore( Sequence++, "%stRemapPreKeyt%st%stRoot: %s", 
  1403.                      process, fullname, ErrorString( retval ),
  1404.                      hRootKey == HKEY_CURRENT_USER ? "HKCU" : "HKCC" );
  1405.     }
  1406.     return retval;
  1407. }
  1409. LONG HookRegQueryMultipleValues( HKEY hKey, PVALENT pValent, 
  1410.                                  DWORD dwNumVals, PCHAR pValueBuf, 
  1411.                                  PDWORD pTotSize ) {
  1412.     LONG      retval;
  1413.     CHAR      fullname[NAMELEN], process[PROCESSLEN];
  1415.     GetFullName( hKey, NULL, NULL, fullname );
  1416.     retval = RealRegQueryMultipleValues( hKey, pValent,
  1417.                                          dwNumVals, pValueBuf, pTotSize );
  1419.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1420.         FilterDef.logreads) {
  1422.         UpdateStore( Sequence++, "%stQueryMultValt%st%s", 
  1423.                      process, fullname, ErrorString( retval ));  
  1424.     }
  1425.     return retval;
  1426. }
  1428. LONG HookRegCreateDynKey( PCHAR szName, PVOID KeyContext, 
  1429.                           PVOID pInfo, PVOID pValList, 
  1430.                           DWORD dwNumVals, PVMMHKEY pKeyHandle ) {
  1431.     LONG      retval;
  1432.     CHAR      fullname[NAMELEN], process[PROCESSLEN];
  1434.     sprintf(fullname, "DYNDAT\%s", szName );
  1435.     retval = RealRegCreateDynKey( szName, KeyContext, pInfo, pValList,
  1436.                                   dwNumVals, pKeyHandle );
  1438.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1439.         FilterDef.logreads) {
  1441.         UpdateStore( Sequence++, "%stCreateDynKeyt%st%sthKey: 0x%X", 
  1442.                      process, fullname, ErrorString( retval ),
  1443.                      *pKeyHandle ); 
  1444.     }
  1445.     if( retval == ERROR_SUCCESS ) {
  1447.         RegmonStoreHash( *pKeyHandle, fullname );
  1448.     }
  1449.     return retval;
  1450. }
  1452. LONG __stdcall HookWin32RegQueryInfoKey( volatile PCLIENT_STRUCT pClientRegs, DWORD Dummy2, 
  1453.                                          HKEY hKey, 
  1454.                                          PDWORD lpcSubKeys, 
  1455.                                          PDWORD lpcchMaxSubKey, 
  1456.                                          PDWORD lpcValues, PDWORD lpcchMaxValueName, 
  1457.                                          PDWORD lpcbMaxValueData )
  1458. {
  1459.     LONG      retval;
  1460.     CHAR      fullname[NAMELEN], process[PROCESSLEN];
  1462.     //
  1463.     // NOTE: this special hook is needed because Win95 has a bug where
  1464.     // the Win32 call to RegQueryInfoKey gets routed to VMM's Win32 
  1465.     // service table, but the service table handler does *not* call the
  1466.     // VMM RegQueryInfoKey entry point. Therefore, we have to hook the
  1467.     // VMM Win32 service as a special case.
  1468.     //
  1469.     GetFullName( hKey, NULL, NULL, fullname );
  1471.     //
  1472.     // The return code is stored in the client registers
  1473.     //
  1474.     RealWin32RegQueryInfoKey( pClientRegs, Dummy2, 
  1475.                               hKey, lpcSubKeys, lpcchMaxSubKey, 
  1476.                               lpcValues, lpcchMaxValueName,
  1477.                               lpcbMaxValueData );
  1478.     retval = pClientRegs->CRS.Client_EAX;
  1480.     if( GetProcess( process ) && ApplyNameFilter( fullname ) && ErrorString( retval ) &&
  1481.         FilterDef.logreads) {
  1483.         if( retval == ERROR_SUCCESS && lpcSubKeys && lpcValues ) 
  1484.             UpdateStore( Sequence++, "%stQueryKeyt%st%stKeys: %d Values: %d", 
  1485.                          process, fullname, ErrorString( retval ), *lpcSubKeys, *lpcValues );
  1486.         else
  1487.             UpdateStore( Sequence++, "%stQueryKeyt%st%s", 
  1488.                          process, fullname, ErrorString( retval ));  
  1489.     }
  1490.     return retval;
  1491. }
  1493. //----------------------------------------------------------------------
  1494. //
  1495. // OnSysDynamicDeviceInit
  1496. //
  1497. // Dynamic init. Hook all registry related VxD APIs.
  1498. //
  1499. //----------------------------------------------------------------------
  1500. BOOL OnSysDynamicDeviceInit()
  1501. {
  1502.     int i;
  1503.     PDDB vmmDDB;
  1505.     //
  1506.     // Initialize semaphores
  1507.     //
  1508.     StoreMutex = Create_Semaphore(1);
  1509.     HashMutex  = Create_Semaphore(1);
  1510.     FilterMutex  = Create_Semaphore(1);
  1512.     //
  1513.     // Zero hash table
  1514.     //
  1515.     for(i = 0; i < NUMHASH; i++ ) HashTable[i] = NULL;
  1517.     //
  1518.     // Allocate first output buffer
  1519.     //
  1520.     PageAllocate(STORESIZE, PG_SYS, 0, 0, 0, 0, NULL, PAGELOCKED, 
  1521.                  (PMEMHANDLE) &Store, (PVOID) &Store );
  1522.     Store->Len = 0;
  1523.     Store->Next = NULL;
  1524.     NumStore = 1;
  1526.     //
  1527.     // Hook all registry routines
  1528.     //
  1529.     RealRegOpenKey = Hook_Device_Service_C(___RegOpenKey, HookRegOpenKey,
  1530.                                            &ROKThunk );
  1531.     RealRegCloseKey = Hook_Device_Service_C(___RegCloseKey, HookRegCloseKey,
  1532.                                             &RCKThunk );
  1533.     RealRegCreateKey = Hook_Device_Service_C(___RegCreateKey, HookRegCreateKey,
  1534.                                              &RCRKThunk );
  1535.     RealRegDeleteKey = Hook_Device_Service_C(___RegDeleteKey, HookRegDeleteKey,
  1536.                                              &RDKThunk );
  1537.     RealRegDeleteValue = Hook_Device_Service_C(___RegDeleteValue, 
  1538.                                                HookRegDeleteValue,
  1539.                                                &RDVThunk );
  1540.     RealRegEnumKey   = Hook_Device_Service_C(___RegEnumKey,
  1541.                                              HookRegEnumKey,
  1542.                                              &REKThunk );
  1543.     RealRegEnumValue = Hook_Device_Service_C(___RegEnumValue, 
  1544.                                              HookRegEnumValue,
  1545.                                              &REVThunk );
  1546.     RealRegFlushKey  = Hook_Device_Service_C(___RegFlushKey,
  1547.                                              HookRegFlushKey,
  1548.                                              &RFKThunk );
  1549.     RealRegQueryInfoKey  = Hook_Device_Service_C(___RegQueryInfoKey,
  1550.                                                  HookRegQueryInfoKey,
  1551.                                                  &RQIKThunk );
  1552.     RealRegQueryValue = Hook_Device_Service_C(___RegQueryValue,
  1553.                                               HookRegQueryValue,
  1554.                                               &RQVThunk );
  1555.     RealRegQueryValueEx = Hook_Device_Service_C(___RegQueryValueEx,
  1556.                                                 HookRegQueryValueEx,
  1557.                                                 &RQVEThunk );
  1558.     RealRegSetValue = Hook_Device_Service_C(___RegSetValue,
  1559.                                             HookRegSetValue,
  1560.                                             &RSVThunk );
  1561.     RealRegSetValueEx = Hook_Device_Service_C(___RegSetValueEx,
  1562.                                               HookRegSetValueEx,
  1563.                                               &RSVEThunk );
  1564.     RealRegRemapPreDefKey = Hook_Device_Service_C(___RegRemapPreDefKey,
  1565.                                                   HookRegRemapPreDefKey,
  1566.                                                   &RRPDKThunk );
  1567.     RealRegQueryMultipleValues = Hook_Device_Service_C(___RegQueryMultipleValues,
  1568.                                                        HookRegQueryMultipleValues,
  1569.                                                        &RQMVThunk );
  1570.     RealRegCreateDynKey = Hook_Device_Service_C(___RegCreateDynKey,
  1571.                                                 HookRegCreateDynKey,
  1572.                                                 &RCDKThunk );
  1574.     //
  1575.     // We have to hook the Win32 service for query info key
  1576.     // (isn't win95 just great?)
  1577.     //
  1578.     vmmDDB = Get_DDB( VMM_DEVICE_ID, "" );
  1579.     VMMWin32ServiceTable = (PDWORD) vmmDDB->DDB_Win32_Service_Table;
  1580.     RealWin32RegQueryInfoKey = (PVOID) VMMWin32ServiceTable[ VMMWIN32QUERYINFOKEY ];
  1581.     VMMWin32ServiceTable[ VMMWIN32QUERYINFOKEY ] = (DWORD) HookWin32RegQueryInfoKey;
  1583.     return TRUE;
  1584. }
  1586. //----------------------------------------------------------------------
  1587. //
  1588. // OnSysDynamicDeviceExit
  1589. //
  1590. // Dynamic exit. Unhook everything.
  1591. //
  1592. //----------------------------------------------------------------------
  1593. BOOL OnSysDynamicDeviceExit()
  1594. {
  1595.     Unhook_Device_Service_C(___RegOpenKey, &ROKThunk );
  1596.     Unhook_Device_Service_C(___RegCloseKey, &RCKThunk );
  1597.     Unhook_Device_Service_C(___RegCreateKey, &RCRKThunk );
  1598.     Unhook_Device_Service_C(___RegDeleteKey, &RDKThunk );
  1599.     Unhook_Device_Service_C(___RegDeleteValue, &RDVThunk );
  1600.     Unhook_Device_Service_C(___RegEnumKey, &REKThunk );
  1601.     Unhook_Device_Service_C(___RegEnumValue, &REVThunk );
  1602.     Unhook_Device_Service_C(___RegFlushKey, &RFKThunk );
  1603.     Unhook_Device_Service_C(___RegQueryInfoKey, &RQIKThunk );
  1604.     Unhook_Device_Service_C(___RegQueryValue, &RQVThunk );
  1605.     Unhook_Device_Service_C(___RegQueryValueEx, &RQVEThunk );
  1606.     Unhook_Device_Service_C(___RegSetValue, &RSVThunk );
  1607.     Unhook_Device_Service_C(___RegSetValueEx, &RSVEThunk );
  1608.     Unhook_Device_Service_C(___RegRemapPreDefKey, &RRPDKThunk );
  1609.     Unhook_Device_Service_C(___RegQueryMultipleValues, &RQMVThunk );
  1610.     Unhook_Device_Service_C(___RegCreateDynKey, &RCDKThunk );
  1611.     VMMWin32ServiceTable[ VMMWIN32QUERYINFOKEY ] = (DWORD) RealWin32RegQueryInfoKey;
  1613.     //
  1614.     // Free all memory
  1615.     //
  1616.     RegmonHashCleanup();
  1617.     RegmonFreeStore();
  1618.     RegmonFreeFilters();
  1619.     return TRUE;
  1620. }
  1622. //----------------------------------------------------------------------
  1623. //
  1624. // OnW32Deviceiocontrol
  1625. //
  1626. // Interface with the GUI.
  1627. //
  1628. //----------------------------------------------------------------------
  1629. DWORD OnW32Deviceiocontrol(PIOCTLPARAMS p)
  1630. {
  1631.     PSTORE_BUF      old;
  1633.     switch( p->dioc_IOCtlCode ) {
  1635.     case 0:
  1636.         return 0;
  1638.     case REGMON_zerostats:
  1639.   
  1640.         Wait_Semaphore( StoreMutex, BLOCK_SVC_INTS );
  1641.         while ( Store->Next )  {
  1642.  
  1643.             //
  1644.             // Release the next entry.
  1645.             //
  1646.             old = Store->Next;
  1647.             Store->Next = old->Next;
  1648.             Signal_Semaphore( StoreMutex );
  1649.             PageFree( (MEMHANDLE) old, 0 );
  1650.             Wait_Semaphore( StoreMutex, BLOCK_SVC_INTS );
  1651.             NumStore--;
  1652.         }
  1653.         Store->Len = 0;
  1654.         Signal_Semaphore( StoreMutex );
  1655.         Sequence = 0;
  1656.         return 0;
  1658.     case REGMON_getstats:
  1659.   
  1660.         //
  1661.         // Copy buffer into user space.
  1662.         Wait_Semaphore( StoreMutex, BLOCK_SVC_INTS );
  1663.         if ( MAX_STORE > p->dioc_cbOutBuf ) {
  1665.             //
  1666.             // Buffer is too small. Return error.
  1667.             //
  1668.             Signal_Semaphore( StoreMutex );
  1670.             return 1;
  1672.         } else if ( Store->Len  ||  Store->Next ) {
  1674.             //
  1675.             // Switch to a new buffer.
  1676.             //
  1677.             RegmonNewStore();
  1679.             //
  1680.             // Fetch the oldest buffer to give to caller.
  1681.             //
  1682.             old = RegmonOldestStore();
  1683.             Signal_Semaphore( StoreMutex );
  1685.             //
  1686.             // Copy it into the caller's buffer.
  1687.             //
  1688.             memcpy( p->dioc_OutBuf, old->Data, old->Len );
  1690.             //
  1691.             // Return length of copied info.
  1692.             //
  1693.             *p->dioc_bytesret = old->Len;
  1695.             //   
  1696.             // Deallocate the buffer.
  1697.             //
  1698.             PageFree( (MEMHANDLE) old, 0 );
  1699.             NumStore--;
  1701.         } else {
  1703.             //
  1704.             // There is no unread data.
  1705.             //
  1706.             Signal_Semaphore( StoreMutex );
  1707.             *p->dioc_bytesret = 0;
  1708.         }
  1709.         return 0;
  1711.     case REGMON_unhook:
  1713.         FilterOn = FALSE;
  1714.         return 0;
  1716.     case REGMON_hook:
  1718.         FilterOn = TRUE;
  1719.         return 0;
  1721.     case REGMON_setfilter:
  1723.         FilterDef = * (PFILTER) p->dioc_InBuf;
  1724.         RegmonUpdateFilters();
  1725.         return 0;
  1726.     }
  1727.     return 0;
  1728. }