libmount: fix mount.nfs segfault, rely on assert() rather than on nonnull

We use
   mnt_optstr_append_option(&o, mnt_fs_get_vfs_options(fs), NULL);

in mount.nfs, unfortunately mnt_optstr_append_option() has been marked
ass nonnull(1, 2). That's wrong because append and prepend should
robust enough to accept NULL as option name.

The patch also removes almost all __attribute__((nonnull). It seems
better to rely on assert() to have usable feedback. In many cases
(nonnull) is premature optimization for the library. This attribute
makes sense for things like strlen() or so...

Addresses: https://bugzilla.redhat.com/show_bug.cgi?id=948274
Signed-off-by: Karel Zak <kzak@redhat.com>

diff --git a/libmount/src/context.c b/libmount/src/context.c
index 614d3f3b5514092aa6f4557ea67d9864d2b1e522..38f80de7a882408778ab6292dede63130eb6a16c 100644 (file)
--- a/libmount/src/context.c
+++ b/libmount/src/context.c
@@ -196,6 +196,7 @@ int mnt_reset_context(struct libmnt_context *cxt)
  */
 int mnt_context_reset_status(struct libmnt_context *cxt)
 {
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
 
@@ -207,6 +208,7 @@ int mnt_context_reset_status(struct libmnt_context *cxt)
 
 static int set_flag(struct libmnt_context *cxt, int flag, int enable)
 {
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
        if (enable) {
@@ -227,7 +229,6 @@ static int set_flag(struct libmnt_context *cxt, int flag, int enable)
  */
 int mnt_context_is_restricted(struct libmnt_context *cxt)
 {
-       assert(cxt);
        return cxt->restricted;
 }
 
@@ -270,6 +271,7 @@ int mnt_context_is_restricted(struct libmnt_context *cxt)
  */
 int mnt_context_set_optsmode(struct libmnt_context *cxt, int mode)
 {
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
        cxt->optsmode = mode;
@@ -285,6 +287,7 @@ int mnt_context_set_optsmode(struct libmnt_context *cxt, int mode)
 
 int mnt_context_get_optsmode(struct libmnt_context *cxt)
 {
+       assert(cxt);
        return cxt->optsmode;
 }
 
@@ -663,6 +666,7 @@ int mnt_context_set_fs(struct libmnt_context *cxt, struct libmnt_fs *fs)
  */
 struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt)
 {
+       assert(cxt);
        if (!cxt)
                return NULL;
        if (!cxt->fs) {
@@ -681,6 +685,7 @@ struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt)
  */
 int mnt_context_set_source(struct libmnt_context *cxt, const char *source)
 {
+       assert(cxt);
        return mnt_fs_set_source(mnt_context_get_fs(cxt), source);
 }
 
@@ -692,6 +697,7 @@ int mnt_context_set_source(struct libmnt_context *cxt, const char *source)
  */
 const char *mnt_context_get_source(struct libmnt_context *cxt)
 {
+       assert(cxt);
        return mnt_fs_get_source(mnt_context_get_fs(cxt));
 }
 
@@ -704,6 +710,7 @@ const char *mnt_context_get_source(struct libmnt_context *cxt)
  */
 int mnt_context_set_target(struct libmnt_context *cxt, const char *target)
 {
+       assert(cxt);
        return mnt_fs_set_target(mnt_context_get_fs(cxt), target);
 }
 
@@ -715,6 +722,7 @@ int mnt_context_set_target(struct libmnt_context *cxt, const char *target)
  */
 const char *mnt_context_get_target(struct libmnt_context *cxt)
 {
+       assert(cxt);
        return mnt_fs_get_target(mnt_context_get_fs(cxt));
 }
 
@@ -731,6 +739,7 @@ const char *mnt_context_get_target(struct libmnt_context *cxt)
  */
 int mnt_context_set_fstype(struct libmnt_context *cxt, const char *fstype)
 {
+       assert(cxt);
        return mnt_fs_set_fstype(mnt_context_get_fs(cxt), fstype);
 }
 
@@ -742,6 +751,7 @@ int mnt_context_set_fstype(struct libmnt_context *cxt, const char *fstype)
  */
 const char *mnt_context_get_fstype(struct libmnt_context *cxt)
 {
+       assert(cxt);
        return mnt_fs_get_fstype(mnt_context_get_fs(cxt));
 }
 
@@ -754,6 +764,7 @@ const char *mnt_context_get_fstype(struct libmnt_context *cxt)
  */
 int mnt_context_set_options(struct libmnt_context *cxt, const char *optstr)
 {
+       assert(cxt);
        return mnt_fs_set_options(mnt_context_get_fs(cxt), optstr);
 }
 
@@ -766,6 +777,7 @@ int mnt_context_set_options(struct libmnt_context *cxt, const char *optstr)
  */
 int mnt_context_append_options(struct libmnt_context *cxt, const char *optstr)
 {
+       assert(cxt);
        return mnt_fs_append_options(mnt_context_get_fs(cxt), optstr);
 }
 
@@ -784,6 +796,7 @@ int mnt_context_append_options(struct libmnt_context *cxt, const char *optstr)
  */
 const char *mnt_context_get_options(struct libmnt_context *cxt)
 {
+       assert(cxt);
        return mnt_fs_get_options(mnt_context_get_fs(cxt));
 }
 
@@ -800,6 +813,7 @@ int mnt_context_set_fstype_pattern(struct libmnt_context *cxt, const char *patte
 {
        char *p = NULL;
 
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
        if (pattern) {
@@ -825,6 +839,7 @@ int mnt_context_set_options_pattern(struct libmnt_context *cxt, const char *patt
 {
        char *p = NULL;
 
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
        if (pattern) {
@@ -856,6 +871,7 @@ int mnt_context_set_options_pattern(struct libmnt_context *cxt, const char *patt
  */
 int mnt_context_set_fstab(struct libmnt_context *cxt, struct libmnt_table *tb)
 {
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
        if (!(cxt->flags & MNT_FL_EXTERN_FSTAB))
@@ -879,9 +895,9 @@ int mnt_context_get_fstab(struct libmnt_context *cxt, struct libmnt_table **tb)
 {
        struct libmnt_cache *cache;
 
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
-
        if (!cxt->fstab) {
                int rc;
 
@@ -921,9 +937,9 @@ int mnt_context_get_mtab(struct libmnt_context *cxt, struct libmnt_table **tb)
 {
        struct libmnt_cache *cache;
 
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
-
        if (!cxt->mtab) {
                int rc;
 
@@ -962,6 +978,7 @@ int mnt_context_set_tabfilter(struct libmnt_context *cxt,
                              int (*fltr)(struct libmnt_fs *, void *),
                              void *data)
 {
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
 
@@ -1002,6 +1019,8 @@ int mnt_context_get_table(struct libmnt_context *cxt,
        struct libmnt_cache *cache;
        int rc;
 
+       assert(cxt);
+       assert(tb);
        if (!cxt || !tb)
                return -EINVAL;
 
@@ -1042,6 +1061,7 @@ int mnt_context_get_table(struct libmnt_context *cxt,
 int mnt_context_set_tables_errcb(struct libmnt_context *cxt,
        int (*cb)(struct libmnt_table *tb, const char *filename, int line))
 {
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
 
@@ -1085,6 +1105,7 @@ int mnt_context_set_cache(struct libmnt_context *cxt, struct libmnt_cache *cache
  */
 struct libmnt_cache *mnt_context_get_cache(struct libmnt_context *cxt)
 {
+       assert(cxt);
        if (!cxt || mnt_context_is_nocanonicalize(cxt))
                return NULL;
 
@@ -1112,9 +1133,9 @@ int mnt_context_set_passwd_cb(struct libmnt_context *cxt,
                              char *(*get)(struct libmnt_context *),
                              void (*release)(struct libmnt_context *, char *))
 {
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
-
        cxt->pwd_get_cb = get;
        cxt->pwd_release_cb = release;
        return 0;
@@ -1142,6 +1163,7 @@ int mnt_context_set_passwd_cb(struct libmnt_context *cxt,
  */
 struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt)
 {
+       assert(cxt);
        /*
         * DON'T call this function within libmount, it will always allocate
         * the lock. The mnt_update_* functions are able to allocate the lock
@@ -1181,6 +1203,7 @@ struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt)
  */
 int mnt_context_set_mflags(struct libmnt_context *cxt, unsigned long flags)
 {
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
 
@@ -1213,6 +1236,8 @@ int mnt_context_get_mflags(struct libmnt_context *cxt, unsigned long *flags)
        int rc = 0;
        struct list_head *p;
 
+       assert(cxt);
+       assert(flags);
        if (!cxt || !flags)
                return -EINVAL;
 
@@ -1249,6 +1274,7 @@ int mnt_context_get_mflags(struct libmnt_context *cxt, unsigned long *flags)
  */
 int mnt_context_set_user_mflags(struct libmnt_context *cxt, unsigned long flags)
 {
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
        cxt->user_mountflags = flags;
@@ -1268,6 +1294,9 @@ int mnt_context_set_user_mflags(struct libmnt_context *cxt, unsigned long flags)
 int mnt_context_get_user_mflags(struct libmnt_context *cxt, unsigned long *flags)
 {
        int rc = 0;
+
+       assert(cxt);
+       assert(flags);
        if (!cxt || !flags)
                return -EINVAL;
 
@@ -1299,6 +1328,7 @@ int mnt_context_get_user_mflags(struct libmnt_context *cxt, unsigned long *flags
  */
 int mnt_context_set_mountdata(struct libmnt_context *cxt, void *data)
 {
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
        cxt->mountdata = data;
@@ -1908,6 +1938,7 @@ int mnt_context_apply_fstab(struct libmnt_context *cxt)
  */
 int mnt_context_tab_applied(struct libmnt_context *cxt)
 {
+       assert(cxt);
        return cxt->flags & MNT_FL_TAB_APPLIED;
 }
 
@@ -1949,6 +1980,7 @@ int mnt_context_propagation_only(struct libmnt_context *cxt)
  */
 int mnt_context_get_status(struct libmnt_context *cxt)
 {
+       assert(cxt);
        return !cxt->syscall_status || !cxt->helper_exec_status;
 }
 
@@ -1960,6 +1992,7 @@ int mnt_context_get_status(struct libmnt_context *cxt)
  */
 int mnt_context_helper_executed(struct libmnt_context *cxt)
 {
+       assert(cxt);
        return cxt->helper_exec_status != 1;
 }
 
@@ -1972,6 +2005,7 @@ int mnt_context_helper_executed(struct libmnt_context *cxt)
  */
 int mnt_context_get_helper_status(struct libmnt_context *cxt)
 {
+       assert(cxt);
        return cxt->helper_status;
 }
 
@@ -1983,6 +2017,7 @@ int mnt_context_get_helper_status(struct libmnt_context *cxt)
  */
 int mnt_context_syscall_called(struct libmnt_context *cxt)
 {
+       assert(cxt);
        return cxt->syscall_status != 1;
 }
 
@@ -1997,9 +2032,9 @@ int mnt_context_syscall_called(struct libmnt_context *cxt)
  */
 int mnt_context_get_syscall_errno(struct libmnt_context *cxt)
 {
+       assert(cxt);
        if (cxt->syscall_status < 0)
                return -cxt->syscall_status;
-
        return 0;
 }
 
@@ -2017,6 +2052,7 @@ int mnt_context_get_syscall_errno(struct libmnt_context *cxt)
  */
 int mnt_context_set_syscall_status(struct libmnt_context *cxt, int status)
 {
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
 
@@ -2063,8 +2099,11 @@ int mnt_context_strerror(struct libmnt_context *cxt __attribute__((__unused__)),
 int mnt_context_init_helper(struct libmnt_context *cxt, int action,
                            int flags __attribute__((__unused__)))
 {
-       int rc = mnt_context_disable_helpers(cxt, TRUE);
+       int rc;
 
+       assert(cxt);
+
+       rc = mnt_context_disable_helpers(cxt, TRUE);
        if (!rc)
                rc = set_flag(cxt, MNT_FL_HELPER, 1);
        if (!rc)
@@ -2115,6 +2154,7 @@ int mnt_context_is_fs_mounted(struct libmnt_context *cxt,
        struct libmnt_table *mtab;
        int rc;
 
+       assert(cxt);
        if (!cxt || !fs || !mounted)
                return -EINVAL;
 
@@ -2130,6 +2170,7 @@ static int mnt_context_add_child(struct libmnt_context *cxt, pid_t pid)
 {
        pid_t *pids;
 
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
 
@@ -2149,6 +2190,7 @@ int mnt_fork_context(struct libmnt_context *cxt)
        int rc = 0;
        pid_t pid;
 
+       assert(cxt);
        if (!mnt_context_is_parent(cxt))
                return -EINVAL;
 
@@ -2182,6 +2224,7 @@ int mnt_context_wait_for_children(struct libmnt_context *cxt,
 {
        int i;
 
+       assert(cxt);
        if (!cxt)
                return -EINVAL;
 

diff --git a/libmount/src/fs.c b/libmount/src/fs.c
index bb9006dee5b9f156109282615e69fc32a355cb97..c95cdc7e759c6cff146b0e840b18ad59009ac6ad 100644 (file)
--- a/libmount/src/fs.c
+++ b/libmount/src/fs.c
@@ -131,7 +131,6 @@ struct libmnt_fs *mnt_copy_fs(struct libmnt_fs *dest,
 
        if (!src)
                return NULL;
-
        if (!dest) {
                dest = mnt_new_fs();
                if (!dest)
@@ -197,6 +196,7 @@ struct libmnt_fs *mnt_copy_mtab_fs(const struct libmnt_fs *fs)
 {
        struct libmnt_fs *n = mnt_new_fs();
 
+       assert(fs);
        if (!n)
                return NULL;
 
@@ -249,6 +249,7 @@ err:
  */
 void *mnt_fs_get_userdata(struct libmnt_fs *fs)
 {
+       assert(fs);
        return fs ? fs->userdata : NULL;
 }
 
@@ -263,6 +264,7 @@ void *mnt_fs_get_userdata(struct libmnt_fs *fs)
  */
 int mnt_fs_set_userdata(struct libmnt_fs *fs, void *data)
 {
+       assert(fs);
        if (!fs)
                return -EINVAL;
        fs->userdata = data;
@@ -303,6 +305,7 @@ const char *mnt_fs_get_srcpath(struct libmnt_fs *fs)
  */
 const char *mnt_fs_get_source(struct libmnt_fs *fs)
 {
+       assert(fs);
        return fs ? fs->source : NULL;
 }
 
@@ -346,6 +349,7 @@ int mnt_fs_set_source(struct libmnt_fs *fs, const char *source)
        char *p = NULL;
        int rc;
 
+       assert(fs);
        if (!fs)
                return -EINVAL;
 
@@ -375,6 +379,7 @@ int mnt_fs_streq_srcpath(struct libmnt_fs *fs, const char *path)
 {
        const char *p;
 
+       assert(fs);
        if (!fs)
                return 0;
 
@@ -401,6 +406,7 @@ int mnt_fs_streq_srcpath(struct libmnt_fs *fs, const char *path)
  */
 int mnt_fs_streq_target(struct libmnt_fs *fs, const char *path)
 {
+       assert(fs);
        return fs && streq_except_trailing_slash(mnt_fs_get_target(fs), path);
 }
 
@@ -439,6 +445,7 @@ int mnt_fs_streq_target(struct libmnt_fs *fs, const char *path)
  */
 int mnt_fs_get_tag(struct libmnt_fs *fs, const char **name, const char **value)
 {
+       assert(fs);
        if (fs == NULL || !fs->tagname)
                return -EINVAL;
        if (name)
@@ -474,7 +481,6 @@ int mnt_fs_set_target(struct libmnt_fs *fs, const char *target)
        char *p = NULL;
 
        assert(fs);
-
        if (!fs)
                return -EINVAL;
        if (target) {
@@ -506,6 +512,7 @@ static int mnt_fs_get_flags(struct libmnt_fs *fs)
  */
 int mnt_fs_get_propagation(struct libmnt_fs *fs, unsigned long *flags)
 {
+       assert(fs);
        if (!fs || !flags)
                return -EINVAL;
 
@@ -547,6 +554,7 @@ int mnt_fs_is_kernel(struct libmnt_fs *fs)
  */
 int mnt_fs_is_swaparea(struct libmnt_fs *fs)
 {
+       assert(fs);
        return mnt_fs_get_flags(fs) & MNT_FS_SWAP;
 }
 
@@ -558,6 +566,7 @@ int mnt_fs_is_swaparea(struct libmnt_fs *fs)
  */
 int mnt_fs_is_pseudofs(struct libmnt_fs *fs)
 {
+       assert(fs);
        return mnt_fs_get_flags(fs) & MNT_FS_PSEUDO;
 }
 
@@ -569,6 +578,7 @@ int mnt_fs_is_pseudofs(struct libmnt_fs *fs)
  */
 int mnt_fs_is_netfs(struct libmnt_fs *fs)
 {
+       assert(fs);
        return mnt_fs_get_flags(fs) & MNT_FS_NET;
 }
 
@@ -622,6 +632,7 @@ int mnt_fs_set_fstype(struct libmnt_fs *fs, const char *fstype)
 {
        char *p = NULL;
 
+       assert(fs);
        if (!fs)
                return -EINVAL;
        if (fstype) {
@@ -700,9 +711,7 @@ char *mnt_fs_strdup_options(struct libmnt_fs *fs)
        char *res;
 
        assert(fs);
-
        errno = 0;
-
        if (fs->optstr)
                return strdup(fs->optstr);
 
@@ -758,7 +767,6 @@ int mnt_fs_set_options(struct libmnt_fs *fs, const char *optstr)
        char *v = NULL, *f = NULL, *u = NULL, *n = NULL;
 
        assert(fs);
-
        if (!fs)
                return -EINVAL;
        if (optstr) {
@@ -801,7 +809,6 @@ int mnt_fs_append_options(struct libmnt_fs *fs, const char *optstr)
        int rc;
 
        assert(fs);
-
        if (!fs)
                return -EINVAL;
        if (!optstr)
@@ -842,7 +849,6 @@ int mnt_fs_prepend_options(struct libmnt_fs *fs, const char *optstr)
        int rc;
 
        assert(fs);
-
        if (!fs)
                return -EINVAL;
        if (!optstr)
@@ -932,6 +938,7 @@ int mnt_fs_set_attributes(struct libmnt_fs *fs, const char *optstr)
 {
        char *p = NULL;
 
+       assert(fs);
        if (!fs)
                return -EINVAL;
        if (optstr) {
@@ -974,6 +981,7 @@ int mnt_fs_append_attributes(struct libmnt_fs *fs, const char *optstr)
  */
 int mnt_fs_prepend_attributes(struct libmnt_fs *fs, const char *optstr)
 {
+       assert(fs);
        if (!fs)
                return -EINVAL;
        if (!optstr)
@@ -1235,6 +1243,7 @@ int mnt_fs_get_option(struct libmnt_fs *fs, const char *name,
 {
        char rc = 1;
 
+       assert(fs);
        if (!fs)
                return -EINVAL;
        if (fs->fs_optstr)
@@ -1260,6 +1269,9 @@ int mnt_fs_get_attribute(struct libmnt_fs *fs, const char *name,
 {
        char rc = 1;
 
+       assert(fs);
+       if (!fs)
+               return -EINVAL;
        if (fs->attrs)
                rc = mnt_optstr_get_option(fs->attrs, name, value, valsz);
        return rc;
@@ -1286,6 +1298,7 @@ int mnt_fs_match_target(struct libmnt_fs *fs, const char *target,
 {
        int rc = 0;
 
+       assert(fs);
        if (!fs || !target || !fs->target)
                return 0;
 
@@ -1330,6 +1343,7 @@ int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
        char *cn;
        const char *src, *t, *v;
 
+       assert(fs);
        if (!fs)
                return 0;
 
@@ -1403,6 +1417,7 @@ int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
  */
 int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types)
 {
+       assert(fs);
        return mnt_match_fstype(fs->fstype, types);
 }
 
@@ -1418,6 +1433,7 @@ int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types)
  */
 int mnt_fs_match_options(struct libmnt_fs *fs, const char *options)
 {
+       assert(fs);
        return mnt_match_options(mnt_fs_get_options(fs), options);
 }
 
@@ -1430,7 +1446,7 @@ int mnt_fs_match_options(struct libmnt_fs *fs, const char *options)
  */
 int mnt_fs_print_debug(struct libmnt_fs *fs, FILE *file)
 {
-       if (!fs)
+       if (!fs || !file)
                return -EINVAL;
        fprintf(file, "------ fs: %p\n", fs);
        fprintf(file, "source: %s\n", mnt_fs_get_source(fs));
@@ -1514,6 +1530,8 @@ int mnt_fs_to_mntent(struct libmnt_fs *fs, struct mntent **mnt)
        int rc;
        struct mntent *m;
 
+       assert(fs);
+       assert(mnt);
        if (!fs || !mnt)
                return -EINVAL;
 

diff --git a/libmount/src/libmount.h.in b/libmount/src/libmount.h.in
index 1b5df82ac861c1b1d9c1ba5b1d203b1772c24898..db479e186543a6949ab94511664d767a084bcaeb 100644 (file)
--- a/libmount/src/libmount.h.in
+++ b/libmount/src/libmount.h.in
@@ -187,8 +187,7 @@ enum {
 extern void mnt_init_debug(int mask);
 
 /* version.c */
-extern int mnt_parse_version_string(const char *ver_string)
-                       __ul_attribute__((nonnull));
+extern int mnt_parse_version_string(const char *ver_string);
 extern int mnt_get_library_version(const char **ver_string);
 extern int mnt_get_library_features(const char ***features);
 
@@ -198,10 +197,8 @@ extern char *mnt_mangle(const char *str)
 extern char *mnt_unmangle(const char *str)
                        __ul_attribute__((warn_unused_result));
 
-extern int mnt_fstype_is_netfs(const char *type)
-                       __ul_attribute__((nonnull));
-extern int mnt_fstype_is_pseudofs(const char *type)
-                       __ul_attribute__((nonnull));
+extern int mnt_fstype_is_netfs(const char *type);
+extern int mnt_fstype_is_pseudofs(const char *type);
 
 extern int mnt_match_fstype(const char *type, const char *pattern)
                        __ul_attribute__((warn_unused_result));
@@ -212,7 +209,7 @@ extern const char *mnt_get_swaps_path(void);
 extern const char *mnt_get_mtab_path(void);
 extern int mnt_has_regular_mtab(const char **mtab, int *writable);
 extern char *mnt_get_mountpoint(const char *path)
-                       __ul_attribute__((nonnull, warn_unused_result));
+                       __ul_attribute__((warn_unused_result));
 
 /* cache.c */
 extern struct libmnt_cache *mnt_new_cache(void)
@@ -224,8 +221,7 @@ extern int mnt_cache_read_tags(struct libmnt_cache *cache, const char *devname);
 extern int mnt_cache_device_has_tag(struct libmnt_cache *cache,
                                const char *devname,
                                 const char *token,
-                               const char *value)
-                       __ul_attribute__((nonnull));
+                               const char *value);
 
 extern char *mnt_cache_find_tag_value(struct libmnt_cache *cache,
                                const char *devname, const char *token);
@@ -245,24 +241,18 @@ extern char *mnt_pretty_path(const char *path, struct libmnt_cache *cache)
 
 /* optstr.c */
 extern int mnt_optstr_next_option(char **optstr, char **name, size_t *namesz,
-                               char **value, size_t *valuesz)
-                       __ul_attribute__((nonnull(1)));
+                               char **value, size_t *valuesz);
 extern int mnt_optstr_append_option(char **optstr, const char *name,
-                               const char *value)
-                       __ul_attribute__((nonnull(1, 2)));
+                               const char *value);
 extern int mnt_optstr_prepend_option(char **optstr, const char *name,
-                               const char *value)
-                       __ul_attribute__((nonnull(1, 2)));
+                               const char *value);
 
 extern int mnt_optstr_get_option(const char *optstr, const char *name,
                                char **value, size_t *valsz);
 extern int mnt_optstr_set_option(char **optstr, const char *name,
-                               const char *value)
-                       __ul_attribute__((nonnull(1, 2)));
-extern int mnt_optstr_remove_option(char **optstr, const char *name)
-                       __ul_attribute__((nonnull));
-extern int mnt_optstr_deduplicate_option(char **optstr, const char *name)
-                       __ul_attribute__((nonnull));
+                               const char *value);
+extern int mnt_optstr_remove_option(char **optstr, const char *name);
+extern int mnt_optstr_deduplicate_option(char **optstr, const char *name);
 
 extern int mnt_split_optstr(const char *optstr,
                            char **user, char **vfs, char **fs,
@@ -301,11 +291,10 @@ extern const struct libmnt_optmap *mnt_get_builtin_optmap(int id);
 
 /* lock.c */
 extern struct libmnt_lock *mnt_new_lock(const char *datafile, pid_t id)
-                       __ul_attribute__((nonnull, warn_unused_result));
+                       __ul_attribute__((warn_unused_result));
 extern void mnt_free_lock(struct libmnt_lock *ml);
 
-extern void mnt_unlock_file(struct libmnt_lock *ml)
-                       __ul_attribute__((nonnull));
+extern void mnt_unlock_file(struct libmnt_lock *ml);
 extern int mnt_lock_file(struct libmnt_lock *ml);
 extern int mnt_lock_block_signals(struct libmnt_lock *ml, int enable);
 
@@ -314,27 +303,21 @@ extern struct libmnt_fs *mnt_new_fs(void)
                        __ul_attribute__((warn_unused_result));
 extern void mnt_free_fs(struct libmnt_fs *fs);
 
-extern void mnt_reset_fs(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern void mnt_reset_fs(struct libmnt_fs *fs);
 extern struct libmnt_fs *mnt_copy_fs(struct libmnt_fs *dest,
                                     const struct libmnt_fs *src)
                        __ul_attribute__((warn_unused_result));
-extern void *mnt_fs_get_userdata(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern void *mnt_fs_get_userdata(struct libmnt_fs *fs);
 extern int mnt_fs_set_userdata(struct libmnt_fs *fs, void *data);
-extern const char *mnt_fs_get_source(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern const char *mnt_fs_get_source(struct libmnt_fs *fs);
 extern int mnt_fs_set_source(struct libmnt_fs *fs, const char *source);
 extern const char *mnt_fs_get_srcpath(struct libmnt_fs *fs);
 
 extern int mnt_fs_get_tag(struct libmnt_fs *fs, const char **name,
-                         const char **value)
-                       __ul_attribute__((nonnull(1)));
-extern const char *mnt_fs_get_target(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+                         const char **value);
+extern const char *mnt_fs_get_target(struct libmnt_fs *fs);
 extern int mnt_fs_set_target(struct libmnt_fs *fs, const char *target);
-extern const char *mnt_fs_get_fstype(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern const char *mnt_fs_get_fstype(struct libmnt_fs *fs);
 extern int mnt_fs_set_fstype(struct libmnt_fs *fs, const char *fstype);
 
 extern int mnt_fs_streq_srcpath(struct libmnt_fs *fs, const char *path)
@@ -343,11 +326,11 @@ extern int mnt_fs_streq_target(struct libmnt_fs *fs, const char *path)
                        __ul_attribute__((warn_unused_result));
 
 extern char *mnt_fs_strdup_options(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull, warn_unused_result));
+                       __ul_attribute__((warn_unused_result));
 extern const char *mnt_fs_get_options(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull, warn_unused_result));
+                       __ul_attribute__((warn_unused_result));
 extern const char *mnt_fs_get_optional_fields(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull, warn_unused_result));
+                       __ul_attribute__((warn_unused_result));
 extern int mnt_fs_get_propagation(struct libmnt_fs *fs, unsigned long *flags);
 
 extern int mnt_fs_set_options(struct libmnt_fs *fs, const char *optstr);
@@ -357,81 +340,56 @@ extern int mnt_fs_prepend_options(struct libmnt_fs *fs, const char *optstr);
 extern int mnt_fs_get_option(struct libmnt_fs *fs, const char *name,
                                char **value, size_t *valsz);
 
-extern const char *mnt_fs_get_fs_options(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
-extern const char *mnt_fs_get_vfs_options(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
-extern const char *mnt_fs_get_user_options(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern const char *mnt_fs_get_fs_options(struct libmnt_fs *fs);
+extern const char *mnt_fs_get_vfs_options(struct libmnt_fs *fs);
+extern const char *mnt_fs_get_user_options(struct libmnt_fs *fs);
 
-extern const char *mnt_fs_get_attributes(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern const char *mnt_fs_get_attributes(struct libmnt_fs *fs);
 extern int mnt_fs_set_attributes(struct libmnt_fs *fs, const char *optstr);
 extern int mnt_fs_get_attribute(struct libmnt_fs *fs, const char *name,
                                char **value, size_t *valsz);
 extern int mnt_fs_append_attributes(struct libmnt_fs *fs, const char *optstr);
 extern int mnt_fs_prepend_attributes(struct libmnt_fs *fs, const char *optstr);
 
-extern int mnt_fs_get_freq(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern int mnt_fs_get_freq(struct libmnt_fs *fs);
 extern int mnt_fs_set_freq(struct libmnt_fs *fs, int freq);
-extern int mnt_fs_get_passno(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern int mnt_fs_get_passno(struct libmnt_fs *fs);
 extern int mnt_fs_set_passno(struct libmnt_fs *fs, int passno);
-extern const char *mnt_fs_get_root(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern const char *mnt_fs_get_root(struct libmnt_fs *fs);
 extern int mnt_fs_set_root(struct libmnt_fs *fs, const char *root);
-extern const char *mnt_fs_get_bindsrc(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern const char *mnt_fs_get_bindsrc(struct libmnt_fs *fs);
 extern int mnt_fs_set_bindsrc(struct libmnt_fs *fs, const char *src);
-extern int mnt_fs_get_id(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
-extern int mnt_fs_get_parent_id(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
-extern dev_t mnt_fs_get_devno(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
-extern pid_t mnt_fs_get_tid(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern int mnt_fs_get_id(struct libmnt_fs *fs);
+extern int mnt_fs_get_parent_id(struct libmnt_fs *fs);
+extern dev_t mnt_fs_get_devno(struct libmnt_fs *fs);
+extern pid_t mnt_fs_get_tid(struct libmnt_fs *fs);
 
-extern const char *mnt_fs_get_swaptype(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
-extern off_t mnt_fs_get_size(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
-extern off_t mnt_fs_get_usedsize(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
-extern int mnt_fs_get_priority(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern const char *mnt_fs_get_swaptype(struct libmnt_fs *fs);
+extern off_t mnt_fs_get_size(struct libmnt_fs *fs);
+extern off_t mnt_fs_get_usedsize(struct libmnt_fs *fs);
+extern int mnt_fs_get_priority(struct libmnt_fs *fs);
 
 extern int mnt_fs_match_target(struct libmnt_fs *fs, const char *target,
-                              struct libmnt_cache *cache)
-                       __ul_attribute__((nonnull(1)));
+                              struct libmnt_cache *cache);
 extern int mnt_fs_match_source(struct libmnt_fs *fs, const char *source,
-                              struct libmnt_cache *cache)
-                       __ul_attribute__((nonnull(1)));
-extern int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types)
-                       __ul_attribute__((nonnull(1)));
-extern int mnt_fs_match_options(struct libmnt_fs *fs, const char *options)
-                       __ul_attribute__((nonnull(1)));
-extern int mnt_fs_print_debug(struct libmnt_fs *fs, FILE *file)
-                       __ul_attribute__((nonnull));
+                              struct libmnt_cache *cache);
+extern int mnt_fs_match_fstype(struct libmnt_fs *fs, const char *types);
+extern int mnt_fs_match_options(struct libmnt_fs *fs, const char *options);
+extern int mnt_fs_print_debug(struct libmnt_fs *fs, FILE *file);
 
-extern int mnt_fs_is_kernel(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
-extern int mnt_fs_is_swaparea(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
-extern int mnt_fs_is_netfs(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
-extern int mnt_fs_is_pseudofs(struct libmnt_fs *fs)
-                       __ul_attribute__((nonnull));
+extern int mnt_fs_is_kernel(struct libmnt_fs *fs);
+extern int mnt_fs_is_swaparea(struct libmnt_fs *fs);
+extern int mnt_fs_is_netfs(struct libmnt_fs *fs);
+extern int mnt_fs_is_pseudofs(struct libmnt_fs *fs);
 
 extern void mnt_free_mntent(struct mntent *mnt);
 extern int mnt_fs_to_mntent(struct libmnt_fs *fs, struct mntent **mnt);
 
 /* tab-parse.c */
 extern struct libmnt_table *mnt_new_table_from_file(const char *filename)
-                       __ul_attribute__((nonnull, warn_unused_result));
+                       __ul_attribute__((warn_unused_result));
 extern struct libmnt_table *mnt_new_table_from_dir(const char *dirname)
-                       __ul_attribute__((nonnull, warn_unused_result));
+                       __ul_attribute__((warn_unused_result));
 extern int mnt_table_parse_stream(struct libmnt_table *tb, FILE *f,
                                  const char *filename);
 extern int mnt_table_parse_file(struct libmnt_table *tb, const char *filename);
@@ -484,27 +442,21 @@ extern int mnt_table_find_next_fs(struct libmnt_table *tb,
                        void *userdata,
                        struct libmnt_fs **fs);
 
-extern int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs)
-                       __ul_attribute__((nonnull));
-
+extern int mnt_table_is_fs_mounted(struct libmnt_table *tb, struct libmnt_fs *fstab_fs);
 
 /* tab_update.c */
 extern struct libmnt_update *mnt_new_update(void)
                        __ul_attribute__((warn_unused_result));
 extern void mnt_free_update(struct libmnt_update *upd);
 
-extern int mnt_update_is_ready(struct libmnt_update *upd)
-                       __ul_attribute__((nonnull));
+extern int mnt_update_is_ready(struct libmnt_update *upd);
 extern int mnt_update_set_fs(struct libmnt_update *upd, unsigned long mountflags,
                              const char *target, struct libmnt_fs *fs);
 extern int mnt_update_table(struct libmnt_update *upd, struct libmnt_lock *lc);
-extern unsigned long mnt_update_get_mflags(struct libmnt_update *upd)
-                       __ul_attribute__((nonnull));
+extern unsigned long mnt_update_get_mflags(struct libmnt_update *upd);
 extern int mnt_update_force_rdonly(struct libmnt_update *upd, int rdonly);
-extern const char *mnt_update_get_filename(struct libmnt_update *upd)
-                       __ul_attribute__((nonnull));
-extern struct libmnt_fs *mnt_update_get_fs(struct libmnt_update *upd)
-                       __ul_attribute__((nonnull));
+extern const char *mnt_update_get_filename(struct libmnt_update *upd);
+extern struct libmnt_fs *mnt_update_get_fs(struct libmnt_update *upd);
 
 /* tab_diff.c */
 enum {
@@ -578,8 +530,8 @@ extern int mnt_context_enable_loopdel(struct libmnt_context *cxt, int enable);
 extern int mnt_context_enable_fork(struct libmnt_context *cxt, int enable);
 extern int mnt_context_disable_swapmatch(struct libmnt_context *cxt, int disable);
 
-extern int mnt_context_get_optsmode(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
+extern int mnt_context_get_optsmode(struct libmnt_context *cxt);
+
 extern int mnt_context_is_lazy(struct libmnt_context *cxt)
                        __ul_attribute__((nonnull));
 extern int mnt_context_is_rdonly_umount(struct libmnt_context *cxt)
@@ -614,28 +566,22 @@ extern int mnt_context_wait_for_children(struct libmnt_context *cxt,
                                   int *nchildren, int *nerrs);
 
 extern int mnt_context_is_fs_mounted(struct libmnt_context *cxt,
-                              struct libmnt_fs *fs, int *mounted)
-                       __ul_attribute__((nonnull));
+                              struct libmnt_fs *fs, int *mounted);
 extern int mnt_context_set_fs(struct libmnt_context *cxt, struct libmnt_fs *fs);
-extern struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
+extern struct libmnt_fs *mnt_context_get_fs(struct libmnt_context *cxt);
 
 extern int mnt_context_set_source(struct libmnt_context *cxt, const char *source);
 extern int mnt_context_set_target(struct libmnt_context *cxt, const char *target);
 extern int mnt_context_set_fstype(struct libmnt_context *cxt, const char *fstype);
 
-extern const char *mnt_context_get_source(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
-extern const char *mnt_context_get_target(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
-extern const char *mnt_context_get_fstype(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
+extern const char *mnt_context_get_source(struct libmnt_context *cxt);
+extern const char *mnt_context_get_target(struct libmnt_context *cxt);
+extern const char *mnt_context_get_fstype(struct libmnt_context *cxt);
 
 extern int mnt_context_set_options(struct libmnt_context *cxt, const char *optstr);
 extern int mnt_context_append_options(struct libmnt_context *cxt, const char *optstr);
 
-extern const char *mnt_context_get_options(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
+extern const char *mnt_context_get_options(struct libmnt_context *cxt);
 
 extern int mnt_context_set_fstype_pattern(struct libmnt_context *cxt, const char *pattern);
 extern int mnt_context_set_options_pattern(struct libmnt_context *cxt, const char *pattern);
@@ -659,10 +605,8 @@ extern int mnt_context_get_table(struct libmnt_context *cxt,
                                struct libmnt_table **tb);
 extern int mnt_context_set_cache(struct libmnt_context *cxt,
                                 struct libmnt_cache *cache);
-extern struct libmnt_cache *mnt_context_get_cache(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
-extern struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
+extern struct libmnt_cache *mnt_context_get_cache(struct libmnt_context *cxt);
+extern struct libmnt_lock *mnt_context_get_lock(struct libmnt_context *cxt);
 extern int mnt_context_set_mflags(struct libmnt_context *cxt,
                                      unsigned long flags);
 extern int mnt_context_get_mflags(struct libmnt_context *cxt,
@@ -676,19 +620,14 @@ extern int mnt_context_set_mountdata(struct libmnt_context *cxt, void *data);
 extern int mnt_context_apply_fstab(struct libmnt_context *cxt);
 
 extern int mnt_context_reset_status(struct libmnt_context *cxt);
-extern int mnt_context_get_status(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
+extern int mnt_context_get_status(struct libmnt_context *cxt);
 
-extern int mnt_context_helper_executed(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
-extern int mnt_context_get_helper_status(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
+extern int mnt_context_helper_executed(struct libmnt_context *cxt);
+extern int mnt_context_get_helper_status(struct libmnt_context *cxt);
 
-extern int mnt_context_syscall_called(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
+extern int mnt_context_syscall_called(struct libmnt_context *cxt);
 
-extern int mnt_context_get_syscall_errno(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
+extern int mnt_context_get_syscall_errno(struct libmnt_context *cxt);
 
 extern int mnt_context_strerror(struct libmnt_context *cxt, char *buf,
                                size_t bufsiz);
@@ -720,8 +659,7 @@ extern int mnt_context_prepare_umount(struct libmnt_context *cxt)
 extern int mnt_context_do_umount(struct libmnt_context *cxt);
 extern int mnt_context_finalize_umount(struct libmnt_context *cxt);
 
-extern int mnt_context_tab_applied(struct libmnt_context *cxt)
-                       __ul_attribute__((nonnull));
+extern int mnt_context_tab_applied(struct libmnt_context *cxt);
 extern int mnt_context_set_syscall_status(struct libmnt_context *cxt, int status);
 
 /*

diff --git a/libmount/src/lock.c b/libmount/src/lock.c
index 9e583cc069d1f515070412319eae4c823edd14bd..e73edf54b471163265f77229af9793d38e2d6410 100644 (file)
--- a/libmount/src/lock.c
+++ b/libmount/src/lock.c
@@ -53,6 +53,8 @@ struct libmnt_lock *mnt_new_lock(const char *datafile, pid_t id)
        char *lo = NULL, *ln = NULL;
        size_t losz;
 
+       assert(datafile);
+
        /* for flock we use "foo.lock, for mtab "foo~"
         */
        losz = strlen(datafile) + sizeof(".lock");

diff --git a/libmount/src/mountP.h b/libmount/src/mountP.h
index 065b815c19b486c803d36a245582926757257dc4..e064a68495c7248281bdadc258859731f8a66aa6 100644 (file)
--- a/libmount/src/mountP.h
+++ b/libmount/src/mountP.h
@@ -26,7 +26,9 @@
 #define CONFIG_LIBMOUNT_DEBUG
 
 #ifdef CONFIG_LIBMOUNT_ASSERT
-#include <assert.h>
+# include <assert.h>
+#else
+# define assert(x)
 #endif
 
 /*

diff --git a/libmount/src/optstr.c b/libmount/src/optstr.c
index a3a5d0a08755d0c2421660caccd126ea7db9ad8a..5e9e708074955118442a2b4403e389d967fd9db2 100644 (file)
--- a/libmount/src/optstr.c
+++ b/libmount/src/optstr.c
@@ -169,8 +169,7 @@ int mnt_optstr_next_option(char **optstr, char **name, size_t *namesz,
        return mnt_optstr_parse_next(optstr, name, namesz, value, valuesz);
 }
 
-static int __attribute__((nonnull(1, 2)))
-__mnt_optstr_append_option(char **optstr,
+static int __mnt_optstr_append_option(char **optstr,
                        const char *name, size_t nsz,
                        const char *value, size_t vsz)
 {
@@ -180,6 +179,7 @@ __mnt_optstr_append_option(char **optstr,
        assert(name);
        assert(*name);
        assert(nsz);
+       assert(optstr);
 
        osz = *optstr ? strlen(*optstr) : 0;
 
@@ -225,6 +225,8 @@ int mnt_optstr_append_option(char **optstr, const char *name, const char *value)
 {
        size_t vsz, nsz;
 
+       assert(optstr);
+
        if (!name || !*name)
                return 0;
 
@@ -248,6 +250,11 @@ int mnt_optstr_prepend_option(char **optstr, const char *name, const char *value
        int rc = 0;
        char *tmp = *optstr;
 
+       assert(optstr);
+
+       if (!name || !*name)
+               return 0;
+
        *optstr = NULL;
 
        rc = mnt_optstr_append_option(optstr, name, value);
@@ -282,6 +289,9 @@ int mnt_optstr_get_option(const char *optstr, const char *name,
        struct libmnt_optloc ol;
        int rc;
 
+       assert(optstr);
+       assert(name);
+
        mnt_init_optloc(&ol);
 
        rc = mnt_optstr_locate_option((char *) optstr, name, &ol);
@@ -307,8 +317,12 @@ int mnt_optstr_get_option(const char *optstr, const char *name,
 int mnt_optstr_deduplicate_option(char **optstr, const char *name)
 {
        int rc;
-       char *begin = NULL, *end = NULL, *opt = *optstr;
+       char *begin = NULL, *end = NULL, *opt;
 
+       assert(optstr);
+       assert(name);
+
+       opt = *optstr;
        do {
                struct libmnt_optloc ol;
 
@@ -421,6 +435,9 @@ int mnt_optstr_set_option(char **optstr, const char *name, const char *value)
        char *nameend;
        int rc = 1;
 
+       assert(optstr);
+       assert(name);
+
        if (!optstr)
                return -EINVAL;
 
@@ -467,6 +484,9 @@ int mnt_optstr_remove_option(char **optstr, const char *name)
        struct libmnt_optloc ol;
        int rc;
 
+       assert(optstr);
+       assert(name);
+
        mnt_init_optloc(&ol);
 
        rc = mnt_optstr_locate_option(*optstr, name, &ol);

diff --git a/libmount/src/tab_parse.c b/libmount/src/tab_parse.c
index 7368d8c988deba7589a29a30cc5ee28c6fc5d947..e930fd841747cd584bfa0328d08b8e82e8580333 100644 (file)
--- a/libmount/src/tab_parse.c
+++ b/libmount/src/tab_parse.c
@@ -720,7 +720,6 @@ struct libmnt_table *__mnt_new_table_from_file(const char *filename, int fmt)
        struct stat st;
 
        assert(filename);
-
        if (!filename)
                return NULL;
        if (stat(filename, &st))
@@ -749,6 +748,7 @@ struct libmnt_table *__mnt_new_table_from_file(const char *filename, int fmt)
  */
 struct libmnt_table *mnt_new_table_from_file(const char *filename)
 {
+       assert(filename);
        return __mnt_new_table_from_file(filename, MNT_FMT_GUESS);
 }
 
@@ -763,7 +763,6 @@ struct libmnt_table *mnt_new_table_from_dir(const char *dirname)
        struct libmnt_table *tb;
 
        assert(dirname);
-
        if (!dirname)
                return NULL;
        tb = mnt_new_table();
@@ -793,6 +792,7 @@ struct libmnt_table *mnt_new_table_from_dir(const char *dirname)
 int mnt_table_set_parser_errcb(struct libmnt_table *tb,
                int (*cb)(struct libmnt_table *tb, const char *filename, int line))
 {
+       assert(tb);
        if (!tb)
                return -EINVAL;
        tb->errcb = cb;
@@ -807,6 +807,7 @@ int mnt_table_set_parser_fltrcb(struct libmnt_table *tb,
                int (*cb)(struct libmnt_fs *, void *),
                void *data)
 {
+       assert(tb);
        if (!tb)
                return -EINVAL;
 
@@ -862,7 +863,6 @@ int mnt_table_parse_fstab(struct libmnt_table *tb, const char *filename)
        int rc = 0;
 
        assert(tb);
-
        if (!tb)
                return -EINVAL;
        if (!filename)
@@ -959,6 +959,8 @@ int mnt_table_parse_mtab(struct libmnt_table *tb, const char *filename)
        const char *utab = NULL;
        struct libmnt_table *u_tb;
 
+       assert(tb);
+
        if (mnt_has_regular_mtab(&filename, NULL)) {
 
                DBG(TAB, mnt_debug_h(tb, "force %s usage", filename));

diff --git a/libmount/src/tab_update.c b/libmount/src/tab_update.c
index 044a13f5e0be365644249ea22d34dbe46bc7ae84..1e7f32be0d567eb7a1792cac508c876346a0e3e1 100644 (file)
--- a/libmount/src/tab_update.c
+++ b/libmount/src/tab_update.c
@@ -131,6 +131,7 @@ int mnt_update_set_filename(struct libmnt_update *upd, const char *filename,
  */
 const char *mnt_update_get_filename(struct libmnt_update *upd)
 {
+       assert(upd);
        return upd ? upd->filename : NULL;
 }
 
@@ -143,6 +144,7 @@ const char *mnt_update_get_filename(struct libmnt_update *upd)
  */
 int mnt_update_is_ready(struct libmnt_update *upd)
 {
+       assert(upd);
        return upd ? upd->ready : FALSE;
 }
 
@@ -227,6 +229,7 @@ int mnt_update_set_fs(struct libmnt_update *upd, unsigned long mountflags,
  */
 struct libmnt_fs *mnt_update_get_fs(struct libmnt_update *upd)
 {
+       assert(upd);
        return upd ? upd->fs : NULL;
 }
 
@@ -238,6 +241,7 @@ struct libmnt_fs *mnt_update_get_fs(struct libmnt_update *upd)
  */
 unsigned long mnt_update_get_mflags(struct libmnt_update *upd)
 {
+       assert(upd);
        return upd ? upd->mountflags : 0;
 }
 
@@ -252,6 +256,7 @@ int mnt_update_force_rdonly(struct libmnt_update *upd, int rdonly)
 {
        int rc = 0;
 
+       assert(upd);
        if (!upd || !upd->fs)
                return -EINVAL;
 
@@ -505,6 +510,7 @@ static int update_table(struct libmnt_update *upd, struct libmnt_table *tb)
        int rc, fd;
        char *uq = NULL;
 
+       assert(upd);
        if (!tb || !upd->filename)
                return -EINVAL;
 
@@ -566,8 +572,11 @@ leave:
 
 static int add_file_entry(struct libmnt_table *tb, struct libmnt_update *upd)
 {
-       struct libmnt_fs *fs = mnt_copy_fs(NULL, upd->fs);
+       struct libmnt_fs *fs;
+
+       assert(upd);
 
+       fs = mnt_copy_fs(NULL, upd->fs);
        if (!fs)
                return -ENOMEM;
 
@@ -638,6 +647,7 @@ static int update_modify_target(struct libmnt_update *upd, struct libmnt_lock *l
        struct libmnt_table *tb = NULL;
        int rc = 0;
 
+       assert(upd);
        DBG(UPDATE, mnt_debug_h(upd, "%s: modify target", upd->filename));
 
        if (lc)
@@ -726,7 +736,6 @@ int mnt_update_table(struct libmnt_update *upd, struct libmnt_lock *lc)
        int rc = -EINVAL;
 
        assert(upd);
-
        if (!upd || !upd->filename)
                return -EINVAL;
        if (!upd->ready)

diff --git a/libmount/src/utils.c b/libmount/src/utils.c
index c910035df89859cae0671c6d6313e8caa878c92a..c328414f2213eddac3b144ea86f3b2204cd3f92c 100644 (file)
--- a/libmount/src/utils.c
+++ b/libmount/src/utils.c
@@ -269,6 +269,8 @@ int mnt_fstype_is_pseudofs(const char *type)
                "tmpfs"
        };
 
+       assert(type);
+
        return !(bsearch(&type, pseudofs, ARRAY_SIZE(pseudofs),
                                sizeof(char*), fstype_cmp) == NULL);
 }
@@ -281,6 +283,8 @@ int mnt_fstype_is_pseudofs(const char *type)
  */
 int mnt_fstype_is_netfs(const char *type)
 {
+       assert(type);
+
        if (strcmp(type, "cifs")   == 0 ||
            strcmp(type, "smbfs")  == 0 ||
            strncmp(type,"nfs", 3) == 0 ||
@@ -859,10 +863,13 @@ int mnt_open_uniq_filename(const char *filename, char **name)
  */
 char *mnt_get_mountpoint(const char *path)
 {
-       char *mnt = strdup(path);
+       char *mnt;
        struct stat st;
        dev_t dir, base;
 
+       assert(path);
+
+       mnt = strdup(path);
        if (!mnt)
                return NULL;
        if (*mnt == '/' && *(mnt + 1) == '\0')

diff --git a/libmount/src/version.c b/libmount/src/version.c
index 00e4f9961ab1b4491992738f2f8e23a87c2fc7b4..00b7c03e7ab1d0bd57f5b332722389ba280017b1 100644 (file)
--- a/libmount/src/version.c
+++ b/libmount/src/version.c
@@ -24,6 +24,9 @@ static const char *lib_features[] = {
 #endif
 #ifdef CONFIG_LIBMOUNT_DEBUG
        "debug",
+#endif
+#ifdef CONFIG_LIBMOUNT_ASSERT
+       "assert",
 #endif
        NULL
 };
@@ -39,6 +42,8 @@ int mnt_parse_version_string(const char *ver_string)
        const char *cp;
        int version = 0;
 
+       assert(ver_string);
+
        for (cp = ver_string; *cp; cp++) {
                if (*cp == '.')
                        continue;