profile_create_node: set magic before strdup(name) to avoid memory leak
PATCH v2 1/12 profile_create_node: set magic before strdup(name) to avoid memory leak
If new->magic != PROF_MAGIC_NODE, profile_free_node() don't free node. This will cause the node to be unable to be released correctly and a memory leak will occur.
--- lib/support/profile.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
lib/support/profile.c +2 -1
@@ -1093,6 +1093,8 @@ errcode_t profile_create_node(const char *name, const char *value,if (!new)return ENOMEM ;memset (new,0 ,sizeof (struct profile_node )); + new->magic =PROF_MAGIC_NODE ; + new->name =strdup (name);if (new->name ==0 ) {profile_free_node (new);
@@ -1105,7 +1107,6 @@ errcode_t profile_create_node(const char *name, const char *value,return ENOMEM ; } } - new->magic =PROF_MAGIC_NODE ; *ret_node = new;return 0 ;
Signature · 1 line
2.19.1
PATCH v2 2/12 tdb_transaction_recover: fix memory leak
In tdb_transaction_recover(), need free data before return, otherwise it will cause memory leak.
--- lib/ext2fs/tdb.c | 1 + 1 file changed, 1 insertion(+)
lib/ext2fs/tdb.c +1 -0
@@ -2186,6 +2186,7 @@ int tdb_transaction_recover(struct tdb_context *tdb) rec.data_len, 0) == -1) {TDB_LOG ((tdb,TDB_DEBUG_FATAL ,"tdb_transaction_recover: failed to read recovery data\n" )); tdb->ecode =TDB_ERR_IO ; +free (data);return -1 ; }
Signature · 1 line
2.19.1
Theodore Y. Ts'o
AppliedRe: [PATCH v2 02/12] tdb_transaction_recover: fix memory leak
Quoted 6 lines · wuguanghao
In
tdb_transaction_recover(), need free data before return, otherwise it will cause memory leak.Signed-off-by Wu Guanghao <[email protected]>Signed-off-by Zhiqiang Liu <[email protected]>Reviewed-by Wu Bo <[email protected]>
Thanks, applied.
- Ted
PATCH v2 3/12 zap_sector: fix memory leak
In reply to wuguanghaoIn zap_sector(), need free buf before return, otherwise it will cause memory leak.
--- misc/mke2fs.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
misc/mke2fs.c +3 -1
@@ -585,8 +585,10 @@ static void zap_sector(ext2_filsys fs, int sect, int nsect)else { magic = (unsigned int *) (buf +BSD_LABEL_OFFSET );if ((*magic ==BSD_DISKMAGIC ) || - (*magic ==BSD_MAGICDISK )) + (*magic ==BSD_MAGICDISK )) { +free (buf);return ; + } } }
Signature · 1 line
2.19.1
Theodore Y. Ts'o
AppliedRe: [PATCH v2 03/12] zap_sector: fix memory leak
Quoted 6 lines · wuguanghao
In
zap_sector(), need free buf before return, otherwise it will cause memory leak.Signed-off-by Wu Guanghao <[email protected]>Signed-off-by Zhiqiang Liu <[email protected]>Reviewed-by Wu Bo <[email protected]>
Thanks, applied.
- Ted
PATCH v2 4/12 ss_add_info_dir: fix memory leak and check whether
In reply to wuguanghaoIn ss_add_info_dir(), need free info->info_dirs before return, otherwise it will cause memory leak. At the same time, it is necessary to check whether dirs[n_dirs] is a null pointer, otherwise a segmentation fault will occur.
--- lib/ss/help.c | 5 +++++ 1 file changed, 5 insertions(+)
lib/ss/help.c +5 -0
@@ -148,6 +148,7 @@ void ss_add_info_dir(int sci_idx, char *info_dir, int *code_ptr) dirs = (char **)realloc ((char *)dirs, (unsigned )(n_dirs +2 )*sizeof (char *));if (dirs == (char **)NULL ) { +free (info->info_dirs); info->info_dirs = (char **)NULL ; *code_ptr = errno;return ;
@@ -155,6 +156,10 @@ void ss_add_info_dir(int sci_idx, char *info_dir, int *code_ptr) info->info_dirs = dirs; dirs[n_dirs +1 ] = (char *)NULL ; dirs[n_dirs] =malloc ((unsigned )strlen (info_dir)+1 ); +if (dirs[n_dirs] == (char *)NULL ) { + *code_ptr = errno; +return ; + }strcpy (dirs[n_dirs], info_dir); *code_ptr =0 ; }
Signature · 1 line
2.19.1
Re: [PATCH v2 04/12] ss_add_info_dir: fix memory leak and check whether
Quoted 17 lines · wuguanghao
In
ss_add_info_dir(), need freeinfo->info_dirsbefore return, otherwise it will cause memory leak. At the same time, it is necessary to check whether dirs[n_dirs] is a null pointer, otherwise a segmentation fault will occur.Signed-off-by Wu Guanghao <[email protected]>Signed-off-by Zhiqiang Liu <[email protected]>Reviewed-by Wu Bo <[email protected]>--- lib/ss/help.c | 5 +++++ 1 file changed, 5 insertions(+)lib/ss/help.c +0
-0
lib/ss/help.c void ss_add_info_dir(int sci_idx, char *info_dir, int *code_ptr) · line 154
Quoted 7 lines
lib/ss/help.c +1
-0@@ -148,6 +148,7 @@ void ss_add_info_dir(int sci_idx, char *info_dir, int *code_ptr) dirs = (char **)realloc ((char *)dirs, (unsigned )(n_dirs +2 )*sizeof (char *));if (dirs == (char **)NULL ) { +free (info->info_dirs); info->info_dirs = (char **)NULL ; *code_ptr = errno;return ;
Adding the free() isn't right fix. The real problem is that this line should be removed:
info->info_dirs = (char **)NULL;
The function is trying to add a string (a directory name) to list, and the realloc() is trying to extend the list. If the realloc fils, we shouldn't be zapping the original list. We should just be returning, and leaving the original list of directories unchanged and untouched.
- Ted
Re: [PATCH v2 04/12] ss_add_info_dir: fix memory leak and check whether
Quoted 28 lines · Theodore Y. Ts'o
Quoted 17 lines · wuguanghao
In
ss_add_info_dir(), need freeinfo->info_dirsbefore return, otherwise it will cause memory leak. At the same time, it is necessary to check whether dirs[n_dirs] is a null pointer, otherwise a segmentation fault will occur.Signed-off-by Wu Guanghao <[email protected]>Signed-off-by Zhiqiang Liu <[email protected]>Reviewed-by Wu Bo <[email protected]>--- lib/ss/help.c | 5 +++++ 1 file changed, 5 insertions(+)lib/ss/help.c +0
-0lib/ss/help.c void ss_add_info_dir(int sci_idx, char *info_dir, int *code_ptr) · line 154
Quoted 7 lines
lib/ss/help.c +1
-0@@ -148,6 +148,7 @@ void ss_add_info_dir(int sci_idx, char *info_dir, int *code_ptr) dirs = (char **)realloc ((char *)dirs, (unsigned )(n_dirs +2 )*sizeof (char *));if (dirs == (char **)NULL ) { +free (info->info_dirs); info->info_dirs = (char **)NULL ; *code_ptr = errno;return ;Adding the
free()isn't right fix. The real problem is that this line should be removed:
Quoted 8 lines
info->info_dirs = (char **)NULL;The function is trying to add a string (a directory name) to list, and the
realloc()is trying to extend the list. If the realloc fils, we shouldn't be zapping the original list. We should just be returning, and leaving the original list of directories unchanged and untouched.- Ted
Thanks for your patient reply.
We will correct that in v3 patch.
Quoted 2 lines
.
PATCH v2 5/12 ss_create_invocation: fix memory leak and check whether NULL pointer
In reply to wuguanghaoIn ss_create_invocation(), it is necessary to check whether returned by malloc is a null pointer.
--- lib/ss/invocation.c | 38 ++++++++++++++++++++++++++++++++------ 1 file changed, 32 insertions(+), 6 deletions(-)
lib/ss/invocation.c +32 -6
@@ -29,26 +29,31 @@ int ss_create_invocation(const char *subsystem_name, const char *version_string, registerint sci_idx; registerss_data *new_table; registerss_data **table; + registerss_data **realloc_table; *code_ptr =0 ; table = _ss_table; new_table = (ss_data *)malloc (sizeof (ss_data)); +if (new_table ==NULL ) + goto out;if (table == (ss_data **)NULL ) { table = (ss_data **)malloc (2 * size); +if (table ==NULL ) + goto free_new_table; table[0 ] = table[1 ] = (ss_data *)NULL ; }initialize_ss_error_table ();for (sci_idx =1 ; table[sci_idx] != (ss_data *)NULL ; sci_idx++) ; - table = (ss_data **)realloc ((char *)table, + realloc_table = (ss_data **)realloc ((char *)table, ((unsigned )sci_idx+2 )*size); -if (table ==NULL ) { - *code_ptr =ENOMEM ; -free (new_table); -return 0 ; - } +if (realloc_table ==NULL ) + goto free_table; + + table = realloc_table; + table[sci_idx+1 ] = (ss_data *)NULL ; table[sci_idx] = new_table;
@@ -57,9 +62,15 @@ int ss_create_invocation(const char *subsystem_name, const char *version_string, new_table->argv = (char **)NULL ; new_table->current_request = (char *)NULL ; new_table->info_dirs = (char **)malloc (sizeof (char *)); +if (new_table->info_dirs ==NULL ) + goto free_table; + *new_table->info_dirs = (char *)NULL ; new_table->info_ptr = info_ptr; new_table->prompt =malloc ((unsigned )strlen (subsystem_name)+4 ); +if (new_table->prompt ==NULL ) + goto free_info_dirs; +strcpy (new_table->prompt, subsystem_name);strcat (new_table->prompt,": " );#ifdef silly
@@ -71,6 +82,9 @@ int ss_create_invocation(const char *subsystem_name, const char *version_string, new_table->flags.abbrevs_disabled =0 ; new_table->rqt_tables = (ss_request_table **)calloc (2 ,sizeof (ss_request_table *)); +if (new_table->rqt_tables ==NULL ) + goto free_prompt; + *(new_table->rqt_tables) = request_table_ptr; *(new_table->rqt_tables+1 ) = (ss_request_table *)NULL ;
@@ -85,6 +99,18 @@ int ss_create_invocation(const char *subsystem_name, const char *version_string,ss_get_readline (sci_idx);#endif return (sci_idx); + +free_prompt: +free (new_table->prompt); +free_info_dirs: +free (new_table->info_dirs); +free_table: +free (table); +free_new_table: +free (new_table); +out: + *code_ptr =ENOMEM ; +return 0 ; }void
Signature · 1 line
2.19.1
Re: [PATCH v2 05/12] ss_create_invocation: fix memory leak and check whether NULL pointer
Quoted 9 lines · wuguanghao
In
ss_create_invocation(), it is necessary to check whether returned by malloc is a null pointer.Signed-off-by Wu Guanghao <[email protected]>Signed-off-by Zhiqiang Liu <[email protected]>--- lib/ss/invocation.c | 38 ++++++++++++++++++++++++++++++++------ 1 file changed, 32 insertions(+), 6 deletions(-)
Instead of adding all of these goto targets (which is fragile if for some reason the code gets rearranged), it would be better to make sure everything that we might want to free is initialized, i.e.:
register ss_data *new_table = NULL; register ss_data **table = NULL;
new_table = (ss_data *) malloc(sizeof(ss_data)); if (!new_table) goto out; memset(new_table, 0, sizeof(ss_data));
and then exit path can just look like this:
out:
if (new_table) {
free(new_table->prompt);
free(new_table->info_dirs);
}
free(new_table);
free(table);
*code_ptr = ENOMEM;
return 0;... which is much cleaner, and means in the future, you don't need to figure out which goto label you might need to jump to.
Cheers,
- Ted
P.S. And if we are making all of these changes to the function's initializers, it might be a good time to zap the "register" keywords for any lines we are changing, or are nearby, while we're at it.
Re: [PATCH v2 05/12] ss_create_invocation: fix memory leak and check whether NULL pointer
Quoted 39 lines · Theodore Y. Ts'o
Quoted 9 lines · wuguanghao
In
ss_create_invocation(), it is necessary to check whether returned by malloc is a null pointer.Signed-off-by Wu Guanghao <[email protected]>Signed-off-by Zhiqiang Liu <[email protected]>--- lib/ss/invocation.c | 38 ++++++++++++++++++++++++++++++++------ 1 file changed, 32 insertions(+), 6 deletions(-)Instead of adding all of these goto targets (which is fragile if for some reason the code gets rearranged), it would be better to make sure everything that we might want to free is initialized, i.e.:
register ss_data *new_table = NULL; register ss_data **table = NULL;new_table = (ss_data *) malloc(sizeof(ss_data)); if (!new_table) goto out; memset(new_table, 0, sizeof(ss_data));and then exit path can just look like this:
out:
if (new_table) { free(new_table->prompt); free(new_table->info_dirs); } free(new_table); free(table); *code_ptr = ENOMEM; return 0;... which is much cleaner, and means in the future, you don't need to figure out which goto label you might need to jump to.
Cheers,
Quoted 7 lines
- Ted
P.S. And if we are making all of these changes to the function's initializers, it might be a good time to zap the "register" keywords for any lines we are changing, or are nearby, while we're at it..
Thanks for your suggestion.
We will rewrite the patch and remove the "register" keywords.
Regards
Zhiqiang Liu
.
PATCH v2 6/12 append_pathname: check the value returned by realloc
In reply to wuguanghaoIn append_pathname(), we need to add a new path to save the value returned by realloc, otherwise the name->path may be NULL, causing segfault
--- contrib/fsstress.c | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-)
contrib/fsstress.c +8 -2
@@ -599,7 +599,7 @@ void add_to_flist(int ft, int id, int parent)void append_pathname (pathname_t * name,char *str) {int len; - +char *path; len =strlen (str);#ifdef DEBUG if (len && *str =='/' && name->len ==0 ) {
@@ -609,7 +609,13 @@ void append_pathname(pathname_t * name, char *str) }#endif - name->path =realloc (name->path, name->len +1 + len); + path =realloc (name->path, name->len +1 + len); +if (path ==NULL ) { +fprintf (stderr,"fsstress: append_pathname realloc failed\n" ); +chdir (homedir); +abort (); + } + name->path = path;strcpy (&name->path[name->len], str); name->len += len; }
Signature · 1 line
2.19.1
Theodore Y. Ts'o
AppliedRe: [PATCH v2 06/12] append_pathname: check the value returned by realloc
Quoted 5 lines · wuguanghao
In
append_pathname(), we need to add a new path to save the value returned by realloc, otherwise thename->pathmay be NULL, causing segfaultSigned-off-by Wu Guanghao <[email protected]>Signed-off-by Zhiqiang Liu <[email protected]>
Thanks, applied, with a minor whitespace fixup, and the commit description linewrapped.
- Ted
PATCH v2 7/12 argv_parse: check return value of malloc in argv_parse()
In reply to wuguanghaoFrom: Zhiqiang Liu <[email protected]>
In argv_parse(), return value of malloc should be checked whether it is NULL, otherwise, it may cause a segfault error.
--- lib/support/argv_parse.c | 2 ++ 1 file changed, 2 insertions(+)
lib/support/argv_parse.c +2 -0
@@ -116,6 +116,8 @@ int argv_parse(char *in_buf, int *ret_argc, char ***ret_argv)if (argv ==0 ) { argv =malloc (sizeof (char *));free (buf); +if (!argv) +return -1 ; } argv[argc] =0 ;if (ret_argc)
Signature · 1 line
2.19.1
Theodore Y. Ts'o
AppliedRe: [PATCH v2 07/12] argv_parse: check return value of malloc in argv_parse()
Quoted 4 lines · wuguanghao
From: Zhiqiang Liu <[email protected]>
In
argv_parse(), return value of malloc should be checked whether it is NULL, otherwise, it may cause a segfault error.
Thanks, applied.
- Ted
PATCH v2 8/12 misc: fix potential segmentation fault problem in scandir()
In reply to wuguanghaoFrom: Zhiqiang Liu <[email protected]>
In scandir(), temp_list[num_dent] is allocated by calling malloc(), we should check whether malloc() returns NULL before accessing temp_list[num_dent].
--- misc/create_inode.c | 3 +++ 1 file changed, 3 insertions(+)
misc/create_inode.c +3 -0
@@ -771,6 +771,9 @@ static int scandir(const char *dir_name, struct dirent ***name_list, }// add the copy of dirent to the list temp_list[num_dent] = (struct dirent *)malloc ((dent->d_reclen +3 ) & ~3 ); +if (!temp_list[num_dent]) { + goto out; + }memcpy (temp_list[num_dent], dent, dent->d_reclen); num_dent++; }
Signature · 1 line
2.19.1
Theodore Y. Ts'o
AppliedRe: [PATCH v2 08/12] misc: fix potential segmentation fault problem in scandir()
Quoted 8 lines · wuguanghao
From: Zhiqiang Liu <[email protected]>
In
scandir(), temp_list[num_dent] is allocated by callingmalloc(), we should check whethermalloc()returns NULL before accessing temp_list[num_dent].Signed-off-by Zhiqiang Liu <[email protected]>Signed-off-by Wu Guanghao <[email protected]>
Thanks, applied.
- Ted
PATCH v2 9/12 lib/ss/error.c: check return value malloc in ss_name()
In reply to wuguanghaoFrom: Zhiqiang Liu <[email protected]>
In ss_name(), we should check return value of malloc(), otherwise, it may cause a segmentation fault problem.
--- lib/ss/error.c | 2 ++ 1 file changed, 2 insertions(+)
lib/ss/error.c +2 -0
@@ -42,6 +42,8 @@ char *ss_name(int sci_idx) (strlen (infop->subsystem_name)+strlen (infop->current_request)+ 4)); +if (ret_val == (char *)NULL ) +return ((char *)NULL ); cp = ret_val; cp1 = infop->subsystem_name;while (*cp1)
Signature · 1 line
2.19.1
Theodore Y. Ts'o
AppliedRe: [PATCH v2 09/12] lib/ss/error.c: check return value malloc in ss_name()
Quoted 4 lines · wuguanghao
From: Zhiqiang Liu <[email protected]>
In
ss_name(), we should check return value ofmalloc(), otherwise, it may cause a segmentation fault problem.
Thanks, applied.
- Ted
PATCH v2 10/12 hashmap: change return value type of ext2fs_hashmap_add()
In reply to wuguanghaoFrom: Zhiqiang Liu <[email protected]>
In ext2fs_hashmap_add(), new entry is allocated by calling malloc(). If malloc() return NULL, it will cause a segmentation fault problem.
Here, we change return value type of ext2fs_hashmap_add() from void to int. If allocating new entry fails, we will return 1, and the callers should also verify the return value of ext2fs_hashmap_add().
--- contrib/android/base_fs.c | 12 +++++++++--- lib/ext2fs/fileio.c | 10 ++++++++-- lib/ext2fs/hashmap.c | 12 ++++++++++-- lib/ext2fs/hashmap.h | 4 ++-- 4 files changed, 29 insertions(+), 9 deletions(-)
contrib/android/base_fs.c +9 -3
@@ -110,10 +110,16 @@ struct ext2fs_hashmap *basefs_parse(const char *file, const char *mountpoint)if (!entries) goto end; -while ((entry =basefs_readline (f, mountpoint, &err))) -ext2fs_hashmap_add (entries, entry, entry->path, +while ((entry =basefs_readline (f, mountpoint, &err))) { + err =ext2fs_hashmap_add (entries, entry, entry->path,strlen (entry->path)); - +if (err) { +free_base_fs_entry (entry); +fclose (f); +ext2fs_hashmap_free (entries); +return NULL ; + } + }if (err) {fclose (f);ext2fs_hashmap_free (entries);
lib/ext2fs/fileio.c +8 -2
@@ -475,8 +475,14 @@ errcode_t ext2fs_file_write(ext2_file_t file, const void *buf,if (new_block) { new_block->physblock = file->physblock; -ext2fs_hashmap_add (fs->block_sha_map, new_block, - new_block->sha,sizeof (new_block->sha)); +int ret =ext2fs_hashmap_add (fs->block_sha_map, + new_block, new_block->sha, +sizeof (new_block->sha)); +if (ret) { + retval =EXT2_ET_NO_MEMORY ; +free (new_block); + goto fail; + } }if (bmap_flags &BMAP_SET ) {
lib/ext2fs/hashmap.c +10 -2
@@ -36,6 +36,9 @@ struct ext2fs_hashmap *ext2fs_hashmap_create( {struct ext2fs_hashmap *h =calloc (sizeof (struct ext2fs_hashmap ) +sizeof (struct ext2fs_hashmap_entry ) * size,1 ); +if (!h) +return NULL ; + h->size = size; h->free = free_fct; h->hash = hash_fct;
@@ -43,12 +46,15 @@ struct ext2fs_hashmap *ext2fs_hashmap_create(return h; } -void ext2fs_hashmap_add (struct ext2fs_hashmap *h,void *data,const void *key, -size_t key_len) +int ext2fs_hashmap_add (struct ext2fs_hashmap *h, +void *data,const void *key,size_t key_len) {uint32_t hash = h->hash (key, key_len) % h->size;struct ext2fs_hashmap_entry *e =malloc (sizeof (*e)); +if (!e) +return -1 ; + e->data = data; e->key = key; e->key_len = key_len;
@@ -62,6 +68,8 @@ void ext2fs_hashmap_add(struct ext2fs_hashmap *h, void *data, const void *key, h->first = e;if (!h->last) h->last = e; + +return 0 ; } void *ext2fs_hashmap_lookup(struct ext2fs_hashmap *h, const void *key,
lib/ext2fs/hashmap.h +2 -2
@@ -27,8 +27,8 @@ struct ext2fs_hashmap_entry {struct ext2fs_hashmap *ext2fs_hashmap_create (uint32_t (*hash_fct)(const void *,size_t ),void (*free_fct)(void *),size_t size); -void ext2fs_hashmap_add (struct ext2fs_hashmap *h,void *data,const void *key, -size_t key_len); +int ext2fs_hashmap_add (struct ext2fs_hashmap *h, +void *data,const void *key,size_t key_len);void *ext2fs_hashmap_lookup (struct ext2fs_hashmap *h,const void *key,size_t key_len); void *ext2fs_hashmap_iter_in_order(struct ext2fs_hashmap *h,
Signature · 1 line
2.19.1
Re: [PATCH v2 10/12] hashmap: change return value type of ext2fs_hashmap_add()
Quoted 10 lines · wuguanghao
From: Zhiqiang Liu <[email protected]>
In
ext2fs_hashmap_add(), new entry is allocated by callingmalloc(). Ifmalloc()return NULL, it will cause a segmentation fault problem.Here, we change return value type of
ext2fs_hashmap_add()from void to int. If allocating new entry fails, we will return 1, and the callers should also verify the return value ofext2fs_hashmap_add().
Changing the function signature of functions in libext2fs, which can be a shared library, is problematic, since it can potentially break callers who are depending on the existing shared library ABI.
In this case, making a function returning void return something else isn't quite so bad, but it still puts callers in a quandry, since they won't necessarily know if they have linked against an older library which is not returning an error (or not).
Unfortunately, there's no other way to fix this, and creating a new ext2fs_hashmap_add2() just to add a return code seems like overkill. Grumble.
I guess it's OK to do it, since there _probably_ aren't users of ext2fs_hashmap_add outside of e2fsprogs. But if we are going to make this change, we should really have ext2fs_hashmap_add return a errcode_t, like the other libext2fs functions.
- Ted
PATCH v2 11/12 misc/lsattr: check whether path is NULL in lsattr_dir_proc()
In reply to wuguanghaoFrom: Zhiqiang Liu <[email protected]>
In lsattr_dir_proc(), if malloc() return NULL, it will cause a segmentation fault problem.
--- misc/lsattr.c | 6 ++++++ 1 file changed, 6 insertions(+)
misc/lsattr.c +6 -0
@@ -144,6 +144,12 @@ static int lsattr_dir_proc (const char * dir_name, struct dirent * de,int dir_len =strlen (dir_name); path =malloc (dir_len +strlen (de->d_name) +2 ); +if (!path) { +fprintf (stderr,"%s" , +_ ("Couldn't allocate path variable " +"in lsattr_dir_proc" )); +return -1 ; + }if (dir_len && dir_name[dir_len-1 ] =='/' )sprintf (path,"%s%s" , dir_name, de->d_name);
Signature · 1 line
2.19.1
Re: [PATCH v2 11/12] misc/lsattr: check whether path is NULL in lsattr_dir_proc()
Quoted 6 lines · wuguanghao
misc/lsattr.c +0
-0
misc/lsattr.c static int lsattr_dir_proc (const char * dir_name, struct dirent * de, · line 152
Quoted 9 lines
misc/lsattr.c +6
-0@@ -144,6 +144,12 @@ static int lsattr_dir_proc (const char * dir_name, struct dirent * de,int dir_len =strlen (dir_name); path =malloc (dir_len +strlen (de->d_name) +2 ); +if (!path) { +fprintf (stderr,"%s" , +_ ("Couldn't allocate path variable " +"in lsattr_dir_proc" )); +return -1 ; + }
The string is missing a closing newline. Also, why not?
fputs(_("Couldn't allocate path variable in lsattr_dir_proc"),
stderr);
- Ted
Re: [PATCH v2 11/12] misc/lsattr: check whether path is NULL in lsattr_dir_proc()
Quoted 17 lines · Theodore Y. Ts'o
Quoted 5 lines · wuguanghao
misc/lsattr.c +0
-0misc/lsattr.c static int lsattr_dir_proc (const char * dir_name, struct dirent * de, · line 152
Quoted 9 lines
misc/lsattr.c +6
-0@@ -144,6 +144,12 @@ static int lsattr_dir_proc (const char * dir_name, struct dirent * de,int dir_len =strlen (dir_name); path =malloc (dir_len +strlen (de->d_name) +2 ); +if (!path) { +fprintf (stderr,"%s" , +_ ("Couldn't allocate path variable " +"in lsattr_dir_proc" )); +return -1 ; + }The string is missing a closing newline. Also, why not?
Quoted 6 lines
fputs(_("Couldn't allocate path variable in
lsattr_dir_proc"),
stderr);- Ted
.
Thanks for your suggestion.
We will resend the v3 patch as your suggestion.
PATCH v2 12/12 ext2ed: fix potential NULL pointer dereference in dupstr()
In reply to wuguanghaoFrom: Zhiqiang Liu <[email protected]>
In dupstr(), we should check return value of malloc().
--- ext2ed/main.c | 2 ++ 1 file changed, 2 insertions(+)
ext2ed/main.c +2 -0
@@ -524,6 +524,8 @@ char *dupstr (char *src)char *ptr; ptr=(char *)malloc (strlen (src)+1 ); +if (!ptr) +return NULL ;strcpy (ptr,src);return (ptr); }
Signature · 1 line
2.19.1
Theodore Y. Ts'o
AppliedRe: [PATCH v2 12/12] ext2ed: fix potential NULL pointer dereference in dupstr()
Quoted 3 lines · wuguanghao
From: Zhiqiang Liu <[email protected]>
In
dupstr(), we should check return value ofmalloc().
Thanks, applied.
- Ted
Theodore Y. Ts'o
AppliedQuoted 7 lines · wuguanghao
If
new->magic!=PROF_MAGIC_NODE,profile_free_node()don't free node. This will cause the node to be unable to be released correctly and a memory leak will occur.Signed-off-by Wu Guanghao <[email protected]>Signed-off-by Zhiqiang Liu <[email protected]>Reviewed-by Wu Bo <[email protected]>
Applied, thanks.
- Ted