windows-pr 0.3.0-mswin32

data/lib/windows/limits.rb

@@ -0,0 +1,13 @@
+module Windows
+   module Limits
+      MINCHAR  = 0x80
+      MAXCHAR  = 0x7f
+      MINSHORT = 0x8000
+      MAXSHORT = 0x7fff
+      MINLONG  = 0x80000000
+      MAXLONG  = 0x7fffffff
+      MAXBYTE  = 0xff
+      MAXWORD  = 0xffff
+      MAXDWORD = 0xffffffff
+   end
+end 

data/lib/windows/memory.rb

@@ -0,0 +1,92 @@
+######################################################################
+# memory.rb
+#
+# Includes the following functions:
+#
+# GlobalAlloc()
+# GlobalDiscard()
+# GlobalFlags()
+# GlobalFree()
+# GlobalHandle()
+# GlobalLock()
+# GlobalMemoryStatus()
+# GlobalMemoryStatusEx()
+# GlobalReAlloc()
+# GlobalSize()
+# GlobalUnlock()
+#
+# Defines the following constants:
+#
+# GHND
+# GMEM_FIXED
+# GMEM_MOVABLE
+# GMEM_ZEROINIT
+# GPTR
+######################################################################
+require 'Win32API'
+
+module Windows
+   module Memory
+      GHND           = 0x0042
+      GMEM_FIXED     = 0x0000
+      GMEM_MOVABLE   = 0002
+      GMEM_ZEROINIT  = 0x0040
+      GPTR           = 0x0040
+
+      GlobalAlloc          = Win32API.new('kernel32', 'GlobalAlloc', 'II', 'I')
+      GlobalDiscard        = Win32API.new('kernel32', 'GlobalDiscard', 'I', 'I')
+      GlobalFlags          = Win32API.new('kernel32', 'GlobalFlags', 'I', 'I')
+      GlobalFree           = Win32API.new('kernel32', 'GlobalFree', 'I', 'I')
+      GlobalHandle         = Win32API.new('kernel32', 'GlobalHandle', 'P', 'I')
+      GlobalLock           = Win32API.new('kernel32', 'GlobalLock', 'I', 'P')
+      GlobalMemoryStatus   = Win32API.new('kernel32', 'GlobalMemoryStatus', 'P', 'V')
+      GlobalMemoryStatusEx = Win32API.new('kernel32', 'GlobalMemoryStatus', 'P', 'V')
+      GlobalReAlloc        = Win32API.new('kernel32', 'GlobalReAlloc', 'III', 'I')
+      GlobalSize           = Win32API.new('kernel32', 'GlobalSize', 'I', 'I')
+      GlobalUnlock         = Win32API.new('kernel32', 'GlobalUnlock', 'I', 'I')
+
+      def GlobalAlloc(flags, bytes)
+         GlobalAlloc.call(flags, bytes)
+      end
+
+      def GlobalDiscard(handle)
+         GlobalDiscard.call(handle)
+      end
+
+      def GlobalFlags(handle)
+         GlobalFlags.call(handle)
+      end
+
+      def GlobalFree(handle)
+         GlobalFree.call(handle)
+      end
+
+      def GlobalHandle(handle)
+         GlobalHandle.call(handle)
+      end
+
+      def GlobalLock(handle)
+         GlobalHandle.call(handle)
+      end
+
+      def GlobalMemoryStatus(buf)
+         GlobalMemoryStatus.call(buf)
+      end
+
+      def GlobalMemoryStatusEx(buf)
+         GlobalMemoryStatusEx.call(buf)
+      end
+
+      def GlobalReAlloc(handle, bytes, flags)
+         GlobalReAlloc.call(handle, bytes, flags)
+      end
+
+      def GlobalSize(handle)
+         GlobalSize.call(handle)
+      end
+
+      def GlobalUnlock(handle)
+         GlobalUnlock.call(handle)
+      end
+   end
+end

data/lib/windows/msvcrt/buffer.rb

