fix

diff --git a/ChangeLog b/ChangeLog
index 16ed905b6a8c96b20711dc252c5787a9dd8c8c1e..8d8e1f589750e69b87b174c8bcaa9944ffe36028 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,10 +1,17 @@
+2005-08-03  Miklos Szeredi <miklos@szeredi.hu>
+
+       * fix warnings in fuse.h and fuse_lowlevel.h if -Wshadow compiler
+       option is used (Paul Alfille).
+
 2005-08-02  Miklos Szeredi <miklos@szeredi.hu>
 
        * highlevel-lib: added mount options "attr_timeout" and
        "entry_timeout".  These options control the length of time file
        attributes and entries (names) are cached.  Both default to 1.0
        second.
-       
+
+       * kernel: correctly handle zero timeout for attributes and entries
+
 2005-08-01  Miklos Szeredi <miklos@szeredi.hu>
 
        * Added missing symbols to versionscript (Joshua J. Berry)
@@ -27,7 +34,7 @@
        newly created
 
        * lib (highlevel): make open method optional
- 
+
 2005-07-28  Miklos Szeredi <miklos@szeredi.hu>
 
        * kernel: invalidate attributes for read/readdir/readlink

diff --git a/configure.in b/configure.in
index 3055b01ddf044ec1e059c2698eb2ebc3a2d48e02..4a5a493310bbb132650a16216730d9c713327b08 100644 (file)
--- a/configure.in
+++ b/configure.in
@@ -13,7 +13,9 @@ if test -z "$mkdir_p"; then
        AC_SUBST(mkdir_p)
 fi
 
