examples/PIPS/antiword/src/datalist.c

/*
 * datalist.c
 * Copyright (C) 2000-2002 A.J. van Os; Released under GPL
 *
 * Description:
 * Build, read and destroy a list of Word data blocks
 */

#include <stdlib.h>
#include <errno.h>
#include "antiword.h"

#if defined(__riscos)
#define EIO             42
#endif /* __riscos */


/*
 * Private structure to hide the way the information
 * is stored from the rest of the program
 */
typedef struct data_mem_tag {
        data_block_type         tInfo;
        struct data_mem_tag     *pNext;
} data_mem_type;

/* Variable to describe the start of the data block list */
static data_mem_type    *pAnchor = NULL;
/* Variable needed to read the data block list */
static data_mem_type    *pBlockLast = NULL;
/* Variable needed to read the data block list */
static data_mem_type    *pBlockCurrent = NULL;
static ULONG    ulBlockOffset = 0;
static size_t   tByteNext = 0;
/* Last block read */
static UCHAR    aucBlock[BIG_BLOCK_SIZE];


/*
 * vDestroyDataBlockList - destroy the data block list
 */
void
vDestroyDataBlockList(void)
{
        data_mem_type   *pCurr, *pNext;

        DBG_MSG("vDestroyDataBlockList");

        pCurr = pAnchor;
        while (pCurr != NULL) {
                pNext = pCurr->pNext;
                pCurr = xfree(pCurr);
                pCurr = pNext;
        }
        pAnchor = NULL;
        /* Reset all the control variables */
        pBlockLast = NULL;
        pBlockCurrent = NULL;
        ulBlockOffset = 0;
        tByteNext = 0;
} /* end of vDestroyDataBlockList */

/*
 * bAdd2DataBlockList - add an element to the data block list
 *
 * Returns TRUE when successful, otherwise FALSE
 */
BOOL
bAdd2DataBlockList(const data_block_type *pDataBlock)
{
        data_mem_type   *pListMember;

        fail(pDataBlock == NULL);
        fail(pDataBlock->ulFileOffset == FC_INVALID);
        fail(pDataBlock->ulDataPos == CP_INVALID);
        fail(pDataBlock->ulLength == 0);

        NO_DBG_MSG("bAdd2DataBlockList");
        NO_DBG_HEX(pDataBlock->ulFileOffset);
        NO_DBG_HEX(pDataBlock->ulDataPos);
        NO_DBG_HEX(pDataBlock->ulLength);

        if (pDataBlock->ulFileOffset == FC_INVALID ||
            pDataBlock->ulDataPos == CP_INVALID ||
            pDataBlock->ulLength == 0) {
                werr(0, "Software (datablock) error");
                return FALSE;
        }
        /* Check for continuous blocks */
        if (pBlockLast != NULL &&
            pBlockLast->tInfo.ulFileOffset +
             pBlockLast->tInfo.ulLength == pDataBlock->ulFileOffset &&
            pBlockLast->tInfo.ulDataPos +
             pBlockLast->tInfo.ulLength == pDataBlock->ulDataPos) {
                /* These are continous blocks */
                pBlockLast->tInfo.ulLength += pDataBlock->ulLength;
                return TRUE;
        }
        /* Make a new block */
        pListMember = xmalloc(sizeof(data_mem_type));
        /* Add the block to the data list */
        pListMember->tInfo = *pDataBlock;
        pListMember->pNext = NULL;
        if (pAnchor == NULL) {
                pAnchor = pListMember;
        } else {
                fail(pBlockLast == NULL);
                pBlockLast->pNext = pListMember;
        }
        pBlockLast = pListMember;
        return TRUE;
} /* end of bAdd2DataBlockList */

/*
 * ulGetDataOffset - get the offset in the data block list
 *
 * Get the fileoffset the current position in the data block list
 */
ULONG
ulGetDataOffset(FILE *pFile)
{
        return pBlockCurrent->tInfo.ulFileOffset + ulBlockOffset + tByteNext;
} /* end of ulGetDataOffset */

