[PATCH] Fix multiple compilation warnings

[apps/madmutt.git] / dotlock.c

diff --git a/dotlock.c b/dotlock.c
index 19e2ad6..f89fb1f 100644 (file)
--- a/dotlock.c
+++ b/dotlock.c
@@ -72,7 +72,7 @@ static gid_t MailGid;
 #endif
 
 static int dotlock_deference_symlink (char *, size_t, const char *);
-static int dotlock_prepare (char *, size_t, const char *, int fd);
+static int dotlock_prepare (char *, ssize_t, const char *, int fd);
 static int dotlock_check_stats (struct stat *, struct stat *);
 static int dotlock_dispatch (const char *, int fd);
 
@@ -191,7 +191,7 @@ static int dotlock_init_privs (void)
 
 static int dotlock_dispatch (const char *f, int fd)
 {
-  char realpath[_POSIX_PATH_MAX];
+  char frealpath[_POSIX_PATH_MAX];
 
   /* If dotlock_prepare () succeeds [return value == 0],
    * realpath contains the basename of f, and we have
@@ -204,7 +204,7 @@ static int dotlock_dispatch (const char *f, int fd)
    * lengthy comment below.
    */
 
-  if (dotlock_prepare (realpath, sizeof (realpath), f, fd) != 0)
+  if (dotlock_prepare (frealpath, sizeof (frealpath), f, fd) != 0)
     return DL_EX_ERROR;
 
   /* Actually perform the locking operation. */
@@ -212,11 +212,11 @@ static int dotlock_dispatch (const char *f, int fd)
   if (DotlockFlags & DL_FL_TRY)
     return dotlock_try ();
   else if (DotlockFlags & DL_FL_UNLOCK)
-    return dotlock_unlock (realpath);
+    return dotlock_unlock (frealpath);
   else if (DotlockFlags & DL_FL_UNLINK)
-    return dotlock_unlink (realpath);
+    return dotlock_unlink (frealpath);
   else                          /* lock */
-    return dotlock_lock (realpath);
+    return dotlock_lock (frealpath);
 }
 
 
@@ -360,39 +360,39 @@ static int dotlock_check_stats (struct stat *fsb, struct stat *lsb)
   return 0;
 }
 
