windows-pr 0.2.0 → 0.5.3

data/lib/windows/eventlog.rb

@@ -0,0 +1,120 @@
+require 'Win32API'
+
+module Windows
+   module EventLog
+      EVENTLOG_SEQUENTIAL_READ = 0x0001
+      EVENTLOG_SEEK_READ       = 0x0002
+      EVENTLOG_FORWARDS_READ   = 0x0004
+      EVENTLOG_BACKWARDS_READ  = 0x0008
+
+      EVENTLOG_SUCCESS          = 0x0000
+      EVENTLOG_ERROR_TYPE       = 0x0001
+      EVENTLOG_WARNING_TYPE     = 0x0002
+      EVENTLOG_INFORMATION_TYPE = 0x0004
+      EVENTLOG_AUDIT_SUCCESS    = 0x0008
+      EVENTLOG_AUDIT_FAILURE    = 0x0010
+      
+      EVENTLOG_FULL_INFO = 0
+
+      BackupEventLog             = Win32API.new('advapi32', 'BackupEventLog', 'LP', 'I')
+      BackupEventLogW            = Win32API.new('advapi32', 'BackupEventLogW', 'LP', 'I')
+      ClearEventLog              = Win32API.new('advapi32', 'ClearEventLog', 'LP', 'I')
+      ClearEventLogW             = Win32API.new('advapi32', 'ClearEventLogW', 'LP', 'I')
+      CloseEventLog              = Win32API.new('advapi32', 'CloseEventLog', 'L', 'I')
+      DeregisterEventSource      = Win32API.new('advapi32', 'DeregisterEventSource', 'L', 'I')
+      GetEventLogInformation     = Win32API.new('advapi32', 'GetEventLogInformation', 'LLPLP', 'I')
+      GetNumberOfEventLogRecords = Win32API.new('advapi32', 'GetNumberOfEventLogRecords', 'LP', 'I')
+      GetOldestEventLogRecord    = Win32API.new('advapi32', 'GetOldestEventLogRecord', 'LP', 'I')
+      NotifyChangeEventLog       = Win32API.new('advapi32', 'NotifyChangeEventLog', 'LL', 'I')
+      OpenBackupEventLog         = Win32API.new('advapi32', 'OpenBackupEventLog', 'PP', 'L')
+      OpenBackupEventLogW        = Win32API.new('advapi32', 'OpenBackupEventLogW', 'PP', 'L')
+      OpenEventLog               = Win32API.new('advapi32', 'OpenEventLog', 'PP', 'L')
+      OpenEventLogW              = Win32API.new('advapi32', 'OpenEventLogW', 'PP', 'L')
+      ReadEventLog               = Win32API.new('advapi32', 'ReadEventLog', 'LLLPLPP', 'I')
+      ReadEventLogW              = Win32API.new('advapi32', 'ReadEventLogW', 'LLLPLPP', 'I')
+      RegisterEventSource        = Win32API.new('advapi32', 'RegisterEventSource', 'PP', 'L')
+      RegisterEventSourceW       = Win32API.new('advapi32', 'RegisterEventSourceW', 'PP', 'L')
+      ReportEvent                = Win32API.new('advapi32', 'ReportEvent', 'LIILPILPP', 'I')
+      ReportEventW               = Win32API.new('advapi32', 'ReportEventW', 'LIILPILPP', 'I')
+
+      def BackupEventLog(handle, file)
+         BackupEventLog.call(handle, file) != 0
+      end
+
+      def BackupEventLogW(handle, file)
+         BackupEventLogW.call(handle, file) != 0
+      end
+
+      def ClearEventLog(handle, file = 0)
+         ClearEventLog.call(handle, file) != 0
+      end
+
+      def ClearEventLogW(handle, file = 0)
+         ClearEventLogW.call(handle, file) != 0
+      end
+
+      def CloseEventLog(handle)
+         CloseEventLog.call(handle) != 0
+      end
+
+      def DeregisterEventSource(handle)
+         DeregisterEventSource.call(handle) != 0
+      end
+
+      def GetEventLogInformation(handle, level, buf, buf_size, bytes)
+         GetEventLogInformation.call(handle, level, buf, buf_size, bytes) != 0
+      end
+
+      def GetNumberOfEventLogRecords(handle, num)
+         GetNumberOfEventLogRecords.call(handle, num) != 0
+      end
+      
+      def GetOldestEventLogRecord(handle, rec)
+         GetOldestEventLogRecord.call(handle, rec) != 0
+      end
+
+      def NotifyChangeEventLog(handle, event)
+         NotifyChangeEventLog.call(handle, event) != 0
+      end
+
+      def OpenBackupEventLog(server, file)
+         OpenBackupEventLog.call(server, file)
+      end
+
+      def OpenBackupEventLogW(server, file)
+         OpenBackupEventLogW.call(server, file)
+      end
+
+      def OpenEventLog(server, source)
+         OpenEventLog.call(server, source)
+      end
+
+      def OpenEventLogW(server, source)
+         OpenEventLogW.call(server, source)
+      end
+
+      def ReadEventLog(handle, flags, offset, buf, bytes, bytes_read, min_bytes)
+         ReadEventLog.call(handle, flags, offset, buf, bytes, bytes_read, min_bytes) != 0
+      end
+
+      def ReadEventLogW(handle, flags, offset, buf, bytes, bytes_read, min_bytes)
+         ReadEventLogW.call(handle, flags, offset, buf, bytes, bytes_read, min_bytes) != 0
+      end
+
+      def RegisterEventSource(server, source)
+         RegisterEventSource.call(server, source)
+      end
+
+      def RegisterEventSourceW(server, source)
+         RegisterEventSourceW.call(server, source)
+      end
+
+      def ReportEvent(handle, type, cat, id, sid, num, size, strings, raw)
+         ReportEvent.call(handle, type, cat, id, sid, num, size, strings, raw) != 0
+      end
+
+      def ReportEventW(handle, type, cat, id, sid, num, size, strings, raw)
+         ReportEventW.call(handle, type, cat, id, sid, num, size, strings, raw) != 0
+      end
+   end
+end

