/*
 *
 *   Copyright (c) International Business Machines  Corp., 2002
 *
 *   This program 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.
 *
 *   This program 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 this program;  if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/* 11/01/2002	Port to LTP	robbiew@us.ibm.com */
/* 06/30/2001	Port to Linux	nsharoff@us.ibm.com */

			   /*inode02.c */
/*======================================================================
	=================== TESTPLAN SEGMENT ===================
CALLS:	mkdir, stat, open

	Run with TERM mode.

>KEYS:  < file system and I/O management, system resource constraints.
>WHAT:  < Can the system handle a heavy load on the file system I/O
	< functions?
>HOW:   < Create several identical process that call inode02.c.  This
	< will simulate the multi-user environment, and hopefully uncover
	< conflicts that might occur in "real life" use.
>BUGS:  <
======================================================================*/

#define PATH_STRING_LENGTH  1024
#define NAME_LENGTH  8
#define MAX_PATH_STRING_LENGTH  (PATH_STRING_LENGTH - NAME_LENGTH - 40)
#define DIRECTORY_MODE  00777
#define FILE_MODE       00777

#define MKDIR_STRING_LENGTH  (MAX_PATH_STRING_LENGTH + 7)

/* #define DEBUG	 you can watch the generation with this flag */

#define TRUE  1
#define FALSE 0
#define READ  0
#define WRITE 1

#include <stdio.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/wait.h>

#ifdef LINUX
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#endif

#define MAXCHILD	25
int allchild[MAXCHILD + 1];

char name[NAME_LENGTH + 1];
char path_string[PATH_STRING_LENGTH + 1];
char read_string[PATH_STRING_LENGTH + 1];
char write_string[PATH_STRING_LENGTH + 1];
char remove_string[PATH_STRING_LENGTH + 10];
int parent_pid;
int nchild;

FILE *list_stream = NULL;
int list_id;
int file_id;

int increment_name(), get_next_name(), mode(), escrivez(), massmurder();
int max_depth, max_breadth, file_length;
int bd_arg(char *);

#ifdef LINUX
void (*sigset(int, void (*)(int))) (int);
#endif

/** LTP Port **/
#include "test.h"

void setup(void);
void fail_exit(void);
void anyfail(void);
void ok_exit(void);
void forkfail(void);
void terror(char *);
int instress(void);

#define FAILED 0
#define PASSED 1

int local_flag = PASSED;
FILE *temp;

char *TCID = "inode02";		/* Test program identifier.    */
int TST_TOTAL = 1;		/* Total number of test cases. */
/**************/

int main(int argc, char *argv[])
{
	int pid, tree(), p, status;
	int count, child;
	register int i;
	int term();

	setup();

	parent_pid = getpid();

	if (sigset(SIGTERM, (void (*)())term) == SIG_ERR) {
		tst_resm(TBROK, "\tSIGTERM sigset set failed, errno=%d\n",
			 errno);
		exit(1);
	}

	/************************************************/
	/*                                              */
	/*  Input the parameters for the directory---   */
	/*  file trees which are to be generated        */
	/*                                              */
	/************************************************/

	if (argc < 2) {
		max_depth = 6;
		max_breadth = 5;
		file_length = 8;
		nchild = 5;
	} else if (argc < 5) {
		tst_resm(TCONF, "Bad argument count.\n");
		printf
		    ("\tinode02 max_depth max_breadth file_length #children\n\tdefault: inode02 6 5 8 5\n");
		exit(1);
	} else {
		i = 1;
		if (sscanf(argv[i++], "%d", &max_depth) != 1)
			bd_arg(argv[i - 1]);
		if (sscanf(argv[i++], "%d", &max_breadth) != 1)
			bd_arg(argv[i - 1]);
		if (sscanf(argv[i++], "%d", &file_length) != 1)
			bd_arg(argv[i - 1]);
		if (sscanf(argv[i++], "%d", &nchild) != 1)
			bd_arg(argv[i - 1]);
		if (nchild > MAXCHILD) {
			fprintf(temp, "too many children - max is %d\n",
				MAXCHILD);
			exit(1);
		}
	}

	/************************************************/
	/*                                              */
	/*  Generate and check nchild trees             */
	/*                                              */
	/************************************************/

	for (p = 0; p < nchild; p++) {
		pid = fork();
		if (pid == 0) {
			tree();
		} else {
			if (pid < 1) {
				terror
				    ("Fork failed (may be OK if under stress)");
				massmurder();
				if (instress()) {
					ok_exit();
				}
				forkfail();
			}
		}
	}

	count = 0;
	while ((child = wait(&status)) > 0) {
#ifdef DEBUG
		tst_resm(TINFO, "Test %d exited status = %d\n", child, status);
#endif
		if (status) {
			fprintf(temp, "Test %d failed - expected 0 exit.\n",
				child);
			local_flag = FAILED;
		}
		count++;
	}

	if (count != nchild) {
		tst_resm(TFAIL, "Wrong number of children waited on!\n");
		tst_resm(TFAIL, "Saw %d, expected %d\n", count, nchild);
		local_flag = FAILED;
	}

	/************************************************/
	/*                                              */
	/*  And report the results..........            */
	/*                                              */
	/************************************************/

	anyfail();
	/** NOT REACHED **/
	tst_exit();
}

