ngcbSHMDB.hpp

Go to the documentation of this file.

#ifndef ngcbSHMDB_H
#define ngcbSHMDB_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/shm.h>
#include <sys/sem.h>

#ifndef str2str
inline char *__str2str(char *s1, const char *s2, size_t n) 
{
  size_t size = strlen(s2);
  if (n > size) n = size;
  memcpy(s1, s2, n);
  s1[n] = '\0'; 
  return (s1);
}
#define str2str(s1, s2, n) __str2str(s1, s2, n)
#endif

typedef union
{
  int val;
  struct semid_ds *buf;
  unsigned short *array;
} ngcbSEM_CTL;

class ngcbSHMDB {
public:
  void *shmBuf;

  ngcbSHMDB(const char *app, const char *s, void *initBuffer = NULL, 
        size_t size = 0) {
 
    /*
     * Initialize member data
     */
    Init_();
 
    /*
     * Check size and appclication name
     */
    if ((size == 0) && (initBuffer != NULL))
      {
      strcpy(ErrMsg(), "invalid database size");
      return;      
      }
    else if (app == NULL)
      {
      strcpy(ErrMsg(), "invalid application name");
      return;
      }
    else if (s == NULL)
      {
      strcpy(ErrMsg(), "invalid key (NULL)");
      return;
      }
    else if (strlen(s) == 0)
      {
      strcpy(ErrMsg(), "invalid key");
      return;
      }
    else
      {
      /*
       * We need a key-file for this instance
       */
      if (initBuffer != NULL)
    {
    /*
     * We always create the key-file and delete it at the end
     */
    if (strncmp(s, "pub_", 4) == 0)
      {
      /*
       * Generate a public key
       */
      if (strlen(s) == 4)
        {
        strcpy(ErrMsg(), "invalid key");
        return;
        }
      else
        {
        snprintf(name_, sizeof(name_), "/tmp/%s_%s", app, s);
        fd_ = open(name_, O_RDWR|O_CREAT|O_TRUNC, 0666);
        }
      }
    else
      {
      /*
       * Generate a private key
       */
      snprintf(name_, sizeof(name_), "/tmp/%s_%u_%s", app, getuid(), s);
      fd_ = open(name_, O_RDWR|O_CREAT|O_TRUNC, 0600);
      }
    if (fd_ < 0)
      {
      name_[0] = 0;
      sprintf(ErrMsg(), "invalid key - %s", strerror(errno));
      return;
      }
    else
      {
      delKey_ = 1;
      }
    }
      else
    {
    /*
     * Check if key-file is there
     */
    snprintf(name_, sizeof(name_), "/tmp/%s_%u_%s", app, getuid(), s);
    fd_ = open(name_, O_RDONLY, 0);
    if (fd_ < 0)
      {
      /*
       * Try with full qualified key
       */
      snprintf(name_, sizeof(name_), "/tmp/%s_%s", app, s);
      fd_ = open(name_, O_RDONLY, 0);
      if (fd_ < 0)
        {
        /*
         * Try with public key
         */
        snprintf(name_, sizeof(name_), "/tmp/%s_pub_%s", app, s);
        fd_ = open(name_, O_RDONLY, 0);
        if (fd_ < 0)
          {
          /*
           * Key-file is not there - we try to create one but then
           * we also have to delete it at the end
           */
          if (strncmp(s, "pub_", 4) == 0)
        {
        /*
         * Generate a public key
         */
        if (strlen(s) == 4)
          {
          strcpy(ErrMsg(), "invalid key");
          return;
          }
        else
          {
          snprintf(name_, sizeof(name_), "/tmp/%s_%s", app, s);
          fd_ = open(name_, O_RDWR|O_CREAT|O_TRUNC, 0666);
          }
        }
          else
        {
        /*
         * Generate a private key
         */
        snprintf(name_, sizeof(name_), "/tmp/%s_%u_%s", app, getuid(), s);
        fd_ = open(name_, O_RDWR|O_CREAT|O_TRUNC, 0600);
        }
          if (fd_ < 0)
        {
        name_[0] = 0;
        sprintf(ErrMsg(), "invalid key - %s", strerror(errno));
        return;
        }
          else
        {
        delKey_ = 1;
        }
          }
        }
      }
    }
 
      /*
       * Get the actual key for this instance
       */
      key_ = ftok(name_, 0x1f);
      if (key_ == static_cast<key_t>(-1))
    {
    sprintf(ErrMsg(), "cannot get key - %s", strerror(errno));
    close(fd_); fd_ = -1;
    return;
    }
 
      if ((initBuffer == NULL) && (fd_ >= 0))
    {
    /*
     * There is no need to keep the key-file open (e.g. to protect it
     * against deletion by tmpwatch cron)
     */
    close(fd_); fd_ = -1;
    }
      }
 
    if (initBuffer != NULL)
      {
      /*
       * Create database
       */
      if (Create_(initBuffer, size) != 0) return;
      server_ = 1;
      }
    else
      {
      /*
       * Attach to database
       */
      if (Attach_(size) != 0) return;
      server_ = 0;
      }
 
    initialized_ = 1;
  }

