如何區分從服務器發送的兩個不同的SIGUSR2信號？

Question

我的服務器需要支持多個客戶端，暫時讓我們假設我們是 與2客戶端一起工作。

這裏的服務器：

#include <signal.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <sys/stat.h> 
#include <sys/ipc.h> 
#include <sys/shm.h> 
#include <fcntl.h> 
#include <sys/types.h> 
#include <unistd.h> 
#include <sys/fcntl.h> 
#include <sys/stat.h> 

#define FIFONAME "fifo_clientTOserver" 
#define SHM_SIZE 1024 /* make it a 1K shared memory segment */ 
#define ROWS 10 
#define COLS 10 



void error(char* str) 
{ 
    perror(str); 
    exit(1); 
} 



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

    unlink(FIFONAME);    // remove any previous fifo pipes 

    // create a FIFO named pipe - only if it's not already exists 
    if(mkfifo(FIFONAME , 0666) < 0) 
     error("mkfifo"); 

    /** 
    * process 1 
    */ 


    // open the fifo for reading 

    int server_to_client = open(FIFONAME, O_RDONLY); 
    int reading; 

    while (1) 
    { 
     if (read(server_to_client, &reading ,sizeof(int)) < 0) 
      perror("read"); 
     else 
      break; 
    } 

    printf("Reading from the fifo : %d\n" , reading); 
    if (close(server_to_client) < 0) 
     error("close"); 

    // casting into pid_t 
    pid_t pid = (pid_t)reading; 

    // signal to the process that he's the first 
    kill(pid, SIGUSR2); 



    /** 
    * process 2 
    */ 

    printf("Now waiting for process 2...\n"); 

    // doing it again - this time for the second process 

    // remove any previous fifo pipes 
    unlink(FIFONAME); 

    // create a FIFO named pipe - only if it's not already exists 
    if(mkfifo(FIFONAME , 0666) < 0) 
     error("mkfifo"); 

    printf("Server tester1\n"); 

    server_to_client = open(FIFONAME, O_RDONLY); 

    // grab the PID of process 2 
    while (1) 
    { 
     if (read(server_to_client, &reading ,sizeof(int)) > 0) 
      break; // got the data 
    } 

    printf("Server tester2\n"); 

    printf("Reading from the fifo : %d\n" , reading); 
    if (close(server_to_client) < 0) 
     error("close"); 

    // casting into pid_t 
    pid = (pid_t)reading; 

    // signal to the process that he's the first 
    kill(pid, SIGUSR2); 




    return 0; 

    } 

的問題是，這兩個客戶需要通過他們的PID（這不是父子關係！這是兩個獨立的過程），然後服務器信號與SIGUSR2到他是第一個被選中的第一個進程，如果是的話，那麼該進程使用X類型的字符。

另一方面，如果你是第二個進程，你使用Y類型的字符。

這裏的客戶端：

int static flagger = 0; 
char process_char = 'a'; 

/** 
* handler for SIGUSR2 
*/ 
void my_handler(int signum) 
{ 

    printf("foo bar\n"); 

    if (signum == SIGUSR2) 
    { 
     printf("Received SIGUSR2!\n"); 
     flagger++; 
    } 

    printf("flagger is :%d\n" , flagger); 

    if (flagger == 1) 
    { 
     // then process works with "X" 
      process_char = 'x'; 
      printf("I'm process 1, working with X char\n"); 
      // exit(1); 
    } 

    else if (flagger == 2) 
    { 
     process_char = 'Y'; 
     printf("I'm process 2 , working with Y char\n"); 
     // exit(1); 
    } 

} 




void error(char* str) 
{ 
    perror(str); 
    exit(1); 
} 




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

    pid_t pid; 

    /* get the process id */ 
    if ((pid = getpid()) < 0) 
    { 
     perror("unable to get pid"); 
    } 
    else 
    { 
     printf("The process id is %d\n", pid); 
    } 

    int pidInt = (int)pid;  // convert the pid to int 

    // write pid into the fifo 

    int fd = open("fifo_clientTOserver",O_WRONLY); // open the fifo for writing 
    if(fd < 0) 
    { 
     perror("open"); 
     exit(1); 
    } 

    signal(SIGUSR2, my_handler); 

    printf("Tester1\n"); 


    // writing the PID of the client into the pipe 
    write(fd, &pidInt ,sizeof(int)); 

    close(fd);  // closing the pipe 

    printf("Tester2\n"); 

    while(1) 
    { 
     printf("Waiting for the signal...\n"); 
     sleep(1); 
    } 


     // more code 

    } 

我試圖用一個靜態int變量在客戶端（flagger）的SIGUSR2信號之間進行區分（第1或2），但因爲沒有幫助，對於每個客戶端，靜態flagger是一個新變量，以0開頭併到達1。

我怎麼能一個進程收到SIGUSR2第一時間和另一過程中收到SIGUSR2第二次區分？

Answer 1

如果您需要傳遞數據，則信號不是合適的機制。考慮使用不同的IPC方法，例如命名管道。