Lab46 Wiki

Fitting, then, that my first update to my opus is monumental in length. The following are the exercises from chapter 7. These really escalated in complexity.

hello1.c

#include	<stdio.h>
#include	<curses.h>

main()
{
	initscr() ;		/* turn on curses	*/

				/* send requests	*/
	clear();			/* clear screen	*/
	move(10,20);			/* row10,col20	*/
	addstr("Hello, world");		/* add a string	*/
	move(LINES-1,0);		/* move to LL	*/

	refresh();		/* update the screen	*/
	getch();		/* wait for user input	*/

	endwin();		/* turn off curses	*/
}

hello2.c

#include	<stdio.h>
#include	<curses.h>

main()
{
	int	i;

	initscr();			/* turn on curses	*/
	   clear();			/* draw some stuff	*/
	   for(i=0; i<LINES; i++ ){		/* in a loop	*/
		move( i, i+i );
		if ( i%2 == 1 )
			standout();
		addstr("Hello, world");
		if ( i%2 == 1 )
		       standend();
	   }

	   refresh();			/* update the screen	*/
	   getch();			/* wait for user input	*/
	endwin();			/* reset the tty etc	*/
}

hello3.c

#include	<stdio.h>
#include	<curses.h>

main()
{
	int	i;

	initscr();
	   clear();
	   for(i=0; i<LINES; i++ ){
		move( i, i+i );
		if ( i%2 == 1 ) 
			standout();
		addstr("Hello, world");
		if ( i%2 == 1 ) 
			standend();
		sleep(1);
		refresh();
	   }
	endwin();
}

hello4.c

#include	<stdio.h>
#include	<curses.h>

main()
{
	int	i;

	initscr();
	   clear();
	   for(i=0; i<LINES; i++ ){
		move( i, i+i );
		if ( i%2 == 1 ) 
			standout();
		addstr("Hello, world");
		if ( i%2 == 1 ) 
			standend();
		refresh();
		sleep(1);
		move(i,i+i);			/* move back	*/
		addstr("             ");	/* erase line	*/
	   }
	endwin();
}

hello5.c

#include	<curses.h>

#define	LEFTEDGE	10
#define	RIGHTEDGE	30
#define	ROW		10

main()
{
	char	message[] = "Hello";
	char	blank[]   = "     ";
	int	dir = +1;
	int	pos = LEFTEDGE ;

	initscr();
	  clear();
	  while(1){
		move(ROW,pos);
		addstr( message );		/* draw string		*/
		move(LINES-1,COLS-1);		/* park the cursor	*/
		refresh();			/* show string		*/
		sleep(1);
		move(ROW,pos);			/* erase string		*/
		addstr( blank );
		pos += dir;			/* advance position	*/
		if ( pos >= RIGHTEDGE )		/* check for bounce	*/
			dir = -1;
		if ( pos <= LEFTEDGE )
			dir = +1;
	  }
}

Up until now, these 5 examples have been playing with the curses library, creating text and moving text.

sleep1.c - demonstrates sleep()

#include	<stdio.h>
#include	<signal.h>
// #define	SHHHH

main()
{
	void	wakeup(int);

	printf("about to sleep for 4 seconds\n");
	signal(SIGALRM, wakeup);		/* catch it	*/
	alarm(4);				/* set clock	*/
	pause();				/* freeze here	*/
	printf("Morning so soon?\n");		/* back to work	*/
}

void wakeup(int signum)
{
#ifndef SHHHH
	printf("Alarm received from kernel\n");
#endif
}

ticker_demo.c - demonstrates to the programmer how an interval timer can be used to generate regular signals

#include	<stdio.h>
#include        <sys/time.h>
#include        <signal.h>

int main()
{
	void	countdown(int);

	signal(SIGALRM, countdown);
	if ( set_ticker(500) == -1 )
		perror("set_ticker");
	else
		while( 1 )
			pause();
	return 0;
}

void countdown(int signum)
{
	static int num = 10;
	printf("%d ..", num--);
	fflush(stdout);
	if ( num < 0 ){
		printf("DONE!\n");
		exit(0);
	}
}

/* [from set_ticker.c]
 * set_ticker( number_of_milliseconds )    
 *      arranges for interval timer to issue SIGALRM's at regular intervals
 *      returns -1 on error, 0 for ok
 *      arg in milliseconds, converted into whole seconds and microseconds
 *      note: set_ticker(0) turns off ticker
 */

