[misc] / locking.c

/* -*-c-*-
 *
 * $Id: locking.c,v 1.2 2003/10/09 15:15:42 mdw Exp $
 *
 * Lock a file, run a program
 *
 * (c) 2003 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------* 
 *
 * This file is part of the Toys utilties collection.
 *
 * Toys is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * Toys is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with Toys; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Revision history --------------------------------------------------* 
 *
 * $Log: locking.c,v $
 * Revision 1.2  2003/10/09 15:15:42  mdw
 * Missed a paren.  Un-`toys'-ify.
 *
 * Revision 1.1  2003/10/09 15:05:34  mdw
 * Lots of stuff.
 *
 * Revision 1.3  2003/09/24 14:58:08  mdw
 * Fix options parsing again.
 *
 * Revision 1.2  2003/09/24 14:14:03  mdw
 * Fix option handling behaviour.
 *
 * Revision 1.1  2003/05/11 13:30:04  mdw
 * Initial checkin.
 *
 */

/*----- Header files ------------------------------------------------------*/

#include <errno.h>
#include <setjmp.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>

#include <mLib/mdwopt.h>
#include <mLib/quis.h>
#include <mLib/report.h>

/*----- Static variables --------------------------------------------------*/

static jmp_buf jmp;

/*----- Main code ---------------------------------------------------------*/

static void alrm(int s) { longjmp(jmp, 1); }

static void usage(FILE *fp)
{
  pquis(fp,
	"Usage: $ [-cfwx] [-p REALPROG] [-t TIMEOUT] FILE PROG ARGS...\n");
}

static void version(FILE *fp)
{
  pquis(fp, "$ (version " VERSION ")\n");
}

static void help(FILE *fp)
{
  version(fp);
  putchar('\n');
  usage(fp);
  pquis(fp, "\n\
Lock FILE and run PROG, passing ARGS.  Options are:\n\
\n\
-h, --help		Show this help message.\n\
-v, --version		Show version string.\n\
-u, --usage		Show terse usage summary.\n\
\n\
-c, --[no-]create	Create FILE if it doesn't exist [default: on].\n\
-f, --[no-]fail		Fail if the file is already locked [default: off].\n\
-w, --[no-]wait		Wait for the lock to be available [default: off].\n\
-x, --[no-]exclusive	Get an exclusive (writer) lock [default: on].\n\
-p, --program=REALPROG	Run REALPROG instead of PROG.\n\
-t, --timeout=TIME	Wait for TIME for lock to become available.\n\
");
}

