windows-pr 0.5.3 → 0.5.4

data/CHANGES

@@ -1,3 +1,13 @@
+= 0.5.4 - 8-Sep-2006
+* Added the Windows::NetworkManagement module, which contains methods like
+  NetUserAdd(), etc.
+* Fixed bugs in SetLastError and SetLastErrorEx declarations.
+* Finer grained method wrapping/checking for the Windows::Library module.
+* Finer grained method wrapping/checking for the Windows::Console module.
+* Added a test case for the Windows::Library module.
+* Added the LOCKFILE_EXCLUSIVE_LOCK and LOCKFILE_FAIL_IMMEDIATELY constants
+  to the Windows::File module.
+  
 = 0.5.3 - 10-Aug-2006
 * Added wide character functions to the EventLog module.
 * Added a test suite for the EventLog module.

data/README

@@ -33,17 +33,17 @@
    then the wrapper method is lower case as well.  For example, instead of
    doing 'Memcpy.call(dest, src, size)' you can do 'memcpy(dest, src, size)'.
    
-   Remember boys and girls, if you write PathIsRoot, you're referring to
-   the constant.  If you write PathIsRoot(), you're calling the wrapper
+   Remember boys and girls, if you write 'PathIsRoot', you're referring to
+   the constant.  If you write 'PathIsRoot()', you're calling the wrapper
    method.
    
    Boolean methods automatically perform a check for success or failure.  So,
    instead of having to do something like 'if PathIsRoot(path) > 0' you can
    just do 'if PathIsRoot(path)'.
    
-   Files contain related functions, by topic.  For example, the clipboard.rb
-   file contains clipboard related functions, such as CloseClipboard(), as
-   well as constants such as CF_TEXT, CF_BITMAP, etc.
+   Source files contain related functions, by topic.  For example, the
+   clipboard.rb file contains clipboard related functions, such as
+   CloseClipboard(), as well as constants such as CF_TEXT, CF_BITMAP, etc.
    
 == Wide character functions
 	I decided that the $KCODE handling was a bad idea, so most of the $KCODE
@@ -55,6 +55,18 @@
 	In the future I'll add the wide character functions explicitly.  I haven't
 	added many yet (as of 29-Jul-2006) but I plan on adding as many as I can
 	as time permits.
+	
+== Platform specific functions
+   Not all functions are defined on all platforms.  For example, the
+   AttachConsole() function is only defined on Windows XP and later.  If you
+   need to conditionally test for its existance, simply use the 'defined?'
+   method:
+   
+   if defined? AttachConsole
+      # Do something
+   else
+      # Do something else
+   end
    
 == Where are the tests, dude?
    While I've made some effort to test these functions, there are simply too
@@ -93,7 +105,9 @@
    http://www.rubyforge.org/projects/win32utils.
    
    The only real bugs you could find are either bad prototype declarations
-   or bad constant values.  But, please report either.
+   or bad constant values.  Sometimes I forget to wrap functions properly
+   that may not be defined on older Windows platforms.  But, please report
+   any of these issues on the project page should you stumble into them.
    
 == Known Issues
    In some cases the MSDN docs are wrong, and we have to learn it the hard

data/doc/conversion_guide.txt

@@ -8,7 +8,7 @@ Void:    'V'
 BOOL  		=> 'I'
 DWORD 		=> 'L'
 HANDLE		=> 'L'
-LPDWORD		=> 'P'
+LPDWORD		=> 'P' (or 'L')
 LPTSTR 		=> 'P'
 UINT  		=> 'I'
 VOID        => 'V'

data/install.rb

@@ -0,0 +1,18 @@
+require "ftools"
+require "rbconfig"
+include Config
+
+sitelibdir  = CONFIG["sitelibdir"]
+installdir  = sitelibdir + "/windows"
+installdir2 = sitelibdir + "/windows/msvcrt"
+
+Dir.mkdir(installdir) unless File.exists?(installdir)
+Dir.mkdir(installdir2) unless File.exists?(installdir2)
+
+Dir["lib/windows/*.rb"].each{ |file|
+   File.copy(file, installdir, true)
+}
+
+Dir["lib/windows/msvcrt/*.rb"].each{ |file|
+   File.copy(file, installdir2, true)
+}

data/lib/windows/console.rb

@@ -43,8 +43,7 @@ module Windows
       CONSOLE_FULLSCREEN_HARDWARE = 2
       
       AddConsoleAlias                = Win32API.new('kernel32', 'AddConsoleAlias', 'PPP', 'I')
-      AllocConsole                   = Win32API.new('kernel32', 'AllocConsole', 'V', 'I')
-      AttachConsole                  = Win32API.new('kernel32', 'AttachConsole', 'L', 'I')
+      AllocConsole                   = Win32API.new('kernel32', 'AllocConsole', 'V', 'I')     
       CreateConsoleScreenBuffer      = Win32API.new('kernel32', 'CreateConsoleScreenBuffer', 'LLPLP', 'L')
       FillConsoleOutputAttribute     = Win32API.new('kernel32', 'FillConsoleOutputAttribute', 'LILLP', 'I')
       FillConsoleOutputCharacter     = Win32API.new('kernel32', 'FillConsoleOutputCharacter', 'LILLP', 'I')
@@ -57,17 +56,11 @@ module Windows
       GetConsoleAliasExes            = Win32API.new('kernel32', 'GetConsoleAliasExes', 'PL', 'L')
       GetConsoleAliasExesLength      = Win32API.new('kernel32', 'GetConsoleAliasExesLength', 'V', 'L')
       GetConsoleCP                   = Win32API.new('kernel32', 'GetConsoleCP', 'V', 'I')
-      GetConsoleCursorInfo           = Win32API.new('kernel32', 'GetConsoleCursorInfo', 'LP', 'I')
-      GetConsoleDisplayMode          = Win32API.new('kernel32', 'GetConsoleDisplayMode', 'P', 'L')
-      GetConsoleFontSize             = Win32API.new('kernel32', 'GetConsoleFontSize', 'LL', 'L')
+      GetConsoleCursorInfo           = Win32API.new('kernel32', 'GetConsoleCursorInfo', 'LP', 'I')     
       GetConsoleMode                 = Win32API.new('kernel32', 'GetConsoleMode', 'LP', 'I')
-      GetConsoleOutputCP             = Win32API.new('kernel32', 'GetConsoleOutputCP', 'V', 'I')
-      GetConsoleProcessList          = Win32API.new('kernel32', 'GetConsoleProcessList', 'PL', 'L')
-      GetConsoleScreenBufferInfo     = Win32API.new('kernel32', 'GetConsoleScreenBufferInfo', 'LP', 'I')
-      GetConsoleSelectionInfo        = Win32API.new('kernel32', 'GetConsoleSelectionInfo', 'P', 'I')
-      GetConsoleTitle                = Win32API.new('kernel32', 'GetConsoleTitle', 'PL', 'L')
-      GetConsoleWindow               = Win32API.new('kernel32', 'GetConsoleWindow', 'V', 'L')
-      GetCurrentConsoleFont          = Win32API.new('kernel32', 'GetCurrentConsoleFont' , 'LIP', 'I')
+      GetConsoleOutputCP             = Win32API.new('kernel32', 'GetConsoleOutputCP', 'V', 'I')    
+      GetConsoleScreenBufferInfo     = Win32API.new('kernel32', 'GetConsoleScreenBufferInfo', 'LP', 'I')     
+      GetConsoleTitle                = Win32API.new('kernel32', 'GetConsoleTitle', 'PL', 'L')     
       GetLargestConsoleWindowSize    = Win32API.new('kernel32', 'GetLargestConsoleWindowSize', 'L', 'L')
       GetNumberOfConsoleInputEvents  = Win32API.new('kernel32', 'GetNumberOfConsoleInputEvents', 'LP', 'I')
       GetNumberOfConsoleMouseButtons = Win32API.new('kernel32', 'GetNumberOfConsoleMouseButtons', 'L', 'I')
