Signals, Pulses, and Messages in C

Further studies in pulses…messages… AND SIGNALS!

Sorry. Signals don’t rate capslock, tbh. But I shall attempt to teach you about them.

The usual includes. msg.h is my teachers’ concoction, and may be found here.

#include &lt;stdio.h&gt;
#include &lt;sys/neutrino.h&gt;
#include "msg.h"
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;sys/netmgr.h&gt;
#include &lt;process.h&gt;
#include &lt;time.h&gt;

#include <stdio.h>

#include <sys/neutrino.h>

#include "msg.h"

#include <stdlib.h>

#include <string.h>

#include <sys/netmgr.h>

#include <process.h>

#include <time.h>

Gonna need some globals – the main and a couple of helpter functions both need to access the logfile, the channel id, and the timestruct.

//globals
 FILE *logfile;
 int chid;

//globals

FILE *logfile;

int chid;

//for timestamps
 time_t timestruct;

1 2	//for timestamps time_t timestruct;

Begin!

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

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

printf("Logger has started.\n");

1	printf("Logger has started.\n");

Initialize the timestruct, cos it is no longer 1970 and I am not Dennis Ritchie.

timestruct = time(NULL);

1	timestruct = time(NULL);

The void pointer – a promise of a method, soon to be revealed.

//declare functions
 int setupPulseAndTimer();
 int setupSignalAndTimer();
 int handleMessage(int header, MESSAGE theMessage, int rcvid);
 void handleSignal(int signalNum);

//declare functions

int setupPulseAndTimer();

int setupSignalAndTimer();

int handleMessage(int header, MESSAGE theMessage, int rcvid);

void handleSignal(int signalNum);

That logfile declaration from above? Time to use it! This is nothing more than a textfile where your program is going to write some stuff down.

//open the log file for writing
 logfile = fopen(argv[1], "w");

1 2	//open the log file for writing logfile = fopen(argv[1], "w");

A couple more variables; theMessage is a handle for data that is received from the client. rcvid will be used to tell the client which of it’s many messages you are currently replying to.

int rcvid;
 MESSAGE theMessage;

1 2	int rcvid; MESSAGE theMessage;

Upon startup, this message logger will report its process id, channel id, and node descriptor, and log that info in a pidfile. As I write this I can’t help noticing that chid isn’t initialized yet. I really hope I figure out an explanation for that later.

//handle pidfile

1	//handle pidfile

//declare the file
 FILE *pidfile;

1 2	//declare the file FILE *pidfile;

//get it's location from the command line
 char *pidFileName = malloc(strlen(argv[0])+5);

1 2	//get it's location from the command line char *pidFileName = malloc(strlen(argv[0])+5);

//tack .pid on the end just in case, you should probably 
//wrap that in an "if not .pid, add .pid" for robustness, 
//but I'm living dangerously.
 strcpy(pidFileName, argv[0]);
 strcat(pidFileName, ".pid");

//tack .pid on the end just in case, you should probably

//wrap that in an "if not .pid, add .pid" for robustness,

//but I'm living dangerously.

strcpy(pidFileName, argv[0]);

strcat(pidFileName, ".pid");

//open that sucker up
 pidfile = fopen(pidFileName, "w");

1 2	//open that sucker up pidfile = fopen(pidFileName, "w");

//write stuff down and hope you don't 
//get a null pointer exception from that chid
 fprintf(pidfile, "%d %d %d \n", ND_LOCAL_NODE, getpid(), chid);

//write stuff down and hope you don't

//get a null pointer exception from that chid

fprintf(pidfile, "%d %d %d \n", ND_LOCAL_NODE, getpid(), chid);

//close up and let it go.
 fclose(pidfile);
 free(pidFileName);

//close up and let it go.

fclose(pidfile);

free(pidFileName);

This bit is kinda weird. These two functions are both at the bottom of this program, so you’re sending pulses and signals to yourself. Why do that? Narcissism? Shpakism? Just do it.

int pulseSet = setupPulseAndTimer();

1	int pulseSet = setupPulseAndTimer();

int signalSet = setupSignalAndTimer();

1	int signalSet = setupSignalAndTimer();

printf("Pulse status: %d \n Signal status: %d \n", pulseSet, signalSet);

1	printf("Pulse status: %d \n Signal status: %d \n", pulseSet, signalSet);

This is also weird. You’re bascially announcing, “Hey, a signal might show up, and if it does, here’s what you do.” And that instruction is standing orders for the rest of the program, or til you change it.

signal(SIGUSR2, &amp;handleSignal);

1	signal(SIGUSR2, &handleSignal);

K, with all that established, begin a for loop that will run until further notice, taking messages and reporting them in the logfile.

