【linux】系統程式設計-1-程序、管道和信号

目錄

• 前言
• 1. 程序
  • 1.1 概念
  • 1.2 檢視程序
  • 1.3 啟動新程序
    • 1.3.1 system() 函數
    • 1.3.2 fork() 函數
    • 1.3.2 exce 系列函數
      • 1.3.2.1 exce 系列函數說明
  • 1.3 終止程序
  • 1.4 等待程序
    • 1.4.1 wait() 函數
    • 1.4.2 waitpid() 函數
• 2. 管道
  • 2.1 概念
  • 2.2 匿名管道
    • 2.2.1 匿名管道特征
    • 2.2.2 pipe() 函數
  • 2.3 命名管道
    • 2.3.1 命名管道特征
    • 2.3.2 建立命名管道指令
    • 2.3.3 fifo() 函數
• 3. 信号
  • 3.1 概念及特征
  • 3.2 系統支援的信号
  • 3.3 信号處理
  • 3.4 發送信号函數
    • 3.4.1 kill()
    • 3.4.2 raise()
    • 3.4.3 alarm()
  • 3.5 捕獲信号函數
    • 3.5.1 signal()
    • 3.5.2 sigaction() *
  • 3.6 信号集
  • 3.7 例子
• 參考

• 李柱明部落格：https://www.cnblogs.com/lizhuming/
• 本文連結：https://www.cnblogs.com/lizhuming/p/14203037.html

• 程式
  • 程式是存放在存儲媒體上的一個可執行檔案
• 程序
  • 程序是程式執行的過程，是程式在執行過程中配置設定和管理資源的基本機關
  • 程式是靜态的，程序是動态的。程序的狀态是變化的，其包括程序的建立、排程和消亡
• 線程
  • 線程是CPU排程和分派的基本機關，它可與同屬一個程序的其他的線程共享程序所擁有的全部資源
  • 一個線程隻能屬于一個程序，而一個程序可以有多個線程，但至少有一個線程
• 程序ID
  • 程序ID 是一個16位的正整數，預設取值範圍是從 2 到 32768（可以修改）
  • PID數字為1的值一般是為特殊程序 init 保留
• 父程序
  • 任何程序（除init程序）都是由另一個程序啟動，該程序稱為被啟動程序的父程序（ID号稱為：PID），被啟動的程序稱為子程序（ID号稱為：PPID），
  • 父程序号無法在使用者層修改

• 檢視程序指令

  • ps -aux

    • 檢視系統程序

  • pstree

    • 将程序以樹狀關系列出來

• 介紹三種方法啟動新程序
  1. system() 函數
  2. fork() 函數
  3. exec() 函數

• 可以了解為 啟動新程序
• system()啟動了一個運作着/bin/sh的子程序
  • 說明 system() 函數依賴與 shell

• int system (const char *string )

  • 效果就相當于執行

    sh –c string

• system() 函數的特點
  • 建立獨立程序，擁有獨立的代碼空間，記憶體空間
  • 等待新的程序執行完畢，system才傳回。(阻塞)
• 例程
  • system 運作完才會傳回，才會在目前終端列印出資料

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    pid_t result;
    printf("This is a system demo!\n\n");
    /*調用 system()函數*/
    result = system("ls -l");
    printf("Done!\n\n");
    return result;
}
           

• 可以了解為 複制程序
• 頭檔案

  1. #include<unistd.h>

  2. #include<sys/types.h>

• pid_t fork( void);

  • 若成功調用一次則
    • 子程序傳回 0
    • 父程序傳回子程序 ID
  • 出錯傳回 -1

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    pid_t result;
    printf("This is a fork demo!\n\n");
    /*調用 fork()函數*/
    result = fork();
    /*通過 result 的值來判斷 fork()函數的傳回情況，首先進行出錯處理*/
    if(result == -1) {
        printf("Fork error\n");
    }
    /*傳回值為 0 代表子程序*/
    else if (result == 0) {
        printf("The returned value is %d, In child process!! My PID is %d\n\n", result, getpid());
    }
    /*傳回值大于 0 代表父程序*/
    else {
        printf("The returned value is %d, In father process!! My PID is %d\n\n", result, getpid());
    }
    return result;}
           

