---

_shm.c

Go to the documentation of this file.

#include "rcs_defs.hh"
#include "_shm.h"
#include "rcs_prnt.hh"
#include "dbg_mem.h"            /* DEBUG_MALLOC, DEBUG_CALLOC, DEBUG_FREE */
/*
  _shm.c

  C implementation of rcslib shared memory API

  Modification history:

  30-Mar-1998  FMP added this comment
  */

#ifdef WIN32

#include <windows.h>

#ifndef NO_STDIO
#include <stdio.h>              //sprintf()
#endif

#ifdef UNDER_CE
#include "rcs_ce.h"
#endif

shm_t *
rcs_shm_open (key_t key, size_t size, int oflag, /* int mode */ ...)
{
  shm_t *shm;
  char name[64];
#ifdef UNICODE
  wchar_t wname[64];
#endif
#ifndef UNDER_CE
  SECURITY_ATTRIBUTES sa;
  SECURITY_DESCRIPTOR sd;
#endif

  rcs_print_debug (PRINT_SHARED_MEMORY_ACTIVITY,
                   "rcs_shm_open(key=%d(0x%X),size=%d(0x%X),oflag=%d)\n",
                   key, key, size, size, oflag);

  if (key < 1)
    {
      rcs_print_error ("rcs_shm_open(%d(0x%X), %d(0x%X), %d(0x%X)): error\n",
                       key, key, size, size, oflag, oflag);
      rcs_print_error ("RCS Shared Memory key may not be zero.\n");
      return NULL;
    }
#ifndef UNDER_CE
  if (FALSE ==
      InitializeSecurityDescriptor (&sd, SECURITY_DESCRIPTOR_REVISION))
    {
      rcs_print_error
        ("Can not initailize security descriptor.(Error = %d)\n",
         GetLastError ());
      return NULL;
    }
  sa.nLength = sizeof (SECURITY_ATTRIBUTES);
  sa.lpSecurityDescriptor = &sd;
  sa.bInheritHandle = TRUE;
#endif

#ifndef NO_STDIO
  sprintf (name, "shm%d", key);
#else
  strcpy (name, "shm");
  _itoa (key, name + 3, 10);
#endif


  shm = (shm_t *) DEBUG_MALLOC (sizeof (shm_t));
  if (NULL == shm)
    {
      rcs_print_error ("Out of memory.\n");
      return NULL;
    }
  memset (shm, 0, sizeof (shm_t));
  if (oflag)
    {
      shm->created = 1;
#ifdef UNDER_CE
#ifdef UNICODE
      RCS_CE_ASCII_TO_UNICODE (wname, name, 64);
      shm->hFileMap =
        CreateFileMapping ((HANDLE) (0xFFFFFFFF), NULL, PAGE_READWRITE, 0,
                           size, wname);
#else
      shm->hFileMap =
        CreateFileMapping ((HANDLE) (0xFFFFFFFF), NULL, PAGE_READWRITE, 0,
                           size, name);
#endif
#else
      shm->hFileMap =
        CreateFileMapping ((HANDLE) (0xFFFFFFFF), &sa, PAGE_READWRITE, 0,
                           size, name);
#endif
      if (NULL == shm->hFileMap)
        {
          rcs_print_error ("CreateFileMapping( failed!! (Error = %d)\n",
                           GetLastError ());
          DEBUG_FREE (shm);
          return NULL;
        }
      if ((shm->hFileMap != NULL) &&
          (GetLastError () == ERROR_ALREADY_EXISTS))
        {
          rcs_print_error ("File mapping name conflict, name = %s\n", name);;
          CloseHandle (shm->hFileMap);
          DEBUG_FREE (shm);
          return NULL;
        }
    }
  else
    {
#ifdef UNDER_CE
#ifdef UNICODE
      RCS_CE_ASCII_TO_UNICODE (wname, name, 64);
      shm->hFileMap =
        CreateFileMapping ((HANDLE) (0xFFFFFFFF), NULL, PAGE_READWRITE, 0,
                           size, wname);
#else
      shm->hFileMap =
        CreateFileMapping ((HANDLE) (0xFFFFFFFF), NULL, PAGE_READWRITE, 0,
                           size, name);
#endif
      if (NULL == shm->hFileMap)
        {
          rcs_print_error ("CreateFileMapping( failed!! (Error = %d)\n",
                           GetLastError ());
          DEBUG_FREE (shm);
          return NULL;
        }
#else
      shm->hFileMap = OpenFileMapping (FILE_MAP_ALL_ACCESS, TRUE, name);
      if (NULL == shm->hFileMap)
        {
          rcs_print_error ("OpenFileMapping failed!! (Error = %d)\n",
                           GetLastError ());
          DEBUG_FREE (shm);
          return NULL;
        }
#endif
    }

  shm->addr = MapViewOfFile (shm->hFileMap, FILE_MAP_ALL_ACCESS, 0, 0, size);
  if (NULL == shm->addr)
    {
      rcs_print_error ("MapViewOfFile failed!! (Error = %d)\n",
                       GetLastError ());
      CloseHandle (shm->hFileMap);
      DEBUG_FREE (shm);
      return NULL;
    }
  return shm;
}


