3 * @author Alex Ott, Victor B Wagner
4 * @date Wed Jun 11 12:33:01 2003
5 * Version: $Id: ole.c,v 1.2 2006-02-25 15:28:14 vitus Exp $
6 * Copyright: Victor B Wagner, 1996-2003 Alex Ott, 2003
8 * @brief Parsing structure of MS Office compound document
10 * This file is part of catdoc project
11 * and distributed under GNU Public License
25 #define min(a,b) ((a) < (b) ? (a) : (b))
27 long int sectorSize, shortSectorSize;
29 long int bbdNumBlocks;
30 unsigned char *BBD=NULL;
32 long int sbdNumber, sbdStart, sbdLen;
33 unsigned char *SBD=NULL;
34 oleEntry *rootEntry=NULL;
36 long propCurNumber, propLen, propNumber, propStart;
37 unsigned char *properties=NULL;
38 long int fileLength=0;
40 char ole_sign[]={0xD0,0xCF,0x11,0xE0,0xA1,0xB1,0x1A,0xE1,0};
41 char zip_sign[]="PK\003\004";
44 * Initializes ole structure
46 * @param f (FILE *) compound document file, positioned at bufSize
47 * byte. Might be pipe or socket
48 * @param buffer (void *) bytes already read from f
49 * @param bufSize number of bytes already read from f should be less
54 FILE* ole_init(FILE *f, void *buffer, size_t bufSize) {
55 unsigned char oleBuf[BBD_BLOCK_SIZE];
56 unsigned char *tmpBuf;
59 long int sbdMaxLen, sbdCurrent, propMaxLen, propCurrent, mblock, msat_size;
62 /* deleting old data (if it was allocated) */
65 if (fseek(f,0,SEEK_SET) == -1) {
66 if ( errno == ESPIPE ) {
67 /* We got non-seekable file, create temp file */
68 if((newfile=tmpfile()) == NULL) {
69 perror("Can't create tmp file");
73 ret=fwrite(buffer, 1, bufSize, newfile);
75 perror("Can't write to tmp file");
81 ret=fread(oleBuf,1,BBD_BLOCK_SIZE,f);
82 fwrite(oleBuf, 1, ret, newfile);
84 fseek(newfile,0,SEEK_SET);
86 perror("Can't seek in file");
92 fseek(newfile,0,SEEK_END);
93 fileLength=ftell(newfile);
94 /* fprintf(stderr, "fileLength=%ld\n", fileLength); */
95 fseek(newfile,0,SEEK_SET);
96 ret=fread(oleBuf,1,BBD_BLOCK_SIZE,newfile);
97 if ( ret != BBD_BLOCK_SIZE ) {
100 if (strncmp((char *)&oleBuf,zip_sign,4) == 0) {
101 fprintf(stderr,"Looks like ZIP archive or Office 2007 or later. Not supported\n");
103 } else if (strncmp((char *)&oleBuf,ole_sign,8) != 0) {
106 sectorSize = 1<<getshort(oleBuf,0x1e);
107 shortSectorSize=1<<getshort(oleBuf,0x20);
109 /* Read BBD into memory */
110 bbdNumBlocks = getulong(oleBuf,0x2c);
111 if((BBD=malloc(bbdNumBlocks*sectorSize)) == NULL ) {
115 if((tmpBuf=malloc(MSAT_ORIG_SIZE)) == NULL ) {
118 memcpy(tmpBuf,oleBuf+0x4c,MSAT_ORIG_SIZE);
119 mblock=getlong(oleBuf,0x44);
120 msat_size=getlong(oleBuf,0x48);
122 /* fprintf(stderr, "msat_size=%ld\n", msat_size); */
125 while((mblock >= 0) && (i < msat_size)) {
126 unsigned char *newbuf;
127 /* fprintf(stderr, "i=%d mblock=%ld\n", i, mblock); */
128 if ((newbuf=realloc(tmpBuf, sectorSize*(i+1)+MSAT_ORIG_SIZE)) != NULL) {
131 perror("MSAT realloc error");
137 fseek(newfile, 512+mblock*sectorSize, SEEK_SET);
138 if(fread(tmpBuf+MSAT_ORIG_SIZE+(sectorSize-4)*i,
139 1, sectorSize, newfile) != sectorSize) {
140 fprintf(stderr, "Error read MSAT!\n");
146 mblock=getlong(tmpBuf, MSAT_ORIG_SIZE+(sectorSize-4)*i);
149 /* fprintf(stderr, "bbdNumBlocks=%ld\n", bbdNumBlocks); */
150 for(i=0; i< bbdNumBlocks; i++) {
151 long int bbdSector=getlong(tmpBuf,4*i);
153 if (bbdSector >= fileLength/sectorSize || bbdSector < 0) {
154 fprintf(stderr, "Bad BBD entry!\n");
158 fseek(newfile, 512+bbdSector*sectorSize, SEEK_SET);
159 if ( fread(BBD+i*sectorSize, 1, sectorSize, newfile) != sectorSize ) {
160 fprintf(stderr, "Can't read BBD!\n");
168 /* Read SBD into memory */
171 sbdCurrent = sbdStart = getlong(oleBuf,0x3c);
173 if((SBD=malloc(sectorSize*sbdMaxLen)) == NULL ) {
178 fseek(newfile, 512+sbdCurrent*sectorSize, SEEK_SET);
179 fread(SBD+sbdLen*sectorSize, 1, sectorSize, newfile);
181 if (sbdLen >= sbdMaxLen) {
182 unsigned char *newSBD;
185 if ((newSBD=realloc(SBD, sectorSize*sbdMaxLen)) != NULL) {
188 perror("SBD realloc error");
193 sbdCurrent = getlong(BBD, sbdCurrent*4);
195 sbdCurrent >= fileLength/sectorSize)
198 sbdNumber = (sbdLen*sectorSize)/shortSectorSize;
199 /* fprintf(stderr, "sbdLen=%ld sbdNumber=%ld\n",sbdLen, sbdNumber); */
203 /* Read property catalog into memory */
206 propCurrent = propStart = getlong(oleBuf,0x30);
207 if (propStart >= 0) {
208 if((properties=malloc(propMaxLen*sectorSize)) == NULL ) {
213 /* fprintf(stderr, "propCurrent=%ld\n",propCurrent); */
214 fseek(newfile, 512+propCurrent*sectorSize, SEEK_SET);
215 fread(properties+propLen*sectorSize,
216 1, sectorSize, newfile);
218 if (propLen >= propMaxLen) {
219 unsigned char *newProp;
222 if ((newProp=realloc(properties, propMaxLen*sectorSize)) != NULL)
225 perror("Properties realloc error");
231 propCurrent = getlong(BBD, propCurrent*4);
232 if(propCurrent < 0 ||
233 propCurrent >= fileLength/sectorSize ) {
237 /* fprintf(stderr, "propLen=%ld\n",propLen); */
238 propNumber = (propLen*sectorSize)/PROP_BLOCK_SIZE;
247 /* Find Root Entry */
248 while((tEntry=(oleEntry*)ole_readdir(newfile)) != NULL) {
249 if (tEntry->type == oleRootDir ) {
253 ole_close((FILE*)tEntry);
256 fseek(newfile, 0, SEEK_SET);
258 fprintf(stderr,"Broken OLE structure. Cannot find root entry in this file!\n"); ole_finish();
271 int rightOleType(unsigned char *oleBuf) {
272 return (oleBuf[0x42] == 1 || oleBuf[0x42] == 2 ||
273 oleBuf[0x42] == 3 || oleBuf[0x42] == 5 );
283 oleType getOleType(unsigned char *oleBuf) {
284 return (oleType)((unsigned char)oleBuf[0x42]);
288 * Reads next directory entry from file
290 * @param name buffer for name converted to us-ascii should be at least 33 chars long
291 * @param size size of file
293 * @return 0 if everything is ok -1 on error
295 FILE *ole_readdir(FILE *f) {
297 unsigned char *oleBuf;
299 long int chainMaxLen, chainCurrent;
301 if ( properties == NULL || propCurNumber >= propNumber || f == NULL )
303 oleBuf=properties + propCurNumber*PROP_BLOCK_SIZE;
304 if( !rightOleType(oleBuf))
306 if ((e = (oleEntry*)malloc(sizeof(oleEntry))) == NULL) {
307 perror("Can\'t allocate memory");
311 e->type=getOleType(oleBuf);
313 e->startBlock=getlong(oleBuf,0x74);
316 nLen=getshort(oleBuf,0x40);
317 for (i=0 ; i < nLen /2; i++)
318 e->name[i]=(char)oleBuf[i*2];
321 e->length=getulong(oleBuf,0x78);
322 /* Read sector chain for object */
325 chainCurrent = e->startBlock;
326 e->isBigBlock = (e->length >= 0x1000) || !strcmp(e->name, "Root Entry");
327 /* fprintf(stderr, "e->name=%s e->length=%ld\n", e->name, e->length); */
328 /* fprintf(stderr, "e->startBlock=%ld BBD=%p\n", e->startBlock, BBD); */
329 if (e->startBlock >= 0 &&
332 fileLength/(e->isBigBlock ? sectorSize : shortSectorSize))) {
333 if((e->blocks=malloc(chainMaxLen*sizeof(long int))) == NULL ) {
338 if(chainCurrent < 0 ||
341 ((bbdNumBlocks*sectorSize)/4) :
342 ((sbdNumber*shortSectorSize)/4)
352 /* fprintf(stderr, "chain End=%ld\n", chainCurrent); */
355 /* fprintf(stderr, "chainCurrent=%ld\n", chainCurrent); */
356 e->blocks[e->numOfBlocks++] = chainCurrent;
357 if (e->numOfBlocks >= chainMaxLen) {
360 if ((newChain=realloc(e->blocks,
361 chainMaxLen*sizeof(long int))) != NULL)
364 perror("Properties realloc error");
370 if ( e->isBigBlock ) {
371 chainCurrent = getlong(BBD, chainCurrent*4);
372 } else if ( SBD != NULL ) {
373 chainCurrent = getlong(SBD, chainCurrent*4);
380 if(e->length > (e->isBigBlock ? sectorSize : shortSectorSize)*e->numOfBlocks)
381 e->length = (e->isBigBlock ? sectorSize : shortSectorSize)*e->numOfBlocks;
382 /* fprintf(stderr, "READDIR: e->name=%s e->numOfBlocks=%ld length=%ld\n", */
383 /* e->name, e->numOfBlocks, e->length); */
389 * Open stream, which correspond to directory entry last read by
393 * @return opaque pointer to pass to ole_read, casted to (FILE *)
395 int ole_open(FILE *stream) {
396 oleEntry *e=(oleEntry *)stream;
397 if ( e->type != oleStream)
401 e->file_offset= ftell(e->file);
413 long int calcFileBlockOffset(oleEntry *e, long int blk) {
415 if ( e->isBigBlock ) {
416 res=512+e->blocks[blk]*sectorSize;
418 long int sbdPerSector=sectorSize/shortSectorSize;
419 long int sbdSecNum=e->blocks[blk]/sbdPerSector;
420 long int sbdSecMod=e->blocks[blk]%sbdPerSector;
421 /* fprintf(stderr, "calcoffset: e->name=%s e->numOfBlocks=%ld length=%ld sbdSecNum=%ld rootEntry->blocks=%p\n",
422 e->name, e->numOfBlocks, e->length, sbdSecNum, rootEntry->blocks);*/
423 res=512 + rootEntry->blocks[sbdSecNum]*sectorSize + sbdSecMod*shortSectorSize;
430 * Reads block from open ole stream interface-compatible with fread
432 * @param ptr pointer to buffer for read to
433 * @param size size of block
434 * @param nmemb size in blocks
435 * @param stream pointer to FILE* structure
437 * @return number of readed blocks
439 size_t ole_read(void *ptr, size_t size, size_t nmemb, FILE *stream) {
440 oleEntry *e = (oleEntry*)stream;
441 long int llen = size*nmemb, rread=0, i;
442 long int blockNumber, modBlock, toReadBlocks, toReadBytes, bytesInBlock;
443 long int ssize; /**< Size of block */
445 unsigned char *cptr = ptr;
446 if( e->ole_offset+llen > e->length )
447 llen= e->length - e->ole_offset;
449 ssize = (e->isBigBlock ? sectorSize : shortSectorSize);
450 blockNumber=e->ole_offset/ssize;
451 /* fprintf(stderr, "blockNumber=%ld e->numOfBlocks=%ld llen=%ld\n", */
452 /* blockNumber, e->numOfBlocks, llen); */
453 if ( blockNumber >= e->numOfBlocks || llen <=0 )
456 modBlock=e->ole_offset%ssize;
457 bytesInBlock = ssize - modBlock;
458 if(bytesInBlock < llen) {
459 toReadBlocks = (llen-bytesInBlock)/ssize;
460 toReadBytes = (llen-bytesInBlock)%ssize;
462 toReadBlocks = toReadBytes = 0;
464 /* fprintf(stderr, "llen=%ld toReadBlocks=%ld toReadBytes=%ld bytesInBlock=%ld blockNumber=%ld modBlock=%ld\n", */
465 /* llen, toReadBlocks, toReadBytes, bytesInBlock, blockNumber, modBlock); */
466 newoffset = calcFileBlockOffset(e,blockNumber)+modBlock;
467 if (e->file_offset != newoffset) {
468 fseek(e->file, e->file_offset=newoffset, SEEK_SET);
470 rread=fread(ptr, 1, min(llen,bytesInBlock), e->file);
471 e->file_offset += rread;
472 for(i=0; i<toReadBlocks; i++) {
475 newoffset = calcFileBlockOffset(e,blockNumber);
476 if (newoffset != e->file_offset);
477 fseek(e->file, e->file_offset=newoffset , SEEK_SET);
478 readbytes=fread(cptr+rread, 1, min(llen-rread, ssize), e->file);
480 e->file_offset +=readbytes;
482 if(toReadBytes > 0) {
485 newoffset = calcFileBlockOffset(e,blockNumber);
486 fseek(e->file, e->file_offset=newoffset, SEEK_SET);
487 readbytes=fread(cptr+rread, 1, toReadBytes,e ->file);
489 e->file_offset +=readbytes;
491 /* fprintf(stderr, "ole_offset=%ld rread=%ld llen=%ld\n",
492 e->ole_offset, rread, llen);*/
493 e->ole_offset+=rread;
504 int ole_eof(FILE *stream) {
505 oleEntry *e=(oleEntry*)stream;
506 /* fprintf(stderr, "EOF: e->ole_offset=%ld e->length=%ld\n",
507 e->ole_offset, e->length);*/
508 return (e->ole_offset >= e->length);
515 void ole_finish(void) {
516 if ( BBD != NULL ) free(BBD);
517 if ( SBD != NULL ) free(SBD);
518 if ( properties != NULL ) free(properties);
519 if ( rootEntry != NULL ) ole_close((FILE*)rootEntry);
520 properties = SBD = BBD = NULL;
531 int ole_close(FILE *stream) {
532 oleEntry *e=(oleEntry*)stream;
535 if (e->blocks != NULL)
544 * @param stream pointer to OLE stream structure
550 int ole_seek(FILE *stream, long offset, int whence) {
551 oleEntry *e=(oleEntry*)stream;
552 long int new_ole_offset=0, new_file_offset;
553 int ssize, modBlock, blockNumber;
557 new_ole_offset=offset;
561 new_ole_offset=e->ole_offset+offset;
565 new_ole_offset=e->length+offset;
574 if(new_ole_offset >= e->length)
575 new_ole_offset=e->length;
577 ssize = (e->isBigBlock ? sectorSize : shortSectorSize);
578 blockNumber=new_ole_offset/ssize;
579 if ( blockNumber >= e->numOfBlocks )
582 modBlock=new_ole_offset%ssize;
583 new_file_offset = calcFileBlockOffset(e,blockNumber)+modBlock;
584 fseek(e->file, e->file_offset=new_file_offset, SEEK_SET);
585 e->ole_offset=new_ole_offset;
591 * Tell position inside OLE stream
593 * @param stream pointer to OLE stream
595 * @return current position inside OLE stream
597 long ole_tell(FILE *stream) {
598 oleEntry *e=(oleEntry*)stream;
599 return e->ole_offset;
607 size_t (*catdoc_read)(void *ptr, size_t size, size_t nmemb, FILE *stream);
608 int (*catdoc_eof)(FILE *stream);
609 int (*catdoc_seek)(FILE *stream, long offset, int whence);
610 long (*catdoc_tell)(FILE *stream);
612 void set_ole_func(void) {
613 catdoc_read=ole_read;
615 catdoc_seek=ole_seek;
616 catdoc_tell=ole_tell;
620 /* feof is macro in Turbo C, so we need a real function to assign to
623 int my_feof(FILE *f) {
631 void set_std_func(void) {