Linx系统编程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

int main(){
    int ret;
    ret = close(10);
    if(ret == -1){
        perror("close error");
    }
    if(ret == -1){
        fprintf(stderr, "close error: %s\n", strerror(errno));
    }
    printf("EINTR desc =  %s\n", strerror(EINTR));  // 系统调用被中断
    // man 2 close
    // E2BIG 参数列表太长   EACCESS 权限不足 EAGAIN 重试 EBADF 错误的文件描述符 EBUSY 设备或资源忙 ECHILD 无子进程     
    // EDOM 数学参数不在函数域内 EEXIST 文件已存在 EFAULT 地址错误 EFBIG 文件太大 EINTR 系统调用被中断
    return 0;
}

1
2
3
4

# 输出
close error: Bad file descriptor
close error: Bad file descriptor
EINTR desc =  Interrupted system call

1
2
3
4
5
6
7

#include <stdlib.h>
#include <stdio.h>

int main(){
    printf("fileno(stdin) = %d\n", fileno(stdin));
    return 0;
}

1
2

# 输出
fileno(stdin) = 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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

// #define ERR_EXIT(m) (perror(m),  exit(EXIT_FAILURE))
#define ERR_EXIT(m)            \
      do                       \
      {                        \
        perror(m);             \
        exit(EXIT_FAILURE);    \
      } while(0)

int main(){
    int fd;
    fd = open("test.txt", O_RDONLY);
    /*
    if(fd == -1){
        fprintf(stderr, "open error with errno=%d %s\n", errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    */
    /*
    if(fd == -1){
        perror("open error");
        exit(EXIT_FAILURE);
    }
    */
    if(fd == -1){
        ERR_EXIT("open error");
    }
    close(fd);
    return 0;
}

1
2

# 输出
open error: No such file or directory

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

CXX = gcc
CXXFLAGS = -c -Wall -g

TARGETS = open
SRCS = $(wildcard *.c)
OBJS = $(patsubst %.c, %.o, $(SRCS))

all: $(TARGETS)

$(TARGETS): %: %.o
	$(CXX) -o $@ $^

%.o: %.c
	$(CXX) $(CXXFLAGS) $< -o $@

.PHONY: clean
clean:
	rm -f *.o $(TARGETS)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#define BUFF_SIZE 1024
#define ERR_EXIT(m)            \
    do {                       \
        perror(m);             \
        exit(EXIT_FAILURE);    \
    } while(0)

