DNS Daemon

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <netdb.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <signal.h>

#define CATCH_TIME 3600
#define CATCH_IDLE 3600

typedef struct dns_catch dns_catch;
struct dns_catch {
    char* name;
    char  addr[16];
    int   refresh;
    int   access;
    dns_catch* next;
};

static void transmit(int fd, char* buf, size_t count, int toread)
{
    int len, ret;

    for(len=0; len<count; len+=ret) {
        ret = (toread)?(read(fd, buf+len, count-len)):(write(fd, buf+len, count-len));
        if(ret==0 || (ret<0 && errno!=EINTR && errno!=EAGAIN)) {
            perror("daemon transmit:"); exit(-1);
        }
        if(ret<0) ret = 0;
    }
}

static void resolve_request(int sfd, dns_catch** list)
{
    dns_catch *catch;
    int count;
    char head[sizeof(int)*2];
    char *name = NULL, *addr = NULL;

    if(sfd<0 || !list) return;

    transmit(sfd, head, sizeof(int)*2, 1);

    memcpy(&count, head, sizeof(int));
    name = (char*)malloc(count+1);

    transmit(sfd, name, count, 1);

    name[count] = '\0';

    for(catch=*list; catch; catch=catch->next) {
        if(catch->name && !strcmp(catch->name, name)) {
            catch->access = time(NULL);
            addr = catch->addr;
            break;
        }
    }
    if(!addr) {
        struct hostent *he = gethostbyname(name);
        char *p;

        if(he && (p=inet_ntoa(*((struct in_addr*)(he->h_addr)))) && strlen(p)<16) {
            dns_catch *tmp = (dns_catch*)malloc(sizeof(dns_catch));
            memset(tmp, 0, sizeof(dns_catch));

            tmp->name = name;
            strcpy(tmp->addr, p);
            tmp->refresh = time(NULL);
            tmp->access  = time(NULL);

            tmp->next = *list;
            *list = tmp;

            name = NULL;
            addr = tmp->addr;
        }
    }
    count = (addr)?(strlen(addr)):(0);
    memcpy(head, &count, sizeof(int));

    transmit(sfd, head, sizeof(int)*2, 0);
    transmit(sfd, addr, count        , 0);

    if(name) free(name);
}

static void refresh_list(dns_catch **list)
{
    if(!list) return;

    while(*list) {
        if(time(NULL)-(*list)->access > CATCH_IDLE) {
            dns_catch *catch = *list;
            *list = (*list)->next;
            if(catch->name) free(catch->name);
            free(catch);
            continue;
        }
        if(time(NULL)-(*list)->refresh > CATCH_TIME) {
            struct hostent *he = gethostbyname((*list)->name);
            char *p;

            if(he && (p=inet_ntoa(*((struct in_addr*)(he->h_addr)))) && strlen(p)<16) {
                strcpy((*list)->addr, p);
                (*list)->refresh = time(NULL);
            }
        }
        list = &((*list)->next);
    }
}

int main(int args, char* argv[])
{
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in sa;
    fd_set rset;
    struct timeval tv;
    dns_catch *list = NULL;

    sleep(1);

    sa.sin_family = AF_INET;
    sa.sin_addr.s_addr = htonl(INADDR_ANY);
    sa.sin_port = htons(atoi(argv[1]));
    if(connect(sfd, (struct sockaddr*)&sa, sizeof(sa)) < 0) {
        perror("connect failed:"); exit(-1);
    }
    while(1) {
        FD_ZERO(&rset); FD_SET(sfd, &rset);
        tv.tv_usec = 0; tv.tv_sec = 10;

        if(select(sfd+1, &rset, NULL, NULL, &tv) < 0) {
            perror("select error:"); exit(-1);
        }
        if(FD_ISSET(sfd, &rset)) resolve_request(sfd, &list);

        refresh_list(&list);
    }
    return 0;
}