#include <stdarg.h>
#include "windef.h"
#include "winerror.h"
#include "wine/debug.h"
#include "fdi.h"
#include "msipriv.h"
#include "winuser.h"
#include "winreg.h"
#include "shlwapi.h"
#include "objidl.h"
#include "resource.h"

Include dependency graph for media.c:

Classes
struct	package_disk

Macros
#define	COBJMACROS

#define	_O_RDONLY 0

#define	_O_WRONLY 1

#define	_O_RDWR 2

#define	_O_ACCMODE (_O_RDONLY\|_O_WRONLY\|_O_RDWR)

#define	_O_APPEND 0x0008

#define	_O_RANDOM 0x0010

#define	_O_SEQUENTIAL 0x0020

#define	_O_TEMPORARY 0x0040

#define	_O_NOINHERIT 0x0080

#define	_O_CREAT 0x0100

#define	_O_TRUNC 0x0200

#define	_O_EXCL 0x0400

#define	_O_SHORT_LIVED 0x1000

#define	_O_TEXT 0x4000

#define	_O_BINARY 0x8000

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msi)

static BOOL	source_matches_volume (MSIMEDIAINFO *mi, LPCWSTR source_root)

static UINT	msi_change_media (MSIPACKAGE package, MSIMEDIAINFO mi)

static MSICABINETSTREAM *	msi_get_cabinet_stream (MSIPACKAGE *package, UINT disk_id)

static void *CDECL	cabinet_alloc (ULONG cb)

static void CDECL	cabinet_free (void *pv)

static INT_PTR CDECL	cabinet_open (char *pszFile, int oflag, int pmode)

static UINT CDECL	cabinet_read (INT_PTR hf, void *pv, UINT cb)

static UINT CDECL	cabinet_write (INT_PTR hf, void *pv, UINT cb)

static int CDECL	cabinet_close (INT_PTR hf)

static LONG CDECL	cabinet_seek (INT_PTR hf, LONG dist, int seektype)

static INT_PTR CDECL	cabinet_open_stream (char *pszFile, int oflag, int pmode)

static UINT CDECL	cabinet_read_stream (INT_PTR hf, void *pv, UINT cb)

static int CDECL	cabinet_close_stream (INT_PTR hf)

static LONG CDECL	cabinet_seek_stream (INT_PTR hf, LONG dist, int seektype)

static UINT	msi_media_get_disk_info (MSIPACKAGE package, MSIMEDIAINFO mi)

static INT_PTR	cabinet_partial_file (FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)

static WCHAR *	get_cabinet_filename (MSIMEDIAINFO *mi)

static INT_PTR	cabinet_next_cabinet (FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)

static INT_PTR	cabinet_next_cabinet_stream (FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)

static INT_PTR	cabinet_copy_file (FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)

static INT_PTR	cabinet_close_file_info (FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)

static INT_PTR CDECL	cabinet_notify (FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)

static INT_PTR CDECL	cabinet_notify_stream (FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)

static BOOL	extract_cabinet (MSIPACKAGE package, MSIMEDIAINFO mi, LPVOID data)

static BOOL	extract_cabinet_stream (MSIPACKAGE package, MSIMEDIAINFO mi, LPVOID data)

BOOL	msi_cabextract (MSIPACKAGE package, MSIMEDIAINFO mi, LPVOID data)

void	msi_free_media_info (MSIMEDIAINFO *mi)

static UINT	get_drive_type (const WCHAR *path)

static WCHAR *	get_base_url (MSIDATABASE *db)

UINT	msi_load_media_info (MSIPACKAGE package, UINT Sequence, MSIMEDIAINFO mi)

static UINT	find_published_source (MSIPACKAGE package, MSIMEDIAINFO mi)

UINT	ready_media (MSIPACKAGE package, BOOL compressed, MSIMEDIAINFO mi)

UINT	msi_add_cabinet_stream (MSIPACKAGE package, UINT disk_id, IStorage storage, const WCHAR *name)

Variables
static struct package_disk	package_disk

Macro Definition Documentation

◆ _O_ACCMODE

#define _O_ACCMODE (_O_RDONLY|_O_WRONLY|_O_RDWR)

Definition at line 42 of file media.c.

◆ _O_APPEND

#define _O_APPEND 0x0008

Definition at line 43 of file media.c.

◆ _O_BINARY

#define _O_BINARY 0x8000

Definition at line 53 of file media.c.

◆ _O_CREAT

#define _O_CREAT 0x0100

Definition at line 48 of file media.c.

◆ _O_EXCL

#define _O_EXCL 0x0400

Definition at line 50 of file media.c.

◆ _O_NOINHERIT

#define _O_NOINHERIT 0x0080

Definition at line 47 of file media.c.

◆ _O_RANDOM

#define _O_RANDOM 0x0010

Definition at line 44 of file media.c.

◆ _O_RDONLY

#define _O_RDONLY 0

Definition at line 39 of file media.c.

◆ _O_RDWR

#define _O_RDWR 2

Definition at line 41 of file media.c.

◆ _O_SEQUENTIAL

#define _O_SEQUENTIAL 0x0020

Definition at line 45 of file media.c.

◆ _O_SHORT_LIVED

#define _O_SHORT_LIVED 0x1000

Definition at line 51 of file media.c.

◆ _O_TEMPORARY

#define _O_TEMPORARY 0x0040

Definition at line 46 of file media.c.

◆ _O_TEXT

#define _O_TEXT 0x4000

Definition at line 52 of file media.c.