• 可以了解為 替換程序
• 調用 exec 并不建立新程序，是以前後的程序 ID 并未改變
• exec 隻是用另一個新程式替換了目前程序的正文、資料、堆和棧段
• 在原程序中已經打開的檔案描述符，在新程序中仍将保持打開，除非它們的“執行時關閉标志”（close on exec flag）被置位
• 任何在原程序中已打開的目錄流都将在新程序中被關閉
• 舉個例子，A程序調用 exce 系列函數啟動一個程序B，此時程序B會替換程序A，程序A的記憶體空間、資料段、代碼段等内容都将被程序B占用，程序A将不複存在

• exec 系列函數有 6 個不同的 exec 函數

  1. int execl(const char *path, const char *arg, ...)

  2. int execlp(const char *file, const char *arg, ...)

  3. int execle(const char *path, const char *arg, ..., char *const envp[])

  4. int execv(const char *path, char *const argv[])

  5. int execvp(const char *file, char *const argv[])

  6. int execve(const char *path, char *const argv[], char *const envp[])

• 函數說明
  • 名稱包含 l 字母的函數（execl、 execlp 和execle）接收參數清單”list”作為調用程式的參數
  • 名稱包含 p 字母的函數（execvp 和execlp）接受一個程式名作為參數，然後在目前的執行路徑中搜尋并執行這個程式
  • 名字不包含 p 字母的函數在調用時必須指定程式的完整路徑，其實就是在系統環境變量”PATH”搜尋可執行檔案
  • 名稱包含 v 字母的函數（execv、execvp 和 execve）的指令參數通過一個數組”vector”傳入
  • 名稱包含 e 字母的函數（execve 和 execle）比其它函數多接收一個指明環境變量清單的參數，并且可以通過參數envp傳遞字元串數組作為新程式的環境變量，這個envp參數的格式應為一個以 NULL 指針作為結束标記的字元串數組，每個字元串應該表示為”environment =virables”的形式

• 可以分為 5 種程序終止
  • 正常終止
    • 從 main 函數傳回
    • 調用 exit() 終止
    • 調用 _exit() 函數終止
  • 異常終止
    • 調用 abort() 函數終止
    • 由系統信号終止

• 父程序中調用wait()或者waitpid()函數讓父程序等待子程序的結束

• wait()函數隻是 waitpid() 函數的一個特例，在 Linux内部實作 wait 函數時直接調用的就是 waitpid 函數

• pid_t wait(int *wstatus);

  • wait() 函數在被調用的時候，系統将暫停父程序的執行，直到有信号來到或子程序結束
  • 如果在調用 wait() 函數時子程序已經結束，則會立即傳回子程序結束狀态值
  • 子程序的結束狀态資訊會由參數wstatus傳回
  • 該函數的傳回值為子程序的PID
• 注意
  • wait()要與fork()配套出現，且 fork() 調用先
  • 參數wstatus用來儲存被收集程序退出時的一些狀态
• 可以使用以下宏來判斷退出狀态
  • WIFEXITED(status) ：如果子程序正常結束，傳回一個非零值
  • WEXITSTATUS(status)： 如果WIFEXITED非零，傳回子程序退出碼
  • WIFSIGNALED(status) ：子程序因為捕獲信号而終止，傳回非零值
  • WTERMSIG(status) ：如果WIFSIGNALED非零，傳回信号代碼
  • WIFSTOPPED(status)： 如果子程序被暫停，傳回一個非零值
  • WSTOPSIG(status)： 如果WIFSTOPPED非零，傳回一個信号代碼

• pid_t waitpid(pid_t pid, int *wstatus, int options);

  • pid：參數pid為要等待的子程序ID
    • pid < -1：等待程序組号為pid絕對值的任何子程序
    • pid = -1：等待任何子程序，此時的waitpid()函數就等同于wait()函數
    • pid = 0：等待程序組号與目前程序相同的任何子程序，即等待任何與調用waitpid()函數的程序在同一個程序組的程序
    • pid > 0：等待指定程序号為pid的子程序
  • wstatus：與wait()函數一樣
  • options：參數 options 提供了一些另外的選項來控制waitpid()函數的行為。如果不想使用這些選項，則可以把這個參數設為0

