1 files changed, 193 insertions, 204 deletions

diff --git a/lib/dns.c b/lib/dns.c
index e23e9ce7..73c23649 100644
--- a/lib/dns.c
+++ b/lib/dns.c
@@ -31,6 +31,7 @@
 #include "libmf.h"
 #include "dns.h"
 #include "mailutils/alloc.h"
+#include "mailutils/argcv.h"
 
 struct mx_buffer {
         unsigned pref;
@@ -70,8 +71,10 @@ static dns_status
 _getmx(const char *host, unsigned char *answer, size_t answer_size,
        struct mxbuf *mxbuf, unsigned long *pttl)
 {
-        int i, n, nmx;
-        struct mx_buffer mx_buffer[MAXMXCOUNT];
+        struct mx_buffer *mx_buffer = NULL;
+        size_t mx_max = 0;
+        size_t nmx = 0;
+        int i, n;
         HEADER *hp;
         unsigned char *eom, *cp;
         unsigned short qdcount, ancount;
@@ -149,23 +152,28 @@ _getmx(const char *host, unsigned char *answer, size_t answer_size,
                                    tname, sizeof tname)) < 0)
                         break;
                 cp += n;
+                if (nmx == mx_max)
+                        mx_buffer = mu_2nrealloc(mx_buffer,
+                                                 &mx_max,
+                                                 sizeof(mx_buffer[0]));
+
                 mx_buffer[nmx].pref = pref;
-                mx_buffer[nmx].name = strdup(tname);
+                mx_buffer[nmx].name = mu_strdup(tname);
                 mu_debug(debug_handle, MU_DEBUG_TRACE2,
                          ("MX %u %s", mx_buffer[nmx].pref,
                           mx_buffer[nmx].name));
-                if (++nmx >= mxbuf->mx_max)
-                        break;
+                nmx++;
         }
 
         /* Sort according to preference value */
         qsort(mx_buffer, nmx, sizeof mx_buffer[0], comp_pref);
 
         /* Prepare return value */
-        mxbuf_init(mxbuf);
+        mxbuf_init(mxbuf, nmx);
         for (i = 0; i < nmx; i++) 
                 mxbuf->mx_buf[i] = mx_buffer[i].name;
-        mxbuf->mx_cnt = nmx;
+        mxbuf->mx_cnt = i;
+        free(mx_buffer);
         return dns_success;
 }
 