int set_ticker( int n_msecs )
{
        struct itimerval new_timeset;
        long    n_sec, n_usecs;

        n_sec = n_msecs / 1000 ;		/* int part	*/
        n_usecs = ( n_msecs % 1000 ) * 1000L ;	/* remainder	*/

        new_timeset.it_interval.tv_sec  = n_sec;        /* set reload       */
        new_timeset.it_interval.tv_usec = n_usecs;      /* new ticker value */
        new_timeset.it_value.tv_sec     = n_sec  ;      /* store this       */
        new_timeset.it_value.tv_usec    = n_usecs ;     /* and this         */

	return setitimer(ITIMER_REAL, &new_timeset, NULL);
}

sigdemo3.c - We toyed around with this concept on Tuesday, using signal()

#include	<stdio.h>
#include	<signal.h>

#define	INPUTLEN	100

main(int ac, char *av[])
{
	void	inthandler(int);
	void	quithandler(int);
	char	input[INPUTLEN];
	int	nchars;

	signal( SIGINT,  inthandler );		/* set handler */
	signal( SIGQUIT, quithandler );		/* set handler */

	do {
		printf("\nType a message\n");
		nchars = read(0, input, (INPUTLEN-1));
		if ( nchars == -1 )
			perror("read returned an error");
		else {
			input[nchars] = '\0';
			printf("You typed: %s", input);
		}
	} 
	while( strncmp( input , "quit" , 4 ) != 0 );
}

void inthandler(int s)
{
	printf(" Received signal %d .. waiting\n", s );
	sleep(2);
	printf("  Leaving inthandler \n");
}

void quithandler(int s)
{
	printf(" Received signal %d .. waiting\n", s );
	sleep(3);
	printf("  Leaving quithandler \n");
}

sigactdemo.c - goes beyond signal() and demonstrates how we may utilize sigaction() to intercept signals.

#include	<stdio.h>
#include	<signal.h>
#define	INPUTLEN	100

main()
{
	struct sigaction newhandler;            /* new settings        */
	sigset_t         blocked;               /* set of blocked sigs */
	void		 inthandler();          /* the handler         */
	char		 x[INPUTLEN];

	/* load these two members first */
	newhandler.sa_handler = inthandler;      /* handler function    */
	newhandler.sa_flags = SA_RESETHAND | SA_RESTART;  /* options    */

	/* then build the list of blocked signals */
	sigemptyset(&blocked);                  /* clear all bits      */
	sigaddset(&blocked, SIGQUIT);		/* add SIGQUIT to list */

	newhandler.sa_mask = blocked;		/* store blockmask     */

	if ( sigaction(SIGINT, &newhandler, NULL) == -1 )
		perror("sigaction");
	else
		while( 1 ){
			fgets(x, INPUTLEN, stdin);
			printf("input: %s", x);
		}
}

void inthandler(int s)
{
	printf("Called with signal %d\n", s);
	sleep(s);
	printf("done handling signal %d\n", s);
}

bounce1d.c - user controlled animation, as in user defined speed and direction! VIDJA GAMES

#include	<stdio.h>
#include	<curses.h>
#include	<signal.h>

/* some global settings main and the handler use */

#define	MESSAGE	"hello"
#define BLANK   "     "

int	row;	/* current row		*/
int	col;	/* current column	*/
int	dir;	/* where we are going	*/

int main()
{
	int	delay;		/* bigger => slower	*/
	int	ndelay;		/* new delay		*/
	int	c;		/* user input		*/
	void	move_msg(int);	/* handler for timer	*/

	initscr();
	crmode();
	noecho();
	clear();

	row   = 10;		/* start here		*/
	col   = 0;
	dir   = 1;		/* add 1 to row number	*/
	delay = 200;		/* 200ms = 0.2 seconds  */

	move(row,col);		/* get into position	*/
	addstr(MESSAGE);	/* draw message		*/
	signal(SIGALRM, move_msg );
	set_ticker( delay );

	while(1)
	{
		ndelay = 0;
		c = getch();
		if ( c == 'Q' ) break;
		if ( c == ' ' ) dir = -dir;
		if ( c == 'f' && delay > 2 ) ndelay = delay/2;
		if ( c == 's' ) ndelay = delay * 2 ;
		if ( ndelay > 0 )
			set_ticker( delay = ndelay );
	}
	endwin();
	return 0;
}

