How do I call other functions with the signal function?

Question

I got a Synthasizer yesterday as a gift, and was interested in writing data to it. I got this much working, here is a program that scales through some notes. Then I thought it would be neat to have it catch the Ctrl+C singal, and close. The problem with just closing the file descriptor is that the MIDI device still processes the last note it was given, so I wrote the mute function, which tells the midi device to mute. That works.

so then I tried to have the signal handler mute the device before exiting, and I have been struggling ever since. The signal(SIGINT, intHandler); function wont take additional arguments. So I thought I would be clever, and write a function mySig that calls the signal function and takes the device file descriptor, and data pointer, and would be able to do one last write, before exiting.

IDK, that might even work, but mySig function, seems to be called from the start, and scaling never happens.

How can I call my mute function, before exiting the program with the signal function?

This is my first signal handing program, Im running linux, and the program is in C.

#include <sys/soundcard.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
static volatile int keepRunning = 1;
char* device =  "/dev/midi1";
//function headers:
void mute(int fd, char *data);
void intHandler(int dummy);
void mySig(void (*intHandler)(int dummy), int fd, char *data);

int main(void){

    unsigned int note=50;

    char data[3] = {0x90, note, 33}; //device address, note, volume
    int fd = open(device, O_WRONLY, 0);
    if( fd < 0 ){
      printf("Error: cannot open Synth %s\n", device);
      exit(1);
      }
    signal(SIGINT, intHandler);      
//      mySig(intHandler,fd,data);

while(keepRunning){
    for( note=30; note < 95; note++ ){
        data[1]=note;//change note
        write( fd, data, sizeof(data) );
        usleep(100000); 
        if(note>=89){
           note =30;
           }
        }
mute(fd,data); //mutes the data stream.
   close(fd); // close device

   return 0;
}
}
//functions:  
void mute(int fd, char *data){
    data[2]=0;//setVolume to 0
    write(fd, data, sizeof(data));
    close(fd);
    }

void mySig(void (*intHandler)(int dummy), int fd, char *data){
    printf("my Sig has been called\n");
    mute(fd,data);
    signal(SIGINT, intHandler);
    }

void intHandler(int dummy) {
    printf("my Sig has been called\n");
    keepRunning = 1;
    printf("ctrl+c was pressed, exiting\n");
    usleep(10000);
    exit(1);
}

Answer 1

Use the signal handler to only clear your keepRunning flag. Personally, I prefer the opposite flag, as in done:

static volatile sig_atomic_t  done = 0;

static void done_handler(int signum)
{
    done = 1; /* Or, in Linux, done = signum. */
}

static int install_done(const int signum)
{
    struct sigaction  act;

    memset(&act, 0, sizeof act);

    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    act.sa_handler = done_handler;
    if (sigaction(signum, &act, NULL) == -1)
        return errno;

    return 0;
}

If the user runs the program in a terminal, and they close the terminal unexpectedly, the program will receive a SIGHUP signal; Ctrl+C causes a SIGINT signal; and SIGTERM is often used to ask a program to exit. So, I personally like to do

    if (install_done(SIGINT) ||
        install_done(SIGHUP) ||
        install_done(SIGTERM)) {
        fprintf(stderr, "Cannot install signal handlers: %s.\n", strerror(errno));
        return EXIT_FAILURE;
    }

early in my main().

All you need to do, is to have your loop -- in my case,

    while (!done) {
        /* Play notes or whatever */
    }

and after the loop, mute the last note played, then close the device.

Consider the signal just a request to exit, as soon as is convenient; not a demand to exit immediately. It is expected that programs do necessary cleanup when they receive a signal asking them to exit. If one wants a program to exit right then, one can always kill the process with SIGKILL.