int bd_arg(char *str)
{
	fprintf(temp,
		"Bad argument - %s - could not parse as number.\n\tinode02 [max_depth] [max_breadth] [file_length] [#children]\n\tdefault: inode02 6 5 8 5\n",
		str);
	exit(1);
}

int tree(void)

/************************************************/
/*						*/
/*  		      TREE			*/
/*						*/
/*   generate a tree of directories and files   */
/*   and save the path names in the path_list	*/
/*   file 					*/
/*						*/
/*   then, read the path names and attempt to   */
/*   access the corresponding directories and	*/
/*   files					*/
/*						*/
/************************************************/
{
	int gen_ret_val, ch_ret_val, exit_val, level;
	int ret_val;
	int generate(), check();
	char path_list_string[PATH_STRING_LENGTH + 10];
	int len;
	int status;
	int snp_ret;

	/********************************/
	/*                              */
	/*  make the root directory for */
	/*  the tree                    */
	/*                              */
	/********************************/

	sprintf(path_string, "inode02.%d", getpid());

	ret_val = mkdir(path_string, DIRECTORY_MODE);

	if (ret_val == -1) {
		tst_resm(TBROK,
			 "Reason: Impossible to create directory %s, errno=%d\n",
			 path_string, errno);
		exit(-5);
	}

	strcpy(remove_string, "rm -rf ");
	strcat(remove_string, path_string);

#ifdef DEBUG
	tst_resm(TINFO, "\n%s\n", path_string);
#endif

	/****************************************/
	/*                                      */
	/*  create the "path_list" file, in     */
	/*  which the list of generated paths   */
	/*  will be stored so that they later   */
	/*  may be checked                      */
	/*                                      */
	/****************************************/

	snp_ret = snprintf(path_list_string, sizeof(path_list_string),
		"%s/path_list",	path_string);
	if (snp_ret < 0 || snp_ret >= sizeof(path_list_string)) {
		tst_resm(TBROK, "snprintf(path_list_string,..) returned %d",
			snp_ret);
		exit(-1);
	}
	list_id = creat(path_list_string, FILE_MODE);
	if (list_id == -1) {
		fprintf(temp,
			"\nThe path_list file '%s' cannot be created, errno=%d\n",
			path_list_string, errno);
		exit(-7);
	}

	/****************************************/
	/*                                      */
	/*   and store its name in path_list    */
	/*                                      */
	/****************************************/

	strcpy(write_string, path_string);
	len = strlen(write_string);
	write_string[len++] = 'D';
	write_string[len] = '\0';
	escrivez(write_string);

	/****************************************/
	/*                                      */
	/*   generate the directory-file tree   */
	/*                                      */
	/****************************************/

	level = 0;

#ifdef DEBUG
	tst_resm(TINFO, "\n\t%s\n\n", "GENERATING:");
#endif

	gen_ret_val = generate(path_string, level);
	close(list_id);
	list_id = open(path_list_string, READ);
	if (list_id == -1) {
		fprintf(temp,
			"\nThe path_list file cannot be opened for reading, errno=%d\n",
			errno);
		exit(-8);
	}
	list_stream = fdopen(list_id, "r");

	/****************************************/
	/*                                      */
	/*   check the directory-file tree      */
	/*      for correctness                 */
	/*                                      */
	/****************************************/

#ifdef DEBUG
	tst_resm(TINFO, "\n\t%s\n\n", "CHECKING:");
#endif

	ch_ret_val = check();

	exit_val = MIN(ch_ret_val, gen_ret_val);

	status = fclose(list_stream);
	if (status != 0) {
		fprintf(temp,
			"Failed to close list_stream: ret=%d errno=%d (%s)\n",
			status, errno, strerror(errno));
		exit(-8);
	}

	/*
	 * Remove file.
	 */

	status = system(remove_string);
	if (status) {
		fprintf(temp, "Caution - `%s' failed.\n", remove_string);
		fprintf(temp, "Status returned %d.\n", status);
	}

	/****************************************/
	/*                                      */
	/*         .....and exit main           */
	/*                                      */
	/****************************************/

	exit(exit_val);
}