@@ -84,8 +77,7 @@ module Windows
       SetConsoleCP                   = Win32API.new('kernel32', 'SetConsoleCP', 'L', 'I')
       SetConsoleCtrlHandler          = Win32API.new('kernel32', 'SetConsoleCtrlHandler', 'PI', 'I')
       SetConsoleCursorInfo           = Win32API.new('kernel32', 'SetConsoleCursorInfo', 'LP', 'I')
-      SetConsoleCursorPosition       = Win32API.new('kernel32', 'SetConsoleCursorPosition', 'LP', 'I')
-      SetConsoleDisplayMode          = Win32API.new('kernel32', 'SetConsoleDisplayMode', 'LLP', 'I')
+      SetConsoleCursorPosition       = Win32API.new('kernel32', 'SetConsoleCursorPosition', 'LP', 'I')      
       SetConsoleMode                 = Win32API.new('kernel32', 'SetConsoleMode', 'LL', 'I')
       SetConsoleOutputCP             = Win32API.new('kernel32', 'SetConsoleOutputCP', 'I', 'I')
       SetConsoleScreenBufferSize     = Win32API.new('kernel32', 'SetConsoleScreenBufferSize', 'LL', 'I')
@@ -98,6 +90,28 @@ module Windows
       WriteConsoleOutput             = Win32API.new('kernel32', 'WriteConsoleOutput', 'LPLLP', 'I')
       WriteConsoleOutputAttribute    = Win32API.new('kernel32', 'WriteConsoleOutputAttribute', 'LPLLP', 'I')
       WriteConsoleOutputCharacter    = Win32API.new('kernel32', 'WriteConsoleOutputCharacter', 'LPLLP', 'I')
+      
+      # Windows XP or later
+      begin
+         AttachConsole           = Win32API.new('kernel32', 'AttachConsole', 'L', 'I')
+         GetConsoleDisplayMode   = Win32API.new('kernel32', 'GetConsoleDisplayMode', 'P', 'L')
+         GetConsoleFontSize      = Win32API.new('kernel32', 'GetConsoleFontSize', 'LL', 'L')
+         GetConsoleProcessList   = Win32API.new('kernel32', 'GetConsoleProcessList', 'PL', 'L')
+         GetConsoleSelectionInfo = Win32API.new('kernel32', 'GetConsoleSelectionInfo', 'P', 'I')
+         GetCurrentConsoleFont   = Win32API.new('kernel32', 'GetCurrentConsoleFont' , 'LIP', 'I')
+         SetConsoleDisplayMode   = Win32API.new('kernel32', 'SetConsoleDisplayMode', 'LLP', 'I')
+      rescue Exception
+         # Do nothing - not supported on current platform.  It's up to you to
+         # check for the existence of the constant in your code.
+      end
+      
+      # Windows 2000 or later
+      begin
+         GetConsoleWindow = Win32API.new('kernel32', 'GetConsoleWindow', 'V', 'L')
+      rescue Exception
+         # Do nothing - not supported on current platform.  It's up to you to
+         # check for the existence of the constant in your code.
+      end
 
       def AddConsoleAlias(source, target, exe)
          AddConsoleAlias.call(source, target, exe) != 0
@@ -107,10 +121,6 @@ module Windows
          AllocConsole.call != 0
       end
 
-      def AttachConsole(pid)
-         AttachConsole.call(pid)
-      end
-
       def CreateConsoleScreenBuffer(access, mode, sec, flags, data)
          CreateConsoleScreenBuffer.call(access, mode, sec, flags, data)
       end
@@ -155,15 +165,6 @@ module Windows
          GetConsoleCursorInfo.call(handle, cursor_info_ptr)
       end
 
-      # The docs say this returns a BOOL, but really it's a DWORD
-      def GetConsoleDisplayMode(flags)
-         GetConsoleDisplayMode.call(flags)
-      end
-
-      def GetConsoleFontSize(handle, font)
-         GetConsoleFontSize.call(handle, font)
-      end
-
       def GetConsoleMode(handle, mode)
          GetConsoleMode.call(handle, mode) != 0
       end
@@ -172,30 +173,14 @@ module Windows
          GetConsoleOutputCP.call
       end
 
-      def GetConsoleProcessList(proc_list, proc_count)
-         GetConsoleProcessList.call(proc_list, proc_count)
-      end
-
       def GetConsoleScreenBufferInfo(handle, buf_info)
          GetConsoleScreenBufferInfo.call(handle, buf_info) != 0
       end
 
-      def GetConsoleSelectionInfo(info_struct)
-         GetConsoleSelectionInfo.call(info_struct) != 0
-      end
-
       def GetConsoleTitle(title, size)
          GetConsoleTitle.call(title, size)
       end
 
-      def GetConsoleWindow()
-         GetConsoleWindow.call
-      end
-
-      def GetCurrentConsoleFont(handle, max_window, current_font_struct)
-         GetCurrentConsoleFont.call(handle, max_window, current_font_struct)
-      end
-
       def GetLargestConsoleWindowSize(handle)
          GetLargestConsoleWindowSize.call(handle)
       end
@@ -264,10 +249,6 @@ module Windows
          SetConsoleCursorPosition.call(handle, coord) != 0
       end
 
-      def SetConsoleDisplayMode(handle, flags, coord)
-         SetConsoleDisplayMode.call(handle, flags, coord) != 0
-      end
-
       def SetConsoleHistoryInfo(info)
          SetConsoleHistoryInfo.call(info) != 0
       end
@@ -319,5 +300,46 @@ module Windows
       def WriteConsoleOutputCharacter(handle, char, length, coord, num)
          WriteConsoleOutputCharacter.call(handle, char, length, coord, num) != 0
       end
+      
+      begin
+         def AttachConsole(pid)
+            AttachConsole.call(pid)
+         end
+         
+         # The docs say this returns a BOOL, but really it's a DWORD
+         def GetConsoleDisplayMode(flags)
+            GetConsoleDisplayMode.call(flags)
+         end
+         
+         def GetConsoleFontSize(handle, font)
+            GetConsoleFontSize.call(handle, font)
+         end
+       
+         def GetConsoleProcessList(proc_list, proc_count)
+            GetConsoleProcessList.call(proc_list, proc_count)
+         end
+         
+         def GetConsoleSelectionInfo(info_struct)
+            GetConsoleSelectionInfo.call(info_struct) != 0
+         end
+         
+         def GetCurrentConsoleFont(handle, max_window, current_font_struct)
+            GetCurrentConsoleFont.call(handle, max_window, current_font_struct)
+         end
+         
+         def SetConsoleDisplayMode(handle, flags, coord)
+            SetConsoleDisplayMode.call(handle, flags, coord) != 0
+         end
+      rescue Exception
+         # Windows XP or later
+      end
+      
+      begin
+         def GetConsoleWindow()
+            GetConsoleWindow.call
+         end
+      rescue Exception
+         # Windows 2000 or later
+      end
    end
 end

data/lib/windows/error.rb

@@ -270,12 +270,16 @@ module Windows
       ERROR_NO_UNICODE_TRANSLATION = 4371 
          
       GetLastError   = Win32API.new('kernel32', 'GetLastError', 'V', 'L')
-      SetLastError   = Win32API.new('kernel32', 'GetLastError', 'L', 'V')
-      SetLastErrorEx = Win32API.new('kernel32', 'GetLastError', 'LL', 'V')
+      SetLastError   = Win32API.new('kernel32', 'SetLastError', 'L', 'V')
       SetErrorMode   = Win32API.new('kernel32', 'SetErrorMode', 'I', 'I')
       FormatMessage  = Win32API.new('kernel32', 'FormatMessage', 'LLLLPLP', 'L')
       FormatMessageW = Win32API.new('kernel32', 'FormatMessageW', 'LLLLPLP', 'L')
       
