1 %{
2
3 /*
4 * Implementation of the Microsoft Installer (msi.dll)
5 *
6 * Copyright 2003 Mike McCormack for CodeWeavers
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #define COBJMACROS
24
25 #include "config.h"
26
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30
31 #include "windef.h"
32 #include "winbase.h"
33 #include "winuser.h"
34 #include "msi.h"
35 #include "msiquery.h"
36 #include "objbase.h"
37 #include "oleauto.h"
38
39 #include "msipriv.h"
40 #include "msiserver.h"
41 #include "wine/debug.h"
42 #include "wine/unicode.h"
43
44 #define YYLEX_PARAM info
45 #define YYPARSE_PARAM info
46
47 static int cond_error(const char *str);
48
49 WINE_DEFAULT_DEBUG_CHANNEL(msi);
50
51 typedef struct tag_yyinput
52 {
53 MSIPACKAGE *package;
54 LPCWSTR str;
55 INT n;
56 MSICONDITION result;
57 } COND_input;
58
59 struct cond_str {
60 LPCWSTR data;
61 INT len;
62 };
63
64 static LPWSTR COND_GetString( const struct cond_str *str );
65 static LPWSTR COND_GetLiteral( const struct cond_str *str );
66 static int cond_lex( void *COND_lval, COND_input *info);
67
68 static INT compare_int( INT a, INT operator, INT b );
69 static INT compare_string( LPCWSTR a, INT operator, LPCWSTR b, BOOL convert );
70
71 static INT compare_and_free_strings( LPWSTR a, INT op, LPWSTR b, BOOL convert )
72 {
73 INT r;
74
75 r = compare_string( a, op, b, convert );
76 msi_free( a );
77 msi_free( b );
78 return r;
79 }
80
81 static BOOL num_from_prop( LPCWSTR p, INT *val )
82 {
83 INT ret = 0, sign = 1;
84
85 if (!p)
86 return FALSE;
87 if (*p == '-')
88 {
89 sign = -1;
90 p++;
91 }
92 if (!*p)
93 return FALSE;
94 while (*p)
95 {
96 if( *p < '0' || *p > '9' )
97 return FALSE;
98 ret = ret*10 + (*p - '0');
99 p++;
100 }
101 *val = ret*sign;
102 return TRUE;
103 }
104
105 %}
106
107 %pure-parser
108
109 %union
110 {
111 struct cond_str str;
112 LPWSTR string;
113 INT value;
114 }
115
116 %token COND_SPACE COND_EOF
117 %token COND_OR COND_AND COND_NOT COND_XOR COND_IMP COND_EQV
118 %token COND_LT COND_GT COND_EQ COND_NE COND_GE COND_LE
119 %token COND_ILT COND_IGT COND_IEQ COND_INE COND_IGE COND_ILE
120 %token COND_LPAR COND_RPAR COND_TILDA COND_SS COND_ISS
121 %token COND_ILHS COND_IRHS COND_LHS COND_RHS
122 %token COND_PERCENT COND_DOLLARS COND_QUESTION COND_AMPER COND_EXCLAM
123 %token <str> COND_IDENT <str> COND_NUMBER <str> COND_LITER
124
125 %nonassoc COND_ERROR COND_EOF
126
127 %type <value> expression boolean_term boolean_factor
128 %type <value> value_i integer operator
129 %type <string> identifier symbol_s value_s literal
130
131 %%
132
133 condition:
134 expression
135 {
136 COND_input* cond = (COND_input*) info;
137 cond->result = $1;
138 }
139 | /* empty */
140 {
141 COND_input* cond = (COND_input*) info;
142 cond->result = MSICONDITION_NONE;
143 }
144 ;
145
146 expression:
147 boolean_term
148 {
149 $$ = $1;
150 }
151 | expression COND_OR boolean_term
152 {
153 $$ = $1 || $3;
154 }
155 | expression COND_IMP boolean_term
156 {
157 $$ = !$1 || $3;
158 }
159 | expression COND_XOR boolean_term
160 {
161 $$ = ( $1 || $3 ) && !( $1 && $3 );
162 }
163 | expression COND_EQV boolean_term
164 {
165 $$ = ( $1 && $3 ) || ( !$1 && !$3 );
166 }
167 ;
168
169 boolean_term:
170 boolean_factor
171 {
172 $$ = $1;
173 }
174 | boolean_term COND_AND boolean_factor
175 {
176 $$ = $1 && $3;
177 }
178 ;
179
180 boolean_factor:
181 COND_NOT boolean_factor
182 {
183 $$ = $2 ? 0 : 1;
184 }
185 | value_i
186 {
187 $$ = $1 ? 1 : 0;
188 }
189 | value_s
190 {
191 $$ = ($1 && $1[0]) ? 1 : 0;
192 msi_free($1);
193 }
194 | value_i operator value_i
195 {
196 $$ = compare_int( $1, $2, $3 );
197 }
198 | symbol_s operator value_i
199 {
200 int num;
201 if (num_from_prop( $1, &num ))
202 $$ = compare_int( num, $2, $3 );
203 else
204 $$ = ($2 == COND_NE || $2 == COND_INE );
205 msi_free($1);
206 }
207 | value_i operator symbol_s
208 {
209 int num;
210 if (num_from_prop( $3, &num ))
211 $$ = compare_int( $1, $2, num );
212 else
213 $$ = ($2 == COND_NE || $2 == COND_INE );
214 msi_free($3);
215 }
216 | symbol_s operator symbol_s
217 {
218 $$ = compare_and_free_strings( $1, $2, $3, TRUE );
219 }
220 | symbol_s operator literal
221 {
222 $$ = compare_and_free_strings( $1, $2, $3, TRUE );
223 }
224 | literal operator symbol_s
225 {
226 $$ = compare_and_free_strings( $1, $2, $3, TRUE );
227 }
228 | literal operator literal
229 {
230 $$ = compare_and_free_strings( $1, $2, $3, FALSE );
231 }
232 | literal operator value_i
233 {
234 $$ = 0;
235 msi_free($1);
236 }
237 | value_i operator literal
238 {
239 $$ = 0;
240 msi_free($3);
241 }
242 | COND_LPAR expression COND_RPAR
243 {
244 $$ = $2;
245 }
246 ;
247
248 operator:
249 /* common functions */
250 COND_EQ { $$ = COND_EQ; }
251 | COND_NE { $$ = COND_NE; }
252 | COND_LT { $$ = COND_LT; }
253 | COND_GT { $$ = COND_GT; }
254 | COND_LE { $$ = COND_LE; }
255 | COND_GE { $$ = COND_GE; }
256 | COND_SS { $$ = COND_SS; }
257 | COND_IEQ { $$ = COND_IEQ; }
258 | COND_INE { $$ = COND_INE; }
259 | COND_ILT { $$ = COND_ILT; }
260 | COND_IGT { $$ = COND_IGT; }
261 | COND_ILE { $$ = COND_ILE; }
262 | COND_IGE { $$ = COND_IGE; }
263 | COND_ISS { $$ = COND_ISS; }
264 | COND_LHS { $$ = COND_LHS; }
265 | COND_RHS { $$ = COND_RHS; }
266 | COND_ILHS { $$ = COND_ILHS; }
267 | COND_IRHS { $$ = COND_IRHS; }
268 ;
269
270 value_s:
271 symbol_s
272 {
273 $$ = $1;
274 }
275 | literal
276 {
277 $$ = $1;
278 }
279 ;
280
281 literal:
282 COND_LITER
283 {
284 $$ = COND_GetLiteral(&$1);
285 if( !$$ )
286 YYABORT;
287 }
288 ;
289
290 value_i:
291 integer
292 {
293 $$ = $1;
294 }
295 | COND_DOLLARS identifier
296 {
297 COND_input* cond = (COND_input*) info;
298 INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
299
300 MSI_GetComponentStateW(cond->package, $2, &install, &action );
301 $$ = action;
302 msi_free( $2 );
303 }
304 | COND_QUESTION identifier
305 {
306 COND_input* cond = (COND_input*) info;
307 INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
308
309 MSI_GetComponentStateW(cond->package, $2, &install, &action );
310 $$ = install;
311 msi_free( $2 );
312 }
313 | COND_AMPER identifier
314 {
315 COND_input* cond = (COND_input*) info;
316 INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
317
318 MSI_GetFeatureStateW(cond->package, $2, &install, &action );
319 if (action == INSTALLSTATE_UNKNOWN)
320 $$ = MSICONDITION_FALSE;
321 else
322 $$ = action;
323
324 msi_free( $2 );
325 }
326 | COND_EXCLAM identifier
327 {
328 COND_input* cond = (COND_input*) info;
329 INSTALLSTATE install = INSTALLSTATE_UNKNOWN, action = INSTALLSTATE_UNKNOWN;
330
331 MSI_GetFeatureStateW(cond->package, $2, &install, &action );
332 $$ = install;
333 msi_free( $2 );
334 }
335 ;
336
337 symbol_s:
338 identifier
339 {
340 COND_input* cond = (COND_input*) info;
341
342 $$ = msi_dup_property( cond->package, $1 );
343 msi_free( $1 );
344 }
345 | COND_PERCENT identifier
346 {
347 UINT len = GetEnvironmentVariableW( $2, NULL, 0 );
348 $$ = NULL;
349 if (len++)
350 {
351 $$ = msi_alloc( len*sizeof (WCHAR) );
352 GetEnvironmentVariableW( $2, $$, len );
353 }
354 msi_free( $2 );
355 }
356 ;
357
358 identifier:
359 COND_IDENT
360 {
361 $$ = COND_GetString(&$1);
362 if( !$$ )
363 YYABORT;
364 }
365 ;
366
367 integer:
368 COND_NUMBER
369 {
370 LPWSTR szNum = COND_GetString(&$1);
371 if( !szNum )
372 YYABORT;
373 $$ = atoiW( szNum );
374 msi_free( szNum );
375 }
376 ;
377
378 %%
379
380
381 static int COND_IsAlpha( WCHAR x )
382 {
383 return( ( ( x >= 'A' ) && ( x <= 'Z' ) ) ||
384 ( ( x >= 'a' ) && ( x <= 'z' ) ) ||
385 ( ( x == '_' ) ) );
386 }
387
388 static int COND_IsNumber( WCHAR x )
389 {
390 return( (( x >= '0' ) && ( x <= '9' )) || (x =='-') || (x =='.') );
391 }
392
393 static WCHAR *strstriW( const WCHAR *str, const WCHAR *sub )
394 {
395 LPWSTR strlower, sublower, r;
396 strlower = CharLowerW( strdupW( str ) );
397 sublower = CharLowerW( strdupW( sub ) );
398 r = strstrW( strlower, sublower );
399 if (r)
400 r = (LPWSTR)str + (r - strlower);
401 msi_free( strlower );
402 msi_free( sublower );
403 return r;
404 }
405
406 static BOOL str_is_number( LPCWSTR str )
407 {
408 int i;
409
410 if (!*str)
411 return FALSE;
412
413 for (i = 0; i < lstrlenW( str ); i++)
414 if (!isdigitW(str[i]))
415 return FALSE;
416
417 return TRUE;
418 }
419
420 static INT compare_substring( LPCWSTR a, INT operator, LPCWSTR b )
421 {
422 int lhs, rhs;
423
424 /* substring operators return 0 if LHS is missing */
425 if (!a || !*a)
426 return 0;
427
428 /* substring operators return 1 if RHS is missing */
429 if (!b || !*b)
430 return 1;
431
432 /* if both strings contain only numbers, use integer comparison */
433 lhs = atoiW(a);
434 rhs = atoiW(b);
435 if (str_is_number(a) && str_is_number(b))
436 return compare_int( lhs, operator, rhs );
437
438 switch (operator)
439 {
440 case COND_SS:
441 return strstrW( a, b ) ? 1 : 0;
442 case COND_ISS:
443 return strstriW( a, b ) ? 1 : 0;
444 case COND_LHS:
445 return 0 == strncmpW( a, b, lstrlenW( b ) );
446 case COND_RHS:
447 return 0 == lstrcmpW( a + (lstrlenW( a ) - lstrlenW( b )), b );
448 case COND_ILHS:
449 return 0 == strncmpiW( a, b, lstrlenW( b ) );
450 case COND_IRHS:
451 return 0 == lstrcmpiW( a + (lstrlenW( a ) - lstrlenW( b )), b );
452 default:
453 ERR("invalid substring operator\n");
454 return 0;
455 }
456 return 0;
457 }
458
459 static INT compare_string( LPCWSTR a, INT operator, LPCWSTR b, BOOL convert )
460 {
461 if (operator >= COND_SS && operator <= COND_RHS)
462 return compare_substring( a, operator, b );
463
464 /* null and empty string are equivalent */
465 if (!a) a = szEmpty;
466 if (!b) b = szEmpty;
467
468 if (convert && str_is_number(a) && str_is_number(b))
469 return compare_int( atoiW(a), operator, atoiW(b) );
470
471 /* a or b may be NULL */
472 switch (operator)
473 {
474 case COND_LT:
475 return -1 == lstrcmpW( a, b );
476 case COND_GT:
477 return 1 == lstrcmpW( a, b );
478 case COND_EQ:
479 return 0 == lstrcmpW( a, b );
480 case COND_NE:
481 return 0 != lstrcmpW( a, b );
482 case COND_GE:
483 return -1 != lstrcmpW( a, b );
484 case COND_LE:
485 return 1 != lstrcmpW( a, b );
486 case COND_ILT:
487 return -1 == lstrcmpiW( a, b );
488 case COND_IGT:
489 return 1 == lstrcmpiW( a, b );
490 case COND_IEQ:
491 return 0 == lstrcmpiW( a, b );
492 case COND_INE:
493 return 0 != lstrcmpiW( a, b );
494 case COND_IGE:
495 return -1 != lstrcmpiW( a, b );
496 case COND_ILE:
497 return 1 != lstrcmpiW( a, b );
498 default:
499 ERR("invalid string operator\n");
500 return 0;
501 }
502 return 0;
503 }
504
505
506 static INT compare_int( INT a, INT operator, INT b )
507 {
508 switch (operator)
509 {
510 case COND_LT:
511 case COND_ILT:
512 return a < b;
513 case COND_GT:
514 case COND_IGT:
515 return a > b;
516 case COND_EQ:
517 case COND_IEQ:
518 return a == b;
519 case COND_NE:
520 case COND_INE:
521 return a != b;
522 case COND_GE:
523 case COND_IGE:
524 return a >= b;
525 case COND_LE:
526 case COND_ILE:
527 return a <= b;
528 case COND_SS:
529 case COND_ISS:
530 return ( a & b ) ? 1 : 0;
531 case COND_RHS:
532 return ( ( a & 0xffff ) == b ) ? 1 : 0;
533 case COND_LHS:
534 return ( ( (a>>16) & 0xffff ) == b ) ? 1 : 0;
535 default:
536 ERR("invalid integer operator\n");
537 return 0;
538 }
539 return 0;
540 }
541
542
543 static int COND_IsIdent( WCHAR x )
544 {
545 return( COND_IsAlpha( x ) || COND_IsNumber( x ) || ( x == '_' )
546 || ( x == '#' ) || (x == '.') );
547 }
548
549 static int COND_GetOperator( COND_input *cond )
550 {
551 static const struct {
552 const WCHAR str[4];
553 int id;
554 } table[] = {
555 { {'~','<','=',0}, COND_ILE },
556 { {'~','>','<',0}, COND_ISS },
557 { {'~','>','>',0}, COND_IRHS },
558 { {'~','<','>',0}, COND_INE },
559 { {'~','>','=',0}, COND_IGE },
560 { {'~','<','<',0}, COND_ILHS },
561 { {'~','=',0}, COND_IEQ },
562 { {'~','<',0}, COND_ILT },
563 { {'~','>',0}, COND_IGT },
564 { {'>','=',0}, COND_GE },
565 { {'>','<',0}, COND_SS },
566 { {'<','<',0}, COND_LHS },
567 { {'<','>',0}, COND_NE },
568 { {'<','=',0}, COND_LE },
569 { {'>','>',0}, COND_RHS },
570 { {'>',0}, COND_GT },
571 { {'<',0}, COND_LT },
572 { {0}, 0 }
573 };
574 LPCWSTR p = &cond->str[cond->n];
575 int i = 0, len;
576
577 while ( 1 )
578 {
579 len = lstrlenW( table[i].str );
580 if ( !len || 0 == strncmpW( table[i].str, p, len ) )
581 break;
582 i++;
583 }
584 cond->n += len;
585 return table[i].id;
586 }
587
588 static int COND_GetOne( struct cond_str *str, COND_input *cond )
589 {
590 int rc, len = 1;
591 WCHAR ch;
592
593 str->data = &cond->str[cond->n];
594
595 ch = str->data[0];
596
597 switch( ch )
598 {
599 case 0: return 0;
600 case '(': rc = COND_LPAR; break;
601 case ')': rc = COND_RPAR; break;
602 case '&': rc = COND_AMPER; break;
603 case '!': rc = COND_EXCLAM; break;
604 case '$': rc = COND_DOLLARS; break;
605 case '?': rc = COND_QUESTION; break;
606 case '%': rc = COND_PERCENT; break;
607 case ' ': rc = COND_SPACE; break;
608 case '=': rc = COND_EQ; break;
609
610 case '~':
611 case '<':
612 case '>':
613 rc = COND_GetOperator( cond );
614 if (!rc)
615 rc = COND_ERROR;
616 return rc;
617 default:
618 rc = 0;
619 }
620
621 if ( rc )
622 {
623 cond->n += len;
624 return rc;
625 }
626
627 if (ch == '"' )
628 {
629 LPCWSTR p = strchrW( str->data + 1, '"' );
630 if (!p)
631 return COND_ERROR;
632 len = p - str->data + 1;
633 rc = COND_LITER;
634 }
635 else if( COND_IsAlpha( ch ) )
636 {
637 static const WCHAR szNot[] = {'N','O','T',0};
638 static const WCHAR szAnd[] = {'A','N','D',0};
639 static const WCHAR szXor[] = {'X','O','R',0};
640 static const WCHAR szEqv[] = {'E','Q','V',0};
641 static const WCHAR szImp[] = {'I','M','P',0};
642 static const WCHAR szOr[] = {'O','R',0};
643
644 while( COND_IsIdent( str->data[len] ) )
645 len++;
646 rc = COND_IDENT;
647
648 if ( len == 3 )
649 {
650 if ( !strncmpiW( str->data, szNot, len ) )
651 rc = COND_NOT;
652 else if( !strncmpiW( str->data, szAnd, len ) )
653 rc = COND_AND;
654 else if( !strncmpiW( str->data, szXor, len ) )
655 rc = COND_XOR;
656 else if( !strncmpiW( str->data, szEqv, len ) )
657 rc = COND_EQV;
658 else if( !strncmpiW( str->data, szImp, len ) )
659 rc = COND_IMP;
660 }
661 else if( (len == 2) && !strncmpiW( str->data, szOr, len ) )
662 rc = COND_OR;
663 }
664 else if( COND_IsNumber( ch ) )
665 {
666 while( COND_IsNumber( str->data[len] ) )
667 len++;
668 rc = COND_NUMBER;
669 }
670 else
671 {
672 ERR("Got unknown character %c(%x)\n",ch,ch);
673 return COND_ERROR;
674 }
675
676 cond->n += len;
677 str->len = len;
678
679 return rc;
680 }
681
682 static int cond_lex( void *COND_lval, COND_input *cond )
683 {
684 int rc;
685 struct cond_str *str = COND_lval;
686
687 do {
688 rc = COND_GetOne( str, cond );
689 } while (rc == COND_SPACE);
690
691 return rc;
692 }
693
694 static LPWSTR COND_GetString( const struct cond_str *str )
695 {
696 LPWSTR ret;
697
698 ret = msi_alloc( (str->len+1) * sizeof (WCHAR) );
699 if( ret )
700 {
701 memcpy( ret, str->data, str->len * sizeof(WCHAR));
702 ret[str->len]=0;
703 }
704 TRACE("Got identifier %s\n",debugstr_w(ret));
705 return ret;
706 }
707
708 static LPWSTR COND_GetLiteral( const struct cond_str *str )
709 {
710 LPWSTR ret;
711
712 ret = msi_alloc( (str->len-1) * sizeof (WCHAR) );
713 if( ret )
714 {
715 memcpy( ret, str->data+1, (str->len-2) * sizeof(WCHAR) );
716 ret[str->len - 2]=0;
717 }
718 TRACE("Got literal %s\n",debugstr_w(ret));
719 return ret;
720 }
721
722 static int cond_error(const char *str)
723 {
724 TRACE("%s\n", str );
725 return 0;
726 }
727
728 MSICONDITION MSI_EvaluateConditionW( MSIPACKAGE *package, LPCWSTR szCondition )
729 {
730 COND_input cond;
731 MSICONDITION r;
732
733 TRACE("%s\n", debugstr_w( szCondition ) );
734
735 if ( szCondition == NULL )
736 return MSICONDITION_NONE;
737
738 cond.package = package;
739 cond.str = szCondition;
740 cond.n = 0;
741 cond.result = MSICONDITION_ERROR;
742
743 if ( !cond_parse( &cond ) )
744 r = cond.result;
745 else
746 r = MSICONDITION_ERROR;
747
748 TRACE("%i <- %s\n", r, debugstr_w(szCondition));
749 return r;
750 }
751
752 MSICONDITION WINAPI MsiEvaluateConditionW( MSIHANDLE hInstall, LPCWSTR szCondition )
753 {
754 MSIPACKAGE *package;
755 UINT ret;
756
757 package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
758 if( !package )
759 {
760 HRESULT hr;
761 BSTR condition;
762 IWineMsiRemotePackage *remote_package;
763
764 remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall );
765 if (!remote_package)
766 return MSICONDITION_ERROR;
767
768 condition = SysAllocString( szCondition );
769 if (!condition)
770 {
771 IWineMsiRemotePackage_Release( remote_package );
772 return ERROR_OUTOFMEMORY;
773 }
774
775 hr = IWineMsiRemotePackage_EvaluateCondition( remote_package, condition );
776
777 SysFreeString( condition );
778 IWineMsiRemotePackage_Release( remote_package );
779
780 if (FAILED(hr))
781 {
782 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
783 return HRESULT_CODE(hr);
784
785 return ERROR_FUNCTION_FAILED;
786 }
787
788 return ERROR_SUCCESS;
789 }
790
791 ret = MSI_EvaluateConditionW( package, szCondition );
792 msiobj_release( &package->hdr );
793 return ret;
794 }
795
796 MSICONDITION WINAPI MsiEvaluateConditionA( MSIHANDLE hInstall, LPCSTR szCondition )
797 {
798 LPWSTR szwCond = NULL;
799 MSICONDITION r;
800
801 szwCond = strdupAtoW( szCondition );
802 if( szCondition && !szwCond )
803 return MSICONDITION_ERROR;
804
805 r = MsiEvaluateConditionW( hInstall, szwCond );
806 msi_free( szwCond );
807 return r;
808 }
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.