Only take into account processes that have our plugin loaded

installer/src/installer-lib/process.h

 /**
  * \file process.h
  */
 
 #ifndef PROCESS_H
 #define PROCESS_H
 
 #include <vector>
 #include <set>
 #include <algorithm>
@@ skipping 62 matching lines @@
    * Copy assignment declared private and not defined.
    *
    * \par Implementation
    *   Add "= delete" for C++11.
    */
   Windows_Handle operator=( const Windows_Handle & ) ;
 
 };
 
 //-------------------------------------------------------
-// exe_name_set: case-insensitive wide-string set
+// file_name_set: case-insensitive wide-string set
 //-------------------------------------------------------
 int wcscmpi( const wchar_t * s1, const wchar_t * s2 ) ;
 
-struct exe_name
+struct file_name
 {
   /**
    * Pointer to wide-character string, which is supposed to be null-terminated.
    */
   const wchar_t * name ;
 
-  exe_name( const wchar_t * name ) : name( name ) {} ;
+  file_name( const wchar_t * name ) : name( name ) {} ;
 } ;
 
 template <>
-struct std::less< exe_name >
-  : std::binary_function< exe_name, exe_name, bool >
-{
-  bool operator()( const exe_name & a, const exe_name & b ) const
+struct std::less< file_name >
+  : std::binary_function< file_name, file_name, bool >
+{
+  bool operator()( const file_name & a, const file_name & b ) const
   {
     return wcscmpi( a.name, b.name ) < 0 ; 
   }
 } ;
 
-struct exe_name_set
-  : public std::set< exe_name >
-{
-  exe_name_set( const wchar_t * exe_name_list[], size_t n_exe_names )
-  {
-    for ( unsigned int j = 0 ; j < n_exe_names ; ++ j )
-    {
-      insert( exe_name( exe_name_list[ j ] ) ) ;
-    }
-  }
-} ;
-
-//-------------------------------------------------------
-//-------------------------------------------------------
-/**
- * Filter by process name. Comparison is case-insensitive.
- */
-class process_by_any_exe_name_CI

[Eric, 2014/03/27 16:56:51]

Since this filter isn't being used any more, it can be moved into the unit test
code. I wouldn't delete it entirely, because it's useful to have the simpler
code around (with tests) already working in case we might derive something else
from it.

[Wladimir Palant, 2014/03/28 07:34:55]

I strongly prefer to remove any unused code that's around. It isn't useful but
rather a maintenance burden. Should we ever need that code (which is very
uncertain) we know where to find it - in the repository history.

-  : public std::unary_function< PROCESSENTRY32W, bool >
-{
-  const exe_name_set & names ;
+struct file_name_set
+  : public std::set< file_name >
+{
+  file_name_set(){};
+
+  file_name_set( const wchar_t * file_name_list[], size_t n_file_names )
+  {
+    for ( unsigned int j = 0 ; j < n_file_names ; ++ j )
+    {
+      insert( file_name( file_name_list[ j ] ) ) ;
+    }
+  }
+} ;
+
+//-------------------------------------------------------
+//-------------------------------------------------------
+/**
+ * Filter by process name. Comparison is case-insensitive. With ABP module loaded
+ */
+class process_by_any_exe_with_any_module
+  : public std::binary_function< PROCESSENTRY32W, file_name_set, bool >
+{
+  const file_name_set & processNames ;
+  const file_name_set & moduleNames;
 public:
   bool operator()( const PROCESSENTRY32W & ) ;
-  process_by_any_exe_name_CI( const exe_name_set & names )
-    : names( names )
-  {}
-} ;
-
-//-------------------------------------------------------
-//-------------------------------------------------------
-/**
- * Filter by process name. Comparison is case-insensitive. With ABP module loaded
- */
-class process_by_any_exe_name_CI_w_ABP

[Eric, 2014/03/27 16:52:44]

This is not ABP-specific until after we pass it ABP module names. I would have
called it something like process_by_any_exe_with_any_module_CI.

In retrospect, I'd drop the _CI suffix, since process and module names are
case-insensitive strings, and the CI comparison is part of their type.

-  : public std::binary_function< PROCESSENTRY32W, exe_name_set, bool >
-{
-  const exe_name_set & names ;

[Eric, 2014/03/27 16:52:44]

This should be renamed to process_names (or the like) since we have two
different names to distinguish.

-  const exe_name_set & moduleNames;
-public:
-  bool operator()( const PROCESSENTRY32W & ) ;
-  process_by_any_exe_name_CI_w_ABP( const exe_name_set & names, const exe_name_set & moduleNames )
-    : names( names ), moduleNames( moduleNames )
+  process_by_any_exe_with_any_module( const file_name_set & names, const file_name_set & moduleNames )
+    : processNames( names ), moduleNames( moduleNames )
   {}
 } ;
 
 
 //-------------------------------------------------------
 // Process utility functions.
 //-------------------------------------------------------
 /**
  * A promiscuous filter admits everything.
  */
@@ skipping 116 matching lines @@
   Snapshot() ;
 
   /**
    * Reconstruct the current instance with a new system snapshot.
    */
   void refresh() ;
 
   /**
    * Return a pointer to the first process in the snapshot.
    */
-  PROCESSENTRY32W * begin() ;
-
-  /**
-   * The end pointer is an alias for the null pointer.
-   */
-  inline PROCESSENTRY32W * end() const { return 0 ; }
+  PROCESSENTRY32W * first() ;
 
   /**
    * Return a pointer to the next process in the snapshot.
    * begin() must have been called first.
    */
   PROCESSENTRY32W * next() ;
-
-  /**
-   * Type definition for pointer to underlying structure.
-   */
-  typedef PROCESSENTRY32W * Pointer ;
 } ;
 

[Eric, 2014/03/27 16:52:44]

We need some documentation here about CreateToolhelp32Snapshot behaves. We need
a second kind of snapshot because that function will snap "all process for the
system" at once, but only "all modules for a process" and not "all modules for
the system".

 class ModulesSnapshot
 {
   /**
    * Handle to the process snapshot.
    */
-  Windows_Handle handle ;
+  Windows_Handle handle;
 
   /**
    * Buffer for reading a single module entry out of the snapshot.
    */
   MODULEENTRY32W module;
-
-  /**
-   * process ID of the process to retrieve modules for.
-   */
-  DWORD processId;

[Eric, 2014/03/27 16:52:44]

Only needed for refresh(), which we don't need.

 
   /**
    * Copy constructor declared private and not defined.
    *
    * \par Implementation
    *   Add "= delete" for C++11.
    */
-  ModulesSnapshot( const ModulesSnapshot & ) ;
+  ModulesSnapshot(const ModulesSnapshot&);
 
   /**
    * Copy assignment declared private and not defined.
    *
    * \par Implementation
    *   Add "= delete" for C++11.
    */
-  ModulesSnapshot operator=( const ModulesSnapshot & ) ;
+  ModulesSnapshot operator=(const ModulesSnapshot&);
 
 
 public:
   /**
    * Default constructor takes the snapshot.
    */
-  ModulesSnapshot(DWORD processId) ;
-
-  /**
-   * Reconstruct the current instance with a new system snapshot.
-   */
-  void refresh(DWORD processId) ;

[Eric, 2014/03/27 16:52:44]

The way this is being used, I don't believe we need a refresh method. This class
is only being instantiated in the process filter, and that instance is
transient.

+  ModulesSnapshot(DWORD processId);
 
   /**
    * Return a pointer to the first process in the snapshot.
    */
-  MODULEENTRY32W * begin() ;
-
-  /**
-   * The end pointer is an alias for the null pointer.
-   */
-  inline MODULEENTRY32W * end() const { return 0 ; }
+  MODULEENTRY32W* first();
 
   /**
    * Return a pointer to the next process in the snapshot.
    * begin() must have been called first.
    */
-  MODULEENTRY32W * next() ;
-
-  /**
-   * Type definition for pointer to underlying structure.
-   */
-  typedef MODULEENTRY32W * Pointer ;
-} ;
+  MODULEENTRY32W* next();
+};
 
 
 //-------------------------------------------------------
 // initialize_process_list
 //-------------------------------------------------------
 /**
  * \tparam T The type into which a PROCESSENTRY32W struture is extracted.
  * \tparam Admittance Function type for argument 'admit'
  * \tparam Extractor Function type for argument 'extract'
  * \param admit A unary predicate function class that determines what's included
  *      A process appears in the list only if the predicate returns true. 
  *      The use of this predicate is analogous to that in std::copy_if.
  * \param convert A conversion function that takes a PROCESSENTRY32W as input argument and returns an element of type T.
  */
