- action.c is getting too big, so split out all the handling of

dlls/msi/Makefile.in

@@ -9,7 +9,9 @@ EXTRALIBS = -luuid $(LIBUNICODE)
 C_SRCS = \
 	action.c \
 	create.c \
+	custom.c \
 	distinct.c \
+	format.c \
 	handle.c \
 	insert.c \
 	msi.c \

dlls/msi/action.h

+/*
+ * Common prototypes for Action handlers
+ *
+ * Copyright 2005 Aric Stewart for CodeWeavers
+ *
+ * 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
+ */
+
+typedef struct tagMSIFEATURE
+{
+    WCHAR Feature[96];
+    WCHAR Feature_Parent[96];
+    WCHAR Title[0x100];
+    WCHAR Description[0x100];
+    INT Display;
+    INT Level;
+    WCHAR Directory[96];
+    INT Attributes;
+    
+    INSTALLSTATE Installed;
+    INSTALLSTATE ActionRequest;
+    INSTALLSTATE Action;
+
+    INT ComponentCount;
+    INT Components[1024]; /* yes hardcoded limit.... I am bad */
+    INT Cost;
+} MSIFEATURE;
+
+typedef struct tagMSICOMPONENT
+{
+    WCHAR Component[96];
+    WCHAR ComponentId[96];
+    WCHAR Directory[96];
+    INT Attributes;
+    WCHAR Condition[0x100];
+    WCHAR KeyPath[96];
+
+    INSTALLSTATE Installed;
+    INSTALLSTATE ActionRequest;
+    INSTALLSTATE Action;
+
+    BOOL Enabled;
+    INT  Cost;
+} MSICOMPONENT;
+
+typedef struct tagMSIFOLDER
+{
+    LPWSTR Directory;
+    LPWSTR TargetDefault;
+    LPWSTR SourceDefault;
+
+    LPWSTR ResolvedTarget;
+    LPWSTR ResolvedSource;
+    LPWSTR Property;   /* initially set property */
+    INT   ParentIndex;
+    INT   State;
+        /* 0 = uninitialized */
+        /* 1 = existing */
+        /* 2 = created remove if empty */
+        /* 3 = created persist if empty */
+    INT   Cost;
+    INT   Space;
+}MSIFOLDER;
+
+typedef struct tagMSIFILE
+{
+    LPWSTR File;
+    INT ComponentIndex;
+    LPWSTR FileName;
+    INT FileSize;
+    LPWSTR Version;
+    LPWSTR Language;
+    INT Attributes;
+    INT Sequence;   
+
+    INT State;
+       /* 0 = uninitialize */
+       /* 1 = not present */
+       /* 2 = present but replace */
+       /* 3 = present do not replace */
+       /* 4 = Installed */
+    LPWSTR  SourcePath;
+    LPWSTR  TargetPath;
+    BOOL    Temporary; 
+}MSIFILE;
+
+
+void ACTION_FinishCustomActions( MSIPACKAGE* package);
+UINT ACTION_CustomAction(MSIPACKAGE *package,const WCHAR *action, BOOL execute);
+
+
+DWORD deformat_string(MSIPACKAGE *package, LPCWSTR ptr, WCHAR** data );
+WCHAR *load_dynamic_stringW(MSIRECORD *row, INT index);
+LPWSTR load_dynamic_property(MSIPACKAGE *package, LPCWSTR prop, UINT* rc);
+LPWSTR resolve_folder(MSIPACKAGE *package, LPCWSTR name, BOOL source, 
+                      BOOL set_prop, MSIFOLDER **folder);
+int get_loaded_component(MSIPACKAGE* package, LPCWSTR Component );
+int get_loaded_feature(MSIPACKAGE* package, LPCWSTR Feature );
+int get_loaded_file(MSIPACKAGE* package, LPCWSTR file);
+int track_tempfile(MSIPACKAGE *package, LPCWSTR name, LPCWSTR path);
+
+
+
+inline static char *strdupWtoA( const WCHAR *str )
+{
+    char *ret = NULL;
+    if (str)
+    {
+        DWORD len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL
+);
+        if ((ret = HeapAlloc( GetProcessHeap(), 0, len )))
+            WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
+    }
+    return ret;
+}
+
+inline static WCHAR *strdupAtoW( const char *str )
+{
+    WCHAR *ret = NULL;
+    if (str)
+    {
+        DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
+        if ((ret = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
+            MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
+    }
+    return ret;
+}
+
+inline static LPWSTR dupstrW(LPCWSTR src)
+{
+    LPWSTR dest;
+    if (!src) return NULL;
+    dest = HeapAlloc(GetProcessHeap(), 0, (strlenW(src)+1)*sizeof(WCHAR));
+    strcpyW(dest, src);
+    return dest;
+}

dlls/msi/format.c

+/*
+ * Implementation of the Microsoft Installer (msi.dll)
+ *
+ * Copyright 2005 Mike McCormack for CodeWeavers
+ * Copyright 2005 Aric Stewart for CodeWeavers
+ *
+ * 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
+ */
+
+/*
+http://msdn.microsoft.com/library/default.asp?url=/library/en-us/msi/setup/msiformatrecord.asp 
+ */
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#define COBJMACROS
+
+#include "windef.h"
+#include "winbase.h"
+#include "winerror.h"
+#include "winreg.h"
+#include "wine/debug.h"
+#include "fdi.h"
+#include "msi.h"
+#include "msiquery.h"
+#include "msvcrt/fcntl.h"
+#include "objbase.h"
+#include "objidl.h"
+#include "msipriv.h"
+#include "winnls.h"
+#include "winuser.h"
+#include "shlobj.h"
+#include "wine/unicode.h"
+#include "ver.h"
+#include "action.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(msi);
+
+static const WCHAR* scanW(LPCWSTR buf, WCHAR token, DWORD len)
+{
+    DWORD i;
+    for (i = 0; i < len; i++)
+        if (buf[i] == token)
+            return &buf[i];
+    return NULL;
+}
+
+/*
+ * This helper function should probably go alot of places
+ *
+ * Thinking about this, maybe this should become yet another Bison file
+ *
+ * len is in WCHARs
+ * return is also in WCHARs
+ */
+static DWORD deformat_string_internal(MSIPACKAGE *package, LPCWSTR ptr, 
+                                     WCHAR** data, DWORD len, MSIRECORD* record)
+{
+    const WCHAR* mark=NULL;
+    WCHAR* mark2;
+    DWORD size=0;
+    DWORD chunk=0;
+    WCHAR key[0x100];
+    LPWSTR value = NULL;
+    DWORD sz;
+    UINT rc;
+    INT index;
+    LPWSTR newdata = NULL;
+
+    if (ptr==NULL)
+    {
+        TRACE("Deformatting NULL string\n");
+        *data = NULL;
+        return 0;
+    }
+
+    TRACE("Starting with %s\n",debugstr_w(ptr));
+
+    /* scan for special characters */
+    if (!scanW(ptr,'[',len) || (scanW(ptr,'[',len) && !scanW(ptr,']',len)))
+    {
+        /* not formatted */
+        *data = HeapAlloc(GetProcessHeap(),0,(len*sizeof(WCHAR)));
+        memcpy(*data,ptr,len*sizeof(WCHAR));
+        TRACE("Returning %s\n",debugstr_w(*data));
+        return len;
+    }
+   
+    /* formatted string located */ 
+    mark = scanW(ptr,'[',len);
+    if (mark != ptr)
+    {
+        INT cnt = (mark - ptr);
+        TRACE("%i  (%i) characters before marker\n",cnt,(mark-ptr));
+        size = cnt * sizeof(WCHAR);
+        newdata = HeapAlloc(GetProcessHeap(),0,size);
+        memcpy(newdata,ptr,(cnt * sizeof(WCHAR)));
+    }
+    else
+    {
+        size = 0;
+        newdata = HeapAlloc(GetProcessHeap(),0,size);
+        newdata[0]=0;
+    }
+    mark++;
+    /* there should be no null characters in a key so strchrW is ok */
+    mark2 = strchrW(mark,']');
+    strncpyW(key,mark,mark2-mark);
+    key[mark2-mark] = 0;
+    mark = strchrW(mark,']');
+    mark++;
+    TRACE("Current %s .. %s\n",debugstr_w(newdata),debugstr_w(key));
+    sz = 0;
+    /* expand what we can deformat... Again, this should become a bison file */
+    switch (key[0])
+    {
+        case '~':
+            value = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*2);
+            value[0] =  0;
+            chunk = sizeof(WCHAR);
+            rc = ERROR_SUCCESS;
+            break;
+        case '$':
+            ERR("POORLY HANDLED DEFORMAT.. [$componentkey] \n");
+            index = get_loaded_component(package,&key[1]);
+            if (index >= 0)
+            {
+                value = resolve_folder(package, 
+                                       package->components[index].Directory, 
+                                       FALSE, FALSE, NULL);
+                chunk = (strlenW(value)) * sizeof(WCHAR);
+                rc = 0;
+            }
+            else
+                rc = ERROR_FUNCTION_FAILED;
+            break;
+        case '#':
+        case '!': /* should be short path */
+            index = get_loaded_file(package,&key[1]);
+            if (index >=0)
+            {
+                sz = strlenW(package->files[index].TargetPath);
+                value = dupstrW(package->files[index].TargetPath);
+                chunk = (strlenW(value)) * sizeof(WCHAR);
+                rc= ERROR_SUCCESS;
+            }
+            else
+                rc = ERROR_FUNCTION_FAILED;
+            break;
+        case '\\':
+            value = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR)*2);
+            value[0] =  key[1];
+            chunk = sizeof(WCHAR);
+            rc = ERROR_SUCCESS;
+            break;
+        case '%':
+            sz  = GetEnvironmentVariableW(&key[1],NULL,0);
+            if (sz > 0)
+            {
+                sz++;
+                value = HeapAlloc(GetProcessHeap(),0,sz * sizeof(WCHAR));
+                GetEnvironmentVariableW(&key[1],value,sz);
+                chunk = (strlenW(value)) * sizeof(WCHAR);
+                rc = ERROR_SUCCESS;
+            }
+            else
+            {
+                ERR("Unknown enviroment variable\n");
+                chunk = 0;
+                value = NULL;
+                rc = ERROR_FUNCTION_FAILED;
+            }
+            break;
+        default:
+            /* check for numaric values */
+            index = 0;
+            while (isdigitW(key[index])) index++;
+            if (key[index] == 0)
+            {
+                index = atoiW(key);
+                TRACE("record index %i\n",index);
+                value = load_dynamic_stringW(record,index);
+                if (value)
+                {
+                    chunk = strlenW(value) * sizeof(WCHAR);
+                    rc = ERROR_SUCCESS;
+                }
+                else
+                {
+                    value = NULL;
+                    rc = ERROR_FUNCTION_FAILED;
+                }
+            }
+            else
+            {
+                value = load_dynamic_property(package,key, &rc);
+                if (rc == ERROR_SUCCESS)
+                    chunk = (strlenW(value)) * sizeof(WCHAR);
+            }
+            break;      
+    }
+    if (((rc == ERROR_SUCCESS) || (rc == ERROR_MORE_DATA)) && value!=NULL)
+    {
+        LPWSTR nd2;
+        TRACE("value %s, chunk %li size %li\n",debugstr_w(value),chunk,size);
+
+        nd2= HeapReAlloc(GetProcessHeap(),0,newdata,(size + chunk));
+        newdata = nd2;
+        memcpy(&newdata[(size/sizeof(WCHAR))],value,chunk);
+        size+=chunk;   
+        HeapFree(GetProcessHeap(),0,value);
+    }
+    TRACE("after value %s .. %s\n",debugstr_w(newdata),debugstr_w(mark));
+    if (mark - ptr < len)
+    {
+        LPWSTR nd2;
+        chunk = (len - (mark - ptr)) * sizeof(WCHAR);
+        TRACE("after chunk is %li\n",chunk);
+        nd2 = HeapReAlloc(GetProcessHeap(),0,newdata,(size+chunk));
+        newdata = nd2;
+        memcpy(&newdata[(size/sizeof(WCHAR))],mark,chunk);
+        size+=chunk;
+    }
+    TRACE("after trailing %s .. %s\n",debugstr_w(newdata),debugstr_w(mark));
+
+    /* recursively do this to clean up */
+    size = deformat_string_internal(package,newdata,data,(size/sizeof(WCHAR)),
+                                    record);
+    HeapFree(GetProcessHeap(),0,newdata);
+    return size;
+}
+
+
+UINT MSI_FormatRecordW(MSIPACKAGE* package, MSIRECORD* record, LPWSTR buffer,
+                        DWORD *size)
+{
+    LPWSTR deformated;
+    LPWSTR rec;
+    DWORD len;
+    UINT rc = ERROR_INVALID_PARAMETER;
+
+    TRACE("%p %p %p %li\n",package, record ,buffer, *size);
+
+    rec = load_dynamic_stringW(record,0);
+    if (!rec)
+        return rc;
+
+    TRACE("(%s)\n",debugstr_w(rec));
+
+    len = deformat_string_internal(package,rec,&deformated,(strlenW(rec)+1),
+                                   record);
+    if (len <= *size)
+    {
+        *size = len;
+        memcpy(buffer,deformated,len*sizeof(WCHAR));
+        rc = ERROR_SUCCESS;
+    }
+    else
+    {
+        *size = len;
+        rc = ERROR_MORE_DATA;
+    }
+
+    HeapFree(GetProcessHeap(),0,rec);
+    HeapFree(GetProcessHeap(),0,deformated);
+    return rc;
+}
+
+UINT WINAPI MsiFormatRecordA(MSIHANDLE hInstall, MSIHANDLE hRecord, LPSTR
+szResult, DWORD *sz)
+{
+    UINT rc;
+    MSIPACKAGE* package;
+    MSIRECORD* record;
+    LPWSTR szwResult;
+    DWORD original_len;
+
+    TRACE("%ld %ld %p %p\n", hInstall, hRecord, szResult, sz);
+
+    package = msihandle2msiinfo(hInstall,MSIHANDLETYPE_PACKAGE);
+    record = msihandle2msiinfo(hRecord,MSIHANDLETYPE_RECORD);
+
+    if (!package || !record)
+        return ERROR_INVALID_HANDLE;
+
+    original_len = *sz;
+    /* +1 just to make sure we have a buffer incase the len is 0 */
+    szwResult = HeapAlloc(GetProcessHeap(),0,(original_len+1) * sizeof(WCHAR));
+
+    rc = MSI_FormatRecordW(package, record, szwResult, sz);
+    
+    WideCharToMultiByte(CP_ACP,0,szwResult,original_len, szResult, original_len,
+                        NULL,NULL);
+
+    HeapFree(GetProcessHeap(),0,szwResult);
+
+    return rc;
+
+}
+
+UINT WINAPI MsiFormatRecordW(MSIHANDLE hInstall, MSIHANDLE hRecord, 
+                             LPWSTR szResult, DWORD *sz)
+{
+    UINT rc;
+    MSIPACKAGE* package;
+    MSIRECORD* record;
+
+    TRACE("%ld %ld %p %p\n", hInstall, hRecord, szResult, sz);
+
+    package = msihandle2msiinfo(hInstall,MSIHANDLETYPE_PACKAGE);
+    record = msihandle2msiinfo(hRecord,MSIHANDLETYPE_RECORD);
+
+    if (!package || !record)
+        return ERROR_INVALID_HANDLE;
+
+    rc = MSI_FormatRecordW(package, record, szResult, sz);
+
+    return rc;
+}

