23 files changed, 498 insertions, 73 deletions

diff --git a/linden/indra/llmessage/CMakeLists.txt b/linden/indra/llmessage/CMakeLists.txt
index ba17265..fd22de9 100644
--- a/linden/indra/llmessage/CMakeLists.txt
+++ b/linden/indra/llmessage/CMakeLists.txt
@@ -189,3 +189,11 @@ set_source_files_properties(${llmessage_HEADER_FILES}
 list(APPEND llmessage_SOURCE_FILES ${llmessage_HEADER_FILES})
 
 add_library (llmessage ${llmessage_SOURCE_FILES})
+target_link_libraries(
+    llmessage
+    ${CURL_LIBRARIES}
+    ${CARES_LIBRARIES}
+    ${OPENSSL_LIBRARIES}
+    ${CRYPTO_LIBRARIES}
+    ${XMLRPCEPI_LIBRARIES}
+    )
diff --git a/linden/indra/llmessage/llcachename.cpp b/linden/indra/llmessage/llcachename.cpp
index 70e1ccf..8f02358 100644
--- a/linden/indra/llmessage/llcachename.cpp
+++ b/linden/indra/llmessage/llcachename.cpp
@@ -41,7 +41,8 @@
 #include "llsdserialize.h"
 #include "lluuid.h"
 #include "message.h"
-
+#include "llservicebuilder.h"
+#include "llframetimer.h"
 // Constants
 static const std::string CN_WAITING("(Loading...)"); // *TODO: translate
 static const std::string CN_NOBODY("(nobody)"); // *TODO: translate
@@ -196,6 +197,8 @@ class LLCacheName::Impl
 public:
         LLMessageSystem*        mMsg;
         LLHost                          mUpstreamHost;
+        std::string mGroupNameURL;
+        std::string mAgentNameURL;
 
         Cache                           mCache;
                 // the map of UUIDs to names
@@ -221,6 +224,8 @@ public:
         void processPendingReplies();
         void sendRequest(const char* msg_name, const AskQueue& queue);
         bool isRequestPending(const LLUUID& id);
+        void getAgentName(const AskQueue&);
+        void getGroupName(const AskQueue&);
 
         // Message system callbacks.
         void processUUIDRequest(LLMessageSystem* msg, bool isGroup);
@@ -234,6 +239,35 @@ public:
         void notifyObservers(const LLUUID& id, const std::string& first, const std::string& last, BOOL group);
 };
 
+class LLHTTPAgentNamesResponse : public LLHTTPClient::Responder
+{
+public:
+        LLHTTPAgentNamesResponse(const LLSD& agent_ids)
+                : mAgentIDs(agent_ids)
+        { }
+        void result(const LLSD& content);
+private:
+        LLHost mSender;
+        LLSD mAgentIDs;
+
+};
+
+class LLHTTPGroupNamesResponse : public LLHTTPClient::Responder
+{
+public:
+        LLHTTPGroupNamesResponse(const LLSD& group_ids)
+                : mGroupIDs(group_ids)
+        { };
+                                                
+        void result(const LLSD& content);
+private:
+        LLHost mSender;
+        LLSD mGroupIDs;
+
+};
+
+
+
 
 /// --------------------------------------------------------------------------
 /// class LLCacheName
@@ -319,6 +353,57 @@ void LLCacheName::cancelCallback(const LLUUID& id, LLCacheNameCallback callback,
         }
 }
 
+void LLCacheName::sendAgentNames(const LLUUID& id, std::string& first, std::string& last)
+{
+
+        LLCacheNameEntry* entry = get_ptr_in_map(impl.mCache, id);
+        if (!entry)
+        {
+                entry = new LLCacheNameEntry;
+                impl.mCache[id] = entry;
+                
+        }
+        entry->mIsGroup = false;
+        entry->mCreateTime = (U32)LLFrameTimer::getTotalSeconds();
+    //entry->mFirstName = first;
+    //entry->mLastName = last;
+    //LLStringUtil::truncate(entry->mFirstName, DB_FIRST_NAME_BUF_SIZE);
+    //LLStringUtil::truncate(entry->mLastName, DB_LAST_NAME_BUF_SIZE);
+    entry->mFirstName = std::string(first, DB_FIRST_NAME_BUF_SIZE);
+    entry->mLastName = std::string(last, DB_LAST_NAME_BUF_SIZE);
+
+        impl.mPendingQueue.erase(id);
+        impl.notifyObservers(id,
+                                entry->mFirstName, entry->mLastName,
+                                FALSE);
+         
+}
+
+void LLCacheName::sendGroupNames(const LLUUID& id, std::string& name)
+{
+         
+        LLCacheNameEntry* entry = get_ptr_in_map(impl.mCache, id);
+    if (!entry)
+        {
+                entry = new LLCacheNameEntry;
+                impl.mCache[id] = entry;
+                                                                     
+        }
+             
+        entry->mIsGroup = true;
+        entry->mCreateTime = (U32)time(NULL);
+        
+    entry->mGroupName = std::string(name, DB_GROUP_NAME_BUF_SIZE);
+
+        impl.mPendingQueue.erase(id);
+                     
+        impl.notifyObservers(id,
+                entry->mFirstName, entry->mLastName,
+                FALSE);
+                         
+        
+}
+
 void LLCacheName::importFile(LLFILE* fp)
 {
         S32 count = 0;
@@ -524,6 +609,16 @@ BOOL LLCacheName::getFullName(const LLUUID& id, std::string& fullname)
         return res;
 }
 
+void LLCacheName::setGroupURL(const std::string& group_url)
+{
+        impl.mGroupNameURL = group_url; 
+}
+
+void LLCacheName::setAgentURL(const std::string& agent_url)
+{
+        impl.mAgentNameURL = agent_url;
+}
+
 BOOL LLCacheName::getGroupName(const LLUUID& id, std::string& group)
 {
         if(id.isNull())
@@ -558,6 +653,111 @@ BOOL LLCacheName::getGroupName(const LLUUID& id, std::string& group)
         }
 }
 
