18 files changed, 305 insertions, 94 deletions

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..b53c955 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,9 @@ 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 ef163fa..a07f379 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)
@@ -160,9 +160,10 @@ namespace
                                 fstream.seekg(0, std::ios::end);
                                 U32 fileSize = fstream.tellg();
                                 fstream.seekg(0, std::ios::beg);
-                                std::vector<char> fileBuffer(fileSize);
-                                fstream.read(&fileBuffer[0], fileSize);
-                                ostream.write(&fileBuffer[0], fileSize);
+                                char* fileBuffer;
+                                fileBuffer = new char [fileSize];
+                                fstream.read(fileBuffer, fileSize);
+                                ostream.write(fileBuffer, fileSize);
                                 fstream.close();
                                 eos = true;
                                 return STATUS_DONE;
@@ -189,9 +190,10 @@ namespace
                         
                         LLVFile vfile(gVFS, mUUID, mAssetType, LLVFile::READ);
                         S32 fileSize = vfile.getSize();
-                        std::vector<U8> fileBuffer(fileSize);
-                        vfile.read(&fileBuffer[0], fileSize);
-                        ostream.write((char*)&fileBuffer[0], fileSize);
+                        U8* fileBuffer;
+                        fileBuffer = new U8 [fileSize];
+            vfile.read(fileBuffer, fileSize);
+            ostream.write((char*)fileBuffer, fileSize);
                         eos = true;
                         return STATUS_DONE;
                 }
@@ -236,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);
             }
@@ -245,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)
@@ -252,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));
         }
 
@@ -284,9 +310,13 @@ void LLHTTPClient::getByteRange(
     request(url,LLURLRequest::HTTP_GET, NULL, responder, timeout, headers);
 }
 
-void LLHTTPClient::head(const std::string& url, ResponderPtr responder, const F32 timeout)
+void LLHTTPClient::head(
+        const std::string& url,
+        ResponderPtr responder,
+        const LLSD& headers,
+        const F32 timeout)
 {
-        request(url, LLURLRequest::HTTP_HEAD, NULL, responder, timeout);
+        request(url, LLURLRequest::HTTP_HEAD, NULL, responder, timeout, headers);
 }
 
 void LLHTTPClient::get(const std::string& url, ResponderPtr responder, const LLSD& headers, const F32 timeout)
@@ -397,39 +427,66 @@ LLSD LLHTTPClient::blockingGet(const std::string& url)
         return response;
 }
 
-void LLHTTPClient::put(const std::string& url, const LLSD& body, ResponderPtr responder, const F32 timeout)
+void LLHTTPClient::put(
+        const std::string& url,
+        const LLSD& body,
+        ResponderPtr responder,
+        const LLSD& headers,
+        const F32 timeout)
 {
-        request(url, LLURLRequest::HTTP_PUT, new LLSDInjector(body), responder, timeout);
+        request(url, LLURLRequest::HTTP_PUT, new LLSDInjector(body), responder, timeout, headers);
 }
 
-void LLHTTPClient::post(const std::string& url, const LLSD& body, ResponderPtr responder, const F32 timeout)
+void LLHTTPClient::post(
+        const std::string& url,
+        const LLSD& body,
+        ResponderPtr responder,
+        const LLSD& headers,
+        const F32 timeout)
 {
-        request(url, LLURLRequest::HTTP_POST, new LLSDInjector(body), responder, timeout);
+        request(url, LLURLRequest::HTTP_POST, new LLSDInjector(body), responder, timeout, headers);
 }
 
-void LLHTTPClient::postRaw(const std::string& url, const U8* data, S32 size, ResponderPtr responder, const F32 timeout)
+void LLHTTPClient::postRaw(
+        const std::string& url,
+        const U8* data,
+        S32 size,
+        ResponderPtr responder,
+        const LLSD& headers,
+        const F32 timeout)
 {
-        request(url, LLURLRequest::HTTP_POST, new RawInjector(data, size), responder, timeout);
+        request(url, LLURLRequest::HTTP_POST, new RawInjector(data, size), responder, timeout, headers);
 }
 