int
rcs_shm_close (shm_t * shm)
{
  rcs_print_debug (PRINT_SHARED_MEMORY_ACTIVITY,
                   "rcs_shm_close(shm->key=%d(0x%X),shm->size=%d(0x%X),shm->addr=0x%X)\n",
                   shm->key, shm->key, shm->size, shm->size, shm->addr);

  if (shm != NULL)
    {
      if (shm->hFileMap != NULL)
        {
          UnmapViewOfFile (shm->addr);
          CloseHandle (shm->hFileMap);
          shm->addr = NULL;
          shm->hFileMap = NULL;
        }
    }
  return 0;
}

int
rcs_shm_delete (shm_t * shm)
{
  return rcs_shm_close (shm);
}



int
rcs_shm_nattch (shm_t * shm)
{
  // FIXME: I don't know how to get this number but it doesn't seem to
  // be neccessary since rcs_shm_delete and rcs_shm_close are identical
  // on this platform.
  return 1;
}






#else


#if defined (VXWORKS)

/* VxWorks shared memory */

#include <vxWorks.h>
#include <taskLib.h>

#ifndef NO_STDIO
#include <stdio.h>              /* stderr, etc */
#endif
#include <stdlib.h>             /* malloc, realloc, calloc, _itoa() */
#include "_table.h"


/* OS table of semaphore keys and sem_t's */
_RCS_TABLE rcs_shm_table;
int rcs_shm_table_inited = 0;
int task_lock_shm_stuff = 1;
int print_rcs_shm_warnings = 0;



/* shell debug functions */

void
rcs_shm_table_print ()
{
  if (!rcs_shm_table_inited)
    {
      printf ("RCS Shared Memory table NOT initialized.\n");
      return;
    }
  table_print (&rcs_shm_table);
  printf ("\t\tid\tkey\taddr\terrno\tsize\tcount\n");
}

void
rcs_shm_table_clear ()
{
  if (task_lock_shm_stuff)
    taskLock ();
  rcs_shm_table_inited = 0;
  table_clearall (&rcs_shm_table);
  if (task_lock_shm_stuff)
    taskUnlock ();
}

/* interface functions */

