Use p_new instead of xmalloc()

[apps/madmutt.git] / dotlock.c

diff --git a/dotlock.c b/dotlock.c
index 19e2ad6..8d562c8 100644 (file)
--- a/dotlock.c
+++ b/dotlock.c
@@ -8,30 +8,10 @@
  * please see the file GPL in the top level source directory.
  */
 
-#if HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include <lib-lib/lib-lib.h>
 
-#include <unistd.h>
-#include <dirent.h>
-#include <sys/file.h>
-#include <sys/stat.h>
 #include <sys/utsname.h>
-#include <errno.h>
-#include <time.h>
-#include <fcntl.h>
-#include <limits.h>
-
-#ifndef _POSIX_PATH_MAX
-#include <posix1_lim.h>
-#endif
-
 #include "dotlock.h"
-#include "config.h"
 
 #ifdef HAVE_GETOPT_H
 #include <getopt.h>
@@ -55,12 +35,6 @@
 
 # endif
 
-# ifndef HAVE_SNPRINTF
-extern int snprintf (char *, size_t, const char *, ...);
-# endif
-
-#include <lib-lib/str.h>
-
 static int DotlockFlags;
 static int Retry = MAXLOCKATTEMPT;
 
@@ -72,7 +46,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);
 
@@ -111,7 +85,7 @@ int main (int argc, char **argv)
   /* determine the system's host name */
 
   uname (&utsname);
-  if (!(Hostname = strdup (utsname.nodename)))  /* __MEM_CHECKED__ */
+  if (!(Hostname = strdup(utsname.nodename)))
     return DL_EX_ERROR;
   if ((p = strchr (Hostname, '.')))
     *p = '\0';
@@ -191,7 +165,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 +178,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 +186,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);
 }
 
 
@@ -273,7 +247,7 @@ static void END_PRIVILEGED (void)
 
 static void usage (const char *av0)
 {
-  fprintf (stderr, "dotlock [Mutt-ng %s]\n", VERSION);
+  fprintf (stderr, "dotlock [Madmutt %s]\n", VERSION);
   fprintf (stderr, "usage: %s [-t|-f|-u|-d] [-p] [-r <retries>] file\n", av0);
 
   fputs ("\noptions:"
@@ -360,39 +334,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 +377,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 +395,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 +428,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 +450,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,11 +472,11 @@ 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];
-  size_t prev_size = 0;
+  ssize_t prev_size = 0;
   int fd;
   int count = 0;
   int hard_count = 0;
@@ -510,8 +484,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 +571,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 +590,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;
 }