win32-process 0.7.5 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7abeeac7e3b746666569ab363e702c8939a4a596
-  data.tar.gz: 693447613255756de95668ddfefa702ecc5b9921
+  metadata.gz: 47640c7bc0c96cd8615348e2f8757c0e1aecec95
+  data.tar.gz: 3f391446c320d0bd0feac23f0effff0bc945ae65
 SHA512:
-  metadata.gz: 2a7faa782828c7a8cbbf54f997ded9a3c97023b641417207e03938378520f0072b29e7fc1d11c26307e59c94ff975cdfdfebdbe9cbc0adedf2abe57a1251ecee
-  data.tar.gz: 9a1ba82a14f16365850fbc7e50787c3233fedd3d54307757202dd60d05a9f4057cc4e617d3ad7d97783861c4098ee82c6bfdb56a8d4210d6404aca1a0682e613
+  metadata.gz: 63c279644c090065293a308b6b1e68b43c67b7d25c53e0019e82dfc2d1022a6a800ab152b4675188e10077037f82b7cb9f4ecdaae0982c3aee8ba7e81dd6a697
+  data.tar.gz: f5b8a0d72aaa046fdd0a749720f7f5ae61ad99a2b157a3339c8f72cfb35685aa6916522626d036d447f7fc5bf2068cfdf8cd74531e222f6619915dc9fba9a697

data/CHANGES

@@ -1,3 +1,7 @@
+= 0.8.0 - 29-Apr-2015
+* Added the Process.snapshot method that lets you gather information for
+  the heap, threads, modules, and processes.
+
 = 0.7.5 - 3-Mar-2015
 * Use require_relative where possible.
 * Fixed a bug in Process.setrlimit. Note that this method has been marked

data/lib/win32/process.rb

@@ -10,7 +10,7 @@ module Process
   extend Process::Constants
 
   # The version of the win32-process library.
-  WIN32_PROCESS_VERSION = '0.7.5'
+  WIN32_PROCESS_VERSION = '0.8.0'
 
   # Disable popups. This mostly affects the Process.kill method.
   SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX)
@@ -914,6 +914,75 @@ module Process
         exitcode
       end
     end
+
+    # Returns a list of process information structs in the form of a hash,
+    # with the pid as the key, and an array of information as the value of
+    # that key. The type of information in that array depends on the
+    # +info_type+ parameter. The possible values for +info_type+, and the
+    # type of information they each return is as follows:
+    #
+    #   :thread  => ThreadSnapInfo[:thread_id, :process_id, :base_priority]
+    #   :heap    => HeapSnapInfo[:address, :block_size, :flags, :process_id, :heap_id]
+    #   :module  => ModuleSnapInfo[:process_id, :address, :module_size, :handle, :name, :path]
+    #   :process => ProcessSnapInfo[:process_id, :threads, :parent_process_id, :priority, :flags, :path]
+    #
+    # If no argument is provided, then :thread is assumed. Note that it is up
+    # to you to filter by pid if you wish.
+    #
+    # Example:
+    #
+    #   # Get all thread info
+    #   Process.snapshot.each{ |pid, v|
+    #     puts "PID: #{pid}"
+    #     p v
+    #   }
+    #
+    #   # Get module info for just the current process
+    #   p Process.snapshot(:module)[Process.pid]
+    #
+    #   # Get heap info for just the current process
+    #   p Process.snapshot(:heap)[Process.pid]
+    #
+    #   # Show pids of all running processes
+    #   p Process.snapshot(:process).keys
+    #
+    def snapshot(info_type = 'thread')
+      case info_type.to_s.downcase
+        when 'thread'
+          flag = TH32CS_SNAPTHREAD
+        when 'heap'
+          flag = TH32CS_SNAPHEAPLIST
+        when 'module'
+          flag = TH32CS_SNAPMODULE
+        when 'process'
+          flag = TH32CS_SNAPPROCESS
+        else
+          raise ArgumentError, "info_type '#{info_type}' unsupported"
+      end
+
+      begin
+        handle = CreateToolhelp32Snapshot(flag, Process.pid)
+
+        if handle == INVALID_HANDLE_VALUE
+          raise SystemCallError.new('CreateToolhelp32Snapshot', FFI.errno)
+        end
+
+        case info_type.to_s.downcase
+          when 'thread'
+            array = get_thread_info(handle)
+          when 'heap'
+            array = get_heap_info(handle)
+          when 'module'
+            array = get_module_info(handle)
+          when 'process'
+            array = get_process_info(handle)
+        end
+
+        array
+      ensure
+        CloseHandle(handle) if handle
+      end
+    end
   end
 
   class << self