  virtual ~ngcbSHMDB() {
    if (server_)
      {
      /*
       * Remove database
       */
      Remove_();
      }
    else
      {
      /*
       * Detach from database
       */
      Detach_();
      }
 
    /*
     * Close key-file
     */
    if (fd_ >= 0) close(fd_);
    
    /*
     * Remove the IPC-key file
     */
    if (delKey_ && (strlen(name_) > 0)) remove(name_);
  }

  int Initialized() {return (initialized_);}
  
  char *ErrMsg() {return (erms_);}

  int Lock() {
    if (sem_ >= 0)
      {
      if (semop(sem_, semOpLock_, 2) != 0)
    {
    if (errno == EINTR)
      {
      while (semop(sem_, semOpLock_, 2) != 0)
        {
        if (errno != EINTR)
          {
          if (errno == EIDRM) sem_ = -1;  // removed (and unlocked)
          sprintf(ErrMsg(), "cannot lock semaphore - %s", strerror(errno));
          return (-1);
          }
        }
      }
    else
      {
      if (errno == EIDRM)
        {
        /*
         * Semaphore has been removed (and unlocked)
         */
        sem_ = -1;
        }
      sprintf(ErrMsg(), "cannot lock semaphore - %s", strerror(errno));
      return (-1);
      }
    }
      }
    else
      {
      strcpy(ErrMsg(), "invalid semaphore");
      return (-1);
      }
    
    return (0);
  }

  void Unlock() {
    if (sem_ >= 0)
      {
      if (semop(sem_, semOpUnlock_, 1) != 0)
    {
    if (errno == EIDRM) sem_ = -1;  // removed (and unlocked)
    }
      }
  }

  int Set(const void *buffer) {
    if (Lock() < 0)
      {
      return (-1);
      }
 
    if (shmBuf != NULL)
      {
      if (buffer != NULL) memcpy(shmBuf, buffer, size_);
      else memset(shmBuf, 0, size_);
      }
 
    Unlock();
 
    return (0);
  }
  
  int Get(void *buffer) {
    if (buffer != NULL)
      {
      if (Lock() < 0)
    {
    return (-1);
    }
 
      if (shmBuf != NULL) memcpy(buffer, shmBuf, size_);
      else memset(buffer, 0, size_);
 
      Unlock();
      }
 
    return (0);
  }
  
  int ShmId() {return (shmId_);}

  size_t Size() {return (size_);}

  int SemId() {return (sem_);}

  int Key() {return (key_);}

  const char *KeyFile() {return (name_);}

  void Remove() {Remove_();}
 
protected: 
  void Initialized(int flag) {initialized_ = flag;}
 
private:
  char erms_[256];

  int initialized_;         

  char name_[320];

  key_t key_;

  int delKey_;

  int fd_;

  int shmId_;

  size_t size_;

  int sem_;

  int server_;

  struct sembuf semOpLock_[2];

  struct sembuf semOpUnlock_[1];

  void Init_() {
    initialized_ = 0;
    name_[0] = '\0';
    erms_[0] = '\0';
    key_ = (key_t)-1;
    fd_ = -1;
    delKey_ = 0;
    shmId_ = -1;
    size_ = 0;
    shmBuf = NULL;
    sem_ = -1;
    server_ = 0;
 
    /*
     * Semaphore operation: 
     * - lock semaphore
     */
    memset(&semOpLock_[0], 0, sizeof(struct sembuf));
    memset(&semOpLock_[1], 0, sizeof(struct sembuf));
    semOpLock_[1].sem_num = 0;
    semOpLock_[1].sem_op = 1;
    semOpLock_[1].sem_flg = SEM_UNDO;
 
    /*
     * Semaphore operation: 
     * - unlock semaphore
     */
    memset(&semOpUnlock_[0], 0, sizeof(struct sembuf));
    semOpUnlock_[0].sem_num = 0;
    semOpUnlock_[0].sem_op = -1;
    semOpUnlock_[0].sem_flg = IPC_NOWAIT|SEM_UNDO;
  }

  void SemRemove_() {
    if (sem_ >= 0)
      {
      ngcbSEM_CTL ctl;
      ctl.val = 0;
      semctl(sem_, 0, IPC_RMID, ctl); sem_ = -1;
      }
  }