◆ _O_TRUNC

#define _O_TRUNC 0x0200

Definition at line 49 of file media.c.

◆ _O_WRONLY

#define _O_WRONLY 1

Definition at line 40 of file media.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 23 of file media.c.

Function Documentation

◆ cabinet_alloc()

static void* CDECL cabinet_alloc ( ULONG cb )

static

Definition at line 113 of file media.c.

 {
     return msi_alloc(cb);
 }

Referenced by extract_cabinet(), and extract_cabinet_stream().

◆ cabinet_close()

static int CDECL cabinet_close ( INT_PTR hf )

static

Definition at line 176 of file media.c.

 {
     HANDLE handle = (HANDLE)hf;
     return CloseHandle(handle) ? 0 : -1;
 }

Referenced by extract_cabinet().

◆ cabinet_close_file_info()

static INT_PTR cabinet_close_file_info	(	FDINOTIFICATIONTYPE	fdint,
		PFDINOTIFICATION	pfdin
	)

static

Definition at line 498 of file media.c.

 {
     MSICABDATA *data = pfdin->pv;
     FILETIME ft;
     FILETIME ftLocal;
     HANDLE handle = (HANDLE)pfdin->hf;
 
     data->mi->is_continuous = FALSE;
 
     if (!DosDateTimeToFileTime(pfdin->date, pfdin->time, &ft))
     {
         CloseHandle(handle);
         return -1;
     }
     if (!LocalFileTimeToFileTime(&ft, &ftLocal))
     {
         CloseHandle(handle);
         return -1;
     }
     if (!SetFileTime(handle, &ftLocal, 0, &ftLocal))
     {
         CloseHandle(handle);
         return -1;
     }
 
     CloseHandle(handle);
     data->cb(data->package, data->curfile, MSICABEXTRACT_FILEEXTRACTED, NULL, NULL, data->user);
 
     msi_free(data->curfile);
     data->curfile = NULL;
 
     return 1;
 }

Referenced by cabinet_notify(), and cabinet_notify_stream().

◆ cabinet_close_stream()

static int CDECL cabinet_close_stream ( INT_PTR hf )

static

Definition at line 250 of file media.c.

 {
     IStream *stm = (IStream *)hf;
     IStream_Release( stm );
     return 0;
 }

Referenced by extract_cabinet_stream().

◆ cabinet_copy_file()

static INT_PTR cabinet_copy_file	(	FDINOTIFICATIONTYPE	fdint,
		PFDINOTIFICATION	pfdin
	)

static

Definition at line 413 of file media.c.

 {
     MSICABDATA *data = pfdin->pv;
     HANDLE handle = 0;
     LPWSTR path = NULL;
     DWORD attrs;
 
     data->curfile = strdupAtoW(pfdin->psz1);
     if (!data->cb(data->package, data->curfile, MSICABEXTRACT_BEGINEXTRACT, &path,
                   &attrs, data->user))
     {
         /* We're not extracting this file, so free the filename. */
         msi_free(data->curfile);
         data->curfile = NULL;
         goto done;
     }
 
     TRACE("extracting %s -> %s\n", debugstr_w(data->curfile), debugstr_w(path));
 
     attrs = attrs & (FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM);
     if (!attrs) attrs = FILE_ATTRIBUTE_NORMAL;
 
     handle = msi_create_file( data->package, path, GENERIC_READ | GENERIC_WRITE, 0, CREATE_ALWAYS, attrs );
     if (handle == INVALID_HANDLE_VALUE)
     {
         DWORD err = GetLastError();
         DWORD attrs2 = msi_get_file_attributes( data->package, path );
 
         if (attrs2 == INVALID_FILE_ATTRIBUTES)
         {
             ERR( "failed to create %s (error %lu)\n", debugstr_w(path), err );
             goto done;
         }
         else if (err == ERROR_ACCESS_DENIED && (attrs2 & FILE_ATTRIBUTE_READONLY))
         {
             TRACE("removing read-only attribute on %s\n", debugstr_w(path));
             msi_set_file_attributes( data->package, path, attrs2 & ~FILE_ATTRIBUTE_READONLY );
             handle = msi_create_file( data->package, path, GENERIC_READ | GENERIC_WRITE, 0, CREATE_ALWAYS, attrs );
 
             if (handle != INVALID_HANDLE_VALUE) goto done;
             err = GetLastError();
         }
         if (err == ERROR_SHARING_VIOLATION || err == ERROR_USER_MAPPED_FILE)
         {
             WCHAR *tmpfileW, *tmppathW, *p;
             DWORD len;
 
             TRACE("file in use, scheduling rename operation\n");
 
             if (!(tmppathW = strdupW( path ))) return ERROR_OUTOFMEMORY;
             if ((p = wcsrchr(tmppathW, '\\'))) *p = 0;
             len = lstrlenW( tmppathW ) + 16;
             if (!(tmpfileW = msi_alloc(len * sizeof(WCHAR))))
             {
                 msi_free( tmppathW );
                 return ERROR_OUTOFMEMORY;
             }
             if (!GetTempFileNameW(tmppathW, L"msi", 0, tmpfileW)) tmpfileW[0] = 0;
             msi_free( tmppathW );
 
             handle = CreateFileW(tmpfileW, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, attrs, NULL);
 
             if (handle != INVALID_HANDLE_VALUE &&
                 msi_move_file( data->package, path, NULL, MOVEFILE_DELAY_UNTIL_REBOOT ) &&
                 msi_move_file( data->package, tmpfileW, path, MOVEFILE_DELAY_UNTIL_REBOOT ))
             {
                 data->package->need_reboot_at_end = 1;
             }
             else
             {
                 WARN( "failed to schedule rename operation %s (error %lu)\n", debugstr_w(path), GetLastError() );
                 DeleteFileW( tmpfileW );
             }
             msi_free(tmpfileW);
         }
         else WARN( "failed to create %s (error %lu)\n", debugstr_w(path), err );
     }
 
 done:
     msi_free(path);
 
     return (INT_PTR)handle;
 }

