fix tests, the ssl upstream setting is per-query (inside outside_network.c).

git-svn-id: file:///svn/unbound/trunk@2535 be551aaa-1e26-0410-a405-d3ace91eadb9

diff --git a/daemon/worker.c b/daemon/worker.c
index 8121f86e53cba9f1132401427b2ad9b9648e8e00..64dc085df8f5423b6fd8311a7d9bdc2b8154c413 100644 (file)
--- a/daemon/worker.c
+++ b/daemon/worker.c
@@ -1255,7 +1255,7 @@ worker_send_query(uint8_t* qname, size_t qnamelen, uint16_t qtype,
        e->qstate = q;
        e->qsent = outnet_serviced_query(worker->back, qname,
                qnamelen, qtype, qclass, flags, dnssec, want_dnssec,
-               q->env->cfg->tcp_upstream || q->env->cfg->ssl_upstream, addr,
+               q->env->cfg->tcp_upstream, q->env->cfg->ssl_upstream, addr,
                addrlen, zone, zonelen, worker_handle_service_reply, e,
                worker->back->udp_buff, &outbound_entry_compare);
        if(!e->qsent) {

diff --git a/libunbound/libworker.c b/libunbound/libworker.c
index 4a90451e4e00989772b52e6c3da9e0fed8193aa6..707a833466be93b308bb9f2c4ce41f65d72fe0b1 100644 (file)
--- a/libunbound/libworker.c
+++ b/libunbound/libworker.c
@@ -704,7 +704,7 @@ struct outbound_entry* libworker_send_query(uint8_t* qname, size_t qnamelen,
        e->qstate = q;
        e->qsent = outnet_serviced_query(w->back, qname,
                qnamelen, qtype, qclass, flags, dnssec, want_dnssec,
-               q->env->cfg->tcp_upstream || q->env->cfg->ssl_upstream, addr,
+               q->env->cfg->tcp_upstream, q->env->cfg->ssl_upstream, addr,
                addrlen, zone, zonelen, libworker_handle_service_reply, e,
                w->back->udp_buff, &outbound_entry_compare);
        if(!e->qsent) {

diff --git a/services/outside_network.c b/services/outside_network.c
index 3366b9ed6056b21e31478f003b173db46578fbbe..fea386f3173b84835158768e2f7416279717ea77 100644 (file)
--- a/services/outside_network.c
+++ b/services/outside_network.c
@@ -238,7 +238,7 @@ outnet_tcp_take_into_use(struct waiting_tcp* w, uint8_t* pkt, size_t pkt_len)
                        return 0;
                }
        }
-       if(w->outnet->sslctx) {
+       if(w->outnet->sslctx && w->ssl_upstream) {
                pend->c->ssl = outgoing_ssl_fd(w->outnet->sslctx, s);
                if(!pend->c->ssl) {
                        pend->c->fd = s;
@@ -1075,7 +1075,7 @@ outnet_tcptimer(void* arg)
 struct waiting_tcp* 
 pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet, 
        struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
-       comm_point_callback_t* callback, void* callback_arg)
+       comm_point_callback_t* callback, void* callback_arg, int ssl_upstream)
 {
        struct pending_tcp* pend = outnet->tcp_free;
        struct waiting_tcp* w;
@@ -1100,6 +1100,7 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
        w->outnet = outnet;
        w->cb = callback;
        w->cb_arg = callback_arg;
+       w->ssl_upstream = ssl_upstream;
 #ifndef S_SPLINT_S
        tv.tv_sec = timeout;
        tv.tv_usec = 0;
@@ -1163,8 +1164,9 @@ lookup_serviced(struct outside_network* outnet, ldns_buffer* buff, int dnssec,
 /** Create new serviced entry */
 static struct serviced_query*
 serviced_create(struct outside_network* outnet, ldns_buffer* buff, int dnssec,
-       int want_dnssec, int tcp_upstream, struct sockaddr_storage* addr,
-       socklen_t addrlen, uint8_t* zone, size_t zonelen)
+       int want_dnssec, int tcp_upstream, int ssl_upstream,
+       struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
+       size_t zonelen)
 {
        struct serviced_query* sq = (struct serviced_query*)malloc(sizeof(*sq));
 #ifdef UNBOUND_DEBUG
@@ -1189,6 +1191,7 @@ serviced_create(struct outside_network* outnet, ldns_buffer* buff, int dnssec,
        sq->dnssec = dnssec;
        sq->want_dnssec = want_dnssec;
        sq->tcp_upstream = tcp_upstream;
+       sq->ssl_upstream = ssl_upstream;
        memcpy(&sq->addr, addr, addrlen);
        sq->addrlen = addrlen;
        sq->outnet = outnet;
@@ -1549,7 +1552,7 @@ serviced_tcp_callback(struct comm_point* c, void* arg, int error,
                        log_err("Out of memory caching no edns for host");
                sq->status = serviced_query_TCP;
        }
-       if(sq->tcp_upstream) {
+       if(sq->tcp_upstream || sq->ssl_upstream) {
            struct timeval now = *sq->outnet->now_tv;
            if(now.tv_sec > sq->last_sent_time.tv_sec ||
                (now.tv_sec == sq->last_sent_time.tv_sec &&
@@ -1587,7 +1590,7 @@ serviced_tcp_initiate(struct outside_network* outnet,
        sq->last_sent_time = *sq->outnet->now_tv;
        sq->pending = pending_tcp_query(outnet, buff, &sq->addr,
                sq->addrlen, TCP_AUTH_QUERY_TIMEOUT, serviced_tcp_callback, 
-               sq);
+               sq, sq->ssl_upstream);
        if(!sq->pending) {
                /* delete from tree so that a retry by above layer does not
                 * clash with this entry */
@@ -1613,7 +1616,7 @@ serviced_tcp_send(struct serviced_query* sq, ldns_buffer* buff)
        sq->last_sent_time = *sq->outnet->now_tv;
        sq->pending = pending_tcp_query(sq->outnet, buff, &sq->addr,
                sq->addrlen, TCP_AUTH_QUERY_TIMEOUT, serviced_tcp_callback, 
-               sq);
+               sq, sq->ssl_upstream);
        return sq->pending != NULL;
 }
 
@@ -1783,9 +1786,9 @@ struct serviced_query*
 outnet_serviced_query(struct outside_network* outnet,
        uint8_t* qname, size_t qnamelen, uint16_t qtype, uint16_t qclass,
        uint16_t flags, int dnssec, int want_dnssec, int tcp_upstream,
-       struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
-       size_t zonelen, comm_point_callback_t* callback, void* callback_arg, 
-       ldns_buffer* buff, int (*arg_compare)(void*,void*))
+       int ssl_upstream, struct sockaddr_storage* addr, socklen_t addrlen,
+       uint8_t* zone, size_t zonelen, comm_point_callback_t* callback,
+       void* callback_arg, ldns_buffer* buff, int (*arg_compare)(void*,void*))
 {
        struct serviced_query* sq;
        struct service_callback* cb;
@@ -1802,13 +1805,14 @@ outnet_serviced_query(struct outside_network* outnet,
        if(!sq) {
                /* make new serviced query entry */
                sq = serviced_create(outnet, buff, dnssec, want_dnssec,
-                       tcp_upstream, addr, addrlen, zone, zonelen);
+                       tcp_upstream, ssl_upstream, addr, addrlen, zone,
+                       zonelen);
                if(!sq) {
                        free(cb);
                        return NULL;
                }
                /* perform first network action */
-               if(outnet->do_udp && !tcp_upstream) {
+               if(outnet->do_udp && !(tcp_upstream || ssl_upstream)) {
                        if(!serviced_udp_send(sq, buff)) {
                                (void)rbtree_delete(outnet->serviced, sq);
                                free(sq->qbuf);

diff --git a/services/outside_network.h b/services/outside_network.h
index bc8d7e0f24bab9c173c2c923a431ce2d4df6f848..bfaab459e409cdf7da17369ab3dbf8e3979bfbf0 100644 (file)
--- a/services/outside_network.h
+++ b/services/outside_network.h
@@ -262,6 +262,8 @@ struct waiting_tcp {
        comm_point_callback_t* cb;
        /** callback user argument */
        void* cb_arg;
+       /** if it uses ssl upstream */
+       int ssl_upstream;
 };
 
 /**
@@ -300,8 +302,8 @@ struct serviced_query {
        int dnssec;
        /** We want signatures, or else the answer is likely useless */
        int want_dnssec;
-       /** tcp upstream used, use tcp */
-       int tcp_upstream;
+       /** tcp upstream used, use tcp, or ssl_upstream for SSL */
+       int tcp_upstream, ssl_upstream;
        /** where to send it */
        struct sockaddr_storage addr;
        /** length of addr field in use. */
@@ -423,12 +425,13 @@ struct pending* pending_udp_query(struct outside_network* outnet,
  *    without any query been sent to the server yet.
  * @param callback: function to call on error, timeout or reply.
  * @param callback_arg: user argument for callback function.
+ * @param ssl_upstream: if the tcp connection must use SSL.
  * @return: false on error for malloc or socket. Else the pending TCP object.
  */
 struct waiting_tcp* pending_tcp_query(struct outside_network* outnet, 
        ldns_buffer* packet, struct sockaddr_storage* addr, 
        socklen_t addrlen, int timeout, comm_point_callback_t* callback, 
-       void* callback_arg);
+       void* callback_arg, int ssl_upstream);
 
 /**
  * Delete pending answer.
@@ -453,6 +456,7 @@ void pending_delete(struct outside_network* outnet, struct pending* p);
  * @param want_dnssec: signatures are needed, without EDNS the answer is
  *     likely to be useless.
  * @param tcp_upstream: use TCP for upstream queries.
+ * @param ssl_upstream: use SSL for upstream queries.
  * @param callback: callback function.
  * @param callback_arg: user argument to callback function.
  * @param addr: to which server to send the query.
@@ -470,9 +474,10 @@ void pending_delete(struct outside_network* outnet, struct pending* p);
 struct serviced_query* outnet_serviced_query(struct outside_network* outnet,
        uint8_t* qname, size_t qnamelen, uint16_t qtype, uint16_t qclass,
        uint16_t flags, int dnssec, int want_dnssec, int tcp_upstream,
-       struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
-       size_t zonelen, comm_point_callback_t* callback, void* callback_arg, 
-       ldns_buffer* buff, int (*arg_compare)(void*,void*));
+       int ssl_upstream, struct sockaddr_storage* addr, socklen_t addrlen,
+       uint8_t* zone, size_t zonelen, comm_point_callback_t* callback,
+       void* callback_arg, ldns_buffer* buff,
+       int (*arg_compare)(void*,void*));
 
 /**
  * Remove service query callback.

diff --git a/testcode/fake_event.c b/testcode/fake_event.c
index 7abcafa3dba7494cf068bdc72572e99221149bc4..c6d0ad3fee2916b443c631c146502e0ff095fb61 100644 (file)
--- a/testcode/fake_event.c
+++ b/testcode/fake_event.c
@@ -962,7 +962,8 @@ pending_udp_query(struct outside_network* outnet, ldns_buffer* packet,
 struct waiting_tcp* 
 pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
        struct sockaddr_storage* addr, socklen_t addrlen, int timeout,
-       comm_point_callback_t* callback, void* callback_arg)
+       comm_point_callback_t* callback, void* callback_arg,
+       int ATTR_UNUSED(ssl_upstream))
 {
        struct replay_runtime* runtime = (struct replay_runtime*)outnet->base;
        struct fake_pending* pend = (struct fake_pending*)calloc(1,
@@ -1014,10 +1015,11 @@ pending_tcp_query(struct outside_network* outnet, ldns_buffer* packet,
 struct serviced_query* outnet_serviced_query(struct outside_network* outnet,
         uint8_t* qname, size_t qnamelen, uint16_t qtype, uint16_t qclass,
        uint16_t flags, int dnssec, int ATTR_UNUSED(want_dnssec),
-       int ATTR_UNUSED(tcp_upstream), struct sockaddr_storage* addr,
-       socklen_t addrlen, uint8_t* zone, size_t ATTR_UNUSED(zonelen),
-       comm_point_callback_t* callback, void* callback_arg, 
-       ldns_buffer* ATTR_UNUSED(buff), int (*arg_compare)(void*,void*))
+       int ATTR_UNUSED(tcp_upstream), int ATTR_UNUSED(ssl_upstream),
+       struct sockaddr_storage* addr, socklen_t addrlen, uint8_t* zone,
+       size_t ATTR_UNUSED(zonelen), comm_point_callback_t* callback,
+       void* callback_arg, ldns_buffer* ATTR_UNUSED(buff),
+       int (*arg_compare)(void*,void*))
 {
        struct replay_runtime* runtime = (struct replay_runtime*)outnet->base;
        struct fake_pending* pend = (struct fake_pending*)calloc(1,