Changeset 34 for trunk/src/sh_utils.c


Ignore:
Timestamp:
May 19, 2006, 8:09:51 PM (14 years ago)
Author:
rainer
Message:

Code cleanup and minor fixes

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/sh_utils.c

    r29 r34  
    270270  size = sl_strlen(formatt);
    271271
    272   fmt = (char *) SH_ALLOC(size + 1);
    273   (void) sl_strlcpy(fmt, formatt, size + 1);
     272  if (!sl_ok_adds(size, 1))
     273    SL_RETURN(NULL, _("sh_util_formatted"));
     274
     275  ++size;
     276  fmt = SH_ALLOC(size);
     277  (void) sl_strlcpy(fmt, formatt, size);
    274278
    275279  p = fmt;
     
    319323                {
    320324                  isiz = sl_strlen(ftab[j].data_str);
    321                   if (isiz > 0)
     325                  if (isiz > 0 && sl_ok_adds(size, isiz))
    322326                    {
    323327                      size += isiz;
     
    339343                  /*@+bufferoverflowhigh@*/
    340344                  isiz = sl_strlen(ftab[j].data_str);
    341                   if (isiz > 0)
     345                  if (isiz > 0 && sl_ok_adds(size, isiz))
    342346                    {
    343347                      size += isiz;
     
    359363                  /*@+bufferoverflowhigh@*/
    360364                  isiz = sl_strlen(ftab[j].data_str);
    361                   if (isiz > 0)
     365                  if (isiz > 0 && sl_ok_adds(size, isiz))
    362366                    {
    363367                      size += isiz;
     
    391395                    }
    392396                  isiz = sl_strlen(ftab[j].data_str);
    393                   if (isiz > 0)
     397                  if (isiz > 0 && sl_ok_adds(size, isiz))
    394398                    {
    395399                      size += isiz;
     
    431435  /* -- closing '\0' --
    432436   */
    433   size++;
     437  if (sl_ok_adds(size, 1))
     438    size++;
    434439  outstr = (char *) SH_ALLOC(size);
    435440
     
    441446                      clist[8],  clist[9], clist[10], clist[11],
    442447                      clist[12], clist[13], clist[14], clist[15]);
    443  
     448  outstr[size-1] = '\0';
     449
    444450  /* -- cleanup --
    445451   */
     
    491497  SL_ENTER(_("sh_util_hextobinary"));
    492498
    493   while (i < bytes)
     499  if (bytes < 2)
     500    SL_RETURN((-1), _("sh_util_hextobinary"));
     501
     502  while (i < (bytes-1))
    494503    {
    495504      SH_HEXCHAR(hex[i],   k);
     
    498507      binary[l] = (char)(k * 16 + j);
    499508      ++l; i+= 2;
    500 
    501       /* k = sh_util_hexchar(hex[i]); j = sh_util_hexchar(hex[i+1]);
    502       if (k != -1 && j != -1)
    503         {
    504           binary[l] = (char)(k * 16 + j);
    505           ++l; i+= 2;
    506         }
    507       else
    508         {
    509           SL_RETURN((-1), _("sh_util_hextobinary"));
    510         }
    511       */
    512509    }
    513510 
     
    581578    }
    582579
    583   inner = (char *) SH_ALLOC (textlen + KEY_BLOCK);
    584 
    585   for (i = 0; i < KEY_BLOCK; ++i)
    586     {
    587       outer[i]  = K[i] ^ opad[i];
    588       inner[i]  = K[i] ^ ipad[i];
    589     }
    590   for (i = KEY_BLOCK; i < (KEY_BLOCK+textlen); ++i)
    591     {
    592       inner[i] = text[i - KEY_BLOCK];
     580  if (sl_ok_adds(textlen, KEY_BLOCK))
     581    {
     582      inner = (char *) SH_ALLOC (textlen + KEY_BLOCK);
     583
     584      for (i = 0; i < KEY_BLOCK; ++i)
     585        {
     586          outer[i]  = K[i] ^ opad[i];
     587          inner[i]  = K[i] ^ ipad[i];
     588        }
     589      for (i = KEY_BLOCK; i < (KEY_BLOCK+textlen); ++i)
     590        {
     591          inner[i] = text[i - KEY_BLOCK];
     592        }
     593    }
     594  else
     595    {
     596      sh_error_handle((-1), FIL__, __LINE__, -1, MSG_E_SUBGEN,
     597                      _("integer overflow"),
     598                      _("sh_util_hmac_tiger"));
     599      res = sh_tiger_hash (NULL, TIGER_DATA, 0);
     600      SL_RETURN(res, _("sh_util_hmac_tiger"));
    593601    }
    594602
     
    14211429/* returns freshly allocated memory, return value should be free'd
    14221430 */
    1423 char * sh_util_basename(char * fullpath)
     1431char * sh_util_dirname(const char * fullpath)
    14241432{
    14251433  char * retval;
    1426   size_t i;
     1434  size_t len;
     1435
     1436  SL_ENTER(_("sh_util_dirname"));
     1437
     1438  ASSERT_RET ((fullpath != NULL), _("fullpath != NULL"), (NULL))
     1439
     1440  len = sl_strlen (fullpath);  /* fullpath[i] is terminating '\0' */
     1441
     1442  if (len > 1 && fullpath[len-1] == '/') /* skip trailing '/' */
     1443    --len;
     1444
     1445  while (len > 0) {
     1446    --len;
     1447    if (fullpath[len] == '/')
     1448      {
     1449        if (len == 0) ++len; /* copy the '/' to output */
     1450        break;
     1451      }
     1452  }
     1453
     1454  /* -- Not an absolute path. --
     1455   */
     1456  if ((len == 0) && (fullpath[len] != '/'))
     1457    {
     1458      SL_RETURN(NULL, _("sh_util_dirname"));
     1459    }
     1460
     1461  retval = SH_ALLOC(len + 1);
     1462  (void) sl_strlcpy (retval, fullpath, len+1);
     1463
     1464  SL_RETURN(retval, _("sh_util_dirname"));
     1465}
     1466
     1467/* returns freshly allocated memory, return value should be free'd
     1468 */
     1469char * sh_util_basename(const char * fullpath)
     1470{
     1471  char * retval = NULL;
     1472  char * tmp;
     1473  char * c;
     1474  size_t len;
    14271475
    14281476  SL_ENTER(_("sh_util_basename"));
     
    14301478  ASSERT_RET ((fullpath != NULL), _("fullpath != NULL"), (NULL))
    14311479
    1432   i = sl_strlen (fullpath);  /* fullpath[i] is terminating '\0' */
    1433 
    1434   while (i > 0) {
    1435     --i;
    1436     if (fullpath[i] == '/') break;
    1437   }
    1438 
    1439   /* -- Not a valid path. --
    1440    */
    1441   if ((fullpath[i] != '/') && (i == 0) )
    1442     SL_RETURN(NULL, _("sh_util_basename"));
    1443 
    1444   retval = SH_ALLOC(i + 1);
    1445 
    1446   (void) sl_strlcpy (retval, fullpath, i+1);
     1480  c = strrchr(fullpath, '/');
     1481  len = sl_strlen (c);
     1482
     1483  if (c == fullpath)
     1484    {
     1485      if (len <= 1)
     1486        retval = sh_util_strdup(c);
     1487      else
     1488        retval = sh_util_strdup(++c);
     1489    }
     1490  else
     1491    {
     1492      if (len > 1)
     1493        {
     1494          retval = sh_util_strdup(++c);
     1495        }
     1496      else
     1497        {
     1498          /* input ends in '/' */
     1499          tmp = sh_util_strdup(fullpath);
     1500          tmp[strlen(tmp)-1] = '\0';
     1501          retval = sh_util_basename(tmp);
     1502          SH_FREE(tmp);
     1503        }
     1504    }
    14471505
    14481506  SL_RETURN(retval, _("sh_util_basename"));
    1449 }
    1450 
    1451 /* returns freshly allocated memory, return value should be free'd
    1452  */
    1453 char * sh_util_filename(char * fullpath)
    1454 {
    1455   char * retval;
    1456   char * c;
    1457   size_t i;
    1458 
    1459   SL_ENTER(_("sh_util_filename"));
    1460 
    1461   ASSERT_RET ((fullpath != NULL), _("fullpath != NULL"), (NULL))
    1462 
    1463   c = strrchr(fullpath, '/');
    1464   i = sl_strlen (c);
    1465   if (i <= 1) SL_RETURN(NULL, _("sh_util_filename")); /* ends in '/' */
    1466   ++c;
    1467   --i;
    1468 
    1469   retval = SH_ALLOC(i + 1);
    1470 
    1471   (void) sl_strlcpy (retval, c, i+1);
    1472 
    1473   SL_RETURN(retval, _("sh_util_filename"));
    14741507}
    14751508
     
    14841517  char          oct[32];
    14851518  char          format[16];
     1519  size_t        len;
    14861520
    14871521  SL_ENTER(_("sh_util_safe_name"));
     
    15001534  */
    15011535
     1536  len = sl_strlen(name);
     1537  p   = name;
     1538
    15021539#ifdef SH_USE_XML
    1503   retval = SH_ALLOC(6 * sl_strlen(name) + 2);
     1540  if (sl_ok_muls (6, len) && sl_ok_adds ((6*len), 2))
     1541    { retval = SH_ALLOC(6 * len + 2); }
     1542  else
     1543    {
     1544      /* return an allocated array
     1545       */
     1546      retval = SH_ALLOC(11);
     1547      (void) sl_strlcpy(retval, _("(overflow)"), 11);
     1548      SL_RETURN(retval, _("sh_util_safe_name"));
     1549    }
    15041550#else
    1505   retval = SH_ALLOC(4 * sl_strlen(name) + 2);
     1551  if (sl_ok_muls (4, len) && sl_ok_adds ((4*len), 2))
     1552    { retval = SH_ALLOC(4 * len + 2); }
     1553  else
     1554    {
     1555      /* return an allocated array
     1556       */
     1557      retval = SH_ALLOC(11);
     1558      (void) sl_strlcpy(retval, _("(overflow)"), 11);
     1559      SL_RETURN(retval, _("sh_util_safe_name"));
     1560    }
    15061561#endif
    15071562
    15081563  (void) sl_strncpy(format, _("%c%03o"), 16);
    1509 
    1510   p = name;
    15111564
    15121565  while (*p != '\0') {
     
    16131666char * sh_util_strconcat (const char * arg1, ...)
    16141667{
    1615   size_t    length;
     1668  size_t    length, l2;
    16161669  char    * s;
    16171670  char    * strnew;
     
    16281681  while (s != NULL)
    16291682    {
    1630       length = length + sl_strlen (s);
     1683      l2 = sl_strlen (s);
     1684      if (sl_ok_adds(length, l2))
     1685        length += l2;
     1686      else
     1687        SL_RETURN(NULL, _("sh_util_strconcat"));
    16311688      s = va_arg (vl, char * );
    16321689    }
    16331690  va_end (vl);
    16341691
    1635   strnew = SH_ALLOC( length + 2 );
     1692  if (sl_ok_adds(length, 2))
     1693    strnew = SH_ALLOC( length + 2 );
     1694  else
     1695    SL_RETURN(NULL, _("sh_util_strconcat"));
     1696
    16361697  strnew[0] = '\0';
    16371698
     
    16801741  if (status != 0 && status != REG_NOMATCH)
    16811742    {
    1682       errbuf = SH_ALLOC(BUFSIZ+2);
     1743      errbuf = SH_ALLOC(BUFSIZ);
    16831744      (void) regerror(status, &preg, errbuf, BUFSIZ);
    1684       errbuf[BUFSIZ] = '\0';
     1745      errbuf[BUFSIZ-1] = '\0';
    16851746      sh_error_handle ((-1), FIL__, __LINE__, status, MSG_E_REGEX,
    16861747                       errbuf, regex_str);
Note: See TracChangeset for help on using the changeset viewer.