与子信号同步，父信号将接收到的信号与文件匹配

Question

编辑：感谢到目前为止给出的建议。 我更改了程序，现在父级处理了一些信号，但看起来它并没有处理所有这些信号。 新代码和结果发布在下面。

EDIT2：我按照建议更改了随机数生成。 现在父级只捕获两个信号，但它总是捕获正确的位（最后两个位）。

“不幸的是，我在 C POSIX 方面没有经验，我必须编写一个程序，该程序将采用一个参数（包含二进制数的文件名）并解析该文件。文件中表示的每一位都意味着应该创建一个孩子（每一位专用于一个孩子）。
位的值（0 或 1）决定哪些信号应该发送到父节点（0 - SIGUSR1, 1 - SIGUSR2）。
子进程应选择一个随机间隔（10-200ms）并向父进程发送适当的信号。

每次新信号到达时，父级应接收信号并打印接收到的最后 5 位。

最后一步是匹配过程——父进程检查接收到的信号（分配给 SIGUSR1 或 SIGUSR2 的位），如果匹配，则打印 SUCCESS。 如果没有匹配（每当发送了错误的位 - 与文件相比），父级从头开始匹配。”

更新版本：

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <signal.h>
volatile sig_atomic_t last_signal = 0;

char * str;
char * received;
int count = 0;

#define ERR(source) (fprintf(stderr,"%s:%d\n",__FILE__,__LINE__),\
                     perror(source),kill(0,SIGKILL),\
                                     exit(EXIT_FAILURE))

void sethandler( void (*f)(int), int sigNo)
{
        struct sigaction act;
        memset(&act, 0, sizeof(struct sigaction));
        act.sa_handler = f;
        if (-1==sigaction(sigNo, &act, NULL)) ERR("sigaction");
}


char *readFile(char *fileName)
{
    FILE *file = fopen(fileName, "r");
    char *code;
    size_t n = 0;
    int c;

    if (file == NULL) return NULL; //could not open file
    fseek(file, 0, SEEK_END);
    long f_size = ftell(file);
    fseek(file, 0, SEEK_SET);
    code = malloc(f_size);
    received = malloc(f_size);
    while ((c = fgetc(file)) != EOF) {
        code[n++] = (char)c;
    }

    code[n] = '\0';

    return code;
}

void append(char* s, char c)
{
        int len = strlen(s);
        s[len] = c;
        s[len+1] = '\0';
}

static void sig_handle(int signum)
{
  last_signal = signum;
}

void child_w(int number_of)
{
    if(str[number_of] == '0')
    {
      if (kill(getppid(), SIGUSR1)==0) printf("[SIGUSR1] sent \n");
      else
      {
        printf("ERROR kill. \n");
        exit(EXIT_FAILURE);
      }
    }

    if(str[number_of] == '1')
    {
      if (kill(getppid(), SIGUSR2) == 0) printf("[SIGUSR2] sent \n");
      else
      {
        printf("ERROR kill. \n");
        exit(EXIT_FAILURE);
      }
    }
}

void create_children(int n)
{
  pid_t s;
  int j = n;
  int time = rand() % 191 + 10;  // range 10 - 200
  struct timespec time_wait = { .tv_sec = 0, .tv_nsec = time * 1000000L };
       while(j-->0)
       {
         nanosleep(&time_wait, NULL);
         if((s=fork())<0) ERR("Fork ERROR");
         if(!s) {
                  printf("Child %d started ", j);
                  printf("with bit: %c \n", str[j]);
                  child_w(j);
                 exit(EXIT_SUCCESS);
         }
       }
}

void parent_w(sigset_t oldmask)
{
    int count = 0;
    int match = 0;
    while(1)
    {
      last_signal = 0;
      while(last_signal != SIGUSR1 && last_signal != SIGUSR2)
      {
        sigsuspend(&oldmask);
      }
      printf("\n");
      if(last_signal == SIGUSR1)
      {
        received[count] = '0';
        for(int i=0; i<sizeof(received); ++i)
        {
          printf("%c ", received[i]);
        }
        count++;
      }

      else if(last_signal == SIGUSR2)
      {
        received[count] = '1';
        for(int i=0; i<sizeof(received); ++i)
        {
          printf("%c ", received[i]);
        }
        count++;
      }
      printf("\n");
    }
}

