wimgapi.dll ##file-based disk image## (imagex.exe) with pb ?

bingo · Post by **bingo** » Sat Sep 16, 2006 9:24 am

http://en.wikipedia.org/wiki/WIM_image_format

/****************************************************************************\

    WIMGAPI.H

    Copyright (c) Microsoft Corporation.
    All rights reserved.

\****************************************************************************/

#ifndef _WIMGAPI_H_
#define _WIMGAPI_H_

#ifdef __cplusplus
extern "C" {
#endif

//
// Defined Value(s):
//

// WIMCreateFile:
//
#define WIM_GENERIC_READ            GENERIC_READ
#define WIM_GENERIC_WRITE           GENERIC_WRITE

#define WIM_CREATE_NEW              CREATE_NEW
#define WIM_CREATE_ALWAYS           CREATE_ALWAYS
#define WIM_OPEN_EXISTING           OPEN_EXISTING
#define WIM_OPEN_ALWAYS             OPEN_ALWAYS

typedef enum
{
    WIM_COMPRESS_NONE = 0,
    WIM_COMPRESS_XPRESS,
    WIM_COMPRESS_LZX
};

typedef enum
{
    WIM_CREATED_NEW = 0,
    WIM_OPENED_EXISTING
};

// WIMCreateFile, WIMCaptureImage, WIMApplyImage flags:
//
#define WIM_FLAG_RESERVED           0x00000001
#define WIM_FLAG_VERIFY             0x00000002
#define WIM_FLAG_INDEX              0x00000004
#define WIM_FLAG_NO_APPLY           0x00000008
#define WIM_FLAG_NO_DIRACL          0x00000010
#define WIM_FLAG_NO_FILEACL         0x00000020
#define WIM_FLAG_SHARE_WRITE        0x00000040
#define WIM_FLAG_FILEINFO           0x00000080
#define WIM_FLAG_NO_RP_FIX          0x00000100  // do not fix up reparse point tag
                                                // only used in WIMCaptureImage

// WIMSetReferenceFile
//
#define WIM_REFERENCE_APPEND        0x00010000
#define WIM_REFERENCE_REPLACE       0x00020000

// WIMExportImage
//
#define WIM_EXPORT_ALLOW_DUPLICATES 0x00000001
#define WIM_EXPORT_ONLY_RESOURCES   0x00000002
#define WIM_EXPORT_ONLY_METADATA    0x00000004

// WIMRegisterMessageCallback:
//
#define INVALID_CALLBACK_VALUE      0xFFFFFFFF

// WIMCopyFile
//
#define WIM_COPY_FILE_RETRY         0x01000000

// WIMMessageCallback Notifications:
//
typedef enum
{
    WIM_MSG = WM_APP + 0x1476,
    WIM_MSG_TEXT,
    WIM_MSG_PROGRESS,
    WIM_MSG_PROCESS,
    WIM_MSG_SCANNING,
    WIM_MSG_SETRANGE,
    WIM_MSG_SETPOS,
    WIM_MSG_STEPIT,
    WIM_MSG_COMPRESS,
    WIM_MSG_ERROR,
    WIM_MSG_ALIGNMENT,
    WIM_MSG_RETRY,
    WIM_MSG_SPLIT,
    WIM_MSG_FILEINFO,
    WIM_MSG_INFO,
    WIM_MSG_WARNING,
    WIM_MSG_CHK_PROCESS

};

//
// WIMMessageCallback Return codes:
//
#define WIM_MSG_SUCCESS     ERROR_SUCCESS
#define WIM_MSG_DONE        0xFFFFFFF0
#define WIM_MSG_SKIP_ERROR  0xFFFFFFFE
#define WIM_MSG_ABORT_IMAGE 0xFFFFFFFF

//
// WIM_INFO dwFlags values:
//
#define WIM_ATTRIBUTE_NORMAL        0x00000000
#define WIM_ATTRIBUTE_RESOURCE_ONLY 0x00000001
#define WIM_ATTRIBUTE_METADATA_ONLY 0x00000002
#define WIM_ATTRIBUTE_VERIFY_DATA   0x00000004
#define WIM_ATTRIBUTE_RP_FIX        0x00000008
#define WIM_ATTRIBUTE_SPANNED       0x00000010
#define WIM_ATTRIBUTE_READONLY      0x00000020

//
// The WIM_INFO structure used by WIMGetAttributes:
//
typedef struct _WIM_INFO
{
    WCHAR  WimPath[MAX_PATH];
    GUID   Guid;
    DWORD  ImageCount;
    DWORD  CompressionType;
    USHORT PartNumber;
    USHORT TotalParts;
    DWORD  BootIndex;
    DWORD  WimAttributes;
    DWORD  WimFlagsAndAttr;
}
WIM_INFO, *PWIM_INFO, *LPWIM_INFO;

//
// The WIM_MOUNT_LIST structure used for getting the list of mounted images.
//
typedef struct _WIM_MOUNT_LIST
{
    WCHAR  WimPath[MAX_PATH];
    WCHAR  MountPath[MAX_PATH];
    DWORD  ImageIndex;
    BOOL   MountedForRW;
}
WIM_MOUNT_LIST, *PWIM_MOUNT_LIST, *LPWIM_MOUNT_LIST;

//
// Naming translations for static library use:
//
#ifdef WIM_STATIC_LIB
#define WIMCreateFile                     _WIMCreateFile
#define WIMCloseHandle                    _WIMCloseHandle
#define WIMSetTemporaryPath               _WIMSetTemporaryPath
#define WIMSetReferenceFile               _WIMSetReferenceFile
#define WIMSplitFile                      _WIMSplitFile
#define WIMExportImage                    _WIMExportImage
#define WIMDeleteImage                    _WIMDeleteImage
#define WIMGetImageCount                  _WIMGetImageCount
#define WIMGetAttributes                  _WIMGetAttributes
#define WIMSetBootImage                   _WIMSetBootImage
#define WIMLoadImage                      _WIMLoadImage
#define WIMApplyImage                     _WIMApplyImage
#define WIMCaptureImage                   _WIMCaptureImage
#define WIMGetImageInformation            _WIMGetImageInformation
#define WIMSetImageInformation            _WIMSetImageInformation
#define WIMGetMessageCallbackCount        _WIMGetMessageCallbackCount
#define WIMRegisterMessageCallback        _WIMRegisterMessageCallback
#define WIMUnregisterMessageCallback      _WIMUnregisterMessageCallback
#define WIMMountImage                     _WIMMountImage
#define WIMUnmountImage                   _WIMUnmountImage
#define WIMGetMountedImages               _WIMGetMountedImages
#define WIMCopyFile                       _WIMCopyFile
#define WIMInitFileIOCallbacks            _WIMInitFileIOCallbacks
#define WIMSetFileIOCallbackTemporaryPath _WIMSetFileIOCallbackTemporaryPath
#endif

//
// Exported Function Prototypes:
//
HANDLE
WINAPI
WIMCreateFile(
    __in      LPWSTR  lpszWimPath,
    IN        DWORD   dwDesiredAccess,
    IN        DWORD   dwCreationDisposition,
    IN        DWORD   dwFlagsAndAttributes,
    IN        DWORD   dwCompressionType,
    __out_opt LPDWORD lpdwCreationResult
    );

BOOL
WINAPI
WIMCloseHandle(
    __in HANDLE hObject
    );

BOOL
WINAPI
WIMSetTemporaryPath(
    __in HANDLE hWim,
    __in LPWSTR lpszPath
    );

BOOL
WINAPI
WIMSetReferenceFile(
    __in HANDLE hWim,
    __in LPWSTR lpszPath,
    IN   DWORD  dwFlags
    );

BOOL
WINAPI
WIMSplitFile(
    __in    HANDLE         hWim,
    __in    LPWSTR         lpszPartPath,
    __inout PLARGE_INTEGER pliPartSize,
    IN      DWORD          dwFlags
    );

BOOL
WINAPI
WIMExportImage(
    __in HANDLE hImage,
    __in HANDLE hWim,
    IN   DWORD  dwFlags
    );

BOOL
WINAPI
WIMDeleteImage(
    __in HANDLE hWim,
    IN   DWORD  dwImageIndex
    );

DWORD
WINAPI
WIMGetImageCount(
    __in HANDLE hWim
    );

BOOL
WINAPI
WIMGetAttributes(
    __in                    HANDLE     hWim,
    __out_bcount(cbWimInfo) LPWIM_INFO lpWimInfo,
    IN                      DWORD      cbWimInfo
    );

BOOL
WINAPI
WIMSetBootImage(
    __in HANDLE hWim,
    __in DWORD  dwImageIndex
    );

HANDLE
WINAPI
WIMCaptureImage(
    __in HANDLE hWim,
    __in LPWSTR lpszPath,
    IN   DWORD  dwCaptureFlags
    );

HANDLE
WINAPI
WIMLoadImage(
    __in HANDLE hWim,
    IN   DWORD  dwImageIndex
    );

BOOL
WINAPI
WIMApplyImage(
    __in HANDLE hImage,
    __in LPWSTR lpszPath,
    IN   DWORD  dwApplyFlags
    );

BOOL
WINAPI
WIMGetImageInformation(
    __in  HANDLE  hImage,
    __out LPVOID  *lplpvImageInfo,
    __out LPDWORD lpcbImageInfo
    );

BOOL
WINAPI
WIMSetImageInformation(
    __in                     HANDLE hImage,
    __in_bcount(cbImageInfo) LPVOID lpvImageInfo,
    IN                       DWORD  cbImageInfo
    );

DWORD
WINAPI
WIMGetMessageCallbackCount(
    __in_opt HANDLE hWim
    );

DWORD
WINAPI
WIMRegisterMessageCallback(
    __in_opt HANDLE  hWim,
    __in     FARPROC fpMessageProc,
    __in_opt LPVOID  lpvUserData
    );

BOOL
WINAPI
WIMUnregisterMessageCallback(
    __in_opt HANDLE  hWim,
    __in_opt FARPROC fpMessageProc
    );

DWORD
WINAPI
WIMMessageCallback(
    IN DWORD  dwMessageId,
    IN WPARAM wParam,
    IN LPARAM lParam,
    IN LPVOID lpvUserData
    );

BOOL
WINAPI
WIMCopyFile(
    __in     LPWSTR             lpszExistingFileName,
    __in     LPWSTR             lpszNewFileName,
    __in_opt LPPROGRESS_ROUTINE lpProgressRoutine,
    __in_opt LPVOID             lpvData,
    __in_opt LPBOOL             pbCancel,
    IN       DWORD              dwCopyFlags
    );

BOOL
WINAPI
WIMMountImage(
    __in     LPWSTR lpszMountPath,
    __in     LPWSTR lpszWimFileName,
    __in     DWORD  dwImageIndex,
    __in_opt LPWSTR lpszTempPath
    );

BOOL
WINAPI
WIMUnmountImage(
    __in     LPWSTR lpszMountPath,
    __in_opt LPWSTR lpszWimFileName,
    __in     DWORD  dwImageIndex,
    __in     BOOL   bCommitChanges
    );

BOOL
WINAPI
WIMGetMountedImages(
    __inout_bcount(*lpcbBufferSize) LPWIM_MOUNT_LIST lpMountList,
    __inout                         LPDWORD          lpcbBufferSize
    );

BOOL
WINAPI
WIMInitFileIOCallbacks(
    __in_opt LPVOID lpCallbacks
    );

BOOL
WINAPI
WIMSetFileIOCallbackTemporaryPath(
    __in_opt LPTSTR lpszPath
    );

//
// File I/O callback prototypes
//
typedef VOID * PFILEIOCALLBACK_SESSION;

typedef
PFILEIOCALLBACK_SESSION
(CALLBACK * FileIOCallbackOpenFile)(
    LPCWSTR lpFileName
    );

typedef
BOOL
(CALLBACK * FileIOCallbackCloseFile)(
    PFILEIOCALLBACK_SESSION hFile
    );

typedef
BOOL
(CALLBACK * FileIOCallbackReadFile)(
    PFILEIOCALLBACK_SESSION hFile,
    LPVOID lpBuffer,
    DWORD nNumberOfBytesToRead,
    LPDWORD lpNumberOfBytesRead,
    LPOVERLAPPED lpOverlapped
    );

typedef
BOOL
(CALLBACK * FileIOCallbackSetFilePointer)(
    PFILEIOCALLBACK_SESSION hFile,
    LARGE_INTEGER liDistanceToMove,
    PLARGE_INTEGER lpNewFilePointer,
    DWORD dwMoveMethod
    );

typedef
BOOL
(CALLBACK * FileIOCallbackGetFileSize)(
    HANDLE hFile,
    PLARGE_INTEGER lpFileSize
    );

typedef struct _SFileIOCallbackInfo
{
    FileIOCallbackOpenFile       pfnOpenFile;
    FileIOCallbackCloseFile      pfnCloseFile;
    FileIOCallbackReadFile       pfnReadFile;
    FileIOCallbackSetFilePointer pfnSetFilePointer;
    FileIOCallbackGetFileSize    pfnGetFileSize;
} SFileIOCallbackInfo;

#ifdef __cplusplus
}
#endif