for (;;) {
 rcvid = MsgReceive(chid, &amp;theMessage, sizeof (theMessage), NULL);

1 2	for (;;) { rcvid = MsgReceive(chid, &theMessage, sizeof (theMessage), NULL);

Now, this part confuses me. Cause I thought that a pulse was just a message, with a rcvid of zero. But the teacher has us, apparently, handling two cases that both match the definition of “pulse” in my mind.

So, the first “if” handles rcvid == 0.

if (rcvid == 0) {
    //When pulse arrives log it along with the code that was received.
    fprintf(logfile, "%s Pulse received - CODE %d \n", 
         ctime(&amp;timestruct), theMessage.pulse.code);
    printf("%s: Pulse received and logged.\n", ctime(&amp;timestruct));
 }

if (rcvid == 0) {

//When pulse arrives log it along with the code that was received.

fprintf(logfile, "%s Pulse received - CODE %d \n",

ctime(&timestruct), theMessage.pulse.code);

printf("%s: Pulse received and logged.\n", ctime(&timestruct));

}

The second “if” redirects to a helper method that has the same big switch statement from my previous post. It also handles a “pulse”, and like I said, I’m confused. However, I swear to god this code runs and drive as written.

Take note of the timeToQuit int there. It takes the return value of the handleMessage function – if the message was a … sigh … pulse, I guess … it returns something other than zero, which terminates the loop, and the program.

else {
    int timeToQuit = handleMessage(theMessage.client.m_hdr, 
          theMessage, rcvid);
    printf("%s: Message received and logged. \n", ctime(&amp;timestruct));
    if (timeToQuit != 0) {
       fclose(logfile);
       exit(EXIT_SUCCESS);
    }
 }
} //end for loop

else {

int timeToQuit = handleMessage(theMessage.client.m_hdr,

theMessage, rcvid);

printf("%s: Message received and logged. \n", ctime(&timestruct));

if (timeToQuit != 0) {

fclose(logfile);

exit(EXIT_SUCCESS);

}

} //end for loop

return 0;
} //end main

1 2	return 0; } //end main

So where are these pulses and signals coming from? Upsettingly, they are coming from within this very program.

Here’s the setup for a pulse. It is straight out of Getting Started With QNX Neutrino, which can be found here, page 152. RTFM fools.

   int setupPulseAndTimer() {

1	int setupPulseAndTimer() {

//Create a timer that sends a pulse and code MSG_PULSE_ALIVE 
//3 sec after startup and every 5 sec thereafter

1 2	//Create a timer that sends a pulse and code MSG_PULSE_ALIVE //3 sec after startup and every 5 sec thereafter

    timer_t timerid;
    struct sigevent event;
    struct itimerspec timer;
    int coid;

timer_t timerid;

struct sigevent event;

struct itimerspec timer;

int coid;

    coid = ConnectAttach (0, 0, chid, 0, 0);

1	coid = ConnectAttach (0, 0, chid, 0, 0);

    if (coid == -1) {
        fprintf (stderr, "Logger: couldn’t ConnectAttach to self!\n");
        perror (NULL);
        exit (EXIT_FAILURE);
    }

if (coid == -1) {

fprintf (stderr, "Logger: couldn’t ConnectAttach to self!\n");

perror (NULL);

exit (EXIT_FAILURE);

}

    SIGEV_PULSE_INIT(&amp;event, coid, SIGEV_PULSE_PRIO_INHERIT, 
    MSG_PULSE_ALIVE, 0);

1 2	SIGEV_PULSE_INIT(&event, coid, SIGEV_PULSE_PRIO_INHERIT, MSG_PULSE_ALIVE, 0);

    if (timer_create (CLOCK_REALTIME, &amp;event, &amp;timerid) == -1) {
        fprintf (stderr, "Logger: couldn’t create a timer, errno %d\n", 
             errno);
        perror (NULL);
        exit (EXIT_FAILURE);
    }

if (timer_create (CLOCK_REALTIME, &event, &timerid) == -1) {

fprintf (stderr, "Logger: couldn’t create a timer, errno %d\n",

errno);

perror (NULL);

exit (EXIT_FAILURE);

}

    timer.it_value.tv_sec = 3; //three seconds after startup...
    timer.it_value.tv_nsec = 0;
    timer.it_interval.tv_sec = 5; //and every five thereafter.
    timer.it_interval.tv_nsec = 0;

timer.it_value.tv_sec = 3; //three seconds after startup...

timer.it_value.tv_nsec = 0;

timer.it_interval.tv_sec = 5; //and every five thereafter.

timer.it_interval.tv_nsec = 0;

    timer_settime (timerid, 0, &amp;timer, NULL);

1	timer_settime (timerid, 0, &timer, NULL);

    return 0; //return zero so my error checking printf above works.

}

return 0; //return zero so my error checking printf above works.

}

The signal setup works almost exactly the same, there’s like one line that’s different.