int main(int argc, char ** argv)
{
  char filename[250];

  if(argc!=2)
  {
    printf("Provide one parameter - filename. \n");
    return EXIT_FAILURE;
  }
  strcpy(filename, argv[1]);

  str = readFile(filename);
  printf("FILE: ");
  for(int i=0; i<sizeof(str); ++i)
  {
    printf("%c ", str[i]);
  }
  printf("\n");

  for(int i=0; i<sizeof(received); ++i)
  {
    received[i] = '-';
  }

  sethandler(sig_handle, SIGUSR1);
  sethandler(sig_handle, SIGUSR2);

  sigset_t mask, oldmask;
    sigemptyset(&mask);
    sigaddset(&mask, SIGUSR1);
    sigaddset(&mask, SIGUSR2);
    sigprocmask(SIG_BLOCK, &mask, &oldmask);

  create_children(sizeof(str));

  parent_w(oldmask);

  sigprocmask(SIG_UNBLOCK, &mask, NULL);
  free(str);
  free(received);

  return EXIT_SUCCESS;
}

现在 output 总是如下所示：

FILE: 1 0 0 1 1 0 1 0 
Child 7 started with bit: 0 
[SIGUSR1] sent 
Child 6 started with bit: 1 
[SIGUSR2] sent 
Child 5 started with bit: 0 
[SIGUSR1] sent 
Child 4 started with bit: 1 
[SIGUSR2] sent 
Child 3 started with bit: 1 
[SIGUSR2] sent 
Child 2 started with bit: 0 
[SIGUSR1] sent 
Child 1 started with bit: 0 
[SIGUSR1] sent 

0 - - - - - - - 
Child 0 started with bit: 1 
[SIGUSR2] sent 

0 1 - - - - - - 

任何进一步的建议将不胜感激:)。

Answer 1

除了其他人提到的问题之外，您的readFile() function 通过超出您为文件内容分配的缓冲区来调用未定义的行为：

char *readFile(char *fileName)
{
    FILE *file = fopen(fileName, "r");
    char *code;
    size_t n = 0;
    int c;

    if (file == NULL) return NULL; //could not open file
    fseek(file, 0, SEEK_END);
    long f_size = ftell(file);
    fseek(file, 0, SEEK_SET);
    code = malloc(f_size);
    received = malloc(f_size);
    while ((c = fgetc(file)) != EOF) {
        code[n++] = (char)c;
    }

    code[n] = '\0';  // <- this is f_size + 1 bytes into the code array

    return code;
}

当您使用code[n] = '\0';终止数据时您写入缓冲区code指向的末尾，从而调用未定义的行为。

而且，题外话...

严格来说，您不能使用fseek() / ftell()来获取文件的大小。 在您的情况下，您使用FILE *file = fopen(fileName, "r");以文本模式打开文件 ，但在文本模式下ftell()不返回字节偏移量。 根据7.21.9.4 的 ftell function ，C11 标准的第 2 段：

ftell function 获取 stream 指向的 position 指标的当前值。 对于二进制 stream，该值是从文件开头开始的字符数。 For a text stream, its file position indicator contains unspecified information, usable by the fseek function for returning the file position indicator for the stream to its position at the time of the ftell call; 两个这样的返回值之间的差异不一定是衡量写入或读取字符数的有意义的指标。

在 POSIX 系统上，您不会遇到问题，因为 POSIX 将ftell()定义为始终返回准确的字节偏移量。 但是在 Windows 上，您可能会读取比文件大小更少的字节，否则文件内容中的\r\n字符序列实际上会被读取为单个\n字符。

但是在某些系统上，您将真正获得“未指定的信息”，并且您的代码将完全失败。

并且寻求二进制 stream 的末尾也不是可移植的。 事实上，它是明确未定义的行为：

