/* Flags to indicate socket events. 0 indicates no event. */

#define POLLIN      0x0001    /* There is data to read */
#define POLLPRI     0x0002    /* There is urgent data to read */
#define POLLOUT     0x0004    /* Writing now will not block */
#define POLLERR     0x0008    /* Error condition */
#define POLLHUP     0x0010    /* Hung up */
#define POLLNVAL    0x0020    /* Invalid request: fd not open */

struct pollfd {
  int fd;
  short events;
  short revents;
};

int poll(struct pollfd *pfds, int number, int timeout);
			

[root@joinc /root]# kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL
 5) SIGTRAP      6) SIGABRT      7) SIGBUS       8) SIGFPE
 9) SIGKILL     10) SIGUSR1     11) SIGSEGV     12) SIGUSR2
13) SIGPIPE     14) SIGALRM     15) SIGTERM     17) SIGCHLD
18) SIGCONT     19) SIGSTOP     20) SIGTSTP     21) SIGTTIN
22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO
30) SIGPWR      31) SIGSYS      32) SIGRTMIN    33) SIGRTMIN+1
34) SIGRTMIN+2  35) SIGRTMIN+3  36) SIGRTMIN+4  37) SIGRTMIN+5
38) SIGRTMIN+6  39) SIGRTMIN+7  40) SIGRTMIN+8  41) SIGRTMIN+9
42) SIGRTMIN+10 43) SIGRTMIN+11 44) SIGRTMIN+12 45) SIGRTMIN+13
46) SIGRTMIN+14 47) SIGRTMIN+15 48) SIGRTMAX-15 49) SIGRTMAX-14
50) SIGRTMAX-13 51) SIGRTMAX-12 52) SIGRTMAX-11 53) SIGRTMAX-10
54) SIGRTMAX-9  55) SIGRTMAX-8  56) SIGRTMAX-7  57) SIGRTMAX-6
58) SIGRTMAX-5  59) SIGRTMAX-4  60) SIGRTMAX-3  61) SIGRTMAX-2
62) SIGRTMAX-1  63) SIGRTMAX
			

int sockfd = accept(..);

// 소켓을 논블럭,비동기로 설정한다.
fcntl(sockfd, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC);
// SIGRTMIN보다 더 큰 RTS시그널이 전달되도록 한다. 
fcntl(sockfd, F_SETSIG, SIGRTMIN);
// 시그널을 보낼 프로세스 ID를 설정한다. 
// 여기에서는 자기 프로세스로 보내도록 했다. 
fcntl(sockfd, F_SETOWN, getpid());
fcntl(sockfd, F_SETAUXFL, O_ONESIGFD);
			

#include <signal.h>

int sigwaitinfo(const sigset_t *set, siginfo_t *info);
int sigtimedwait(const sigset_t *set, siginfo_t *info, const
      struct timespec *timeout);
int sigqueue(pid_tpid, int sig, const union sigval value);
			

sigset_t signalset;
siginfo_t siginfo;
int signum, sockfd, revents;

sigemptyset(&signalset);
sigaddset(&signalset, SIGRTMIN);

signum = sigwaitinfo (&signalset, &siginfo); 
if (signum == SIGRTMIN)
{
    sockfd = siginfo.si_fd;
    revents = siginfo.si_band;
    // sockfd와 revents를 이용해서 필요한 작업을 한다. 
}
			

#include <signal.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>

// F_SETSIG의 이용을 위해서 __USE_GNU를 디파인 한다. 
#ifndef __USE_GNU
#define __USE_GNU
#endif

#include <fcntl.h>

/*
 * 클라이언트와 통신에 사용할 데이터
 */  
struct data
{
    int a;
    int b;
    int sum;
};

/*
 * 인자로 주어진 파일 지정자에 대허서   
 * 비봉쇄(NONBLOCK), 비동기(ASYNC)로 지정하고
 * 리얼타임 시그널(SIGRTMIN)에 대응하도록 작업한다. 
 */
int setup_sigio(int fd)
{
    if (fcntl(fd, F_SETFL, O_RDWR|O_NONBLOCK|O_ASYNC) < 0)
    {
        printf("Couldn't setup nonblocking io %d\n", fd);
        return -1;
    }
    if (fcntl(fd, F_SETSIG, SIGRTMIN) < 0)
    {
        printf("Couldn't set signal %d on %d\n", SIGRTMIN, fd);
        return -1;
    }    
    if (fcntl(fd, F_SETOWN, getpid()) < 0)
    {
        printf("Couldn't set owner %d on %d\n", getpid(), fd);
        return -1;
    }
    return 0;
}

/*
 * setup_sigio()에 대한 포장함수
 */
void setup_sigio_listeners(fd)
{
    if (setup_sigio(fd) != 0)
    {
        printf("setup_sigio_listners error : %d\n", fd);
        exit(0);
    }
    else
    {
    }
}