int setupSignalAndTimer() {
 //Create a timer that sends a signal SIGUSR2 2 seconds after 
 //startup and every 7 seconds thereafter.

    timer_t timerid;
    struct sigevent event;
    struct itimerspec timer;
    int coid;

int setupSignalAndTimer() {

//Create a timer that sends a signal SIGUSR2 2 seconds after

//startup and every 7 seconds thereafter.

timer_t timerid;

struct sigevent event;

struct itimerspec timer;

int coid;

    coid = ConnectAttach (0, 0, chid, 0, 0);

    if (coid == -1) {
        fprintf (stderr, "Logger: couldn’t ConnectAttach to self!\n");
        perror (NULL);
        exit (EXIT_FAILURE);
    }

coid = ConnectAttach (0, 0, chid, 0, 0);

if (coid == -1) {

fprintf (stderr, "Logger: couldn’t ConnectAttach to self!\n");

perror (NULL);

exit (EXIT_FAILURE);

}

    //this is the line that's different.
    SIGEV_SIGNAL_INIT (&amp;event, SIGUSR2); timer_create 
       (CLOCK_REALTIME, &amp;event, &amp;timerid);

//this is the line that's different.

SIGEV_SIGNAL_INIT (&event, SIGUSR2); timer_create

(CLOCK_REALTIME, &event, &timerid);

    if (timer_create (CLOCK_REALTIME, &amp;event, &amp;timerid) == -1) {
       fprintf (stderr, "Logger: couldn’t create a timer, errno %d\n", 
           errno);
       perror (NULL);
       exit (EXIT_FAILURE);
    }

if (timer_create (CLOCK_REALTIME, &event, &timerid) == -1) {

fprintf (stderr, "Logger: couldn’t create a timer, errno %d\n",

errno);

perror (NULL);

exit (EXIT_FAILURE);

}

    timer.it_value.tv_sec = 2;
    timer.it_value.tv_nsec = 0;
    timer.it_interval.tv_sec = 7;
    timer.it_interval.tv_nsec = 0;

timer.it_value.tv_sec = 2;

timer.it_value.tv_nsec = 0;

timer.it_interval.tv_sec = 7;

timer.it_interval.tv_nsec = 0;

    timer_settime (timerid, 0, &amp;timer, NULL);

1	timer_settime (timerid, 0, &timer, NULL);

    return 0;
}

1 2	return 0; }

My message handler. It logs a message if a message turns up, and shuts the whole show down if a confusingly explained pulse shows up.

int handleMessage(int header, MESSAGE theMessage, int rcvid) {

1	int handleMessage(int header, MESSAGE theMessage, int rcvid) {

   char reply[512];

1	char reply[512];

   switch(header) {
      //if message type is MSG_DATA, log message and replay MSG_OK
      case (MSG_DATA):
          fprintf(logfile, "%s %s \n", ctime(&amp;timestruct), 
              theMessage.client.m_data);
          printf("Message logged. \n");
          strcpy(reply, "Message logged. \n");
          int repBytes = sizeof(reply);
          MsgReply(rcvid, MSG_OK, reply, repBytes);
          fflush(logfile);
          break;
      //if message type is MSG_END, reply MSG_END then exit
      case (MSG_END):
          fprintf(logfile, "%s Pulse recieved - server exiting.\n", 
               ctime(&amp;timestruct));
          MsgReply(rcvid, MSG_END, NULL, NULL);
          fflush(logfile);
          return 1;
      //break;
      //if it is neither of these, reply MSG_INVALID and log incident.
      default:
      fprintf(logfile, "Warning: invalid message format received.\n");
          MsgReply(rcvid, MSG_INVALID, NULL, NULL);
          break;
       }
      return 0;
 }

switch(header) {

//if message type is MSG_DATA, log message and replay MSG_OK

case (MSG_DATA):

fprintf(logfile, "%s %s \n", ctime(&timestruct),

theMessage.client.m_data);

printf("Message logged. \n");

strcpy(reply, "Message logged. \n");

int repBytes = sizeof(reply);

MsgReply(rcvid, MSG_OK, reply, repBytes);

fflush(logfile);

break;

//if message type is MSG_END, reply MSG_END then exit

case (MSG_END):

fprintf(logfile, "%s Pulse recieved - server exiting.\n",

ctime(&timestruct));

MsgReply(rcvid, MSG_END, NULL, NULL);

fflush(logfile);

return 1;

//break;

//if it is neither of these, reply MSG_INVALID and log incident.

default:

fprintf(logfile, "Warning: invalid message format received.\n");

MsgReply(rcvid, MSG_INVALID, NULL, NULL);

break;

}

return 0;

}

And finally, the signal handler. It’s pretty easy.

void handleSignal(int signalNum) {
    fflush(logfile);
}

void handleSignal(int signalNum) {

fflush(logfile);

}

And that’s the whole mess. It runs on my machine; I take no responsibility if it causes your computer to have a stroke instead. Here’s the finished code.

Begin!

Success!