shm_t *
rcs_shm_open (key_t key, size_t size, int oflag, /* int mode */ ...)
{
  int tid = taskIdSelf ();
  shm_t *shm;

  rcs_print_debug (PRINT_SHARED_MEMORY_ACTIVITY,
                   "rcs_shm_open(key=%d(0x%X),size=%d(0x%X),oflag=%d)\n",
                   key, key, size, size, oflag);

  if (task_lock_shm_stuff)
    taskLock ();

  /* ignore mode-- we always run privileged.  oflag non-zero means
     create it; 0 means it must exist */
  if (key == 0)
    {
      if (task_lock_shm_stuff)
        taskUnlock ();
      rcs_print_error ("rcs_shm_open(%d(0x%X), %d(0x%X), %d(0x%X)): error\n",
                       key, key, size, size, oflag, oflag);
      rcs_print_error ("RCS Shared Memory key is zero.\n");
      return NULL;
    }

  /* get shared mem data structure */
  shm = (shm_t *) DEBUG_CALLOC (sizeof (shm_t), 1);
  shm->id = (int) key;
  shm->addr = NULL;
  shm->size = -1;
  shm->created = 0;

  /* fill in address by consulting table */
  if (oflag)
    {
      if (rcs_shm_table_inited)
        {
          if (table_get (&rcs_shm_table, key, shm) >= 0)
            {
              /* got the id already-- just copy out the address */
              if (shm->id != key)
                {
                  if (task_lock_shm_stuff)
                    taskUnlock ();
                  rcs_print_error
                    ("Shared Memory Key retrieved from table does not match. (%d) != (%d).\n",
                     key, shm->id);
                  return NULL;
                }
              if (shm->addr <= 0)
                {
                  if (task_lock_shm_stuff)
                    taskUnlock ();
                  return NULL;
                }
              shm->count++;
              table_add (&rcs_shm_table, key, shm);
              if (task_lock_shm_stuff)
                taskUnlock ();
              if (shm->size < size)
                {
                  rcs_print_error
                    ("This process(%d(0x%X)) was configured to create a shared memory area with key = (%d(0x%X)) and size=(%d(0x%X)\n",
                     tid, tid, key, key, size, size);
                  rcs_print_error
                    (" but a shared memory area with this key and a size of only (%d(0x%X)) already exists.",
                     shm->size, shm->size);
                  return NULL;
                }
              if (print_rcs_shm_warnings)
                {
                  rcs_print_error
                    ("Warning: This process(%d(0x%X)) was configured to create a shared memory area with key = (%d(0x%X)), and size=(%d(0x%X)\n",
                     tid, tid, key, key, size, size);
                  rcs_print_error
                    ("Warning: but a shared memory area with this key has already been created.\n");
                  rcs_print_error ("\n");
                }
              return shm;
            }
        }
      shm->addr = (void *) DEBUG_MALLOC (size);
      shm->size = size;
      shm->id = key;
      shm->count = 1;
      shm->created = 1;
      if (!rcs_shm_table_inited)
        {
          /* get a new table of rcs_shm_table_t's */
          table_new (&rcs_shm_table, sizeof (shm_t));
          rcs_shm_table_inited = 1;
        }
      table_add (&rcs_shm_table, key, shm);
    }
  else
    {
      /* it's connecting to created memory-- increment the reference count */
      if (!rcs_shm_table_inited)
        {
#if 0
          shm->addr = (void *) DEBUG_CALLOC (size, 1);
          shm->size = size;
          shm->count = 1;
          shm->id = key;
          if (!rcs_shm_table_inited)
            {
              /* get a new table of rcs_shm_t's */
              table_new (&rcs_shm_table, sizeof (shm_t));
              rcs_shm_table_inited = 1;
            }
          table_add (&rcs_shm_table, key, shm);
          if (task_lock_shm_stuff)
            taskUnlock ();

          if (print_rcs_shm_warnings)
            {
              rcs_print_error
                ("Warning: RCS Shared Memory Area table contains no entry for (%d(0x%X)), creating one.\n",
                 key, key);
            }
#endif
          shm->create_errno = ENOENT;
          return shm;
        }
      else
        {
          if (table_get (&rcs_shm_table, key, shm) < 0)
            {
#if 0
              shm->addr = (void *) DEBUG_CALLOC (size, 1);
              shm->size = size;
              shm->count = 1;
              shm->id = key;
              if (!rcs_shm_table_inited)
                {
                  /* get a new table of rcs_shm_t's */
                  table_new (&rcs_shm_table, sizeof (shm_t));
                  rcs_shm_table_inited = 1;
                }
              table_add (&rcs_shm_table, key, shm);
              if (task_lock_shm_stuff)
                taskUnlock ();

              if (print_rcs_shm_warnings)
                {
                  rcs_print_error
                    ("Warning: RCS Shared Memory Area table contains no entry for (%d(0x%X)), creating one.\n",
                     key, key);
                }
#endif
              shm->create_errno = ENOENT;
              return shm;
            }
          if (shm->id != key)
            {
              if (task_lock_shm_stuff)
                taskUnlock ();
              rcs_print_error
                ("Shared Memory Key retrieved from table does not match. (%d) != (%d).\n",
                 key, shm->id);
              return NULL;
            }
          if (shm->addr <= 0)
            {
              if (task_lock_shm_stuff)
                taskUnlock ();
              return NULL;
            }
          if (shm->size < size)
            {
              if (task_lock_shm_stuff)
                taskUnlock ();
              rcs_print_error
                ("This process(%d(0x%X)) was configured to connect a shared memory area with key = (%d(0x%X)) and size=(%d(0x%X)\n",
                 tid, tid, key, key, size, size);
              rcs_print_error
                (" but a shared memory area with this key and a size of only (%d(0x%X)) already exists.",
                 shm->size, shm->size);
              return NULL;
            }
          shm->count++;
          table_add (&rcs_shm_table, key, shm);
          /* got the id already-- just copy out the address */
        }
    }

  if (task_lock_shm_stuff)
    taskUnlock ();

  return shm;
}

