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