posix: upgrade libevent from 1.4.7 to 1.4.13

third_party/libevent/evdns.c

 /* $Id: evdns.c 6979 2006-08-04 18:31:13Z nickm $ */
 
 /* The original version of this module was written by Adam Langley; for
  * a history of modifications, check out the subversion logs.
  *
  * When editing this module, try to keep it re-mergeable by Adam.  Don't
  * reformat the whitespace, add Tor dependencies, or so on.
  *
  * TODO:
  *   - Support IPv6 and PTR records.
@@ skipping 56 matching lines @@
 #include <time.h>
 #endif
 
 #ifdef DNS_USE_OPENSSL_FOR_ID
 #ifdef DNS_USE_GETTIMEOFDAY_FOR_ID
 #error Multiple id options selected
 #endif
 #include <openssl/rand.h>
 #endif
 
+#ifndef _FORTIFY_SOURCE
 #define _FORTIFY_SOURCE 3
+#endif
 
 #include <string.h>
 #include <fcntl.h>
 #ifdef HAVE_SYS_TIME_H
 #include <sys/time.h>
 #endif
 #ifdef HAVE_STDINT_H
 #include <stdint.h>
 #endif
 #include <stdlib.h>
@@ skipping 114 matching lines @@
                 } aaaa;
                 struct {
                         char name[HOST_NAME_MAX];
                 } ptr;
         } data;
 };
 
 struct nameserver {
         int socket;  /* a connected UDP socket */
         u32 address;
+        u16 port;
         int failed_times;  /* number of times which we have given this server a chance */
         int timedout;  /* number of times in a row a request has timed out */
         struct event event;
         /* these objects are kept in a circular list */
         struct nameserver *next, *prev;
         struct event timeout_event;  /* used to keep the timeout for */
                                      /* when we next probe this server. */
                                      /* Valid if state == 0 */
         char state;  /* zero if we think that this server is down */
         char choked;  /* true if we have an EAGAIN from this server's socket */
@@ skipping 240 matching lines @@
                 /* This can happen if the nameserver acts in a way which makes us mark */
                 /* it as bad and then starts sending good replies. */
                 return;
         }
 
         timeout =
           &global_nameserver_timeouts[MIN(ns->failed_times,
                                           global_nameserver_timeouts_length - 1)];
         ns->failed_times++;
 
