1 files changed, 105 insertions, 62 deletions

diff --git a/plugins/check_ntp.c b/plugins/check_ntp.c
index 86709a1f..149ca98f 100644
--- a/plugins/check_ntp.c
+++ b/plugins/check_ntp.c
@@ -29,6 +29,7 @@ const char *email = "nagiosplug-devel@lists.sourceforge.net";
 #include "common.h"
 #include "netutils.h"
 #include "utils.h"
+#include <sys/poll.h>
 
 static char *server_address=NULL;
 static int verbose=0;
@@ -64,6 +65,13 @@ typedef struct {
         uint64_t txts;       /* time at which request departed server */
 } ntp_message;
 
+/* this structure holds data about results from querying offset from a peer */
+typedef struct {
+        int waiting;            /* we set to 1 to signal waiting for a response */  
+        int num_responses;      /* number of successfully recieved responses */
+        double offset[AVG_NUM]; /* offsets from each response */
+} ntp_server_results;
+
 /* this structure holds everything in an ntp control message as per rfc1305 */
 typedef struct {
         uint8_t flags;       /* byte with leapindicator,vers,mode. see macros */
@@ -271,38 +279,20 @@ void setup_request(ntp_message *p){
         TVtoNTP64(t,p->txts);
 }
 
+/* do everything we need to get the total average offset
+ * - we use a certain amount of parallelization with poll() to ensure
+ *   we don't waste time sitting around waiting for single packets. 
+ * - we also "manually" handle resolving host names and connecting, because
+ *   we have to do it in a way that our lazy macros don't handle currently :( */
 double offset_request(const char *host){
-        int i=0, conn=-1;
-        ntp_message req;
-        double next_offset=0., avg_offset=0.;
-        struct timeval recv_time;
-
-        for(i=0; i<AVG_NUM; i++){
-                if(verbose) printf("offset run: %d/%d\n", i+1, AVG_NUM);
-                setup_request(&req);
-                my_udp_connect(server_address, 123, &conn);
-                write(conn, &req, sizeof(ntp_message));
-                read(conn, &req, sizeof(ntp_message));
-                gettimeofday(&recv_time, NULL);
-                /* if(verbose) print_packet(&req); */
-                close(conn);
-                next_offset=calc_offset(&req, &recv_time);
-                if(verbose) printf("offset: %g\n", next_offset);
-                avg_offset+=next_offset;
-        }
-        avg_offset/=AVG_NUM;
-        if(verbose) printf("average offset: %g\n", avg_offset);
-        return avg_offset;
-}
-
-
-/* this should behave more like ntpdate, but needs optomisations... */
-double offset_request_ntpdate(const char *host){
-        int i=0, j=0, ga_result=0, num_hosts=0, *socklist=NULL;
-        ntp_message req;
-        double offset=0., avg_offset=0.;
+        int i=0, j=0, ga_result=0, num_hosts=0, *socklist=NULL, respnum=0;
+        int servers_completed=0, one_written=0, servers_readable=0, offsets_recvd=0;
+        ntp_message *req=NULL;
+        double avg_offset=0.;
         struct timeval recv_time;
         struct addrinfo *ai=NULL, *ai_tmp=NULL, hints;
+        struct pollfd *ufds=NULL;
+        ntp_server_results *servers=NULL;
 
         /* setup hints to only return results from getaddrinfo that we'd like */
         memset(&hints, 0, sizeof(struct addrinfo));
@@ -310,24 +300,26 @@ double offset_request_ntpdate(const char *host){
         hints.ai_protocol = IPPROTO_UDP;
         hints.ai_socktype = SOCK_DGRAM;
 
-        /* XXX better error handling here... */
+        /* fill in ai with the list of hosts resolved by the host name */
         ga_result = getaddrinfo(host, "123", &hints, &ai);
         if(ga_result!=0){
-                fprintf(stderr, "error getting address for %s: %s\n",
-                                host, gai_strerror(ga_result));
-                return -1.0;
+                die(STATE_UNKNOWN, "error getting address for %s: %s\n",
+                    host, gai_strerror(ga_result));
         }
 
-        /* count te number of returned hosts, and allocate an array of sockets */
-        ai_tmp=ai;
-        while(ai_tmp){
-                ai_tmp = ai_tmp->ai_next;
-                num_hosts++;
-        }
+        /* count the number of returned hosts, and allocate stuff accordingly */
+        for(ai_tmp=ai; ai_tmp!=NULL; ai_tmp=ai_tmp->ai_next){ num_hosts++; }
+        req=(ntp_message*)malloc(sizeof(ntp_message)*num_hosts);
+        if(req==NULL) die(STATE_UNKNOWN, "can not allocate ntp message array");
         socklist=(int*)malloc(sizeof(int)*num_hosts);
         if(socklist==NULL) die(STATE_UNKNOWN, "can not allocate socket array");
+        ufds=(struct pollfd*)malloc(sizeof(struct pollfd)*num_hosts);
+        if(ufds==NULL) die(STATE_UNKNOWN, "can not allocate socket array");
+        servers=(ntp_server_results*)malloc(sizeof(ntp_server_results)*num_hosts);
+        if(servers==NULL) die(STATE_UNKNOWN, "can not allocate server array");
+        memset(servers, 0, sizeof(ntp_server_results)*num_hosts);
 
-        /* setup each socket for writing */
+        /* setup each socket for writing, and the corresponding struct pollfd */
         ai_tmp=ai;
         for(i=0;ai_tmp;i++){
                 socklist[i]=socket(ai_tmp->ai_family, SOCK_DGRAM, IPPROTO_UDP);
@@ -337,37 +329,88 @@ double offset_request_ntpdate(const char *host){
                 }
                 if(connect(socklist[i], ai_tmp->ai_addr, ai_tmp->ai_addrlen)){
                         die(STATE_UNKNOWN, "can't create socket connection");
+                } else {
+                        ufds[i].fd=socklist[i];
+                        ufds[i].events=POLLIN;
+                        ufds[i].revents=0;
                 }
                 ai_tmp = ai_tmp->ai_next;
         }
 
-        /* now do AVG_NUM checks to each host. this needs to be optimized
-         * two ways:
-         *  - use some parellization w/poll for much faster results.  currently
-         *    we do send/recv, send/recv, etc, whereas we could use poll(), to
-         *    determine when to read and just do a bunch of writing when we
-         *    have free time.
-         *  - behave like ntpdate and only take the 5 best responses.
-         */
-        for(i=0; i<AVG_NUM; i++){
-                if(verbose) printf("offset calculation run %d/%d\n", i+1, AVG_NUM);
-                for(j=0; j<num_hosts; j++){
-                        if(verbose) printf("peer %d: ", j);
-                        setup_request(&req);
-                        write(socklist[j], &req, sizeof(ntp_message));
-                        read(socklist[j], &req, sizeof(ntp_message));
-                        gettimeofday(&recv_time, NULL);
-                        offset=calc_offset(&req, &recv_time);
-                        if(verbose) printf("offset: %g\n", offset);
-                        avg_offset+=offset;
+        /* now do AVG_NUM checks to each host. */
+        while(servers_completed<num_hosts){
+
+                /* write to any servers that are free and have done < AVG_NUM reqs */
+                /* XXX we need some kind of ability to retransmit lost packets.
+                 * XXX one way would be replace "waiting" with a timestamp and
+                 * XXX if the timestamp is old enough the request is re-transmitted.
+                 * XXX then a certain number of failures could mark a server as
+                 * XXX bad, which is what i imagine that ntpdate does though
+                 * XXX i can't confirm it (i think it still only sends a max
+                 * XXX of AVG_NUM requests, but what does it do if one fails
+                 * XXX but the others succeed? */
+                /* XXX also we need the ability to cut out failed/unresponsive
+                 * XXX servers.  currently after doing all other servers we
+                 * XXX still wait for them until the bitter end/timeout. */
+                one_written=0;
+                for(i=0; i<num_hosts; i++){
+                        if(!servers[i].waiting && servers[i].num_responses<AVG_NUM){
+                                if(verbose) printf("sending request to peer %d\n", i);
+                                setup_request(&req[i]);
+                                write(socklist[i], &req[i], sizeof(ntp_message));
+                                servers[i].waiting=1;
+                                one_written=1;
+                                break;
+                        }
                 }
-                avg_offset/=num_hosts;
+
+                /* quickly poll for any sockets with pending data */
+                servers_readable=poll(ufds, num_hosts, 100);
+                if(servers_readable==-1){
+                        perror("polling ntp sockets");
+                        die(STATE_UNKNOWN, "communication errors");
+                }
+
+                /* read from any sockets with pending data */
+                for(i=0; servers_readable && i<num_hosts; i++){
+                        if(ufds[i].revents&POLLIN){
+                                if(verbose) {
+                                        printf("response from peer %d: ", i);
+                                }
+                                read(ufds[i].fd, &req[i], sizeof(ntp_message));
+                                gettimeofday(&recv_time, NULL);
+                                respnum=servers[i].num_responses++;
+                                servers[i].offset[respnum]=calc_offset(&req[i], &recv_time);
+                                if(verbose) {
+                                        printf("offset %g\n", servers[i].offset[respnum]);
+                                }
+                                servers[i].waiting=0;
+                                servers_readable--;
+                                if(servers[i].num_responses==AVG_NUM) servers_completed++;
+                        }
+                }
+                /* lather, rinse, repeat. */
         }
-        avg_offset/=AVG_NUM;
-        if(verbose) printf("overall average offset: %g\n", avg_offset);
 
+        /* finally, calculate the average offset */
+        /* XXX still something about the "top 5" */
+        for(i=0;i<num_hosts;i++){
+                for(j=0;j<servers[i].num_responses;j++){
+                        offsets_recvd++;
+                        avg_offset+=servers[i].offset[j];
+                }
+        }
+        avg_offset/=offsets_recvd;
+
+        /* cleanup */
         for(j=0; j<num_hosts; j++){ close(socklist[j]); }
+        free(socklist);
+        free(ufds);
+        free(servers);
+        free(req);
         freeaddrinfo(ai);
+
+        if(verbose) printf("overall average offset: %g\n", avg_offset);
         return avg_offset;
 }