A couple of places where a string is overrun. This fixes both of them.

2 files changed, 5 insertions, 4 deletions

diff --git a/noncore/apps/opie-reader/chm_lib.c b/noncore/apps/opie-reader/chm_lib.c
index ecf8278..7acd1d2 100644
--- a/noncore/apps/opie-reader/chm_lib.c
+++ b/noncore/apps/opie-reader/chm_lib.c
@@ -579,1298 +579,1299 @@ static int _unmarshal_lzxc_control_data(unsigned char **pData,
     if (*pDataLen >= _CHM_LZXC_V2_LEN)
         _unmarshal_uint32    (pData, pDataLen, &dest->unknown_18);
     else
         dest->unknown_18 = 0;
 
     if (dest->version == 2)
     {
         dest->resetInterval *= 0x8000;
         dest->windowSize *= 0x8000;
         dest->unknown_14 *= 0x8000;
     }
     if (dest->windowSize == 0  ||  dest->resetInterval == 0)
         return 0;
 
     /* for now, only support resetInterval a multiple of windowSize/2 */
     if (dest->windowSize == 1)
         return 0;
     if ((dest->resetInterval % (dest->windowSize/2)) != 0)
         return 0;
 
     /* check structure */
     if (memcmp(dest->signature, "LZXC", 4) != 0)
         return 0;
 
     return 1;
 }
 
 /* the structure used for chm file handles */
 struct chmFile
 {
 #ifdef WIN32
     HANDLE              fd;
 #else
     int                 fd;
 #endif
 
 #ifdef CHM_MT
 #ifdef WIN32
     CRITICAL_SECTION    mutex;
     CRITICAL_SECTION    lzx_mutex;
     CRITICAL_SECTION    cache_mutex;
 #else
     pthread_mutex_t     mutex;
     pthread_mutex_t     lzx_mutex;
     pthread_mutex_t     cache_mutex;
 #endif
 #endif
 
     UInt64              dir_offset;
     UInt64              dir_len;    
     UInt64              data_offset;
     Int32               index_root;
     Int32               index_head;
     UInt32              block_len;     
 
     UInt64              span;
     struct chmUnitInfo  rt_unit;
     struct chmUnitInfo  cn_unit;
     struct chmLzxcResetTable reset_table;
 
     /* LZX control data */
     UInt32              window_size;
     UInt32              reset_interval;
     UInt32              reset_blkcount;
 
     /* decompressor state */
     struct LZXstate    *lzx_state;
     int                 lzx_last_block;
 
     /* cache for decompressed blocks */
     UChar             **cache_blocks;
     Int64              *cache_block_indices;
     Int32               cache_num_blocks;
 };
 
 /*
  * utility functions local to this module
  */
 
 /* utility function to handle differences between {pread,read}(64)? */
 static Int64 _chm_fetch_bytes(struct chmFile *h,
                               UChar *buf,
                               UInt64 os,
                               Int64 len)
 {
     Int64 readLen=0, oldOs=0;
     if (h->fd  ==  CHM_NULL_FD)
         return readLen;
 
     CHM_ACQUIRE_LOCK(h->mutex);
 #ifdef CHM_USE_WIN32IO
     /* NOTE: this might be better done with CreateFileMapping, et cetera... */
     {
         DWORD origOffsetLo=0, origOffsetHi=0;
         DWORD offsetLo, offsetHi;
         DWORD actualLen=0;
 
         /* awkward Win32 Seek/Tell */
         offsetLo = (unsigned long)(os & 0xffffffffL);
         offsetHi = (unsigned long)((os >> 32) & 0xffffffffL);
         origOffsetLo = SetFilePointer(h->fd, 0, &origOffsetHi, FILE_CURRENT);
         offsetLo = SetFilePointer(h->fd, offsetLo, &offsetHi, FILE_BEGIN);
 
         /* read the data */
         if (ReadFile(h->fd,
                      buf,
                      (DWORD)len,
                      &actualLen,
                      NULL) == TRUE)
             readLen = actualLen;
         else
             readLen = 0;
 
         /* restore original position */
         SetFilePointer(h->fd, origOffsetLo, &origOffsetHi, FILE_BEGIN);
     }
 #else
 #ifdef CHM_USE_PREAD
 #ifdef CHM_USE_IO64
     readLen = pread64(h->fd, buf, (long)len, os);
 #else
     readLen = pread(h->fd, buf, (long)len, (unsigned long)os);
 #endif
 #else
 #ifdef CHM_USE_IO64
     oldOs = lseek64(h->fd, 0, SEEK_CUR);
     lseek64(h->fd, os, SEEK_SET);
     readLen = read(h->fd, buf, len);
     lseek64(h->fd, oldOs, SEEK_SET);
 #else
     oldOs = lseek(h->fd, 0, SEEK_CUR);
     lseek(h->fd, (long)os, SEEK_SET);
     readLen = read(h->fd, buf, len);
     lseek(h->fd, (long)oldOs, SEEK_SET);
 #endif
 #endif
 #endif
     CHM_RELEASE_LOCK(h->mutex);
     return readLen;
 }
 
 /* open an ITS archive */
 struct chmFile *chm_open(const char *filename)
 {
     unsigned char               sbuffer[256];
     unsigned long               sremain;
     unsigned char              *sbufpos;
     struct chmFile             *newHandle=NULL;
     struct chmItsfHeader        itsfHeader;
     struct chmItspHeader        itspHeader;
     struct chmUnitInfo          uiSpan;
     struct chmUnitInfo          uiLzxc;
     struct chmLzxcControlData   ctlData;
 
     /* allocate handle */
     newHandle = (struct chmFile *)malloc(sizeof(struct chmFile));
     newHandle->fd = CHM_NULL_FD;
     newHandle->lzx_state = NULL;
     newHandle->cache_blocks = NULL;
     newHandle->cache_block_indices = NULL;
     newHandle->cache_num_blocks = 0;
 
     /* open file */
 #ifdef WIN32
     if ((newHandle->fd=CreateFileA(filename,
                                    GENERIC_READ,
                                    0,
                                    NULL,
                                    OPEN_EXISTING,
                                    FILE_ATTRIBUTE_NORMAL,
                                    NULL)) == CHM_NULL_FD)
     {
         free(newHandle);
         return NULL;
     }
 #else
     if ((newHandle->fd=open(filename, O_RDONLY)) == CHM_NULL_FD)
     {
         free(newHandle);
         return NULL;
     }
 #endif
 
     /* initialize mutexes, if needed */
 #ifdef CHM_MT
 #ifdef WIN32
     InitializeCriticalSection(&newHandle->mutex);
     InitializeCriticalSection(&newHandle->lzx_mutex);
     InitializeCriticalSection(&newHandle->cache_mutex);
 #else
     pthread_mutex_init(&newHandle->mutex, NULL);
     pthread_mutex_init(&newHandle->lzx_mutex, NULL);
     pthread_mutex_init(&newHandle->cache_mutex, NULL);
 #endif
 #endif
 
     /* read and verify header */
     sremain = _CHM_ITSF_V3_LEN;
     sbufpos = sbuffer;
     if (_chm_fetch_bytes(newHandle, sbuffer, (UInt64)0, sremain) != sremain    ||
         !_unmarshal_itsf_header(&sbufpos, &sremain, &itsfHeader))
     {
         chm_close(newHandle);
         return NULL;
     }
 
     /* stash important values from header */
     newHandle->dir_offset  = itsfHeader.dir_offset;
     newHandle->dir_len     = itsfHeader.dir_len;
     newHandle->data_offset = itsfHeader.data_offset;
 
     /* now, read and verify the directory header chunk */
     sremain = _CHM_ITSP_V1_LEN;
     sbufpos = sbuffer;
     if (_chm_fetch_bytes(newHandle, sbuffer,
                          (UInt64)itsfHeader.dir_offset, sremain) != sremain       ||
         !_unmarshal_itsp_header(&sbufpos, &sremain, &itspHeader))
     {
         chm_close(newHandle);
         return NULL;
     }
 
     /* grab essential information from ITSP header */
     newHandle->dir_offset += itspHeader.header_len;
     newHandle->dir_len    -= itspHeader.header_len;
     newHandle->index_root  = itspHeader.index_root;
     newHandle->index_head  = itspHeader.index_head;
     newHandle->block_len   = itspHeader.block_len;
 
     /* if the index root is -1, this means we don't have any PMGI blocks.
      * as a result, we must use the sole PMGL block as the index root
      */
     if (newHandle->index_root == -1)
         newHandle->index_root = newHandle->index_head;
 
     /* prefetch most commonly needed unit infos */
     if (CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
                                                   _CHMU_SPANINFO,
                                                   &uiSpan)                ||
         uiSpan.space == CHM_COMPRESSED                                    ||
         CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
                                                   _CHMU_RESET_TABLE,
                                                   &newHandle->rt_unit)    ||
         newHandle->rt_unit.space == CHM_COMPRESSED                        ||
         CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
                                                   _CHMU_CONTENT,
                                                   &newHandle->cn_unit)    ||
         newHandle->cn_unit.space == CHM_COMPRESSED                        ||
         CHM_RESOLVE_SUCCESS != chm_resolve_object(newHandle,
                                                   _CHMU_LZXC_CONTROLDATA,
                                                   &uiLzxc)                ||
         uiLzxc.space == CHM_COMPRESSED)
     {
         chm_close(newHandle);
         return NULL;
     }
 
     /* try to read span */
     /* N.B.: we've already checked that uiSpan is in the uncompressed section,
      *       so this should not require attempting to decompress, which may
      *       rely on having a valid "span"
      */
     sremain = 8;
     sbufpos = sbuffer;
     if (chm_retrieve_object(newHandle, &uiSpan, sbuffer,
                             0, sremain) != sremain                        ||
         !_unmarshal_uint64(&sbufpos, &sremain, &newHandle->span))
     {
         chm_close(newHandle);
         return NULL;
     }
 
     /* read reset table info */
     sremain = _CHM_LZXC_RESETTABLE_V1_LEN;
     sbufpos = sbuffer;
     if (chm_retrieve_object(newHandle, &newHandle->rt_unit, sbuffer,
                             0, sremain) != sremain                        ||
         !_unmarshal_lzxc_reset_table(&sbufpos, &sremain,
                                      &newHandle->reset_table))
     {
         chm_close(newHandle);
         return NULL;
     }
 
     /* read control data */
     sremain = (unsigned long)uiLzxc.length;
     sbufpos = sbuffer;
     if (chm_retrieve_object(newHandle, &uiLzxc, sbuffer,
                              0, sremain) != sremain                       ||
         !_unmarshal_lzxc_control_data(&sbufpos, &sremain,
                                       &ctlData))
     {
         chm_close(newHandle);
         return NULL;
     }
     newHandle->window_size = ctlData.windowSize;
     newHandle->reset_interval = ctlData.resetInterval;
     newHandle->reset_blkcount = newHandle->reset_interval /
                                (newHandle->window_size / 2);
 
     /* initialize cache */
     chm_set_param(newHandle, CHM_PARAM_MAX_BLOCKS_CACHED,
                   CHM_MAX_BLOCKS_CACHED);
 
     return newHandle;
 }
 
 /* close an ITS archive */
 void chm_close(struct chmFile *h)
 {
     if (h != NULL)
     {
         if (h->fd != CHM_NULL_FD)
             CHM_CLOSE_FILE(h->fd);
         h->fd = CHM_NULL_FD;
 
 #ifdef CHM_MT
 #ifdef WIN32
         DeleteCriticalSection(&h->mutex);
         DeleteCriticalSection(&h->lzx_mutex);
         DeleteCriticalSection(&h->cache_mutex);
 #else
         pthread_mutex_destroy(&h->mutex);
         pthread_mutex_destroy(&h->lzx_mutex);
         pthread_mutex_destroy(&h->cache_mutex);
 #endif
 #endif
 
         if (h->lzx_state)
             LZXteardown(h->lzx_state);
         h->lzx_state = NULL;
 
         if (h->cache_blocks)
         {
             int i;
             for (i=0; i<h->cache_num_blocks; i++)
             {
                 if (h->cache_blocks[i])
                     free(h->cache_blocks[i]);
             }
             free(h->cache_blocks);
             h->cache_blocks = NULL;
         }
 
         if (h->cache_block_indices)
             free(h->cache_block_indices);
         h->cache_block_indices = NULL;
 
         free(h);
     }
 }
 
 /*
  * set a parameter on the file handle.
  * valid parameter types:
  *          CHM_PARAM_MAX_BLOCKS_CACHED:
  *                 how many decompressed blocks should be cached?  A simple
  *                 caching scheme is used, wherein the index of the block is
  *                 used as a hash value, and hash collision results in the
  *                 invalidation of the previously cached block.
  */
 void chm_set_param(struct chmFile *h,
                    int paramType,
                    int paramVal)
 {
     switch (paramType)
     {
         case CHM_PARAM_MAX_BLOCKS_CACHED:
             CHM_ACQUIRE_LOCK(h->cache_mutex);
             if (paramVal != h->cache_num_blocks)
             {
                 UChar **newBlocks;
                 UInt64 *newIndices;
                 int     i;
 
                 /* allocate new cached blocks */
                 newBlocks = (UChar **)malloc(paramVal * sizeof (UChar *));
                 newIndices = (UInt64 *)malloc(paramVal * sizeof (UInt64));
                 for (i=0; i<paramVal; i++)
                 {
                     newBlocks[i] = NULL;
                     newIndices[i] = 0;
                 }
 
                 /* re-distribute old cached blocks */
                 if (h->cache_blocks)
                 {
                     for (i=0; i<h->cache_num_blocks; i++)
                     {
                         int newSlot = (int)(h->cache_block_indices[i] % paramVal);
 
                         if (h->cache_blocks[i])
                         {
                             /* in case of collision, destroy newcomer */
                             if (newBlocks[newSlot])
                             {
                                 free(h->cache_blocks[i]);
                                 h->cache_blocks[i] = NULL;
                             }
                             else
                             {
                                 newBlocks[newSlot] = h->cache_blocks[i];
                                 newIndices[newSlot] =
                                             h->cache_block_indices[i];
                             }
                         }
                     }
 
                     free(h->cache_blocks);
                     free(h->cache_block_indices);
                 }
 
                 /* now, set new values */
                 h->cache_blocks = newBlocks;
                 h->cache_block_indices = newIndices;
                 h->cache_num_blocks = paramVal;
             }
             CHM_RELEASE_LOCK(h->cache_mutex);
             break;
 
         default:
             break;
     }
 }
 
 /*
  * helper methods for chm_resolve_object
  */
 
 /* skip a compressed dword */
 static void _chm_skip_cword(UChar **pEntry)
 {
     while (*(*pEntry)++ >= 0x80)
         ;
 }
 
 /* skip the data from a PMGL entry */
 static void _chm_skip_PMGL_entry_data(UChar **pEntry)
 {
     _chm_skip_cword(pEntry);
     _chm_skip_cword(pEntry);
     _chm_skip_cword(pEntry);
 }
 
 /* parse a compressed dword */
 static UInt64 _chm_parse_cword(UChar **pEntry)
 {
     UInt64 accum = 0;
     UChar temp;
     while ((temp=*(*pEntry)++) >= 0x80)
     {
         accum <<= 7;
         accum += temp & 0x7f;
     }
 
     return (accum << 7) + temp;
 }
 
 /* parse a utf-8 string into an ASCII char buffer */
 static int _chm_parse_UTF8(UChar **pEntry, UInt64 count, char *path)
 {
     /* XXX: implement UTF-8 support, including a real mapping onto
      *      ISO-8859-1?  probably there is a library to do this?  As is
      *      immediately apparent from the below code, I'm only handling files
      *      in which none of the strings contain UTF-8 multi-byte characters.
      */
     while (count != 0)
     {
         if (*(*pEntry) > 0x7f)
             return 0;
 
         *path++ = (char)(*(*pEntry)++);
         --count;
     }
 
     *path = '\0';
     return 1;
 }
 
 /* parse a PMGL entry into a chmUnitInfo struct; return 1 on success. */
 static int _chm_parse_PMGL_entry(UChar **pEntry, struct chmUnitInfo *ui)
 {
     UInt64 strLen;
 
     /* parse str len */
     strLen = _chm_parse_cword(pEntry);
     if (strLen > CHM_MAX_PATHLEN)
         return 0;
 
     /* parse path */
     if (! _chm_parse_UTF8(pEntry, strLen, ui->path))
         return 0;
 
     /* parse info */
     ui->space  = (int)_chm_parse_cword(pEntry);
     ui->start  = _chm_parse_cword(pEntry);
     ui->length = _chm_parse_cword(pEntry);
     return 1;
 }
 
 /* find an exact entry in PMGL; return NULL if we fail */
 static UChar *_chm_find_in_PMGL(UChar *page_buf,
                          UInt32 block_len,
                          const char *objPath)
 {
     /* XXX: modify this to do a binary search using the nice index structure
      *      that is provided for us.
      */
     struct chmPmglHeader header;
     UInt32 hremain;
     UChar *end;
     UChar *cur;
     UChar *temp;
     UInt64 strLen;
     char buffer[CHM_MAX_PATHLEN+1];
 
     /* figure out where to start and end */
     cur = page_buf;
     hremain = _CHM_PMGL_LEN;
     if (! _unmarshal_pmgl_header(&cur, &hremain, &header))
         return NULL;
     end = page_buf + block_len - (header.free_space);
 
     /* now, scan progressively */
     while (cur < end)
     {
         /* grab the name */
         temp = cur;
         strLen = _chm_parse_cword(&cur);
         if (! _chm_parse_UTF8(&cur, strLen, buffer))
             return NULL;
 
         /* check if it is the right name */
 #ifdef WIN32
                 if (! stricmp(buffer, objPath))
                         return temp;
 #else
         if (! strcasecmp(buffer, objPath))
             return temp;
 #endif
 
         _chm_skip_PMGL_entry_data(&cur);
     }
 
     return NULL;
 }
 
 /* find which block should be searched next for the entry; -1 if no block */
 static Int32 _chm_find_in_PMGI(UChar *page_buf,
                         UInt32 block_len,
                         const char *objPath)
 {
     /* XXX: modify this to do a binary search using the nice index structure
      *      that is provided for us
      */
     struct chmPmgiHeader header;
     UInt32 hremain;
     int page=-1;
     UChar *end;
     UChar *cur;
     UInt64 strLen;
     char buffer[CHM_MAX_PATHLEN+1];
 
     /* figure out where to start and end */
     cur = page_buf;
     hremain = _CHM_PMGI_LEN;
     if (! _unmarshal_pmgi_header(&cur, &hremain, &header))
         return -1;
     end = page_buf + block_len - (header.free_space);
 
     /* now, scan progressively */
     while (cur < end)
     {
         /* grab the name */
         strLen = _chm_parse_cword(&cur);
         if (! _chm_parse_UTF8(&cur, strLen, buffer))
             return -1;
 
         /* check if it is the right name */
 #ifdef WIN32
         if (stricmp(buffer, objPath) > 0)
             return page;
 #else
         if (strcasecmp(buffer, objPath) > 0)
             return page;
 #endif
 
         /* load next value for path */
         page = (int)_chm_parse_cword(&cur);
     }
 
     return page;
 }
 
 /* resolve a particular object from the archive */
 int chm_resolve_object(struct chmFile *h,
                        const char *objPath,
                        struct chmUnitInfo *ui)
 {
     /*
      * XXX: implement caching scheme for dir pages
      */
 
     Int32 curPage;
 
     /* buffer to hold whatever page we're looking at */
 #ifdef WIN32
         UChar *page_buf = alloca(h->block_len);
 #else
     UChar page_buf[h->block_len];
 #endif
 
     /* starting page */
     curPage = h->index_root;
 
     /* until we have either returned or given up */
     while (curPage != -1)
     {
 
         /* try to fetch the index page */
         if (_chm_fetch_bytes(h, page_buf,
                              (UInt64)h->dir_offset + (UInt64)curPage*h->block_len,
                              h->block_len) != h->block_len)
             return CHM_RESOLVE_FAILURE;
 
         /* now, if it is a leaf node: */
         if (memcmp(page_buf, _chm_pmgl_marker, 4) == 0)
         {
             /* scan block */
             UChar *pEntry = _chm_find_in_PMGL(page_buf,
                                               h->block_len,
                                               objPath);
             if (pEntry == NULL)
                 return CHM_RESOLVE_FAILURE;
 
             /* parse entry and return */
             _chm_parse_PMGL_entry(&pEntry, ui);
             return CHM_RESOLVE_SUCCESS;
         }
 
         /* else, if it is a branch node: */
         else if (memcmp(page_buf, _chm_pmgi_marker, 4) == 0)
             curPage = _chm_find_in_PMGI(page_buf, h->block_len, objPath);
 
         /* else, we are confused.  give up. */
         else
             return CHM_RESOLVE_FAILURE;
     }
 
         /* didn't find anything.  fail. */
         return CHM_RESOLVE_FAILURE;
 }
 
 /*
  * utility methods for dealing with compressed data
  */
 
 /* get the bounds of a compressed block.  return 0 on failure */
 static int _chm_get_cmpblock_bounds(struct chmFile *h,
                              UInt64 block,
                              UInt64 *start,
                              Int64 *len)
 {
     UChar buffer[8], *dummy;
     UInt32 remain;
 
     /* for all but the last block, use the reset table */
     if (block < h->reset_table.block_count-1)
     {
         /* unpack the start address */
         dummy = buffer;
         remain = 8;
         if (_chm_fetch_bytes(h, buffer,
                              (UInt64)h->data_offset
                                 + (UInt64)h->rt_unit.start
                                 + (UInt64)h->reset_table.table_offset
                                 + (UInt64)block*8,
                              remain) != remain                            ||
             !_unmarshal_uint64(&dummy, &remain, start))
             return 0;
 
         /* unpack the end address */
         dummy = buffer;
         remain = 8;
         if (_chm_fetch_bytes(h, buffer,
                          (UInt64)h->data_offset
                                 + (UInt64)h->rt_unit.start
                                 + (UInt64)h->reset_table.table_offset
                                 + (UInt64)block*8 + 8,
                          remain) != remain                                ||
             !_unmarshal_int64(&dummy, &remain, len))
             return 0;
     }
 
     /* for the last block, use the span in addition to the reset table */
     else
     {
         /* unpack the start address */
         dummy = buffer;
         remain = 8;
         if (_chm_fetch_bytes(h, buffer,
                              (UInt64)h->data_offset
                                 + (UInt64)h->rt_unit.start
                                 + (UInt64)h->reset_table.table_offset
                                 + (UInt64)block*8,
                              remain) != remain                            ||
             !_unmarshal_uint64(&dummy, &remain, start))
             return 0;
 
         *len = h->reset_table.compressed_len;
     }
 
     /* compute the length and absolute start address */
     *len -= *start;
     *start += h->data_offset + h->cn_unit.start;
 
     return 1;
 }
 
 /* decompress the block.  must have lzx_mutex. */
 static Int64 _chm_decompress_block(struct chmFile *h,
                                    UInt64 block,
                                    UChar **ubuffer)
 {
 #ifdef WIN32
         UChar *cbuffer = alloca(((unsigned int)h->reset_table.block_len + 6144));
 #else
     UChar cbuffer[h->reset_table.block_len + 6144];     /* compressed buffer */
 #endif
     UInt64 cmpStart;                                    /* compressed start  */
     Int64 cmpLen;                                       /* compressed len    */
     int indexSlot;                                      /* cache index slot  */
     UChar *lbuffer;                                     /* local buffer ptr  */
     UInt32 blockAlign = (UInt32)(block % h->reset_blkcount); /* reset intvl. aln. */
     UInt32 i;                                           /* local loop index  */
 
     /* check if we need previous blocks */
     if (blockAlign != 0)
     {
         /* fetch all required previous blocks since last reset */
         for (i = h->reset_blkcount - blockAlign; i > 0; i--)
         {
 
             /* check if we most recently decompressed the previous block */
             if (h->lzx_last_block != block-i)
             {
                 indexSlot = (int)((block-i) % h->cache_num_blocks);
                 h->cache_block_indices[indexSlot] = block-i;
                 if (! h->cache_blocks[indexSlot])
                     h->cache_blocks[indexSlot] = (UChar *)malloc(
                                             (unsigned int)(h->reset_table.block_len));
                 lbuffer = h->cache_blocks[indexSlot];
 
                 /* decompress the previous block */
                 LZXreset(h->lzx_state);
                 if (!_chm_get_cmpblock_bounds(h, block-i, &cmpStart, &cmpLen) ||
                     _chm_fetch_bytes(h, cbuffer, cmpStart, cmpLen) != cmpLen  ||
                     LZXdecompress(h->lzx_state, cbuffer, lbuffer, (int)cmpLen,
                                   (int)h->reset_table.block_len) != DECR_OK)
                     return (Int64)0;
             }
 
             h->lzx_last_block = (int)(block - i);
         }
     }
     else
         LZXreset(h->lzx_state);
 
     /* allocate slot in cache */
     indexSlot = (int)(block % h->cache_num_blocks);
     h->cache_block_indices[indexSlot] = block;
     if (! h->cache_blocks[indexSlot])
         h->cache_blocks[indexSlot] = (UChar *)malloc(
                                           ((unsigned int)h->reset_table.block_len));
     lbuffer = h->cache_blocks[indexSlot];
     *ubuffer = lbuffer;
 
     /* decompress the block we actually want */
     if (! _chm_get_cmpblock_bounds(h, block, &cmpStart, &cmpLen)          ||
         _chm_fetch_bytes(h, cbuffer, cmpStart, cmpLen) != cmpLen          ||
         LZXdecompress(h->lzx_state, cbuffer, lbuffer, (int)cmpLen,
                       (int)h->reset_table.block_len) != DECR_OK)
         return (Int64)0;
     h->lzx_last_block = (int)block;
 
     /* XXX: modify LZX routines to return the length of the data they
      * decompressed and return that instead, for an extra sanity check.
      */
     return h->reset_table.block_len;
 }
 
 /* grab a region from a compressed block */
 static Int64 _chm_decompress_region(struct chmFile *h,
                                     UChar *buf,
                                     UInt64 start,
                                     Int64 len)
 {
     UInt64 nBlock, nOffset;
     UInt64 nLen;
     UInt64 gotLen;
     UChar *ubuffer;
 
         if (len <= 0)
                 return (Int64)0;
 
     /* figure out what we need to read */
     nBlock = start / h->reset_table.block_len;
     nOffset = start % h->reset_table.block_len;
     nLen = len;
     if (nLen > (h->reset_table.block_len - nOffset))
         nLen = h->reset_table.block_len - nOffset;
 
     /* if block is cached, return data from it. */
     CHM_ACQUIRE_LOCK(h->lzx_mutex);
     CHM_ACQUIRE_LOCK(h->cache_mutex);
     if (h->cache_block_indices[nBlock % h->cache_num_blocks] == nBlock    &&
         h->cache_blocks[nBlock % h->cache_num_blocks] != NULL)
     {
         memcpy(buf,
                h->cache_blocks[nBlock % h->cache_num_blocks] + nOffset,
                (unsigned int)nLen);
         CHM_RELEASE_LOCK(h->cache_mutex);
         CHM_RELEASE_LOCK(h->lzx_mutex);
         return nLen;
     }
     CHM_RELEASE_LOCK(h->cache_mutex);
 
     /* data request not satisfied, so... start up the decompressor machine */
     if (! h->lzx_state)
     {
         int window_size = ffs(h->window_size) - 1;
         h->lzx_last_block = -1;
         h->lzx_state = LZXinit(window_size);
     }
 
     /* decompress some data */
     gotLen = _chm_decompress_block(h, nBlock, &ubuffer);
     if (gotLen < nLen)
         nLen = gotLen;
     memcpy(buf, ubuffer+nOffset, (unsigned int)nLen);
     CHM_RELEASE_LOCK(h->lzx_mutex);
     return nLen;
 }
 
 /* retrieve (part of) an object */
 LONGINT64 chm_retrieve_object(struct chmFile *h,
                                struct chmUnitInfo *ui,
                                unsigned char *buf,
                                LONGUINT64 addr,
                                LONGINT64 len)
 {
     /* must be valid file handle */
     if (h == NULL)
         return (Int64)0;
 
     /* starting address must be in correct range */
     if (addr < 0  ||  addr >= ui->length)
         return (Int64)0;
 
     /* clip length */
     if (addr + len > ui->length)
         len = ui->length - addr;
 
     /* if the file is uncompressed, it's simple */
     if (ui->space == CHM_UNCOMPRESSED)
     {
         /* read data */
         return _chm_fetch_bytes(h,
                                 buf,
                                 (UInt64)h->data_offset + (UInt64)ui->start + (UInt64)addr,
                                 len);
     }
 
     /* else if the file is compressed, it's a little trickier */
     else /* ui->space == CHM_COMPRESSED */
     {
         Int64 swath=0, total=0;
         do {
 
             /* swill another mouthful */
             swath = _chm_decompress_region(h, buf, ui->start + addr, len);
 
             /* if we didn't get any... */
             if (swath == 0)
                 return total;
 
             /* update stats */
             total += swath;
             len -= swath;
             addr += swath;
             buf += swath;
 
         } while (len != 0);
 
         return total;
     }
 }
 
 /* enumerate the objects in the .chm archive */
 int chm_enumerate(struct chmFile *h,
                   int what,
                   CHM_ENUMERATOR e,
                   void *context)
 {
     Int32 curPage;
 
     /* buffer to hold whatever page we're looking at */
 #ifdef WIN32
         UChar *page_buf = alloca((unsigned int)h->block_len);
 #else
     UChar page_buf[h->block_len];
 #endif
     struct chmPmglHeader header;
     UChar *end;
     UChar *cur;
     unsigned long lenRemain;
 
     /* the current ui */
     struct chmUnitInfo ui;
     int flag;
 
     /* starting page */
     curPage = h->index_head;
 
     /* until we have either returned or given up */
     while (curPage != -1)
     {
 
         /* try to fetch the index page */
         if (_chm_fetch_bytes(h,
                              page_buf,
                              (UInt64)h->dir_offset + (UInt64)curPage*h->block_len,
                              h->block_len) != h->block_len)
             return 0;
 
         /* figure out start and end for this page */
         cur = page_buf;
         lenRemain = _CHM_PMGL_LEN;
         if (! _unmarshal_pmgl_header(&cur, &lenRemain, &header))
             return 0;
         end = page_buf + h->block_len - (header.free_space);
 
         /* loop over this page */
         while (cur < end)
         {
             if (! _chm_parse_PMGL_entry(&cur, &ui))
                 return 0;
 
             /* check for DIRS */
             if (ui.length == 0  &&  !(what & CHM_ENUMERATE_DIRS))
                 continue;
 
             /* check for FILES */
             if (ui.length != 0  &&  !(what & CHM_ENUMERATE_FILES))
                 continue;
 
             /* check for NORMAL vs. META */
             if (ui.path[0] == '/')
             {
 
                 /* check for NORMAL vs. SPECIAL */
                 if (ui.path[1] == '#'  ||  ui.path[1] == '$')
                     flag = CHM_ENUMERATE_SPECIAL;
                 else
                     flag = CHM_ENUMERATE_NORMAL;
             }
             else
                 flag = CHM_ENUMERATE_META;
             if (! (what & flag))
                 continue;
 
             /* call the enumerator */
             {
                 int status = (*e)(h, &ui, context);
                 switch (status)
                 {
                     case CHM_ENUMERATOR_FAILURE:  return 0;
                     case CHM_ENUMERATOR_CONTINUE: break;
                     case CHM_ENUMERATOR_SUCCESS:  return 1;
                     default:                      break;
                 }
             }
         }
 
         /* advance to next page */
         curPage = header.block_next;
     }
 
     return 1;
 }
 
 int chm_enumerate_dir(struct chmFile *h,
                       const char *prefix,
                       int what,
                       CHM_ENUMERATOR e,
                       void *context)
 {
     /*
      * XXX: do this efficiently (i.e. using the tree index)
      */
 
     Int32 curPage;
 
     /* buffer to hold whatever page we're looking at */
 #ifdef WIN32
         UChar *page_buf = alloca((unsigned int)h->block_len);
 #else
     UChar page_buf[h->block_len];
 #endif
     struct chmPmglHeader header;
     UChar *end;
     UChar *cur;
     unsigned long lenRemain;
 
     /* set to 1 once we've started */
     int it_has_begun=0;
 
     /* the current ui */
     struct chmUnitInfo ui;
     int flag;
 
     /* the length of the prefix */
     char prefixRectified[CHM_MAX_PATHLEN+1];
     int prefixLen;
-    char lastPath[CHM_MAX_PATHLEN];
+    char lastPath[CHM_MAX_PATHLEN+1];
     int lastPathLen;
 
     /* starting page */
     curPage = h->index_head;
 
     /* initialize pathname state */
     strncpy(prefixRectified, prefix, CHM_MAX_PATHLEN);
     prefixLen = strlen(prefixRectified);
     if (prefixLen != 0)
     {
         if (prefixRectified[prefixLen-1] != '/')
         {
             prefixRectified[prefixLen] = '/';
             prefixRectified[prefixLen+1] = '\0';
             ++prefixLen;
         }
     }
     lastPath[0] = '\0';
     lastPathLen = -1;
 
     /* until we have either returned or given up */
     while (curPage != -1)
     {
 
         /* try to fetch the index page */
         if (_chm_fetch_bytes(h,
                              page_buf,
                              (UInt64)h->dir_offset + (UInt64)curPage*h->block_len,
                              h->block_len) != h->block_len)
             return 0;
 
         /* figure out start and end for this page */
         cur = page_buf;
         lenRemain = _CHM_PMGL_LEN;
         if (! _unmarshal_pmgl_header(&cur, &lenRemain, &header))
             return 0;
         end = page_buf + h->block_len - (header.free_space);
 
         /* loop over this page */
         while (cur < end)
         {
             if (! _chm_parse_PMGL_entry(&cur, &ui))
                 return 0;
 
             /* check if we should start */
             if (! it_has_begun)
             {
                 if (ui.length == 0  &&  strncmp(ui.path, prefixRectified, prefixLen) == 0)
                     it_has_begun = 1;
                 else
                     continue;
 
                 if (ui.path[prefixLen] == '\0')
                     continue;
             }
 
             /* check if we should stop */
             else
             {
                 if (strncmp(ui.path, prefixRectified, prefixLen) != 0)
                     return 1;
             }
 
             /* check if we should include this path */
             if (lastPathLen != -1)
             {
                 if (strncmp(ui.path, lastPath, lastPathLen) == 0)
                     continue;
             }
-            strcpy(lastPath, ui.path);
+            strncpy(lastPath, ui.path, CHM_MAX_PATHLEN);
+            lastPath[CHM_MAX_PATHLEN] = '\0';
             lastPathLen = strlen(lastPath);
 
             /* check for DIRS */
             if (ui.length == 0  &&  !(what & CHM_ENUMERATE_DIRS))
                 continue;
 
             /* check for FILES */
             if (ui.length != 0  &&  !(what & CHM_ENUMERATE_FILES))
                 continue;
 
             /* check for NORMAL vs. META */
             if (ui.path[0] == '/')
             {
 
                 /* check for NORMAL vs. SPECIAL */
                 if (ui.path[1] == '#'  ||  ui.path[1] == '$')
                     flag = CHM_ENUMERATE_SPECIAL;
                 else
                     flag = CHM_ENUMERATE_NORMAL;
             }
             else
                 flag = CHM_ENUMERATE_META;
             if (! (what & flag))
                 continue;
 
             /* call the enumerator */
             {
                 int status = (*e)(h, &ui, context);
                 switch (status)
                 {
                     case CHM_ENUMERATOR_FAILURE:  return 0;
                     case CHM_ENUMERATOR_CONTINUE: break;
                     case CHM_ENUMERATOR_SUCCESS:  return 1;
                     default:                      break;
                 }
             }
         }
 
         /* advance to next page */
         curPage = header.block_next;
     }
 
     return 1;
 }
 
 /* resolve a particular object from the archive */
 int chm_resolve_location(struct chmFile *h,
 			 unsigned long pos,
 			 struct chmUnitInfo *ui)
 {
   /*
    * XXX: implement caching scheme for dir pages
    */
 
   Int32 curPage;
 
   /* buffer to hold whatever page we're looking at */
 #ifdef WIN32
   UChar *page_buf = alloca(h->block_len);
 #else
   UChar page_buf[h->block_len];
 #endif
 
   /* starting page */
   curPage = h->index_root;
 
   /* until we have either returned or given up */
   while (curPage != -1)
     {
 
       /* try to fetch the index page */
       if (_chm_fetch_bytes(h, page_buf,
 			   (UInt64)h->dir_offset + (UInt64)curPage*h->block_len,
 			   h->block_len) != h->block_len)
 	return CHM_RESOLVE_FAILURE;
 
       /* now, if it is a leaf node: */
       if (memcmp(page_buf, _chm_pmgl_marker, 4) == 0)
         {
 	  /* scan block */
 	  /*	  UChar *pEntry = _chm_find_in_PMGL(page_buf, h->block_len, objPath);*/
 	  {
 	    /* XXX: modify this to do a binary search using the nice index structure
 	     *      that is provided for us.
 	     */
 	    struct chmPmglHeader header;
 	    UInt32 hremain;
 	    UChar *end;
 	    UChar *cur;
 	    UChar *temp;
 /*

 	    UInt64 strLen;
 	    char buffer[CHM_MAX_PATHLEN+1];
 */
 	    /* figure out where to start and end */
 	    cur = page_buf;
 	    hremain = _CHM_PMGL_LEN;
 	    if (! _unmarshal_pmgl_header(&cur, &hremain, &header))
 	      return CHM_RESOLVE_FAILURE;
 	    end = page_buf + h->block_len - (header.free_space);
 
 	    /* now, scan progressively */
 	    while (cur < end)
 	      {
 		UInt32 st = 0;
 		UInt32 nd = 0;
 		/* grab the name */
 		temp = cur;
 
 		if (_chm_parse_PMGL_entry(&cur, ui) == 0)
 		  {
 		    return CHM_RESOLVE_FAILURE;
 		  }
 		st = ui->start;
 		nd = ui->start+ui->length;
 		if ((st <= pos) && (pos < nd))
 		  {
 		    printf("Resolve:[%u,%u,%u]\n", st, pos, nd);
 		    return CHM_RESOLVE_SUCCESS;
 		  }
 	      }
 
 	    return CHM_RESOLVE_FAILURE;
 	  }
 
         }
 
       /* else, if it is a branch node: */
       else if (memcmp(page_buf, _chm_pmgi_marker, 4) == 0)
 	{
 	  /*	  curPage = _chm_find_in_PMGI(page_buf, h->block_len, objPath);*/
 	  return CHM_RESOLVE_FAILURE;
 	  if (0)
 	  {
 	    /* XXX: modify this to do a binary search using the nice index structure
 	     *      that is provided for us
 	     */
 	    struct chmPmgiHeader header;
 	    UInt32 hremain;
 	    int page=-1;
 	    UChar *end;
 	    UChar *cur;
 	    UInt64 strLen;
 	    char buffer[CHM_MAX_PATHLEN+1];
 
 	    /* figure out where to start and end */
 	    cur = page_buf;
 	    hremain = _CHM_PMGI_LEN;
 	    if (! _unmarshal_pmgi_header(&cur, &hremain, &header))
 	      return -1;
 	    end = page_buf + h->block_len - (header.free_space);
 
 	    /* now, scan progressively */
 	    while (cur < end)
 	      {
 
 
 
 		if (_chm_parse_PMGL_entry(&cur, ui) == 0)
 		  {
 		    return CHM_RESOLVE_FAILURE;
 		  }
 
 		if (ui->start <= pos && pos < ui->start + ui->length)
 		  {
 		    return CHM_RESOLVE_SUCCESS;
 		  }
 
 
 
 
 
 		/* grab the name */
 		strLen = _chm_parse_cword(&cur);
 		if (! _chm_parse_UTF8(&cur, strLen, buffer))
 		  return -1;
 
 		/* check if it is the right name */
 		/*
 #ifdef WIN32
 		if (stricmp(buffer, objPath) > 0)
 		  return page;
 #else
 		if (strcasecmp(buffer, objPath) > 0)
 		  return page;
 #endif
 		*/
 		/* load next value for path */
 		page = (int)_chm_parse_cword(&cur);
 	      }
 
 	    curPage = page;
 	  }
 	}
       /* else, we are confused.  give up. */
       else
 	return CHM_RESOLVE_FAILURE;
     }
 
   /* didn't find anything.  fail. */
   return CHM_RESOLVE_FAILURE;
 
 }