  int Create_(void *initBuffer, size_t size) {
    ngcbSEM_CTL ctl;
    int tmp;
 
    /*
     * Check size
     */
    if (size == 0)
      {
      strcpy(ErrMsg(), "invalid size");
      return (-1);
      }
 
    /*
     * Check if we have a valid key
     */
    if (key_ == (key_t)-1)
      {
      strcpy(ErrMsg(), "invalid key");
      return (-1);
      }
 
    /*
     * Ensure that the protection semaphore does not yet exist
     */
    tmp = semget(key_, 0, 0666);
    if (tmp >= 0)
      {
      /*
       * Remove the semaphore
       */
      ctl.val = 0;
      semctl(tmp, 0, IPC_RMID, ctl);      
      }
 
    /*
     * Ensure that the shared memory does not yet exist
     */
    shmId_ = shmget(key_, 0, 0666);
    if (shmId_ != -1)
      {
      /*
       * Remove existing shared memory region
       */
      shmctl(shmId_, IPC_RMID, 0); shmId_ = -1;
      }
 
    /*
     * Get protection semaphore
     */
    sem_ = semget(key_, 1, 0666|IPC_CREAT|IPC_EXCL);
    if (sem_ == -1)
      {
      sprintf(ErrMsg(), "error creating semaphore - %s", strerror(errno));
      return (-1);
      }
 
    /*
     * Initialize the semaphore
     */
    ctl.val = 0;
    if (semctl(sem_, 0, SETVAL, ctl) == -1)
      {
      sprintf(ErrMsg(), "semaphore error - %s", strerror(errno));
      
      /*
       * Delete the semaphore again
       */ 
      SemRemove_();
      
      return (-1);
      }
    
    if (Lock() == 0)
      {
      /*
       * Create a new shared memory region
       */
      shmId_ = shmget(key_, size, 0666|IPC_CREAT|IPC_EXCL);
      if (shmId_ == -1)
    {
    sprintf(ErrMsg(), "error creating shared memory - %s", 
        strerror(errno));
    Unlock();
    SemRemove_();
    return (-1);
    }
      
      /*
       * Attach to the shared memory
       */
      shmBuf = shmat(shmId_, 0, 0);
      if (shmBuf == (void *)-1)
    {
    sprintf(ErrMsg(), "cannot attach to shared memory - %s", 
        strerror(errno));
    shmctl(shmId_, IPC_RMID, 0); shmId_ = -1;
    shmBuf = NULL;
    Unlock();
    SemRemove_();
    return (-1);
    }
      
      /*
       * Initialize shared memory
       */
      memcpy(shmBuf, initBuffer, size);
      Unlock();
      }
    else
      {
      SemRemove_();
      return (-1);
      }
 
    size_ = size;
 
    return (0);
  }

  int Attach_(size_t size) {
    /*
     * Check if we have a valid key
     */
    if (key_ == (key_t)-1)
      {
      strcpy(ErrMsg(), "invalid key");
      return (-1);
      }
 
    /*
     * Get shared memory region
     */
    shmId_ = shmget(key_, size, 0666);
    if (shmId_ == -1)
      {
      sprintf(ErrMsg(), "cannot access shared memory - %s", strerror(errno));
      return (-1);
      }
 
    if (size == 0)
      {
      struct shmid_ds ds;
 
      /*
       * Retrieve shared memory segment size
       */
      if (shmctl(shmId_, IPC_STAT, &ds) == -1)
    {
    sprintf(ErrMsg(), "cannot get shared memory size - %s", 
        strerror(errno));
    return (-1);
    }
      size = ds.shm_segsz;
      if (size == 0)
    {
    strcpy(ErrMsg(), "invalid shared memory segment size");
    return (-1);
    }
      }
 
    /*
     * Attach to the shared memory
     */
    shmBuf = shmat(shmId_, 0, 0);
    if (shmBuf == (void *)-1)
      {
      sprintf(ErrMsg(), "error attaching to shared memory - %s", 
          strerror(errno));
      return (-1);
      }
    
    /*
     * Get protection semaphore
     */
    sem_ = semget(key_, 1, 0666);
    if (sem_ == -1)
      {
      sprintf(ErrMsg(), "cannot get semaphore - %s", strerror(errno));
      shmdt(shmBuf); shmBuf = NULL;
      return (-1);
      }
 
    size_ = size;
    return (0);
  }

  void Remove_() {
    /*
     * Remove event semaphore set
     */
    SemRemove_();
    
    if (shmId_ != -1)
      {
      if (shmBuf != NULL)
    {
    /*
     * Detach from shared memory
     */ 
    shmdt(shmBuf); shmBuf = NULL;
    }
      
      /*
       * Delete the shared memory
       */ 
      shmctl(shmId_, IPC_RMID, 0); shmId_ = -1;
      }
    
    /*
     * Database can no longer be used
     */
    initialized_ = 0;
  }
  
  void Detach_() {
    if (shmBuf != NULL)
      {
      /*
       * Detach from shared memory
       */
      shmdt(shmBuf); shmBuf = NULL;
      }
  }
};
 
#endif