+void LLCacheName::Impl::getAgentName(const AskQueue &queue)
+{
+         
+        // get the names from backbone module
+        if(queue.empty())
+        {
+                 return;
+        }
+                
+        LLSD request;
+        request["action"] = "GET";
+        LLSD id_block = LLSD::emptyArray();
+        AskQueue::const_iterator it = queue.begin();
+        AskQueue::const_iterator end = queue.end();
+        for(;it!=end;++it)
+        {
+                id_block.append(*it);
+        }
+        lldebugs<<LLSDOStreamer<LLSDNotationFormatter>(id_block) <<llendl;
+                 
+        request["agents"] = id_block;
+        
+        LLHTTPClient::post(
+                        mAgentNameURL,
+                        request, 
+                        new LLHTTPAgentNamesResponse(id_block));
+                 
+                                                           
+        lldebugs<<"Service builder call to agent-name "<<mAgentNameURL<<llendl;
+                 
+}
+
+void LLHTTPAgentNamesResponse::result(const LLSD& content)
+{
+        LLUUID id;
+        lldebugs<<LLSDOStreamer<LLSDNotationFormatter>(content) <<llendl;
+
+        LLSD::map_const_iterator iter = content.beginMap();
+        for ( ; iter != content.endMap(); ++iter)
+        {
+                id.set((*iter).first);
+                LLSD name = (*iter).second;
+                LLCacheNameEntry* entry = new LLCacheNameEntry;
+                entry->mIsGroup = FALSE;
+                entry->mCreateTime = (U32)LLFrameTimer::getTotalSeconds();
+        std::string first = name["first"];
+        std::string last = name["last"];
+        entry->mFirstName = std::string(first, DB_FIRST_NAME_BUF_SIZE);
+        entry->mLastName = std::string(last, DB_LAST_NAME_BUF_SIZE);
+
+                gCacheName->sendAgentNames(id,first,last);
+        }       
+}
+
+
+void LLCacheName::Impl::getGroupName(const AskQueue &queue)
+{
+        // get the group names from backbone module
+        if(queue.empty())
+        {
+                return;
+        }
+                
+        LLSD request;
+        request["action"] = "GET";
+        LLSD id_block = LLSD::emptyArray();
+        AskQueue::const_iterator it = queue.begin();
+        AskQueue::const_iterator end = queue.end();
+        for(;it!=end;++it)
+        {
+                id_block.append(*it);
+        }
+                
+        request["groups"] = id_block;
+                                                                             
+        if(!mGroupNameURL.empty())
+        {       
+                LLHTTPClient::post(
+                        mGroupNameURL,
+                        request,
+                        new LLHTTPGroupNamesResponse(id_block));
+        }
+        lldebugs<<"Service builder call to group-name "<< mGroupNameURL<<llendl;
+}
+
+void LLHTTPGroupNamesResponse::result(const LLSD& content)
+{
+        lldebugs<<"Result"<<LLSDOStreamer<LLSDNotationFormatter>(content) << llendl;
+        LLUUID id;
+
+        LLSD::map_const_iterator iter = content.beginMap();
+        for ( ; iter != content.endMap(); ++iter)
+        {
+                                          
+                id.set((*iter).first);
+                std::string name = (*iter).second.asString();
+                LLCacheNameEntry* entry = new LLCacheNameEntry;
+                entry->mIsGroup = TRUE;                                         
+                entry->mCreateTime = (U32)time(NULL);
+        entry->mGroupName = std::string(name, DB_GROUP_NAME_BUF_SIZE);
+                lldebugs<<"Group Name"<<name<<llendl;
+                gCacheName->sendGroupNames(id,name);                                                    
+        }
+}
+
 // TODO: Make the cache name callback take a SINGLE std::string,
 // not a separate first and last name.
 void LLCacheName::get(const LLUUID& id, BOOL is_group, LLCacheNameCallback callback, void* user_data)
@@ -606,12 +806,14 @@ void LLCacheName::processPending()
                 return;
         }
 
+    /*
         if(!impl.mUpstreamHost.isOk())
         {
                 lldebugs << "LLCacheName::processPending() - bad upstream host."
                                  << llendl;
                 return;
         }
+    */
 
         impl.processPendingAsks();
         impl.processPendingReplies();
@@ -693,8 +895,16 @@ std::string LLCacheName::getDefaultName()
 
 void LLCacheName::Impl::processPendingAsks()
 {
-        sendRequest(_PREHASH_UUIDNameRequest, mAskNameQueue);
-        sendRequest(_PREHASH_UUIDGroupNameRequest, mAskGroupQueue);
+        if (mUpstreamHost.isOk()) //its the vuewer asking for names send request to simulator
+        {
+                sendRequest(_PREHASH_UUIDNameRequest, mAskNameQueue);
+                sendRequest(_PREHASH_UUIDGroupNameRequest, mAskGroupQueue);
+        }
+        else //its simulator asking for names ask the backbone
+        {
+                getAgentName(mAskNameQueue);
+                getGroupName(mAskGroupQueue);
+        }
         mAskNameQueue.clear();
         mAskGroupQueue.clear();
 }
