Changeset 382


Ignore:
Timestamp:
Dec 4, 2011, 6:26:15 PM (9 years ago)
Author:
katerina
Message:

Fix for ticket #280 (Memory leak in inotify related code).

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/docs/Changelog

    r381 r382  
    113.0.1:
     2        * fix a memory leak (reported by C. Westlake)
    23        * fix an uninitialized variable in the suidcheck code (problem
    34          reports by T- Luettgert and Kai)
    4         * fix a bug in the port check with --disable-ipv6 (reported by C. Westlake)
     5        * fix a bug in the port check with --disable-ipv6 (reported
     6          by C. Westlake)
    57        * fix potential deadlock in sh_files.c (reported by S. Mirolo)
    68        * change Makefile.in to stop on compile error rather than at link stage
  • trunk/include/sh_utils.h

    r373 r382  
    6565 */
    6666char * sh_util_strdup (const char * str) SH_GNUC_MALLOC;
     67char * sh_util_strdup_track (const char * str,
     68                             char * file, int line) SH_GNUC_MALLOC;
    6769
    6870/* returns allocated memory
  • trunk/src/sh_fInotify.c

    r376 r382  
    167167{
    168168  ssize_t len = -1;
    169   char *  buffer = SH_ALLOC(16384);
     169  char *  buffer;
    170170  static int count  = 0;
    171171  static int count2 = 0;
    172172
    173173  if (ShfInotifyActive == S_FALSE)
    174     return SH_MOD_FAILED;
     174    {
     175      return SH_MOD_FAILED;
     176    }
    175177
    176178  if ( (sh.flag.inotify & SH_INOTIFY_DOSCAN) ||
     
    178180    {
    179181      if (0 != sh_fInotify_init_internal())
    180         return SH_MOD_FAILED;
    181     }
     182        {
     183          return SH_MOD_FAILED;
     184        }
     185    }
     186
     187  buffer = SH_ALLOC(16384);
    182188
    183189  /* Blocking read from inotify file descriptor.
     
    203209        {
    204210          if (0 != sh_fInotify_init_internal())
    205            return SH_MOD_FAILED;
     211            {
     212              SH_FREE(buffer);
     213              return SH_MOD_FAILED;
     214            }
    206215        }
    207216     }
     
    230239    }
    231240
     241  SH_FREE(buffer);
    232242  return 0;
    233243}
     
    371381            }
    372382        }
     383      SH_FREE(filename);
    373384    }
    374385
  • trunk/src/sh_inotify.c

    r377 r382  
    246246}
    247247
    248 static sh_watch * sh_inotify_create_watch(const char * file, int nwatch, int flag)
     248static sh_watch * sh_inotify_create_watch(const char * file,
     249                                          int nwatch, int flag)
    249250{
    250251  sh_watch * this = SH_ALLOC(sizeof(sh_watch));
    251252
    252   this->file  = sh_util_strdup(file);
     253  this->file  = sh_util_strdup_track(file, __FILE__, __LINE__);
    253254  this->watch = nwatch;
    254255  this->flag  = flag;
     
    378379      *rdepth = this->watch->rdepth;
    379380      *check_mask = this->watch->check_mask;
    380       popret  = sh_util_strdup(this->watch->file);
     381      popret  = sh_util_strdup_track(this->watch->file, __FILE__, __LINE__);
    381382
    382383      watches->dormant_watches = this->next;
     
    477478int sh_inotify_add_watch_later(const char * filename, sh_watches * watches,
    478479                               int * errnum,
    479                                int class, unsigned long check_mask, int type, int rdepth)
     480                               int class, unsigned long check_mask, int type,
     481                               int rdepth)
    480482{
    481483  sh_watch   * item;
     
    645647            {
    646648              *errnum = ENOMEM;
     649              sh_inotify_free_watch(item);
    647650              retval = -1;
    648651              goto retpoint;
     
    694697      *type       = item->type;
    695698      *rdepth     = item->rdepth;
    696       sret = sh_util_strdup(item->file);
     699      sret = sh_util_strdup_track(item->file, __FILE__, __LINE__);
    697700    }
    698701  SH_MUTEX_UNLOCK(mutex_watches);
  • trunk/src/sh_utils.c

    r373 r382  
    329329      if        (0 == strncmp((char *) p, "user", 4)) {
    330330        out[rem] = 'u'; ++rem;
    331         p += 3; state = 1;
     331        p += 3;
    332332      } else if (0 == strncmp((char *) p, "group", 5)) {
    333333        out[rem] = 'g'; ++rem;
    334         p += 4; state = 1;
     334        p += 4;
    335335      } else if (0 == strncmp((char *) p, "mask", 4)) {
    336336        out[rem] = 'm'; ++rem;
    337         p += 3; state = 1;
     337        p += 3;
    338338      } else if (0 == strncmp((char *) p, "other", 5)) {
    339339        out[rem] = 'o';
    340         p += 4; state = 1; ++rem;
     340        p += 4; ++rem;
    341341      } else if (*p == '\0') {
    342342        if (rem > 0) { out[rem-1] = '\0'; }
     
    366366  SH_VALIDATE_NE(len, 0);
    367367
    368   if (sl_ok_adds (len, 1))
     368  if (str && sl_ok_adds (len, 1))
    369369    {
    370370      p   = SH_ALLOC (len + 1);
     
    387387  SH_VALIDATE_NE(str, NULL);
    388388
    389   len = sl_strlen(str);
    390   p   = SH_ALLOC (len + 1);
    391   (void) memcpy (p, str, len+1);
    392 
     389  if (str)
     390    {
     391      len = sl_strlen(str);
     392      p   = SH_ALLOC (len + 1);
     393      (void) memcpy (p, str, len+1);
     394    }
    393395  SL_RETURN( p, _("sh_util_strdup"));
     396}
     397
     398char * sh_util_strdup_track (const char * str, char * file, int line)
     399{
     400  char * p = NULL;
     401  size_t len;
     402
     403  SL_ENTER(_("sh_util_strdup_track"));
     404
     405  SH_VALIDATE_NE(str, NULL);
     406
     407  if (str)
     408    {
     409      len = sl_strlen(str);
     410      p   = SH_OALLOC (len + 1, file, line);
     411      (void) memcpy (p, str, len+1);
     412    }
     413  SL_RETURN( p, _("sh_util_strdup_track"));
    394414}
    395415
     
    407427  SH_VALIDATE_NE(ret, NULL);
    408428
    409   for (c = *str; *c != '\0'; c++) {
    410     for (d = delim; *d != '\0'; d++) {
    411       if (*c == *d) {
    412         *c = '\0';
    413         *str = c + 1;
    414         SL_RETURN(ret, _("sh_util_strsep"));
     429  if (*str)
     430    {
     431      for (c = *str; *c != '\0'; c++) {
     432        for (d = delim; *d != '\0'; d++) {
     433          if (*c == *d) {
     434            *c = '\0';
     435            *str = c + 1;
     436            SL_RETURN(ret, _("sh_util_strsep"));
     437          }
     438        }
    415439      }
    416440    }
    417   }
    418441
    419442  /* If we get to here, there's no delimiters in the string */
     
    19601983        }
    19611984
    1962       c = strrchr(tmp2, '/');
    1963       if (c)
    1964         {
    1965           retval = sh_util_strdup(++c);
    1966           SH_FREE(tmp2);
    1967         }
    1968       else
    1969         {
    1970           retval = tmp2;
     1985      if (tmp2) /* for llvm/clang analyzer */
     1986        {
     1987          c = strrchr(tmp2, '/');
     1988          if (c)
     1989            {
     1990              retval = sh_util_strdup(++c);
     1991              SH_FREE(tmp2);
     1992            }
     1993          else
     1994            {
     1995              retval = tmp2;
     1996            }
    19711997        }
    19721998    }
Note: See TracChangeset for help on using the changeset viewer.