initial import of OpenBSD tools

3 files changed, 768 insertions, 0 deletions

diff --git a/src/usr.bin/jot/Makefile b/src/usr.bin/jot/Makefile
new file mode 100644
index 0000000..c552df3
--- /dev/null
+++ b/src/usr.bin/jot/Makefile
@@ -0,0 +1,6 @@
+#	$OpenBSD: Makefile,v 1.4 2003/12/29 08:51:19 otto Exp $
+
+PROG=	jot
+CFLAGS+= -Wall
+
+.include <bsd.prog.mk>
diff --git a/src/usr.bin/jot/jot.1 b/src/usr.bin/jot/jot.1
new file mode 100644
index 0000000..9845fa3
--- /dev/null
+++ b/src/usr.bin/jot/jot.1
@@ -0,0 +1,315 @@
+.\"	$OpenBSD: jot.1,v 1.18 2014/01/20 05:07:48 schwarze Exp $
+.\"	$NetBSD: jot.1,v 1.2 1994/11/14 20:27:36 jtc Exp $
+.\"
+.\" Copyright (c) 1993
+.\"	The Regents of the University of California.  All rights reserved.
+.\"
+.\" 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.
+.\" 3. Neither the name of the University nor the names of its contributors
+.\"    may be used to endorse or promote products derived from this software
+.\"    without specific prior written permission.
+.\"
+.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+.\"
+.\"	@(#)jot.1	8.1 (Berkeley) 6/6/93
+.\"
+.Dd $Mdocdate: January 20 2014 $
+.Dt JOT 1
+.Os
+.Sh NAME
+.Nm jot
+.Nd print sequential or random data
+.Sh SYNOPSIS
+.Nm jot
+.Bk -words
+.Op Fl cnr
+.Op Fl b Ar word
+.Op Fl p Ar precision
+.Op Fl s Ar string
+.Op Fl w Ar word
+.Oo Ar reps Oo Ar begin Oo Ar end
+.Oo Ar s Oc Oc Oc Oc
+.Ek
+.Sh DESCRIPTION
+.Nm
+is used to print out increasing, decreasing, random,
+or redundant data, usually numbers, one per line.
+.Pp
+The options are as follows:
+.Bl -tag -width "-p precision"
+.It Fl b Ar word
+Just print
+.Ar word
+repetitively.
+.It Fl c
+This is an abbreviation for
+.Fl w Ic %c .
+.It Fl n
+Do not print the final newline normally appended to the output.
+.It Fl p Ar precision
+Print only as many digits or characters of the data
+as indicated by the integer
+.Ar precision .
+In the absence of
+.Fl p ,
+the precision is the greater of the numbers
+.Ar begin
+and
+.Ar end .
+The
+.Fl p
+option is overridden by whatever appears in a
+.Xr printf 3
+conversion following
+.Fl w .
+.It Fl r
+Generate random data.
+By default,
+.Nm
+generates sequential data.
+.It Fl s Ar string
+Print data separated by
+.Ar string .
+Normally, newlines separate data.
+.It Fl w Ar word
+Print
+.Ar word
+with the generated data appended to it.
+Octal, hexadecimal, exponential, ASCII, zero-padded,
+and right-adjusted representations
+are possible by using the appropriate
+.Xr printf 3
+conversion specification inside
+.Ar word ,
+in which case the data is inserted rather than appended.
+.El
+.Pp
+The last four arguments indicate, respectively,
+the maximum number of data, the lower bound, the upper bound,
+and the step size.
+While at least one of them must appear,
+any of the other three may be omitted, and
+will be considered as such if given as
+.Ql - .
+Any three of these arguments determines the fourth.
+If four are specified and the given and computed values of
+.Ar reps
+conflict, the lower value is used.
+If fewer than three are specified, defaults are assigned
+left to right, except for
+.Ar s ,
+which assumes its default unless both
+.Ar begin
+and
+.Ar end
+are given.
+.Pp
+Defaults for the four arguments are, respectively,
+100, 1, 100, and 1.
+.Ar reps
+is expected to be an unsigned integer,
+and if given as zero is taken to be infinite.
+.Ar begin
+and
+.Ar end
+may be given as real numbers or as characters
+representing the corresponding value in ASCII.
+The last argument must be a real number.
+.Pp
+Random numbers are obtained through
+.Xr arc4random 3 .
+Historical versions of
+.Nm
+used
+.Ar s
+to seed the random number generator.
+This is no longer supported.
+The name
+.Nm
+derives in part from
+.Dq iota ,
+a function in APL.
+.Ss Rounding and truncation
+The
+.Nm
+utility uses double precision floating point arithmetic internally.
+Before printing a number, it is converted depending on the output
+format used.
+.Pp
+If no output format is specified or the output format is a
+floating point format
+.Po
+.Sq f ,
+.Sq e ,
+.Sq g ,
+.Sq E ,
+or
+.Sq G
+.Pc ,
+the value is rounded using the
+.Xr printf 3
+function, taking into account the requested precision.
+.Pp
+If the output format is an integer format
+.Po
+.Sq c ,
+.Sq d ,
+.Sq o ,
+.Sq x ,
+.Sq u ,
+.Sq D ,
+.Sq O ,
+.Sq X ,
+.Sq U ,
+or
+.Sq i
+.Pc ,
+the value is converted to an integer value by truncation.
+.Pp
+As an illustration, consider the following command:
+.Bd -literal -offset indent
+$ jot 6 1 10 0.5
+1
+2
+2
+2
+3
+4
+.Ed
+.Pp
+By requesting an explicit precision of 1, the values generated before rounding
+can be seen.
+The .5 values are rounded down if the integer part is even,
+up otherwise.
+.Bd -literal -offset indent
+$ jot -p 1 6 1 10 0.5
+1.0
+1.5
+2.0
+2.5
+3.0
+3.5
+.Ed
+.Pp
+By offsetting the values slightly, the values generated by the following
+command are always rounded down:
+.Bd -literal -offset indent
+$ jot -p 0 6 .9999999999 10 0.5
+1
+1
+2
+2
+3
+3
+.Ed
+.Pp
+Another way of achieving the same result is to force truncation by
+specifying an integer format:
+.Bd -literal -offset indent
+$ jot -w %d 6 1 10 0.5
+.Ed
+.Pp
+For random sequences, the output format also influences the range
+and distribution of the generated numbers:
+.Bd -literal -offset indent
+$ jot -r 100000 1 3 | sort -n | uniq -c
+24950 1
+50038 2
+25012 3
+.Ed
+.Pp
+The values at the beginning and end of the interval
+are generated less frequently than the other values.
+There are several ways to solve this problem and generate evenly distributed
+integers:
+.Bd -literal -offset indent
+$ jot -r -p 0 100000 0.5 3.5 | sort -n | uniq -c
+33374 1
+33363 2
+33263 3
+
+$ jot -w %d -r 100000 1 4 | sort -n | uniq -c
+33306 1
+33473 2
+33221 3
+.Ed
+.Pp
+Note that with random sequences, all numbers generated will
+be smaller than the upper bound.
+The largest value generated will be a tiny bit smaller than
+the upper bound.
+For floating point formats, the value is rounded as described
+before being printed.
+For integer formats, the highest value printed will be one less
+than the requested upper bound, because the generated value will
+be truncated.
+.Sh EXAMPLES
+Print 21 evenly spaced numbers increasing from \-1 to 1:
+.Pp
+.Dl $ jot 21 \-1 1.00
+.Pp
+Generate the ASCII character set:
+.Pp
+.Dl $ jot \-c 128 0
+.Pp
+Generate the strings xaa through xaz:
+.Pp
+.Dl $ jot \-w xa%c 26 a
+.Pp
+Generate 20 random 8-letter strings
+(note that the character
+.Sq {
+comes after the character
+.Sq z
+in the ASCII character set):
+.Pp
+.Dl "$ jot \-r \-c 160 a { | rs \-g0 0 8"
+.Pp
+Infinitely many
+.Xr yes 1 Ns 's
+may be obtained through:
+.Pp
+.Dl $ jot \-b yes 0
+.Pp
+Thirty
+.Xr ed 1
+substitution commands applying to lines 2, 7, 12, etc. is the result of:
+.Pp
+.Dl $ jot \-w %ds/old/new/ 30 2 \- 5
+.Pp
+Create a file containing exactly 1024 bytes:
+.Pp
+.Dl $ jot \-b x 512 > block
+.Pp
+To set tabs four spaces apart starting
+from column 10 and ending in column 132, use:
+.Pp
+.Dl $ expand \-`jot \-s, \- 10 132 4`
+.Pp
+To print all lines 80 characters or longer:
+.Pp
+.Dl $ grep `jot \-s \&"\&" \-b . 80`
+.Sh SEE ALSO
+.Xr ed 1 ,
+.Xr expand 1 ,
+.Xr rs 1 ,
+.Xr yes 1 ,
+.Xr arc4random 3 ,
+.Xr printf 3
diff --git a/src/usr.bin/jot/jot.c b/src/usr.bin/jot/jot.c
new file mode 100644
index 0000000..23ba16b
--- /dev/null
+++ b/src/usr.bin/jot/jot.c
@@ -0,0 +1,447 @@
+/*	$OpenBSD: jot.c,v 1.23 2013/11/26 13:21:18 deraadt Exp $	*/
+/*	$NetBSD: jot.c,v 1.3 1994/12/02 20:29:43 pk Exp $	*/
+
+/*-
+ * Copyright (c) 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * 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.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+/*
+ * jot - print sequential or random data
+ *
+ * Author:  John Kunze, Office of Comp. Affairs, UCB
+ */
+
+#include <err.h>
+#include <stdbool.h>
+#include <ctype.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define	REPS_DEF	100
+#define	BEGIN_DEF	1
+#define	ENDER_DEF	100
+#define	STEP_DEF	1
+
+#define	is_default(s)	(strcmp((s), "-") == 0)
+
+static double	begin;
+static double	ender;
+static double	s;
+static long	reps;
+static bool	randomize;
+static bool	infinity;
+static bool	boring;
+static int	prec = -1;
+static bool	intdata;
+static bool	longdata;
+static bool	chardata;
+static bool	nosign;
+static bool	finalnl = true;
+static char	sepstring[BUFSIZ] = "\n";
+static char	format[BUFSIZ];
+
+static void	getformat(void);
+static int	getprec(char *);
+static int	putdata(double, bool);
+static void	usage(void);
+
+int
+main(int argc, char *argv[])
+{
+	double		x;
+	double		y;
+	long		i;
+	unsigned int	mask = 0;
+	int		n = 0;
+	int		ch;
+	const	char	*errstr;
+
+	while ((ch = getopt(argc, argv, "rb:w:cs:np:")) != -1)
+		switch (ch) {
+		case 'r':
+			randomize = true;
+			break;
+		case 'c':
+			chardata = true;
+			break;
+		case 'n':
+			finalnl = false;
+			break;
+		case 'b':
+			boring = true;
+			if (strlcpy(format, optarg, sizeof(format)) >=
+			    sizeof(format))
+				errx(1, "-b word too long");
+			break;
+		case 'w':
+			if (strlcpy(format, optarg, sizeof(format)) >=
+			    sizeof(format))
+				errx(1, "-w word too long");
+			break;
+		case 's':
+			if (strlcpy(sepstring, optarg, sizeof(sepstring)) >=
+			    sizeof(sepstring))
+				errx(1, "-s string too long");
+			break;
+		case 'p':
+			prec = strtonum(optarg, 0, INT_MAX, &errstr);
+			if (errstr != NULL)
+				errx(1, "bad precision value, %s: %s", errstr, 
+					optarg);
+			break;
+		default:
+			usage();
+		}
+	argc -= optind;
+	argv += optind;
+
+	switch (argc) {	/* examine args right to left, falling thru cases */
+	case 4:
+		if (!is_default(argv[3])) {
+			if (!sscanf(argv[3], "%lf", &s))
+				errx(1, "Bad s value:  %s", argv[3]);
+			mask |= 01;
+			if (randomize)
+				warnx("random seeding not supported");
+		}
+	case 3:
+		if (!is_default(argv[2])) {
+			if (!sscanf(argv[2], "%lf", &ender))
+				ender = argv[2][strlen(argv[2])-1];
+			mask |= 02;
+			if (prec == -1)
+				n = getprec(argv[2]);
+		}
+	case 2:
+		if (!is_default(argv[1])) {
+			if (!sscanf(argv[1], "%lf", &begin))
+				begin = argv[1][strlen(argv[1])-1];
+			mask |= 04;
+			if (prec == -1)
+				prec = getprec(argv[1]);
+			if (n > prec)		/* maximum precision */
+				prec = n;
+		}
+	case 1:
+		if (!is_default(argv[0])) {
+			if (!sscanf(argv[0], "%ld", &reps))
+				errx(1, "Bad reps value:  %s", argv[0]);
+			mask |= 010;
+			if (prec == -1)
+				prec = 0;
+		}
+		break;
+	case 0:
+		usage();
+		break;
+	default:
+		errx(1, "Too many arguments.  What do you mean by %s?",
+		    argv[4]);
+	}
+	getformat();
+	while (mask)	/* 4 bit mask has 1's where last 4 args were given */
+		switch (mask) {	/* fill in the 0's by default or computation */
+		case 001:
+			reps = REPS_DEF;
+			mask = 011;
+			break;
+		case 002:
+			reps = REPS_DEF;
+			mask = 012;
+			break;
+		case 003:
+			reps = REPS_DEF;
+			mask = 013;
+			break;
+		case 004:
+			reps = REPS_DEF;
+			mask = 014;
+			break;
+		case 005:
+			reps = REPS_DEF;
+			mask = 015;
+			break;
+		case 006:
+			reps = REPS_DEF;
+			mask = 016;
+			break;
+		case 007:
+			if (randomize) {
+				reps = REPS_DEF;
+				mask = 0;
+				break;
+			}
+			if (s == 0.0) {
+				reps = 0;
+				mask = 0;
+				break;
+			}
+			reps = (ender - begin + s) / s;
+			if (reps <= 0)
+				errx(1, "Impossible stepsize");
+			mask = 0;
+			break;
+		case 010:
+			begin = BEGIN_DEF;
+			mask = 014;
+			break;
+		case 011:
+			begin = BEGIN_DEF;
+			mask = 015;
+			break;
+		case 012:
+			s = STEP_DEF;
+			mask = 013;
+			break;
+		case 013:
+			if (randomize)
+				begin = BEGIN_DEF;
+			else if (reps == 0)
+				errx(1, "Must specify begin if reps == 0");
+			begin = ender - reps * s + s;
+			mask = 0;
+			break;
+		case 014:
+			s = STEP_DEF;
+			mask = 015;
+			break;
+		case 015:
+			if (randomize)
+				ender = ENDER_DEF;
+			else
+				ender = begin + reps * s - s;
+			mask = 0;
+			break;
+		case 016:
+			if (reps == 0)
+				errx(1, "Infinite sequences cannot be bounded");
+			else if (reps == 1)
+				s = 0.0;
+			else
+				s = (ender - begin) / (reps - 1);
+			mask = 0;
+			break;
+		case 017:		/* if reps given and implied, */
+			if (!randomize && s != 0.0) {
+				long t = (ender - begin + s) / s;
+				if (t <= 0)
+					errx(1, "Impossible stepsize");
+				if (t < reps)		/* take lesser */
+					reps = t;
+			}
+			mask = 0;
+			break;
+		default:
+			errx(1, "bad mask");
+		}
+	if (reps == 0)
+		infinity = true;
+	if (randomize) {
+		x = (ender - begin) * (ender > begin ? 1 : -1);
+		for (i = 1; i <= reps || infinity; i++) {
+			double v;
+			y = arc4random() / ((double)0xffffffff + 1);
+			v = y * x + begin;
+			if (putdata(v, reps == i && !infinity))
+				errx(1, "range error in conversion: %f", v);
+		}
+	}
+	else
+		for (i = 1, x = begin; i <= reps || infinity; i++, x += s)
+			if (putdata(x, reps == i && !infinity))
+				errx(1, "range error in conversion: %f", x);
+	if (finalnl)
+		putchar('\n');
+	exit(0);
+}
+
+static int
+putdata(double x, bool last)
+{
+	if (boring)
+		printf("%s", format);
+	else if (longdata && nosign) {
+		if (x <= (double)ULONG_MAX && x >= 0.0)
+			printf(format, (unsigned long)x);
+		else
+			return (1);
+	} else if (longdata) {
+		if (x <= (double)LONG_MAX && x >= (double)LONG_MIN)
+			printf(format, (long)x);
+		else
+			return (1);
+	} else if (chardata || (intdata && !nosign)) {
+		if (x <= (double)INT_MAX && x >= (double)INT_MIN)
+			printf(format, (int)x);
+		else
+			return (1);
+	} else if (intdata) {
+		if (x <= (double)UINT_MAX && x >= 0.0)
+			printf(format, (unsigned int)x);
+		else
+			return (1);
+	} else
+		printf(format, x);
+	if (!last)
+		fputs(sepstring, stdout);
+
+	return (0);
+}
+
+static void
+usage(void)
+{
+	(void)fprintf(stderr, "usage: jot [-cnr] [-b word] [-p precision] "
+	    "[-s string] [-w word]\n"
+	    "	   [reps [begin [end [s]]]]\n");
+	exit(1);
+}
+
+static int
+getprec(char *s)
+{
+	char	*p;
+	char	*q;
+
+	for (p = s; *p != '\0'; p++)
+		if (*p == '.')
+			break;
+	if (*p == '\0')
+		return (0);
+	for (q = ++p; *p != '\0'; p++)
+		if (!isdigit((unsigned char)*p))
+			break;
+	return (p - q);
+}
+
+static void
+getformat(void)
+{
+	char	*p, *p2;
+	int dot, hash, space, sign, numbers = 0;
+	size_t sz;
+
+	if (boring)				/* no need to bother */
+		return;
+	for (p = format; *p != '\0'; p++)	/* look for '%' */
+		if (*p == '%' && *(p+1) != '%')	/* leave %% alone */
+			break;
+	sz = sizeof(format) - strlen(format) - 1;
+	if (*p == '\0' && !chardata) {
+		int n;
+
+		n = snprintf(p, sz, "%%.%df", prec);
+		if (n == -1 || n >= (int)sz)
+			errx(1, "-w word too long");
+	} else if (*p == '\0' && chardata) {
+		if (strlcpy(p, "%c", sz) >= sz)
+			errx(1, "-w word too long");
+		intdata = true;
+	} else if (*(p+1) == '\0') {
+		if (sz <= 0)
+			errx(1, "-w word too long");
+		/* cannot end in single '%' */
+		strlcat(format, "%", sizeof format);
+	} else {
+		/*
+		 * Allow conversion format specifiers of the form
+		 * %[#][ ][{+,-}][0-9]*[.[0-9]*]? where ? must be one of
+		 * [l]{d,i,o,u,x} or {f,e,g,E,G,d,o,x,D,O,U,X,c,u}
+		 */
+		p2 = p++;
+		dot = hash = space = sign = numbers = 0;
+		while (!isalpha((unsigned char)*p)) {
+			if (isdigit((unsigned char)*p)) {
+				numbers++;
+				p++;
+			} else if ((*p == '#' && !(numbers|dot|sign|space|
+			    hash++)) ||
+			    (*p == ' ' && !(numbers|dot|space++)) ||
+			    ((*p == '+' || *p == '-') && !(numbers|dot|sign++))
+			    || (*p == '.' && !(dot++)))
+				p++;
+			else
+				goto fmt_broken;
+		}
+		if (*p == 'l') {
+			longdata = true;
+			if (*++p == 'l') {
+				if (p[1] != '\0')
+					p++;
+				goto fmt_broken;
+			}
+		}
+		switch (*p) {
+		case 'o': case 'u': case 'x': case 'X':
+			intdata = nosign = true;
+			break;
+		case 'd': case 'i':
+			intdata = true;
+			break;
+		case 'D':
+			if (!longdata) {
+				intdata = true;
+				break;
+			}
+		case 'O': case 'U':
+			if (!longdata) {
+				intdata = nosign = true;
+				break;
+			}
+		case 'c':
+			if (!(intdata | longdata)) {
+				chardata = true;
+				break;
+			}
+		case 'h': case 'n': case 'p': case 'q': case 's': case 'L':
+		case '$': case '*':
+			goto fmt_broken;
+		case 'f': case 'e': case 'g': case 'E': case 'G':
+			if (!longdata)
+				break;
+			/* FALLTHROUGH */
+		default:
+fmt_broken:
+			*++p = '\0';
+			errx(1, "illegal or unsupported format '%s'", p2);
+			/* NOTREACHED */
+		}
+		while (*++p != '\0')
+			if (*p == '%' && *(p+1) != '\0' && *(p+1) != '%')
+				errx(1, "too many conversions");
+			else if (*p == '%' && *(p+1) == '%')
+				p++;
+			else if (*p == '%' && *(p+1) == '\0') {
+				strlcat(format, "%", sizeof format);
+				break;
+			}
+	}
+}