@@ -0,0 +1,48 @@
+require 'Win32API'
+
+module Windows
+   module MSVCRT
+      module Buffer
+         Memcpy  = Win32API.new('msvcrt', 'memcpy', 'PLL', 'P')
+         Memccpy = Win32API.new('msvcrt', '_memccpy', 'PPIL', 'P')
+         Memchr  = Win32API.new('msvcrt', 'memchr', 'PIL', 'P')
+         Memcmp  = Win32API.new('msvcrt', 'memcmp', 'PPL', 'I')
+         Memicmp = Win32API.new('msvcrt', '_memicmp', 'PPL', 'I')
+         Memmove = Win32API.new('msvcrt', 'memmove', 'PPL', 'P')
+         Memset  = Win32API.new('msvcrt', 'memset', 'PLL', 'L')
+         Swab    = Win32API.new('msvcrt', '_swab', 'PPI', 'V')
+      
+         def memcpy(dest, src, size)
+            Memcpy.call(dest, src, size)
+         end
+      
+         def memccpy(dest, src, char, count)
+            Memccpy.call(dest, src, char, count)
+         end
+         
+         def memchr(buf, char, count)
+            Memchr.call(buf, char, count)
+         end
+         
+         def memcmp(buf1, buf2, count)
+            Memcmp.call(buf1, buf2, count)
+         end
+         
+         def memicmp(buf1, buf2, count)
+            Memicmp.call(buf1, buf2, count)
+         end
+         
+         def memmove(dest, src, count)
+            Memmove.call(dest, src, count)
+         end
+      
+         def memset(dest, char, count)
+            Memset.call(dest, char, count)
+         end
+         
+         def swab(src, dest, count)
+            Swab.call(src, dest, count)
+         end
+      end
+   end
+end

data/lib/windows/msvcrt/file.rb

@@ -0,0 +1,18 @@
+require 'Win32API'
+
+module Windows
+   module MSVCRT
+      module File
+         Stat   = Win32API.new('msvcrt', '_stat', 'PP', 'I')
+         Stat64 = Win32API.new('msvcrt', '_stat64', 'PP', 'I')
+         
+         def stat(path, buffer)
+            Stat.call(path, buffer)
+         end
+      
+         def stat64(path, buffer)
+            Stat64.call(path, buffer)
+         end
+      end
+   end
+end

data/lib/windows/path.rb