Referenced by cabinet_notify(), and cabinet_notify_stream().

◆ cabinet_free()

static void CDECL cabinet_free ( void * pv )

static

Definition at line 118 of file media.c.

 {
     msi_free(pv);
 }

Referenced by extract_cabinet(), and extract_cabinet_stream().

◆ cabinet_next_cabinet()

static INT_PTR cabinet_next_cabinet	(	FDINOTIFICATIONTYPE	fdint,
		PFDINOTIFICATION	pfdin
	)

static

Definition at line 313 of file media.c.

 {
     MSICABDATA *data = pfdin->pv;
     MSIMEDIAINFO *mi = data->mi;
     LPWSTR cabinet_file = NULL, cab = strdupAtoW(pfdin->psz1);
     INT_PTR res = -1;
     UINT rc;
 
     msi_free(mi->disk_prompt);
     msi_free(mi->cabinet);
     msi_free(mi->volume_label);
     mi->disk_prompt = NULL;
     mi->cabinet = NULL;
     mi->volume_label = NULL;
 
     mi->disk_id++;
     mi->is_continuous = TRUE;
 
     rc = msi_media_get_disk_info(data->package, mi);
     if (rc != ERROR_SUCCESS)
     {
         ERR("Failed to get next cabinet information: %d\n", rc);
         goto done;
     }
 
     if (wcsicmp( mi->cabinet, cab ))
     {
         char *next_cab;
         ULONG length;
 
         WARN("Continuous cabinet %s does not match the next cabinet %s in the media table => use latter one\n", debugstr_w(cab), debugstr_w(mi->cabinet));
 
         /* Use cabinet name from the media table */
         next_cab = strdupWtoA(mi->cabinet);
         /* Modify path to cabinet file with full filename (psz3 points to a 256 bytes buffer that can be modified contrary to psz1 and psz2) */
         length = strlen(pfdin->psz3) + 1 + strlen(next_cab) + 1;
         if (length > 256)
         {
             WARN( "cannot update next cabinet filename with a string size %lu > 256\n", length );
             msi_free(next_cab);
             goto done;
         }
         else
         {
             strcat(pfdin->psz3, "\\");
             strcat(pfdin->psz3, next_cab);
         }
         /* Path psz3 and cabinet psz1 are concatenated by FDI so just reset psz1 */
         *pfdin->psz1 = 0;
         msi_free(next_cab);
     }
 
     if (!(cabinet_file = get_cabinet_filename(mi)))
         goto done;
 
     TRACE("Searching for %s\n", debugstr_w(cabinet_file));
 
     res = 0;
     if (GetFileAttributesW(cabinet_file) == INVALID_FILE_ATTRIBUTES)
     {
         if (msi_change_media(data->package, mi) != ERROR_SUCCESS)
             res = -1;
     }
 
 done:
     msi_free(cab);
     msi_free(cabinet_file);
     return res;
 }

Referenced by cabinet_notify().

◆ cabinet_next_cabinet_stream()

static INT_PTR cabinet_next_cabinet_stream	(	FDINOTIFICATIONTYPE	fdint,
		PFDINOTIFICATION	pfdin
	)

static

Definition at line 384 of file media.c.

 {
     MSICABDATA *data = pfdin->pv;
     MSIMEDIAINFO *mi = data->mi;
     UINT rc;
 
     msi_free( mi->disk_prompt );
     msi_free( mi->cabinet );
     msi_free( mi->volume_label );
     mi->disk_prompt = NULL;
     mi->cabinet = NULL;
     mi->volume_label = NULL;
 
     mi->disk_id++;
     mi->is_continuous = TRUE;
 
     rc = msi_media_get_disk_info( data->package, mi );
     if (rc != ERROR_SUCCESS)
     {
         ERR("Failed to get next cabinet information: %u\n", rc);
         return -1;
     }
     package_disk.id = mi->disk_id;
 
     TRACE("next cabinet is %s disk id %u\n", debugstr_w(mi->cabinet), mi->disk_id);
     return 0;
 }

Referenced by cabinet_notify_stream().

◆ cabinet_notify()

static INT_PTR CDECL cabinet_notify	(	FDINOTIFICATIONTYPE	fdint,
		PFDINOTIFICATION	pfdin
	)

static

Definition at line 533 of file media.c.

 {
     switch (fdint)
     {
     case fdintPARTIAL_FILE:
         return cabinet_partial_file(fdint, pfdin);
 
     case fdintNEXT_CABINET:
         return cabinet_next_cabinet(fdint, pfdin);
 
     case fdintCOPY_FILE:
         return cabinet_copy_file(fdint, pfdin);
 
     case fdintCLOSE_FILE_INFO:
         return cabinet_close_file_info(fdint, pfdin);
 
     default:
         return 0;
     }
 }

Referenced by extract_cabinet().

◆ cabinet_notify_stream()

static INT_PTR CDECL cabinet_notify_stream	(	FDINOTIFICATIONTYPE	fdint,
		PFDINOTIFICATION	pfdin
	)