-template< class T, class Admittance, class Extractor >
-void initialize_process_list( std::vector< T > & v, Snapshot & snap, Admittance admit = Admittance(), Extractor extract = Extractor() )
-{
-  Snapshot::Pointer p = snap.begin() ;
-  while ( p != snap.end() )
-  {
-    if ( admit( * p ) )
+template<class T, class Admittance, class Extractor>
+void initialize_process_list(std::vector<T>& v, Snapshot& snap, Admittance admit = Admittance(), Extractor extract = Extractor())
+{
+  PROCESSENTRY32W* p = snap.first();
+  while (p != NULL)
+  {
+    if (admit(*p ))
     {
       /*
         * We don't have C++11 emplace_back, which can construct the element in place.
         * Instead, we copy the return value of the converter.
         */
-      v.push_back( extract( * p ) );
-    }
-    p = snap.next() ;
-  }
-} ;
+      v.push_back(extract(*p));
+    }
+    p = snap.next();
+  }
+};
 
 //-------------------------------------------------------
 // initialize_process_set
 //-------------------------------------------------------
 /**
  * \tparam T The type into which a PROCESSENTRY32W struture is extracted.
  * \tparam Admittance Function type for argument 'admit'
  * \tparam Extractor Function type for argument 'extract'
  * \param admit A unary predicate function class that determines what's included
  *      A process appears in the list only if the predicate returns true. 
  *      The use of this predicate is analogous to that in std::copy_if.
  * \param convert A conversion function that takes a PROCESSENTRY32W as input argument and returns an element of type T.
  */
