1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// man 2 open
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
// man 3 perror
#include <stdio.h>
// man 2 close
#include <unistd.h>

int main() {
    // flags - int32, 每一位是一个标志位
    int fd = open("test.txt", O_RDWR | O_CREAT, 0777);

    if (fd == -1) {
        perror("open");
        return -1;
    }

    close(fd);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// man 2 read/write
#include <unistd.h>

int main() {
    int srcfd = open("source.txt", O_RDONLY);
    int dstfd = open("destination.txt", O_WRONLY | O_CREAT, 0777);

    if (srcfd == -1 || dstfd == -1) {
        perror("open");
        return -1;
    }

    char buf[1024];
    while ((len = read(srcfd, buf, sizeof(buf))) > 0) {
        write(dstfd, buf, len);
    }

    close(srcfd);
    close(dstfd);

    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
// man 2 lseek
#include <sys/types.h>
#include <unistd.h>
// man 3 fseek
#include <stdio.h>

int main() {
    int fd = open("test.txt", O_RDWR | O_CREAT, 0777);

    if (fd == -1) {
        perror("open");
        return -1;
    }

    int ret = lseek(fd, 100, SEEK_END);

    if (ret == -1) {
        perror("lseek");
        return -1;
    }

    close(fd);

    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
53
54
55
56
57
58
59
60
61
62
63
64
65
// man 2 stat
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
// man 3 getpwuid/getgrgid
#include <pwd.h>
#include <grp.h>

#include <stdint.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/sysmacros.h>

int main(int argc, char *argv[])
{
    struct stat sb;

    if (argc != 2) {
        fprintf(stderr, "Usage: %s <pathname>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    if (lstat(argv[1], &sb) == -1) {
        perror("lstat");
        exit(EXIT_FAILURE);
    }
    printf("ID of containing device:  [%jx,%jx]\n",
            (uintmax_t) major(sb.st_dev),
            (uintmax_t) minor(sb.st_dev));

    printf("File type:                ");

    switch (sb.st_mode & S_IFMT) {
    case S_IFBLK:  printf("block device\n");            break;
    case S_IFCHR:  printf("character device\n");        break;
    case S_IFDIR:  printf("directory\n");               break;
    case S_IFIFO:  printf("FIFO/pipe\n");               break;
    case S_IFLNK:  printf("symlink\n");                 break;
    case S_IFREG:  printf("regular file\n");            break;
    case S_IFSOCK: printf("socket\n");                  break;
    default:       printf("unknown?\n");                break;
    }
    printf("I-node number:            %ju\n", (uintmax_t) sb.st_ino);

    printf("Mode:                     %jo (octal)\n",
            (uintmax_t) sb.st_mode);

    printf("Link count:               %ju\n", (uintmax_t) sb.st_nlink);
    printf("Ownership:                UID=%ju   GID=%ju\n",
            (uintmax_t) sb.st_uid, (uintmax_t) sb.st_gid);

    printf("Preferred I/O block size: %jd bytes\n",
            (intmax_t) sb.st_blksize);
    printf("File size:                %jd bytes\n",
            (intmax_t) sb.st_size);
    // or lseek(fd, 0, SEEK_END)
    printf("Blocks allocated:         %jd\n",
            (intmax_t) sb.st_blocks);
    printf("Last status change:       %s", ctime(&sb.st_ctime));
    printf("Last file access:         %s", ctime(&sb.st_atime));
    printf("Last file modification:   %s", ctime(&sb.st_mtime));

    exit(EXIT_SUCCESS);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// man 2 access
#include <unistd.h>
// man 2 chmod
#include <sys/stat.h>
// man 2 chown
#include <unistd.h>
// man 2 truncate
#include <unistd.h>
#include <sys/types.h>

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

int main() {
    if (access("test.txt", F_OK) == -1) {
        perror("access");
        exit(EXIT_FAILURE);
    }

    chmod("test.txt", 0777);

    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
// man 2 mkdir
#include <sys/stat.h>
#include <sys/types.h>
// man 2 rmdir
#include <unistd.h>
// man 2 rename
#include <stdio.h>
// man 2 chdir
#include <unistd.h>
// man 2 getcwd
#include <unistd.h>

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
// man 3 opendir
#include <sys/types.h>
#include <dirent.h>
// man 3 readdir
#include <dirent.h>
// man 3 closedir
#include <sys/types.h>
#include <dirent.h>

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

int getFileNum(const char* path) {
    DIR* dir = opendir(path);
    if (dir == NULL) {
        perror("opendir");
        exit(EXIT_FAILURE);
    }
    struct dirent* ptr;
    int ret = 0;
    while ((ptr = readdir(dir)) != NULL) {
        char* dname = ptr->d_name;
        if (strcmp(dname, ".") == 0 || strcmp(dname, "..") == 0) {
            continue;
        }
        if (ptr->d_type == DT_DIR) {
            char newpath[256];
            sprintf(newpath, "%s/%s", path, dname);
            ret += getFileNum(newpath);
        }
        else if (ptr->d_type == DT_REG) {
            ret += 1;
        }
    }
    closedir(dir);
    return ret;
}

int main(int argc, char* argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s path\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    int fn = getFileNum(argv[1]);
    printf("%d\n", fn);
    exit(EXIT_SUCCESS);
}

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
// man 2 dup
#include <unistd.h>

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

int main() {
    int fd1 = open("test1.txt", O_RDWR | O_CREAT, 0777);
    if (fd1 == -1) {
        perror("open");
        return -1;
    }
    int fd2 = dup(fd1);
    if (fd2 == -1) {
        perror("dup");
        return -1;
    }
    printf("old: %d, new: %d\n", fd1, fd2);
    int fd3 = open("test2.txt", O_RDWR | O_CREAT, 0777);
    int fd4 = dup2(fd1, fd3);

    char* str1 = (char*) "hello, ";
    char* str2 = (char*) "world!";
    write(fd1, str1, strlen(str1));
    write(fd2, str2, strlen(str2));
    write(fd3, str1, strlen(str1));
    write(fd4, str2, strlen(str2));
    close(fd1);
    close(fd2);
    close(fd3);
    close(fd4);
    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
// man 2 fcntl
#include <unistd.h>
#include <fcntl.h>
// man 3 printf

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>

int main() {
    int fd = open("test.txt", O_RDWR | O_CREAT, 0777);
    if (fd == -1) {
        perror("open");
        return -1;
    }
    int ret = fcntl(fd, F_DUPFD);

    int fl = fcntl(ret, F_GETFL);
    fcntl(ret, F_SETFL, fl | O_APPEND);

    close(fd);
    close(ret)
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <unistd.h>

extern char **environ;

int execl(const char *pathname, const char *arg, .../* (char  *) NULL */);
int execlp(const char *file, const char *arg, .../* (char  *) NULL */);
int execle(const char *pathname, const char *arg, .../*, (char *) NULL, char *const envp[] */);
int execv(const char *pathname, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);
int execve(const char *pathname, char *const argv[], char *const envp[]);
/*
l(list)         参数地址列表，以空指针结尾
v(vector)       存有各参数地址的指针数组的地址
p(path)         按PATH环境变量指定的目录搜索可执行文件
e(environment)  存有环境变量字符串地址的指针数组的地址
*/

1
2
3
4
5
6
7
8
9
//exit相比_exit会在退出前刷新I/O缓冲、关闭文件描述符
#include <stdlib.h>

void exit(int status);
void _Exit(int status);

#include <unistd.h>

void _exit(int 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
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
//man 2 wait
//wait()会阻塞，一次回收一个子进程
//waitpid()可以设置不阻塞，还可以指定等待哪个子进程结束
#include <sys/types.h>
#include <sys/wait.h>

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

//man 2 fork
#include <sys/types.h>
#include <unistd.h>

pid_t fork(void);

int main() {
    pid_t pid = fork();
    if (pid > 0) {
        printf("parent\n");
        // int ret = wait(NULL);
        int st;
        // int ret = wait(&st);
        int ret = waitpid(0, &st, WNOHANG);
        print("%d\n", ret);
        if (ret == -1) break;
        else if (ret == 0) continue;
        else if (ret > 0) {
            if (WIFEXITED(st)) {
                cout << WEXITSTATUS(st);
            }
            else if (WIFSIGNALED(st)) {
                cout << WTERMSIG(st);
            }
        }
    } else if (pid == 0) {
        printf("child\n");
    }

    return 0;
}
/*
退出状态宏函数
WIFEXITED(status)非0，进程正常退出
WEXITSTATUS(status)如果上宏为真，获取进程退出的状态（exit的参数）
WIFSIGNALED(status)非0，进程异常终止
WTERMSIG(status)如果上宏为真，获取使进程终止的信号编号
WIFSTOPPED(status)非0，进程处于暂停状态
WSTOPSIG(status)如果上宏为真，获取使进程暂停的信号的编号
WIFCONTINUED(status)非0，进程暫停后已经继续运行
*/

/*
waitpid:
pid > 0 : 某个子进程的pid
pid = 0 : 回收当前进程组的任意子进程
pid = -1 : 回收任意的子进程，相当于wait()
pid < -1 : 回收指定进程组的组id的负数
options = 0 : 阻塞
options > 0 : 非阻塞，WNOHANG WUNTRACED WCONTINUED
return > 0 : 返回子进程的pid
return = 0 : options = WNOHANG，非阻塞，还有子进程
return < 0 : 错误或没有子进程
*/

1
2
3
4
5
6
7
8
9
10
11
12
// man 2 mmap
#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
int munmap(void *addr, size_t length);
/*
length: stat, lseek
prot: PROT_EXEC, PROT_READ, PROT_WRITE, PROT_NONE
flags: MAP_SHARED(sync), MAP_PRIVATE(copy), MAP_ANONYMOUS(匿名映射，fd=-1)
fd: open权限 >= prot
offset: 页大小的整数倍sysconf(_SC_PAGE_SIZE)
返回内存首地址
*/

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
// man 2 kill
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);
/*
pid > 0 : 将信号发送给指定的进程
pid = 0 : 将信号发送给当前的进程组
pid = -1 : 将信号发送给每一个有权限接收这个信号的进程
pid < -1 : 这个pid=某个进程组的ID取反 （-12345）
对照waitpid中的设定
sig = 0 : 不发送信号，但会执行存在性和权限检查
kill(getppid(), 9);
kill(getpid(), 9);
*/
// man 3 raise
#include <signal.h>
int raise(int sig); // == kill(getpid(), sig);
// man 3 abort
#include <stdlib.h>
void abort(void); // == kill(getpid(), SIGABRT);
// man 2 alarm
#include <unistd.h>
unsigned int alarm(unsigned int seconds); // 发送SIGALRM信号，非阻塞
/*
seconds = 0时，定时器无效，alarm(0)用于取消一个定时器
返回之前的定时器剩余的时间
与进程状态无关（自然定时法）：无论进程处于什么状态，alarm都会继续计时
*/
// man 2 setitimer
#include <sys/time.h>
int getitimer(int which, struct itimerval *curr_value);
int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value);
struct itimerval {
    struct timeval it_interval; /* Interval for periodic timer */
    struct timeval it_value;    /* Time until next expiration */
};
struct timeval {
    time_t      tv_sec;         /* seconds */
    suseconds_t tv_usec;        /* microseconds */
};
/*
周期定时器：精度更高
which: 定时器以什么时间类型计时
    ITIMER_REAL: 真实世界时间，SIGALRM
    ITIMER_VIRTUAL: 进程所耗的用户模式CPU时间，SIGVTALRM
    ITIMER_PROF: 进程所耗的用户和内核模式总CPU时间，SIGPROF
new_value: 设定定时
old_value: 返回上个定时器的定时，常置为NULL
*/
// man 2 signal - ANSI C signal handling
#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
/*
disposition: SIG_IGN, SIG_DFL, signal_handler
The signals SIGKILL and SIGSTOP cannot be caught or ignored.
成功返回上次注册的信号处理函数的地址，首次返回NULL
失败返回SIG_ERR
*/
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

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
// 修改自定义信号集
// man 3 sigsetops
#include <signal.h>
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signum); 
int sigdelset(sigset_t *set, int signum);
int sigismember(const sigset_t *set, int signum);
/*
sigemptyset() initializes the signal set given by set to empty, with all signals excluded from the set.
sigfillset() initializes set to full, including all signals.
sigaddset() and sigdelset() add and delete respectively signal signum from set.
sigismember() tests whether signum is a member of set.
*/
// 修改阻塞信号集
// man 2 sigprocmask
#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
/*
how: 
    SIG_BLOCK: mask |= set
    SIG_UNBLOCK: mask &= ~set
    SIG_SETMASK: mask = set
获取：sigprocmask(~, NULL, ptr)
*/
// 获取未决信号集
// man 2 sigpending
#include <signal.h>
int sigpending(sigset_t *set);

1
2
3
4
5
6
7
8
9
10
11
// man 2 sigaction
// avoid to use signal
#include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
struct sigaction {
    void     (*sa_handler)(int); // 信号处理函数
    void     (*sa_sigaction)(int, siginfo_t *, void *);
    sigset_t   sa_mask; // 临时阻塞信号集
    int        sa_flags; // 0使用sa_handler，SA_SIGINFO使用sa_sigaction，其他...
    void     (*sa_restorer)(void); // 不用
};

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
// man 2 shmget
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
/*
- 功能：创建一个新的共享内存段，或者获取一个既有的共享内存段的标识。
    新创建的内存段中的数据都会被初始化为0
- 参数：
    - key : key_t类型是一个整形，通过这个找到或者创建一个共享内存。
            一般使用16进制表示，非0值
    - size: 共享内存的大小，round up to page size
    - shmflg: 属性
        - 访问权限
        - 附加属性：创建/判断共享内存是不是存在
            - 创建：IPC_CREAT
            - 判断共享内存是否存在： IPC_EXCL , 需要和IPC_CREAT一起使用
                IPC_CREAT | IPC_EXCL | 0664
    - 返回值：
        失败：-1 并设置错误号
        成功：>0 返回共享内存的引用的ID，后面操作共享内存都是通过这个值。
*/
// man 2 shmop
#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);
/*
- 功能：和当前的进程进行关联
- 参数：
    - shmid : 共享内存的标识（ID）,由shmget返回值获取
    - shmaddr: 申请的共享内存的起始地址，指定NULL，内核指定
    - shmflg : 对共享内存的操作
        - 读 ： SHM_RDONLY, 必须要有读权限
        - 读写： 0
- 返回值：
    成功：返回共享内存的首（起始）地址。  失败(void *) -1
*/
int shmdt(const void *shmaddr);
/*
- 功能：解除当前进程和共享内存的关联
- 参数：
    shmaddr：共享内存的首地址
- 返回值：成功 0， 失败 -1
*/
// man 2 shmctl
#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
struct shmid_ds {
    struct ipc_perm shm_perm;    /* Ownership and permissions */
    size_t          shm_segsz;   /* Size of segment (bytes) */
    time_t          shm_atime;   /* Last attach time */
    time_t          shm_dtime;   /* Last detach time */
    time_t          shm_ctime;   /* Creation time/time of last
                                    modification via shmctl() */
    pid_t           shm_cpid;    /* PID of creator */
    pid_t           shm_lpid;    /* PID of last shmat(2)/shmdt(2) */
    shmatt_t        shm_nattch;  /* No. of current attaches */
    ...
};
/*
- 功能：对共享内存进行操作。删除共享内存，共享内存要删除才会消失，创建共享内存的进程被销毁了对共享内存是没有任何影响。
- 参数：
    - shmid: 共享内存的ID
    - cmd : 要做的操作
        - IPC_STAT : 获取共享内存的当前的状态
        - IPC_SET : 设置共享内存的状态
        - IPC_RMID: 标记共享内存被销毁
    - buf：需要设置或者获取的共享内存的属性信息
        - IPC_STAT : buf存储数据
        - IPC_SET : buf中需要初始化数据，设置到内核中
        - IPC_RMID : 没有用，NULL
*/
// man 3 ftok
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);
/*
- 功能：根据指定的路径名，和int值，生成一个IPC key。用于msgget, semget, shmget
- 参数：
    - pathname:指定一个存在的路径
        /home/nowcoder/Linux/a.txt
        / 
    - proj_id: int类型的值，但是这系统调用只会使用其中的1个字节
                范围 ： 0-255  一般指定一个字符 'a'
- 两个进程如在pathname和proj_id上达成一致（即约定好），双方就都能够通过调用ftok函数得到同一个IPC键。
- ftok调用返回的整数IPC键由proj_id的低序8位，st_dev成员的低序8位，st_info的低序16位组合而成。
*/
int main() {
    int shmid = shmget(100, 4096, IPC_CREAT|0664); // 创建
    // int shmid = shmget(100, 0, IPC_CREAT); // 获取
    void *ptr = shmat(shmid, NULL, 0);
    char *str = "hello, world";
    memcpy(ptr, str, strlen(str) + 1);
    shmdt(ptr);
    shmctl(shmid, IPC_RMID, NULL);
}

1
2
3
4
5
6
7
8
9
10
struct ipc_perm
{
        __kernel_key_t  key;//端口号
        __kernel_uid_t  uid;//所有者的用户ID
        __kernel_gid_t  gid;//所有者组ID
        __kernel_uid_t  cuid;//创建者的用户ID
        __kernel_gid_t  cgid;//创建者的组ID
        __kernel_mode_t mode; //访问模式
        unsigned short  seq;//顺序值
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct msqid_ds {
        struct ipc_perm msg_perm;    /* IPC对象结构体 */
        struct msg *msg_first;       /*消息队列头指针*/
        struct msg *msg_last;        /*消息队列尾指针*/
        __kernel_time_t msg_stime;   /*最后一次插入消息队列消息的时间*/
        __kernel_time_t msg_rtime;   /*最后一次接收消息即删除队列中一个消息的时间*/
        __kernel_time_t msg_ctime;   /* 最后修改队列的时间*/
        unsigned long  msg_lcbytes;  /* Reuse junk fields for 32 bit */
        unsigned long  msg_lqbytes;  /* ditto */
        unsigned short msg_cbytes;   /*队列上所有消息总的字节数 */
        unsigned short msg_qnum;     /*在当前队列上消息的个数 */
        unsigned short msg_qbytes;   /* 队列最大的字节数 */
        __kernel_ipc_pid_t msg_lspid;/* 发送最后一条消息的进程的pid */
        __kernel_ipc_pid_t msg_lrpid;/* 接收最后一条消息的进程的pid */
};

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
// sendmsg.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<string.h>

struct my_msg
{
    int mtype; // 消息类型
    char buf[256];
}msg1, msg2;

int main()
{
    key_t key = ftok("./", 88);

    int msgid = msgget(key, 0666|IPC_CREAT);
    if(-1 == msgid)
    {
        perror("msgget failed!!!");
        exit(1);
    }

    msg1.mtype = 2;
    strcpy(msg1.buf, "hello, msg2");
    msgsnd(msgid, &msg1, sizeof(msg1), 0); // 阻塞
//    msgsnd(msgid, &msg1, sizeof(msg1), IPC_NOWAIT); // 非阻塞

    msg2.mtype = 1;
    strcpy(msg2.buf, "hello, msg1");
    msgsnd(msgid, &msg2, sizeof(msg2), 0); // 阻塞

    printf("消息发送完成，按回车销毁消息队列\n");
    getchar();

    if(-1 == shmctl(msgid, IPC_RMID, NULL))
    {
        perror("shmctl failed");
        exit(2);
    }
    return 0;
}

// recvmsg.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/msg.h>
#include<string.h>

struct my_msg
{
    int mtype; // 消息类型
    char buf[256];
}msg;

int main()
{
    key_t key = ftok("./", 88);

    // 获取消息队列
    int msgid = msgget(key, 0);
    if(-1 == msgid)
    {
        perror("msgget failed!!!");
        exit(1);
    }

    int res = msgrcv(msgid, &msg, sizeof(msg),
            2, // 取消息类型为2的消息
            0);
    printf("类型：%d, 内容：%s\n", msg.mtype, msg.buf);

    printf("消息接收完成，按回车销毁消息队列\n");
    getchar();

    if(-1 == shmctl(msgid, IPC_RMID, NULL))
    {
        perror("shmctl failed");
        exit(2);
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// man 2 setpgid
#include <sys/types.h>
#include <unistd.h>

int setpgid(pid_t pid, pid_t pgid);
pid_t getpgid(pid_t pid);

pid_t getpgrp(void);                 /* POSIX.1 version */
pid_t getpgrp(pid_t pid);            /* BSD version */

int setpgrp(void);                   /* System V version */
int setpgrp(pid_t pid, pid_t pgid);  /* BSD version */

// man 2 getsid/setsid
#include <sys/types.h>
#include <unistd.h>

pid_t getsid(pid_t pid);
pid_t setsid(void);

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
#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <signal.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>

void work(int num) {
    // man 2 time
    time_t tm = time(NULL);
    // man 3 ctime
    struct tm * loc = localtime(&tm);
    // char buf[1024];
    // sprintf(buf, "%d-%d-%d %d:%d:%d\n",loc->tm_year,loc->tm_mon
    // ,loc->tm_mday, loc->tm_hour, loc->tm_min, loc->tm_sec);
    // printf("%s\n", buf);
    char * str = asctime(loc);
    int fd = open("time.txt", O_RDWR | O_CREAT | O_APPEND, 0664);
    write(fd ,str, strlen(str));
    close(fd);
}

int main() {
    pid_t pid = fork();
    if(pid > 0) exit(0);
    setsid();
    umask(022);
    chdir("/");
    int fd = open("/dev/null", O_RDWR);
    dup2(fd, STDIN_FILENO);
    dup2(fd, STDOUT_FILENO);
    dup2(fd, STDERR_FILENO);
    // 信号捕捉
    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = work;
    sigemptyset(&act.sa_mask);
    sigaction(SIGALRM, &act, NULL);
    // 周期定时器
    struct itimerval val;
    val.it_value.tv_sec = 2;
    val.it_value.tv_usec = 0;
    val.it_interval.tv_sec = 2;
    val.it_interval.tv_usec = 0;
    setitimer(ITIMER_REAL, &val, NULL);
    while(1) sleep(10);
    return 0;
}