进程间通信

#include "apue.h"

int main(void)
{
        int     n;
        int     fd[2];
        pid_t   pid;
        char    line[MAXLINE];

        if (pipe(fd) < 0)
                err_sys("pipe error");

        if ((pid = fork()) < 0) {
                err_sys("fork error");
        } else if (pid > 0) {       /* parent */
                close(fd[0]);// close read tunnel of pipe in parent process
                if(write(fd[1], "hello world\n", 12) < 0)
                        err_sys("write to pipe error");
        } else {                /* child */
                close(fd[1]); // close write tunnel of pipe in child process
                n = read(fd[0], line, MAXLINE);
                if(write(STDOUT_FILENO, line, n) < 0)
                        err_sys("write to console error");
        }

        exit(0);
}

$ ./src/ipc/pipe1

hello world

$ ./src/ipc/most2 Makefile

# Makefile.in generated by automake 1.15 from Makefile.am.
# Makefile.  Generated from Makefile.in by configure.

# Copyright (C) 1994-2014 Free Software Foundation, Inc.

# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.



am__is_gnu_make = { \
  if test -z '$(MAKELEVEL)'; then \
    false; \
  elif test -n '$(MAKE_HOST)'; then \
    true; \
  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
: #分页开始

#include "apue.h"

static int  pfd1[2], pfd2[2];

void TELL_WAIT(void)
{
        if (pipe(pfd1) < 0 || pipe(pfd2) < 0)
                err_sys("pipe error");
}

void TELL_PARENT(pid_t pid)
{
        if (write(pfd2[1], "c", 1) != 1)
                err_sys("write error");
}

void WAIT_PARENT(void)
{
        char    c;

        if (read(pfd1[0], &c, 1) != 1)
                err_sys("read error");

        if (c != 'p')
                err_quit("WAIT_PARENT: incorrect data");
}

void TELL_CHILD(pid_t pid)
{
        if (write(pfd1[1], "p", 1) != 1)
                err_sys("write error");
}

void WAIT_CHILD(void)
{
        char    c;

        if (read(pfd2[0], &c, 1) != 1)
                err_sys("read error");

        if (c != 'c')
                err_quit("WAIT_CHILD: incorrect data");
}

$ sh -c cmdstring

fp = popen("ls *.c", "r");

fp = popen("cmd 2>&1", "w");

#include "apue.h"
#include <sys/wait.h>

#define PAGER   "${PAGER:-more}" /* environment variable, or default */

int main(int argc, char *argv[])
{
        char    line[MAXLINE];
        FILE    *fpin, *fpout;

        if (argc != 2)
                err_quit("usage: a.out <pathname>");
        if ((fpin = fopen(argv[1], "r")) == NULL)
                err_sys("can't open %s", argv[1]);

        if ((fpout = popen(PAGER, "w")) == NULL)
                err_sys("popen error");

        /* copy argv[1] to pager */
        while (fgets(line, MAXLINE, fpin) != NULL) {
                if (fputs(line, fpout) == EOF)
                        err_sys("fputs error to pipe");
        }
        if (ferror(fpin))
                err_sys("fgets error");
        if (pclose(fpout) == -1)
                err_sys("pclose error");

        exit(0);
}

#include "apue.h"
#include <errno.h>
#include <fcntl.h>
#include <sys/wait.h>

/*
 * Pointer to array allocated at run-time.
 */
static pid_t *childpid = NULL;

/*
 * From our open_max(), {Prog openmax}.
 */
static int maxfd;

FILE *popen(const char *cmdstring, const char *type)
{
        int     i;
        int     pfd[2];
        pid_t   pid;
        FILE    *fp;

        /* only allow "r" or "w" */
        if ((type[0] != 'r' && type[0] != 'w') || type[1] != 0) {
                errno = EINVAL;     /* required by POSIX */
                return(NULL);
        }

        if (childpid == NULL) {     /* first time through */
                /* allocate zeroed out array for child pids */
                maxfd = open_max();
                if ((childpid = calloc(maxfd, sizeof(pid_t))) == NULL)
                        return(NULL);
        }

        if (pipe(pfd) < 0)
                return(NULL);   /* errno set by pipe() */

        if ((pid = fork()) < 0) {
                return(NULL);   /* errno set by fork() */
        } else if (pid == 0) {                          /* child */
                if (*type == 'r') {
                        close(pfd[0]);
                        if (pfd[1] != STDOUT_FILENO) {
                                dup2(pfd[1], STDOUT_FILENO);
                                close(pfd[1]);
                        }
                } else {
                        close(pfd[1]);
                        if (pfd[0] != STDIN_FILENO) {
                                dup2(pfd[0], STDIN_FILENO);
                                close(pfd[0]);
                        }
                }

                /* close all descriptors in childpid[] */
                for (i = 0; i < maxfd; i++)
                        if (childpid[i] > 0)
                                close(i);

                execl("/bin/sh", "sh", "-c", cmdstring, (char *)0);
                _exit(127);
        }

        /* parent continues... */
        if (*type == 'r') {
                close(pfd[1]);
                if ((fp = fdopen(pfd[0], type)) == NULL)
                        return(NULL);
        } else {
                close(pfd[0]);
                if ((fp = fdopen(pfd[1], type)) == NULL)
                        return(NULL);
        }

        childpid[fileno(fp)] = pid; /* remember child pid for this fd */
        return(fp);
}

int pclose(FILE *fp)
{
        int     fd, stat;
        pid_t   pid;

        if (childpid == NULL) {
                errno = EINVAL;
                return(-1);     /* popen() has never been called */
        }

        fd = fileno(fp);
        if ((pid = childpid[fd]) == 0) {
                errno = EINVAL;
                return(-1);     /* fp wasn't opened by popen() */
        }

        childpid[fd] = NULL;
        if (fclose(fp) == EOF)
                return(-1);

        while (waitpid(pid, &stat, 0) < 0)
                if (errno != EINTR)
                        return(-1); /* error other than EINTR from waitpid() */

        return(stat);   /* return child's termination status */
}

#include "apue.h"
#include <ctype.h>

int main(void)
{
        int     c;

        while ((c = getchar()) != EOF) {
                if (isupper(c))
                        c = tolower(c);
                if (putchar(c) == EOF)
                        err_sys("output error");
                if (c == '\n')
                        fflush(stdout);
        }
        exit(0);
}

#include "apue.h"
#include <sys/wait.h>

int main(void)
{
    char    line[MAXLINE];
    FILE    *fpin;

    if ((fpin = popen("myuclc", "r")) == NULL)
        err_sys("popen error");
    for ( ; ; ) {
        fputs("prompt> ", stdout);
        fflush(stdout);
        if (fgets(line, MAXLINE, fpin) == NULL) /* read from pipe */
            break;
        if (fputs(line, stdout) == EOF)
            err_sys("fputs error to pipe");
    }
    if (pclose(fpin) == -1)
        err_sys("pclose error");
    putchar('\n');
    exit(0);
}

$ ./src/ipc/popen1 
prompt> HELLO WORLD
hello world
prompt> ^C

#include "apue.h"

int main(void)
{
        int     n, int1, int2;
        char    line[MAXLINE];

        while ((n = read(STDIN_FILENO, line, MAXLINE)) > 0) {
                line[n] = 0;        /* null terminate */
                if (sscanf(line, "%d%d", &int1, &int2) == 2) {
                        sprintf(line, "%d\n", int1 + int2);
                        n = strlen(line);
                        if (write(STDOUT_FILENO, line, n) != n)
                                err_sys("write error");
                } else {
                        if (write(STDOUT_FILENO, "invalid args\n", 13) != 13)
                                err_sys("write error");
                }
        }
        exit(0);
}

#include <sys/stat.h>
/**
 * 创建命名管道
 *
 * pathname: 管道文件名
 * mode: 可选择参数，当oflag包含O_CREAT的时候，表示创建文件的权限
 *
 * return: 若成功则为 0，若出错则为 -1
 *
 */
int mkfifo(const char *pathname, mode_t mode);

#include <sys/ipc.h>
/* Data structure used to pass permission information to IPC operations.  */
struct ipc_perm
{
        __key_t __key;                      /* Key.  */
        __uid_t uid;                        /* Owner's user ID.  */
        __gid_t gid;                        /* Owner's group ID.  */
        __uid_t cuid;                       /* Creator's user ID.  */
        __gid_t cgid;                       /* Creator's group ID.  */
        unsigned short int mode;            /* Read/write permission.  */
        unsigned short int __pad1;
        unsigned short int __seq;           /* Sequence number.  */
        unsigned short int __pad2;
        unsigned long int __unused1;
        unsigned long int __unused2;
};

/* Structure of record for one message inside the kernel.
   The type `struct msg' is opaque.  */
struct msqid_ds
{
        struct ipc_perm msg_perm;   /* structure describing operation permission */
        struct msg *msg_first;      /* ptr to first message on queue */
        struct msg *msg_last;       /* ptr to last message on queue */
        time_t msg_stime;           /* time of last msgsnd command */
        time_t msg_rtime;           /* time of last msgrcv command */
        time_t msg_ctime;           /* time of last change */
        unsigned long int msg_cbytes; /* current number of bytes on queue */
        msgqnum_t msg_qnum;           /* number of messages currently on queue */
        msglen_t msg_qbytes;          /* max number of bytes allowed on queue */
        pid_t msg_lspid;            /* pid of last msgsnd() */
        pid_t msg_lrpid;            /* pid of last msgrcv() */
};

#include <unistd.h>
#include <sys/msg.h>
#include <stdio.h>
#include "apue.h"

//消息结构
struct message{
        long int mtype;
        char mtext[512];
};

int main(void)
{
        //创建消息队列
        int msgid = msgget(IPC_PRIVATE,0666);
        //创建消息结构
        struct message snd;
        //消息类型
        snd.mtype = 911;
        //消息内容
        strcpy(snd.mtext,"help");
        //发送消息到队列
        if(msgsnd(msgid,&snd,5,0) == -1){
                printf("msgsnd %m\n");
                return -1;
        }

        //读取消息队列信息
        struct msqid_ds ds;
        if(msgctl(msgid, IPC_STAT, &ds) == -1){
                printf("msgctl IPC_STAT %m\n");
                return -1;
        }
        printf("current bytes:%d ,current number:%d ,max bytes:%d \n",
               ds.msg_cbytes, ds.msg_qnum, ds.msg_qbytes);

        struct message rcv;
        //非阻塞读取消息类型为910的消息，出错返回
        if(msgrcv(msgid, &rcv, 512, 910, IPC_NOWAIT) == -1){
                printf("msgrcv1 %m\n");
        }
        //阻塞读取消息类型为911的消息
        if(msgrcv(msgid, &rcv, 521, 911, 0) == -1){
                printf("msgrcv2 %m\n");
                return -1;
        }
        //打印读取的消息
        printf("%s\n",rcv.mtext);
        //清除消息队列
        if(msgctl(msgid,IPC_RMID,NULL)==-1){
                printf("msgctl IPC_RMID %m\n");
        }
        return 0;
}

$ ./src/ipc/msg1 

current bytes:5 ,current number:1 ,max bytes:16384 #当前消息队列信息：写入5个字节，拥有1个消息，最大可写入字节数是16384 
msgrcv1 No message of desired type # 无法读取类型为910的消息
help #读取出的消息

struct semid_ds
{
        struct ipc_perm sem_perm; /* see Section 14.6.2 */
        struct sem *sem_base; /* ptr to first semaphore in set */
        ushort sem_nsems; /* # of semaphores in set */
        time_t sem_otime; /* last-semop() time */
        time_t sem_ctime; /* last-change time */
};

struct sem
{
        ushort semval; /* semaphore value always >= 0*/
        pid_t sempid; /* pid for last operation */
        ushort semncnt; /* # processes awaiting semval > currentval */
        ushort semzcnt; /* # processes awaiting semval = 0 */
};

#include <unistd.h>
#include <sys/sem.h>
#include <sys/wait.h>
#include "apue.h"

int main(void){

        //创建信号量集
        int semid = semget(IPC_PRIVATE, 1, 0666);
        int value = 0;

        //初始化信号量，设置信号量集的第一个信号量的当前值为0
        semctl(semid, 0, SETVAL, &value);

        pid_t pid=fork();
        if(pid==0){//child
                struct sembuf buf;
                buf.sem_num = 0;
                buf.sem_op = -1;
                printf("child wait to exit\n");
                //从信号量集的第一个信号量获取一个资源
                semop(semid, &buf, 1);
                printf("child about to exit\n");
                return 0;
        }

        sleep(2);
        struct sembuf buf;
        buf.sem_num = 0;
        buf.sem_op = 1;
        printf("tell child ready\n");
        //向信号量集的第一个信号量增加一个资源
        semop(semid,&buf,1);
        wait(NULL);

        //清理信号量集
        semctl(semid, 0, IPC_RMID);
        return 0;
}

$ ./src/ipc/semp1

child wait to exit
child about to exit
tell child ready

struct shmid_ds
{
        struct ipc_perm shm_perm;           /* operation permission struct */
        struct anop_map *shm_amp;           /* pointer in kernel */
        size_t shm_segsz;                   /* size of segment in bytes */
        time_t shm_atime;                 /* time of last shmat() */
        time_t shm_dtime;                 /* time of last shmdt() */
        time_t shm_ctime;                 /* time of last change by shmctl() */
        pid_t shm_cpid;                   /* pid of creator */
        pid_t shm_lpid;                   /* pid of last shmop */
        shmatt_t shm_nattch;                /* number of current attaches */
        shmatt_t shm_cattch;              /* used only for shminfo */
};

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

/**
   解除共享内存的连接

   addr：指向共享内存的指针，以前调用shmat时的返回值

   return：若成功则为0，若出错则为-1
 */
int shmdt(void *addr);

#include "apue.h"
#include <sys/shm.h>

#define ARRAY_SIZE  40000
#define MALLOC_SIZE 100000
#define SHM_SIZE    100000
#define SHM_MODE    ( SHM_R | SHM_W )   /* user read/write */

char    array[ARRAY_SIZE];  /* uninitialized data = bss */

int main(void)
{
        int     shmid;
        char    *ptr, *shmptr;

        printf("array[] from %lx to %lx\n", (unsigned long)&array[0],
               (unsigned long)&array[ARRAY_SIZE]);
        printf("stack around %lx\n", (unsigned long)&shmid);

        if ((ptr = malloc(MALLOC_SIZE)) == NULL)
                err_sys("malloc error");

        printf("malloced from %lx to %lx\n", (unsigned long)ptr,
               (unsigned long) ptr + MALLOC_SIZE);

        if ((shmid = shmget(IPC_PRIVATE, SHM_SIZE, SHM_MODE)) < 0)
                err_sys("shmget error");
        if ((shmptr = shmat(shmid, 0, 0)) == (void *)-1)
                err_sys("shmat error");
        printf("shared memory attached from %lx to %lx\n",
               (unsigned long)shmptr, (unsigned long)shmptr+SHM_SIZE);

        if (shmctl(shmid, IPC_RMID, 0) < 0)
                err_sys("shmctl error");

        exit(0);
}

$ ./src/ipc/tshm

array[] from 602100 to 60bd40 # bss段
stack around 7ffea7bbf2e4 # 函数栈
malloced from 220c420 to 2224ac0 # 堆
shared memory attached from 7f6e70571000 to 7f6e705896a0 # 共享内存区域

#include "apue.h"
#include <fcntl.h>
#include <sys/mman.h>

#define NLOOPS      1000
#define SIZE        sizeof(long)    /* size of shared memory area */

static int update(long *ptr)
{
        return((*ptr)++);   /* return value before increment */
}

int main(void)
{
        int     fd, i, counter;
        pid_t   pid;
        void    *area;

        if ((fd = open("/dev/zero", O_RDWR)) < 0)
                err_sys("open error");
        if ((area = mmap(0, SIZE, PROT_READ | PROT_WRITE, MAP_SHARED,
                         fd, 0)) == MAP_FAILED)
                err_sys("mmap error");
        close(fd);      /* can close /dev/zero now that it's mapped */

        TELL_WAIT();

        if ((pid = fork()) < 0) {
                err_sys("fork error");
        } else if (pid > 0) {           /* parent */
                for (i = 0; i < NLOOPS; i += 2) {
                        if ((counter = update((long *)area)) != i)
                                err_quit("parent: expected %d, got %d", i, counter);

                        //printf("parent counter: %d \n", counter);

                        TELL_CHILD(pid);
                        WAIT_CHILD();
                }
        } else {                        /* child */
                for (i = 1; i < NLOOPS + 1; i += 2) {
                        WAIT_PARENT();

                        if ((counter = update((long *)area)) != i)
                                err_quit("child: expected %d, got %d", i, counter);

                        //printf("child counter: %d \n", counter);

                        TELL_PARENT(getppid());
                }
        }

        exit(0);
}