?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Hacked stdio functions to use Win32 file handles. Still needs a proper
[wine/multimedia.git] / ole / storage.c
blob83ce52ece49d32e8bdbada26b9e498e21797d7ac
1 /* Compound Storage
2 *
3 * Implemented using the documentation of the LAOLA project at
4 * <URL:http://wwwwbs.cs.tu-berlin.de/~schwartz/pmh/index.html>
5 * (Thanks to Martin Schwartz <schwartz@cs.tu-berlin.de>)
6 *
7 * Copyright 1998 Marcus Meissner
8 */
9
10 #include <assert.h>
11 #include <time.h>
12 #include <string.h>
13 #include "windows.h"
14 #include "winerror.h"
15 #include "file.h"
16 #include "ole.h"
17 #include "ole2.h"
18 #include "compobj.h"
19 #include "interfaces.h"
20 #include "storage.h"
21 #include "heap.h"
22 #include "module.h"
23 #include "ldt.h"
24 #include "debug.h"
25
26 static const BYTE STORAGE_magic[8] ={0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1};
27 static const BYTE STORAGE_notmagic[8]={0x0e,0x11,0xfc,0x0d,0xd0,0xcf,0x11,0xe0};
28 static const BYTE STORAGE_oldmagic[8]={0xd0,0xcf,0x11,0xe0,0x0e,0x11,0xfc,0x0d};
29
30 #define BIGSIZE 512
31 #define SMALLSIZE 64
32
33 #define SMALLBLOCKS_PER_BIGBLOCK (BIGSIZE/SMALLSIZE)
34
35 #define READ_HEADER assert(STORAGE_get_big_block(hf,-1,(LPBYTE)&sth));assert(!memcmp(STORAGE_magic,sth.magic,sizeof(STORAGE_magic)));
36 static ICOM_VTABLE(IStorage16) stvt16;
37 static ICOM_VTABLE(IStorage16) *segstvt16 = NULL;
38 static ICOM_VTABLE(IStorage32) stvt32;
39 static ICOM_VTABLE(IStream16) strvt16;
40 static ICOM_VTABLE(IStream16) *segstrvt16 = NULL;
41 static ICOM_VTABLE(IStream32) strvt32;
42
43 /*ULONG WINAPI IStorage16_AddRef(LPSTORAGE16 this);*/
44 static void _create_istorage16(LPSTORAGE16 *stg);
45 static void _create_istream16(LPSTREAM16 *str);
46
47 #define IMPLEMENTED 1
48
49
50 /******************************************************************************
51 * STORAGE_get_big_block [Internal]
52 *
53 * Reading OLE compound storage
54 */
55 static BOOL32
56 STORAGE_get_big_block(HFILE32 hf,int n,BYTE *block) {
57 assert(n>=-1);
58 if (-1==_llseek32(hf,(n+1)*BIGSIZE,SEEK_SET)) {
59 WARN(ole," seek failed (%ld)\n",GetLastError());
60 return FALSE;
61 }
62 assert((n+1)*BIGSIZE==_llseek32(hf,0,SEEK_CUR));
63 if (BIGSIZE!=_lread32(hf,block,BIGSIZE)) {
64 WARN(ole,"(block size %d): read didn't read (%ld)\n",n,GetLastError());
65 assert(0);
66 return FALSE;
67 }
68 return TRUE;
69 }
70
71 /******************************************************************************
72 * STORAGE_put_big_block [INTERNAL]
73 */
74 static BOOL32
75 STORAGE_put_big_block(HFILE32 hf,int n,BYTE *block) {
76 assert(n>=-1);
77 if (-1==_llseek32(hf,(n+1)*BIGSIZE,SEEK_SET)) {
78 WARN(ole," seek failed (%ld)\n",GetLastError());
79 return FALSE;
80 }
81 assert((n+1)*BIGSIZE==_llseek32(hf,0,SEEK_CUR));
82 if (BIGSIZE!=_lwrite32(hf,block,BIGSIZE)) {
83 WARN(ole," write failed (%ld)\n",GetLastError());
84 return FALSE;
85 }
86 return TRUE;
87 }
88
89 /******************************************************************************
90 * STORAGE_get_next_big_blocknr [INTERNAL]
91 */
92 static int
93 STORAGE_get_next_big_blocknr(HFILE32 hf,int blocknr) {
94 INT32 bbs[BIGSIZE/sizeof(INT32)];
95 struct storage_header sth;
96
97 READ_HEADER;
98
99 assert(blocknr>>7<sth.num_of_bbd_blocks);
100 if (sth.bbd_list[blocknr>>7]==0xffffffff)
101 return -5;
102 if (!STORAGE_get_big_block(hf,sth.bbd_list[blocknr>>7],(LPBYTE)bbs))
103 return -5;
104 assert(bbs[blocknr&0x7f]!=STORAGE_CHAINENTRY_FREE);
105 return bbs[blocknr&0x7f];
106 }
107
108 /******************************************************************************
109 * STORAGE_get_nth_next_big_blocknr [INTERNAL]
110 */
111 static int
112 STORAGE_get_nth_next_big_blocknr(HFILE32 hf,int blocknr,int nr) {
113 INT32 bbs[BIGSIZE/sizeof(INT32)];
114 int lastblock = -1;
115 struct storage_header sth;
116
117 READ_HEADER;
118
119 assert(blocknr>=0);
120 while (nr--) {
121 assert((blocknr>>7)<sth.num_of_bbd_blocks);
122 assert(sth.bbd_list[blocknr>>7]!=0xffffffff);
123
124 /* simple caching... */
125 if (lastblock!=sth.bbd_list[blocknr>>7]) {
126 assert(STORAGE_get_big_block(hf,sth.bbd_list[blocknr>>7],(LPBYTE)bbs));
127 lastblock = sth.bbd_list[blocknr>>7];
128 }
129 blocknr = bbs[blocknr&0x7f];
130 }
131 return blocknr;
132 }
133
134 /******************************************************************************
135 * STORAGE_get_root_pps_entry [Internal]
136 */
137 static BOOL32
138 STORAGE_get_root_pps_entry(HFILE32 hf,struct storage_pps_entry *pstde) {
139 int blocknr,i;
140 BYTE block[BIGSIZE];
141 struct storage_pps_entry *stde=(struct storage_pps_entry*)block;
142 struct storage_header sth;
143
144 READ_HEADER;
145 blocknr = sth.root_startblock;
146 while (blocknr>=0) {
147 assert(STORAGE_get_big_block(hf,blocknr,block));
148 for (i=0;i<4;i++) {
149 if (!stde[i].pps_sizeofname)
150 continue;
151 if (stde[i].pps_type==5) {
152 *pstde=stde[i];
153 return TRUE;
154 }
155 }
156 blocknr=STORAGE_get_next_big_blocknr(hf,blocknr);
157 }
158 return FALSE;
159 }
160
161 /******************************************************************************
162 * STORAGE_get_small_block [INTERNAL]
163 */
164 static BOOL32
165 STORAGE_get_small_block(HFILE32 hf,int blocknr,BYTE *sblock) {
166 BYTE block[BIGSIZE];
167 int bigblocknr;
168 struct storage_pps_entry root;
169
170 assert(blocknr>=0);
171 assert(STORAGE_get_root_pps_entry(hf,&root));
172 bigblocknr = STORAGE_get_nth_next_big_blocknr(hf,root.pps_sb,blocknr/SMALLBLOCKS_PER_BIGBLOCK);
173 assert(bigblocknr>=0);
174 assert(STORAGE_get_big_block(hf,bigblocknr,block));
175
176 memcpy(sblock,((LPBYTE)block)+SMALLSIZE*(blocknr&(SMALLBLOCKS_PER_BIGBLOCK-1)),SMALLSIZE);
177 return TRUE;
178 }
179
180 /******************************************************************************
181 * STORAGE_put_small_block [INTERNAL]
182 */
183 static BOOL32
184 STORAGE_put_small_block(HFILE32 hf,int blocknr,BYTE *sblock) {
185 BYTE block[BIGSIZE];
186 int bigblocknr;
187 struct storage_pps_entry root;
188
189 assert(blocknr>=0);
190
191 assert(STORAGE_get_root_pps_entry(hf,&root));
192 bigblocknr = STORAGE_get_nth_next_big_blocknr(hf,root.pps_sb,blocknr/SMALLBLOCKS_PER_BIGBLOCK);
193 assert(bigblocknr>=0);
194 assert(STORAGE_get_big_block(hf,bigblocknr,block));
195
196 memcpy(((LPBYTE)block)+SMALLSIZE*(blocknr&(SMALLBLOCKS_PER_BIGBLOCK-1)),sblock,SMALLSIZE);
197 assert(STORAGE_put_big_block(hf,bigblocknr,block));
198 return TRUE;
199 }
200
201 /******************************************************************************
202 * STORAGE_get_next_small_blocknr [INTERNAL]
203 */
204 static int
205 STORAGE_get_next_small_blocknr(HFILE32 hf,int blocknr) {
206 BYTE block[BIGSIZE];
207 LPINT32 sbd = (LPINT32)block;
208 int bigblocknr;
209 struct storage_header sth;
210
211 READ_HEADER;
212 assert(blocknr>=0);
213 bigblocknr = STORAGE_get_nth_next_big_blocknr(hf,sth.sbd_startblock,blocknr/128);
214 assert(bigblocknr>=0);
215 assert(STORAGE_get_big_block(hf,bigblocknr,block));
216 assert(sbd[blocknr & 127]!=STORAGE_CHAINENTRY_FREE);
217 return sbd[blocknr & (128-1)];
218 }
219
220 /******************************************************************************
221 * STORAGE_get_nth_next_small_blocknr [INTERNAL]
222 */
223 static int
224 STORAGE_get_nth_next_small_blocknr(HFILE32 hf,int blocknr,int nr) {
225 int lastblocknr;
226 BYTE block[BIGSIZE];
227 LPINT32 sbd = (LPINT32)block;
228 struct storage_header sth;
229
230 READ_HEADER;
231 lastblocknr=-1;
232 assert(blocknr>=0);
233 while ((nr--) && (blocknr>=0)) {
234 if (lastblocknr/128!=blocknr/128) {
235 int bigblocknr;
236 bigblocknr = STORAGE_get_nth_next_big_blocknr(hf,sth.sbd_startblock,blocknr/128);
237 assert(bigblocknr>=0);
238 assert(STORAGE_get_big_block(hf,bigblocknr,block));
239 lastblocknr = blocknr;
240 }
241 assert(lastblocknr>=0);
242 lastblocknr=blocknr;
243 blocknr=sbd[blocknr & (128-1)];
244 assert(blocknr!=STORAGE_CHAINENTRY_FREE);
245 }
246 return blocknr;
247 }
248
249 /******************************************************************************
250 * STORAGE_get_pps_entry [INTERNAL]
251 */
252 static int
253 STORAGE_get_pps_entry(HFILE32 hf,int n,struct storage_pps_entry *pstde) {
254 int blocknr;
255 BYTE block[BIGSIZE];
256 struct storage_pps_entry *stde = (struct storage_pps_entry*)(((LPBYTE)block)+128*(n&3));
257 struct storage_header sth;
258
259 READ_HEADER;
260 /* we have 4 pps entries per big block */
261 blocknr = STORAGE_get_nth_next_big_blocknr(hf,sth.root_startblock,n/4);
262 assert(blocknr>=0);
263 assert(STORAGE_get_big_block(hf,blocknr,block));
264
265 *pstde=*stde;
266 return 1;
267 }
268
269 /******************************************************************************
270 * STORAGE_put_pps_entry [Internal]
271 */
272 static int
273 STORAGE_put_pps_entry(HFILE32 hf,int n,struct storage_pps_entry *pstde) {
274 int blocknr;
275 BYTE block[BIGSIZE];
276 struct storage_pps_entry *stde = (struct storage_pps_entry*)(((LPBYTE)block)+128*(n&3));
277 struct storage_header sth;
278
279 READ_HEADER;
280
281 /* we have 4 pps entries per big block */
282 blocknr = STORAGE_get_nth_next_big_blocknr(hf,sth.root_startblock,n/4);
283 assert(blocknr>=0);
284 assert(STORAGE_get_big_block(hf,blocknr,block));
285 *stde=*pstde;
286 assert(STORAGE_put_big_block(hf,blocknr,block));
287 return 1;
288 }
289
290 /******************************************************************************
291 * STORAGE_look_for_named_pps [Internal]
292 */
293 static int
294 STORAGE_look_for_named_pps(HFILE32 hf,int n,LPOLESTR32 name) {
295 struct storage_pps_entry stde;
296 int ret;
297
298 if (n==-1)
299 return -1;
300 if (1!=STORAGE_get_pps_entry(hf,n,&stde))
301 return -1;
302
303 if (!lstrcmp32W(name,stde.pps_rawname))
304 return n;
305 if (stde.pps_prev != -1) {
306 ret=STORAGE_look_for_named_pps(hf,stde.pps_prev,name);
307 if (ret!=-1)
308 return ret;
309 }
310 if (stde.pps_next != -1) {
311 ret=STORAGE_look_for_named_pps(hf,stde.pps_next,name);
312 if (ret!=-1)
313 return ret;
314 }
315 return -1;
316 }
317
318 /******************************************************************************
319 * STORAGE_dump_pps_entry [Internal]
320 *
321 * FIXME
322 * Function is unused
323 */
324 void
325 STORAGE_dump_pps_entry(struct storage_pps_entry *stde) {
326 char name[33],xguid[50];
327
328 WINE_StringFromCLSID(&(stde->pps_guid),xguid);
329
330 lstrcpyWtoA(name,stde->pps_rawname);
331 if (!stde->pps_sizeofname)
332 return;
333 DUMP("name: %s\n",name);
334 DUMP("type: %d\n",stde->pps_type);
335 DUMP("prev pps: %ld\n",stde->pps_prev);
336 DUMP("next pps: %ld\n",stde->pps_next);
337 DUMP("dir pps: %ld\n",stde->pps_dir);
338 DUMP("guid: %s\n",xguid);
339 if (stde->pps_type !=2) {
340 time_t t;
341
342 t = DOSFS_FileTimeToUnixTime(&(stde->pps_ft1),NULL);
343 DUMP("ts1: %s\n",ctime(&t));
344 t = DOSFS_FileTimeToUnixTime(&(stde->pps_ft2),NULL);
345 DUMP("ts2: %s\n",ctime(&t));
346 }
347 DUMP("startblock: %ld\n",stde->pps_sb);
348 DUMP("size: %ld\n",stde->pps_size);
349 }
350
351 /******************************************************************************
352 * STORAGE_init_storage [INTERNAL]
353 */
354 static BOOL32
355 STORAGE_init_storage(HFILE32 hf) {
356 BYTE block[BIGSIZE];
357 LPDWORD bbs;
358 struct storage_header *sth;
359 struct storage_pps_entry *stde;
360
361 assert(-1!=_llseek32(hf,0,SEEK_SET));
362 /* block -1 is the storage header */
363 sth = (struct storage_header*)block;
364 memcpy(sth->magic,STORAGE_magic,8);
365 memset(sth->unknown1,0,sizeof(sth->unknown1));
366 memset(sth->unknown2,0,sizeof(sth->unknown2));
367 memset(sth->unknown3,0,sizeof(sth->unknown3));
368 sth->num_of_bbd_blocks = 1;
369 sth->root_startblock = 1;
370 sth->sbd_startblock = 0xffffffff;
371 memset(sth->bbd_list,0xff,sizeof(sth->bbd_list));
372 sth->bbd_list[0] = 0;
373 assert(BIGSIZE==_lwrite32(hf,block,BIGSIZE));
374 /* block 0 is the big block directory */
375 bbs=(LPDWORD)block;
376 memset(block,0xff,sizeof(block)); /* mark all blocks as free */
377 bbs[0]=STORAGE_CHAINENTRY_ENDOFCHAIN; /* for this block */
378 bbs[1]=STORAGE_CHAINENTRY_ENDOFCHAIN; /* for directory entry */
379 assert(BIGSIZE==_lwrite32(hf,block,BIGSIZE));
380 /* block 1 is the root directory entry */
381 memset(block,0x00,sizeof(block));
382 stde = (struct storage_pps_entry*)block;
383 lstrcpyAtoW(stde->pps_rawname,"RootEntry");
384 stde->pps_sizeofname = lstrlen32W(stde->pps_rawname)*2+2;
385 stde->pps_type = 5;
386 stde->pps_dir = -1;
387 stde->pps_next = -1;
388 stde->pps_prev = -1;
389 stde->pps_sb = 0xffffffff;
390 stde->pps_size = 0;
391 assert(BIGSIZE==_lwrite32(hf,block,BIGSIZE));
392 return TRUE;
393 }
394
395 /******************************************************************************
396 * STORAGE_set_big_chain [Internal]
397 */
398 static BOOL32
399 STORAGE_set_big_chain(HFILE32 hf,int blocknr,INT32 type) {
400 BYTE block[BIGSIZE];
401 LPINT32 bbd = (LPINT32)block;
402 int nextblocknr,bigblocknr;
403 struct storage_header sth;
404
405 READ_HEADER;
406 assert(blocknr!=type);
407 while (blocknr>=0) {
408 bigblocknr = sth.bbd_list[blocknr/128];
409 assert(bigblocknr>=0);
410 assert(STORAGE_get_big_block(hf,bigblocknr,block));
411
412 nextblocknr = bbd[blocknr&(128-1)];
413 bbd[blocknr&(128-1)] = type;
414 if (type>=0)
415 return TRUE;
416 assert(STORAGE_put_big_block(hf,bigblocknr,block));
417 type = STORAGE_CHAINENTRY_FREE;
418 blocknr = nextblocknr;
419 }
420 return TRUE;
421 }
422
423 /******************************************************************************
424 * STORAGE_set_small_chain [Internal]
425 */
426 static BOOL32
427 STORAGE_set_small_chain(HFILE32 hf,int blocknr,INT32 type) {
428 BYTE block[BIGSIZE];
429 LPINT32 sbd = (LPINT32)block;
430 int lastblocknr,nextsmallblocknr,bigblocknr;
431 struct storage_header sth;
432
433 READ_HEADER;
434
435 assert(blocknr!=type);
436 lastblocknr=-129;bigblocknr=-2;
437 while (blocknr>=0) {
438 /* cache block ... */
439 if (lastblocknr/128!=blocknr/128) {
440 bigblocknr = STORAGE_get_nth_next_big_blocknr(hf,sth.sbd_startblock,blocknr/128);
441 assert(bigblocknr>=0);
442 assert(STORAGE_get_big_block(hf,bigblocknr,block));
443 }
444 lastblocknr = blocknr;
445 nextsmallblocknr = sbd[blocknr&(128-1)];
446 sbd[blocknr&(128-1)] = type;
447 assert(STORAGE_put_big_block(hf,bigblocknr,block));
448 if (type>=0)
449 return TRUE;
450 type = STORAGE_CHAINENTRY_FREE;
451 blocknr = nextsmallblocknr;
452 }
453 return TRUE;
454 }
455
456 /******************************************************************************
457 * STORAGE_get_free_big_blocknr [Internal]
458 */
459 static int
460 STORAGE_get_free_big_blocknr(HFILE32 hf) {
461 BYTE block[BIGSIZE];
462 LPINT32 sbd = (LPINT32)block;
463 int lastbigblocknr,i,curblock,bigblocknr;
464 struct storage_header sth;
465
466 READ_HEADER;
467 curblock = 0;
468 lastbigblocknr = -1;
469 bigblocknr = sth.bbd_list[curblock];
470 while (curblock<sth.num_of_bbd_blocks) {
471 assert(bigblocknr>=0);
472 assert(STORAGE_get_big_block(hf,bigblocknr,block));
473 for (i=0;i<128;i++)
474 if (sbd[i]==STORAGE_CHAINENTRY_FREE) {
475 sbd[i] = STORAGE_CHAINENTRY_ENDOFCHAIN;
476 assert(STORAGE_put_big_block(hf,bigblocknr,block));
477 memset(block,0x42,sizeof(block));
478 assert(STORAGE_put_big_block(hf,i+curblock*128,block));
479 return i+curblock*128;
480 }
481 lastbigblocknr = bigblocknr;
482 bigblocknr = sth.bbd_list[++curblock];
483 }
484 bigblocknr = curblock*128;
485 /* since we have marked all blocks from 0 up to curblock*128-1
486 * the next free one is curblock*128, where we happily put our
487 * next large block depot.
488 */
489 memset(block,0xff,sizeof(block));
490 /* mark the block allocated and returned by this function */
491 sbd[1] = STORAGE_CHAINENTRY_ENDOFCHAIN;
492 assert(STORAGE_put_big_block(hf,bigblocknr,block));
493
494 /* if we had a bbd block already (mostlikely) we need
495 * to link the new one into the chain
496 */
497 if (lastbigblocknr!=-1)
498 assert(STORAGE_set_big_chain(hf,lastbigblocknr,bigblocknr));
499 sth.bbd_list[curblock]=bigblocknr;
500 sth.num_of_bbd_blocks++;
501 assert(sth.num_of_bbd_blocks==curblock+1);
502 assert(STORAGE_put_big_block(hf,-1,(LPBYTE)&sth));
503
504 /* Set the end of the chain for the bigblockdepots */
505 assert(STORAGE_set_big_chain(hf,bigblocknr,STORAGE_CHAINENTRY_ENDOFCHAIN));
506 /* add 1, for the first entry is used for the additional big block
507 * depot. (means we already used bigblocknr) */
508 memset(block,0x42,sizeof(block));
509 /* allocate this block (filled with 0x42) */
510 assert(STORAGE_put_big_block(hf,bigblocknr+1,block));
511 return bigblocknr+1;
512 }
513
514
515 /******************************************************************************
516 * STORAGE_get_free_small_blocknr [Internal]
517 */
518 static int
519 STORAGE_get_free_small_blocknr(HFILE32 hf) {
520 BYTE block[BIGSIZE];
521 LPINT32 sbd = (LPINT32)block;
522 int lastbigblocknr,newblocknr,i,curblock,bigblocknr;
523 struct storage_pps_entry root;
524 struct storage_header sth;
525
526 READ_HEADER;
527 bigblocknr = sth.sbd_startblock;
528 curblock = 0;
529 lastbigblocknr = -1;
530 newblocknr = -1;
531 while (bigblocknr>=0) {
532 if (!STORAGE_get_big_block(hf,bigblocknr,block))
533 return -1;
534 for (i=0;i<128;i++)
535 if (sbd[i]==STORAGE_CHAINENTRY_FREE) {
536 sbd[i]=STORAGE_CHAINENTRY_ENDOFCHAIN;
537 newblocknr = i+curblock*128;
538 break;
539 }
540 if (i!=128)
541 break;
542 lastbigblocknr = bigblocknr;
543 bigblocknr = STORAGE_get_next_big_blocknr(hf,bigblocknr);
544 curblock++;
545 }
546 if (newblocknr==-1) {
547 bigblocknr = STORAGE_get_free_big_blocknr(hf);
548 if (bigblocknr<0)
549 return -1;
550 READ_HEADER;
551 memset(block,0xff,sizeof(block));
552 sbd[0]=STORAGE_CHAINENTRY_ENDOFCHAIN;
553 if (!STORAGE_put_big_block(hf,bigblocknr,block))
554 return -1;
555 if (lastbigblocknr==-1) {
556 sth.sbd_startblock = bigblocknr;
557 if (!STORAGE_put_big_block(hf,-1,(LPBYTE)&sth)) /* need to write it */
558 return -1;
559 } else {
560 if (!STORAGE_set_big_chain(hf,lastbigblocknr,bigblocknr))
561 return -1;
562 }
563 if (!STORAGE_set_big_chain(hf,bigblocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
564 return -1;
565 newblocknr = curblock*128;
566 }
567 /* allocate enough big blocks for storing the allocated small block */
568 if (!STORAGE_get_root_pps_entry(hf,&root))
569 return -1;
570 if (root.pps_sb==-1)
571 lastbigblocknr = -1;
572 else
573 lastbigblocknr = STORAGE_get_nth_next_big_blocknr(hf,root.pps_sb,(root.pps_size-1)/BIGSIZE);
574 while (root.pps_size < (newblocknr*SMALLSIZE+SMALLSIZE-1)) {
575 /* we need to allocate more stuff */
576 bigblocknr = STORAGE_get_free_big_blocknr(hf);
577 if (bigblocknr<0)
578 return -1;
579 READ_HEADER;
580 if (root.pps_sb==-1) {
581 root.pps_sb = bigblocknr;
582 root.pps_size += BIGSIZE;
583 } else {
584 if (!STORAGE_set_big_chain(hf,lastbigblocknr,bigblocknr))
585 return -1;
586 root.pps_size += BIGSIZE;
587 }
588 lastbigblocknr = bigblocknr;
589 }
590 if (!STORAGE_set_big_chain(hf,lastbigblocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
591 return -1;
592 if (!STORAGE_put_pps_entry(hf,0,&root))
593 return -1;
594 return newblocknr;
595 }
596
597 /******************************************************************************
598 * STORAGE_get_free_pps_entry [Internal]
599 */
600 static int
601 STORAGE_get_free_pps_entry(HFILE32 hf) {
602 int blocknr,i,curblock,lastblocknr;
603 BYTE block[BIGSIZE];
604 struct storage_pps_entry *stde = (struct storage_pps_entry*)block;
605 struct storage_header sth;
606
607 READ_HEADER;
608 blocknr = sth.root_startblock;
609 assert(blocknr>=0);
610 curblock=0;
611 while (blocknr>=0) {
612 if (!STORAGE_get_big_block(hf,blocknr,block))
613 return -1;
614 for (i=0;i<4;i++)
615 if (stde[i].pps_sizeofname==0) /* free */
616 return curblock*4+i;
617 lastblocknr = blocknr;
618 blocknr = STORAGE_get_next_big_blocknr(hf,blocknr);
619 curblock++;
620 }
621 assert(blocknr==STORAGE_CHAINENTRY_ENDOFCHAIN);
622 blocknr = STORAGE_get_free_big_blocknr(hf);
623 /* sth invalidated */
624 if (blocknr<0)
625 return -1;
626
627 if (!STORAGE_set_big_chain(hf,lastblocknr,blocknr))
628 return -1;
629 if (!STORAGE_set_big_chain(hf,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
630 return -1;
631 memset(block,0,sizeof(block));
632 STORAGE_put_big_block(hf,blocknr,block);
633 return curblock*4;
634 }
635
636 /* --- IStream16 implementation */
637
638 typedef struct _IStream16 {
639 /* IUnknown fields */
640 ICOM_VTABLE(IStream16)* lpvtbl;
641 DWORD ref;
642 /* IStream16 fields */
643 SEGPTR thisptr; /* pointer to this struct as segmented */
644 struct storage_pps_entry stde;
645 int ppsent;
646 HFILE32 hf;
647 ULARGE_INTEGER offset;
648 } _IStream16;
649
650 /******************************************************************************
651 * IStream16_QueryInterface [STORAGE.518]
652 */
653 HRESULT WINAPI IStream16_fnQueryInterface(
654 LPUNKNOWN iface,REFIID refiid,LPVOID *obj
655 ) {
656 ICOM_THIS(IStream16,iface);
657 char xrefiid[50];
658 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
659 TRACE(relay,"(%p)->(%s,%p)\n",this,xrefiid,obj);
660 if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
661 *obj = this;
662 return 0;
663 }
664 return OLE_E_ENUM_NOMORE;
665
666 }
667
668 /******************************************************************************
669 * IStream16_AddRef [STORAGE.519]
670 */
671 ULONG WINAPI IStream16_fnAddRef(LPUNKNOWN iface) {
672 ICOM_THIS(IStream16,iface);
673 return ++(this->ref);
674 }
675
676 /******************************************************************************
677 * IStream16_Release [STORAGE.520]
678 */
679 ULONG WINAPI IStream16_fnRelease(LPUNKNOWN iface) {
680 ICOM_THIS(IStream16,iface);
681 FlushFileBuffers(this->hf);
682 this->ref--;
683 if (!this->ref) {
684 CloseHandle(this->hf);
685 SEGPTR_FREE(this);
686 return 0;
687 }
688 return this->ref;
689 }
690
691 /******************************************************************************
692 * IStream16_Seek [STORAGE.523]
693 *
694 * FIXME
695 * Does not handle 64 bits
696 */
697 HRESULT WINAPI IStream16_fnSeek(
698 LPSTREAM16 iface,LARGE_INTEGER offset,DWORD whence,ULARGE_INTEGER *newpos
699 ) {
700 ICOM_THIS(IStream16,iface);
701 TRACE(relay,"(%p)->([%ld.%ld],%ld,%p)\n",this,offset.HighPart,offset.LowPart,whence,newpos);
702
703 switch (whence) {
704 /* unix SEEK_xx should be the same as win95 ones */
705 case SEEK_SET:
706 /* offset must be ==0 (<0 is invalid, and >0 cannot be handled
707 * right now.
708 */
709 assert(offset.HighPart==0);
710 this->offset.HighPart = offset.HighPart;
711 this->offset.LowPart = offset.LowPart;
712 break;
713 case SEEK_CUR:
714 if (offset.HighPart < 0) {
715 /* FIXME: is this negation correct ? */
716 offset.HighPart = -offset.HighPart;
717 offset.LowPart = (0xffffffff ^ offset.LowPart)+1;
718
719 assert(offset.HighPart==0);
720 assert(this->offset.LowPart >= offset.LowPart);
721 this->offset.LowPart -= offset.LowPart;
722 } else {
723 assert(offset.HighPart==0);
724 this->offset.LowPart+= offset.LowPart;
725 }
726 break;
727 case SEEK_END:
728 assert(offset.HighPart==0);
729 this->offset.LowPart = this->stde.pps_size-offset.LowPart;
730 break;
731 }
732 if (this->offset.LowPart>this->stde.pps_size)
733 this->offset.LowPart=this->stde.pps_size;
734 if (newpos) *newpos = this->offset;
735 return OLE_OK;
736 }
737
738 /******************************************************************************
739 * IStream16_Read [STORAGE.521]
740 */
741 HRESULT WINAPI IStream16_fnRead(
742 LPSTREAM16 iface,void *pv,ULONG cb,ULONG *pcbRead
743 ) {
744 ICOM_THIS(IStream16,iface);
745 BYTE block[BIGSIZE];
746 ULONG *bytesread=pcbRead,xxread;
747 int blocknr;
748
749 TRACE(relay,"(%p)->(%p,%ld,%p)\n",this,pv,cb,pcbRead);
750 if (!pcbRead) bytesread=&xxread;
751 *bytesread = 0;
752
753 if (cb>this->stde.pps_size-this->offset.LowPart)
754 cb=this->stde.pps_size-this->offset.LowPart;
755 if (this->stde.pps_size < 0x1000) {
756 /* use small block reader */
757 blocknr = STORAGE_get_nth_next_small_blocknr(this->hf,this->stde.pps_sb,this->offset.LowPart/SMALLSIZE);
758 while (cb) {
759 int cc;
760
761 if (!STORAGE_get_small_block(this->hf,blocknr,block)) {
762 WARN(ole,"small block read failed!!!\n");
763 return E_FAIL;
764 }
765 cc = cb;
766 if (cc>SMALLSIZE-(this->offset.LowPart&(SMALLSIZE-1)))
767 cc=SMALLSIZE-(this->offset.LowPart&(SMALLSIZE-1));
768 memcpy((LPBYTE)pv,block+(this->offset.LowPart&(SMALLSIZE-1)),cc);
769 this->offset.LowPart+=cc;
770 (LPBYTE)pv+=cc;
771 *bytesread+=cc;
772 cb-=cc;
773 blocknr = STORAGE_get_next_small_blocknr(this->hf,blocknr);
774 }
775 } else {
776 /* use big block reader */
777 blocknr = STORAGE_get_nth_next_big_blocknr(this->hf,this->stde.pps_sb,this->offset.LowPart/BIGSIZE);
778 while (cb) {
779 int cc;
780
781 if (!STORAGE_get_big_block(this->hf,blocknr,block)) {
782 WARN(ole,"big block read failed!!!\n");
783 return E_FAIL;
784 }
785 cc = cb;
786 if (cc>BIGSIZE-(this->offset.LowPart&(BIGSIZE-1)))
787 cc=BIGSIZE-(this->offset.LowPart&(BIGSIZE-1));
788 memcpy((LPBYTE)pv,block+(this->offset.LowPart&(BIGSIZE-1)),cc);
789 this->offset.LowPart+=cc;
790 (LPBYTE)pv+=cc;
791 *bytesread+=cc;
792 cb-=cc;
793 blocknr=STORAGE_get_next_big_blocknr(this->hf,blocknr);
794 }
795 }
796 return OLE_OK;
797 }
798
799 /******************************************************************************
800 * IStream16_Write [STORAGE.522]
801 */
802 HRESULT WINAPI IStream16_fnWrite(
803 LPSTREAM16 iface,const void *pv,ULONG cb,ULONG *pcbWrite
804 ) {
805 ICOM_THIS(IStream16,iface);
806 BYTE block[BIGSIZE];
807 ULONG *byteswritten=pcbWrite,xxwritten;
808 int oldsize,newsize,i,curoffset=0,lastblocknr,blocknr,cc;
809 HFILE32 hf = this->hf;
810
811 if (!pcbWrite) byteswritten=&xxwritten;
812 *byteswritten = 0;
813
814 TRACE(relay,"(%p)->(%p,%ld,%p)\n",this,pv,cb,pcbWrite);
815 /* do we need to junk some blocks? */
816 newsize = this->offset.LowPart+cb;
817 oldsize = this->stde.pps_size;
818 if (newsize < oldsize) {
819 if (oldsize < 0x1000) {
820 /* only small blocks */
821 blocknr=STORAGE_get_nth_next_small_blocknr(hf,this->stde.pps_sb,newsize/SMALLSIZE);
822
823 assert(blocknr>=0);
824
825 /* will set the rest of the chain to 'free' */
826 if (!STORAGE_set_small_chain(hf,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
827 return E_FAIL;
828 } else {
829 if (newsize >= 0x1000) {
830 blocknr=STORAGE_get_nth_next_big_blocknr(hf,this->stde.pps_sb,newsize/BIGSIZE);
831 assert(blocknr>=0);
832
833 /* will set the rest of the chain to 'free' */
834 if (!STORAGE_set_big_chain(hf,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
835 return E_FAIL;
836 } else {
837 /* Migrate large blocks to small blocks
838 * (we just migrate newsize bytes)
839 */
840 LPBYTE curdata,data = HeapAlloc(GetProcessHeap(),0,newsize+BIGSIZE);
841 cc = newsize;
842 blocknr = this->stde.pps_sb;
843 curdata = data;
844 while (cc>0) {
845 if (!STORAGE_get_big_block(hf,blocknr,curdata)) {
846 HeapFree(GetProcessHeap(),0,data);
847 return E_FAIL;
848 }
849 curdata += BIGSIZE;
850 cc -= BIGSIZE;
851 blocknr = STORAGE_get_next_big_blocknr(hf,blocknr);
852 }
853 /* frees complete chain for this stream */
854 if (!STORAGE_set_big_chain(hf,this->stde.pps_sb,STORAGE_CHAINENTRY_FREE))
855 return E_FAIL;
856 curdata = data;
857 blocknr = this->stde.pps_sb = STORAGE_get_free_small_blocknr(hf);
858 if (blocknr<0)
859 return E_FAIL;
860 cc = newsize;
861 while (cc>0) {
862 if (!STORAGE_put_small_block(hf,blocknr,curdata))
863 return E_FAIL;
864 cc -= SMALLSIZE;
865 if (cc<=0) {
866 if (!STORAGE_set_small_chain(hf,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
867 return E_FAIL;
868 break;
869 } else {
870 int newblocknr = STORAGE_get_free_small_blocknr(hf);
871 if (newblocknr<0)
872 return E_FAIL;
873 if (!STORAGE_set_small_chain(hf,blocknr,newblocknr))
874 return E_FAIL;
875 blocknr = newblocknr;
876 }
877 curdata += SMALLSIZE;
878 }
879 HeapFree(GetProcessHeap(),0,data);
880 }
881 }
882 this->stde.pps_size = newsize;
883 }
884
885 if (newsize > oldsize) {
886 if (oldsize >= 0x1000) {
887 /* should return the block right before the 'endofchain' */
888 blocknr = STORAGE_get_nth_next_big_blocknr(hf,this->stde.pps_sb,this->stde.pps_size/BIGSIZE);
889 assert(blocknr>=0);
890 lastblocknr = blocknr;
891 for (i=oldsize/BIGSIZE;i<newsize/BIGSIZE;i++) {
892 blocknr = STORAGE_get_free_big_blocknr(hf);
893 if (blocknr<0)
894 return E_FAIL;
895 if (!STORAGE_set_big_chain(hf,lastblocknr,blocknr))
896 return E_FAIL;
897 lastblocknr = blocknr;
898 }
899 if (!STORAGE_set_big_chain(hf,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
900 return E_FAIL;
901 } else {
902 if (newsize < 0x1000) {
903 /* find startblock */
904 if (!oldsize)
905 this->stde.pps_sb = blocknr = STORAGE_get_free_small_blocknr(hf);
906 else
907 blocknr = STORAGE_get_nth_next_small_blocknr(hf,this->stde.pps_sb,this->stde.pps_size/SMALLSIZE);
908 if (blocknr<0)
909 return E_FAIL;
910
911 /* allocate required new small blocks */
912 lastblocknr = blocknr;
913 for (i=oldsize/SMALLSIZE;i<newsize/SMALLSIZE;i++) {
914 blocknr = STORAGE_get_free_small_blocknr(hf);
915 if (blocknr<0)
916 return E_FAIL;
917 if (!STORAGE_set_small_chain(hf,lastblocknr,blocknr))
918 return E_FAIL;
919 lastblocknr = blocknr;
920 }
921 /* and terminate the chain */
922 if (!STORAGE_set_small_chain(hf,lastblocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
923 return E_FAIL;
924 } else {
925 if (!oldsize) {
926 /* no single block allocated yet */
927 blocknr=STORAGE_get_free_big_blocknr(hf);
928 if (blocknr<0)
929 return E_FAIL;
930 this->stde.pps_sb = blocknr;
931 } else {
932 /* Migrate small blocks to big blocks */
933 LPBYTE curdata,data = HeapAlloc(GetProcessHeap(),0,oldsize+BIGSIZE);
934 cc = oldsize;
935 blocknr = this->stde.pps_sb;
936 curdata = data;
937 /* slurp in */
938 while (cc>0) {
939 if (!STORAGE_get_small_block(hf,blocknr,curdata)) {
940 HeapFree(GetProcessHeap(),0,data);
941 return E_FAIL;
942 }
943 curdata += SMALLSIZE;
944 cc -= SMALLSIZE;
945 blocknr = STORAGE_get_next_small_blocknr(hf,blocknr);
946 }
947 /* free small block chain */
948 if (!STORAGE_set_small_chain(hf,this->stde.pps_sb,STORAGE_CHAINENTRY_FREE))
949 return E_FAIL;
950 curdata = data;
951 blocknr = this->stde.pps_sb = STORAGE_get_free_big_blocknr(hf);
952 if (blocknr<0)
953 return E_FAIL;
954 /* put the data into the big blocks */
955 cc = this->stde.pps_size;
956 while (cc>0) {
957 if (!STORAGE_put_big_block(hf,blocknr,curdata))
958 return E_FAIL;
959 cc -= BIGSIZE;
960 if (cc<=0) {
961 if (!STORAGE_set_big_chain(hf,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
962 return E_FAIL;
963 break;
964 } else {
965 int newblocknr = STORAGE_get_free_big_blocknr(hf);
966 if (newblocknr<0)
967 return E_FAIL;
968 if (!STORAGE_set_big_chain(hf,blocknr,newblocknr))
969 return E_FAIL;
970 blocknr = newblocknr;
971 }
972 curdata += BIGSIZE;
973 }
974 HeapFree(GetProcessHeap(),0,data);
975 }
976 /* generate big blocks to fit the new data */
977 lastblocknr = blocknr;
978 for (i=oldsize/BIGSIZE;i<newsize/BIGSIZE;i++) {
979 blocknr = STORAGE_get_free_big_blocknr(hf);
980 if (blocknr<0)
981 return E_FAIL;
982 if (!STORAGE_set_big_chain(hf,lastblocknr,blocknr))
983 return E_FAIL;
984 lastblocknr = blocknr;
985 }
986 /* terminate chain */
987 if (!STORAGE_set_big_chain(hf,lastblocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
988 return E_FAIL;
989 }
990 }
991 this->stde.pps_size = newsize;
992 }
993
994 /* There are just some cases where we didn't modify it, we write it out
995 * everytime
996 */
997 if (!STORAGE_put_pps_entry(hf,this->ppsent,&(this->stde)))
998 return E_FAIL;
999
1000 /* finally the write pass */
1001 if (this->stde.pps_size < 0x1000) {
1002 blocknr = STORAGE_get_nth_next_small_blocknr(hf,this->stde.pps_sb,this->offset.LowPart/SMALLSIZE);
1003 assert(blocknr>=0);
1004 while (cb>0) {
1005 /* we ensured that it is allocated above */
1006 assert(blocknr>=0);
1007 /* Read old block everytime, since we can have
1008 * overlapping data at START and END of the write
1009 */
1010 if (!STORAGE_get_small_block(hf,blocknr,block))
1011 return E_FAIL;
1012
1013 cc = SMALLSIZE-(this->offset.LowPart&(SMALLSIZE-1));
1014 if (cc>cb)
1015 cc=cb;
1016 memcpy( ((LPBYTE)block)+(this->offset.LowPart&(SMALLSIZE-1)),
1017 (LPBYTE)(pv+curoffset),
1018 cc
1019 );
1020 if (!STORAGE_put_small_block(hf,blocknr,block))
1021 return E_FAIL;
1022 cb -= cc;
1023 curoffset += cc;
1024 (LPBYTE)pv += cc;
1025 this->offset.LowPart += cc;
1026 *byteswritten += cc;
1027 blocknr = STORAGE_get_next_small_blocknr(hf,blocknr);
1028 }
1029 } else {
1030 blocknr = STORAGE_get_nth_next_big_blocknr(hf,this->stde.pps_sb,this->offset.LowPart/BIGSIZE);
1031 assert(blocknr>=0);
1032 while (cb>0) {
1033 /* we ensured that it is allocated above, so it better is */
1034 assert(blocknr>=0);
1035 /* read old block everytime, since we can have
1036 * overlapping data at START and END of the write
1037 */
1038 if (!STORAGE_get_big_block(hf,blocknr,block))
1039 return E_FAIL;
1040
1041 cc = BIGSIZE-(this->offset.LowPart&(BIGSIZE-1));
1042 if (cc>cb)
1043 cc=cb;
1044 memcpy( ((LPBYTE)block)+(this->offset.LowPart&(BIGSIZE-1)),
1045 (LPBYTE)(pv+curoffset),
1046 cc
1047 );
1048 if (!STORAGE_put_big_block(hf,blocknr,block))
1049 return E_FAIL;
1050 cb -= cc;
1051 curoffset += cc;
1052 (LPBYTE)pv += cc;
1053 this->offset.LowPart += cc;
1054 *byteswritten += cc;
1055 blocknr = STORAGE_get_next_big_blocknr(hf,blocknr);
1056 }
1057 }
1058 return OLE_OK;
1059 }
1060
1061 /******************************************************************************
1062 * _create_istream16 [Internal]
1063 */
1064 static void _create_istream16(LPSTREAM16 *str) {
1065 _IStream16* lpst;
1066
1067 if (!strvt16.bvt.fnQueryInterface) {
1068 HMODULE16 wp = GetModuleHandle16("STORAGE");
1069 if (wp>=32) {
1070 /* FIXME: what is this WIN32_GetProcAddress16. Should the name be IStream16_QueryInterface of IStream16_fnQueryInterface */
1071 #define VTENT(xfn) strvt16.bvt.fn##xfn = (void*)WIN32_GetProcAddress16(wp,"IStream16_"#xfn);
1072 VTENT(QueryInterface)
1073 VTENT(AddRef)
1074 VTENT(Release)
1075 #undef VTENT
1076 #define VTENT(xfn) strvt16.fn##xfn = (void*)WIN32_GetProcAddress16(wp,"IStream16_"#xfn);
1077 VTENT(Read)
1078 VTENT(Write)
1079 VTENT(Seek)
1080 VTENT(SetSize)
1081 VTENT(CopyTo)
1082 VTENT(Commit)
1083 VTENT(Revert)
1084 VTENT(LockRegion)
1085 VTENT(UnlockRegion)
1086 VTENT(Stat)
1087 VTENT(Clone)
1088 #undef VTENT
1089 segstrvt16 = SEGPTR_NEW(ICOM_VTABLE(IStream16));
1090 memcpy(segstrvt16,&strvt16,sizeof(strvt16));
1091 segstrvt16 = (ICOM_VTABLE(IStream16)*)SEGPTR_GET(segstrvt16);
1092 } else {
1093 #define VTENT(xfn) strvt16.bvt.fn##xfn = IStream16_fn##xfn;
1094 VTENT(QueryInterface)
1095 VTENT(AddRef)
1096 VTENT(Release)
1097 #undef VTENT
1098 #define VTENT(xfn) strvt16.fn##xfn = IStream16_fn##xfn;
1099 VTENT(Read)
1100 VTENT(Write)
1101 VTENT(Seek)
1102 /*
1103 VTENT(CopyTo)
1104 VTENT(Commit)
1105 VTENT(SetSize)
1106 VTENT(Revert)
1107 VTENT(LockRegion)
1108 VTENT(UnlockRegion)
1109 VTENT(Stat)
1110 VTENT(Clone)
1111 */
1112 #undef VTENT
1113 segstrvt16 = &strvt16;
1114 }
1115 }
1116 lpst = SEGPTR_NEW(_IStream16);
1117 lpst->lpvtbl = segstrvt16;
1118 lpst->ref = 1;
1119 lpst->thisptr = SEGPTR_GET(lpst);
1120 *str = (void*)lpst->thisptr;
1121 }
1122
1123
1124 /* --- IStream32 implementation */
1125
1126 typedef struct _IStream32 {
1127 /* IUnknown fields */
1128 ICOM_VTABLE(IStream32)* lpvtbl;
1129 DWORD ref;
1130 /* IStream32 fields */
1131 struct storage_pps_entry stde;
1132 int ppsent;
1133 HFILE32 hf;
1134 ULARGE_INTEGER offset;
1135 } _IStream32;
1136
1137 /*****************************************************************************
1138 * IStream32_QueryInterface [VTABLE]
1139 */
1140 HRESULT WINAPI IStream32_fnQueryInterface(
1141 LPUNKNOWN iface,REFIID refiid,LPVOID *obj
1142 ) {
1143 ICOM_THIS(IStream32,iface);
1144 char xrefiid[50];
1145
1146 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1147 TRACE(relay,"(%p)->(%s,%p)\n",this,xrefiid,obj);
1148 if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
1149 *obj = this;
1150 return 0;
1151 }
1152 return OLE_E_ENUM_NOMORE;
1153
1154 }
1155
1156 /******************************************************************************
1157 * IStream32_AddRef [VTABLE]
1158 */
1159 ULONG WINAPI IStream32_fnAddRef(LPUNKNOWN iface) {
1160 ICOM_THIS(IStream32,iface);
1161 return ++(this->ref);
1162 }
1163
1164 /******************************************************************************
1165 * IStream32_Release [VTABLE]
1166 */
1167 ULONG WINAPI IStream32_fnRelease(LPUNKNOWN iface) {
1168 ICOM_THIS(IStream32,iface);
1169 FlushFileBuffers(this->hf);
1170 this->ref--;
1171 if (!this->ref) {
1172 CloseHandle(this->hf);
1173 SEGPTR_FREE(this);
1174 return 0;
1175 }
1176 return this->ref;
1177 }
1178
1179 static ICOM_VTABLE(IStream32) strvt32 = {
1180 {
1181 IStream32_fnQueryInterface,
1182 IStream32_fnAddRef,
1183 IStream32_fnRelease
1184 },
1185 (void*)0xdead0004,
1186 (void*)0xdead0005,
1187 (void*)0xdead0006,
1188 (void*)0xdead0007,
1189 (void*)0xdead0008,
1190 (void*)0xdead0009,
1191 (void*)0xdead0010,
1192 (void*)0xdead0011
1193 };
1194
1195
1196 /* --- IStorage16 implementation */
1197
1198 typedef struct _IStorage16 {
1199 /* IUnknown fields */
1200 ICOM_VTABLE(IStorage16)* lpvtbl;
1201 DWORD ref;
1202 /* IStorage16 fields */
1203 SEGPTR thisptr; /* pointer to this struct as segmented */
1204 struct storage_pps_entry stde;
1205 int ppsent;
1206 HFILE32 hf;
1207 } _IStorage16;
1208
1209 /******************************************************************************
1210 * IStorage16_QueryInterface [STORAGE.500]
1211 */
1212 HRESULT WINAPI IStorage16_fnQueryInterface(
1213 LPUNKNOWN iface,REFIID refiid,LPVOID *obj
1214 ) {
1215 ICOM_THIS(IStorage16,iface);
1216 char xrefiid[50];
1217
1218 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1219 TRACE(relay,"(%p)->(%s,%p)\n",this,xrefiid,obj);
1220
1221 if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
1222 *obj = this;
1223 return 0;
1224 }
1225 return OLE_E_ENUM_NOMORE;
1226 }
1227
1228 /******************************************************************************
1229 * IStorage16_AddRef [STORAGE.501]
1230 */
1231 ULONG WINAPI IStorage16_fnAddRef(LPUNKNOWN iface) {
1232 ICOM_THIS(IStorage16,iface);
1233 return ++(this->ref);
1234 }
1235
1236 /******************************************************************************
1237 * IStorage16_Release [STORAGE.502]
1238 */
1239 ULONG WINAPI IStorage16_fnRelease(LPUNKNOWN iface) {
1240 ICOM_THIS(IStorage16,iface);
1241 this->ref--;
1242 if (this->ref)
1243 return this->ref;
1244 SEGPTR_FREE(this);
1245 return 0;
1246 }
1247
1248 /******************************************************************************
1249 * IStorage16_Stat [STORAGE.517]
1250 */
1251 HRESULT WINAPI IStorage16_fnStat(
1252 LPSTORAGE16 iface,STATSTG *pstatstg, DWORD grfStatFlag
1253 ) {
1254 ICOM_THIS(IStorage16,iface);
1255 TRACE(ole,"(%p)->(%p,0x%08lx)\n",
1256 this,pstatstg,grfStatFlag
1257 );
1258 pstatstg->pwcsName=(LPOLESTR16)SEGPTR_GET(SEGPTR_STRDUP_WtoA(this->stde.pps_rawname));
1259 pstatstg->type = this->stde.pps_type;
1260 pstatstg->cbSize.LowPart = this->stde.pps_size;
1261 pstatstg->mtime = this->stde.pps_ft1; /* FIXME */ /* why? */
1262 pstatstg->atime = this->stde.pps_ft2; /* FIXME */
1263 pstatstg->ctime = this->stde.pps_ft2; /* FIXME */
1264 pstatstg->grfMode = 0; /* FIXME */
1265 pstatstg->grfLocksSupported = 0; /* FIXME */
1266 pstatstg->clsid = this->stde.pps_guid;
1267 pstatstg->grfStateBits = 0; /* FIXME */
1268 pstatstg->reserved = 0;
1269 return OLE_OK;
1270 }
1271
1272 /******************************************************************************
1273 * IStorage16_Commit [STORAGE.509]
1274 */
1275 HRESULT WINAPI IStorage16_fnCommit(
1276 LPSTORAGE16 iface,DWORD commitflags
1277 ) {
1278 ICOM_THIS(IStorage16,iface);
1279 FIXME(ole,"(%p)->(0x%08lx),STUB!\n",
1280 this,commitflags
1281 );
1282 return OLE_OK;
1283 }
1284
1285 /******************************************************************************
1286 * IStorage16_CopyTo [STORAGE.507]
1287 */
1288 HRESULT WINAPI IStorage16_fnCopyTo(LPSTORAGE16 iface,DWORD ciidExclude,const IID *rgiidExclude,SNB16 SNB16Exclude,IStorage16 *pstgDest) {
1289 ICOM_THIS(IStorage16,iface);
1290 char xguid[50];
1291
1292 if (rgiidExclude)
1293 WINE_StringFromCLSID(rgiidExclude,xguid);
1294 else
1295 strcpy(xguid,"<no guid>");
1296 FIXME(ole,"IStorage16(%p)->(0x%08lx,%s,%p,%p),stub!\n",
1297 this,ciidExclude,xguid,SNB16Exclude,pstgDest
1298 );
1299 return OLE_OK;
1300 }
1301
1302
1303 /******************************************************************************
1304 * IStorage16_CreateStorage [STORAGE.505]
1305 */
1306 HRESULT WINAPI IStorage16_fnCreateStorage(
1307 LPSTORAGE16 iface,LPCOLESTR16 pwcsName,DWORD grfMode,DWORD dwStgFormat,DWORD reserved2, IStorage16 **ppstg
1308 ) {
1309 ICOM_THIS(IStorage16,iface);
1310 _IStorage16* lpstg;
1311 int ppsent,x;
1312 struct storage_pps_entry stde;
1313 struct storage_header sth;
1314 HFILE32 hf=this->hf;
1315
1316 READ_HEADER;
1317
1318 TRACE(ole,"(%p)->(%s,0x%08lx,0x%08lx,0x%08lx,%p)\n",
1319 this,pwcsName,grfMode,dwStgFormat,reserved2,ppstg
1320 );
1321 if (grfMode & STGM_TRANSACTED)
1322 FIXME(ole,"We do not support transacted Compound Storage. Using direct mode.\n");
1323 _create_istorage16(ppstg);
1324 lpstg = (_IStorage16*)PTR_SEG_TO_LIN(*ppstg);
1325 lpstg->hf = this->hf;
1326
1327 ppsent=STORAGE_get_free_pps_entry(lpstg->hf);
1328 if (ppsent<0)
1329 return E_FAIL;
1330 stde=this->stde;
1331 if (stde.pps_dir==-1) {
1332 stde.pps_dir = ppsent;
1333 x = this->ppsent;
1334 } else {
1335 FIXME(ole," use prev chain too ?\n");
1336 x=stde.pps_dir;
1337 if (1!=STORAGE_get_pps_entry(lpstg->hf,x,&stde))
1338 return E_FAIL;
1339 while (stde.pps_next!=-1) {
1340 x=stde.pps_next;
1341 if (1!=STORAGE_get_pps_entry(lpstg->hf,x,&stde))
1342 return E_FAIL;
1343 }
1344 stde.pps_next = ppsent;
1345 }
1346 assert(STORAGE_put_pps_entry(lpstg->hf,x,&stde));
1347 assert(1==STORAGE_get_pps_entry(lpstg->hf,ppsent,&(lpstg->stde)));
1348 lstrcpyAtoW(lpstg->stde.pps_rawname,pwcsName);
1349 lpstg->stde.pps_sizeofname = lstrlen32A(pwcsName)*2+2;
1350 lpstg->stde.pps_next = -1;
1351 lpstg->stde.pps_prev = -1;
1352 lpstg->stde.pps_dir = -1;
1353 lpstg->stde.pps_sb = -1;
1354 lpstg->stde.pps_size = 0;
1355 lpstg->stde.pps_type = 1;
1356 lpstg->ppsent = ppsent;
1357 /* FIXME: timestamps? */
1358 if (!STORAGE_put_pps_entry(lpstg->hf,ppsent,&(lpstg->stde)))
1359 return E_FAIL;
1360 return OLE_OK;
1361 }
1362
1363 /******************************************************************************
1364 * IStorage16_CreateStream [STORAGE.503]
1365 */
1366 HRESULT WINAPI IStorage16_fnCreateStream(
1367 LPSTORAGE16 iface,LPCOLESTR16 pwcsName,DWORD grfMode,DWORD reserved1,DWORD reserved2, IStream16 **ppstm
1368 ) {
1369 ICOM_THIS(IStorage16,iface);
1370 _IStream16* lpstr;
1371 int ppsent,x;
1372 struct storage_pps_entry stde;
1373
1374 TRACE(ole,"(%p)->(%s,0x%08lx,0x%08lx,0x%08lx,%p)\n",
1375 this,pwcsName,grfMode,reserved1,reserved2,ppstm
1376 );
1377 if (grfMode & STGM_TRANSACTED)
1378 FIXME(ole,"We do not support transacted Compound Storage. Using direct mode.\n");
1379 _create_istream16(ppstm);
1380 lpstr = (_IStream16*)PTR_SEG_TO_LIN(*ppstm);
1381 lpstr->hf = FILE_Dup(this->hf);
1382 lpstr->offset.LowPart = 0;
1383 lpstr->offset.HighPart = 0;
1384
1385 ppsent=STORAGE_get_free_pps_entry(lpstr->hf);
1386 if (ppsent<0)
1387 return E_FAIL;
1388 stde=this->stde;
1389 if (stde.pps_next==-1)
1390 x=this->ppsent;
1391 else
1392 while (stde.pps_next!=-1) {
1393 x=stde.pps_next;
1394 if (1!=STORAGE_get_pps_entry(lpstr->hf,x,&stde))
1395 return E_FAIL;
1396 }
1397 stde.pps_next = ppsent;
1398 assert(STORAGE_put_pps_entry(lpstr->hf,x,&stde));
1399 assert(1==STORAGE_get_pps_entry(lpstr->hf,ppsent,&(lpstr->stde)));
1400 lstrcpyAtoW(lpstr->stde.pps_rawname,pwcsName);
1401 lpstr->stde.pps_sizeofname = lstrlen32A(pwcsName)*2+2;
1402 lpstr->stde.pps_next = -1;
1403 lpstr->stde.pps_prev = -1;
1404 lpstr->stde.pps_dir = -1;
1405 lpstr->stde.pps_sb = -1;
1406 lpstr->stde.pps_size = 0;
1407 lpstr->stde.pps_type = 2;
1408 lpstr->ppsent = ppsent;
1409 /* FIXME: timestamps? */
1410 if (!STORAGE_put_pps_entry(lpstr->hf,ppsent,&(lpstr->stde)))
1411 return E_FAIL;
1412 return OLE_OK;
1413 }
1414
1415 /******************************************************************************
1416 * IStorage16_OpenStorage [STORAGE.506]
1417 */
1418 HRESULT WINAPI IStorage16_fnOpenStorage(
1419 LPSTORAGE16 iface,LPCOLESTR16 pwcsName, IStorage16 *pstgPrio, DWORD grfMode, SNB16 snbExclude, DWORD reserved, IStorage16 **ppstg
1420 ) {
1421 ICOM_THIS(IStorage16,iface);
1422 _IStream16* lpstg;
1423 WCHAR name[33];
1424 int newpps;
1425
1426 TRACE(relay,"(%p)->(%s,%p,0x%08lx,%p,0x%08lx,%p)\n",
1427 this,pwcsName,pstgPrio,grfMode,snbExclude,reserved,ppstg
1428 );
1429 if (grfMode & STGM_TRANSACTED)
1430 FIXME(ole,"We do not support transacted Compound Storage. Using direct mode.\n");
1431 _create_istorage16(ppstg);
1432 lpstg = (_IStream16*)PTR_SEG_TO_LIN(*ppstg);
1433 lpstg->hf = FILE_Dup(this->hf);
1434 lstrcpyAtoW(name,pwcsName);
1435 newpps = STORAGE_look_for_named_pps(lpstg->hf,this->stde.pps_dir,name);
1436 if (newpps==-1) {
1437 IStream16_fnRelease((IUnknown*)lpstg);
1438 return E_FAIL;
1439 }
1440
1441 if (1!=STORAGE_get_pps_entry(lpstg->hf,newpps,&(lpstg->stde))) {
1442 IStream16_fnRelease((IUnknown*)lpstg);
1443 return E_FAIL;
1444 }
1445 lpstg->ppsent = newpps;
1446 return OLE_OK;
1447 }
1448
1449 /******************************************************************************
1450 * IStorage16_OpenStream [STORAGE.504]
1451 */
1452 HRESULT WINAPI IStorage16_fnOpenStream(
1453 LPSTORAGE16 iface,LPCOLESTR16 pwcsName, void *reserved1, DWORD grfMode, DWORD reserved2, IStream16 **ppstm
1454 ) {
1455 ICOM_THIS(IStorage16,iface);
1456 _IStream16* lpstr;
1457 WCHAR name[33];
1458 int newpps;
1459
1460 TRACE(relay,"(%p)->(%s,%p,0x%08lx,0x%08lx,%p)\n",
1461 this,pwcsName,reserved1,grfMode,reserved2,ppstm
1462 );
1463 if (grfMode & STGM_TRANSACTED)
1464 FIXME(ole,"We do not support transacted Compound Storage. Using direct mode.\n");
1465 _create_istream16(ppstm);
1466 lpstr = (_IStream16*)PTR_SEG_TO_LIN(*ppstm);
1467 lpstr->hf = FILE_Dup(this->hf);
1468 lstrcpyAtoW(name,pwcsName);
1469 newpps = STORAGE_look_for_named_pps(lpstr->hf,this->stde.pps_dir,name);
1470 if (newpps==-1) {
1471 IStream16_fnRelease((IUnknown*)lpstr);
1472 return E_FAIL;
1473 }
1474
1475 if (1!=STORAGE_get_pps_entry(lpstr->hf,newpps,&(lpstr->stde))) {
1476 IStream16_fnRelease((IUnknown*)lpstr);
1477 return E_FAIL;
1478 }
1479 lpstr->offset.LowPart = 0;
1480 lpstr->offset.HighPart = 0;
1481 lpstr->ppsent = newpps;
1482 return OLE_OK;
1483 }
1484
1485 /******************************************************************************
1486 * _create_istorage16 [INTERNAL]
1487 */
1488 static void _create_istorage16(LPSTORAGE16 *stg) {
1489 _IStorage16* lpst;
1490
1491 if (!stvt16.bvt.fnQueryInterface) {
1492 HMODULE16 wp = GetModuleHandle16("STORAGE");
1493 if (wp>=32) {
1494 #define VTENT(xfn) stvt16.bvt.fn##xfn = (void*)WIN32_GetProcAddress16(wp,"IStorage16_"#xfn);
1495 VTENT(QueryInterface)
1496 VTENT(AddRef)
1497 VTENT(Release)
1498 #undef VTENT
1499 #define VTENT(xfn) stvt16.fn##xfn = (void*)WIN32_GetProcAddress16(wp,"IStorage16_"#xfn);
1500 VTENT(CreateStream)
1501 VTENT(OpenStream)
1502 VTENT(CreateStorage)
1503 VTENT(OpenStorage)
1504 VTENT(CopyTo)
1505 VTENT(MoveElementTo)
1506 VTENT(Commit)
1507 VTENT(Revert)
1508 VTENT(EnumElements)
1509 VTENT(DestroyElement)
1510 VTENT(RenameElement)
1511 VTENT(SetElementTimes)
1512 VTENT(SetClass)
1513 VTENT(SetStateBits)
1514 VTENT(Stat)
1515 #undef VTENT
1516 segstvt16 = SEGPTR_NEW(ICOM_VTABLE(IStorage16));
1517 memcpy(segstvt16,&stvt16,sizeof(stvt16));
1518 segstvt16 = (ICOM_VTABLE(IStorage16)*)SEGPTR_GET(segstvt16);
1519 } else {
1520 #define VTENT(xfn) stvt16.bvt.fn##xfn = IStorage16_fn##xfn;
1521 VTENT(QueryInterface)
1522 VTENT(AddRef)
1523 VTENT(Release)
1524 #undef VTENT
1525 #define VTENT(xfn) stvt16.fn##xfn = IStorage16_fn##xfn;
1526 VTENT(CreateStream)
1527 VTENT(OpenStream)
1528 VTENT(CreateStorage)
1529 VTENT(OpenStorage)
1530 VTENT(CopyTo)
1531 VTENT(Commit)
1532 /* not (yet) implemented ...
1533 VTENT(MoveElementTo)
1534 VTENT(Revert)
1535 VTENT(EnumElements)
1536 VTENT(DestroyElement)
1537 VTENT(RenameElement)
1538 VTENT(SetElementTimes)
1539 VTENT(SetClass)
1540 VTENT(SetStateBits)
1541 VTENT(Stat)
1542 */
1543 #undef VTENT
1544 segstvt16 = &stvt16;
1545 }
1546 }
1547 lpst = SEGPTR_NEW(_IStorage16);
1548 lpst->lpvtbl = segstvt16;
1549 lpst->ref = 1;
1550 lpst->thisptr = SEGPTR_GET(lpst);
1551 *stg = (void*)lpst->thisptr;
1552 }
1553
1554
1555 /* --- IStorage32 implementation */
1556
1557 typedef struct _IStorage32 {
1558 /* IUnknown fields */
1559 ICOM_VTABLE(IStorage32)* lpvtbl;
1560 DWORD ref;
1561 /* IStorage32 fields */
1562 struct storage_pps_entry stde;
1563 int ppsent;
1564 HFILE32 hf;
1565 } _IStorage32;
1566
1567 /******************************************************************************
1568 * IStorage32_QueryInterface [VTABLE]
1569 */
1570 HRESULT WINAPI IStorage32_fnQueryInterface(
1571 LPUNKNOWN iface,REFIID refiid,LPVOID *obj
1572 ) {
1573 ICOM_THIS(IStorage32,iface);
1574 char xrefiid[50];
1575
1576 WINE_StringFromCLSID((LPCLSID)refiid,xrefiid);
1577 TRACE(relay,"(%p)->(%s,%p)\n",this,xrefiid,obj);
1578
1579 if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
1580 *obj = this;
1581 return 0;
1582 }
1583 return OLE_E_ENUM_NOMORE;
1584 }
1585
1586 /******************************************************************************
1587 * IStorage32_AddRef [VTABLE]
1588 */
1589 ULONG WINAPI IStorage32_fnAddRef(LPUNKNOWN iface) {
1590 ICOM_THIS(IStorage32,iface);
1591 return ++(this->ref);
1592 }
1593
1594 /******************************************************************************
1595 * IStorage32_Release [VTABLE]
1596 */
1597 ULONG WINAPI IStorage32_fnRelease(LPUNKNOWN iface) {
1598 ICOM_THIS(IStorage32,iface);
1599 this->ref--;
1600 if (this->ref)
1601 return this->ref;
1602 HeapFree(GetProcessHeap(),0,this);
1603 return 0;
1604 }
1605
1606 /******************************************************************************
1607 * IStorage32_CreateStream [VTABLE]
1608 */
1609 HRESULT WINAPI IStorage32_fnCreateStream(
1610 LPSTORAGE32 iface,LPCOLESTR32 pwcsName,DWORD grfMode,DWORD reserved1,DWORD reserved2, IStream32 **ppstm
1611 ) {
1612 ICOM_THIS(IStorage32,iface);
1613 TRACE(ole,"(%p)->(%p,0x%08lx,0x%08lx,0x%08lx,%p)\n",
1614 this,pwcsName,grfMode,reserved1,reserved2,ppstm
1615 );
1616 *ppstm = (IStream32*)HeapAlloc(GetProcessHeap(),0,sizeof(IStream32));
1617 ((_IStream32*)(*ppstm))->lpvtbl= &strvt32;
1618 ((_IStream32*)(*ppstm))->ref = 1;
1619
1620 return OLE_OK;
1621 }
1622
1623 /******************************************************************************
1624 * IStorage32_OpenStream [VTABLE]
1625 */
1626 HRESULT WINAPI IStorage32_fnOpenStream(
1627 LPSTORAGE32 iface,LPCOLESTR32 pwcsName, void *reserved1, DWORD grfMode, DWORD reserved2, IStream32 **ppstm
1628 ) {
1629 ICOM_THIS(IStorage32,iface);
1630 TRACE(ole,"(%p)->(%p,%p,0x%08lx,0x%08lx,%p)\n",
1631 this,pwcsName,reserved1,grfMode,reserved2,ppstm
1632 );
1633 *ppstm = (IStream32*)HeapAlloc(GetProcessHeap(),0,sizeof(IStream32));
1634 ((_IStream32*)(*ppstm))->lpvtbl= &strvt32;
1635 ((_IStream32*)(*ppstm))->ref = 1;
1636 return OLE_OK;
1637 }
1638
1639 static ICOM_VTABLE(IStorage32) stvt32 = {
1640 {
1641 IStorage32_fnQueryInterface,
1642 IStorage32_fnAddRef,
1643 IStorage32_fnRelease
1644 },
1645 IStorage32_fnCreateStream,
1646 IStorage32_fnOpenStream,
1647 (void*)0xdead0006,
1648 (void*)0xdead0007,
1649 (void*)0xdead0008,
1650 (void*)0xdead0009,
1651 (void*)0xdead0010,
1652 (void*)0xdead0011,
1653 (void*)0xdead0012,
1654 (void*)0xdead0013,
1655 (void*)0xdead0014,
1656 (void*)0xdead0015,
1657 (void*)0xdead0016,
1658 (void*)0xdead0017,
1659 (void*)0xdead0018,
1660 };
1661
1662 /******************************************************************************
1663 * Storage API functions
1664 */
1665
1666 /******************************************************************************
1667 * StgCreateDocFile16 [STORAGE.1]
1668 */
1669 OLESTATUS WINAPI StgCreateDocFile16(
1670 LPCOLESTR16 pwcsName,DWORD grfMode,DWORD reserved,IStorage16 **ppstgOpen
1671 ) {
1672 HFILE32 hf;
1673 int i,ret;
1674 _IStorage16* lpstg;
1675 struct storage_pps_entry stde;
1676
1677 TRACE(ole,"(%s,0x%08lx,0x%08lx,%p)\n",
1678 pwcsName,grfMode,reserved,ppstgOpen
1679 );
1680 _create_istorage16(ppstgOpen);
1681 hf = CreateFile32A(pwcsName,GENERIC_READ|GENERIC_WRITE,0,NULL,CREATE_NEW,0,0);
1682 if (hf==INVALID_HANDLE_VALUE32) {
1683 WARN(ole,"couldn't open file for storage:%ld\n",GetLastError());
1684 return E_FAIL;
1685 }
1686 lpstg = (_IStorage16*)PTR_SEG_TO_LIN(*ppstgOpen);
1687 lpstg->hf = hf;
1688 /* FIXME: check for existance before overwriting? */
1689 if (!STORAGE_init_storage(hf)) {
1690 CloseHandle(hf);
1691 return E_FAIL;
1692 }
1693 i=0;ret=0;
1694 while (!ret) { /* neither 1 nor <0 */
1695 ret=STORAGE_get_pps_entry(hf,i,&stde);
1696 if ((ret==1) && (stde.pps_type==5)) {
1697 lpstg->stde = stde;
1698 lpstg->ppsent = i;
1699 break;
1700 }
1701 i++;
1702 }
1703 if (ret!=1) {
1704 IStorage16_fnRelease((IUnknown*)lpstg); /* will remove it */
1705 return E_FAIL;
1706 }
1707 return OLE_OK;
1708 }
1709
1710 /******************************************************************************
1711 * StgCreateDocFile32 [OLE32.144]
1712 */
1713 OLESTATUS WINAPI StgCreateDocFile32(
1714 LPCOLESTR32 pwcsName,DWORD grfMode,DWORD reserved,IStorage32 **ppstgOpen
1715 ) {
1716 TRACE(ole,"(%p,0x%08lx,0x%08lx,%p)\n",
1717 pwcsName,grfMode,reserved,ppstgOpen
1718 );
1719 *ppstgOpen = (IStorage32*)HeapAlloc(GetProcessHeap(),0,sizeof(IStorage32));
1720 ((_IStorage32*)(*ppstgOpen))->ref = 1;
1721 ((_IStorage32*)(*ppstgOpen))->lpvtbl = &stvt32;
1722 return OLE_OK;
1723 }
1724
1725 /******************************************************************************
1726 * StgIsStorageFile16 [STORAGE.5]
1727 */
1728 OLESTATUS WINAPI StgIsStorageFile16(LPCOLESTR16 fn) {
1729 HFILE32 hf;
1730 OFSTRUCT ofs;
1731 BYTE magic[24];
1732
1733 TRACE(ole,"(\'%s\')\n",fn);
1734 hf = OpenFile32(fn,&ofs,OF_SHARE_DENY_NONE);
1735 if (hf==HFILE_ERROR32)
1736 return STG_E_FILENOTFOUND;
1737 if (24!=_lread32(hf,magic,24)) {
1738 WARN(ole," too short\n");
1739 _lclose32(hf);
1740 return S_FALSE;
1741 }
1742 if (!memcmp(magic,STORAGE_magic,8)) {
1743 WARN(ole," -> YES\n");
1744 _lclose32(hf);
1745 return S_OK;
1746 }
1747 if (!memcmp(magic,STORAGE_notmagic,8)) {
1748 WARN(ole," -> NO\n");
1749 _lclose32(hf);
1750 return S_FALSE;
1751 }
1752 if (!memcmp(magic,STORAGE_oldmagic,8)) {
1753 WARN(ole," -> old format\n");
1754 _lclose32(hf);
1755 return STG_E_OLDFORMAT;
1756 }
1757 WARN(ole," -> Invalid header.\n");
1758 _lclose32(hf);
1759 return STG_E_INVALIDHEADER;
1760 }
1761
1762 /******************************************************************************
1763 * StgIsStorageFile32 [OLE32.146]
1764 */
1765 OLESTATUS WINAPI
1766 StgIsStorageFile32(LPCOLESTR32 fn)
1767 {
1768 LPOLESTR16 xfn = HEAP_strdupWtoA(GetProcessHeap(),0,fn);
1769 OLESTATUS ret = StgIsStorageFile16(xfn);
1770
1771 HeapFree(GetProcessHeap(),0,xfn);
1772 return ret;
1773 }
1774
1775
1776 /******************************************************************************
1777 * StgOpenStorage16 [STORAGE.3]
1778 */
1779 OLESTATUS WINAPI StgOpenStorage16(
1780 const OLECHAR16 * pwcsName,IStorage16 *pstgPriority,DWORD grfMode,
1781 SNB16 snbExclude,DWORD reserved, IStorage16 **ppstgOpen
1782 ) {
1783 HFILE32 hf;
1784 int ret,i;
1785 _IStorage16* lpstg;
1786 struct storage_pps_entry stde;
1787
1788 TRACE(ole,"(%s,%p,0x%08lx,%p,%ld,%p)\n",
1789 pwcsName,pstgPriority,grfMode,snbExclude,reserved,ppstgOpen
1790 );
1791 _create_istorage16(ppstgOpen);
1792 hf = CreateFile32A(pwcsName,GENERIC_READ,0,NULL,0,0,0);
1793 if (hf==INVALID_HANDLE_VALUE32) {
1794 WARN(ole,"Couldn't open file for storage\n");
1795 return E_FAIL;
1796 }
1797 lpstg = (_IStorage16*)PTR_SEG_TO_LIN(*ppstgOpen);
1798 lpstg->hf = hf;
1799
1800 i=0;ret=0;
1801 while (!ret) { /* neither 1 nor <0 */
1802 ret=STORAGE_get_pps_entry(hf,i,&stde);
1803 if ((ret==1) && (stde.pps_type==5)) {
1804 lpstg->stde=stde;
1805 break;
1806 }
1807 i++;
1808 }
1809 if (ret!=1) {
1810 IStorage16_fnRelease((IUnknown*)lpstg); /* will remove it */
1811 return E_FAIL;
1812 }
1813 return OLE_OK;
1814
1815 }
1816
1817 /******************************************************************************
1818 * StgOpenStorage32 [OLE32.148]
1819 */
1820 OLESTATUS WINAPI StgOpenStorage32(
1821 const OLECHAR32 * pwcsName,IStorage32 *pstgPriority,DWORD grfMode,
1822 SNB32 snbExclude,DWORD reserved, IStorage32 **ppstgOpen
1823 ) {
1824 FIXME(ole,"StgOpenStorage32(%p,%p,0x%08lx,%p,%ld,%p),stub!\n",
1825 pwcsName,pstgPriority,grfMode,snbExclude,reserved,
1826 ppstgOpen);
1827 *ppstgOpen = (IStorage32*)HeapAlloc(GetProcessHeap(),0,sizeof(IStorage32));
1828 ((_IStorage32*)(*ppstgOpen))->ref = 1;
1829 ((_IStorage32*)(*ppstgOpen))->lpvtbl = &stvt32;
1830 return OLE_OK;
1831 }
1832
1833
Maarten's multimedia branch