#endif // _WIMGAPI_H_

my testcode für pb4 ... but how use this callback ?

Code: Select all

Import "wimgapi.lib"
WIMCreateFile(lpszWimPath.s,dwDesiredAccess.l,dwCreationDisposition.l,dwFlagsAndAttributes.l,dwCompressionType.l,lpdwCreationResult.l)
WIMCaptureImage (hWim.l,captureDir.s,flag.l)
WIMCloseHandle(hObject.l)
WIMRegisterMessageCallback(hWim.l,fpMessageProc.l,lpvUserData.l)
WIMUnregisterMessageCallback(hWIM.l,fpMessageProc.l)
EndImport

#WIM_FLAG_VERIFY = 2
#WIM_COMPRESS_LZX = 2
#WIM_GENERIC_READ = #GENERIC_READ
#WIM_GENERIC_WRITE = #GENERIC_WRITE
#WIM_CREATE_ALWAYS = #CREATE_ALWAYS

Enumeration 
    #WIM_MSG = #WM_APP + $1476
    #WIM_MSG_TEXT
    #WIM_MSG_PROGRESS
    #WIM_MSG_PROCESS
    #WIM_MSG_SCANNING
    #WIM_MSG_SETRANGE
    #WIM_MSG_SETPOS
    #WIM_MSG_STEPIT
    #WIM_MSG_COMPRESS
    #WIM_MSG_ERROR
    #WIM_MSG_ALIGNMENT
    #WIM_MSG_RETRY
    #WIM_MSG_SPLIT
    #WIM_MSG_FILEINFO
    #WIM_MSG_INFO
    #WIM_MSG_WARNING
    #WIM_MSG_CHK_PROCESS