-template< class T, class Admittance, class Extractor >
-void initialize_process_set( std::set< T > & set, Snapshot & snap, Admittance admit = Admittance(), Extractor extract = Extractor() )
-{
-  Snapshot::Pointer p = snap.begin() ;
-  while ( p != snap.end() )
-  {
-    if ( admit( * p ) )
-    {
-      set.insert( extract( * p ) );
-    }
-    p = snap.next() ;
-  }
-} ;
+template<class T, class Admittance, class Extractor>
+void initialize_process_set(std::set< T > & set, Snapshot& snap, Admittance admit = Admittance(), Extractor extract = Extractor())
+{
+  PROCESSENTRY32W* p = snap.first();
+  while (p != NULL)
+  {
+    if (admit(*p))
+    {
+      set.insert(extract(*p));
+    }
+    p = snap.next();
+  }
+};
 
 //-------------------------------------------------------
 // enumerate_windows
 //-------------------------------------------------------
 
 /**
  * States of a window enumeration.
  */
 typedef enum
 {
@@ skipping 107 matching lines @@
    * Set of process identifiers matching one of the executable names.
    */
   std::set< DWORD > pid_set ;
 
   /**
    * Set of executable names by which to filter.
    *
    * The argument of the filter constructor is a set by reference.
    * Since it does not make a copy for itself, we define it as a class member to provide its allocation.
    */
-  exe_name_set exe_names ;
-  exe_name_set module_names ;

[Eric, 2014/03/27 16:52:44]

I'd use dll_names. We configure these with .EXE and .DLL file names. The Windows
terms are process and module. I used the file names in this class as a
slightly-easier documentation for the user about what to expect.

Also, we should likely rename 'exe_name_set', since it's now holding more that
.EXE names. Probably 'file_name_set'

[Oleksandr, 2014/03/27 23:28:46]

I actually think module_names is more consistent, since it's called modules in
Windows functions.

On 2014/03/27 16:52:44, Eric wrote:

-
-  /**
-   * Filter function object matches on any of the exe names specified in the constructor.
-   */
-//  process_by_any_exe_name_CI filter ;
-
-  process_by_any_exe_name_CI_w_ABP filter ;
+  file_name_set file_names ;
+  /**
+   * Set of module (DLL) names by which to filter.
+   */
+  file_name_set module_names ;
+
+  process_by_any_exe_with_any_module filter ;
 
   /**
    * Copy function object copies just the process ID.
    */
   copy_PID copy ;
 
   /** 
    * Snapshot of running processes.
    */
   Snapshot & snapshot ;
@@ skipping 30 matching lines @@
       if ( ! b )
       {
         // Assert the process that created the window is not in our pid_set
         return true ;
       }
       return f( window ) ;
     }
   } ;
 
 public:
-  Process_Closer( Snapshot & snapshot, const wchar_t * exe_name_list[], size_t n_exe_names, const wchar_t * module_name_list[], size_t n_module_names )

[Eric, 2014/03/27 16:52:44]

Likewise dll_name_list etc. here.

-    : snapshot( snapshot ), exe_names( exe_name_list, n_exe_names ), module_names(module_name_list, n_module_names), filter( exe_names, module_names )
+  template <size_t n_file_names, size_t n_module_names>
+  Process_Closer(Snapshot & snapshot, const wchar_t* (&file_name_list)[n_file_names], const wchar_t* (&module_name_list)[n_module_names])
+    : snapshot(snapshot), file_names(file_name_list, n_file_names), module_names(module_name_list, n_module_names), filter(file_names, module_names)
+  {
+    update() ;
+  }
+  template <size_t n_file_names>
+  Process_Closer(Snapshot & snapshot, const wchar_t * (&file_name_list)[n_file_names])
+    : snapshot(snapshot), file_names(file_name_list, n_file_names), module_names(), filter(file_names, module_names)
   {
     update() ;
   }
 
   /**
    * Refresh our state to match the snapshot state.
    */
   void refresh()
   {
     pid_set.clear() ;
@@ skipping 12 matching lines @@
   }
 
   /*
    * Shut down every process in the pid_set.
    */
   bool shut_down() ;
 
 } ;
 
 #endif