sm18

14-4

   1   │ #include <stdio.h>
   2   │ #include <signal.h>
   3   │ #include <unistd.h>
   4   │ #include <stdlib.h>
   5   │ #include <sys/types.h>
   6   │ #include <sys/stat.h>
   7   │ #include <fcntl.h>
   8   │ #include <errno.h>
   9   │ #include <string.h>
  10   │
  11   │ volatile sig_atomic_t current_signal = 0;
  12   │
  13   │ void handler(int s) {
  14   │     current_signal = s;
  15   │ }
  16   │
  17   │ int main(int argc, char* argv[]) {
  18   │     sigset_t sigset, empty;
  19   │     sigemptyset(&sigset);
  20   │     sigemptyset(&empty);
  21   │     sigaddset(&sigset, SIGTERM);
  22   │     for (int i = 1; i <= 20; ++i) {
  23   │         sigaddset(&sigset, SIGRTMIN + (i - 1));
  24   │     }
  25   │     sigprocmask(SIG_BLOCK, &sigset, NULL);
  26   │
  27   │     sigaction(SIGTERM, &(struct sigaction) { .sa_handler=handler }, NULL);
  28   │     for (int i = 1; i <= 20; ++i) {
  29   │         sigaction(SIGRTMIN + (i - 1), &(struct sigaction) { .sa_handler=handler }, NULL);
  30   │     }
  31   │
  32   │     int fd[argc];
  33   │     long long ans[argc];
  34   │     char buf[argc][17];
  35   │     int len[argc];
  36   │     memset(ans, 0, sizeof(ans));
  37   │     memset(buf, 0, sizeof(buf));
  38   │     memset(len, 0, sizeof(len));
  39   │     for (int i = 1; i < argc; ++i) {
  40   │         fd[i] = open(argv[i], O_RDONLY);
  41   │     }
  42   │
  43   │     int already_triggered = 0;
  44   │
  45   │     printf("%d\n", getpid());
  46   │     fflush(stdout);
  47   │
  48   │     while (1) {
  49   │         if (!already_triggered) {
  50   │             sigsuspend(&empty);
  51   │         } else {
  52   │             already_triggered = 0;
  53   │         }
  54   │         if (current_signal == SIGTERM) {
  55   │             for (int i = 1; i < argc; ++i) {
  56   │                 printf("%lld\n", ans[i]);
  57   │                 fflush(stdout);
  58   │                 if (fd[i] >= 0) {
  59   │                     close(fd[i]);
  60   │                 }
  61   │             }
  62   │             _exit(0);
  63   │         } else {
  64   │             int cur_fd = current_signal - (int)SIGRTMIN + 1;
  65   │             if (cur_fd <= 0 || cur_fd >= argc || fd[cur_fd] < 0) {
  66   │                 continue;
  67   │             }
  68   │             while (1) {
  69   │                 sigprocmask(SIG_UNBLOCK, &sigset, NULL);
  70   │                 errno = 0;
  71   │                 int value = read(fd[cur_fd], buf[cur_fd] + len[cur_fd], 16 - len[cur_fd]);
  72   │                 sigprocmask(SIG_BLOCK, &sigset, NULL);
  73   │                 if (errno == EINTR || value < 0) {
  74   │                     already_triggered = 1;
  75   │                     break;
  76   │                 }
  77   │                 if (value == 0) {
  78   │                     close(fd[cur_fd]);
  79   │                     fd[cur_fd] = -1;
  80   │                     break;
  81   │                 }
  82   │                 len[cur_fd] += value;
  83   │                 //// printf("%d\n", value);
  84   │                 if (len[cur_fd] == 16) {
  85   │                     ans[cur_fd] += strtoll(buf[cur_fd], NULL, 10);
  86   │                     len[cur_fd] = 0;
  87   │                 }
  88   │             }
  89   │         }
  90   │     }
  91   │ }


14-5
   1   │ #include <stdio.h>
   2   │ #include <signal.h>
   3   │ #include <unistd.h>
   4   │ #include <stdlib.h>
   5   │ #include <sys/types.h>
   6   │ #include <sys/wait.h>
   7   │ #include <sys/stat.h>
   8   │ #include <sys/signalfd.h>
   9   │ #include <fcntl.h>
  10   │
  11   │ int n;
  12   │
  13   │ void work(int my_id, FILE* file1, FILE* file2, int sfd) {
  14   │     while (1) {
  15   │         struct signalfd_siginfo sss;
  16   │         read(sfd, &sss, sizeof(sss));
  17   │
  18   │         int val;
  19   │         fscanf(file1, "%d", &val);
  20   │         if (val > n) {
  21   │             return;
  22   │         }
  23   │         printf("%d %d\n", my_id, val);
  24   │         fflush(stdout);
  25   │         ++val;
  26   │         fprintf(file2, "%d\n", val);
  27   │         fflush(file2);
  28   │
  29   │         kill(sss.ssi_pid, SIGUSR1);
  30   │         if (val >= n) {
  31   │             return;
  32   │         }
  33   │     }
  34   │ }
  35   │
  36   │ int main(int argc, char* argv[]) {
  37   │     sigset_t ss;
  38   │     sigemptyset(&ss);
  39   │     sigaddset(&ss, SIGUSR1);
  40   │     sigprocmask(SIG_BLOCK, &ss, NULL);
  41   │     int sfd = signalfd(-1, &ss, 0);
  42   │
  43   │     n = strtol(argv[1], NULL, 10);
  44   │     if (n > 0) {
  45   │         int pfd[2];
  46   │         pipe(pfd);
  47   │         FILE* file1 = fdopen(pfd[0], "r");
  48   │         FILE* file2 = fdopen(pfd[1], "w");
  49   │
  50   │         pid_t pid1;
  51   │         if (!(pid1 = fork())) {
  52   │             work(1, file1, file2, sfd);
  53   │             fclose(file1);
  54   │             fclose(file2);
  55   │             close(sfd);
  56   │             _exit(0);
  57   │         }
  58   │
  59   │         if (!fork()) {
  60   │             fprintf(file2, "1\n");
  61   │             fflush(file2);
  62   │             kill(pid1, SIGUSR1);
  63   │
  64   │             work(2, file1, file2, sfd);
  65   │             fclose(file1);
  66   │             fclose(file2);
  67   │             close(sfd);
  68   │             _exit(0);
  69   │         }
  70   │         while (wait(NULL) > 0) {}
  71   │         fclose(file1);
  72   │         fclose(file2);
  73   │     }
  74   │
  75   │     close(sfd);
  76   │ }