Linux信号和命名管道

Linux信号和命名管道

概述:
    在同一台计算机中，进程相互通信的方式主要有：管道(Pipe)、信号(Signal)、信号量(Semaphore)、消息队列(Message)和共享内存(Shared Memory)。信号量、消息队列和共享内存称为：IPC机制（Inter Process Communication）
    不同计算机之间的进程之间通信可以使用套接字技术（Socket）。

一、信号

基本概念:

    软中断信号（signal，又简称为信号）用来通知进程发生了异步事件。进程之间可以互相通过系统调用kill发送软中断信号。内核也可以因为内部事件而给进程发送信号，通知进程发生了某个事件。注意，信号只是用来通知某进程发生了什么事件，并不给该进程传递任何数据。 
    信号是进程间通信机制唯一的异步通信机制。一个进程不必通过任何操作等待信号的到达。使用kill命令来结束进程就是通过信号实现的。

常用信号及解释：

信号名称	信号值	解释
SIGHUP	1	由于终端挂起或者控制进程终止而发出的信号
SIGINT	2	一般由键盘按键产生的中断信号，比如按下Ctrl+c组合键
SIGQUIT	3	一般由键盘的退出键被按下而产生的结束信号。比如Ctrl+\组合键
SIGILL	4	非法指令
SIGABRT	6	由abort()函数发出的退出指令，收到SIGABRT信号，说 明检测出程序是有问题。
SIGKILL	9	不能被捕捉或忽略的信息，一般用来强行结束异常进程
SIGUSR1	10	用户自定义信号1，进程可以使用这个信号进行通信
SIGSEGV	11	内存引用无效
SIGCHLD	17	子进程结束信号
…	…	…

信号处理的具体函数:

#include <signal.h>
/*******
* 用法：signal(signum信号类型, 函数句柄);
* 在调用中，参数signum指出要设置处理方法的信号。或者是
* SIG_IGN（忽略参数signum所指的信号）
* SIG_DFL（恢复参数signum所指信号的处理方法为默认值） 
*/
void (*signal(int sig, void (*func)(int)))(int);

/*******
* 用法：sigaction(要检测或修改其具体动作的信号, 指向sigaction的一个实例指针, 指向对象用来保存原来对相应信号的处理，可指定oldact为NULL)
* 检查和改变一个行动的信号
*/
int sigaction(int sig, const struct sigaction *restrict act, struct sigaction *restrict oact);

程序实现:

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/time.h>

void SignalHandle(int signal)
{
    switch(signal)
    {
    case SIGHUP:
        printf("Catch Signal : SIGHUP (%d) \n", signal);
        break;
    case SIGINT:
        printf("Catch Signal : SIGINT (%d) \n", signal);
        break;
    case SIGQUIT:
        printf("Catch Signal : SIGQUIT (%d) \n", signal);
        break;
    case SIGALRM:
        printf("Catch Signal : SIGALRM (%d) \n", signal);
        break;
    case SIGSTOP:
        printf("Catch Signal : SIGSTOP (%d) \n", signal);
        break;
    }
}

int main()
{
    int sec_delay = 5;

    printf("Curent Process ID : %d\n", (int)getpid());

    signal(SIGINT, SignalHandle);
    signal(SIGQUIT, SignalHandle);
    signal(SIGALRM, SignalHandle);

    alarm(sec_delay);

    while(1);
    pause();

    return 0;
}

---

二、管道

    管道：指进程直接进行数据交换的通道，可分为普通管道(Pipe)和命名管道(FIFO)。通过内核缓冲区按先进先出的方式进行数据传输。管道一端顺序地写入数据，另一端顺序地读入数据。管道是半双工，数据只能向一个方向流动；要双方通信时需要建立两个管道。
    对命名管道操作与文件操作相似。
    一般使用mkfifo()函数创建命名管道文件，函数定义如下：

/*******
* 参数一pathname：是文件路径名称
* 参数二mode：打开普通文件的open()函数中的mode
*/
int mkfifo(const char *pathname,mode_t mode);

打开方式