-        evtimer_set(&ns->timeout_event, nameserver_prod_callback, ns);
         if (evtimer_add(&ns->timeout_event, (struct timeval *) timeout) < 0) {
           log(EVDNS_LOG_WARN,
               "Error from libevent when adding timer event for %s",
               debug_ntoa(ns->address));
           /* ???? Do more? */
         }
 }
 
 /* called when a nameserver has been deemed to have failed. For example, too */
 /* many packets have timed out etc */
 static void
 nameserver_failed(struct nameserver *const ns, const char *msg) {
         struct request *req, *started_at;
         /* if this nameserver has already been marked as failed */
         /* then don't do anything */
         if (!ns->state) return;
 
         log(EVDNS_LOG_WARN, "Nameserver %s has failed: %s",
             debug_ntoa(ns->address), msg);
         global_good_nameservers--;
         assert(global_good_nameservers >= 0);
         if (global_good_nameservers == 0) {
                 log(EVDNS_LOG_WARN, "All nameservers have failed");
         }
 
         ns->state = 0;
         ns->failed_times = 1;
 
-        evtimer_set(&ns->timeout_event, nameserver_prod_callback, ns);
         if (evtimer_add(&ns->timeout_event, (struct timeval *) &global_nameserver_timeouts[0]) < 0) {
                 log(EVDNS_LOG_WARN,
                     "Error from libevent when adding timer event for %s",
                     debug_ntoa(ns->address));
                 /* ???? Do more? */
         }
 
         /* walk the list of inflight requests to see if any can be reassigned to */
         /* a different server. Requests in the waiting queue don't have a */
         /* nameserver assigned yet */
@@ skipping 161 matching lines @@
                         req->user_callback(err, 0, 0, 0, NULL, req->user_pointer);
                 return;
         }
         assert(0);
 }
 
 /* this processes a parsed reply packet */
 static void
 reply_handle(struct request *const req, u16 flags, u32 ttl, struct reply *reply) {
         int error;
-        static const int error_codes[] = {DNS_ERR_FORMAT, DNS_ERR_SERVERFAILED, DNS_ERR_NOTEXIST, DNS_ERR_NOTIMPL, DNS_ERR_REFUSED};
+        static const int error_codes[] = {
+                DNS_ERR_FORMAT, DNS_ERR_SERVERFAILED, DNS_ERR_NOTEXIST,
+                DNS_ERR_NOTIMPL, DNS_ERR_REFUSED
+        };
 
         if (flags & 0x020f || !reply || !reply->have_answer) {
                 /* there was an error */
                 if (flags & 0x0200) {
                         error = DNS_ERR_TRUNCATED;
                 } else {
                         u16 error_code = (flags & 0x000f) - 1;
                         if (error_code > 4) {
                                 error = DNS_ERR_UNKNOWN;
                         } else {
                                 error = error_codes[error_code];
                         }
                 }
 
                 switch(error) {
                 case DNS_ERR_NOTIMPL:
                 case DNS_ERR_REFUSED:
                         /* we regard these errors as marking a bad nameserver */
                         if (req->reissue_count < global_max_reissues) {
                                 char msg[64];
                                 evutil_snprintf(msg, sizeof(msg),
                                     "Bad response %d (%s)",
                                          error, evdns_err_to_string(error));
                                 nameserver_failed(req->ns, msg);
                                 if (!request_reissue(req)) return;
                         }
                         break;
                 case DNS_ERR_SERVERFAILED:
-                        /* rcode 2 (servfailed) sometimes means "we are broken" and
-                         * sometimes (with some binds) means "that request was very
-                         * confusing."  Treat this as a timeout, not a failure. 
+                        /* rcode 2 (servfailed) sometimes means "we
+                         * are broken" and sometimes (with some binds)
+                         * means "that request was very confusing."
+                         * Treat this as a timeout, not a failure.
                          */
                         log(EVDNS_LOG_DEBUG, "Got a SERVERFAILED from nameserver %s; "
                                 "will allow the request to time out.",
                                 debug_ntoa(req->ns->address));
                         break;
                 default:
                         /* we got a good reply from the nameserver */
                         nameserver_up(req->ns);
                 }
 
                 if (req->search_state && req->request_type != TYPE_PTR) {
-                        /* if we have a list of domains to search in, try the next one */
+                        /* if we have a list of domains to search in,
+                         * try the next one */
                         if (!search_try_next(req)) {
-                                /* a new request was issued so this request is finished and */
-                                /* the user callback will be made when that request (or a */
+                                /* a new request was issued so this
+                                 * request is finished and */
+                                /* the user callback will be made when
+                                 * that request (or a */
                                 /* child of it) finishes. */
                                 request_finished(req, &req_head);
                                 return;
                         }
                 }
 
                 /* all else failed. Pass the failure up */
                 reply_callback(req, 0, error, NULL);
                 request_finished(req, &req_head);
         } else {
@@ skipping 56 matching lines @@
         else
                 *idx = name_end;
         return 0;
  err:
         return -1;
 }
 
 /* parses a raw request from a nameserver */
 static int
 reply_parse(u8 *packet, int length) {
-        int j = 0;  /* index into packet */
+        int j = 0, k = 0;  /* index into packet */
         u16 _t;  /* used by the macros */
         u32 _t32;  /* used by the macros */
-        char tmp_name[256]; /* used by the macros */
+        char tmp_name[256], cmp_name[256]; /* used by the macros */
 
         u16 trans_id, questions, answers, authority, additional, datalength;
         u16 flags = 0;
         u32 ttl, ttl_r = 0xffffffff;
         struct reply reply;
         struct request *req = NULL;
         unsigned int i;
 
         GET16(trans_id);
         GET16(flags);
@@ skipping 12 matching lines @@
         /* If it's not an answer, it doesn't correspond to any request. */
         if (!(flags & 0x8000)) return -1;  /* must be an answer */
         if (flags & 0x020f) {
                 /* there was an error */
                 goto err;
         }
         /* if (!answers) return; */  /* must have an answer of some form */
 
         /* This macro skips a name in the DNS reply. */
 #define SKIP_NAME \
-        do { tmp_name[0] = '\0';                                        \
-                if (name_parse(packet, length, &j, tmp_name, sizeof(tmp_name))<0) \
-                        goto err;                                                                                                       \
-        } while(0);
+        do { tmp_name[0] = '\0';                                \
+                if (name_parse(packet, length, &j, tmp_name, sizeof(tmp_name))<0)\
+                        goto err;                               \
+        } while(0)
+#define TEST_NAME \
+        do { tmp_name[0] = '\0';                                \
+                cmp_name[0] = '\0';                             \
+                k = j;                                          \
+                if (name_parse(packet, length, &j, tmp_name, sizeof(tmp_name))<0)\
+                        goto err;                                       \
+                if (name_parse(req->request, req->request_len, &k, cmp_name, sizeof(cmp_name))<0)       \
+                        goto err;                               \
+                if (memcmp(tmp_name, cmp_name, strlen (tmp_name)) != 0) \
+                        return (-1); /* we ignore mismatching names */  \
+        } while(0)
 
         reply.type = req->request_type;
 
         /* skip over each question in the reply */
         for (i = 0; i < questions; ++i) {
                 /* the question looks like
                  *   <label:name><u16:type><u16:class>
                  */
-                SKIP_NAME;
+                TEST_NAME;
                 j += 4;
                 if (j > length) goto err;
         }
 
         /* now we have the answer section which looks like
          * <label:name><u16:type><u16:class><u32:ttl><u16:len><data...>
          */
 
         for (i = 0; i < answers; ++i) {
                 u16 type, class;
@@ skipping 262 matching lines @@
                         /* so we just return this one and hope for the */
                         /* best */
                         assert(global_good_nameservers == 0);
                         picked = server_head;
                         server_head = server_head->next;
                         return picked;
                 }
         }
 }
 