int
rcs_shm_close (shm_t * shm)
{
  shm_t entry;

  rcs_print_debug (PRINT_SHARED_MEMORY_ACTIVITY,
                   "rcs_shm_close(shm->key=%d(0x%X),shm->size=%d(0x%X),shm->addr=0x%X)\n",
                   shm->key, shm->key, shm->size, shm->size, shm->addr);

  if (task_lock_shm_stuff)
    taskLock ();


  /* decrement the reference count, and if it's zero remove the
     shared mem */
  table_get (&rcs_shm_table, shm->id, &entry);
  entry.count--;
  if (entry.count == 0 && entry.addr != NULL)
    {
      DEBUG_FREE (entry.addr);
      entry.addr = NULL;
      shm->addr = NULL;
      table_clear (&rcs_shm_table, shm->id);
    }
  else
    {
      /* rewrite the entry to reflect decremented ref count */
      table_add (&rcs_shm_table, shm->id, &entry);
    }

  if (task_lock_shm_stuff)
    taskUnlock ();
  DEBUG_FREE (shm);
  return 0;
}

int
rcs_shm_delete (shm_t * shm)
{
  shm_t entry;

  if (task_lock_shm_stuff)
    taskLock ();

  /* decrement the reference count, and if it's zero remove the
     shared mem */
  table_get (&rcs_shm_table, shm->id, &entry);
  entry.count--;
  if (entry.addr != NULL)
    {
      DEBUG_FREE (entry.addr);
      entry.addr = NULL;
      shm->addr = NULL;
      table_clear (&rcs_shm_table, shm->id);
    }
  else
    {
      /* rewrite the entry to reflect decremented ref count */
      table_add (&rcs_shm_table, shm->id, &entry);
    }

  if (task_lock_shm_stuff)
    taskUnlock ();

  DEBUG_FREE (shm);
  return 0;
}

int
rcs_shm_nattch (shm_t * shm)
{
  shm_t entry;

  if (task_lock_shm_stuff)
    taskLock ();

  table_get (&rcs_shm_table, shm->id, &entry);
  shm->count = entry.count;
  if (task_lock_shm_stuff)
    taskUnlock ();
  return shm->count;
}

#else

/* Unix shared memory */

#ifndef NO_STDIO
#include <stdio.h>              /* NULL */
#endif

#ifdef linux_2_4
#include <linux/posix_types.h>
#endif

