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
@@ -1507,263 +1507,264 @@ int chm_enumerate(struct chmFile *h,
         /* 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;
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
@@ -402,193 +402,193 @@ double dtime()
 /************************************************/
 #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 */
 
@@ -890,121 +890,121 @@ double dhry_main( int n )
     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);
 */
 
   }
 
 }