/*
 * bSetDataOffset - set the offset in the data block list
 *
 * Make the given fileoffset the current position in the data block list
 */
BOOL
bSetDataOffset(FILE *pFile, ULONG ulFileOffset)
{
        data_mem_type   *pCurr;
        size_t  tReadLen;

        DBG_HEX(ulFileOffset);

        for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
                if (ulFileOffset < pCurr->tInfo.ulFileOffset ||
                    ulFileOffset >= pCurr->tInfo.ulFileOffset +
                     pCurr->tInfo.ulLength) {
                        /* The file offset is not in this block */
                        continue;
                }
                /* Compute the maximum number of bytes to read */
                tReadLen = (size_t)(pCurr->tInfo.ulFileOffset +
                                pCurr->tInfo.ulLength -
                                ulFileOffset);
                /* Compute the real number of bytes to read */
                if (tReadLen > sizeof(aucBlock)) {
                        tReadLen = sizeof(aucBlock);
                }
                /* Read the bytes */
                if (!bReadBytes(aucBlock, tReadLen, ulFileOffset, pFile)) {
                        return FALSE;
                }
                /* Set the control variables */
                pBlockCurrent = pCurr;
                ulBlockOffset = ulFileOffset - pCurr->tInfo.ulFileOffset;
                tByteNext = 0;
                return TRUE;
        }
        return FALSE;
} /* end of bSetDataOffset */

/*
 * iNextByte - get the next byte from the data block list
 */
int
iNextByte(FILE *pFile)
{
        ULONG   ulReadOff;
        size_t  tReadLen;

        fail(pBlockCurrent == NULL);

        if (tByteNext >= sizeof(aucBlock) ||
            ulBlockOffset + tByteNext >= pBlockCurrent->tInfo.ulLength) {
                if (ulBlockOffset + sizeof(aucBlock) <
                                        pBlockCurrent->tInfo.ulLength) {
                        /* Same block, next part */
                        ulBlockOffset += sizeof(aucBlock);
                } else {
                        /* Next block, first part */
                        pBlockCurrent = pBlockCurrent->pNext;
                        ulBlockOffset = 0;
                }
                if (pBlockCurrent == NULL) {
                        /* Past the last part of the last block */
                        errno = EIO;
                        return EOF;
                }
                tReadLen = (size_t)
                                (pBlockCurrent->tInfo.ulLength - ulBlockOffset);
                if (tReadLen > sizeof(aucBlock)) {
                        tReadLen = sizeof(aucBlock);
                }
                ulReadOff = pBlockCurrent->tInfo.ulFileOffset + ulBlockOffset;
                if (!bReadBytes(aucBlock, tReadLen, ulReadOff, pFile)) {
                        errno = EIO;
                        return EOF;
                }
                tByteNext = 0;
        }
        return (int)aucBlock[tByteNext++];
} /* end of iNextByte */

/*
 * usNextWord - get the next word from the data block list
 *
 * Read a two byte value in Little Endian order, that means MSB last
 *
 * All return values can be valid so errno is set in case of error
 */
USHORT
usNextWord(FILE *pFile)
{
        USHORT  usLSB, usMSB;

        usLSB = (USHORT)iNextByte(pFile);
        if (usLSB == (USHORT)EOF) {
                errno = EIO;
                return (USHORT)EOF;
        }
        usMSB = (USHORT)iNextByte(pFile);
        if (usMSB == (USHORT)EOF) {
                DBG_MSG("usNextWord: Unexpected EOF");
                errno = EIO;
                return (USHORT)EOF;
        }
        return (usMSB << 8) | usLSB;
} /* end of usNextWord */

/*
 * ulNextLong - get the next long from the data block list
 *
 * Read a four byte value in Little Endian order, that means MSW last
 *
 * All return values can be valid so errno is set in case of error
 */
