1 files changed, 197 insertions, 35 deletions

diff --git a/linden/indra/newview/llsrv.cpp b/linden/indra/newview/llsrv.cpp
index 4dec48d..5a623bc 100644
--- a/linden/indra/newview/llsrv.cpp
+++ b/linden/indra/newview/llsrv.cpp
@@ -73,49 +73,37 @@ vector<LLSRVRecord> LLSRV::query(const string& name)
 
 #include <netdb.h>
 
-vector<LLSRVRecord> LLSRV::query(const string& queryName)
+#ifdef HOMEGROWN_RESPONSE_PARSER
+
+// We ought to be using libresolv's ns_initparse and ns_parserr to
+// parse the result of our query.  However, libresolv isn't packaged
+// correctly on Linux (as of BIND 9), so neither of these functions is
+// available without statically linking against libresolv.  Ugh!  This
+// fallback function is available if we need to parse the response
+// ourselves without relying too much on libresolv.  It is NOT THE
+// DEFAULT.
+
+vector<LLSRVRecord> LLSRV::parseResponse(const unsigned char *response,
+                                                                                 int resp_len)
 {
-        unsigned char response[16384];
         vector<LLSRVRecord> recs;
-        char name[1024];
-        int len;
-        
-        len = res_query(queryName.c_str(), ns_c_in, ns_t_srv, response,
-                                        sizeof(response));
-
-        if (len == -1)
-        {
-                llinfos << "Query failed for " << queryName << llendl;
-                return recs;
-        }
-        else if (len > (int) sizeof(response))
-        {
-                llinfos << "Response too big for " << queryName
-                                << " (capacity " << sizeof(response)
-                                << ", response " << len << ")" << llendl;
-                return recs;
-        }
-
-    // We "should" be using libresolv's ns_initparse and ns_parserr to
-    // parse the result of our query.  However, libresolv isn't
-    // packaged correctly on Linux (as of BIND 9), so neither of these
-    // functions is available without statically linking against
-    // libresolv.  Ugh!  So we parse the response ourselves.
 
         const unsigned char *pos = response + sizeof(HEADER);
-        const unsigned char *end = response + len;
+        const unsigned char *end = response + resp_len;
         const HEADER *hdr = (const HEADER *) response;
+        char name[1024];
 
         // Skip over the query embedded in the response.
 
         for (int q = ntohs(hdr->qdcount); q > 0; --q)
         {
-                len = dn_expand(response, end, pos, name, sizeof(name));
+                int len = dn_expand(response, end, pos, name, sizeof(name));
 
                 if (len == -1)
                 {
-                        llinfos << "Could not expand queried name in RR response" << llendl;
-                        return recs;
+                        llinfos << "Could not expand queried name in RR response"
+                                        << llendl;
+                        goto bail;
                 }
                 
                 pos += len + NS_QFIXEDSZ;
@@ -125,11 +113,12 @@ vector<LLSRVRecord> LLSRV::query(const string& queryName)
         {
                 static const ns_rr *rr;
 
-                len = dn_expand(response, end, pos, name, sizeof(name) - 1);
+                int len = dn_expand(response, end, pos, name, sizeof(name) - 1);
                 if (len == -1)
                 {
-                        llinfos << "Could not expand response name in RR response" << llendl;
-                        return recs;
+                        llinfos << "Could not expand response name in RR response"
+                                        << llendl;
+                        goto bail;
                 }
 
                 // Skip over the resource name and headers we don't care about.
@@ -150,7 +139,7 @@ vector<LLSRVRecord> LLSRV::query(const string& queryName)
                 if (len == -1)
                 {
                         llinfos << "Could not expand name in RR response" << llendl;
-                        return recs;
+                        goto bail;
                 }
 
                 recs.push_back(LLSRVRecord(prio, weight, name, port));
@@ -158,12 +147,177 @@ vector<LLSRVRecord> LLSRV::query(const string& queryName)
 
         // There are likely to be more records in the response, but we
         // don't care about those, at least for now.
+bail:
+        return reorder(recs);
+}
 
-        return recs;
+#else // HOMEGROWN_RESPONSE_PARSER
+
+// This version of the response parser is the one to use if libresolv
+// is available and behaving itself.
+
+vector<LLSRVRecord> LLSRV::parseResponse(const unsigned char *response,
+                                                                                 int resp_len)
+{
+        vector<LLSRVRecord> recs;
+        ns_msg hdr;
+
+        if (ns_initparse(response, resp_len, &hdr))
+        {
+                llinfos << "Could not parse response" << llendl;
+                goto bail;
+        }
+        
+        for (int i = 0; i < ns_msg_count(hdr, ns_s_an); i++)
+        {
+                ns_rr rr;
+                
+                if (ns_parserr(&hdr, ns_s_an, i, &rr))
+                {
+                        llinfos << "Could not parse RR" << llendl;
+                        goto bail;
+                }
+
+                if (ns_rr_type(rr) != ns_t_srv)
+                {
+                        continue;
+                }
+
+                const unsigned char *pos = ns_rr_rdata(rr);
+                U16 prio, weight, port;
+                char name[1024];
+                int ret;
+                
+                NS_GET16(prio, pos);
+                NS_GET16(weight, pos);
+                NS_GET16(port, pos);
+                
+                ret = dn_expand(ns_msg_base(hdr), ns_msg_end(hdr), pos,
+                                                name, sizeof(name));
+
+                if (ret == -1)
+                {
+                        llinfos << "Could not decompress name" << llendl;
+                        goto bail;
+                }
+
+                recs.push_back(LLSRVRecord(prio, weight, name, port));
+        }
+        
+bail:
+        return reorder(recs);
+}
+
+#endif // HOMEGROWN_RESPONSE_PARSER
+
+vector<LLSRVRecord> LLSRV::query(const string& queryName)
+{
+        unsigned char response[16384];
+        vector<LLSRVRecord> recs;
+        int len;
+        
+        len = res_query(queryName.c_str(), ns_c_in, ns_t_srv, response,
+                                        sizeof(response));
+
+        if (len == -1)
+        {
+                llinfos << "Query failed for " << queryName << llendl;
+                goto bail;
+        }
+        else if (len > (int) sizeof(response))
+        {
+                llinfos << "Response too big for " << queryName
+                                << " (capacity " << sizeof(response)
+                                << ", response " << len << ")" << llendl;
+                goto bail;
+        }
+
+        recs = parseResponse(response, len);
+bail:
+        return reorder(recs);
 }
 
 #endif // LL_WINDOWS
 
+// Implement the algorithm specified in RFC 2782 for dealing with RRs
+// of differing priorities and weights.
+vector<LLSRVRecord> LLSRV::reorder(vector<LLSRVRecord>& recs)
+{
+        typedef list<const LLSRVRecord *> reclist_t;
+        typedef map<U16, reclist_t> bucket_t;
+        vector<LLSRVRecord> newRecs;
+        bucket_t buckets;
+
+        // Don't rely on the DNS server to shuffle responses.
+        
+        random_shuffle(recs.begin(), recs.end());
+
+        for (vector<LLSRVRecord>::const_iterator iter = recs.begin();
+                 iter != recs.end(); ++iter)
+        {
+                buckets[iter->priority()].push_back(&*iter);
+        }
+        
+        // Priorities take precedence over weights.
+
+        for (bucket_t::iterator iter = buckets.begin();
+                 iter != buckets.end(); ++iter)
+        {
+                reclist_t& myPrio = iter->second;
+                reclist_t r;
+
+                // RRs with weight zero go to the front of the intermediate
+                // list, so they'll have little chance of being chosen.
+                // Larger weights have a higher likelihood of selection.
+
+                for (reclist_t::iterator i = myPrio.begin(); i != myPrio.end(); )
+                {
+                        if ((*i)->weight() == 0)
+                        {
+                                r.push_back(*i);
+                                i = myPrio.erase(i);
+                        } else {
+                                ++i;
+                        }
+                }
+
+                r.insert(r.end(), myPrio.begin(), myPrio.end());
+                
+                while (!r.empty())
+                {
+                        U32 total = 0;
+
+                        for (reclist_t::const_iterator i = r.begin(); i != r.end(); ++i)
+                        {
+                                total += (*i)->weight();
+                        }
+
+                        U32 target = total > 1 ? (rand() % total) : 0;
+                        U32 partial = 0;
+                        
+                        for (reclist_t::iterator i = r.begin(); i != r.end(); )
+                        {
+                                partial += (*i)->weight();
+                                if (partial >= target)
+                                {
+                                        newRecs.push_back(**i);
+                                        i = r.erase(i);
+                                } else {
+                                        ++i;
+                                }
+                        }
+                }
+        }
+        
+        // Order RRs by lowest numeric priority.  The stable sort
+        // preserves the weight choices we made above.
+
+        stable_sort(newRecs.begin(), newRecs.end(),
+                                LLSRVRecord::ComparePriorityLowest());
+
+        return newRecs;
+}
+
 vector<string> LLSRV::rewriteURI(const string& uriStr)
 {
         LLURI uri(uriStr);
@@ -186,6 +340,14 @@ vector<string> LLSRV::rewriteURI(const string& uriStr)
                 size_t i;
 
                 llinfos << "Got " << srvs.size() << " results" << llendl;
+                for (iter = srvs.begin(); iter != srvs.end(); ++iter)
+                {
+                        lldebugs << "host " << iter->target() << ':' << iter->port()
+                                         << " prio " << iter->priority()
+                                         << " weight " << iter->weight()
+                                         << llendl;
+                }
+
                 if (srvs.size() > maxSrvs)
                 {
                         llinfos << "Clamping to " << maxSrvs << llendl;