Linux下通过共享内存进行进程间通信，进程间同步使用信号量来实现

Linux 环境下C编程指南，通过共享内存进行进程间通信的例子，进程间同步使用信号量来实现。、

书中有几个错误。。

使用说明：这是一个简单的服务器和客户端程序，如果启动程序时不带参数，则执行服务器程序；
如果带参数，则执行客户端程序，所带参数只有一个，就是服务器端所显示的共享内存的引用ID。

实现原理：服务器端启动后，创建信号量和共享内存，并将共享内存的引用ID显示出来，将信号量
的引用ID存放在共享内存中。客户端启动后，利用服务器端提供的内存共享ID将共享内存附加到地址段，
读取信号量以实现两个进程之间的同步。之后，这两个进程就可以利用共享内存进行进程间通信，客户

端输入的信息将在服务器端显示出来。

#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#define SHMDATASIZE 1000
#define BUFFERSIZE (SHMDATASIZE - sizeof(int))
#define SN_EMPTY 0
#define SN_FULL 1
int deleteSemid=0;

union semun
{
     int val;                           
     struct semid_ds *buf;              
     unsigned short int *array;         
     struct seminfo *__buf;             
};

void server(void);
void client(int shmid);
void delete(void);
void sigdelete(int signum);
void locksem(int semid, int semnum);
void unlocksem(int semid, int semnum);
void waitzero(int semid, int semnum);
void clientwrite(int shmid, int semid, char *buffer);

int safesemget(key_t key, int nsems, int semflg);
int safesemctl(int semid, int semnum, int cmd, union semun arg);
int safesemop(int semid, struct sembuf *sops, unsigned nsops);
int safeshmget(key_t key, int size, int shmflg);
void *safeshmat(int shmid, const void *shmaddr, int shmflg);
int safeshmctl(int shmid, int cmd, struct shmid_ds *buf);

int main(int argc, char *argv[])
{
    if ( argc < 2 )
    {
        server();
    }
    else
    {
        client(atoi(argv[1]));
    }
    return 0;
}

void server(void)
{
    union semun sunion;
    int semid,shmid;
    void *shmdata;
    char *buffer;

    semid = safesemget(IPC_PRIVATE, 2, SHM_R|SHM_W);
    deleteSemid = semid;
    atexit(&delete);                    //当程序终止执行时，执行 delete 函数
    signal(SIGINT, &sigdelete); //接收到信号 SIGINT 则执行 sigdelete 函数
    sunion.val = 1;
    safesemctl(semid, SN_EMPTY, SETVAL, sunion);
    sunion.val = 0;
    safesemctl(semid, SN_FULL, SETVAL, sunion);
    shmid = safeshmget(IPC_PRIVATE, SHMDATASIZE, IPC_CREAT|SHM_R|SHM_W);
    shmdata = safeshmat(shmid, 0, 0);
    safeshmctl(shmid, IPC_RMID, NULL);   //删除共享内存，当所有附加该共享内存的进程结束或断开与该
                                                                //共享内存的连接时才执行
    *(int *)shmdata = semid;
    buffer = shmdata + sizeof(int);
    printf("Server is running with SHM id ** %d **/n", shmid);

    while(1)
    {
        printf("Waiting until full...");
        fflush(stdout);
        locksem(semid, SN_FULL);
        printf("done./n");
        printf("Message received: %s./n", buffer);
        unlocksem(semid, SN_EMPTY);
    }
}

void client(int shmid)
{
    int semid;
    void *shmdata;
    char *buffer;
    shmdata = safeshmat(shmid, 0, 0);
    semid = *(int *)shmdata;
    buffer = shmdata + sizeof(int);
    printf("Client operational: shm id is %d, sem id is %d/n", shmid, semid);

    while(1)
    {
        char input[3];
        printf("/n/nMenu/n1.send a message/n");
        printf("2.Exit/n");
        fgets(input, sizeof(input), stdin);
        switch(input[0])
        {
            case '1': clientwrite(shmid, semid, buffer);
                      break;
            case '2': exit(0);
                      break;
        }
    }
}

void delete(void)
{
    printf("/nMaster exiting; deleting semaphore %d./n", deleteSemid);
    if (semctl(deleteSemid, 0, IPC_RMID, 0) == -1 )
    {
        printf("Error releasing semaphore./n");
    }
}

void sigdelete(int signum)
{
    exit(0);
}

void locksem(int semid, int semnum)
{
    struct sembuf sb;
    sb.sem_num = semnum;
    sb.sem_op = -1;
    sb.sem_flg = SEM_UNDO;
    safesemop(semid, &sb, 1);
}

void unlocksem(int semid, int semnum)
{
    struct sembuf sb;
    sb.sem_num = semnum;
    sb.sem_op = 1;
    sb.sem_flg = SEM_UNDO;
    safesemop(semid, &sb, 1);
}

void waitzero(int semid, int semnum)
{
    struct sembuf sb;
    sb.sem_num = semnum;
    sb.sem_op = 0;
    sb.sem_flg = 0;
    safesemop(semid, &sb, 1);
}

void clientwrite(int shmid, int semid, char *buffer)
{
    printf("Waiting until empty...");
    fflush(stdout);
    locksem(semid, SN_EMPTY);
    printf("done./n");
    printf("Enter Message: ");
    fgets(buffer, BUFFERSIZE, stdin);
    unlocksem(semid, SN_FULL);
}

int safesemget(key_t key, int nsems, int semflg)
{
    int retval;
    if ( (retval=semget(key, nsems, semflg)) == -1)
    {
       printf("semget error: %s./n", strerror(errno));
       exit(254);
    }
    return retval;
}

int safesemctl(int semid, int semnum, int cmd, union semun arg)
{
    int retval;
    if ( (retval=semctl(semid, semnum, cmd, arg)) == -1)
    {
       printf("semctl error: %s./n", strerror(errno));
       exit(254);
    }
    return retval;
}

int safesemop(int semid, struct sembuf *sops, unsigned nsops)
{
    int retval;
    if ( (retval=semop(semid, sops, nsops)) == -1)
    {
       printf("semop error: %s./n", strerror(errno));
       exit(254);
    }
    return retval;
}

int safeshmget(key_t key, int size, int shmflg)
{
    int retval;
    if ( (retval=shmget(key, size, shmflg)) == -1)
    {
       printf("shmget error: %s./n", strerror(errno));
       exit(254);
    }
    return retval;
}

void *safeshmat(int shmid, const void *shmaddr, int shmflg)
{
    void *retval;
    if ( (retval=shmat(shmid, shmaddr, shmflg)) == (void *)-1)
    {
       printf("shmat error: %s./n", strerror(errno));
       exit(254);
    }
    return retval;
}
int safeshmctl(int shmid, int cmd, struct shmid_ds *buf)
{
    int retval;
    if ( (retval=shmctl(shmid, cmd, buf)) == -1)
    {
       printf("shmctl error: %s./n", strerror(errno));
       exit(254);
    }
    return retval;
}