• 管道
  • 管道是 Linux 由 Unix 那裡繼承過來的程序間的通信機制，它是Unix早期的一個重要通信機制。
  • 其思想是，在記憶體中建立一個共享檔案，進而使通信雙方利用這個共享檔案來傳遞資訊。由于這種方式具有單向傳遞資料的特點，是以這個作為傳遞消息的共享檔案就叫做“管道”
• 管道分類
  • 匿名管道（無名管道）（PIPE）
  • 命名管道（有名管道）（FIFO）

1. 沒有名字，是以不能使用 open() 函數打開，但可以使用 close() 函數關閉
2. 隻提供單向通信
3. 隻能用于具有血緣關系的程序間通信，通常用于父子程序建通信
4. 管道是基于位元組流來通信的
5. 依賴于檔案系統，它的生命周期随程序的結束而結束
6. 寫入操作不具有原子性，是以隻能用于一對一的簡單通信情形
7. 管道也可以看成是一種特殊的檔案，對于它的讀寫也可以使用普通的read()和write()等函數。但是它又不是普通的檔案，并不屬于其他任何檔案系統，并且隻存在于核心的記憶體空間中，是以不能使用lseek()來定位

• pipe() 函數用于建立一個匿名管道，一個可用于程序間通信的單向資料通道。

• • #include <unistd.h>

• 函數原型

  • int pipe(int pipefd[2]);

    • pipefd[0] 指向管道的 讀取 端
    • pipefd[1] 指向管道的 寫 端
    • 傳回 0：匿名管道建立成功
    • 傳回 -1：建立失敗
• 使用步驟
  1. 父程序調用 pipe() 函數建立匿名管道
  2. 父程序調用 fork() 函數啟動（建立）一個子程序
  3. 若想從父程序将資料傳遞給子程序
     1. 父程序：關閉讀取端
     2. 子程序：關閉寫端
  4. 若想從子程序将資料傳遞給父程序
     1. 父程序：關閉寫端
     2. 子程序：關閉讀取端
  5. 當不需要使用管道時，關閉所有端口即可

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_DATA_LEN 256
#define DELAY_TIME 1

int main()
{
    pid_t pid;
    int pipe_fd[2];                             //(1)
    char buf[MAX_DATA_LEN];
    const char data[] = "Pipe Test Program";
    int real_read, real_write;

    memset((void*)buf, 0, sizeof(buf));

    /* 建立管道 */
    if (pipe(pipe_fd) < 0)                  //(2)
    {
        printf("pipe create error\n");
        exit(1);
    }

    /* 建立一子程序 */
    if ((pid = fork()) == 0)
    {
        /* 子程序關閉寫描述符，并通過使子程序暫停 3s 等待父程序已關閉相應的讀描述符 */
        close(pipe_fd[1]);
        sleep(DELAY_TIME * 3);
        /* 子程序讀取管道内容 */ 
        if ((real_read = read(pipe_fd[0], buf, MAX_DATA_LEN)) > 0)
        {
            printf("%d bytes read from the pipe is '%s'\n", real_read, buf);
        }
        /* 關閉子程序讀描述符 */
        close(pipe_fd[0]);
        exit(0);
    }
    else if (pid > 0)
    {
        /* 父程序關閉讀描述符，并通過使父程序暫停 1s 等待子程序已關閉相應的寫描述符 */
        close(pipe_fd[0]);
        sleep(DELAY_TIME);
        if((real_write = write(pipe_fd[1], data, strlen(data))) != -1)
        {
            printf("Parent write %d bytes : '%s'\n", real_write, data);
        }
        /*關閉父程序寫描述符*/
        close(pipe_fd[1]);
        /*收集子程序退出資訊*/
        waitpid(pid, NULL, 0);
        exit(0);
    }
}
           

1. 有名字，存儲于普通檔案系統之中
2. 任何具有相應權限的程序都可以使用 open() 來擷取命名管道的檔案描述符
3. 跟普通檔案一樣：使用統一的 read()/write() 來讀寫
4. 跟普通檔案不同：不能使用 lseek() 來定位，原因是資料存儲于記憶體中
5. 具有寫入原子性，支援多寫者同時進行寫操作而資料不會互相踐踏
6. 遵循先進先出（First In First Out）原則，最先被寫入 FIFO 的資料，最先被讀出來

