console22.txt

linux/kd.h文件中介绍了ioctl函数能够使用的命令

Example:
	/* ACS - Auto Console Switching                                    */
	/* What this does is allows you to specify VTs (virtual terminals, */
	/* also known as consoles) to watch. When it detects new data on   */
	/* this tty it will automatically switch.                          */
	/*								   */
	/* This allows you to do many things at once such as:              */
	/*   1.) IRC on one VT                                             */
	/*   2.) IRC on a different IRC network on another                 */
	/*   3.) wait for a web page to load up on another                 */
	/*   4.) wait for telnet to connect to a site on another           */
	/*								   */
        /* Compile with -DBEEPONLY to cause a beep on new activity, rather */
        /* than switching to the console with new activity.                */
	/*								   */
	/* So you can see the uses of this. Enjoy.                         */
	/* Shok (Matt Conover), [e-mail]                         */

	#include <stdio.h>
	#include <fcntl.h>
	#include <signal.h>
	#include <sys/stat.h>
	#include <linux/vt.h>
	#include <sys/ioctl.h>
	#include <sys/types.h>

	#define ERROR -1
	#define MAXVTNUM 63
          
	struct vcs {
	  int fd;
	  char curbuf[6666], prevbuf[6666];
	} vcs[MAXVTNUM];

	int fd;

	void clean(int val);
	void syntax(char **argv);
	void parse(int argc, char **argv);

	void sighandler(int signum);


	void main(int argc, char **argv)
	{
	  char buf[512];
	  register int i;
	  register int tty;
  
	  /* Initialization. */
	  bzero(buf, sizeof(buf));


	  for (i = 0 ; i < MAXVTNUM; i++) {
	     vcs[i].fd = -1, vcs[i].curbuf[0] = 0;

	     bzero(vcs[i].curbuf,  sizeof(vcs[i].curbuf));
	     bzero(vcs[i].prevbuf, sizeof(vcs[i].prevbuf));
	  }
	  /* --------------- */

	  printf("w00w00!\n");
	  parse(argc, argv); /* Take care of arguments (such as the VTs), */
	                     /* as well as open the files.                */

	  /* Turn into a daemon, exit the parent. */
	  if (fork() != 0) 
	     exit(0);

	  /* Need to switch to the active console. tty is what we pass */
	  /* to ioctl() with VT_ACTIVATE.                              */
	  if ((tty = open("/dev/tty", O_RDWR)) == ERROR) {
	     perror("open");
	     exit(ERROR);
	  }
 
	  /* Used so that when we receive a signal to abort, we close up */
	  /* all the open file descriptors, and give them a message that */
	  /* we are aborting. If this is run as a daemon, then you would */
	  /* have to send it with kill -2, -3 or -15.                    */
	  signal(SIGINT,  sighandler);  
	  signal(SIGTERM, sighandler);
	  signal(SIGQUIT, sighandler);

	  while (1)
	     for (i = 0; i < MAXVTNUM; i++) 
	        if (vcs[i].fd != -1) {

	           /* Copy the current buffer into the previous one, */
                   /* for later use.                                 */
	           strcpy(vcs[i].prevbuf, vcs[i].curbuf);

	           /* Get to the beginning of the screen. */
	           lseek(vcs[i].fd, 0, SEEK_SET); 

	           if ((read(vcs[i].fd, vcs[i].curbuf, sizeof(vcs[i].curbuf)))
			== ERROR) {
		      perror("read");
		      clean(ERROR);
	           }

	           /* Compare the buffer of the previous screen dumb with */
	           /* this one. If they are different, new data has been  */
	           /* received and we switch consoles.                    */

	           if ((strcmp(vcs[i].curbuf, vcs[i].prevbuf) != 0) 
                           && (vcs[i].prevbuf[0] != 0))
#                     ifdef BEEPONLY
	              ioctl(tty, VT_ACTIVATE, i+1);
#                     else
                      write(tty, '\a', 1);
#                     endif
	           usleep(500000);
	        } 
	}

	void parse(int argc, char **argv)
	{
	  int i;
	  char *p;
	  char buf[512], bfa[512];

	  if (argc < 2)
	     syntax(argv);

	  sprintf(buf,"Watching ");

	  for (argc--; argc; argc--) {
	     if (strcasecmp(argv[argc], "all") == 0) {
	        for (i = 0; i < MAXVTNUM; i++) {
	           sprintf(buf, "/dev/vcs%d", i+1);

	           vcs[i].fd = open(buf, O_RDONLY | O_NOCTTY);
                   if (vcs[i].fd == ERROR) {
	              perror("open");
	              clean(ERROR);
                   }
                }

	        printf("Watching all tty's...\n");
	        return;
	     }

	     if (strncasecmp(argv[argc], "tty", 3) != 0)
  	         syntax(argv);

	     strcat(buf, argv[argc]);
	     strcat(buf, " ");

	     p = (argv[argc]+3);

	     sprintf(bfa, "/dev/vcs%d", atoi(p));
	     vcs[atoi(p) - 1].fd = i = open(bfa, O_RDONLY | O_NOCTTY);

       	     if (vcs[atoi(p) - 1].fd == ERROR) {
		perror("open");
		clean(ERROR);
             }
          }

          buf[strlen(buf) - 1] = 0;

          strcat(buf, "...\n");
          printf(buf);
        }

	void syntax(char **argv)
	{
	  printf("Syntax: %s <all | tty2 tty3 ttyX ...>\n", argv[0]);
	  exit(ERROR);
	}

	void clean(int val)
	{
	  register int i;

	  for (i = 0; i < MAXVTNUM; i++)
	      if (vcs[i].fd != -1) close(vcs[i].fd);

	  close(fd);
	  exit(val);
	}

	void sighandler(int signum)
	{
	  char msg[] = "Received signal to abort. Now exiting.\n";

          close(fd);

          fd = open("/dev/tty", O_NOCTTY | O_WRONLY);
          if (fd == ERROR) {
	     printf(msg);
	     clean(signum);
          }

	  /* Give aborting message to current VT. */
	  write(fd, msg, sizeof(msg)); 

	  clean(signum);
	}