-CFLAGS="-Wall -W -g -O2"
+if test -z "$CFLAGS"; then
+       CFLAGS="-Wall -W -g -O2"
+fi
 CPPFLAGS="$CPPFLAGS -D_FILE_OFFSET_BITS=64 -D_REENTRANT -DFUSE_USE_VERSION=22"
 
 AC_ARG_ENABLE(kernel-module,

diff --git a/example/hello_ll.c b/example/hello_ll.c
index 9f7086560bee76a3fdfb3dceb22ca4d25663d543..3a6ea098eb8f6f0a50952d857dca595bd96c4f35 100644 (file)
--- a/example/hello_ll.c
+++ b/example/hello_ll.c
@@ -78,7 +78,7 @@ static void dirbuf_add(struct dirbuf *b, const char *name, fuse_ino_t ino)
     struct stat stbuf;
     size_t oldsize = b->size;
     b->size += fuse_dirent_size(strlen(name));
-    b->p = realloc(b->p, b->size);
+    b->p = (char *) realloc(b->p, b->size);
     memset(&stbuf, 0, sizeof(stbuf));
     stbuf.st_ino = ino;
     fuse_add_dirent(b->p + oldsize, name, &stbuf, b->size);

diff --git a/example/null.c b/example/null.c
index d58feabb2bced8ee6d3cb47466a3c2c47a18cf1b..d9539ab1fb87d2592167e55fff3d9cdf4f1757fd 100644 (file)
--- a/example/null.c
+++ b/example/null.c
@@ -12,8 +12,6 @@
 #include <time.h>
 #include <errno.h>
 
-#define UNUSED(x) x __attribute__((unused))
-
 static int null_getattr(const char *path, struct stat *stbuf)
 {
     if(strcmp(path, "/") != 0)
@@ -30,34 +28,46 @@ static int null_getattr(const char *path, struct stat *stbuf)
     return 0;
 }
 
-static int null_truncate(const char *path, off_t UNUSED(size))
+static int null_truncate(const char *path, off_t size)
 {
+    (void) size;
+
     if(strcmp(path, "/") != 0)
         return -ENOENT;
 
     return 0;
 }
 
-static int null_open(const char *path, struct fuse_file_info *UNUSED(fi))
+static int null_open(const char *path, struct fuse_file_info *fi)
 {
+    (void) fi;
+
     if(strcmp(path, "/") != 0)
         return -ENOENT;
 
     return 0;
 }
 
-static int null_read(const char *path, char *UNUSED(buf), size_t size,
-                     off_t UNUSED(offset), struct fuse_file_info *UNUSED(fi))
+static int null_read(const char *path, char *buf, size_t size,
+                     off_t offset, struct fuse_file_info *fi)
 {
+    (void) buf;
+    (void) offset;
+    (void) fi;
+
     if(strcmp(path, "/") != 0)
         return -ENOENT;
 
     return size;
 }
 
-static int null_write(const char *path, const char *UNUSED(buf), size_t size,
-                     off_t UNUSED(offset), struct fuse_file_info *UNUSED(fi))
+static int null_write(const char *path, const char *buf, size_t size,
+                     off_t offset, struct fuse_file_info *fi)
 {
+    (void) buf;
+    (void) offset;
+    (void) fi;
+
     if(strcmp(path, "/") != 0)
         return -ENOENT;
 

diff --git a/include/fuse.h b/include/fuse.h
index db9a417e9068dc25c4a77485c0709b2557d9e7c9..ade49f57c2579b72c83084e08bdfd1cb100a96e8 100644 (file)
--- a/include/fuse.h
+++ b/include/fuse.h
@@ -58,7 +58,7 @@ struct fuse;
  * @return 1 if buffer is full, zero otherwise
  */
 typedef int (*fuse_fill_dir_t) (void *buf, const char *name,
-                                const struct stat *stat, off_t off);
+                                const struct stat *stbuf, off_t off);
 
 /* Used by deprecated getdir() method */
 typedef struct fuse_dirhandle *fuse_dirh_t;
@@ -148,7 +148,7 @@ struct fuse_operations {
      * with the given flags.  In fact it cannot correctly do that
      * since it doesn't have a way to determine if the file was just
      * created (and hence the permission need not be checked).
-     * 
+     *
      * If permission needs to be checked, implement the access()
      * method, and do the check there.
      *
@@ -313,7 +313,7 @@ struct fuse_operations {
 
     /**
      * Check file access permissions
-     * 
+     *
      * Need not be implemented.  Will only be called for the access()
      * system call, and for the open() system call, unless a new file
      * is created (file didn't exist and O_CREAT was given).  If the

diff --git a/include/fuse_lowlevel.h b/include/fuse_lowlevel.h
index 16257a94476d083b462086cbfa6beffa38eb428e..8b189592d82d842fffe7dc0578ff50e64d58e677 100644 (file)
--- a/include/fuse_lowlevel.h
+++ b/include/fuse_lowlevel.h
@@ -115,7 +115,7 @@ struct fuse_ll_operations {
                      size_t size);
     void (*listxattr)(fuse_req_t req, fuse_ino_t ino, size_t size);
     void (*removexattr)(fuse_req_t req, fuse_ino_t ino, const char *name);
-    void (*getlk)  (fuse_req_t req, fuse_ino_t ino, 
+    void (*getlk)  (fuse_req_t req, fuse_ino_t ino,
                     const struct fuse_lock_param *lk);
     void (*setlk)  (fuse_req_t req, fuse_ino_t ino, int sleep,
                     const struct fuse_lock_param *lk);
@@ -149,7 +149,7 @@ int fuse_reply_write(fuse_req_t req, size_t count);
 int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size);
 
 /* statfs */
-int fuse_reply_statfs(fuse_req_t req, const struct statfs *statfs);
+int fuse_reply_statfs(fuse_req_t req, const struct statfs *stbuf);
 
 /* getxattr, listxattr */
 int fuse_reply_xattr(fuse_req_t req, size_t count);
@@ -163,7 +163,7 @@ int fuse_reply_getlk(fuse_req_t req, const struct fuse_lock_param *lk);
 size_t fuse_dirent_size(size_t namelen);
 
 /* add a directory entry to the buffer */
-char *fuse_add_dirent(char *buf, const char *name, const struct stat *stat,
+char *fuse_add_dirent(char *buf, const char *name, const struct stat *stbuf,
                       off_t off);
 
 /* ------------------------------------------ */

diff --git a/kernel/dir.c b/kernel/dir.c
index a7a694569dd2b015a9677d7211e4dec5ac9d0a27..f2fe170f74ba8a4a69c57e92e6ae77b50af47659 100644 (file)
--- a/kernel/dir.c
+++ b/kernel/dir.c
@@ -24,7 +24,7 @@ static inline unsigned long time_to_jiffies(unsigned long sec,
                                            unsigned long nsec)
 {
        struct timespec ts = {sec, nsec};
-       return jiffies + timespec_to_jiffies(&ts);
+       return jiffies + ((sec || nsec) ? timespec_to_jiffies(&ts) : 0) - 1;
 }
 
 static void fuse_lookup_init(struct fuse_req *req, struct inode *dir,
@@ -552,7 +552,7 @@ static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
                        return -EACCES;
 
                err = 0;
-               if (nd && 
+               if (nd &&
                    ((nd->flags & LOOKUP_ACCESS) ||
                     ((nd->flags & LOOKUP_OPEN) && mode != 0)))
                        err = fuse_access(inode, mask);

diff --git a/lib/fuse.c b/lib/fuse.c
index b3203d26d8810c80f4e4ec6a1ff555997ab6a743..68eeee0e8a030ab9a69d7228ed5dff80e89a74ed 100644 (file)
--- a/lib/fuse.c
+++ b/lib/fuse.c
@@ -745,7 +745,7 @@ static void fuse_access(fuse_req_t req, fuse_ino_t ino, int mask)
 static void fuse_readlink(fuse_req_t req, fuse_ino_t ino)
 {
     struct fuse *f = req_fuse_prepare(req);
-    char link[PATH_MAX + 1];
+    char linkname[PATH_MAX + 1];
     char *path;
     int err;
 
@@ -755,13 +755,13 @@ static void fuse_readlink(fuse_req_t req, fuse_ino_t ino)
     if (path != NULL) {
         err = -ENOSYS;
         if (f->op.readlink)
-            err = f->op.readlink(path, link, sizeof(link));
+            err = f->op.readlink(path, linkname, sizeof(linkname));
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
     if (!err) {
-        link[PATH_MAX] = '\0';
-        fuse_reply_readlink(req, link);
+        linkname[PATH_MAX] = '\0';
+        fuse_reply_readlink(req, linkname);
     } else
         reply_err(req, err);
 }
@@ -878,8 +878,8 @@ static void fuse_rmdir(fuse_req_t req, fuse_ino_t parent, const char *name)
     reply_err(req, err);
 }
 
-static void fuse_symlink(fuse_req_t req, const char *link, fuse_ino_t parent,
-                         const char *name)
+static void fuse_symlink(fuse_req_t req, const char *linkname,
+                         fuse_ino_t parent, const char *name)
 {
     struct fuse *f = req_fuse_prepare(req);
     struct fuse_entry_param e;
@@ -896,7 +896,7 @@ static void fuse_symlink(fuse_req_t req, const char *link, fuse_ino_t parent,
         }
         err = -ENOSYS;
         if (f->op.symlink && f->op.getattr) {
-            err = f->op.symlink(link, path);
+            err = f->op.symlink(linkname, path);
             if (!err)
                 err = lookup_path(f, parent, name, path, &e);
         }
@@ -1253,7 +1253,7 @@ static void fuse_opendir(fuse_req_t req, fuse_ino_t ino,
 }
 
 static int fill_dir_common(struct fuse_dirhandle *dh, const char *name,
-                           const struct stat *stat, off_t off)
+                           const struct stat *statp, off_t off)
 {
     struct stat stbuf;
     unsigned namelen = strlen(name);
@@ -1261,11 +1261,11 @@ static int fill_dir_common(struct fuse_dirhandle *dh, const char *name,
     unsigned newlen;
     char *newptr;
 
-    if (stat)
-        stbuf = *stat;
+    if (statp)
+        stbuf = *statp;
     else {
         memset(&stbuf, 0, sizeof(stbuf));
-        stbuf.st_ino = -1;
+        stbuf.st_ino = (ino_t) -1;
     }
 
     if (!(dh->fuse->flags & FUSE_USE_INO)) {
@@ -1289,7 +1289,7 @@ static int fill_dir_common(struct fuse_dirhandle *dh, const char *name,
             return 1;
     }
 
-    newptr = realloc(dh->contents, newlen);
+    newptr = (char *) realloc(dh->contents, newlen);
     if (!newptr) {
         dh->error = -ENOMEM;
         return 1;
@@ -1300,10 +1300,10 @@ static int fill_dir_common(struct fuse_dirhandle *dh, const char *name,
     return 0;
 }
 
-static int fill_dir(void *buf, const char *name, const struct stat *stat,
+static int fill_dir(void *buf, const char *name, const struct stat *stbuf,
                     off_t off)
 {
-    return fill_dir_common((struct fuse_dirhandle *) buf, name, stat, off);
+    return fill_dir_common((struct fuse_dirhandle *) buf, name, stbuf, off);
 }
 
 static int fill_dir_old(struct fuse_dirhandle *dh, const char *name, int type,
@@ -1431,15 +1431,15 @@ static int default_statfs(struct statfs *buf)
 }
 
 static void convert_statfs_compat(struct fuse_statfs_compat1 *compatbuf,
-                                  struct statfs *statfs)
+                                  struct statfs *stbuf)
 {
-    statfs->f_bsize   = compatbuf->block_size;
-    statfs->f_blocks  = compatbuf->blocks;
-    statfs->f_bfree   = compatbuf->blocks_free;
-    statfs->f_bavail  = compatbuf->blocks_free;
-    statfs->f_files   = compatbuf->files;
-    statfs->f_ffree   = compatbuf->files_free;
-    statfs->f_namelen = compatbuf->namelen;
+    stbuf->f_bsize   = compatbuf->block_size;
+    stbuf->f_blocks  = compatbuf->blocks;
+    stbuf->f_bfree   = compatbuf->blocks_free;
+    stbuf->f_bavail  = compatbuf->blocks_free;
+    stbuf->f_files   = compatbuf->files;
+    stbuf->f_ffree   = compatbuf->files_free;
+    stbuf->f_namelen = compatbuf->namelen;
 }
 
 static void fuse_statfs(fuse_req_t req)
@@ -1870,7 +1870,7 @@ struct fuse *fuse_new_compat2(int fd, const char *opts,
 struct fuse *fuse_new_compat1(int fd, int flags,
                               const struct fuse_operations_compat1 *op)
 {
-    char *opts = NULL;
+    const char *opts = NULL;
     if (flags & FUSE_DEBUG_COMPAT1)
         opts = "debug";
     return fuse_new_common(fd, opts, (struct fuse_operations *) op,

diff --git a/lib/fuse_lowlevel.c b/lib/fuse_lowlevel.c
index 9df0e098f645c7fae2f51603be321895a18e2ab1..fce1d6dcd8401934167dc975d2d4ec02cebf5ed4 100644 (file)
--- a/lib/fuse_lowlevel.c
+++ b/lib/fuse_lowlevel.c
@@ -225,7 +225,7 @@ size_t fuse_dirent_size(size_t namelen)
     return FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + namelen);
 }
 
-char *fuse_add_dirent(char *buf, const char *name, const struct stat *stat,
+char *fuse_add_dirent(char *buf, const char *name, const struct stat *stbuf,
                       off_t off)
 {
     unsigned namelen = strlen(name);
@@ -234,10 +234,10 @@ char *fuse_add_dirent(char *buf, const char *name, const struct stat *stat,
     unsigned padlen = entsize - entlen;
     struct fuse_dirent *dirent = (struct fuse_dirent *) buf;
 
-    dirent->ino = stat->st_ino;
+    dirent->ino = stbuf->st_ino;
     dirent->off = off;
     dirent->namelen = namelen;
-    dirent->type = (stat->st_mode & 0170000) >> 12;
+    dirent->type = (stbuf->st_mode & 0170000) >> 12;
     strncpy(dirent->name, name, namelen);
     if (padlen)
         memset(buf + entlen, 0, padlen);
@@ -245,16 +245,16 @@ char *fuse_add_dirent(char *buf, const char *name, const struct stat *stat,
     return buf + entsize;
 }
 
-static void convert_statfs(const struct statfs *statfs,
+static void convert_statfs(const struct statfs *stbuf,
                            struct fuse_kstatfs *kstatfs)
 {
-    kstatfs->bsize     = statfs->f_bsize;
-    kstatfs->blocks    = statfs->f_blocks;
-    kstatfs->bfree     = statfs->f_bfree;
-    kstatfs->bavail    = statfs->f_bavail;
-    kstatfs->files     = statfs->f_files;
-    kstatfs->ffree     = statfs->f_ffree;
-    kstatfs->namelen   = statfs->f_namelen;
+    kstatfs->bsize     = stbuf->f_bsize;
+    kstatfs->blocks    = stbuf->f_blocks;
+    kstatfs->bfree     = stbuf->f_bfree;
+    kstatfs->bavail    = stbuf->f_bavail;
+    kstatfs->files     = stbuf->f_files;
+    kstatfs->ffree     = stbuf->f_ffree;
+    kstatfs->namelen   = stbuf->f_namelen;
 }
 
 static void free_req(fuse_req_t req)
@@ -332,9 +332,9 @@ int fuse_reply_attr(fuse_req_t req, const struct stat *attr,
     return send_reply_req(req, &arg, sizeof(arg));
 }
 
-int fuse_reply_readlink(fuse_req_t req, const char *link)
+int fuse_reply_readlink(fuse_req_t req, const char *linkname)
 {
-    return send_reply_req(req, link, strlen(link));
+    return send_reply_req(req, linkname, strlen(linkname));
 }
 
 int fuse_reply_open(fuse_req_t req, const struct fuse_file_info *f)
@@ -366,12 +366,12 @@ int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size)
     return send_reply_req(req, buf, size);
 }
 
-int fuse_reply_statfs(fuse_req_t req, const struct statfs *statfs)
+int fuse_reply_statfs(fuse_req_t req, const struct statfs *stbuf)
 {
     struct fuse_statfs_out arg;
 
     memset(&arg, 0, sizeof(arg));
-    convert_statfs(statfs, &arg.st);
+    convert_statfs(stbuf, &arg.st);
 
     return send_reply_req(req, &arg, sizeof(arg));
 }
@@ -389,10 +389,10 @@ int fuse_reply_xattr(fuse_req_t req, size_t count)
 int fuse_reply_getlk(fuse_req_t req, const struct fuse_lock_param *lk)
 {
     struct fuse_lk_in_out arg;
-    
+
     memset(&arg, 0, sizeof(arg));
     convert_lock_param(lk, &arg.lk);
-    
+
     return send_reply_req(req, &arg, sizeof(arg));
 }
 
@@ -482,10 +482,10 @@ static void do_rmdir(fuse_req_t req, fuse_ino_t nodeid, char *name)
 }
 
 static void do_symlink(fuse_req_t req, fuse_ino_t nodeid, char *name,
-                       char *link)
+                       char *linkname)
 {
     if (req->f->op.symlink)
-        req->f->op.symlink(req, link, nodeid, name);
+        req->f->op.symlink(req, linkname, nodeid, name);
     else
         fuse_reply_err(req, ENOSYS);
 }
@@ -706,7 +706,7 @@ static void do_getlk(fuse_req_t req, fuse_ino_t nodeid,
 {
     if (req->f->op.getlk) {
         struct fuse_lock_param lk;
-        
+
         memset(&lk, 0, sizeof(lk));
         convert_file_lock(&arg->lk, &lk);
         req->f->op.getlk(req, nodeid, &lk);
@@ -714,15 +714,15 @@ static void do_getlk(fuse_req_t req, fuse_ino_t nodeid,
         fuse_reply_err(req, ENOSYS);
 }
 
-static void do_setlk(fuse_req_t req, fuse_ino_t nodeid, int sleep, 
+static void do_setlk(fuse_req_t req, fuse_ino_t nodeid, int issleep,
                      struct fuse_lk_in_out *arg)
 {
     if (req->f->op.setlk) {
         struct fuse_lock_param lk;
-        
+
         memset(&lk, 0, sizeof(lk));
         convert_file_lock(&arg->lk, &lk);
-        req->f->op.setlk(req, nodeid, sleep, &lk);
+        req->f->op.setlk(req, nodeid, issleep, &lk);
     } else
         fuse_reply_err(req, ENOSYS);
 }
@@ -781,7 +781,7 @@ void fuse_ll_process_cmd(struct fuse_ll *f, struct fuse_cmd *cmd)
 
     if (f->debug) {
         printf("unique: %llu, opcode: %s (%i), nodeid: %lu, insize: %i\n",
-               in->unique, opname(in->opcode), in->opcode,
+               in->unique, opname((enum fuse_opcode) in->opcode), in->opcode,
                (unsigned long) in->nodeid, cmd->buflen);
         fflush(stdout);
     }
@@ -936,7 +936,7 @@ void fuse_ll_process_cmd(struct fuse_ll *f, struct fuse_cmd *cmd)
     case FUSE_SETLKW:
         do_setlk(req, in->nodeid, 1, (struct fuse_lk_in_out *) inarg);
         break;
-        
+
     case FUSE_ACCESS:
         do_access(req, in->nodeid, (struct fuse_access_in *) inarg);
         break;

diff --git a/lib/fuse_lowlevel_mt.c b/lib/fuse_lowlevel_mt.c
index a06d42c41498e7d6fe22236838eddd188428f398..ee3a0ac786476ea4627f48449741e490844bcae2 100644 (file)
--- a/lib/fuse_lowlevel_mt.c
+++ b/lib/fuse_lowlevel_mt.c
@@ -94,7 +94,7 @@ int fuse_ll_loop_mt_proc(struct fuse_ll *f, fuse_ll_processor_t proc, void *data
     struct fuse_worker *w;
     int i;
 
-    w = malloc(sizeof(struct fuse_worker));
+    w = (struct fuse_worker *) malloc(sizeof(struct fuse_worker));
     if (w == NULL) {
         fprintf(stderr, "fuse: failed to allocate worker structure\n");
         return -1;

diff --git a/lib/fuse_mt.c b/lib/fuse_mt.c
index bbd03921fef957ba1d59e6004396a62fb850883d..835999475585673ff8477466385549e50103b501 100644 (file)
--- a/lib/fuse_mt.c
+++ b/lib/fuse_mt.c
@@ -40,7 +40,7 @@ static void mt_freecontext(void *data)
     free(data);
 }
 
-static int mt_create_context_key()
+static int mt_create_context_key(void)
 {
     int err = 0;
     pthread_mutex_lock(&context_lock);
@@ -58,7 +58,7 @@ static int mt_create_context_key()
     return err;
 }
 
-static void mt_delete_context_key()
+static void mt_delete_context_key(void)
 {
     pthread_mutex_lock(&context_lock);
     context_ref--;

diff --git a/lib/helper.c b/lib/helper.c
index 681197d613cf054fc1fc6e1ee3f2be0efc98d963..a6c472fe06795b8e4bad80ad8a26b1bacf688b73 100644 (file)
--- a/lib/helper.c
+++ b/lib/helper.c
@@ -63,13 +63,14 @@ static void invalid_option(const char *argv[], int argctr)
     fprintf(stderr, "see `%s -h' for usage\n", argv[0]);
 }
 
-static void exit_handler()
+static void exit_handler(int sig)
 {
+    (void) sig;
     if (fuse_instance != NULL)
         fuse_exit(fuse_instance);
 }
 
-static int set_one_signal_handler(int signal, void (*handler)(int))
+static int set_one_signal_handler(int sig, void (*handler)(int))
 {
     struct sigaction sa;
     struct sigaction old_sa;
@@ -79,20 +80,20 @@ static int set_one_signal_handler(int signal, void (*handler)(int))
     sigemptyset(&(sa.sa_mask));
     sa.sa_flags = 0;
 
-    if (sigaction(signal, NULL, &old_sa) == -1) {
+    if (sigaction(sig, NULL, &old_sa) == -1) {
         perror("FUSE: cannot get old signal handler");
         return -1;
     }
 
     if (old_sa.sa_handler == SIG_DFL &&
-        sigaction(signal, &sa, NULL) == -1) {
+        sigaction(sig, &sa, NULL) == -1) {
         perror("Cannot set signal handler");
         return -1;
     }
     return 0;
 }
 
-static int set_signal_handlers()
+static int set_signal_handlers(void)
 {
     if (set_one_signal_handler(SIGHUP, exit_handler) == -1 ||
         set_one_signal_handler(SIGINT, exit_handler) == -1 ||
@@ -121,13 +122,13 @@ static int add_option_to(const char *opt, char **optp)
     unsigned len = strlen(opt);
     if (*optp) {
         unsigned oldlen = strlen(*optp);
-        *optp = realloc(*optp, oldlen + 1 + len + 1);
+        *optp = (char *) realloc(*optp, oldlen + 1 + len + 1);
         if (*optp == NULL)
             return -1;
         (*optp)[oldlen] = ',';
         strcpy(*optp + oldlen + 1, opt);
     } else {
-        *optp = malloc(len + 1);
+        *optp = (char *) malloc(len + 1);
         if (*optp == NULL)
             return -1;
         strcpy(*optp, opt);
@@ -197,7 +198,7 @@ static int fuse_parse_cmdline(int argc, const char *argv[], char **kernel_opts,
     else if (basename[1] != '\0')
         basename++;
 
-    fsname_opt = malloc(strlen(basename) + 64);
+    fsname_opt = (char *) malloc(strlen(basename) + 64);
     if (fsname_opt == NULL) {
         fprintf(stderr, "fuse: memory allocation failed\n");
         return -1;
@@ -419,7 +420,7 @@ int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
 }
 
 #undef fuse_main
-int fuse_main()
+int fuse_main(void)
 {
     fprintf(stderr, "fuse_main(): This function does not exist\n");
     return -1;

diff --git a/lib/mount.c b/lib/mount.c
index 01081bb814aea3446a395a2f87b9fd699126659c..3236ce854d665927dad7a6fdd871a3303a0103b4 100644 (file)
--- a/lib/mount.c
+++ b/lib/mount.c
@@ -108,7 +108,7 @@ int fuse_mount(const char *mountpoint, const char *opts)
         char env[10];
         const char *argv[32];
         int a = 0;
-        
+
         argv[a++] = mountprog;
         if (opts) {
             argv[a++] = "-o";

diff --git a/util/fusermount.c b/util/fusermount.c
index 9c7bbf31491c32455b784f2037db730940456fc6..21504d4bd1da4e0227d1854d3a803bb77425899f 100644 (file)
--- a/util/fusermount.c
+++ b/util/fusermount.c
@@ -51,7 +51,7 @@ static const char *progname;
 static int user_allow_other = 0;
 static int mount_max = 1000;
 
-static const char *get_user_name()
+static const char *get_user_name(void)
 {
     struct passwd *pw = getpwuid(getuid());
     if (pw != NULL && pw->pw_name != NULL)
@@ -95,7 +95,7 @@ static int do_unmount(const char *mnt, int quiet, int lazy)
 #ifndef USE_UCLIBC
 /* use a lock file so that multiple fusermount processes don't try and
    modify the mtab file at once! */
-static int lock_mtab()
+static int lock_mtab(void)
 {
     const char *mtab_lock = _PATH_MOUNTED ".fuselock";
     int mtablock;
@@ -184,18 +184,18 @@ static int remove_mount(const char *mnt, int quiet, const char *mtab,
 
     found = 0;
     while ((entp = getmntent(fp)) != NULL) {
-        int remove = 0;
+        int removed = 0;
         if (!found && strcmp(entp->mnt_dir, mnt) == 0 &&
            strcmp(entp->mnt_type, "fuse") == 0) {
             if (user == NULL)
-                remove = 1;
+                removed = 1;
             else {
                 char *p = strstr(entp->mnt_opts, "user=");
                 if (p != NULL && strcmp(p + 5, user) == 0)
-                    remove = 1;
+                    removed = 1;
             }
         }
-        if (remove)
+        if (removed)
             found = 1;
         else {
             res = addmntent(newfp, entp);
@@ -220,7 +220,7 @@ static int remove_mount(const char *mnt, int quiet, const char *mtab,
     return 0;
 }
 
-static int count_fuse_fs()
+static int count_fuse_fs(void)
 {
     struct mntent *entp;
     int count = 0;
@@ -424,7 +424,7 @@ static int add_option(char **optsp, const char *opt, unsigned expand)
     else {
         unsigned oldsize = strlen(*optsp);
         unsigned newsize = oldsize + 1 + strlen(opt) + expand + 1;
-        newopts = realloc(*optsp, newsize);
+        newopts = (char *) realloc(*optsp, newsize);
         if (newopts)
             sprintf(newopts + oldsize, ",%s", opt);
     }
@@ -521,7 +521,7 @@ static int do_mount(const char *mnt, const char *type, mode_t rootmode,
     char *fsname = NULL;
     int check_empty = 1;
 
-    optbuf = malloc(strlen(opts) + 128);
+    optbuf = (char *) malloc(strlen(opts) + 128);
     if (!optbuf) {
         fprintf(stderr, "%s: failed to allocate memory\n", progname);
         return -1;
@@ -535,7 +535,7 @@ static int do_mount(const char *mnt, const char *type, mode_t rootmode,
             unsigned fsname_str_len = strlen(fsname_str);
             if (fsname)
                 free(fsname);
-            fsname = malloc(len - fsname_str_len + 1);
+            fsname = (char *) malloc(len - fsname_str_len + 1);
             if (!fsname) {
                 fprintf(stderr, "%s: failed to allocate memory\n", progname);
                 goto err;