data/lib/windows/file.rb

@@ -1,36 +1,4 @@
-######################################################################
-# file.rb
-#
-# Defines the following functions:
-#
-# CopyFile()
-# CopyFileEx()
-# CreateFile()
-# CreateHardLink()
-# DecryptFile()
-# DeleteFile()
-# EncryptFile()
-# GetFileAttributes()
-# GetFileAttributesEx()
-# GetFileSize()
-# GetFileSizeEx()
-# GetFileType()
-# LockFile()
-# LockFileEx()
-# ReadFile()
-# ReadFileEx()
-# ReOpenFile()
-# SetFileAttributes()
-# UnlockFile()
-# UnlockFileEx()
-# WriteFile()
-# WriteFileEx()
-#
-# TODO:
-#
-# Add remaining file functions.
-######################################################################
-require 'Win32API'
+require 'windows/unicode'
 
 module Windows
    module File
@@ -169,6 +137,40 @@ 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
+      SECTION_MAP_READ    = 0x0004
+      SECTION_MAP_EXECUTE = 0x0008
+      SECTION_EXTEND_SIZE = 0x0010
+
+      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
@@ -178,10 +180,16 @@ module Windows
       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')
@@ -189,9 +197,18 @@ module Windows
       GetFileSize         = Win32API.new('kernel32', 'GetFileSize', 'LP', 'L')
       GetFileSizeEx       = Win32API.new('kernel32', 'GetFileSizeEx', 'LP', 'L')
       GetFileType         = Win32API.new('kernel32', 'GetFileType', 'L', 'L')