@@ -0,0 +1,372 @@
+######################################################################
+# path.rb
+# 
+# Defines the following functions:
+#
+# PathAddBackslash()
+# PathAddExtension()
+# PathAppend()
+# PathBuildRoot()
+# PathCanonicalize()
+# PathCombine()
+# PathCommonPrefix()
+# PathCompactPath()
+# PathCompactPathEx()
+# PathCreateFromUrl()
+# PathFileExists()
+# PathFindExtension()
+# PathFindFileName()
+# PathFindNextComponent()
+# PathFindOnPath()
+# PathFindSuffixArray()
+# PathGetArgs()
+# PathGetCharType()
+# PathGetDriveNumber()
+# PathIsContentType()
+# PathIsDirectory()
+# PathIsDirectoryEmpty()
+# PathIsFileSpec()
+# PathIsHTMLFile() - BROKEN
+# PathIsLFNFileSpec()
+# PathIsNetworkPath()
+# PathIsPrefix()
+# PathIsRelative()
+# PathIsRoot()
+# PathIsSameRoot()
+# PathIsSystemFolder()
+# PathIsUNC()
+# PathIsUNCServer()
+# PathIsUNCServerShare()
+# PathIsURL()
+# PathMakePretty()
+# PathMakeSystemFolder()
+# PathMatchSpec()
+# PathParseIconLocation()
+# PathQuoteSpaces()
+# PathRelativePathTo()
+# PathRemoveArgs()
+# PathRemoveBackslash()
+# PathRemoveBlanks()
+# PathRemoveExtension()
+# PathRemoveFileSpec()
+# PathRenameExtension()
+# PathSearchAndQualify()
+# PathSetDlgItemPath()
+# PathSkipRoot()
+# PathStripPath()
+# PathStripToRoot()
+# PathUndecorate()
+# PathUnExpandEnvStrings()
+# PathUnmakeSystemFolder() 
+# PathUnquoteSpaces()
+#
+# Defines the following constants:
+#
+# GCT_INVALID
+# GCT_LFNCHAR
+# GCT_SHORTCHAR
+# GCT_WILD
+# GCT_SEPARATOR
+#
+# Notes:
+#
+# The PathIsHTMLFile() function does not appear to be exported in the
+# shlwapi.dll file that is currently (March, 2006) shipped with the
+# free compiler libs from Microsoft.
+######################################################################
+require 'Win32API'
+
+module Windows
+   module Path
+      # These constants are for use by the PathGetCharType() function.
+      GCT_INVALID   = 0x0000   # The character is not valid in a path.
+      GCT_LFNCHAR   = 0x0001   # The character is valid in a long file name.
+      GCT_SHORTCHAR = 0x0002   # The character is valid in a short (8.3) file name.
+      GCT_WILD      = 0x0004   # The character is a wildcard character.
+      GCT_SEPARATOR = 0x0008   # The character is a path separator.
+
+      PathAddBackslash  = Win32API.new('shlwapi', 'PathAddBackslash', 'P', 'P')
+      PathAddExtension  = Win32API.new('shlwapi', 'PathAddExtension', 'PP', 'I')
+      PathAppend        = Win32API.new('shlwapi', 'PathAppend', 'PP', 'I')
+      PathBuildRoot     = Win32API.new('shlwapi', 'PathBuildRoot', 'PI', 'P')
+      PathCanonicalize  = Win32API.new('shlwapi', 'PathCanonicalize', 'PP', 'I')
+      PathCombine       = Win32API.new('shlwapi', 'PathCombine', 'PPP', 'P')
+      PathCommonPrefix  = Win32API.new('shlwapi', 'PathCommonPrefix', 'PPP', 'I')
+      PathCompactPath   = Win32API.new('shlwapi', 'PathCompactPath', 'PPI', 'I')
+      PathCompactPathEx = Win32API.new('shlwapi', 'PathCompactPathEx', 'PPIL', 'I')
+      PathCreateFromUrl = Win32API.new('shlwapi', 'PathCreateFromUrl', 'PPPL', 'L')      
+      PathFileExists    = Win32API.new('shlwapi', 'PathFileExists', 'P', 'I')
+      PathFindExtension = Win32API.new('shlwapi', 'PathFindExtension', 'P', 'P')
+      PathFindFileName  = Win32API.new('shlwapi', 'PathFindFileName', 'P', 'P') 
+
+      PathFindNextComponent  = Win32API.new('shlwapi', 'PathFindNextComponent', 'P', 'P')
+      PathFindOnPath         = Win32API.new('shlwapi', 'PathFindOnPath', 'PP', 'I')
+      PathFindSuffixArray    = Win32API.new('shlwapi', 'PathFindSuffixArray', 'PPI', 'P')
+      PathGetArgs            = Win32API.new('shlwapi', 'PathGetArgs', 'P', 'P')
+      PathGetCharType        = Win32API.new('shlwapi', 'PathGetCharType', 'P', 'I')
+      PathGetDriveNumber     = Win32API.new('shlwapi', 'PathGetDriveNumber', 'P', 'I')
+      PathIsContentType      = Win32API.new('shlwapi', 'PathIsContentType', 'PP', 'I')
+      PathIsDirectory        = Win32API.new('shlwapi', 'PathIsDirectory', 'P', 'I')
+      PathIsDirectoryEmpty   = Win32API.new('shlwapi', 'PathIsDirectoryEmpty', 'P', 'I')
+      PathIsFileSpec         = Win32API.new('shlwapi', 'PathIsFileSpec', 'P', 'I')
+      #PathIsHTMLFile        = Win32API.new('shlwapi', 'PathIsHTMLFile', 'P', 'I')
+      PathIsLFNFileSpec      = Win32API.new('shlwapi', 'PathIsLFNFileSpec', 'P', 'I')
+      PathIsNetworkPath      = Win32API.new('shlwapi', 'PathIsNetworkPath', 'P', 'I')
+      PathIsPrefix           = Win32API.new('shlwapi', 'PathIsPrefix', 'PP', 'I')
+      PathIsRelative         = Win32API.new('shlwapi', 'PathIsRelative', 'P', 'I')
+      PathIsRoot             = Win32API.new('shlwapi', 'PathIsRoot', 'P', 'I')
+      PathIsSameRoot         = Win32API.new('shlwapi', 'PathIsSameRoot', 'PP', 'I')
+      PathIsSystemFolder     = Win32API.new('shlwapi', 'PathIsSystemFolder', 'PL', 'I')
+      PathIsUNC              = Win32API.new('shlwapi', 'PathIsUNC', 'P', 'I')
+      PathIsUNCServer        = Win32API.new('shlwapi', 'PathIsUNCServer', 'P', 'I')  
+      PathIsUNCServerShare   = Win32API.new('shlwapi', 'PathIsUNCServerShare','P','I')     
+      PathIsURL              = Win32API.new('shlwapi', 'PathIsURL', 'P', 'I')
+      PathMakePretty         = Win32API.new('shlwapi', 'PathMakePretty', 'P', 'I')  
+      PathMakeSystemFolder   = Win32API.new('shlwapi', 'PathMakeSystemFolder', 'P', 'I')      
+      PathMatchSpec          = Win32API.new('shlwapi', 'PathMatchSpec', 'PP', 'I')
+      PathParseIconLocation  = Win32API.new('shlwapi', 'PathParseIconLocation', 'P', 'I')
+      PathQuoteSpaces        = Win32API.new('shlwapi', 'PathQuoteSpaces', 'P', 'V')
+      PathRelativePathTo     = Win32API.new('shlwapi', 'PathRelativePathTo', 'PPLPL', 'I')
+      PathRemoveArgs         = Win32API.new('shlwapi', 'PathRemoveArgs', 'P', 'V')
+      PathRemoveBackslash    = Win32API.new('shlwapi', 'PathRemoveBackslash', 'P', 'P')
+      PathRemoveBlanks       = Win32API.new('shlwapi', 'PathRemoveBlanks', 'P', 'V')
+      PathRemoveExtension    = Win32API.new('shlwapi', 'PathRemoveExtension', 'P','V')
+      PathRemoveFileSpec     = Win32API.new('shlwapi', 'PathRemoveFileSpec', 'P', 'L')
+      PathRenameExtension    = Win32API.new('shlwapi', 'PathRenameExtension', 'PP','I')
+      PathSearchAndQualify   = Win32API.new('shlwapi', 'PathSearchAndQualify', 'PPI', 'I')
+      PathSetDlgItemPath     = Win32API.new('shlwapi', 'PathSetDlgItemPath', 'LIP', 'V')
+      PathSkipRoot           = Win32API.new('shlwapi', 'PathSkipRoot', 'P', 'P')
+      PathStripPath          = Win32API.new('shlwapi', 'PathStripPath', 'P', 'V')
+      PathStripToRoot        = Win32API.new('shlwapi', 'PathStripToRoot', 'P', 'I')
+      PathUndecorate         = Win32API.new('shlwapi', 'PathUndecorate', 'P', 'V')
+      PathUnExpandEnvStrings = Win32API.new('shlwapi', 'PathUnExpandEnvStrings', 'PPI', 'I')
+      PathUnmakeSystemFolder = Win32API.new('shlwapi', 'PathUnmakeSystemFolder', 'P', 'I')
+      PathUnquoteSpaces      = Win32API.new('shlwapi', 'PathUnquoteSpaces', 'P', 'V')
+
+      def PathAddBackslash(path)
+         PathAddBackslash.call(path)
+      end
+
+      def PathAddExtension(path, ext)
+         PathAddExtension.call(path, ext) > 0
+      end
+
+      def PathAppend(path, more)
+         PathAppend.call(path, more) > 0
+      end
+
+      def PathBuildRoot(root, drive)
+         PathBuildRoot.call(root, drive)
+      end
+
+      def PathCanonicalize(dst, src)
+         PathCanonicalize.call(dst, src)
+      end
+
+      def PathCombine(dest, dir, file)
+         PathCombine.call(dest, dir, file)
+      end
+
+      def PathCommonPrefix(path1, path2, buf)
+         PathCommonPrefix.call(path1, path2, buf)
+      end
+
+      def PathCompactPath(handle, path, px_width)
+         PathCompactPath.call(handle, path, px_width) > 0
+      end
+
+      def PathCompactPathEx(out, src, max, flags = nil)
+         PathCompactPathEx.call(out, src, max, flags) > 0
+      end
+
+      def PathCreateFromUrl(url, path, path_size, reserved = nil)
+         PathCreateFromUrl.call(url, path, path_size, reserved) >= 0
+      end
+
+      def PathFileExists(path)
+         PathFileExists.call(path) > 0
+      end
+
+      def PathFindExtension(path)
+         PathFindExtension.call(path)
+      end
+
+      def PathFindFileName(path)
+         PathFindFileName.call(path)
+      end
+
+      def PathFindNextComponent(path)
+         PathFindNextComponent.call(path)
+      end
+
+      def PathFindOnPath(file, dirs)
+         PathFindOnPath.call(file, dirs)
+      end
+
+      def PathFindSuffixArray(path, suffix_array, suffix_size)
+         PathFindSuffixArray.call(path, suffix_array, suffix_size)
+      end
+
+      def PathGetArgs(path)
+         PathGetArgs.call(path)
+      end
+
+      def PathGetCharType(char)
+         PathGetCharType.call(char)
+      end
+
+      def PathGetDriveNumber(path)
+         PathGetDriveNumber.call(path)
+      end
+
+      def PathIsContentType(path, content_type)
+         PathIsContentType.call(path, content_type) > 0
+      end
+
+      def PathIsDirectory(path)
+         PathIsDirectory.call(path) > 0
+      end
+
+      def PathIsDirectoryEmpty(path)
+         PathIsDirectoryEmpty.call(path) > 0
+      end
+
+      def PathIsFileSpec(path)
+         PathIsFileSpec.call(path) > 0
+      end
+
+      # This appears to be broken with the current MSVC distro.  Use
+      # PathIsContentType instead.
+      #def PathIsHTMLFile(path)
+      #   PathIsHTMLFile.call(path)
+      #end
+
+      def PathIsLFNFileSpec(path)
+         PathIsLFNFileSpec.call(path) > 0
+      end
+
+      def PathIsNetworkPath(path)
+         PathIsNetworkPath.call(path) > 0
+      end
+
+      def PathIsPrefix(prefix, path)
+         PathIsPrefix.call(prefix, path) > 0
+      end
+
+      def PathIsRelative(path)
+         PathIsRelative.call(path) > 0
+      end
+
+      def PathIsRoot(path)
+         PathIsRoot.call(path) > 0
+      end
+
+      def PathIsSameRoot(path1, path2)
+         PathIsSameRoot.call(path1, path2) > 0
+      end
+
+      def PathIsSystemFolder(path)
+         PathIsSystemFolder.call(path) > 0
+      end
+
+      def PathIsUNC(path)
+         PathIsUNC.call(path) > 0
+      end
+
+      def PathIsUNCServer(path)
+         PathIsUNCServer.call(path) > 0
+      end
+
+      def PathIsUNCServerShare(path)
+         PathIsUNCServerShare.call(path) > 0
+      end
+
+      def PathIsURL(path)
+         PathIsURL.call(path) > 0
+      end
+
+      def PathMakePretty(path)
+         PathMakePretty.call(path) > 0
+      end
+
+      def PathMakeSystemFolder(path)
+         PathMakeSystemFolder.call(path) > 0
+      end
+
+      def PathMatchSpec(path, spec)
+         PathMatchSpec.call(path, spec) > 0
+      end
+
+      def PathParseIconLocation(path)
+         PathParseIconLocation.call(path)
+      end
+
+      def PathQuoteSpaces(path)
+         PathQuoteSpaces.call(path)
+      end
+
+      def PathRelativePathTo(path, from, from_attr, to, to_attr)
+         PathRelativePathTo.call(path, from, from_attr, to, to_attr) > 0
+      end
+
+      def PathRemoveArgs(path)
+         PathRemoveArgs.call(path)
+      end
+
+      def PathRemoveBackslash(path)
+         PathRemoveBackslash.call(path)
+      end
+
+      def PathRemoveBlanks(path)
+         PathRemoveBlanks.call(path)
+      end
+
+      def PathRemoveExtension(path)
+         PathRemoveExtension.call(path)
+      end
+
+      def PathRemoveFileSpec(path)
+         PathRemoveFileSpec.call(path) > 0
+      end
+
+      def PathRenameExtension(path, ext)
+         PathRenameExtension.call(path, ext) > 0
+      end
+      
+      def PathSearchAndQualify(path, full_path, full_path_size)
+         PathSearchAndQualify.call(path, full_path, full_path_size) > 0
+      end
+      
+      def PathSetDlgItemPath(handle, id, path)
+         PathSetDlgItemPath.call(handle, id, path)
+      end
+      
+      def PathSkipRoot(path)
+         PathSkipRoot.call(path)
+      end
+      
+      def PathStripPath(path)
+         PathStripPath.call(path)
+      end
+      
+      def PathStripToRoot(path)
+         PathStripToRoot.call(path) > 0
+      end
+      
+      def PathUndecorate(path)
+         PathUndecorate.call(path)
+      end
+      
+      def PathUnExpandEnvStrings(path, buf, buf_size)
+         PathUnExpandEnvStrings.call(path, buf, buf_size) > 0
+      end
+      
+      def PathUnmakeSystemFolder(path)
+         PathUnmakeSystemFolder.call(path) > 0
+      end 
+      
+      def PathUnquoteSpaces(path)
+         PathUnquoteSpaces.call(path)
+      end
+   end
+end