将文件 position 指示器设置为文件结尾，与fseek(file, 0, SEEK_END)一样，对于二进制 stream 具有未定义的行为...

同样，在 POSIX 或 Windows 系统上不是问题。

但是， fseek() / ftell()的一个真正问题是，从ftell()返回的long值在许多系统上没有足够的范围来表示大于 2 GB 的文件大小。 long在 32 位 Linux 系统上是 32 位，在所有Windows 系统（包括 32 位和64 位）上也只有 32 位。

Answer 2

首先，好的代码。

第二：

• 手册页是你的朋友。 人信号
• signal()为信号注册处理程序。 所以在signal(SIGUSR1, some_function)之后 function some_function将在收到信号后执行。
• 从信号处理程序中删除signal()调用（为什么要从处理程序内部重新注册相同的处理程序？它已经是此信号的处理程序。）
• 从父循环中删除signal()调用。 只需注册一次函数，仅此而已。
• 您的sethandler function 与signal相同。

经过一些修复：

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

char * str; // the array consisting of bits from the file
char * received; //array of the parent receiving the signals
int count = 0;
//Error macro
#define ERR(source) (fprintf(stderr,"%s:%d\n",__FILE__,__LINE__),\
                     perror(source),exit(EXIT_FAILURE))

//Reading file char by char and returning allocated char array
char *readFile(char *fileName)
{
    FILE *file = fopen(fileName, "r");
    char *code;
    size_t n = 0;
    int c;

    if (file == NULL) return NULL; //could not open file
    fseek(file, 0, SEEK_END);
    long f_size = ftell(file);
    fseek(file, 0, SEEK_SET);
    code = malloc(f_size);
    received = malloc(f_size);
    while ((c = fgetc(file)) != EOF) {
        code[n++] = (char)c;
    }

    code[n] = '\0';

    return code;
}
// Append the character to the received array
void append(char* s, char c)
{
        int len = strlen(s);
        s[len] = c;
        s[len+1] = '\0';
}
// SIGUSR1 handler. I tried to implement simple counter to check if the parent is receiving the signals, then proceed to printing last 5 bits received. Unfortunately this part seems to not work at all.
static void sig_handle1(int signum) {
  count++;
  printf("%s %d \n", __func__, count);

}
// Handler for SIGUSR2 - same as handler for SIGUSR1
static void sig_handle2(int signum) {
  count++;
  printf("%s %d \n", __func__, count);

}
// Child function - set the random interval, wait and then send the appropriate signal to the parent
void child_w(int number_of)
{
  srand(time(NULL)*getpid());
  int time = rand()%100 + 10;
  struct timespec time_wait = {time/1000, 0};
  nanosleep(&time_wait, NULL);

    if(str[number_of] == '0')
    {
      if (kill(getppid(), SIGUSR1)==0) printf("[SIGUSR1] sent \n");
      else
      {
        printf("ERROR kill. \n");
        exit(EXIT_FAILURE);
      }
    }

    if(str[number_of] == '1')
    {
      if (kill(getppid(), SIGUSR2) == 0) printf("[SIGUSR2] sent \n");
      else
      {
        printf("ERROR kill. \n");
        exit(EXIT_FAILURE);
      }
    }
}
// Function which will create children (number of children = number of bits in the file)
void create_children(int n)
{
  pid_t s;
  int j = n;
       while(j-->0)
       {
         if((s=fork())<0) ERR("Fork ERROR");
         if(!s) {
                  printf("Child %d started ", j);
                  printf("with bit: %c \n", str[j]);
                  child_w(j);
                 //if(j==1) kill(getppid(), SIGUSR2);
                 exit(EXIT_SUCCESS);
         }
       }
}
// Parent function to check the received signals
void parent_w()
{
        signal(SIGUSR1, sig_handle1);
        signal(SIGUSR2, sig_handle2);
  while(1)
  {
          pause();

  }
}

