/*
 * Copyright (c) 2011
 *	The President and Fellows of Harvard College.
 *
 * 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 UNIVERSITY 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 UNIVERSITY 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.
 */

/*
 * bigexec.c
 *
 * Checks that argv passing works and is not restricted to an
 * unreasonably small size.
 */

#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <assert.h>
#include <err.h>

#define _PATH_MYSELF "/testbin/bigexec"

////////////////////////////////////////////////////////////
// words

static const char word8[] = "Dalemark";
static char word4050[4051];
static char word16320[16321];
static char word65500[65501];

static
void
fill(char *buf, size_t buflen)
{
	static const char *const names[22] = {
		"Alhammitt", "Biffa", "Cennoreth", "Dastgandlen", "Enblith",
		"Fenna", "Gull", "Hern", "Hildrida", "Kankredin", "Kialan",
		"Lenina", "Manaliabrid", "Mayelbridwen", "Noreth", "Osfameron",
		"Robin", "Tanamil", "Tanamoril", "Tanaqui", "Ynen", "Ynynen"
	};

	const char *name;
	size_t len;

	while (buflen > 4) {
		name = names[random()%22];
		len = strlen(name);
		if (len < buflen) {
			strcpy(buf, name);
			buf += len;
			buflen -= len;
			if (buflen > 1) {
				*buf = ' ';
				buf++;
				buflen--;
			}
		}
	}
	while (buflen > 1) {
		*buf = '.';
		buf++;
		buflen--;
	}
	*buf = 0;
}

static
void
prepwords(void)
{
	srandom(16581);
	fill(word4050, sizeof(word4050));
	fill(word16320, sizeof(word16320));
	fill(word65500, sizeof(word65500));
}

////////////////////////////////////////////////////////////
// execing/checking

static
void
try(const char *first, ...)
{
	const char *args[20];
	const char *s;
	va_list ap;
	int num;

	assert(first != NULL);
	args[0] = _PATH_MYSELF;
	args[1] = first;
	num = 2;

	va_start(ap, first);
	while (1) {
		s = va_arg(ap, const char *);
		if (s == NULL) {
			break;
		}
		assert(num < 20);
		args[num++] = s;
	}
	assert(num < 20);
	args[num] = NULL;
	execv(_PATH_MYSELF, (char **)args);
	err(1, "execv");
}

static
void
trymany(int num, const char *word)
{
	const char *args[num+2];
	int i;

	args[0] = _PATH_MYSELF;
	for (i=0; i<num; i++) {
		args[i+1] = word;
	}
	args[num+1] = NULL;
	execv(_PATH_MYSELF, (char **)args);
	err(1, "execv");
}

static
int
check(int argc, char *argv[], const char *first, ...)
{
	const char *s;
	va_list ap;
	int pos;

	pos = 1;
	va_start(ap, first);
	s = first;
	while (s != NULL) {
		if (pos == argc) {
			/* not enough args */
			return 0;
		}
		assert(pos < argc);
		if (argv[pos] == NULL) {
			/* woops */
			warnx("argv[%d] is null but argc is %d", pos, argc);
			return 0;
		}
		if (strcmp(argv[pos], s) != 0) {
			/* does not match */
			return 0;
		}
		s = va_arg(ap, const char *);
		pos++;
	}
	if (pos != argc) {
		/* too many args */
		return 0;
	}
	if (argv[pos] != NULL) {
		warnx("argv[argc] is not null");
		return 0;
	}
	return 1;
}

static
int
checkmany(int argc, char *argv[], int num, const char *word)
{
	int i;

	if (argc != num + 1) {
		/* wrong number of args */
		return 0;
	}
	for (i=1; i<argc; i++) {
		if (strcmp(argv[i], word) != 0) {
			/* doesn't match */
			return 0;
		}
	}
	return 1;
}

////////////////////////////////////////////////////////////
// test driver

static
void
dumpargs(int argc, char *argv[])
{
	const char *s;
	int i;

	warnx("%d args", argc);
	warnx("argv[0]: %s", argv[0]);
	for (i=1; i<=argc; i++) {
		s = argv[i];
		if (s == NULL) {
			warnx("argv[%d]: is null", i);
		}
		else if (!strcmp(s, word8)) {
			warnx("argv[%d] is word8", i);
		}
		else if (!strcmp(s, word4050)) {
			warnx("argv[%d] is word4050", i);
		}
		else if (!strcmp(s, word16320)) {
			warnx("argv[%d] is word16320", i);
		}
		else if (!strcmp(s, word65500)) {
			warnx("argv[%d] is word65500", i);
		}
		else if (strlen(s) < 72) {
			warnx("argv[%d]: %s", i, s);
		}
		else {
			warnx("argv[%d] is %zu bytes, begins %.64s",
			      i, strlen(s), s);
		}
	}
}