data/lib/windows/security.rb

@@ -0,0 +1,89 @@
+require 'Win32API'
+
+module Windows
+   module Security
+      ACL_REVISION                   = 2
+      ACL_REVISION2                  = 2
+      ACL_REVISION3                  = 3
+      ACL_REVISION4                  = 4
+      ALLOW_ACE_LENGTH               = 62
+      DACL_SECURITY_INFORMATION      = 4
+      SE_DACL_PRESENT                = 4
+      SECURITY_DESCRIPTOR_MIN_LENGTH = 20
+      SECURITY_DESCRIPTOR_REVISION   = 1
+      
+      GENERIC_RIGHTS_MASK = 4026597376
+      GENERIC_RIGHTS_CHK  = 4026531840
+      REST_RIGHTS_MASK    = 2097151
+      
+      AddAce          = Win32API.new('advapi32', 'AddAce', 'PLLLL', 'I')
+      CopySid         = Win32API.new('advapi32', 'CopySid', 'LLP', 'I')
+      GetAce          = Win32API.new('advapi32', 'GetAce', 'LLP', 'I')
+      GetFileSecurity = Win32API.new('advapi32', 'GetFileSecurity', 'PLPLP', 'I')      
+      GetLengthSid    = Win32API.new('advapi32', 'GetLengthSid', 'P', 'L')  
+       
+      GetSecurityDescriptorControl = Win32API.new('advapi32', 'GetSecurityDescriptorControl', 'PPP', 'I')
+      GetSecurityDescriptorDacl    = Win32API.new('advapi32', 'GetSecurityDescriptorDacl', 'PPPP', 'I')
+      
+      InitializeAcl                = Win32API.new('advapi32', 'InitializeAcl', 'PLL', 'I')
+      InitializeSecurityDescriptor = Win32API.new('advapi32', 'InitializeSecurityDescriptor', 'PL', 'I')
+        
+      LookupAccountName = Win32API.new('advapi32', 'LookupAccountName', 'PPPPPPP', 'I')
+      LookupAccountSid  = Win32API.new('advapi32', 'LookupAccountSid', 'PLPPPPP', 'I')
+          
+      SetFileSecurity           = Win32API.new('advapi32', 'SetFileSecurity', 'PPP', 'I') 
+      SetSecurityDescriptorDacl = Win32API.new('advapi32', 'SetSecurityDescriptorDacl', 'PIPI', 'I')
+      
+      def AddAce(acl, rev, index, list, length)
+         AddAce.call(acl, rev, index, list, length) != 0
+      end
+      
+      def CopySid(sid_length, sid_buf, sid_source)
+         CopySid.call(sid_length, sid_buf, sid_source) != 0
+      end
+      
+      def GetAce(acl, index, ace)
+         GetAce.call(acl, index, ace) != 0
+      end
+
+      def GetFileSecurity(file, info, descriptor, length, nlength)
+         GetFileSecurity.call(file, info, descriptor, length, nlength) != 0
+      end
+
+      def GetLengthSid(sid)
+         GetLengthSid.call(sid)
+      end
+      
+      def GetSecurityDescriptorControl(descriptor, control, revision)
+         GetSecurityDescriptorControl.call(descriptor, control, revision) != 0
+      end
+
+      def GetSecurityDescriptorDacl(descriptor, dacl_present, dacl, default)
+         GetSecurityDescriptorDacl.call(descriptor, dacl_present, dacl, default) != 0
+      end
+      
+      def InitializeAcl(acl, length, revision = ACL_REVISION)
+         InitializeAcl.call(acl, length, revision) != 0
+      end
+
+      def InitializeSecurityDescriptor(descriptor, revision = SECURITY_DESCRIPTOR_REVISION)
+         InitializeSecurityDescriptor.call(descriptor, revision) != 0
+      end
+
+      def LookupAccountName(sys, name, sid, sid_size, domain, domain_size, use)
+         LookupAccountName.call(sys, name, sid, sid_size, domain, domain_size, use) != 0
+      end
+
+      def LookupAccountSid(sys, sid, name, name_size, domain, domain_size, use)
+         LookupAccountSid.call(sys, sid, name, name_size, domain, domain_size, use) != 0
+      end
+
+      def SetFileSecurity(file, info, descriptor)
+         SetFileSecurity.call(file, info, descriptor) != 0
+      end
+
+      def SetSecurityDescriptorDacl(descriptor, present, dacl, default)
+         SetSecurityDescriptorDacl.call(descriptor, present, dacl, default) != 0
+      end
+   end
+end