@@ -815,12 +1025,15 @@ void LLCacheName::Impl::processUUIDRequest(LLMessageSystem* msg, bool isGroup)
 {
         // You should only get this message if the cache is at the simulator
         // level, hence having an upstream provider.
+        // 03/31/2008 Simulator is talking to backbone and not dataserver
+        // This check was for dataserver
+        /*
         if (!mUpstreamHost.isOk())
         {
                 llwarns << "LLCacheName - got UUID name/group request, but no upstream provider!" << llendl;
                 return;
         }
-
+        */
         LLHost fromHost = msg->getSender();
         ReplySender sender(msg);
 
diff --git a/linden/indra/llmessage/llcachename.h b/linden/indra/llmessage/llcachename.h
index 965b4ba..af644d0 100644
--- a/linden/indra/llmessage/llcachename.h
+++ b/linden/indra/llmessage/llcachename.h
@@ -31,7 +31,9 @@
 
 #ifndef LL_LLCACHENAME_H
 #define LL_LLCACHENAME_H
-
+#include "llhttpclient.h"
+#include "llhost.h"
+#include "lluri.h"
 class LLMessageSystem;
 class LLHost;
 class LLUUID;
@@ -97,10 +99,15 @@ public:
         // This method needs to be called from time to time to send out
         // requests.
         void processPending();
-
+        void setAgentURL(const std::string& url);
+        void setGroupURL(const std::string& url);
+        
         // Expire entries created more than "secs" seconds ago.
         void deleteEntriesOlderThan(S32 secs);
 
+        //send the information retrived from backbone
+        void sendAgentNames(const LLUUID& id, std::string& first, std::string& last);
+        void sendGroupNames(const LLUUID& id, std::string& name);
         // Debugging
         void dump();            // Dumps the contents of the cache
         void dumpStats();       // Dumps the sizes of the cache and associated queues.
@@ -111,9 +118,8 @@ private:
 
         class Impl;
         Impl& impl;
-};
-
 
+};
 
 extern LLCacheName* gCacheName;
 
diff --git a/linden/indra/llmessage/llcircuit.cpp b/linden/indra/llmessage/llcircuit.cpp
index 12a1520..7b2f241 100644
--- a/linden/indra/llmessage/llcircuit.cpp
+++ b/linden/indra/llmessage/llcircuit.cpp
@@ -60,6 +60,7 @@
 #include "llrand.h"
 #include "llstl.h"
 #include "lltransfermanager.h"
+#include "llmodularmath.h"
 
 const F32 PING_INTERVAL = 5.f; // seconds
 const S32 PING_START_BLOCK = 3;         // How many pings behind we have to be to consider ourself blocked.
@@ -676,6 +677,8 @@ void LLCircuitData::checkPacketInID(TPACKETID id, BOOL receive_resent)
                 mPacketsIn++;
                 setPacketInID((id + 1) % LL_MAX_OUT_PACKET_ID);
 
+        mLastPacketGap = 0;
+        mOutOfOrderRate.count(0);
                 return;
         }
 
@@ -683,6 +686,7 @@ void LLCircuitData::checkPacketInID(TPACKETID id, BOOL receive_resent)
 
 
         // now, check to see if we've got a gap
+    U32 gap = 0;
         if ((mPacketsInID == id))
         {
                 // nope! bump and wrap the counter, then return
@@ -704,6 +708,11 @@ void LLCircuitData::checkPacketInID(TPACKETID id, BOOL receive_resent)
                 // otherwise, walk from mCurrentCircuit->mPacketsInID to id with wrapping, adding the values to the map
                 // and setting mPacketsInID to id + 1 % LL_MAX_OUT_PACKET_ID
 
+        // babbage: all operands in expression are unsigned, so modular 
+                // arithmetic will always find correct gap, regardless of wrap arounds.
+                const U8 width = 24;
+                gap = LLModularMath::subtract<width>(mPacketsInID, id);
+
                 if (mPotentialLostPackets.find(id) != mPotentialLostPackets.end())
                 {
                         if(gMessageSystem->mVerboseLog)
@@ -765,6 +774,8 @@ void LLCircuitData::checkPacketInID(TPACKETID id, BOOL receive_resent)
 
                 }
         }
+    mOutOfOrderRate.count(gap);
+    mLastPacketGap = gap;
 }
 
 
diff --git a/linden/indra/llmessage/llcircuit.h b/linden/indra/llmessage/llcircuit.h
index 552b50f..3b9df02 100644
--- a/linden/indra/llmessage/llcircuit.h
+++ b/linden/indra/llmessage/llcircuit.h
@@ -45,6 +45,7 @@
 #include "llpacketack.h"
 #include "lluuid.h"
 #include "llthrottle.h"
+#include "llstat.h"
 
 //
 // Constants
@@ -133,6 +134,10 @@ public:
         S32                     getUnackedPacketCount() const   { return mUnackedPacketCount; }
         S32                     getUnackedPacketBytes() const   { return mUnackedPacketBytes; }
         F64         getNextPingSendTime() const { return mNextPingSendTime; }
+    F32         getOutOfOrderRate(LLStatAccum::TimeScale scale = LLStatAccum::SCALE_MINUTE) 
+                    { return mOutOfOrderRate.meanValue(scale); }
+    U32         getLastPacketGap() const { return mLastPacketGap; }
+    LLHost      getHost() const { return mHost; }
 
         LLThrottleGroup &getThrottleGroup()             {       return mThrottles; }
 
@@ -276,6 +281,8 @@ protected:
         LLTimer mExistenceTimer;            // initialized when circuit created, used to track bandwidth numbers
 
         S32             mCurrentResendCount;    // Number of resent packets since last spam
+    LLStatRate  mOutOfOrderRate;    // Rate of out of order packets coming in.
+    U32     mLastPacketGap;         // Gap in sequence number of last packet.
 };
 
 
diff --git a/linden/indra/llmessage/llcurl.cpp b/linden/indra/llmessage/llcurl.cpp
index 834ec4b..167e237 100644
--- a/linden/indra/llmessage/llcurl.cpp
+++ b/linden/indra/llmessage/llcurl.cpp
@@ -265,6 +265,10 @@ LLCurl::Easy* LLCurl::Easy::getEasy()
                 delete easy;
                 return NULL;
         }
+        
+        // set no DMS caching as default for all easy handles. This prevents them adopting a
+        // multi handles cache if they are added to one.
+        curl_easy_setopt(easy->mCurlEasyHandle, CURLOPT_DNS_CACHE_TIMEOUT, 0);
         ++gCurlEasyCount;
         return easy;
 }