dlls/msi/msipriv.h

@@ -203,6 +203,9 @@ typedef struct tagMSIPACKAGE
     LPWSTR *CommitAction;
     UINT CommitActionCount;
 
+    struct tagMSIRUNNINGACTION *RunningAction;
+    UINT RunningActionCount;
+
     LPWSTR PackagePath;
 } MSIPACKAGE;
 
@@ -329,6 +332,10 @@ extern UINT MSI_SetPropertyW( MSIPACKAGE *, LPCWSTR, LPCWSTR );
 extern UINT MSI_GetComponentStateW(MSIPACKAGE *, LPWSTR, INSTALLSTATE *, INSTALLSTATE *);
 extern UINT MSI_GetFeatureStateW(MSIPACKAGE *, LPWSTR, INSTALLSTATE *, INSTALLSTATE *);
 
+/* for deformating */
+extern UINT MSI_FormatRecordW(MSIPACKAGE* package, MSIRECORD* record, 
+                              LPWSTR buffer, DWORD *size);
+    
 /* registry data encoding/decoding functions */
 BOOL unsquash_guid(LPCWSTR in, LPWSTR out);
 BOOL squash_guid(LPCWSTR in, LPWSTR out);

dlls/msi/package.c

@@ -53,7 +53,6 @@ void MSI_FreePackage( MSIOBJECTHDR *arg)
 {
     MSIPACKAGE *package= (MSIPACKAGE*) arg;
 
-    ACTION_remove_tracked_tempfiles(package);
     ACTION_free_package_structures(package);
 
     msiobj_release( &package->db->hdr );

dlls/msi/record.c

@@ -520,18 +520,6 @@ UINT WINAPI MsiRecordSetStringW( MSIHANDLE handle, unsigned int iField, LPCWSTR
     return ret;
 }
 
-UINT WINAPI MsiFormatRecordA(MSIHANDLE hInstall, MSIHANDLE hRecord, LPSTR szResult, DWORD *sz)
-{
-    FIXME("%ld %ld %p %p\n", hInstall, hRecord, szResult, sz);
-    return ERROR_CALL_NOT_IMPLEMENTED;
-}
-
-UINT WINAPI MsiFormatRecordW(MSIHANDLE hInstall, MSIHANDLE hRecord, LPWSTR szResult, DWORD *sz)
-{
-    FIXME("%ld %ld %p %p\n", hInstall, hRecord, szResult, sz);
-    return ERROR_CALL_NOT_IMPLEMENTED;
-}
-
 /* read the data in a file into an IStream */
 UINT RECORD_StreamFromFile(LPCWSTR szFile, IStream **pstm)
 {