fast-stats 1.7

data/ext/stats/semaphore.c

@@ -0,0 +1,278 @@
+/* semaphore.c */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+#include "stats/error.h"
+#include "stats/semaphore.h"
+#include "stats/debug.h"
+
+int semaphore_create(const char *name, unsigned short size, struct semaphore **sem_out )
+{
+    struct semaphore * sem;
+    int err;
+
+    if (sem_out == NULL)
+        return ERROR_INVALID_PARAMETERS;
+
+    if (strlen(name) >= SEMAPHORE_MAX_NAME_LEN)
+        return ERROR_SEMAPHORE_NAME_TOO_LONG;
+
+    sem = malloc(sizeof(struct semaphore));
+    if (!sem)
+        return ERROR_MEMORY;
+
+    err = semaphore_init(sem,name,size);
+    if (err == S_OK)
+    {
+        *sem_out = sem;
+    }
+    else
+    {
+        free(sem);
+        *sem_out = NULL;
+    }
+
+    return err;
+}
+
+
+int semaphore_init(struct semaphore *sem, const char *name, unsigned short size)
+{
+    if (sem == NULL)
+        return ERROR_INVALID_PARAMETERS;
+
+    if (strlen(name) >= SEMAPHORE_MAX_NAME_LEN)
+        return ERROR_SEMAPHORE_NAME_TOO_LONG;
+
+    memset(sem, 0, sizeof(struct semaphore));
+
+    sem->magic = SEMAPHORE_MAGIC;
+    sem->semkey = -1;
+    sem->semid = -1;
+    sem->size = size;
+    strcpy(sem->name, name);
+
+    return S_OK;
+}
+
+
+int semaphore_open(struct semaphore * sem, int flags)
+{
+    struct stat s;
+    char path[MAX_PATH];
+    int mode;
+    int omode;
+
+    if (sem == NULL || sem->magic != SEMAPHORE_MAGIC)
+        return ERROR_INVALID_PARAMETERS;
+
+    /* extract open mode from flags */
+    omode = flags & OMODE_MASK;
+
+    /* check for existance of the directory */
+    if (stat(SEMAPHORE_DIRECTORY,&s) != 0)
+    {
+        /* try to create the directory */
+        if (mkdir(SEMAPHORE_DIRECTORY, 0755) != 0)
+            return ERROR_SEMAPHORE_CANNOT_CREATE_DIRECTORY;
+    }
+    else
+    {
+        if ((s.st_mode & S_IFDIR) != S_IFDIR)
+            return ERROR_SEMAPHORE_PATH_NOT_DIRECTORY;
+    }
+
+    sprintf(path, "%s/%s", SEMAPHORE_DIRECTORY, sem->name);
+
+    if (access(path, W_OK) == -1)
+    {
+        int fd = creat(path, 0644 );
+        if (fd == -1)
+            return ERROR_SEMAPHORE_CANNOT_CREATE_PATH;
+        close(fd);
+    }
+
+    sem->semkey = ftok(path, 1);
+    if (sem->semkey == -1)
+    {
+        return ERROR_SEMAPHORE_CANNOT_CREATE_IPC_TOKEN;
+    }
+
+    switch (omode)
+    {
+    case OMODE_CREATE:
+        mode = IPC_CREAT | IPC_EXCL | 0644;
+        break;
+    case OMODE_OPEN_OR_CREATE:
+        mode = IPC_CREAT | 0644;
+        break;
+    case OMODE_OPEN_EXISTING:
+    default:
+        mode = 0644;
+        break;
+    }
+
+    DPRINTF("Opening semaphore key %08x for %s (absolute path: %s), mode 0%o, size %d\n", sem->semkey, sem->name, path, mode, sem->size);
+
+    sem->semid = semget(sem->semkey, sem->size, mode) ;
+    if (sem->semid == -1)
+    {
+        if (errno == EEXIST && omode == OMODE_CREATE)
+            return ERROR_SEMAPHORE_ALREADY_EXISTS;
+        if (errno == ENOENT && omode == OMODE_OPEN_EXISTING)
+            return ERROR_SEMAPHORE_DOES_NOT_EXIST;
+        if (errno == EINVAL)
+            return ERROR_SEMAPHORE_INVALID_SIZE;
+        return ERROR_SEMAPHORE_CANNOT_OPEN;
+    }
+
+    DPRINTF("Successfylly openend semaphore %d (key 0x%08x) for %s.\n", sem->semid, sem->semkey, sem->name);
+
+    return S_OK;
+}
+
+int semaphore_set_value(struct semaphore *sem, unsigned short nsem, unsigned short value)
+{
+    union semun s;
+
+    if (sem == NULL || sem->magic != SEMAPHORE_MAGIC)
+        return ERROR_INVALID_PARAMETERS;
+
+    if (nsem >= sem->size)
+        return ERROR_INVALID_PARAMETERS;
+
+    s.val = value;
+
+    semctl(sem->semid, nsem, SETVAL, s);
+
+    return S_OK;
+}
+
+int semaphore_set_values(struct semaphore *sem, unsigned short *values)
+{
+    union semun s;
+
+    if (sem == NULL || sem->magic != SEMAPHORE_MAGIC)
+        return ERROR_INVALID_PARAMETERS;
+
+    s.array = values;
+
+    semctl(sem->semid, 0, SETALL, s);
+
+    return S_OK;
+}
+
+int semaphore_open_and_set(struct semaphore *sem, ... )
+{
+    va_list ap;
+    int i;
+    unsigned short *values;
+    int res;
+
+    if (sem == NULL || sem->magic != SEMAPHORE_MAGIC)
+        return ERROR_INVALID_PARAMETERS;
+
+    values = (unsigned short *) alloca(sizeof(unsigned short) * sem->size);
+
+    va_start(ap, sem);
+    for (i = 0; i < sem->size; i++)
+    {
+        values[i] = (unsigned short) va_arg(ap, int);
+    }
+    va_end(ap);
+
+
+    res = semaphore_open(sem, OMODE_CREATE);
+    if (res == S_OK)
+    {
+        DPRINTF("Created semaphore. setting initial value\n");
+        res = semaphore_set_values(sem,values);
+    }
+    else if (res == ERROR_SEMAPHORE_ALREADY_EXISTS)
+    {
+        res = semaphore_open(sem, OMODE_OPEN_OR_CREATE);
+        /*
+           Race condition possible here!!! this function could return when after the creating process
+           has created the semaphore, but not yet set the initial values, so it is possible that the
+           semaphore values are uninitialized.  See the stevens solution with polling on ipc_stat
+        */
+    }
+
+    return res;
+}
+
+int semaphore_P(struct semaphore *sem, unsigned short nsem)
+{
+    struct sembuf s;
+
+    if (sem == NULL || sem->magic != SEMAPHORE_MAGIC)
+        return ERROR_INVALID_PARAMETERS;
+
+    if (nsem >= sem->size)
+        return ERROR_INVALID_PARAMETERS;
+
+    s.sem_num = nsem;
+    s.sem_op = -1;
+    s.sem_flg = SEM_UNDO;
+
+    if (semop(sem->semid,&s,1) == -1)
+    {
+
+    }
+
+    return S_OK;
+}
+
+int semaphore_V(struct semaphore *sem, unsigned short nsem)
+{
+    struct sembuf s;
+
+    if (sem == NULL || sem->magic != SEMAPHORE_MAGIC)
+        return ERROR_INVALID_PARAMETERS;
+
+    if (nsem >= sem->size)
+        return ERROR_INVALID_PARAMETERS;
+
+    s.sem_num = nsem;
+    s.sem_op = 1;
+    s.sem_flg = SEM_UNDO;
+
+    if (semop(sem->semid,&s,1) == -1)
+    {
+
+    }
+
+    return S_OK;
+}
+
+
+int semaphore_close(struct semaphore *sem, int remove)
+{
+    char path[MAX_PATH];
+
+    if (remove)
+    {
+        DPRINTF("Destroying semaphore %s 0x%08x (%d).\n", sem->name, sem->semkey, sem->semid);
+        semctl(sem->semid, 0, IPC_RMID);
+        sprintf(path, "%s/%s", SEMAPHORE_DIRECTORY, sem->name);
+        unlink(path);
+    }
+
+    sem->semid = -1;
+    sem->semkey = -1;
+
+    return S_OK;
+}
+
+void semaphore_free(struct semaphore *sem)
+{
+    free(sem);
+}
+

