第八章 异常控制流

#include <sys/type.h>  
#include <unistd.h>  
pid_t getpid();   // 返回调用者PID,Linux系统中pid_t被定义为int  
pid_t getppid();  // 返回父进程的PID  

#include <stdlib.h>  
void exit(int status);  // 以status退出状态来终止进程  

#include <sys/type.h>  
#include <unistd.h>  
pid_t fork();  // 子进程返回0，父进程返回子进程PID，出错返回-1  

#include <sys/types.h>  
#include <sys/wait.h>  
// 成功时返回子进程的PID且该进程被系统回收，options取WNOHANG时返回0，其他错误返回-1  
// 默认情况(options=0)：waitpid挂起调用进程的执行，直到它的等待集合中的一个子进程终止  
// 等待集合中的一个进程如果在调用waitpid之前就已经终止，那么waitpid就立即返回  
// pid>0时等待集合就是进程ID等于pid的子进程，pid=-1时等待集合由父进程的所有子进程组成  
// options可设为常量WNOHANG,WUNTRACED和WCONTINUED的组合，可以修改waitpid的默认行为  
// statusp参数非空时，waitpid会在status中放上关于导致返回子进程的状态信息  
// 调用进程没有子进程时waitpid返回-1，且设置全局变量errno为ECHILD  
// 如果waitpid被一个信号中断时返回-1，且设置全局变量errno为EINTR  
// Unix函数的man页列出了使用该函数需要包含的头文件  
pid_t waitpid(pid_t pid, int *statusp, int options);  

// waitpid的简单版本，wait(&status)等价于waitpid(-1, &status, 0)  
pid_t wait(int *statusp);  

#include <unistd.h>  
unsigned int sleep(unsigned int secs);   // 挂起进程secs秒，返回还要休眠的秒数  
unsigned int pause();  // 让进程休眠，总是返回-1  

#include <unistd.h>  
// 执行成功则不返回，错误则返回-1  
int execve(const char *filename, const char *argv[], const char *envp[]);  

int main(int argc, char **argv, char **envp);  

#include <stdlib.h>  
char *getenv(const char *name);  // 存在则返回指向name的指针，否则返回NULL  
int setenv(const char *name, const char *newvalue, int overwrite);  // 成功返回0， 错误返回-1  
void unsetenv(const char *name);  // 无返回  

#include "csapp.h"  
#define MAXARGS 128  

/* Function prototypes */  
void eval(char *cmdlines);  
int parseline(char *buf, char **argv);  
int builtin_command(char **argv);  

int main()  
{  
    char cmdline[MAXLINE];  /* Command line */  
    while(1)  
    {  
        /* Read */  
        printf("> ");  
        Fgets(cmdline, MAXLINE, stdin);  
        if(feof(stdin))  
            exit(0);  
        /* Evaluate */  
        eval(cmdline);  
    }  
}  

void eval(char *cmdline)  
{  
    char *argv[MAXARGS];  /* Argument list execve() */  
    char buf[MAXLINE];    /* Holds modified command line */  
    int bg;               /* Should the job run in bg or fg? */  
    pid_t pid;            /* Process id */  
    strcpy(buf, cmdline);  
    bg = parseline(buf, argv);  
    if(argv[0] == NULL)  
        return;   /* Ignore empty lines */  
    if(!builtin_command(argv))  
    {  
        if((pid = Fork()) == 0)  /* Child runs user job */  
        {  
            if(execve(argv[0], argv, environ) < 0)  
            {  
                printf("%s: Command not found.\n", argv[0]);  
                exit(0);  
            }  
        }  
        /* Parent waits for foreground job to terminate */  
        if(!bg)  
        {  
            int status;  
            if(waitpid(pid, &status, 0) < 0)  
                unix_error("waitfg: waitpid error");  
            else  
                printf("pid %d is terminated\n", pid);  
        }  
        else  
            printf("%d %s\n", pid, cmdline);  
    }  
    return;  
}  

