/* $NetBSD: flock.c,v 1.12 2019/10/04 16:27:00 mrg Exp $ */
/*-
* Copyright (c) 2012 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Christos Zoulas.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS 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 FOUNDATION OR 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.
*/
#include <sys/cdefs.h>
__RCSID("$NetBSD: flock.c,v 1.12 2019/10/04 16:27:00 mrg Exp $");
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <err.h>
#include <errno.h>
#include <getopt.h>
#include <paths.h>
#include <limits.h>
#include <time.h>
static struct option flock_longopts[] = {
{ "debug", no_argument, 0, 'd' },
{ "help", no_argument, 0, 'h' },
{ "nonblock", no_argument, 0, 'n' },
{ "nb", no_argument, 0, 'n' },
{ "close", no_argument, 0, 'o' },
{ "shared", no_argument, 0, 's' },
{ "exclusive", no_argument, 0, 'x' },
{ "unlock", no_argument, 0, 'u' },
{ "verbose", no_argument, 0, 'v' },
{ "command", required_argument, 0, 'c' },
{ "wait", required_argument, 0, 'w' },
{ "timeout", required_argument, 0, 'w' },
{ NULL, 0, 0, 0 },
};
static sig_atomic_t timeout_expired;
static __dead __printflike(1, 2) void
usage(const char *fmt, ...)
{
if (fmt) {
va_list ap;
va_start(ap, fmt);
fprintf(stderr, "%s: ", getprogname());
vfprintf(stderr, fmt, ap);
fputc('\n', stderr);
va_end(ap);
}
fprintf(stderr, "Usage: %s [-dnosvx] [-w timeout] lockfile|lockdir "
"[-c command]|command ...\n\t%s [-dnsuvx] [-w timeout] lockfd\n",
getprogname(), getprogname());
exit(EXIT_FAILURE);
}
static void
sigalrm(int sig)
{
timeout_expired++;
}
static const char *
lock2name(int l)
{
static char buf[1024];
int nb = l & LOCK_NB;
l &= ~LOCK_NB;
if (nb)
strlcpy(buf, "LOCK_NB|", sizeof(buf));
else
buf[0] = '\0';
switch (l) {
case LOCK_SH:
strlcat(buf, "LOCK_SH", sizeof(buf));
return buf;
case LOCK_EX:
strlcat(buf, "LOCK_EX", sizeof(buf));
return buf;
case LOCK_UN:
strlcat(buf, "LOCK_UN", sizeof(buf));
return buf;
default:
snprintf(buf, sizeof(buf), "*%d*", l | nb);
return buf;
}
}
static char
lockchar(int l)
{
switch (l & ~LOCK_NB) {
case LOCK_SH:
return 's';
case LOCK_EX:
return 'x';
case LOCK_UN:
return 'u';
default:
return '*';
}
}
static char *
cmdline(char **av)
{
char *v = NULL;
while (*av)
if (v) {
if (asprintf(&v, "%s %s", v, *av++) < 0)
err(EXIT_FAILURE, "malloc");
} else {
if ((v = strdup(*av++)) == NULL)
err(EXIT_FAILURE, "strdup");
}
return v;
}
int
main(int argc, char *argv[])
{
int c;
int lock = 0;
double timeout = 0;
int cls = 0;
int fd = -1;
int debug = 0;
int verbose = 0;
long l;
char *mcargv[] = {
__UNCONST(_PATH_BSHELL), __UNCONST("-c"), NULL, NULL
};
char **cmdargv = NULL, *v;
timer_t tm;
setprogname(argv[0]);
while ((c = getopt_long(argc, argv, "+dnosuvw:x", flock_longopts, NULL))
!= -1)
switch (c) {
case 'd':
debug++;
break;
case 'x':
#define T(l) (lock & ~LOCK_NB) != (l) && (lock & ~LOCK_NB) != 0
if (T(LOCK_EX))
goto badlock;
lock |= LOCK_EX;
break;
case 'n':
lock |= LOCK_NB;
break;
case 's':
if (T(LOCK_SH))
goto badlock;
lock |= LOCK_SH;
break;
case 'u':
if (T(LOCK_UN))
goto badlock;
lock |= LOCK_UN;
break;
case 'w':
timeout = strtod(optarg, NULL);
break;
case 'v':
verbose = 1;
break;
case 'o':
cls = 1;
break;
default:
usage("Invalid option '%c'", c);
badlock:
usage("-%c can't be used with -%c", c, lockchar(lock));
}
argc -= optind;
argv += optind;
if ((lock & ~LOCK_NB) == 0)
lock |= LOCK_EX; /* default to exclusive like linux */
switch (argc) {
case 0:
usage("Missing lock file argument");
case 1:
if (cls)
usage("Close is not valid for descriptors");
errno = 0;
l = strtol(argv[0], &v, 0);
if ((l == LONG_MIN || l == LONG_MAX) && errno == ERANGE)
err(EXIT_FAILURE, "Bad file descriptor `%s'", argv[0]);
if (l > INT_MAX || l < 0 || *v)
errx(EXIT_FAILURE, "Bad file descriptor `%s'", argv[0]);
fd = (int)l;
if (debug) {
fprintf(stderr, "descriptor %s lock %s\n",
argv[0], lock2name(lock));
}
break;
default:
if ((lock & ~LOCK_NB) == LOCK_UN)
usage("Unlock is only valid for descriptors");
if (strcmp(argv[1], "-c") == 0 ||
strcmp(argv[1], "--command") == 0) {
if (argc == 2)
usage("Missing argument to %s", strcmp(argv[1],
"-c") == 0 ? "-c" : "--command");
mcargv[2] = argv[2];
cmdargv = mcargv;
} else
cmdargv = argv + 1;
if ((fd = open(argv[0], O_RDONLY)) == -1) {
if (errno != ENOENT ||
(fd = open(argv[0], O_RDWR|O_CREAT, 0600)) == -1)
err(EXIT_FAILURE, "Cannot open `%s'", argv[0]);
}
if (debug) {
fprintf(stderr, "file %s lock %s command %s ...\n",
argv[0], lock2name(lock), v = cmdline(cmdargv));
free(v);
}
break;
}
if (timeout) {
struct sigevent ev;
struct itimerspec it;
struct sigaction sa;
timespecclear(&it.it_interval);
it.it_value.tv_sec = timeout;
it.it_value.tv_nsec = (timeout - it.it_value.tv_sec) *
1000000000;
memset(&ev, 0, sizeof(ev));
ev.sigev_notify = SIGEV_SIGNAL;
ev.sigev_signo = SIGALRM;
if (timer_create(CLOCK_REALTIME, &ev, &tm) == -1)
err(EXIT_FAILURE, "timer_create");
if (timer_settime(tm, TIMER_RELTIME, &it, NULL) == -1)
err(EXIT_FAILURE, "timer_settime");
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sigalrm;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
if (sigaction(SIGALRM, &sa, NULL) == -1)
err(EXIT_FAILURE, "sigaction");
if (debug)
fprintf(stderr, "alarm %g\n", timeout);
}
while (flock(fd, lock) == -1) {
if (errno == EINTR && timeout_expired == 0)
continue;
if (verbose)
err(EXIT_FAILURE, "flock(%d, %s)", fd, lock2name(lock));
else
return EXIT_FAILURE;
}
if (timeout)
timer_delete(tm);
if (cls)
(void)close(fd);
if (cmdargv != NULL) {
execvp(cmdargv[0], cmdargv);
err(EXIT_FAILURE, "execvp '%s'", v = cmdline(cmdargv));
free(v);
}
return 0;
}