int
main(int argc, char *argv[])
{
	if (argc < 0) {
		err(1, "argc is negative!?");
	}

	prepwords();
	assert(strlen(word8) == 8);
	assert(strlen(word4050) == 4050);
	assert(strlen(word16320) == 16320);
	assert(strlen(word65500) == 65500);

	assert(ARG_MAX >= 65536);

	if (argv == NULL || argc == 0 || argc == 1) {
		/* no args -- start the test */
		warnx("Starting.");

		/*
		 * 1. Should always fit no matter what.
		 */
		warnx("1. Execing with one 8-letter word.");
		try(word8, NULL);
	}
	else if (check(argc, argv, word8, NULL)) {
		/*
		 * 2. Fits in one page.
		 */
		warnx("2. Execing with one 4050-letter word.");
		try(word4050, NULL);
	}
	else if (check(argc, argv, word4050, NULL)) {
		/*
		 * 3. Requires two pages but each word fits on a page.
		 */
		warnx("3. Execing with two 4050-letter words.");
		try(word4050, word4050, NULL);
	}
	else if (check(argc, argv, word4050, word4050, NULL)) {
		/*
		 * 4. Requires the full 64K argv buffer, in large
		 * chunks, with a little space for slop. Each word
		 * fits on a page though. With null terminators and
		 * 4-byte pointers the size is 4085*16 = 65360, and
		 * with 8-byte pointers it would become 65424.
		 *
		 * Don't forget that argv[0] will be another 21 or 25
		 * bytes and some implementations may reasonably need
		 * to stash an ending NULL in the buffer too.
		 */
		warnx("4. Execing with 16 4050-letter words.");
		try(word4050, word4050, word4050, word4050,
		    word4050, word4050, word4050, word4050,
		    word4050, word4050, word4050, word4050,
		    word4050, word4050, word4050, word4050,
		    NULL);
	}
	else if (check(argc, argv,
		       word4050, word4050, word4050, word4050,
		       word4050, word4050, word4050, word4050,
		       word4050, word4050, word4050, word4050,
		       word4050, word4050, word4050, word4050,
		       NULL)) {
		/*
		 * 5. Requires more than one page for a single word.
		 */
		warnx("5. Execing with one 16320-letter word.");
		try(word16320, NULL);
	}
	else if (check(argc, argv, word16320, NULL)) {
		/*
		 * 6. Ditto but makes sure it works with two of them.
		 */
		warnx("6. Execing with two 16320-letter words.");
		try(word16320, word16320, NULL);
	}
	else if (check(argc, argv, word16320, word16320, NULL)) {
		/*
		 * 7. Requires the full 64K argv buffer.
		 */
		warnx("7. Execing with four 16320-letter words.");
		try(word16320, word16320, word16320, word16320,
		    NULL);
	}
	else if (check(argc, argv, word16320, word16320,
		       word16320, word16320, NULL)) {
		/*
		 * 8. Also requires the full 64K argv buffer, but with
		 * only one huge word.
		 */
		warnx("8. Execing with one 65500-letter word.");
		try(word65500, NULL);
	}
	else if (check(argc, argv, word65500, NULL)) {
		/*
		 * 9. This fits on one page. Given 4-byte pointers,
		 * (8+1+4)*300 = 3900. With 8-byte pointers, it
		 * doesn't, but we aren't doing that. (Update this if
		 * we ever move to a 64-bit platform.)
		 */
		assert((8+1+sizeof(char *))*300 < 4096);
		warnx("9. Execing with 300 8-letter words.");
		trymany(300, word8);
	}
	else if (checkmany(argc, argv, 300, word8)) {
#if 1 /* enforce the full size */
		/*
		 * 10. This requires the full 64K argv buffer.
		 * With 4-byte pointers, (8+1+4)*5020 = 65260.
		 * It also doesn't fit with 8-byte pointers.
		 *
		 * XXX for the time being, we'll allow less efficient
		 * implementations that use two pointers per word.
		 * Hence, (8+1+4+4)*3850 = 65450.
		 */
		assert((8+1+sizeof(char *))*5020 < 65536);
		assert((8+1+2*sizeof(char *))*3850 < 65536);
		warnx("10. Execing with 3850 8-letter words.");
		trymany(3850, word8);
	}
	else if (checkmany(argc, argv, 3850, word8)) {
#else
		/*
		 * 10a. This requires more than one page using small
		 * words. With 4-byte pointers, (8+1+4)*1000 = 13000.
		 */
		warnx("10. Execing with 1000 8-letter words.");
		trymany(1000, word8);
	}
	else if (checkmany(argc, argv, 1000, word8)) {
#endif
		warnx("Complete.");
		return 0;
	}
	else {
		warnx("Received unknown/unexpected args:");
		dumpargs(argc, argv);
		return 1;
	}
}