data/lib/windows/sound.rb

@@ -0,0 +1,52 @@
+##############################################################################
+# sound.rb
+#
+# Includes the following functions:
+#
+# Beep()
+# PlaySound()
+# WaveOutSetVolume()
+# WaveOutGetVolume()
+#
+# Defines the following constants:
+# 
+# SND_APPLICATION
+# SND_ALIAS
+# SND_ALIAS_ID
+# SND_ASYNC
+# SND_FILENAME
+# SND_LOOP
+# SND_MEMORY
+# SND_NODEFAULT
+# SND_NOSTOP
+# SND_NOWAIT
+# SND_PURGE
+# SND_RESOURCE
+# SND_SYNC
+##############################################################################
+require 'Win32API'
+
+module Windows  
+   module Sound
+      SND_SYNC          = 0x0000  # play synchronously (default)
+      SND_ASYNC         = 0x0001  # play asynchronously
+      SND_NODEFAULT     = 0x0002  # silence (!default) if sound not found
+      SND_MEMORY        = 0x0004  # pszSound points to a memory file
+      SND_LOOP          = 0x0008  # loop the sound until next sndPlaySound
+      SND_NOSTOP        = 0x0010  # don't stop any currently playing sound 
+
+      SND_NOWAIT        = 8192    # don't wait if the driver is busy
+      SND_ALIAS         = 65536   # name is a registry alias
+      SND_ALIAS_ID      = 1114112 # alias is a predefined ID
+      SND_FILENAME      = 131072  # name is file name
+      SND_RESOURCE      = 262148  # name is resource name or atom
+
+      SND_PURGE         = 0x0040  # purge non-static events for task
+      SND_APPLICATION   = 0x0080  # look for application specific association
+      
+      Beep             = Win32API.new('kernel32', 'Beep', 'LL', 'I')
+      PlaySound        = Win32API.new('winmm', 'PlaySound', 'PPL', 'I')
+      WaveOutSetVolume = Win32API.new('winmm', 'waveOutSetVolume', 'PL', 'I')
+      WaveOutGetVolume = Win32API.new('winmm', 'waveOutGetVolume', 'IP', 'I')
+   end
+end