+static int
+address_is_correct(struct nameserver *ns, struct sockaddr *sa, socklen_t slen)
+{
+        struct sockaddr_in *sin = (struct sockaddr_in*) sa;
+        if (sa->sa_family != AF_INET || slen != sizeof(struct sockaddr_in))
+                return 0;
+        if (sin->sin_addr.s_addr != ns->address)
+                return 0;
+        return 1;
+}
+
 /* this is called when a namesever socket is ready for reading */
 static void
 nameserver_read(struct nameserver *ns) {
         u8 packet[1500];
+        struct sockaddr_storage ss;
+        socklen_t addrlen = sizeof(ss);
 
         for (;;) {
-                const int r = recv(ns->socket, packet, sizeof(packet), 0);
+                const int r = recvfrom(ns->socket, packet, sizeof(packet), 0,
+                    (struct sockaddr*)&ss, &addrlen);
                 if (r < 0) {
                         int err = last_error(ns->socket);
                         if (error_is_eagain(err)) return;
                         nameserver_failed(ns, strerror(err));
                         return;
                 }
+                if (!address_is_correct(ns, (struct sockaddr*)&ss, addrlen)) {
+                        log(EVDNS_LOG_WARN, "Address mismatch on received "
+                            "DNS packet.");
+                        return;
+                }
                 ns->timedout = 0;
                 reply_parse(packet, r);
         }
 }
 
 /* Read a packet from a DNS client on a server port s, parse it, and */
 /* act accordingly. */
 static void
 server_port_read(struct evdns_server_port *s) {
         u8 packet[1500];
@@ skipping 500 matching lines @@
                                 memcpy(buf+j, item->data, item->datalen);
                                 j += item->datalen;
                         }
                         item = item->next;
                 }
         }
 
         if (j > 512) {
 overflow:
                 j = 512;
-                buf[3] |= 0x02; /* set the truncated bit. */
+                buf[2] |= 0x02; /* set the truncated bit. */
         }
 
         req->response_len = j;
 
         if (!(req->response = malloc(req->response_len))) {
                 server_request_free_answers(req);
                 dnslabel_clear(&table);
                 return (-1);
         }
         memcpy(req->response, buf, req->response_len);