• mkfifo

  • 如

    mkfifo test

    • test 檔案為命名管道檔案

• fifo() 函數

• • #include <unistd.h>

• • int mkfifo(const char * pathname,mode_t mode);

    • pathname：命名管道檔案
    • mode：
      • O_RDONLY：讀管道
      • O_WRONLY：寫管道
      • O_RDWR：讀寫管道
      • O_NONBLOCK：非阻塞
      • O_CREAT：如果該檔案不存在，那麼就建立一個新的檔案，并用第三個參數為其設定權限
      • O_EXCL：如果使用 O_CREAT 時檔案存在，那麼可傳回錯誤消息
    • 傳回值：
      • 0：成功
      • EACCESS：參數 filename 所指定的目錄路徑無可執行的權限
      • EEXIST：參數 filename 所指定的檔案已存在
      • ENAMETOOLONG：參數 filename 的路徑名稱太長
      • ENOENT：參數 filename 包含的目錄不存在
      • ENOSPC：檔案系統的剩餘空間不足
      • ENOTDIR：參數 filename 路徑中的目錄存在但卻非真正的目錄
      • EROFS：參數 filename 指定的檔案存在于隻讀檔案系統内

#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>

#define MYFIFO "myfifo"    /* 命名管道檔案名*/

#define MAX_BUFFER_SIZE PIPE_BUF /* 4096 定義在于 limits.h 中*/

void fifo_read(void)
{
    char buff[MAX_BUFFER_SIZE];
    int fd;
    int nread;

    printf("***************** read fifo ************************\n");
    /* 判斷命名管道是否已存在，若尚未建立，則以相應的權限建立*/
    if (access(MYFIFO, F_OK) == -1)
    {
        if ((mkfifo(MYFIFO, 0666) < 0) && (errno != EEXIST))
        {
            printf("Cannot create fifo file\n");
            exit(1);
        }
    }
    /* 以隻讀阻塞方式打開命名管道 */
    fd = open(MYFIFO, O_RDONLY);
    if (fd == -1)
    {
        printf("Open fifo file error\n");
        exit(1);
    }
    memset(buff, 0, sizeof(buff));
    if ((nread = read(fd, buff, MAX_BUFFER_SIZE)) > 0)
    {
        printf("Read '%s' from FIFO\n", buff);
    }
    printf("***************** close fifo ************************\n");
    close(fd);
    exit(0);
}

void fifo_write(void)
{
    int fd;
    char buff[] = "this is a fifo test demo";
    int nwrite;
    sleep(2);   //等待子程序先運作
    /* 以隻寫阻塞方式打開 FIFO 管道 */
    fd = open(MYFIFO, O_WRONLY | O_CREAT, 0644);
    if (fd == -1)
    {
        printf("Open fifo file error\n");
        exit(1);
    }
    printf("Write '%s' to FIFO\n", buff);
    /*向管道中寫入字元串*/
    nwrite = write(fd, buff, MAX_BUFFER_SIZE);
    if(wait(NULL))  //等待子程序退出
    {
        close(fd);
        exit(0);
    }
}

int main()
{
    pid_t result;
    /*調用 fork()函數*/
    result = fork();
    /*通過 result 的值來判斷 fork() 函數的傳回情況，首先進行出錯處理*/
    if(result == -1)
    {
        printf("Fork error\n");
    }
    else if (result == 0) /*傳回值為 0 代表子程序*/
    {
        fifo_read();
    }
    else /*傳回值大于 0 代表父程序*/
    {
        fifo_write();
    }
    return result;
}
           

• 信号（signal）
  • 又稱為軟中斷信号，用于通知程序發生了異步事件
  • 它是Linux系統響應某些條件而産生的一個事件
  • 它是在軟體層次上對中斷機制的一種模拟
  • 是一種異步通信方式
  • 在原理上，一個程序收到一個信号與處理器收到一個中斷請求可以說是一樣的
• 信号是程序間通信機制中唯一的異步通信機制
• 信号産生
  • 信号可能是由于系統中某些錯誤而産生
  • 也可以是某個程序主動生成的一個信号

• 查詢系統支援的信号種類指令：

  kill -l

