sigaction structure initialisation

[gemera]

To initialise structures, instead of using memset() I've got used to doing e.g.

struct sockaddr_in serv = {0};

I'm learning about the sigaction() function and

struct sigaction sa = {0};

produces following warnings?

warning: missing braces around initializer
warning: (near initialization for 'sa.__sigaction_handler')

I'm using gcc compiler in Puppy Linux.

[dmh2000]

that structure must have some nested elements and the compiler is picky that the initializer conform to the nesting. if you were explicitly initializing all members, you would have a nesting of braces to match the structure format. so you have two choices: ignore the warning, the code will still work. or fix your initializer to match the structure nesting.

[christop]

The standard sigaction structure doesn't have any nested structures. I'm guessing that sa_sigaction and sa_handler are stored in a union named "sa" in the structure on this system (since the two handler callbacks are mutually exclusive anyway), and those names are aliases (macros) for sa.__sigaction_handler and (I'm guessing) sa.__sigaction_sigaction.

I'd leave the initializer the way it is and ignore the warning, or leave out the initializer and use memset if the warning bothers you.

[Salem]

You could try something like this

    struct sigaction sa = { { 0 } };

But beware of this:

union foo {
    int a;
    char b[100];
} var = { 0 };

A union initialiser only initialises the first named element of a union.
If you then try to use another member, it will NOT be initialised as you would expect.

[oogabooga]

For gcc, this warning only shows up with -Wextra (-Wall doesn't show it).

In the following nested structure (x) I could only get the warning to go away by doing this:

    struct X x = { 0, 0, 0, {0, 0} };

Interestingly, there's a difference between doing this and using memset, in that the "holes" in the structure are not zeroed with the initializer method, as demonstrated by this program:

#include <stdio.h>

struct Y {
    char d;
    int e;
};

struct X {
    char   a;
    int    b;
    double c;
    struct Y y;
};

int main(void) {
    struct X x = { 0, 0, 0, {0, 0} };
    char *p, *pend = (char*)&x + sizeof(x);

    for (p = (char*)&x; p < pend; p++)
        if (*p != 0)
            printf("%d\n", p - (char*)&x);

    return 0;
}

[christop]

Interestingly, there's a difference between doing this and using memset, in that the "holes" in the structure are not zeroed with the initializer method, as demonstrated by this program:

Certainly, but the (padding) holes shouldn't be accessed in most cases anyway.

[gemera]

I'm still struggling with this program, it's a server program that uses signal() to trap SIGCHLD.

I thought it would be easy to convert to sigaction but the output seems to show spurious child processes being created,most often when another child process has just terminated.

The original program works perfectly.

I'm still using the same handling function which is

void sigchld_handler(int signo)
{
    while(waitpid(-1,NULL,WNOHANG)>0);
}

the call to signal was

signal(SIGCHLD,sigchld_handler);

so I created the sigaction struct and replaced signal with this sigaction call

struct sigaction san;
memset(&san,0,sizeof(san));
san.sa_handler = &sigchld_handler;


sigaction(SIGCHLD,&san,NULL);

That's the only changes.

[gemera]

[QUOTE=Salem;1123361]You could try something like this

    struct sigaction sa = { { 0 } };

yup, that works.

excellent!