int generate(char *string, int level)

/****************************************/
/*					*/
/*   generate recursively a tree of	*/
/*   directories and files:  within   	*/
/*   created directory, an alternating	*/
/*   series of files and directories 	*/
/*   are constructed---until tree	*/
/*   breadth and depth limits are	*/
/*   reached or an error occurs		*/
/*					*/
/****************************************/
/***************************/
/*  string:                */
/*  the directory path     */
/*  string below which a   */
/*  tree is generated      */
/*                         */
/***************************/

/***************************/
/* level:                  */
/* the tree depth variable */
/*                         */
/***************************/
{
	int switch_flag;
	int ret_val = 0;
	int new_ret_val, len, ret_len;
	char new_string[PATH_STRING_LENGTH + 1];
	int new_level;
	int i, j;		/* iteration counters */
	int snp_ret;

	switch_flag = level & TRUE;
	if (strlen(string) >= MAX_PATH_STRING_LENGTH) {

		/********************************/
		/*                              */
		/*   Maximum path name length   */
		/*          reached             */
		/*                              */
		/********************************/

		fprintf(temp, "\nMaximum path_name length reached\n");
		return (-1);
	} else if (level < max_depth) {
		for (i = 0; i <= max_breadth; i++) {
			get_next_name();
			snp_ret = snprintf(new_string, sizeof(new_string),
				"%s/%s", string, name);
			if (snp_ret < 0 || snp_ret >= sizeof(new_string)) {
				tst_resm(TBROK, "snprintf(new_string,..) "
					"returned %d", snp_ret);
				exit(-1);
			}

			/****************************************/
			/*                                      */
			/*    switch between creating files     */
			/*    and making directories            */
			/*                                      */
			/****************************************/

			if (switch_flag) {
				switch_flag = FALSE;

				/****************************************/
				/*                                      */
				/*        create a new file             */
				/*                                      */
				/****************************************/

				file_id = creat(new_string, FILE_MODE);
				if (file_id == -1) {
					fprintf(temp,
						"\nImpossible to create file %s, errno=%d\n",
						new_string, errno);
					return (-2);
				}
#ifdef DEBUG
				tst_resm(TINFO, "%d  %s F\n", level,
					 new_string);
#endif

				/****************************************/
				/*                                      */
				/*            write to it               */
				/*                                      */
				/****************************************/

				len = strlen(new_string);
				for (j = 1; j <= file_length; j++) {
					ret_len =
					    write(file_id, new_string, len);
					if (ret_len != len) {
						fprintf(temp,
							"\nUnsuccessful write to file %s, errno=%d\n",
							new_string, errno);
						return (-3);
					}
				}
				close(file_id);

				/****************************************/
				/*                                      */
				/*   and store its name in path_list    */
				/*                                      */
				/****************************************/

				strcpy(write_string, new_string);
				len = strlen(write_string);
				write_string[len++] = 'F';
				write_string[len] = '\0';
				escrivez(write_string);
			} else {
				switch_flag = TRUE;

				/****************************************/
				/*                                      */
				/*       or make a directory            */
				/*                                      */
				/*  (mknod can only be called when in   */
				/*   super user mode)                   */
				/*                                      */
				/****************************************/

				ret_val = mkdir(new_string, DIRECTORY_MODE);

				if (ret_val != 0) {
					fprintf(temp,
						"\nImpossible to create directory %s, errno=%d\n",
						new_string, errno);
					return (-5);
				}
#ifdef DEBUG
				tst_resm(TINFO, "%d  %s D\n", level,
					 new_string);
#endif

				/****************************************/
				/*                                      */
				/*     store its name in path_list      */
				/*                                      */
				/****************************************/

				strcpy(write_string, new_string);
				len = strlen(write_string);
				write_string[len++] = 'D';
				write_string[len] = '\0';
				escrivez(write_string);

				/****************************************/
				/*                                      */
				/*      and generate a new level        */
				/*                                      */
				/****************************************/

				new_level = level + 1;
				new_ret_val = generate(new_string, new_level);
				if (new_ret_val < ret_val)
					ret_val = new_ret_val;
			}
		}

		/********************************/
		/*                              */
		/*    Maximum breadth reached   */
		/*                              */
		/********************************/

		return (ret_val);
	} else
		    /********************************/
		/*                             */
		/*    Maximum depth reached    */
		/*                             */
 /********************************/
		return 0;
}

