Search  

---

C:/temp/src/j2k/nto/bakJuly/cs3.cpp

Go to the documentation of this file.

#ifndef __J2K__CS_CPP__
#define __J2K__CS_CPP__

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <pthread.h>
#include <sys/neutrino.h>
#include <sys/dispatch.h>
#include <sync.h>
#include <time.h>

#include <j2k/nto/Basic_PThread.hpp>
#include <j2k/nto/Basic_PThread.cpp>
#include <j2k/nto/Message.hpp>
#include <j2k/nto/Message.cpp>
#include <j2k/nto/NameSpace.hpp>
#include <j2k/nto/NameSpace.cpp>

pthread_barrier_t barrier;
pthread_barrier_t barrier2;

#define ATTACH_POINT "myname"

NameSpace n;

/* We specify the header as being at least a pulse */
typedef struct _pulse msg_header_t;

/* Our real data comes after the header */
typedef struct _my_data 
{
  msg_header_t hdr;
  int data;
} my_data_t;

class Server : public Basic_PThread
{
public:
  Server() : Basic_PThread() { }
  virtual ~Server() { }

/*** Server Side of the code ***/
virtual void run()
{
  printf( "Server started \n" );

  name_attach_t *attach;
  my_data_t msg;
  int rcvid;

  /* Create a local name (/dev/name/local/...) */
  if ((attach = name_attach(NULL, ATTACH_POINT, 0)) == NULL) 
  {
    exit( EXIT_FAILURE );
  }

  printf( "Server attached \n" );

  pthread_barrier_wait( &barrier  );

  /* Do your MsgReceive's here now with the chid */
  while( 1 ) 
  {
    rcvid = MsgReceive(attach->chid, &msg, sizeof(msg), NULL);

    if (rcvid == -1) /* Error condition, exit */
    {
      break;
    }

    if (rcvid == 0) /* Pulse received */
    {
      switch (msg.hdr.code) 
      {
      case _PULSE_CODE_DISCONNECT:
        /*
         * A client disconnected all its connections (called
         * name_close() for each name_open() of our name) or
         * terminated
         */
        ConnectDetach(msg.hdr.scoid);
        break;
      case _PULSE_CODE_UNBLOCK:
        /*
         * REPLY blocked client wants to unblock (was hit by
         * a signal or timed out).  It's up to you if you
         * reply now or later.
         */
        break;
      default:
        /*
         * A pulse sent by one of your processes or a
         * _PULSE_CODE_COIDDEATH or _PULSE_CODE_THREADDEATH 
         * from the kernel?
         */
         break;
      }
      continue;
    }

    /* A QNX IO message received, reject */
    if (msg.hdr.type >= _IO_BASE && msg.hdr.type <= _IO_MAX) 
    {
      MsgError(rcvid, ENOSYS);
      continue;
    }

    /* A message (presumable ours) received, handle */
    printf("Server receive %d \n", msg.data);
    MsgReply(rcvid, EOK, 0, 0);

  }

  /* Remove the name from the space */
  name_detach(attach, 0);

//  pthread_barrier_wait( &barrier2 );
}

};

/*** Client Side of the code ***/
class Client : public Basic_PThread
{
public:
  Client() : Basic_PThread() { }
  virtual ~Client() { }

/*** Server Side of the code ***/
virtual void run()
{
  printf( "Client started \n" );
  my_data_t msg;
  int fd;

  if ((fd = name_open(ATTACH_POINT, 0)) == -1) {
    exit( EXIT_FAILURE );
  }

  printf( "Client opened a connection \n" );

  /* We would have pre-defined data to stuff here */
  msg.hdr.type  = 0x00;
  msg.hdr.subtype = 0x00;

  /* Do whatever work you wanted with server connection */
  for (msg.data=0; msg.data < 5; msg.data++) 
  {
    printf("Client sending %d \n", msg.data);

    if (MsgSend(fd, &msg, sizeof(msg), NULL, 0) == -1) 
    {
      break;
    }
  }

  printf( "Client closed the connection \n" );
  /* Close the connection */
  name_close(fd);

  pthread_barrier_wait( &barrier2 );

  printf( "Client Done \n" );
}

};

int main( int argc, char **argv ) 
{
  pthread_barrier_init( &barrier,  NULL, 2 );
  pthread_barrier_init( &barrier2, NULL, 2 );
 
  Server s;
  Client c;

  s.start();

  pthread_barrier_wait( &barrier );

  c.start();

  pthread_join( c.getPID(), NULL );

  pthread_barrier_wait( &barrier2 );

  printf( "Main Done \n" );

  // Shut down the READ-blocked server
  pthread_kill( s.getPID(), SIGKILL );

  return 0;
}

#endif

---