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

openpkg/mutex.c@c10fb90893b9 (annotated)

openpkg/mutex.c

Thu, 04 Oct 2012 20:30:05 +0200

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 04 Oct 2012 20:30:05 +0200
changeset 715: c10fb90893b9
permissions: -rw-r--r--

Correct out of date build configuration, porting to Solaris 11 network
link infrastructure and new libpcap logic. This additionally allows for
device drivers in subdirectories of /dev. Correct packaged nmap
personalities and signatures to work out of the box. Finally, hack
arpd logic to properly close sockets and quit on TERM by repeating
signaling in the run command script. Sadly, all this fails to correct
the run time behaviour of honeyd which fails to bind to the IP layer.

 /*
 **  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@c10fb90893b9 (annotated)

openpkg/mutex.c