int check(void)

/****************************************/
/*					*/
/*   check for file and directory	*/
/*   correctness by reading records	*/
/*   from the path_list and attempting	*/
/*   to determine if the corresponding	*/
/*   files or directories are as 	*/
/*   created 				*/
/*					*/
/****************************************/
{
	int len, path_mode, val, ret_len, j;

	for (;;) {

		/****************************************/
		/*                                      */
		/*  read a path string from path_list   */
		/*                                      */
		/****************************************/

		if (fscanf(list_stream, "%s", path_string) == EOF) {

#ifdef DEBUG
			tst_resm(TINFO, "\nEnd of path_list file reached \n");
#endif

			return 0;
		}
#ifdef DEBUG
		tst_resm(TINFO, "%s\n", path_string);
#endif

		len = strlen(path_string);
		len--;
		if (path_string[len] == 'F') {

		/********************************/
			/*                              */
			/*    this should be a file     */
			/*                              */
		/********************************/

			path_string[len] = '\0';
			file_id = open(path_string, READ);
			if (file_id <= 0) {
				fprintf(temp,
					"\nImpossible to open file %s, errno=%d\n",
					path_string, errno);
				return (-1);
			}

			else {
				/********************************/
				/*                              */
				/*    check its contents        */
				/*                              */
				/********************************/

				ret_len = 0;
				len = strlen(path_string);
				for (j = 1; j <= file_length; j++) {
					ret_len =
					    read(file_id, read_string, len);
					if (len != ret_len) {
						fprintf(temp,
							"\nFile read error for file %s, errno=%d\n",
							path_string, errno);
						return (-3);
					}
					read_string[len] = '\0';
					val = strcmp(read_string, path_string);
					if (val != 0) {
						fprintf(temp,
							"\nContents of file %s are different than expected: %s\n",
							path_string,
							read_string);
						return (-4);
					}
				}
				close(file_id);
			}	/* else for */
			if (ret_len <= 0) {
				fprintf(temp,
					"\nImpossible to read file %s, errno=%d\n",
					path_string, errno);
				return (-2);
			}
		} else {

		/********************************/
			/*                              */
			/*  otherwise..........         */
			/*  it should be a directory    */
			/*                              */
		/********************************/

			path_string[len] = '\0';
			path_mode = mode(path_string);
			if (path_mode == -1) {
				fprintf(temp,
					"\nPreviously created directory path %s was not open\n",
					path_string);
				return (-4);
			}
			if ((040000 & path_mode) != 040000) {
				fprintf(temp,
					"\nPath %s was not recognized to be a directory\n",
					path_string);
				fprintf(temp, "Its mode is %o\n", path_mode);
				return (-5);
			}
		}
	}			/* while */
}

int get_next_name(void)

/****************************************/
/*					*/
/*   get the next---in a dictionary	*/
/*   sense---file or directory name	*/
/*					*/
/****************************************/
{
	static int k;
	int i;
	int last_position;

	last_position = NAME_LENGTH - 1;
	if (k == 0) {

		/************************/
		/*                      */
		/*   initialize name    */
		/*                      */
		/************************/

		for (i = 0; i < NAME_LENGTH; i++)
			name[i] = 'a';
		name[NAME_LENGTH] = '\0';
		k++;
	}
					    /********************************/
	/*                              */
	else
		increment_name(last_position);	/* i.e., beginning at the last  */
	/* position                     */
	/*                              */
					    /********************************/
	return 0;
}