+      begin
+         SetLastErrorEx = Win32API.new('kernel32', 'SetLastErrorEx', 'LL', 'V')
+      rescue Exception
+      end
+      
       def GetLastError
          GetLastError.call
       end
@@ -284,10 +288,6 @@ module Windows
          SetLastError.call(error)
       end
       
-      def SetLastErrorEx(error, type=0)
-         SetLastErrorEx.call(error, type)
-      end
-      
       def SetErrorMode(mode)
          SetErrorMode.call(mode)
       end
@@ -300,14 +300,22 @@ module Windows
          FormatMessageW.call(flags, src, msg_id, lang_id, buf, size, args)
       end
       
+      begin
+         def SetLastErrorEx(error, type=0)
+            SetLastErrorEx.call(error, type)
+         end
+      rescue Exception
+         # VC++ 7.0 or later
+      end
+      
       # Convenience method that wraps FormatMessage with some sane defaults and
       # returns a human readable string.
       #
       def get_last_error(err_num = GetLastError.call)
          buf   = 0.chr * 260
          flags = FORMAT_MESSAGE_FROM_SYSTEM + FORMAT_MESSAGE_ARGUMENT_ARRAY        
-         FormatMessage.call(flags, 0, err_num, 0, buf, buf.size, 0)      
-         buf.split(0.chr).first.chomp       
+         FormatMessage.call(flags, 0, err_num, 0, buf, buf.size, 0)
+         buf.split(0.chr).first.chomp rescue 'Unknown error'       
       end
    end
 end

data/lib/windows/file.rb

@@ -137,25 +137,6 @@ module Windows
       OPEN_EXISTING     = 3
       OPEN_ALWAYS       = 4
       TRUNCATE_EXISTING = 5
-
-      # Page file access
-      PAGE_NOACCESS          = 0x01     
-      PAGE_READONLY          = 0x02     
-      PAGE_READWRITE         = 0x04     
-      PAGE_WRITECOPY         = 0x08     
-      PAGE_EXECUTE           = 0x10     
-      PAGE_EXECUTE_READ      = 0x20     
-      PAGE_EXECUTE_READWRITE = 0x40     
-      PAGE_EXECUTE_WRITECOPY = 0x80     
-      PAGE_GUARD             = 0x100     
-      PAGE_NOCACHE           = 0x200     
-      PAGE_WRITECOMBINE      = 0x400
-      SEC_FILE               = 0x800000     
-      SEC_IMAGE              = 0x1000000     
-      SEC_VLM                = 0x2000000     
-      SEC_RESERVE            = 0x4000000     
-      SEC_COMMIT             = 0x8000000     
-      SEC_NOCACHE            = 0x10000000
       
       SECTION_QUERY       = 0x0001
       SECTION_MAP_WRITE   = 0x0002
@@ -166,30 +147,24 @@ module Windows
       SECTION_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SECTION_QUERY |
          SECTION_MAP_WRITE | SECTION_MAP_READ | SECTION_MAP_EXECUTE |
          SECTION_EXTEND_SIZE
-      
-      FILE_MAP_COPY       = SECTION_QUERY
-      FILE_MAP_WRITE      = SECTION_MAP_WRITE
-      FILE_MAP_READ       = SECTION_MAP_READ
-      FILE_MAP_ALL_ACCESS = SECTION_ALL_ACCESS
-      
+           
       # Errors
       INVALID_FILE_ATTRIBUTES   = -1
       INVALID_HANDLE_VALUE      = -1
       INVALID_FILE_SIZE         = 0xFFFFFFFF
+      
+      # Misc
+      LOCKFILE_EXCLUSIVE_LOCK   = 0x00000001
+      LOCKFILE_FAIL_IMMEDIATELY = 0x00000002
      
       CopyFile       = Win32API.new('kernel32', 'CopyFile', 'PPI', 'I')
       CopyFileEx     = Win32API.new('kernel32', 'CopyFileEx', 'PPPPPL', 'I')
       CreateFile     = Win32API.new('kernel32', 'CreateFile', 'PLLPLLL', 'L')
       CreateFileW    = Win32API.new('kernel32', 'CreateFileW', 'PLLPLLL', 'L')
-
-      CreateFileMapping = Win32API.new('kernel32', 'CreateFileMapping', 'LPLLLP', 'L')
-
       CreateHardLink = Win32API.new('kernel32', 'CreateHardLink', 'PPP', 'I')
       DecryptFile    = Win32API.new('advapi32', 'DecryptFile', 'PL', 'I')
       DeleteFile     = Win32API.new('kernel32', 'DeleteFile', 'P', 'I')
       EncryptFile    = Win32API.new('advapi32', 'EncryptFile', 'P', 'I')
-      
-      FlushViewOfFile = Win32API.new('kernel32', 'FlushViewOfFile', 'PL', 'I')
 
       GetBinaryType       = Win32API.new('kernel32', 'GetBinaryType', 'PP', 'I')
       GetFileAttributes   = Win32API.new('kernel32', 'GetFileAttributes', 'P', 'L')
@@ -204,11 +179,6 @@ module Windows
 
       LockFile   = Win32API.new('kernel32', 'LockFile', 'LLLLL', 'I')
       LockFileEx = Win32API.new('kernel32', 'LockFileEx', 'LLLLLL', 'I')
-
-      MapViewOfFile   = Win32API.new('kernel32', 'MapViewOfFile', 'LLLLL', 'L')
-      MapViewOfFileEx = Win32API.new('kernel32', 'MapViewOfFileEx', 'LLLLLL', 'L')
-      OpenFileMapping = Win32API.new('kernel32', 'OpenFileMapping', 'LIP', 'L')
-
       ReadFile   = Win32API.new('kernel32', 'ReadFile', 'LPLPP', 'I')
       ReadFileEx = Win32API.new('kernel32', 'ReadFileEx', 'LPLPP', 'I')
 
@@ -216,9 +186,6 @@ module Windows
 
       UnlockFile   = Win32API.new('kernel32', 'UnlockFile', 'LLLLL', 'I')
       UnlockFileEx = Win32API.new('kernel32', 'UnlockFileEx', 'LLLLL', 'I')
-
-      UnmapViewOfFile = Win32API.new('kernel32', 'UnmapViewOfFile', 'P', 'I')
-
       WriteFile    = Win32API.new('kernel32', 'WriteFile', 'LPLPP', 'I')
       WriteFileEx  = Win32API.new('kernel32', 'WriteFileEx', 'LPLPP', 'I')
 
@@ -234,10 +201,6 @@ module Windows
          CreateFile.call(file, access, share, sec, disp, flags, template)
       end
 
-      def CreateFileMapping(handle, security, protect, high, low, name)
-         CreateFileMapping.call(handle, security, protect, high, low, name)
-      end
-
       def CreateHardLink(new_file, old_file, attributes)
          CreateHardLink.call(new_file, old_file, attributes) > 0
       end
@@ -253,10 +216,6 @@ module Windows
       def EncryptFile(file)
          EncryptFile.call(file) > 0
       end
-      
-      def FlushViewOfFile(address, bytes)
-         FlushViewOfFile.call(address, bytes) != 0
-      end
 
       def GetBinaryType(file, type)
          GetBinaryType.call(file, type) > 0
@@ -302,18 +261,6 @@ module Windows
          LockFileEx.call(handle, flags, res, low, high, overlapped) > 0
       end
 