static

Definition at line 554 of file media.c.

 {
     switch (fdint)
     {
     case fdintPARTIAL_FILE:
         return cabinet_partial_file( fdint, pfdin );
 
     case fdintNEXT_CABINET:
         return cabinet_next_cabinet_stream( fdint, pfdin );
 
     case fdintCOPY_FILE:
         return cabinet_copy_file( fdint, pfdin );
 
     case fdintCLOSE_FILE_INFO:
         return cabinet_close_file_info( fdint, pfdin );
 
     case fdintCABINET_INFO:
         return 0;
 
     default:
         ERR("Unexpected notification %d\n", fdint);
         return 0;
     }
 }

Referenced by extract_cabinet_stream().

◆ cabinet_open()

static INT_PTR CDECL cabinet_open	(	char *	pszFile,
		int	oflag,
		int	pmode
	)

static

Definition at line 123 of file media.c.

 {
     DWORD dwAccess = 0;
     DWORD dwShareMode = 0;
     DWORD dwCreateDisposition = OPEN_EXISTING;
 
     switch (oflag & _O_ACCMODE)
     {
     case _O_RDONLY:
         dwAccess = GENERIC_READ;
         dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE;
         break;
     case _O_WRONLY:
         dwAccess = GENERIC_WRITE;
         dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
         break;
     case _O_RDWR:
         dwAccess = GENERIC_READ | GENERIC_WRITE;
         dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
         break;
     }
 
     if ((oflag & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL))
         dwCreateDisposition = CREATE_NEW;
     else if (oflag & _O_CREAT)
         dwCreateDisposition = CREATE_ALWAYS;
 
     return (INT_PTR)CreateFileA(pszFile, dwAccess, dwShareMode, NULL,
                                 dwCreateDisposition, 0, NULL);
 }

Referenced by extract_cabinet().

◆ cabinet_open_stream()

static INT_PTR CDECL cabinet_open_stream	(	char *	pszFile,
		int	oflag,
		int	pmode
	)

static

Definition at line 197 of file media.c.

 {
     MSICABINETSTREAM *cab;
     IStream *stream;
 
     if (!(cab = msi_get_cabinet_stream( package_disk.package, package_disk.id )))
     {
         WARN("failed to get cabinet stream\n");
         return -1;
     }
     if (cab->storage == package_disk.package->db->storage)
     {
         UINT r = msi_get_stream( package_disk.package->db, cab->stream + 1, &stream );
         if (r != ERROR_SUCCESS)
         {
             WARN("failed to get stream %u\n", r);
             return -1;
         }
     }
     else /* patch storage */
     {
         HRESULT hr;
         WCHAR *encoded;
 
         if (!(encoded = encode_streamname( FALSE, cab->stream + 1 )))
         {
             WARN("failed to encode stream name\n");
             return -1;
         }
         hr = IStorage_OpenStream( cab->storage, encoded, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE, 0, &stream );
         msi_free( encoded );
         if (FAILED(hr))
         {
             WARN( "failed to open stream %#lx\n", hr );
             return -1;
         }
     }
     return (INT_PTR)stream;
 }

Referenced by extract_cabinet_stream().

◆ cabinet_partial_file()

static INT_PTR cabinet_partial_file	(	FDINOTIFICATIONTYPE	fdint,
		PFDINOTIFICATION	pfdin
	)

static

Definition at line 293 of file media.c.

 {
     MSICABDATA *data = pfdin->pv;
     data->mi->is_continuous = FALSE;
     return 0;
 }

Referenced by cabinet_notify(), and cabinet_notify_stream().

◆ cabinet_read()

static UINT CDECL cabinet_read	(	INT_PTR	hf,
		void *	pv,
		UINT	cb
	)

static

Definition at line 154 of file media.c.

 {
     HANDLE handle = (HANDLE)hf;
     DWORD read;
 
     if (ReadFile(handle, pv, cb, &read, NULL))
         return read;
 
     return 0;
 }

Referenced by extract_cabinet().

◆ cabinet_read_stream()

static UINT CDECL cabinet_read_stream	(	INT_PTR	hf,
		void *	pv,
		UINT	cb
	)

static

Definition at line 237 of file media.c.

 {
     IStream *stm = (IStream *)hf;
     DWORD read;
     HRESULT hr;
 
     hr = IStream_Read( stm, pv, cb, &read );
     if (hr == S_OK || hr == S_FALSE)
         return read;
 
     return 0;
 }

Referenced by extract_cabinet_stream().

◆ cabinet_seek()

static LONG CDECL cabinet_seek	(	INT_PTR	hf,
		LONG	dist,
		int	seektype
	)

static

Definition at line 182 of file media.c.

 {
     HANDLE handle = (HANDLE)hf;
     /* flags are compatible and so are passed straight through */
     return SetFilePointer(handle, dist, NULL, seektype);
 }

Referenced by extract_cabinet().

◆ cabinet_seek_stream()

static LONG CDECL cabinet_seek_stream	(	INT_PTR	hf,
		LONG	dist,
		int	seektype
	)

static

Definition at line 257 of file media.c.

 {
     IStream *stm = (IStream *)hf;
     LARGE_INTEGER move;
     ULARGE_INTEGER newpos;
     HRESULT hr;
 
     move.QuadPart = dist;
     hr = IStream_Seek( stm, move, seektype, &newpos );
     if (SUCCEEDED(hr))
     {
         if (newpos.QuadPart <= MAXLONG) return newpos.QuadPart;
         ERR("Too big!\n");
     }
     return -1;
 }