#include <stdlib.h>
#ifdef __CENTERLINE__
#define USING_VARARGS
#include <varargs.h>
#else
#include <stdarg.h>
#endif
#include <errno.h>
#include <stddef.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/ipc.h>
#if defined(qnx) && !defined(USE_POSIX_SHAREDMEM)
#define USE_POSIX_SHAREDMEM 1
#endif
#ifdef USE_POSIX_SHAREDMEM
#include <fcntl.h>
#include <sys/mman.h>
#else
#include <sys/shm.h>
#endif
#include <string.h>

static int shmems_created_list[100];
static int shmems_created_list_initialized = 0;

shm_t *
rcs_shm_open (key_t key, size_t size, int oflag, /* int mode */ ...)
{
  va_list ap;
  int mode;
  int shmflg = 0;
  shm_t *shm;
#ifdef USE_POSIX_SHAREDMEM
  int existed_before = 0;
  rcs_print_debug (PRINT_SHARED_MEMORY_ACTIVITY,
                   "rcs_shm_open(key=%d(0x%X),size=%d(0x%X),oflag=%d)\n",
                   key, key, size, size, oflag);

  if (key == 0)
    {
      rcs_print_error ("rcs_shm_open(%d(0x%X), %d(0x%X), %d(0x%X)): error\n",
                       key, key, size, size, oflag, oflag);
      rcs_print_error ("RCS Shared Memory key may not be zero.\n");
      return NULL;
    }

  shm = (shm_t *) DEBUG_CALLOC (sizeof (shm_t), 1);
  if (NULL == shm)
    {
      rcs_print_error ("rcs_shm_open: calloc failed\n");
      return NULL;
    }
  shm->create_errno = 0;
  shm->addr = NULL;
  shm->key = key;
  shm->size = size;
  sprintf (shm->name, "/rcs_shm%d", key);
  shm->id = 0;
  errno = 0;


#if defined(IPC_CREAT)
#if O_CREAT != IPC_CREAT
  if ((oflag & IPC_CREAT) && !(oflag & O_CREAT))
    {
      oflag &= ~(IPC_CREAT);
      oflag |= O_CREAT;
    }
#endif
#endif

  if ((oflag & O_CREAT))
    {
      shm->id = shm_open (shm->name, O_RDWR, mode);
      if (shm->id > 0)
        {
          shm->created = 0;
          existed_before = 1;
        }
    }

  /* Create a new memory object */
  if (shm->id <= 0)
    {
      shm->id = shm_open (shm->name, oflag | O_RDWR, mode);
      if (shm->id == -1)
        {
          rcs_print_error ("shm_open(%s,%d(0x%X),%d(0x%X)) failed:%s %d\n",
                           shm->name, oflag | O_RDWR, oflag | O_RDWR,
                           mode, mode, strerror (errno), errno);
          shm->create_errno = errno;
          return shm;
        }
      shm->created = 1;
      existed_before = 0;
    }

  /* Set the memory object's size */
  if (ftruncate (shm->id, size + 16) == -1)
    {
      rcs_print_error ("ftruncate(%d,%d): %s %d\n",
                       shm->id, size, strerror (errno), errno);
      shm->create_errno = errno;
      return shm;
    }

  /* Map the memory object */
  shm->addr = mmap (0, size + 16,
                    PROT_READ | PROT_WRITE, MAP_SHARED, shm->id, 0);
  if (shm->addr == MAP_FAILED)
    {
      rcs_print_error
        ("mmap(0,%d,PROT_READ | PROT_WRITE, MAP_SHARED,%d,0) failed: %s %d\n",
         shm->id, size, strerror (errno), errno);
      shm->create_errno = errno;
    }
  if (oflag & O_CREAT && !existed_before)
    {
      *((int *) ((char *) shm->addr + size)) = 0;
    }
  else
    {
      (*((int *) ((char *) shm->addr + size)))++;
    }

  return (shm);
#else

  struct shmid_ds shared_mem_info;
  int pid;
  int i;

  rcs_print_debug (PRINT_SHARED_MEMORY_ACTIVITY,
                   "rcs_shm_open(key=%d(0x%X),size=%d(0x%X),oflag=%d)\n",
                   key, key, size, size, oflag);

  if (key == 0)
    {
      rcs_print_error ("rcs_shm_open(%d(0x%X), %d(0x%X), %d(0x%X)): error\n",
                       key, key, size, size, oflag, oflag);
      rcs_print_error ("RCS Shared Memory key may not be zero.\n");
      return NULL;
    }

#if defined(O_CREAT)
#if O_CREAT != IPC_CREAT
  if ((oflag & O_CREAT) && !(oflag & IPC_CREAT))
    {
      oflag &= ~(O_CREAT);
      oflag |= IPC_CREAT;
    }
#endif
#endif

  if (oflag)
    {
      shmflg |= IPC_CREAT;
    }
  if (shmflg & IPC_CREAT)
    {
#ifdef USING_VARARGS
      va_start (ap);
#else
      va_start (ap, oflag);
#endif
      mode = va_arg (ap, int);
      shmflg |= mode;
    }

  shm = (shm_t *) DEBUG_CALLOC (sizeof (shm_t), 1);
  if (NULL == shm)
    {
      rcs_print_error ("rcs_shm_open: calloc failed\n");
      return NULL;
    }
  shm->create_errno = 0;
  shm->addr = NULL;
  shm->key = key;
  errno = 0;

  if ((shm->id = shmget (key, (int) size, shmflg)) == -1)
    {
      shm->create_errno = errno;
      rcs_print_error ("shmget(%d(0x%X),%d,%d) failed: (errno = %d): %s\n",
                       key, key, size, shmflg, errno, strerror (errno));
      switch (errno)
        {
        case EEXIST:
          rcs_print_error
            ("A shared memory buffer for this key already exists.\n");
          break;

        case EINVAL:
          rcs_print_error
            ("Either the size is too big or the shared memory buffer already exists but is of the wrong size.\n");
          break;

        case ENOSPC:
          rcs_print_error
            ("The system imposed limit on the maximum number of shared memory segments has been exceeded.\n");
          break;
        }
      return (shm);
    }

  /* map shmem area into local address space */
  shmflg = 0;
  shmflg &= ~SHM_RDONLY;
  if ((shm->addr = (void *) shmat (shm->id, 0, shmflg)) == (void *) -1)
    {
      shm->create_errno = errno;
      rcs_print_error ("shmat(%d,0,%d) failed:(errno = %d): %s\n", shm->id,
                       shmflg, errno, strerror (errno));
      rcs_print_error ("key = %d (0x%X)\n", key, key);
      shm->addr = NULL;
      return (shm);
    }

  /* Check to see if I am the creator of this shared memory buffer. */
  if (shmctl (shm->id, IPC_STAT, &shared_mem_info) < 0)
    {
      rcs_print_error ("shmctl error: %d %s\n", errno, strerror (errno));
      return shm;
    }

  /* If oflag was not set this process couldn't be the creator. */
  if (!oflag)
    {
      return shm;
    }

  if (!shmems_created_list_initialized)
    {
      memset (shmems_created_list, 0, 100 * sizeof (int));
      shmems_created_list_initialized = 1;
    }
  else
    {
      for (i = 0; i < 100; i++)
        {
          if (shmems_created_list[i] == key)
            {
              return shm;
            }
        }
    }

  pid = (int) getpid ();
  if (pid <= 0)
    {
      rcs_print_error ("getpid error: %d %s\n", errno, strerror (errno));
      return shm;
    }
  shm->created = (shared_mem_info.shm_cpid == pid);
#if defined(darwin) || defined(linux_2_4_0)
  shm->created = 1;
#endif

  if (shm->created)
    {
      for (i = 0; i < 100; i++)
        {
          if (shmems_created_list[i] <= 0)
            {
              shmems_created_list[i] = shm->key;
              break;
            }
        }
    }
  return shm;
#endif
}