+      GetFullPathName     = Win32API.new('kernel32', 'GetFullPathName', 'PLPP', 'L')
+      GetFullPathNameW    = Win32API.new('kernel32', 'GetFullPathNameW', 'PLPP', 'L')
+      GetLongPathName     = Win32API.new('kernel32', 'GetLongPathName', 'PPL', 'L')
+      GetShortPathName    = Win32API.new('kernel32', 'GetShortPathName', 'PPL', 'L')
 
       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')
 
@@ -199,6 +216,9 @@ 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')
 
@@ -214,6 +234,10 @@ 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
@@ -229,6 +253,10 @@ 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
@@ -253,6 +281,18 @@ module Windows
       def GetFileType(handle)
          GetFileType.call(handle)
       end
+      
+      def GetFullPathName(file, buf, buf_size, part)
+         GetFullPathName.call(file, buf, buf_size, part)
+      end
+      
+      def GetLongPathName(short, buf, buf_size)
+         GetLongPathName.call(short, buf, buf_size)
+      end
+      
+      def GetShortPathName(long, buf, buf_size)
+         GetShortPathName.call(long, buf, buf_size)
+      end
 
       def LockFile(handle, off_low, off_high, lock_low, lock_high)
          LockFile.call(handle, off_low, off_high, lock_low, lock_high) > 0
@@ -262,6 +302,18 @@ 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
@@ -282,6 +334,10 @@ 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/handle.rb

@@ -1,19 +1,3 @@
-#####################################################################
-# handle.rb
-#
-# Defines the following functions:
-#
-# CloseHandle()
-# DuplicateHandle()
-# GetHandleInformation()
-# SetHandleInformation()
-#
-# Defines the following constants
-#
-# INVALID_HANDLE_VALUE
-# HANDLE_FLAG_INHERIT
-# HANDLE_FLAG_PROTECT_FROM_CLOSE
-######################################################################
 require 'Win32API'
 
 module Windows

data/lib/windows/library.rb

@@ -0,0 +1,76 @@
+require 'Win32API'
+
+module Windows
+   module Library
+      DLL_PROCESS_DETACH = 0
+      DLL_PROCESS_ATTACH = 1
+      DLL_THREAD_ATTACH  = 2
+      DLL_THREAD_DETACH  = 3
+          
+      GET_MODULE_HANDLE_EX_FLAG_PIN                = 1
+      GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT = 2
+      GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS       = 4
+      
+      DONT_RESOLVE_DLL_REFERENCES   = 0x00000001
+      LOAD_LIBRARY_AS_DATAFILE      = 0x00000002
+      LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008
+      LOAD_IGNORE_CODE_AUTHZ_LEVEL  = 0x00000010
+            
+      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')
+      GetModuleFileName         = Win32API.new('kernel32', 'GetModuleFileName', 'LPL', 'L')
+      GetModuleHandle           = Win32API.new('kernel32', 'GetModuleHandle', 'P', 'L')
+      GetModuleHandleEx         = Win32API.new('kernel32', 'GetModuleHandleEx', 'LPP', 'I')
+      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')
+      
+      def DisableThreadLibraryCalls(hmodule)
+         DisableThreadLibraryCalls.call(hmodule) != 0
+      end
+      
+      def FreeLibrary(hmodule)
+         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
+      
+      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
+      
+      def LoadLibrary(library)
+         LoadLibrary.call(library)
+      end
+      
+      def LoadLibraryEx(library, file, flags)
+         LoadLibraryEx.call(library, file, flags)
+      end
+      
+      def LoadModule(hmodule, param_block)
+         LoadModule.call(hmodule, param_block)
+      end
+      
+      def SetDllDirectory(path)
+         SetDllDirectory.call(path)
+      end
+   end
+end

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

@@ -1,28 +1,3 @@
-######################################################################
-# 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
@@ -34,25 +9,31 @@ module Windows
       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')
+      GlobalLock           = Win32API.new('kernel32', 'GlobalLock', 'L', 'L')
       GlobalMemoryStatus   = Win32API.new('kernel32', 'GlobalMemoryStatus', 'P', 'V')