void move_msg(int signum)
{
	signal(SIGALRM, move_msg);	/* reset, just in case	*/
	move( row, col );
	addstr( BLANK );
	col += dir;			/* move to new column	*/
	move( row, col );		/* then set cursor	*/
	addstr( MESSAGE );		/* redo message		*/
	refresh();			/* and show it		*/

	/*
	 * now handle borders
	 */
	if ( dir == -1 && col <= 0 )
		dir = 1;
	else if ( dir == 1 && col+strlen(MESSAGE) >= COLS )
		dir = -1;
}

bounce2d.c - More advanced version of bounce1d, instead of moving in a completely linear fashion, movement in two directions is now applied simultaneously. MATH.

#include	<curses.h>
#include	<signal.h>
#include	"bounce.h"

struct ppball the_ball ;

/**  the main loop  **/

void set_up();
void wrap_up();

int main()
{
	int	c;

	set_up();

	while ( ( c = getchar()) != 'Q' ){
		if ( c == 'f' )	     the_ball.x_ttm--;
		else if ( c == 's' ) the_ball.x_ttm++;
		else if ( c == 'F' ) the_ball.y_ttm--;
		else if ( c == 'S' ) the_ball.y_ttm++;
	}

	wrap_up();
}


void set_up()
/*
 *	init structure and other stuff
 */
{
	void	ball_move(int);

	the_ball.y_pos = Y_INIT;
	the_ball.x_pos = X_INIT;
	the_ball.y_ttg = the_ball.y_ttm = Y_TTM ;
	the_ball.x_ttg = the_ball.x_ttm = X_TTM ;
	the_ball.y_dir = 1  ;
	the_ball.x_dir = 1  ;
	the_ball.symbol = DFL_SYMBOL ;

	initscr();
	noecho();
	crmode();

	signal( SIGINT , SIG_IGN );
	mvaddch( the_ball.y_pos, the_ball.x_pos, the_ball.symbol  );
	refresh();
	
	signal( SIGALRM, ball_move );
	set_ticker( 1000 / TICKS_PER_SEC );	/* send millisecs per tick */
}

void wrap_up()
{

	set_ticker( 0 );
	endwin();		/* put back to normal	*/
}


void ball_move(int signum)
{
	int	y_cur, x_cur, moved;

	signal( SIGALRM , SIG_IGN );		/* dont get caught now 	*/
	y_cur = the_ball.y_pos ;		/* old spot		*/
	x_cur = the_ball.x_pos ;
	moved = 0 ;

	if ( the_ball.y_ttm > 0 && the_ball.y_ttg-- == 1 ){
		the_ball.y_pos += the_ball.y_dir ;	/* move	*/
		the_ball.y_ttg = the_ball.y_ttm  ;	/* reset*/
		moved = 1;
	}

	if ( the_ball.x_ttm > 0 && the_ball.x_ttg-- == 1 ){
		the_ball.x_pos += the_ball.x_dir ;	/* move	*/
		the_ball.x_ttg = the_ball.x_ttm  ;	/* reset*/
		moved = 1;
	}

	if ( moved ){
		mvaddch( y_cur, x_cur, BLANK );
		mvaddch( y_cur, x_cur, BLANK );
		mvaddch( the_ball.y_pos, the_ball.x_pos, the_ball.symbol );
		bounce_or_lose( &the_ball );
		move(LINES-1,COLS-1);
		refresh();
	}
	signal( SIGALRM, ball_move);		/* for unreliable systems */

}

int bounce_or_lose(struct ppball *bp)
{
	int	return_val = 0 ;

	if ( bp->y_pos == TOP_ROW ){
		bp->y_dir = 1 ; 
		return_val = 1 ;
	} else if ( bp->y_pos == BOT_ROW ){
		bp->y_dir = -1 ;
	       	return_val = 1;
	}
	if ( bp->x_pos == LEFT_EDGE ){
		bp->x_dir = 1 ;
	       	return_val = 1 ;
	} else if ( bp->x_pos == RIGHT_EDGE ){
		bp->x_dir = -1;
	       	return_val = 1;
	}

	return return_val;
}

