2 * Implementation of the Microsoft Installer (msi.dll)
4 * Copyright 2005 Mike McCormack for CodeWeavers
5 * Copyright 2005 Aric Stewart for CodeWeavers
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
30 #include "wine/debug.h"
37 #include "msiserver.h"
38 #include "wine/unicode.h"
40 WINE_DEFAULT_DEBUG_CHANNEL(msi
);
42 /* types arranged by precedence */
43 #define FORMAT_NULL 0x0001
44 #define FORMAT_LITERAL 0x0002
45 #define FORMAT_NUMBER 0x0004
46 #define FORMAT_LBRACK 0x0010
47 #define FORMAT_LBRACE 0x0020
48 #define FORMAT_RBRACK 0x0011
49 #define FORMAT_RBRACE 0x0021
50 #define FORMAT_ESCAPE 0x0040
51 #define FORMAT_PROPNULL 0x0080
52 #define FORMAT_ERROR 0x1000
53 #define FORMAT_FAIL 0x2000
55 #define left_type(x) (x & 0xF0)
57 typedef struct _tagFORMAT
69 typedef struct _tagFORMSTR
79 typedef struct _tagSTACK
84 static STACK
*create_stack(void)
86 STACK
*stack
= msi_alloc(sizeof(STACK
));
87 list_init(&stack
->items
);
91 static void free_stack(STACK
*stack
)
93 while (!list_empty(&stack
->items
))
95 FORMSTR
*str
= LIST_ENTRY(list_head(&stack
->items
), FORMSTR
, entry
);
96 list_remove(&str
->entry
);
103 static void stack_push(STACK
*stack
, FORMSTR
*str
)
105 list_add_head(&stack
->items
, &str
->entry
);
108 static FORMSTR
*stack_pop(STACK
*stack
)
112 if (list_empty(&stack
->items
))
115 ret
= LIST_ENTRY(list_head(&stack
->items
), FORMSTR
, entry
);
116 list_remove(&ret
->entry
);
120 static FORMSTR
*stack_find(STACK
*stack
, int type
)
124 LIST_FOR_EACH_ENTRY(str
, &stack
->items
, FORMSTR
, entry
)
126 if (str
->type
== type
)
133 static FORMSTR
*stack_peek(STACK
*stack
)
135 return LIST_ENTRY(list_head(&stack
->items
), FORMSTR
, entry
);
138 static LPCWSTR
get_formstr_data(FORMAT
*format
, FORMSTR
*str
)
140 return &format
->deformatted
[str
->n
];
143 static WCHAR
*dup_formstr( FORMAT
*format
, FORMSTR
*str
, int *ret_len
)
147 if (!str
->len
) return NULL
;
148 if ((val
= msi_alloc( (str
->len
+ 1) * sizeof(WCHAR
) )))
150 memcpy( val
, get_formstr_data(format
, str
), str
->len
* sizeof(WCHAR
) );
157 static WCHAR
*deformat_index( FORMAT
*format
, FORMSTR
*str
, int *ret_len
)
163 if (!(val
= msi_alloc( (str
->len
+ 1) * sizeof(WCHAR
) ))) return NULL
;
164 lstrcpynW(val
, get_formstr_data(format
, str
), str
->len
+ 1);
165 field
= atoiW( val
);
168 if (MSI_RecordIsNull( format
->record
, field
) ||
169 MSI_RecordGetStringW( format
->record
, field
, NULL
, &len
)) return NULL
;
172 if (!(ret
= msi_alloc( len
* sizeof(WCHAR
) ))) return NULL
;
174 if (MSI_RecordGetStringW( format
->record
, field
, ret
, &len
))
183 static WCHAR
*deformat_property( FORMAT
*format
, FORMSTR
*str
, int *ret_len
)
189 if (!(prop
= msi_alloc( (str
->len
+ 1) * sizeof(WCHAR
) ))) return NULL
;
190 lstrcpynW( prop
, get_formstr_data(format
, str
), str
->len
+ 1 );
192 r
= msi_get_property( format
->package
->db
, prop
, NULL
, &len
);
193 if (r
!= ERROR_SUCCESS
&& r
!= ERROR_MORE_DATA
)
199 if ((ret
= msi_alloc( len
* sizeof(WCHAR
) )))
200 msi_get_property( format
->package
->db
, prop
, ret
, &len
);
206 static WCHAR
*deformat_component( FORMAT
*format
, FORMSTR
*str
, int *ret_len
)
211 if (!(key
= msi_alloc( (str
->len
+ 1) * sizeof(WCHAR
) ))) return NULL
;
212 lstrcpynW(key
, get_formstr_data(format
, str
), str
->len
+ 1);
214 if (!(comp
= msi_get_loaded_component( format
->package
, key
)))
219 if (comp
->Action
== INSTALLSTATE_SOURCE
)
220 ret
= msi_resolve_source_folder( format
->package
, comp
->Directory
, NULL
);
222 ret
= strdupW( msi_get_target_folder( format
->package
, comp
->Directory
) );
224 if (ret
) *ret_len
= strlenW( ret
);
230 static WCHAR
*deformat_file( FORMAT
*format
, FORMSTR
*str
, BOOL shortname
, int *ret_len
)
232 WCHAR
*key
, *ret
= NULL
;
236 if (!(key
= msi_alloc( (str
->len
+ 1) * sizeof(WCHAR
) ))) return NULL
;
237 lstrcpynW(key
, get_formstr_data(format
, str
), str
->len
+ 1);
239 if (!(file
= msi_get_loaded_file( format
->package
, key
))) goto done
;
242 if ((ret
= strdupW( file
->TargetPath
))) len
= strlenW( ret
);
245 if ((len
= GetShortPathNameW(file
->TargetPath
, NULL
, 0)) <= 0)
247 if ((ret
= strdupW( file
->TargetPath
))) len
= strlenW( ret
);
251 if ((ret
= msi_alloc( len
* sizeof(WCHAR
) )))
252 len
= GetShortPathNameW( file
->TargetPath
, ret
, len
);
260 static WCHAR
*deformat_environment( FORMAT
*format
, FORMSTR
*str
, int *ret_len
)
262 WCHAR
*key
, *ret
= NULL
;
265 if (!(key
= msi_alloc((str
->len
+ 1) * sizeof(WCHAR
)))) return NULL
;
266 lstrcpynW(key
, get_formstr_data(format
, str
), str
->len
+ 1);
268 if ((len
= GetEnvironmentVariableW( key
, NULL
, 0 )))
271 if ((ret
= msi_alloc( len
* sizeof(WCHAR
) )))
272 *ret_len
= GetEnvironmentVariableW( key
, ret
, len
);
278 static WCHAR
*deformat_literal( FORMAT
*format
, FORMSTR
*str
, BOOL
*propfound
,
279 BOOL
*nonprop
, int *type
, int *len
)
281 LPCWSTR data
= get_formstr_data(format
, str
);
282 WCHAR
*replaced
= NULL
;
296 replaced
= dup_formstr( format
, str
, len
);
303 else if ((replaced
= msi_alloc( sizeof(WCHAR
) )))
309 else if (ch
== '%' || ch
== '#' || ch
== '!' || ch
== '$')
317 replaced
= deformat_environment( format
, str
, len
); break;
319 replaced
= deformat_file( format
, str
, FALSE
, len
); break;
321 replaced
= deformat_file( format
, str
, TRUE
, len
); break;
323 replaced
= deformat_component( format
, str
, len
); break;
326 *type
= FORMAT_LITERAL
;
330 replaced
= deformat_property( format
, str
, len
);
331 *type
= FORMAT_LITERAL
;
336 format
->propfailed
= TRUE
;
342 static LPWSTR
build_default_format(const MSIRECORD
* record
)
347 static const WCHAR fmt
[] = {'%','i',':',' ','%','s',' ',0};
348 static const WCHAR fmt_null
[] = {'%','i',':',' ',' ',0};
349 static const WCHAR fmt_index
[] = {'%','i',0};
352 DWORD size
, max_len
, len
;
354 count
= MSI_RecordGetFieldCount(record
);
357 buf
= msi_alloc((max_len
+ 1) * sizeof(WCHAR
));
361 for (i
= 1; i
<= count
; i
++)
363 sprintfW(index
, fmt_index
, i
);
364 str
= MSI_RecordGetString(record
, i
);
365 len
= (str
) ? lstrlenW(str
) : 0;
366 len
+= (sizeof(fmt_null
)/sizeof(fmt_null
[0]) - 3) + lstrlenW(index
);
372 buf
= msi_realloc(buf
, (max_len
+ 1) * sizeof(WCHAR
));
373 if (!buf
) return NULL
;
377 sprintfW(buf
, fmt
, i
, str
);
379 sprintfW(buf
, fmt_null
, i
);
383 rc
= msi_alloc(size
* sizeof(WCHAR
));
388 rc
= msi_realloc(rc
, size
* sizeof(WCHAR
));
397 static BOOL
format_is_number(WCHAR x
)
399 return ((x
>= '0') && (x
<= '9'));
402 static BOOL
format_str_is_number(LPWSTR str
)
406 for (ptr
= str
; *ptr
; ptr
++)
407 if (!format_is_number(*ptr
))
413 static BOOL
format_is_alpha(WCHAR x
)
415 return (!format_is_number(x
) && x
!= '\0' &&
416 x
!= '[' && x
!= ']' && x
!= '{' && x
!= '}');
419 static BOOL
format_is_literal(WCHAR x
)
421 return (format_is_alpha(x
) || format_is_number(x
));
424 static int format_lex(FORMAT
*format
, FORMSTR
**out
)
433 if (!format
->deformatted
)
436 *out
= msi_alloc_zero(sizeof(FORMSTR
));
443 data
= get_formstr_data(format
, str
);
448 case '{': type
= FORMAT_LBRACE
; break;
449 case '}': type
= FORMAT_RBRACE
; break;
450 case '[': type
= FORMAT_LBRACK
; break;
451 case ']': type
= FORMAT_RBRACK
; break;
452 case '~': type
= FORMAT_PROPNULL
; break;
453 case '\0': type
= FORMAT_NULL
; break;
468 while (data
[len
] && data
[len
] != ']')
471 type
= FORMAT_ESCAPE
;
473 else if (format_is_alpha(ch
))
475 while (format_is_literal(data
[len
]))
478 type
= FORMAT_LITERAL
;
480 else if (format_is_number(ch
))
482 while (format_is_number(data
[len
]))
485 type
= FORMAT_NUMBER
;
487 if (data
[len
] != ']')
489 while (format_is_literal(data
[len
]))
492 type
= FORMAT_LITERAL
;
497 ERR("Got unknown character %c(%x)\n", ch
, ch
);
508 static FORMSTR
*format_replace( FORMAT
*format
, BOOL propfound
, BOOL nonprop
,
509 int oldsize
, int type
, WCHAR
*replace
, int len
)
525 size
= format
->len
+ size
+ 1;
529 msi_free(format
->deformatted
);
530 format
->deformatted
= NULL
;
535 str
= msi_alloc(size
* sizeof(WCHAR
));
540 memcpy(str
, format
->deformatted
, format
->n
* sizeof(WCHAR
));
545 if (!len
) str
[n
++] = 0;
548 memcpy( str
+ n
, replace
, len
* sizeof(WCHAR
) );
554 ptr
= &format
->deformatted
[format
->n
+ oldsize
];
555 memcpy(&str
[n
], ptr
, (lstrlenW(ptr
) + 1) * sizeof(WCHAR
));
557 msi_free(format
->deformatted
);
558 format
->deformatted
= str
;
559 format
->len
= size
- 1;
561 /* don't reformat the NULL */
568 ret
= msi_alloc_zero(sizeof(FORMSTR
));
575 ret
->propfound
= propfound
;
576 ret
->nonprop
= nonprop
;
581 static WCHAR
*replace_stack_group( FORMAT
*format
, STACK
*values
,
582 BOOL
*propfound
, BOOL
*nonprop
,
583 int *oldsize
, int *type
, int *len
)
586 FORMSTR
*content
, *node
;
592 node
= stack_pop(values
);
594 *oldsize
= node
->len
;
597 while ((node
= stack_pop(values
)))
599 *oldsize
+= node
->len
;
610 content
= msi_alloc_zero(sizeof(FORMSTR
));
612 content
->len
= *oldsize
;
613 content
->type
= FORMAT_LITERAL
;
615 if (!format
->groupfailed
&& (*oldsize
== 2 ||
616 (format
->propfailed
&& !*nonprop
)))
621 else if (format
->deformatted
[content
->n
+ 1] == '{' &&
622 format
->deformatted
[content
->n
+ content
->len
- 2] == '}')
624 format
->groupfailed
= FALSE
;
627 else if (*propfound
&& !*nonprop
&&
628 !format
->groupfailed
&& format
->groups
== 0)
635 if (format
->groups
!= 0)
636 format
->groupfailed
= TRUE
;
641 replaced
= dup_formstr( format
, content
, len
);
642 *type
= content
->type
;
645 if (format
->groups
== 0)
646 format
->propfailed
= FALSE
;
651 static WCHAR
*replace_stack_prop( FORMAT
*format
, STACK
*values
,
652 BOOL
*propfound
, BOOL
*nonprop
,
653 int *oldsize
, int *type
, int *len
)
656 FORMSTR
*content
, *node
;
662 node
= stack_pop(values
);
664 *oldsize
= node
->len
;
665 *type
= stack_peek(values
)->type
;
668 while ((node
= stack_pop(values
)))
670 *oldsize
+= node
->len
;
672 if (*type
!= FORMAT_ESCAPE
&&
673 stack_peek(values
) && node
->type
!= *type
)
674 *type
= FORMAT_LITERAL
;
679 content
= msi_alloc_zero(sizeof(FORMSTR
));
681 content
->len
= *oldsize
- 2;
682 content
->type
= *type
;
684 if (*type
== FORMAT_NUMBER
)
686 replaced
= deformat_index( format
, content
, len
);
690 format
->propfailed
= TRUE
;
693 *type
= format_str_is_number(replaced
) ?
694 FORMAT_NUMBER
: FORMAT_LITERAL
;
696 else if (format
->package
)
698 replaced
= deformat_literal( format
, content
, propfound
, nonprop
, type
, len
);
705 replaced
= dup_formstr( format
, content
, len
);
711 static UINT
replace_stack(FORMAT
*format
, STACK
*stack
, STACK
*values
)
713 WCHAR
*replaced
= NULL
;
714 FORMSTR
*beg
, *top
, *node
;
715 BOOL propfound
= FALSE
, nonprop
= FALSE
, group
= FALSE
;
716 int type
, n
, len
= 0, oldsize
= 0;
718 node
= stack_peek(values
);
722 if (type
== FORMAT_LBRACK
)
723 replaced
= replace_stack_prop( format
, values
, &propfound
,
724 &nonprop
, &oldsize
, &type
, &len
);
725 else if (type
== FORMAT_LBRACE
)
727 replaced
= replace_stack_group( format
, values
, &propfound
,
728 &nonprop
, &oldsize
, &type
, &len
);
733 beg
= format_replace( format
, propfound
, nonprop
, oldsize
, type
, replaced
, len
);
735 return ERROR_SUCCESS
;
738 format
->n
= beg
->n
+ beg
->len
;
740 top
= stack_peek(stack
);
745 if ((type
== FORMAT_LITERAL
|| type
== FORMAT_NUMBER
) &&
748 top
->len
+= beg
->len
;
751 top
->nonprop
= FALSE
;
753 if (type
== FORMAT_LITERAL
)
754 top
->nonprop
= beg
->nonprop
;
757 top
->propfound
= TRUE
;
760 return ERROR_SUCCESS
;
764 stack_push(stack
, beg
);
765 return ERROR_SUCCESS
;
768 static BOOL
verify_format(LPWSTR data
)
774 if (*data
== '[' && *(data
- 1) != '\\')
776 else if (*data
== ']')
788 static DWORD
deformat_string_internal(MSIPACKAGE
*package
, LPCWSTR ptr
,
789 WCHAR
** data
, DWORD
*len
,
790 MSIRECORD
* record
, INT
* failcount
)
802 return ERROR_SUCCESS
;
805 *data
= strdupW(ptr
);
806 *len
= lstrlenW(ptr
);
808 ZeroMemory(&format
, sizeof(FORMAT
));
809 format
.package
= package
;
810 format
.record
= record
;
811 format
.deformatted
= *data
;
814 if (!verify_format(*data
))
815 return ERROR_SUCCESS
;
817 stack
= create_stack();
818 temp
= create_stack();
820 while ((type
= format_lex(&format
, &str
)) != FORMAT_NULL
)
822 if (type
== FORMAT_LBRACK
|| type
== FORMAT_LBRACE
||
823 type
== FORMAT_LITERAL
|| type
== FORMAT_NUMBER
||
824 type
== FORMAT_ESCAPE
|| type
== FORMAT_PROPNULL
)
826 if (type
== FORMAT_LBRACE
)
828 format
.propfailed
= FALSE
;
831 else if (type
== FORMAT_ESCAPE
&&
832 !stack_find(stack
, FORMAT_LBRACK
))
834 format
.n
-= str
->len
- 1;
838 stack_push(stack
, str
);
840 else if (type
== FORMAT_RBRACK
|| type
== FORMAT_RBRACE
)
842 if (type
== FORMAT_RBRACE
)
845 stack_push(stack
, str
);
847 if (stack_find(stack
, left_type(type
)))
851 node
= stack_pop(stack
);
852 stack_push(temp
, node
);
853 } while (node
->type
!= left_type(type
));
855 replace_stack(&format
, stack
, temp
);
860 *data
= format
.deformatted
;
867 return ERROR_SUCCESS
;
870 UINT
MSI_FormatRecordW( MSIPACKAGE
* package
, MSIRECORD
* record
, LPWSTR buffer
,
873 WCHAR
*format
, *deformated
;
874 UINT rc
= ERROR_INVALID_PARAMETER
;
877 TRACE("%p %p %p %p\n", package
, record
, buffer
, size
);
879 if (!(format
= msi_dup_record_field( record
, 0 )))
880 format
= build_default_format( record
);
882 TRACE("%s\n", debugstr_w(format
));
884 deformat_string_internal( package
, format
, &deformated
, &len
, record
, NULL
);
889 memcpy(buffer
,deformated
,len
*sizeof(WCHAR
));
897 memcpy(buffer
,deformated
,(*size
)*sizeof(WCHAR
));
898 buffer
[(*size
)-1] = 0;
900 rc
= ERROR_MORE_DATA
;
903 else rc
= ERROR_SUCCESS
;
907 msi_free( deformated
);
911 UINT WINAPI
MsiFormatRecordW( MSIHANDLE hInstall
, MSIHANDLE hRecord
,
912 LPWSTR szResult
, LPDWORD sz
)
914 UINT r
= ERROR_INVALID_HANDLE
;
918 TRACE("%d %d %p %p\n", hInstall
, hRecord
, szResult
, sz
);
920 package
= msihandle2msiinfo( hInstall
, MSIHANDLETYPE_PACKAGE
);
924 IWineMsiRemotePackage
*remote_package
;
928 remote_package
= (IWineMsiRemotePackage
*)msi_get_remote( hInstall
);
931 hr
= IWineMsiRemotePackage_FormatRecord( remote_package
, hRecord
,
937 wstr
.str
.w
= szResult
;
938 r
= msi_strcpy_to_awstring( value
, SysStringLen(value
), &wstr
, sz
);
941 IWineMsiRemotePackage_Release( remote_package
);
942 SysFreeString( value
);
946 if (HRESULT_FACILITY(hr
) == FACILITY_WIN32
)
947 return HRESULT_CODE(hr
);
949 return ERROR_FUNCTION_FAILED
;
956 record
= msihandle2msiinfo( hRecord
, MSIHANDLETYPE_RECORD
);
959 return ERROR_INVALID_HANDLE
;
962 msiobj_release( &record
->hdr
);
964 return ERROR_INVALID_PARAMETER
;
966 return ERROR_SUCCESS
;
969 r
= MSI_FormatRecordW( package
, record
, szResult
, sz
);
970 msiobj_release( &record
->hdr
);
972 msiobj_release( &package
->hdr
);
976 UINT WINAPI
MsiFormatRecordA( MSIHANDLE hInstall
, MSIHANDLE hRecord
,
977 LPSTR szResult
, LPDWORD sz
)
983 TRACE("%d %d %p %p\n", hInstall
, hRecord
, szResult
, sz
);
986 return ERROR_INVALID_HANDLE
;
991 return ERROR_INVALID_PARAMETER
;
993 return ERROR_SUCCESS
;
996 r
= MsiFormatRecordW( hInstall
, hRecord
, NULL
, &len
);
997 if (r
!= ERROR_SUCCESS
)
1000 value
= msi_alloc(++len
* sizeof(WCHAR
));
1002 return ERROR_OUTOFMEMORY
;
1004 r
= MsiFormatRecordW( hInstall
, hRecord
, value
, &len
);
1005 if (r
!= ERROR_SUCCESS
)
1009 len
= WideCharToMultiByte(CP_ACP
, 0, value
, len
+ 1, NULL
, 0, NULL
, NULL
);
1010 WideCharToMultiByte(CP_ACP
, 0, value
, len
, szResult
, *sz
, NULL
, NULL
);
1012 if (szResult
&& len
> *sz
)
1014 if (*sz
) szResult
[*sz
- 1] = '\0';
1015 r
= ERROR_MORE_DATA
;
1025 /* wrapper to resist a need for a full rewrite right now */
1026 DWORD
deformat_string( MSIPACKAGE
*package
, const WCHAR
*ptr
, WCHAR
**data
)
1031 MSIRECORD
*rec
= MSI_CreateRecord( 1 );
1033 MSI_RecordSetStringW( rec
, 0, ptr
);
1034 MSI_FormatRecordW( package
, rec
, NULL
, &len
);
1037 *data
= msi_alloc( len
* sizeof(WCHAR
) );
1038 if (len
> 1) MSI_FormatRecordW( package
, rec
, *data
, &len
);
1041 msiobj_release( &rec
->hdr
);