-      def MapViewOfFile(handle, access, high, low, bytes)
-         MapViewOfFile.call(handle, access, high, low, bytes)
-      end
-      
-      def MapViewOfFileEx(handle, access, high, low, bytes, address)
-         MapViewOfFileEx.call(handle, access, high, low, bytes, address)
-      end
-
-      def OpenFileMapping(access, inherit, name)
-         OpenFileMapping.call(access, inherit, name)
-      end
-
       def ReadFile(file, buf, bytes, bytes_read, overlapped)
          ReadFile.call(file, buf, bytes, bytes_read, overlapped) > 0
       end
@@ -334,10 +281,6 @@ module Windows
          UnlockFileEx.call(handle, res, low, high, overlapped) > 0
       end
 
-      def UnmapViewOfFile(address)
-         UnmapViewOfFile.call(address) != 0
-      end
-
       def WriteFile(handle, buf, bytes, overlapped)
          WriteFileEx.call(handle, buf, bytes, overlapped) > 0
       end

data/lib/windows/file_mapping.rb

@@ -0,0 +1,59 @@
+require 'Win32API'
+
+module Windows
+   module FileMapping     
+      FILE_MAP_COPY       = 0x0001
+      FILE_MAP_WRITE      = 0x0002
+      FILE_MAP_READ       = 0x0004
+      FILE_MAP_ALL_ACCESS = 983071
+      
+      PAGE_NOACCESS          = 0x01     
+      PAGE_READONLY          = 0x02     
+      PAGE_READWRITE         = 0x04     
+      PAGE_WRITECOPY         = 0x08     
+      PAGE_EXECUTE           = 0x10     
+      PAGE_EXECUTE_READ      = 0x20     
+      PAGE_EXECUTE_READWRITE = 0x40     
+      PAGE_EXECUTE_WRITECOPY = 0x80     
+      PAGE_GUARD             = 0x100     
+      PAGE_NOCACHE           = 0x200     
+      PAGE_WRITECOMBINE      = 0x400
+      SEC_FILE               = 0x800000     
+      SEC_IMAGE              = 0x1000000     
+      SEC_VLM                = 0x2000000     
+      SEC_RESERVE            = 0x4000000     
+      SEC_COMMIT             = 0x8000000     
+      SEC_NOCACHE            = 0x10000000
+      
+      CreateFileMapping = Win32API.new('kernel32', 'CreateFileMapping', 'LPLLLP', 'L')
+      FlushViewOfFile   = Win32API.new('kernel32', 'FlushViewOfFile', 'PL', 'I')
+      MapViewOfFile     = Win32API.new('kernel32', 'MapViewOfFile', 'LLLLL', 'L')
+      MapViewOfFileEx   = Win32API.new('kernel32', 'MapViewOfFileEx', 'LLLLLL', 'L')
+      OpenFileMapping   = Win32API.new('kernel32', 'OpenFileMapping', 'LIP', 'L')
+      UnmapViewOfFile   = Win32API.new('kernel32', 'UnmapViewOfFile', 'P', 'I')
+      
+      def CreateFileMapping(handle, security, protect, high, low, name)
+         CreateFileMapping.call(handle, security, protect, high, low, name)
+      end
+      
+      def FlushViewOfFile(address, bytes)
+         FlushViewOfFile.call(address, bytes) != 0
+      end
+      
+      def MapViewOfFile(handle, access, high, low, bytes)
+         MapViewOfFile.call(handle, access, high, low, bytes)
+      end
+      
+      def MapViewOfFileEx(handle, access, high, low, bytes, address)
+         MapViewOfFileEx.call(handle, access, high, low, bytes, address)
+      end
+
+      def OpenFileMapping(access, inherit, name)
+         OpenFileMapping.call(access, inherit, name)
+      end
+      
+      def UnmapViewOfFile(address)
+         UnmapViewOfFile.call(address) != 0
+      end
+   end
+end

data/lib/windows/library.rb

@@ -18,16 +18,23 @@ module Windows
             
       DisableThreadLibraryCalls = Win32API.new('kernel32', 'DisableThreadLibraryCalls', 'L', 'I')
       FreeLibrary               = Win32API.new('kernel32', 'FreeLibrary', 'L', 'I')
-      FreeLibraryAndExitThread  = Win32API.new('kernel32', 'FreeLibraryAndExitThread', 'LL', 'V')
-      GetDllDirectory           = Win32API.new('kernel32', 'GetDllDirectory', 'LP', 'L')
+      FreeLibraryAndExitThread  = Win32API.new('kernel32', 'FreeLibraryAndExitThread', 'LL', 'V')     
       GetModuleFileName         = Win32API.new('kernel32', 'GetModuleFileName', 'LPL', 'L')
-      GetModuleHandle           = Win32API.new('kernel32', 'GetModuleHandle', 'P', 'L')
-      GetModuleHandleEx         = Win32API.new('kernel32', 'GetModuleHandleEx', 'LPP', 'I')
+      GetModuleHandle           = Win32API.new('kernel32', 'GetModuleHandle', 'P', 'L')      
       GetProcAddress            = Win32API.new('kernel32', 'GetProcAddress', 'LP', 'L')
       LoadLibrary               = Win32API.new('kernel32', 'LoadLibrary', 'P', 'L')
       LoadLibraryEx             = Win32API.new('kernel32', 'LoadLibraryEx', 'PLL', 'L')
       LoadModule                = Win32API.new('kernel32', 'LoadModule', 'PP', 'L')
-      SetDllDirectory           = Win32API.new('kernel32', 'SetDllDirectory', 'P', 'I')
+      
+      # Windows XP or later     
+      begin
+         GetDllDirectory   = Win32API.new('kernel32', 'GetDllDirectory', 'LP', 'L')
+         GetModuleHandleEx = Win32API.new('kernel32', 'GetModuleHandleEx', 'LPP', 'I')
+         SetDllDirectory   = Win32API.new('kernel32', 'SetDllDirectory', 'P', 'I')
+      rescue Exception
+         # Do nothing - not supported on current platform.  It's up to you to
+         # check for the existence of the constant in your code.
+      end
       
       def DisableThreadLibraryCalls(hmodule)
          DisableThreadLibraryCalls.call(hmodule) != 0
@@ -37,10 +44,6 @@ module Windows
          FreeLibrary.call(hmodule) != 0
       end
       
-      def GetDllDirectory(length, buffer)
-         GetDllDirectory.call(length, buffer)
-      end
-      
       def GetModuleFileName(hmodule, file, size)
          GetModuleFileName.call(hmodule, file, size)
       end
@@ -48,11 +51,7 @@ module Windows
       def GetModuleHandle(module_name)
          GetModuleHandle.call(module_name)
       end
-      
-      def GetModuleHandleEx(flags, module_name, hmodule)
-         GetModuleHandleEx.call(flags, module_name, hmodule)
-      end
-      
+     
       def GetProcAddress(hmodule, proc_name)
          GetProcAddress.call(hmodule, proc_name)
       end
@@ -69,8 +68,20 @@ module Windows
          LoadModule.call(hmodule, param_block)
       end
       
-      def SetDllDirectory(path)
-         SetDllDirectory.call(path)
+      begin
+         def SetDllDirectory(path)
+            SetDllDirectory.call(path)
+         end
+         
+         def GetModuleHandleEx(flags, module_name, hmodule)
+            GetModuleHandleEx.call(flags, module_name, hmodule)
+         end
+         
+         def GetDllDirectory(length, buffer)
+            GetDllDirectory.call(length, buffer)
+         end
+      rescue Exception
+         # Windows XP or later
       end
    end
 end

data/lib/windows/network_management.rb