Tables	Are
O_RDONLY	只读方式打开
O_WRONLY	只写方式打开
O_RDONLY | O_NONBLOCK	只读且非阻塞的方式打开
O_ WRONLY | O_NONBLOCK	只读且非阻塞的方式打开

注意: PIPE_BUF值 对应头文件 limits.h。数据长度不能大于管道缓冲区长度，一般为4096。

代码实现:

// 发送部分
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define FIFO_HANDLE_NAME "/tmp/fifo_handle  "
#define FIFO_CLIENT_NAME "/tmp/fifo_client_%d"

struct ps_fifo_struct{
    pid_t pid;
    char str[64];
};

int main ()
{
    int fifo_handle, fifo_client;
    struct ps_fifo_struct ps_fifo;
    char client_fifo_name[64];

    fifo_handle = open(FIFO_HANDLE_NAME, O_WRONLY); //以只写方式打开目标文件

        if(fifo_handle == -1)
    {
        fprintf(stderr, "Open Handle fifo failed. \n");
        exit(EXIT_FAILURE);
    }

    ps_fifo.pid = getpid();
    memset(client_fifo_name, 0, 64);
    sprintf(client_fifo_name, FIFO_CLIENT_NAME, ps_fifo.pid);

    if(access(client_fifo_name,F_OK) == -1)
    {
        if(mkfifo(client_fifo_name, 0777) != 0)
        {
            fprintf(stderr, "Could Not Create FIFO %s \n", client_fifo_name);
            exit(EXIT_FAILURE);
        }
    }

    sprintf(ps_fifo.str, "Hello I am %d.", ps_fifo.pid);
    printf("%d sent:\'%s\'. \n", ps_fifo.pid, ps_fifo.str);
    write(fifo_handle, &ps_fifo, sizeof(ps_fifo));
    fifo_client = open(client_fifo_name, O_RDONLY);

    if(fifo_client != -1)
    {
        if(read(fifo_client, &ps_fifo, sizeof(ps_fifo)) > 0)
        {
            printf("received from %d : %s \n", ps_fifo.pid, ps_fifo.str);
            close(fifo_client);
        }
    }

    close(fifo_handle);
    unlink(client_fifo_name);
    exit(EXIT_SUCCESS);

    return 0;
}

// 接收部分
#include <unistd.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define FIFO_HANDLE_NAME "/tmp/fifo_handle  "
#define FIFO_CLIENT_NAME "/tmp/fifo_client_%d"

struct ps_fifo_strcut
{
    pid_t pid;
    char str[64];
};

int main()
{
    int fifo_handle, fifo_client;
    struct ps_fifo_strcut ps_fifo;
    char client_fifo_name[64];
    int read_len;
    char answer_str[64];

    if (access(FIFO_HANDLE_NAME, F_OK) == -1)
    {
        if (mkfifo(FIFO_HANDLE_NAME, 0777) != 0)
        {
            fprintf(stderr, "Could Not Create FIFO %s\n", FIFO_HANDLE_NAME);
            exit(EXIT_FAILURE);
        }
    }

    fifo_handle = open(FIFO_HANDLE_NAME, O_RDONLY);
    if (fifo_handle == -1)
    {
        fprintf(stderr, "Handle FIFO failure.\n");
        exit(EXIT_FAILURE);
    }

    do
    {
        read_len = read(fifo_handle, &ps_fifo, sizeof(ps_fifo));
        memset(answer_str, 0, 64);
        if (read_len > 0)
        {
            sprintf(answer_str, "hello, %d I have received the string : '%s'.\n", ps_fifo.pid, ps_fifo.str);
            memset(client_fifo_name, 0, 64);
            sprintf(client_fifo_name, FIFO_CLIENT_NAME, ps_fifo.pid);
            fifo_client = open(client_fifo_name, O_WRONLY);
            ps_fifo.pid = getpid();
            if (fifo_client != -1)
            {
                write(fifo_client, &ps_fifo, sizeof(ps_fifo));
                close(fifo_client);
            }
        }
    } while (/*read_len > 0*/1);

    close(fifo_handle);
    unlink(FIFO_HANDLE_NAME);
    exit(EXIT_SUCCESS);

    return 0;
}