?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dnsapi: Sign-compare warnings fix.
[wine/gsoc_dplay.git] / dlls / ole32 / storage.c
blobd356c67622014375f1aadf62c418c903110b602c
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25
26 #include <assert.h>
27 #include <time.h>
28 #include <stdarg.h>
29 #include <string.h>
30 #include <sys/types.h>
31 #ifdef HAVE_UNISTD_H
32 # include <unistd.h>
33 #endif
34
35 #define NONAMELESSUNION
36 #define NONAMELESSSTRUCT
37 #include "windef.h"
38 #include "winbase.h"
39 #include "winternl.h"
40 #include "winerror.h"
41 #include "wine/winbase16.h"
42 #include "wownt32.h"
43 #include "wine/unicode.h"
44 #include "objbase.h"
45 #include "wine/debug.h"
46
47 #include "ifs.h"
48
49 WINE_DEFAULT_DEBUG_CHANNEL(ole);
50 WINE_DECLARE_DEBUG_CHANNEL(relay);
51
52 struct storage_header {
53 BYTE magic[8]; /* 00: magic */
54 BYTE unknown1[36]; /* 08: unknown */
55 DWORD num_of_bbd_blocks;/* 2C: length of big datablocks */
56 DWORD root_startblock;/* 30: root storage first big block */
57 DWORD unknown2[2]; /* 34: unknown */
58 DWORD sbd_startblock; /* 3C: small block depot first big block */
59 DWORD unknown3[3]; /* 40: unknown */
60 DWORD bbd_list[109]; /* 4C: big data block list (up to end of sector)*/
61 };
62 struct storage_pps_entry {
63 WCHAR pps_rawname[32];/* 00: \0 terminated widechar name */
64 WORD pps_sizeofname; /* 40: namelength in bytes */
65 BYTE pps_type; /* 42: flags, 1 storage/dir, 2 stream, 5 root */
66 BYTE pps_unknown0; /* 43: unknown */
67 DWORD pps_prev; /* 44: previous pps */
68 DWORD pps_next; /* 48: next pps */
69 DWORD pps_dir; /* 4C: directory pps */
70 GUID pps_guid; /* 50: class ID */
71 DWORD pps_unknown1; /* 60: unknown */
72 FILETIME pps_ft1; /* 64: filetime1 */
73 FILETIME pps_ft2; /* 70: filetime2 */
74 DWORD pps_sb; /* 74: data startblock */
75 DWORD pps_size; /* 78: datalength. (<0x1000)?small:big blocks*/
76 DWORD pps_unknown2; /* 7C: unknown */
77 };
78
79 #define STORAGE_CHAINENTRY_FAT 0xfffffffd
80 #define STORAGE_CHAINENTRY_ENDOFCHAIN 0xfffffffe
81 #define STORAGE_CHAINENTRY_FREE 0xffffffff
82
83
84 static const BYTE STORAGE_magic[8] ={0xd0,0xcf,0x11,0xe0,0xa1,0xb1,0x1a,0xe1};
85
86 #define BIGSIZE 512
87 #define SMALLSIZE 64
88
89 #define SMALLBLOCKS_PER_BIGBLOCK (BIGSIZE/SMALLSIZE)
90
91 #define READ_HEADER(str) STORAGE_get_big_block(str,-1,(LPBYTE)&sth);assert(!memcmp(STORAGE_magic,sth.magic,sizeof(STORAGE_magic)));
92 static IStorage16Vtbl stvt16;
93 static const IStorage16Vtbl *segstvt16 = NULL;
94 static IStream16Vtbl strvt16;
95 static const IStream16Vtbl *segstrvt16 = NULL;
96
97 /*ULONG WINAPI IStorage16_AddRef(LPSTORAGE16 this);*/
98 static void _create_istorage16(LPSTORAGE16 *stg);
99 static void _create_istream16(LPSTREAM16 *str);
100
101 #define IMPLEMENTED 1
102
103 /* The following is taken from the CorVu implementation of docfiles, and
104 * documents things about the file format that are not implemented here, and
105 * not documented by the LAOLA project. The CorVu implementation was posted
106 * to wine-devel in February 2004, and released under the LGPL at the same
107 * time. Because that implementation is in C++, it's not directly usable in
108 * Wine, but does have documentation value.
109 *
110 *
111 * #define DF_EXT_VTOC -4
112 * #define DF_VTOC_VTOC -3
113 * #define DF_VTOC_EOF -2
114 * #define DF_VTOC_FREE -1
115 * #define DF_NAMELEN 0x20 // Maximum entry name length - 31 characters plus
116 * // a NUL terminator
117 *
118 * #define DF_FT_STORAGE 1
119 * #define DF_FT_STREAM 2
120 * #define DF_FT_LOCKBYTES 3 // Not used -- How the bloody hell did I manage
121 * #define DF_FT_PROPERTY 4 // Not Used -- to figure these two out?
122 * #define DF_FT_ROOT 5
123 *
124 * #define DF_BLOCK_SIZE 0x200
125 * #define DF_VTOC_SIZE 0x80
126 * #define DF_DE_PER_BLOCK 4
127 * #define DF_STREAM_BLOCK_SIZE 0x40
128 *
129 * A DocFile is divided into blocks of 512 bytes.
130 * The first block contains the header.
131 *
132 * The file header contains The first 109 entries in the VTOC of VTOCs.
133 *
134 * Each block pointed to by a VTOC of VTOCs contains a VTOC, which
135 * includes block chains - just like FAT. This is a somewhat poor
136 * design for the following reasons:
137 *
138 * 1. FAT was a poor file system design to begin with, and
139 * has long been known to be horrendously inefficient
140 * for day to day operations.
141 *
142 * 2. The problem is compounded here, since the file
143 * level streams are generally *not* read sequentially.
144 * This means that a significant percentage of reads
145 * require seeking from the start of the chain.
146 *
147 * Data chains also contain an internal VTOC. The block size for
148 * the standard VTOC is 512. The block size for the internal VTOC
149 * is 64.
150 *
151 * Now, the 109 blocks in the VTOC of VTOCs allows for files of
152 * up to around 7MB. So what do you think happens if that's
153 * exceeded? Well, there's an entry in the header block which
154 * points to the first block used as additional storage for
155 * the VTOC of VTOCs.
156 *
157 * Now we can get up to around 15MB. Now, guess how the file
158 * format adds in another block to the VTOC of VTOCs. Come on,
159 * it's no big surprise. That's right - the last entry in each
160 * block extending the VTOC of VTOCs is, you guessed it, the
161 * block number of the next block containing an extension to
162 * the VTOC of VTOCs. The VTOC of VTOCs is chained!!!!
163 *
164 * So, to review:
165 *
166 * 1. If you are using a FAT file system, the location of
167 * your file's blocks is stored in chains.
168 *
169 * 2. At the abstract level, the file contains a VTOC of VTOCs,
170 * which is stored in the most inefficient possible format for
171 * random access - a chain (AKA list).
172 *
173 * 3. The VTOC of VTOCs contains descriptions of three file level
174 * streams:
175 *
176 * a. The Directory stream
177 * b. The Data stream
178 * c. The Data VTOC stream
179 *
180 * These are, of course, represented as chains.
181 *
182 * 4. The Data VTOC contains data describing the chains of blocks
183 * within the Data stream.
184 *
185 * That's right - we have a total of four levels of block chains!
186 *
187 * Now, is that complicated enough for you? No? OK, there's another
188 * complication. If an individual stream (ie. an IStream) reaches
189 * 4096 bytes in size, it gets moved from the Data Stream to
190 * a new file level stream. Now, if the stream then gets truncated
191 * back to less than 4096 bytes, it returns to the data stream.
192 *
193 * The effect of using this format can be seen very easily. Pick
194 * an arbitrary application with a grid data representation that
195 * can export to both Lotus 123 and Excel 5 or higher. Export
196 * a large file to Lotus 123 and time it. Export the same thing
197 * to Excel 5 and time that. The difference is the inefficiency
198 * of the Microsoft DocFile format.
199 *
200 *
201 * #define TOTAL_SIMPLE_VTOCS 109
202 *
203 * struct DocFile_Header
204 * {
205 * df_byte iMagic1; // 0xd0
206 * df_byte iMagic2; // 0xcf
207 * df_byte iMagic3; // 0x11
208 * df_byte iMagic4; // 0xe0 - Spells D0CF11E0, or DocFile
209 * df_byte iMagic5; // 161 (igi upside down)
210 * df_byte iMagic6; // 177 (lli upside down - see below
211 * df_byte iMagic7; // 26 (gz upside down)
212 * df_byte iMagic8; // 225 (szz upside down) - see below
213 * df_int4 aiUnknown1[4];
214 * df_int4 iVersion; // DocFile Version - 0x03003E
215 * df_int4 aiUnknown2[4];
216 * df_int4 nVTOCs; // Number of VTOCs
217 * df_int4 iFirstDirBlock; // First Directory Block
218 * df_int4 aiUnknown3[2];
219 * df_int4 iFirstDataVTOC; // First data VTOC block
220 * df_int4 iHasData; // 1 if there is data in the file - yes, this is important
221 * df_int4 iExtendedVTOC; // Extended VTOC location
222 * df_int4 iExtendedVTOCSize; // Size of extended VTOC (+1?)
223 * df_int4 aiVTOCofVTOCs[TOTAL_SIMPLE_VTOCS];
224 * };
225 *
226 * struct DocFile_VTOC
227 * {
228 * df_int4 aiBlocks[DF_VTOC_SIZE];
229 * };
230 *
231 *
232 * The meaning of the magic numbers
233 *
234 * 0xd0cf11e0 is DocFile with a zero on the end (sort of)
235 *
236 * If you key 177161 into a calculator, then turn the calculator
237 * upside down, you get igilli, which may be a reference to
238 * somebody's name, or to the Hebrew word for "angel".
239 *
240 * If you key 26225 into a calculator, then turn it upside down, you
241 * get szzgz. Microsoft has a tradition of creating nonsense words
242 * using the letters s, g, z and y. We think szzgz may be one of the
243 * Microsoft placeholder variables, along the lines of foo, bar and baz.
244 * Alternatively, it could be 22526, which would be gzszz.
245 *
246 *
247 * struct DocFile_DirEnt
248 * {
249 * df_char achEntryName[DF_NAMELEN]; // Entry Name
250 * df_int2 iNameLen; // Name length in bytes, including NUL terminator
251 * df_byte iFileType; // Entry type
252 * df_byte iColour; // 1 = Black, 0 = Red
253 * df_int4 iLeftSibling; // Next Left Sibling Entry - See below
254 * df_int4 iRightSibling; // Next Right Sibling Entry
255 * df_int4 iFirstChild; // First Child Entry
256 * df_byte achClassID[16]; // Class ID
257 * df_int4 iStateBits; // [GS]etStateBits value
258 * df_int4 iCreatedLow; // Low DWORD of creation time
259 * df_int4 iCreatedHigh; // High DWORD of creation time
260 * df_int4 iModifiedLow; // Low DWORD of modification time
261 * df_int4 iModifiedHigh; // High DWORD of modification time
262 * df_int4 iVTOCPosition; // VTOC Position
263 * df_int4 iFileSize; // Size of the stream
264 * df_int4 iZero; // We think this is part of the 64 bit stream size - must be 0
265 * };
266 *
267 * Siblings
268 * ========
269 *
270 * Siblings are stored in an obscure but incredibly elegant
271 * data structure called a red-black tree. This is generally
272 * defined as a 2-3-4 tree stored in a binary tree.
273 *
274 * A red-black tree can always be balanced very easily. The rules
275 * for a red-black tree are as follows:
276 *
277 * 1. The root node is always black.
278 * 2. The parent of a red node is always black.
279 *
280 * There is a Java demo of red-black trees at:
281 *
282 * http://langevin.usc.edu/BST/RedBlackTree-Example.html
283 *
284 * This demo is an excellent tool for learning how red-black
285 * trees work, without having to go through the process of
286 * learning how they were derived.
287 *
288 * Within the tree, elements are ordered by the length of the
289 * name and within that, ASCII order by name. This causes the
290 * apparently bizarre reordering you see when you use dfview.
291 *
292 * This is a somewhat bizarre choice. It suggests that the
293 * designer of the DocFile format was trying to optimise
294 * searching through the directory entries. However searching
295 * through directory entries is a relatively rare operation.
296 * Reading and seeking within a stream are much more common
297 * operations, especially within the file level streams, yet
298 * these use the horrendously inefficient FAT chains.
299 *
300 * This suggests that the designer was probably somebody
301 * fresh out of university, who had some basic knowledge of
302 * basic data structures, but little knowledge of anything
303 * more practical. It is bizarre to attempt to optimise
304 * directory searches while not using a more efficient file
305 * block locating system than FAT (seedling/sapling/tree
306 * would result in a massive improvement - in fact we have
307 * an alternative to docfiles that we use internally that
308 * uses seedling/sapling/tree and *is* far more efficient).
309 *
310 * It is worth noting that the MS implementation of red-black
311 * trees is incorrect (I can tell you're surprised) and
312 * actually causes more operations to occur than are really
313 * needed. Fortunately the fact that our implementation is
314 * correct will not cause any problems - the MS implementation
315 * still appears to cause the tree to satisfy the rules, albeit
316 * a sequence of the same insertions in the different
317 * implementations may result in a different, and possibly
318 * deeper (but never shallower) tree.
319 */
320
321 typedef struct {
322 HANDLE hf;
323 SEGPTR lockbytes;
324 } stream_access16;
325 /* --- IStorage16 implementation struct */
326
327 typedef struct
328 {
329 /* IUnknown fields */
330 const IStorage16Vtbl *lpVtbl;
331 LONG ref;
332 /* IStorage16 fields */
333 SEGPTR thisptr; /* pointer to this struct as segmented */
334 struct storage_pps_entry stde;
335 int ppsent;
336 stream_access16 str;
337 } IStorage16Impl;
338
339
340 /******************************************************************************
341 * STORAGE_get_big_block [Internal]
342 *
343 * Reading OLE compound storage
344 */
345 static BOOL
346 STORAGE_get_big_block(stream_access16 *str,int n,BYTE *block)
347 {
348 DWORD result;
349
350 assert(n>=-1);
351 if (str->hf) {
352 if ((SetFilePointer( str->hf, (n+1)*BIGSIZE, NULL,
353 SEEK_SET ) == INVALID_SET_FILE_POINTER) && GetLastError())
354 {
355 WARN("(%p,%d,%p), seek failed (%d)\n",str->hf, n, block, GetLastError());
356 return FALSE;
357 }
358 if (!ReadFile( str->hf, block, BIGSIZE, &result, NULL ) || result != BIGSIZE)
359 {
360 WARN("(hf=%p, block size %d): read didn't read (%d)\n",str->hf,n,GetLastError());
361 return FALSE;
362 }
363 } else {
364 DWORD args[6];
365 HRESULT hres;
366 HANDLE16 hsig;
367
368 args[0] = (DWORD)str->lockbytes; /* iface */
369 args[1] = (n+1)*BIGSIZE;
370 args[2] = 0; /* ULARGE_INTEGER offset */
371 args[3] = WOWGlobalAllocLock16( 0, BIGSIZE, &hsig ); /* sig */
372 args[4] = BIGSIZE;
373 args[5] = 0;
374
375 if (!WOWCallback16Ex(
376 (DWORD)((const ILockBytes16Vtbl*)MapSL(
377 (SEGPTR)((LPLOCKBYTES16)MapSL(str->lockbytes))->lpVtbl)
378 )->ReadAt,
379 WCB16_PASCAL,
380 6*sizeof(DWORD),
381 (LPVOID)args,
382 (LPDWORD)&hres
383 )) {
384 ERR("CallTo16 ILockBytes16::ReadAt() failed, hres %x\n",hres);
385 return FALSE;
386 }
387 memcpy(block, MapSL(args[3]), BIGSIZE);
388 WOWGlobalUnlockFree16(args[3]);
389 }
390 return TRUE;
391 }
392
393 static BOOL
394 _ilockbytes16_writeat(SEGPTR lockbytes, DWORD offset, DWORD length, void *buffer) {
395 DWORD args[6];
396 HRESULT hres;
397
398 args[0] = (DWORD)lockbytes; /* iface */
399 args[1] = offset;
400 args[2] = 0; /* ULARGE_INTEGER offset */
401 args[3] = (DWORD)MapLS( buffer );
402 args[4] = length;
403 args[5] = 0;
404
405 /* THIS_ ULARGE_INTEGER ulOffset, const void *pv, ULONG cb, ULONG *pcbWritten); */
406
407 if (!WOWCallback16Ex(
408 (DWORD)((const ILockBytes16Vtbl*)MapSL(
409 (SEGPTR)((LPLOCKBYTES16)MapSL(lockbytes))->lpVtbl)
410 )->WriteAt,
411 WCB16_PASCAL,
412 6*sizeof(DWORD),
413 (LPVOID)args,
414 (LPDWORD)&hres
415 )) {
416 ERR("CallTo16 ILockBytes16::WriteAt() failed, hres %x\n",hres);
417 return FALSE;
418 }
419 UnMapLS(args[3]);
420 return TRUE;
421 }
422
423 /******************************************************************************
424 * STORAGE_put_big_block [INTERNAL]
425 */
426 static BOOL
427 STORAGE_put_big_block(stream_access16 *str,int n,BYTE *block)
428 {
429 DWORD result;
430
431 assert(n>=-1);
432 if (str->hf) {
433 if ((SetFilePointer( str->hf, (n+1)*BIGSIZE, NULL,
434 SEEK_SET ) == INVALID_SET_FILE_POINTER) && GetLastError())
435 {
436 WARN("seek failed (%d)\n",GetLastError());
437 return FALSE;
438 }
439 if (!WriteFile( str->hf, block, BIGSIZE, &result, NULL ) || result != BIGSIZE)
440 {
441 WARN(" write failed (%d)\n",GetLastError());
442 return FALSE;
443 }
444 return TRUE;
445 } else {
446 _ilockbytes16_writeat(str->lockbytes, (n+1)*BIGSIZE, BIGSIZE, block);
447 return TRUE;
448 }
449 }
450
451 /******************************************************************************
452 * STORAGE_get_next_big_blocknr [INTERNAL]
453 */
454 static int
455 STORAGE_get_next_big_blocknr(stream_access16 *str,int blocknr) {
456 INT bbs[BIGSIZE/sizeof(INT)];
457 struct storage_header sth;
458
459 READ_HEADER(str);
460
461 assert(blocknr>>7<sth.num_of_bbd_blocks);
462 if (sth.bbd_list[blocknr>>7]==0xffffffff)
463 return -5;
464 if (!STORAGE_get_big_block(str,sth.bbd_list[blocknr>>7],(LPBYTE)bbs))
465 return -5;
466 assert(bbs[blocknr&0x7f]!=STORAGE_CHAINENTRY_FREE);
467 return bbs[blocknr&0x7f];
468 }
469
470 /******************************************************************************
471 * STORAGE_get_nth_next_big_blocknr [INTERNAL]
472 */
473 static int
474 STORAGE_get_nth_next_big_blocknr(stream_access16 *str,int blocknr,int nr) {
475 INT bbs[BIGSIZE/sizeof(INT)];
476 int lastblock = -1;
477 struct storage_header sth;
478
479 TRACE("(blocknr=%d, nr=%d)\n", blocknr, nr);
480 READ_HEADER(str);
481
482 assert(blocknr>=0);
483 while (nr--) {
484 assert((blocknr>>7)<sth.num_of_bbd_blocks);
485 assert(sth.bbd_list[blocknr>>7]!=0xffffffff);
486
487 /* simple caching... */
488 if (lastblock!=sth.bbd_list[blocknr>>7]) {
489 BOOL ret = STORAGE_get_big_block(str,sth.bbd_list[blocknr>>7],(LPBYTE)bbs);
490 assert(ret);
491 lastblock = sth.bbd_list[blocknr>>7];
492 }
493 blocknr = bbs[blocknr&0x7f];
494 }
495 return blocknr;
496 }
497
498 /******************************************************************************
499 * STORAGE_get_root_pps_entry [Internal]
500 */
501 static BOOL
502 STORAGE_get_root_pps_entry(stream_access16* str,struct storage_pps_entry *pstde) {
503 int blocknr,i;
504 BYTE block[BIGSIZE];
505 struct storage_pps_entry *stde=(struct storage_pps_entry*)block;
506 struct storage_header sth;
507
508 READ_HEADER(str);
509 blocknr = sth.root_startblock;
510 TRACE("startblock is %d\n", blocknr);
511 while (blocknr>=0) {
512 BOOL ret = STORAGE_get_big_block(str,blocknr,block);
513 assert(ret);
514 for (i=0;i<4;i++) {
515 if (!stde[i].pps_sizeofname)
516 continue;
517 if (stde[i].pps_type==5) {
518 *pstde=stde[i];
519 return TRUE;
520 }
521 }
522 blocknr=STORAGE_get_next_big_blocknr(str,blocknr);
523 TRACE("next block is %d\n", blocknr);
524 }
525 return FALSE;
526 }
527
528 /******************************************************************************
529 * STORAGE_get_small_block [INTERNAL]
530 */
531 static BOOL
532 STORAGE_get_small_block(stream_access16 *str,int blocknr,BYTE *sblock) {
533 BYTE block[BIGSIZE];
534 int bigblocknr;
535 struct storage_pps_entry root;
536 BOOL ret;
537
538 TRACE("(blocknr=%d)\n", blocknr);
539 assert(blocknr>=0);
540 ret = STORAGE_get_root_pps_entry(str,&root);
541 assert(ret);
542 bigblocknr = STORAGE_get_nth_next_big_blocknr(str,root.pps_sb,blocknr/SMALLBLOCKS_PER_BIGBLOCK);
543 assert(bigblocknr>=0);
544 ret = STORAGE_get_big_block(str,bigblocknr,block);
545 assert(ret);
546
547 memcpy(sblock,((LPBYTE)block)+SMALLSIZE*(blocknr&(SMALLBLOCKS_PER_BIGBLOCK-1)),SMALLSIZE);
548 return TRUE;
549 }
550
551 /******************************************************************************
552 * STORAGE_put_small_block [INTERNAL]
553 */
554 static BOOL
555 STORAGE_put_small_block(stream_access16 *str,int blocknr,const BYTE *sblock) {
556 BYTE block[BIGSIZE];
557 int bigblocknr;
558 struct storage_pps_entry root;
559 BOOL ret;
560
561 assert(blocknr>=0);
562 TRACE("(blocknr=%d)\n", blocknr);
563
564 ret = STORAGE_get_root_pps_entry(str,&root);
565 assert(ret);
566 bigblocknr = STORAGE_get_nth_next_big_blocknr(str,root.pps_sb,blocknr/SMALLBLOCKS_PER_BIGBLOCK);
567 assert(bigblocknr>=0);
568 ret = STORAGE_get_big_block(str,bigblocknr,block);
569 assert(ret);
570
571 memcpy(((LPBYTE)block)+SMALLSIZE*(blocknr&(SMALLBLOCKS_PER_BIGBLOCK-1)),sblock,SMALLSIZE);
572 ret = STORAGE_put_big_block(str,bigblocknr,block);
573 assert(ret);
574 return TRUE;
575 }
576
577 /******************************************************************************
578 * STORAGE_get_next_small_blocknr [INTERNAL]
579 */
580 static int
581 STORAGE_get_next_small_blocknr(stream_access16 *str,int blocknr) {
582 BYTE block[BIGSIZE];
583 LPINT sbd = (LPINT)block;
584 int bigblocknr;
585 struct storage_header sth;
586 BOOL ret;
587
588 TRACE("(blocknr=%d)\n", blocknr);
589 READ_HEADER(str);
590 assert(blocknr>=0);
591 bigblocknr = STORAGE_get_nth_next_big_blocknr(str,sth.sbd_startblock,blocknr/128);
592 assert(bigblocknr>=0);
593 ret = STORAGE_get_big_block(str,bigblocknr,block);
594 assert(ret);
595 assert(sbd[blocknr & 127]!=STORAGE_CHAINENTRY_FREE);
596 return sbd[blocknr & (128-1)];
597 }
598
599 /******************************************************************************
600 * STORAGE_get_nth_next_small_blocknr [INTERNAL]
601 */
602 static int
603 STORAGE_get_nth_next_small_blocknr(stream_access16*str,int blocknr,int nr) {
604 int lastblocknr=-1;
605 BYTE block[BIGSIZE];
606 LPINT sbd = (LPINT)block;
607 struct storage_header sth;
608 BOOL ret;
609
610 TRACE("(blocknr=%d, nr=%d)\n", blocknr, nr);
611 READ_HEADER(str);
612 assert(blocknr>=0);
613 while ((nr--) && (blocknr>=0)) {
614 if (lastblocknr/128!=blocknr/128) {
615 int bigblocknr;
616 bigblocknr = STORAGE_get_nth_next_big_blocknr(str,sth.sbd_startblock,blocknr/128);
617 assert(bigblocknr>=0);
618 ret = STORAGE_get_big_block(str,bigblocknr,block);
619 assert(ret);
620 lastblocknr = blocknr;
621 }
622 assert(lastblocknr>=0);
623 lastblocknr=blocknr;
624 blocknr=sbd[blocknr & (128-1)];
625 assert(blocknr!=STORAGE_CHAINENTRY_FREE);
626 }
627 return blocknr;
628 }
629
630 /******************************************************************************
631 * STORAGE_get_pps_entry [INTERNAL]
632 */
633 static int
634 STORAGE_get_pps_entry(stream_access16*str,int n,struct storage_pps_entry *pstde) {
635 int blocknr;
636 BYTE block[BIGSIZE];
637 struct storage_pps_entry *stde = (struct storage_pps_entry*)(((LPBYTE)block)+128*(n&3));
638 struct storage_header sth;
639 BOOL ret;
640
641 TRACE("(n=%d)\n", n);
642 READ_HEADER(str);
643 /* we have 4 pps entries per big block */
644 blocknr = STORAGE_get_nth_next_big_blocknr(str,sth.root_startblock,n/4);
645 assert(blocknr>=0);
646 ret = STORAGE_get_big_block(str,blocknr,block);
647 assert(ret);
648
649 *pstde=*stde;
650 return 1;
651 }
652
653 /******************************************************************************
654 * STORAGE_put_pps_entry [Internal]
655 */
656 static int
657 STORAGE_put_pps_entry(stream_access16*str,int n,const struct storage_pps_entry *pstde) {
658 int blocknr;
659 BYTE block[BIGSIZE];
660 struct storage_pps_entry *stde = (struct storage_pps_entry*)(((LPBYTE)block)+128*(n&3));
661 struct storage_header sth;
662 BOOL ret;
663
664 TRACE("(n=%d)\n", n);
665 READ_HEADER(str);
666 /* we have 4 pps entries per big block */
667 blocknr = STORAGE_get_nth_next_big_blocknr(str,sth.root_startblock,n/4);
668 assert(blocknr>=0);
669 ret = STORAGE_get_big_block(str,blocknr,block);
670 assert(ret);
671 *stde=*pstde;
672 ret = STORAGE_put_big_block(str,blocknr,block);
673 assert(ret);
674 return 1;
675 }
676
677 /******************************************************************************
678 * STORAGE_look_for_named_pps [Internal]
679 */
680 static int
681 STORAGE_look_for_named_pps(stream_access16*str,int n,LPOLESTR name) {
682 struct storage_pps_entry stde;
683 int ret;
684
685 TRACE("(n=%d,name=%s)\n", n, debugstr_w(name));
686 if (n==-1)
687 return -1;
688 if (1!=STORAGE_get_pps_entry(str,n,&stde))
689 return -1;
690
691 if (!lstrcmpW(name,stde.pps_rawname))
692 return n;
693 if (stde.pps_prev != -1) {
694 ret=STORAGE_look_for_named_pps(str,stde.pps_prev,name);
695 if (ret!=-1)
696 return ret;
697 }
698 if (stde.pps_next != -1) {
699 ret=STORAGE_look_for_named_pps(str,stde.pps_next,name);
700 if (ret!=-1)
701 return ret;
702 }
703 return -1;
704 }
705
706 /******************************************************************************
707 * STORAGE_dump_pps_entry [Internal]
708 *
709 * FIXME
710 * Function is unused
711 */
712 void
713 STORAGE_dump_pps_entry(struct storage_pps_entry *stde) {
714 char name[33];
715
716 WideCharToMultiByte( CP_ACP, 0, stde->pps_rawname, -1, name, sizeof(name), NULL, NULL);
717 if (!stde->pps_sizeofname)
718 return;
719 TRACE("name: %s\n",name);
720 TRACE("type: %d\n",stde->pps_type);
721 TRACE("prev pps: %d\n",stde->pps_prev);
722 TRACE("next pps: %d\n",stde->pps_next);
723 TRACE("dir pps: %d\n",stde->pps_dir);
724 TRACE("guid: %s\n",debugstr_guid(&(stde->pps_guid)));
725 if (stde->pps_type !=2) {
726 time_t t;
727 DWORD dw;
728 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&(stde->pps_ft1),&dw);
729 t = dw;
730 TRACE("ts1: %s\n",ctime(&t));
731 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&(stde->pps_ft2),&dw);
732 t = dw;
733 TRACE("ts2: %s\n",ctime(&t));
734 }
735 TRACE("startblock: %d\n",stde->pps_sb);
736 TRACE("size: %d\n",stde->pps_size);
737 }
738
739 /******************************************************************************
740 * STORAGE_init_storage [INTERNAL]
741 */
742 static BOOL
743 STORAGE_init_storage(stream_access16 *str) {
744 BYTE block[BIGSIZE];
745 LPDWORD bbs;
746 struct storage_header *sth;
747 struct storage_pps_entry *stde;
748 DWORD result;
749
750 if (str->hf)
751 SetFilePointer( str->hf, 0, NULL, SEEK_SET );
752 /* block -1 is the storage header */
753 sth = (struct storage_header*)block;
754 memcpy(sth->magic,STORAGE_magic,8);
755 memset(sth->unknown1,0,sizeof(sth->unknown1));
756 memset(sth->unknown2,0,sizeof(sth->unknown2));
757 memset(sth->unknown3,0,sizeof(sth->unknown3));
758 sth->num_of_bbd_blocks = 1;
759 sth->root_startblock = 1;
760 sth->sbd_startblock = 0xffffffff;
761 memset(sth->bbd_list,0xff,sizeof(sth->bbd_list));
762 sth->bbd_list[0] = 0;
763 if (str->hf) {
764 if (!WriteFile( str->hf, block, BIGSIZE, &result, NULL ) || result != BIGSIZE) return FALSE;
765 } else {
766 if (!_ilockbytes16_writeat(str->lockbytes, 0, BIGSIZE, block)) return FALSE;
767 }
768 /* block 0 is the big block directory */
769 bbs=(LPDWORD)block;
770 memset(block,0xff,sizeof(block)); /* mark all blocks as free */
771 bbs[0]=STORAGE_CHAINENTRY_ENDOFCHAIN; /* for this block */
772 bbs[1]=STORAGE_CHAINENTRY_ENDOFCHAIN; /* for directory entry */
773 if (str->hf) {
774 if (!WriteFile( str->hf, block, BIGSIZE, &result, NULL ) || result != BIGSIZE) return FALSE;
775 } else {
776 if (!_ilockbytes16_writeat(str->lockbytes, BIGSIZE, BIGSIZE, block)) return FALSE;
777 }
778 /* block 1 is the root directory entry */
779 memset(block,0x00,sizeof(block));
780 stde = (struct storage_pps_entry*)block;
781 MultiByteToWideChar( CP_ACP, 0, "RootEntry", -1, stde->pps_rawname,
782 sizeof(stde->pps_rawname)/sizeof(WCHAR));
783 stde->pps_sizeofname = (strlenW(stde->pps_rawname)+1) * sizeof(WCHAR);
784 stde->pps_type = 5;
785 stde->pps_dir = -1;
786 stde->pps_next = -1;
787 stde->pps_prev = -1;
788 stde->pps_sb = 0xffffffff;
789 stde->pps_size = 0;
790 if (str->hf) {
791 return (WriteFile( str->hf, block, BIGSIZE, &result, NULL ) && result == BIGSIZE);
792 } else {
793 return _ilockbytes16_writeat(str->lockbytes, BIGSIZE, BIGSIZE, block);
794 }
795 }
796
797 /******************************************************************************
798 * STORAGE_set_big_chain [Internal]
799 */
800 static BOOL
801 STORAGE_set_big_chain(stream_access16*str,int blocknr,INT type) {
802 BYTE block[BIGSIZE];
803 LPINT bbd = (LPINT)block;
804 int nextblocknr,bigblocknr;
805 struct storage_header sth;
806 BOOL ret;
807
808 READ_HEADER(str);
809 assert(blocknr!=type);
810 while (blocknr>=0) {
811 bigblocknr = sth.bbd_list[blocknr/128];
812 assert(bigblocknr>=0);
813 ret = STORAGE_get_big_block(str,bigblocknr,block);
814 assert(ret);
815
816 nextblocknr = bbd[blocknr&(128-1)];
817 bbd[blocknr&(128-1)] = type;
818 if (type>=0)
819 return TRUE;
820 ret = STORAGE_put_big_block(str,bigblocknr,block);
821 assert(ret);
822 type = STORAGE_CHAINENTRY_FREE;
823 blocknr = nextblocknr;
824 }
825 return TRUE;
826 }
827
828 /******************************************************************************
829 * STORAGE_set_small_chain [Internal]
830 */
831 static BOOL
832 STORAGE_set_small_chain(stream_access16*str,int blocknr,INT type) {
833 BYTE block[BIGSIZE];
834 LPINT sbd = (LPINT)block;
835 int lastblocknr,nextsmallblocknr,bigblocknr;
836 struct storage_header sth;
837 BOOL ret;
838
839 READ_HEADER(str);
840
841 assert(blocknr!=type);
842 lastblocknr=-129;bigblocknr=-2;
843 while (blocknr>=0) {
844 /* cache block ... */
845 if (lastblocknr/128!=blocknr/128) {
846 bigblocknr = STORAGE_get_nth_next_big_blocknr(str,sth.sbd_startblock,blocknr/128);
847 assert(bigblocknr>=0);
848 ret = STORAGE_get_big_block(str,bigblocknr,block);
849 assert(ret);
850 }
851 lastblocknr = blocknr;
852 nextsmallblocknr = sbd[blocknr&(128-1)];
853 sbd[blocknr&(128-1)] = type;
854 ret = STORAGE_put_big_block(str,bigblocknr,block);
855 assert(ret);
856 if (type>=0)
857 return TRUE;
858 type = STORAGE_CHAINENTRY_FREE;
859 blocknr = nextsmallblocknr;
860 }
861 return TRUE;
862 }
863
864 /******************************************************************************
865 * STORAGE_get_free_big_blocknr [Internal]
866 */
867 static int
868 STORAGE_get_free_big_blocknr(stream_access16 *str) {
869 BYTE block[BIGSIZE];
870 LPINT sbd = (LPINT)block;
871 int lastbigblocknr,i,bigblocknr;
872 unsigned int curblock;
873 struct storage_header sth;
874 BOOL ret;
875
876 READ_HEADER(str);
877 curblock = 0;
878 lastbigblocknr = -1;
879 bigblocknr = sth.bbd_list[curblock];
880 while (curblock<sth.num_of_bbd_blocks) {
881 assert(bigblocknr>=0);
882 ret = STORAGE_get_big_block(str,bigblocknr,block);
883 assert(ret);
884 for (i=0;i<128;i++)
885 if (sbd[i]==STORAGE_CHAINENTRY_FREE) {
886 sbd[i] = STORAGE_CHAINENTRY_ENDOFCHAIN;
887 ret = STORAGE_put_big_block(str,bigblocknr,block);
888 assert(ret);
889 memset(block,0x42,sizeof(block));
890 ret = STORAGE_put_big_block(str,i+curblock*128,block);
891 assert(ret);
892 return i+curblock*128;
893 }
894 lastbigblocknr = bigblocknr;
895 bigblocknr = sth.bbd_list[++curblock];
896 }
897 bigblocknr = curblock*128;
898 /* since we have marked all blocks from 0 up to curblock*128-1
899 * the next free one is curblock*128, where we happily put our
900 * next large block depot.
901 */
902 memset(block,0xff,sizeof(block));
903 /* mark the block allocated and returned by this function */
904 sbd[1] = STORAGE_CHAINENTRY_ENDOFCHAIN;
905 ret = STORAGE_put_big_block(str,bigblocknr,block);
906 assert(ret);
907
908 /* if we had a bbd block already (mostlikely) we need
909 * to link the new one into the chain
910 */
911 if (lastbigblocknr!=-1) {
912 ret = STORAGE_set_big_chain(str,lastbigblocknr,bigblocknr);
913 assert(ret);
914 }
915 sth.bbd_list[curblock]=bigblocknr;
916 sth.num_of_bbd_blocks++;
917 assert(sth.num_of_bbd_blocks==curblock+1);
918 ret = STORAGE_put_big_block(str,-1,(LPBYTE)&sth);
919 assert(ret);
920
921 /* Set the end of the chain for the bigblockdepots */
922 ret = STORAGE_set_big_chain(str,bigblocknr,STORAGE_CHAINENTRY_ENDOFCHAIN);
923 assert(ret);
924 /* add 1, for the first entry is used for the additional big block
925 * depot. (means we already used bigblocknr) */
926 memset(block,0x42,sizeof(block));
927 /* allocate this block (filled with 0x42) */
928 ret = STORAGE_put_big_block(str,bigblocknr+1,block);
929 assert(ret);
930 return bigblocknr+1;
931 }
932
933
934 /******************************************************************************
935 * STORAGE_get_free_small_blocknr [Internal]
936 */
937 static int
938 STORAGE_get_free_small_blocknr(stream_access16 *str) {
939 BYTE block[BIGSIZE];
940 LPINT sbd = (LPINT)block;
941 int lastbigblocknr,newblocknr,i,curblock,bigblocknr;
942 struct storage_pps_entry root;
943 struct storage_header sth;
944
945 READ_HEADER(str);
946 bigblocknr = sth.sbd_startblock;
947 curblock = 0;
948 lastbigblocknr = -1;
949 newblocknr = -1;
950 while (bigblocknr>=0) {
951 if (!STORAGE_get_big_block(str,bigblocknr,block))
952 return -1;
953 for (i=0;i<128;i++)
954 if (sbd[i]==STORAGE_CHAINENTRY_FREE) {
955 sbd[i]=STORAGE_CHAINENTRY_ENDOFCHAIN;
956 newblocknr = i+curblock*128;
957 break;
958 }
959 if (i!=128)
960 break;
961 lastbigblocknr = bigblocknr;
962 bigblocknr = STORAGE_get_next_big_blocknr(str,bigblocknr);
963 curblock++;
964 }
965 if (newblocknr==-1) {
966 bigblocknr = STORAGE_get_free_big_blocknr(str);
967 if (bigblocknr<0)
968 return -1;
969 READ_HEADER(str);
970 memset(block,0xff,sizeof(block));
971 sbd[0]=STORAGE_CHAINENTRY_ENDOFCHAIN;
972 if (!STORAGE_put_big_block(str,bigblocknr,block))
973 return -1;
974 if (lastbigblocknr==-1) {
975 sth.sbd_startblock = bigblocknr;
976 if (!STORAGE_put_big_block(str,-1,(LPBYTE)&sth)) /* need to write it */
977 return -1;
978 } else {
979 if (!STORAGE_set_big_chain(str,lastbigblocknr,bigblocknr))
980 return -1;
981 }
982 if (!STORAGE_set_big_chain(str,bigblocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
983 return -1;
984 newblocknr = curblock*128;
985 }
986 /* allocate enough big blocks for storing the allocated small block */
987 if (!STORAGE_get_root_pps_entry(str,&root))
988 return -1;
989 if (root.pps_sb==-1)
990 lastbigblocknr = -1;
991 else
992 lastbigblocknr = STORAGE_get_nth_next_big_blocknr(str,root.pps_sb,(root.pps_size-1)/BIGSIZE);
993 while (root.pps_size < (newblocknr*SMALLSIZE+SMALLSIZE-1)) {
994 /* we need to allocate more stuff */
995 bigblocknr = STORAGE_get_free_big_blocknr(str);
996 if (bigblocknr<0)
997 return -1;
998 READ_HEADER(str);
999 if (root.pps_sb==-1) {
1000 root.pps_sb = bigblocknr;
1001 root.pps_size += BIGSIZE;
1002 } else {
1003 if (!STORAGE_set_big_chain(str,lastbigblocknr,bigblocknr))
1004 return -1;
1005 root.pps_size += BIGSIZE;
1006 }
1007 lastbigblocknr = bigblocknr;
1008 }
1009 if (!STORAGE_set_big_chain(str,lastbigblocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
1010 return -1;
1011 if (!STORAGE_put_pps_entry(str,0,&root))
1012 return -1;
1013 return newblocknr;
1014 }
1015
1016 /******************************************************************************
1017 * STORAGE_get_free_pps_entry [Internal]
1018 */
1019 static int
1020 STORAGE_get_free_pps_entry(stream_access16*str) {
1021 int blocknr, i, curblock, lastblocknr=-1;
1022 BYTE block[BIGSIZE];
1023 struct storage_pps_entry *stde = (struct storage_pps_entry*)block;
1024 struct storage_header sth;
1025
1026 READ_HEADER(str);
1027 blocknr = sth.root_startblock;
1028 assert(blocknr>=0);
1029 curblock=0;
1030 while (blocknr>=0) {
1031 if (!STORAGE_get_big_block(str,blocknr,block))
1032 return -1;
1033 for (i=0;i<4;i++)
1034 if (stde[i].pps_sizeofname==0) /* free */
1035 return curblock*4+i;
1036 lastblocknr = blocknr;
1037 blocknr = STORAGE_get_next_big_blocknr(str,blocknr);
1038 curblock++;
1039 }
1040 assert(blocknr==STORAGE_CHAINENTRY_ENDOFCHAIN);
1041 blocknr = STORAGE_get_free_big_blocknr(str);
1042 /* sth invalidated */
1043 if (blocknr<0)
1044 return -1;
1045
1046 if (!STORAGE_set_big_chain(str,lastblocknr,blocknr))
1047 return -1;
1048 if (!STORAGE_set_big_chain(str,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
1049 return -1;
1050 memset(block,0,sizeof(block));
1051 STORAGE_put_big_block(str,blocknr,block);
1052 return curblock*4;
1053 }
1054
1055 /* --- IStream16 implementation */
1056
1057 typedef struct
1058 {
1059 /* IUnknown fields */
1060 const IStream16Vtbl *lpVtbl;
1061 LONG ref;
1062 /* IStream16 fields */
1063 SEGPTR thisptr; /* pointer to this struct as segmented */
1064 struct storage_pps_entry stde;
1065 int ppsent;
1066 ULARGE_INTEGER offset;
1067 stream_access16 str;
1068 } IStream16Impl;
1069
1070 /******************************************************************************
1071 * IStream16_QueryInterface [STORAGE.518]
1072 */
1073 HRESULT CDECL IStream16_fnQueryInterface(
1074 IStream16* iface,REFIID refiid,LPVOID *obj
1075 ) {
1076 IStream16Impl *This = (IStream16Impl *)iface;
1077 TRACE_(relay)("(%p)->(%s,%p)\n",This,debugstr_guid(refiid),obj);
1078 if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
1079 *obj = This;
1080 return 0;
1081 }
1082 return OLE_E_ENUM_NOMORE;
1083
1084 }
1085
1086 /******************************************************************************
1087 * IStream16_AddRef [STORAGE.519]
1088 */
1089 ULONG CDECL IStream16_fnAddRef(IStream16* iface) {
1090 IStream16Impl *This = (IStream16Impl *)iface;
1091 return InterlockedIncrement(&This->ref);
1092 }
1093
1094 static void
1095 _ilockbytes16_addref(SEGPTR lockbytes) {
1096 DWORD args[1];
1097 HRESULT hres;
1098
1099 args[0] = (DWORD)lockbytes; /* iface */
1100 if (!WOWCallback16Ex(
1101 (DWORD)((const ILockBytes16Vtbl*)MapSL(
1102 (SEGPTR)((LPLOCKBYTES16)MapSL(lockbytes))->lpVtbl)
1103 )->AddRef,
1104 WCB16_PASCAL,
1105 1*sizeof(DWORD),
1106 (LPVOID)args,
1107 (LPDWORD)&hres
1108 ))
1109 ERR("CallTo16 ILockBytes16::AddRef() failed, hres %x\n",hres);
1110 }
1111
1112 static void
1113 _ilockbytes16_release(SEGPTR lockbytes) {
1114 DWORD args[1];
1115 HRESULT hres;
1116
1117 args[0] = (DWORD)lockbytes; /* iface */
1118 if (!WOWCallback16Ex(
1119 (DWORD)((const ILockBytes16Vtbl*)MapSL(
1120 (SEGPTR)((LPLOCKBYTES16)MapSL(lockbytes))->lpVtbl)
1121 )->Release,
1122 WCB16_PASCAL,
1123 1*sizeof(DWORD),
1124 (LPVOID)args,
1125 (LPDWORD)&hres
1126 ))
1127 ERR("CallTo16 ILockBytes16::Release() failed, hres %x\n",hres);
1128 }
1129
1130 static void
1131 _ilockbytes16_flush(SEGPTR lockbytes) {
1132 DWORD args[1];
1133 HRESULT hres;
1134
1135 args[0] = (DWORD)lockbytes; /* iface */
1136 if (!WOWCallback16Ex(
1137 (DWORD)((const ILockBytes16Vtbl*)MapSL(
1138 (SEGPTR)((LPLOCKBYTES16)MapSL(lockbytes))->lpVtbl)
1139 )->Flush,
1140 WCB16_PASCAL,
1141 1*sizeof(DWORD),
1142 (LPVOID)args,
1143 (LPDWORD)&hres
1144 ))
1145 ERR("CallTo16 ILockBytes16::Flush() failed, hres %x\n",hres);
1146 }
1147
1148 /******************************************************************************
1149 * IStream16_Release [STORAGE.520]
1150 */
1151 ULONG CDECL IStream16_fnRelease(IStream16* iface) {
1152 IStream16Impl *This = (IStream16Impl *)iface;
1153 ULONG ref;
1154
1155 if (This->str.hf)
1156 FlushFileBuffers(This->str.hf);
1157 else
1158 _ilockbytes16_flush(This->str.lockbytes);
1159 ref = InterlockedDecrement(&This->ref);
1160 if (ref)
1161 return ref;
1162
1163 if (This->str.hf)
1164 CloseHandle(This->str.hf);
1165 else
1166 _ilockbytes16_release(This->str.lockbytes);
1167 UnMapLS( This->thisptr );
1168 HeapFree( GetProcessHeap(), 0, This );
1169 return 0;
1170 }
1171
1172 /******************************************************************************
1173 * IStream16_Seek [STORAGE.523]
1174 *
1175 * FIXME
1176 * Does not handle 64 bits
1177 */
1178 HRESULT CDECL IStream16_fnSeek(
1179 IStream16* iface,LARGE_INTEGER offset,DWORD whence,ULARGE_INTEGER *newpos
1180 ) {
1181 IStream16Impl *This = (IStream16Impl *)iface;
1182 TRACE_(relay)("(%p)->([%d.%d],%d,%p)\n",This,offset.u.HighPart,offset.u.LowPart,whence,newpos);
1183
1184 switch (whence) {
1185 /* unix SEEK_xx should be the same as win95 ones */
1186 case SEEK_SET:
1187 /* offset must be ==0 (<0 is invalid, and >0 cannot be handled
1188 * right now.
1189 */
1190 assert(offset.u.HighPart==0);
1191 This->offset.u.HighPart = offset.u.HighPart;
1192 This->offset.u.LowPart = offset.u.LowPart;
1193 break;
1194 case SEEK_CUR:
1195 if (offset.u.HighPart < 0) {
1196 /* FIXME: is this negation correct ? */
1197 offset.u.HighPart = -offset.u.HighPart;
1198 offset.u.LowPart = (0xffffffff ^ offset.u.LowPart)+1;
1199
1200 assert(offset.u.HighPart==0);
1201 assert(This->offset.u.LowPart >= offset.u.LowPart);
1202 This->offset.u.LowPart -= offset.u.LowPart;
1203 } else {
1204 assert(offset.u.HighPart==0);
1205 This->offset.u.LowPart+= offset.u.LowPart;
1206 }
1207 break;
1208 case SEEK_END:
1209 assert(offset.u.HighPart==0);
1210 This->offset.u.LowPart = This->stde.pps_size-offset.u.LowPart;
1211 break;
1212 }
1213 if (This->offset.u.LowPart>This->stde.pps_size)
1214 This->offset.u.LowPart=This->stde.pps_size;
1215 if (newpos) *newpos = This->offset;
1216 return S_OK;
1217 }
1218
1219 /******************************************************************************
1220 * IStream16_Read [STORAGE.521]
1221 */
1222 HRESULT CDECL IStream16_fnRead(
1223 IStream16* iface,void *pv,ULONG cb,ULONG *pcbRead
1224 ) {
1225 IStream16Impl *This = (IStream16Impl *)iface;
1226 BYTE block[BIGSIZE];
1227 ULONG *bytesread=pcbRead,xxread;
1228 int blocknr;
1229 LPBYTE pbv = pv;
1230
1231 TRACE_(relay)("(%p)->(%p,%d,%p)\n",This,pv,cb,pcbRead);
1232 if (!pcbRead) bytesread=&xxread;
1233 *bytesread = 0;
1234
1235 if (cb>This->stde.pps_size-This->offset.u.LowPart)
1236 cb=This->stde.pps_size-This->offset.u.LowPart;
1237 if (This->stde.pps_size < 0x1000) {
1238 /* use small block reader */
1239 blocknr = STORAGE_get_nth_next_small_blocknr(&This->str,This->stde.pps_sb,This->offset.u.LowPart/SMALLSIZE);
1240 while (cb) {
1241 unsigned int cc;
1242
1243 if (!STORAGE_get_small_block(&This->str,blocknr,block)) {
1244 WARN("small block read failed!!!\n");
1245 return E_FAIL;
1246 }
1247 cc = cb;
1248 if (cc>SMALLSIZE-(This->offset.u.LowPart&(SMALLSIZE-1)))
1249 cc=SMALLSIZE-(This->offset.u.LowPart&(SMALLSIZE-1));
1250 memcpy(pbv,block+(This->offset.u.LowPart&(SMALLSIZE-1)),cc);
1251 This->offset.u.LowPart+=cc;
1252 pbv+=cc;
1253 *bytesread+=cc;
1254 cb-=cc;
1255 blocknr = STORAGE_get_next_small_blocknr(&This->str,blocknr);
1256 }
1257 } else {
1258 /* use big block reader */
1259 blocknr = STORAGE_get_nth_next_big_blocknr(&This->str,This->stde.pps_sb,This->offset.u.LowPart/BIGSIZE);
1260 while (cb) {
1261 unsigned int cc;
1262
1263 if (!STORAGE_get_big_block(&This->str,blocknr,block)) {
1264 WARN("big block read failed!!!\n");
1265 return E_FAIL;
1266 }
1267 cc = cb;
1268 if (cc>BIGSIZE-(This->offset.u.LowPart&(BIGSIZE-1)))
1269 cc=BIGSIZE-(This->offset.u.LowPart&(BIGSIZE-1));
1270 memcpy(pbv,block+(This->offset.u.LowPart&(BIGSIZE-1)),cc);
1271 This->offset.u.LowPart+=cc;
1272 pbv+=cc;
1273 *bytesread+=cc;
1274 cb-=cc;
1275 blocknr=STORAGE_get_next_big_blocknr(&This->str,blocknr);
1276 }
1277 }
1278 return S_OK;
1279 }
1280
1281 /******************************************************************************
1282 * IStream16_Write [STORAGE.522]
1283 */
1284 HRESULT CDECL IStream16_fnWrite(
1285 IStream16* iface,const void *pv,ULONG cb,ULONG *pcbWrite
1286 ) {
1287 IStream16Impl *This = (IStream16Impl *)iface;
1288 BYTE block[BIGSIZE];
1289 ULONG *byteswritten=pcbWrite,xxwritten;
1290 int oldsize,newsize,i,curoffset=0,lastblocknr,blocknr,cc;
1291 const BYTE* pbv = (const BYTE*)pv;
1292
1293 if (!pcbWrite) byteswritten=&xxwritten;
1294 *byteswritten = 0;
1295
1296 TRACE_(relay)("(%p)->(%p,%d,%p)\n",This,pv,cb,pcbWrite);
1297 /* do we need to junk some blocks? */
1298 newsize = This->offset.u.LowPart+cb;
1299 oldsize = This->stde.pps_size;
1300 if (newsize < oldsize) {
1301 if (oldsize < 0x1000) {
1302 /* only small blocks */
1303 blocknr=STORAGE_get_nth_next_small_blocknr(&This->str,This->stde.pps_sb,newsize/SMALLSIZE);
1304
1305 assert(blocknr>=0);
1306
1307 /* will set the rest of the chain to 'free' */
1308 if (!STORAGE_set_small_chain(&This->str,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
1309 return E_FAIL;
1310 } else {
1311 if (newsize >= 0x1000) {
1312 blocknr=STORAGE_get_nth_next_big_blocknr(&This->str,This->stde.pps_sb,newsize/BIGSIZE);
1313 assert(blocknr>=0);
1314
1315 /* will set the rest of the chain to 'free' */
1316 if (!STORAGE_set_big_chain(&This->str,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
1317 return E_FAIL;
1318 } else {
1319 /* Migrate large blocks to small blocks
1320 * (we just migrate newsize bytes)
1321 */
1322 LPBYTE curdata,data = HeapAlloc(GetProcessHeap(),0,newsize+BIGSIZE);
1323 HRESULT r = E_FAIL;
1324
1325 cc = newsize;
1326 blocknr = This->stde.pps_sb;
1327 curdata = data;
1328 while (cc>0) {
1329 if (!STORAGE_get_big_block(&This->str,blocknr,curdata)) {
1330 HeapFree(GetProcessHeap(),0,data);
1331 return E_FAIL;
1332 }
1333 curdata += BIGSIZE;
1334 cc -= BIGSIZE;
1335 blocknr = STORAGE_get_next_big_blocknr(&This->str,blocknr);
1336 }
1337 /* frees complete chain for this stream */
1338 if (!STORAGE_set_big_chain(&This->str,This->stde.pps_sb,STORAGE_CHAINENTRY_FREE))
1339 goto err;
1340 curdata = data;
1341 blocknr = This->stde.pps_sb = STORAGE_get_free_small_blocknr(&This->str);
1342 if (blocknr<0)
1343 goto err;
1344 cc = newsize;
1345 while (cc>0) {
1346 if (!STORAGE_put_small_block(&This->str,blocknr,curdata))
1347 goto err;
1348 cc -= SMALLSIZE;
1349 if (cc<=0) {
1350 if (!STORAGE_set_small_chain(&This->str,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
1351 goto err;
1352 break;
1353 } else {
1354 int newblocknr = STORAGE_get_free_small_blocknr(&This->str);
1355 if (newblocknr<0)
1356 goto err;
1357 if (!STORAGE_set_small_chain(&This->str,blocknr,newblocknr))
1358 goto err;
1359 blocknr = newblocknr;
1360 }
1361 curdata += SMALLSIZE;
1362 }
1363 r = S_OK;
1364 err:
1365 HeapFree(GetProcessHeap(),0,data);
1366 if(r != S_OK)
1367 return r;
1368 }
1369 }
1370 This->stde.pps_size = newsize;
1371 }
1372
1373 if (newsize > oldsize) {
1374 if (oldsize >= 0x1000) {
1375 /* should return the block right before the 'endofchain' */
1376 blocknr = STORAGE_get_nth_next_big_blocknr(&This->str,This->stde.pps_sb,This->stde.pps_size/BIGSIZE);
1377 assert(blocknr>=0);
1378 lastblocknr = blocknr;
1379 for (i=oldsize/BIGSIZE;i<newsize/BIGSIZE;i++) {
1380 blocknr = STORAGE_get_free_big_blocknr(&This->str);
1381 if (blocknr<0)
1382 return E_FAIL;
1383 if (!STORAGE_set_big_chain(&This->str,lastblocknr,blocknr))
1384 return E_FAIL;
1385 lastblocknr = blocknr;
1386 }
1387 if (!STORAGE_set_big_chain(&This->str,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
1388 return E_FAIL;
1389 } else {
1390 if (newsize < 0x1000) {
1391 /* find startblock */
1392 if (!oldsize)
1393 This->stde.pps_sb = blocknr = STORAGE_get_free_small_blocknr(&This->str);
1394 else
1395 blocknr = STORAGE_get_nth_next_small_blocknr(&This->str,This->stde.pps_sb,This->stde.pps_size/SMALLSIZE);
1396 if (blocknr<0)
1397 return E_FAIL;
1398
1399 /* allocate required new small blocks */
1400 lastblocknr = blocknr;
1401 for (i=oldsize/SMALLSIZE;i<newsize/SMALLSIZE;i++) {
1402 blocknr = STORAGE_get_free_small_blocknr(&This->str);
1403 if (blocknr<0)
1404 return E_FAIL;
1405 if (!STORAGE_set_small_chain(&This->str,lastblocknr,blocknr))
1406 return E_FAIL;
1407 lastblocknr = blocknr;
1408 }
1409 /* and terminate the chain */
1410 if (!STORAGE_set_small_chain(&This->str,lastblocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
1411 return E_FAIL;
1412 } else {
1413 if (!oldsize) {
1414 /* no single block allocated yet */
1415 blocknr=STORAGE_get_free_big_blocknr(&This->str);
1416 if (blocknr<0)
1417 return E_FAIL;
1418 This->stde.pps_sb = blocknr;
1419 } else {
1420 /* Migrate small blocks to big blocks */
1421 LPBYTE curdata,data = HeapAlloc(GetProcessHeap(),0,oldsize+BIGSIZE);
1422 HRESULT r = E_FAIL;
1423
1424 cc = oldsize;
1425 blocknr = This->stde.pps_sb;
1426 curdata = data;
1427 /* slurp in */
1428 while (cc>0) {
1429 if (!STORAGE_get_small_block(&This->str,blocknr,curdata))
1430 goto err2;
1431 curdata += SMALLSIZE;
1432 cc -= SMALLSIZE;
1433 blocknr = STORAGE_get_next_small_blocknr(&This->str,blocknr);
1434 }
1435 /* free small block chain */
1436 if (!STORAGE_set_small_chain(&This->str,This->stde.pps_sb,STORAGE_CHAINENTRY_FREE))
1437 goto err2;
1438 curdata = data;
1439 blocknr = This->stde.pps_sb = STORAGE_get_free_big_blocknr(&This->str);
1440 if (blocknr<0)
1441 goto err2;
1442 /* put the data into the big blocks */
1443 cc = This->stde.pps_size;
1444 while (cc>0) {
1445 if (!STORAGE_put_big_block(&This->str,blocknr,curdata))
1446 goto err2;
1447 cc -= BIGSIZE;
1448 if (cc<=0) {
1449 if (!STORAGE_set_big_chain(&This->str,blocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
1450 goto err2;
1451 break;
1452 } else {
1453 int newblocknr = STORAGE_get_free_big_blocknr(&This->str);
1454 if (newblocknr<0)
1455 goto err2;
1456 if (!STORAGE_set_big_chain(&This->str,blocknr,newblocknr))
1457 goto err2;
1458 blocknr = newblocknr;
1459 }
1460 curdata += BIGSIZE;
1461 }
1462 r = S_OK;
1463 err2:
1464 HeapFree(GetProcessHeap(),0,data);
1465 if(r != S_OK)
1466 return r;
1467 }
1468 /* generate big blocks to fit the new data */
1469 lastblocknr = blocknr;
1470 for (i=oldsize/BIGSIZE;i<newsize/BIGSIZE;i++) {
1471 blocknr = STORAGE_get_free_big_blocknr(&This->str);
1472 if (blocknr<0)
1473 return E_FAIL;
1474 if (!STORAGE_set_big_chain(&This->str,lastblocknr,blocknr))
1475 return E_FAIL;
1476 lastblocknr = blocknr;
1477 }
1478 /* terminate chain */
1479 if (!STORAGE_set_big_chain(&This->str,lastblocknr,STORAGE_CHAINENTRY_ENDOFCHAIN))
1480 return E_FAIL;
1481 }
1482 }
1483 This->stde.pps_size = newsize;
1484 }
1485
1486 /* There are just some cases where we didn't modify it, we write it out
1487 * everytime
1488 */
1489 if (!STORAGE_put_pps_entry(&This->str,This->ppsent,&(This->stde)))
1490 return E_FAIL;
1491
1492 /* finally the write pass */
1493 if (This->stde.pps_size < 0x1000) {
1494 blocknr = STORAGE_get_nth_next_small_blocknr(&This->str,This->stde.pps_sb,This->offset.u.LowPart/SMALLSIZE);
1495 assert(blocknr>=0);
1496 while (cb>0) {
1497 /* we ensured that it is allocated above */
1498 assert(blocknr>=0);
1499 /* Read old block everytime, since we can have
1500 * overlapping data at START and END of the write
1501 */
1502 if (!STORAGE_get_small_block(&This->str,blocknr,block))
1503 return E_FAIL;
1504
1505 cc = SMALLSIZE-(This->offset.u.LowPart&(SMALLSIZE-1));
1506 if (cc>cb)
1507 cc=cb;
1508 memcpy( ((LPBYTE)block)+(This->offset.u.LowPart&(SMALLSIZE-1)),
1509 pbv+curoffset,
1510 cc
1511 );
1512 if (!STORAGE_put_small_block(&This->str,blocknr,block))
1513 return E_FAIL;
1514 cb -= cc;
1515 curoffset += cc;
1516 pbv += cc;
1517 This->offset.u.LowPart += cc;
1518 *byteswritten += cc;
1519 blocknr = STORAGE_get_next_small_blocknr(&This->str,blocknr);
1520 }
1521 } else {
1522 blocknr = STORAGE_get_nth_next_big_blocknr(&This->str,This->stde.pps_sb,This->offset.u.LowPart/BIGSIZE);
1523 assert(blocknr>=0);
1524 while (cb>0) {
1525 /* we ensured that it is allocated above, so it better is */
1526 assert(blocknr>=0);
1527 /* read old block everytime, since we can have
1528 * overlapping data at START and END of the write
1529 */
1530 if (!STORAGE_get_big_block(&This->str,blocknr,block))
1531 return E_FAIL;
1532
1533 cc = BIGSIZE-(This->offset.u.LowPart&(BIGSIZE-1));
1534 if (cc>cb)
1535 cc=cb;
1536 memcpy( ((LPBYTE)block)+(This->offset.u.LowPart&(BIGSIZE-1)),
1537 pbv+curoffset,
1538 cc
1539 );
1540 if (!STORAGE_put_big_block(&This->str,blocknr,block))
1541 return E_FAIL;
1542 cb -= cc;
1543 curoffset += cc;
1544 pbv += cc;
1545 This->offset.u.LowPart += cc;
1546 *byteswritten += cc;
1547 blocknr = STORAGE_get_next_big_blocknr(&This->str,blocknr);
1548 }
1549 }
1550 return S_OK;
1551 }
1552
1553 /******************************************************************************
1554 * _create_istream16 [Internal]
1555 */
1556 static void _create_istream16(LPSTREAM16 *str) {
1557 IStream16Impl* lpst;
1558
1559 if (!strvt16.QueryInterface) {
1560 HMODULE16 wp = GetModuleHandle16("STORAGE");
1561 if (wp>=32) {
1562 /* FIXME: what is This GetProcAddress16. Should the name be IStream16_QueryInterface of IStream16_fnQueryInterface */
1563 #define VTENT(xfn) strvt16.xfn = (void*)GetProcAddress16(wp,"IStream16_"#xfn);assert(strvt16.xfn)
1564 VTENT(QueryInterface);
1565 VTENT(AddRef);
1566 VTENT(Release);
1567 VTENT(Read);
1568 VTENT(Write);
1569 VTENT(Seek);
1570 VTENT(SetSize);
1571 VTENT(CopyTo);
1572 VTENT(Commit);
1573 VTENT(Revert);
1574 VTENT(LockRegion);
1575 VTENT(UnlockRegion);
1576 VTENT(Stat);
1577 VTENT(Clone);
1578 #undef VTENT
1579 segstrvt16 = (const IStream16Vtbl*)MapLS( &strvt16 );
1580 } else {
1581 #define VTENT(xfn) strvt16.xfn = IStream16_fn##xfn;
1582 VTENT(QueryInterface);
1583 VTENT(AddRef);
1584 VTENT(Release);
1585 VTENT(Read);
1586 VTENT(Write);
1587 VTENT(Seek);
1588 /*
1589 VTENT(CopyTo);
1590 VTENT(Commit);
1591 VTENT(SetSize);
1592 VTENT(Revert);
1593 VTENT(LockRegion);
1594 VTENT(UnlockRegion);
1595 VTENT(Stat);
1596 VTENT(Clone);
1597 */
1598 #undef VTENT
1599 segstrvt16 = &strvt16;
1600 }
1601 }
1602 lpst = HeapAlloc( GetProcessHeap(), 0, sizeof(*lpst) );
1603 lpst->lpVtbl = segstrvt16;
1604 lpst->ref = 1;
1605 lpst->thisptr = MapLS( lpst );
1606 lpst->str.hf = NULL;
1607 lpst->str.lockbytes = 0;
1608 *str = (void*)lpst->thisptr;
1609 }
1610
1611
1612 /* --- IStream32 implementation */
1613
1614 typedef struct
1615 {
1616 /* IUnknown fields */
1617 const IStreamVtbl *lpVtbl;
1618 LONG ref;
1619 /* IStream32 fields */
1620 struct storage_pps_entry stde;
1621 int ppsent;
1622 HANDLE hf;
1623 ULARGE_INTEGER offset;
1624 } IStream32Impl;
1625
1626 /*****************************************************************************
1627 * IStream32_QueryInterface [VTABLE]
1628 */
1629 HRESULT WINAPI IStream_fnQueryInterface(
1630 IStream* iface,REFIID refiid,LPVOID *obj
1631 ) {
1632 IStream32Impl *This = (IStream32Impl *)iface;
1633
1634 TRACE_(relay)("(%p)->(%s,%p)\n",This,debugstr_guid(refiid),obj);
1635 if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
1636 *obj = This;
1637 return 0;
1638 }
1639 return OLE_E_ENUM_NOMORE;
1640
1641 }
1642
1643 /******************************************************************************
1644 * IStream32_AddRef [VTABLE]
1645 */
1646 ULONG WINAPI IStream_fnAddRef(IStream* iface) {
1647 IStream32Impl *This = (IStream32Impl *)iface;
1648 return InterlockedIncrement(&This->ref);
1649 }
1650
1651 /******************************************************************************
1652 * IStream32_Release [VTABLE]
1653 */
1654 ULONG WINAPI IStream_fnRelease(IStream* iface) {
1655 IStream32Impl *This = (IStream32Impl *)iface;
1656 ULONG ref;
1657 FlushFileBuffers(This->hf);
1658 ref = InterlockedDecrement(&This->ref);
1659 if (!ref) {
1660 CloseHandle(This->hf);
1661 HeapFree( GetProcessHeap(), 0, This );
1662 }
1663 return ref;
1664 }
1665
1666 /******************************************************************************
1667 * IStorage16_QueryInterface [STORAGE.500]
1668 */
1669 HRESULT CDECL IStorage16_fnQueryInterface(
1670 IStorage16* iface,REFIID refiid,LPVOID *obj
1671 ) {
1672 IStorage16Impl *This = (IStorage16Impl *)iface;
1673
1674 TRACE_(relay)("(%p)->(%s,%p)\n",This,debugstr_guid(refiid),obj);
1675
1676 if (!memcmp(&IID_IUnknown,refiid,sizeof(IID_IUnknown))) {
1677 *obj = This;
1678 return 0;
1679 }
1680 return OLE_E_ENUM_NOMORE;
1681 }
1682
1683 /******************************************************************************
1684 * IStorage16_AddRef [STORAGE.501]
1685 */
1686 ULONG CDECL IStorage16_fnAddRef(IStorage16* iface) {
1687 IStorage16Impl *This = (IStorage16Impl *)iface;
1688 return InterlockedIncrement(&This->ref);
1689 }
1690
1691 /******************************************************************************
1692 * IStorage16_Release [STORAGE.502]
1693 */
1694 ULONG CDECL IStorage16_fnRelease(IStorage16* iface) {
1695 IStorage16Impl *This = (IStorage16Impl *)iface;
1696 ULONG ref;
1697 ref = InterlockedDecrement(&This->ref);
1698 if (!ref)
1699 {
1700 UnMapLS( This->thisptr );
1701 HeapFree( GetProcessHeap(), 0, This );
1702 }
1703 return ref;
1704 }
1705
1706 /******************************************************************************
1707 * IStorage16_Stat [STORAGE.517]
1708 */
1709 HRESULT CDECL IStorage16_fnStat(
1710 LPSTORAGE16 iface,STATSTG16 *pstatstg, DWORD grfStatFlag
1711 ) {
1712 IStorage16Impl *This = (IStorage16Impl *)iface;
1713 DWORD len = WideCharToMultiByte( CP_ACP, 0, This->stde.pps_rawname, -1, NULL, 0, NULL, NULL );
1714 LPSTR nameA = HeapAlloc( GetProcessHeap(), 0, len );
1715
1716 TRACE("(%p)->(%p,0x%08x)\n",
1717 This,pstatstg,grfStatFlag
1718 );
1719 WideCharToMultiByte( CP_ACP, 0, This->stde.pps_rawname, -1, nameA, len, NULL, NULL );
1720 pstatstg->pwcsName=(LPOLESTR16)MapLS( nameA );
1721 pstatstg->type = This->stde.pps_type;
1722 pstatstg->cbSize.u.LowPart = This->stde.pps_size;
1723 pstatstg->mtime = This->stde.pps_ft1; /* FIXME */ /* why? */
1724 pstatstg->atime = This->stde.pps_ft2; /* FIXME */
1725 pstatstg->ctime = This->stde.pps_ft2; /* FIXME */
1726 pstatstg->grfMode = 0; /* FIXME */
1727 pstatstg->grfLocksSupported = 0; /* FIXME */
1728 pstatstg->clsid = This->stde.pps_guid;
1729 pstatstg->grfStateBits = 0; /* FIXME */
1730 pstatstg->reserved = 0;
1731 return S_OK;
1732 }
1733
1734 /******************************************************************************
1735 * IStorage16_Commit [STORAGE.509]
1736 */
1737 HRESULT CDECL IStorage16_fnCommit(
1738 LPSTORAGE16 iface,DWORD commitflags
1739 ) {
1740 IStorage16Impl *This = (IStorage16Impl *)iface;
1741 FIXME("(%p)->(0x%08x),STUB!\n",
1742 This,commitflags
1743 );
1744 return S_OK;
1745 }
1746
1747 /******************************************************************************
1748 * IStorage16_CopyTo [STORAGE.507]
1749 */
1750 HRESULT CDECL IStorage16_fnCopyTo(LPSTORAGE16 iface,DWORD ciidExclude,const IID *rgiidExclude,SNB16 SNB16Exclude,IStorage16 *pstgDest) {
1751 IStorage16Impl *This = (IStorage16Impl *)iface;
1752 FIXME("IStorage16(%p)->(0x%08x,%s,%p,%p),stub!\n",
1753 This,ciidExclude,debugstr_guid(rgiidExclude),SNB16Exclude,pstgDest
1754 );
1755 return S_OK;
1756 }
1757
1758
1759 /******************************************************************************
1760 * IStorage16_CreateStorage [STORAGE.505]
1761 */
1762 HRESULT CDECL IStorage16_fnCreateStorage(
1763 LPSTORAGE16 iface,LPCOLESTR16 pwcsName,DWORD grfMode,DWORD dwStgFormat,DWORD reserved2, IStorage16 **ppstg
1764 ) {
1765 IStorage16Impl *This = (IStorage16Impl *)iface;
1766 IStorage16Impl* lpstg;
1767 int ppsent,x;
1768 struct storage_pps_entry stde;
1769 struct storage_header sth;
1770 BOOL ret;
1771 int nPPSEntries;
1772
1773 READ_HEADER(&This->str);
1774 TRACE("(%p)->(%s,0x%08x,0x%08x,0x%08x,%p)\n",
1775 This,pwcsName,grfMode,dwStgFormat,reserved2,ppstg
1776 );
1777 if (grfMode & STGM_TRANSACTED)
1778 FIXME("We do not support transacted Compound Storage. Using direct mode.\n");
1779 _create_istorage16(ppstg);
1780 lpstg = MapSL((SEGPTR)*ppstg);
1781 if (This->str.hf) {
1782 DuplicateHandle( GetCurrentProcess(), This->str.hf, GetCurrentProcess(),
1783 &lpstg->str.hf, 0, TRUE, DUPLICATE_SAME_ACCESS );
1784 } else {
1785 lpstg->str.lockbytes = This->str.lockbytes;
1786 _ilockbytes16_addref(This->str.lockbytes);
1787 }
1788
1789 ppsent=STORAGE_get_free_pps_entry(&lpstg->str);
1790 if (ppsent<0)
1791 return E_FAIL;
1792 stde=This->stde;
1793 if (stde.pps_dir==-1) {
1794 stde.pps_dir = ppsent;
1795 x = This->ppsent;
1796 } else {
1797 FIXME(" use prev chain too ?\n");
1798 x=stde.pps_dir;
1799 if (1!=STORAGE_get_pps_entry(&lpstg->str,x,&stde))
1800 return E_FAIL;
1801 while (stde.pps_next!=-1) {
1802 x=stde.pps_next;
1803 if (1!=STORAGE_get_pps_entry(&lpstg->str,x,&stde))
1804 return E_FAIL;
1805 }
1806 stde.pps_next = ppsent;
1807 }
1808 ret = STORAGE_put_pps_entry(&lpstg->str,x,&stde);
1809 assert(ret);
1810 nPPSEntries = STORAGE_get_pps_entry(&lpstg->str,ppsent,&(lpstg->stde));
1811 assert(nPPSEntries == 1);
1812 MultiByteToWideChar( CP_ACP, 0, pwcsName, -1, lpstg->stde.pps_rawname,
1813 sizeof(lpstg->stde.pps_rawname)/sizeof(WCHAR));
1814 lpstg->stde.pps_sizeofname = (strlenW(lpstg->stde.pps_rawname)+1)*sizeof(WCHAR);
1815 lpstg->stde.pps_next = -1;
1816 lpstg->stde.pps_prev = -1;
1817 lpstg->stde.pps_dir = -1;
1818 lpstg->stde.pps_sb = -1;
1819 lpstg->stde.pps_size = 0;
1820 lpstg->stde.pps_type = 1;
1821 lpstg->ppsent = ppsent;
1822 /* FIXME: timestamps? */
1823 if (!STORAGE_put_pps_entry(&lpstg->str,ppsent,&(lpstg->stde)))
1824 return E_FAIL;
1825 return S_OK;
1826 }
1827
1828 /******************************************************************************
1829 * IStorage16_CreateStream [STORAGE.503]
1830 */
1831 HRESULT CDECL IStorage16_fnCreateStream(
1832 LPSTORAGE16 iface,LPCOLESTR16 pwcsName,DWORD grfMode,DWORD reserved1,DWORD reserved2, IStream16 **ppstm
1833 ) {
1834 IStorage16Impl *This = (IStorage16Impl *)iface;
1835 IStream16Impl* lpstr;
1836 int ppsent,x;
1837 struct storage_pps_entry stde;
1838 BOOL ret;
1839 int nPPSEntries;
1840
1841 TRACE("(%p)->(%s,0x%08x,0x%08x,0x%08x,%p)\n",
1842 This,pwcsName,grfMode,reserved1,reserved2,ppstm
1843 );
1844 if (grfMode & STGM_TRANSACTED)
1845 FIXME("We do not support transacted Compound Storage. Using direct mode.\n");
1846 _create_istream16(ppstm);
1847 lpstr = MapSL((SEGPTR)*ppstm);
1848 if (This->str.hf) {
1849 DuplicateHandle( GetCurrentProcess(), This->str.hf, GetCurrentProcess(),
1850 &lpstr->str.hf, 0, TRUE, DUPLICATE_SAME_ACCESS );
1851 } else {
1852 lpstr->str.lockbytes = This->str.lockbytes;
1853 _ilockbytes16_addref(This->str.lockbytes);
1854 }
1855 lpstr->offset.u.LowPart = 0;
1856 lpstr->offset.u.HighPart= 0;
1857
1858 ppsent=STORAGE_get_free_pps_entry(&lpstr->str);
1859 if (ppsent<0)
1860 return E_FAIL;
1861 stde=This->stde;
1862 if (stde.pps_next==-1)
1863 x=This->ppsent;
1864 else
1865 while (stde.pps_next!=-1) {
1866 x=stde.pps_next;
1867 if (1!=STORAGE_get_pps_entry(&lpstr->str,x,&stde))
1868 return E_FAIL;
1869 }
1870 stde.pps_next = ppsent;
1871 ret = STORAGE_put_pps_entry(&lpstr->str,x,&stde);
1872 assert(ret);
1873 nPPSEntries = STORAGE_get_pps_entry(&lpstr->str,ppsent,&(lpstr->stde));
1874 assert(nPPSEntries == 1);
1875 MultiByteToWideChar( CP_ACP, 0, pwcsName, -1, lpstr->stde.pps_rawname,
1876 sizeof(lpstr->stde.pps_rawname)/sizeof(WCHAR));
1877 lpstr->stde.pps_sizeofname = (strlenW(lpstr->stde.pps_rawname)+1) * sizeof(WCHAR);
1878 lpstr->stde.pps_next = -1;
1879 lpstr->stde.pps_prev = -1;
1880 lpstr->stde.pps_dir = -1;
1881 lpstr->stde.pps_sb = -1;
1882 lpstr->stde.pps_size = 0;
1883 lpstr->stde.pps_type = 2;
1884 lpstr->ppsent = ppsent;
1885
1886 /* FIXME: timestamps? */
1887 if (!STORAGE_put_pps_entry(&lpstr->str,ppsent,&(lpstr->stde)))
1888 return E_FAIL;
1889 return S_OK;
1890 }
1891
1892 /******************************************************************************
1893 * IStorage16_OpenStorage [STORAGE.506]
1894 */
1895 HRESULT CDECL IStorage16_fnOpenStorage(
1896 LPSTORAGE16 iface,LPCOLESTR16 pwcsName, IStorage16 *pstgPrio, DWORD grfMode, SNB16 snbExclude, DWORD reserved, IStorage16 **ppstg
1897 ) {
1898 IStorage16Impl *This = (IStorage16Impl *)iface;
1899 IStream16Impl* lpstg;
1900 WCHAR name[33];
1901 int newpps;
1902
1903 TRACE("(%p)->(%s,%p,0x%08x,%p,0x%08x,%p)\n",
1904 This,pwcsName,pstgPrio,grfMode,snbExclude,reserved,ppstg
1905 );
1906 if (grfMode & STGM_TRANSACTED)
1907 FIXME("We do not support transacted Compound Storage. Using direct mode.\n");
1908 _create_istorage16(ppstg);
1909 lpstg = MapSL((SEGPTR)*ppstg);
1910 if (This->str.hf) {
1911 DuplicateHandle( GetCurrentProcess(), This->str.hf, GetCurrentProcess(),
1912 &lpstg->str.hf, 0, TRUE, DUPLICATE_SAME_ACCESS );
1913 } else {
1914 lpstg->str.lockbytes = This->str.lockbytes;
1915 _ilockbytes16_addref(This->str.lockbytes);
1916 }
1917 MultiByteToWideChar( CP_ACP, 0, pwcsName, -1, name, sizeof(name)/sizeof(WCHAR));
1918 newpps = STORAGE_look_for_named_pps(&lpstg->str,This->stde.pps_dir,name);
1919 if (newpps==-1) {
1920 IStream16_fnRelease((IStream16*)lpstg);
1921 return E_FAIL;
1922 }
1923
1924 if (1!=STORAGE_get_pps_entry(&lpstg->str,newpps,&(lpstg->stde))) {
1925 IStream16_fnRelease((IStream16*)lpstg);
1926 return E_FAIL;
1927 }
1928 lpstg->ppsent = newpps;
1929 return S_OK;
1930 }
1931
1932 /******************************************************************************
1933 * IStorage16_OpenStream [STORAGE.504]
1934 */
1935 HRESULT CDECL IStorage16_fnOpenStream(
1936 LPSTORAGE16 iface,LPCOLESTR16 pwcsName, void *reserved1, DWORD grfMode, DWORD reserved2, IStream16 **ppstm
1937 ) {
1938 IStorage16Impl *This = (IStorage16Impl *)iface;
1939 IStream16Impl* lpstr;
1940 WCHAR name[33];
1941 int newpps;
1942
1943 TRACE("(%p)->(%s,%p,0x%08x,0x%08x,%p)\n",
1944 This,pwcsName,reserved1,grfMode,reserved2,ppstm
1945 );
1946 if (grfMode & STGM_TRANSACTED)
1947 FIXME("We do not support transacted Compound Storage. Using direct mode.\n");
1948 _create_istream16(ppstm);
1949 lpstr = MapSL((SEGPTR)*ppstm);
1950 if (This->str.hf) {
1951 DuplicateHandle( GetCurrentProcess(), This->str.hf, GetCurrentProcess(),
1952 &lpstr->str.hf, 0, TRUE, DUPLICATE_SAME_ACCESS );
1953 } else {
1954 lpstr->str.lockbytes = This->str.lockbytes;
1955 _ilockbytes16_addref(This->str.lockbytes);
1956 }
1957 MultiByteToWideChar( CP_ACP, 0, pwcsName, -1, name, sizeof(name)/sizeof(WCHAR));
1958 newpps = STORAGE_look_for_named_pps(&lpstr->str,This->stde.pps_dir,name);
1959 if (newpps==-1) {
1960 IStream16_fnRelease((IStream16*)lpstr);
1961 return E_FAIL;
1962 }
1963
1964 if (1!=STORAGE_get_pps_entry(&lpstr->str,newpps,&(lpstr->stde))) {
1965 IStream16_fnRelease((IStream16*)lpstr);
1966 return E_FAIL;
1967 }
1968 lpstr->offset.u.LowPart = 0;
1969 lpstr->offset.u.HighPart = 0;
1970 lpstr->ppsent = newpps;
1971 return S_OK;
1972 }
1973
1974 /******************************************************************************
1975 * _create_istorage16 [INTERNAL]
1976 */
1977 static void _create_istorage16(LPSTORAGE16 *stg) {
1978 IStorage16Impl* lpst;
1979
1980 if (!stvt16.QueryInterface) {
1981 HMODULE16 wp = GetModuleHandle16("STORAGE");
1982 if (wp>=32) {
1983 #define VTENT(xfn) stvt16.xfn = (void*)GetProcAddress16(wp,"IStorage16_"#xfn);
1984 VTENT(QueryInterface)
1985 VTENT(AddRef)
1986 VTENT(Release)
1987 VTENT(CreateStream)
1988 VTENT(OpenStream)
1989 VTENT(CreateStorage)
1990 VTENT(OpenStorage)
1991 VTENT(CopyTo)
1992 VTENT(MoveElementTo)
1993 VTENT(Commit)
1994 VTENT(Revert)
1995 VTENT(EnumElements)
1996 VTENT(DestroyElement)
1997 VTENT(RenameElement)
1998 VTENT(SetElementTimes)
1999 VTENT(SetClass)
2000 VTENT(SetStateBits)
2001 VTENT(Stat)
2002 #undef VTENT
2003 segstvt16 = (const IStorage16Vtbl*)MapLS( &stvt16 );
2004 } else {
2005 #define VTENT(xfn) stvt16.xfn = IStorage16_fn##xfn;
2006 VTENT(QueryInterface)
2007 VTENT(AddRef)
2008 VTENT(Release)
2009 VTENT(CreateStream)
2010 VTENT(OpenStream)
2011 VTENT(CreateStorage)
2012 VTENT(OpenStorage)
2013 VTENT(CopyTo)
2014 VTENT(Commit)
2015 /* not (yet) implemented ...
2016 VTENT(MoveElementTo)
2017 VTENT(Revert)
2018 VTENT(EnumElements)
2019 VTENT(DestroyElement)
2020 VTENT(RenameElement)
2021 VTENT(SetElementTimes)
2022 VTENT(SetClass)
2023 VTENT(SetStateBits)
2024 VTENT(Stat)
2025 */
2026 #undef VTENT
2027 segstvt16 = &stvt16;
2028 }
2029 }
2030 lpst = HeapAlloc( GetProcessHeap(), 0, sizeof(*lpst) );
2031 lpst->lpVtbl = segstvt16;
2032 lpst->str.hf = NULL;
2033 lpst->str.lockbytes = 0;
2034 lpst->ref = 1;
2035 lpst->thisptr = MapLS(lpst);
2036 *stg = (void*)lpst->thisptr;
2037 }
2038
2039 /******************************************************************************
2040 * Storage API functions
2041 */
2042
2043 /******************************************************************************
2044 * StgCreateDocFileA [STORAGE.1]
2045 */
2046 HRESULT WINAPI StgCreateDocFile16(
2047 LPCOLESTR16 pwcsName,DWORD grfMode,DWORD reserved,IStorage16 **ppstgOpen
2048 ) {
2049 HANDLE hf;
2050 int i,ret;
2051 IStorage16Impl* lpstg;
2052 struct storage_pps_entry stde;
2053
2054 TRACE("(%s,0x%08x,0x%08x,%p)\n",
2055 pwcsName,grfMode,reserved,ppstgOpen
2056 );
2057 _create_istorage16(ppstgOpen);
2058 hf = CreateFileA(pwcsName,GENERIC_READ|GENERIC_WRITE,0,NULL,CREATE_NEW,0,0);
2059 if (hf==INVALID_HANDLE_VALUE) {
2060 WARN("couldn't open file for storage:%d\n",GetLastError());
2061 return E_FAIL;
2062 }
2063 lpstg = MapSL((SEGPTR)*ppstgOpen);
2064 lpstg->str.hf = hf;
2065 lpstg->str.lockbytes = 0;
2066 /* FIXME: check for existence before overwriting? */
2067 if (!STORAGE_init_storage(&lpstg->str)) {
2068 CloseHandle(hf);
2069 return E_FAIL;
2070 }
2071 i=0;ret=0;
2072 while (!ret) { /* neither 1 nor <0 */
2073 ret=STORAGE_get_pps_entry(&lpstg->str,i,&stde);
2074 if ((ret==1) && (stde.pps_type==5)) {
2075 lpstg->stde = stde;
2076 lpstg->ppsent = i;
2077 break;
2078 }
2079 i++;
2080 }
2081 if (ret!=1) {
2082 IStorage16_fnRelease((IStorage16*)lpstg); /* will remove it */
2083 return E_FAIL;
2084 }
2085
2086 return S_OK;
2087 }
2088
2089 /******************************************************************************
2090 * StgIsStorageFile [STORAGE.5]
2091 */
2092 HRESULT WINAPI StgIsStorageFile16(LPCOLESTR16 fn) {
2093 UNICODE_STRING strW;
2094 HRESULT ret;
2095
2096 RtlCreateUnicodeStringFromAsciiz(&strW, fn);
2097 ret = StgIsStorageFile( strW.Buffer );
2098 RtlFreeUnicodeString( &strW );
2099
2100 return ret;
2101 }
2102
2103 /******************************************************************************
2104 * StgOpenStorage [STORAGE.3]
2105 */
2106 HRESULT WINAPI StgOpenStorage16(
2107 LPCOLESTR16 pwcsName,IStorage16 *pstgPriority,DWORD grfMode,
2108 SNB16 snbExclude,DWORD reserved, IStorage16 **ppstgOpen
2109 ) {
2110 HANDLE hf;
2111 int ret,i;
2112 IStorage16Impl* lpstg;
2113 struct storage_pps_entry stde;
2114
2115 TRACE("(%s,%p,0x%08x,%p,%d,%p)\n",
2116 pwcsName,pstgPriority,grfMode,snbExclude,reserved,ppstgOpen
2117 );
2118 _create_istorage16(ppstgOpen);
2119 hf = CreateFileA(pwcsName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
2120 if (hf==INVALID_HANDLE_VALUE) {
2121 WARN("Couldn't open file for storage\n");
2122 return E_FAIL;
2123 }
2124 lpstg = MapSL((SEGPTR)*ppstgOpen);
2125 lpstg->str.hf = hf;
2126
2127 i=0;ret=0;
2128 while (!ret) { /* neither 1 nor <0 */
2129 ret=STORAGE_get_pps_entry(&lpstg->str,i,&stde);
2130 if ((ret==1) && (stde.pps_type==5)) {
2131 lpstg->stde=stde;
2132 break;
2133 }
2134 i++;
2135 }
2136 if (ret!=1) {
2137 IStorage16_fnRelease((IStorage16*)lpstg); /* will remove it */
2138 return E_FAIL;
2139 }
2140 return S_OK;
2141
2142 }
2143
2144 /******************************************************************************
2145 * StgIsStorageILockBytes [STORAGE.6]
2146 *
2147 * Determines if the ILockBytes contains a storage object.
2148 */
2149 HRESULT WINAPI StgIsStorageILockBytes16(SEGPTR plkbyt)
2150 {
2151 DWORD args[6];
2152 HRESULT hres;
2153 HANDLE16 hsig;
2154
2155 args[0] = (DWORD)plkbyt; /* iface */
2156 args[1] = args[2] = 0; /* ULARGE_INTEGER offset */
2157 args[3] = WOWGlobalAllocLock16( 0, 8, &hsig ); /* sig */
2158 args[4] = 8;
2159 args[5] = 0;
2160
2161 if (!WOWCallback16Ex(
2162 (DWORD)((const ILockBytes16Vtbl*)MapSL(
2163 (SEGPTR)((LPLOCKBYTES16)MapSL(plkbyt))->lpVtbl)
2164 )->ReadAt,
2165 WCB16_PASCAL,
2166 6*sizeof(DWORD),
2167 (LPVOID)args,
2168 (LPDWORD)&hres
2169 )) {
2170 ERR("CallTo16 ILockBytes16::ReadAt() failed, hres %x\n",hres);
2171 return hres;
2172 }
2173 if (memcmp(MapSL(args[3]), STORAGE_magic, sizeof(STORAGE_magic)) == 0) {
2174 WOWGlobalUnlockFree16(args[3]);
2175 return S_OK;
2176 }
2177 WOWGlobalUnlockFree16(args[3]);
2178 return S_FALSE;
2179 }
2180
2181 /******************************************************************************
2182 * StgOpenStorageOnILockBytes [STORAGE.4]
2183 *
2184 * PARAMS
2185 * plkbyt FIXME: Should probably be an ILockBytes16 *.
2186 */
2187 HRESULT WINAPI StgOpenStorageOnILockBytes16(
2188 SEGPTR plkbyt,
2189 IStorage16 *pstgPriority,
2190 DWORD grfMode,
2191 SNB16 snbExclude,
2192 DWORD reserved,
2193 IStorage16 **ppstgOpen)
2194 {
2195 IStorage16Impl* lpstg;
2196 int i,ret;
2197 struct storage_pps_entry stde;
2198
2199 FIXME("(%x, %p, 0x%08x, %d, %x, %p)\n", plkbyt, pstgPriority, grfMode, (int)snbExclude, reserved, ppstgOpen);
2200 if ((plkbyt == 0) || (ppstgOpen == 0))
2201 return STG_E_INVALIDPOINTER;
2202
2203 *ppstgOpen = 0;
2204
2205 _create_istorage16(ppstgOpen);
2206 lpstg = MapSL((SEGPTR)*ppstgOpen);
2207 lpstg->str.hf = NULL;
2208 lpstg->str.lockbytes = plkbyt;
2209 i=0;ret=0;
2210 while (!ret) { /* neither 1 nor <0 */
2211 ret=STORAGE_get_pps_entry(&lpstg->str,i,&stde);
2212 if ((ret==1) && (stde.pps_type==5)) {
2213 lpstg->stde=stde;
2214 break;
2215 }
2216 i++;
2217 }
2218 if (ret!=1) {
2219 IStorage16_fnRelease((IStorage16*)lpstg); /* will remove it */
2220 return E_FAIL;
2221 }
2222 return S_OK;
2223 }
2224
2225 /***********************************************************************
2226 * ReadClassStg (OLE2.18)
2227 *
2228 * This method reads the CLSID previously written to a storage object with
2229 * the WriteClassStg.
2230 *
2231 * PARAMS
2232 * pstg [I] Segmented LPSTORAGE pointer.
2233 * pclsid [O] Pointer to where the CLSID is written
2234 *
2235 * RETURNS
2236 * Success: S_OK.
2237 * Failure: HRESULT code.
2238 */
2239 HRESULT WINAPI ReadClassStg16(SEGPTR pstg, CLSID *pclsid)
2240 {
2241 STATSTG16 statstg;
2242 HANDLE16 hstatstg;
2243 HRESULT hres;
2244 DWORD args[3];
2245
2246 TRACE("(%x, %p)\n", pstg, pclsid);
2247
2248 if(pclsid==NULL)
2249 return E_POINTER;
2250 /*
2251 * read a STATSTG structure (contains the clsid) from the storage
2252 */
2253 args[0] = (DWORD)pstg; /* iface */
2254 args[1] = WOWGlobalAllocLock16( 0, sizeof(STATSTG16), &hstatstg );
2255 args[2] = STATFLAG_DEFAULT;
2256
2257 if (!WOWCallback16Ex(
2258 (DWORD)((const IStorage16Vtbl*)MapSL(
2259 (SEGPTR)((LPSTORAGE16)MapSL(pstg))->lpVtbl)
2260 )->Stat,
2261 WCB16_PASCAL,
2262 3*sizeof(DWORD),
2263 (LPVOID)args,
2264 (LPDWORD)&hres
2265 )) {
2266 WOWGlobalUnlockFree16(args[1]);
2267 ERR("CallTo16 IStorage16::Stat() failed, hres %x\n",hres);
2268 return hres;
2269 }
2270 memcpy(&statstg, MapSL(args[1]), sizeof(STATSTG16));
2271 WOWGlobalUnlockFree16(args[1]);
2272
2273 if(SUCCEEDED(hres)) {
2274 *pclsid=statstg.clsid;
2275 TRACE("clsid is %s\n", debugstr_guid(&statstg.clsid));
2276 }
2277 return hres;
2278 }
2279
2280 /***********************************************************************
2281 * GetConvertStg (OLE2.82)
2282 */
2283 HRESULT WINAPI GetConvertStg16(LPSTORAGE stg) {
2284 FIXME("unimplemented stub!\n");
2285 return E_FAIL;
2286 }
DirectPlay implementation for GSoC