@@ -926,6 +995,137 @@ module Process
       bool ? buf.read_string : nil
     end
 
+    # Return thread info for Process.snapshot
+    def get_thread_info(handle, pid = nil)
+      lpte = THREADENTRY32.new
+      lpte[:dwSize] = lpte.size
+
+      hash = Hash.new{ |h,k| h[k] = [] }
+
+      if Thread32First(handle, lpte)
+        hash[lpte[:th32OwnerProcessID]] << ThreadSnapInfo.new(lpte[:th32ThreadID], lpte[:th32OwnerProcessID], lpte[:tpBasePri])
+      else
+        if FFI.errno == ERROR_NO_MORE_FILES
+          return hash
+        else
+          raise SystemCallError.new('Thread32First', FFI.errno)
+        end
+      end
+
+      while Thread32Next(handle, lpte)
+        hash[lpte[:th32OwnerProcessID]] << ThreadSnapInfo.new(lpte[:th32ThreadID], lpte[:th32OwnerProcessID], lpte[:tpBasePri])
+      end
+
+      hash
+    end
+
+    # Return heap info for Process.snapshot
+    def get_heap_info(handle)
+      hash = Hash.new{ |h,k| h[k] = [] }
+
+      hl = HEAPLIST32.new
+      hl[:dwSize] = hl.size
+
+      if Heap32ListFirst(handle, hl)
+        while Heap32ListNext(handle, hl)
+          he = HEAPENTRY32.new
+          he[:dwSize] = he.size
+
+          if Heap32First(he, Process.pid, hl[:th32HeapID])
+            hash[he[:th32ProcessID]] << HeapSnapInfo.new(he[:dwAddress], he[:dwBlockSize], he[:dwFlags], he[:th32ProcessID], he[:th32HeapID])
+          else
+            if FFI.errno == ERROR_NO_MORE_FILES
+              break
+            else
+              raise SystemCallError.new('Heap32First', FFI.errno)
+            end
+          end
+
+          while Heap32Next(he)
+            hash[he[:th32ProcessID]] << HeapSnapInfo.new(he[:dwAddress], he[:dwBlockSize], he[:dwFlags], he[:th32ProcessID], he[:th32HeapID])
+          end
+        end
+      end
+
+      hash
+    end
+
+    # Return module info for Process.snapshot
+    def get_module_info(handle)
+      hash = Hash.new{ |h,k| h[k] = [] }
+
+      me = MODULEENTRY32.new
+      me[:dwSize] = me.size
+
+      if Module32First(handle, me)
+        hash[me[:th32ProcessID]] << ModuleSnapInfo.new(
+          me[:th32ProcessID],
+          me[:modBaseAddr].to_i,
+          me[:modBaseSize],
+          me[:hModule],
+          me[:szModule].to_s,
+          me[:szExePath].to_s
+        )
+      else
+        if FFI.errno == ERROR_NO_MORE_FILES
+          return hash
+        else
+          raise SystemCallError.new('Module32First', FFI.errno)
+        end
+      end
+
+      while Module32Next(handle, me)
+        hash[me[:th32ProcessID]] << ModuleSnapInfo.new(
+          me[:th32ProcessID],
+          me[:modBaseAddr].to_i,
+          me[:modBaseSize],
+          me[:hModule],
+          me[:szModule].to_s,
+          me[:szExePath].to_s
+        )
+      end
+
+      hash
+    end
+
+    # Return process info for Process.snapshot
+    def get_process_info(handle)
+      hash = Hash.new{ |h,k| h[k] = [] }
+
+      pe = PROCESSENTRY32.new
+      pe[:dwSize] = pe.size
+
+      if Process32First(handle, pe)
+        hash[pe[:th32ProcessID]] = ProcessSnapInfo.new(
+          pe[:th32ProcessID],
+          pe[:cntThreads],
+          pe[:th32ParentProcessID],
+          pe[:pcPriClassBase],
+          pe[:dwFlags],
+          pe[:szExeFile].to_s
+        )
+      else
+        if FFI.errno == ERROR_NO_MORE_FILES
+          return hash
+        else
+          raise SystemCallError.new('Process32First', FFI.errno)
+        end
+      end
+
+      while Process32Next(handle, pe)
+        hash[pe[:th32ProcessID]] = ProcessSnapInfo.new(
+          pe[:th32ProcessID],
+          pe[:cntThreads],
+          pe[:th32ParentProcessID],
+          pe[:pcPriClassBase],
+          pe[:dwFlags],
+          pe[:szExeFile].to_s
+        )
+      end
+
+      hash      
+    end
+
     # Private method that returns the Windows major version number.
     def windows_version
       ver = OSVERSIONINFO.new