• linux支援62種信号（沒有 32 号和 33 号信号）
  • 非實時信号（不可靠）：1-32
    • 沒有排隊功能，信号可能被丢棄
    • 不會立即執行
    • 先放入該程序控制塊（PCB），待合适的時候處理
  • 實時信号（可靠信号）：34-64
    • 有排隊功能

• 信号類似可分為三大類型：程式錯誤、外部事件以及顯式請求
• 當信号發生時，信号可以采取如下三種操作：
  • 忽略信号（SIGTOP 和 SIGKILL 是絕不能被忽略的）
  • 捕獲信号
  • 讓預設信号起作用
    • 終止程序并且生成記憶體轉儲檔案
    • 終止終止程序但不生成core檔案
    • 忽略信号
    • 暫停程序
    • 若程序是暫時暫停，恢複程序，否則将忽略信号

• kill()
• raise()
• alarm()

• 指令：

  kill [信号或選項] PID(s)

• 函數
  • 頭檔案：

    #include <sys/types.h>
    #include <signal.h>
               

  • 函數原型：

    int kill(pid_t pid, int sig);

    • pid 取值如下
      • pid > 1：将信号sig發送到程序ID值為pid指定的程序
      • pid = 0：信号被發送到所有和目前程序在同一個程序組的程序
      • pid = -1：将sig發送到系統中所有的程序，但程序1（init）除外
      • pid < -1：将信号sig發送給程序組号為-pid （pid絕對值）的每一個程序
    • sig 為 信号值
    • 傳回值
      • 0：發送成功
      • -1：發送失敗

• raise() 函數為程序向自身發送信号

• • #include <signal.h>
               

  • int raise(int sig);

• alarm() 稱為鬧鐘函數，設定時間為 seconds 秒，時間到後，它就向程序發送SIGALARM信号。在時間未到時便重新調用 alarm() 函數，會更新到時值。

• • #include <unistd.h>
               

  • unsigned int alarm(unsigned int seconds);

• signal()、sigaction()等函數

• signal()主要是用于捕獲信号，可以改變程序中對信号的預設行為

• • #include <signal.h>
               

  • typedef void (*sighandler_t)(int);
    sighandler_t signal(int signum, sighandler_t handler);
               

  • signum 是指定捕獲的信号，如果指定的是一個無效的信号，或者嘗試處理的信号是不可捕獲或不可忽略的信号（如SIGKILL），errno将被設定為EINVAL
  • handler 是一個函數指針，它的類型是

    void(*sighandler_t)(int)

    類型
  • handler 也可以是一個宏定義
    • SIG_IGN：忽略該信号
    • SIG_DFL：采用系統預設方式處理信号

• 不推薦讀者使用signal()，而推薦使用

  sigaction();