ULONG
ulNextLong(FILE *pFile)
{
        ULONG   ulLSW, ulMSW;

        ulLSW = (ULONG)usNextWord(pFile);
        if (ulLSW == (ULONG)EOF) {
                errno = EIO;
                return (ULONG)EOF;
        }
        ulMSW = (ULONG)usNextWord(pFile);
        if (ulMSW == (ULONG)EOF) {
                DBG_MSG("ulNextLong: Unexpected EOF");
                errno = EIO;
                return (ULONG)EOF;
        }
        return (ulMSW << 16) | ulLSW;
} /* end of ulNextLong */

/*
 * usNextWordBE - get the next two byte value
 *
 * Read a two byte value in Big Endian order, that means MSB first
 *
 * All return values can be valid so errno is set in case of error
 */
USHORT
usNextWordBE(FILE *pFile)
{
        USHORT usLSB, usMSB;

        usMSB = (USHORT)iNextByte(pFile);
        if (usMSB == (USHORT)EOF) {
                errno = EIO;
                return (USHORT)EOF;
        }
        usLSB = (USHORT)iNextByte(pFile);
        if (usLSB == (USHORT)EOF) {
                DBG_MSG("usNextWordBE: Unexpected EOF");
                errno = EIO;
                return (USHORT)EOF;
        }
        return (usMSB << 8) | usLSB;
} /* end of usNextWordBE */

/*
 * ulNextLongBE - get the next four byte value
 *
 * Read a four byte value in Big Endian order, that means MSW first
 *
 * All return values can be valid so errno is set in case of error
 */
ULONG
ulNextLongBE(FILE *pFile)
{
        ULONG   ulLSW, ulMSW;

        ulMSW = (ULONG)usNextWordBE(pFile);
        if (ulMSW == (ULONG)EOF) {
                errno = EIO;
                return (ULONG)EOF;
        }
        ulLSW = (ULONG)usNextWordBE(pFile);
        if (ulLSW == (ULONG)EOF) {
                DBG_MSG("ulNextLongBE: Unexpected EOF");
                errno = EIO;
                return (ULONG)EOF;
        }
        return (ulMSW << 16) | ulLSW;
} /* end of ulNextLongBE */

/*
 * tSkipBytes - skip over the given number of bytes
 *
 * Returns the number of skipped bytes
 */
size_t
tSkipBytes(FILE *pFile, size_t tToSkip)
{
        size_t  tToGo, tMaxMove, tMove;

        fail(pFile == NULL);
        fail(pBlockCurrent == NULL);

        tToGo = tToSkip;
        while (tToGo != 0) {
                /* Goto the end of the current block */
                tMaxMove = min(sizeof(aucBlock) - tByteNext,
                                (size_t)(pBlockCurrent->tInfo.ulLength -
                                ulBlockOffset - tByteNext));
                tMove = min(tMaxMove, tToGo);
                tByteNext += tMove;
                tToGo -= tMove;
                if (tToGo != 0) {
                        /* Goto the next block */
                        if (iNextByte(pFile) == EOF) {
                                return tToSkip - tToGo;
                        }
                        tToGo--;
                }
        }
        return tToSkip;
} /* end of tSkipBytes */

/*
 * Translate  a data position to an offset in the file.
 * Logical to physical offset.
 *
 * Returns:     FC_INVALID: in case of error
 *              otherwise: the computed file offset
 */
ULONG
ulDataPos2FileOffset(ULONG ulDataPos)
{
        data_mem_type   *pCurr;

        fail(ulDataPos == CP_INVALID);

        for (pCurr = pAnchor; pCurr != NULL; pCurr = pCurr->pNext) {
                if (ulDataPos < pCurr->tInfo.ulDataPos ||
                    ulDataPos >= pCurr->tInfo.ulDataPos +
                     pCurr->tInfo.ulLength) {
                        /* The data offset is not in this block, try the next */
                        continue;
                }
                /* The data offset is in the current block */
                return pCurr->tInfo.ulFileOffset +
                                ulDataPos -
                                pCurr->tInfo.ulDataPos;
        }
        /* Passed beyond the end of the list */
        DBG_HEX_C(ulDataPos != 0, ulDataPos);
        return FC_INVALID;
} /* end of ulDataPos2FileOffset */

---