diff --git a/noncore/settings/sysinfo/contrib/dhry.c b/noncore/settings/sysinfo/contrib/dhry.c
index 20b627c..07fd1c0 100644
--- a/noncore/settings/sysinfo/contrib/dhry.c
+++ b/noncore/settings/sysinfo/contrib/dhry.c
@@ -1,1010 +1,1010 @@
 /*****************************************************/
 /* Various timer routines.                           */
 /* Al Aburto, aburto@nosc.mil, 18 Feb 1997           */
 /*                                                   */
 /* t = dtime() outputs the current time in seconds.  */
 /* Use CAUTION as some of these routines will mess   */
 /* up when timing across the hour mark!!!            */
 /*                                                   */
 /* For timing I use the 'user' time whenever         */
 /* possible. Using 'user+sys' time is a separate     */
 /* issue.                                            */
 /*                                                   */
 /* Example Usage:                                    */
 /* [timer options added here]                        */
 /* main()                                            */
 /* {                                                 */
 /* double starttime,benchtime,dtime();               */
 /*                                                   */
 /* starttime = dtime();                              */
 /* [routine to time]                                 */
 /* benchtime = dtime() - starttime;                  */
 /* }                                                 */
 /*                                                   */
 /* [timer code below added here]                     */
 /*****************************************************/
 
 /***************************************************************/
 /* Timer options. You MUST uncomment one of the options below  */
 /* or compile, for example, with the '-DUNIX' option.          */
 /***************************************************************/
 /* #define Amiga       */
 /* #define UNIX        */
 /* #define UNIX_Old    */
 /* #define VMS         */
 /* #define BORLAND_C   */
 /* #define MSC         */
 /* #define MAC         */
 /* #define IPSC        */
 /* #define FORTRAN_SEC */
 /* #define GTODay      */
 /* #define CTimer      */
 /* #define UXPM        */
 /* #define MAC_TMgr    */
 /* #define PARIX       */
 /* #define POSIX       */
 /* #define WIN32       */
 /* #define POSIX1      */
 /***********************/
 
 /*********************************/
 /* Timer code.                   */
 /*********************************/
 /*******************/
 /*  Amiga dtime()  */
 /*******************/
 #ifdef Amiga
 #include <ctype.h>
 #define HZ 50
 
 double dtime()
 {
  double q;
 
  struct tt
        {
 	long  days;
 	long  minutes;
 	long  ticks;
        } tt;
 
  DateStamp(&tt);
 
  q = ((double)(tt.ticks + (tt.minutes * 60L * 50L))) / (double)HZ;
 
  return q;
 }
 #endif
 
 /*****************************************************/
 /*  UNIX dtime(). This is the preferred UNIX timer.  */
 /*  Provided by: Markku Kolkka, mk59200@cc.tut.fi    */
 /*  HP-UX Addition by: Bo Thide', bt@irfu.se         */
 /*****************************************************/
 #ifdef UNIX
 #include <sys/time.h>
 #include <sys/resource.h>
 
 #ifdef hpux
 #include <sys/syscall.h>
 #define getrusage(a,b) syscall(SYS_getrusage,a,b)
 #endif
 
 struct rusage rusage;
 
 double dtime()
 {
  double q;
 
  getrusage(RUSAGE_SELF,&rusage);
 
  q = (double)(rusage.ru_utime.tv_sec);
  q = q + (double)(rusage.ru_utime.tv_usec) * 1.0e-06;
 
  return q;
 }
 #endif
 
 /***************************************************/
 /*  UNIX_Old dtime(). This is the old UNIX timer.  */
 /*  Make sure HZ is properly defined in param.h !! */
 /***************************************************/
 #ifdef UNIX_Old
 #include <sys/types.h>
 #include <sys/times.h>
 #include <sys/param.h>
 
 #ifndef HZ
 #define HZ 60
 #endif
 
 struct tms tms;
 
 double dtime()
 {
  double q;
 
  times(&tms);
 
  q = (double)(tms.tms_utime) / (double)HZ;
 
  return q;
 }
 #endif
 
 /*********************************************************/
 /*  VMS dtime() for VMS systems.                         */
 /*  Provided by: RAMO@uvphys.phys.UVic.CA                */
 /*  Some people have run into problems with this timer.  */
 /*********************************************************/
 #ifdef VMS
 #include time
 
 #ifndef HZ
 #define HZ 100
 #endif
 
 struct tbuffer_t
       {
        int proc_user_time;
        int proc_system_time;
        int child_user_time;
        int child_system_time;
       };
 
 struct tbuffer_t tms;
 
 double dtime()
 {
  double q;
 
  times(&tms);
 
  q = (double)(tms.proc_user_time) / (double)HZ;
 
  return q;
 }
 #endif
 
 /******************************/
 /*  BORLAND C dtime() for DOS */
 /******************************/
 #ifdef BORLAND_C
 #include <ctype.h>
 #include <dos.h>
 #include <time.h>
 
 #define HZ 100
 struct time tnow;
 
 double dtime()
 {
  double q;
 
  gettime(&tnow);
 
  q = 60.0 * (double)(tnow.ti_min);
  q = q + (double)(tnow.ti_sec);
  q = q + (double)(tnow.ti_hund)/(double)HZ;
 
  return q;
 }
 #endif
 
 /**************************************/
 /*  Microsoft C (MSC) dtime() for DOS */
 /**************************************/
 #ifdef MSC
 #include <time.h>
 #include <ctype.h>
 
 #define HZ CLOCKS_PER_SEC
 clock_t tnow;
 
 double dtime()
 {
  double q;
 
  tnow = clock();
 
  q = (double)tnow / (double)HZ;
 
  return q;
 }
 #endif
 
 /*************************************/
 /*  Macintosh (MAC) Think C dtime()  */
 /*************************************/
 #ifdef MAC
 #include <time.h>
 
 #define HZ 60
 
 double dtime()
 {
  double q;
 
  q = (double)clock() / (double)HZ;
 
  return q;
 }
 #endif
 
 /************************************************************/
 /*  iPSC/860 (IPSC) dtime() for i860.                       */
 /*  Provided by: Dan Yergeau, yergeau@gloworm.Stanford.EDU  */
 /************************************************************/
 #ifdef IPSC
 extern double dclock();
 
 double dtime()
 {
  double q;
 
  q = dclock();
 
  return q;
 }
 #endif
 
 /**************************************************/
 /*  FORTRAN dtime() for Cray type systems.        */
 /*  This is the preferred timer for Cray systems. */
 /**************************************************/
 #ifdef FORTRAN_SEC
 
 fortran double second();
 
 double dtime()
 {
  double q;
 
  second(&q);
 
  return q;
 }
 #endif
 
 /***********************************************************/
 /*  UNICOS C dtime() for Cray UNICOS systems.  Don't use   */
 /*  unless absolutely necessary as returned time includes  */
 /*  'user+system' time.  Provided by: R. Mike Dority,      */
 /*  dority@craysea.cray.com                                */
 /***********************************************************/
 #ifdef CTimer
 #include <time.h>
 
 double dtime()
 {
  double    q;
  clock_t   clock(void);
 
  q = (double)clock() / (double)CLOCKS_PER_SEC;
 
  return q;
 }
 #endif
 
 /********************************************/
 /* Another UNIX timer using gettimeofday(). */
 /* However, getrusage() is preferred.       */
 /********************************************/
 #ifdef GTODay
 #include <sys/time.h>
 
 struct timeval tnow;
 
 double dtime()
 {
  double q;
 
  gettimeofday(&tnow,NULL);
  q = (double)tnow.tv_sec + (double)tnow.tv_usec * 1.0e-6;
 
  return q;
 }
 #endif
 
 /*****************************************************/
 /*  Fujitsu UXP/M timer.                             */
 /*  Provided by: Mathew Lim, ANUSF, M.Lim@anu.edu.au */
 /*****************************************************/
 #ifdef UXPM
 #include <sys/types.h>
 #include <sys/timesu.h>
 struct tmsu rusage;
 
 double dtime()
 {
  double q;
 
  timesu(&rusage);
 
  q = (double)(rusage.tms_utime) * 1.0e-06;
 
  return q;
 }
 #endif
 
 /**********************************************/
 /*    Macintosh (MAC_TMgr) Think C dtime()    */
 /*   requires Think C Language Extensions or  */
 /*    #include <MacHeaders> in the prefix     */
 /*  provided by Francis H Schiffer 3rd (fhs)  */
 /*         skipschiffer@genie.geis.com        */
 /**********************************************/
 #ifdef MAC_TMgr
 #include <Timer.h>
 #include <stdlib.h>
 
 static TMTask   mgrTimer;
 static Boolean  mgrInited = false;
 static double   mgrClock;
 
 #define RMV_TIMER RmvTime( (QElemPtr)&mgrTimer )
 #define MAX_TIME  1800000000L
 /* MAX_TIME limits time between calls to */
 /* dtime( ) to no more than 30 minutes   */
 /* this limitation could be removed by   */
 /* creating a completion routine to sum  */
 /* 30 minute segments (fhs 1994 feb 9)   */
 
 static void Remove_timer( )
 {
  RMV_TIMER;
  mgrInited = false;
 }
 
 double  dtime( )
 {
  if( mgrInited ) {
    RMV_TIMER;
    mgrClock += (MAX_TIME + mgrTimer.tmCount)*1.0e-6;
  } else {
    if( _atexit( &Remove_timer ) == 0 ) mgrInited = true;
    mgrClock = 0.0;
  }
 
  if ( mgrInited )
    {
     mgrTimer.tmAddr = NULL;
     mgrTimer.tmCount = 0;
     mgrTimer.tmWakeUp = 0;
     mgrTimer.tmReserved = 0;
     InsTime( (QElemPtr)&mgrTimer );
     PrimeTime( (QElemPtr)&mgrTimer, -MAX_TIME );
    }
  return( mgrClock );
 }
 #endif
 
 /***********************************************************/
 /*  Parsytec GCel timer.                                   */
 /*  Provided by: Georg Wambach, gw@informatik.uni-koeln.de */
 /***********************************************************/
 #ifdef PARIX
 #include <sys/time.h>
 
 double dtime()
 {
  double q;
 
  q = (double) (TimeNowHigh()) / (double) CLK_TCK_HIGH;
 
  return q;
 }
 #endif
 
 /************************************************/
 /*  Sun Solaris POSIX dtime() routine           */
 /*  Provided by: Case Larsen, CTLarsen.lbl.gov  */
 /************************************************/
 #ifdef POSIX
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/rusage.h>
 
 #ifdef __hpux
 #include <sys/syscall.h>
 #endif
 
 struct rusage rusage;
 
 double dtime()
 {
  double q;
 
  getrusage(RUSAGE_SELF,&rusage);
 
  q = (double)(rusage.ru_utime.tv_sec);
  q = q + (double)(rusage.ru_utime.tv_nsec) * 1.0e-09;
 
  return q;
 }
 #endif
 
 
 /****************************************************/
 /*  Windows NT (32 bit) dtime() routine             */
 /*  Provided by: Piers Haken, piersh@microsoft.com  */
 /****************************************************/
 #ifdef WIN32
 #include <windows.h>
 
 double dtime(void)
 {
  double q;
 
  q = (double)GetTickCount() * 1.0e-03;
 
  return q;
 }
 #endif
 
 /*****************************************************/
 /* Time according to POSIX.1  -  <J.Pelan@qub.ac.uk> */
 /* Ref: "POSIX Programmer's Guide"  O'Reilly & Assoc.*/
 /*****************************************************/
 #ifdef POSIX1
 #define _POSIX_SOURCE 1
 #include <unistd.h>
 #include <limits.h>
 #include <sys/times.h>
 
 struct tms tms;
 
 double dtime()
 {
  double q;
  times(&tms);
  q = (double)tms.tms_utime / (double)CLK_TCK;
  return q;
 }
 #endif
 /*
  *************************************************************************
  *
  *                   "DHRYSTONE" Benchmark Program
  *                   -----------------------------
  *
  *  Version:    C, Version 2.1
  *
  *  File:       dhry_1.c (part 2 of 3)
  *
  *  Date:       May 25, 1988
  *
  *  Author:     Reinhold P. Weicker
  *
  *************************************************************************
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "dhry.h"
 
 /* Global Variables: */
 
 Rec_Pointer     Ptr_Glob,
                 Next_Ptr_Glob;
 int             Int_Glob;
 Boolean         Bool_Glob;
 char            Ch_1_Glob,
                 Ch_2_Glob;
 int             Arr_1_Glob [50];
 int             Arr_2_Glob [50] [50];
 