Referenced by extract_cabinet_stream().

◆ cabinet_write()

static UINT CDECL cabinet_write	(	INT_PTR	hf,
		void *	pv,
		UINT	cb
	)

static

Definition at line 165 of file media.c.

 {
     HANDLE handle = (HANDLE)hf;
     DWORD written;
 
     if (WriteFile(handle, pv, cb, &written, NULL))
         return written;
 
     return 0;
 }

Referenced by extract_cabinet(), and extract_cabinet_stream().

◆ extract_cabinet()

static BOOL extract_cabinet	(	MSIPACKAGE *	package,
		MSIMEDIAINFO *	mi,
		LPVOID	data
	)

static

Definition at line 579 of file media.c.

 {
     LPSTR cabinet, cab_path = NULL;
     HFDI hfdi;
     ERF erf;
     BOOL ret = FALSE;
 
     TRACE("extracting %s disk id %u\n", debugstr_w(mi->cabinet), mi->disk_id);
 
     hfdi = FDICreate( cabinet_alloc, cabinet_free, cabinet_open, cabinet_read,
                       cabinet_write, cabinet_close, cabinet_seek, 0, &erf );
     if (!hfdi)
     {
         ERR("FDICreate failed\n");
         return FALSE;
     }
 
     cabinet = strdupWtoA( mi->cabinet );
     if (!cabinet)
         goto done;
 
     cab_path = strdupWtoA( mi->sourcedir );
     if (!cab_path)
         goto done;
 
     ret = FDICopy( hfdi, cabinet, cab_path, 0, cabinet_notify, NULL, data );
     if (!ret)
         ERR("FDICopy failed\n");
 
 done:
     FDIDestroy( hfdi );
     msi_free(cabinet );
     msi_free( cab_path );
 
     if (ret)
         mi->is_extracted = TRUE;
 
     return ret;
 }

Referenced by msi_cabextract().

◆ extract_cabinet_stream()

static BOOL extract_cabinet_stream	(	MSIPACKAGE *	package,
		MSIMEDIAINFO *	mi,
		LPVOID	data
	)

static

Definition at line 619 of file media.c.

 {
     static char filename[] = {'<','S','T','R','E','A','M','>',0};
     HFDI hfdi;
     ERF erf;
     BOOL ret = FALSE;
 
     TRACE("extracting %s disk id %u\n", debugstr_w(mi->cabinet), mi->disk_id);
 
     hfdi = FDICreate( cabinet_alloc, cabinet_free, cabinet_open_stream, cabinet_read_stream,
                       cabinet_write, cabinet_close_stream, cabinet_seek_stream, 0, &erf );
     if (!hfdi)
     {
         ERR("FDICreate failed\n");
         return FALSE;
     }
 
     package_disk.package = package;
     package_disk.id      = mi->disk_id;
 
     ret = FDICopy( hfdi, filename, NULL, 0, cabinet_notify_stream, NULL, data );
     if (!ret) ERR("FDICopy failed\n");
 
     FDIDestroy( hfdi );
     if (ret) mi->is_extracted = TRUE;
     return ret;
 }

Referenced by msi_cabextract().

◆ find_published_source()

static UINT find_published_source	(	MSIPACKAGE *	package,
		MSIMEDIAINFO *	mi
	)

static