int main(int argc, char *argv[])
{
  const char *file = 0;
  const char *prog = 0;
  char *const *av;
  void (*oalrm)(int) = 0;
  int fd;
  struct flock l;
  char *p;
  int t = -1;
  unsigned int ot;
  time_t nt;
  pid_t kid;
  int st;

#define f_bogus 1u
#define f_wait 2u
#define f_fail 4u
#define f_create 8u
#define f_excl 16u

  unsigned f = f_create | f_excl;

  ego(argv[0]);

  for (;;) {
    static const struct option opts[] = {
      { "help",			0,		0,	'h' },
      { "version",		0,		0,	'v' },
      { "usage",		0,		0,	'u' },
      { "wait",			OPTF_NEGATE,	0,	'w' },
      { "fail",			OPTF_NEGATE,	0,	'f' },
      { "create",		OPTF_NEGATE,	0,	'c' },
      { "program",		OPTF_ARGREQ,	0,	'p' },
      { "timeout",		OPTF_ARGREQ,	0,	't' },
      { "exclusive",		OPTF_NEGATE,	0,	'x' },
      {	0,			0,		0,	0 }
    };

    int i = mdwopt(argc, argv, "-hvuw+f+c+x+p:t:", opts,
		   0, 0, OPTF_NEGATION);
    if (i < 0)
      break;
    switch (i) {
      case 'h':
	help(stdout);
	exit(0);
      case 'v':
	version(stdout);
	exit(0);
      case 'u':
	usage(stdout);
	exit(0);
      case 'w':
	f |= f_wait;
	break;
      case 'w' | OPTF_NEGATED:
	f &= ~f_wait;
	break;
      case 'f':
	f |= f_fail;
	break;
      case 'f' | OPTF_NEGATED:
	f &= ~f_fail;
	break;
      case 'c':
	f |= f_create;
	break;
      case 'c' | OPTF_NEGATED:
	f &= ~f_create;
	break;
      case 'x':
	f |= f_excl;
	break;
      case 'x' | OPTF_NEGATED:
	f &= ~f_excl;
	break;
      case 't':
	errno = 0;
	t = strtol(optarg, &p, 0);
	switch (*p) {
	  case 'd': t *= 24;
	  case 'h': t *= 60;
	  case 'm': t *= 60;
	  case 's': p++;
	  case 0: break;
	  default: die(111, "unknown time unit `%c'", *p);
	}
	if (*p || t < 0 || errno)
	  die(111, "bad time value `%s'", optarg);
	f |= f_wait;
	break;
      case 'p':
	prog = optarg;
	break;
      case 0:
	if (file) {
	  optind--;
	  goto doneopts;
	}
	file = optarg;
	break;
      default:
	f |= f_bogus;
	break;
    }
  }

doneopts:
  if (f & f_bogus || argc - optind < 1) {
    usage(stderr);
    exit(EXIT_FAILURE);
  }

  av = &argv[optind];
  if (!prog)
    prog = av[0];
  if ((fd = open(file,
		 ((f & f_create ? O_CREAT : 0) |
		  (f & f_excl ? O_RDWR : O_RDONLY)), 0666)) < 0)
    die(111, "error opening `%s': %s", file, strerror(errno));
  l.l_type = f & f_excl ? F_WRLCK : F_RDLCK;
  l.l_whence = SEEK_SET;
  l.l_start = 0;
  l.l_len = 0;
  nt = time(0);
  if (setjmp(jmp)) {
    errno = EAGAIN;
    nt = t;
  } else {
    ot = alarm(0);
    oalrm = signal(SIGALRM, alrm);
    if (t >= 0)
      alarm(t);
    if (fcntl(fd, f & f_wait ? F_SETLKW : F_SETLK, &l) >= 0)
      errno = 0;
  }
  signal(SIGALRM, oalrm);
  if (ot) {
    nt = time(0) - nt;
    if (nt > ot)
      raise(SIGALRM);
    else
      alarm(ot - nt);
  }
  if (errno &&
      ((errno != EAGAIN && errno != EWOULDBLOCK && errno != EACCES) ||
       (f & f_fail)))
    die(111, "error locking `%s': %s", file, strerror(errno));
  if (errno)
    exit(0);

  if ((kid = fork()) < 0)
    die(111, "error from fork: %s", strerror(errno));
  if (!kid) {
    close(fd);
    execvp(prog, av);
    die(111, "couldn't exec `%s': %s", prog, strerror(errno));
  }
  if (waitpid(kid, &st, 0) < 0)
    die(EXIT_FAILURE, "error from wait: %s", strerror(errno));
  l.l_type = F_UNLCK;
  l.l_whence = SEEK_SET;
  l.l_start = 0;
  l.l_len = 0;
  fcntl(fd, F_SETLK, &l);
  close(fd);
  if (WIFEXITED(st))
    exit(WEXITSTATUS(st));
  else
    exit(255);
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
f342fce2	1	/* --c--
f342fce2	2	*
5b11bb47	3	* $Id: locking.c,v 1.2 2003/10/09 15:15:42 mdw Exp $
f342fce2	4	*
	5	* Lock a file, run a program
	6	*
	7	* (c) 2003 Mark Wooding
	8	*/
	9
	10	/----- Licensing notice --------------------------------------------------
	11	*
	12	* This file is part of the Toys utilties collection.
	13	*
	14	* Toys is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU General Public License as published by
	16	* the Free Software Foundation; either version 2 of the License, or
	17	* (at your option) any later version.
	18	*
	19	* Toys is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU General Public License
	25	* along with Toys; if not, write to the Free Software Foundation,
	26	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	27	*/
	28
	29	/----- Revision history --------------------------------------------------
	30	*
	31	* $Log: locking.c,v $
5b11bb47	32	* Revision 1.2 2003/10/09 15:15:42 mdw
	33	* Missed a paren. Un-`toys'-ify.
	34	*
f342fce2	35	* Revision 1.1 2003/10/09 15:05:34 mdw
	36	* Lots of stuff.
	37	*
	38	* Revision 1.3 2003/09/24 14:58:08 mdw
	39	* Fix options parsing again.
	40	*
	41	* Revision 1.2 2003/09/24 14:14:03 mdw
	42	* Fix option handling behaviour.
	43	*
	44	* Revision 1.1 2003/05/11 13:30:04 mdw
	45	* Initial checkin.
	46	*
	47	*/
	48
	49	/----- Header files ------------------------------------------------------/
	50
	51	#include <errno.h>
	52	#include <setjmp.h>
	53	#include <signal.h>
	54	#include <stdio.h>
	55	#include <stdlib.h>
	56	#include <string.h>
	57
	58	#include <sys/types.h>
	59	#include <sys/time.h>
	60	#include <unistd.h>
	61	#include <fcntl.h>
	62	#include <sys/wait.h>
	63
	64	#include <mLib/mdwopt.h>
	65	#include <mLib/quis.h>
	66	#include <mLib/report.h>
	67
	68	/----- Static variables --------------------------------------------------/
	69
	70	static jmp_buf jmp;
	71
	72	/----- Main code ---------------------------------------------------------/
	73
	74	static void alrm(int s) { longjmp(jmp, 1); }
	75
	76	static void usage(FILE *fp)
	77	{
	78	pquis(fp,
	79	"Usage: $ [-cfwx] [-p REALPROG] [-t TIMEOUT] FILE PROG ARGS...\n");
	80	}
	81
	82	static void version(FILE *fp)
	83	{
5b11bb47	84	pquis(fp, "$ (version " VERSION ")\n");
f342fce2	85	}
	86
	87	static void help(FILE *fp)
	88	{
	89	version(fp);
	90	putchar('\n');
	91	usage(fp);
	92	pquis(fp, "\n\
	93	Lock FILE and run PROG, passing ARGS. Options are:\n\
	94	\n\
	95	-h, --help Show this help message.\n\
	96	-v, --version Show version string.\n\
	97	-u, --usage Show terse usage summary.\n\
	98	\n\
	99	-c, --[no-]create Create FILE if it doesn't exist [default: on].\n\
	100	-f, --[no-]fail Fail if the file is already locked [default: off].\n\
	101	-w, --[no-]wait Wait for the lock to be available [default: off].\n\
	102	-x, --[no-]exclusive Get an exclusive (writer) lock [default: on].\n\
	103	-p, --program=REALPROG Run REALPROG instead of PROG.\n\
	104	-t, --timeout=TIME Wait for TIME for lock to become available.\n\
	105	");
	106	}
	107
	108	int main(int argc, char *argv[])
	109	{
	110	const char *file = 0;
	111	const char *prog = 0;
	112	char const av;
	113	void (*oalrm)(int) = 0;
	114	int fd;
	115	struct flock l;
	116	char *p;
	117	int t = -1;
	118	unsigned int ot;
	119	time_t nt;
	120	pid_t kid;
	121	int st;
	122
	123	#define f_bogus 1u
	124	#define f_wait 2u
	125	#define f_fail 4u
	126	#define f_create 8u
	127	#define f_excl 16u
	128
	129	unsigned f = f_create \| f_excl;
	130
	131	ego(argv[0]);
	132
	133	for (;;) {
	134	static const struct option opts[] = {
	135	{ "help", 0, 0, 'h' },
	136	{ "version", 0, 0, 'v' },
	137	{ "usage", 0, 0, 'u' },
	138	{ "wait", OPTF_NEGATE, 0, 'w' },
	139	{ "fail", OPTF_NEGATE, 0, 'f' },
	140	{ "create", OPTF_NEGATE, 0, 'c' },
	141	{ "program", OPTF_ARGREQ, 0, 'p' },
	142	{ "timeout", OPTF_ARGREQ, 0, 't' },
	143	{ "exclusive", OPTF_NEGATE, 0, 'x' },
	144	{ 0, 0, 0, 0 }
	145	};
	146
	147	int i = mdwopt(argc, argv, "-hvuw+f+c+x+p:t:", opts,
	148	0, 0, OPTF_NEGATION);
149	if (i < 0)
150	break;
151	switch (i) {
152	case 'h':
153	help(stdout);
154	exit(0);
155	case 'v':
156	version(stdout);
157	exit(0);
158	case 'u':
159	usage(stdout);
160	exit(0);
161	case 'w':
162	f \|= f_wait;
163	break;
164	case 'w' \| OPTF_NEGATED:
165	f &= ~f_wait;
166	break;
167	case 'f':
168	f \|= f_fail;
169	break;
170	case 'f' \| OPTF_NEGATED:
171	f &= ~f_fail;
172	break;
173	case 'c':
174	f \|= f_create;
175	break;
176	case 'c' \| OPTF_NEGATED:
177	f &= ~f_create;
178	break;
179	case 'x':
180	f \|= f_excl;
181	break;
182	case 'x' \| OPTF_NEGATED:
183	f &= ~f_excl;
184	break;
185	case 't':
186	errno = 0;
187	t = strtol(optarg, &p, 0);
188	switch (*p) {
189	case 'd': t *= 24;
190	case 'h': t *= 60;
191	case 'm': t *= 60;
192	case 's': p++;
193	case 0: break;
194	default: die(111, "unknown time unit `%c'", *p);
195	}
196	if (*p \|\| t < 0 \|\| errno)
197	die(111, "bad time value `%s'", optarg);
198	f \|= f_wait;
199	break;
200	case 'p':
201	prog = optarg;
202	break;
203	case 0:
204	if (file) {
205	optind--;
206	goto doneopts;
207	}
208	file = optarg;
209	break;
210	default:
211	f \|= f_bogus;
212	break;
213	}
214	}
215
216	doneopts:
217	if (f & f_bogus \|\| argc - optind < 1) {
218	usage(stderr);
219	exit(EXIT_FAILURE);
220	}
221
222	av = &argv[optind];
223	if (!prog)
224	prog = av[0];
225	if ((fd = open(file,
226	((f & f_create ? O_CREAT : 0) \|
227	(f & f_excl ? O_RDWR : O_RDONLY)), 0666)) < 0)
228	die(111, "error opening `%s': %s", file, strerror(errno));
229	l.l_type = f & f_excl ? F_WRLCK : F_RDLCK;
230	l.l_whence = SEEK_SET;
231	l.l_start = 0;
232	l.l_len = 0;
233	nt = time(0);
234	if (setjmp(jmp)) {
235	errno = EAGAIN;
236	nt = t;
237	} else {
238	ot = alarm(0);
239	oalrm = signal(SIGALRM, alrm);
240	if (t >= 0)
241	alarm(t);
242	if (fcntl(fd, f & f_wait ? F_SETLKW : F_SETLK, &l) >= 0)
243	errno = 0;
244	}
245	signal(SIGALRM, oalrm);
246	if (ot) {
247	nt = time(0) - nt;
248	if (nt > ot)
249	raise(SIGALRM);
250	else
251	alarm(ot - nt);
252	}
253	if (errno &&
254	((errno != EAGAIN && errno != EWOULDBLOCK && errno != EACCES) \|\|
255	(f & f_fail)))
256	die(111, "error locking `%s': %s", file, strerror(errno));
257	if (errno)
258	exit(0);
259
260	if ((kid = fork()) < 0)
261	die(111, "error from fork: %s", strerror(errno));
262	if (!kid) {
263	close(fd);
264	execvp(prog, av);
265	die(111, "couldn't exec `%s': %s", prog, strerror(errno));
266	}
267	if (waitpid(kid, &st, 0) < 0)
268	die(EXIT_FAILURE, "error from wait: %s", strerror(errno));
269	l.l_type = F_UNLCK;
270	l.l_whence = SEEK_SET;
271	l.l_start = 0;
272	l.l_len = 0;
273	fcntl(fd, F_SETLK, &l);
274	close(fd);
275	if (WIFEXITED(st))
276	exit(WEXITSTATUS(st));
277	else
278	exit(255);
279	}
280
281	/----- That's all, folks -------------------------------------------------/