OpenPKG Specs: openpkg/mutex.c@a2c6460cfb16 (annotated)

openpkg/mutex.c@a2c6460cfb16 (annotated)

openpkg/mutex.c

Mon, 28 Jan 2013 17:37:18 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Mon, 28 Jan 2013 17:37:18 +0100
changeset 758: a2c6460cfb16
permissions: -rw-r--r--

Correct socket error reporting improvement with IPv6 portable code,
after helpful recommendation by Saúl Ibarra Corretgé on OSips devlist.

 /*
 **  mutex.c -- OpenPKG Mutex Utility
 **  Copyright (c) 2008-2012 OpenPKG GmbH <http://openpkg.com/>
 **
 **  This software is property of the OpenPKG GmbH, DE MUC HRB 160208.
 **  All rights reserved. Licenses which grant limited permission to use,
 **  copy, modify and distribute this software are available from the
 **  OpenPKG GmbH.
 **
 **  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 **  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 **  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 **  IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
 **  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 **  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 **  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 **  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 **  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 **  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 **  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 **  SUCH DAMAGE.
 */
 /*  standard system headers  */
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 /*  non-standard add-on headers */
 #include "popt.h"
 /*  program information  */
 #define PROGRAM_NAME         "mutex"
 /*  error handling constants  */
 #define EXITCODE_NONE        00
 #define EXITCODE_USAGE       64
 #define EXITCODE_OSERR       71
 #define EXITCODE_CANTCREAT   73
 #define EXITCODE_TEMPFAIL    75
 #define ERRORCODE_NONE       0
 #define ERRORCODE_SYSTEM     1
 /*  global variables  */
 static const char           *mutex_filename  = NULL;
 static int                   mutex_fd        = -1;
 static int                   mutex_keep      = 0;
 static int                   mutex_timeout   = -1;
 static volatile int          mutex_timed_out = 0;
 /*  display warning and continue or display error and exit  */
 static void
 error(
     int exitcode,
     int errorcode,
     const char *fmt, ...)
 {
     va_list ap;
     int errno_safed = errno;
     va_start(ap, fmt);
     if (exitcode != 0)
         fprintf(stderr, PROGRAM_NAME ":ERROR: ");
     else
         fprintf(stderr, PROGRAM_NAME ":WARNING: ");
     vfprintf(stderr, fmt, ap);
     if (errorcode)
        fprintf(stderr, ": %s", strerror(errno_safed));
     fprintf(stderr, "\n");
     va_end(ap);
     if (exitcode != 0)
         exit(exitcode);
     return;
 }
 /*  acquire mutex */
 static int
 mutex_acquire(int nonblock)
 {
     static struct flock lock;
     int flags;
     /* open mutex file (and optionally create it) */
     flags = O_RDWR|O_CREAT;
     if (nonblock)
         flags |= O_NONBLOCK;
     if ((mutex_fd = open(mutex_filename, flags, 0600)) == -1) {
         if (errno == EAGAIN || errno == EINTR)
             return 0;
         error(EXITCODE_CANTCREAT, ERRORCODE_SYSTEM, "cannot open mutex file \"%s\"",
             mutex_filename);
     }
     /* acquire exclusive lock on the mutex file */
     lock.l_whence = SEEK_SET; /* from current point */
     lock.l_start  = 0;        /* -"- */
     lock.l_len    = 0;        /* until end of file */
     lock.l_type   = F_WRLCK;  /* set exclusive/read-write lock */
     lock.l_pid    = 0;        /* pid not actually interesting */
     if (fcntl(mutex_fd, nonblock ? F_SETLK : F_SETLKW, &lock) == -1) {
         close(mutex_fd);
         mutex_fd = -1;
         return 0;
     }
     return 1;
 }
 /*  release mutex  */
 static void
 mutex_release(void)
 {
     static struct flock unlock;
     if (mutex_fd != -1) {
         /* release lock on the mutex file */
         unlock.l_whence  = SEEK_SET; /* from current point */
         unlock.l_start   = 0;        /* -"- */
         unlock.l_len     = 0;        /* until end of file */
         unlock.l_type    = F_UNLCK;  /* unlock */
         unlock.l_pid     = 0;        /* pid not actually interesting */
         fcntl(mutex_fd, F_SETLK, &unlock);
         /* close mutex file */
         close(mutex_fd);
         mutex_fd = -1;
     }
     return;
 }
 /*  destroy the mutex  */
 static void
 mutex_destroy(
     void)
 {
     /* release lock on mutex file */
     mutex_release();
     /* optionally remove mutex file */
     if (!mutex_keep)
         unlink(mutex_filename);
     return;
 }
 /*  signal handler for SIGTERM  */
 static void
 handler_killed(
     int sig)
 {
     /* destroy mutex */
     mutex_destroy();
     /* re-raise the signal */
     signal(sig, SIG_DFL);
     if (kill(getpid(), sig) == -1)
         error(EXITCODE_OSERR, ERRORCODE_SYSTEM, "kill(2) failed");
     return;
 }
 /*  signal handler for SIGALRM  */
 static void
 handler_timeout(
     int sig)
 {
     mutex_timed_out = 1;
     return;
 }
 /*  command line options  */
 static struct poptOption options_tab[] = {
     { "keep",    'k', POPT_ARG_NONE, &mutex_keep,    0, NULL, NULL },
     { "timeout", 't', POPT_ARG_INT,  &mutex_timeout, 0, NULL, NULL },
     POPT_TABLEEND
 };
 /*  main program procedure  */
 int
 main(
     int argc,
     char *argv[])
 {
     int status;
     pid_t child;
     int locked;
     char c;
     const char **args;
     poptContext options_ctx;
     /* process command line arguments */
     options_ctx = poptGetContext(argv[0], argc, (const char **)argv,
         options_tab, POPT_CONTEXT_NO_EXEC|POPT_CONTEXT_POSIXMEHARDER);
     while ((c = poptGetNextOpt(options_ctx)) > 0)
         ;
     if (c < -1)
         error(EXITCODE_USAGE, ERRORCODE_NONE, "command line option \"%s\": %s",
             poptBadOption(options_ctx, POPT_BADOPTION_NOALIAS), poptStrerror(c));
     mutex_filename = poptGetArg(options_ctx);
     if (mutex_filename == NULL) {
         fprintf(stderr,
             "usage: %s [--keep|-k] [--timeout|-t <seconds>] <mutex-file> <command> [<arguments>]\n",
             PROGRAM_NAME);
         exit(EXITCODE_USAGE);
     }
     args = poptGetArgs(options_ctx);
     /* optionally set up a timeout */
     if (mutex_timeout > 0) {
         struct sigaction act;
         act.sa_handler = handler_timeout;
         act.sa_flags = 0;
         sigemptyset(&act.sa_mask);
         sigaction(SIGALRM, &act, NULL);
         alarm(mutex_timeout);
     }
     /* try to acquire the mutex lock */
     locked = mutex_acquire(1 /* non-blocking */);
     while (!locked && !mutex_timed_out && mutex_timeout != 0)
         locked = mutex_acquire(0 /* blocking */);
     /* optionally destroy timeout */
     if (mutex_timeout > 0)
         alarm(0);
     /* exit in case we failed to acquire the mutex lock */
     if (!locked)
         error(EXITCODE_TEMPFAIL, ERRORCODE_NONE, "%s: already locked", mutex_filename);
     /* execute the command */
     if (atexit(mutex_destroy) == -1)
         error(EXITCODE_OSERR, ERRORCODE_SYSTEM, "atexit(3) failed");
     if ((child = fork()) == -1)
         error(EXITCODE_OSERR, ERRORCODE_SYSTEM, "fork(2) failed");
     if (child == 0) {
         /* the child process */
         mutex_release();
         execvp((char *)args[0], (char **)args);
         error(EXITCODE_NONE, ERRORCODE_SYSTEM, "execvp(2) failed: %s", args[0]);
         exit(1);
     }
     poptFreeContext(options_ctx);
     /* wait for child process and return its exit status */
     signal(SIGINT,  SIG_IGN);
     signal(SIGQUIT, SIG_IGN);
     signal(SIGTERM, handler_killed);
     if (waitpid(child, &status, 0) == -1)
         error(EXITCODE_OSERR, ERRORCODE_SYSTEM, "waitpid(2) failed");
     return (WIFEXITED(status) ? WEXITSTATUS(status) : 1);
 }

OpenPKG Specs / annotate

openpkg/mutex.c@a2c6460cfb16 (annotated)

openpkg/mutex.c