• • #include <signal.h>
               

  • int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

    • signum：指定捕獲的信号值
    • act：是一個結構體
      • sa_handler 是一個函數指針，是捕獲信号後的處理函數
      • sa_sigaction 是擴充信号處理函數，它也是一個函數指針，不僅可以接收到int 型的信号值，還會接收到一個 siginfo_t 類 型的結構體指針，還有一個void類型的指針，還有需要注意的就是，不要同時使用 sa_handler 和 sa_sigaction，因為這兩個處理函數是有聯合的部分（聯合體）
      • sa_mask 是信号掩碼，它指定了在執行信号處理函數期間阻塞的信号的掩碼，被設定在該掩碼中的信号，在程序響應信号期間被臨時阻塞。除非使用 SA_NODEFER 标志，否則即使是目前正在處理的響應的信号再次到來的時候也會被阻塞
      • re_restorer 則是一個已經廢棄的成員變量，不要使用
      • oldact 傳回原有的信号處理參數，一般設定為NULL即可
      • sa_flags 是指定一系列用于修改信号處理過程行為的标志
        • SA_NOCLDSTOP 使父程序在它的子程序暫停或繼續運作時不會收到 SIGCHLD 信号。即當它們接收到SIGSTOP、SIGTSTP、SIGTTIN或SIGTTOU（停止）中的一種時或接收到SIGCONT（恢複）時，父程序不會收到通知
        • SA_NOCLDWAIT 從Linux 2.6開始就存在這個标志了，它表示父程序在它的子程序終止時不會收到 SIGCHLD 信号，這時子程序終止則不會成為僵屍程序。
        • SA_NODEFER 一般情況下， 當信号處理函數運作時，核心将阻塞該給定信号。但是如果設定了 SA_NODEFER标記， 那麼在該信号處理函數運作時，核心将不會阻塞該信号
        • SA_RESETHAND 信号處理之後重新設定為預設的處理方式。
        • SA_SIGINFO 從Linux 2.2開始就存在這個标志了，使用 sa_sigaction成員而不是使用sa_handler 成員作為信号處理函數。

      struct sigaction {
                               void     (*sa_handler)(int);
                               void     (*sa_sigaction)(int, siginfo_t *, void *);
                               sigset_t   sa_mask;
                               int        sa_flags;
                               void     (*sa_restorer)(void);
           };
                 

      • siginfo_t

      siginfo_t {
         int      si_signo;     /* 信号數值 */
         int      si_errno;     /* 錯誤值 */
         int      si_code;      /* 信号代碼 */
         int      si_trapno;   /*導緻硬體生成信号的陷阱号，在大多數體系結構中未使用*/
         pid_t    si_pid;       /* 發送信号的程序ID */
         uid_t    si_uid;       /*發送信号的真實使用者ID */
         int      si_status;    /* 退出值或信号狀态*/
         clock_t  si_utime;     /*消耗的使用者時間*/
         clock_t  si_stime;     /*消耗的系統時間*/
         sigval_t si_value;     /*信号值*/
         int      si_int;       /* POSIX.1b 信号*/
         void    *si_ptr;
         int      si_overrun;   /*計時器溢出計數*/
         int      si_timerid;   /* 計時器ID */
         void    *si_addr;      /*導緻故障的記憶體位置 */
         long     si_band;
         int      si_fd;        /* 檔案描述符*/
         short    si_addr_lsb;  /*位址的最低有效位 (從Linux 2.6.32開始存在) */
         void    *si_lower;     /*位址沖突時的下限*/
         void    *si_upper;     /*位址沖突時的上限 (從Linux 3.19開始存在) */
         int      si_pkey;      /*導緻的PTE上的保護密鑰*/
         void    *si_call_addr; /*系統調用指令的位址*/
         int      si_syscall;   /*嘗試的系統調用次數*/
         unsigned int si_arch;  /* 嘗試的系統調用的體系結構*/
      }
                 

• 資料類型 sigset_t 是信号集，信号掩碼就是這種類型

• #include <signal.h>

• 1. int sigemptyset(sigset_t *set);

     • 将信号集初始化為空，使程序不會屏蔽任何信号

  2. int sigfillset(sigset_t *set);

     • 将信号集初始化為包含所有已定義的信号

  3. int sigaddset(sigset_t *set, int signum);

     • 添加一個信号到信号集中

  4. int sigdelset(sigset_t *set, int signum);

     • 從信号集中删除一個信号

  5. int sigismember(const sigset_t *set, int signum);

     • 判斷一個信号是否在信号集中
• 注意：
  • 一個應用程式，在使用信号集前，必須對其進行初始化，即是調用 sigemptyset() 或 sigfillset()

• 例程來自野火
• 實驗現象

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

/** 信号處理函數 **/void signal_handler(int sig)                    //(1){
    printf("\nthis signal numble is %d \n",sig);
    if (sig == SIGINT) {
        printf("I have get SIGINT!\n\n");
        printf("The signal is automatically restored to the default handler!\n\n");
        /** 信号自動恢複為預設處理函數 **/
    }

}
int main(void){
    struct sigaction act;
    printf("this is sigaction function test demo!\n\n");
    /** 設定信号處理的回調函數 */
    act.sa_handler = signal_handler;
    /* 清空屏蔽信号集 */
    sigemptyset(&act.sa_mask);
    /** 在處理完信号後恢複預設信号處理 */
    act.sa_flags = SA_RESETHAND;
    sigaction(SIGINT, &act, NULL);
    while (1)
    {
        printf("waiting for the SIGINT signal , please enter \"ctrl + c\"...\n\n");
        sleep(1);
    }
    exit(0);
}
           

* 野火