开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
JwaPatchApi.pas
资源名称：win32api.zip　[点击查看]
上传用户：davidchvip
上传日期：2009-07-28
资源大小：1749k
文件大小：36k
源码类别：

Windows编程

开发平台：

Delphi

JwaPatchApi.pas：源码内容
  1. {******************************************************************************}
  2. {                                                                       }
  3. { Creating and applying patches to filesAPI interface Unit for Object Pascal   }
  4. {                                                                       }
  5. { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft          }
  6. { Corporation. All Rights Reserved.                                            }
  7. {                 }
  8. { The original file is: patchapi.h, released August 2001. The original Pascal  }
  9. { code is: PatchApi.pas, released December 2001. The initial developer of the  }
  10. { Pascal code is Marcel van Brakel (brakelm@chello.nl).                        }
  11. {                                                                              }
  12. { Portions created by Marcel van Brakel are Copyright (C) 1999-2001            }
  13. { Marcel van Brakel. All Rights Reserved.                                      }
  14. {                 }
  15. { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI)        }
  16. {                }
  17. { You may retrieve the latest version of this file at the Project JEDI home    }
  18. { page, located at http://delphi-jedi.org or my personal homepage located at   }
  19. { http://members.chello.nl/m.vanbrakel2                                        }
  20. {                }
  21. { The contents of this file are used with permission, subject to the Mozilla   }
  22. { Public License Version 1.1 (the "License"); you may not use this file except }
  23. { in compliance with the License. You may obtain a copy of the License at      }
  24. { http://www.mozilla.org/MPL/MPL-1.1.html                                      }
  25. {                                                                              }
  26. { Software distributed under the License is distributed on an "AS IS" basis,   }
  27. { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
  28. { the specific language governing rights and limitations under the License.    }
  29. {                                                                              }
  30. { Alternatively, the contents of this file may be used under the terms of the  }
  31. { GNU Lesser General Public License (the  "LGPL License"), in which case the   }
  32. { provisions of the LGPL License are applicable instead of those above.        }
  33. { If you wish to allow use of your version of this file only under the terms   }
  34. { of the LGPL License and not to allow others to use your version of this file }
  35. { under the MPL, indicate your decision by deleting  the provisions above and  }
  36. { replace  them with the notice and other provisions required by the LGPL      }
  37. { License.  If you do not delete the provisions above, a recipient may use     }
  38. { your version of this file under either the MPL or the LGPL License.          }
  39. {                 }
  40. { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
  41. {                 }
  42. {******************************************************************************}
  44. unit JwaPatchApi;
  46. {$WEAKPACKAGEUNIT}
  48. {$HPPEMIT ''}
  49. {$HPPEMIT '#include "patchapi.h"'}
  50. {$HPPEMIT ''}
  52. {$I WINDEFINES.INC}
  54. interface
  56. uses
  57.   JwaWinType;
  59. //
  60. //  The following constants can be combined and used as the OptionFlags
  61. //  parameter in the patch creation apis.
  62. //
  64. const
  65.   PATCH_OPTION_USE_BEST = $00000000; // auto choose best (slower)
  66.   {$EXTERNALSYM PATCH_OPTION_USE_BEST}
  68.   PATCH_OPTION_USE_LZX_BEST  = $00000003; // auto choose best of LZX
  69.   {$EXTERNALSYM PATCH_OPTION_USE_LZX_BEST}
  70.   PATCH_OPTION_USE_LZX_A     = $00000001; // normal
  71.   {$EXTERNALSYM PATCH_OPTION_USE_LZX_A}
  72.   PATCH_OPTION_USE_LZX_B     = $00000002; // better on some x86 binaries
  73.   {$EXTERNALSYM PATCH_OPTION_USE_LZX_B}
  74.   PATCH_OPTION_USE_LZX_LARGE = $00000004; // better support for files >8MB
  75.   {$EXTERNALSYM PATCH_OPTION_USE_LZX_LARGE}
  77.   PATCH_OPTION_NO_BINDFIX        = $00010000; // PE bound imports
  78.   {$EXTERNALSYM PATCH_OPTION_NO_BINDFIX}
  79.   PATCH_OPTION_NO_LOCKFIX        = $00020000; // PE smashed locks
  80.   {$EXTERNALSYM PATCH_OPTION_NO_LOCKFIX}
  81.   PATCH_OPTION_NO_REBASE         = $00040000; // PE rebased image
  82.   {$EXTERNALSYM PATCH_OPTION_NO_REBASE}
  83.   PATCH_OPTION_FAIL_IF_SAME_FILE = $00080000; // don't create if same
  84.   {$EXTERNALSYM PATCH_OPTION_FAIL_IF_SAME_FILE}
  85.   PATCH_OPTION_FAIL_IF_BIGGER    = $00100000; // fail if patch is larger than simply compressing new file (slower)
  86.   {$EXTERNALSYM PATCH_OPTION_FAIL_IF_BIGGER}
  87.   PATCH_OPTION_NO_CHECKSUM       = $00200000; // PE checksum zero
  88.   {$EXTERNALSYM PATCH_OPTION_NO_CHECKSUM}
  89.   PATCH_OPTION_NO_RESTIMEFIX     = $00400000; // PE resource timestamps
  90.   {$EXTERNALSYM PATCH_OPTION_NO_RESTIMEFIX}
  91.   PATCH_OPTION_NO_TIMESTAMP      = $00800000; // don't store new file timestamp in patch
  92.   {$EXTERNALSYM PATCH_OPTION_NO_TIMESTAMP}
  93.   PATCH_OPTION_SIGNATURE_MD5     = $01000000; // use MD5 instead of CRC32
  94.   {$EXTERNALSYM PATCH_OPTION_SIGNATURE_MD5}
  95.   PATCH_OPTION_RESERVED1         = DWORD($80000000); // (used internally)
  96.   {$EXTERNALSYM PATCH_OPTION_RESERVED1}
  98.   PATCH_OPTION_VALID_FLAGS = DWORD($80FF0007);
  99.   {$EXTERNALSYM PATCH_OPTION_VALID_FLAGS}
  101.   PATCH_SYMBOL_NO_IMAGEHLP     = $00000001; // don't use imagehlp.dll
  102.   {$EXTERNALSYM PATCH_SYMBOL_NO_IMAGEHLP}
  103.   PATCH_SYMBOL_NO_FAILURES     = $00000002; // don't fail patch due to imagehlp failures
  104.   {$EXTERNALSYM PATCH_SYMBOL_NO_FAILURES}
  105.   PATCH_SYMBOL_UNDECORATED_TOO = $00000004; // after matching decorated symbols, try to match remaining by undecorated names
  106.   {$EXTERNALSYM PATCH_SYMBOL_UNDECORATED_TOO}
  107.   PATCH_SYMBOL_RESERVED1       = DWORD($80000000); // (used internally)
  108.   {$EXTERNALSYM PATCH_SYMBOL_RESERVED1}
  110. //
  111. //  The following constants can be combined and used as the ApplyOptionFlags
  112. //  parameter in the patch apply and test apis.
  113. //
  115.   APPLY_OPTION_FAIL_IF_EXACT = $00000001; // don't copy new file
  116.   {$EXTERNALSYM APPLY_OPTION_FAIL_IF_EXACT}
  117.   APPLY_OPTION_FAIL_IF_CLOSE = $00000002; // differ by rebase, bind
  118.   {$EXTERNALSYM APPLY_OPTION_FAIL_IF_CLOSE}
  119.   APPLY_OPTION_TEST_ONLY     = $00000004; // don't create new file
  120.   {$EXTERNALSYM APPLY_OPTION_TEST_ONLY}
  121.   APPLY_OPTION_VALID_FLAGS   = $00000007;
  122.   {$EXTERNALSYM APPLY_OPTION_VALID_FLAGS}
  124. //
  125. //  In addition to standard Win32 error codes, the following error codes may
  126. //  be returned via GetLastError() when one of the patch APIs fails.
  127. //
  129.   ERROR_PATCH_ENCODE_FAILURE         = DWORD($C00E3101); // create
  130.   {$EXTERNALSYM ERROR_PATCH_ENCODE_FAILURE}
  131.   ERROR_PATCH_INVALID_OPTIONS        = DWORD($C00E3102); // create
  132.   {$EXTERNALSYM ERROR_PATCH_INVALID_OPTIONS}
  133.   ERROR_PATCH_SAME_FILE              = DWORD($C00E3103); // create
  134.   {$EXTERNALSYM ERROR_PATCH_SAME_FILE}
  135.   ERROR_PATCH_RETAIN_RANGES_DIFFER   = DWORD($C00E3104); // create
  136.   {$EXTERNALSYM ERROR_PATCH_RETAIN_RANGES_DIFFER}
  137.   ERROR_PATCH_BIGGER_THAN_COMPRESSED = DWORD($C00E3105); // create
  138.   {$EXTERNALSYM ERROR_PATCH_BIGGER_THAN_COMPRESSED}
  139.   ERROR_PATCH_IMAGEHLP_FAILURE       = DWORD($C00E3106); // create
  140.   {$EXTERNALSYM ERROR_PATCH_IMAGEHLP_FAILURE}
  142.   ERROR_PATCH_DECODE_FAILURE = DWORD($C00E4101); // apply
  143.   {$EXTERNALSYM ERROR_PATCH_DECODE_FAILURE}
  144.   ERROR_PATCH_CORRUPT        = DWORD($C00E4102); // apply
  145.   {$EXTERNALSYM ERROR_PATCH_CORRUPT}
  146.   ERROR_PATCH_NEWER_FORMAT   = DWORD($C00E4103); // apply
  147.   {$EXTERNALSYM ERROR_PATCH_NEWER_FORMAT}
  148.   ERROR_PATCH_WRONG_FILE     = DWORD($C00E4104); // apply
  149.   {$EXTERNALSYM ERROR_PATCH_WRONG_FILE}
  150.   ERROR_PATCH_NOT_NECESSARY  = DWORD($C00E4105); // apply
  151.   {$EXTERNALSYM ERROR_PATCH_NOT_NECESSARY}
  152.   ERROR_PATCH_NOT_AVAILABLE  = DWORD($C00E4106); // apply
  153.   {$EXTERNALSYM ERROR_PATCH_NOT_AVAILABLE}
  155. type
  156.   PATCH_PROGRESS_CALLBACK = function (CallbackContext: PVOID; CurrentPosition, MaximumPosition: ULONG): BOOL; stdcall;
  157.   {$EXTERNALSYM PATCH_PROGRESS_CALLBACK}
  158.   TPatchProgressCallback = PATCH_PROGRESS_CALLBACK;
  161.   PPATCH_PROGRESS_CALLBACK = ^PATCH_PROGRESS_CALLBACK;
  162.   {$EXTERNALSYM PPATCH_PROGRESS_CALLBACK}
  163.   PPatchProgressCallback = PPATCH_PROGRESS_CALLBACK;
  165.   PATCH_SYMLOAD_CALLBACK = function (WhichFile: ULONG; SymbolFileName: LPCSTR; SymType, SymbolFileCheckSum,
  166.     SymbolFileTimeDate, ImageFileCheckSum, ImageFileTimeDate: ULONG; CallbackContext: PVOID): BOOL; stdcall;
  167.   {$EXTERNALSYM PATCH_SYMLOAD_CALLBACK}
  168.   TPatchSymLoadCallback = PATCH_SYMLOAD_CALLBACK;
  170.   PPATCH_SYMLOAD_CALLBACK = ^PATCH_SYMLOAD_CALLBACK;
  171.   {$EXTERNALSYM PPATCH_SYMLOAD_CALLBACK}
  172.   PPatchSymLoadCallback = PPATCH_SYMLOAD_CALLBACK;
  174.   PPATCH_IGNORE_RANGE = ^PATCH_IGNORE_RANGE;
  175.   {$EXTERNALSYM PPATCH_IGNORE_RANGE}
  176.   _PATCH_IGNORE_RANGE = record
  177.     OffsetInOldFile: ULONG;
  178.     LengthInBytes: ULONG;
  179.   end;
  180.   {$EXTERNALSYM _PATCH_IGNORE_RANGE}
  181.   PATCH_IGNORE_RANGE = _PATCH_IGNORE_RANGE;
  182.   {$EXTERNALSYM PATCH_IGNORE_RANGE}
  183.   TPatchIgnoreRange = PATCH_IGNORE_RANGE;
  184.   PPatchIgnoreRange = PPATCH_IGNORE_RANGE;
  186.   PPATCH_RETAIN_RANGE = ^PATCH_RETAIN_RANGE;
  187.   {$EXTERNALSYM PPATCH_RETAIN_RANGE}
  188.   _PATCH_RETAIN_RANGE = record
  189.     OffsetInOldFile: ULONG;
  190.     LengthInBytes: ULONG;
  191.     OffsetInNewFile: ULONG;
  192.   end;
  193.   {$EXTERNALSYM _PATCH_RETAIN_RANGE}
  194.   PATCH_RETAIN_RANGE = _PATCH_RETAIN_RANGE;
  195.   {$EXTERNALSYM PATCH_RETAIN_RANGE}
  196.   TPatchRetainRange = PATCH_RETAIN_RANGE;
  197.   PPatchRetainRange = PPATCH_RETAIN_RANGE;
  199.   PPATCH_OLD_FILE_INFO_A = ^PATCH_OLD_FILE_INFO_A;
  200.   {$EXTERNALSYM PPATCH_OLD_FILE_INFO_A}
  201.   _PATCH_OLD_FILE_INFO_A = record
  202.     SizeOfThisStruct: ULONG;
  203.     OldFileName: LPCSTR;
  204.     IgnoreRangeCount: ULONG; // maximum 255
  205.     IgnoreRangeArray: PPATCH_IGNORE_RANGE;
  206.     RetainRangeCount: ULONG; // maximum 255
  207.     RetainRangeArray: PPATCH_RETAIN_RANGE;
  208.   end;
  209.   {$EXTERNALSYM _PATCH_OLD_FILE_INFO_A}
  210.   PATCH_OLD_FILE_INFO_A = _PATCH_OLD_FILE_INFO_A;
  211.   {$EXTERNALSYM PATCH_OLD_FILE_INFO_A}
  212.   TPatchOldFileInfoA = PATCH_OLD_FILE_INFO_A;
  213.   PPatchOldFileInfoA = PPATCH_OLD_FILE_INFO_A;
  215.   PPATCH_OLD_FILE_INFO_W = ^PATCH_OLD_FILE_INFO_W;
  216.   {$EXTERNALSYM PPATCH_OLD_FILE_INFO_W}
  217.   _PATCH_OLD_FILE_INFO_W = record
  218.     SizeOfThisStruct: ULONG;
  219.     OldFileName: LPCWSTR;
  220.     IgnoreRangeCount: ULONG; // maximum 255
  221.     IgnoreRangeArray: PPATCH_IGNORE_RANGE;
  222.     RetainRangeCount: ULONG; // maximum 255
  223.     RetainRangeArray: PPATCH_RETAIN_RANGE;
  224.   end;
  225.   {$EXTERNALSYM _PATCH_OLD_FILE_INFO_W}
  226.   PATCH_OLD_FILE_INFO_W = _PATCH_OLD_FILE_INFO_W;
  227.   {$EXTERNALSYM PATCH_OLD_FILE_INFO_W}
  228.   TPatchOldFileInfoW = PATCH_OLD_FILE_INFO_W;
  229.   PPatchOldFileInfoW = PPATCH_OLD_FILE_INFO_W;
  231.   PPATCH_OLD_FILE_INFO_H = ^PATCH_OLD_FILE_INFO_H;
  232.   {$EXTERNALSYM PPATCH_OLD_FILE_INFO_H}
  233.   _PATCH_OLD_FILE_INFO_H = record
  234.     SizeOfThisStruct: ULONG;
  235.     OldFileHandle: HANDLE;
  236.     IgnoreRangeCount: ULONG; // maximum 255
  237.     IgnoreRangeArray: PPATCH_IGNORE_RANGE;
  238.     RetainRangeCount: ULONG; // maximum 255
  239.     RetainRangeArray: PPATCH_RETAIN_RANGE;
  240.   end;
  241.   {$EXTERNALSYM _PATCH_OLD_FILE_INFO_H}
  242.   PATCH_OLD_FILE_INFO_H = _PATCH_OLD_FILE_INFO_H;
  243.   {$EXTERNALSYM PATCH_OLD_FILE_INFO_H}
  244.   TPatchOldFileInfoH = PATCH_OLD_FILE_INFO_H;
  245.   PPatchOldFileInfoH = PPATCH_OLD_FILE_INFO_H;
  247.   PPATCH_OLD_FILE_INFO = ^PATCH_OLD_FILE_INFO;
  248.   {$EXTERNALSYM PPATCH_OLD_FILE_INFO}
  249.   _PATCH_OLD_FILE_INFO = record
  250.     SizeOfThisStruct: ULONG;
  251.     Union: record
  252.     case Integer of
  253.       0: (OldFileNameA: LPCSTR);
  254.       1: (OldFileNameW: LPCWSTR);
  255.       2: (OldFileHandle: HANDLE);
  256.     end;
  257.     IgnoreRangeCount: ULONG; // maximum 255
  258.     IgnoreRangeArray: PPATCH_IGNORE_RANGE;
  259.     RetainRangeCount: ULONG; // maximum 255
  260.     RetainRangeArray: PPATCH_RETAIN_RANGE;
  261.   end;
  262.   {$EXTERNALSYM _PATCH_OLD_FILE_INFO}
  263.   PATCH_OLD_FILE_INFO = _PATCH_OLD_FILE_INFO;
  264.   {$EXTERNALSYM PATCH_OLD_FILE_INFO}
  265.   TPatchOldFileInfo = PATCH_OLD_FILE_INFO;
  266.   PPatchOldFileInfo = PPATCH_OLD_FILE_INFO;
  268.   PPATCH_OPTION_DATA = ^PATCH_OPTION_DATA;
  269.   {$EXTERNALSYM PPATCH_OPTION_DATA}
  270.   _PATCH_OPTION_DATA = record
  271.     SizeOfThisStruct: ULONG;
  272.     SymbolOptionFlags: ULONG; // PATCH_SYMBOL_xxx flags
  273.     NewFileSymbolPath: LPCSTR; // always ANSI, never Unicode
  274.     OldFileSymbolPathArray: ^LPCSTR; // array[ OldFileCount ]
  275.     ExtendedOptionFlags: ULONG;
  276.     SymLoadCallback: PATCH_SYMLOAD_CALLBACK;
  277.     SymLoadContext: PVOID;
  278.   end;
  279.   {$EXTERNALSYM _PATCH_OPTION_DATA}
  280.   PATCH_OPTION_DATA = _PATCH_OPTION_DATA;
  281.   {$EXTERNALSYM PATCH_OPTION_DATA}
  282.   TPatchOptionData = PATCH_OPTION_DATA;
  283.   PPatchOptionData = PPATCH_OPTION_DATA;
  285. //
  286. //  Note that PATCH_OPTION_DATA contains LPCSTR paths, and no LPCWSTR (Unicode)
  287. //  path argument is available, even when used with one of the Unicode APIs
  288. //  such as CreatePatchFileW.  This is because the underlying system services
  289. //  for symbol file handling (IMAGEHLP.DLL) only support ANSI file/path names.
  290. //
  292. //
  293. //  A note about PATCH_RETAIN_RANGE specifiers with multiple old files:
  294. //
  295. //  Each old version file must have the same RetainRangeCount, and the same
  296. //  retain range LengthInBytes and OffsetInNewFile values in the same order.
  297. //  Only the OffsetInOldFile values can differ between old files for retain
  298. //  ranges.
  299. //
  301. //
  302. //  The following prototypes are interface for creating patches from files.
  303. //
  305. function CreatePatchFileA(OldFileName: LPCSTR; NewFileName: LPCSTR; PatchFileName: LPCSTR; OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA): BOOL; stdcall;
  306. {$EXTERNALSYM CreatePatchFileA}
  308. function CreatePatchFileW(OldFileName: LPCWSTR; NewFileName: LPCWSTR; PatchFileName: LPCWSTR; OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA): BOOL; stdcall;
  309. {$EXTERNALSYM CreatePatchFileW}
  311. function CreatePatchFileByHandles(OldFileHandle: HANDLE; NewFileHandle: HANDLE; PatchFileHandle: HANDLE; OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA): BOOL; stdcall;
  312. {$EXTERNALSYM CreatePatchFileByHandles}
  314. function CreatePatchFileExA(OldFileCount: ULONG; OldFileInfoArray: PPATCH_OLD_FILE_INFO_A; NewFileName: LPCSTR; PatchFileName: LPCSTR;
  315.   OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
  316. {$EXTERNALSYM CreatePatchFileExA}
  318. function CreatePatchFileExW(OldFileCount: ULONG; OldFileInfoArray: PPATCH_OLD_FILE_INFO_W; NewFileName: LPCWSTR; PatchFileName: LPCWSTR;
  319.   OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
  320. {$EXTERNALSYM CreatePatchFileExW}
  322. function CreatePatchFileByHandlesEx(OldFileCount: ULONG; OldFileInfoArray: PPATCH_OLD_FILE_INFO_H; NewFileHandle: HANDLE;
  323.   PatchFileHandle: HANDLE; OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
  324. {$EXTERNALSYM CreatePatchFileByHandlesEx}
  326. function ExtractPatchHeaderToFileA(PatchFileName: LPCSTR; PatchHeaderFileName: LPCSTR): BOOL; stdcall;
  327. {$EXTERNALSYM ExtractPatchHeaderToFileA}
  329. function ExtractPatchHeaderToFileW(PatchFileName: LPCWSTR; PatchHeaderFileName: LPCWSTR): BOOL; stdcall;
  330. {$EXTERNALSYM ExtractPatchHeaderToFileW}
  332. function ExtractPatchHeaderToFileByHandles(PatchFileHandle: HANDLE; PatchHeaderFileHandle: HANDLE): BOOL; stdcall;
  333. {$EXTERNALSYM ExtractPatchHeaderToFileByHandles}
  335. //
  336. //  The following prototypes are interface for creating new file from old file
  337. //  and patch file.  Note that it is possible for the TestApply API to succeed
  338. //  but the actual Apply to fail since the TestApply only verifies that the
  339. //  old file has the correct CRC without actually applying the patch.  The
  340. //  TestApply API only requires the patch header portion of the patch file,
  341. //  but its CRC must be fixed up.
  342. //
  344. function TestApplyPatchToFileA(PatchFileName: LPCSTR; OldFileName: LPCSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
  345. {$EXTERNALSYM TestApplyPatchToFileA}
  347. function TestApplyPatchToFileW(PatchFileName: LPCWSTR; OldFileName: LPCWSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
  348. {$EXTERNALSYM TestApplyPatchToFileW}
  350. function TestApplyPatchToFileByHandles(PatchFileHandle: HANDLE; OldFileHandle: HANDLE; ApplyOptionFlags: ULONG): BOOL; stdcall;
  351. {$EXTERNALSYM TestApplyPatchToFileByHandles}
  353. function ApplyPatchToFileA(PatchFileName: LPCSTR; OldFileName: LPCSTR; NewFileName: LPCSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
  354. {$EXTERNALSYM ApplyPatchToFileA}
  356. function ApplyPatchToFileW(PatchFileName: LPCWSTR; OldFileName: LPCWSTR; NewFileName: LPCWSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
  357. {$EXTERNALSYM ApplyPatchToFileW}
  359. function ApplyPatchToFileByHandles(PatchFileHandle: HANDLE; OldFileHandle: HANDLE; NewFileHandle: HANDLE; ApplyOptionFlags: ULONG): BOOL; stdcall;
  360. {$EXTERNALSYM ApplyPatchToFileByHandles}
  362. function ApplyPatchToFileExA(PatchFileName: LPCSTR; OldFileName: LPCSTR; NewFileName: LPCSTR; ApplyOptionFlags: ULONG;
  363.   ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
  364. {$EXTERNALSYM ApplyPatchToFileExA}
  366. function ApplyPatchToFileExW(PatchFileName: LPCWSTR; OldFileName: LPCWSTR; NewFileName: LPCWSTR; ApplyOptionFlags: ULONG;
  367.   ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
  368. {$EXTERNALSYM ApplyPatchToFileExW}
  370. function ApplyPatchToFileByHandlesEx(PatchFileHandle: HANDLE; OldFileHandle: HANDLE; NewFileHandle: HANDLE;
  371.   ApplyOptionFlags: ULONG; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
  372. {$EXTERNALSYM ApplyPatchToFileByHandlesEx}
  374. //
  375. //  The following prototypes provide a unique patch "signature" for a given
  376. //  file.  Consider the case where you have a new foo.dll and the machines
  377. //  to be updated with the new foo.dll may have one of three different old
  378. //  foo.dll files.  Rather than creating a single large patch file that can
  379. //  update any of the three older foo.dll files, three separate smaller patch
  380. //  files can be created and "named" according to the patch signature of the
  381. //  old file.  Then the patch applyer application can determine at runtime
  382. //  which of the three foo.dll patch files is necessary given the specific
  383. //  foo.dll to be updated.  If patch files are being downloaded over a slow
  384. //  network connection (Internet over a modem), this signature scheme provides
  385. //  a mechanism for choosing the correct single patch file to download at
  386. //  application time thus decreasing total bytes necessary to download.
  387. //
  389. function GetFilePatchSignatureA(FileName: LPCSTR; OptionFlags: ULONG; OptionData: PVOID; IgnoreRangeCount: ULONG; IgnoreRangeArray: PPATCH_IGNORE_RANGE;
  390.   RetainRangeCount: ULONG; RetainRangeArray: PPATCH_RETAIN_RANGE; SignatureBufferSize: ULONG; SignatureBuffer: PVOID): BOOL; stdcall;
  391. {$EXTERNALSYM GetFilePatchSignatureA}
  393. function GetFilePatchSignatureW(FileName: LPCWSTR; OptionFlags: ULONG; OptionData: PVOID; IgnoreRangeCount: ULONG; IgnoreRangeArray: PPATCH_IGNORE_RANGE;
  394.   RetainRangeCount: ULONG; RetainRangeArray: PPATCH_RETAIN_RANGE; SignatureBufferSizeInBytes: ULONG; SignatureBuffer: PVOID): BOOL; stdcall;
  395. {$EXTERNALSYM GetFilePatchSignatureW}
  397. function GetFilePatchSignatureByHandle(FileHandle: HANDLE; OptionFlags: ULONG; OptionData: PVOID; IgnoreRangeCount: ULONG; IgnoreRangeArray: PPATCH_IGNORE_RANGE;
  398.   RetainRangeCount: ULONG; RetainRangeArray: PPATCH_RETAIN_RANGE; SignatureBufferSize: ULONG; SignatureBuffer: PVOID): BOOL; stdcall;
  399. {$EXTERNALSYM GetFilePatchSignatureByHandle}
  401. //
  402. //  Depending on whether UNICODE is defined, map the generic API names to the
  403. //  appropriate Unicode or Ansi APIs.
  404. //
  406. {$IFDEF UNICODE}
  408. function CreatePatchFile(OldFileName: LPCWSTR; NewFileName: LPCWSTR; PatchFileName: LPCWSTR; OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA): BOOL; stdcall;
  409. {$EXTERNALSYM CreatePatchFile}
  410. function CreatePatchFileEx(OldFileCount: ULONG; OldFileInfoArray: PPATCH_OLD_FILE_INFO_W; NewFileName: LPCWSTR; PatchFileName: LPCWSTR;
  411.   OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
  412. {$EXTERNALSYM CreatePatchFileEx}
  413. function ExtractPatchHeaderToFile(PatchFileName: LPCWSTR; PatchHeaderFileName: LPCWSTR): BOOL; stdcall;
  414. {$EXTERNALSYM ExtractPatchHeaderToFile}
  415. function TestApplyPatchToFile(PatchFileName: LPCWSTR; OldFileName: LPCWSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
  416. {$EXTERNALSYM TestApplyPatchToFile}
  417. function ApplyPatchToFile(PatchFileName: LPCWSTR; OldFileName: LPCWSTR; NewFileName: LPCWSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
  418. {$EXTERNALSYM ApplyPatchToFile}
  419. function ApplyPatchToFileEx(PatchFileName: LPCWSTR; OldFileName: LPCWSTR; NewFileName: LPCWSTR; ApplyOptionFlags: ULONG; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
  420. {$EXTERNALSYM ApplyPatchToFileEx}
  421. function GetFilePatchSignature(FileName: LPCWSTR; OptionFlags: ULONG; OptionData: PVOID; IgnoreRangeCount: ULONG; IgnoreRangeArray: PPATCH_IGNORE_RANGE;
  422.   RetainRangeCount: ULONG; RetainRangeArray: PPATCH_RETAIN_RANGE; SignatureBufferSizeInBytes: ULONG; SignatureBuffer: PVOID): BOOL; stdcall;
  423. {$EXTERNALSYM GetFilePatchSignature}
  425. {$ELSE}
  427. function CreatePatchFile(OldFileName: LPCSTR; NewFileName: LPCSTR; PatchFileName: LPCSTR; OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA): BOOL; stdcall;
  428. {$EXTERNALSYM CreatePatchFile}
  429. function CreatePatchFileEx(OldFileCount: ULONG; OldFileInfoArray: PPATCH_OLD_FILE_INFO_A; NewFileName: LPCSTR; PatchFileName: LPCSTR;
  430.   OptionFlags: ULONG; OptionData: PPATCH_OPTION_DATA; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
  431. {$EXTERNALSYM CreatePatchFileEx}
  432. function ExtractPatchHeaderToFile(PatchFileName: LPCSTR; PatchHeaderFileName: LPCSTR): BOOL; stdcall;
  433. {$EXTERNALSYM ExtractPatchHeaderToFile}
  434. function TestApplyPatchToFile(PatchFileName: LPCSTR; OldFileName: LPCSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
  435. {$EXTERNALSYM TestApplyPatchToFile}
  436. function ApplyPatchToFile(PatchFileName: LPCSTR; OldFileName: LPCSTR; NewFileName: LPCSTR; ApplyOptionFlags: ULONG): BOOL; stdcall;
  437. {$EXTERNALSYM ApplyPatchToFile}
  438. function ApplyPatchToFileEx(PatchFileName: LPCSTR; OldFileName: LPCSTR; NewFileName: LPCSTR; ApplyOptionFlags: ULONG; ProgressCallback: PATCH_PROGRESS_CALLBACK; CallbackContext: PVOID): BOOL; stdcall;
  439. {$EXTERNALSYM ApplyPatchToFileEx}
  440. function GetFilePatchSignature(FileName: LPCSTR; OptionFlags: ULONG; OptionData: PVOID; IgnoreRangeCount: ULONG; IgnoreRangeArray: PPATCH_IGNORE_RANGE;
  441.   RetainRangeCount: ULONG; RetainRangeArray: PPATCH_RETAIN_RANGE; SignatureBufferSize: ULONG; SignatureBuffer: PVOID): BOOL; stdcall;
  442. {$EXTERNALSYM GetFilePatchSignature}
  444. {$ENDIF}
  446. implementation
  448. const
  449.   patchapi = 'patchapi.dll'; // todo verify
  451. {$IFDEF DYNAMIC_LINK}
  452. var
  453.   _CreatePatchFileA: Pointer;
  455. function CreatePatchFileA;
  456. begin
  457.   GetProcedureAddress(_CreatePatchFileA, patchapi, 'CreatePatchFileA');
  458.   asm
  459.     mov esp, ebp
  460.     pop ebp
  461.     jmp [_CreatePatchFileA]
  462.   end;
  463. end;
  464. {$ELSE}
  465. function CreatePatchFileA; external patchapi name 'CreatePatchFileA';
  466. {$ENDIF DYNAMIC_LINK}
  468. {$IFDEF DYNAMIC_LINK}
  469. var
  470.   _CreatePatchFileW: Pointer;
  472. function CreatePatchFileW;
  473. begin
  474.   GetProcedureAddress(_CreatePatchFileW, patchapi, 'CreatePatchFileW');
  475.   asm
  476.     mov esp, ebp
  477.     pop ebp
  478.     jmp [_CreatePatchFileW]
  479.   end;
  480. end;
  481. {$ELSE}
  482. function CreatePatchFileW; external patchapi name 'CreatePatchFileW';
  483. {$ENDIF DYNAMIC_LINK}
  485. {$IFDEF DYNAMIC_LINK}
  486. var
  487.   _CreatePatchFileByHandles: Pointer;
  489. function CreatePatchFileByHandles;
  490. begin
  491.   GetProcedureAddress(_CreatePatchFileByHandles, patchapi, 'CreatePatchFileByHandles');
  492.   asm
  493.     mov esp, ebp
  494.     pop ebp
  495.     jmp [_CreatePatchFileByHandles]
  496.   end;
  497. end;
  498. {$ELSE}
  499. function CreatePatchFileByHandles; external patchapi name 'CreatePatchFileByHandles';
  500. {$ENDIF DYNAMIC_LINK}
  502. {$IFDEF DYNAMIC_LINK}
  503. var
  504.   _CreatePatchFileExA: Pointer;
  506. function CreatePatchFileExA;
  507. begin
  508.   GetProcedureAddress(_CreatePatchFileExA, patchapi, 'CreatePatchFileExA');
  509.   asm
  510.     mov esp, ebp
  511.     pop ebp
  512.     jmp [_CreatePatchFileExA]
  513.   end;
  514. end;
  515. {$ELSE}
  516. function CreatePatchFileExA; external patchapi name 'CreatePatchFileExA';
  517. {$ENDIF DYNAMIC_LINK}
  519. {$IFDEF DYNAMIC_LINK}
  520. var
  521.   _CreatePatchFileExW: Pointer;
  523. function CreatePatchFileExW;
  524. begin
  525.   GetProcedureAddress(_CreatePatchFileExW, patchapi, 'CreatePatchFileExW');
  526.   asm
  527.     mov esp, ebp
  528.     pop ebp
  529.     jmp [_CreatePatchFileExW]
  530.   end;
  531. end;
  532. {$ELSE}
  533. function CreatePatchFileExW; external patchapi name 'CreatePatchFileExW';
  534. {$ENDIF DYNAMIC_LINK}
  536. {$IFDEF DYNAMIC_LINK}
  537. var
  538.   _CreatePatchFileByHandlesEx: Pointer;
  540. function CreatePatchFileByHandlesEx;
  541. begin
  542.   GetProcedureAddress(_CreatePatchFileByHandlesEx, patchapi, 'CreatePatchFileByHandlesEx');
  543.   asm
  544.     mov esp, ebp
  545.     pop ebp
  546.     jmp [_CreatePatchFileByHandlesEx]
  547.   end;
  548. end;
  549. {$ELSE}
  550. function CreatePatchFileByHandlesEx; external patchapi name 'CreatePatchFileByHandlesEx';
  551. {$ENDIF DYNAMIC_LINK}
  553. {$IFDEF DYNAMIC_LINK}
  554. var
  555.   _ExtractPatchHeaderToFileA: Pointer;
  557. function ExtractPatchHeaderToFileA;
  558. begin
  559.   GetProcedureAddress(_ExtractPatchHeaderToFileA, patchapi, 'ExtractPatchHeaderToFileA');
  560.   asm
  561.     mov esp, ebp
  562.     pop ebp
  563.     jmp [_ExtractPatchHeaderToFileA]
  564.   end;
  565. end;
  566. {$ELSE}
  567. function ExtractPatchHeaderToFileA; external patchapi name 'ExtractPatchHeaderToFileA';
  568. {$ENDIF DYNAMIC_LINK}
  570. {$IFDEF DYNAMIC_LINK}
  571. var
  572.   _ExtractPatchHeaderToFileW: Pointer;
  574. function ExtractPatchHeaderToFileW;
  575. begin
  576.   GetProcedureAddress(_ExtractPatchHeaderToFileW, patchapi, 'ExtractPatchHeaderToFileW');
  577.   asm
  578.     mov esp, ebp
  579.     pop ebp
  580.     jmp [_ExtractPatchHeaderToFileW]
  581.   end;
  582. end;
  583. {$ELSE}
  584. function ExtractPatchHeaderToFileW; external patchapi name 'ExtractPatchHeaderToFileW';
  585. {$ENDIF DYNAMIC_LINK}
  587. {$IFDEF DYNAMIC_LINK}
  588. var
  589.   _ExtrPatchHdrToFileByHandles: Pointer;
  591. function ExtractPatchHeaderToFileByHandles;
  592. begin
  593.   GetProcedureAddress(_ExtrPatchHdrToFileByHandles, patchapi, 'ExtractPatchHeaderToFileByHandles');
  594.   asm
  595.     mov esp, ebp
  596.     pop ebp
  597.     jmp [_ExtrPatchHdrToFileByHandles]
  598.   end;
  599. end;
  600. {$ELSE}
  601. function ExtractPatchHeaderToFileByHandles; external patchapi name 'ExtractPatchHeaderToFileByHandles';
  602. {$ENDIF DYNAMIC_LINK}
  604. {$IFDEF DYNAMIC_LINK}
  605. var
  606.   _TestApplyPatchToFileA: Pointer;
  608. function TestApplyPatchToFileA;
  609. begin
  610.   GetProcedureAddress(_TestApplyPatchToFileA, patchapi, 'TestApplyPatchToFileA');
  611.   asm
  612.     mov esp, ebp
  613.     pop ebp
  614.     jmp [_TestApplyPatchToFileA]
  615.   end;
  616. end;
  617. {$ELSE}
  618. function TestApplyPatchToFileA; external patchapi name 'TestApplyPatchToFileA';
  619. {$ENDIF DYNAMIC_LINK}
  621. {$IFDEF DYNAMIC_LINK}
  622. var
  623.   _TestApplyPatchToFileW: Pointer;
  625. function TestApplyPatchToFileW;
  626. begin
  627.   GetProcedureAddress(_TestApplyPatchToFileW, patchapi, 'TestApplyPatchToFileW');
  628.   asm
  629.     mov esp, ebp
  630.     pop ebp
  631.     jmp [_TestApplyPatchToFileW]
  632.   end;
  633. end;
  634. {$ELSE}
  635. function TestApplyPatchToFileW; external patchapi name 'TestApplyPatchToFileW';
  636. {$ENDIF DYNAMIC_LINK}
  638. {$IFDEF DYNAMIC_LINK}
  639. var
  640.   _TestApplyPatchToFileByHandles: Pointer;
  642. function TestApplyPatchToFileByHandles;
  643. begin
  644.   GetProcedureAddress(_TestApplyPatchToFileByHandles, patchapi, 'TestApplyPatchToFileByHandles');
  645.   asm
  646.     mov esp, ebp
  647.     pop ebp
  648.     jmp [_TestApplyPatchToFileByHandles]
  649.   end;
  650. end;
  651. {$ELSE}
  652. function TestApplyPatchToFileByHandles; external patchapi name 'TestApplyPatchToFileByHandles';
  653. {$ENDIF DYNAMIC_LINK}
  655. {$IFDEF DYNAMIC_LINK}
  656. var
  657.   _ApplyPatchToFileA: Pointer;
  659. function ApplyPatchToFileA;
  660. begin
  661.   GetProcedureAddress(_ApplyPatchToFileA, patchapi, 'ApplyPatchToFileA');
  662.   asm
  663.     mov esp, ebp
  664.     pop ebp
  665.     jmp [_ApplyPatchToFileA]
  666.   end;
  667. end;
  668. {$ELSE}
  669. function ApplyPatchToFileA; external patchapi name 'ApplyPatchToFileA';
  670. {$ENDIF DYNAMIC_LINK}
  672. {$IFDEF DYNAMIC_LINK}
  673. var
  674.   _ApplyPatchToFileW: Pointer;
  676. function ApplyPatchToFileW;
  677. begin
  678.   GetProcedureAddress(_ApplyPatchToFileW, patchapi, 'ApplyPatchToFileW');
  679.   asm
  680.     mov esp, ebp
  681.     pop ebp
  682.     jmp [_ApplyPatchToFileW]
  683.   end;
  684. end;
  685. {$ELSE}
  686. function ApplyPatchToFileW; external patchapi name 'ApplyPatchToFileW';
  687. {$ENDIF DYNAMIC_LINK}
  689. {$IFDEF DYNAMIC_LINK}
  690. var
  691.   _ApplyPatchToFileByHandles: Pointer;
  693. function ApplyPatchToFileByHandles;
  694. begin
  695.   GetProcedureAddress(_ApplyPatchToFileByHandles, patchapi, 'ApplyPatchToFileByHandles');
  696.   asm
  697.     mov esp, ebp
  698.     pop ebp
  699.     jmp [_ApplyPatchToFileByHandles]
  700.   end;
  701. end;
  702. {$ELSE}
  703. function ApplyPatchToFileByHandles; external patchapi name 'ApplyPatchToFileByHandles';
  704. {$ENDIF DYNAMIC_LINK}
  706. {$IFDEF DYNAMIC_LINK}
  707. var
  708.   _ApplyPatchToFileExA: Pointer;
  710. function ApplyPatchToFileExA;
  711. begin
  712.   GetProcedureAddress(_ApplyPatchToFileExA, patchapi, 'ApplyPatchToFileExA');
  713.   asm
  714.     mov esp, ebp
  715.     pop ebp
  716.     jmp [_ApplyPatchToFileExA]
  717.   end;
  718. end;
  719. {$ELSE}
  720. function ApplyPatchToFileExA; external patchapi name 'ApplyPatchToFileExA';
  721. {$ENDIF DYNAMIC_LINK}
  723. {$IFDEF DYNAMIC_LINK}
  724. var
  725.   _ApplyPatchToFileExW: Pointer;
  727. function ApplyPatchToFileExW;
  728. begin
  729.   GetProcedureAddress(_ApplyPatchToFileExW, patchapi, 'ApplyPatchToFileExW');
  730.   asm
  731.     mov esp, ebp
  732.     pop ebp
  733.     jmp [_ApplyPatchToFileExW]
  734.   end;
  735. end;
  736. {$ELSE}
  737. function ApplyPatchToFileExW; external patchapi name 'ApplyPatchToFileExW';
  738. {$ENDIF DYNAMIC_LINK}
  740. {$IFDEF DYNAMIC_LINK}
  741. var
  742.   _ApplyPatchToFileByHandlesEx: Pointer;
  744. function ApplyPatchToFileByHandlesEx;
  745. begin
  746.   GetProcedureAddress(_ApplyPatchToFileByHandlesEx, patchapi, 'ApplyPatchToFileByHandlesEx');
  747.   asm
  748.     mov esp, ebp
  749.     pop ebp
  750.     jmp [_ApplyPatchToFileByHandlesEx]
  751.   end;
  752. end;
  753. {$ELSE}
  754. function ApplyPatchToFileByHandlesEx; external patchapi name 'ApplyPatchToFileByHandlesEx';
  755. {$ENDIF DYNAMIC_LINK}
  757. {$IFDEF DYNAMIC_LINK}
  758. var
  759.   _GetFilePatchSignatureA: Pointer;
  761. function GetFilePatchSignatureA;
  762. begin
  763.   GetProcedureAddress(_GetFilePatchSignatureA, patchapi, 'GetFilePatchSignatureA');
  764.   asm
  765.     mov esp, ebp
  766.     pop ebp
  767.     jmp [_GetFilePatchSignatureA]
  768.   end;
  769. end;
  770. {$ELSE}
  771. function GetFilePatchSignatureA; external patchapi name 'GetFilePatchSignatureA';
  772. {$ENDIF DYNAMIC_LINK}
  774. {$IFDEF DYNAMIC_LINK}
  775. var
  776.   _GetFilePatchSignatureW: Pointer;
  778. function GetFilePatchSignatureW;
  779. begin
  780.   GetProcedureAddress(_GetFilePatchSignatureW, patchapi, 'GetFilePatchSignatureW');
  781.   asm
  782.     mov esp, ebp
  783.     pop ebp
  784.     jmp [_GetFilePatchSignatureW]
  785.   end;
  786. end;
  787. {$ELSE}
  788. function GetFilePatchSignatureW; external patchapi name 'GetFilePatchSignatureW';
  789. {$ENDIF DYNAMIC_LINK}
  791. {$IFDEF DYNAMIC_LINK}
  792. var
  793.   _GetFilePatchSignatureByHandle: Pointer;
  795. function GetFilePatchSignatureByHandle;
  796. begin
  797.   GetProcedureAddress(_GetFilePatchSignatureByHandle, patchapi, 'GetFilePatchSignatureByHandle');
  798.   asm
  799.     mov esp, ebp
  800.     pop ebp
  801.     jmp [_GetFilePatchSignatureByHandle]
  802.   end;
  803. end;
  804. {$ELSE}
  805. function GetFilePatchSignatureByHandle; external patchapi name 'GetFilePatchSignatureByHandle';
  806. {$ENDIF DYNAMIC_LINK}
  808. {$IFDEF UNICODE}
  811. {$IFDEF DYNAMIC_LINK}
  812. var
  813.   _CreatePatchFile: Pointer;
  815. function CreatePatchFile;
  816. begin
  817.   GetProcedureAddress(_CreatePatchFile, patchapi, 'CreatePatchFileW');
  818.   asm
  819.     mov esp, ebp
  820.     pop ebp
  821.     jmp [_CreatePatchFile]
  822.   end;
  823. end;
  824. {$ELSE}
  825. function CreatePatchFile; external patchapi name 'CreatePatchFileW';
  826. {$ENDIF DYNAMIC_LINK}
  828. {$IFDEF DYNAMIC_LINK}
  829. var
  830.   _CreatePatchFileEx: Pointer;
  832. function CreatePatchFileEx;
  833. begin
  834.   GetProcedureAddress(_CreatePatchFileEx, patchapi, 'CreatePatchFileExW');
  835.   asm
  836.     mov esp, ebp
  837.     pop ebp
  838.     jmp [_CreatePatchFileEx]
  839.   end;
  840. end;
  841. {$ELSE}
  842. function CreatePatchFileEx; external patchapi name 'CreatePatchFileExW';
  843. {$ENDIF DYNAMIC_LINK}
  845. {$IFDEF DYNAMIC_LINK}
  846. var
  847.   _ExtractPatchHeaderToFile: Pointer;
  849. function ExtractPatchHeaderToFile;
  850. begin
  851.   GetProcedureAddress(_ExtractPatchHeaderToFile, patchapi, 'ExtractPatchHeaderToFileW');
  852.   asm
  853.     mov esp, ebp
  854.     pop ebp
  855.     jmp [_ExtractPatchHeaderToFile]
  856.   end;
  857. end;
  858. {$ELSE}
  859. function ExtractPatchHeaderToFile; external patchapi name 'ExtractPatchHeaderToFileW';
  860. {$ENDIF DYNAMIC_LINK}
  862. {$IFDEF DYNAMIC_LINK}
  863. var
  864.   _TestApplyPatchToFile: Pointer;
  866. function TestApplyPatchToFile;
  867. begin
  868.   GetProcedureAddress(_TestApplyPatchToFile, patchapi, 'TestApplyPatchToFileW');
  869.   asm
  870.     mov esp, ebp
  871.     pop ebp
  872.     jmp [_TestApplyPatchToFile]
  873.   end;
  874. end;
  875. {$ELSE}
  876. function TestApplyPatchToFile; external patchapi name 'TestApplyPatchToFileW';
  877. {$ENDIF DYNAMIC_LINK}
  879. {$IFDEF DYNAMIC_LINK}
  880. var
  881.   _ApplyPatchToFile: Pointer;
  883. function ApplyPatchToFile;
  884. begin
  885.   GetProcedureAddress(_ApplyPatchToFile, patchapi, 'ApplyPatchToFileW');
  886.   asm
  887.     mov esp, ebp
  888.     pop ebp
  889.     jmp [_ApplyPatchToFile]
  890.   end;
  891. end;
  892. {$ELSE}
  893. function ApplyPatchToFile; external patchapi name 'ApplyPatchToFileW';
  894. {$ENDIF DYNAMIC_LINK}
  896. {$IFDEF DYNAMIC_LINK}
  897. var
  898.   _ApplyPatchToFileEx: Pointer;
  900. function ApplyPatchToFileEx;
  901. begin
  902.   GetProcedureAddress(_ApplyPatchToFileEx, patchapi, 'ApplyPatchToFileExW');
  903.   asm
  904.     mov esp, ebp
  905.     pop ebp
  906.     jmp [_ApplyPatchToFileEx]
  907.   end;
  908. end;
  909. {$ELSE}
  910. function ApplyPatchToFileEx; external patchapi name 'ApplyPatchToFileExW';
  911. {$ENDIF DYNAMIC_LINK}
  913. {$IFDEF DYNAMIC_LINK}
  914. var
  915.   _GetFilePatchSignature: Pointer;
  917. function GetFilePatchSignature;
  918. begin
  919.   GetProcedureAddress(_GetFilePatchSignature, patchapi, 'GetFilePatchSignatureW');
  920.   asm
  921.     mov esp, ebp
  922.     pop ebp
  923.     jmp [_GetFilePatchSignature]
  924.   end;
  925. end;
  926. {$ELSE}
  927. function GetFilePatchSignature; external patchapi name 'GetFilePatchSignatureW';
  928. {$ENDIF DYNAMIC_LINK}
  930. {$ELSE}
  933. {$IFDEF DYNAMIC_LINK}
  934. var
  935.   _CreatePatchFile: Pointer;
  937. function CreatePatchFile;
  938. begin
  939.   GetProcedureAddress(_CreatePatchFile, patchapi, 'CreatePatchFileA');
  940.   asm
  941.     mov esp, ebp
  942.     pop ebp
  943.     jmp [_CreatePatchFile]
  944.   end;
  945. end;
  946. {$ELSE}
  947. function CreatePatchFile; external patchapi name 'CreatePatchFileA';
  948. {$ENDIF DYNAMIC_LINK}
  950. {$IFDEF DYNAMIC_LINK}
  951. var
  952.   _CreatePatchFileEx: Pointer;
  954. function CreatePatchFileEx;
  955. begin
  956.   GetProcedureAddress(_CreatePatchFileEx, patchapi, 'CreatePatchFileExA');
  957.   asm
  958.     mov esp, ebp
  959.     pop ebp
  960.     jmp [_CreatePatchFileEx]
  961.   end;
  962. end;
  963. {$ELSE}
  964. function CreatePatchFileEx; external patchapi name 'CreatePatchFileExA';
  965. {$ENDIF DYNAMIC_LINK}
  967. {$IFDEF DYNAMIC_LINK}
  968. var
  969.   _ExtractPatchHeaderToFile: Pointer;
  971. function ExtractPatchHeaderToFile;
  972. begin
  973.   GetProcedureAddress(_ExtractPatchHeaderToFile, patchapi, 'ExtractPatchHeaderToFileA');
  974.   asm
  975.     mov esp, ebp
  976.     pop ebp
  977.     jmp [_ExtractPatchHeaderToFile]
  978.   end;
  979. end;
  980. {$ELSE}
  981. function ExtractPatchHeaderToFile; external patchapi name 'ExtractPatchHeaderToFileA';
  982. {$ENDIF DYNAMIC_LINK}
  984. {$IFDEF DYNAMIC_LINK}
  985. var
  986.   _TestApplyPatchToFile: Pointer;
  988. function TestApplyPatchToFile;
  989. begin
  990.   GetProcedureAddress(_TestApplyPatchToFile, patchapi, 'TestApplyPatchToFileA');
  991.   asm
  992.     mov esp, ebp
  993.     pop ebp
  994.     jmp [_TestApplyPatchToFile]
  995.   end;
  996. end;
  997. {$ELSE}
  998. function TestApplyPatchToFile; external patchapi name 'TestApplyPatchToFileA';
  999. {$ENDIF DYNAMIC_LINK}
  1001. {$IFDEF DYNAMIC_LINK}
  1002. var
  1003.   _ApplyPatchToFile: Pointer;
  1005. function ApplyPatchToFile;
  1006. begin
  1007.   GetProcedureAddress(_ApplyPatchToFile, patchapi, 'ApplyPatchToFileA');
  1008.   asm
  1009.     mov esp, ebp
  1010.     pop ebp
  1011.     jmp [_ApplyPatchToFile]
  1012.   end;
  1013. end;
  1014. {$ELSE}
  1015. function ApplyPatchToFile; external patchapi name 'ApplyPatchToFileA';
  1016. {$ENDIF DYNAMIC_LINK}
  1018. {$IFDEF DYNAMIC_LINK}
  1019. var
  1020.   _ApplyPatchToFileEx: Pointer;
  1022. function ApplyPatchToFileEx;
  1023. begin
  1024.   GetProcedureAddress(_ApplyPatchToFileEx, patchapi, 'ApplyPatchToFileExA');
  1025.   asm
  1026.     mov esp, ebp
  1027.     pop ebp
  1028.     jmp [_ApplyPatchToFileEx]
  1029.   end;
  1030. end;
  1031. {$ELSE}
  1032. function ApplyPatchToFileEx; external patchapi name 'ApplyPatchToFileExA';
  1033. {$ENDIF DYNAMIC_LINK}
  1035. {$IFDEF DYNAMIC_LINK}
  1036. var
  1037.   _GetFilePatchSignature: Pointer;
  1039. function GetFilePatchSignature;
  1040. begin
  1041.   GetProcedureAddress(_GetFilePatchSignature, patchapi, 'GetFilePatchSignatureA');
  1042.   asm
  1043.     mov esp, ebp
  1044.     pop ebp
  1045.     jmp [_GetFilePatchSignature]
  1046.   end;
  1047. end;
  1048. {$ELSE}
  1049. function GetFilePatchSignature; external patchapi name 'GetFilePatchSignatureA';
  1050. {$ENDIF DYNAMIC_LINK}
  1052. {$ENDIF}
  1055. end.