@@ -938,4 +1138,4 @@ module Process
       ver[:dwMajorVersion]
     end
   end
-end
+end

data/lib/win32/process/constants.rb

@@ -110,4 +110,12 @@ module Process::Constants
   # GetExitCodeProcess
 
   STILL_ACTIVE = 259
+
+  # Snapshot constants
+
+  TH32CS_SNAPHEAPLIST = 0x00000001
+  TH32CS_SNAPPROCESS  = 0x00000002
+  TH32CS_SNAPTHREAD   = 0x00000004
+  TH32CS_SNAPMODULE   = 0x00000008
+  ERROR_NO_MORE_FILES = 0x00000018
 end

data/lib/win32/process/functions.rb

@@ -24,6 +24,7 @@ module Process::Functions
   ffi_lib :kernel32
 
   attach_pfunc :CloseHandle, [:handle], :bool
+  attach_pfunc :CreateToolhelp32Snapshot, [:dword, :dword], :handle
   attach_pfunc :GenerateConsoleCtrlEvent, [:dword, :dword], :bool
   attach_pfunc :GetCurrentProcess, [], :handle
   attach_pfunc :GetModuleHandle, :GetModuleHandleA, [:string], :hmodule
@@ -31,12 +32,22 @@ module Process::Functions
   attach_pfunc :GetPriorityClass, [:handle], :dword
   attach_pfunc :GetProcAddress, [:hmodule, :string], :pointer
   attach_pfunc :GetVersionExA, [:pointer], :bool
+  attach_pfunc :Heap32ListFirst, [:handle, :pointer], :bool
+  attach_pfunc :Heap32ListNext, [:handle, :pointer], :bool
+  attach_pfunc :Heap32First, [:pointer, :dword, :uintptr_t], :bool
+  attach_pfunc :Heap32Next, [:pointer], :bool
+  attach_pfunc :Module32First, [:handle, :pointer], :bool
+  attach_pfunc :Module32Next, [:handle, :pointer], :bool
   attach_pfunc :IsProcessInJob, [:handle, :pointer, :pointer], :bool # 2nd arg optional
   attach_pfunc :OpenProcess, [:dword, :bool, :dword], :handle
+  attach_pfunc :Process32First, [:handle, :pointer], :bool
+  attach_pfunc :Process32Next, [:handle, :pointer], :bool
   attach_pfunc :SetHandleInformation, [:handle, :dword, :dword], :bool
   attach_pfunc :SetErrorMode, [:uint], :uint
   attach_pfunc :SetPriorityClass, [:handle, :dword], :bool
   attach_pfunc :TerminateProcess, [:handle, :uint], :bool
+  attach_pfunc :Thread32First, [:handle, :pointer], :bool
+  attach_pfunc :Thread32Next, [:handle, :pointer], :bool
   attach_pfunc :WaitForSingleObject, [:handle, :dword], :dword
 
   attach_pfunc :CreateRemoteThread,

data/lib/win32/process/helper.rb

@@ -10,4 +10,4 @@ class String
   def to_wide_string!
     replace((self + 0.chr).encode('UTF-16LE'))
   end
-end
+end

data/lib/win32/process/structs.rb

@@ -108,11 +108,111 @@ module Process::Structs
     )
   end
 
