cur_udp_kbd_tim.c

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <curses.h>
#include <unistd.h>
#include <aio.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/socket.h> 
#include <arpa/inet.h> 
#include <netinet/in.h> 
#include <netdb.h> 
  
#define PORT     8900 
#define MAXLINE 1024 


#define LOG_FILE "game.log"

#define DIALOG_WIDTH 40
#define DIALOG_HEIGHT 20
#define CONTENT_WIDTH (DIALOG_WIDTH - 2)

void set_colors() 
{
  // these don't actually have anything to do with binary, so we are free to use "normal" numbers
  init_pair(1, COLOR_RED, COLOR_BLACK); // red on black
  init_pair(2, COLOR_GREEN, COLOR_BLACK); // green on black
  init_pair(3, COLOR_YELLOW, COLOR_BLACK); // yellow on black
  init_pair(4, COLOR_BLUE, COLOR_BLACK); // blue on black
  init_pair(5, COLOR_MAGENTA, COLOR_BLACK); // magenta on black
  init_pair(6, COLOR_CYAN, COLOR_BLACK); // cyan on black
  init_pair(7, COLOR_WHITE, COLOR_BLACK); // white on black
}

void end_curses() 
{
  endwin();
}

// a simple log function, works similar to printf
void glog(const char *format, ... ) 
{
  va_list args; // argument list
  static FILE *logfile = NULL; // file pointer to the logfile
  char *fformat; // the modified format of the string which will be written to the logfile
  int length; // length of the format

  if(!(format == NULL && logfile == NULL)) {
    // open the logfile if not already opened
    if(logfile == NULL) {
      logfile = fopen(LOG_FILE, "w");
      // if that doesn't work exit with an error message
      if(logfile == NULL) {
        fprintf(stderr, "Cannot open logfile %s\n", LOG_FILE);
        exit(EXIT_FAILURE);
      }
    }

    // if NULL is given as format, close the opened file
    if(format != NULL) {
      // increase length by 2 (for \n\0
      length = strlen(format) + 2;
      // allocate memory
      fformat = malloc(sizeof(char) * length);
      // copy the format over
      strncpy(fformat, format, length - 2);
      // append \n\0
      fformat[length - 2] = '\n';
      fformat[length - 1] = '\0';

      // get the rest of the arguments
      va_start(args, format);

      // use vfprintf() to 
      vfprintf(logfile, fformat, args); 
      // forces the logmessage to be written into the file right now
      fflush(logfile);
     
      va_end(args);

      // free the allocated memory for the format string
      free(fformat);
    } 
    else 
    {
      // close the logfile
      fclose(logfile);
    }
  }
}



// create a basic dialog with title which looks like this:
//
// +--------------------------------------+
// +---------------- TITLE ---------------+
// +--------------------------------------+
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// |                                      |
// +--------------------------------------+
//
WINDOW *create_dialog_window(const char *title) {
  WINDOW *win;
  int sx, sy, i, u, startpos;

  // get the screen size
  getmaxyx(stdscr, sy, sx);
  // create a little window in the center of the screen with a border and a size of 40x20
  win = newwin(DIALOG_HEIGHT, DIALOG_WIDTH, sy / 2 - DIALOG_HEIGHT / 2, sx / 2 - DIALOG_WIDTH / 2);

  // create the border
  wborder(win, '|', '|', '-', '-', '+', '+', '+', '+');

  // fill the first two lines with "-" and "+" on the border
  for(u = 1; u <= 2; u++) {
    for(i = 0; i < DIALOG_WIDTH; i++) {
      mvwprintw(win, u, i, "%c", i == 0 || i == DIALOG_WIDTH - 1 ? '+' : '-');
    }
  }

  // print the title in the middle of the dialog
  startpos = DIALOG_WIDTH / 2 - strlen(title) / 2;
  // print a space before the title
  mvwprintw(win, 1, startpos - 1, " ");
  // print the title itself
  mvwprintw(win, 1, startpos, "%s", title);
  // print a space after the title
  mvwprintw(win, 1, startpos + strlen(title), " ");
  return win;
}


// creates a dialog with menu entries, you can press numbers to select a menu entry and close the dialog
int create_numbered_dialog(const char *title, const char *contents, int lines) {
  WINDOW *win = create_dialog_window(title);
  int i, ch, number = 0;

  // insert menu entries into the dialog
  for(i = 0; i < lines; i++) {
    mvwprintw(win, i + 3, 1, &contents[i * CONTENT_WIDTH], i + 1);
  }

  // display the dialog
  wrefresh(win);

  // wait for some input
  while((ch = wgetch(win))) {
    // error? begin again.
    //if(ch == ERR) continue;

    // select the first menu entry if enter is pressed
    if(ch == '\n') ch = '1';
    // a number pressed?
    if(ch >= '0' && ch <= '9') {
      number = ch - '0';
      // prevent from handling numbers which are > than the number of menu entries
      if(ch - '0' <= lines) {
        // get out of the loop
        break;
      }
    }
  }

  // delete the window
  delwin(win);

  // return the number pressed
  return number;
}


// displays the main menu
int display_menu() 
{
  // the contents of the menu
  // %i will be replaced with the number of the menu entry
  char menu[][CONTENT_WIDTH] = 
  {
  "%i) Start the game",
  "%i) Highscores",
  "%i) Controls",
  "%i) Help",
  "%i) Clear Highscores",
  "%i) Exit"
  };
  // create a numbered dialog
  return create_numbered_dialog("MENU", (char *)menu, 6);
}


