Search  

---

C:/temp/src/j2k/QNX4/Timer1.c

Go to the documentation of this file.

/*

Example of a server that receives periodic messages from a timer,
and regular messages from a client.

Illustrates using the timer functions with a proxy.

*/

#include <j2k/Fred/Basic.hpp>
#include <j2k/Fred/System.hpp>
#include <j2k/Fred/Boolean.hpp>
#include <j2k/Fred/StdTypes.hpp>

#define  DEBUG_ON

// Message send definitions

#define MT_TIMER      1      // Message from timer
#define MT_WAIT_DATA  2      // Message from client
#define MT_SEND_DATA  3      // Message from client

// Message reply definitions
#define MT_OK         0      // Message to client
#define MT_TIME_OUT   1      // Message to client

// Message structure
typedef struct {
  int messageType;           // Contains both messages to and from client
  int messageData;           // Optional data, depending upon message
} MessageT;

// Client table
#define MAX_CLIENT    16     // Maximum number of simultaneous client

struct {
  int in_use;                // Is this client entry in use ?
  int pid;                   // Process ID of client
  int timeout;               // Timeout left for client
} clients [MAX_CLIENT];      // Client Table

char* progname = "time1.c";

// The server

int main() {
  int senderPID;             // Process ID of the sender
  int proxyPID;              // Process ID of the proxy
  MessageT msg;              // The message itself

  // Set up the proxy and timer
  proxyPID = setupProxyAndTimer();

  // Receive messages
  for(;;) {
    senderPID = Receive( 0, &msg, sizeof( msg ) );

    // Determine who the message came from
    if ( senderPID == proxyPID ) {
      fromProxy();
    } else {
      fromMessage( senderPID, &msg );
    }
  }

  // Shouldn't get here
  return ( EXIT_SUCCESS );
}

/*
 setupProxyAndTimer

 This routine is responsible for setting up a proxy so it
 sends a message of type MT_TIMER.  It then sets up a periodic timer
 that fires once per second.
*/

int setupProxyAndTimer() {
  pid_t    pid;              // Process ID for proxy
  timer_t  tid;              // Timer ID for timer
  struct sigevent    event;  // event to deliver
  struct itimerspec  timer;  // the timer data structure
  MessageT   proxy_message;  // message for proxy to deliver

  // Set up the canned proxy message
  proxy_message.messageType = MT_TIMER
  proxy_message.messageData = 0;

  pid = qnx_proxy_attach( 0, &proxy_message, sizeof( proxy_message), 10 );
  if (pid == -1) {
    fprintf( stderr,
             "%s: couldn't attach a proxy, errno %d \n",
             progname, errno );

    perror( NULL );
    exit( EXIT_FAILURE );
  }

  // Set up the kind of event that we want to deliver -- a proxy
  event.sigev_signo = -pid;

  // Create the timer, binding it to the event
  tid = timer_create( CLOCK_REALTIME, &event );
  if (tid == -1) {
    fprintf( stderr,
             "%s: couldn't create a timer, errno %d \n",
             progname, errno );

    perror( NULL );
    exit( EXIT_FAILURE );
  }

  // Start the timer ( 1 sec delay, 1 sec reload )
  timer.it_value.tv_sec  = 1;
  timer.it_value.tv_nsec = 0;

  timer.it_interval.tv_sec  = 1;
  timer.it_interval.tv_nsec = 0;

  timer_settime( tid, 0, &timer, NULL );

  // Return value from the function is the proxy PID
  return (pid);
}

/*

 fromProxy                      

 This rountine is responsible for handling the fact that a timeout
 has occurred. It runs through the list of clients to see which client
 has timed out, and replies to it with a timed out message.

*/

void fromProxy() {
  MessageT  msg;
  int i;

#ifdef  DEBUG_ON
   time_t now;
   time ( &now );
   printf( "Got a Proxy at %s", ctime( &now ) );
#endif

  // Prepare a response message
  msg.messageType = MT_TIME_OUT

  // Walk down list of clients
  for( i = 0; i < MAX_CLIENT; i++ ) {

    // Is this entry in use ?
    if ( clients[i].in_use ) {

      // Is it about to time out ?
      if (--client[i].timeout == 0) {
        // Send a reply
        Reply( clients[i].pid, &msg, sizeof( msg ) );

        // Entry no longer used
        clients[i].in_use = 0;
      }
    }
  }
}

/*

 fromMessage

 This routine is called whenever a message arrives.
 We look at the type of message (either a 'wait for data' message,
 or a 'here's some data' message), and act accordingly.

 For simplify, we'll assume that there is never any data waiting.
 See the text for more discussion about this.

*/

void fromMessage( int pid, MessageT*  msg ) {
  int i;

  // Determine the kind of message that it is
  switch( msg->messageType ) {

    // Client wants to wait for data
    case  MT_WAIT_DATA:

      // See if we can find a blank spot in the client table
      for( i = 0; i < MAX_CLIENT; i++ ) {
        if ( !clients[i].in_use ) {

          // Found one -- mark as in use, save pid, set timeout
          clients[i].in_use  = 1;
          clients[i].pid     = pid;
          clients[i].timeout = 5;
          return;
        }
      }

      fprintf( stderr,
         "%s: Table full, message from PID %d ignored, client blocked\n",
         pid );

      break;

      case  MT_SEND_DATA:

        // See if we can find another client
        // to reply to with this client's data.
        for( i = 0; i < MAX_CLIENT; i++ ) {
          if ( clients[i].in_use ) {
            // Found one -- reuse the incoming message as an outgoing message
            msg->message_type = MT_OK;

            // Reply to BOTH CLIENTS:
            Reply( clients[i].pid, msg, sizeof( *msg ) );
            Reply( pid, msg, sizeof( *msg ) );

            clients[i].in_use = 0;
            return;
          }
        }

      fprintf( stderr,
         "%s: Table empty, message from PID %d ignored, client blocked\n",
         pid );

      break;
  }
}

---