data/ext/stats/shared_mem.c

@@ -0,0 +1,238 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <errno.h>
+
+#include "stats/error.h"
+#include "stats/shared_mem.h"
+#include "stats/debug.h"
+
+int shared_memory_create(const char *name, int flags, int size, struct shared_memory **shmem_out )
+{
+    struct shared_memory * shmem;
+    int err;
+
+    if (shmem_out == NULL)
+        return ERROR_INVALID_PARAMETERS;
+
+    shmem = malloc(sizeof(struct shared_memory));
+    if (!shmem)
+        return ERROR_MEMORY;
+
+    err = shared_memory_init(shmem,name,flags,size);
+    if (err == S_OK)
+    {
+        *shmem_out = shmem;
+    }
+    else
+    {
+        free(shmem);
+        *shmem_out = NULL;
+    }
+
+    return err;
+}
+
+int shared_memory_init(struct shared_memory *shmem, const char *name, int flags, int size)
+{
+    if (shmem == NULL)
+        return ERROR_INVALID_PARAMETERS;
+
+    if (strlen(name) >= SHARED_MEMORY_MAX_NAME_LEN)
+        return ERROR_SHARED_MEM_NAME_TOO_LONG;
+
+    memset(shmem, 0, sizeof(struct shared_memory));
+
+    shmem->magic = SHARED_MEMORY_MAGIC;
+    shmem->shmkey = -1;
+    shmem->shmid = -1;
+    shmem->flags = flags;
+    shmem->size = size;
+    strcpy(shmem->name, name);
+
+    return S_OK;
+}
+
+int shared_memory_open(struct shared_memory * shmem)
+{
+    struct stat s;
+    char path[MAX_PATH];
+    int mode;
+    struct shmid_ds ds;
+    int omode;
+
+    if (shmem == NULL || shmem->magic != SHARED_MEMORY_MAGIC)
+        return ERROR_INVALID_PARAMETERS;
+
+    /* extract open mode from flags */
+    omode = shmem->flags & OMODE_MASK;
+
+    /* check for existance of the directory */
+    if (stat(SHARED_MEMORY_DIRECTORY,&s) != 0)
+    {
+        /* try to create the directory */
+        if (mkdir(SHARED_MEMORY_DIRECTORY, 0755) != 0)
+            return ERROR_SHARED_MEM_CANNOT_CREATE_DIRECTORY;
+    }
+    else
+    {
+        if ((s.st_mode & S_IFDIR) != S_IFDIR)
+            return ERROR_SHARED_MEM_PATH_NOT_DIRECTORY;
+    }
+
+    sprintf(path, "%s/%s", SHARED_MEMORY_DIRECTORY, shmem->name);
+
+    if (access(path, W_OK) == -1)
+    {
+        int fd = creat(path, 0644 );
+        if (fd == -1)
+            return ERROR_SHARED_MEM_CANNOT_CREATE_PATH;
+        close(fd);
+    }
+
+    shmem->shmkey = ftok(path, 1);
+    if (shmem->shmkey == -1)
+    {
+        return ERROR_SHARED_MEM_CANNOT_CREATE_IPC_TOKEN;
+    }
+
+    switch (omode)
+    {
+    case OMODE_CREATE:
+        mode = IPC_CREAT | IPC_EXCL | 0644;
+        break;
+    case OMODE_OPEN_OR_CREATE:
+        mode = IPC_CREAT | 0644;
+        break;
+    case OMODE_OPEN_EXISTING:
+    default:
+        mode = 0644;
+        break;
+    }
+
+    DPRINTF("Opening shmkey %08x for %s (absolute path: %s), mode 0%o, size %d\n", shmem->shmkey, shmem->name, path, mode, shmem->size);
+
+    shmem->shmid = shmget(shmem->shmkey, shmem->size, mode) ;
+    if (shmem->shmid == -1)
+    {
+        if (errno == EEXIST && omode == OMODE_CREATE)
+            return ERROR_SHARED_MEM_ALREADY_EXISTS;
+        if (errno == ENOENT && omode == OMODE_OPEN_EXISTING)
+            return ERROR_SHARED_MEM_DOES_NOT_EXIST;
+        if (errno == EINVAL)
+            return ERROR_SHARED_MEM_INVALID_SIZE;
+        return ERROR_SHARED_MEM_CANNOT_OPEN;
+    }
+
+    switch (omode)
+    {
+    case OMODE_CREATE:
+        shmem->created = TRUE;
+        break;
+    case OMODE_OPEN_OR_CREATE:
+        if (shmctl(shmem->shmid, IPC_STAT, &ds) != 0)
+            return ERROR_SHARED_MEM_CANNOT_STAT;
+        if (ds.shm_cpid == getpid())
+            shmem->created = TRUE;
+        else
+            shmem->created = FALSE;
+        break;
+    case OMODE_OPEN_EXISTING:
+        shmem->created = FALSE;
+        break;
+    }
+
+    shmem->ptr = shmat(shmem->shmid, NULL, 0);
+    if ((intptr_t)shmem->ptr == -1)
+    {
+        shmem->ptr = NULL;
+        return ERROR_SHARED_MEM_CANNOT_ATTACH;
+    }
+
+    DPRINTF("Successfylly openend shm 0x%08x for %s.  Attached at 0x%016lx\n", shmem->shmkey, shmem->name, (intptr_t) shmem->ptr);
+
+    return S_OK;
+}
+
+
+int shared_memory_nattach(struct shared_memory *shmem, int *attach_count_out)
+{
+    struct shmid_ds ds;
+
+    if (!shmem || shmem->magic != SHARED_MEMORY_MAGIC || shmem->shmid == -1)
+        return ERROR_INVALID_PARAMETERS;
+
+    if (shmctl(shmem->shmid, IPC_STAT, &ds) != 0)
+        return ERROR_SHARED_MEM_CANNOT_STAT;
+
+    *attach_count_out = ds.shm_nattch;
+    return S_OK;
+}
+
+
+int shared_memory_close(struct shared_memory *shmem, int *did_destroy)
+{
+    struct shmid_ds ds;
+    int destroy_mode;
+    int destroy = FALSE;
+    char path[MAX_PATH];
+
+    if (shmem == NULL || shmem->magic != SHARED_MEMORY_MAGIC)
+        return ERROR_INVALID_PARAMETERS;
+
+    destroy_mode = shmem->flags & DESTROY_MASK;
+
+    if (shmem->ptr)
+    {
+        shmdt(shmem->ptr);
+        shmem->ptr = NULL;
+    }
+
+    if (shmem->shmid != -1)
+    {
+        if (destroy_mode == DESTROY_ON_CLOSE_IF_LAST)
+        {
+            /* need to stat to see if there are no more attaches */
+            if (shmctl(shmem->shmid, IPC_STAT, &ds) == 0)
+            {
+                if (ds.shm_nattch == 0)
+                    destroy = TRUE;
+            }
+        }
+
+        if (destroy_mode == DESTROY_ON_CLOSE)
+            destroy = TRUE;
+
+        if (destroy)
+        {
+            DPRINTF("Destroying shared memory %s 0x%08x (%d).\n", shmem->name, shmem->shmkey, shmem->shmid);
+            shmctl(shmem->shmid, IPC_RMID, NULL);
+            sprintf(path, "%s/%s", SHARED_MEMORY_DIRECTORY, shmem->name);
+            unlink(path);
+
+            if (did_destroy != NULL)
+                *did_destroy = 1;
+        }
+        else
+        {
+            if (did_destroy != NULL)
+                *did_destroy = 0;
+        }
+
+        shmem->shmid = -1;
+    }
+
+    shmem->shmkey = -1;
+
+    return S_OK;
+}
+
+void shared_memory_free(struct shared_memory *shmem)
+{
+    free(shmem);
+}
+
+

