Receiving UDP Packets Asynchronously From Multiple File Descriptors - c++

Question

I have a questions about using fcntl and sigaction to receive a UDP packet asynchronously. In my program I have two sources of UDP traffic that I would like to monitor. I have set up two sockets for the traffic and used this tutorial to set the file descriptor to trigger a sigaction whenever I receive a UDP packet.
This works fine with only one source, but when I add the other source it will trigger only one of the handlers whenever either file descriptor receives a packet.
Here is a short program demonstrating the behavior:
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int done;
int a_fd;
int b_fd;
int recv_dgram(int fd, char* dgram, int size)
{
struct sockaddr_in addr;
int fromlen = sizeof(addr);
return recvfrom(fd, dgram, size, 0, (struct sockaddr*)&addr, (socklen_t*)&fromlen);
}
void a_handler(int signum)
{
char dgram[256];
int size = recv_dgram(a_fd, dgram, 256);
printf("a recieve size: %d\n", size);
}
void b_handler(int signum)
{
char dgram[256];
int size = recv_dgram(b_fd, dgram, 256);
printf("b recieve size: %d\n", size);
}
void sig_handle(int signum)
{
done = 1;
}
int init_fd(int port, const char* group, const char* interface)
{
int fd = socket(AF_INET, SOCK_DGRAM, 0);
if(fd < 0) {
return -1;
}
int reuse = 1;
if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (char*)&reuse, sizeof(reuse)) < 0) {
close(fd);
return -1;
}
if(fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
close(fd);
return -1;
}
struct sockaddr_in addr;
memset((char*)&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = INADDR_ANY;
if(bind(fd, (struct sockaddr*)&addr, sizeof(addr))) {
close(fd);
return -1;
}
struct ip_mreq mcast_group;
mcast_group.imr_multiaddr.s_addr = inet_addr(group);
mcast_group.imr_interface.s_addr = inet_addr(interface);
if(setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mcast_group, sizeof(mcast_group))) {
close(fd);
return -1;
}
return fd;
}
int main(int argc, const char* argv[])
{
done = 0;
signal(SIGINT, sig_handle);
signal(SIGTERM, sig_handle);
// make sockets and sigactions
a_fd = init_fd([a port], [a multicast group], [a interface]);
if(a_fd < 0) {
return -1;
}
pid_t pid = getpid();
int a_flags = fcntl(a_fd, F_GETFL);
fcntl(a_fd, F_SETFL, a_flags | O_ASYNC);
struct sigaction a_sa;
a_sa.sa_flags = 0;
a_sa.sa_handler = a_handler;
sigemptyset(&a_sa.sa_mask);
sigaction(SIGIO, &a_sa, NULL);
fcntl(a_fd, F_SETOWN, pid);
fcntl(a_fd, F_SETSIG, SIGIO);
b_fd = init_fd([b port], [b multicast group], [b interface]);
if(b_fd < 0) {
close(a_fd);
return -1;
}
int b_flags = fcntl(b_fd, F_GETFL);
fcntl(b_fd, F_SETFL, b_flags | O_ASYNC);
struct sigaction b_sa;
b_sa.sa_flags = 0;
b_sa.sa_handler = b_handler;
sigemptyset(&b_sa.sa_mask);
sigaction(SIGIO, &b_sa, NULL);
fcntl(b_fd, F_SETOWN, pid);
fcntl(b_fd, F_SETSIG, SIGIO);
printf("start\n");
while(!done) { pause(); }
printf("done\n");
close(a_fd);
close(b_fd);
return 0;
}
I can compile this with (you can compile using gcc too):
g++ -c test.cpp
g++ -o test test.o
I'm using g++ 4.6.3 on Ubuntu 12.04 LTS.
When I run this program with two sources of UDP data, b_handler gets triggered when either file descriptors has a packet available. So it will print "b received size: -1" whenever a_handler should receive a packet. a_handler never gets called.
I suspect that this is because getpid() will return the same value for both of them so one of the sigaction handler will be overwritten.
Is there any way I can have these two handlers trigger independent of each other?
Thanks for the help.

Answer 1

Use two different signals, say SIGIO and SIGUSR1.
fcntl(descriptor, SETSIG, signal_desired);