X-Git-Url: https://gapil.gnulinux.it/gitweb/?p=gapil.git;a=blobdiff_plain;f=sources%2Fwrappers.h;fp=sources%2Fwrappers.h;h=0000000000000000000000000000000000000000;hp=ed4a19b32f06b190ead58071714cdef518df0aa3;hb=6483a787322c614bc6282a0bf0ee001f1bf54b44;hpb=78a82bdb333ca71e395ba39a5c03745761341150 diff --git a/sources/wrappers.h b/sources/wrappers.h deleted file mode 100644 index ed4a19b..0000000 --- a/sources/wrappers.h +++ /dev/null @@ -1,214 +0,0 @@ -/*************************************************************** - * - * File wrappers.h: define a set of macro and inlined - * functions for signal, shared memory and semaphore handling - * - * Author: S. Piccardi - * - * $Id: wrappers.h,v 1.5 2002/12/02 23:06:59 piccardi Exp $ - * - ***************************************************************/ -#include /* IPC semaphore declarations */ -#include /* IPC shared memory declarations */ -#include -#include -#include -#include /* signal handling declarations */ -/** - ** Semaphore definition; used to implement a MutexXXXX API - ** To create a Mutex use an underlaying semaphore and init it; - ** we put here all the needed data structires - **/ -/* put this definition, get from the man pages */ -#if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED) -/* union semun is defined by including */ -#else -/* according to X/OPEN we have to define it ourselves */ -union semun { - int val; /* value for SETVAL */ - struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */ - unsigned short int *array; /* array for GETALL, SETALL */ - struct seminfo *__buf; /* buffer for IPC_INFO */ -}; -#endif -/* - * Function MutexCreate: create a mutex/semaphore - * - * First call create a semaphore, using the given key. - * We want only one semaphore so we set second argument to 1; third - * parameter is the flag argument, and is set to create a semaphore - * with R/W privilege for the user. - * Second call initialize the semaphore to 1 (unlocked) - * - * Input: an IPC key value (to create an unique semaphore) - * Return: the semaphore id# or -1 on error - */ -inline int MutexCreate(key_t ipc_key) -{ - const union semun semunion={1}; /* semaphore union structure */ - int sem_id, ret; - sem_id = semget(ipc_key, 1, IPC_CREAT|0666); /* get semaphore ID */ - if (sem_id == -1) { /* if error return code */ - return sem_id; - } - ret = semctl(sem_id, 0, SETVAL, semunion); /* init semaphore */ - if (ret == -1) { - return ret; - } - return sem_id; -} -/* - * Function MutexFind: get the semaphore/mutex Id given the IPC key value - * - * Input: an IPC key value - */ -inline int MutexFind(key_t ipc_key) -{ - return semget(ipc_key,1,0); -} -/* - * Function MutexRead: read the current value of the mutex/semaphore - * - * Input: a semaphore id # - * Return: the semaphore value - */ -inline int MutexRead(int sem_id) -{ - return semctl(sem_id, 0, GETVAL); -} -/* - * Define sembuf structures to lock and unlock the semaphore - * (used to implement a mutex) - */ -struct sembuf sem_lock={ /* to lock semaphore */ - 0, /* semaphore number (only one so 0) */ - -1, /* operation (-1 to use resource) */ - SEM_UNDO}; /* flag (set for undo at exit) */ -struct sembuf sem_ulock={ /* to unlock semaphore */ - 0, /* semaphore number (only one so 0) */ - 1, /* operation (1 to release resource) */ - SEM_UNO}; /* flag (in this case 0) */ -/* - * Function MutexLock: to lock a mutex/semaphore - * - * Input: a semaphore id # - * Output: semop return code (0 OK, -1 KO) - */ -inline int MutexLock(int sem_id) -{ - return semop(sem_id, &sem_lock, 1); -} -/* - * Function MutexUnlock: to unlock a mutex/semaphore - * - * Input: a semaphore id # - * Return: semop return code (0 OK, -1 KO) - */ -inline int MutexUnlock(int sem_id) -{ - return semop(sem_id, &sem_ulock, 1); -} -/* - * Function ShmCreate: - * Allocate a shared memory segment. - * First call get a shared memory segment with KEY key access and size SIZE, - * by creating it with R/W privilege for the user (this is the meaning of - * the ored flags). The function return an identifier shmid used for any - * further reference to the shared memory segment. - * Second call attach the shared memory segment to this process and return a - * pointer to it (of char * type). - * Then initialize shared memory: - * Set all to 0x55 (means 0101 un binary notation - * - * Input: an IPC key value - * the shared memory segment size - * Return: the address of the segment - */ -inline char * ShmCreate(key_t ipc_key, int shm_size) -{ - char * shptr; - int shmid; /* ID of the IPC shared memory segment */ - if ((shmid=shmget(ipc_key,shm_size,IPC_CREAT|0666))<0){ /* get shm ID */ - perror("cannot find shared memory"); - exit(1); - } - if ( (shptr=shmat(shmid,0,0)) < 0 ){ /* take the pointer to it */ - perror("cannot attach shared memory"); - exit(1); - } - memset((void *)shptr,0x55,shm_size); /* second couter starts from "0" */ - return shptr; -} -/* - * Function ShmFind: - * Find a shared memory segment - * Input: an IPC key value - * the shared memory segment size - * Return: the address of the segment - */ -inline char * ShmFind(key_t ipc_key, int shm_size) -{ - char * shptr; - int shmid; /* ID of the IPC shared memory segment */ - if ( (shmid=shmget(ipc_key,shm_size,0))<0 ){ /* find shared memory ID */ - perror("cannot find shared memory"); - exit(1); - } - if ( (shptr=shmat(shmid,0,0)) < 0 ){ /* take the pointer to it */ - perror("cannot attach shared memory"); - exit(1); - } - return shptr; -} -/* - * Function LockFile & UnlockFile: - * Create and remove a lockfile of the given pathname. - * Fail and exit in case of error or existence of the same lock - * file, using unlink do not need to remove the file, - */ -inline int LockFile(const char* path_name) -{ - return open(path_name, O_EXCL|O_CREAT); -} -inline int UnlockFile(const char* path_name) -{ - return unlink(path_name); -} -/* - * Function Signal - * Initialize a signal handler. - * To enable the signal handling a process we need to tell it to - * kernel; this is done writing all needed info to a sigaction structure - * named sigact, and then callind sigaction() system call passing the - * information stored in the sigact structure variable. - * - * Input: the signal to handle - * the signal handler function - * Return: the previous sigaction structure - */ -typedef void SigFunc(int); -inline SigFunc * Signal(int signo, SigFunc *func) -{ - struct sigaction new_handl, old_handl; - new_handl.sa_handler=func; - /* clear signal mask: no signal blocked during execution of func */ - if (sigemptyset(&new_handl.sa_mask)!=0){ /* initialize signal set */ - perror("cannot initializes the signal set to empty"); /* see mess. */ - exit(1); - } - new_handl.sa_flags=0; /* init to 0 all flags */ - /* change action for signo signal */ - if (sigaction(signo,&new_handl,&old_handl)){ - perror("sigaction failed on signal action setting"); - exit(1); - } - return (old_handl.sa_handler); -} - -/** - ** Defining prototypes for the all other functions - **/ -ssize_t SockRead(int fd, void *buf, size_t count); -ssize_t SockWrite(int fd, const void *buf, size_t count); - -void HandSIGCHLD(int sig);