-      GlobalMemoryStatusEx = Win32API.new('kernel32', 'GlobalMemoryStatus', 'P', 'V')
+      GlobalMemoryStatusEx = Win32API.new('kernel32', 'GlobalMemoryStatusEx', 'P', 'V')
       GlobalReAlloc        = Win32API.new('kernel32', 'GlobalReAlloc', 'III', 'I')
       GlobalSize           = Win32API.new('kernel32', 'GlobalSize', 'I', 'I')
       GlobalUnlock         = Win32API.new('kernel32', 'GlobalUnlock', 'I', 'I')
+      VirtualAlloc         = Win32API.new('kernel32', 'VirtualAlloc', 'PLLL', 'P')
+      VirtualAllocEx       = Win32API.new('kernel32', 'VirtualAllocEx', 'LPLLL', 'P')
+      VirtualFree          = Win32API.new('kernel32', 'VirtualFree', 'PLL', 'I')
+      VirtualFreeEx        = Win32API.new('kernel32', 'VirtualFreeEx', 'LPLL', 'I')
+      VirtualLock          = Win32API.new('kernel32', 'VirtualLock', 'PL', 'I')
+      VirtualProtect       = Win32API.new('kernel32', 'VirtualProtect', 'PLLP', 'I')
+      VirtualProtectEx     = Win32API.new('kernel32', 'VirtualProtectEx', 'LPLLP', 'I')
+      VirtualQuery         = Win32API.new('kernel32', 'VirtualQuery', 'PPL', 'L')
+      VirtualQueryEx       = Win32API.new('kernel32', 'VirtualQueryEx', 'LPPL', 'L')
+      VirtualUnlock        = Win32API.new('kernel32', 'VirtualUnlock', 'PL', 'I')
+      ZeroMemory           = Win32API.new('kernel32', 'RtlZeroMemory', 'PL', 'I')
 
       def GlobalAlloc(flags, bytes)
          GlobalAlloc.call(flags, bytes)
       end
 
-      def GlobalDiscard(handle)
-         GlobalDiscard.call(handle)
-      end
-
       def GlobalFlags(handle)
          GlobalFlags.call(handle)
       end
@@ -66,7 +47,7 @@ module Windows
       end
 
       def GlobalLock(handle)
-         GlobalHandle.call(handle)
+         GlobalLock.call(handle)
       end
 
       def GlobalMemoryStatus(buf)
@@ -88,5 +69,49 @@ module Windows
       def GlobalUnlock(handle)
          GlobalUnlock.call(handle)
       end
+
+      def VirtualAlloc(address, size, alloc_type, protect)
+         VirtualAlloc.call(address, size, alloc_type, protect)
+      end
+
+      def VirtualAllocEx(handle, address, size, alloc_type, protect)
+         VirtualAllocEx.call(handle, address, size, alloc_type, protect)
+      end
+
+      def VirtualFree(address, size, free_type)
+         VirtualFree.call(address, size, free_type) != 0
+      end
+
+      def VirtualFreeEx(handle, address, size, free_type)
+         VirtualFreeEx.call(handle, address, size, free_type) != 0
+      end
+
+      def VirtualLock(address, size)
+         VirtualLock.call(address, size) != 0
+      end
+
+      def VirtualProtect(address, size, new_protect, old_protect)
+         VirtualProtect.call(address, size, new_protect, old_protect) != 0
+      end
+
+      def VirtualProtectEx(handle, address, size, new_protect, old_protect)
+         VirtualProtect.call(handle, address, size, new_protect, old_protect) != 0
+      end
+
+      def VirtualQuery(address, buffer, length)
+         VirtualQuery.call(address, buffer, length)
+      end
+      
+      def VirtualQueryEx(handle, address, buffer, length)
+         VirtualQueryEx.call(handle, address, buffer, length)
+      end
+
+      def VirtualUnlock(address, size)
+         VirtualUnlock.call(address, size) != 0
+      end
+
+      def ZeroMemory(dest, length)
+         ZeroMemory.call(dest, length)
+      end
    end
 end