int
rcs_shm_close (shm_t * shm)
{
#ifdef USE_POSIX_SHAREDMEM
  if (shm == 0)
    {
      return -1;
    }
  if (shm->addr > 0)
    {
      (*((int *) ((char *) shm->addr + shm->size)))--;
      if (munmap (shm->addr, shm->size + 16) == -1)
        {
          rcs_print_error ("munmap(%p,%d) failed. %s %d\n",
                           shm->addr, shm->size, strerror (errno), errno);
          return -1;
        }
      shm->addr = NULL;
      if (shm->id > 0)
        {
          if (close (shm->id) == -1)
            {
              rcs_print_error ("close(%d) failed. %s %d\n",
                               shm->id, strerror (errno), errno);
            }
        }
      shm->id = 0;
    }
#else
  struct shmid_ds shm_ds;       /* dummy */
  int i;

  /* check for invalid ptr */
  if (shm == NULL)
    return -1;

  rcs_print_debug (PRINT_SHARED_MEMORY_ACTIVITY,
                   "rcs_shm_close(shm->key=%d(0x%X),shm->size=%d(0x%X),shm->addr=0x%X)\n",
                   shm->key, shm->key, shm->size, shm->size, shm->addr);

  /* detach from shmem */
  shmdt ((char *) shm->addr);

  /* remove OS shmem if there are no attached processes */
  if (rcs_shm_nattch (shm) == 0)
    {
      shmctl (shm->id, IPC_RMID, &shm_ds);
    }

  if (shm->created && shmems_created_list_initialized)
    {
      for (i = 0; i < 100; i++)
        {
          if (shmems_created_list[i] == shm->key)
            {
              shmems_created_list[i] = 0;
              break;
            }
        }
    }

#endif

  /* DEBUG_FREE the shm_t data struct */
#ifdef sparcworks_sun4          /* free is defined as int free(char *) for this platform
                                   it should be void free(void *); */
  DEBUG_FREE ((char *) shm);
#else
  DEBUG_FREE (shm);
#endif

  return 0;
}