@@ -747,7 +751,7 @@ bool LLCurlRequest::post(const std::string& url, const LLSD& data, LLCurl::Respo
         easy->setopt(CURLOPT_POSTFIELDS, (void*)NULL);
         easy->setopt(CURLOPT_POSTFIELDSIZE, bytes);
 
-        easy->slist_append("Content-Type: application/xml");
+        easy->slist_append("Content-Type: application/llsd+xml");
         easy->setHeaders();
 
         lldebugs << "POSTING: " << bytes << " bytes." << llendl;
diff --git a/linden/indra/llmessage/llhttpassetstorage.cpp b/linden/indra/llmessage/llhttpassetstorage.cpp
index fdd521f..6d5a716 100644
--- a/linden/indra/llmessage/llhttpassetstorage.cpp
+++ b/linden/indra/llmessage/llhttpassetstorage.cpp
@@ -256,6 +256,10 @@ void LLHTTPAssetRequest::setupCurlHandle()
                         // disable use of proxy, which can't handle chunked transfers
         }
         mHTTPHeaders = curl_slist_append(mHTTPHeaders, "Pragma:");
+
+        // bug in curl causes DNS to be cached for too long a time, 0 sets it to never cache DNS results internally (to curl)
+        curl_easy_setopt(mCurlHandle, CURLOPT_DNS_CACHE_TIMEOUT, 0);
+        
         // resist the temptation to explicitly add the Transfer-Encoding: chunked
         // header here - invokes a libCURL bug
         curl_easy_setopt(mCurlHandle, CURLOPT_HTTPHEADER, mHTTPHeaders);
diff --git a/linden/indra/llmessage/llhttpclient.cpp b/linden/indra/llmessage/llhttpclient.cpp
index fc2612f..fb43861 100644
--- a/linden/indra/llmessage/llhttpclient.cpp
+++ b/linden/indra/llmessage/llhttpclient.cpp
@@ -106,7 +106,7 @@ namespace
                 LLSDInjector(const LLSD& sd) : mSD(sd) {}
                 virtual ~LLSDInjector() {}
 
-                const char* contentType() { return "application/xml"; }
+                const char* contentType() { return "application/llsd+xml"; }
 
                 virtual EStatus process_impl(const LLChannelDescriptors& channels,
                         buffer_ptr_t& buffer, bool& eos, LLSD& context, LLPumpIO* pump)
@@ -238,7 +238,8 @@ static void request(
             //the Pragma header it so gratuitously inserts
             //Before inserting the header, force libcurl
             //to not use the proxy (read: llurlrequest.cpp)
-            if ((iter->first == "Pragma") && (iter->second.asString() == ""))
+                        static const std::string PRAGMA("Pragma");
+                        if ((iter->first == PRAGMA) && (iter->second.asString().empty()))
             {
                 req->useProxy(false);
             }
@@ -247,6 +248,19 @@ static void request(
             req->addHeader(header.str().c_str());
         }
     }
+
+        // Check to see if we have already set Accept or not. If no one
+        // set it, set it to application/llsd+xml since that's what we
+        // almost always want.
+        if( method != LLURLRequest::HTTP_PUT && method != LLURLRequest::HTTP_POST )
+        {
+                static const std::string ACCEPT("Accept");
+                if(!headers.has(ACCEPT))
+                {
+                        req->addHeader("Accept: application/llsd+xml");
+                }
+        }
+
         req->setCallback(new LLHTTPClientURLAdaptor(responder));
 
         if (method == LLURLRequest::HTTP_POST  &&  gMessageSystem)
@@ -254,12 +268,22 @@ static void request(
                 req->addHeader(llformat("X-SecondLife-UDP-Listen-Port: %d",
                                                                 gMessageSystem->mPort).c_str());
         }
-        
+
         if (method == LLURLRequest::HTTP_PUT || method == LLURLRequest::HTTP_POST)
         {
-                req->addHeader(llformat("Content-Type: %s",
-                                                                body_injector->contentType()).c_str());
-
+                static const std::string CONTENT_TYPE("Content-Type");
+                if(!headers.has(CONTENT_TYPE))
+                {
+                        // If the Content-Type header was passed in, it has
+                        // already been added as a header through req->addHeader
+                        // in the loop above. We defer to the caller's wisdom, but
+                        // if they did not specify a Content-Type, then ask the
+                        // injector.
+                        req->addHeader(
+                                llformat(
+                                        "Content-Type: %s",
+                                        body_injector->contentType()).c_str());
+                }
                 chain.push_back(LLIOPipe::ptr_t(body_injector));
         }
 
diff --git a/linden/indra/llmessage/lliohttpserver.cpp b/linden/indra/llmessage/lliohttpserver.cpp
index d4155f6..64222ff 100644
--- a/linden/indra/llmessage/lliohttpserver.cpp
+++ b/linden/indra/llmessage/lliohttpserver.cpp
@@ -47,6 +47,7 @@
 #include "llpumpio.h"
 #include "llsd.h"
 #include "llsdserialize_xml.h"
+#include "llstat.h"
 #include "llstl.h"
 #include "lltimer.h"
 
