root/lang/c/friendsd/shm.c @ 32953

#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <signal.h>

#define KEY_DEF ((key_t)7221)
#define INTERVAL 50000 /* by useconds */

extern int shmStat( void );
extern char *shmOpen( int size );
static int newShm( int key, int size );
extern int shmClose( void );
extern void shmWrite( void );
extern void shmRead( void );
extern void shmReset( void );
extern int getShmVersion( void );
extern int setShmDebug( int mode );
extern int getShmDebug( void );
extern int setShmOwner( int new_id );
extern int getShmOwner( void );

static int id = -1;

struct FLAGS {
  int write;
  int wait;
  int read;
  int version;
  int debug;
  int ownerID;
};
static volatile struct FLAGS *flags;

int shmStat( void ) {
  struct shmid_ds buf;
  
  if( shmctl( id, IPC_STAT, &buf ) ) {
    fprintf( stderr, "Couldn't obtain shm data.\n" );
    fflush( stderr );
    return( 1 );
  }
  fprintf( stderr, "       SHM Connection: %d.\n", buf.shm_nattch );
  fflush( stderr );
  return( 0 );
}

char *shmOpen( int size ) {
  int x;
  char *r;
  
  if( size ) {
    for( x = 0; x < 10; x++ )
      if( EOF != ( id = newShm( KEY_DEF + x, size ) ) )
        goto ON_SUCCEED;
    goto ON_ERROR;
  } else
    goto ON_SUCCEED;
 ON_SUCCEED:
  if( -1 == ( int )( flags = ( struct FLAGS * )shmat( id, ( char * )NULL, 0 ) ) ) {
    fprintf( stderr, "Couldn't allocate shared memory.\n" );
    return( NULL );
  }
  if( getShmDebug() )
    shmStat();
  return( ( ( char * )flags ) + sizeof( struct FLAGS ) );
 ON_ERROR:
  return( NULL );
}

int newShm( int key, int size ) {
  int r;
  struct FLAGS *tmpflags;
  size += sizeof( struct FLAGS );
  if( EOF == ( r = shmget( key, size, IPC_CREAT | IPC_EXCL | 0660 ) ) )
    return( EOF );
  
  tmpflags = ( struct FLAGS * )shmat( r, ( char * )NULL, 0 );
  tmpflags->write = 0;
  tmpflags->read = 0;
  tmpflags->wait = 0;
  tmpflags->version = 0;
  tmpflags->debug = 0;
  tmpflags->ownerID = getpid();
  shmdt( tmpflags );
  return( r );
}

int shmClose() {
  struct shmid_ds d;
  int ret, f;
  
  if( getShmDebug() ) {
    fprintf( stderr, "        shmClose()\n" );
    fflush( stderr );
  }
  if( getpid() == flags->ownerID )
    return( shmctl( id, IPC_RMID, &d ) );
  else {
    f = getShmDebug(); /* done because shm is going to be removed */
    ret = shmdt( flags );
    if( f )
      shmStat();
    return( ret );
  }
}

void shmEnter( char *mode ) {
  int waitTime;
  
  if( !strcmp( mode, "w" ) ) {
    flags->wait++;
    for( waitTime = 0; ; waitTime++ ) {
      if( !flags->write && !flags->read )
        break;
      usleep( INTERVAL );
    }
    flags->write++;
  } else {
    for( waitTime = 0; ; waitTime++ ) {
      if( !flags->wait )
        break;
      usleep( INTERVAL );
    }
    flags->read++;
  }
  if( getShmDebug() ) {
    fprintf( stderr, "        shmEnter( \"%s\" ): %d:%d:%d(w:r:wait)\n", mode, flags->write, flags->read, waitTime );
    fflush( stderr );
  }
}

void shmLeave( char *mode ) {
  if( !strcmp( mode, "w" ) ) {
    flags->write = 0;
    flags->wait--;
    flags->version++;
  } else
    flags->read--;
  if( getShmDebug() ) {
    fprintf( stderr, "        shmLeave( \"%s\" ): %d:%d(w:r)\n", mode, flags->write, flags->read );
    fflush( stderr );
  }
}

int getShmVersion() {
  return( flags->version );
}

int setShmDebug( int mode ) {
  flags->debug = mode;
  return( flags->debug );
}

int getShmDebug() {
  return( flags->debug );
}

int setShmOwner( int new_id ) {
  int ret = flags->ownerID;
  flags->ownerID = new_id;
  return( ret );
}

int getShmOwner() {
  return( flags->ownerID );
}