int
rcs_shm_delete (shm_t * shm)
{
#ifdef USE_POSIX_SHAREDMEM
  if (shm == 0)
    {
      return -1;
    }
  if (shm->addr > 0)
    {
      (*((int *) ((char *) shm->addr + shm->size)))--;
      if (munmap (shm->addr, shm->size + 16) == -1)
        {
          rcs_print_error ("munmap(%p,%d) failed. %s %d\n",
                           shm->addr, shm->size, strerror (errno), errno);
          return -1;
        }
      shm->addr = NULL;
      if (shm->id > 0)
        {
          if (close (shm->id) == -1)
            {
              rcs_print_error ("close(%d) failed. %s %d\n",
                               shm->id, strerror (errno), errno);
            }
        }
      shm->id = 0;
    }
  shm_unlink (shm->name);
#else
  struct shmid_ds shm_ds;       /* dummy */

  /* check for invalid ptr */
  if (shm == NULL)
    return -1;

  /* detach from shmem */
  shmdt ((char *) shm->addr);

  /* remove OS shmem regardless of whether there are attached processes */
  shmctl (shm->id, IPC_RMID, &shm_ds);
#endif

  /* DEBUG_FREE the shm_t data struct */
#ifdef sparcworks_sun4          /* free is defined as int free(char *) for this platform
                                   it should be void free(void *); */
  DEBUG_FREE ((char *) shm);
#else
  DEBUG_FREE (shm);
#endif

  return 0;
}

int
rcs_shm_nattch (shm_t * shm)
{
#ifdef USE_POSIX_SHAREDMEM
  if (shm == 0)
    {
      return -1;
    }
  if (shm->addr == 0)
    {
      return -1;
    }
  return *((int *) (((char *) shm->addr) + shm->size));
#else
  struct shmid_ds shm_ds;

  /* check for invalid ptr */
  if (shm == NULL)
    return -1;

  /* get the status of shared memory */
  shmctl (shm->id, IPC_STAT, &shm_ds);

  return shm_ds.shm_nattch;
#endif

}

#endif

#endif

---