Thread: I need a program to recognize a pattern of signals(linux environment)

I need to write a c program that can receive signals and recognize a certain pattern (SIGUSR1, SIGUSR2, SIGUSR1, SIGUSR2). once the pattern is caught the program terminates itself.

I am able to send the signals to the program from a different process, but I am unsure on how to get the signal handler to recognize the pattern.

here is what i have so far:

Code:

#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
sig_atomic_t sigusr1_count = 0;
sig_atomic_t sigusr2_count = 0;

void do_sleep(int i)
{
 while(i)
 {
  i=sleep(i);
 }
}

void handler(int signal_number)
{
 if(signal_number == SIGUSR1)
 {
  ++sigusr1_count;
 }
 if(signal_number == SIGUSR2)
 {
  ++sigusr2_count;
 }
}

int main()
{
 struct sigaction sa;
 memset (&sa, 0, sizeof (sa));
 sa.sa_handler = &handler;
 sigaction (SIGUSR1, &sa, NULL);
 sigaction (SIGUSR2, &sa, NULL);
 printf("going to sleep, ima %i\n", getpid());
 do_sleep(30);


 printf("SIGUSR1 was raised %d times\n", sigusr1_count);
 printf("SIGUSR2 was raised %d times\n", sigusr2_count);
 return 0;
}

I just need help on getting the program to be able to catch that specific pattern.

Originally Posted by Elkvis

I would keep a list of signals that your program receives, and every time you receive one, check the last n signals to see if they match the pattern. Is there a specific time frame during which the signals should arrive? You could store a unix timestamp along with the signal, so that you can only do it if all of the signals have been received within the last x seconds.

there isn't a specific time frame, the goal of the exercise is to get familiar with signals and handling them. I'm just struggling with the logic behind making the program recognize the pattern of signals.

Perhaps you should consider using a state machine.

It could be structured something like this:

Code:

case STATE_0
  wait for signal
  if signal is what you expect, move to STATE_1

case STATE_1
  wait for signal
  if signal is what you expect, move to STATE_2
  else, move to STATE_0

// ...etc

Originally Posted by Matticus

Perhaps you should consider using a state machine.

It could be structured something like this:

Code:

case STATE_0
  wait for signal
  if signal is what you expect, move to STATE_1

case STATE_1
  wait for signal
  if signal is what you expect, move to STATE_2
  else, move to STATE_0

// ...etc

Awesome! I took your advice and this is what I came up with (seems to be working perfectly!!!!):

Code:

#include <signal.h> 
#include <stdio.h> 
#include <string.h> 
#include <sys/types.h> 
#include <unistd.h> 
#include <stdlib.h> 
sig_atomic_t sigusr1_count = 0; 
sig_atomic_t sigusr2_count = 0; 
 
typedef enum 
{ 
 state1=0, 
 state2, 
 state3, 
 state4 
} my_state_t;  
 
my_state_t state = state1; 
 
void do_sleep(int i) 
{ 
 while(i) 
 { 
  i=sleep(i); 
 } 
} 
 
void handler(int signal_number) 
{ 
 
 if(signal_number == SIGUSR1) 
 { 
  ++sigusr1_count; 
 } 
 if(signal_number == SIGUSR2) 
 { 
  ++sigusr2_count; 
 } 
 switch(state) 
 { 
  case state1: 
  if(signal_number == SIGUSR1) 
  state = state2; 
  break; 
 
  case state2: 
  if(signal_number == SIGUSR2) 
  state = state3; 
  else 
  state = state1; 
  break; 
case state3:
  if(signal_number == SIGUSR1)
  state = state4;
  else
  state = state1;
  break;

  case state4:
  if(signal_number == SIGUSR2)
  exit(1);
  else
  state = state1;
  break;
  
  default:
  printf("Invalid signal");
 }
 
}


int main()
{
 struct sigaction sa;
 memset (&sa, 0, sizeof (sa));
 sa.sa_handler = &handler;
 sigaction (SIGUSR1, &sa, NULL);
 sigaction (SIGUSR2, &sa, NULL);
 printf("going to sleep, ima %i\n", getpid());
 do_sleep(30);


 
 printf("SIGUSR1 was raised %d times\n", sigusr1_count);
 printf("SIGUSR2 was raised %d times\n", sigusr2_count);
  
 
 return 0;
}