@@ -0,0 +1,462 @@
+require 'Win32API'
+
+module Windows
+   module NetworkManagement
+      NERR_Success         = 0
+      MAX_PREFERRED_LENGTH = -1
+
+      # Taken from LMServer.h
+      SV_TYPE_WORKSTATION       = 0x00000001
+      SV_TYPE_SERVER            = 0x00000002
+      SV_TYPE_SQLSERVER         = 0x00000004
+      SV_TYPE_DOMAIN_CTRL       = 0x00000008
+      SV_TYPE_DOMAIN_BAKCTRL    = 0x00000010
+      SV_TYPE_TIME_SOURCE       = 0x00000020
+      SV_TYPE_AFP               = 0x00000040
+      SV_TYPE_NOVELL            = 0x00000080
+      SV_TYPE_DOMAIN_MEMBER     = 0x00000100
+      SV_TYPE_PRINTQ_SERVER     = 0x00000200
+      SV_TYPE_DIALIN_SERVER     = 0x00000400
+      SV_TYPE_XENIX_SERVER      = 0x00000800
+      SV_TYPE_SERVER_UNIX       = SV_TYPE_XENIX_SERVER
+      SV_TYPE_NT                = 0x00001000
+      SV_TYPE_WFW               = 0x00002000
+      SV_TYPE_SERVER_MFPN       = 0x00004000
+      SV_TYPE_SERVER_NT         = 0x00008000
+      SV_TYPE_POTENTIAL_BROWSER = 0x00010000
+      SV_TYPE_BACKUP_BROWSER    = 0x00020000
+      SV_TYPE_MASTER_BROWSER    = 0x00040000
+      SV_TYPE_DOMAIN_MASTER     = 0x00080000
+      SV_TYPE_SERVER_OSF        = 0x00100000
+      SV_TYPE_SERVER_VMS        = 0x00200000
+      SV_TYPE_WINDOWS           = 0x00400000
+      SV_TYPE_DFS               = 0x00800000
+      SV_TYPE_CLUSTER_NT        = 0x01000000
+      SV_TYPE_TERMINALSERVER    = 0x02000000
+      SV_TYPE_CLUSTER_VS_NT     = 0x04000000
+      SV_TYPE_DCE               = 0x10000000
+      SV_TYPE_ALTERNATE_XPORT   = 0x20000000
+      SV_TYPE_LOCAL_LIST_ONLY   = 0x40000000
+      SV_TYPE_DOMAIN_ENUM       = 0x80000000
+      SV_TYPE_ALL               = 0xFFFFFFFF
+
+      NetAlertRaise          = Win32API.new('netapi32', 'NetAlertRaise', 'PPL', 'L')
+      NetAlertRaiseEx        = Win32API.new('netapi32', 'NetAlertRaiseEx', 'PPLP', 'L')
+      NetApiBufferAllocate   = Win32API.new('netapi32', 'NetApiBufferAllocate', 'LP', 'L')
+      NetApiBufferFree       = Win32API.new('netapi32', 'NetApiBufferFree', 'P', 'L')
+      NetApiBufferReallocate = Win32API.new('netapi32', 'NetApiBufferReallocate', 'PLP', 'L')
+      NetApiBufferSize       = Win32API.new('netapi32', 'NetApiBufferSize', 'PP', 'L')
+      NetGetAnyDCName        = Win32API.new('netapi32', 'NetGetAnyDCName', 'PPP', 'L')
+      NetGetDCName           = Win32API.new('netapi32', 'NetGetDCName', 'PPP', 'L')
+
+      NetGetDisplayInformationIndex = Win32API.new('netapi32', 'NetGetDisplayInformationIndex', 'PLPP', 'L')
+      NetGetJoinableOUs             = Win32API.new('netapi32', 'NetGetJoinableOUs', 'PPPPPP', 'L')
+      NetGetJoinInformation         = Win32API.new('netapi32', 'NetGetJoinInformation', 'PPP', 'L')
+
+      NetGroupAdd      = Win32API.new('netapi32', 'NetGroupAdd', 'PLPP', 'L')
+      NetGroupAddUser  = Win32API.new('netapi32', 'NetGroupAddUser', 'PPP', 'L')
+      NetGroupDel      = Win32API.new('netapi32', 'NetGroupDel', 'PP', 'L')
+      NetGroupDelUser  = Win32API.new('netapi32', 'NetGroupDelUser', 'PPP', 'L')
+      NetGroupEnum     = Win32API.new('netapi32', 'NetGroupEnum', 'PLPLPPP', 'L')
+      NetGroupGetInfo  = Win32API.new('netapi32', 'NetGroupGetInfo', 'PPLP', 'L')
+      NetGroupGetUsers = Win32API.new('netapi32', 'NetGroupGetUsers', 'PPLPLPPP', 'L')
+      NetGroupSetInfo  = Win32API.new('netapi32', 'NetGroupSetInfo', 'PPLPP', 'L')
+      NetGroupSetUsers = Win32API.new('netapi32', 'NetGroupSetUsers', 'PPLPL', 'L')
+      NetJoinDomain    = Win32API.new('netapi32', 'NetJoinDomain', 'PPPPPL', 'L')
+
+      NetLocalGroupAdd        = Win32API.new('netapi32', 'NetLocalGroupAdd', 'PLPP', 'L')
+      NetLocalGroupAddMembers = Win32API.new('netapi32', 'NetLocalGroupAddMembers', 'PPLPL', 'L')
+      NetLocalGroupDel        = Win32API.new('netapi32', 'NetLocalGroupDel', 'PP', 'L')
+      NetLocalGroupDelMembers = Win32API.new('netapi32', 'NetLocalGroupDelMembers', 'PPLPL', 'L')
+      NetLocalGroupEnum       = Win32API.new('netapi32', 'NetLocalGroupEnum', 'PLPLPPP', 'L')
+      NetLocalGroupGetInfo    = Win32API.new('netapi32', 'NetLocalGroupGetInfo', 'PPLP', 'L')
+      NetLocalGroupGetMembers = Win32API.new('netapi32', 'NetLocalGroupGetMembers', 'PPLPLPPP', 'L')
+      NetLocalGroupSetInfo    = Win32API.new('netapi32', 'NetLocalGroupSetInfo', 'PPLPP', 'L')
+      NetLocalGroupSetMembers = Win32API.new('netapi32', 'NetLocalGroupSetMembers', 'PPLPP', 'L')
+      NetMessageBufferSend    = Win32API.new('netapi32', 'NetMessageBufferSend', 'PPPPL', 'L')
+      NetMessageNameAdd       = Win32API.new('netapi32', 'NetMessageNameAdd', 'PP', 'L')
+      NetMessageNameDel       = Win32API.new('netapi32', 'NetMessageNameDel', 'PP', 'L')
+      NetMessageNameEnum      = Win32API.new('netapi32', 'NetMessageNameEnum', 'PLPLPPP', 'L')
+      NetMessageNameGetInfo   = Win32API.new('netapi32', 'NetMessageNameGetInfo', 'PPLP', 'L')
+
+      NetQueryDisplayInformation = Win32API.new('netapi32', 'NetQueryDisplayInformation', 'PLLLLPP', 'L')
+      NetRemoteComputerSupports  = Win32API.new('netapi32', 'NetRemoteComputerSupports', 'PLP', 'L')
+      NetRemoteTOD               = Win32API.new('netapi32', 'NetRemoteTOD', 'PP', 'L')
+      NetRenameMachineInDomain   = Win32API.new('netapi32', 'NetRenameMachineInDomain', 'PPPPL', 'L')
+      NetScheduleJobAdd          = Win32API.new('netapi32', 'NetScheduleJobAdd', 'PPP', 'L')
+      NetScheduleJobDel          = Win32API.new('netapi32', 'NetScheduleJobDel', 'PLL', 'L')
+      NetScheduleJobEnum         = Win32API.new('netapi32', 'NetScheduleJobEnum', 'PPLPPP', 'L')
+      NetScheduleJobGetInfo      = Win32API.new('netapi32', 'NetScheduleJobGetInfo', 'PLP', 'L')
+
+      NetServerComputerNameAdd = Win32API.new('netapi32', 'NetServerComputerNameAdd', 'PPP', 'L')
+      NetServerComputerNameDel = Win32API.new('netapi32', 'NetServerComputerNameDel', 'PP', 'L')
+      NetServerDiskEnum        = Win32API.new('netapi32', 'NetServerDiskEnum', 'PLPLPPP', 'L')
+      NetServerEnum            = Win32API.new('netapi32', 'NetServerEnum', 'PLPLPPLPP', 'L')
+      NetServerGetInfo         = Win32API.new('netapi32', 'NetServerGetInfo', 'PLP', 'L')
+      NetServerSetInfo         = Win32API.new('netapi32', 'NetServerSetInfo', 'PLPP', 'L')
+      NetServerTransportAdd    = Win32API.new('netapi32', 'NetServerTransportAdd', 'PLP', 'L')
+      NetServerTransportAddEx  = Win32API.new('netapi32', 'NetServerTransportAddEx', 'PLP', 'L')
+      NetServerTransportDel    = Win32API.new('netapi32', 'NetServerTransportDel', 'PLP', 'L')
+      NetServerTransportEnum   = Win32API.new('netapi32', 'NetServerTransportEnum', 'PLPLPPP', 'L')
+      NetUnjoinDomain          = Win32API.new('netapi32', 'NetUnjoinDomain', 'PPPL', 'L')
+
+      NetUseAdd     = Win32API.new('netapi32', 'NetUseAdd', 'PLPP', 'L')
+      NetUseDel     = Win32API.new('netapi32', 'NetUseDel', 'PPL', 'L')
+      NetUseEnum    = Win32API.new('netapi32', 'NetUseEnum', 'PLPLPPP', 'L')
+      NetUseGetInfo = Win32API.new('netapi32', 'NetUseGetInfo', 'PPLP', 'L')
+
+      NetUserAdd            = Win32API.new('netapi32', 'NetUserAdd', 'PLPP', 'L')
+      NetUserChangePassword = Win32API.new('netapi32', 'NetUserChangePassword', 'PPPP', 'L')
+      NetUserDel            = Win32API.new('netapi32', 'NetUserDel', 'PP', 'L')
+      NetUserEnum           = Win32API.new('netapi32', 'NetUserEnum', 'PLLPLPPP', 'L')
+      NetUserGetGroups      = Win32API.new('netapi32', 'NetUserGetGroups', 'PPLPLPP', 'L')
+      NetUserGetInfo        = Win32API.new('netapi32', 'NetUserGetInfo', 'PPLP', 'L')
+      NetUserGetLocalGroups = Win32API.new('netapi32', 'NetUserGetLocalGroups', 'PPLLPLPP', 'L')
+
+      NetUserModalsGet = Win32API.new('netapi32', 'NetUserModalsGet', 'PLP', 'L')
+      NetUserModalsSet = Win32API.new('netapi32', 'NetUserModalsSet', 'PLPP', 'L')
+      NetUserSetGroups = Win32API.new('netapi32', 'NetUserSetGroups', 'PPLPL', 'L')
+      NetUserSetInfo   = Win32API.new('netapi32', 'NetUserSetInfo', 'PPLPP', 'L')
+      NetValidateName  = Win32API.new('netapi32', 'NetValidateName', 'PPPPP', 'L')
+
+      NetWkstaGetInfo       = Win32API.new('netapi32', 'NetWkstaGetInfo', 'PLP', 'L')
+      NetWkstaSetInfo       = Win32API.new('netapi32', 'NetWkstaSetInfo', 'PLPP', 'L')
+      NetWkstaTransportAdd  = Win32API.new('netapi32', 'NetWkstaTransportAdd', 'PLPP', 'L')
+      NetWkstaTransportDel  = Win32API.new('netapi32', 'NetWkstaTransportDel', 'PPL', 'L')
+      NetWkstaTransportEnum = Win32API.new('netapi32', 'NetWkstaTransportEnum', 'PLPLPPP', 'L')
+      NetWkstaUserEnum      = Win32API.new('netapi32', 'NetWkstaUserEnum', 'PLPLPPP', 'L')
+      NetWkstaUserGetInfo   = Win32API.new('netapi32', 'NetWkstaUserGetInfo', 'PLP', 'L')
+      NetWkstaUserSetInfo   = Win32API.new('netapi32', 'NetWkstaUserSetInfo', 'PPLP', 'L')
+
+      begin 
+         GetNetScheduleAccountInformation = Win32API.new('mstask', 'GetNetScheduleAccountInformation', 'PLP', 'L')
+         SetNetScheduleAccountInformation = Win32API.new('netapi32', 'SetNetScheduleAccountInformation', 'PPP', 'L')
+      rescue Exception
+         # Do nothing.  Not supported on current platform
+      end
+
+      def NetAlertRaise(name, buf, bufsize)
+         NetAlertRaise.call(name, buf, bufsize) == NERR_Success
+      end
+
+      def NetAlertRaiseEx(name, data, size, service)
+         NetAlertRaiseEx.call(name, data, size, service) == NERR_Success
+      end
+
+      def NetApiBufferAllocate(num_bytes, buf)
+         NetApiBufferAllocate.call(num_bytes, buf) == NERR_Success
+      end
+
+      def NetApiBufferFree(buf)
+         NetApiBufferFree.call(buf) == NERR_Success
+      end
+
+      def NetApiBufferReallocate(old_buf, count, new_buf)
+         NetApiBufferReallocate.call(old_buf, count, new_buf) == NERR_Success
+      end
+
+      def NetApiBufferSize(buf, count)
+         NetApiBufferSize.call(buf, count) == NERR_Success
+      end
+
+      def NetGetAnyDCName(server, domain, buf)
+         NetGetAnyDCName.call(server, domain, buf) == NERR_Success
+      end
+
+      def NetGetDCName(server, domain, buf)
+         NetGetDCName.call(server, domain, buf) == NERR_Success
+      end
+
+      def NetGetDisplayInformationIndex(server, level, prefix, index)
+         NetGetDisplayInformationIndex.call(server, level, prefix, index) == NERR_Success
+      end
+
+      def NetGetJoinableOUs(server, domain, account, password, count, ous)
+         NetGetJoinableOUs.call(server, domain, account, password, count, ous) == NERR_Success
+      end
+
+      def NetGetJoinInformation(server, buf, buf_type)
+         NetGetJoinInformation.call(server, buf, buf_type) == NERR_Success
+      end
+
+      def NetGroupAdd(server, level, buf, err)
+         NetGroupAdd.call(server, level, buf, err).call == NERR_Success
+      end
+
+      def NetGroupAddUser(server, group, user)
+         NetGroupAddUser.call(server, group, user) == NERR_Success
+      end
+
+      def NetGroupDel(server, group)
+         NetGroupDel.call(server, group) == NERR_Success
+      end
+
+      def NetGroupDelUser(server, group, user)
+         NetGroupDelUser.call(server, group, user) == NERR_Success
+      end
+
+      def NetGroupEnum(server, level, buf, max, entries, total_entries, resume)
+         NetGroupEnum.call(server, level, buf, max, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetGroupGetInfo(server, group, level, buf)
+         NetGroupGetInfo.call(server, group, level, buf) == NERR_Success
+      end
+
+      def NetGroupGetUsers(server, group, level, buf, max, entries, total_entries, resume)
+         NetGroupGetUsers.call(server, group, level, buf, max, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetGroupSetInfo(server, group, level, buf, err)
+         NetGroupSetInfo.call(server, group, level, buf, err) == NERR_Success
+      end
+
+      def NetGroupSetUsers(server, group, level, buf, total)
+         NetGroupSetUsers.call(server, group, level, buf, total) == NERR_Success
+      end
+
+      def NetJoinDomain(server, domain, account_ou, account, password, opts)
+         NetJoinDomain.call(server, domain, account_ou, account, password, opts) == NERR_Success
+      end
+
+      def NetLocalGroupAdd(server, level, buf, err)
+         NetLocalGroupAdd.call(server, level, buf, err) == NERR_Success
+      end
+
+      def NetLocalGroupAddMembers(server, group, level, buf, total)
+         NetLocalGroupAddMembers.call(server, group, level, buf, total) == NERR_Success
+      end
+
+      def NetLocalGroupDel(server, group)
+         NetLocalGroupDel.call(server, group) == NERR_Success
+      end
+
+      def NetLocalGroupDelMembers(server, group, level, buf, total)
+         NetLocalGroupDelMembers.call(server, group, level, buf, total) == NERR_Success
+      end
+
+      def NetLocalGroupEnum(server, level, buf, max, entries, total_entries, resume)
+         NetLocalGroupEnum.call(server, level, buf, max, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetLocalGroupGetInfo(server, group, level, buf)
+         NetLocalGroupGetInfo.call(server, group, level, buf) == NERR_Success
+      end
+
+      def NetLocalGroupGetMembers(server, group, level, buf, max, entries, total_entries, resume)
+         NetLocalGroupGetMembers.call(server, group, level, buf, max, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetLocalGroupSetInfo(server, group, level, buf, err)
+         NetLocalGroupSetInfo.call(server, group, level, buf, err) == NERR_Success
+      end
+
+      def NetLocalGroupSetMembers(server, group, level, buf, total)
+         NetLocalGroupSetMembers.call(server, group, level, buf, total) == NERR_Success
+      end
+
+      def NetMessageBufferSend(server, msg, from, buf, bufsize)
+         NetMessageBufferSend.call(server, msg, from, buf, bufsize) == NERR_Success
+      end
+
+      def NetMessageNameAdd(server, msg)
+         NetMessageNameAdd.call(server, msg) == NERR_Success
+      end
+
+      def NetMessageNameDel(server, msg)
+         NetMessageNameDel.call(server, msg) == NERR_Success
+      end
+
+      def NetMessageNameEnum(server, level, buf, max, entries, total_entries, resume)
+         NetMessageNameEnum.call(server, level, buf, max, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetMessageNameGetInfo(server, msg, level, buf)
+         NetMessageNameGetInfo.call(server, msg, level, buf) == NERR_Success
+      end
+
+      def NetQueryDisplayInformation(server, level, index, entries, max, count, buf)
+         NetQueryDisplayInformation.call(server, level, index, entries, max, count, buf) == NERR_Success
+      end
+
+      def NetRemoteComputerSupports(server, level, index, entries, max, count, buf)
+         NetRemoteComputerSupports.call(server, level, index, entries, max, count, buf) == NERR_Success
+      end
+
+      def NetRemoteTOD(server, buf)
+         NetRemoteTOD.call(server, buf) == NERR_Success
+      end
+
+      def NetRenameMachineInDomain(server, machine, account, password, options)
+         NetRenameMachineInDomain.call(server, machine, account, password, options) == NERR_Success
+      end
+
+      def NetScheduleJobAdd(server, buf, job)
+         NetScheduleJobAdd.call(server, buf, job) == NERR_Success
+      end
+      
+      def NetScheduleJobDel(server, min, max)
+         NetScheduleJobDel.call(server, min, max) == NERR_Success
+      end
+
+      def NetScheduleJobEnum(server, buf, max, entries, total_entries, resume)
+         NetScheduleJobEnum.call(server, buf, max, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetScheduleJobGetInfo(server, job, buf)
+         NetScheduleJobGetInfo.call(server, job, buf) == NERR_Success
+      end
+
+      def NetServerComputerNameAdd(server, em_domain, em_server)
+         NetServerComputerNameAdd.call(server, em_domain, em_server) == NERR_Success
+      end
+
+      def NetServerComputerNameDel(server, em_server)
+         NetServerComputerNameDel.call(server, em_server) == NERR_Success
+      end
+
+      def NetServerDiskEnum(server, level, buf, maxlen, entries, total_entries, resume)
+         NetServerDiskEnum.call(server, level, buf, maxlen, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetServerEnum(server, level, ptr, maxlen, num, total, stype, domain, handle)
+         NetServerEnum.call(server, level, ptr, maxlen, num, total, stype, domain, handle) == NERR_Success
+      end
+
+      def NetServerGetInfo(server, level, buf)
+         NetServerGetInfo.call(server, level, buf) == NERR_Success
+      end
+
+      def NetServerSetInfo(server, level, buf, error)
+         NetServerSetInfo.call(server, level, buf, error) == NERR_Success
+      end
+
+      def NetServerTransportAdd(server, level, buf)
+         NetServerTransportAdd.call(server, level, buf) == NERR_Success
+      end
+
+      def NetServerTransportAddEx(server, level, buf)
+         NetServerTransportAddEx.call(server, level, buf) == NERR_Success
+      end
+
+      def NetServerTransportDel(server, level, buf)
+         NetServerTransportDel.call(server, level, buf) == NERR_Success
+      end
+
+      def NetServerTransportEnum(server, level, buf, maxlen, entries, total_entries, resume)
+         NetServerTransportEnum.call(server, level, buf, maxlen, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetUnjoinDomain(server, account, password, options)
+         NetUnjoinDomain.call(server, account, password, options) == NERR_Success
+      end
+
+      def NetUseAdd(server, level, buf, error)
+         NetUseAdd.call(server, level, buf, error) == NERR_Success
+      end
+
+      def NetUseDel(server, name, conn)
+         NetUseDel.call(server, name, conn) == NERR_Success
+      end
+
+      def NetUseEnum(server, level, buf, max, entries, total_entries, resume)
+         NetUseEnum.call(server, level, buf, max, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetUseGetInfo(server, name, level, buf)
+         NetUseGetInfo.call(server, name, level, buf) == NERR_Success
+      end
+
+      def NetUserAdd(server, level, buf, error)
+         NetUserAdd.call(server, level, buf, error) == NERR_Success
+      end
+
+      def NetUserChangePassword(domain, user, old, new)
+         NetUserChangePassword.call(domain, user, old, new) == NERR_Success
+      end
+
+      def NetUserDel(server, user)
+         NetUserDel.call(server, user) == NERR_Success
+      end
+
+      def NetUserEnum(server, level, filter, buf, max, entries, total_entries, resume)
+         NetUserEnum.call(server, level, filter, buf, max, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetUserGetGroups(server, user, level, buf, max, entries, total_entries)
+         NetUserGetGroups.call(server, user, level, buf, max, entries, total_entries) == NERR_Success
+      end
+
+      def NetUserGetInfo(server, user, level, buf)
+         NetUserGetInfo.call(server, user, level, buf) == NERR_Success
+      end
+
+      def NetUserGetLocalGroups(server, user, level, flags, buf, max, entries, total_entries)
+         NetUserGetLocalGroups.call(server, user, level, flags, buf, max, entries, total_entries) == NERR_Success
+      end
+
+      def NetUserModalsGet(server, level, buf)
+         NetUserModalsGet.call(server, level, buf) == NERR_Success
+      end
+
+      def NetUserModalsSet(server, level, buf, error)
+         NetUserModalsSet.call(server, level, buf, error) == NERR_Success
+      end
+
+      def NetUserSetGroups(server, user, level, buf, num)
+         NetUserSetGroups.call(server, user, level, buf, num) == NERR_Success
+      end
+
+      def NetUserSetInfo(server, user, level, buf, error)
+         NetUserSetInfo.call(server, user, level, buf, error) == NERR_Success
+      end
+
+      def NetValidateName(server, name, account, password, name_type)
+         NetValidateName.call(server, name, account, password, name_type) == NERR_Success
+      end
+
+      def NetWkstaGetInfo(server, level, buf)
+         NetWkstaGetInfo.call(server, level, buf) == NERR_Success
+      end
+
+      def NetWkstaSetInfo.call(server, level, buf, error)
+         NetWkstaSetInfo.call(server, level, buf, error) == NERR_Success
+      end
+
+      def NetWkstaTransportAdd(server, level, buf, error)
+         NetWkstaTransportAdd.call(server, level, buf, error) == NERR_Success
+      end
+
+      def NetWkstaTransportDel(server, name, cond)
+         NetWkstaTransportDel.call(server, name, cond) == NERR_Success
+      end
+
+      def NetWkstaTransportEnum(server, level, buf, maxlen, entries, total_entries, resume)
+         NetWkstaTransportEnum.call(server, level, buf, maxlen, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetWkstaUserEnum(server, level, buf, maxlen, entries, total_entries, resume)
+         NetWkstaUserEnum.call(server, level, buf, maxlen, entries, total_entries, resume) == NERR_Success
+      end
+
+      def NetWkstaUserGetInfo(res, level, buf)
+         NetWkstaUserGetInfo.call(res, level, buf) == NERR_Success
+      end
+
+      def NetWkstaUserSetInfo(res, level, buf, error)
+         NetWkstaUserSetInfo.call(res, level, buf, error) == NERR_Success
+      end
+
+      # Windows XP or later
+      begin
+         def GetNetScheduleAccountInformation(server, num_chars, chars)
+            GetNetScheduleAccountInformation.call(server, num_chars, chars) == NERR_Success
+         end
+
+         def SetNetScheduleAccountInformation(server, account, password)
+            SetNetScheduleAccountInformation.call(server, account, password) == NERR_Success
+         end
+      rescue Exception
+      end
+   end
+end

data/lib/windows/synchronize.rb

@@ -1,34 +1,3 @@
-#######################################################################
-# synchronize.rb
-#
-# Defines the following functions:
-#
-# CreateEvent()
-# CreateMutex()
-# CreateSemaphore()
-# MsgWaitForMultipleObjects()
-# MsgWaitForMultipleObjectsEx()
-# OpenEvent()
-# OpenMutex()
-# OpenSemaphore()
-# WaitForDebugEvent()
-# WaitForSingleObject()
-# WaitForSingleObjectEx()
-# WaitForMultipleObjects()
-# WaitForMultipleObjectsEx()
-#
-# Defines the the following constants:
-#
-# WAIT_ABANDONED
-# WAIT_OBJECT_0
-# WAIT_TIMEOUT
-# WAIT_FAILED
-# INFINITE
-#
-# TODO:
-#
-# Add the rest of the synchronization functions.
-#######################################################################
 require 'Win32API'
 
 module Windows

data/test/tc_error.rb

@@ -40,7 +40,7 @@ class TC_Windows_Error < Test::Unit::TestCase
    def test_method_constants
       assert_not_nil(Foo::GetLastError)
       assert_not_nil(Foo::SetLastError)
-      assert_not_nil(Foo::SetLastErrorEx)
+      assert_not_nil(Foo::SetLastErrorEx) # Ignore for VC++ 6 or earlier.
       assert_not_nil(Foo::SetErrorMode)
       assert_not_nil(Foo::FormatMessage)
    end

data/test/tc_library.rb

@@ -0,0 +1,44 @@
+#####################################################################
+# tc_library.rb
+#
+# Test case for the Windows::Library module.
+#####################################################################
+base = File.basename(Dir.pwd)
+if base == 'test' || base =~ /windows-pr/
+   Dir.chdir '..' if base == 'test'
+   $LOAD_PATH.unshift Dir.pwd + '/lib'
+   Dir.chdir 'test' rescue nil
+end
+
+require 'windows/library'
+require 'test/unit'
+
+class Foo
+   include Windows::Library
+end
+
+class TC_Windows_Library < Test::Unit::TestCase
+   def setup
+      @foo  = Foo.new
+   end
+
+   def test_numeric_constants
+      assert_equal(0, Foo::DLL_PROCESS_DETACH)
+      assert_equal(1, Foo::DLL_PROCESS_ATTACH)
+      assert_equal(2, Foo::DLL_THREAD_ATTACH)
+      assert_equal(3, Foo::DLL_THREAD_DETACH)
+   end
+
+   def test_method_constants
+      assert_not_nil(Foo::FreeLibrary)
+      assert_not_nil(Foo::GetModuleFileName)
+      assert_not_nil(Foo::GetModuleHandle)
+      assert_not_nil(Foo::LoadLibrary)
+      assert_not_nil(Foo::LoadLibraryEx)
+      assert_not_nil(Foo::LoadModule)
+   end
+
+   def teardown
+      @foo  = nil
+   end
+end

data/windows-pr.gemspec

@@ -0,0 +1,25 @@
+require "rubygems"
+
+spec = Gem::Specification.new do |gem|
+   gem.name        = "windows-pr"
+   gem.version     = "0.5.4"
+   gem.author      = "Daniel J. Berger"
+   gem.email       = "djberg96@gmail.com"
+   gem.homepage    = "http://www.rubyforge.org/projects/win32utils"
+   gem.platform    = Gem::Platform::RUBY
+   gem.summary     = "Windows functions and constants predefined via Win32API"
+   gem.description = "Windows functions and constants predefined via Win32API"
+   gem.test_file   = "test/ts_all.rb"
+   gem.has_rdoc    = true
+   gem.files       = Dir["doc/*.txt"] + Dir["lib/windows/*.rb"]
+   gem.files += Dir["lib/windows/msvcrt/*.rb"] 
+   gem.files += Dir["test/*"] + Dir["[A-Z]*"]
+   gem.files.reject! { |fn| fn.include? "CVS" }
+   gem.require_path = "lib"
+   gem.extra_rdoc_files = ["README", "CHANGES"]
+end
+
+if $0 == __FILE__
+   Gem.manage_gems
+   Gem::Builder.new(spec).build
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: windows-pr
 version: !ruby/object:Gem::Version 
-  version: 0.5.3
-date: 2006-08-10 00:00:00 -06:00
+  version: 0.5.4
+date: 2006-09-08 00:00:00 -06:00
 summary: Windows functions and constants predefined via Win32API
 require_paths: 
 - lib
@@ -38,11 +38,13 @@ files:
 - lib/windows/eventlog.rb
 - lib/windows/file.rb
 - lib/windows/filesystem.rb
+- lib/windows/file_mapping.rb
 - lib/windows/handle.rb
 - lib/windows/library.rb
 - lib/windows/limits.rb
 - lib/windows/memory.rb
 - lib/windows/national.rb
+- lib/windows/network_management.rb
 - lib/windows/path.rb
 - lib/windows/pipe.rb
 - lib/windows/process.rb
@@ -65,6 +67,7 @@ files:
 - test/tc_error.rb
 - test/tc_eventlog.rb
 - test/tc_file.rb
+- test/tc_library.rb
 - test/tc_memory.rb
 - test/tc_msvcrt_buffer.rb
 - test/tc_path.rb
@@ -76,8 +79,13 @@ files:
 - test/tc_unicode.rb
 - CHANGES
 - CVS
+- doc
+- install.rb
+- lib
 - MANIFEST
 - README
+- test
+- windows-pr.gemspec
 test_files: 
 - test/ts_all.rb
 rdoc_options: []