int increment_name(int position)

/****************************************/
/*					*/
/*  recursively revise the letters in 	*/
/*  a name to get the lexiographically	*/
/*  next name				*/
/*					*/
/****************************************/
{
	int next_position;

	if (name[position] == 'z')
		if (position == 0) {
			fprintf(temp,
				"ERROR: There are no more available names\n");
			exit(-1);
		} else {
			name[position] = 'a';	       /**********************/
			next_position = --position;	/*                    */
			increment_name(next_position);	/*  increment the     */
			/*  previous letter   */
			/*                    */
						       /**********************/
		}
				  /*********************************/
	/*                               */
	else
		name[position]++;	/* otherwise, increment this one */
	return 0;		/*                               */
				  /*********************************/
}

int mode(char *path_string)

/****************************************/
/*					*/
/*   determine and return the mode of	*/
/*   the file named by path_string 	*/
/*					*/
/****************************************/
{
	struct stat buf;
	int ret_val, mod;

	ret_val = stat(path_string, &buf);
	if (ret_val == -1)
		return (-1);
	else {
		mod = buf.st_mode;
		return (mod);
	}
}

int escrivez(char *string)
{
	char write_string[PATH_STRING_LENGTH + 1];
	int len, ret_len;

	strcpy(write_string, string);
	len = strlen(write_string);
	write_string[len] = '\n';
	len++;
	ret_len = write(list_id, write_string, len);
	if (len != ret_len) {
		fprintf(temp,
			"A string of deviant length %d written to path_list, errno=%d\n",
			ret_len, errno);
		exit(-2);
	}
	return 0;
}

int term(void)
{
	int status;

	fflush(temp);
	if (parent_pid == getpid()) {
		massmurder();	/* kill kids */
		fprintf(temp, "\term1 - SIGTERM received by parent.\n");
		fflush(temp);
	} else {
		fprintf(temp, "\tchild - got SIGTERM signal.\n");
		if (list_stream != NULL)
			fclose(list_stream);
		close(list_id);
		close(file_id);
		status = system(remove_string);
		if (status) {
			fprintf(temp, "Caution - ``%s'' returned status %d\n",
				remove_string, status);
		}
		exit(0);
	}
	return 0;
}

int massmurder(void)
{
	int i;
	for (i = 0; i < MAXCHILD; i++) {
		if (allchild[i]) {
			kill(allchild[i], SIGTERM);
		}
	}
	return 0;
}

/** LTP Port **/
/*
 * setup
 *
 * Do set up - here its a dummy function
 */
void setup(void)
{
	tst_tmpdir();
	temp = stderr;
}

/*
 * fail_exit()
 *
 * Exit on failure
 */
void fail_exit(void)
{
	tst_brkm(TFAIL, tst_rmdir, "Test failed\n");
}

/*
 *
 * Function: anyfail()
 *
 * Description: Exit a test.
 */
void anyfail(void)
{
	(local_flag == FAILED) ? tst_resm(TFAIL, "Test failed")
	    : tst_resm(TPASS, "Test passed");
	tst_rmdir();
	tst_exit();
}

/*
 * ok_exit
 *
 * Calling block passed the test
 */
void ok_exit(void)
{
	local_flag = PASSED;
	return;
}

/*
 * forkfail()
 *
 * exit on failure
 */
void forkfail(void)
{
	tst_brkm(TBROK, tst_rmdir, "Reason: %s\n", strerror(errno));
}

/*
 * Function: terror
 *
 * Description: prints error message this may not be because some part of the
 *              test case failed, for example fork() failed. We will log this
 *              failure as TBROK instead of TFAIL.
 */
void terror(char *message)
{
	tst_resm(TBROK, "Reason: %s:%s\n", message, strerror(errno));
	return;
}

/*
 * instress
 *
 * Assume that we are always running under stress, so this function will
 * return > 0 value always.
 */
int instress(void)
{
	tst_resm(TINFO, "System resource may be too low, fork() malloc()"
		 " etc are likely to fail.\n");
	return 1;
}