+  class THREADENTRY32 < FFI::Struct
+    layout(
+      :dwSize, :dword,
+      :cntUsage, :dword,
+      :th32ThreadID, :dword,
+      :th32OwnerProcessID, :dword,
+      :tpBasePri, :long,
+      :tpDeltaPri, :long,
+      :dwFlags, :dword
+    )
+  end
+
+  class HEAPLIST32 < FFI::Struct
+    layout(
+      :dwSize, :size_t,
+      :th32ProcessID, :dword,
+      :th32HeapID, :uintptr_t,
+      :dwFlags, :dword
+    )
+  end
+
+  class HEAPENTRY32 < FFI::Struct
+    layout(
+      :dwSize, :size_t,
+      :hHandle, :handle,
+      :dwAddress, :uintptr_t,
+      :dwBlockSize, :size_t,
+      :dwFlags, :dword,
+      :dwLockCount, :dword,
+      :dwResvd, :dword,
+      :th32ProcessID, :dword,
+      :th32HeapID, :uintptr_t
+    )
+  end
+
+  class MODULEENTRY32 < FFI::Struct
+    layout(
+      :dwSize, :dword,
+      :th32ModuleID, :dword,
+      :th32ProcessID, :dword,
+      :GlblcntUsage, :dword,
+      :ProccntUsage, :dword,
+      :modBaseAddr, :pointer,
+      :modBaseSize, :dword,
+      :hModule, :handle,
+      :szModule, [:char, 256],
+      :szExePath, [:char, 260]
+    )
+  end
+
+  class PROCESSENTRY32 < FFI::Struct
+    layout(
+      :dwSize, :dword,
+      :cntUsage, :dword,
+      :th32ProcessID, :dword,
+      :th32DefaultHeapID, :uintptr_t,
+      :th32ModuleID, :dword,
+      :cntThreads, :dword,
+      :th32ParentProcessID, :dword,
+      :pcPriClassBase, :long,
+      :dwFlags, :dword,
+      :szExeFile, [:char, 260]
+    )
+  end
+
   # Used by Process.create
+
   ProcessInfo = Struct.new("ProcessInfo",
     :process_handle,
     :thread_handle,
     :process_id,
     :thread_id
   )
+
+  # Used by Process.snapshot
+
+  ThreadSnapInfo = Struct.new("ThreadSnapInfo",
+    :thread_id,
+    :process_id,
+    :base_priority
+  )
+
+  HeapSnapInfo = Struct.new("HeapSnapInfo",
+    :address,
+    :block_size,
+    :flags,
+    :process_id,
+    :heap_id
+  )
+
+  ModuleSnapInfo = Struct.new("ModuleSnapInfo",
+    :process_id,
+    :address,
+    :module_size,
+    :handle,
+    :name,
+    :path
+  )
+
+  ProcessSnapInfo = Struct.new("ProcessSnapInfo",
+    :process_id,
+    :threads,
+    :parent_process_id,
+    :priority,
+    :flags,
+    :path
+  )
 end

data/test/test_win32_process.rb

@@ -25,7 +25,7 @@ class TC_Win32Process < Test::Unit::TestCase
   end
 
   test "win32-process version is set to the correct value" do
-    assert_equal('0.7.5', Process::WIN32_PROCESS_VERSION)
+    assert_equal('0.8.0', Process::WIN32_PROCESS_VERSION)
   end
 
   test "create basic functionality" do
@@ -298,6 +298,23 @@ class TC_Win32Process < Test::Unit::TestCase
     assert_not_respond_to(Process, :volume_type)
   end
 
+  test "snapshot method basic functionality" do
+    assert_respond_to(Process, :snapshot)
+    assert_nothing_raised{ Process.snapshot }
+    assert_kind_of(Hash, Process.snapshot)
+  end
+
+  test "snapshot accepts :thread, :module or :heap arguments" do
+    assert_nothing_raised{ Process.snapshot(:thread) }
+    assert_nothing_raised{ Process.snapshot(:module) }
+    assert_nothing_raised{ Process.snapshot(:heap) }
+    assert_nothing_raised{ Process.snapshot(:process) }
+  end
+
+  test "snapshot raises an error if an invalid argument is passed" do
+    assert_raise(ArgumentError){ Process.snapshot(:bogus) }
+  end
+
   test "ffi functions are private" do
     assert_not_respond_to(Process, :CloseHandle)
     assert_not_respond_to(Process, :GetCurrentProcess)

data/win32-process.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'win32-process'
-  spec.version    = '0.7.5'
+  spec.version    = '0.8.0'
   spec.license    = 'Artistic 2.0'
   spec.authors    = ['Daniel Berger', 'Park Heesob']
   spec.email      = 'djberg96@gmail.com'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: win32-process
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.8.0
 platform: ruby
 authors:
 - Daniel Berger
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-03 00:00:00.000000000 Z
+date: 2015-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi