install.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef enum _FILE_COPY_STATUS	FILE_COPY_STATUS
typedef VOID(__cdecl *	PFILE_COPY_STATUS_ROUTINE) (IN FILE_COPY_STATUS,...)

Enumerations
enum	_FILE_COPY_STATUS { None = 0 }

Functions
BOOLEAN	PrepareFileCopy (IN OUT PUSETUP_DATA pSetupData, IN PFILE_COPY_STATUS_ROUTINE StatusRoutine OPTIONAL)
BOOLEAN	DoFileCopy (IN OUT PUSETUP_DATA pSetupData, IN PSP_FILE_CALLBACK_W MsgHandler, IN PVOID Context OPTIONAL)

Typedef Documentation

FILE_COPY_STATUS

typedef enum _FILE_COPY_STATUS FILE_COPY_STATUS

PFILE_COPY_STATUS_ROUTINE

typedef VOID(__cdecl * PFILE_COPY_STATUS_ROUTINE) (IN FILE_COPY_STATUS,...)

Definition at line 18 of file install.h.

Enumeration Type Documentation

_FILE_COPY_STATUS

enum _FILE_COPY_STATUS

Enumerator
None

Definition at line 12 of file install.h.

{
    None = 0,
    // Success = 0,
} FILE_COPY_STATUS;

Function Documentation

DoFileCopy()

BOOLEAN DoFileCopy	(	IN OUT PUSETUP_DATA	pSetupData,
		IN PSP_FILE_CALLBACK_W	MsgHandler,
		IN PVOID Context	OPTIONAL
	)

Definition at line 818 of file install.c.

{
    BOOLEAN Success;
 
    Success = SpFileQueueCommit(NULL,
                                (HSPFILEQ)pSetupData->SetupFileQueue,
                                MsgHandler,
                                Context);
 
    SpFileQueueClose((HSPFILEQ)pSetupData->SetupFileQueue);
    pSetupData->SetupFileQueue = NULL;
 
    return Success;
}

Referenced by FileCopyPage(), and PrepareAndDoCopyThread().

PrepareFileCopy()

BOOLEAN PrepareFileCopy	(	IN OUT PUSETUP_DATA	pSetupData,
		IN PFILE_COPY_STATUS_ROUTINE StatusRoutine	OPTIONAL
	)

Definition at line 676 of file install.c.

{
    HINF InfHandle;
    INFCONTEXT CabinetsContext;
    PCWSTR CabinetName;
    UINT ErrorLine;
#if defined(__REACTOS__) && defined(USE_CABINET_INF)
    ULONG InfFileSize;
    PVOID InfFileData;
    CABINET_CONTEXT CabinetContext;
#endif
    WCHAR PathBuffer[MAX_PATH];
 
    /* Create the file queue */
    pSetupData->SetupFileQueue = (PVOID)SpFileQueueOpen();
    if (pSetupData->SetupFileQueue == NULL)
    {
        pSetupData->LastErrorNumber = ERROR_COPY_QUEUE;
        if (pSetupData->ErrorRoutine)
            pSetupData->ErrorRoutine(pSetupData);
        return FALSE;
    }
 
    /* Prepare the copy of the common files that are not in installation cabinets */
    if (!PrepareCopyInfFile(pSetupData, pSetupData->SetupInf, NULL))
    {
        /* FIXME: show an error dialog */
        return FALSE;
    }
 
    /* Search for the 'Cabinets' section */
    if (!SpInfFindFirstLine(pSetupData->SetupInf, L"Cabinets", NULL, &CabinetsContext))
    {
        /* Skip this step and return success if no cabinet file is listed */
        return TRUE;
    }
 
    /*
     * Enumerate the installation cabinets listed in the
     * 'Cabinets' section and parse their inf files.
     */
    do
    {
        if (!INF_GetData(&CabinetsContext, NULL, &CabinetName))
            break;
 
        CombinePaths(PathBuffer, ARRAYSIZE(PathBuffer), 2,
                     pSetupData->SourcePath.Buffer, CabinetName);
 
#if defined(__REACTOS__) && defined(USE_CABINET_INF)
        INF_FreeData(CabinetName);
 
        CabinetInitialize(&CabinetContext);
        CabinetSetEventHandlers(&CabinetContext, NULL, NULL, NULL);
        CabinetSetCabinetName(&CabinetContext, PathBuffer);
 
        if (CabinetOpen(&CabinetContext) == CAB_STATUS_SUCCESS)
        {
            DPRINT("Cabinet %S\n", PathBuffer);
 
            InfFileData = CabinetGetCabinetReservedArea(&CabinetContext, &InfFileSize);
            if (InfFileData == NULL)
            {
                CabinetCleanup(&CabinetContext);
 
                pSetupData->LastErrorNumber = ERROR_CABINET_SCRIPT;
                if (pSetupData->ErrorRoutine)
                    pSetupData->ErrorRoutine(pSetupData, PathBuffer);
                return FALSE;
            }
        }
        else
        {
            DPRINT("Cannot open cabinet: %S.\n", PathBuffer);
            CabinetCleanup(&CabinetContext);
 
            pSetupData->LastErrorNumber = ERROR_CABINET_MISSING;
            if (pSetupData->ErrorRoutine)
                pSetupData->ErrorRoutine(pSetupData, PathBuffer);
            return FALSE;
        }
 
        InfHandle = INF_OpenBufferedFileA((PSTR)InfFileData,
                                          InfFileSize,
                                          NULL,
                                          INF_STYLE_WIN4,
                                          pSetupData->LanguageId,
                                          &ErrorLine);
 
        CabinetCleanup(&CabinetContext);
#else
        {
        PWCHAR ptr;
 
        /* First find the filename */
        ptr = wcsrchr(PathBuffer, L'\\');
        if (!ptr) ptr = PathBuffer;
 
        /* Then find its extension */
        ptr = wcsrchr(ptr, L'.');
        if (!ptr)
            ptr = PathBuffer + wcslen(PathBuffer);
 
        /* Replace it by '.inf' */
        wcscpy(ptr, L".inf");
 
        InfHandle = SpInfOpenInfFile(PathBuffer,
                                     NULL,
                                     INF_STYLE_WIN4,
                                     pSetupData->LanguageId,
                                     &ErrorLine);
        }
#endif
 
        if (InfHandle == INVALID_HANDLE_VALUE)
        {
            pSetupData->LastErrorNumber = ERROR_INVALID_CABINET_INF;
            if (pSetupData->ErrorRoutine)
                pSetupData->ErrorRoutine(pSetupData, PathBuffer);
            return FALSE;
        }
 
        if (!PrepareCopyInfFile(pSetupData, InfHandle, CabinetName))
        {
#if !(defined(__REACTOS__) && defined(USE_CABINET_INF))
            SpInfCloseInfFile(InfHandle);
#endif
            /* FIXME: show an error dialog */
            return FALSE;
        }
 
#if !(defined(__REACTOS__) && defined(USE_CABINET_INF))
        SpInfCloseInfFile(InfHandle);
#endif
    } while (SpInfFindNextLine(&CabinetsContext, &CabinetsContext));
 
    return TRUE;
}

Referenced by PrepareAndDoCopyThread(), and PrepareCopyPage().