Multiple timers in C

Question

I have an application which needs to do the following:

• If an event happens (a disconnect from server), a long timer is started (say 5 minutes). The application then tries to reconnect to the server.
• If the reconnect fails, a short timer is started (20 seconds) which should attempt to reconnect again.
• If it succeeds, the long timer should keep going.
• When the long timer expires, if there is no connection, the application should exit, otherwise it should continue as normal.

I am limited in that I cannot use threads, only processes. I also cannot afford to wait for the result of reconnect() to return.

So far I have a design like this:

int main(int argc, char **argv)
{
    /* do main loop work, if disconnected, call reconnect() & continue doing work */
}

void reconnect()
{
    pid = fork();

    if (pid >= 0) {
        /*Successful fork*/
        if (pid == 0) {

            rv = attempt_reconnect;               
            if (rv == 0) {
                /*Notify sig_child Success*/
                exit(0);
            } else {
                /*Notify sig_child Fail*/
                exit(1);
            }
        }
    } 
}

void sig_child(int signum)
{
    if(fork returned success) {
        set flag to continue network stuff
    }
    else {
        alarm(20);
    }
}

void sig_alarm(int signo)
{
    /*Received alarm, trying to reconnect...*/
    reconnect();
}

Any help would be greatly appreciated!

Edit

I think I have a solution working from an example here. It allows me to create timers with separate ID's, and then identify which one has has signalled the program

Answer 1

Using the following code I found here, I have achieved (I think) what I was trying to do.

It allows the creation and handling of multiple timer_t objects using the functions "makeTtimer" and "timerHandler" respectively:

timer_t reconnect_timer_id;
timer_t timeout_timer_id;

int main(int argc, char **argv)
{
    /* do main loop work */
    if(disconnected()) {
        /*IF TIMEOUT SET, SKIP, IF OK, RESET*/
        if(timeout_set != 1) {
            "Schedule Alarm"
            makeTimer("Timeout Timer", &timeout_timer_id, 600,0);
            timeout_set = 1;
        } else {
              "Timeout alarm already set..";
        }
        reconnect();
    }
}

void reconnect()
{
    pid = fork();

    if (pid >= 0) {
        /*Successful fork*/
        if (pid == 0) {

            rv = attempt_reconnect;               
            if (rv == 0) {
                /*Notify sig_child Success*/
                exit(0);
            } else {
                /*Notify sig_child Fail*/
                exit(1);
            }
        }
    } 
}

void sig_child(int signum)
{
    if(fork returned success) {
        set flag to continue network stuff
    }
    else {
        "Reconnect fail, retrying in 20 seconds...";
        makeTimer("Reconnect Timer", &reconnect_timer_id, 20,0);
    }
}

static void
timerHandler( int sig, siginfo_t *si, void *uc )
{
    timer_t *tidp;
    tidp = si->si_value.sival_ptr;
    if ( *tidp == timeout_timer_id ) {

        if(state != STATE_CONNECTED) {
            "Timeout alarm received, not connected to server, exiting..."
            exit(0);
        } else {
            "Timeout alarm received, connected to server, continuing..."
            timeout_set = 0;
        }

    } else if ( *tidp == reconnect_timer_id ) {
        "Reconnect alarm received, retrying...";
        reconnect();
    }
}

static int
makeTimer( char *name, timer_t *timerID, int expireSeconds, int intervalSeconds )
{
    struct sigevent         te;
    struct itimerspec       its;
    struct sigaction        sa;
    int sigNo = SIGRTMIN;

    /* Set up signal handler. */
    sa.sa_flags = SA_SIGINFO;
    sa.sa_sigaction = timerHandler;
    sigemptyset(&sa.sa_mask);

    if (sigaction(sigNo, &sa, NULL) == -1) {
          "Failed to setup signal handling for" *name;

        return(-1);
    }

    /* Set and enable alarm */
    te.sigev_notify = SIGEV_SIGNAL;
    te.sigev_signo = sigNo;
    te.sigev_value.sival_ptr = timerID;
    timer_create(CLOCK_REALTIME, &te, timerID);
    its.it_interval.tv_sec = intervalSeconds;
    its.it_interval.tv_nsec =0;

    its.it_value.tv_sec = expireSeconds;
    its.it_value.tv_nsec = 0;
    timer_settime(*timerID, 0, &its, NULL);
    return(0);
}

Answer 2

One idea could be not to use alarm( ) but create timers as subprocesses that kill the main processes with two different signals after sleep():

void timer( int nsec, int signum )
{
    pid_t pid = getpid();
    if( fork() > 0 ) {
        sleep( nsec );
        kill( pid, signum );
        exit( 0 );
    }
}

By using two different signals, (e.g. SIGUSR1 for the short timer and SIGUSR2 for the long one) you can have a signal handler like that:

void sig_timer( int signum )
{
    if( signum == SIGUSR1 ) {
        // reconnect
    } else if( signumm == SIGUSR2 ) {
        if( !reconnected )
            exit( 11 );
    } 
}

Answer 3

You can do this only using alarm and flags by polling them in main loop. Once disconnect event is selected in main loop, you can set alarm of 20 seconds and handle reconnect either in handler or in main loop using flags. Keep setting alarms of 20 seconds till you reconnect or 5 five minuted expired. You can check this again in alarm handler if 20 seconds alarm occur 15 times. Now if 5 mins expired then you can reset alarm(0) and notify to main loop for shutdown. Something like this.

int disconnect_event = 0;
int reconnect_try = 1;
int five_minutes  = 0;
int shutdown = 0;
void alarm_handler(int signum)
{
  if(five_minutes == 15)
  {
    alarm(0);
    shutdown = 1;
  }
  else
  {
    reconnect_try = 1;
    alarm(20);
    five_minutes++
  }

} 

int main(int argc, char*argv[])
{
  signal(SIGALRM, alarm_handler);
  while(1)
  {
    if(disconnect_event && reconnect_try)
    {
      if(reconnect() == 0)
      {
        alarm(20);
        reconnect_try = 0;
      }
      else
      {
         disconnect_event = 0;
         reconnect_try = 1;
      }
    }
    if(shutdown)
    {
      disconnect_event = 0;
      reconnect_try = 0;
      alarm(0)
    }

  }

}

Answer 4

It is not clear from the question if the application needs to continue running (1) while connect() is in progress, and (2) while it is in the "short wait".

If it does not need to run in either of these periods, then when you need to engage the long timer, put the absolute time of the expiration of the long timer into some variable, like this:

time_t run_until = time(NULL) + 60;

and after every unsuccessful connect() check if the current time is larger than run_until:

if (connect_rc) {if (time(NULL) > run_until) shutdown(); else reconnect();}

You will get the logic that you described above without any processes or threads.

If you need your process to continue running while connect() is in progress, and/or while you are in a short pause before reconnecting, you might use non-blocking sockets. How to do it is a matter of a lengthy lecture; in essence you arrange your main loop around select() or poll(). These functions lets you wait for one of a set of events to happen, the events being: completion of background connect(), or arrived data ready for recv()/read(), or, importantly, expiration of a timer. This approach, too, will not involve either threads or processes.