/* * (C) Finite State Machine Labs Inc. 2000 business@fsmlabs.com * * Released under the terms of GPL 2. * Open RTLinux makes use of a patented process described in * US Patent 5,995,745. Use of this process is governed * by the Open RTLinux Patent License which can be obtained from * www.fsmlabs.com/PATENT or by sending email to * licensequestions@fsmlabs.com */#include <sys/types.h>#include <sys/stat.h>#include <sys/poll.h>#include <unistd.h>#include <string.h>#include <fcntl.h>#include <stdio.h>#include <stdlib.h>#include <errno.h>#include <signal.h>#include "fifo_test.h"/* module unload and loading commands */#define	MODULE_LOAD	"/sbin/insmod regression/fifo_module.o fifo_size=%d fifo_nr=%d"#define MODULE_UNLOAD	"/sbin/rmmod fifo_module"/* fifo size params */#define	MIN_SIZE	1#define	MAX_SIZE	65536/* this is set to 32 to make the test go faster; it will test fifos of size 1, * 32, 1024 and 32768 (even though the MAX_SIZE is 65536).  Set this number to * 2 or any other multiple of 2 smaller than 32 to make it be more thorough * and slow; set it to any multiple higher than 32 to make it go faster, but * be less thorough. */#define	MUL_SIZE	2char *construct_filename(int);int stat_test(const char *);int open_test_fail(const char *);int load_module();int over_write_test(const char *, int);int over_read_test(const char *, int);char *read_test(const char *, int, int);int unload_module();int write_test(const char *, const char *, int, int);int write_read_test(const char *, int);char *get_random_str(int);int sig_handler_setup(void);void my_sahandler(int);int big_fifo_test(int);int main(void){	int i;	int retval;	int test_nr, fifo_size, buf_size;	char *filename, *teststr, *resstr;	/* set up handler to unload module if we get ^C or similar */	if ((retval = sig_handler_setup()) != 0) {		return (retval);	}	/* attempt to unload the module because the signal handler doesn't	 * always manage to do it when we get ^C */	unload_module();	/* outer loop to test ALL the FIFOs */	/* instead of looping through any arbitrary FIFOs, just do the	 * important ones */	if ((retval = big_fifo_test(1)) != 0) {		return retval;	}	if ((retval = big_fifo_test(32)) != 0) {		return retval;	}	if ((retval = big_fifo_test(63)) != 0) {		return retval;	}	if ((retval = big_fifo_test(10)) != 0) {		return retval;	}	if ((retval = big_fifo_test(11)) != 0) {		return retval;	}	if ((retval = big_fifo_test(12)) != 0) {		return retval;	}	/* now try testing to see how big a FIFO we can make */	/* don't do this -Nathan	   i = 1;	   retval = 0;	   while (retval == 0) {	   retval = load_module(1, i);	   unload_module();	   i *= 2;	   }	 */	return (0);}char *construct_filename(int i){	char *filename;	if ((filename = (char *) calloc(11, sizeof(char))) == NULL) {		fprintf(stderr, "calloc (11, sizeof (char)): %s\n",			strerror(errno));		return (NULL);	}	if ((snprintf(filename, 11, "/dev/rtf%d", i)) < 0) {		fprintf(stderr, "snprintf (filename, 11, /dev/rtf%d): %s",			i, strerror(errno));		free(filename);		return (NULL);	}	return (filename);}int stat_test(const char *filename){	struct stat file_stats;	if (stat(filename, &file_stats) != 0) {		fprintf(stderr, "stat (%s, &file_stats): %s\n", filename,			strerror(errno));		return (errno);	}	if (!(S_ISCHR(file_stats.st_mode))) {		fprintf(stderr, "%s is not a character device.\n",			filename);		return (-1);	}	return (0);}/* this function assumes the module is not already loaded */int open_test_fail(const char *filename){	int filedes;	if ((filedes = open(filename, O_RDONLY)) > 0) {		fprintf(stderr,			"Opened %s for read without module loaded!\n",			filename);		if ((close(filedes)) != 0) {			fprintf(stderr, "close (%d): %s\n", filedes,				strerror(errno));			return (errno);		}		return (-1);	}	if ((filedes = open(filename, O_WRONLY | O_NONBLOCK)) > 0) {		fprintf(stderr,			"Opened %s for write without module loaded!\n",			filename);		if ((close(filedes)) != 0) {			fprintf(stderr, "close (%d): %s\n", filedes,				strerror(errno));			return (errno);		}		return (-1);	}	if ((filedes = open(filename, O_RDWR)) > 0) {		fprintf(stderr,			"Opened %s for read/write without module loaded!\n",			filename);		if ((close(filedes)) != 0) {			fprintf(stderr, "close (%d): %s\n", filedes,				strerror(errno));			return (errno);		}		return (-1);	}	return (0);}int load_module(int fifo_size, int fifo_nr){	int i = strlen(MODULE_LOAD) + 4;	char command[i];	if ((snprintf(command, i, MODULE_LOAD, fifo_size, fifo_nr)) < 0) {		fprintf(stderr, "snprintf (): %s", strerror(errno));		return (errno);	}	i = system(command);	if ((i == 127) || (i == -1)) {		fprintf(stderr, "system (%s): %d %s\n", command, i,			strerror(errno));		return (errno);	}	return (0);}int unload_module(){	int i;	i = system(MODULE_UNLOAD);	if ((i == 127) || (i == -1)) {		fprintf(stderr, "system (%s): %d %s\n", MODULE_UNLOAD, i,			strerror(errno));		return (errno);	}	return (0);}int over_read_test(const char *filename, int size){	int filedes;	int read_size;	char *inbuf;	if ((inbuf = (char *) calloc(size + 1, sizeof(char))) == NULL) {		fprintf(stderr, "calloc (1, %d): %s\n", sizeof(char),			strerror(errno));		return (errno);	}	if ((filedes = open(filename, O_RDONLY | O_NONBLOCK)) < 0) {		fprintf(stderr, "open (%s, O_RDONLY): %s\n", filename,			strerror(errno));		free(inbuf);		return (errno);	}	if ((read_size = read(filedes, inbuf, size + 1)) > size) {		fprintf(stderr, "read %d bytes from %d size FIFO!\n",			read_size, size);		close(filedes);		free(inbuf);		return (-1);	}	free(inbuf);	if ((close(filedes)) != 0) {		fprintf(stderr, "close (%d): %s\n", filedes,			strerror(errno));		return (errno);	}	return (0);}char *read_test(const char *filename, int buf_size, int size){	int filedes;	int read_size;	int inbuf_size;	char *inbuf;	struct pollfd fifo_poll;	read_size = 1;	inbuf_size = 0;	if ((inbuf = (char *) calloc(size, sizeof(char))) == NULL) {		fprintf(stderr, "calloc (1, %d): %s\n", sizeof(char),			strerror(errno));		return (NULL);	}	if ((filedes = open(filename, O_RDONLY | O_NONBLOCK)) < 0) {		fprintf(stderr, "open (%s, O_RDONLY): %s\n", filename,			strerror(errno));		free(inbuf);		return (NULL);	}	/* wait for data to arrive in FIFO */	fifo_poll.fd = filedes;	fifo_poll.events = POLLIN;	if ((poll(&fifo_poll, 1, 5000)) <= 0) {		fprintf(stderr, "poll (&fifo_poll, 1, 5000): %s\n",			strerror(errno));		free(inbuf);		close(filedes);		return (NULL);	}	/* attempt to empty the FIFO buf_size blocks at a time */	while (inbuf_size < size) {		if (		    (read_size =		     read(filedes, inbuf + inbuf_size, buf_size)) < 0) {			fprintf(stderr, "read (%d, inbuf, %d): %s\n",				filedes, buf_size, strerror(errno));			close(filedes);			free(inbuf);			return (NULL);		}		inbuf_size += read_size;	}	if ((close(filedes)) != 0) {		fprintf(stderr, "close (%d): %s\n", filedes,			strerror(errno));		free(inbuf);		return (NULL);	}	return (inbuf);}int over_write_test(const char *filename, int size){	int filedes;	int write_size;	char *outbuf;	if ((outbuf = (char *) calloc(size + 1, sizeof(char))) == NULL) {		fprintf(stderr, "calloc (%d, %d): %s\n", 2 * size,			sizeof(char), strerror(errno));		return (errno);	}	if ((filedes = open(filename, O_WRONLY | O_NONBLOCK)) < 0) {		fprintf(stderr, "open (%s, O_RDONLY): %s\n", filename,			strerror(errno));		free(outbuf);		return (errno);	}