Watching for a control chracter

I have writen a program that watches a port on the local machine and prints out the contents of each packet it receives to that port.
The main part of the program is in a function monitorLoop, a while loop usesa variable stayAlive to loop as shown below

Code:

---

int monitorLoop(void)
{
  //socket setup code
  while (stayAlive == 1)
        {
          //watch the port
        //print the data
        }
}

---

Wha i want to is to watch for an escape character that will shutdown the server insteas of having to use ^z. ( like telnet watches for ctrl ] ) n

Obviously i can't use a scanf or anything like that becuase the program would puase until it receives input, can anyone give me an idea on how to do this#?

using gcc on slackware 10

mtia

I have written into the server to watch for a special stop packet but would like to stop it locally aswell

Well once you've read the data from wherever you're reading it from - then use a for loop to examine each char in the buffer.

I must be missing something - this seems too obvious

but a ctrl X from the keyboard wouldn't go into the same buffer as the data from the port, unless im missing something really obvious

Oh, so you want to read from the network socket as well as from stdin, without blocking on either of them.

And if there is a ctrl-x on stdin, you want to go away and do some stuff.

Is that it?

curses can catch ctrl-x and ctrl-c etc. That's how VI does it.

You could also use signals and catch the ones masked with control c, but the ones that do not have signals associated with them, you could run select on stdin.

>>Is that it?
Yes - i want to watch for a ctrl X from the keyboard while constantly watching the port my server runs on. From the information above would curses or signals be more effective?

Well it goes something like this

Code:

---

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/select.h>
#include <termios.h>

void set_nonblock ( ) {
  struct termios newt;
  tcgetattr( 0, &newt );
  newt.c_lflag &= ~( ICANON | ECHO );
  tcsetattr( 0, TCSANOW, &newt );
}

int main ( ) {
    int status;

    set_nonblock();

    while ( 1 ) {
        int            max_fd = 0;    /* max fd to be watched - currently only stdin */
        fd_set          read_set;      /* file descriptors to watch */
        struct timeval  tmo;            /* timeout */

        FD_ZERO(&read_set);
        FD_SET(0,&read_set);            /* watch for changes on stdin */
        tmo.tv_sec = 1;
        tmo.tv_usec= 0;                /* wait for up to 1 second */

        status = select( max_fd+1, &read_set, 0, 0, &tmo );
        switch ( status ) {
            case -1:
                /* an error */
                perror( "select" );
                break;
            case 0:
                /* timeout */
                printf( "select timed out\n" );
                break;
            default:
                /* something worth doing - check each fd in each set */
                if ( FD_ISSET(0,&read_set) ) {
                    char ch;
                    int n = read( 0, &ch, sizeof(ch) );
                    printf( "Read char %c(%d)\n", ch, n );
                }
                break;
        }
    }

    return 0;
}

---

Add your socket fd's to the read_set and bump max_fd appropriately and add another FD_ISSET() test.

thank you salem :)