@@ skipping 186 matching lines @@
 }
 
 /* try to send a request to a given server. */
 /* */
 /* return: */
 /*   0 ok */
 /*   1 temporary failure */
 /*   2 other failure */
 static int
 evdns_request_transmit_to(struct request *req, struct nameserver *server) {
-        const int r = send(server->socket, req->request, req->request_len, 0);
+        struct sockaddr_in sin;
+        int r;
+        memset(&sin, 0, sizeof(sin));
+        sin.sin_addr.s_addr = req->ns->address;
+        sin.sin_port = req->ns->port;
+        sin.sin_family = AF_INET;
+
+        r = sendto(server->socket, req->request, req->request_len, 0,
+            (struct sockaddr*)&sin, sizeof(sin));
         if (r < 0) {
                 int err = last_error(server->socket);
                 if (error_is_eagain(err)) return 1;
                 nameserver_failed(req->ns, strerror(err));
                 return 2;
         } else if (r != (int)req->request_len) {
                 return 1;  /* short write */
         } else {
                 return 0;
         }
@@ skipping 28 matching lines @@
                 nameserver_write_waiting(req->ns, 1);
                 return 1;
         case 2:
                 /* failed in some other way */
                 retcode = 1;
                 /* fall through */
         default:
                 /* all ok */
                 log(EVDNS_LOG_DEBUG,
                     "Setting timeout for request %lx", (unsigned long) req);
-                evtimer_set(&req->timeout_event, evdns_request_timeout_callback, req);
                 if (evtimer_add(&req->timeout_event, &global_timeout) < 0) {
                   log(EVDNS_LOG_WARN,
                       "Error from libevent when adding timer for request %lx",
                       (unsigned long) req);
                   /* ???? Do more? */
                 }
                 req->tx_count++;
                 req->transmit_me = 0;
                 return retcode;
         }