EndEnumeration


handle = WIMCreateFile("c:\my-wim.wim",#WIM_GENERIC_WRITE,#WIM_CREATE_ALWAYS,#WIM_FLAG_VERIFY,#WIM_COMPRESS_LZX,@ret.l)


; ????
;Procedure WimCaptureCallback(msgId.l,param1.l,param2.l,unused.l)

;EndProcedure


;WIMRegisterMessageCallback(0,@WimCaptureCallback(),0)

;WIMCaptureImage(handle,"c:\any-folder",0)

Debug WIMCloseHandle(handle)

;WIMUnregisterMessageCallback(0,0)

End

sample code - capture directory in new wim file

Code: Select all

#include <stdio.h>
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <tchar.h>
#include <wimgapi.h>

#define IN
#define OUT
#define INOUT

//
//Callback function:
//
DWORD
WINAPI
SampleCaptureCallback(
    IN      DWORD msgId,    // message ID
    IN      long  *param1,   // usually file name
    INOUT   DWORD *param2,   // usually error code
    IN      void  *unused
    )
{
    //first parameter: full file path for if WIM_MSG_PROCESS, message string for others
    TCHAR *message  = (TCHAR *) param1;
    TCHAR *filePath = (TCHAR *) param1;

    //second parameter: message back to caller if WIM_MSG_PROCESS, error code for others
    DWORD errorCode = *param2;
    DWORD *msg_back =  param2;


    switch ( msgId )
    {
        case WIM_MSG_PROCESS:

            //This message is sent for each file, capturing to see if callee intends to
            //capture the file or not.
            //
            //If you do not intend to capture this file, then assign FALSE in msg_back
            //but still returns WIM_MSG_SUCCESS
            //Default is TRUE.
            //

            //In this sample, simply print out file name being applied
            //
            _tprintf(TEXT("FilePath: %s\n"), filePath);

            break;

        case WIM_MSG_ERROR:

            //This message is sent upon failure error case
            //
            printf("ERROR: %s [err = %d]\n", message, errorCode);
            break;

        case WIM_MSG_RETRY:

            //This message is sent when file is being reapplied because of
            //network timeout. Retry is done up to five times.
            //
            printf("RETRY: %s [err = %d]\n", message, errorCode);
            break;

        case WIM_MSG_INFO:

            //This message is sent when informational message is available
            //
            printf("INFO: %s [err = %d]\n", message, errorCode);
            break;

        case WIM_MSG_WARNING:

            //This message is sent when warning message is available
            //
            printf("WARNING: %s [err = %d]\n", message, errorCode);
            break;
    }

    return WIM_MSG_SUCCESS;
}


void
SampleCaptureCleanup ( HANDLE hwim, HANDLE himg, FARPROC callback )
{
    DWORD err = GetLastError();

    //Do not overwrite the original error code
    //
    if (himg &&
        !WIMCloseHandle (himg) &&   // close Image file first
        (err == ERROR_SUCCESS)) {

        err = GetLastError();
    }

    if (hwim &&
        !WIMCloseHandle (hwim) &&   // close WIM file last
        (err == ERROR_SUCCESS)) {

        err = GetLastError();
    }

    if (callback &&
        !WIMUnregisterMessageCallback( NULL, callback ) &&
        (err == ERROR_SUCCESS)) {

        err = GetLastError();
    }

    SetLastError (err);
}

//
// Main Fuction:
//
__cdecl
wmain(DWORD argc, TCHAR *argv[])
{
    HANDLE hWim = NULL;
    HANDLE hImg = NULL;
    DWORD  created = 0;
    DWORD  oFlag = 0, oAccess = 0;
    FARPROC callback = (FARPROC) SampleCaptureCallback;

    TCHAR *wimFile    = TEXT("C:\\sample_image.wim");  // target WIM file
    TCHAR *tmpDir     = TEXT("C:\\tmp");               // temporary directory: OPTIONAL
    TCHAR *captureDir = TEXT("C:\\src");               // capture directory or drive

    //generic capture/append call sequence
    //
    //w = WIMCreateFile()
    //WIMSetTemporaryPath() - optional
    //i = WIMCaptureImage()
    //WIMCloseHandle(i)
    //WIMCloseHandle(w)
    //

    //Set up access mode and open flag
    //
    if (argc < 1 || argc > 2) {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 1;
    }

    if (argc == 1) {                        // capture
        oFlag   = WIM_CREATE_ALWAYS;
        oAccess = WIM_GENERIC_WRITE;
    }
    else if (*argv[1] != TEXT('a')) {       // append
        printf("need 'a' to append\n");
        SetLastError(ERROR_INVALID_PARAMETER);
        return 2;
    }
    else {
        oFlag   = WIM_OPEN_EXISTING;
        oAccess = WIM_GENERIC_WRITE | WIM_GENERIC_READ;
    }

    //Register callback
    //
    if (WIMRegisterMessageCallback( NULL,
                                    callback,
                                    NULL ) == INVALID_CALLBACK_VALUE) {
        printf ("Cannot set callback\n");
        return 3;
    }

    //Call SampleCleanup() upon exit from here
    //
    hWim = WIMCreateFile ( wimFile,             // existing WIM file to append to
                           oAccess,             // access mode
                           oFlag,               // open flag
                           0, // WIM_FLAG_VERIFY,     // recommended flag for file corruption check
                           WIM_COMPRESS_XPRESS, // or WIM_COMPRESS_LZX or WIM_COMPRESS_NONE
                           &created );

    if ( !hWim ) {
        printf ("Cannot open WIM file\n");

        SampleCaptureCleanup(hWim, hImg, callback);
        return 4;
    }

    //set temporary directory to work in
    //OPTIONAL, but recommended for large WIM file
    //
    //WIMSetTemporaryPath (hWim, tmpDir);         // OK to fail.

    //Now capture or append image
    //
    hImg = WIMCaptureImage ( hWim,
                             captureDir,  // capture directory or drive
                             0);          // WIM_FLAG_VERIFY

    //Now we are done
    //
    SampleCaptureCleanup (hWim, hImg, callback);

    if (GetLastError() != ERROR_SUCCESS) {
        printf ("Cannot capture/append image\n");
        return 5;
    }

    return 0;
}

bingo · Post by **bingo** » Thu May 13, 2010 6:34 pm

after long time...

for friends of winpe (vista/win7)

my temporary code ...

Code: Select all

Import "wimgapi.lib"
WIMCreateFile(lpszWimPath.l,dwDesiredAccess.l,dwCreationDisposition.l,dwFlagsAndAttributes.l,dwCompressionType.l,lpdwCreationResult.l)
WIMCaptureImage (hWim.l,captureDir.l,flag.l)
WIMCloseHandle(hObject.l)
WIMRegisterMessageCallback(hWim.l,fpMessageProc.l,lpvUserData.l)
WIMUnregisterMessageCallback(hWIM.l,fpMessageProc.l)
WIMLoadImage(hWim.l,dwImageIndex.l)
WIMSetTemporaryPath(hWim.l,lpszPath.l)
WIMApplyImage(hImage.l,lpszPath.l,dwApplyFlags.l)
WIMGetImageCount(hWim.l)
WIMGetImageInformation(hImage.l,lplpvImageInfo.l,lpcbImageInfo.l)
WIMGetAttributes(hWim.l,lpWimInfo.l,cbWimInfo.l)
EndImport

Structure wim_info
WimPath.w[#MAX_PATH];
pp.Guid
ImageCount.l
CompressionType.l
PartNumber.w
TotalParts.w
BootIndex.l
WimAttributes.l
WimFlagsAndAttr.l
EndStructure

#WIM_FLAG_VERIFY = 2

Enumeration
    #WIM_COMPRESS_NONE = 0
    #WIM_COMPRESS_XPRESS
    #WIM_COMPRESS_LZX
EndEnumeration

Enumeration 
    #WIM_MSG = #WM_APP + $1476
    #WIM_MSG_TEXT
    #WIM_MSG_PROGRESS
    #WIM_MSG_PROCESS
    #WIM_MSG_SCANNING
    #WIM_MSG_SETRANGE
    #WIM_MSG_SETPOS
    #WIM_MSG_STEPIT
    #WIM_MSG_COMPRESS
    #WIM_MSG_ERROR
    #WIM_MSG_ALIGNMENT
    #WIM_MSG_RETRY
    #WIM_MSG_SPLIT
    #WIM_MSG_FILEINFO
    #WIM_MSG_INFO
    #WIM_MSG_WARNING
    #WIM_MSG_CHK_PROCESS
EndEnumeration

#WIM_MSG_SUCCESS     =#ERROR_SUCCESS
#WIM_MSG_DONE        =$FFFFFFF0
#WIM_MSG_SKIP_ERROR  =$FFFFFFFE
#WIM_MSG_ABORT_IMAGE =$FFFFFFFF


Procedure.l Ansi2Uni(ansi.s) 
SHStrDup_(@ansi,@memziel)
ProcedureReturn memziel
EndProcedure

wim.wim_info
wimsize.l = SizeOf(wim)
Debug wimsize

handle = WIMCreateFile(Ansi2Uni("c:\_wim\test.wim"),#GENERIC_READ,#OPEN_EXISTING,#WIM_FLAG_VERIFY,0,@ret.l)

Debug handle

;wim info
Debug WIMGetAttributes(handle,@wim,wimsize)

Debug WIMGetImageCount(handle)

Debug WIMSetTemporaryPath(handle,Ansi2Uni("c:\_wim-test"))

handle_image = WIMLoadImage(handle,1)

Debug handle_image

Procedure WimCaptureCallback(msgId.l,param1.l,param2.l,unused.l)

ret = #WIM_MSG_DONE

  Select msgId
  
  Case #WIM_MSG_SCANNING
  Debug "scanning... dir:" + Str(param1) + " files:" + Str(param2)
  
  Case #WIM_MSG_PROGRESS
  Debug Str(param1) + "%" 
  
  Case #WIM_MSG_ERROR 
  Debug "error"
  ret = #WIM_MSG_ABORT_IMAGE

  EndSelect

ProcedureReturn ret
EndProcedure

WIMRegisterMessageCallback(handle,@WimCaptureCallback(),0)

WIMApplyImage(handle_image,Ansi2Uni("c:\wim-extract"),#WIM_FLAG_VERIFY)

Debug WIMUnregisterMessageCallback(handle,0)

Debug WIMCloseHandle(handle_image)

Debug WIMCloseHandle(handle)

End

now it works!

* install latest microsoft windows aik

use UNLOCKER (http://ccollomb.free.fr/unlocker/) for deleting of "c:\wim-extract"

ts-soft · Post by **ts-soft** » Thu May 13, 2010 6:54 pm

Interesting think, but i can't test in the moment.

Small Hint: You should use pseudotypes p-unicode for strings in your import, this make the
Ansi2Uni Procedure unnecessary, and i would use .u for the Arrays.

greetings
Thomas

PureBasic Forums - English

wimgapi.dll ##file-based disk image## (imagex.exe) with pb ?

wimgapi.dll ##file-based disk image## (imagex.exe) with pb ?

Re: wimgapi.dll ##file-based disk image## (imagex.exe) with

Re: wimgapi.dll ##file-based disk image## (imagex.exe) with