Added MIME type checking to ResProtocol::Start.
[wine] / dlls / msi / where.c
1 /*
2  * Implementation of the Microsoft Installer (msi.dll)
3  *
4  * Copyright 2002 Mike McCormack for CodeWeavers
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include <stdarg.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winerror.h"
26 #include "wine/debug.h"
27 #include "msi.h"
28 #include "msiquery.h"
29 #include "objbase.h"
30 #include "objidl.h"
31 #include "msipriv.h"
32 #include "winnls.h"
33
34 #include "query.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(msi);
37
38
39 /* below is the query interface to a table */
40
41 typedef struct tagMSIWHEREVIEW
42 {
43     MSIVIEW        view;
44     MSIDATABASE   *db;
45     MSIVIEW       *table;
46     UINT           row_count;
47     UINT          *reorder;
48     struct expr   *cond;
49 } MSIWHEREVIEW;
50
51 static UINT WHERE_fetch_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT *val )
52 {
53     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
54
55     TRACE("%p %d %d %p\n", wv, row, col, val );
56
57     if( !wv->table )
58         return ERROR_FUNCTION_FAILED;
59
60     if( row > wv->row_count )
61         return ERROR_NO_MORE_ITEMS;
62
63     row = wv->reorder[ row ];
64
65     return wv->table->ops->fetch_int( wv->table, row, col, val );
66 }
67
68 static UINT WHERE_fetch_stream( struct tagMSIVIEW *view, UINT row, UINT col, IStream **stm )
69 {
70     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
71
72     TRACE("%p %d %d %p\n", wv, row, col, stm );
73
74     if( !wv->table )
75         return ERROR_FUNCTION_FAILED;
76
77     if( row > wv->row_count )
78         return ERROR_NO_MORE_ITEMS;
79
80     row = wv->reorder[ row ];
81
82     return wv->table->ops->fetch_stream( wv->table, row, col, stm );
83 }
84
85 static UINT WHERE_set_int( struct tagMSIVIEW *view, UINT row, UINT col, UINT val )
86 {
87     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
88
89     TRACE("%p %d %d %04x\n", wv, row, col, val );
90
91     if( !wv->table )
92          return ERROR_FUNCTION_FAILED;
93     
94     if( row > wv->row_count )
95         return ERROR_NO_MORE_ITEMS;
96     
97     row = wv->reorder[ row ];
98     
99     return wv->table->ops->set_int( wv->table, row, col, val );
100 }
101
102 static UINT INT_evaluate( UINT lval, UINT op, UINT rval )
103 {
104     switch( op )
105     {
106     case OP_EQ:
107         return ( lval == rval );
108     case OP_AND:
109         return ( lval && rval );
110     case OP_OR:
111         return ( lval || rval );
112     case OP_GT:
113         return ( lval > rval );
114     case OP_LT:
115         return ( lval < rval );
116     case OP_LE:
117         return ( lval <= rval );
118     case OP_GE:
119         return ( lval >= rval );
120     case OP_NE:
121         return ( lval != rval );
122     case OP_ISNULL:
123         return ( !lval );
124     case OP_NOTNULL:
125         return ( lval );
126     default:
127         ERR("Unknown operator %d\n", op );
128     }
129     return 0;
130 }
131
132 static const WCHAR *STRING_evaluate( string_table *st,
133               MSIVIEW *table, UINT row, struct expr *expr, MSIRECORD *record )
134 {
135     UINT val = 0, r;
136
137     switch( expr->type )
138     {
139     case EXPR_COL_NUMBER_STRING:
140         r = table->ops->fetch_int( table, row, expr->u.col_number, &val );
141         if( r != ERROR_SUCCESS )
142             return NULL;
143         return msi_string_lookup_id( st, val );
144
145     case EXPR_SVAL:
146         return expr->u.sval;
147
148     case EXPR_WILDCARD:
149         return MSI_RecordGetString( record, 1 );
150
151     default:
152         ERR("Invalid expression type\n");
153         break;
154     }
155     return NULL;
156 }
157
158 static UINT STRCMP_Evaluate( string_table *st, MSIVIEW *table, UINT row, 
159                              struct expr *cond, UINT *val, MSIRECORD *record )
160 {
161     int sr;
162     const WCHAR *l_str, *r_str;
163
164     l_str = STRING_evaluate( st, table, row, cond->u.expr.left, record );
165     r_str = STRING_evaluate( st, table, row, cond->u.expr.right, record );
166     if( l_str == r_str )
167         sr = 0;
168     else if( l_str && ! r_str )
169         sr = 1;
170     else if( r_str && ! l_str )
171         sr = -1;
172     else
173         sr = lstrcmpW( l_str, r_str );
174
175     *val = ( cond->u.expr.op == OP_EQ && ( sr == 0 ) ) ||
176            ( cond->u.expr.op == OP_LT && ( sr < 0 ) ) ||
177            ( cond->u.expr.op == OP_GT && ( sr > 0 ) );
178
179     return ERROR_SUCCESS;
180 }
181
182 static UINT WHERE_evaluate( MSIDATABASE *db, MSIVIEW *table, UINT row, 
183                              struct expr *cond, UINT *val, MSIRECORD *record )
184 {
185     UINT r, lval, rval;
186
187     if( !cond )
188         return ERROR_SUCCESS;
189
190     switch( cond->type )
191     {
192     case EXPR_COL_NUMBER_STRING:
193     case EXPR_COL_NUMBER:
194         return table->ops->fetch_int( table, row, cond->u.col_number, val );
195
196     case EXPR_UVAL:
197         *val = cond->u.uval;
198         return ERROR_SUCCESS;
199
200     case EXPR_COMPLEX:
201         r = WHERE_evaluate( db, table, row, cond->u.expr.left, &lval, record );
202         if( r != ERROR_SUCCESS )
203             return r;
204         r = WHERE_evaluate( db, table, row, cond->u.expr.right, &rval, record );
205         if( r != ERROR_SUCCESS )
206             return r;
207         *val = INT_evaluate( lval, cond->u.expr.op, rval );
208         return ERROR_SUCCESS;
209
210     case EXPR_STRCMP:
211         return STRCMP_Evaluate( db->strings, table, row, cond, val, record );
212
213     case EXPR_WILDCARD:
214         *val = MSI_RecordGetInteger( record, 1 );
215         return ERROR_SUCCESS;
216
217     default:
218         ERR("Invalid expression type\n");
219         break;
220     } 
221
222     return ERROR_SUCCESS;
223
224 }
225
226 static UINT WHERE_execute( struct tagMSIVIEW *view, MSIRECORD *record )
227 {
228     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
229     UINT count = 0, r, val, i;
230     MSIVIEW *table = wv->table;
231
232     TRACE("%p %p\n", wv, record);
233
234     if( !table )
235          return ERROR_FUNCTION_FAILED;
236
237     r = table->ops->execute( table, record );
238     if( r != ERROR_SUCCESS )
239         return r;
240
241     r = table->ops->get_dimensions( table, &count, NULL );
242     if( r != ERROR_SUCCESS )
243         return r;
244
245     wv->reorder = HeapAlloc( GetProcessHeap(), 0, count*sizeof(UINT) );
246     if( !wv->reorder )
247         return ERROR_FUNCTION_FAILED;
248
249     wv->row_count = 0;
250     for( i=0; i<count; i++ )
251     {
252         val = 0;
253         r = WHERE_evaluate( wv->db, table, i, wv->cond, &val, record );
254         if( r != ERROR_SUCCESS )
255             return r;
256         if( val )
257             wv->reorder[ wv->row_count ++ ] = i;
258     }
259
260     return ERROR_SUCCESS;
261 }
262
263 static UINT WHERE_close( struct tagMSIVIEW *view )
264 {
265     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
266
267     TRACE("%p\n", wv );
268
269     if( !wv->table )
270          return ERROR_FUNCTION_FAILED;
271
272     HeapFree( GetProcessHeap(), 0, wv->reorder );
273     wv->reorder = NULL;
274
275     return wv->table->ops->close( wv->table );
276 }
277
278 static UINT WHERE_get_dimensions( struct tagMSIVIEW *view, UINT *rows, UINT *cols )
279 {
280     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
281
282     TRACE("%p %p %p\n", wv, rows, cols );
283
284     if( !wv->table )
285          return ERROR_FUNCTION_FAILED;
286
287     if( rows )
288     {
289         if( !wv->reorder )
290             return ERROR_FUNCTION_FAILED;
291         *rows = wv->row_count;
292     }
293
294     return wv->table->ops->get_dimensions( wv->table, NULL, cols );
295 }
296
297 static UINT WHERE_get_column_info( struct tagMSIVIEW *view,
298                 UINT n, LPWSTR *name, UINT *type )
299 {
300     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
301
302     TRACE("%p %d %p %p\n", wv, n, name, type );
303
304     if( !wv->table )
305          return ERROR_FUNCTION_FAILED;
306
307     return wv->table->ops->get_column_info( wv->table, n, name, type );
308 }
309
310 static UINT WHERE_modify( struct tagMSIVIEW *view, MSIMODIFY eModifyMode,
311                 MSIRECORD *rec )
312 {
313     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
314
315     TRACE("%p %d %p\n", wv, eModifyMode, rec );
316
317     if( !wv->table )
318          return ERROR_FUNCTION_FAILED;
319
320     return wv->table->ops->modify( wv->table, eModifyMode, rec );
321 }
322
323 static UINT WHERE_delete( struct tagMSIVIEW *view )
324 {
325     MSIWHEREVIEW *wv = (MSIWHEREVIEW*)view;
326
327     TRACE("%p\n", wv );
328
329     if( wv->table )
330         wv->table->ops->delete( wv->table );
331
332     HeapFree( GetProcessHeap(), 0, wv->reorder );
333     wv->reorder = NULL;
334     wv->row_count = 0;
335
336     msiobj_release( &wv->db->hdr );
337     HeapFree( GetProcessHeap(), 0, wv );
338
339     return ERROR_SUCCESS;
340 }
341
342
343 MSIVIEWOPS where_ops =
344 {
345     WHERE_fetch_int,
346     WHERE_fetch_stream,
347     WHERE_set_int,
348     NULL,
349     WHERE_execute,
350     WHERE_close,
351     WHERE_get_dimensions,
352     WHERE_get_column_info,
353     WHERE_modify,
354     WHERE_delete
355 };
356
357 static UINT WHERE_VerifyCondition( MSIDATABASE *db, MSIVIEW *table, struct expr *cond,
358                                    UINT *valid )
359 {
360     UINT r, val = 0;
361
362     switch( cond->type )
363     {
364     case EXPR_COLUMN:
365         r = VIEW_find_column( table, cond->u.column, &val );
366         if( r == ERROR_SUCCESS )
367         {
368             UINT type = 0;
369             r = table->ops->get_column_info( table, val, NULL, &type );
370             if( r == ERROR_SUCCESS )
371             {
372                 if (type&MSITYPE_STRING)
373                     cond->type = EXPR_COL_NUMBER_STRING;
374                 else
375                     cond->type = EXPR_COL_NUMBER;
376                 cond->u.col_number = val;
377                 *valid = 1;
378             }
379             else
380                 *valid = 0;
381         }
382         else
383         {
384             *valid = 0;
385             ERR("Couldn't find column %s\n", debugstr_w( cond->u.column ) );
386         }
387         break;
388     case EXPR_COMPLEX:
389         r = WHERE_VerifyCondition( db, table, cond->u.expr.left, valid );
390         if( r != ERROR_SUCCESS )
391             return r;
392         if( !*valid )
393             return ERROR_SUCCESS;
394         r = WHERE_VerifyCondition( db, table, cond->u.expr.right, valid );
395         if( r != ERROR_SUCCESS )
396             return r;
397
398         /* check the type of the comparison */
399         if( ( cond->u.expr.left->type == EXPR_SVAL ) ||
400             ( cond->u.expr.left->type == EXPR_COL_NUMBER_STRING ) ||
401             ( cond->u.expr.right->type == EXPR_SVAL ) ||
402             ( cond->u.expr.right->type == EXPR_COL_NUMBER_STRING ) )
403         {
404             switch( cond->u.expr.op )
405             {
406             case OP_EQ:
407             case OP_GT:
408             case OP_LT:
409                 break;
410             default:
411                 *valid = FALSE;
412                 return ERROR_INVALID_PARAMETER;
413             }
414
415             /* FIXME: check we're comparing a string to a column */
416
417             cond->type = EXPR_STRCMP;
418         }
419
420         break;
421     case EXPR_IVAL:
422         *valid = 1;
423         cond->type = EXPR_UVAL;
424         cond->u.uval = cond->u.ival + (1<<15);
425         break;
426     case EXPR_WILDCARD:
427         *valid = 1;
428         break;
429     case EXPR_SVAL:
430         *valid = 1;
431         break;
432     default:
433         ERR("Invalid expression type\n");
434         *valid = 0;
435         break;
436     } 
437
438     return ERROR_SUCCESS;
439 }
440
441 UINT WHERE_CreateView( MSIDATABASE *db, MSIVIEW **view, MSIVIEW *table,
442                        struct expr *cond )
443 {
444     MSIWHEREVIEW *wv = NULL;
445     UINT count = 0, r, valid = 0;
446
447     TRACE("%p\n", wv );
448
449     r = table->ops->get_dimensions( table, NULL, &count );
450     if( r != ERROR_SUCCESS )
451     {
452         ERR("can't get table dimensions\n");
453         return r;
454     }
455
456     if( cond )
457     {
458         r = WHERE_VerifyCondition( db, table, cond, &valid );
459         if( r != ERROR_SUCCESS )
460             return r;
461         if( !valid )
462             return ERROR_FUNCTION_FAILED;
463     }
464
465     wv = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof *wv );
466     if( !wv )
467         return ERROR_FUNCTION_FAILED;
468     
469     /* fill the structure */
470     wv->view.ops = &where_ops;
471     msiobj_addref( &db->hdr );
472     wv->db = db;
473     wv->table = table;
474     wv->row_count = 0;
475     wv->reorder = NULL;
476     wv->cond = cond;
477     *view = (MSIVIEW*) wv;
478
479     return ERROR_SUCCESS;
480 }