bounce.h - The accompanying header to bounce1d and bounce2d

/* bounce.h			*/

/* some settings for the game	*/

#define	BLANK		' '
#define	DFL_SYMBOL	'o'
#define	TOP_ROW		5
#define	BOT_ROW 	20
#define	LEFT_EDGE	10
#define	RIGHT_EDGE	70
#define	X_INIT		10		/* starting col		*/
#define	Y_INIT		10		/* starting row		*/
#define	TICKS_PER_SEC	50		/* affects speed	*/

#define	X_TTM		5
#define	Y_TTM		8

/** the ping pong ball **/

struct ppball {
		int	y_pos, x_pos,
			y_ttm, x_ttm,
			y_ttg, x_ttg,
			y_dir, x_dir;
		char	symbol ;

	} ;

bounce_async.c and bounce_aio.c are above my head, currently. Here they are, respectively. Hopefully we will dissect these in class.

#include	<stdio.h>
#include	<curses.h>
#include	<signal.h>
#include	<fcntl.h>

/* The state of the game */

#define	MESSAGE	"hello"
#define	BLANK	"     "

int	row   = 10;	/* current row		*/
int	col   =  0;	/* current column	*/
int	dir   =  1;	/* where we are going	*/
int	delay = 200;	/* how long to wait	*/
int	done  = 0;

main()
{
	void	on_alarm(int);	/* handler for alarm	*/
	void	on_input(int);	/* handler for keybd    */
	void	enable_kbd_signals();

	initscr();		/* set up screen */
	crmode();
	noecho();
	clear();

	signal(SIGIO, on_input);          /* install a handler        */
	enable_kbd_signals();             /* turn on kbd signals      */
	signal(SIGALRM, on_alarm);        /* install alarm handler    */
	set_ticker(delay);		  /* start ticking	      */

	move(row,col);		          /* get into position	      */
	addstr( MESSAGE );	          /* draw initial image       */

	while( !done )			  /* the main loop */
		pause();
	endwin();
}
void on_input(int signum)
{
	int	c = getch();		  /* grab the char */

	if ( c == 'Q' || c == EOF )
		done = 1;
	else if ( c == ' ' )
		dir = -dir;
}

void on_alarm(int signum)
{
	signal(SIGALRM, on_alarm);	/* reset, just in case	*/
	mvaddstr( row, col, BLANK );	/* note mvaddstr()	*/
	col += dir;			/* move to new column	*/
	mvaddstr( row, col, MESSAGE );	/* redo message		*/
	refresh();			/* and show it		*/

	/*
	 * now handle borders
	 */
	if ( dir == -1 && col <= 0 )
		dir = 1;
	else if ( dir == 1 && col+strlen(MESSAGE) >= COLS )
		dir = -1;
}
/*
 * install a handler, tell kernel who to notify on input, enable signals
 */
void enable_kbd_signals()
{
	int  fd_flags;

	fcntl(0, F_SETOWN, getpid());
	fd_flags = fcntl(0, F_GETFL);
	fcntl(0, F_SETFL, (fd_flags|O_ASYNC));
}

And

#include	<stdio.h>
#include	<curses.h>
#include	<signal.h>
#include	<aio.h>
#include	<string.h>

/* The state of the game 			*/

#define	MESSAGE	"hello"
#define	BLANK	"     "

int	row   = 10;	/* current row		*/
int	col   =  0;	/* current column	*/
int	dir   =  1;	/* where we are going	*/
int	delay = 200;	/* how long to wait	*/
int	done  = 0;

struct aiocb kbcbuf;	/* an aio control buf   */

main()
{
	void	on_alarm(int);	/* handler for alarm	*/
	void	on_input(int);	/* handler for keybd    */
	void	setup_aio_buffer();

	initscr();		/* set up screen */
	crmode();
	noecho();
	clear();

	signal(SIGIO, on_input);          /* install a handler        */
	setup_aio_buffer();	  	  /* initialize aio ctrl buff */
	aio_read(&kbcbuf);		  /* place a read request     */

	signal(SIGALRM, on_alarm);        /* install alarm handler    */
	set_ticker(delay);		  /* start ticking	      */

	mvaddstr( row, col, MESSAGE );    /* draw initial image       */

	while( !done )			  /* the main loop */
		pause();
	endwin();
}
/*
 * handler called when aio_read() has stuff to read
 *   First check for any error codes, and if ok, then get the return code
 */