@@ skipping 126 matching lines @@
         evdns_requests_pump_waiting_queue();
         return 0;
 }
 
 static int
 _evdns_nameserver_add_impl(unsigned long int address, int port) {
         /* first check to see if we already have this nameserver */
 
         const struct nameserver *server = server_head, *const started_at = server_head;
         struct nameserver *ns;
-        struct sockaddr_in sin;
         int err = 0;
         if (server) {
                 do {
                         if (server->address == address) return 3;
                         server = server->next;
                 } while (server != started_at);
         }
 
         ns = (struct nameserver *) malloc(sizeof(struct nameserver));
         if (!ns) return -1;
 
         memset(ns, 0, sizeof(struct nameserver));
 
+        evtimer_set(&ns->timeout_event, nameserver_prod_callback, ns);
+
         ns->socket = socket(PF_INET, SOCK_DGRAM, 0);
         if (ns->socket < 0) { err = 1; goto out1; }
         evutil_make_socket_nonblocking(ns->socket);
-        sin.sin_addr.s_addr = address;
-        sin.sin_port = htons(port);
-        sin.sin_family = AF_INET;
-        if (connect(ns->socket, (struct sockaddr *) &sin, sizeof(sin)) != 0) {
-                err = 2;
-                goto out2;
-        }
 
         ns->address = address;
+        ns->port = htons(port);
         ns->state = 1;
         event_set(&ns->event, ns->socket, EV_READ | EV_PERSIST, nameserver_ready_callback, ns);
         if (event_add(&ns->event, NULL) < 0) {
           err = 2;
           goto out2;
         }
 
         log(EVDNS_LOG_DEBUG, "Added nameserver %s", debug_ntoa(address));
 
         /* insert this nameserver into the list of them */
@@ skipping 92 matching lines @@
         const u16 trans_id = issuing_now ? transaction_id_pick() : 0xffff;
         /* the request data is alloced in a single block with the header */
         struct request *const req =
             (struct request *) malloc(sizeof(struct request) + request_max_len);
         int rlen;
         (void) flags;
 
         if (!req) return NULL;
         memset(req, 0, sizeof(struct request));
 
+        evtimer_set(&req->timeout_event, evdns_request_timeout_callback, req);
+
         /* request data lives just after the header */
         req->request = ((u8 *) req) + sizeof(struct request);
         /* denotes that the request data shouldn't be free()ed */
         req->request_appended = 1;
         rlen = evdns_request_data_build(name, name_len, trans_id,
             type, CLASS_INET, req->request, request_max_len);
         if (rlen < 0)
                 goto err1;
         req->request_len = rlen;
         req->trans_id = trans_id;
@@ skipping 49 matching lines @@
                         request_new(TYPE_AAAA, name, flags, callback, ptr);
                 if (req == NULL)
                         return (1);
                 request_submit(req);
                 return (0);
         } else {
                 return (search_request_new(TYPE_AAAA, name, flags, callback, ptr));
         }
 }
 
-int evdns_resolve_reverse(struct in_addr *in, int flags, evdns_callback_type callback, void *ptr) {
+int evdns_resolve_reverse(const struct in_addr *in, int flags, evdns_callback_type callback, void *ptr) {
         char buf[32];
         struct request *req;
         u32 a;
         assert(in);
         a = ntohl(in->s_addr);
         evutil_snprintf(buf, sizeof(buf), "%d.%d.%d.%d.in-addr.arpa",
                         (int)(u8)((a    )&0xff),
                         (int)(u8)((a>>8 )&0xff),
                         (int)(u8)((a>>16)&0xff),
                         (int)(u8)((a>>24)&0xff));
         log(EVDNS_LOG_DEBUG, "Resolve requested for %s (reverse)", buf);
         req = request_new(TYPE_PTR, buf, flags, callback, ptr);
         if (!req) return 1;
         request_submit(req);
         return 0;
 }
 
-int evdns_resolve_reverse_ipv6(struct in6_addr *in, int flags, evdns_callback_type callback, void *ptr) {
+int evdns_resolve_reverse_ipv6(const struct in6_addr *in, int flags, evdns_callback_type callback, void *ptr) {
         /* 32 nybbles, 32 periods, "ip6.arpa", NUL. */
         char buf[73];
         char *cp;
         struct request *req;
         int i;
         assert(in);
         cp = buf;
         for (i=15; i >= 0; --i) {
                 u8 byte = in->s6_addr[i];
                 *cp++ = "0123456789abcdef"[byte & 0x0f];
@@ skipping 631 matching lines @@
         }
 
         if (found == 0) {
                 log(EVDNS_LOG_WARN,"Didn't find any nameservers.");
         }
 
         return found ? 0 : -1;
 #undef TRY
 }
 
-static int
+int
 evdns_config_windows_nameservers(void)
 {
         if (load_nameservers_with_getnetworkparams() == 0)
                 return 0;
         return load_nameservers_from_registry();
 }
 #endif
 
 int
 evdns_init(void)
@@ skipping 176 matching lines @@
                 } else {
                         fprintf(stderr, "resolving (fwd) %s...\n",v[idx]);
                         evdns_resolve_ipv4(v[idx], 0, main_callback, v[idx]);
                 }
         }
         fflush(stdout);
         event_dispatch();
         return 0;
 }
 #endif