void main_menu() 
{
  int selected_menu_entry;
  do {
    selected_menu_entry = display_menu();
    if(selected_menu_entry == 1) {
      // run the game
      //run();
    } else if(selected_menu_entry == 2) {
      // display the highscores
      //show_highscores();
    } else if(selected_menu_entry == 3) {
      // display a dialog which explains the controls of the game
      //display_controls();
    } else if(selected_menu_entry == 4) {
      // display a dialog which explains the elements of the game
      //display_help();
    } else if(selected_menu_entry == 5) {
      // clear highscores
#if 0
      if(clear_score_dialog() == 1) 
      {
          clear_highscore();
      }
#endif
    }
    // leave if the menu entry "exit" is chosen
  } while(selected_menu_entry != 6);
}

#if 0
void enable_kbd_signals(void)
{

	int fd_flags;

	fcntl(0,F_SETOWN,getpid());
	fd_flags = fcntl(0,F_GETFL);

	fcntl(0,F_SETFL,(fd_flags|O_ASYNC));
	//fcntl(0,F_SETFL,(fd_flags|O_RSYNC));

}
#endif


struct aiocb  kbcbuf;
void setup_aio_buffer(void)
{

	static char input[1];

	kbcbuf.aio_fildes = 0;
	kbcbuf.aio_buf = input;
	kbcbuf.aio_nbytes = 1;
	kbcbuf.aio_offset = 0;


	kbcbuf.aio_sigevent.sigev_notify = SIGEV_SIGNAL;
	kbcbuf.aio_sigevent.sigev_signo = SIGIO;
	


}

void on_input(int signum)
{
#if 0
	int c = getch();
	move(15,15);
	addch(c);

#endif

	int c;
	char *cp = (char*)kbcbuf.aio_buf;/*cast to char*/

	if(aio_error(&kbcbuf) != 0)
	{
		perror("reading failed");
	}
	else
	{
		if(aio_return(&kbcbuf) == 1)
		{
			c=*cp;

			move(15,15);
			addch(c);
			refresh();

			if(c == 'q')
			{
				endwin();	
				printf("that is it\n");
				exit(EXIT_SUCCESS);

			}

		}

		aio_read(&kbcbuf);

	}

}


void init_curses() 
{

#if _BSD_SOURCE || _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600
  // by default, ncurses stops the execution of the program for
  // 1 second if escape is pressed. Disable this behaviour.
  setenv("ESCDELAY", "0", 1);
#endif
  
  initscr();
  // get more control over the input
  cbreak();
  // getch() returns ERR if no input is present and doesn't wait
  //nodelay(stdscr, TRUE);
  // don't echo the inserted keys to the screen
  noecho();
  // colors!
  start_color();
  set_colors();
  // also grab keys like F1 etc.
  keypad(stdscr, TRUE);

}


int main(int argc, char* argv[])
{    
	int sockfd; 
	char hname[128]={0};
	char buffer[MAXLINE]; 
	char *hello = "Hello from server"; 
	struct sockaddr_in servaddr, cliaddr; 
	struct hostent *hent=NULL;

	gethostname(hname,sizeof(hname));
	hent = gethostbyname(hname);

	if ( (sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0 )
	{ 
		perror("socket creation failed"); 
		exit(EXIT_FAILURE); 
	} 

	memset(&servaddr, 0, sizeof(servaddr)); 
	memset(&cliaddr, 0, sizeof(cliaddr)); 
	// Filling server information 
	servaddr.sin_family    = AF_INET; // IPv4 
	//servaddr.sin_addr.s_addr = htonl(INADDR_ANY); 
	servaddr.sin_addr.s_addr = INADDR_ANY; 
	servaddr.sin_port = htons(PORT); 
	//servaddr.sin_port = PORT; 

	// Bind the socket with the server address 
	if ( bind(sockfd, (const struct sockaddr *)&servaddr,  
				sizeof(servaddr)) < 0 ) 
	{ 
		perror("bind failed"); 
		exit(EXIT_FAILURE); 
	} 

	int len, n; 
	len = sizeof(cliaddr);  //len is value/resuslt 



	WINDOW *xw;
	void on_input(int);
	signal(SIGIO,on_input);
	//enable_kbd_signals();

	setup_aio_buffer();
	aio_read(&kbcbuf);

	init_curses();

	while(1)
	{
		//pause();
		move(20,25);
		//printf("waiting on port %d\n",PORT);
		printw("waiting on port %d\n",PORT);
		refresh();
#if 0
		n = recvfrom(sockfd, (char *)buffer, MAXLINE,  
				MSG_WAITALL, ( struct sockaddr *) &cliaddr, 
				&len); 
#endif
		n = recvfrom(sockfd, (char *)buffer, MAXLINE,  
				0, ( struct sockaddr *) &cliaddr, 
				&len); 


		buffer[n] = '\0'; 
		//printf("Client : %s\n", buffer); 
		move(25,25);
		printw("Client : %s\n", buffer); 
		refresh();

		//sleep(5);
	}
	//	main_menu(); 
	//	xw=create_dialog_window("hello"); 
	//	wrefresh(xw);
	//	refresh();

	//	sleep(4);
	end_curses();
}