data/ext/stats/stats/debug.h

@@ -0,0 +1,8 @@
+/* debug.h */
+
+#ifndef _DEBUG_H_INCLUDED_
+#define _DEBUG_H_INCLUDED_
+
+#define DPRINTF if (DEBUG) printf
+
+#endif

data/ext/stats/stats/error.h

@@ -0,0 +1,50 @@
+/* error.h */
+
+#ifndef _ERROR_H_INCLUDED_
+#define _ERROR_H_INCLUDED_
+
+#define TRUE  1
+#define FALSE 0
+
+#define S_OK                         0x00000000
+#define ERROR_FLAG                   0x80000000
+
+#define ERROR_FACILITY_GENERAL       0x00010000
+#define ERROR_FACILITY_SHARED_MEM    0x00020000
+#define ERROR_FACILITY_SEMAPHORE     0x00030000
+#define ERROR_FACILITY_STATS         0x00040000
+
+#define ERROR_FAIL                                      (ERROR_FLAG | ERROR_FACILITY_GENERAL    | 0x0000)
+#define ERROR_INVALID_PARAMETERS                        (ERROR_FLAG | ERROR_FACILITY_GENERAL    | 0x0001)
+#define ERROR_MEMORY                                    (ERROR_FLAG | ERROR_FACILITY_GENERAL    | 0x0002)
+
+#define ERROR_SHARED_MEM_NAME_TOO_LONG                  (ERROR_FLAG | ERROR_FACILITY_SHARED_MEM | 0x0001)
+#define ERROR_SHARED_MEM_CANNOT_CREATE_DIRECTORY        (ERROR_FLAG | ERROR_FACILITY_SHARED_MEM | 0x0002)
+#define ERROR_SHARED_MEM_PATH_NOT_DIRECTORY             (ERROR_FLAG | ERROR_FACILITY_SHARED_MEM | 0x0003)
+#define ERROR_SHARED_MEM_CANNOT_CREATE_PATH             (ERROR_FLAG | ERROR_FACILITY_SHARED_MEM | 0x0004)
+#define ERROR_SHARED_MEM_CANNOT_CREATE_IPC_TOKEN        (ERROR_FLAG | ERROR_FACILITY_SHARED_MEM | 0x0005)
+#define ERROR_SHARED_MEM_ALREADY_EXISTS                 (ERROR_FLAG | ERROR_FACILITY_SHARED_MEM | 0x0006)
+#define ERROR_SHARED_MEM_DOES_NOT_EXIST                 (ERROR_FLAG | ERROR_FACILITY_SHARED_MEM | 0x0007)
+#define ERROR_SHARED_MEM_INVALID_SIZE                   (ERROR_FLAG | ERROR_FACILITY_SHARED_MEM | 0x0008)
+#define ERROR_SHARED_MEM_CANNOT_STAT                    (ERROR_FLAG | ERROR_FACILITY_SHARED_MEM | 0x0009)
+#define ERROR_SHARED_MEM_CANNOT_OPEN                    (ERROR_FLAG | ERROR_FACILITY_SHARED_MEM | 0x000A)
+#define ERROR_SHARED_MEM_CANNOT_ATTACH                  (ERROR_FLAG | ERROR_FACILITY_SHARED_MEM | 0x000B)
+
+
+#define ERROR_SEMAPHORE_NAME_TOO_LONG                   (ERROR_FLAG | ERROR_FACILITY_SEMAPHORE | 0x0001)
+#define ERROR_SEMAPHORE_CANNOT_CREATE_DIRECTORY         (ERROR_FLAG | ERROR_FACILITY_SEMAPHORE | 0x0002)
+#define ERROR_SEMAPHORE_PATH_NOT_DIRECTORY              (ERROR_FLAG | ERROR_FACILITY_SEMAPHORE | 0x0003)
+#define ERROR_SEMAPHORE_CANNOT_CREATE_PATH              (ERROR_FLAG | ERROR_FACILITY_SEMAPHORE | 0x0004)
+#define ERROR_SEMAPHORE_CANNOT_CREATE_IPC_TOKEN         (ERROR_FLAG | ERROR_FACILITY_SEMAPHORE | 0x0005)
+#define ERROR_SEMAPHORE_ALREADY_EXISTS                  (ERROR_FLAG | ERROR_FACILITY_SEMAPHORE | 0x0006)
+#define ERROR_SEMAPHORE_DOES_NOT_EXIST                  (ERROR_FLAG | ERROR_FACILITY_SEMAPHORE | 0x0007)
+#define ERROR_SEMAPHORE_INVALID_SIZE                    (ERROR_FLAG | ERROR_FACILITY_SEMAPHORE | 0x0008)
+#define ERROR_SEMAPHORE_CANNOT_OPEN                     (ERROR_FLAG | ERROR_FACILITY_SEMAPHORE | 0x000A)
+
+#define ERROR_STATS_CANNOT_ALLOCATE_COUNTER             (ERROR_FLAG | ERROR_FACILITY_STATS | 0x0001)
+#define ERROR_STATS_KEY_TOO_LONG                        (ERROR_FLAG | ERROR_FACILITY_STATS | 0x0002)
+
+const char * error_message(int code);
+
+
+#endif

