[IOMultiplexerV2] added reverse lookups to IODNSEngine_default and added DNS example...

diff --git a/configure.ac b/configure.ac
index dfd4bc6b372992c604a952ae538b3858c3bcdc46..d6522e1ca29d3a137e8325d9a728875f1b5f1ce0 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -54,5 +54,5 @@ AC_CHECK_LIB(cares, ares_init, [
   ])
 ])
 
-AC_CONFIG_FILES([Makefile src/Makefile src/IOHandler/Makefile src/IOHandler++/Makefile src/IOHandler_test/Makefile src/IOHandler_test/socket/Makefile src/IOHandler_test/socket++/Makefile src/IOHandler_test/timer/Makefile])
+AC_CONFIG_FILES([Makefile src/Makefile src/IOHandler/Makefile src/IOHandler++/Makefile src/IOHandler_test/Makefile src/IOHandler_test/socket/Makefile src/IOHandler_test/socket++/Makefile src/IOHandler_test/timer/Makefile src/IOHandler_test/resolv/Makefile])
 AC_OUTPUT

diff --git a/src/IOHandler/IODNSEngine_cares.c b/src/IOHandler/IODNSEngine_cares.c
index fd5cf48bd8a0bcc152e66eabcb5dfc3ed7b79bd1..6b108ba856d3f89857a3a8829f37933444977720 100644 (file)
--- a/src/IOHandler/IODNSEngine_cares.c
+++ b/src/IOHandler/IODNSEngine_cares.c
@@ -250,6 +250,7 @@ static void dnsengine_cares_callback(void *arg, int status, int timeouts, struct
                                        void *target = (host->h_addrtype == AF_INET ? ((void *) &((struct sockaddr_in *)dnsresult->result.addr.address)->sin_addr) : ((void *) &((struct sockaddr_in6 *)dnsresult->result.addr.address)->sin6_addr));
                                        memcpy(target, *h_addr, host->h_length);
                                        
+                                       dnsresult->result.addr.address->sa_family = host->h_addrtype;
                                        if(host->h_addrtype == AF_INET) {
                                                char str[INET_ADDRSTRLEN];
                                                inet_ntop( AF_INET, &((struct sockaddr_in *)dnsresult->result.addr.address)->sin_addr, str, INET_ADDRSTRLEN );

diff --git a/src/IOHandler/IODNSEngine_default.c b/src/IOHandler/IODNSEngine_default.c
index da10fac8a42af0b84e0423e8f714f052b547b132..f66b453b922e0d2f662ad16bc6bded5008f4ba09 100644 (file)
--- a/src/IOHandler/IODNSEngine_default.c
+++ b/src/IOHandler/IODNSEngine_default.c
@@ -174,6 +174,7 @@ static void iodns_process_queries() {
     struct addrinfo hints, *res, *allres;
     struct _IODNSQuery *iodns, *next_iodns;
     struct IODNSResult *dnsresult;
+       int ret;
        iodns_process_queries_start:
        IOSYNCHRONIZE(iodns_sync);
     for(iodns = iodnsquery_first; iodns; iodns = next_iodns) {
@@ -194,7 +195,6 @@ static void iodns_process_queries() {
             hints.ai_family = PF_UNSPEC;
             hints.ai_socktype = SOCK_STREAM;
             hints.ai_flags |= AI_CANONNAME;
-                       int ret;
             if (!(ret = getaddrinfo(iodns->request.host, NULL, &hints, &allres))) {
                                res = allres;
                 while (res) {
@@ -204,7 +204,8 @@ static void iodns_process_queries() {
                             dnsresult = malloc(sizeof(*dnsresult));
                             dnsresult->type = IODNS_RECORD_A;
                             dnsresult->result.addr.addresslen = res->ai_addrlen;
-                            dnsresult->result.addr.address = malloc(dnsresult->result.addr.addresslen);
+                            dnsresult->result.addr.address = calloc(dnsresult->result.addr.addresslen, 1);
+                                                       dnsresult->result.addr.address->sa_family = AF_INET;
                             memcpy(dnsresult->result.addr.address, res->ai_addr, dnsresult->result.addr.addresslen);
                             dnsresult->next = iodns->result;
                             iodns->result = dnsresult;
@@ -222,6 +223,7 @@ static void iodns_process_queries() {
                             dnsresult->type = IODNS_RECORD_AAAA;
                             dnsresult->result.addr.addresslen = res->ai_addrlen;
                             dnsresult->result.addr.address = calloc(dnsresult->result.addr.addresslen, 1);
+                                                       dnsresult->result.addr.address->sa_family = AF_INET6;
                             memcpy(dnsresult->result.addr.address, res->ai_addr, dnsresult->result.addr.addresslen);
                             dnsresult->next = iodns->result;
                             iodns->result = dnsresult;
@@ -240,7 +242,31 @@ static void iodns_process_queries() {
             } else {
                                iolog_trigger(IOLOG_WARNING, "getaddrinfo returned error code: %d", ret);
                        }
-        }
+        } else if((iodns->type & IODNS_REVERSE)) {
+                       char hostname[NI_MAXHOST];
+                       if(!(ret = getnameinfo(iodns->request.addr.address, iodns->request.addr.addresslen, hostname, sizeof(hostname), NULL, 0, 0))) {
+                               dnsresult = malloc(sizeof(*dnsresult));
+                               dnsresult->type = IODNS_RECORD_PTR;
+                               dnsresult->result.host = strdup(hostname);
+                               dnsresult->next = iodns->result;
+                               iodns->result = dnsresult;
+                               
+                               if(iodns->request.addr.address->sa_family == AF_INET) {
+                                       char str[INET_ADDRSTRLEN];
+                                       inet_ntop(AF_INET, &((struct sockaddr_in *)iodns->request.addr.address)->sin_addr, str, INET_ADDRSTRLEN);
+                                       iolog_trigger(IOLOG_DEBUG, "Resolved %s to (PTR): %s", str, hostname);
+                               } else {
+                                       char str[INET6_ADDRSTRLEN];
+                                       inet_ntop(AF_INET6, &((struct sockaddr_in6 *)iodns->request.addr.address)->sin6_addr, str, INET6_ADDRSTRLEN);
+                                       iolog_trigger(IOLOG_DEBUG, "Resolved %s to (PTR): %s", str, hostname);
+                               }
+                               
+                               querystate = IODNSEVENT_SUCCESS;
+                       } else {
+                               iolog_trigger(IOLOG_WARNING, "getnameinfo returned error code: %d", ret);
+                       }
+                       
+               }
                IOSYNCHRONIZE(iodns_sync);
                if(!(iodns->flags & IODNSFLAG_RUNNING)) {
                        iodns_free_result(iodns->result);

diff --git a/src/IOHandler/IODNSLookup.c b/src/IOHandler/IODNSLookup.c
index 71d014daf45d10270dfa132ef46f6f9984c08402..f458bf5ca033bf89e4f0eb4d264c8209a8539f3f 100644 (file)
--- a/src/IOHandler/IODNSLookup.c
+++ b/src/IOHandler/IODNSLookup.c
@@ -130,7 +130,7 @@ void iodns_poll() {
 
 /* public functions */
 
-struct IODNSQuery *iodns_getaddrinfo(char *hostname, int records, iodns_callback *callback) {
+struct IODNSQuery *iodns_getaddrinfo(char *hostname, int records, iodns_callback *callback, void *arg) {
        if(!(records & IODNS_FORWARD) || !hostname || !callback)
                return NULL;
        
@@ -149,6 +149,7 @@ struct IODNSQuery *iodns_getaddrinfo(char *hostname, int records, iodns_callback
        query->parent = descriptor;
        query->flags |= IODNSFLAG_PARENT_PUBLIC;
        descriptor->query = query;
+       descriptor->data = arg;
        
        query->request.host = strdup(hostname);
        query->type = (records & IODNS_FORWARD);
@@ -159,7 +160,7 @@ struct IODNSQuery *iodns_getaddrinfo(char *hostname, int records, iodns_callback
        return descriptor;
 }
 
-struct IODNSQuery *iodns_getnameinfo(const struct sockaddr *addr, size_t addrlen, iodns_callback *callback) {
+struct IODNSQuery *iodns_getnameinfo(const struct sockaddr *addr, size_t addrlen, iodns_callback *callback, void *arg) {
        if(!addr || !callback)
                return NULL;
        
@@ -178,6 +179,7 @@ struct IODNSQuery *iodns_getnameinfo(const struct sockaddr *addr, size_t addrlen
        query->parent = descriptor;
        query->flags |= IODNSFLAG_PARENT_PUBLIC;
        descriptor->query = query;
+       descriptor->data = arg;
        
        query->type = IODNS_RECORD_PTR;
        query->request.addr.addresslen = addrlen;

diff --git a/src/IOHandler/IODNSLookup.h b/src/IOHandler/IODNSLookup.h
index 72ac5dc9110dcc27b499b7dbf212515d9bb1049b..d62c88a904677cec4befe6bba4a1b2ce9bd61a65 100644 (file)
--- a/src/IOHandler/IODNSLookup.h
+++ b/src/IOHandler/IODNSLookup.h
@@ -148,8 +148,8 @@ struct IODNSEvent {
        struct IODNSResult *result;
 };
 
-struct IODNSQuery *iodns_getaddrinfo(char *hostname, int records, iodns_callback *callback);
-struct IODNSQuery *iodns_getnameinfo(const struct sockaddr *addr, size_t addrlen, iodns_callback *callback);
+struct IODNSQuery *iodns_getaddrinfo(char *hostname, int records, iodns_callback *callback, void *arg);
+struct IODNSQuery *iodns_getnameinfo(const struct sockaddr *addr, size_t addrlen, iodns_callback *callback, void *arg);
 void iodns_abort(struct IODNSQuery *query);
 
 void iodns_free_result(struct IODNSResult *result);

diff --git a/src/IOHandler_test/Makefile.am b/src/IOHandler_test/Makefile.am
index 1f4d5e5eef239dbdb72a30cb6d0a13de4a45444b..90d56feff6a30b86850d7bddfc9442965d952730 100644 (file)
--- a/src/IOHandler_test/Makefile.am
+++ b/src/IOHandler_test/Makefile.am
@@ -1,3 +1,3 @@
 ##Process this file with automake to create Makefile.in
 ACLOCAL_AMFLAGS = -I m4
-SUBDIRS = socket socket++ timer
+SUBDIRS = socket socket++ timer resolv

diff --git a/src/IOHandler_test/resolv/.gitignore b/src/IOHandler_test/resolv/.gitignore
new file mode 100644 (file)
index 0000000..7af2f69
--- /dev/null
+++ b/src/IOHandler_test/resolv/.gitignore
@@ -0,0 +1,7 @@
+.deps
+.libs
+*.o
+*.exe
+iotest
+Makefile
+Makefile.in

diff --git a/src/IOHandler_test/resolv/Makefile.am b/src/IOHandler_test/resolv/Makefile.am
new file mode 100644 (file)
index 0000000..1dac3a5
--- /dev/null
+++ b/src/IOHandler_test/resolv/Makefile.am
@@ -0,0 +1,8 @@
+##Process this file with automake to create Makefile.in
+ACLOCAL_AMFLAGS = -I m4
+
+noinst_PROGRAMS = iotest
+iotest_LDADD = ../../IOHandler/libiohandler.a
+
+iotest_SOURCES = iotest.c
+

diff --git a/src/IOHandler_test/resolv/iotest.c b/src/IOHandler_test/resolv/iotest.c
new file mode 100644 (file)
index 0000000..c2d4417
--- /dev/null
+++ b/src/IOHandler_test/resolv/iotest.c
@@ -0,0 +1,88 @@
+/* main.c - IOMultiplexer
+ * Copyright (C) 2012  Philipp Kreil (pk910)
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License 
+ * along with this program. If not, see <http://www.gnu.org/licenses/>. 
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include "../../IOHandler/IOHandler.h"
+#include "../../IOHandler/IODNSLookup.h"
+#include "../../IOHandler/IOLog.h"
+
+#ifndef WIN32
+#include "arpa/inet.h"
+#endif
+#include "../../IOHandler/compat/inet.h"
+
+#define TEST_DURATION 100
+
+static IODNS_CALLBACK(io_callback);
+static IOLOG_CALLBACK(io_log);
+
+int main(int argc, char *argv[]) {
+       iohandler_init();
+       iolog_register_callback(io_log);
+       
+       iodns_getaddrinfo("google.de", (IODNS_RECORD_A | IODNS_RECORD_AAAA), io_callback, "01");
+       iodns_getaddrinfo("pk910.de", IODNS_RECORD_AAAA, io_callback, "02");
+       iodns_getaddrinfo("nonexisting.no-tld", (IODNS_RECORD_A | IODNS_RECORD_AAAA), io_callback, "03");
+       iodns_getaddrinfo("google.com", (IODNS_RECORD_A | IODNS_RECORD_AAAA), io_callback, "04");
+       iodns_getaddrinfo("test.pk910.de", IODNS_RECORD_A, io_callback, "05");
+       
+       struct sockaddr_in addr;
+       addr.sin_family = AF_INET;
+       inet_pton(AF_INET, "8.8.8.8", &addr.sin_addr);
+       iodns_getnameinfo((struct sockaddr *)&addr, sizeof(addr), io_callback, "06");
+       
+       iohandler_run();
+       return 1;
+}
+
+static IODNS_CALLBACK(io_callback) {
+       struct IODNSQuery *iodns = event->query;
+       char *id = iodns->data;
+       if(event->type == IODNSEVENT_SUCCESS) {
+               printf("Query %s succeeded:\n", id);
+               struct IODNSResult *result;
+               char str[1024];
+               for(result = event->result; result; result = result->next) {
+                       switch(result->type) {
+                       case IODNS_RECORD_A:
+                               inet_ntop(AF_INET, &((struct sockaddr_in *)result->result.addr.address)->sin_addr, str, INET_ADDRSTRLEN);
+                               printf("  A: %s\n", str);
+                               
+                               if(!strcmp(id, "05"))
+                                       iodns_getnameinfo(result->result.addr.address, result->result.addr.addresslen, io_callback, "07");
+                               break;
+                       case IODNS_RECORD_AAAA:
+                               inet_ntop(AF_INET6, &((struct sockaddr_in6 *)result->result.addr.address)->sin6_addr, str, INET6_ADDRSTRLEN);
+                               printf("  AAAA: %s\n", str);
+                               
+                               if(!strcmp(id, "05"))
+                                       iodns_getnameinfo(result->result.addr.address, result->result.addr.addresslen, io_callback, "07");
+                               break;
+                       case IODNS_RECORD_PTR:
+                               printf("  PTR: %s\n", result->result.host);
+                               break;
+                       }
+               }
+               iodns_free_result(event->result);
+       } else
+               printf("Query %s failed.\n", id);
+}
+
+static IOLOG_CALLBACK(io_log) {
+       //printf("%s", line);
+}