3 * @author Alex Ott, Victor B Wagner
4 * @date Wed Jun 11 12:33:01 2003
5 * Version: $Id: ole.c,v 1.1 2006-02-24 17:44:06 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 static unsigned char ole_sign[]={0xD0,0xCF,0x11,0xE0,0xA1,0xB1,0x1A,0xE1,0};
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(oleBuf,ole_sign,8) != 0) {
103 sectorSize = 1<<getshort(oleBuf,0x1e);
104 shortSectorSize=1<<getshort(oleBuf,0x20);
106 /* Read BBD into memory */
107 bbdNumBlocks = getulong(oleBuf,0x2c);
108 if((BBD=malloc(bbdNumBlocks*sectorSize)) == NULL ) {
112 if((tmpBuf=malloc(MSAT_ORIG_SIZE)) == NULL ) {
115 memcpy(tmpBuf,oleBuf+0x4c,MSAT_ORIG_SIZE);
116 mblock=getlong(oleBuf,0x44);
117 msat_size=getlong(oleBuf,0x48);
119 /* fprintf(stderr, "msat_size=%ld\n", msat_size); */
122 while((mblock >= 0) && (i < msat_size)) {
123 unsigned char *newbuf;
124 /* fprintf(stderr, "i=%d mblock=%ld\n", i, mblock); */
125 if ((newbuf=realloc(tmpBuf, sectorSize*(i+1)+MSAT_ORIG_SIZE)) != NULL) {
128 perror("MSAT realloc error");
134 fseek(newfile, 512+mblock*sectorSize, SEEK_SET);
135 if(fread(tmpBuf+MSAT_ORIG_SIZE+(sectorSize-4)*i,
136 1, sectorSize, newfile) != sectorSize) {
137 fprintf(stderr, "Error read MSAT!\n");
143 mblock=getlong(tmpBuf, MSAT_ORIG_SIZE+(sectorSize-4)*i);
146 /* fprintf(stderr, "bbdNumBlocks=%ld\n", bbdNumBlocks); */
147 for(i=0; i< bbdNumBlocks; i++) {
148 long int bbdSector=getlong(tmpBuf,4*i);
150 if (bbdSector >= fileLength/sectorSize || bbdSector < 0) {
151 fprintf(stderr, "Bad BBD entry!\n");
155 fseek(newfile, 512+bbdSector*sectorSize, SEEK_SET);
156 if ( fread(BBD+i*sectorSize, 1, sectorSize, newfile) != sectorSize ) {
157 fprintf(stderr, "Can't read BBD!\n");
165 /* Read SBD into memory */
168 sbdCurrent = sbdStart = getlong(oleBuf,0x3c);
170 if((SBD=malloc(sectorSize*sbdMaxLen)) == NULL ) {
175 fseek(newfile, 512+sbdCurrent*sectorSize, SEEK_SET);
176 fread(SBD+sbdLen*sectorSize, 1, sectorSize, newfile);
178 if (sbdLen >= sbdMaxLen) {
179 unsigned char *newSBD;
182 if ((newSBD=realloc(SBD, sectorSize*sbdMaxLen)) != NULL) {
185 perror("SBD realloc error");
190 sbdCurrent = getlong(BBD, sbdCurrent*4);
192 sbdCurrent >= fileLength/sectorSize)
195 sbdNumber = (sbdLen*sectorSize)/shortSectorSize;
196 /* fprintf(stderr, "sbdLen=%ld sbdNumber=%ld\n",sbdLen, sbdNumber); */
200 /* Read property catalog into memory */
203 propCurrent = propStart = getlong(oleBuf,0x30);
204 if (propStart >= 0) {
205 if((properties=malloc(propMaxLen*sectorSize)) == NULL ) {
210 /* fprintf(stderr, "propCurrent=%ld\n",propCurrent); */
211 fseek(newfile, 512+propCurrent*sectorSize, SEEK_SET);
212 fread(properties+propLen*sectorSize,
213 1, sectorSize, newfile);
215 if (propLen >= propMaxLen) {
216 unsigned char *newProp;
219 if ((newProp=realloc(properties, propMaxLen*sectorSize)) != NULL)
222 perror("Properties realloc error");
228 propCurrent = getlong(BBD, propCurrent*4);
229 if(propCurrent < 0 ||
230 propCurrent >= fileLength/sectorSize ) {
234 /* fprintf(stderr, "propLen=%ld\n",propLen); */
235 propNumber = (propLen*sectorSize)/PROP_BLOCK_SIZE;
244 /* Find Root Entry */
245 while((tEntry=(oleEntry*)ole_readdir(newfile)) != NULL) {
246 if (!tEntry->name[0]||strcmp(tEntry->name,"Root Entry") == 0) {
250 ole_close((FILE*)tEntry);
253 fseek(newfile, 0, SEEK_SET);
255 fprintf(stderr,"Cannot find root entry in this file!\n");
269 int rightOleType(unsigned char *oleBuf) {
270 return (oleBuf[0x42] == 1 || oleBuf[0x42] == 2 ||
271 oleBuf[0x42] == 3 || oleBuf[0x42] == 5 );
281 oleType getOleType(unsigned char *oleBuf) {
282 return (oleType)((unsigned char)oleBuf[0x42]);
286 * Reads next directory entry from file
288 * @param name buffer for name converted to us-ascii should be at least 33 chars long
289 * @param size size of file
291 * @return 0 if everything is ok -1 on error
293 FILE *ole_readdir(FILE *f) {
295 unsigned char *oleBuf;
297 long int chainMaxLen, chainCurrent;
299 if ( properties == NULL || propCurNumber >= propNumber || f == NULL )
301 oleBuf=properties + propCurNumber*PROP_BLOCK_SIZE;
302 if( !rightOleType(oleBuf))
304 if ((e = (oleEntry*)malloc(sizeof(oleEntry))) == NULL) {
305 perror("Can\'t allocate memory");
309 e->type=getOleType(oleBuf);
311 e->startBlock=getlong(oleBuf,0x74);
314 nLen=getshort(oleBuf,0x40);
315 for (i=0 ; i < nLen /2; i++)
316 e->name[i]=(char)oleBuf[i*2];
319 e->length=getulong(oleBuf,0x78);
320 /* Read sector chain for object */
323 chainCurrent = e->startBlock;
324 e->isBigBlock = (e->length >= 0x1000) || !strcmp(e->name, "Root Entry");
325 /* fprintf(stderr, "e->name=%s e->length=%ld\n", e->name, e->length); */
326 /* fprintf(stderr, "e->startBlock=%ld BBD=%p\n", e->startBlock, BBD); */
327 if (e->startBlock >= 0 &&
330 fileLength/(e->isBigBlock ? sectorSize : shortSectorSize))) {
331 if((e->blocks=malloc(chainMaxLen*sizeof(long int))) == NULL ) {
335 /* fprintf(stderr, "chainCurrent=%ld\n", chainCurrent); */
336 e->blocks[e->numOfBlocks++] = chainCurrent;
337 if (e->numOfBlocks >= chainMaxLen) {
340 if ((newChain=realloc(e->blocks,
341 chainMaxLen*sizeof(long int))) != NULL)
344 perror("Properties realloc error");
350 if ( e->isBigBlock ) {
351 chainCurrent = getlong(BBD, chainCurrent*4);
352 } else if ( SBD != NULL ) {
353 chainCurrent = getlong(SBD, chainCurrent*4);
357 if(chainCurrent <= 0 ||
358 chainCurrent >= ( e->isBigBlock ?
359 ((bbdNumBlocks*sectorSize)/4)
360 : ((sbdNumber*shortSectorSize)/4) ) ||
362 e->length/(e->isBigBlock ? sectorSize : shortSectorSize))) {
363 /* fprintf(stderr, "chain End=%ld\n", chainCurrent); */
369 if(e->length > (e->isBigBlock ? sectorSize : shortSectorSize)*e->numOfBlocks)
370 e->length = (e->isBigBlock ? sectorSize : shortSectorSize)*e->numOfBlocks;
371 /* fprintf(stderr, "READDIR: e->name=%s e->numOfBlocks=%ld length=%ld\n", */
372 /* e->name, e->numOfBlocks, e->length); */
378 * Open stream, which correspond to directory entry last read by
382 * @return opaque pointer to pass to ole_read, casted to (FILE *)
384 int ole_open(FILE *stream) {
385 oleEntry *e=(oleEntry *)stream;
386 if ( e->type != oleStream)
390 e->file_offset= ftell(e->file);
402 long int calcFileBlockOffset(oleEntry *e, long int blk) {
404 if ( e->isBigBlock ) {
405 res=512+e->blocks[blk]*sectorSize;
407 long int sbdPerSector=sectorSize/shortSectorSize;
408 long int sbdSecNum=e->blocks[blk]/sbdPerSector;
409 long int sbdSecMod=e->blocks[blk]%sbdPerSector;
410 /* fprintf(stderr, "calcoffset: e->name=%s e->numOfBlocks=%ld length=%ld sbdSecNum=%ld rootEntry->blocks=%p\n",
411 e->name, e->numOfBlocks, e->length, sbdSecNum, rootEntry->blocks);*/
412 res=512 + rootEntry->blocks[sbdSecNum]*sectorSize + sbdSecMod*shortSectorSize;
419 * Reads block from open ole stream interface-compatible with fread
421 * @param ptr pointer to buffer for read to
422 * @param size size of block
423 * @param nmemb size in blocks
424 * @param stream pointer to FILE* structure
426 * @return number of readed blocks
428 size_t ole_read(void *ptr, size_t size, size_t nmemb, FILE *stream) {
429 oleEntry *e = (oleEntry*)stream;
430 long int llen = size*nmemb, rread=0, i;
431 long int blockNumber, modBlock, toReadBlocks, toReadBytes, bytesInBlock;
432 long int ssize; /**< Size of block */
434 unsigned char *cptr = ptr;
435 if( e->ole_offset+llen > e->length )
436 llen= e->length - e->ole_offset;
438 ssize = (e->isBigBlock ? sectorSize : shortSectorSize);
439 blockNumber=e->ole_offset/ssize;
440 /* fprintf(stderr, "blockNumber=%ld e->numOfBlocks=%ld llen=%ld\n", */
441 /* blockNumber, e->numOfBlocks, llen); */
442 if ( blockNumber >= e->numOfBlocks || llen <=0 )
445 modBlock=e->ole_offset%ssize;
446 bytesInBlock = ssize - modBlock;
447 if(bytesInBlock < llen) {
448 toReadBlocks = (llen-bytesInBlock)/ssize;
449 toReadBytes = (llen-bytesInBlock)%ssize;
451 toReadBlocks = toReadBytes = 0;
453 /* fprintf(stderr, "llen=%ld toReadBlocks=%ld toReadBytes=%ld bytesInBlock=%ld blockNumber=%ld modBlock=%ld\n", */
454 /* llen, toReadBlocks, toReadBytes, bytesInBlock, blockNumber, modBlock); */
455 newoffset = calcFileBlockOffset(e,blockNumber)+modBlock;
456 if (e->file_offset != newoffset) {
457 fseek(e->file, e->file_offset=newoffset, SEEK_SET);
459 rread=fread(ptr, 1, min(llen,bytesInBlock), e->file);
460 e->file_offset += rread;
461 for(i=0; i<toReadBlocks; i++) {
464 newoffset = calcFileBlockOffset(e,blockNumber);
465 if (newoffset != e->file_offset);
466 fseek(e->file, e->file_offset=newoffset , SEEK_SET);
467 readbytes=fread(cptr+rread, 1, min(llen-rread, ssize), e->file);
469 e->file_offset +=readbytes;
471 if(toReadBytes > 0) {
474 newoffset = calcFileBlockOffset(e,blockNumber);
475 fseek(e->file, e->file_offset=newoffset, SEEK_SET);
476 readbytes=fread(cptr+rread, 1, toReadBytes,e ->file);
478 e->file_offset +=readbytes;
480 /* fprintf(stderr, "ole_offset=%ld rread=%ld llen=%ld\n",
481 e->ole_offset, rread, llen);*/
482 e->ole_offset+=rread;
493 int ole_eof(FILE *stream) {
494 oleEntry *e=(oleEntry*)stream;
495 /* fprintf(stderr, "EOF: e->ole_offset=%ld e->length=%ld\n",
496 e->ole_offset, e->length);*/
497 return (e->ole_offset >= e->length);
504 void ole_finish(void) {
505 if ( BBD != NULL ) free(BBD);
506 if ( SBD != NULL ) free(SBD);
507 if ( properties != NULL ) free(properties);
508 if ( rootEntry != NULL ) ole_close((FILE*)rootEntry);
509 properties = SBD = BBD = NULL;
520 int ole_close(FILE *stream) {
521 oleEntry *e=(oleEntry*)stream;
524 if (e->blocks != NULL)
533 * @param stream pointer to OLE stream structure
539 int ole_seek(FILE *stream, long offset, int whence) {
540 oleEntry *e=(oleEntry*)stream;
541 long int new_ole_offset=0, new_file_offset;
542 int ssize, modBlock, blockNumber;
546 new_ole_offset=offset;
550 new_ole_offset=e->ole_offset+offset;
554 new_ole_offset=e->length+offset;
563 if(new_ole_offset >= e->length)
564 new_ole_offset=e->length;
566 ssize = (e->isBigBlock ? sectorSize : shortSectorSize);
567 blockNumber=new_ole_offset/ssize;
568 if ( blockNumber >= e->numOfBlocks )
571 modBlock=new_ole_offset%ssize;
572 new_file_offset = calcFileBlockOffset(e,blockNumber)+modBlock;
573 fseek(e->file, e->file_offset=new_file_offset, SEEK_SET);
574 e->ole_offset=new_ole_offset;
580 * Tell position inside OLE stream
582 * @param stream pointer to OLE stream
584 * @return current position inside OLE stream
586 long ole_tell(FILE *stream) {
587 oleEntry *e=(oleEntry*)stream;
588 return e->ole_offset;
596 size_t (*catdoc_read)(void *ptr, size_t size, size_t nmemb, FILE *stream);
597 int (*catdoc_eof)(FILE *stream);
598 int (*catdoc_seek)(FILE *stream, long offset, int whence);
599 long (*catdoc_tell)(FILE *stream);
601 void set_ole_func(void) {
602 catdoc_read=ole_read;
604 catdoc_seek=ole_seek;
605 catdoc_tell=ole_tell;
609 /* feof is macro in Turbo C, so we need a real function to assign to
612 int my_feof(FILE *f) {
620 void set_std_func(void) {