data/ext/stats/stats/hash.h

@@ -0,0 +1,10 @@
+/* hash.h */
+
+#ifndef _HASH_H_
+#define _HASH_H_
+
+#include <stdint.h>
+
+uint32_t fast_hash(const char * data, int len);
+
+#endif

data/ext/stats/stats/lock.h

@@ -0,0 +1,27 @@
+/* lock.h */
+
+#ifndef _LOCK_H_INCLUDED_
+#define _LOCK_H_INCLUDED_
+
+#include "semaphore.h"
+
+struct lock {
+    struct semaphore sem;
+};
+
+int lock_create(const char * name, struct lock **lock_out);
+
+int lock_acquire(struct lock *lock);
+int lock_release(struct lock *lock);
+
+int lock_close(struct lock *lock);
+void lock_free(struct lock *lock);
+
+#define lock_init(lock,name) semaphore_init(&(lock)->sem,name,1)
+#define lock_open(lock) semaphore_open_and_set(&(lock)->sem,1)
+#define lock_acquire(lock) semaphore_P(&(lock)->sem,0)
+#define lock_release(lock) semaphore_V(&(lock)->sem,0)
+#define lock_close(lock,remove) semaphore_close(&(lock)->sem,(remove));
+#define lock_is_open(lock) semaphore_is_open(&((lock)->sem))
+
+#endif