int main(int argc, char *argv[]){
    int infd, outfd;
    if (argc != 3){
        fprintf(stderr, "Usage %s src dest\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    infd = open(argv[1], O_RDONLY);
    if ((infd = open(argv[1], O_RDONLY)) == -1){
        ERR_EXIT("open src file error");
    }
    if ((outfd = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0644)) == -1){ // 等价creat()，creat不多见了
        ERR_EXIT("open std file error");
    }
    char buff[BUFF_SIZE];
    int numRead;
    while ((numRead = read(infd, buff, BUFF_SIZE)) > 0) {
        write(outfd, buff, numRead);
    }
    if (close(infd) == -1){
        ERR_EXIT("close src file error");
    }
    if (close(outfd) == -1){
        ERR_EXIT("close dst file error");
    }
    exit(EXIT_SUCCESS);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

int main(){
    int fd;
    fd = open("test.txt", O_RDONLY);
    if (fd == -1){
        ERR_EXIT("open error");
    }
    char buf[1024] = {0};
    int ret = read(fd, buf, 5);
    if (ret == -1){
        ERR_EXIT("read error");
    }
    printf("buf = %s \n", buf);
    ret = lseek(fd, 0, SEEK_CUR);
    if(ret == -1){
        ERR_EXIT("lseek");
    }
    printf("current offset = %d \n", ret);
    close(fd);
    return 0;
}

int main(){
    int fd;
    fd = open("test.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd == -1){
        ERR_EXIT("open error");
    }
    write(fd, "hello", 5);
    int ret = lseek(fd, 1024*1024*1024, SEEK_CUR);
    if(ret == -1){
        ERR_EXIT("lseek");
    }
    write(fd, "world", 5);
    close(fd);
    return 0;
}
// od -c file 查看文件空格

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

int main(){
    DIR *dir = opendir(".");
    struct dirent *de;
    while((de = readdir(dir)) != NULL){
        if(strncmp(de->d_name, ".", 1) != 0){
            printf("%s  ", de->d_name);
        }
    }
    printf("\n");
    closedir(dir);
    exit(EXIT_SUCCESS);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#define MAJOR(a) (int)((unsigned short)a >> 8)
#define MINOR(a) (int)((unsigned short)a & 0xFF)

int filetype(struct stat *buf); // 使用 man 2 stat查看相关定义
void fileperm(struct stat *buf, char *perm); // 权限转成字符
int main(int argc, char *argv[]){
    if (argc != 2){
        fprintf(stderr, "Usage %s file\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    printf("File Name: %s \n", argv[1]);
    struct stat sbuf;
    if (lstat(argv[1], &sbuf) == -1){
        ERR_EXIT("stat error");
    }
    printf("File number: major %d, minor %d inode %d\n", MAJOR(sbuf.st_dev), MINOR(sbuf.st_dev), (int)sbuf.st_ino);
    // ls -li file 查看节点号
    if (filetype(&sbuf)){
        printf("Device number: major %d, min %d\n", MAJOR(sbuf.st_rdev), MINOR(sbuf.st_rdev));
    }
    char perm[11] = {0};
    fileperm(&sbuf, perm);
    printf("File permission bits=%o %s\n", sbuf.st_mode & 0777, perm);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

int filetype(struct stat *buf){
    int flag = 0;
    printf("Filetype: ");
    mode_t mode;  
    mode = buf->st_mode;
    switch (mode & S_IFMT){
        case S_IFSOCK:
            printf("socket\n");
            break;
        case S_IFLNK:
            printf("symbolic link\n");
            break;
        case S_IFREG:
            printf("regular file\n");
            break;
        case S_IFBLK:
            printf("block device\n");
            flag = 1;
            break;
        case S_IFDIR:
            printf("directory\n");
            break;
        case S_IFCHR:
            printf("character device\n");
            flag = 1;
            break;
        case S_IFIFO:
            printf("FIFO\n");
            break;
        default:
            printf("unknown file type\n");
    }
    return flag;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

void fileperm(struct stat *buf, char *perm) {
    strcpy(perm, "----------"); // 初始化
    mode_t mode = buf->st_mode;
    if (S_ISSOCK(mode))
        perm[0] = 's';
    else if (S_ISLNK(mode))
        perm[0] = 'l';
    else if (S_ISREG(mode))
        perm[0] = '-';
    else if (S_ISBLK(mode))
        perm[0] = 'b';
    else if (S_ISDIR(mode))
        perm[0] = 'd';
    else if (S_ISCHR(mode))
        perm[0] = 'c';
    else if (S_ISFIFO(mode))
        perm[0] = 'p';
    else {
        printf("unknown file type\n");
        return;
    }

    // 文件权限转换
    for (int i = 0; i < 9; i += 3) {
        perm[i + 1] = (mode & (S_IRUSR >> i)) ? 'r' : '-';
        perm[i + 2] = (mode & (S_IWUSR >> i)) ? 'w' : '-';
        perm[i + 3] = (mode & (S_IXUSR >> i)) ? 'x' : '-';
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

/*
实现ls -l功能
lstat 查看 man 2 stat
getpwuid  查看 man getpwuid 通过用户id即st_uid获得用户名pw_name
getgrgid  查看 man getgrgid 通过组id即st_gid获得组名gr_name
readlink
-rw-r--r--    1      fengchen     xxx          1090      Oct 14 11:25   copy.c
权限        连接数     用户名      组名         文件大小       时间         文件名称
st_mode   st_nlink    pw_name    gr_name      st_size       st_mtime
ln -s file file1
符合链接文件名称  file1 -> file 查看 man 2 readlink
*/
void file_perm(struct stat *buf, char *perm); // 权限转成字符
void format_time(struct stat *sbuf, char *buf_time, size_t buf_time_size); // 时间转换
void link_file_name(struct dirent *de, struct stat *sbuf, char *file_name,  size_t file_name_size); // 链接的文件名
int compare(const void *a, const void *b); // 文件名排序

struct ls_l_info {
    char each_st_mode[11];
    unsigned long int each_st_nlink;
    char each_pw_name[20];
    char each_gr_name[20];
    off_t each_st_size;
    char each_st_mtime[64];
    char each_file_name[256];
};

int main(int argc, char *argv[]) {
    const char *dir_path = ".";
    if (argc > 1) {
        dir_path = argv[1];
    }
    DIR *dir = opendir(dir_path);
    if (dir == NULL) {
        ERR_EXIT("opendir error");
    }

    struct dirent *de;
    struct ls_l_info *file_list = NULL;  // 存储文件名的数组
    int file_count = 0;  // 文件计数

    int  uname_width = 0;
    int  gname_width = 0;
    int  size_width = 0;
    int  perm_width = 0;
    int  nlink_width = 0;
    int  buf_time_width = 0;

    while ((de = readdir(dir)) != NULL) {
        if (strncmp(de->d_name, ".", 1) != 0) {
            struct ls_l_info *temp_list = (struct ls_l_info *)realloc(file_list, (file_count + 1) * sizeof(struct ls_l_info));
            if (temp_list == NULL) {
                ERR_EXIT("realloc error");
            }
            file_list = temp_list;

            struct stat sbuf;
            char file_path[PATH_MAX];
            snprintf(file_path, PATH_MAX, "%s/%s", dir_path, de->d_name);
            if (lstat(file_path, &sbuf) == -1) {
                ERR_EXIT("stat error");
            }
            char perm[11] = {0};
            file_perm(&sbuf, perm);
            strcpy(file_list[file_count].each_st_mode, perm);

            file_list[file_count].each_st_nlink = sbuf.st_nlink;

            struct passwd *pwname;
            pwname = getpwuid(sbuf.st_uid);
            strcpy(file_list[file_count].each_pw_name, pwname->pw_name);

            struct group *grname;
            grname = getgrgid(sbuf.st_gid);
            strcpy(file_list[file_count].each_gr_name, grname->gr_name);

            file_list[file_count].each_st_size = sbuf.st_size;

            char buf_time[64] = {0};
            format_time(&sbuf, buf_time, sizeof(buf_time));
            strcpy(file_list[file_count].each_st_mtime, buf_time);

            char file_name[256] = {0};
            link_file_name(de, &sbuf, file_name, sizeof(file_name));
            strcpy(file_list[file_count].each_file_name, file_name);

            uname_width = (uname_width > strlen(pwname->pw_name)) ? uname_width : strlen(pwname->pw_name);
            gname_width = (gname_width > strlen(grname->gr_name)) ? gname_width : strlen(grname->gr_name);
            char size_str[20];
            snprintf(size_str, sizeof(size_str), "%ld", sbuf.st_size);
            size_width = (size_width > strlen(size_str)) ? size_width : strlen(size_str);
            perm_width = (perm_width > strlen(perm)) ? perm_width : strlen(perm);
            char n_link_str[20];
            snprintf(n_link_str, sizeof(n_link_str), "%ld", sbuf.st_nlink);
            nlink_width = (nlink_width > strlen(n_link_str)) ? nlink_width : strlen(n_link_str);
            buf_time_width = (buf_time_width > strlen(buf_time)) ? buf_time_width : strlen(buf_time);

            file_count++;
        }
    }
    closedir(dir);
    qsort(file_list, file_count, sizeof(struct ls_l_info), compare);
    for (int i = 0; i < file_count; i++) {
        printf("%-*s %*ld %-*s %-*s %*ld %-*s %s\n",
            perm_width, file_list[i].each_st_mode,
            nlink_width, file_list[i].each_st_nlink,
            uname_width, file_list[i].each_pw_name,
            gname_width, file_list[i].each_gr_name,
            size_width, file_list[i].each_st_size,
            buf_time_width, file_list[i].each_st_mtime,
            file_list[i].each_file_name);
    }
    free(file_list); 
    exit(EXIT_SUCCESS);
}


int compare(const void *a, const void *b) {
    const struct ls_l_info *info_a = (const struct ls_l_info *)a;
    const struct ls_l_info *info_b = (const struct ls_l_info *)b;
    return strcmp(info_a->each_file_name, info_b->each_file_name);
}

void file_perm(struct stat *buf, char *perm) {
    strcpy(perm, "----------"); // 初始化
    mode_t mode = buf->st_mode;
    if (S_ISSOCK(mode))
        perm[0] = 's';
    else if (S_ISLNK(mode))
        perm[0] = 'l';
    else if (S_ISREG(mode))
        perm[0] = '-';
    else if (S_ISBLK(mode))
        perm[0] = 'b';
    else if (S_ISDIR(mode))
        perm[0] = 'd';
    else if (S_ISCHR(mode))
        perm[0] = 'c';
    else if (S_ISFIFO(mode))
        perm[0] = 'p';
    else {
        printf("unknown file type\n");
        return;
    }

    // 文件权限转换
    for (int i = 0; i < 9; i += 3) {
        perm[i + 1] = (mode & (S_IRUSR >> i)) ? 'r' : '-';
        perm[i + 2] = (mode & (S_IWUSR >> i)) ? 'w' : '-';
        perm[i + 3] = (mode & (S_IXUSR >> i)) ? 'x' : '-';
    }
}

void format_time(struct stat *sbuf, char *buf_time, size_t buf_time_size){
    struct tm *tm = localtime(&(sbuf->st_mtime));
    strftime(buf_time, buf_time_size, "%b %d %H:%M", tm);
}

void link_file_name(struct dirent *de, struct stat *sbuf, char *file_name, size_t file_name_size) {
    char *linkname;
    ssize_t r;
    linkname = malloc(sbuf->st_size + 1);
    if (linkname == NULL) {
        ERR_EXIT("malloc error");
    }
    r = readlink(de->d_name, linkname, sbuf->st_size + 1);
    if (r == -1) {
        strncpy(file_name, de->d_name, file_name_size - 1);
    }
    else{
        linkname[r] = '\0';
        snprintf(file_name, file_name_size, "%s -> %s", de->d_name, linkname);
    }
    free(linkname);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

int main(int argc, char *argv[]){
    int fd1, fd2;
    char buf1[BUFF_SIZE] = {0};
    char buf2[BUFF_SIZE] = {0};
    fd1 = open("test.txt", O_RDONLY);
    if (fd1 == -1){
        ERR_EXIT("open error");
    }
    read(fd1, buf1, 5);
    printf("buf1 = %s\n", buf1);

    fd2 = open("test.txt", O_RDWR);
    if (fd2 == -1){
        ERR_EXIT("open error");
    }
    read(fd2, buf2, 5);
    printf("buf2 = %s\n", buf2);

    write(fd2, "world", 5);
    memset(buf1, 0, sizeof(buf1));
    read(fd1, buf1, 5);
    printf("buf1 = %s\n", buf1);
    close(fd1);
    close(fd2);
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

int main(int argc, char *argv[]){
    int fd;
    fd = open("test.txt", O_WRONLY);
    if (fd == -1){
        ERR_EXIT("open error");
    }
    /*
    close(1);
    dup(fd);  // 0,1,2(输入，输出,错误)占用，默认返回3
    */
    /*
    dup2(fd, 1); // 如果由 newfd 参数所指定编号的文件描述符之前已经打开，那么 dup2()会首先将其关闭
    */
    close(1);
    if (fcntl(fd, F_DUPFD, 0) < 0){
        ERR_EXIT("dup fd error");
    }
    printf("hello\n");
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

void set_flag(int fd, int flags);
void clr_flag(int fd, int flags);

int main(int argc, char *argv[]){
    char buf[BUFF_SIZE] = {0};
    int ret;
    /*  set_flag function
    int flags;
    flags = fcntl(0, F_GETFL, 0);
    if (flags == -1) {
        ERR_EXIT("fcntl get flag error");
    }
    ret = fcntl(0, F_SETFL, flags | O_NONBLOCK);
    if (ret == -1) {
        ERR_EXIT("fcntl set flag error");
    }
    */
    set_flag(0, O_NONBLOCK); 
    clr_flag(0, O_NONBLOCK);

    ret = read(0, buf, BUFF_SIZE);
    if (ret == -1) {
        ERR_EXIT("read error");
    }

    printf("buf = %s \n", buf);
    return 0;
}

void set_flag(int fd, int flags){
    int val;
    val = fcntl(fd, F_GETFL, 0);
    if(val == -1){
        ERR_EXIT("fcntl get flag error");
    }
    val |= flags;
    if(fcntl(fd, F_SETFL, val) < 0){
        ERR_EXIT("fcntl set flag error");
    }
}

void clr_flag(int fd, int flags){
    int val;
    val = fcntl(fd, F_GETFL, 0);
    if(val == -1){
        ERR_EXIT("fcntl get flag error");
    }
    val &= ~flags;
    if(fcntl(fd, F_SETFL, val) < 0){
        ERR_EXIT("fcntl set flag error");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

int main(int argc, char *argv[]){
    int fd;
    fd = open("test.txt", O_CREAT | O_RDWR | O_TRUNC, 0644);
    if (fd == -1){
        ERR_EXIT("open error");
    }
    struct flock lock;
    memset(&lock, 0, sizeof(lock));
    lock.l_type = F_WRLCK;
    lock.l_whence = SEEK_SET;
    lock.l_start = 0;
    lock.l_len = 0;

    if(fcntl(fd, F_SETLK, &lock) == 0){
        printf("lock success\n");
        printf("press any key to unlock\n");
        lock.l_type = F_UNLCK;
        if (fcntl(fd, F_SETLK, &lock) == 0){
            printf("unlock success\n");
        }
        else {
            ERR_EXIT("unlock fail");
        }
    }
    else {
        ERR_EXIT("lock fail");    
    }
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

int main(int argc, char *argv[]){
    signal(SIGCHLD, SIG_IGN);
    printf("before fork pid = %d\n", getpid());
    pid_t pid;
    pid = fork();
    if (oid == -1){
        ERR_EXIT("fork fail");
    }
    if (pid > 0){
        printf("this is parent pid = %d, child pid = %d\n", getpid(), pid);
        sleep(1);
    }
    else if (pid == 0){
        printf("this is child pid = %d, parent pid = %d\n", getpid(), getppid());
    }
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

int gval = 100;

int main(int argc, char *argv[]){
    signal(SIGCHLD, SIG_IGN);
    printf("before fork pid = %d\n", getpid());
    pid_t pid;
    pid = vfork();
    if (pid == -1){
        ERR_EXIT("fork fail");
    }
    if (pid > 0){
        printf("this is parent pid = %d, child pid = %d, gval = %d\n", getpid(), pid, gval);
        sleep(1);
    }
    else if (pid == 0){
        gval++; // copy on write
        printf("this is child pid = %d, parent pid = %d, gval = %d\n", getpid(), getppid(), gval);
        _exit(0);
    }
    return 0;
}

1
2
3
4
5
6
7
8

int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg,
           ..., char * const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[],
            char *const envp[]);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

printf("pid = %d \n", getpid());
int ret = execlp("./fork_pid", "fork_pid", NULL);

int ret = execl("/bin/ls", "ls", "-l", NULL); // 指定全路径
等价于
int ret = execlp("ls", "ls", "-l", NULL);
等价于
char *const args[] = {"ls", "-l", NULL};
int ret = execvp("ls", args);

char *const envp[] = {"AA=11", "BB=22", NULL}; // 配置环境变量， 但是没输出AA和BB很奇怪
int ret = execle("/bin/ls", "ls", NULL, envp);
if (ret == -1){
    perror("ececlp error");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

int main(int argc, char *argv[]){
    printf("Entering main ... \n");
    int fret = fcntl(1, F_SETFD, FD_CLOEXEC);
    if (fret == -1){
        perror("fcntl error");
    }
    int ret = execlp("./fork_pid", "fork_pid", NULL);
    if (ret == -1){
        perror("ececlp error");
    }
    printf("Entering main ... \n");
    return 0;
}
# 输出
Entering main ... 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

int main(int argc, char *argv[]){
    pid_t pid;
    printf("before fork pid = %d\n", getpid());
    pid = fork();
    if (pid == -1){
        ERR_EXIT("fork fail");
    }
    if (pid > 0){
        printf("this is parent pid = %d, child pid = %d\n", getpid(), pid);
    }
    if (pid == 0){
        sleep(3);
        printf("this is child pid = %d, parent pid = %d\n", getpid(), getppid());
        // exit(1);
        abort(); // 异常终止
    }
    printf("this is parent\n");
    int ret, status;
    ret = wait(&status); // 等待子进程退出
    printf("ret = %d, pid = %d\n", ret, pid); // wait返回值子进程PIDS
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// 状态信息
if (WIFEXITED(status)){
        printf("child exited normal, exit status = %d\n", WEXITSTATUS(status));
    }
    else if (WIFSIGNALED(status)){
        printf("child exited abnormal, signal number = %d\n", WTERMSIG(status));// 通过kill -l查看信号 man 7 signal
    }
    else if (WIFSTOPPED(status)){
        printf("child stoped , signal number = %d\n", WTERMSIG(status));
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

int main(int argc, char *argv[]){
    // system("ls -l | wc -w");
    my_system("ls -l | wc -w");
    return 0;
}

int my_system(const char *command){
    pid_t pid;
    int status;
    if (command == NULL){
        return 1;
    }
    if ((pid = fork()) < 0){
        status = -1;
    }
    else if (pid == 0){
        execl("/bin/sh", "sh", "-c", command, NULL);
        exit(127);
    }
    else {
        while (waitpid(pid, &status, 0) < 0){
            if (errno == EINTR){
                continue;
            }
            status = -1;
            break;
        }
    }
    return status;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

int steup_daemon(int nochdir, int noclose){
    pid_t pid;
    pid = fork();
    if (pid == -1){
        ERR_EXIT("fork fail");
    }
    if (pid > 0){
        exit(EXIT_SUCCESS);
    }
    setsid();
    if (nochdir == 0){
        chdir("/");
    }
    if (noclose == 0){
        for (int i = 0; i < 3; ++i){
            close(i);
        }
        open("/dev/null", O_RDWR);
        dup(0);
        dup(0);
    }
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

void handler(int sig);
void func(int numLoops, char ch, char *pass);
int main(int argc, char *argv[]){
    if (signal(SIGINT, handler) == SIG_ERR){
        ERR_EXIT("signal error");
    }
    int numLoops = 0;
    char ch = '\0';
    func(numLoops, ch, "pass");
    return 0;
}
void handler(int sig){
    printf("\nrecieve a signal = %d\n", sig);
}

void func(int numLoops, char ch, char *pass){
     while (1) {
        printf("Press ENTER to test (loop  %d )...", numLoops);
        numLoops++;
        ch = getchar();
        if (ch == '\n'){
            printf("%s\n", pass);
        }
        else {
            break;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

void handler(int sig);
int main(int argc, char *argv[]){
    if (signal(SIGUSR1, handler) == SIG_ERR){
        ERR_EXIT("signal error");
    }
    pid_t pid = fork();
    if (pid == -1){
        ERR_EXIT("fork error");
    }
    if (pid == 0){
        // kill(getppid(), SIGUSR1);
        // exit(EXIT_SUCCESS);
        
        pid = getpgrp();
        kill(-pid, SIGUSR1);
        exit(EXIT_SUCCESS);
    }
    int n = 5;
    do {
        n = sleep(n);
    } while (n > 0);
    return 0;
}
void handler(int sig){
    printf("recv a sig = %d\n", sig);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

void handler(int sig);
int main(int argc, char *argv[]){
    if (signal(SIGINT, handler) == SIG_ERR){
        ERR_EXIT("signal error");
    }
    alarm(1);
    for (;;){
        pause();
        printf("pause return\n");
    }
    return 0;
}
void handler(int sig){
    printf("recv a sig = %d\n", sig);
    alarm(1);
}

1

kill -ALRM `ps aux | grep demo | grep -v vi | grep -v grep | awk '{print $2}'`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 接收
void handler(int sig, siginfo_t *info, void *ctx);

int main(int argc, char *argv[]){
    struct sigaction act;
    act.sa_sigaction = handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = SA_SIGINFO;
    if (sigaction(SIGINT, &act, NULL) < 0){
        ERR_EXIT("sigaction error");
    }
    for (;;){
        pause();
    }
    return 0;
}

void handler(int sig, siginfo_t *info, void *ctx){
    printf("recv a sig = %d data = %d\n", sig, info->si_value.sival_int);
}
// 发送
int main(int argc, char *argv[]){
    if (argc != 2){
        fprintf(stderr, "Usage %s pid\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    pid_t pid = atoi(argv[1]);
    union sigval v;
    v.sival_int = 100;
    sigqueue(pid, SIGINT, v);
    return 0;
}
// 运行 
./sigqueue_send `ps aux | grep sigqueue_recv | grep -v vi | grep -v grep | awk '{print $2}'`