-void LLHTTPClient::postFile(const std::string& url, const std::string& filename, ResponderPtr responder, const F32 timeout)
+void LLHTTPClient::postFile(
+        const std::string& url,
+        const std::string& filename,
+        ResponderPtr responder,
+        const LLSD& headers,
+        const F32 timeout)
 {
-        request(url, LLURLRequest::HTTP_POST, new FileInjector(filename), responder, timeout);
+        request(url, LLURLRequest::HTTP_POST, new FileInjector(filename), responder, timeout, headers);
 }
 
-void LLHTTPClient::postFile(const std::string& url, const LLUUID& uuid,
-                                                        LLAssetType::EType asset_type, ResponderPtr responder, const F32 timeout)
+void LLHTTPClient::postFile(
+        const std::string& url,
+        const LLUUID& uuid,
+        LLAssetType::EType asset_type,
+        ResponderPtr responder,
+        const LLSD& headers,
+        const F32 timeout)
 {
-        request(url, LLURLRequest::HTTP_POST, new VFileInjector(uuid, asset_type), responder, timeout);
+        request(url, LLURLRequest::HTTP_POST, new VFileInjector(uuid, asset_type), responder, timeout, headers);
 }
 
 // static
 void LLHTTPClient::del(
         const std::string& url,
         ResponderPtr responder,
+        const LLSD& headers,
         const F32 timeout)
 {
-        request(url, LLURLRequest::HTTP_DELETE, NULL, responder, timeout);
+        request(url, LLURLRequest::HTTP_DELETE, NULL, responder, timeout, headers);
 }
 
 // static
@@ -437,9 +494,10 @@ void LLHTTPClient::move(
         const std::string& url,
         const std::string& destination,
         ResponderPtr responder,
+        const LLSD& hdrs,
         const F32 timeout)
 {
-        LLSD headers;
+        LLSD headers = hdrs;
         headers["Destination"] = destination;
         request(url, LLURLRequest::HTTP_MOVE, NULL, responder, timeout, headers);
 }
diff --git a/linden/indra/llmessage/llhttpclient.h b/linden/indra/llmessage/llhttpclient.h
index 50c6f7a..367098f 100644
--- a/linden/indra/llmessage/llhttpclient.h
+++ b/linden/indra/llmessage/llhttpclient.h
@@ -62,28 +62,56 @@ public:
 
         /** @name non-blocking API */
         //@{
