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