-static int dotlock_prepare (char *bn, size_t l, const char *f, int _fd)
+static int dotlock_prepare (char *bn, ssize_t l, const char *f, int _fd)
 {
   struct stat fsb, lsb;
-  char realpath[_POSIX_PATH_MAX];
-  char *basename, *dirname;
+  char frealpath[_POSIX_PATH_MAX];
+  char *fbasename, *dirname;
   char *p;
   int fd;
   int r;
 
-  if (dotlock_deference_symlink (realpath, sizeof (realpath), f) == -1)
+  if (dotlock_deference_symlink (frealpath, sizeof (frealpath), f) == -1)
     return -1;
 
-  if ((p = strrchr (realpath, '/'))) {
+  if ((p = strrchr (frealpath, '/'))) {
     *p = '\0';
-    basename = p + 1;
-    dirname = realpath;
+    fbasename = p + 1;
+    dirname = frealpath;
   }
   else {
-    basename = realpath;
-    dirname = ".";
+    fbasename = frealpath;
+    dirname = m_strdup(".");
   }
 
-  if (m_strlen(basename) + 1 > l)
+  if (m_strlen(fbasename) + 1 > l)
     return -1;
 
-  m_strcpy(bn, l, basename);
+  m_strcpy(bn, l, fbasename);
 
   if (chdir (dirname) == -1)
     return -1;
 
   if (_fd != -1)
     fd = _fd;
-  else if ((fd = open (basename, O_RDONLY)) == -1)
+  else if ((fd = open (fbasename, O_RDONLY)) == -1)
     return -1;
 
   r = fstat (fd, &fsb);
@@ -403,7 +403,7 @@ static int dotlock_prepare (char *bn, size_t l, const char *f, int _fd)
   if (r == -1)
     return -1;
 
-  if (lstat (basename, &lsb) == -1)
+  if (lstat (fbasename, &lsb) == -1)
     return -1;
 
   if (dotlock_check_stats (&fsb, &lsb) == -1)
@@ -421,26 +421,26 @@ static int dotlock_prepare (char *bn, size_t l, const char *f, int _fd)
  */
 
 static void
-dotlock_expand_link (char *newpath, const char *path, const char *link)
+dotlock_expand_link (char *newpath, const char *path, const char *flink)
 {
   const char *lb = NULL;
   size_t len;
 
   /* link is full path */
-  if (*link == '/') {
-    m_strcpy(newpath, _POSIX_PATH_MAX, link);
+  if (*flink == '/') {
+    m_strcpy(newpath, _POSIX_PATH_MAX, flink);
     return;
   }
 
   if ((lb = strrchr (path, '/')) == NULL) {
     /* no path in link */
-    m_strcpy(newpath, _POSIX_PATH_MAX, link);
+    m_strcpy(newpath, _POSIX_PATH_MAX, flink);
     return;
   }
 
   len = lb - path + 1;
   memcpy (newpath, path, len);
-  m_strcpy(newpath + len, _POSIX_PATH_MAX - len, link);
+  m_strcpy(newpath + len, _POSIX_PATH_MAX - len, flink);
 }
 
 
@@ -454,7 +454,7 @@ dotlock_expand_link (char *newpath, const char *path, const char *link)
 static int dotlock_deference_symlink (char *d, size_t l, const char *path)
 {
   struct stat sb;
-  char realpath[_POSIX_PATH_MAX];
+  char frealpath[_POSIX_PATH_MAX];
   const char *pathptr = path;
   int count = 0;
 
@@ -476,8 +476,8 @@ static int dotlock_deference_symlink (char *d, size_t l, const char *path)
 
       linkfile[len] = '\0';
       dotlock_expand_link (linkpath, pathptr, linkfile);
-      m_strcpy(realpath, sizeof(realpath), linkpath);
-      pathptr = realpath;
+      m_strcpy(frealpath, sizeof(frealpath), linkpath);
+      pathptr = frealpath;
     }
     else
       break;
@@ -498,7 +498,7 @@ static int dotlock_deference_symlink (char *d, size_t l, const char *path)
 
 #define HARDMAXATTEMPTS 10
 
-static int dotlock_lock (const char *realpath)
+static int dotlock_lock (const char *frealpath)
 {
   char lockfile[_POSIX_PATH_MAX + LONG_STRING];
   char nfslockfile[_POSIX_PATH_MAX + LONG_STRING];
@@ -510,8 +510,8 @@ static int dotlock_lock (const char *realpath)
   time_t t;
 
   snprintf (nfslockfile, sizeof (nfslockfile), "%s.%s.%d",
-            realpath, Hostname, (int) getpid ());
-  snprintf (lockfile, sizeof (lockfile), "%s.lock", realpath);
+            frealpath, Hostname, (int) getpid ());
+  snprintf (lockfile, sizeof (lockfile), "%s.lock", frealpath);
 
 
   BEGIN_PRIVILEGED ();
@@ -597,12 +597,12 @@ static int dotlock_lock (const char *realpath)
  * 
  */
 
-static int dotlock_unlock (const char *realpath)
+static int dotlock_unlock (const char *frealpath)
 {
   char lockfile[_POSIX_PATH_MAX + LONG_STRING];
   int i;
 
-  snprintf (lockfile, sizeof (lockfile), "%s.lock", realpath);
+  snprintf (lockfile, sizeof (lockfile), "%s.lock", frealpath);
 
   BEGIN_PRIVILEGED ();
   i = unlink (lockfile);
@@ -616,18 +616,18 @@ static int dotlock_unlock (const char *realpath)
 
 /* remove an empty file */
 
-static int dotlock_unlink (const char *realpath)
+static int dotlock_unlink (const char *frealpath)
 {
   struct stat lsb;
   int i = -1;
 
-  if (dotlock_lock (realpath) != DL_EX_OK)
+  if (dotlock_lock (frealpath) != DL_EX_OK)
     return DL_EX_ERROR;
 
-  if ((i = lstat (realpath, &lsb)) == 0 && lsb.st_size == 0)
-    unlink (realpath);
+  if ((i = lstat (frealpath, &lsb)) == 0 && lsb.st_size == 0)
+    unlink (frealpath);
 
-  dotlock_unlock (realpath);
+  dotlock_unlock (frealpath);
 
   return (i == 0) ? DL_EX_OK : DL_EX_ERROR;
 }