-        static void head(const std::string& url, ResponderPtr, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
+        static void head(
+                const std::string& url,
+                ResponderPtr,
+                const LLSD& headers = LLSD(),
+                const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
         static void getByteRange(const std::string& url, S32 offset, S32 bytes, ResponderPtr, const LLSD& headers=LLSD(), const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
         static void get(const std::string& url, ResponderPtr, const LLSD& headers = LLSD(), const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
         static void get(const std::string& url, const LLSD& query, ResponderPtr, const LLSD& headers = LLSD(), const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
 
-        static void put(const std::string& url, const LLSD& body, ResponderPtr, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
+        static void put(
+                const std::string& url,
+                const LLSD& body,
+                ResponderPtr,
+                const LLSD& headers = LLSD(),
+                const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
         static void getHeaderOnly(const std::string& url, ResponderPtr, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
         static void getHeaderOnly(const std::string& url, ResponderPtr, const LLSD& headers, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
 
-        static void post(const std::string& url, const LLSD& body, ResponderPtr, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-
+        static void post(
+                const std::string& url,
+                const LLSD& body,
+                ResponderPtr,
+                const LLSD& headers = LLSD(),
+                const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
         /** Takes ownership of data and deletes it when sent */
-        static void postRaw(const std::string& url, const U8* data, S32 size, ResponderPtr responder, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-        
-        static void postFile(const std::string& url, const std::string& filename, ResponderPtr, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
-        #
-        static void postFile(const std::string& url, const LLUUID& uuid,
-                LLAssetType::EType asset_type, ResponderPtr responder, const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
+        static void postRaw(
+                const std::string& url,
+                const U8* data,
+                S32 size,
+                ResponderPtr responder,
+                const LLSD& headers = LLSD(),
+                const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
+        static void postFile(
+                const std::string& url,
+                const std::string& filename,
+                ResponderPtr,
+                const LLSD& headers = LLSD(),
+                const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
+        static void postFile(
+                const std::string& url,
+                const LLUUID& uuid,
+                LLAssetType::EType asset_type,
+                ResponderPtr responder,
+                const LLSD& headers = LLSD(),
+                const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
 
         static void del(
                 const std::string& url,
                 ResponderPtr responder,
+                const LLSD& headers = LLSD(),
                 const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
                 ///< sends a DELETE method, but we can't call it delete in c++
         
@@ -93,12 +121,14 @@ public:
          * @param url The complete serialized (and escaped) url to get.
          * @param destination The complete serialized destination url.
          * @param responder The responder that will handle the result.
+         * @param headers A map of key:value headers to pass to the request
          * @param timeout The number of seconds to give the server to respond.
          */
         static void move(
                 const std::string& url,
                 const std::string& destination,
                 ResponderPtr responder,
+                const LLSD& headers = LLSD(),
                 const F32 timeout=HTTP_REQUEST_EXPIRY_SECS);
 
         //@}
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/llmail.cpp b/linden/indra/llmessage/llmail.cpp
index 8ae7206..0504080 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();
 }
 
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/llmessagethrottle.cpp b/linden/indra/llmessage/llmessagethrottle.cpp
index ad9df26..47e1bd6 100644
--- a/linden/indra/llmessage/llmessagethrottle.cpp
+++ b/linden/indra/llmessage/llmessagethrottle.cpp
@@ -119,7 +119,7 @@ BOOL LLMessageThrottle::addViewerAlert(const LLUUID& to, const std::string& mesg
         full_mesg << to << mesg;
 
         // Create an entry for this message.
-        size_t hash = llhash<const char*> (full_mesg.str().c_str());
+        size_t hash = llhash(full_mesg.str().c_str());
         LLMessageThrottleEntry entry(hash, LLFrameTimer::getTotalTime());
 
         // Check if this message is already in the list.
@@ -153,7 +153,7 @@ BOOL LLMessageThrottle::addAgentAlert(const LLUUID& agent, const LLUUID& task, c
         full_mesg << agent << task << mesg;
 
         // Create an entry for this message.
-        size_t hash = llhash<const char*> (full_mesg.str().c_str());
+        size_t hash = llhash(full_mesg.str().c_str());
         LLMessageThrottleEntry entry(hash, LLFrameTimer::getTotalTime());
 
         // Check if this message is already in the list.
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/llpumpio.cpp b/linden/indra/llmessage/llpumpio.cpp
index 6adf9c2..9ce0bab 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
@@ -521,7 +522,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)
                 {
diff --git a/linden/indra/llmessage/llregionflags.h b/linden/indra/llmessage/llregionflags.h
index af010ae..46624c1 100644
--- a/linden/indra/llmessage/llregionflags.h
+++ b/linden/indra/llmessage/llregionflags.h
@@ -60,8 +60,10 @@ const U32 REGION_FLAGS_BLOCK_LAND_RESELL		= (1 << 7);
 // All content wiped once per night
 const U32 REGION_FLAGS_SANDBOX                                  = (1 << 8);
 const U32 REGION_FLAGS_NULL_LAYER                               = (1 << 9);
-const U32 REGION_FLAGS_SKIP_AGENT_ACTION                = (1 << 10);
-const U32 REGION_FLAGS_SKIP_UPDATE_INTEREST_LIST= (1 << 11);
+// const U32 REGION_FLAGS_SKIP_AGENT_ACTION             = (1 << 10);
+const U32 REGION_FLAGS_HARD_ALLOW_LAND_TRANSFER = (1 << 10);    // Region allows land reselling
+// const U32 REGION_FLAGS_SKIP_UPDATE_INTEREST_LIST= (1 << 11);
+const U32 REGION_FLAGS_HARD_ALLOW_POST_CLASSIFIED       = (1 << 11);    // Region allows posting of classified ads
 const U32 REGION_FLAGS_SKIP_COLLISIONS                  = (1 << 12); // Pin all non agent rigid bodies
 const U32 REGION_FLAGS_SKIP_SCRIPTS                             = (1 << 13);
 const U32 REGION_FLAGS_SKIP_PHYSICS                             = (1 << 14); // Skip all physics
diff --git a/linden/indra/llmessage/message.cpp b/linden/indra/llmessage/message.cpp
index b20731a..3ee3c03 100644
--- a/linden/indra/llmessage/message.cpp
+++ b/linden/indra/llmessage/message.cpp
@@ -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