data/ext/stats/stats/omode.h

@@ -0,0 +1,11 @@
+/* omode.h */
+
+#ifndef _OMODE_H_INCLUDED_
+#define _OMODE_H_INCLUDED_
+
+#define OMODE_CREATE                        0x0000001
+#define OMODE_OPEN_OR_CREATE                0x0000002
+#define OMODE_OPEN_EXISTING                 0x0000004
+#define OMODE_MASK                          0x0000007
+
+#endif

data/ext/stats/stats/semaphore.h

@@ -0,0 +1,53 @@
+/* semaphore.h */
+
+#ifndef _SEMAPHORE_H_
+#define _SEMAPHORE_H_
+
+#include <sys/ipc.h>
+#include <sys/sem.h>
+
+#include "omode.h"
+
+#define SEMAPHORE_MAGIC   'semm'
+
+#define SEMAPHORE_MAX_NAME_LEN 31
+
+struct semaphore {
+    int magic;
+    unsigned short size;
+    char name[SEMAPHORE_MAX_NAME_LEN + 1];
+    key_t semkey;
+    int semid;
+};
+
+#ifdef LINUX
+union semun {
+    int              val;    /* Value for SETVAL */
+    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
+    unsigned short  *array;  /* Array for GETALL, SETALL */
+    struct seminfo  *__buf;  /* Buffer for IPC_INFO
+                                (Linux-specific) */
+};
+#endif
+
+int semaphore_create(const char *name, unsigned short size, struct semaphore **sem_out);
+int semaphore_init(struct semaphore *sem, const char *name, unsigned short size);
+int semaphore_open(struct semaphore *sem, int flags);
+int semaphore_open_and_set(struct semaphore *sem, ... );
+int semaphore_set_value(struct semaphore *sem, unsigned short nsem, unsigned short value);
+int semaphore_set_values(struct semaphore *sem, unsigned short *values);
+int semaphore_P(struct semaphore *sem, unsigned short nsem);
+int semaphore_V(struct semaphore *sem, unsigned short nsem);
+int semaphore_close(struct semaphore *sem, int remove);
+void semaphore_free(struct semaphore *sem);
+
+#define semaphore_signal semaphore_V
+#define semaphore_wait semaphore_P
+
+#define semaphore_size(s) ((s)->size)
+#define semaphore_name(s) ((s)->name)
+#define semaphore_is_open(s) ((s)->semid != -1)
+#define SEMAPHORE_DIRECTORY "/tmp"
+#define MAX_PATH 255
+
+#endif