/* If first arg is a builtin command, run it and return true */  
int builtin_command(char **argv)  
{  
    if(!strcmp(argv[0], "quit"))  /* quit command */  
        exit(0);  
    if(!strcmp(argv[0], "&")) /* Ignore singleton*/  
        return 1;  
    return 0;          /* Not a builtin command */  
}  

/* parseline - Parse the command line and build the argv array */  
int parseline(char *buf, char **argv)  
{  
    char *delim;   /* Points to first space delimiter */  
    int argc;      /* Number of args */  
    int bg;        /* Background job? */  
    buf[strlen(buf)-1] = ' ';  /* Replace trailing '\n' with space */  
    while(*buf && (*buf == ' '))  /* Ignore leading space */  
        ++buf;  
    /* Build the argv list */  
    argc = 0;  
    while((delim = strchr(buf, ' ')))  
    {  
        argv[argc++] = buf;  
        *delim = '\0';  
        buf = delim + 1;  
        while(*buf && (*buf == ' '))  /* Ignore space */  
            ++buf;  
    }  
    argv[argc] = NULL;  
    if(argc == 0)  /* Ignore blank line */  
        return 1;  
    /* Should the job run in the background? */  
    if((bg = (*argv[argc-1] == '&')) != 0)  
        argv[--argc] = NULL;  
    return bg;  
}  

#include <unistd.h>  
pid_t getgrp();  // 返回调用进程的进程组ID  

#include <unistd.h>  
// pid为0时，表示使用当前进程的pid；pgid为0时，就用pid指定的进程的PID作为进程组ID  
int setpgid(pid_t pid, pid_t pgid);  // 成功则返回0，错误返回-1  

#include <sys/types.h>  
#include <signal.h>  
// pid大于0时，发送信号号码sig给进程pid  
// pid等于0时，发送信号sig给调用进程所在进程组中的每个进程，包括调用进程自己  
// pid小于0时，发送信号sig给进程组|pid|中的每个进程  
// 成功时返回0，错误则返回-1  
int kill(pid_t pid, int sig);  

#include <unistd.h>  
// 安排内核在secs秒后发送一个SIGALRM信号给调用进程，secs为0时不会调度安排新的闹钟  
// 返回前一次闹钟剩余的秒数，以前如果没有设定闹钟，则返回0  
unsigned int alarm(unsigned int secs);  

#include <signal.h>  
typedef void (*sighandler_t)(int);   // 函数指针  
// 成功时返回指向前次处理程序的指针，出错为SIG_ERR(不设置errno)  
sighandler_t signal(int signum, sighandler_t handler);  

#include <signal.h>  
// 成功返回0， 出错返回-1  
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);  
// 初始化set为空集合  
int sigemptyset(sigset_t *set);  
// 把所有信号都添加到set中  
int sigfillset(sigset_t *set);  
// 把signum添加到set  
int sigaddset(sigset_t *set, int signum);  
// 从set中删除signum  
int sigdelset(sigset_t *set, int signum);  
//signum是set的成员则返回1，不是返回0，出错返回-1  
int sigismember(const sigset_t *set, int signum);  

// 临时阻塞接收一个信号  
sigset_t mask, prev_mask;  
Sigemptyset(&mask);  
Sigaddset(&mask, SIGINT);  
// Block SIGINT and save previous blocked set  
Sigprocmask(SIG_BLOCK, &mask, &prev_mask);  
//... Code region that will not be interrupted by SIGINT  
// Restore previous blocked set  
Sigprocmask(SIG_SETMASK, &prev_mask, NULL);  

#include <signal.h>  
int sigsuspend(const sigset_t *mask);  
// 等价于下述代码的原子的版本(不可中断)  
// sigprocmask(SIG_SETMASK, &mask, &prev);  
// pause();  
// sigprocmask(SIG_SETMASK, &prev, NULL);