@@ -171,22 +172,26 @@ LLIOPipe::EStatus LLHTTPPipe::process_impl(
                 std::string verb = context[CONTEXT_REQUEST][CONTEXT_VERB];
                 if(verb == HTTP_VERB_GET)
                 {
+            LLPerfBlock getblock("http_get");   
                         mNode.get(LLHTTPNode::ResponsePtr(mResponse), context);
                 }
                 else if(verb == HTTP_VERB_PUT)
                 {
+            LLPerfBlock putblock("http_put");
                         LLSD input;
                         LLSDSerialize::fromXML(input, istr);
                         mNode.put(LLHTTPNode::ResponsePtr(mResponse), context, input);
                 }
                 else if(verb == HTTP_VERB_POST)
                 {
+            LLPerfBlock postblock("http_post");
                         LLSD input;
                         LLSDSerialize::fromXML(input, istr);
                         mNode.post(LLHTTPNode::ResponsePtr(mResponse), context, input);
                 }
                 else if(verb == HTTP_VERB_DELETE)
                 {
+            LLPerfBlock delblock("http_delete");
                         mNode.del(LLHTTPNode::ResponsePtr(mResponse), context);
                 }               
                 else if(verb == HTTP_VERB_OPTIONS)
@@ -240,7 +245,7 @@ LLIOPipe::EStatus LLHTTPPipe::process_impl(
                 case STATE_GOOD_RESULT:
                 {
                         LLSD headers = mHeaders;
-                        headers["Content-Type"] = "application/xml";
+                        headers["Content-Type"] = "application/llsd+xml";
                         context[CONTEXT_RESPONSE][CONTEXT_HEADERS] = headers;
                         LLBufferStream ostr(channels, buffer.get());
                         LLSDSerialize::toXML(mGoodResult, ostr);
diff --git a/linden/indra/llmessage/lliosocket.cpp b/linden/indra/llmessage/lliosocket.cpp
index dec83b0..28fee37 100644
--- a/linden/indra/llmessage/lliosocket.cpp
+++ b/linden/indra/llmessage/lliosocket.cpp
@@ -355,8 +355,11 @@ LLIOPipe::EStatus LLIOSocketReader::process_impl(
         }
         else if(APR_STATUS_IS_EAGAIN(status))
         {
+/*Commented out by Aura 9-9-8 for DEV-19961.
                 // everything is fine, but we can terminate this process pump.
+        
                 rv = STATUS_BREAK;
+*/
         }
         else
         {
diff --git a/linden/indra/llmessage/llmail.cpp b/linden/indra/llmessage/llmail.cpp
index 8ae7206..181f378 100644
--- a/linden/indra/llmessage/llmail.cpp
+++ b/linden/indra/llmessage/llmail.cpp
@@ -51,6 +51,7 @@
 #include "llblowfishcipher.h"
 #include "llerror.h"
 #include "llhost.h"
+#include "llsd.h"
 #include "llstring.h"
 #include "lluuid.h"
 #include "net.h"
@@ -111,16 +112,22 @@ void disconnect_smtp()
 // Returns TRUE on success.
 // message should NOT be SMTP escaped.
 // static
-BOOL LLMail::send(const char* from_name, const char* from_address,
-                           const char* to_name, const char* to_address,
-                           const char* subject, const char* message)
+BOOL LLMail::send(
+        const char* from_name,
+        const char* from_address,
+        const char* to_name,
+        const char* to_address,
+        const char* subject,
+        const char* message,
+        const LLSD& headers)
 {
         std::string header = buildSMTPTransaction(
                 from_name,
                 from_address,
                 to_name,
                 to_address,
-                subject);
+                subject,
+                headers);
         if(header.empty())
         {
                 return FALSE;
@@ -192,7 +199,8 @@ std::string LLMail::buildSMTPTransaction(
         const char* from_address,
         const char* to_name,
         const char* to_address,
-        const char* subject)
+        const char* subject,
+        const LLSD& headers)
 {
         if(!from_address || !to_address)
         {
@@ -236,8 +244,20 @@ std::string LLMail::buildSMTPTransaction(
                 << "DATA\r\n"
                 << "From: " << from_fmt.str() << "\r\n"
                 << "To: " << to_fmt.str() << "\r\n"
-                << "Subject: " << subject << "\r\n"
-                << "\r\n";
+                << "Subject: " << subject << "\r\n";
+        
+        if(headers.isMap())
+        {
+                LLSD::map_const_iterator iter = headers.beginMap();
+                LLSD::map_const_iterator end = headers.endMap();
+                for(; iter != end; ++iter)
+                {
+                        header << (*iter).first << ": " << ((*iter).second).asString()
+                                << "\r\n";
+                }
+        }
+
+        header << "\r\n";
         return header.str();
 }
 
@@ -324,7 +344,7 @@ bool LLMail::send(
                         << "when sending messages larger than " << LL_MAX_KNOWN_GOOD_MAIL_SIZE
                         << " bytes. The next log about success is potentially a lie." << llendl;
         }
-        llinfos << "send_mail success: "
+        lldebugs << "send_mail success: "
                 << "to=<" << to_address
                 << ">, from=<" << from_address << ">"
                 << ", bytes=" << original_size
diff --git a/linden/indra/llmessage/llmail.h b/linden/indra/llmessage/llmail.h
index 86b7793..018e180 100644
--- a/linden/indra/llmessage/llmail.h
+++ b/linden/indra/llmessage/llmail.h
@@ -34,7 +34,7 @@
 
 typedef struct apr_pool_t apr_pool_t;
 
-class LLUUID;
+#include "llsd.h"
 
 class LLMail
 {
@@ -45,34 +45,51 @@ public:
         // Allow all email transmission to be disabled/enabled.
         static void enable(bool mail_enabled);
 
-        // returns TRUE if the call succeeds, FALSE otherwise.
-        //
-        // Results in:
-        // From: "from_name" <from_address>
-        // To:   "to_name" <to_address>
-        // Subject: subject
-        // message
-        static BOOL send(const char* from_name, const char* from_address,
-                                const char* to_name, const char* to_address,
-                                const char* subject, const char* message);
+        /**
+         * @brief send an email
+         * @param from_name The name of the email sender
+         * @param from_address The email address for the sender
+         * @param to_name The name of the email recipient
+         * @param to_address The email recipient address
+         * @param subject The subject of the email
+         * @param headers optional X-Foo headers in an llsd map. 
+         * @return Returns TRUE if the call succeeds, FALSE otherwise.
+         *
+         * Results in:
+         * From: "from_name" <from_address>
+         * To:   "to_name" <to_address>
+         * Subject: subject
+         * 
+         * message
+         */
+        static BOOL send(
+                const char* from_name,
+                const char* from_address,
+                const char* to_name,
+                const char* to_address,
+                const char* subject,
+                const char* message,
+                const LLSD& headers = LLSD());
 
         /**
-        * @brief build the complete smtp transaction & header for use in an
-        * mail.
-        *
-        * @param from_name The name of the email sender
-        * @param from_address The email address for the sender
-        * @param to_name The name of the email recipient
-        * @param to_name The email recipient address
-        * @param subject The subject of the email
-        * @return Returns the complete SMTP transaction mail header.
-        */
+         * @brief build the complete smtp transaction & header for use in an
+         * mail.
+         *
+         * @param from_name The name of the email sender
+         * @param from_address The email address for the sender
+         * @param to_name The name of the email recipient
+         * @param to_address The email recipient address
+         * @param subject The subject of the email
+         * @param headers optional X-Foo headers in an llsd map. 
+         * @return Returns the complete SMTP transaction mail header.
+         */
         static std::string buildSMTPTransaction(
                 const char* from_name,
                 const char* from_address,
                 const char* to_name,
                 const char* to_address,
-                const char* subject);
+                const char* subject,
+                const LLSD& headers = LLSD());
 
         /**
         * @brief send an email with header and body.
diff --git a/linden/indra/llmessage/llmessagetemplate.cpp b/linden/indra/llmessage/llmessagetemplate.cpp
index 4a560ca..ff44d45 100644
--- a/linden/indra/llmessage/llmessagetemplate.cpp
+++ b/linden/indra/llmessage/llmessagetemplate.cpp
@@ -50,7 +50,7 @@ void LLMsgVarData::addData(const void *data, S32 size, EMsgVariableType type, S3
         }
         if(size)
         {
-                delete mData; // Delete it if it already exists
+                delete[] mData; // Delete it if it already exists
                 mData = new U8[size];
                 htonmemcpy(mData, data, mType, size);
         }
@@ -175,3 +175,23 @@ std::ostream& operator<<(std::ostream& s, LLMessageTemplate &msg)
 
         return s;
 }
+
+void LLMessageTemplate::banUdp()
+{
+        static const char* deprecation[] = {
+                "NotDeprecated",
+                "Deprecated",
+                "UDPDeprecated",
+                "UDPBlackListed"
+        };
+        if (mDeprecation != MD_DEPRECATED)
+        {
+                llinfos << "Setting " << mName << " to UDPBlackListed was " << deprecation[mDeprecation] << llendl;
+                mDeprecation = MD_UDPBLACKLISTED;
+        }
+        else
+        {
+                llinfos << mName << " is already more deprecated than UDPBlackListed" << llendl;
+        }
+}
+
diff --git a/linden/indra/llmessage/llmessagetemplate.h b/linden/indra/llmessage/llmessagetemplate.h
index 716c618..445d1a8 100644
--- a/linden/indra/llmessage/llmessagetemplate.h
+++ b/linden/indra/llmessage/llmessagetemplate.h
@@ -34,6 +34,7 @@
 
 #include "lldarray.h"
 #include "message.h" // TODO: babbage: Remove...
+#include "llstat.h"
 #include "llstl.h"
 
 class LLMsgVarData
@@ -370,20 +371,23 @@ public:
         {
                 if (mHandlerFunc)
                 {
+            LLPerfBlock msg_cb_time("msg_cb", mName);
                         mHandlerFunc(msgsystem, mUserData);
                         return TRUE;
                 }
                 return FALSE;
         }
 
-        bool isBanned(bool trustedSource) const
+        bool isUdpBanned() const
         {
-                return trustedSource ? mBanFromTrusted : mBanFromUntrusted;
+                return mDeprecation == MD_UDPBLACKLISTED;
         }
 
-        bool isUdpBanned() const
+        void banUdp();
+
+        bool isBanned(bool trustedSource) const
         {
-                return mDeprecation == MD_UDPBLACKLISTED;
+                return trustedSource ? mBanFromTrusted : mBanFromUntrusted;
         }
 
         friend std::ostream&     operator<<(std::ostream& s, LLMessageTemplate &msg);
diff --git a/linden/indra/llmessage/llnamevalue.cpp b/linden/indra/llmessage/llnamevalue.cpp
index c44f6ce..f661261 100644
--- a/linden/indra/llmessage/llnamevalue.cpp
+++ b/linden/indra/llmessage/llnamevalue.cpp
@@ -896,7 +896,7 @@ void LLNameValue::setVec3(const LLVector3 &a)
 }
 
 
-std::string LLNameValue::printNameValue()
+std::string LLNameValue::printNameValue() const
 {
         std::string buffer;
         buffer = llformat("%s %s %s %s ", mName, mStringType, mStringClass, mStringSendto);
@@ -905,7 +905,7 @@ std::string LLNameValue::printNameValue()
         return buffer;
 }
 
-std::string LLNameValue::printData()
+std::string LLNameValue::printData() const
 {
         std::string buffer;
         switch(mType)
diff --git a/linden/indra/llmessage/llnamevalue.h b/linden/indra/llmessage/llnamevalue.h
index 52beb07..f6c5040 100644
--- a/linden/indra/llmessage/llnamevalue.h
+++ b/linden/indra/llmessage/llnamevalue.h
@@ -148,8 +148,8 @@ public:
         BOOL                    sendToViewer() const;
 
         void                    callCallback();
-        std::string             printNameValue();
-        std::string             printData();
+        std::string             printNameValue() const;
+        std::string             printData() const;
         
         ENameValueType          getTypeEnum() const             { return mType; }
         ENameValueClass         getClassEnum() const    { return mClass; }
diff --git a/linden/indra/llmessage/llpartdata.h b/linden/indra/llmessage/llpartdata.h
index 82757ec..58a1fae 100644
--- a/linden/indra/llmessage/llpartdata.h
+++ b/linden/indra/llmessage/llpartdata.h
@@ -114,6 +114,7 @@ public:
                 //LL_PART_TRAIL_MASK =                  0x400,          // Particles have historical "trails"
 
                 // Viewer side use only!
+                LL_PART_HUD =                                   0x40000000,
                 LL_PART_DEAD_MASK =                             0x80000000,
         };
 
diff --git a/linden/indra/llmessage/llpumpio.cpp b/linden/indra/llmessage/llpumpio.cpp
index c92612f..467502b 100644
--- a/linden/indra/llmessage/llpumpio.cpp
+++ b/linden/indra/llmessage/llpumpio.cpp
@@ -41,6 +41,7 @@
 #include "llapr.h"
 #include "llmemtype.h"
 #include "llstl.h"
+#include "llstat.h"
 
 // These should not be enabled in production, but they can be
 // intensely useful during development for finding certain kinds of
@@ -176,7 +177,8 @@ LLPumpIO::LLPumpIO(apr_pool_t* pool) :
         mCurrentPool(NULL),
         mCurrentPoolReallocCount(0),
         mChainsMutex(NULL),
-        mCallbackMutex(NULL)
+        mCallbackMutex(NULL),
+        mCurrentChain(mRunningChains.end())
 {
         LLMemType m1(LLMemType::MTYPE_IO_PUMP);
         initialize(pool);
@@ -269,6 +271,16 @@ bool LLPumpIO::setTimeoutSeconds(F32 timeout)
         return true;
 }
 
+void LLPumpIO::adjustTimeoutSeconds(F32 delta)
+{
+        // If no chain is running, bail
+        if(mRunningChains.end() == mCurrentChain) 
+        {
+                return;
+        }
+        (*mCurrentChain).adjustTimeoutSeconds(delta);
+}
+
 static std::string events_2_string(apr_int16_t events)
 {
         std::ostringstream ostr;
@@ -514,7 +526,10 @@ void LLPumpIO::pump(const S32& poll_timeout)
                 //llinfos << "polling" << llendl;
                 S32 count = 0;
                 S32 client_id = 0;
-                apr_pollset_poll(mPollset, poll_timeout, &count, &poll_fd);
+        {
+            LLPerfBlock polltime("pump_poll");
+            apr_pollset_poll(mPollset, poll_timeout, &count, &poll_fd);
+        }
                 PUMP_DEBUG;
                 for(S32 ii = 0; ii < count; ++ii)
                 {
@@ -1161,3 +1176,14 @@ void LLPumpIO::LLChainInfo::setTimeoutSeconds(F32 timeout)
                 mTimer.stop();
         }
 }
+
+void LLPumpIO::LLChainInfo::adjustTimeoutSeconds(F32 delta)
+{
+        LLMemType m1(LLMemType::MTYPE_IO_PUMP);
+        if(mTimer.getStarted())
+        {
+                F64 expiry = mTimer.expiresAt();
+                expiry += delta;
+                mTimer.setExpiryAt(expiry);
+        }
+}
diff --git a/linden/indra/llmessage/llpumpio.h b/linden/indra/llmessage/llpumpio.h
index d2392a3..daff723 100644
--- a/linden/indra/llmessage/llpumpio.h
+++ b/linden/indra/llmessage/llpumpio.h
@@ -166,6 +166,14 @@ public:
         bool setTimeoutSeconds(F32 timeout);
 
         /** 
+         * @brief Adjust the timeout of the running chain.
+         *
+         * This method has no effect if there is no timeout on the chain.
+         * @param delta The number of seconds to add to/remove from the timeout.
+         */
+        void adjustTimeoutSeconds(F32 delta);
+
+        /** 
          * @brief Set up file descriptors for for the running chain.
          * @see rebuildPollset()
          *
@@ -349,6 +357,7 @@ protected:
                 // methods
                 LLChainInfo();
                 void setTimeoutSeconds(F32 timeout);
+                void adjustTimeoutSeconds(F32 delta);
 
                 // basic member data
                 bool mInit;
diff --git a/linden/indra/llmessage/llqueryflags.h b/linden/indra/llmessage/llqueryflags.h
index 1d8d500..6740d46 100644
--- a/linden/indra/llmessage/llqueryflags.h
+++ b/linden/indra/llmessage/llqueryflags.h
@@ -38,7 +38,7 @@
 const U32 DFQ_PEOPLE                    = 0x1 << 0;
 const U32 DFQ_ONLINE                    = 0x1 << 1;
 //const U32 DFQ_PLACES                  = 0x1 << 2;
-const U32 DFQ_EVENTS                    = 0x1 << 3;
+const U32 DFQ_EVENTS                    = 0x1 << 3; // This is not set by the 1.21 viewer, but I don't know about older versions. JC
 const U32 DFQ_GROUPS                    = 0x1 << 4;
 const U32 DFQ_DATE_EVENTS               = 0x1 << 5;
 
diff --git a/linden/indra/llmessage/llurlrequest.cpp b/linden/indra/llmessage/llurlrequest.cpp
index ee62798..e561597 100644
--- a/linden/indra/llmessage/llurlrequest.cpp
+++ b/linden/indra/llmessage/llurlrequest.cpp
@@ -68,6 +68,7 @@ public:
         LLChannelDescriptors mChannels;
         U8* mLastRead;
         U32 mBodyLimit;
+        S32 mByteAccumulator;
         bool mIsBodyLimitSet;
 };
 
@@ -76,8 +77,8 @@ LLURLRequestDetail::LLURLRequestDetail() :
         mResponseBuffer(NULL),
         mLastRead(NULL),
         mBodyLimit(0),
+        mByteAccumulator(0),
         mIsBodyLimitSet(false)
-        
 {
         LLMemType m1(LLMemType::MTYPE_IO_URL_REQUEST);
         mCurlRequest = new LLCurlEasyRequest();
@@ -264,8 +265,25 @@ LLIOPipe::EStatus LLURLRequest::process_impl(
                 {
                         CURLcode result;
                         bool newmsg = mDetail->mCurlRequest->getResult(&result);
-                        if (!newmsg)
+                        if(!newmsg)
                         {
+                                // we're still waiting or prcessing, check how many
+                                // bytes we have accumulated.
+                                const S32 MIN_ACCUMULATION = 100000;
+                                if(pump && (mDetail->mByteAccumulator > MIN_ACCUMULATION))
+                                {
+                                        // This is a pretty sloppy calculation, but this
+                                        // tries to make the gross assumption that if data
+                                        // is coming in at 56kb/s, then this transfer will
+                                        // probably succeed. So, if we're accumlated
+                                        // 100,000 bytes (MIN_ACCUMULATION) then let's
+                                        // give this client another 2s to complete.
+                                        const F32 TIMEOUT_ADJUSTMENT = 2.0f;
+                                        mDetail->mByteAccumulator = 0;
+                                        pump->adjustTimeoutSeconds(TIMEOUT_ADJUSTMENT);
+                                }
+
+                                // keep processing
                                 break;
                         }
 
@@ -434,6 +452,7 @@ size_t LLURLRequest::downCallback(
                 req->mDetail->mChannels.out(),
                 (U8*)data,
                 bytes);
+        req->mDetail->mByteAccumulator += bytes;
         return bytes;
 }
 
diff --git a/linden/indra/llmessage/message.cpp b/linden/indra/llmessage/message.cpp
index b20731a..9ca7211 100644
--- a/linden/indra/llmessage/message.cpp
+++ b/linden/indra/llmessage/message.cpp
@@ -763,7 +763,7 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count )
                                 clearReceiveState();
                                 valid_packet = FALSE;
                         }
-                        
+
                         if( valid_packet )
                         {
                                 logValidMsg(cdp, host, recv_reliable, recv_resent, (BOOL)(acks>0) );
@@ -3956,22 +3956,27 @@ void LLMessageSystem::getString(const char *block, const char *var,
                                   blocknum);
 }
 
-S32     LLMessageSystem::getNumberOfBlocksFast(const char *blockname)
+BOOL    LLMessageSystem::has(const char *blockname) const
+{
+        return getNumberOfBlocks(blockname) > 0;
+}
+
+S32     LLMessageSystem::getNumberOfBlocksFast(const char *blockname) const
 {
         return mMessageReader->getNumberOfBlocks(blockname);
 }
 
-S32     LLMessageSystem::getNumberOfBlocks(const char *blockname)
+S32     LLMessageSystem::getNumberOfBlocks(const char *blockname) const
 {
         return getNumberOfBlocksFast(LLMessageStringTable::getInstance()->getString(blockname));
 }
         
-S32     LLMessageSystem::getSizeFast(const char *blockname, const char *varname)
+S32     LLMessageSystem::getSizeFast(const char *blockname, const char *varname) const
 {
         return mMessageReader->getSize(blockname, varname);
 }
 
-S32     LLMessageSystem::getSize(const char *blockname, const char *varname)
+S32     LLMessageSystem::getSize(const char *blockname, const char *varname) const
 {
         return getSizeFast(LLMessageStringTable::getInstance()->getString(blockname), 
                                            LLMessageStringTable::getInstance()->getString(varname));
@@ -3979,13 +3984,13 @@ S32	LLMessageSystem::getSize(const char *blockname, const char *varname)
         
 // size in bytes of variable length data
 S32     LLMessageSystem::getSizeFast(const char *blockname, S32 blocknum, 
-                                                                 const char *varname)
+                                                                 const char *varname) const
 {
         return mMessageReader->getSize(blockname, blocknum, varname);
 }
                 
 S32     LLMessageSystem::getSize(const char *blockname, S32 blocknum, 
-                                                         const char *varname)
+                                                         const char *varname) const
 {
         return getSizeFast(LLMessageStringTable::getInstance()->getString(blockname), blocknum, 
                                            LLMessageStringTable::getInstance()->getString(varname));
@@ -4021,3 +4026,18 @@ bool LLMessageSystem::checkAllMessages(S64 frame_count, LLPumpIO* http_pump)
         http_pump->callback();
         return (mPacketsIn - packetsIn) > 0;
 }
+
+void LLMessageSystem::banUdpMessage(const std::string& name)
+{
+        message_template_name_map_t::iterator itt = mMessageTemplates.find(
+                LLMessageStringTable::getInstance()->getString(name.c_str())
+                );
+        if(itt != mMessageTemplates.end())
+        {
+                itt->second->banUdp();
+        }
+        else
+        {
+                llwarns << "Attempted to ban an unknown message: " << name << "." << llendl;
+        }
+}
diff --git a/linden/indra/llmessage/message.h b/linden/indra/llmessage/message.h
index 8807521..b72aa9a 100644
--- a/linden/indra/llmessage/message.h
+++ b/linden/indra/llmessage/message.h
@@ -562,6 +562,9 @@ public:
         /** Return false true if name is unknown or trusted */
         bool isUntrustedMessage(const std::string& name) const;
 
+        // Change this message to be UDP black listed.
+        void banUdpMessage(const std::string& name);
+
 private:
         // A list of the circuits that need to be sent DenyTrustedCircuit messages.
         typedef std::set<LLHost> host_set_t;
@@ -591,13 +594,14 @@ public:
         LLHost  findHost(const U32 circuit_code);
         void    sanityCheck();
 
-        S32             getNumberOfBlocksFast(const char *blockname);
-        S32             getNumberOfBlocks(const char *blockname);
-        S32             getSizeFast(const char *blockname, const char *varname);
-        S32             getSize(const char *blockname, const char *varname);
+        BOOL    has(const char *blockname) const;
+        S32             getNumberOfBlocksFast(const char *blockname) const;
+        S32             getNumberOfBlocks(const char *blockname) const;
+        S32             getSizeFast(const char *blockname, const char *varname) const;
+        S32             getSize(const char *blockname, const char *varname) const;
         S32             getSizeFast(const char *blockname, S32 blocknum, 
-                                                const char *varname); // size in bytes of data
-        S32             getSize(const char *blockname, S32 blocknum, const char *varname);
+                                                const char *varname) const; // size in bytes of data
+        S32             getSize(const char *blockname, S32 blocknum, const char *varname) const;
 
         void    resetReceiveCounts();                           // resets receive counts for all message types to 0
         void    dumpReceiveCounts();                            // dumps receive count for each message type to llinfos