Definition at line 754 of file media.c.

 {
     WCHAR source[MAX_PATH];
     WCHAR volume[MAX_PATH];
     WCHAR prompt[MAX_PATH];
     DWORD volumesz, promptsz;
     DWORD index, size, id;
     WCHAR last_type[2];
     UINT r;
 
     size = 2;
     r = MsiSourceListGetInfoW(package->ProductCode, NULL,
                               package->Context, MSICODE_PRODUCT,
                               INSTALLPROPERTY_LASTUSEDTYPEW, last_type, &size);
     if (r != ERROR_SUCCESS)
         return r;
 
     size = MAX_PATH;
     r = MsiSourceListGetInfoW(package->ProductCode, NULL,
                               package->Context, MSICODE_PRODUCT,
                               INSTALLPROPERTY_LASTUSEDSOURCEW, source, &size);
     if (r != ERROR_SUCCESS)
         return r;
 
     if (last_type[0] == 'n')
     {
         WCHAR cabinet_file[MAX_PATH];
         BOOL check_all = FALSE;
 
         while(TRUE)
         {
             index = 0;
             volumesz = MAX_PATH;
             while (MsiSourceListEnumSourcesW(package->ProductCode, NULL,
                                              package->Context,
                                              MSISOURCETYPE_NETWORK, index++,
                                              volume, &volumesz) == ERROR_SUCCESS)
             {
                 if (check_all || !wcsnicmp(source, volume, lstrlenW(source)))
                 {
                     lstrcpyW(cabinet_file, volume);
                     PathAddBackslashW(cabinet_file);
                     lstrcatW(cabinet_file, mi->cabinet);
 
                     if (GetFileAttributesW(cabinet_file) == INVALID_FILE_ATTRIBUTES)
                     {
                         volumesz = MAX_PATH;
                         if(!check_all)
                             break;
                         continue;
                     }
 
                     lstrcpyW(mi->sourcedir, volume);
                     PathAddBackslashW(mi->sourcedir);
                     TRACE("Found network source %s\n", debugstr_w(mi->sourcedir));
                     return ERROR_SUCCESS;
                 }
             }
 
             if (!check_all)
                 check_all = TRUE;
             else
                 break;
         }
     }
 
     index = 0;
     volumesz = MAX_PATH;
     promptsz = MAX_PATH;
     while (MsiSourceListEnumMediaDisksW(package->ProductCode, NULL,
                                         package->Context,
                                         MSICODE_PRODUCT, index++, &id,
                                         volume, &volumesz, prompt, &promptsz) == ERROR_SUCCESS)
     {
         mi->disk_id = id;
         msi_free( mi->volume_label );
         if (!(mi->volume_label = msi_alloc( ++volumesz * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
         lstrcpyW( mi->volume_label, volume );
 
         msi_free( mi->disk_prompt );
         if (!(mi->disk_prompt = msi_alloc( ++promptsz * sizeof(WCHAR) ))) return ERROR_OUTOFMEMORY;
         lstrcpyW( mi->disk_prompt, prompt );
 
         if (source_matches_volume(mi, source))
         {
             /* FIXME: what about SourceDir */
             lstrcpyW(mi->sourcedir, source);
             PathAddBackslashW(mi->sourcedir);
             TRACE("Found disk source %s\n", debugstr_w(mi->sourcedir));
             return ERROR_SUCCESS;
         }
     }
 
     return ERROR_FUNCTION_FAILED;
 }

Referenced by ready_media().

◆ get_base_url()

static WCHAR* get_base_url ( MSIDATABASE * db )

static

Definition at line 681 of file media.c.

 {
     WCHAR *p, *ret = NULL, *orig_db = msi_dup_property( db, L"OriginalDatabase" );
     if (UrlIsW( orig_db, URLIS_URL ) && (ret = strdupW( orig_db )) && (p = wcsrchr( ret, '/'))) p[1] = 0;
     msi_free( orig_db );
     return ret;
 }

Referenced by msi_load_media_info(), and ready_media().

◆ get_cabinet_filename()

static WCHAR* get_cabinet_filename ( MSIMEDIAINFO * mi )

static

Definition at line 301 of file media.c.

 {
     int len;
     WCHAR *ret;
 
     len = lstrlenW(mi->sourcedir) + lstrlenW(mi->cabinet) + 1;
     if (!(ret = msi_alloc(len * sizeof(WCHAR)))) return NULL;
     lstrcpyW(ret, mi->sourcedir);
     lstrcatW(ret, mi->cabinet);
     return ret;
 }

Referenced by cabinet_next_cabinet(), and ready_media().

◆ get_drive_type()

static UINT get_drive_type ( const WCHAR * path )

static

Definition at line 670 of file media.c.

 {
     WCHAR root[MAX_PATH + 1];
 
     lstrcpyW(root, path);
     PathStripToRootW(root);
     PathAddBackslashW(root);
 
     return GetDriveTypeW(root);
 }

Referenced by msi_load_media_info().

◆ msi_add_cabinet_stream()

UINT msi_add_cabinet_stream	(	MSIPACKAGE *	package,
		UINT	disk_id,
		IStorage *	storage,
		const WCHAR *	name
	)

Definition at line 935 of file media.c.

 {
     MSICABINETSTREAM *cab, *item;
 
     TRACE("%p, %u, %p, %s\n", package, disk_id, storage, debugstr_w(name));
 
     LIST_FOR_EACH_ENTRY( item, &package->cabinet_streams, MSICABINETSTREAM, entry )
     {
         if (item->disk_id == disk_id)
         {
             TRACE("duplicate disk id %u\n", disk_id);
             return ERROR_FUNCTION_FAILED;
         }
     }
     if (!(cab = msi_alloc( sizeof(*cab) ))) return ERROR_OUTOFMEMORY;
     if (!(cab->stream = msi_alloc( (lstrlenW( name ) + 1) * sizeof(WCHAR ) )))
     {
         msi_free( cab );
         return ERROR_OUTOFMEMORY;
     }
     lstrcpyW( cab->stream, name );
     cab->disk_id = disk_id;
     cab->storage = storage;
     IStorage_AddRef( storage );
     list_add_tail( &package->cabinet_streams, &cab->entry );
 
     return ERROR_SUCCESS;
 }

Referenced by load_media(), and patch_add_media().

◆ msi_cabextract()

BOOL msi_cabextract	(	MSIPACKAGE *	package,
		MSIMEDIAINFO *	mi,
		LPVOID	data
	)

Definition at line 652 of file media.c.

 {
     if (mi->cabinet[0] == '#')
     {
         return extract_cabinet_stream( package, mi, data );
     }
     return extract_cabinet( package, mi, data );
 }

Referenced by ACTION_InstallFiles(), and ACTION_PatchFiles().

◆ msi_change_media()

static UINT msi_change_media	(	MSIPACKAGE *	package,
		MSIMEDIAINFO *	mi
	)

static

Definition at line 79 of file media.c.

 {
     MSIRECORD *record;
     LPWSTR source_dir;
     UINT r = IDRETRY;
 
     source_dir = msi_dup_property(package->db, L"SourceDir");
     record = MSI_CreateRecord(2);
 
     while (r == IDRETRY && !source_matches_volume(mi, source_dir))
     {
         MSI_RecordSetStringW(record, 0, NULL);
         MSI_RecordSetInteger(record, 1, MSIERR_CABNOTFOUND);
         MSI_RecordSetStringW(record, 2, mi->disk_prompt);
         r = MSI_ProcessMessage(package, INSTALLMESSAGE_ERROR | MB_RETRYCANCEL, record);
     }
 
     msiobj_release(&record->hdr);
     msi_free(source_dir);
 
     return r == IDRETRY ? ERROR_SUCCESS : ERROR_INSTALL_SOURCE_ABSENT;
 }

Referenced by cabinet_next_cabinet(), and ready_media().

◆ msi_free_media_info()

void msi_free_media_info ( MSIMEDIAINFO * mi )

Definition at line 661 of file media.c.

 {
     msi_free(mi->disk_prompt);
     msi_free(mi->cabinet);
     msi_free(mi->volume_label);
     msi_free(mi->last_volume);
     msi_free(mi);
 }

Referenced by ACTION_InstallFiles(), and ACTION_PatchFiles().

◆ msi_get_cabinet_stream()

static MSICABINETSTREAM* msi_get_cabinet_stream	(	MSIPACKAGE *	package,
		UINT	disk_id
	)

static

Definition at line 102 of file media.c.

 {
     MSICABINETSTREAM *cab;
 
     LIST_FOR_EACH_ENTRY( cab, &package->cabinet_streams, MSICABINETSTREAM, entry )
     {
         if (cab->disk_id == disk_id) return cab;
     }
     return NULL;
 }

Referenced by cabinet_open_stream().

◆ msi_load_media_info()

UINT msi_load_media_info	(	MSIPACKAGE *	package,
		UINT	Sequence,
		MSIMEDIAINFO *	mi
	)

Definition at line 689 of file media.c.

 {
     MSIRECORD *row;
     WCHAR *source_dir, *source, *base_url = NULL;
     DWORD options;
 
     if (Sequence <= mi->last_sequence) /* already loaded */
         return ERROR_SUCCESS;
 
     row = MSI_QueryGetRecord(package->db, L"SELECT * FROM `Media` WHERE `LastSequence` >= %d ORDER BY `DiskId`", Sequence);
     if (!row)
     {
         TRACE("Unable to query row\n");
         return ERROR_FUNCTION_FAILED;
     }
 
     mi->is_extracted = FALSE;
     mi->disk_id = MSI_RecordGetInteger(row, 1);
     mi->last_sequence = MSI_RecordGetInteger(row, 2);
     msi_free(mi->disk_prompt);
     mi->disk_prompt = strdupW(MSI_RecordGetString(row, 3));
     msi_free(mi->cabinet);
     mi->cabinet = strdupW(MSI_RecordGetString(row, 4));
     msi_free(mi->volume_label);
     mi->volume_label = strdupW(MSI_RecordGetString(row, 5));
     msiobj_release(&row->hdr);
 
     msi_set_sourcedir_props(package, FALSE);
     source_dir = msi_dup_property(package->db, L"SourceDir");
     lstrcpyW(mi->sourcedir, source_dir);
     PathAddBackslashW(mi->sourcedir);
     mi->type = get_drive_type(source_dir);
 
     options = MSICODE_PRODUCT;
     if (mi->type == DRIVE_CDROM || mi->type == DRIVE_REMOVABLE)
     {
         source = source_dir;
         options |= MSISOURCETYPE_MEDIA;
     }
     else if ((base_url = get_base_url(package->db)))
     {
         source = base_url;
         options |= MSISOURCETYPE_URL;
     }
     else
     {
         source = mi->sourcedir;
         options |= MSISOURCETYPE_NETWORK;
     }
 
     msi_package_add_media_disk(package, package->Context,
                                MSICODE_PRODUCT, mi->disk_id,
                                mi->volume_label, mi->disk_prompt);
 
     msi_package_add_info(package, package->Context,
                          options, INSTALLPROPERTY_LASTUSEDSOURCEW, source);
 
     TRACE("sequence %u -> cabinet %s disk id %u\n", Sequence, debugstr_w(mi->cabinet), mi->disk_id);
 
     msi_free(base_url);
     msi_free(source_dir);
     return ERROR_SUCCESS;
 }

Referenced by ACTION_InstallFiles(), and ACTION_PatchFiles().

◆ msi_media_get_disk_info()

static UINT msi_media_get_disk_info	(	MSIPACKAGE *	package,
		MSIMEDIAINFO *	mi
	)

static

Definition at line 274 of file media.c.

 {
     MSIRECORD *row;
 
     row = MSI_QueryGetRecord(package->db, L"SELECT * FROM `Media` WHERE `DiskId` = %d", mi->disk_id);
     if (!row)
     {
         TRACE("Unable to query row\n");
         return ERROR_FUNCTION_FAILED;
     }
 
     mi->disk_prompt = strdupW(MSI_RecordGetString(row, 3));
     mi->cabinet = strdupW(MSI_RecordGetString(row, 4));
     mi->volume_label = strdupW(MSI_RecordGetString(row, 5));
 
     msiobj_release(&row->hdr);
     return ERROR_SUCCESS;
 }

Referenced by cabinet_next_cabinet(), and cabinet_next_cabinet_stream().

◆ ready_media()

UINT ready_media	(	MSIPACKAGE *	package,
		BOOL	compressed,
		MSIMEDIAINFO *	mi
	)

Definition at line 850 of file media.c.

 {
     UINT rc;
     WCHAR *cabinet_file = NULL;
 
     /* media info for continuous cabinet is already loaded */
     if (mi->is_continuous) return ERROR_SUCCESS;
 
     if (mi->cabinet)
     {
         WCHAR *base_url;
 
         /* cabinet is internal, no checks needed */
         if (mi->cabinet[0] == '#') return ERROR_SUCCESS;
 
         if (!(cabinet_file = get_cabinet_filename( mi ))) return ERROR_OUTOFMEMORY;
 
         /* package should be downloaded */
         if (compressed && GetFileAttributesW( cabinet_file ) == INVALID_FILE_ATTRIBUTES &&
             (base_url = get_base_url( package->db )))
         {
             WCHAR temppath[MAX_PATH], *p, *url;
 
             msi_free( cabinet_file );
             if (!(url = msi_alloc( (lstrlenW( base_url ) + lstrlenW( mi->cabinet ) + 1) * sizeof(WCHAR) )))
             {
                 return ERROR_OUTOFMEMORY;
             }
             lstrcpyW( url, base_url );
             lstrcatW( url, mi->cabinet );
             if ((rc = msi_download_file( url, temppath )) != ERROR_SUCCESS)
             {
                 ERR("failed to download %s (%u)\n", debugstr_w(url), rc);
                 msi_free( url );
                 return rc;
             }
             if ((p = wcsrchr( temppath, '\\' ))) *p = 0;
             lstrcpyW( mi->sourcedir, temppath );
             PathAddBackslashW( mi->sourcedir );
             msi_free( mi->cabinet );
             mi->cabinet = strdupW( p + 1 );
 
             msi_free( url );
             return ERROR_SUCCESS;
         }
     }
     /* check volume matches, change media if not */
     if (mi->volume_label)
     {
         /* assume first volume is in the drive */
         if (mi->last_volume && wcsicmp( mi->last_volume, mi->volume_label ))
         {
             WCHAR *source = msi_dup_property( package->db, L"SourceDir" );
             BOOL match = source_matches_volume( mi, source );
             msi_free( source );
 
             if (!match && (mi->type == DRIVE_CDROM || mi->type == DRIVE_REMOVABLE))
             {
                 if ((rc = msi_change_media( package, mi )) != ERROR_SUCCESS)
                 {
                     msi_free( cabinet_file );
                     return rc;
                 }
             }
         }
 
         msi_free(mi->last_volume);
         mi->last_volume = strdupW(mi->volume_label);
     }
     if (mi->cabinet)
     {
         if (compressed && GetFileAttributesW( cabinet_file ) == INVALID_FILE_ATTRIBUTES)
         {
             if ((rc = find_published_source( package, mi )) != ERROR_SUCCESS)
             {
                 ERR("cabinet not found: %s\n", debugstr_w(cabinet_file));
                 msi_free( cabinet_file );
                 return ERROR_INSTALL_FAILURE;
             }
         }
     }
     msi_free( cabinet_file );
     return ERROR_SUCCESS;
 }

Referenced by ACTION_InstallFiles(), and ACTION_PatchFiles().

◆ source_matches_volume()

static BOOL source_matches_volume	(	MSIMEDIAINFO *	mi,
		LPCWSTR	source_root
	)

static

Definition at line 55 of file media.c.

 {
     WCHAR volume_name[MAX_PATH + 1], root[MAX_PATH + 1];
     const WCHAR *p;
     int len, len2;
 
     lstrcpyW(root, source_root);
     PathStripToRootW(root);
     PathAddBackslashW(root);
 
     if (!GetVolumeInformationW(root, volume_name, MAX_PATH + 1, NULL, NULL, NULL, NULL, 0))
     {
         WARN( "failed to get volume information for %s (%lu)\n", debugstr_w(root), GetLastError() );
         return FALSE;
     }
 
     len = lstrlenW( volume_name );
     len2 = lstrlenW( mi->volume_label );
     if (len2 > len) return FALSE;
     p = volume_name + len - len2;
 
     return !wcsicmp( mi->volume_label, p );
 }

Referenced by find_published_source(), msi_change_media(), and ready_media().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( msi )

Variable Documentation

◆ package_disk

struct package_disk package_disk

static

Definition at line 195 of file media.c.

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ _O_ACCMODE

◆ _O_APPEND

◆ _O_BINARY

◆ _O_CREAT

◆ _O_EXCL

◆ _O_NOINHERIT

◆ _O_RANDOM

◆ _O_RDONLY

◆ _O_RDWR

◆ _O_SEQUENTIAL

◆ _O_SHORT_LIVED

◆ _O_TEMPORARY

◆ _O_TEXT

◆ _O_TRUNC

◆ _O_WRONLY

◆ COBJMACROS

Function Documentation

◆ cabinet_alloc()

◆ cabinet_close()

◆ cabinet_close_file_info()

◆ cabinet_close_stream()

◆ cabinet_copy_file()

◆ cabinet_free()

◆ cabinet_next_cabinet()

◆ cabinet_next_cabinet_stream()

◆ cabinet_notify()

◆ cabinet_notify_stream()

◆ cabinet_open()

◆ cabinet_open_stream()

◆ cabinet_partial_file()

◆ cabinet_read()

◆ cabinet_read_stream()

◆ cabinet_seek()

◆ cabinet_seek_stream()

◆ cabinet_write()

◆ extract_cabinet()

◆ extract_cabinet_stream()

◆ find_published_source()

◆ get_base_url()

◆ get_cabinet_filename()

◆ get_drive_type()

◆ msi_add_cabinet_stream()

◆ msi_cabextract()

◆ msi_change_media()

◆ msi_free_media_info()

◆ msi_get_cabinet_stream()

◆ msi_load_media_info()

◆ msi_media_get_disk_info()

◆ ready_media()

◆ source_matches_volume()

◆ WINE_DEFAULT_DEBUG_CHANNEL()

Variable Documentation

◆ package_disk