-char Reg_Define[] = "Register option selected.";
+char Reg_Define[32] = "Register option selected.";
 
 //extern char     *malloc ();
 Enumeration     Func_1 ();
   /*
   forward declaration necessary since Enumeration may not simply be int
   */
 
 #ifndef ROPT
 #define REG
         /* REG becomes defined as empty */
         /* i.e. no register variables   */
 #else
 #define REG register
 #endif
 
 
 /* variables for time measurement: */
 
 #define Too_Small_Time 2
                 /* Measurements should last at least 2 seconds */
 
 double          Begin_Time,
                 End_Time,
                 User_Time;
 
 double          Microseconds,
                 Dhrystones_Per_Second,
                 Vax_Mips;
 
 /* end of variables for time measurement */
 
 /**********************************************************************************************/
 
 
 Proc_1 (Ptr_Val_Par)
 /******************/
 
 REG Rec_Pointer Ptr_Val_Par;
     /* executed once */
 {
   REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp;
                                         /* == Ptr_Glob_Next */
   /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp,    */
   /* corresponds to "rename" in Ada, "with" in Pascal           */
 
   structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob);
   Ptr_Val_Par->variant.var_1.Int_Comp = 5;
   Next_Record->variant.var_1.Int_Comp
         = Ptr_Val_Par->variant.var_1.Int_Comp;
   Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp;
   Proc_3 (&Next_Record->Ptr_Comp);
     /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp
                         == Ptr_Glob->Ptr_Comp */
   if (Next_Record->Discr == Ident_1)
     /* then, executed */
   {
     Next_Record->variant.var_1.Int_Comp = 6;
     Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp,
            &Next_Record->variant.var_1.Enum_Comp);
     Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp;
     Proc_7 (Next_Record->variant.var_1.Int_Comp, 10,
            &Next_Record->variant.var_1.Int_Comp);
   }
   else /* not executed */
     structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp);
 } /* Proc_1 */
 
 
 Proc_2 (Int_Par_Ref)
 /******************/
     /* executed once */
     /* *Int_Par_Ref == 1, becomes 4 */
 
 One_Fifty   *Int_Par_Ref;
 {
   One_Fifty  Int_Loc;
   Enumeration   Enum_Loc;
 
   Int_Loc = *Int_Par_Ref + 10;
   do /* executed once */
     if (Ch_1_Glob == 'A')
       /* then, executed */
     {
       Int_Loc -= 1;
       *Int_Par_Ref = Int_Loc - Int_Glob;
       Enum_Loc = Ident_1;
     } /* if */
   while (Enum_Loc != Ident_1); /* true */
 } /* Proc_2 */
 
 
 Proc_3 (Ptr_Ref_Par)
 /******************/
     /* executed once */
     /* Ptr_Ref_Par becomes Ptr_Glob */
 
 Rec_Pointer *Ptr_Ref_Par;
 
 {
   if (Ptr_Glob != Null)
     /* then, executed */
     *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp;
   Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp);
 } /* Proc_3 */
 
 
 Proc_4 () /* without parameters */
 /*******/
     /* executed once */
 {
   Boolean Bool_Loc;
 
   Bool_Loc = Ch_1_Glob == 'A';
   Bool_Glob = Bool_Loc | Bool_Glob;
   Ch_2_Glob = 'B';
 } /* Proc_4 */
 
 
 Proc_5 () /* without parameters */
 /*******/
     /* executed once */
 {
   Ch_1_Glob = 'A';
   Bool_Glob = false;
 } /* Proc_5 */
 
 
         /* Procedure for the assignment of structures,          */
         /* if the C compiler doesn't support this feature       */
 #ifdef  NOSTRUCTASSIGN
 memcpy (d, s, l)
 register char   *d;
 register char   *s;
 register int    l;
 {
         while (l--) *d++ = *s++;
 }
 #endif
 
 
 Proc_6 (Enum_Val_Par, Enum_Ref_Par)
 /*********************************/
     /* executed once */
     /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */
 
 Enumeration  Enum_Val_Par;
 Enumeration *Enum_Ref_Par;
 {
   *Enum_Ref_Par = Enum_Val_Par;
   if (! Func_3 (Enum_Val_Par))
     /* then, not executed */
     *Enum_Ref_Par = Ident_4;
   switch (Enum_Val_Par)
   {
     case Ident_1:
       *Enum_Ref_Par = Ident_1;
       break;
     case Ident_2:
       if (Int_Glob > 100)
         /* then */
       *Enum_Ref_Par = Ident_1;
       else *Enum_Ref_Par = Ident_4;
       break;
     case Ident_3: /* executed */
       *Enum_Ref_Par = Ident_2;
       break;
     case Ident_4: break;
     case Ident_5:
       *Enum_Ref_Par = Ident_3;
       break;
   } /* switch */
 } /* Proc_6 */
 
 
 Proc_7 (Int_1_Par_Val, Int_2_Par_Val, Int_Par_Ref)
 /**********************************************/
     /* executed three times                                      */
     /* first call:      Int_1_Par_Val == 2, Int_2_Par_Val == 3,  */
     /*                  Int_Par_Ref becomes 7                    */
     /* second call:     Int_1_Par_Val == 10, Int_2_Par_Val == 5, */
     /*                  Int_Par_Ref becomes 17                   */
     /* third call:      Int_1_Par_Val == 6, Int_2_Par_Val == 10, */
     /*                  Int_Par_Ref becomes 18                   */
 One_Fifty       Int_1_Par_Val;
 One_Fifty       Int_2_Par_Val;
 One_Fifty      *Int_Par_Ref;
 {
   One_Fifty Int_Loc;
 
   Int_Loc = Int_1_Par_Val + 2;
   *Int_Par_Ref = Int_2_Par_Val + Int_Loc;
 } /* Proc_7 */
 
 
 Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val)
 /*********************************************************************/
     /* executed once      */
     /* Int_Par_Val_1 == 3 */
     /* Int_Par_Val_2 == 7 */
 Arr_1_Dim       Arr_1_Par_Ref;
 Arr_2_Dim       Arr_2_Par_Ref;
 int             Int_1_Par_Val;
 int             Int_2_Par_Val;
 {
   REG One_Fifty Int_Index;
   REG One_Fifty Int_Loc;
 
   Int_Loc = Int_1_Par_Val + 5;
   Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val;
   Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc];
   Arr_1_Par_Ref [Int_Loc+30] = Int_Loc;
   for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index)
     Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc;
   Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1;
   Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc];
   Int_Glob = 5;
 } /* Proc_8 */
 
 
 Enumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val)
 /*************************************************/
     /* executed three times                                         */
     /* first call:      Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R'    */
     /* second call:     Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C'    */
     /* third call:      Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C'    */
 
 Capital_Letter   Ch_1_Par_Val;
 Capital_Letter   Ch_2_Par_Val;
 {
   Capital_Letter        Ch_1_Loc;
   Capital_Letter        Ch_2_Loc;
 
   Ch_1_Loc = Ch_1_Par_Val;
   Ch_2_Loc = Ch_1_Loc;
   if (Ch_2_Loc != Ch_2_Par_Val)
     /* then, executed */
     return (Ident_1);
   else  /* not executed */
   {
     Ch_1_Glob = Ch_1_Loc;
     return (Ident_2);
    }
 } /* Func_1 */
 
 
 Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref)
 /*************************************************/
     /* executed once */
     /* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */
     /* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */
 
 Str_30  Str_1_Par_Ref;
 Str_30  Str_2_Par_Ref;
 {
   REG One_Thirty        Int_Loc;
       Capital_Letter    Ch_Loc;
 
   Int_Loc = 2;
   while (Int_Loc <= 2) /* loop body executed once */
     if (Func_1 (Str_1_Par_Ref[Int_Loc],
                 Str_2_Par_Ref[Int_Loc+1]) == Ident_1)
       /* then, executed */
     {
       Ch_Loc = 'A';
       Int_Loc += 1;
     } /* if, while */
   if (Ch_Loc >= 'W' && Ch_Loc < 'Z')
     /* then, not executed */
     Int_Loc = 7;
   if (Ch_Loc == 'R')
     /* then, not executed */
     return (true);
   else /* executed */
   {
     if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0)
       /* then, not executed */
     {
       Int_Loc += 7;
       Int_Glob = Int_Loc;
       return (true);
     }
     else /* executed */
       return (false);
   } /* if Ch_Loc */
 } /* Func_2 */
 
 
 Boolean Func_3 (Enum_Par_Val)
 /***************************/
     /* executed once        */
     /* Enum_Par_Val == Ident_3 */
 Enumeration Enum_Par_Val;
 {
   Enumeration Enum_Loc;
 
   Enum_Loc = Enum_Par_Val;
   if (Enum_Loc == Ident_3)
     /* then, executed */
     return (true);
   else /* not executed */
     return (false);
 } /* Func_3 */
 
 /*********************************************************************************/
 
 double dhry_main( int n )
 /*****/
 
   /* main program, corresponds to procedures        */
   /* Main and Proc_0 in the Ada version             */
 {
         One_Fifty       Int_1_Loc;
   REG   One_Fifty       Int_2_Loc;
         One_Fifty       Int_3_Loc;
   REG   char            Ch_Index;
         Enumeration     Enum_Loc;
         Str_30          Str_1_Loc;
         Str_30          Str_2_Loc;
   REG   int             Run_Index;
   REG   int             Number_Of_Runs;
 
         FILE            *Ap;
 
   /* Initializations */
 
 /*  if ((Ap = fopen("dhry.res","a+")) == NULL)
     {
        printf("Can not open dhry.res\n\n");
        exit(1);
     }
 */
   Next_Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
   Ptr_Glob = (Rec_Pointer) malloc (sizeof (Rec_Type));
 
   Ptr_Glob->Ptr_Comp                    = Next_Ptr_Glob;
   Ptr_Glob->Discr                       = Ident_1;
   Ptr_Glob->variant.var_1.Enum_Comp     = Ident_3;
   Ptr_Glob->variant.var_1.Int_Comp      = 40;
   strcpy (Ptr_Glob->variant.var_1.Str_Comp,
           "DHRYSTONE PROGRAM, SOME STRING");
   strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING");
 
   Arr_2_Glob [8][7] = 10;
         /* Was missing in published program. Without this statement,    */
         /* Arr_2_Glob [8][7] would have an undefined value.             */
         /* Warning: With 16-Bit processors and Number_Of_Runs > 32000,  */
         /* overflow may occur for this array element.                   */
 
 /*
   if (Reg)
   {
     printf ("Program compiled with 'register' attribute\n");
     printf ("\n");
   }
   else
   {
     printf ("Program compiled without 'register' attribute\n");
     printf ("\n");
   }
 */
   Number_Of_Runs = n;
 
   /***************/
   /* Start timer */
   /***************/
 
   Begin_Time = dtime();
 
   for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index)
   {
 
     Proc_5();
     Proc_4();
       /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */
     Int_1_Loc = 2;
     Int_2_Loc = 3;
     strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
     Enum_Loc = Ident_2;
     Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc);
       /* Bool_Glob == 1 */
     while (Int_1_Loc < Int_2_Loc)  /* loop body executed once */
     {
       Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc;
         /* Int_3_Loc == 7 */
       Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc);
         /* Int_3_Loc == 7 */
       Int_1_Loc += 1;
     } /* while */
       /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
     Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc);
       /* Int_Glob == 5 */
     Proc_1 (Ptr_Glob);
     for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index)
                              /* loop body executed twice */
     {
       if (Enum_Loc == Func_1 (Ch_Index, 'C'))
           /* then, not executed */
         {
         Proc_6 (Ident_1, &Enum_Loc);
         strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING");
         Int_2_Loc = Run_Index;
         Int_Glob = Run_Index;
         }
     }
       /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */
     Int_2_Loc = Int_2_Loc * Int_1_Loc;
     Int_1_Loc = Int_2_Loc / Int_3_Loc;
     Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc;
       /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */
     Proc_2 (&Int_1_Loc);
       /* Int_1_Loc == 5 */
 
   } /* loop "for Run_Index" */
 
   /**************/
   /* Stop timer */
   /**************/
 
   End_Time = dtime();
 
 /*
   printf ("Execution ends\n");
   printf ("\n");
   printf ("Final values of the variables used in the benchmark:\n");
   printf ("\n");
   printf ("Int_Glob:            %d\n", Int_Glob);
   printf ("        should be:   %d\n", 5);
   printf ("Bool_Glob:           %d\n", Bool_Glob);
   printf ("        should be:   %d\n", 1);
   printf ("Ch_1_Glob:           %c\n", Ch_1_Glob);
   printf ("        should be:   %c\n", 'A');
   printf ("Ch_2_Glob:           %c\n", Ch_2_Glob);
   printf ("        should be:   %c\n", 'B');
   printf ("Arr_1_Glob[8]:       %d\n", Arr_1_Glob[8]);
   printf ("        should be:   %d\n", 7);
   printf ("Arr_2_Glob[8][7]:    %d\n", Arr_2_Glob[8][7]);
   printf ("        should be:   Number_Of_Runs + 10\n");
   printf ("Ptr_Glob->\n");
   printf ("  Ptr_Comp:          %d\n", (int) Ptr_Glob->Ptr_Comp);
   printf ("        should be:   (implementation-dependent)\n");
   printf ("  Discr:             %d\n", Ptr_Glob->Discr);
   printf ("        should be:   %d\n", 0);
   printf ("  Enum_Comp:         %d\n", Ptr_Glob->variant.var_1.Enum_Comp);
   printf ("        should be:   %d\n", 2);
   printf ("  Int_Comp:          %d\n", Ptr_Glob->variant.var_1.Int_Comp);
   printf ("        should be:   %d\n", 17);
   printf ("  Str_Comp:          %s\n", Ptr_Glob->variant.var_1.Str_Comp);
   printf ("        should be:   DHRYSTONE PROGRAM, SOME STRING\n");
   printf ("Next_Ptr_Glob->\n");
   printf ("  Ptr_Comp:          %d\n", (int) Next_Ptr_Glob->Ptr_Comp);
   printf ("        should be:   (implementation-dependent), same as above\n");
   printf ("  Discr:             %d\n", Next_Ptr_Glob->Discr);
   printf ("        should be:   %d\n", 0);
   printf ("  Enum_Comp:         %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp);
   printf ("        should be:   %d\n", 1);
   printf ("  Int_Comp:          %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp);
   printf ("        should be:   %d\n", 18);
   printf ("  Str_Comp:          %s\n", Next_Ptr_Glob->variant.var_1.Str_Comp);
   printf ("        should be:   DHRYSTONE PROGRAM, SOME STRING\n");
   printf ("Int_1_Loc:           %d\n", Int_1_Loc);
   printf ("        should be:   %d\n", 5);
   printf ("Int_2_Loc:           %d\n", Int_2_Loc);
   printf ("        should be:   %d\n", 13);
   printf ("Int_3_Loc:           %d\n", Int_3_Loc);
   printf ("        should be:   %d\n", 7);
   printf ("Enum_Loc:            %d\n", Enum_Loc);
   printf ("        should be:   %d\n", 1);
   printf ("Str_1_Loc:           %s\n", Str_1_Loc);
   printf ("        should be:   DHRYSTONE PROGRAM, 1'ST STRING\n");
   printf ("Str_2_Loc:           %s\n", Str_2_Loc);
   printf ("        should be:   DHRYSTONE PROGRAM, 2'ND STRING\n");
   printf ("\n");
 */
   User_Time = End_Time - Begin_Time;
 
   if (User_Time < Too_Small_Time) return -1;
   else
   {
     Microseconds = User_Time * Mic_secs_Per_Second
                         / (double) Number_Of_Runs;
     Dhrystones_Per_Second = (double) Number_Of_Runs / User_Time;
     Vax_Mips = Dhrystones_Per_Second / 1757.0;
 
 #ifdef ROPT
     //printf ("Register option selected?  YES\n");
 #else
     //printf ("Register option selected?  NO\n");
-    strcpy(Reg_Define, "Register option not selected.");
+    strncpy(Reg_Define, "Register option not selected.", 30);
 #endif
     printf ("Microseconds for one run through Dhrystone: ");
     printf ("%7.1lf \n", Microseconds);
     printf ("Dhrystones per Second:                      ");
     printf ("%10.1lf \n", Dhrystones_Per_Second);
     printf ("VAX MIPS rating = %10.3lf \n",Vax_Mips);
     printf ("\n");
 
     return Dhrystones_Per_Second;
 
 /*
 
   fprintf(Ap,"\n");
   fprintf(Ap,"Dhrystone Benchmark, Version 2.1 (Language: C)\n");
   fprintf(Ap,"%s\n",Reg_Define);
   fprintf(Ap,"Microseconds for one loop: %7.1lf\n",Microseconds);
   fprintf(Ap,"Dhrystones per second: %10.1lf\n",Dhrystones_Per_Second);
   fprintf(Ap,"VAX MIPS rating: %10.3lf\n",Vax_Mips);
   fclose(Ap);
 */
 
   }
 
 }