int main(int argc, char ** argv)
{
  char filename[250];

  if(argc!=2)
  {
    printf("Provide one parameter - filename. \n");
    return EXIT_FAILURE;
  }
  strcpy(filename, argv[1]);

  str = readFile(filename);
  printf("FILE: ");
  for(int i=0; i<sizeof(str); ++i)
  {
    printf("%c ", str[i]);
  }
  printf("\n");

  create_children(sizeof(str)-1);
  parent_w();


  free(str);
  free(received);

  return EXIT_SUCCESS;
}

示例执行：

FILE: 1 0 0 1 1 0 1

Child 0 started with bit: 1
Child 1 started with bit: 0
Child 2 started with bit: 0
Child 3 started with bit: 1
[SIGUSR2] sent
sig_handle2 1
[SIGUSR1] sent
sig_handle1 2
[SIGUSR1] sent
sig_handle1 3
[SIGUSR2] sent
sig_handle2 4
Child 4 started with bit: 1
Child 5 started with bit: 0
sig_handle2 5
[SIGUSR2] sent
Child 6 started with bit: 1
sig_handle1 6
[SIGUSR1] sent
sig_handle2 7
[SIGUSR2] sent
^C

Answer 3

正如@KamilCuk 所观察到的，在信号处理程序触发时重新注册它们是没有必要或不合适的。 这曾经是标准的，因为关于signal() function（直到今天仍然存在）的实现的不确定性：一些实现注册处理程序，以便在它们触发一次后，信号处理被重置。 但是，使用sigaction() ，一旦可以指定他们是否想要“一次性”行为，或者他们是否希望信号处理程序在触发时保持注册状态，后者是 function 的默认设置。

sigaction()允许控制关于哪些signal()实现有所不同的其他一些细节。 在实践中， signal()很少有合适的用途，而且sigaction()也没有涵盖。 如果您正在为 POSIX 编程，那么最好忘记signal()的存在。

尽管如此，我认为您对signal()的使用并不是这里的关键问题。

---

另一个问题是信号处理程序在他们可以安全地做的事情上受到相当的限制：

• 他们可以访问sig_atomic_t类型的文件范围变量
• 他们可能会调用异步信号安全标准函数
• 他们可以声明和访问局部变量
• 他们可以调用符合这些限制的程序的任何其他函数

然而，信号处理程序通常使用它们自己的、单独的堆栈来调用，而且这些堆栈通常非常小，因此在实践中，它们不能安全地以局部变量的方式声明，也不能启动非常深的调用树。 确切的限制是什么是未指定的，因此信号处理程序通常应该尽可能少地做。

特别是， printf()和任何其他 stdio 函数都不是异步信号安全的。 如果调用其中任何一个，信号处理程序会产生未定义的行为。 如果您愿意，他们可能会调用write() ，但这里可能有更好的选择。 例如，父进程可以pause()或sigsuspend()等待信号，然后在处理程序之外打印它需要做的任何事情。 处理程序只需要设置一个变量来指示接收到的信号。 这将避免父母像现在那样忙于等待，尽管您仍然存在潜在冲突的问题。

这更有可能是您问题的一部分，但我怀疑这也不是关键问题。

---

我认为真正的问题可能是信号正在丢失。 普通信号不会排队，因此如果在该信号已经为进程挂起时接收到一个信号，那么它不会产生额外的影响。 该问题的结构是通过要求每个孩子在发出信号之前延迟随机时间量来避免这种情况，但是

1. 这并不是真正的安全，只是不太可能出现碰撞，并且
2. 您的实施实际上并没有延迟。

考虑：

 int time = rand()%100 + 10; struct timespec time_wait = {time/1000, 0}; nanosleep(&time_wait, NULL);

变量time将被分配一个介于 10 和 109 之间的值，因此time / 1000 - integer 除法 - 将始终评估为 0 。

像这样的东西会更合适：

int time = rand() % 191 + 10;  // range 10 - 200
struct timespec time_wait = { .tv_sec = 0, .tv_nsec = time * 1000000L };
nanosleep(&time_wait, NULL);

此外，我不会在每个子节点中播种一个单独的 (P)RNG，而是在父节点中播种一次，并在每个分叉之前在那里生成延迟。 从同一个 RNG 中抽取随机数会产生更均匀的分布。