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