dlls/dbghelp/minidump.c - wine - Git at Google


            
            /*

            
             * File minidump.c - management of dumps (read & write)

            
             *

            
             * Copyright (C) 2004, Eric Pouech

            
             *

            
             * This library is free software; you can redistribute it and/or

            
             * modify it under the terms of the GNU Lesser General Public

            
             * License as published by the Free Software Foundation; either

            
             * version 2.1 of the License, or (at your option) any later version.

            
             *

            
             * This library is distributed in the hope that it will be useful,

            
             * but WITHOUT ANY WARRANTY; without even the implied warranty of

            
             * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

            
             * Lesser General Public License for more details.

            
             *

            
             * You should have received a copy of the GNU Lesser General Public

            
             * License along with this library; if not, write to the Free Software

            
             * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

            
             */


            #include <time.h>


            #define NONAMELESSUNION

            
            #define NONAMELESSSTRUCT


            #include "dbghelp_private.h"

            
            #include "wine/debug.h"


            WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);


            #if 0

            
            /* hard to see how we can generate this very easily (how to grab latest exception

            
             * in a process ?)

            
             */

            
            static  void    DumpException(struct process* pcs, HANDLE hFile, RVA* rva)

            
            {

            
                MINIDUMP_EXCEPTION_STREAM   mdExcpt;


                mdExcpt.ThreadId = DEBUG_CurrThread->tid;

            
                mdExcpt.__alignment = 0;

            
                mdExcpt.ExceptionRecord.


                ULONG                       ExceptionCode;

            
                ULONG                       ExceptionFlags;

            
                ULONGLONG                   ExceptionRecord;

            
                ULONGLONG                   ExceptionAddress;

            
                ULONG                       NumberParameters;

            
                ULONG                        __unusedAlignment;

            
                ULONGLONG                   ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];

            
            }

            
            #endif


            /******************************************************************

            
             *		dump_modules

            
             *

            
             * Write in File the modules from pcs

            
             */

            
            static  void    dump_modules(struct process* pcs, HANDLE hFile, RVA* rva)

            
            {

            
                MINIDUMP_MODULE             mdModule;

            
                MINIDUMP_MODULE_LIST        mdModuleList;

            
                DWORD                       written;

            
                struct module*              module = NULL;


                mdModuleList.NumberOfModules = 0;

            
                for (module = pcs->lmodules; module; module = module->next)

            
                    mdModuleList.NumberOfModules++;

            
                WriteFile(hFile, &mdModuleList.NumberOfModules,

            
                          sizeof(mdModuleList.NumberOfModules), &written, NULL);

            
                *rva += sizeof(mdModuleList.NumberOfModules) +

            
                    sizeof(mdModule) * mdModuleList.NumberOfModules;

            
                for (module = pcs->lmodules; module; module = module->next)

            
                {

            
                    mdModule.BaseOfImage = (DWORD)module->module.BaseOfImage;

            
                    mdModule.SizeOfImage = module->module.ImageSize;

            
                    mdModule.CheckSum = module->module.CheckSum;

            
                    mdModule.TimeDateStamp = module->module.TimeDateStamp;

            
                    mdModule.ModuleNameRva = *rva;

            
                    *rva += strlen(module->module.ModuleName) + 1;

            
                    memset(&mdModule.VersionInfo, 0, sizeof(mdModule.VersionInfo)); /* FIXME */

            
                    mdModule.CvRecord.DataSize = 0; /* FIXME */

            
                    mdModule.CvRecord.Rva = 0; /* FIXME */

            
                    mdModule.MiscRecord.DataSize = 0; /* FIXME */

            
                    mdModule.MiscRecord.Rva = 0; /* FIXME */

            
                    mdModule.Reserved0 = 0;

            
                    mdModule.Reserved1 = 0;

            
                    WriteFile(hFile, &mdModule, sizeof(mdModule), &written, NULL);

            
                }

            
                for (module = pcs->lmodules; module; module = module->next)

            
                {

            
                    WriteFile(hFile, module->module.ModuleName,

            
                              strlen(module->module.ModuleName) + 1, &written, NULL);

            
                    FIXME("CV and misc records not written\n");

            
                }

            
            }


            /******************************************************************

            
             *		dump_system_info

            
             *

            
             * Dumps into File the information about the system

            
             */

            
            static  void    dump_system_info(struct process* pcs, HANDLE hFile, RVA* rva)

            
            {

            
                MINIDUMP_SYSTEM_INFO        mdSysInfo;

            
                SYSTEM_INFO                 sysInfo;

            
                OSVERSIONINFOA              osInfo;

            
                DWORD                       written;


                GetSystemInfo(&sysInfo);

            
                GetVersionExA(&osInfo);


                mdSysInfo.ProcessorArchitecture = sysInfo.u.s.wProcessorArchitecture;

            
                mdSysInfo.ProcessorLevel = sysInfo.wProcessorLevel;

            
                mdSysInfo.ProcessorRevision = sysInfo.wProcessorRevision;

            
                mdSysInfo.Reserved0 = 0;


                mdSysInfo.MajorVersion = osInfo.dwMajorVersion;

            
                mdSysInfo.MinorVersion = osInfo.dwMinorVersion;

            
                mdSysInfo.BuildNumber = osInfo.dwBuildNumber;

            
                mdSysInfo.PlatformId = osInfo.dwPlatformId;


                mdSysInfo.CSDVersionRva = *rva + sizeof(mdSysInfo);

            
                mdSysInfo.Reserved1 = 0;


                WriteFile(hFile, &mdSysInfo, sizeof(mdSysInfo), &written, NULL);

            
                *rva += sizeof(mdSysInfo);

            
                WriteFile(hFile, osInfo.szCSDVersion, strlen(osInfo.szCSDVersion) + 1,

            
                          &written, NULL);

            
                *rva += strlen(osInfo.szCSDVersion) + 1;

            
            }


            /******************************************************************

            
             *		dump_threads

            
             *

            
             * Dumps into File the information about running threads

            
             */

            
            static  void    dump_threads(struct process* pcs, HANDLE hFile, RVA* rva)

            
            {

            
            #if 0

            
                MINIDUMP_THREAD             mdThd;

            
                MINIDUMP_THREAD_LIST        mdThdList;

            
                DWORD                       written;

            
                DBG_THREAD*                 thd;


                mdThdList.NumberOfThreads = pcs->num_threads;

            
                WriteFile(hFile, &mdThdList.NumberOfThreads, sizeof(mdThdList.NumberOfThreads),

            
                          &written, NULL);

            
                *rva += sizeof(mdThdList.NumberOfThreads) +

            
                    mdThdList.NumberOfThreads * sizeof(mdThd);

            
                for (thd = pcs->threads; thd; thd = thd->next)

            
                {

            
                    mdThd.ThreadId = thd->tid;

            
                    mdThd.SuspendCount = 0; /* FIXME */

            
                    mdThd.PriorityClass = 0; /* FIXME */

            
                    mdThd.Priority = 0; /* FIXME */

            
                    mdThd.Teb = 0; /* FIXME */

            
                    mdThd.Stack.StartOfMemoryRange = 0; /* FIXME */

            
                    mdThd.Stack.Memory.DataSize = 0; /* FIXME */

            
                    mdThd.Stack.Memory.Rva = 0; /* FIXME */

            
                    mdThd.ThreadContext.DataSize = 0;/* FIXME */

            
                    mdThd.ThreadContext.Rva = 0; /* FIXME */


                    WriteFile(hFile, &mdThd, sizeof(mdThd), &written, NULL);

            
                    FIXME("Stack & thread context not written\n");

            
                }

            
            #endif

            
            }


            /******************************************************************

            
             *		MiniDumpWriteDump (DEBUGHLP.@)

            
             *

            
             *

            
             */

            
            BOOL WINAPI MiniDumpWriteDump(HANDLE hProcess, DWORD ProcessId, HANDLE hFile,

            
                                          MINIDUMP_TYPE DumpType,

            
                                          PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,

            
                                          PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,

            
                                          PMINIDUMP_CALLBACK_INFORMATION CallbackParam)

            
            {

            
                struct process*     pcs;

            
                MINIDUMP_HEADER     mdHead;

            
                MINIDUMP_DIRECTORY  mdDir;

            
                DWORD               currRva, written;

            
                DWORD               i, nStream, addStream;

            
                RVA                 rva;


                pcs = process_find_by_handle(hProcess);

            
                if (!pcs) return FALSE; /* FIXME: should try to load it ??? */


                /* 1) init */


                nStream = UserStreamParam ? UserStreamParam->UserStreamCount : 0;

            
                addStream = 0;

            
                if (DumpType & MiniDumpNormal)

            
                    addStream += 3; /* sure ? thread stack back trace */


                if (DumpType & MiniDumpWithDataSegs)

            
                    FIXME("NIY MiniDumpWithDataSegs\n");

            
                if (DumpType & MiniDumpWithFullMemory)

            
                    FIXME("NIY MiniDumpWithFullMemory\n");

            
                if (DumpType & MiniDumpWithHandleData)

            
                    FIXME("NIY MiniDumpWithHandleData\n");

            
                if (DumpType & MiniDumpFilterMemory)

            
                    FIXME("NIY MiniDumpFilterMemory\n");

            
                if (DumpType & MiniDumpScanMemory)

            
                    FIXME("NIY MiniDumpScanMemory\n");


                /* 2) write header */

            
                rva = sizeof(mdHead);

            
                mdHead.Signature = MINIDUMP_SIGNATURE;

            
                mdHead.Version = MINIDUMP_VERSION;

            
                mdHead.NumberOfStreams = nStream + addStream;

            
                mdHead.StreamDirectoryRva = rva;

            
                mdHead.u.TimeDateStamp = time(NULL);

            
                mdHead.Flags = DumpType;

            
                WriteFile(hFile, &mdHead, sizeof(mdHead), &written, NULL);


                /* 3) write stream directories */

            
                rva += (nStream + addStream) * sizeof(mdDir);

            
                /* 3.1) write data stream directories */

            
                currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);

            
                SetFilePointer(hFile, rva, NULL, FILE_BEGIN);

            
                mdDir.StreamType = ModuleListStream;

            
                mdDir.Location.Rva = rva;

            
                dump_modules(pcs, hFile, &rva);

            
                mdDir.Location.DataSize = SetFilePointer(hFile, 0, NULL, FILE_CURRENT) - mdDir.Location.Rva;

            
                SetFilePointer(hFile, currRva, NULL, FILE_BEGIN);

            
                WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL);


                currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);

            
                SetFilePointer(hFile, rva, NULL, FILE_BEGIN);

            
                mdDir.StreamType = ThreadListStream;

            
                mdDir.Location.Rva = rva;

            
                dump_threads(pcs, hFile, &rva);

            
                mdDir.Location.DataSize = SetFilePointer(hFile, 0, NULL, FILE_CURRENT) - mdDir.Location.Rva;

            
                SetFilePointer(hFile, currRva, NULL, FILE_BEGIN);

            
                WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL);


                currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);

            
                SetFilePointer(hFile, rva, NULL, FILE_BEGIN);

            
                mdDir.StreamType = SystemInfoStream;

            
                mdDir.Location.Rva = rva;

            
                dump_system_info(pcs, hFile, &rva);

            
                mdDir.Location.DataSize = SetFilePointer(hFile, 0, NULL, FILE_CURRENT) - mdDir.Location.Rva;

            
                SetFilePointer(hFile, currRva, NULL, FILE_BEGIN);

            
                WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL);


                /* 3.2) write user define stream */

            
                for (i = 0; i < nStream; i++)

            
                {

            
                    mdDir.StreamType = UserStreamParam->UserStreamArray[i].Type;

            
                    mdDir.Location.DataSize = UserStreamParam->UserStreamArray[i].BufferSize;

            
                    mdDir.Location.Rva = rva;

            
                    WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL);

            
                    currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);

            
                    SetFilePointer(hFile, rva, NULL, FILE_BEGIN);

            
                    WriteFile(hFile,

            
                              UserStreamParam->UserStreamArray[i].Buffer,

            
                              UserStreamParam->UserStreamArray[i].BufferSize,

            
                              &written, NULL);

            
                    rva += UserStreamParam->UserStreamArray[i].BufferSize;

            
                    SetFilePointer(hFile, currRva, NULL, FILE_BEGIN);

            
                }


                return TRUE;

            
            }
	/*
	* File minidump.c - management of dumps (read & write)
	*
	* Copyright (C) 2004, Eric Pouech
	*
	* This library is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This library is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this library; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	*/

	#include <time.h>

	#define NONAMELESSUNION
	#define NONAMELESSSTRUCT

	#include "dbghelp_private.h"
	#include "wine/debug.h"

	WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);

	#if 0
	/* hard to see how we can generate this very easily (how to grab latest exception
	* in a process ?)
	*/
	static void DumpException(struct process* pcs, HANDLE hFile, RVA* rva)
	{
	MINIDUMP_EXCEPTION_STREAM mdExcpt;

	mdExcpt.ThreadId = DEBUG_CurrThread->tid;
	mdExcpt.__alignment = 0;
	mdExcpt.ExceptionRecord.

	ULONG ExceptionCode;
	ULONG ExceptionFlags;
	ULONGLONG ExceptionRecord;
	ULONGLONG ExceptionAddress;
	ULONG NumberParameters;
	ULONG __unusedAlignment;
	ULONGLONG ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
	}
	#endif

	/******************************************************************
	* dump_modules
	*
	* Write in File the modules from pcs
	*/
	static void dump_modules(struct process* pcs, HANDLE hFile, RVA* rva)
	{
	MINIDUMP_MODULE mdModule;
	MINIDUMP_MODULE_LIST mdModuleList;
	DWORD written;
	struct module* module = NULL;

	mdModuleList.NumberOfModules = 0;
	for (module = pcs->lmodules; module; module = module->next)
	mdModuleList.NumberOfModules++;
	WriteFile(hFile, &mdModuleList.NumberOfModules,
	sizeof(mdModuleList.NumberOfModules), &written, NULL);
	*rva += sizeof(mdModuleList.NumberOfModules) +
	sizeof(mdModule) * mdModuleList.NumberOfModules;
	for (module = pcs->lmodules; module; module = module->next)
	{
	mdModule.BaseOfImage = (DWORD)module->module.BaseOfImage;
	mdModule.SizeOfImage = module->module.ImageSize;
	mdModule.CheckSum = module->module.CheckSum;
	mdModule.TimeDateStamp = module->module.TimeDateStamp;
	mdModule.ModuleNameRva = *rva;
	*rva += strlen(module->module.ModuleName) + 1;
	memset(&mdModule.VersionInfo, 0, sizeof(mdModule.VersionInfo)); /* FIXME */
	mdModule.CvRecord.DataSize = 0; /* FIXME */
	mdModule.CvRecord.Rva = 0; /* FIXME */
	mdModule.MiscRecord.DataSize = 0; /* FIXME */
	mdModule.MiscRecord.Rva = 0; /* FIXME */
	mdModule.Reserved0 = 0;
	mdModule.Reserved1 = 0;
	WriteFile(hFile, &mdModule, sizeof(mdModule), &written, NULL);
	}
	for (module = pcs->lmodules; module; module = module->next)
	{
	WriteFile(hFile, module->module.ModuleName,
	strlen(module->module.ModuleName) + 1, &written, NULL);
	FIXME("CV and misc records not written\n");
	}
	}

	/******************************************************************
	* dump_system_info
	*
	* Dumps into File the information about the system
	*/
	static void dump_system_info(struct process* pcs, HANDLE hFile, RVA* rva)
	{
	MINIDUMP_SYSTEM_INFO mdSysInfo;
	SYSTEM_INFO sysInfo;
	OSVERSIONINFOA osInfo;
	DWORD written;

	GetSystemInfo(&sysInfo);
	GetVersionExA(&osInfo);

	mdSysInfo.ProcessorArchitecture = sysInfo.u.s.wProcessorArchitecture;
	mdSysInfo.ProcessorLevel = sysInfo.wProcessorLevel;
	mdSysInfo.ProcessorRevision = sysInfo.wProcessorRevision;
	mdSysInfo.Reserved0 = 0;

	mdSysInfo.MajorVersion = osInfo.dwMajorVersion;
	mdSysInfo.MinorVersion = osInfo.dwMinorVersion;
	mdSysInfo.BuildNumber = osInfo.dwBuildNumber;
	mdSysInfo.PlatformId = osInfo.dwPlatformId;

	mdSysInfo.CSDVersionRva = *rva + sizeof(mdSysInfo);
	mdSysInfo.Reserved1 = 0;

	WriteFile(hFile, &mdSysInfo, sizeof(mdSysInfo), &written, NULL);
	*rva += sizeof(mdSysInfo);
	WriteFile(hFile, osInfo.szCSDVersion, strlen(osInfo.szCSDVersion) + 1,
	&written, NULL);
	*rva += strlen(osInfo.szCSDVersion) + 1;
	}

	/******************************************************************
	* dump_threads
	*
	* Dumps into File the information about running threads
	*/
	static void dump_threads(struct process* pcs, HANDLE hFile, RVA* rva)
	{
	#if 0
	MINIDUMP_THREAD mdThd;
	MINIDUMP_THREAD_LIST mdThdList;
	DWORD written;
	DBG_THREAD* thd;

	mdThdList.NumberOfThreads = pcs->num_threads;
	WriteFile(hFile, &mdThdList.NumberOfThreads, sizeof(mdThdList.NumberOfThreads),
	&written, NULL);
	*rva += sizeof(mdThdList.NumberOfThreads) +
	mdThdList.NumberOfThreads * sizeof(mdThd);
	for (thd = pcs->threads; thd; thd = thd->next)
	{
	mdThd.ThreadId = thd->tid;
	mdThd.SuspendCount = 0; /* FIXME */
	mdThd.PriorityClass = 0; /* FIXME */
	mdThd.Priority = 0; /* FIXME */
	mdThd.Teb = 0; /* FIXME */
	mdThd.Stack.StartOfMemoryRange = 0; /* FIXME */
	mdThd.Stack.Memory.DataSize = 0; /* FIXME */
	mdThd.Stack.Memory.Rva = 0; /* FIXME */
	mdThd.ThreadContext.DataSize = 0;/* FIXME */
	mdThd.ThreadContext.Rva = 0; /* FIXME */

	WriteFile(hFile, &mdThd, sizeof(mdThd), &written, NULL);
	FIXME("Stack & thread context not written\n");
	}
	#endif
	}

	/******************************************************************
	* MiniDumpWriteDump (DEBUGHLP.@)
	*
	*
	*/
	BOOL WINAPI MiniDumpWriteDump(HANDLE hProcess, DWORD ProcessId, HANDLE hFile,
	MINIDUMP_TYPE DumpType,
	PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
	PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
	PMINIDUMP_CALLBACK_INFORMATION CallbackParam)
	{
	struct process* pcs;
	MINIDUMP_HEADER mdHead;
	MINIDUMP_DIRECTORY mdDir;
	DWORD currRva, written;
	DWORD i, nStream, addStream;
	RVA rva;

	pcs = process_find_by_handle(hProcess);
	if (!pcs) return FALSE; /* FIXME: should try to load it ??? */

	/* 1) init */

	nStream = UserStreamParam ? UserStreamParam->UserStreamCount : 0;
	addStream = 0;
	if (DumpType & MiniDumpNormal)
	addStream += 3; /* sure ? thread stack back trace */

	if (DumpType & MiniDumpWithDataSegs)
	FIXME("NIY MiniDumpWithDataSegs\n");
	if (DumpType & MiniDumpWithFullMemory)
	FIXME("NIY MiniDumpWithFullMemory\n");
	if (DumpType & MiniDumpWithHandleData)
	FIXME("NIY MiniDumpWithHandleData\n");
	if (DumpType & MiniDumpFilterMemory)
	FIXME("NIY MiniDumpFilterMemory\n");
	if (DumpType & MiniDumpScanMemory)
	FIXME("NIY MiniDumpScanMemory\n");

	/* 2) write header */
	rva = sizeof(mdHead);
	mdHead.Signature = MINIDUMP_SIGNATURE;
	mdHead.Version = MINIDUMP_VERSION;
	mdHead.NumberOfStreams = nStream + addStream;
	mdHead.StreamDirectoryRva = rva;
	mdHead.u.TimeDateStamp = time(NULL);
	mdHead.Flags = DumpType;
	WriteFile(hFile, &mdHead, sizeof(mdHead), &written, NULL);

	/* 3) write stream directories */
	rva += (nStream + addStream) * sizeof(mdDir);
	/* 3.1) write data stream directories */
	currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
	SetFilePointer(hFile, rva, NULL, FILE_BEGIN);
	mdDir.StreamType = ModuleListStream;
	mdDir.Location.Rva = rva;
	dump_modules(pcs, hFile, &rva);
	mdDir.Location.DataSize = SetFilePointer(hFile, 0, NULL, FILE_CURRENT) - mdDir.Location.Rva;
	SetFilePointer(hFile, currRva, NULL, FILE_BEGIN);
	WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL);

	currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
	SetFilePointer(hFile, rva, NULL, FILE_BEGIN);
	mdDir.StreamType = ThreadListStream;
	mdDir.Location.Rva = rva;
	dump_threads(pcs, hFile, &rva);
	mdDir.Location.DataSize = SetFilePointer(hFile, 0, NULL, FILE_CURRENT) - mdDir.Location.Rva;
	SetFilePointer(hFile, currRva, NULL, FILE_BEGIN);
	WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL);

	currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
	SetFilePointer(hFile, rva, NULL, FILE_BEGIN);
	mdDir.StreamType = SystemInfoStream;
	mdDir.Location.Rva = rva;
	dump_system_info(pcs, hFile, &rva);
	mdDir.Location.DataSize = SetFilePointer(hFile, 0, NULL, FILE_CURRENT) - mdDir.Location.Rva;
	SetFilePointer(hFile, currRva, NULL, FILE_BEGIN);
	WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL);

	/* 3.2) write user define stream */
	for (i = 0; i < nStream; i++)
	{
	mdDir.StreamType = UserStreamParam->UserStreamArray[i].Type;
	mdDir.Location.DataSize = UserStreamParam->UserStreamArray[i].BufferSize;
	mdDir.Location.Rva = rva;
	WriteFile(hFile, &mdDir, sizeof(mdDir), &written, NULL);
	currRva = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
	SetFilePointer(hFile, rva, NULL, FILE_BEGIN);
	WriteFile(hFile,
	UserStreamParam->UserStreamArray[i].Buffer,
	UserStreamParam->UserStreamArray[i].BufferSize,
	&written, NULL);
	rva += UserStreamParam->UserStreamArray[i].BufferSize;
	SetFilePointer(hFile, currRva, NULL, FILE_BEGIN);
	}

	return TRUE;
	}