/*
 * 해당 포트를 이용해서 
 * UDP소켓을 작성하고
 * 소켓 지정자를 리턴한다.
 */
int get_listener_fd(int port)
{
    int sockfd;
    int clilen;
    int state;
    struct sockaddr_in serveraddr;

    clilen = sizeof(serveraddr);
    sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        printf("Socket create error\n");
        exit(0);
    }
    serveraddr.sin_family = AF_INET;
    serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serveraddr.sin_port = htons(port);

    state = bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
    if (state == -1)
    {
        perror("bind error : ");
        exit(0);
    }

    return sockfd;
}

int main()
{
    struct siginfo si; 
    sigset_t set;
    int ret;
    int resockfd;
    int sockfd1, sockfd2;
    struct data add_data;
    struct sockaddr_in clientaddr; 
    int clilen;

    // 1.
    // 리얼 타임시그널에 대해서 SIG_BLOCK로 
    // 작동하도록 설정한다. 
    sigemptyset(&set);
    sigaddset(&set, SIGRTMIN); 
    sigprocmask(SIG_BLOCK, &set, NULL);

    // 2.
    // 포트번호 1234, 1235로 2개의 UDP 소켓을 
    // 만들고 이들 소켓이 RTS에 대응하도록 한다. 
    sockfd1 = get_listener_fd(1234);
    setup_sigio_listeners(sockfd1);

    sockfd2 = get_listener_fd(1235);
    setup_sigio_listeners(sockfd2);

    while(1)
    {
        clilen = sizeof(clientaddr);

        // 3. RTS를 기다린다.  
        printf("Sig wait\n");    
        ret = sigwaitinfo(&set, &si);

        // 4.
        // 만약 RTS가 도착했다면
        // siginfo구조체의 값을 검사해서 어느 소켓으로 부터 
        // 데이터가 왔는지 확인하고, 해당 소켓을 통해 
        // 클라이언트와 통신한다.  
        if(ret == SIGRTMIN)
        {
            // select를 쓰지 않고도 이벤트가 발생한 
            // 소켓을 알아낼 수 있다.
            printf("=========================\n");
            printf("RTS I/O socket  %d\n", si.si_fd);
            printf("RTS I/O revents %d\n", si.si_band);
            printf("=========================\n");
            resockfd = si.si_fd;
            recvfrom(resockfd, (void *)&add_data, sizeof(add_data), 0, 
                            (struct sockaddr *)&clientaddr, &clilen);
            add_data.sum = add_data.a + add_data.b; 
            sendto(resockfd, (void *)&add_data, sizeof(add_data), 0,
                            (struct sockaddr *)&clientaddr, clilen);
            // 5.
            // 디버깅용 : 필요에 따라 주석을 풀고 테스트 해본다. 
            // printf("sleep\n");
            // sleep(10);
        }
    }
}

			

union sigval
{
    int sival_int;
    void *sival_ptr;
}
			

#include <signal.h>
#include <stdio.h>
#include <unistd.h>

/* 
 * 시그널 핸들러
 * si_code가 SI_QUEUE 인지를 확인한후 원하는 작업을 한다.  
 * SI_QUEUE일 경우 RTS형식으로 전달된 시그널이며 
 * 그렇지 않을경우 표준 유닉스 시그널이다.  
 */
void sighandler(int signo, siginfo_t *si)
{
    if(si->si_code == SI_QUEUE)
    {
        printf("User RTS signal %d\n", si->si_pid);
        printf("Sig  Number %d\n",     si->si_signo);
        printf("User Data is %d\n",    si->si_value.sival_int);
        // 시그널이 큐잉되는지 확인하기 위한 코드
        getchar();
    }
    else
    {
        // kill등을 이용해서 표준 유닉스 시그널을 보냈을 경우
        // 실행되는 루틴 
        printf("Get none realtime signal %d\n", signo); 
    }
}

int main()
{
    struct sigaction sigact;

    printf("My pid %d\n", getpid());

    /*
     * sa_flags를 SA_SIGINFO로 설정하고 
     * 시그널 핸들러를 등록한다. 
     */
    sigemptyset(&sigact.sa_mask);
    sigact.sa_flags     = SA_SIGINFO;
    sigact.sa_restorer  = NULL; 
    sigact.sa_sigaction = sighandler; 

    /*
     * RTS시그널에 대한 핸들러를 설치한다.  
     */
    if (sigaction(SIGRTMIN, &sigact, 0) == 1)
    {
        printf("signal error\n");
        exit(0);
    }   
    while(1)
    {
        sleep(1);
    }   
}   
			

#include <signal.h>
#include <stdio.h>

/*
 * argv[1]은 보내고자 하는 프로세스의 PID  
 * argv[2]는 보내고자 하는 값이다.   
 * SIGUSR1을 RTS로 전송한다. 
 */  
int main(int argc, char **argv)
{
    union sigval sv;

    sv.sival_int = atoi(argv[2]);
    sigqueue(atoi(argv[1]), SIGRTMIN, sv);
}