@@ -211,28 +219,23 @@ dns_get_mx_records(const char *host, int maxdepth, struct mxbuf *mxbuf,
         }
         
         if (host) {             
-                unsigned char *answer = malloc(MAXPACKET);
-                if (!answer)
-                        status = dns_failure;
-                else {
-                        const char *p;
-                        int depth;
+                unsigned char *answer = mu_alloc(MAXPACKET);
+                const char *p;
+                int depth;
                         
-                        for (p = host, depth = 0; p && depth < maxdepth;
-                             p++, depth++) {
-                                if (ttl)
-                                        *ttl = ~(unsigned long)0;
-                                status = _getmx(p, answer, MAXPACKET, mxbuf,
-                                                ttl);
-                                if (status == dns_success 
-                                    || status == dns_temp_failure)
-                                        break;
-                                p = strchr(p, '.');
-                                if (!p)
-                                        break;
-                        }
-                        free(answer);
+                for (p = host, depth = 0; p && depth < maxdepth;
+                     p++, depth++) {
+                        if (ttl)
+                                *ttl = ~(unsigned long)0;
+                        status = _getmx(p, answer, MAXPACKET, mxbuf, ttl);
+                        if (status == dns_success 
+                            || status == dns_temp_failure)
+                                break;
+                        p = strchr(p, '.');
+                        if (!p)
+                                break;
                 }
+                free(answer);
         }
         MUTEX_UNLOCK(dns_mutex);
         free(hbuf);
@@ -240,20 +243,24 @@ dns_get_mx_records(const char *host, int maxdepth, struct mxbuf *mxbuf,
 }
 
 void
-mxbuf_init(struct mxbuf *mxbuf)
+mxbuf_init(struct mxbuf *mxbuf, size_t nmx)
 {
-        if (!(mxbuf->mx_flags & MXF_MAX))
-                mxbuf->mx_max = MAXMXCOUNT;
         if (mxbuf->mx_flags & MXF_REUSE) {
-                int i;
+                size_t i;
                 
-                for (i = 0; i < mxbuf->mx_max && mxbuf->mx_buf[i]; i++) {
+                for (i = 0; i < mxbuf->mx_cnt; i++) {
                         free(mxbuf->mx_buf[i]);
                         mxbuf->mx_buf[i] = NULL;
                 }
+                if (nmx > mxbuf->mx_max) {
+                        mxbuf->mx_buf =
+                                mu_realloc(mxbuf->mx_buf,
+                                           nmx * sizeof(mxbuf->mx_buf[0]));
+                        mxbuf->mx_max = nmx;
+                }
         } else {
-                mxbuf->mx_buf = mu_calloc(mxbuf->mx_max,
-                                        sizeof(mxbuf->mx_buf[0]));
+                mxbuf->mx_buf = mu_calloc(nmx, sizeof(mxbuf->mx_buf[0]));
+                mxbuf->mx_max = nmx;
                 mxbuf->mx_flags |= MXF_REUSE;
         }
         mxbuf->mx_cnt = 0;
@@ -267,7 +274,10 @@ mxbuf_free(struct mxbuf *mxbuf)
 
                 for (i = 0; i < mxbuf->mx_max && mxbuf->mx_buf[i]; i++)
                         free(mxbuf->mx_buf[i]);
+                free(mxbuf->mx_buf);
                 mxbuf->mx_buf = NULL;
+                mxbuf->mx_flags &= ~MXF_REUSE;
+                mxbuf->mx_cnt = mxbuf->mx_max = 0;
         }
 }
 
@@ -275,6 +285,44 @@ mxbuf_free(struct mxbuf *mxbuf)
 #define LOOKUP_SUCCESS 0
 #define LOOKUP_CNAME   1
 
+void
+dns_reply_free(struct dns_reply *r)
+{
+        if (r->base) {
+                size_t i;
+                for (i = 0; i < r->count; i++)
+                        free(r->base[i]);
+                free(r->base);
+        }
+}
+        
+static void
+dns_reply_append(struct dns_reply *r, void *ptr, size_t len, int last)
+{
+        if (r->count == r->max)
+                r->base = mu_2nrealloc(r->base,
+                                       &r->max,
+                                       sizeof(r->base[0]));
+        if (last && r->count) {
+                while (r->last_len + len > r->last_max)
+                        r->base[r->count-1] =
+                                mu_2nrealloc(r->base[r->count-1],
+                                             &r->last_max,
+                                             1);
+        } else if (ptr == NULL) {
+                r->base[r->count] = NULL;
+                return;
+        } else {
+                r->base[r->count] = mu_alloc(len);
+                r->count++;
+                r->last_len = 0;
+                r->last_max = len;
+        }
+        
+        memcpy((char*)r->base[r->count-1] + r->last_len, ptr, len);
+        r->last_len += len;
+}
+
 struct loop_data {
         int qtype;                /* Type of the query */
         char *name;               /* Key to look up */ 
@@ -285,9 +333,7 @@ struct loop_data {
         size_t answer_size;       /* Size of answer buffer */
 
         /* Return data: */
-        char *hbuf;               /* Return buffer */
-        size_t hbsize;            /* Size of return buffer */
-        size_t hbcount;           /* Number of items returned */
+        struct dns_reply repl;
         
         time_t ttl;               /* TTL value */  
         dns_status status;        /* Status */
@@ -431,20 +477,11 @@ cname_loop_body(struct loop_data *lp)
                         if (bp + n >= nbuf + blen) {
                                 mu_debug(debug_handle, MU_DEBUG_TRACE0, 
                                          ("size (%d) too big", n));
+                        } else if (n != sizeof(GACOPYZ_UINT32_T)) {
+                                mu_debug(debug_handle, MU_DEBUG_TRACE0,
+                                         ("unsupported address size: %d", n));
                         } else {
-                                if (n != sizeof(GACOPYZ_UINT32_T)) {
-                                        mu_debug(debug_handle, MU_DEBUG_TRACE0,
-                                              ("unsupported address size: %d",
-                                               n));
+                                dns_reply_append(&lp->repl, cp, n, 0);