Changeset 871 for trunk/dll/literal.c


Ignore:
Timestamp:
Nov 17, 2007, 2:13:23 AM (18 years ago)
Author:
Steven Levine
Message:

Correct hex edit buffer sizing to avoid data loss
Detect and report overflows in fixup()

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/dll/literal.c

    r834 r871  
    88
    99  Copyright (c) 1993-98 M. Kimes
    10   Copyright (c) 2004, 2006 Steven H.Levine
     10  Copyright (c) 2004, 2007 Steven H.Levine
    1111
    1212  Archive containers
    … …  
    1616  22 Jul 06 SHL Check more run time errors
    1717  20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
     18  16 Nov 07 SHL Report fixup buffer overflow
    1819
    1920***********************************************************************/
    … …  
    100101      switch (pszBuf[iBuf + 1]) {
    101102      case 'x':                        /* hexadecimal */
    102         wchar = 0;
    103         iBuf += 2;                        /* get past "\x" */
    104         if (index(HEX, (CHAR) toupper(pszBuf[iBuf])) != -1) {
    105           iBufSave = iBuf;
    106           while (((wpos = index(HEX, (CHAR) toupper(pszBuf[iBuf]))) != -1) &&
    107                  iBuf < iBufSave + 2) {
    108             wchar = (CHAR) (wchar << 4) + (CHAR) wpos;
    109             iBuf++;
    110           }
    111         }
    112         else
    113           wchar = 'x';                        /* just an x */
    114         iBuf--;
    115         *pszOut++ = wchar;
    116         break;
     103        wchar = 0;
     104        iBuf += 2;                        /* get past "\x" */
     105        if (index(HEX, (CHAR) toupper(pszBuf[iBuf])) != -1) {
     106          iBufSave = iBuf;
     107          while (((wpos = index(HEX, (CHAR) toupper(pszBuf[iBuf]))) != -1) &&
     108                 iBuf < iBufSave + 2) {
     109            wchar = (CHAR) (wchar << 4) + (CHAR) wpos;
     110            iBuf++;
     111          }
     112        }
     113        else
     114          wchar = 'x';                        /* just an x */
     115        iBuf--;
     116        *pszOut++ = wchar;
     117        break;
    117118
    118119      case '\\':                        /* we want a "\" */
    119         iBuf++;
    120         *pszOut++ = '\\';
    121         break;
     120        iBuf++;
     121        *pszOut++ = '\\';
     122        break;
    122123
    123124      case 't':                        /* tab CHAR */
    124         iBuf++;
    125         *pszOut++ = '\t';
    126         break;
     125        iBuf++;
     126        *pszOut++ = '\t';
     127        break;
    127128
    128129      case 'n':                        /* new line */
    129         iBuf++;
    130         *pszOut++ = '\n';
    131         break;
     130        iBuf++;
     131        *pszOut++ = '\n';
     132        break;
    132133
    133134      case 'r':                        /* carr return */
    134         iBuf++;
    135         *pszOut++ = '\r';
    136         break;
     135        iBuf++;
     136        *pszOut++ = '\r';
     137        break;
    137138
    138139      case 'b':                        /* back space */
    139         iBuf++;
    140         *pszOut++ = '\b';
    141         break;
     140        iBuf++;
     141        *pszOut++ = '\b';
     142        break;
    142143
    143144      case 'f':                        /* formfeed */
    144         iBuf++;
    145         *pszOut++ = '\x0c';
    146         break;
     145        iBuf++;
     146        *pszOut++ = '\x0c';
     147        break;
    147148
    148149      case 'a':                        /* bell */
    149         iBuf++;
    150         *pszOut++ = '\07';
    151         break;
     150        iBuf++;
     151        *pszOut++ = '\07';
     152        break;
    152153
    153154      case '\'':                        /* single quote */
    154         iBuf++;
    155         *pszOut++ = '\'';
    156         break;
     155        iBuf++;
     156        *pszOut++ = '\'';
     157        break;
    157158
    158159      case '\"':                        /* double quote */
    159160
    160         iBuf++;
    161         *pszOut++ = '\"';
    162         break;
     161        iBuf++;
     162        *pszOut++ = '\"';
     163        break;
    163164
    164165      default:                                /* decimal */
    165         iBuf++;                                /* get past "\" */
    166         wchar = 0;
    167         if (index(DEC, pszBuf[iBuf]) != -1) {
    168           iBufSave = iBuf;
    169           do {                                /* cvt to binary */
    170             wchar = (CHAR) (wchar * 10 + (pszBuf[iBuf++] - 48));
    171           } while (index(DEC, pszBuf[iBuf]) != -1 && iBuf < iBufSave + 3);
    172           iBuf--;
    173         }
    174         else
    175           wchar = pszBuf[iBuf];
    176         *pszOut++ = wchar;
    177         break;
     166        iBuf++;                                /* get past "\" */
     167        wchar = 0;
     168        if (index(DEC, pszBuf[iBuf]) != -1) {
     169          iBufSave = iBuf;
     170          do {                                /* cvt to binary */
     171            wchar = (CHAR) (wchar * 10 + (pszBuf[iBuf++] - 48));
     172          } while (index(DEC, pszBuf[iBuf]) != -1 && iBuf < iBufSave + 3);
     173          iBuf--;
     174        }
     175        else
     176          wchar = pszBuf[iBuf];
     177        *pszOut++ = wchar;
     178        break;
    178179      }                                        // switch
    179180      break;
    … …  
    202203
    203204BOOL wildcard(const PSZ pszBuf, const PSZ pszWildCard,
    204               const BOOL fNotFileSpec)
     205              const BOOL fNotFileSpec)
    205206{
    206207  const CHAR *fstr = pszBuf;
    … …  
    215216      tcard[strlen(tcard) - 1] = 0;
    216217      if (!(strchr(tcard, '?')) && !(strchr(tcard, '*'))){
    217         if (strstr(fstr, tcard)){ //strstr match for *stuff* pattern no wildcards in "stuff"
    218           xfree(tcard);
    219           return TRUE;
    220         }
    221         else{
    222           xfree(tcard);
    223           return FALSE;
    224         }
     218        if (strstr(fstr, tcard)){ //strstr match for *stuff* pattern no wildcards in "stuff"
     219          xfree(tcard);
     220          return TRUE;
     221        }
     222        else{
     223          xfree(tcard);
     224          return FALSE;
     225        }
    225226      }
    226227      xfree(tcard);
    … …  
    228229    else   //reverse search for *stuff pattern "stuff" can contain wildcards
    229230      if (*fcard == '*' && fcard[strlen(fcard) - 1] != '*'){
    230         fstr = strrev(pszBuf);
    231         fcard = strrev(pszWildCard);
    232         reverse = TRUE;
     231        fstr = strrev(pszBuf);
     232        fcard = strrev(pszWildCard);
     233        reverse = TRUE;
    233234      }
    234235     switch (*fcard) { //fm2 standard forward search for all other cases
    235236      case '?':                                /* character substitution */
    236         fcard++;
    237         if (fNotFileSpec || (*fstr != '.' && *fstr != '/' && *fstr != '\\'))
    238           fstr++;                                /* skip (match) next character */
    239         break;
     237        fcard++;
     238        if (fNotFileSpec || (*fstr != '.' && *fstr != '/' && *fstr != '\\'))
     239          fstr++;                                /* skip (match) next character */
     240        break;
    240241
    241242      case '*':
    242         /* find next non-wild character in wildcard */
    243         while (*fcard && (*fcard == '?' || *fcard == '*'))
    244           fcard++;
    245         if (!*fcard){                        /* if last char of wildcard is *, it matches */
    246           if (reverse){
    247             fstr = strrev(pszBuf);
    248             fcard = strrev(pszWildCard);
    249           }
    250           return TRUE;
    251         }
    252         /* skip until partition, match, or eos */
    253         while (*fstr && toupper(*fstr) != toupper(*fcard) &&
    254                (fNotFileSpec || (*fstr != '\\' &&
    255                                  *fstr != '/' && *fstr != '.')))
    256           fstr++;
    257         if (!fNotFileSpec && !*fstr)        /* implicit '.' */
    258           if (*fcard == '.')
    259             fcard++;
    260         break;
     243        /* find next non-wild character in wildcard */
     244        while (*fcard && (*fcard == '?' || *fcard == '*'))
     245          fcard++;
     246        if (!*fcard){                        /* if last char of wildcard is *, it matches */
     247          if (reverse){
     248            fstr = strrev(pszBuf);
     249            fcard = strrev(pszWildCard);
     250          }
     251          return TRUE;
     252        }
     253        /* skip until partition, match, or eos */
     254        while (*fstr && toupper(*fstr) != toupper(*fcard) &&
     255               (fNotFileSpec || (*fstr != '\\' &&
     256                                 *fstr != '/' && *fstr != '.')))
     257          fstr++;
     258        if (!fNotFileSpec && !*fstr)        /* implicit '.' */
     259          if (*fcard == '.')
     260            fcard++;
     261        break;
    261262
    262263      default:
    263         if (!fNotFileSpec && ((*fstr == '/' || *fstr == '\\') &&
    264                               (*fcard == '/' || *fcard == '\\')))
    265           wmatch = TRUE;
    266         else
    267           wmatch = (toupper(*fstr) == toupper(*fcard));
    268         fstr++;
    269         fcard++;
    270         break;
     264        if (!fNotFileSpec && ((*fstr == '/' || *fstr == '\\') &&
     265                              (*fcard == '/' || *fcard == '\\')))
     266          wmatch = TRUE;
     267        else
     268          wmatch = (toupper(*fstr) == toupper(*fcard));
     269        fstr++;
     270        fcard++;
     271        break;
    271272      }
    272273  }  //while
    … …  
    292293
    293294PSZ fixup(const PCH pachIn, PSZ pszOutBuf, const UINT cBufBytes,
    294           const UINT cInBytes)
     295          const UINT cInBytes)
    295296{
    296297  PCH pchIn = pachIn;
    297298  PCH pchOut = pszOutBuf;
    298   PSZ pszTemp;
    299   static CHAR szTemp[5] = "\\x";        // Constant prefix
    300299
    301300  // input is a character array, not a string - may not be null terminated
    302301  // cBufBytes is buffer size
    303302  if (pachIn) {
     303    // 16 Nov 07 SHL fixme to optimize counting and speed
    304304    // Ensure room for null and possible \ escape
    305     while (pchIn - pachIn < cInBytes && pchOut - pszOutBuf + 2 < cBufBytes) {
     305    while (pchIn - pachIn < cInBytes) {
     306      if (pchOut - pszOutBuf + 4 >= cBufBytes) {
     307        *pchOut = 0;
     308        Runtime_Error(pszSrcFile, __LINE__, "buffer too small for %s", pszOutBuf);
     309        break;
     310      }
     311
    306312      if (!isprint(*pchIn)) {
    307         if (*pchIn == '\r') {
    308           *pchOut++ = '\\';
    309           *pchOut++ = 'r';
    310         }
    311         else if (*pchIn == '\n') {
    312           *pchOut++ = '\\';
    313           *pchOut++ = 'n';
    314         }
    315         else if (*pchIn == '\b') {
    316           *pchOut++ = '\\';
    317           *pchOut++ = 'b';
    318         }
    319         else {
    320           sprintf(szTemp + 2, "%02x", (UCHAR)*pchIn);
    321           for (pszTemp = szTemp; *pszTemp;)
    322             *pchOut++ = *pszTemp++;
    323         }
    324         pchIn++;
     313        if (*pchIn == '\r') {
     314          *pchOut++ = '\\';
     315          *pchOut++ = 'r';
     316        }
     317        else if (*pchIn == '\n') {
     318          *pchOut++ = '\\';
     319          *pchOut++ = 'n';
     320        }
     321        else if (*pchIn == '\b') {
     322          *pchOut++ = '\\';
     323          *pchOut++ = 'b';
     324        }
     325        else {
     326          sprintf(pchOut, "\\x%02x", (UCHAR)*pchIn);
     327          pchOut += 4;
     328        }
     329        pchIn++;
    325330      }
    326331      else if (*pchIn == '\\') {
    327         *pchOut++ = '\\';
    328         *pchOut++ = '\\';
    329         pchIn++;
     332        *pchOut++ = '\\';
     333        *pchOut++ = '\\';
     334        pchIn++;
    330335      }
    331336      else
    332         *pchOut++ = *pchIn++;
    333     }                                        // while
    334   }                                        // if pachIn
     337        *pchOut++ = *pchIn++;
     338    } // while
     339
     340  } // if pachIn
    335341  *pchOut = 0;
    336342  return pszOutBuf;
Note: See TracChangeset for help on using the changeset viewer.