void on_input(int s)
{
	int  c;
	char *cp = (char *) kbcbuf.aio_buf;	/* cast to char * */

	/* check for errors */
	if ( aio_error(&kbcbuf) != 0 )
		perror("reading failed");
	else 
		/* get number of chars read */
		if ( aio_return(&kbcbuf) == 1 )
		{
			c = *cp;
			if ( c == 'Q' || c == EOF )
				done = 1;
			else if ( c == ' ' )
				dir = -dir;
		}

	/* place a new request */
	aio_read(&kbcbuf);
}

void on_alarm(int s)
{
	signal(SIGALRM, on_alarm);	/* reset, just in case	*/
	mvaddstr( row, col, BLANK );	/* clear old string	*/
	col += dir;			/* move to new column	*/
	mvaddstr( row, col, MESSAGE );	/* draw new string	*/
	refresh();			/* and show it		*/
	/*
	 * now handle borders
	 */
	if ( dir == -1 && col <= 0 )
		dir = 1;
	else if ( dir == 1 && col+strlen(MESSAGE) >= COLS )
		dir = -1;
}
/*
 * set members of struct.  
 *   First specify args like those for read(fd, buf, num)  and offset
 *   Then  specify what to do (send signal) and what signal (SIGIO)
 */
void setup_aio_buffer()
{
	static char input[1];		      /* 1 char of input */

	/* describe what to read */
	kbcbuf.aio_fildes     = 0;	      /* standard intput */
	kbcbuf.aio_buf        = input;	      /* buffer          */
	kbcbuf.aio_nbytes     = 1;             /* number to read  */
	kbcbuf.aio_offset     = 0;             /* offset in file  */

	/* describe what to do when read is ready */
	kbcbuf.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
	kbcbuf.aio_sigevent.sigev_signo  = SIGIO;  /* send sIGIO   */
}

This chapter contained almost as much information as the preceding 6 chapters. Sometimes I wonder if the author to this book finds joy in anything since he obviously has attained supreme knowledge.

“”

Today we continued with Chapter 8, adding to the fork concept. Using fork4 we played with wait() and added some interesting use of exec(). in this case we used execl().

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>

int main(int argc, char **argv)
{
        pid_t me, you;
        char input, *fname;
        FILE *fptr;

        int i, j, data[100][2], rank = 0, numproc = 0;
        int pidlist[5];

        for(i=0; i<100; i++)
        {
                data[i][0] = i * i;
        }

        pidlist[0] = getpid();
        for(i = 1; i <= 4; i++)
        {
                if(pidlist[0] == getpid())
                {
                        rank = rank + 1;
                        pidlist[i] = fork();
                }
        }

        if (getpid() == pidlist[0])
        {
                printf("I am PID %i, my child processes are: ", pidlist[0]);
                for(i=1; i<=4; i++)
                        printf("%i ", pidlist[i]);
                printf("\n");

                // could put code to wait for child process termination here
                for(i = 0; i < rank; i++)
                {
                        you = wait(&j);
                        printf("child PID %d has finished with status %d\n",you,j);
                }
        }
        else
        {
                if(rank==2){
                        execl("/bin/ls","ls","-l",NULL);
                }
                me = getpid();
                printf("I am child %i (pid %i), so I will process ", rank, me);
                printf("elements %i-%i ...\n", ((rank*25)-25), ((((rank+1)*25)-1)-25));
                for(i = ((rank*25)-25); i < (((rank+1)*25)-25); i++)
                        data[i][1] = data[i][0] * rank;

                fname = (char *) malloc (sizeof(char) * 8);
                sprintf(fname, "rank%i", rank);
                fptr = fopen(fname, "w");

                fprintf(fptr, "%i\n", (rank*25)-25);
                fprintf(fptr, "%i\n", (((rank+1)*25)-1)-25);
                for(i = rank*25-25; i < ((rank+1)*25)-25; i++)
                        fprintf(fptr, "%i\t%i\n", data[i][0], data[i][1]);

                fclose(fptr);
                sleep(rank * 2+60);
        }

        return(0);
}