49 files changed, 2815 insertions, 451 deletions

diff --git a/linden/indra/llmessage/files.lst b/linden/indra/llmessage/files.lst
index b2f7d41..2ff3771 100644
--- a/linden/indra/llmessage/files.lst
+++ b/linden/indra/llmessage/files.lst
@@ -1,10 +1,12 @@
 llmessage/llassetstorage.cpp
+llmessage/llblowfishcipher.cpp
 llmessage/llbuffer.cpp
 llmessage/llbufferstream.cpp
 llmessage/llcachename.cpp
 llmessage/llchainio.cpp
 llmessage/llcircuit.cpp
 llmessage/llclassifiedflags.cpp
+llmessage/llcurl.cpp
 llmessage/lldatapacker.cpp
 llmessage/lldispatcher.cpp
 llmessage/llfiltersd2xmlrpc.cpp
diff --git a/linden/indra/llmessage/llassetstorage.cpp b/linden/indra/llmessage/llassetstorage.cpp
index eb26157..a8cd0e5 100644
--- a/linden/indra/llmessage/llassetstorage.cpp
+++ b/linden/indra/llmessage/llassetstorage.cpp
@@ -174,10 +174,40 @@ LLAssetRequest::LLAssetRequest(const LLUUID &uuid, const LLAssetType::EType type
         mTime = LLMessageSystem::getMessageTimeSeconds(TRUE);
 }
 
+// virtual
 LLAssetRequest::~LLAssetRequest()
 {
 }
 
+// virtual
+LLSD LLAssetRequest::getTerseDetails() const
+{
+        LLSD sd;
+        sd["asset_id"] = getUUID();
+        sd["type_long"] = LLAssetType::lookupHumanReadable(getType());
+        sd["type"] = LLAssetType::lookup(getType());
+        sd["time"] = mTime;
+        time_t timestamp = (time_t) mTime;
+        std::ostringstream time_string;
+        time_string << ctime(&timestamp);
+        sd["time_string"] = time_string.str();
+        return sd;
+}
+
+// virtual
+LLSD LLAssetRequest::getFullDetails() const
+{
+        LLSD sd = getTerseDetails();
+        sd["host"] = mHost.getIPandPort();
+        sd["requesting_agent"] = mRequestingAgentID;
+        sd["is_temp"] = mIsTemp;
+        sd["is_local"] = mIsLocal;
+        sd["is_priority"] = mIsPriority;
+        sd["data_send_in_first_packet"] = mDataSentInFirstPacket;
+        sd["data_is_in_vfs"] = mDataIsInVFS;
+
+        return sd;
+}
 
 ///----------------------------------------------------------------------------
 /// LLInvItemRequest
@@ -298,47 +328,41 @@ void LLAssetStorage::checkForTimeouts()
 
 void LLAssetStorage::_cleanupRequests(BOOL all, S32 error)
 {
-        const S32 NUM_QUEUES = 3;
         F64 mt_secs = LLMessageSystem::getMessageTimeSeconds();
 
-        std::list<LLAssetRequest*>* requests[NUM_QUEUES];
-        requests[0] = &mPendingDownloads;
-        requests[1] = &mPendingUploads;
-        requests[2] = &mPendingLocalUploads;
-        static const char* REQUEST_TYPE[NUM_QUEUES] = { "download", "upload", "localuploads"};
-        
-        std::list<LLAssetRequest*> timed_out;
-        
-        for (S32 ii = 0; ii < NUM_QUEUES; ++ii)
+        request_list_t timed_out;
+        S32 rt;
+        for (rt = 0; rt < RT_COUNT; rt++)
         {
-                for (std::list<LLAssetRequest*>::iterator iter = requests[ii]->begin();
-                         iter != requests[ii]->end(); )
+                request_list_t* requests = getRequestList((ERequestType)rt);
+                for (request_list_t::iterator iter = requests->begin();
+                         iter != requests->end(); )
                 {
-                        std::list<LLAssetRequest*>::iterator curiter = iter++;
+                        request_list_t::iterator curiter = iter++;
                         LLAssetRequest* tmp = *curiter;
                         // if all is true, we want to clean up everything
                         // otherwise just check for timed out requests
                         // EXCEPT for upload timeouts
                         if (all 
-                                || ((0 == ii)
+                                || ((RT_DOWNLOAD == rt)
                                         && LL_ASSET_STORAGE_TIMEOUT < (mt_secs - tmp->mTime)))
                         {
-                                llwarns << "Asset " << REQUEST_TYPE[ii] << " request "
+                                llwarns << "Asset " << getRequestName((ERequestType)rt) << " request "
                                                 << (all ? "aborted" : "timed out") << " for "
                                                 << tmp->getUUID() << "."
                                                 << LLAssetType::lookup(tmp->getType()) << llendl;
 
                                 timed_out.push_front(tmp);
-                                iter = requests[ii]->erase(curiter);
+                                iter = requests->erase(curiter);
                         }
                 }
         }
 
         LLAssetInfo     info;
-        for (std::list<LLAssetRequest*>::iterator iter = timed_out.begin();
+        for (request_list_t::iterator iter = timed_out.begin();
                  iter != timed_out.end();  )
         {
-                std::list<LLAssetRequest*>::iterator curiter = iter++;
+                request_list_t::iterator curiter = iter++;
                 LLAssetRequest* tmp = *curiter;
                 if (tmp->mUpCallback)
                 {
@@ -401,7 +425,7 @@ void LLAssetStorage::getAssetData(const LLUUID uuid, LLAssetType::EType type, vo
                 BOOL duplicate = FALSE;
                 
                 // check to see if there's a pending download of this uuid already
-                for (std::list<LLAssetRequest*>::iterator iter = mPendingDownloads.begin();
+                for (request_list_t::iterator iter = mPendingDownloads.begin();
                          iter != mPendingDownloads.end(); ++iter )
                 {
                         LLAssetRequest  *tmp = *iter;
@@ -523,11 +547,11 @@ void LLAssetStorage::downloadCompleteCallback(
         // find and callback ALL pending requests for this UUID
         // SJB: We process the callbacks in reverse order, I do not know if this is important,
         //      but I didn't want to mess with it.
-        std::list<LLAssetRequest*> requests;
-        for (std::list<LLAssetRequest*>::iterator iter = gAssetStorage->mPendingDownloads.begin();
+        request_list_t requests;
+        for (request_list_t::iterator iter = gAssetStorage->mPendingDownloads.begin();
                  iter != gAssetStorage->mPendingDownloads.end();  )
         {
-                std::list<LLAssetRequest*>::iterator curiter = iter++;
+                request_list_t::iterator curiter = iter++;
                 LLAssetRequest* tmp = *curiter;
                 if ((tmp->getUUID() == req->getUUID()) && (tmp->getType()== req->getType()))
                 {
@@ -535,10 +559,10 @@ void LLAssetStorage::downloadCompleteCallback(
                         iter = gAssetStorage->mPendingDownloads.erase(curiter);
                 }
         }
-        for (std::list<LLAssetRequest*>::iterator iter = requests.begin();
+        for (request_list_t::iterator iter = requests.begin();
                  iter != requests.end();  )
         {
-                std::list<LLAssetRequest*>::iterator curiter = iter++;
+                request_list_t::iterator curiter = iter++;
                 LLAssetRequest* tmp = *curiter;
                 if (tmp->mDownCallback)
                 {
@@ -896,11 +920,11 @@ void LLAssetStorage::_callUploadCallbacks(const LLUUID &uuid, LLAssetType::EType
 {
         // SJB: We process the callbacks in reverse order, I do not know if this is important,
         //      but I didn't want to mess with it.
-        std::list<LLAssetRequest*> requests;
-        for (std::list<LLAssetRequest*>::iterator iter = mPendingUploads.begin();
+        request_list_t requests;
+        for (request_list_t::iterator iter = mPendingUploads.begin();
                  iter != mPendingUploads.end();  )
         {
-                std::list<LLAssetRequest*>::iterator curiter = iter++;
+                request_list_t::iterator curiter = iter++;
                 LLAssetRequest* req = *curiter;
                 if ((req->getUUID() == uuid) && (req->getType() == asset_type))
                 {
@@ -908,10 +932,10 @@ void LLAssetStorage::_callUploadCallbacks(const LLUUID &uuid, LLAssetType::EType
                         iter = mPendingUploads.erase(curiter);
                 }
         }
-        for (std::list<LLAssetRequest*>::iterator iter = mPendingLocalUploads.begin();
+        for (request_list_t::iterator iter = mPendingLocalUploads.begin();
                  iter != mPendingLocalUploads.end();  )
         {
-                std::list<LLAssetRequest*>::iterator curiter = iter++;
+                request_list_t::iterator curiter = iter++;
                 LLAssetRequest* req = *curiter;
                 if ((req->getUUID() == uuid) && (req->getType() == asset_type))
                 {
@@ -919,10 +943,10 @@ void LLAssetStorage::_callUploadCallbacks(const LLUUID &uuid, LLAssetType::EType
                         iter = mPendingLocalUploads.erase(curiter);
                 }
         }
-        for (std::list<LLAssetRequest*>::iterator iter = requests.begin();
+        for (request_list_t::iterator iter = requests.begin();
                  iter != requests.end();  )
         {
-                std::list<LLAssetRequest*>::iterator curiter = iter++;
+                request_list_t::iterator curiter = iter++;
                 LLAssetRequest* req = *curiter;
                 if (req->mUpCallback)
                 {
@@ -932,45 +956,239 @@ void LLAssetStorage::_callUploadCallbacks(const LLUUID &uuid, LLAssetType::EType
         }
 }
 
+LLAssetStorage::request_list_t* LLAssetStorage::getRequestList(LLAssetStorage::ERequestType rt)
+{
+        switch (rt)
+        {
+        case RT_DOWNLOAD:
+                return &mPendingDownloads;
+        case RT_UPLOAD:
+                return &mPendingUploads;
+        case RT_LOCALUPLOAD:
+                return &mPendingLocalUploads;
+        default:
+                llwarns << "Unable to find request list for request type '" << rt << "'" << llendl;
+                return NULL;
+        }
+}
+
+const LLAssetStorage::request_list_t* LLAssetStorage::getRequestList(LLAssetStorage::ERequestType rt) const
+{
+        switch (rt)
+        {
+        case RT_DOWNLOAD:
+                return &mPendingDownloads;
+        case RT_UPLOAD:
+                return &mPendingUploads;
+        case RT_LOCALUPLOAD:
+                return &mPendingLocalUploads;
+        default:
+                llwarns << "Unable to find request list for request type '" << rt << "'" << llendl;
+                return NULL;
+        }
+}
+
+// static
+std::string LLAssetStorage::getRequestName(LLAssetStorage::ERequestType rt)
+{
+        switch (rt)
+        {
+        case RT_DOWNLOAD:
+                return "download";
+        case RT_UPLOAD:
+                return "upload";
+        case RT_LOCALUPLOAD:
+                return "localupload";
+        default:
+                llwarns << "Unable to find request name for request type '" << rt << "'" << llendl;
+                return "";
+        }
+}
+
+S32 LLAssetStorage::getNumPending(LLAssetStorage::ERequestType rt) const
+{
+        const request_list_t* requests = getRequestList(rt);
+        S32 num_pending = -1;
+        if (requests)
+        {
+                num_pending = requests->size();
+        }
+        return num_pending;
+}
 
 S32 LLAssetStorage::getNumPendingDownloads() const
 {
-        return mPendingDownloads.size();
+        return getNumPending(RT_DOWNLOAD);
 }
 
 S32 LLAssetStorage::getNumPendingUploads() const
 {
-        return mPendingUploads.size();
+        return getNumPending(RT_UPLOAD);
 }
 
 S32 LLAssetStorage::getNumPendingLocalUploads()
 {
-        return mPendingLocalUploads.size();
+        return getNumPending(RT_LOCALUPLOAD);
+}
+
+// virtual
+LLSD LLAssetStorage::getPendingDetails(LLAssetStorage::ERequestType rt,
+                                                                                LLAssetType::EType asset_type,
+                                                                                const std::string& detail_prefix) const
+{
+        const request_list_t* requests = getRequestList(rt);
+        LLSD sd;
+        sd["requests"] = getPendingDetails(requests, asset_type, detail_prefix);
+        return sd;
+}
+
+// virtual
+LLSD LLAssetStorage::getPendingDetails(const LLAssetStorage::request_list_t* requests,
+                                                                                LLAssetType::EType asset_type,
+                                                                                const std::string& detail_prefix) const
+{
+        LLSD details;
+        if (requests)
+        {
+                request_list_t::const_iterator it = requests->begin();
+                request_list_t::const_iterator end = requests->end();
+                for ( ; it != end; ++it)
+                {
+                        LLAssetRequest* req = *it;
+                        if (   (LLAssetType::AT_NONE == asset_type)
+                                || (req->getType() == asset_type) )
+                        {
+                                LLSD row = req->getTerseDetails();
+
+                                std::ostringstream detail;
+                                detail  << detail_prefix << "/" << LLAssetType::lookup(req->getType())
+                                                << "/" << req->getUUID();
+                                row["detail"] = LLURI(detail.str());
+
+                                details.append(row);
+                        }
+                }
+        }
+        return details;
+}
+
+
+// static
+const LLAssetRequest* LLAssetStorage::findRequest(const LLAssetStorage::request_list_t* requests,
+                                                                                LLAssetType::EType asset_type,
+                                                                                const LLUUID& asset_id)
+{
+        if (requests) 
+        {
+                // Search the requests list for the asset.
+                request_list_t::const_iterator iter = requests->begin();
+                request_list_t::const_iterator end  = requests->end();
+                for (; iter != end; ++iter)
+                {
+                        const LLAssetRequest* req = *iter;
+                        if (asset_type == req->getType() &&
+                                asset_id == req->getUUID() )
+                        {
+                                return req;
+                        }
+                }
+        }
+        return NULL;
 }
 
-LLSD LLAssetStorage::getPendingTypes(const std::list<LLAssetRequest*>& requests) const
+// static
+LLAssetRequest* LLAssetStorage::findRequest(LLAssetStorage::request_list_t* requests,
+                                                                                LLAssetType::EType asset_type,
+                                                                                const LLUUID& asset_id)
 {
-        LLSD type_counts;
-        std::list<LLAssetRequest*>::const_iterator it = requests.begin();
-        std::list<LLAssetRequest*>::const_iterator end = requests.end();
-        for ( ; it != end; ++it)
+        if (requests) 
         {
-                LLAssetRequest* req = *it;
+                // Search the requests list for the asset.
+                request_list_t::iterator iter = requests->begin();
+                request_list_t::iterator end  = requests->end();
+                for (; iter != end; ++iter)
+                {
+                        LLAssetRequest* req = *iter;
+                        if (asset_type == req->getType() &&
+                                asset_id == req->getUUID() )
+                        {
+                                return req;
+                        }
+                }
+        }
+        return NULL;
+}
+
 
-                const char* type_name = LLAssetType::lookupHumanReadable(req->getType());
-                type_counts[type_name] = type_counts[type_name].asInteger() + 1;
+// virtual
+LLSD LLAssetStorage::getPendingRequest(LLAssetStorage::ERequestType rt,
+                                                                                LLAssetType::EType asset_type,
+                                                                                const LLUUID& asset_id) const
+{
+        const request_list_t* requests = getRequestList(rt);
+        return getPendingRequest(requests, asset_type, asset_id);
+}
+
+// virtual
+LLSD LLAssetStorage::getPendingRequest(const LLAssetStorage::request_list_t* requests,
+                                                                                LLAssetType::EType asset_type,
+                                                                                const LLUUID& asset_id) const
+{
+        LLSD sd;
+        const LLAssetRequest* req = findRequest(requests, asset_type, asset_id);
+        if (req)
+        {
+                sd = req->getFullDetails();
         }
-        return type_counts;
+        return sd;
 }
 
-LLSD LLAssetStorage::getPendingDownloadTypes() const
+// virtual
+bool LLAssetStorage::deletePendingRequest(LLAssetStorage::ERequestType rt,
+                                                                                        LLAssetType::EType asset_type,
+                                                                                        const LLUUID& asset_id)
 {
-        return getPendingTypes(mPendingDownloads);
+        request_list_t* requests = getRequestList(rt);
+        if (deletePendingRequest(requests, asset_type, asset_id))
+        {
+                llinfos << "Asset " << getRequestName(rt) << " request for "
+                                << asset_id << "." << LLAssetType::lookup(asset_type)
+                                << " removed from pending queue." << llendl;
+                return true;
+        }
+        return false;
 }
 
-LLSD LLAssetStorage::getPendingUploadTypes() const
+// virtual
+bool LLAssetStorage::deletePendingRequest(LLAssetStorage::request_list_t* requests,
+                                                                                        LLAssetType::EType asset_type,
+                                                                                        const LLUUID& asset_id)
 {
-        return getPendingTypes(mPendingUploads);
+        LLAssetRequest* req = findRequest(requests, asset_type, asset_id);
+        if (req)
+        {
+                // Remove the request from this list.
+                requests->remove(req);
+                S32 error = LL_ERR_TCP_TIMEOUT;
+                // Run callbacks.
+                if (req->mUpCallback)
+                {
+                        req->mUpCallback(req->getUUID(), req->mUserData, error);
+                }
+                if (req->mDownCallback)
+                {
+                        req->mDownCallback(mVFS, req->getUUID(), req->getType(), req->mUserData, error);
+                }
+                if (req->mInfoCallback)
+                {
+                        LLAssetInfo info;
+                        req->mInfoCallback(&info, req->mUserData, error);
+                }
+                delete req;
+                return true;
+        }
+        
+        return false;
 }
 
 // static
@@ -1015,7 +1233,7 @@ const char* LLAssetStorage::getErrorString(S32 status)
 void LLAssetStorage::getAssetData(const LLUUID uuid, LLAssetType::EType type, void (*callback)(const char*, const LLUUID&, void *, S32), void *user_data, BOOL is_priority)
 {
         // check for duplicates here, since we're about to fool the normal duplicate checker
-        for (std::list<LLAssetRequest*>::iterator iter = mPendingDownloads.begin();
+        for (request_list_t::iterator iter = mPendingDownloads.begin();
                  iter != mPendingDownloads.end();  )
         {
                 LLAssetRequest* tmp = *iter++;
@@ -1056,12 +1274,12 @@ void LLAssetStorage::legacyGetDataCallback(LLVFS *vfs, const LLUUID &uuid, LLAss
                 uuid.toString(uuid_str);
                 snprintf(filename,sizeof(filename),"%s.%s",gDirUtilp->getExpandedFilename(LL_PATH_CACHE,uuid_str).c_str(),LLAssetType::lookup(type));   /* Flawfinder: ignore */ 
 
-                FILE *fp = LLFile::fopen(filename, "wb");       /* Flawfinder: ignore */ 
+                FILE* fp = LLFile::fopen(filename, "wb");       /* Flawfinder: ignore */ 
                 if (fp)
                 {
                         const S32 buf_size = 65536;
                         U8 copy_buf[buf_size];
-                        while (file.read(copy_buf, buf_size))
+                        while (file.read(copy_buf, buf_size))   /* Flawfinder: ignore */
                         {
                                 if (fwrite(copy_buf, file.getLastBytesRead(), 1, fp) < 1)
                                 {
diff --git a/linden/indra/llmessage/llassetstorage.h b/linden/indra/llmessage/llassetstorage.h
index deccad3..639ab59 100644
--- a/linden/indra/llmessage/llassetstorage.h
+++ b/linden/indra/llmessage/llassetstorage.h
@@ -109,6 +109,19 @@ public:
         BOOL    mDataSentInFirstPacket;
         BOOL    mDataIsInVFS;
         LLUUID  mRequestingAgentID;     // Only valid for uploads from an agent
+
+        virtual LLSD getTerseDetails() const;
+        virtual LLSD getFullDetails() const;
+};
+
+template <class T>
+struct ll_asset_request_equal : public std::equal_to<T>
+{
+        bool operator()(const T& x, const T& y) const 
+        { 
+                return (        x->getType() == y->getType()
+                                &&      x->getUUID() == y->getUUID() );
+        }
 };
 
 
@@ -184,6 +197,15 @@ public:
         LLVFS *mVFS;
         typedef void (*LLStoreAssetCallback)(const LLUUID &asset_id, void *user_data, S32 status);
 
+        enum ERequestType
+        {
+                RT_INVALID = -1,
+                RT_DOWNLOAD = 0,
+                RT_UPLOAD = 1,
+                RT_LOCALUPLOAD = 2,
+                RT_COUNT = 3
+        };
+
 protected:
         BOOL mShutDown;
         LLHost mUpstreamHost;
@@ -191,9 +213,11 @@ protected:
         LLMessageSystem *mMessageSys;
         LLXferManager   *mXferManager;
 
-        std::list<LLAssetRequest*> mPendingDownloads;
-        std::list<LLAssetRequest*> mPendingUploads;
-        std::list<LLAssetRequest*> mPendingLocalUploads;
+
+        typedef std::list<LLAssetRequest*> request_list_t;
+        request_list_t mPendingDownloads;
+        request_list_t mPendingUploads;
+        request_list_t mPendingLocalUploads;
         
 public:
         LLAssetStorage(LLMessageSystem *msg, LLXferManager *xfer,
@@ -258,14 +282,48 @@ public:
                                                  const LLUUID &asset_id, LLAssetType::EType atype,
                                                  LLGetAssetCallback cb, void *user_data, BOOL is_priority = FALSE); // Get a particular inventory item.
 
+protected:
+        virtual LLSD getPendingDetails(const request_list_t* requests,
+                                        LLAssetType::EType asset_type,
+                                        const std::string& detail_prefix) const;
+
+        virtual LLSD getPendingRequest(const request_list_t* requests,
+                                                        LLAssetType::EType asset_type,
+                                                        const LLUUID& asset_id) const;
+
+        virtual bool deletePendingRequest(request_list_t* requests,
+                                                        LLAssetType::EType asset_type,
+                                                        const LLUUID& asset_id);
+
+public:
+        static const LLAssetRequest* findRequest(const request_list_t* requests,
+                                                                                LLAssetType::EType asset_type,
+                                                                                const LLUUID& asset_id);
+        static LLAssetRequest* findRequest(request_list_t* requests,
+                                                                                LLAssetType::EType asset_type,
+                                                                                const LLUUID& asset_id);
+
+        request_list_t* getRequestList(ERequestType rt);
+        const request_list_t* getRequestList(ERequestType rt) const;
+        static std::string getRequestName(ERequestType rt);
 
         S32 getNumPendingDownloads() const;
         S32 getNumPendingUploads() const;
         S32 getNumPendingLocalUploads();
+        S32 getNumPending(ERequestType rt) const;
+
+        virtual LLSD getPendingDetails(ERequestType rt,
+                                        LLAssetType::EType asset_type,
+                                        const std::string& detail_prefix) const;
+
+        virtual LLSD getPendingRequest(ERequestType rt,
+                                                        LLAssetType::EType asset_type,
+                                                        const LLUUID& asset_id) const;
+
+        virtual bool deletePendingRequest(ERequestType rt,
+                                                        LLAssetType::EType asset_type,
+                                                        const LLUUID& asset_id);
 
-        // Returns a map from type to num pending, eg 'texture' => 5, 'object' => 10
-        LLSD getPendingDownloadTypes() const;
-        LLSD getPendingUploadTypes() const;
 
         // download process callbacks
         static void downloadCompleteCallback(
@@ -349,8 +407,6 @@ private:
                            LLXferManager *xfer,
                            LLVFS *vfs,
                            const LLHost &upstream_host);
-        LLSD getPendingTypes(const std::list<LLAssetRequest*>& requests) const;
-
 };
 
 ////////////////////////////////////////////////////////////////////////
diff --git a/linden/indra/llmessage/llblowfishcipher.cpp b/linden/indra/llmessage/llblowfishcipher.cpp
new file mode 100644
index 0000000..f9a68ab
--- /dev/null
+++ b/linden/indra/llmessage/llblowfishcipher.cpp
@@ -0,0 +1,154 @@
+/** 
+ * @file llblowcipher.cpp
+ * @brief Wrapper around OpenSSL Blowfish encryption algorithm.
+ *
+ * We do not have OpenSSL headers or libraries on Windows, so this
+ * class only works on Linux.
+ *
+ * Copyright (c) 2007-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#include "linden_common.h"
+
+#include "llblowfishcipher.h"
+
+
+LLBlowfishCipher::LLBlowfishCipher(const U8* secret, size_t secret_size)
+:       LLCipher()
+{
+        llassert(secret);
+
+        mSecretSize = secret_size;
+        mSecret = new U8[mSecretSize];
+        memcpy(mSecret, secret, mSecretSize);
+}
+
+LLBlowfishCipher::~LLBlowfishCipher()
+{
+        delete [] mSecret;
+        mSecret = NULL;
+}
+
+
+#if LL_LINUX
+
+#include <openssl/evp.h>
+
+// virtual
+U32 LLBlowfishCipher::encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
+{
+        if (!src || !src_len || !dst || !dst_len) return 0;
+        if (src_len > dst_len) return 0;
+
+        // OpenSSL uses "cipher contexts" to hold encryption parameters.
+    EVP_CIPHER_CTX context;
+    EVP_CIPHER_CTX_init(&context);
+
+        // We want a blowfish cyclic block chain cipher, but need to set 
+        // the key length before we pass in a key, so call EncryptInit 
+        // first with NULLs.
+        EVP_EncryptInit_ex(&context, EVP_bf_cbc(), NULL, NULL, NULL);
+        EVP_CIPHER_CTX_set_key_length(&context, (int)mSecretSize);
+        
+        // Complete initialization.  Per EVP_EncryptInit man page, the
+        // cipher pointer must be NULL.  Apparently initial_vector must
+        // be 8 bytes for blowfish, as this is the block size.
+    unsigned char initial_vector[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+        EVP_EncryptInit_ex(&context, NULL, NULL, mSecret, initial_vector);
+
+    int blocksize = EVP_CIPHER_CTX_block_size(&context);
+    int keylen = EVP_CIPHER_CTX_key_length(&context);
+    int iv_length = EVP_CIPHER_CTX_iv_length(&context);
+    lldebugs << "LLBlowfishCipher blocksize " << blocksize
+                << " keylen " << keylen
+                << " iv_len " << iv_length
+                << llendl;
+
+    int output_len = 0;
+    if (!EVP_EncryptUpdate(&context,
+                dst,
+                &output_len,
+                src,
+                src_len))
+    {
+        llwarns << "LLBlowfishCipher::encrypt EVP_EncryptUpdate failure" << llendl;
+        return 0;
+    }
+
+        // There may be some final data left to encrypt if the input is
+        // not an exact multiple of the block size.
+    int temp_len = 0;
+    if (!EVP_EncryptFinal_ex(&context, (unsigned char*)(dst + output_len), &temp_len))
+    {
+        llwarns << "LLBlowfishCipher::encrypt EVP_EncryptFinal failure" << llendl;
+        return 0;
+    }
+    output_len += temp_len;
+        return output_len;
+}
+
+// virtual
+U32 LLBlowfishCipher::decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
+{
+        llerrs << "LLBlowfishCipher decrypt unsupported" << llendl;
+        return 0;
+}
+
+// virtual
+U32 LLBlowfishCipher::requiredEncryptionSpace(U32 len) const
+{
+        // *HACK: We know blowfish uses an 8 byte block size.
+        // Oddly, sometimes EVP_Encrypt produces an extra block
+        // if the input is an exact multiple of the block size.
+        // So round up.
+        const U32 BLOCK_SIZE = 8;
+        len += BLOCK_SIZE;
+        len -= (len % BLOCK_SIZE);
+        return len;
+}
+
+#else   // !LL_LINUX
+
+// virtual
+U32 LLBlowfishCipher::encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
+{
+        llerrs << "LLBlowfishCipher only supported on Linux" << llendl;
+        return 0;
+}
+
+// virtual
+U32 LLBlowfishCipher::decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
+{
+        llerrs << "LLBlowfishCipher only supported on Linux" << llendl;
+        return 0;
+}
+
+// virtual
+U32 LLBlowfishCipher::requiredEncryptionSpace(U32 len) const
+{
+        llerrs << "LLBlowfishCipher only supported on Linux" << llendl;
+        return 0;
+}
+
+#endif
+
diff --git a/linden/indra/llmessage/llblowfishcipher.h b/linden/indra/llmessage/llblowfishcipher.h
new file mode 100644
index 0000000..2557598
--- /dev/null
+++ b/linden/indra/llmessage/llblowfishcipher.h
@@ -0,0 +1,58 @@
+/** 
+ * @file llblowfishcipher.h
+ * @brief A symmetric block cipher, designed in 1993 by Bruce Schneier.
+ * We use it because it has an 8 byte block size, allowing encryption of
+ * two UUIDs and a timestamp (16x2 + 4 = 36 bytes) with only 40 bytes of
+ * output.  AES has a block size of 32 bytes, so this would require 64 bytes.
+ *
+ * Copyright (c) 2007-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LLBLOWFISHCIPHER_H
+#define LLBLOWFISHCIPHER_H
+
+#include "llcipher.h"
+
+
+class LLBlowfishCipher : public LLCipher
+{
+public:
+        // Secret may be up to 56 bytes in length per Blowfish spec.
+        LLBlowfishCipher(const U8* secret, size_t secret_size);
+        virtual ~LLBlowfishCipher();
+
+        // See llcipher.h for documentation.
+        /*virtual*/ U32 encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len);
+        /*virtual*/ U32 decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len);
+        /*virtual*/ U32 requiredEncryptionSpace(U32 src_len) const;
+
+#ifdef _DEBUG
+        static BOOL testHarness();
+#endif
+
+private:
+        U8* mSecret;
+        size_t mSecretSize;
+};
+
+#endif // LL_LLCRYPTO_H
diff --git a/linden/indra/llmessage/llbuffer.cpp b/linden/indra/llmessage/llbuffer.cpp
index 07c730a..3dd34a0 100644
--- a/linden/indra/llmessage/llbuffer.cpp
+++ b/linden/indra/llmessage/llbuffer.cpp
@@ -109,7 +109,7 @@ LLHeapBuffer::LLHeapBuffer(const U8* src, S32 len)
                 allocate(len);
                 if(mBuffer)
                 {
-                        memcpy(mBuffer, src, len);
+                        memcpy(mBuffer, src, len);      /*Flawfinder: ignore*/
                 }
         }
         else
@@ -735,7 +735,7 @@ bool LLBufferArray::copyIntoBuffers(
                 }
                 segments.push_back(segment);
                 S32 bytes = llmin(segment.size(), len);
-                memcpy(segment.data(), src + copied, bytes);  /* Flawfinder Ignore */
+                memcpy(segment.data(), src + copied, bytes);  /* Flawfinder: Ignore */
                 copied += bytes;
                 len -= bytes;
                 if(0 == len)
@@ -757,7 +757,7 @@ bool LLBufferArray::copyIntoBuffers(
                         return false;
                 }
                 segments.push_back(segment);
-                memcpy(segment.data(), src + copied, segment.size());
+                memcpy(segment.data(), src + copied, segment.size());   /*Flawfinder: ignore*/
                 copied += segment.size();
                 len -= segment.size();
         }
diff --git a/linden/indra/llmessage/llcachename.cpp b/linden/indra/llmessage/llcachename.cpp
index 3a92812..e92c72f 100644
--- a/linden/indra/llmessage/llcachename.cpp
+++ b/linden/indra/llmessage/llcachename.cpp
@@ -276,6 +276,40 @@ void LLCacheName::addObserver(LLCacheNameCallback callback)
         impl.mObservers.push_back(callback);
 }
 
+void LLCacheName::removeObserver(LLCacheNameCallback callback)
+{
+        Observers::iterator it = impl.mObservers.begin();
+        Observers::iterator end = impl.mObservers.end();
+
+        for ( ; it != end; ++it)
+        {
+                const LLCacheNameCallback& cb = (*it);
+                if (cb == callback)
+                {
+                        impl.mObservers.erase(it);
+                        return;
+                }
+        }
+}
+
+void LLCacheName::cancelCallback(const LLUUID& id, LLCacheNameCallback callback, void* user_data)
+{
+        ReplyQueue::iterator it = impl.mReplyQueue.begin();
+        ReplyQueue::iterator end = impl.mReplyQueue.end();
+        
+        for(; it != end; ++it)
+        {
+                const PendingReply& reply = (*it);
+
+                if ((callback == reply.mCallback)
+                        && (id == reply.mID)
+                        && (user_data == reply.mData) )
+                {
+                        impl.mReplyQueue.erase(it);
+                        return;
+                }
+        }
+}
 
 void LLCacheName::importFile(FILE* fp)
 {
@@ -297,7 +331,10 @@ void LLCacheName::importFile(FILE* fp)
         // *NOTE: This buffer size is hardcoded into sscanf() below
         char version_string[BUFFER_SIZE]; /*Flawfinder: ignore*/
         S32 version = 0;
-        S32 match = sscanf(buffer, "%1023s %d", version_string, &version);
+        S32 match = sscanf(     /* Flawfinder: ignore */
+                buffer,
+                "%1023s %d",
+                version_string, &version);
         if (   match != 2
                 || strcmp(version_string, "version")
                 || version != CN_FILE_VERSION)
@@ -316,7 +353,7 @@ void LLCacheName::importFile(FILE* fp)
                 valid = fgets(buffer, BUFFER_SIZE, fp);
                 if (!valid) break;
 
-                match = sscanf(
+                match = sscanf( /* Flawfinder: ignore */
                         buffer,
                         "%254s %u %254s %254s",
                         id_string, 
@@ -395,7 +432,7 @@ BOOL LLCacheName::getName(const LLUUID& id, char* first, char* last)
         {
                 // The function signature needs to change to pass in the
                 // length of first and last.
-                strcpy(first, CN_NOBODY);
+                strcpy(first, CN_NOBODY);       /*Flawfinder: ignore*/
                 last[0] = '\0';
                 return FALSE;
         }
@@ -405,8 +442,8 @@ BOOL LLCacheName::getName(const LLUUID& id, char* first, char* last)
         {
                 // The function signature needs to change to pass in the
                 // length of first and last.
-                strcpy(first, entry->mFirstName);
-                strcpy(last,  entry->mLastName);
+                strcpy(first, entry->mFirstName);       /*Flawfinder: ignore*/
+                strcpy(last,  entry->mLastName);        /*Flawfinder: ignore*/
                 return TRUE;
         }
         else
@@ -416,7 +453,7 @@ BOOL LLCacheName::getName(const LLUUID& id, char* first, char* last)
                 strcpy(first,(ll_frand() < HIPPO_PROBABILITY)
                                                 ? CN_HIPPOS 
                                                 : CN_WAITING);
-                strcpy(last, "");
+                strcpy(last, "");       /*Flawfinder: ignore*/
 
                 impl.mAskNameQueue.push_back(id);
                 return FALSE;
@@ -432,7 +469,7 @@ BOOL LLCacheName::getGroupName(const LLUUID& id, char* group)
         {
                 // The function signature needs to change to pass in the
                 // length of first and last.
-                strcpy(group, CN_NONE);
+                strcpy(group, CN_NONE); /*Flawfinder: ignore*/
                 return FALSE;
         }
 
@@ -450,14 +487,14 @@ BOOL LLCacheName::getGroupName(const LLUUID& id, char* group)
         {
                 // The function signature needs to change to pass in the length
                 // of group.
-                strcpy(group, entry->mGroupName);
+                strcpy(group, entry->mGroupName);       /*Flawfinder: ignore*/
                 return TRUE;
         }
         else 
         {
                 // The function signature needs to change to pass in the length
                 // of first and last.
-                strcpy(group, CN_WAITING);
+                strcpy(group, CN_WAITING);      /*Flawfinder: ignore*/
 
                 impl.mAskGroupQueue.push_back(id);
                 return FALSE;
diff --git a/linden/indra/llmessage/llcachename.h b/linden/indra/llmessage/llcachename.h
index 4dd42cb..9987f11 100644
--- a/linden/indra/llmessage/llcachename.h
+++ b/linden/indra/llmessage/llcachename.h
@@ -60,6 +60,8 @@ public:
         void addObserver(LLCacheNameCallback callback);
         void removeObserver(LLCacheNameCallback callback);
 
+        void cancelCallback(const LLUUID& id, LLCacheNameCallback callback, void* user_data = NULL);
+
         // storing cache on disk; for viewer, in name.cache
         void importFile(FILE* fp);
         void exportFile(FILE* fp);
diff --git a/linden/indra/llmessage/llcipher.h b/linden/indra/llmessage/llcipher.h
new file mode 100644
index 0000000..c1f88ff
--- /dev/null
+++ b/linden/indra/llmessage/llcipher.h
@@ -0,0 +1,57 @@
+/** 
+ * @file llcipher.h
+ * @brief Abstract base class for encryption ciphers.
+ *
+ * Copyright (c) 2003-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LLCIPHER_H
+#define LLCIPHER_H
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLCipher
+//
+// Abstract base class for a cipher object.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLCipher
+{
+public:
+        virtual ~LLCipher() {}
+
+        // encrypt src and place result into dst. returns TRUE if
+        // Returns number of bytes written into dst, or 0 on error.
+        virtual U32 encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len) = 0;
+
+        // decrypt src and place result into dst. 
+        // Returns number of bytes written into dst, or 0 on error.
+        virtual U32 decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len) = 0;
+
+        // returns the minimum amount of space required to encrypt for a 
+        // unencrypted source buffer of length len.
+        // *NOTE: This is estimated space and you should check the return value
+        // of the encrypt function.
+        virtual U32 requiredEncryptionSpace(U32 src_len) const = 0 ;
+};
+
+#endif
diff --git a/linden/indra/llmessage/llcurl.cpp b/linden/indra/llmessage/llcurl.cpp
new file mode 100644
index 0000000..886697e
--- /dev/null
+++ b/linden/indra/llmessage/llcurl.cpp
@@ -0,0 +1,343 @@
+/*
+ *  llcurl.cpp
+ *  MacTester
+ *
+ *  Created by Zero Linden on 10/15/06.
+ *  Copyright 2006 __MyCompanyName__. All rights reserved.
+ *
+ */
+
+#include "llcurl.h"
+
+#include <iomanip>
+
+#include "llsdserialize.h"
+
+//////////////////////////////////////////////////////////////////////////////
+/*
+        The trick to getting curl to do keep-alives is to reuse the
+        same easy handle for the requests.  It appears that curl
+        keeps a pool of connections alive for each easy handle, but
+        doesn't share them between easy handles.  Therefore it is
+        important to keep a pool of easy handles and reuse them,
+        rather than create and destroy them with each request.  This
+        code does this.
+
+        Furthermore, it would behoove us to keep track of which
+        hosts an easy handle was used for and pick an easy handle
+        that matches the next request.  This code does not current
+        do this.
+ */
+
+using namespace std;
+        
+LLCurl::Responder::Responder()
+        : mReferenceCount(0)
+{
+}
+LLCurl::Responder::~Responder()
+{
+}
+
+// virtual
+void LLCurl::Responder::error(U32 status, const std::stringstream& content)
+{
+        llinfos << "LLCurl::Responder::error " << status << ": " << content.str() << llendl;
+}
+
+// virtual
+void LLCurl::Responder::result(const std::stringstream& content)
+{
+}
+
+// virtual
+void LLCurl::Responder::completed(U32 status, const std::stringstream& content)
+{
+        if (200 <= status &&  status < 300)
+        {
+                result(content);
+        }
+        else
+        {
+                error(status, content);
+        }
+}
+
+
+namespace boost
+{
+        void intrusive_ptr_add_ref(LLCurl::Responder* p)
+        {
+                ++p->mReferenceCount;
+        }
+        
+        void intrusive_ptr_release(LLCurl::Responder* p)
+        {
+                if(0 == --p->mReferenceCount)
+                {
+                        delete p;
+                }
+        }
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+size_t
+curlOutputCallback(void* data, size_t size, size_t nmemb, void* user_data)
+{
+        stringstream& output = *(stringstream*)user_data;
+        
+        size_t n = size * nmemb;
+        output.write((const char*)data, n);
+        if (!((istream&)output).good()) {
+                std::cerr << "WHAT!?!?!? istream side bad" << std::endl;
+        }
+        if (!((ostream&)output).good()) {
+                std::cerr << "WHAT!?!?!? ostream side bad" << std::endl;
+        }
+
+        return n;
+}
+
+// Only used if request contained a body (post or put), Not currently implemented.
+// size_t
+// curlRequestCallback(void* data, size_t size, size_t nmemb, void* user_data)
+// {
+//      stringstream& request = *(stringstream*)user_data;
+        
+//      size_t n = size * nmemb;
+//      request.read((char*)data, n);
+//      return request.gcount();
+// }
+
+
+
+
+
+LLCurl::Easy::Easy()
+{
+        mHeaders = 0;
+        mHeaders = curl_slist_append(mHeaders, "Connection: keep-alive");
+        mHeaders = curl_slist_append(mHeaders, "Keep-alive: 300");
+        mHeaders = curl_slist_append(mHeaders, "Content-Type: application/xml");
+                // FIXME: shouldn't be there for GET/DELETE
+                // FIXME: should have ACCEPT headers
+                
+        mHandle = curl_easy_init();
+}
+
+LLCurl::Easy::~Easy()
+{
+        curl_easy_cleanup(mHandle);
+        curl_slist_free_all(mHeaders);
+}
+
+void
+LLCurl::Easy::get(const string& url, ResponderPtr responder)
+{
+        prep(url, responder);
+        curl_easy_setopt(mHandle, CURLOPT_HTTPGET, 1);
+}
+
+void
+LLCurl::Easy::getByteRange(const string& url, S32 offset, S32 length, ResponderPtr responder)
+{
+        mRange = llformat("Range: bytes=%d-%d", offset,offset+length-1);
+        mHeaders = curl_slist_append(mHeaders, mRange.c_str());
+        prep(url, responder);
+        curl_easy_setopt(mHandle, CURLOPT_HTTPGET, 1);
+}
+
+void
+LLCurl::Easy::perform()
+{
+        report(curl_easy_perform(mHandle));
+}
+
+void
+LLCurl::Easy::prep(const std::string& url, ResponderPtr responder)
+{
+#if !LL_DARWIN
+        curl_easy_reset(mHandle); // SJB: doesn't exisit on OSX 10.3.9
+#else
+        // SJB: equivalent? fast?
+        curl_easy_cleanup(mHandle);
+        mHandle = curl_easy_init();
+#endif
+        
+        curl_easy_setopt(mHandle, CURLOPT_PRIVATE, this);
+
+//      curl_easy_setopt(mHandle, CURLOPT_VERBOSE, 1); // usefull for debugging
+        curl_easy_setopt(mHandle, CURLOPT_NOSIGNAL, 1);
+        curl_easy_setopt(mHandle, CURLOPT_WRITEFUNCTION, &curlOutputCallback);
+        curl_easy_setopt(mHandle, CURLOPT_WRITEDATA, &mOutput);
+#if 1 // For debug
+        curl_easy_setopt(mHandle, CURLOPT_HEADERFUNCTION, &curlOutputCallback);
+        curl_easy_setopt(mHandle, CURLOPT_HEADERDATA, &mHeaderOutput);
+#endif
+        curl_easy_setopt(mHandle, CURLOPT_ERRORBUFFER, &mErrorBuffer);
+        curl_easy_setopt(mHandle, CURLOPT_ENCODING, "");
+        curl_easy_setopt(mHandle, CURLOPT_SSL_VERIFYPEER, false);
+        curl_easy_setopt(mHandle, CURLOPT_HTTPHEADER, mHeaders);
+
+        mOutput.str("");
+        if (!((istream&)mOutput).good()) {
+                std::cerr << "WHAT!?!?!? istream side bad" << std::endl;
+        }
+        if (!((ostream&)mOutput).good()) {
+                std::cerr << "WHAT!?!?!? ostream side bad" << std::endl;
+        }
+
+        mURL = url;
+        curl_easy_setopt(mHandle, CURLOPT_URL, mURL.c_str());
+
+        mResponder = responder;
+}
+
+void
+LLCurl::Easy::report(CURLcode code)
+{
+        if (!mResponder) return;
+        
+        long responseCode;
+        
+        if (code == CURLE_OK)
+        {
+                curl_easy_getinfo(mHandle, CURLINFO_RESPONSE_CODE, &responseCode);
+        }
+        else
+        {
+                responseCode = 499;
+        }
+        
+        mResponder->completed(responseCode, mOutput);
+        mResponder = NULL;
+}
+
+
+
+
+
+
+LLCurl::Multi::Multi()
+{
+        mHandle = curl_multi_init();
+}
+
+LLCurl::Multi::~Multi()
+{
+        // FIXME: should clean up excess handles in mFreeEasy
+        curl_multi_cleanup(mHandle);
+}
+
+
+void
+LLCurl::Multi::get(const std::string& url, ResponderPtr responder)
+{
+        LLCurl::Easy* easy = easyAlloc();
+        easy->get(url, responder);
+        curl_multi_add_handle(mHandle, easy->mHandle);
+}
+        
+void
+LLCurl::Multi::getByteRange(const std::string& url, S32 offset, S32 length, ResponderPtr responder)
+{
+        LLCurl::Easy* easy = easyAlloc();
+        easy->getByteRange(url, offset, length, responder);
+        curl_multi_add_handle(mHandle, easy->mHandle);
+}
+        
+void
+LLCurl::Multi::process()
+{
+        int count;
+        for (int call_count = 0; call_count < 5; call_count += 1)
+        {
+                if (CURLM_CALL_MULTI_PERFORM != curl_multi_perform(mHandle, &count))
+                {
+                        break;
+                }
+        }
+                
+        CURLMsg* msg;
+        int msgs_in_queue;
+        while ((msg = curl_multi_info_read(mHandle, &msgs_in_queue)))
+        {
+                if (msg->msg != CURLMSG_DONE) continue;
+                Easy* easy = 0;
+                curl_easy_getinfo(msg->easy_handle, CURLINFO_PRIVATE, &easy);
+                if (!easy) continue;
+                easy->report(msg->data.result);
+                
+                curl_multi_remove_handle(mHandle, easy->mHandle);
+                easyFree(easy);
+        }
+}
+
+
+
+LLCurl::Easy*
+LLCurl::Multi::easyAlloc()
+{
+        Easy* easy = 0;
+        
+        if (mFreeEasy.empty())
+        {
+                easy = new Easy();
+        }
+        else
+        {
+                easy = mFreeEasy.back();
+                mFreeEasy.pop_back();
+        }
+
+        return easy;
+}
+
+void
+LLCurl::Multi::easyFree(Easy* easy)
+{
+        if (mFreeEasy.size() < 5)
+        {
+                mFreeEasy.push_back(easy);
+        }
+        else
+        {
+                delete easy;
+        }
+}
+
+
+
+namespace
+{
+        static LLCurl::Multi* sMainMulti = 0;
+        
+        LLCurl::Multi*
+        mainMulti()
+        {
+                if (!sMainMulti) {
+                        sMainMulti = new LLCurl::Multi();
+                }
+                return sMainMulti;
+        }
+}
+
+void
+LLCurl::get(const std::string& url, ResponderPtr responder)
+{
+        mainMulti()->get(url, responder);
+}
+        
+void
+LLCurl::getByteRange(const std::string& url, S32 offset, S32 length, ResponderPtr responder)
+{
+        mainMulti()->getByteRange(url, offset, length, responder);
+}
+        
+void
+LLCurl::process()
+{
+        mainMulti()->process();
+}
+
diff --git a/linden/indra/llmessage/llcurl.h b/linden/indra/llmessage/llcurl.h
new file mode 100644
index 0000000..4f1b5e6
--- /dev/null
+++ b/linden/indra/llmessage/llcurl.h
@@ -0,0 +1,118 @@
+/*
+ *  llcurl.h
+ *  MacTester
+ *
+ *  Created by Zero Linden on 10/15/06.
+ *  Copyright 2006 __MyCompanyName__. All rights reserved.
+ *
+ */
+ 
+#ifndef LL_LLCURL_H
+#define LL_LLCURL_H
+
+#include "linden_common.h"
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <boost/intrusive_ptr.hpp>
+#include <curl/curl.h>
+
+// #include "llhttpclient.h"
+
+class LLCurl
+{
+public:
+        class Multi;
+
+        class Responder
+        {
+        public:
+                Responder();
+                virtual ~Responder();
+
+                virtual void error(U32 status, const std::stringstream& content);       // called with bad status codes
+                
+                virtual void result(const std::stringstream& content);
+                
+                virtual void completed(U32 status, const std::stringstream& content);
+                        /**< The default implemetnation calls
+                                either:
+                                * result(), or
+                                * error() 
+                        */
+                        
+        public: /* but not really -- don't touch this */
+                U32 mReferenceCount;
+        };
+        typedef boost::intrusive_ptr<Responder> ResponderPtr;
+        
+        class Easy
+        {
+        public:
+                Easy();
+                ~Easy();
+                
+                void get(const std::string& url, ResponderPtr);
+                void getByteRange(const std::string& url, S32 offset, S32 length, ResponderPtr);
+
+                void perform();
+
+        private:
+                void prep(const std::string& url, ResponderPtr);
+                void report(CURLcode);
+                
+                CURL*                           mHandle;
+                struct curl_slist*      mHeaders;
+                
+                std::string                     mURL;
+                std::string                     mRange;
+                std::stringstream       mRequest;
+
+                std::stringstream       mOutput;
+                char                            mErrorBuffer[CURL_ERROR_SIZE];
+
+                std::stringstream       mHeaderOutput; // Debug
+                
+                ResponderPtr            mResponder;
+
+                friend class Multi;
+        };
+
+
+        class Multi
+        {
+        public:
+                Multi();
+                ~Multi();
+
+                void get(const std::string& url, ResponderPtr);
+                void getByteRange(const std::string& url, S32 offset, S32 length, ResponderPtr);
+
+                void process();
+                
+        private:
+                Easy* easyAlloc();
+                void easyFree(Easy*);
+                
+                CURLM* mHandle;
+                
+                typedef std::vector<Easy*>      EasyList;
+                EasyList mFreeEasy;
+        };
+
+
+        static void get(const std::string& url, ResponderPtr);
+        static void getByteRange(const std::string& url, S32 offset, S32 length, ResponderPtr responder);
+        
+        static void process();
+};
+
+namespace boost
+{
+        void intrusive_ptr_add_ref(LLCurl::Responder* p);
+        void intrusive_ptr_release(LLCurl::Responder* p);
+};
+
+#endif // LL_LLCURL_H
diff --git a/linden/indra/llmessage/lldatapacker.cpp b/linden/indra/llmessage/lldatapacker.cpp
index 4a15d8b..d4c8704 100644
--- a/linden/indra/llmessage/lldatapacker.cpp
+++ b/linden/indra/llmessage/lldatapacker.cpp
@@ -543,7 +543,7 @@ const LLDataPackerBinaryBuffer&	LLDataPackerBinaryBuffer::operator=(const LLData
                 // We've got problems, ack!
                 llerrs << "Trying to do an assignment with not enough room in the target." << llendl;
         }
-        memcpy(mBufferp, a.mBufferp, a.getBufferSize());
+        memcpy(mBufferp, a.mBufferp, a.getBufferSize());        /*Flawfinder: ignore*/
         return *this;
 }
 
@@ -1236,7 +1236,7 @@ BOOL LLDataPackerAsciiBuffer::unpackUUID(LLUUID &value, const char *name)
         }
 
         char tmp_str[64];       /* Flawfinder: ignore */
-        sscanf(valuestr, "%63s", tmp_str);
+        sscanf(valuestr, "%63s", tmp_str);      /* Flawfinder: ignore */
         value.set(tmp_str);
 
         return success;
@@ -1258,7 +1258,7 @@ void LLDataPackerAsciiBuffer::writeIndentedName(const char *name)
                 }
                 else
                 {
-                        numCopied = (S32)strlen(name) + 1; //name + tab            /* Flawfinder: ignore */
+                        numCopied = (S32)strlen(name) + 1;      /* Flawfinder: ignore */ //name + tab   
                 }
 
                 // snprintf returns number of bytes that would have been written had the 
@@ -1288,9 +1288,9 @@ BOOL LLDataPackerAsciiBuffer::getValueStr(const char *name, char *out_value, S32
                 // Read both the name and the value, and validate the name.
                 sscanf(mCurBufferp, "%511[^\n]", buffer);
                 // Skip the \n
-                mCurBufferp += (S32)strlen(buffer) + 1;
+                mCurBufferp += (S32)strlen(buffer) + 1; /* Flawfinder: ignore */
 
-                sscanf(buffer, "%511s %511[^\n]", keyword, value);
+                sscanf(buffer, "%511s %511[^\n]", keyword, value);      /* Flawfinder: ignore */
 
                 if (strcmp(keyword, name))
                 {
@@ -1794,7 +1794,7 @@ BOOL LLDataPackerAsciiFile::unpackUUID(LLUUID &value, const char *name)
         }
 
         char tmp_str[64]; /*Flawfinder: ignore */
-        sscanf(valuestr,"%63s",tmp_str);
+        sscanf(valuestr,"%63s",tmp_str);        /* Flawfinder: ignore */
         value.set(tmp_str);
 
         return success;
@@ -1838,7 +1838,7 @@ BOOL LLDataPackerAsciiFile::getValueStr(const char *name, char *out_value, S32 v
                 fgetpos(mFP, &last_pos);
                 fgets(buffer, DP_BUFSIZE, mFP);
         
-                sscanf(buffer, "%511s %511[^\n]", keyword, value);
+                sscanf(buffer, "%511s %511[^\n]", keyword, value);      /* Flawfinder: ignore */
         
                 if (!keyword[0])
                 {
@@ -1863,7 +1863,7 @@ BOOL LLDataPackerAsciiFile::getValueStr(const char *name, char *out_value, S32 v
         {
                 mInputStream->getline(buffer, DP_BUFSIZE);
         
-                sscanf(buffer, "%511s %511[^\n]", keyword, value);
+                sscanf(buffer, "%511s %511[^\n]", keyword, value);      /* Flawfinder: ignore */
                 if (!keyword[0])
                 {
                         llwarns << "Data packer could not get the keyword!" << llendl;
diff --git a/linden/indra/llmessage/lldispatcher.cpp b/linden/indra/llmessage/lldispatcher.cpp
index cf83079..7ba9f44 100644
--- a/linden/indra/llmessage/lldispatcher.cpp
+++ b/linden/indra/llmessage/lldispatcher.cpp
@@ -76,6 +76,7 @@ bool LLDispatcher::dispatch(
                 LLDispatchHandler* func = (*it).second;
                 return (*func)(this, name, invoice, strings);
         }
+        llwarns << "Unable to find handler for Generic message: " << name << llendl;
         return false;
 }
 
diff --git a/linden/indra/llmessage/llfiltersd2xmlrpc.cpp b/linden/indra/llmessage/llfiltersd2xmlrpc.cpp
index feae47a..63913d5 100644
--- a/linden/indra/llmessage/llfiltersd2xmlrpc.cpp
+++ b/linden/indra/llmessage/llfiltersd2xmlrpc.cpp
@@ -267,6 +267,7 @@ void LLFilterSD2XMLRPC::streamOut(std::ostream& ostr, const LLSD& sd)
                 LLSD::Binary buffer = sd.asBinary();
                 if(!buffer.empty())
                 {
+                        // *TODO: convert to LLBase64
                         int b64_buffer_length = apr_base64_encode_len(buffer.size());
                         char* b64_buffer = new char[b64_buffer_length];
                         b64_buffer_length = apr_base64_encode_binary(
diff --git a/linden/indra/llmessage/llhost.cpp b/linden/indra/llmessage/llhost.cpp
index c071063..c1ca4b0 100644
--- a/linden/indra/llmessage/llhost.cpp
+++ b/linden/indra/llmessage/llhost.cpp
@@ -87,7 +87,7 @@ void LLHost::getIPString(char* buffer, S32 length) const
 
 std::string LLHost::getIPandPort() const
 {
-        char buffer[MAXADDRSTR + 1 + 5];
+        char buffer[MAXADDRSTR + 1 + 5];        /*Flawfinder: ignore*/
         getString(buffer, sizeof(buffer));
         return buffer;
 }
diff --git a/linden/indra/llmessage/llhttpassetstorage.cpp b/linden/indra/llmessage/llhttpassetstorage.cpp
index 2b64385..6c57499 100644
--- a/linden/indra/llmessage/llhttpassetstorage.cpp
+++ b/linden/indra/llmessage/llhttpassetstorage.cpp
@@ -30,12 +30,15 @@
 
 #include "llhttpassetstorage.h"
 
+#include <sys/stat.h>
+
 #include "indra_constants.h"
 #include "llvfile.h"
 #include "llvfs.h"
 
 #include "zlib/zlib.h"
 
+const U32 MAX_RUNNING_REQUESTS = 4;
 const F32 MAX_PROCESSING_TIME = 0.005f;
 const S32 CURL_XFER_BUFFER_SIZE = 65536;
 // Try for 30 minutes for now.
@@ -68,7 +71,9 @@ struct LLTempAssetData
 class LLHTTPAssetRequest : public LLAssetRequest
 {
 public:
-        LLHTTPAssetRequest(LLHTTPAssetStorage *asp, const LLUUID &uuid, LLAssetType::EType type, const char *url, CURLM *curl_multi);
+        LLHTTPAssetRequest(LLHTTPAssetStorage *asp, const LLUUID &uuid, 
+                                        LLAssetType::EType type, LLAssetStorage::ERequestType rt,
+                                        const char *url, CURLM *curl_multi);
         virtual ~LLHTTPAssetRequest();
         
         void setupCurlHandle();
@@ -80,6 +85,9 @@ public:
         static size_t curlCompressedUploadCallback(
                                         void *data, size_t size, size_t nmemb, void *user_data);
 
+        virtual LLSD getTerseDetails() const;
+        virtual LLSD getFullDetails() const;
+
 public:
         LLHTTPAssetStorage *mAssetStoragep;
 
@@ -89,9 +97,7 @@ public:
         struct curl_slist *mHTTPHeaders;
         LLVFile *mVFile;
         LLUUID  mTmpUUID;
-        BOOL    mIsUpload;
-        BOOL    mIsLocalUpload;
-        BOOL    mIsDownload;
+        LLAssetStorage::ERequestType mRequestType;
 
         bool            mZInitialized;
         z_stream        mZStream;
@@ -102,7 +108,12 @@ public:
 };
 
 
-LLHTTPAssetRequest::LLHTTPAssetRequest(LLHTTPAssetStorage *asp, const LLUUID &uuid, LLAssetType::EType type, const char *url, CURLM *curl_multi)
+LLHTTPAssetRequest::LLHTTPAssetRequest(LLHTTPAssetStorage *asp, 
+                                                const LLUUID &uuid, 
+                                                LLAssetType::EType type, 
+                                                LLAssetStorage::ERequestType rt,
+                                                const char *url, 
+                                                CURLM *curl_multi)
         : LLAssetRequest(uuid, type),
         mZInitialized(false)
 {
@@ -110,15 +121,16 @@ LLHTTPAssetRequest::LLHTTPAssetRequest(LLHTTPAssetStorage *asp, const LLUUID &uu
         mCurlHandle = NULL;
         mCurlMultiHandle = curl_multi;
         mVFile = NULL;
-        mIsUpload = FALSE;
-        mIsLocalUpload = FALSE;
-        mIsDownload = FALSE;
+        mRequestType = rt;
         mHTTPHeaders = NULL;
+        mFP = NULL;
+        mZInputBuffer = NULL;
+        mZInputExhausted = false;
         
         mURLBuffer = new char[strlen(url) + 1]; /*Flawfinder: ignore*/
         if (mURLBuffer)
         {
-            strcpy(mURLBuffer, url);
+            strcpy(mURLBuffer, url);    /*Flawfinder: ignore*/
         }
 }
 
@@ -132,22 +144,7 @@ LLHTTPAssetRequest::~LLHTTPAssetRequest()
                 if (mAssetStoragep)
                 {
                         // Terminating a request.  Thus upload or download is no longer pending.
-                        if (mIsUpload)
-                        {
-                                mAssetStoragep->clearPendingUpload();
-                        }
-                        else if (mIsLocalUpload)
-                        {
-                                mAssetStoragep->clearPendingLocalUpload();
-                        }
-                        else if (mIsDownload)
-                        {
-                                mAssetStoragep->clearPendingDownload();
-                        }
-                        else
-                        {
-                                llerrs << "LLHTTPAssetRequest::~LLHTTPAssetRequest - Destroyed request is not upload OR download, this is bad!" << llendl;
-                        }
+                        mAssetStoragep->removeRunningRequest(mRequestType, this);
                 }
                 else
                 {
@@ -163,6 +160,82 @@ LLHTTPAssetRequest::~LLHTTPAssetRequest()
         finishCompressedUpload();
 }
 
+// virtual
+LLSD LLHTTPAssetRequest::getTerseDetails() const
+{
+        LLSD sd = LLAssetRequest::getTerseDetails();
+
+        sd["url"] = mURLBuffer;
+
+        return sd;
+}
+
+// virtual
+LLSD LLHTTPAssetRequest::getFullDetails() const
+{
+        LLSD sd = LLAssetRequest::getFullDetails();
+
+        if (mCurlHandle)
+        {
+                long curl_response = -1;
+                long curl_connect = -1;
+                double curl_total_time = -1.0f;
+                double curl_size_upload = -1.0f;
+                double curl_size_download = -1.0f;
+                long curl_content_length_upload = -1;
+                long curl_content_length_download = -1;
+                long curl_request_size = -1;
+                const char* curl_content_type = NULL;
+
+                curl_easy_getinfo(mCurlHandle, CURLINFO_HTTP_CODE, &curl_response);
+                curl_easy_getinfo(mCurlHandle, CURLINFO_HTTP_CONNECTCODE, &curl_connect);
+                curl_easy_getinfo(mCurlHandle, CURLINFO_TOTAL_TIME, &curl_total_time);
+                curl_easy_getinfo(mCurlHandle, CURLINFO_SIZE_UPLOAD,  &curl_size_upload);
+                curl_easy_getinfo(mCurlHandle, CURLINFO_SIZE_DOWNLOAD, &curl_size_download);
+                curl_easy_getinfo(mCurlHandle, CURLINFO_CONTENT_LENGTH_UPLOAD,   &curl_content_length_upload);
+                curl_easy_getinfo(mCurlHandle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &curl_content_length_download);
+                curl_easy_getinfo(mCurlHandle, CURLINFO_REQUEST_SIZE, &curl_request_size);
+                curl_easy_getinfo(mCurlHandle, CURLINFO_CONTENT_TYPE, &curl_content_type);
+
+                sd["curl_response_code"] = (int) curl_response;
+                sd["curl_http_connect_code"] = (int) curl_connect;
+                sd["curl_total_time"] = curl_total_time;
+                sd["curl_size_upload"]   = curl_size_upload;
+                sd["curl_size_download"] = curl_size_download;
+                sd["curl_content_length_upload"]   = (int) curl_content_length_upload;
+                sd["curl_content_length_download"] = (int) curl_content_length_download;
+                sd["curl_request_size"] = (int) curl_request_size;
+                if (curl_content_type)
+                {
+                        sd["curl_content_type"] = curl_content_type;
+                }
+                else
+                {
+                        sd["curl_content_type"] = "";
+                }
+        }
+
+        sd["temp_id"] = mTmpUUID;
+        sd["request_type"] = LLAssetStorage::getRequestName(mRequestType);
+        sd["z_initialized"] = mZInitialized;
+        sd["z_input_exhausted"] = mZInputExhausted;
+
+        S32 file_size = -1;
+        if (mFP)
+        {
+                struct stat file_stat;
+                int file_desc = fileno(mFP);
+                if ( fstat(file_desc, &file_stat) == 0)
+                {
+                        file_size = file_stat.st_size;
+                }
+        }
+        sd["file_size"] = file_size;
+
+        return sd;
+}
+
+
 void LLHTTPAssetRequest::setupCurlHandle()
 {
         mCurlHandle = curl_easy_init();
@@ -170,7 +243,7 @@ void LLHTTPAssetRequest::setupCurlHandle()
         curl_easy_setopt(mCurlHandle, CURLOPT_NOPROGRESS, 1);
         curl_easy_setopt(mCurlHandle, CURLOPT_URL, mURLBuffer);
         curl_easy_setopt(mCurlHandle, CURLOPT_PRIVATE, this);
-        if (mIsDownload)
+        if (LLAssetStorage::RT_DOWNLOAD == mRequestType)
         {
                 curl_easy_setopt(mCurlHandle, CURLOPT_ENCODING, "");
                 // only do this on downloads, as uploads 
@@ -193,22 +266,7 @@ void LLHTTPAssetRequest::setupCurlHandle()
         if (mAssetStoragep)
         {
                 // Set the appropriate pending upload or download flag
-                if (mIsUpload)
-                {
-                        mAssetStoragep->setPendingUpload();
-                }
-                else if (mIsLocalUpload)
-                {
-                        mAssetStoragep->setPendingLocalUpload();
-                }
-                else if (mIsDownload)
-                {
-                        mAssetStoragep->setPendingDownload();
-                }
-                else
-                {
-                        llerrs << "LLHTTPAssetRequest::setupCurlHandle - Request is not upload OR download, this is bad!" << llendl;
-                }
+                mAssetStoragep->addRunningRequest(mRequestType, this);
         }
         else
         {
@@ -342,10 +400,6 @@ void LLHTTPAssetStorage::_init(const char *web_host, const char *local_web_host,
         curl_global_init(CURL_GLOBAL_ALL);
 
         mCurlMultiHandle = curl_multi_init();
-
-        mPendingDownload = FALSE;
-        mPendingUpload = FALSE;
-        mPendingLocalUpload = FALSE;
 }
 
 LLHTTPAssetStorage::~LLHTTPAssetStorage()
@@ -457,6 +511,113 @@ void LLHTTPAssetStorage::storeAssetData(
         }
 }
 
+// virtual
+LLSD LLHTTPAssetStorage::getPendingDetails(LLAssetStorage::ERequestType rt,
+                                                                                LLAssetType::EType asset_type,
+                                                                                const std::string& detail_prefix) const
+{
+        LLSD sd = LLAssetStorage::getPendingDetails(rt, asset_type, detail_prefix);
+        const request_list_t* running = getRunningList(rt);
+        if (running)
+        {
+                // Loop through the pending requests sd, and add extra info about its running status.
+                S32 num_pending = sd["requests"].size();
+                S32 i;
+                for (i = 0; i < num_pending; ++i)
+                {
+                        LLSD& pending = sd["requests"][i];
+                        // See if this pending request is running.
+                        const LLAssetRequest* req = findRequest(running, 
+                                                                        LLAssetType::lookup(pending["type"].asString().c_str()),
+                                                                        pending["asset_id"]);
+                        if (req)
+                        {
+                                // Keep the detail_url so we don't have to rebuild it.
+                                LLURI detail_url = pending["detail"];
+                                pending = req->getTerseDetails();
+                                pending["detail"] = detail_url;
+                                pending["is_running"] = true;
+                        }
+                        else
+                        {
+                                pending["is_running"] = false;
+                        }
+                }
+        }
+        return sd;
+}
+
+// virtual
+LLSD LLHTTPAssetStorage::getPendingRequest(LLAssetStorage::ERequestType rt,
+                                                                                LLAssetType::EType asset_type,
+                                                                                const LLUUID& asset_id) const
+{
+        // Look for this asset in the running list first.
+        const request_list_t* running = getRunningList(rt);
+        if (running)
+        {
+                LLSD sd = LLAssetStorage::getPendingRequest(running, asset_type, asset_id);
+                if (sd)
+                {
+                        sd["is_running"] = true;
+                        return sd;
+                }
+        }
+        LLSD sd = LLAssetStorage::getPendingRequest(rt, asset_type, asset_id);
+        if (sd)
+        {
+                sd["is_running"] = false;
+        }
+        return sd;
+}
+
+// virtual
+bool LLHTTPAssetStorage::deletePendingRequest(LLAssetStorage::ERequestType rt,
+                                                                                        LLAssetType::EType asset_type,
+                                                                                        const LLUUID& asset_id)
+{
+        // Try removing this from the running list first.
+        request_list_t* running = getRunningList(rt);
+        if (running)
+        {
+                LLAssetRequest* req = findRequest(running, asset_type, asset_id);
+                if (req)
+                {
+                        // Remove this request from the running list to get it out of curl.
+                        running->remove(req);
+                        
+                        // Find this request in the pending list, so we can move it to the end of the line.
+                        request_list_t* pending = getRequestList(rt);
+                        if (pending)
+                        {
+                                request_list_t::iterator result = std::find_if(pending->begin(), pending->end(),
+                                                                                std::bind2nd(ll_asset_request_equal<LLAssetRequest*>(), req));
+                                if (pending->end() != result)
+                                {
+                                        // This request was found in the pending list.  Move it to the end!
+                                        LLAssetRequest* pending_req = *result;
+                                        pending->remove(pending_req);
+                                        pending->push_back(pending_req);
+
+                                        llinfos << "Asset " << getRequestName(rt) << " request for "
+                                                        << asset_id << "." << LLAssetType::lookup(asset_type)
+                                                        << " removed from curl and placed at the end of the pending queue."
+                                                        << llendl;
+                                }
+                                else
+                                {
+                                        llwarns << "Unable to find pending " << getRequestName(rt) << " request for "
+                                                        << asset_id << "." << LLAssetType::lookup(asset_type) << llendl;
+                                }
+                        }
+                        delete req;
+
+                        return true;
+                }
+        }
+        return LLAssetStorage::deletePendingRequest(rt, asset_type, asset_id);
+}
+
 // internal requester, used by getAssetData in superclass
 void LLHTTPAssetStorage::_queueDataRequest(const LLUUID& uuid, LLAssetType::EType type,
                                                                                   void (*callback)(LLVFS *vfs, const LLUUID&, LLAssetType::EType, void *, S32),
@@ -488,13 +649,41 @@ void LLHTTPAssetStorage::_queueDataRequest(const LLUUID& uuid, LLAssetType::ETyp
         }
 }
 
+LLAssetRequest* LLHTTPAssetStorage::findNextRequest(LLAssetStorage::request_list_t& pending, 
+                                                                                                        LLAssetStorage::request_list_t& running)
+{
+        // Early exit if the running list is full, or we don't have more pending than running.
+        if (running.size() >= MAX_RUNNING_REQUESTS
+                || pending.size() <= running.size()) return NULL;
+
+        // Look for the first pending request that is not already running.
+        request_list_t::iterator running_begin = running.begin();
+        request_list_t::iterator running_end   = running.end();
+
+        request_list_t::iterator pending_iter = pending.begin();
+        request_list_t::iterator pending_end  = pending.end();
+        // Loop over all pending requests until we miss finding it in the running list.
+        for (; pending_iter != pending.end(); ++pending_iter)
+        {
+                LLAssetRequest* req = *pending_iter;
+                // Look for this pending request in the running list.
+                if (running_end == std::find_if(running_begin, running_end, 
+                                                std::bind2nd(ll_asset_request_equal<LLAssetRequest*>(), req)))
+                {
+                        // It isn't running!  Return it.
+                        return req;
+                }
+        }
+        return NULL;
+}
+
 // overloaded to additionally move data to/from the webserver
 void LLHTTPAssetStorage::checkForTimeouts()
 {
-        LLAssetRequest *req = NULL;
-        if (mPendingDownloads.size() > 0  && !mPendingDownload)
-        {       
-                req = mPendingDownloads.front();
+        CURLMcode mcode;
+        LLAssetRequest *req;
+        while (req = findNextRequest(mPendingDownloads, mRunningDownloads))
+        {
                 // Setup this curl download request
                 // We need to generate a new request here
                 // since the one in the list could go away
@@ -504,9 +693,9 @@ void LLHTTPAssetStorage::checkForTimeouts()
                 std::string base_url = getBaseURL(req->getUUID(), req->getType());
                 snprintf(tmp_url, sizeof(tmp_url), "%s/%36s.%s", base_url.c_str() , uuid_str, LLAssetType::lookup(req->getType())); /*Flawfinder: ignore*/
 
-                LLHTTPAssetRequest *new_req = new LLHTTPAssetRequest(this, req->getUUID(), req->getType(), tmp_url, mCurlMultiHandle);
+                LLHTTPAssetRequest *new_req = new LLHTTPAssetRequest(this, req->getUUID(), 
+                                                                                req->getType(), RT_DOWNLOAD, tmp_url, mCurlMultiHandle);
                 new_req->mTmpUUID.generate();
-                new_req->mIsDownload = TRUE;
 
                 // Sets pending download flag internally
                 new_req->setupCurlHandle();
@@ -514,15 +703,22 @@ void LLHTTPAssetStorage::checkForTimeouts()
                 curl_easy_setopt(new_req->mCurlHandle, CURLOPT_WRITEFUNCTION, &curlDownCallback);
                 curl_easy_setopt(new_req->mCurlHandle, CURLOPT_WRITEDATA, new_req->mCurlHandle);
         
-                curl_multi_add_handle(mCurlMultiHandle, new_req->mCurlHandle);
-                llinfos << "Requesting " << new_req->mURLBuffer << llendl;
-
+                mcode = curl_multi_add_handle(mCurlMultiHandle, new_req->mCurlHandle);
+                if (mcode > CURLM_OK)
+                {
+                        // Failure.  Deleting the pending request will remove it from the running
+                        // queue, and push it to the end of the pending queue.
+                        deletePendingRequest(RT_DOWNLOAD, req->getType(), req->getUUID());
+                        break;
+                }
+                else
+                {
+                        llinfos << "Requesting " << new_req->mURLBuffer << llendl;
+                }
         }
 
-        
-        if (mPendingUploads.size() > 0 && !mPendingUpload)
+        while (req = findNextRequest(mPendingUploads, mRunningUploads))
         {
-                req = mPendingUploads.front();
                 // setup this curl upload request
 
                 bool do_compress = req->getType() == LLAssetType::AT_OBJECT;
@@ -534,8 +730,8 @@ void LLHTTPAssetStorage::checkForTimeouts()
                                 do_compress ? "%s/%s.%s.gz" : "%s/%s.%s",
                                 mBaseURL.c_str(), uuid_str, LLAssetType::lookup(req->getType())); 
 
-                LLHTTPAssetRequest *new_req = new LLHTTPAssetRequest(this, req->getUUID(), req->getType(), tmp_url, mCurlMultiHandle);
-                new_req->mIsUpload = TRUE;
+                LLHTTPAssetRequest *new_req = new LLHTTPAssetRequest(this, req->getUUID(), 
+                                                                        req->getType(), RT_UPLOAD, tmp_url, mCurlMultiHandle);
                 if (do_compress)
                 {
                         new_req->prepareCompressedUpload();
@@ -560,15 +756,23 @@ void LLHTTPAssetStorage::checkForTimeouts()
                 }
                 curl_easy_setopt(new_req->mCurlHandle, CURLOPT_READDATA, new_req->mCurlHandle);
         
-                curl_multi_add_handle(mCurlMultiHandle, new_req->mCurlHandle);
-                llinfos << "Requesting PUT " << new_req->mURLBuffer << llendl;
+                mcode = curl_multi_add_handle(mCurlMultiHandle, new_req->mCurlHandle);
+                if (mcode > CURLM_OK)
+                {
+                        // Failure.  Deleting the pending request will remove it from the running
+                        // queue, and push it to the end of the pending queue.
+                        deletePendingRequest(RT_UPLOAD, req->getType(), req->getUUID());
+                        break;
+                }
+                else
+                {
+                        llinfos << "Requesting PUT " << new_req->mURLBuffer << llendl;
+                }
                 // Pending upload will have been flagged by the request
         }
 
-
-        if (mPendingLocalUploads.size() > 0 && !mPendingLocalUpload)
+        while (req = findNextRequest(mPendingLocalUploads, mRunningLocalUploads))
         {
-                req = mPendingLocalUploads.front();
                 // setup this curl upload request
                 LLVFile file(mVFS, req->getUUID(), req->getType());
 
@@ -579,8 +783,8 @@ void LLHTTPAssetStorage::checkForTimeouts()
                 // KLW - All temporary uploads are saved locally "http://localhost:12041/asset"
                 snprintf(tmp_url, sizeof(tmp_url), "%s/%36s.%s", mLocalBaseURL.c_str(), uuid_str, LLAssetType::lookup(req->getType())); /*Flawfinder: ignore*/
 
-                LLHTTPAssetRequest *new_req = new LLHTTPAssetRequest(this, req->getUUID(), req->getType(), tmp_url, mCurlMultiHandle);
-                new_req->mIsLocalUpload = TRUE;
+                LLHTTPAssetRequest *new_req = new LLHTTPAssetRequest(this, req->getUUID(), 
+                                                                                req->getType(), RT_LOCALUPLOAD, tmp_url, mCurlMultiHandle);
                 new_req->mRequestingAgentID = req->mRequestingAgentID;
 
                 // Sets pending upload flag internally
@@ -591,13 +795,22 @@ void LLHTTPAssetStorage::checkForTimeouts()
                 curl_easy_setopt(new_req->mCurlHandle, CURLOPT_READFUNCTION, &curlUpCallback);
                 curl_easy_setopt(new_req->mCurlHandle, CURLOPT_READDATA, new_req->mCurlHandle);
         
-                curl_multi_add_handle(mCurlMultiHandle, new_req->mCurlHandle);
-                llinfos << "TAT: LLHTTPAssetStorage::checkForTimeouts() : pending local!"
-                        << " Requesting PUT " << new_req->mURLBuffer << llendl;
+                mcode = curl_multi_add_handle(mCurlMultiHandle, new_req->mCurlHandle);
+                if (mcode > CURLM_OK)
+                {
+                        // Failure.  Deleting the pending request will remove it from the running
+                        // queue, and push it to the end of the pending queue.
+                        deletePendingRequest(RT_LOCALUPLOAD, req->getType(), req->getUUID());
+                        break;
+                }
+                else
+                {
+                        llinfos << "TAT: LLHTTPAssetStorage::checkForTimeouts() : pending local!"
+                                << " Requesting PUT " << new_req->mURLBuffer << llendl;
+                }
                 // Pending upload will have been flagged by the request
         }
         S32 count = 0;
-        CURLMcode mcode;
         int queue_length;
         do
         {
@@ -618,12 +831,15 @@ void LLHTTPAssetStorage::checkForTimeouts()
                         curl_easy_getinfo(curl_msg->easy_handle, CURLINFO_PRIVATE, &req);
                                                                 
                         curl_easy_getinfo(curl_msg->easy_handle, CURLINFO_HTTP_CODE, &curl_result);
-                        if (req->mIsUpload || req->mIsLocalUpload)
+                        if (RT_UPLOAD == req->mRequestType || RT_LOCALUPLOAD == req->mRequestType)
                         {
-                                if (curl_msg->data.result == CURLE_OK && (curl_result == HTTP_OK || curl_result == HTTP_PUT_OK || curl_result == HTTP_NO_CONTENT))
+                                if (curl_msg->data.result == CURLE_OK && 
+                                        (   curl_result == HTTP_OK 
+                                         || curl_result == HTTP_PUT_OK 
+                                         || curl_result == HTTP_NO_CONTENT))
                                 {
                                         llinfos << "Success uploading " << req->getUUID() << " to " << req->mURLBuffer << llendl;
-                                        if (req->mIsLocalUpload)
+                                        if (RT_LOCALUPLOAD == req->mRequestType)
                                         {
                                                 addTempAssetData(req->getUUID(), req->mRequestingAgentID, mHostName);
                                         }
@@ -655,7 +871,7 @@ void LLHTTPAssetStorage::checkForTimeouts()
                                         // Pending upload flag will get cleared when the request is deleted
                                 }
                         }
-                        else if (req->mIsDownload)
+                        else if (RT_DOWNLOAD == req->mRequestType)
                         {
                                 if (curl_result == HTTP_OK && curl_msg->data.result == CURLE_OK)
                                 {
@@ -667,7 +883,7 @@ void LLHTTPAssetStorage::checkForTimeouts()
                                         }
                                         else
                                         {
-                                                // TODO: if this actually indicates a bad asset on the server
+                                                // *TODO: if this actually indicates a bad asset on the server
                                                 // (not certain at this point), then delete it
                                                 llwarns << "Found " << req->mURLBuffer << " to be zero size" << llendl;
                                                 xfer_result = LL_ERR_ASSET_REQUEST_NOT_IN_DATABASE;
@@ -793,9 +1009,8 @@ S32 LLHTTPAssetStorage::getURLToFile(const LLUUID& uuid, LLAssetType::EType asse
         }
 
         // make sure we use the normal curl setup, even though we don't really need a request object
-        LLHTTPAssetRequest req(this, uuid, asset_type, url.c_str(), mCurlMultiHandle);
+        LLHTTPAssetRequest req(this, uuid, asset_type, RT_DOWNLOAD, url.c_str(), mCurlMultiHandle);
         req.mFP = fp;
-        req.mIsDownload = TRUE;
         
         req.setupCurlHandle();
         curl_easy_setopt(req.mCurlHandle, CURLOPT_FOLLOWLOCATION, TRUE);
@@ -887,6 +1102,63 @@ size_t LLHTTPAssetStorage::curlFileDownCallback(void *data, size_t size, size_t
         return fwrite(data, size, nmemb, req->mFP);
 }
 
+LLAssetStorage::request_list_t* LLHTTPAssetStorage::getRunningList(LLAssetStorage::ERequestType rt)
+{
+        switch (rt)
+        {
+        case RT_DOWNLOAD:
+                return &mRunningDownloads;
+        case RT_UPLOAD:
+                return &mRunningUploads;
+        case RT_LOCALUPLOAD:
+                return &mRunningLocalUploads;
+        default:
+                return NULL;
+        }
+}
+
+const LLAssetStorage::request_list_t* LLHTTPAssetStorage::getRunningList(LLAssetStorage::ERequestType rt) const
+{
+        switch (rt)
+        {
+        case RT_DOWNLOAD:
+                return &mRunningDownloads;
+        case RT_UPLOAD:
+                return &mRunningUploads;
+        case RT_LOCALUPLOAD:
+                return &mRunningLocalUploads;
+        default:
+                return NULL;
+        }
+}
+
+
+void LLHTTPAssetStorage::addRunningRequest(ERequestType rt, LLHTTPAssetRequest* request)
+{
+        request_list_t* requests = getRunningList(rt);
+        if (requests)
+        {
+                requests->push_back(request);
+        }
+        else
+        {
+                llerrs << "LLHTTPAssetStorage::addRunningRequest - Request is not an upload OR download, this is bad!" << llendl;
+        }
+}
+
+void LLHTTPAssetStorage::removeRunningRequest(ERequestType rt, LLHTTPAssetRequest* request)
+{
+        request_list_t* requests = getRunningList(rt);
+        if (requests)
+        {
+                requests->remove(request);
+        }
+        else
+        {
+                llerrs << "LLHTTPAssetStorage::removeRunningRequest - Destroyed request is not an upload OR download, this is bad!" << llendl;
+        }
+}
+
 // virtual 
 void LLHTTPAssetStorage::addTempAssetData(const LLUUID& asset_id, const LLUUID& agent_id, const std::string& host_name)
 {
diff --git a/linden/indra/llmessage/llhttpassetstorage.h b/linden/indra/llmessage/llhttpassetstorage.h
index d09e2ce..d98af45 100644
--- a/linden/indra/llmessage/llhttpassetstorage.h
+++ b/linden/indra/llmessage/llhttpassetstorage.h
@@ -32,6 +32,7 @@
 #include "curl/curl.h"
 
 class LLVFile;
+class LLHTTPAssetRequest;
 typedef void (*progress_callback)(void* userdata);
 
 struct LLTempAssetData;
@@ -75,11 +76,25 @@ public:
                 bool temp_file,
                 bool is_priority);
 
+        virtual LLSD getPendingDetails(ERequestType rt,
+                                        LLAssetType::EType asset_type,
+                                        const std::string& detail_prefix) const;
+
+        virtual LLSD getPendingRequest(ERequestType rt,
+                                                        LLAssetType::EType asset_type,
+                                                        const LLUUID& asset_id) const;
+
+        virtual bool deletePendingRequest(ERequestType rt,
+                                                        LLAssetType::EType asset_type,
+                                                        const LLUUID& asset_id);
+
         // Hack.  One off curl download an URL to a file.  Probably should be elsewhere.
         // Only used by lldynamicstate.  The API is broken, and should be replaced with
         // a generic HTTP file fetch - Doug 9/25/06
         S32 getURLToFile(const LLUUID& uuid, LLAssetType::EType asset_type, const LLString &url, const char *filename, progress_callback callback, void *userdata);
         
+        LLAssetRequest* findNextRequest(request_list_t& pending, request_list_t& running);
+
         void checkForTimeouts();
         
         static size_t curlDownCallback(void *data, size_t size, size_t nmemb, void *user_data);
@@ -88,12 +103,11 @@ public:
         static size_t nullOutputCallback(void *data, size_t size, size_t nmemb, void *user_data);
 
         // Should only be used by the LLHTTPAssetRequest
-        void setPendingUpload()                 { mPendingUpload = TRUE; }
-        void setPendingLocalUpload()    { mPendingLocalUpload = TRUE; }
-        void setPendingDownload()               { mPendingDownload = TRUE; }
-        void clearPendingUpload()               { mPendingUpload = FALSE; }
-        void clearPendingLocalUpload()  { mPendingLocalUpload = FALSE; }
-        void clearPendingDownload()             { mPendingDownload = FALSE; }
+        void addRunningRequest(ERequestType rt, LLHTTPAssetRequest* request);
+        void removeRunningRequest(ERequestType rt, LLHTTPAssetRequest* request);
+
+        request_list_t* getRunningList(ERequestType rt);
+        const request_list_t* getRunningList(ERequestType rt) const;
 
         // Temp assets are stored on sim nodes, they have agent ID and location data associated with them.
         virtual void addTempAssetData(const LLUUID& asset_id, const LLUUID& agent_id, const std::string& host_name);
@@ -125,9 +139,9 @@ protected:
 
         CURLM  *mCurlMultiHandle;
 
-        BOOL mPendingDownload;
-        BOOL mPendingUpload;
-        BOOL mPendingLocalUpload;
+        request_list_t mRunningDownloads;
+        request_list_t mRunningUploads;
+        request_list_t mRunningLocalUploads;
 
         uuid_tempdata_map mTempAssets;
 };
diff --git a/linden/indra/llmessage/llhttpclient.cpp b/linden/indra/llmessage/llhttpclient.cpp
index d94918e..3755ae0 100644
--- a/linden/indra/llmessage/llhttpclient.cpp
+++ b/linden/indra/llmessage/llhttpclient.cpp
@@ -37,6 +37,8 @@
 #include "llvfile.h"
 #include "llvfs.h"
 
+#include <curl/curl.h>
+
 static const F32 HTTP_REQUEST_EXPIRY_SECS = 60.0f;
 
 static std::string gCABundle;
@@ -148,6 +150,27 @@ namespace
 
                 const LLSD mSD;
         };
+
+        class RawInjector : public Injector
+        {
+        public:
+                RawInjector(const U8* data, S32 size) : mData(data), mSize(size) {}
+                virtual ~RawInjector() {}
+
+                const char* contentType() { return "application/octet-stream"; }
+
+                virtual EStatus process_impl(const LLChannelDescriptors& channels,
+                        buffer_ptr_t& buffer, bool& eos, LLSD& context, LLPumpIO* pump)
+                {
+                        LLBufferStream ostream(channels, buffer.get());
+                        ostream.write((const char *)mData, mSize);  // hopefully chars are always U8s
+                        eos = true;
+                        return STATUS_DONE;
+                }
+
+                const U8* mData;
+                S32 mSize;
+        };
         
         class FileInjector : public Injector
         {
@@ -243,6 +266,84 @@ void LLHTTPClient::get(const std::string& url, ResponderPtr responder)
         request(url, LLURLRequest::HTTP_GET, NULL, responder);
 }
 
+// A simple class for managing data returned from a curl http request.
+class LLHTTPBuffer
+{
+public:
+        LLHTTPBuffer() { }
+
+        static size_t curl_write( void *ptr, size_t size, size_t nmemb, void *user_data)
+        {
+                LLHTTPBuffer* self = (LLHTTPBuffer*)user_data;
+                
+                size_t bytes = (size * nmemb);
+                self->mBuffer.append((char*)ptr,bytes);
+                return nmemb;
+        }
+
+        LLSD asLLSD()
+        {
+                LLSD content;
+
+                if (mBuffer.empty()) return content;
+                
+                std::istringstream istr(mBuffer);
+                LLSDSerialize::fromXML(content, istr);
+                return content;
+        }
+
+        std::string asString()
+        {
+                return mBuffer;
+        }
+
+private:
+        std::string mBuffer;
+};
+
+// This call is blocking! This is probably usually bad. :(
+LLSD LLHTTPClient::blockingGet(const std::string& url)
+{
+        llinfos << "blockingGet of " << url << llendl;
+
+        // Returns an LLSD map: {status: integer, body: map}
+        char curl_error_buffer[CURL_ERROR_SIZE];
+        CURL* curlp = curl_easy_init();
+
+        LLHTTPBuffer http_buffer;
+
+        curl_easy_setopt(curlp, CURLOPT_WRITEFUNCTION, LLHTTPBuffer::curl_write);
+        curl_easy_setopt(curlp, CURLOPT_WRITEDATA, &http_buffer);
+        curl_easy_setopt(curlp, CURLOPT_URL, url.c_str());
+        curl_easy_setopt(curlp, CURLOPT_ERRORBUFFER, curl_error_buffer);
+        curl_easy_setopt(curlp, CURLOPT_FAILONERROR, 1);
+
+        LLSD response = LLSD::emptyMap();
+
+        S32 curl_success = curl_easy_perform(curlp);
+
+        S32 http_status = 499;
+        curl_easy_getinfo(curlp,CURLINFO_RESPONSE_CODE, &http_status);
+
+        response["status"] = http_status;
+
+        if (curl_success != 0 
+                && http_status != 404)  // We expect 404s, don't spam for them.
+        {
+                llwarns << "CURL ERROR: " << curl_error_buffer << llendl;
+                
+                response["body"] = http_buffer.asString();
+        }
+        else
+        {
+                response["body"] = http_buffer.asLLSD();
+        }
+        
+        curl_easy_cleanup(curlp);
+
+        return response;
+}
+
 void LLHTTPClient::put(const std::string& url, const LLSD& body, ResponderPtr responder)
 {
         request(url, LLURLRequest::HTTP_PUT, new LLSDInjector(body), responder);
@@ -253,6 +354,11 @@ void LLHTTPClient::post(const std::string& url, const LLSD& body, ResponderPtr r
         request(url, LLURLRequest::HTTP_POST, new LLSDInjector(body), responder);
 }
 
+void LLHTTPClient::post(const std::string& url, const U8* data, S32 size, ResponderPtr responder)
+{
+        request(url, LLURLRequest::HTTP_POST, new RawInjector(data, size), responder);
+}
+
 void LLHTTPClient::del(const std::string& url, ResponderPtr responder)
 {
         request(url, LLURLRequest::HTTP_DELETE, NULL, responder);
@@ -301,4 +407,3 @@ namespace boost
                 }
         }
 };
-
diff --git a/linden/indra/llmessage/llhttpclient.h b/linden/indra/llmessage/llhttpclient.h
index d48d084..93859eb 100644
--- a/linden/indra/llmessage/llhttpclient.h
+++ b/linden/indra/llmessage/llhttpclient.h
@@ -73,10 +73,14 @@ public:
         static void put(const std::string& url, const LLSD& body, ResponderPtr);
                 ///< non-blocking
         static void post(const std::string& url, const LLSD& body, ResponderPtr);
+        static void post(const std::string& url, const U8* data, S32 size, ResponderPtr responder);
         static void postFile(const std::string& url, const std::string& filename, ResponderPtr);
         static void postFile(const std::string& url, const LLUUID& uuid,
                 LLAssetType::EType asset_type, ResponderPtr responder);
 
+        // Blocking HTTP get that returns an LLSD map of status and body.
+        static LLSD blockingGet(const std::string& url);
+
         static void del(const std::string& url, ResponderPtr);
                 ///< sends a DELETE method, but we can't call it delete in c++
         
diff --git a/linden/indra/llmessage/llinstantmessage.cpp b/linden/indra/llmessage/llinstantmessage.cpp
index f1f4514..6f6e022 100644
--- a/linden/indra/llmessage/llinstantmessage.cpp
+++ b/linden/indra/llmessage/llinstantmessage.cpp
@@ -226,8 +226,8 @@ void pack_instant_message_block(
         S32 bytes_left = MTUBYTES;
         if(message)
         {
-                char buffer[MTUBYTES];
-                bytes_left -= snprintf(buffer, MTUBYTES, "%s", message);
+                char buffer[MTUBYTES];  /*Flawfinder: ignore*/
+                bytes_left -= snprintf(buffer, MTUBYTES, "%s", message);        /*Flawfinder: ignore*/
                 bytes_left = llmax(0, bytes_left);
                 msg->addStringFast(_PREHASH_Message, buffer);
         }
@@ -263,11 +263,11 @@ void LLIMInfo::unpackMessageBlock(LLMessageSystem* msg)
         mIMType = (EInstantMessage) dialog;
         msg->getUUIDFast(_PREHASH_MessageBlock, _PREHASH_ID, mID);
         msg->getU32Fast(_PREHASH_MessageBlock, _PREHASH_Timestamp, mTimeStamp);
-        char name[DB_FULL_NAME_BUF_SIZE];
+        char name[DB_FULL_NAME_BUF_SIZE];       /*Flawfinder: ignore*/
         msg->getStringFast(_PREHASH_MessageBlock, _PREHASH_FromAgentName, DB_FULL_NAME_BUF_SIZE, name);
         mName.assign(name);
 
-        char message[DB_IM_MSG_BUF_SIZE];
+        char message[DB_IM_MSG_BUF_SIZE];       /*Flawfinder: ignore*/
         msg->getStringFast(_PREHASH_MessageBlock, _PREHASH_Message, DB_IM_MSG_BUF_SIZE, message);
         mMessage.assign(message);
 
diff --git a/linden/indra/llmessage/llmail.cpp b/linden/indra/llmessage/llmail.cpp
index e84d097..aea3689 100644
--- a/linden/indra/llmessage/llmail.cpp
+++ b/linden/indra/llmessage/llmail.cpp
@@ -27,6 +27,8 @@
 
 #include "linden_common.h"
 
+#include "llmail.h"
+
 // APR on Windows needs full windows headers
 #ifdef LL_WINDOWS
 #       undef WIN32_LEAN_AND_MEAN
@@ -38,14 +40,16 @@
 #include <sstream>
 #include <boost/regex.hpp>
 
-#include "llmail.h"
-
 #include "apr-1/apr_pools.h"
 #include "apr-1/apr_network_io.h"
 
 #include "llapr.h"
+#include "llbase32.h"   // IM-to-email address
+#include "llblowfishcipher.h"
 #include "llerror.h"
 #include "llhost.h"
+#include "llstring.h"
+#include "lluuid.h"
 #include "net.h"
 
 //
@@ -105,11 +109,12 @@ void disconnect_smtp()
 
 // Returns TRUE on success.
 // message should NOT be SMTP escaped.
-BOOL send_mail(const char* from_name, const char* from_address,
+// 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)
 {
-        std::string header = build_smtp_transaction(
+        std::string header = buildSMTPTransaction(
                 from_name,
                 from_address,
                 to_name,
@@ -125,12 +130,13 @@ BOOL send_mail(const char* from_name, const char* from_address,
         {
                 message_str = message;
         }
-        bool rv = send_mail(header, message_str, to_address, from_address);
+        bool rv = send(header, message_str, to_address, from_address);
         if(rv) return TRUE;
         return FALSE;
 }
 
-void init_mail(const std::string& hostname, apr_pool_t* pool)
+// static
+void LLMail::init(const std::string& hostname, apr_pool_t* pool)
 {
         gMailSocket = NULL;
         if(hostname.empty() || !pool)
@@ -157,12 +163,14 @@ void init_mail(const std::string& hostname, apr_pool_t* pool)
         }
 }
 
-void enable_mail(bool mail_enabled)
+// static
+void LLMail::enable(bool mail_enabled)
 {
         gMailEnabled = mail_enabled;
 }
 
-std::string build_smtp_transaction(
+// static
+std::string LLMail::buildSMTPTransaction(
         const char* from_name,
         const char* from_address,
         const char* to_name,
@@ -216,7 +224,8 @@ std::string build_smtp_transaction(
         return header.str();
 }
 
-bool send_mail(
+// static
+bool LLMail::send(
         const std::string& header,
         const std::string& message,
         const char* from_address,
@@ -309,3 +318,40 @@ bool send_mail(
 #endif
         return true;
 }
+
+
+// static
+std::string LLMail::encryptIMEmailAddress(const LLUUID& from_agent_id,
+                                                                                        const LLUUID& to_agent_id,
+                                                                                        U32 time,
+                                                                                        const U8* secret,
+                                                                                        size_t secret_size)
+{
+#if LL_WINDOWS
+        return "blowfish-not-supported-on-windows";
+#else
+        size_t data_size = 4 + UUID_BYTES + UUID_BYTES;
+        // Convert input data into a binary blob
+        std::vector<U8> data;
+        data.resize(data_size);
+        // *NOTE: This may suffer from endian issues.  Could be htonmemcpy.
+        memcpy(&data[0], &time, 4);
+        memcpy(&data[4], &from_agent_id.mData[0], UUID_BYTES);
+        memcpy(&data[4 + UUID_BYTES], &to_agent_id.mData[0], UUID_BYTES);
+        
+        // Encrypt the blob
+        LLBlowfishCipher cipher(secret, secret_size);
+        size_t encrypted_size = cipher.requiredEncryptionSpace(data.size());
+        U8* encrypted = new U8[encrypted_size];
+        cipher.encrypt(&data[0], data_size, encrypted, encrypted_size);
+
+        std::string address = LLBase32::encode(encrypted, encrypted_size);
+
+        // Make it more pretty for humans.
+        LLString::toLower(address);
+
+        delete [] encrypted;
+
+        return address;
+#endif
+}
diff --git a/linden/indra/llmessage/llmail.h b/linden/indra/llmessage/llmail.h
index 82c272f..b1dc3b5 100644
--- a/linden/indra/llmessage/llmail.h
+++ b/linden/indra/llmessage/llmail.h
@@ -30,55 +30,84 @@
 
 typedef struct apr_pool_t apr_pool_t;
 
-// if hostname is NULL, then the host is resolved as 'mail'
-void init_mail(const std::string& hostname, apr_pool_t* pool);
+class LLUUID;
 
-// Allow all email transmission to be disabled/enabled.
-void enable_mail(bool mail_enabled);
+class LLMail
+{
+public:
+        // if hostname is NULL, then the host is resolved as 'mail'
+        static void init(const std::string& hostname, apr_pool_t* pool);
 
-// returns TRUE if the call succeeds, FALSE otherwise.
-//
-// Results in:
-// From: "from_name" <from_address>
-// To:   "to_name" <to_address>
-// Subject: subject
-// message
-BOOL send_mail(const char* from_name, const char* from_address,
-                           const char* to_name, const char* to_address,
-                           const char* subject, const char* message);
+        // Allow all email transmission to be disabled/enabled.
+        static void enable(bool mail_enabled);
 
-/**
- * @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.
- */
-std::string build_smtp_transaction(
-        const char* from_name,
-        const char* from_address,
-        const char* to_name,
-        const char* to_address,
-        const char* subject);
+        // 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 with header and body.
- *
- * @param header The email header. Use build_mail_header().
- * @param message The unescaped email message.
- * @param from_address Used for debugging
- * @param to_address Used for debugging
- * @return Returns true if the message could be sent.
- */
-bool send_mail(
-        const std::string& header,
-        const std::string& message,
-        const char* from_address,
-        const char* to_address);
+        /**
+        * @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.
+        */
+        static std::string buildSMTPTransaction(
+                const char* from_name,
+                const char* from_address,
+                const char* to_name,
+                const char* to_address,
+                const char* subject);
+
+        /**
+        * @brief send an email with header and body.
+        *
+        * @param header The email header. Use build_mail_header().
+        * @param message The unescaped email message.
+        * @param from_address Used for debugging
+        * @param to_address Used for debugging
+        * @return Returns true if the message could be sent.
+        */
+        static bool send(
+                const std::string& header,
+                const std::string& message,
+                const char* from_address,
+                const char* to_address);
+
+        // IM-to-email sessions use a "session id" based on an encrypted
+        // combination of from agent_id, to agent_id, and timestamp.  When
+        // a user replies to an email we use the from_id to determine the
+        // sender's name and the to_id to route the message.  The address
+        // is encrypted to prevent users from building addresses to spoof
+        // IMs from other users.  The timestamps allow the "sessions" to 
+        // expire, in case one of the sessions is stolen/hijacked.
+        //
+        // indra/tools/mailglue is responsible for parsing the inbound mail.
+        //
+        // secret: binary blob passed to blowfish, max length 56 bytes
+        // secret_size: length of blob, in bytes
+        //
+        // Returns: "base64" encoded email local-part, with _ and - as the
+        // non-alphanumeric characters.  This allows better compatibility
+        // with email systems than the default / and + extra chars.  JC
+        static std::string encryptIMEmailAddress(
+                const LLUUID& from_agent_id,
+                const LLUUID& to_agent_id,
+                U32 time,
+                const U8* secret,
+                size_t secret_size);
+};
 
 extern const size_t LL_MAX_KNOWN_GOOD_MAIL_SIZE;
 
diff --git a/linden/indra/llmessage/llmessage.vcproj b/linden/indra/llmessage/llmessage.vcproj
index 3043ee5..11f4dbf 100644
--- a/linden/indra/llmessage/llmessage.vcproj
+++ b/linden/indra/llmessage/llmessage.vcproj
@@ -153,6 +153,9 @@
                                 RelativePath=".\llassetstorage.cpp">
                         </File>
                         <File
+                                RelativePath=".\llblowfishcipher.cpp">
+                        </File>
+                        <File
                                 RelativePath=".\llbuffer.cpp">
                         </File>
                         <File
@@ -171,6 +174,9 @@
                                 RelativePath=".\llclassifiedflags.cpp">
                         </File>
                         <File
+                                RelativePath=".\llcurl.cpp">
+                        </File>
+                        <File
                                 RelativePath=".\lldatapacker.cpp">
                         </File>
                         <File
@@ -344,6 +350,9 @@
                                 RelativePath=".\llassetstorage.h">
                         </File>
                         <File
+                                RelativePath=".\llblowfishcipher.h">
+                        </File>
+                        <File
                                 RelativePath=".\llbuffer.h">
                         </File>
                         <File
@@ -362,6 +371,9 @@
                                 RelativePath=".\llchainio.h">
                         </File>
                         <File
+                                RelativePath=".\llcipher.h">
+                        </File>
+                        <File
                                 RelativePath=".\llcircuit.h">
                         </File>
                         <File
@@ -371,7 +383,7 @@
                                 RelativePath=".\llcoordframe.h">
                         </File>
                         <File
-                                RelativePath=".\llcrypto.h">
+                                RelativePath=".\llcurl.h">
                         </File>
                         <File
                                 RelativePath=".\lldatapacker.h">
@@ -440,6 +452,9 @@
                                 RelativePath=".\llnamevalue.h">
                         </File>
                         <File
+                                RelativePath=".\llnullcipher.h">
+                        </File>
+                        <File
                                 RelativePath=".\llpacketack.h">
                         </File>
                         <File
@@ -530,6 +545,9 @@
                                 RelativePath=".\llxfermanager.h">
                         </File>
                         <File
+                                RelativePath=".\llxorcipher.h">
+                        </File>
+                        <File
                                 RelativePath=".\machine.h">
                         </File>
                         <File
diff --git a/linden/indra/llmessage/llmessage_vc8.vcproj b/linden/indra/llmessage/llmessage_vc8.vcproj
new file mode 100644
index 0000000..ac32525
--- /dev/null
+++ b/linden/indra/llmessage/llmessage_vc8.vcproj
@@ -0,0 +1,843 @@
+<?xml version="1.0" encoding="Windows-1252"?>

+<VisualStudioProject

+        ProjectType="Visual C++"

+        Version="8.00"

+        Name="llmessage"

+        ProjectGUID="{E5D94794-5671-4BD6-A16D-26EC18F3DB34}"

+        RootNamespace="llmessage"

+        Keyword="Win32Proj"

+        >

+        <Platforms>

+                <Platform

+                        Name="Win32"

+                />

+        </Platforms>

+        <ToolFiles>

+        </ToolFiles>

+        <Configurations>

+                <Configuration

+                        Name="Debug|Win32"

+                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"

+                        IntermediateDirectory="Debug"

+                        ConfigurationType="4"

+                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"

+                        CharacterSet="1"

+                        >

+                        <Tool

+                                Name="VCPreBuildEventTool"

+                        />

+                        <Tool

+                                Name="VCCustomBuildTool"

+                        />

+                        <Tool

+                                Name="VCXMLDataGeneratorTool"

+                        />

+                        <Tool

+                                Name="VCWebServiceProxyGeneratorTool"

+                        />

+                        <Tool

+                                Name="VCMIDLTool"

+                        />

+                        <Tool

+                                Name="VCCLCompilerTool"

+                                Optimization="0"

+                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\..\libraries\i686-win32\include;..\..\libraries\include\"

+                                PreprocessorDefinitions="WIN32;_DEBUG;_LIB;LL_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_USE_32BIT_TIME_T;LL_DEBUG"

+                                MinimalRebuild="true"

+                                BasicRuntimeChecks="3"

+                                RuntimeLibrary="1"

+                                StructMemberAlignment="4"

+                                TreatWChar_tAsBuiltInType="false"

+                                ForceConformanceInForLoopScope="true"

+                                UsePrecompiledHeader="0"

+                                WarningLevel="3"

+                                WarnAsError="true"

+                                Detect64BitPortabilityProblems="false"

+                                DebugInformationFormat="4"

+                        />

+                        <Tool

+                                Name="VCManagedResourceCompilerTool"

+                        />

+                        <Tool

+                                Name="VCResourceCompilerTool"

+                        />

+                        <Tool

+                                Name="VCPreLinkEventTool"

+                        />

+                        <Tool

+                                Name="VCLibrarianTool"

+                                OutputFile="$(OutDir)/llmessage.lib"

+                        />

+                        <Tool

+                                Name="VCALinkTool"

+                        />

+                        <Tool

+                                Name="VCXDCMakeTool"

+                        />

+                        <Tool

+                                Name="VCBscMakeTool"

+                        />

+                        <Tool

+                                Name="VCFxCopTool"

+                        />

+                        <Tool

+                                Name="VCPostBuildEventTool"

+                        />

+                </Configuration>

+                <Configuration

+                        Name="Release|Win32"

+                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"

+                        IntermediateDirectory="Release"

+                        ConfigurationType="4"

+                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"

+                        CharacterSet="1"

+                        >

+                        <Tool

+                                Name="VCPreBuildEventTool"

+                        />

+                        <Tool

+                                Name="VCCustomBuildTool"

+                        />

+                        <Tool

+                                Name="VCXMLDataGeneratorTool"

+                        />

+                        <Tool

+                                Name="VCWebServiceProxyGeneratorTool"

+                        />

+                        <Tool

+                                Name="VCMIDLTool"

+                        />

+                        <Tool

+                                Name="VCCLCompilerTool"

+                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\..\libraries\i686-win32\include;..\..\libraries\include\"

+                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;LL_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_USE_32BIT_TIME_T;LL_RELEASE"

+                                RuntimeLibrary="0"

+                                StructMemberAlignment="0"

+                                TreatWChar_tAsBuiltInType="false"

+                                ForceConformanceInForLoopScope="true"

+                                UsePrecompiledHeader="0"

+                                WarningLevel="3"

+                                WarnAsError="true"

+                                Detect64BitPortabilityProblems="false"

+                                DebugInformationFormat="3"

+                        />

+                        <Tool

+                                Name="VCManagedResourceCompilerTool"

+                        />

+                        <Tool

+                                Name="VCResourceCompilerTool"

+                        />

+                        <Tool

+                                Name="VCPreLinkEventTool"

+                        />

+                        <Tool

+                                Name="VCLibrarianTool"

+                                OutputFile="$(OutDir)/llmessage.lib"

+                        />

+                        <Tool

+                                Name="VCALinkTool"

+                        />

+                        <Tool

+                                Name="VCXDCMakeTool"

+                        />

+                        <Tool

+                                Name="VCBscMakeTool"

+                        />

+                        <Tool

+                                Name="VCFxCopTool"

+                        />

+                        <Tool

+                                Name="VCPostBuildEventTool"

+                        />

+                </Configuration>

+                <Configuration

+                        Name="ReleaseNoOpt|Win32"

+                        OutputDirectory="../lib_$(ConfigurationName)/i686-win32"

+                        IntermediateDirectory="$(ConfigurationName)"

+                        ConfigurationType="4"

+                        InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"

+                        CharacterSet="1"

+                        >

+                        <Tool

+                                Name="VCPreBuildEventTool"

+                        />

+                        <Tool

+                                Name="VCCustomBuildTool"

+                        />

+                        <Tool

+                                Name="VCXMLDataGeneratorTool"

+                        />

+                        <Tool

+                                Name="VCWebServiceProxyGeneratorTool"

+                        />

+                        <Tool

+                                Name="VCMIDLTool"

+                        />

+                        <Tool

+                                Name="VCCLCompilerTool"

+                                Optimization="0"

+                                AdditionalIncludeDirectories="..\llcommon;..\llmath;..\llvfs;..\..\libraries\i686-win32\include;..\..\libraries\include\"

+                                PreprocessorDefinitions="WIN32;NDEBUG;_LIB;LL_WINDOWS;_CRT_SECURE_NO_DEPRECATE;_CRT_NONSTDC_NO_DEPRECATE;_USE_32BIT_TIME_T;LL_RELEASE"

+                                RuntimeLibrary="0"

+                                StructMemberAlignment="0"

+                                TreatWChar_tAsBuiltInType="false"

+                                ForceConformanceInForLoopScope="true"

+                                UsePrecompiledHeader="0"

+                                WarningLevel="3"

+                                WarnAsError="true"

+                                Detect64BitPortabilityProblems="false"

+                                DebugInformationFormat="3"

+                        />

+                        <Tool

+                                Name="VCManagedResourceCompilerTool"

+                        />

+                        <Tool

+                                Name="VCResourceCompilerTool"

+                        />

+                        <Tool

+                                Name="VCPreLinkEventTool"

+                        />

+                        <Tool

+                                Name="VCLibrarianTool"

+                                OutputFile="$(OutDir)/llmessage.lib"

+                        />

+                        <Tool

+                                Name="VCALinkTool"

+                        />

+                        <Tool

+                                Name="VCXDCMakeTool"

+                        />

+                        <Tool

+                                Name="VCBscMakeTool"

+                        />

+                        <Tool

+                                Name="VCFxCopTool"

+                        />

+                        <Tool

+                                Name="VCPostBuildEventTool"

+                        />

+                </Configuration>

+        </Configurations>

+        <References>

+        </References>

+        <Files>

+                <Filter

+                        Name="Source Files"

+                        Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"

+                        UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"

+                        >

+                        <File

+                                RelativePath=".\llassetstorage.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llblowfishcipher.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llbuffer.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llbufferstream.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llcachename.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llchainio.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llcircuit.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llclassifiedflags.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llcurl.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lldatapacker.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lldispatcher.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llfiltersd2xmlrpc.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llhost.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llhttpassetstorage.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llhttpassetstorage.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llhttpclient.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llhttpnode.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llinstantmessage.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lliobuffer.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lliohttpserver.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lliopipe.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lliosocket.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llioutil.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lllogtextmessage.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llmail.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llmessagethrottle.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llmime.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llnamevalue.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llnullcipher.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llpacketbuffer.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llpacketring.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llpartdata.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llpumpio.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llsdappservices.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llsdhttpserver.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llsdmessagesystem.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llsdrpcclient.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llsdrpcserver.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llservice.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llthrottle.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lltransfermanager.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lltransfersourceasset.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lltransfersourcefile.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lltransfertargetfile.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lltransfertargetvfile.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llurlrequest.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lluseroperation.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxfer.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxfer_file.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxfer_mem.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxfer_vfile.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxfermanager.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxorcipher.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\message.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\message_prehash.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\message_string_table.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\net.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\network.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\partsyspacket.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\patch_code.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\patch_dct.cpp"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\patch_idct.cpp"

+                                >

+                        </File>

+                </Filter>

+                <Filter

+                        Name="Header Files"

+                        Filter="h;hpp;hxx;hm;inl;inc;xsd"

+                        UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"

+                        >

+                        <File

+                                RelativePath=".\camera.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\coordframe.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llassetstorage.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llblowfishcipher.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llbuffer.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llbufferstream.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llcachename.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llcallbacklisth.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llcamera.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llchainio.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llcipher.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llcircuit.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llclassifiedflags.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llcoordframe.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llcurl.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lldatapacker.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lldbstrings.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lldispatcher.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lleventflags.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llfiltersd2xmlrpc.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llfollowcamparams.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llhost.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llhttpclient.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llinstantmessage.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llinvite.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lliobuffer.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lliohttpserver.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lliopipe.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lliosocket.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llioutil.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llloginflags.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lllogtextmessage.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lllsltransmit.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llmail.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llmessagethrottle.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llmime.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llnamevalue.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llnullcipher.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llpacketack.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llpacketbuffer.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llpacketring.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llpartdata.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llpumpio.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llqueryflags.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llregionflags.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llregionhandle.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llsdappservices.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llsdhttpserver.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llsdmessagesystem.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llsdrpcclient.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llsdrpcserver.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llservice.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lltaskname.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llteleportflags.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llthrottle.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lltransfermanager.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lltransfersourceasset.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lltransfersourcefile.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lltransfertargetfile.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lltransfertargetvfile.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llurlrequest.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\lluseroperation.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llvehicleparams.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxfer.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxfer_file.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxfer_mem.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxfer_vfile.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxfermanager.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\llxorcipher.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\machine.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\mean_collision_data.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\message.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\message_prehash.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\net.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\network.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\partsyspacket.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\patch_code.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\patch_dct.h"

+                                >

+                        </File>

+                        <File

+                                RelativePath=".\sound_ids.h"

+                                >

+                        </File>

+                </Filter>

+                <Filter

+                        Name="Resource Files"

+                        Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"

+                        UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"

+                        >

+                </Filter>

+                <File

+                        RelativePath="..\..\scripts\messages\message_template.msg"

+                        >

+                        <FileConfiguration

+                                Name="Debug|Win32"

+                                >

+                                <Tool

+                                        Name="VCCustomBuildTool"

+                                        Description=""

+                                        CommandLine=""

+                                        Outputs=""

+                                />

+                        </FileConfiguration>

+                        <FileConfiguration

+                                Name="Release|Win32"

+                                >

+                                <Tool

+                                        Name="VCCustomBuildTool"

+                                        Description=""

+                                        CommandLine=""

+                                        Outputs=""

+                                />

+                        </FileConfiguration>

+                        <FileConfiguration

+                                Name="ReleaseNoOpt|Win32"

+                                >

+                                <Tool

+                                        Name="VCCustomBuildTool"

+                                        Description=""

+                                        CommandLine=""

+                                        Outputs=""

+                                />

+                        </FileConfiguration>

+                </File>

+        </Files>

+        <Globals>

+        </Globals>

+</VisualStudioProject>

diff --git a/linden/indra/llmessage/llnamevalue.cpp b/linden/indra/llmessage/llnamevalue.cpp
index 0b4f0b6..1304923 100644
--- a/linden/indra/llmessage/llnamevalue.cpp
+++ b/linden/indra/llmessage/llnamevalue.cpp
@@ -59,7 +59,7 @@ user_callback_map_t gUserCallbackMap;
 
 LLStringTable   gNVNameTable(16384);
 
-char NameValueTypeStrings[NVT_EOF][NAME_VALUE_TYPE_STRING_LENGTH] =
+char NameValueTypeStrings[NVT_EOF][NAME_VALUE_TYPE_STRING_LENGTH] = /*Flawfinder: Ignore*/
 {
         "NULL",
         "STRING",
@@ -70,17 +70,17 @@ char NameValueTypeStrings[NVT_EOF][NAME_VALUE_TYPE_STRING_LENGTH] =
         "CAMERA", // Deprecated, but leaving in case removing completely would cause problems
         "ASSET",
         "U64"
-};              /*Flawfinder: Ignore*/
+};              
 
-char NameValueClassStrings[NVC_EOF][NAME_VALUE_CLASS_STRING_LENGTH] =
+char NameValueClassStrings[NVC_EOF][NAME_VALUE_CLASS_STRING_LENGTH] = /*Flawfinder: Ignore*/
 {
         "NULL",
         "R",                    // read only
         "RW",                   // read write
         "CB"                    // callback
-};              /*Flawfinder: Ignore*/
+};              
 
-char NameValueSendtoStrings[NVS_EOF][NAME_VALUE_SENDTO_STRING_LENGTH] =
+char NameValueSendtoStrings[NVS_EOF][NAME_VALUE_SENDTO_STRING_LENGTH] = /*Flawfinder: Ignore*/
 {
         "NULL",
         "S",    // "Sim", formerly SIM
@@ -412,11 +412,11 @@ LLNameValue::LLNameValue(const char *name, const char *type, const char *nvclass
 LLNameValue::LLNameValue(const char *data)
 {
         baseInit();
-        static char name[NV_BUFFER_LEN];
-        static char type[NV_BUFFER_LEN];
-        static char nvclass[NV_BUFFER_LEN];
-        static char nvsendto[NV_BUFFER_LEN];
-        static char nvdata[NV_BUFFER_LEN];
+        static char name[NV_BUFFER_LEN];        /*Flawfinder: ignore*/
+        static char type[NV_BUFFER_LEN];        /*Flawfinder: ignore*/
+        static char nvclass[NV_BUFFER_LEN];     /*Flawfinder: ignore*/
+        static char nvsendto[NV_BUFFER_LEN];    /*Flawfinder: ignore*/
+        static char nvdata[NV_BUFFER_LEN];      /*Flawfinder: ignore*/
 
         S32 i;
 
@@ -440,7 +440,7 @@ LLNameValue::LLNameValue(const char *data)
         }
 
         // read in the name
-        sscanf((data + character_count), "%2047s", name);
+        sscanf((data + character_count), "%2047s", name);       /*Flawfinder: ignore*/
 
         // bump past it and add null terminator
         length = (S32)strlen(name);                     /* Flawfinder: ignore */
@@ -464,7 +464,7 @@ LLNameValue::LLNameValue(const char *data)
         }
 
         // read in the type
-        sscanf((data + character_count), "%2047s", type);
+        sscanf((data + character_count), "%2047s", type);       /*Flawfinder: ignore*/
 
         // bump past it and add null terminator
         length = (S32)strlen(type);             /* Flawfinder: ignore */
@@ -500,7 +500,7 @@ LLNameValue::LLNameValue(const char *data)
         {
                 // yes we do!
                 // read in the class
-                sscanf((data + character_count), "%2047s", nvclass);
+                sscanf((data + character_count), "%2047s", nvclass);    /*Flawfinder: ignore*/
 
                 // bump past it and add null terminator
                 length = (S32)strlen(nvclass);          /* Flawfinder: ignore */
@@ -542,7 +542,7 @@ LLNameValue::LLNameValue(const char *data)
         if (i != NVS_EOF)
         {
                 // found a sendto argument
-                sscanf((data + character_count), "%2047s", nvsendto);
+                sscanf((data + character_count), "%2047s", nvsendto);   /*Flawfinder: ignore*/
 
                 // add null terminator
                 length = (S32)strlen(nvsendto);         /* Flawfinder: ignore */
diff --git a/linden/indra/llmessage/llnullcipher.cpp b/linden/indra/llmessage/llnullcipher.cpp
index 1b60e44..ad2b25f 100644
--- a/linden/indra/llmessage/llnullcipher.cpp
+++ b/linden/indra/llmessage/llnullcipher.cpp
@@ -27,33 +27,33 @@
 
 #include "linden_common.h"
 
-#include "llcrypto.h"
+#include "llnullcipher.h"
 
 ///----------------------------------------------------------------------------
 /// Class LLNullCipher
 ///----------------------------------------------------------------------------
 
-BOOL LLNullCipher::encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
+U32  LLNullCipher::encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
 {
         if((src_len == dst_len) && src && dst)
         {
                 memmove(dst, src, src_len);
-                return TRUE;
+                return src_len;
         }
-        return FALSE;
+        return 0;
 }
 
-BOOL LLNullCipher::decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
+U32 LLNullCipher::decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
 {
         if((src_len == dst_len) && src && dst)
         {
                 memmove(dst, src, src_len);
-                return TRUE;
+                return src_len;
         }
-        return FALSE;
+        return 0;
 }
 
-U32 LLNullCipher::requiredEncryptionSpace(U32 len)
+U32 LLNullCipher::requiredEncryptionSpace(U32 len) const
 {
         return len;
 }
diff --git a/linden/indra/llmessage/llnullcipher.h b/linden/indra/llmessage/llnullcipher.h
new file mode 100644
index 0000000..75d022d
--- /dev/null
+++ b/linden/indra/llmessage/llnullcipher.h
@@ -0,0 +1,49 @@
+/** 
+ * @file llnullcipher.h
+ *
+ * Copyright (c) 2003-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LLNULLCIPHER_H
+#define LLNULLCIPHER_H
+
+#include "llcipher.h"
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// Class LLNullCipher
+//
+// A class which implements LLCipher, but does not transform src
+// during encryption.
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+class LLNullCipher : public LLCipher
+{
+public:
+        LLNullCipher() {}
+        virtual ~LLNullCipher() {}
+        virtual U32 encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len);
+        virtual U32 decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len);
+        virtual U32 requiredEncryptionSpace(U32 src_len) const;
+};
+
+#endif
diff --git a/linden/indra/llmessage/llpacketack.h b/linden/indra/llmessage/llpacketack.h
index d7d960e..e8d598a 100644
--- a/linden/indra/llmessage/llpacketack.h
+++ b/linden/indra/llmessage/llpacketack.h
@@ -130,7 +130,7 @@ public:
                         mBuffer = new U8[buf_len];
                         if (mBuffer != NULL)
                         {
-                                memcpy(mBuffer,buf_ptr,buf_len);
+                                memcpy(mBuffer,buf_ptr,buf_len);        /*Flawfinder: ignore*/
                                 mBufferLength = buf_len;
                         }
                         
diff --git a/linden/indra/llmessage/llpacketbuffer.cpp b/linden/indra/llmessage/llpacketbuffer.cpp
index 3559ecb..855fb40 100644
--- a/linden/indra/llmessage/llpacketbuffer.cpp
+++ b/linden/indra/llmessage/llpacketbuffer.cpp
@@ -44,7 +44,7 @@ LLPacketBuffer::LLPacketBuffer(const LLHost &host, const char *datap, const S32
 
         if (datap != NULL)
         {
-                memcpy(mData, datap, size);
+                memcpy(mData, datap, size);     /*Flawfinder: ignore*/
                 mSize = size;
         }
         
diff --git a/linden/indra/llmessage/llpacketring.cpp b/linden/indra/llmessage/llpacketring.cpp
index 6a6a456..a2e6eb9 100644
--- a/linden/indra/llmessage/llpacketring.cpp
+++ b/linden/indra/llmessage/llpacketring.cpp
@@ -132,7 +132,7 @@ S32 LLPacketRing::receiveFromRing (S32 socket, char *datap)
         packet_size = packetp->getSize();
         if (packetp->getData() != NULL)
         {
-                memcpy(datap, packetp->getData(), packet_size);
+                memcpy(datap, packetp->getData(), packet_size); /*Flawfinder: ignore*/
         }
         // need to set sender IP/port!!
         mLastSender = packetp->getHost();
diff --git a/linden/indra/llmessage/llpartdata.cpp b/linden/indra/llmessage/llpartdata.cpp
index 11969d0..de0cb13 100644
--- a/linden/indra/llmessage/llpartdata.cpp
+++ b/linden/indra/llmessage/llpartdata.cpp
@@ -231,6 +231,20 @@ BOOL LLPartSysData::unpack(LLDataPacker &dp)
         return TRUE;
 }
 
+std::ostream& operator<<(std::ostream& s, const LLPartSysData &data)
+{
+        s << "Flags: " << std::hex << data.mFlags;
+        s << " Pattern: " << std::hex << (U32) data.mPattern << "\n";
+        s << "Age: [" << data.mStartAge << ", " << data.mMaxAge << "]\n";
+        s << "Angle: [" << data.mInnerAngle << ", " << data.mOuterAngle << "]\n";
+        s << "Burst Rate: " << data.mBurstRate << "\n";
+        s << "Burst Radius: " << data.mBurstRadius << "\n";
+        s << "Burst Speed: [" << data.mBurstSpeedMin << ", " << data.mBurstSpeedMax << "]\n";
+        s << "Burst Part Count: " << std::hex << (U32) data.mBurstPartCount << "\n";
+        s << "Angular Velocity: " << data.mAngularVelocity << "\n";
+        s << "Accel: " << data.mPartAccel;
+        return s;
+}
 
 BOOL LLPartSysData::isNullPS(const S32 block_num)
 {
diff --git a/linden/indra/llmessage/llpartdata.h b/linden/indra/llmessage/llpartdata.h
index 4045ada..55d22d5 100644
--- a/linden/indra/llmessage/llpartdata.h
+++ b/linden/indra/llmessage/llpartdata.h
@@ -186,6 +186,9 @@ public:
         // a combination of multiple parameters, we
         // need to clamp it using a separate method instead of an accessor.
         void clampSourceParticleRate();
+        
+        friend std::ostream&     operator<<(std::ostream& s, const LLPartSysData &data);                // Stream a
+        
 public:
         // Public because I'm lazy....
 
diff --git a/linden/indra/llmessage/llpumpio.cpp b/linden/indra/llmessage/llpumpio.cpp
index b1495f6..c1f1821 100644
--- a/linden/indra/llmessage/llpumpio.cpp
+++ b/linden/indra/llmessage/llpumpio.cpp
@@ -887,7 +887,7 @@ void LLPumpIO::processChain(LLChainInfo& chain)
                         PUMP_DEBUG;
                         if(LLIOPipe::isError(status))
                         {
-                                llinfos << "Pump generated pipe error: '"
+                                llinfos << "Pump generated pipe err: '"
 #if LL_DEBUG_PIPE_TYPE_IN_PUMP
                                                 << typeid(*((*it).mPipe)).name() << "':'"
 #endif
diff --git a/linden/indra/llmessage/llsdappservices.cpp b/linden/indra/llmessage/llsdappservices.cpp
index d923b22..8574f87 100644
--- a/linden/indra/llmessage/llsdappservices.cpp
+++ b/linden/indra/llmessage/llsdappservices.cpp
@@ -261,7 +261,7 @@ public:
                 llinfos << "LLHTTPLiveConfigSingleService::validate(" << name
                         << ")" << llendl;
                 LLSD option = LLApp::instance()->getOption(name);
-                if(option) return true;
+                if(option.isDefined()) return true;
                 else return false;
         }
 
diff --git a/linden/indra/llmessage/llsdmessagesystem.cpp b/linden/indra/llmessage/llsdmessagesystem.cpp
index 7d508f0..66382ea 100644
--- a/linden/indra/llmessage/llsdmessagesystem.cpp
+++ b/linden/indra/llmessage/llsdmessagesystem.cpp
@@ -25,6 +25,7 @@
  * COMPLETENESS OR PERFORMANCE.
  */
 
+#include "linden_common.h"
 #include "llsdmessagesystem.h"
 
 #include "llhttpnode.h"
@@ -98,7 +99,7 @@ void LLSDMessageSystem::getStringFast(const char *block, const char *var, S32 bu
         std::string data = getLLSD(mInput, block, var, blocknum).asString();
         S32 length = data.length();
         memset(buffer, 0, buffer_size);
-        strncpy(buffer, data.c_str(), llmin(length, buffer_size));
+        strncpy(buffer, data.c_str(), llmin(length, buffer_size));      /* Flawfinder: ignore */
 }
 
 //virtual 
diff --git a/linden/indra/llmessage/lltransfermanager.cpp b/linden/indra/llmessage/lltransfermanager.cpp
index bfeedd0..43afa78 100644
--- a/linden/indra/llmessage/lltransfermanager.cpp
+++ b/linden/indra/llmessage/lltransfermanager.cpp
@@ -354,7 +354,7 @@ void LLTransferManager::processTransferInfo(LLMessageSystem *msgp, void **)
                 {
                         // Perhaps this stuff should be inside a method in LLTransferPacket?
                         // I'm too lazy to do it now, though.
-                        llinfos << "Playing back delayed packet " << packet_id << llendl;
+//                      llinfos << "Playing back delayed packet " << packet_id << llendl;
                         LLTransferPacket *packetp = ttp->mDelayedPacketMap[packet_id];
 
                         // This is somewhat inefficient, but avoids us having to duplicate
@@ -365,7 +365,7 @@ void LLTransferManager::processTransferInfo(LLMessageSystem *msgp, void **)
                         {
                                 if ((packetp->mDatap != NULL) && (size<(S32)sizeof(tmp_data)))
                                 {
-                                        memcpy(tmp_data, packetp->mDatap, size);
+                                        memcpy(tmp_data, packetp->mDatap, size);        /*Flawfinder: ignore*/
                                 }
                         }
                         status = packetp->mStatus;
@@ -474,6 +474,8 @@ void LLTransferManager::processTransferPacket(LLMessageSystem *msgp, void **)
                         ttcp->deleteTransfer(ttp);
                         return;
                 }
+#if 0
+                // Spammy!
                 const S32 LL_TRANSFER_WARN_GAP = 10;
                 if(!ttp->gotInfo())
                 {
@@ -487,6 +489,7 @@ void LLTransferManager::processTransferPacket(LLMessageSystem *msgp, void **)
                                 << " from " << msgp->getSender() << ", got " << packet_id
                                 << " expecting " << ttp->getNextPacketID() << llendl;
                 }
+#endif
                 return;
         }
 
@@ -527,7 +530,7 @@ void LLTransferManager::processTransferPacket(LLMessageSystem *msgp, void **)
                 {
                         // Perhaps this stuff should be inside a method in LLTransferPacket?
                         // I'm too lazy to do it now, though.
-                        llinfos << "Playing back delayed packet " << packet_id << llendl;
+//                      llinfos << "Playing back delayed packet " << packet_id << llendl;
                         LLTransferPacket *packetp = ttp->mDelayedPacketMap[packet_id];
 
                         // This is somewhat inefficient, but avoids us having to duplicate
@@ -538,7 +541,7 @@ void LLTransferManager::processTransferPacket(LLMessageSystem *msgp, void **)
                         {
                                 if ((packetp->mDatap != NULL) && (size<(S32)sizeof(tmp_data)))
                                 {
-                                        memcpy(tmp_data, packetp->mDatap, size);
+                                        memcpy(tmp_data, packetp->mDatap, size);        /*Flawfinder: ignore*/
                                 }
                         }
                         status = packetp->mStatus;
@@ -738,8 +741,11 @@ LLTransferSourceChannel::LLTransferSourceChannel(const LLTransferChannelType cha
 
 LLTransferSourceChannel::~LLTransferSourceChannel()
 {
-        LLPriQueueMap<LLTransferSource *>::pqm_iter iter;
-        for (iter = mTransferSources.mMap.begin(); iter != mTransferSources.mMap.end(); iter++)
+        LLPriQueueMap<LLTransferSource*>::pqm_iter iter =
+                mTransferSources.mMap.begin();
+        LLPriQueueMap<LLTransferSource*>::pqm_iter end =
+                mTransferSources.mMap.end();
+        for (; iter != end; ++iter)
         {
                 // Just kill off all of the transfers
                 (*iter).second->abortTransfer();
@@ -1176,7 +1182,7 @@ LLTransferPacket::LLTransferPacket(const S32 packet_id, const LLTSCode status, c
         mDatap = new U8[size];
         if (mDatap != NULL)
         {
-                memcpy(mDatap, datap, size);
+                memcpy(mDatap, datap, size);    /*Flawfinder: ignore*/
         }
 }
 
diff --git a/linden/indra/llmessage/lltransfertargetvfile.cpp b/linden/indra/llmessage/lltransfertargetvfile.cpp
index ce21605..5a1acf3 100644
--- a/linden/indra/llmessage/lltransfertargetvfile.cpp
+++ b/linden/indra/llmessage/lltransfertargetvfile.cpp
@@ -34,33 +34,8 @@
 #include "llvfile.h"
 
 //static
-std::list<LLTransferTargetParamsVFile*> LLTransferTargetVFile::sCallbackQueue;
-
-//static
 void LLTransferTargetVFile::updateQueue(bool shutdown)
 {
-        for(std::list<LLTransferTargetParamsVFile*>::iterator iter = sCallbackQueue.begin();
-                iter != sCallbackQueue.end(); )
-        {
-                std::list<LLTransferTargetParamsVFile*>::iterator curiter = iter++;
-                LLTransferTargetParamsVFile* params = *curiter;
-                LLVFSThread::status_t s = LLVFile::getVFSThread()->getRequestStatus(params->mHandle);
-                if (s == LLVFSThread::STATUS_COMPLETE || s == LLVFSThread::STATUS_EXPIRED)
-                {
-                        params->mCompleteCallback(
-                                params->mErrCode,
-                                params->getAssetID(),
-                                params->getAssetType(),
-                                params->mUserDatap);
-                        delete params;
-                        iter = sCallbackQueue.erase(curiter);
-                }
-                else if (shutdown)
-                {
-                        delete params;
-                        iter = sCallbackQueue.erase(curiter);
-                }
-        }
 }
 
 
@@ -69,8 +44,7 @@ LLTransferTargetParamsVFile::LLTransferTargetParamsVFile() :
         mAssetType(LLAssetType::AT_NONE),
         mCompleteCallback(NULL),
         mUserDatap(NULL),
-        mErrCode(0),
-        mHandle(LLVFSThread::nullHandle())
+        mErrCode(0)
 {
 }
 
@@ -185,7 +159,6 @@ void LLTransferTargetVFile::completionCallback(const LLTSCode status)
                 llwarns << "Aborting vfile transfer after asset storage shut down!" << llendl;
                 return;
         }
-        LLVFSThread::handle_t handle = LLVFSThread::nullHandle();
         
         // Still need to gracefully handle error conditions.
         S32 err_code = 0;
@@ -194,11 +167,11 @@ void LLTransferTargetVFile::completionCallback(const LLTSCode status)
           case LLTS_DONE:
                 if (!mNeedsCreate)
                 {
-                        handle = LLVFile::getVFSThread()->rename(
-                                gAssetStorage->mVFS,
-                                mTempID, mParams.getAssetType(),
-                                mParams.getAssetID(), mParams.getAssetType(),
-                                LLVFSThread::AUTO_DELETE);
+                        LLVFile file(gAssetStorage->mVFS, mTempID, mParams.getAssetType(), LLVFile::WRITE);
+                        if (!file.rename(mParams.getAssetID(), mParams.getAssetType()))
+                        {
+                                llerrs << "LLTransferTargetVFile: rename failed" << llendl;
+                        }
                 }
                 err_code = LL_ERR_NOERR;
                 lldebugs << "LLTransferTargetVFile::completionCallback for "
@@ -238,20 +211,9 @@ void LLTransferTargetVFile::completionCallback(const LLTSCode status)
         }
         if (mParams.mCompleteCallback)
         {
-                if (handle != LLVFSThread::nullHandle())
-                {
-                        LLTransferTargetParamsVFile* params = new LLTransferTargetParamsVFile(mParams);
-                        params->mErrCode = err_code;
-                        params->mHandle = handle;
-                        sCallbackQueue.push_back(params);
-                }
-                else
-                {
-                        mParams.mCompleteCallback(
-                                err_code,
-                                mParams.getAssetID(),
-                                mParams.getAssetType(),
-                                mParams.mUserDatap);
-                }
+                mParams.mCompleteCallback(err_code,
+                                                                  mParams.getAssetID(),
+                                                                  mParams.getAssetType(),
+                                                                  mParams.mUserDatap);
         }
 }
diff --git a/linden/indra/llmessage/lltransfertargetvfile.h b/linden/indra/llmessage/lltransfertargetvfile.h
index a4b6f93..4c915dc 100644
--- a/linden/indra/llmessage/lltransfertargetvfile.h
+++ b/linden/indra/llmessage/lltransfertargetvfile.h
@@ -90,8 +90,6 @@ protected:
 
         BOOL mNeedsCreate;
         LLUUID mTempID;
-
-        static std::list<LLTransferTargetParamsVFile*> sCallbackQueue;
 };
 
 #endif // LL_LLTRANSFERTARGETFILE_H
diff --git a/linden/indra/llmessage/llxfer.cpp b/linden/indra/llmessage/llxfer.cpp
index f02d106..507b820 100644
--- a/linden/indra/llmessage/llxfer.cpp
+++ b/linden/indra/llmessage/llxfer.cpp
@@ -135,7 +135,7 @@ S32 LLXfer::receiveData (char *datap, S32 data_size)
         {
                 if (datap != NULL)
                 {
-                        memcpy(&mBuffer[mBufferLength],datap,data_size);
+                        memcpy(&mBuffer[mBufferLength],datap,data_size);        /*Flawfinder: ignore*/
                         mBufferLength += data_size;
                 }
                 else
@@ -212,7 +212,7 @@ void LLXfer::sendPacket(S32 packet_num)
                 num_copy = llmin(num_copy, (S32)(mBufferLength - desired_read_position));
                 if (num_copy > 0)
                 {
-                        memcpy(fdata_buf,&mBuffer[desired_read_position],num_copy);
+                        memcpy(fdata_buf,&mBuffer[desired_read_position],num_copy);     /*Flawfinder: ignore*/
                 }
         }
         else  
@@ -225,7 +225,7 @@ void LLXfer::sendPacket(S32 packet_num)
                         (S32)(mBufferLength - desired_read_position));
                 if (num_copy > 0)
                 {
-                        memcpy(
+                        memcpy( /*Flawfinder: ignore*/
                                 fdata_buf + sizeof(S32),
                                 &mBuffer[desired_read_position],
                                 num_copy);
diff --git a/linden/indra/llmessage/llxfer_file.cpp b/linden/indra/llmessage/llxfer_file.cpp
index 8d38644..2fec06b 100644
--- a/linden/indra/llmessage/llxfer_file.cpp
+++ b/linden/indra/llmessage/llxfer_file.cpp
@@ -413,8 +413,8 @@ U32 LLXfer_File::getXferTypeTag()
 S32 copy_file(const char* from, const char* to)
 {
         S32 rv = 0;
-        FILE* in = LLFile::fopen(from, "rb");
-        FILE* out = LLFile::fopen(to, "wb");
+        FILE* in = LLFile::fopen(from, "rb");   /*Flawfinder: ignore*/
+        FILE* out = LLFile::fopen(to, "wb");    /*Flawfinder: ignore*/
         if(in && out)
         {
                 S32 read = 0;
diff --git a/linden/indra/llmessage/llxorcipher.cpp b/linden/indra/llmessage/llxorcipher.cpp
index 7a72866..3c3f690 100644
--- a/linden/indra/llmessage/llxorcipher.cpp
+++ b/linden/indra/llmessage/llxorcipher.cpp
@@ -27,7 +27,8 @@
 
 #include "linden_common.h"
 
-#include "llcrypto.h"
+#include "llxorcipher.h"
+
 #include "llerror.h"
 
 ///----------------------------------------------------------------------------
@@ -63,25 +64,26 @@ LLXORCipher& LLXORCipher::operator=(const LLXORCipher& cipher)
         return *this;
 }
 
-BOOL LLXORCipher::encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
+U32 LLXORCipher::encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
 {
-        if(!src || !src_len || !dst || !dst_len || !mPad) return FALSE;
+        if(!src || !src_len || !dst || !dst_len || !mPad) return 0;
         U8* pad_end = mPad + mPadLen;
-        while(src_len--)
+        U32 count = src_len;
+        while(count--)
         {
                 *dst++ = *src++ ^ *mHead++;
                 if(mHead >= pad_end) mHead = mPad;
         }
-        return TRUE;
+        return src_len;
 }
 
-BOOL LLXORCipher::decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
+U32 LLXORCipher::decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len)
 {
         // xor is a symetric cipher, thus, just call the other function.
         return encrypt(src, src_len, dst, dst_len);
 }
 
-U32 LLXORCipher::requiredEncryptionSpace(U32 len)
+U32 LLXORCipher::requiredEncryptionSpace(U32 len) const
 {
         return len;
 }
diff --git a/linden/indra/llmessage/llcrypto.h b/linden/indra/llmessage/llxorcipher.h
index b142d25..fbb879e 100644
--- a/linden/indra/llmessage/llcrypto.h
+++ b/linden/indra/llmessage/llxorcipher.h
@@ -1,8 +1,5 @@
 /** 
- * @file llcrypto.h
- * @brief llcrypto library module header. For now, all crypto classes
- * are here, and as we grow the library, we can split these things
- * out.
+ * @file llxorcipher.h
  *
  * Copyright (c) 2003-2007, Linden Research, Inc.
  * 
@@ -27,50 +24,10 @@
  * COMPLETENESS OR PERFORMANCE.
  */
 
-#ifndef LL_LLCRYPTO_H
-#define LL_LLCRYPTO_H
+#ifndef LLXORCIPHER_H
+#define LLXORCIPHER_H
 
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// Class LLCipher
-//
-// Abstract base class for a cipher object.
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-class LLCipher
-{
-public:
-        virtual ~LLCipher() {}
-
-        // encrypt src and place result into dst. returns TRUE if
-        // encryption was successful, otherwise FALSE.
-        virtual BOOL encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len) = 0;
-
-        // decrypt src and place result into dst. returns TRUE if
-        // encryption was successful, otherwise FALSE. 
-        virtual BOOL decrpyt(const U8* src, U32 src_len, U8* dst, U32 dst_len) = 0;
-
-        // returns the space required to encrypt for a unencrypted source
-        // buffer of length len.
-        virtual U32 requiredEncryptionSpace(U32 src_len) const = 0 ;
-};
-
-
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-// Class LLNullCipher
-//
-// A class which implements LLCipher, but does not transform src
-// during encryption.
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-class LLNullCipher
-{
-public:
-        LLNullCipher() {}
-        virtual ~LLNullCipher() {}
-        virtual BOOL encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len);
-        virtual BOOL decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len);
-        virtual U32 requiredEncryptionSpace(U32 src_len);
-};
+#include "llcipher.h"
 
 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // Class LLXORCipher
@@ -78,7 +35,7 @@ public:
 // Implementation of LLCipher which encrypts using a XOR pad.
 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-class LLXORCipher
+class LLXORCipher : public LLCipher
 {
 public:
         LLXORCipher(const U8* pad, U32 pad_len);
@@ -87,9 +44,9 @@ public:
         LLXORCipher& operator=(const LLXORCipher& cipher);
 
         // Cipher functions
-        virtual BOOL encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len);
-        virtual BOOL decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len);
-        virtual U32 requiredEncryptionSpace(U32 src_len);
+        /*virtual*/ U32 encrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len);
+        /*virtual*/ U32 decrypt(const U8* src, U32 src_len, U8* dst, U32 dst_len);
+        /*virtual*/ U32 requiredEncryptionSpace(U32 src_len) const;
 
         // special syntactic-sugar since xor can be performed in place.
         BOOL encrypt(U8* buf, U32 len) { return encrypt((const U8*)buf, len, buf, len); }
@@ -108,4 +65,4 @@ protected:
         U32 mPadLen;
 };
 
-#endif // LL_LLCRYPTO_H
+#endif
diff --git a/linden/indra/llmessage/message.cpp b/linden/indra/llmessage/message.cpp
index 5baefff..2e7cb6a 100644
--- a/linden/indra/llmessage/message.cpp
+++ b/linden/indra/llmessage/message.cpp
@@ -987,7 +987,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
 
         LLMessageVariable       var;
         char                            var_name[MAX_MESSAGE_INTERNAL_NAME_SIZE];               /* Flawfinder: ignore */ 
-        char                            formatString[MAX_MESSAGE_INTERNAL_NAME_SIZE];
+        char                            formatString[MAX_MESSAGE_INTERNAL_NAME_SIZE];           /* Flawfinder: ignore */
 
         FILE* messagefilep = NULL;
         mMessageFileChecksum = 0;
@@ -995,14 +995,19 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
         S32 checksum_offset = 0;
         char* checkp = NULL;
 
-        snprintf(formatString, sizeof(formatString), "%%%ds", MAX_MESSAGE_INTERNAL_NAME_SIZE);
-        messagefilep = LLFile::fopen(filename, "r");
+        // scanf needs 1 byte more than width, thus the MAX_... -1.
+        snprintf(       /* Flawfinder: ignore */
+                formatString,
+                sizeof(formatString),
+                "%%%ds",
+                MAX_MESSAGE_INTERNAL_NAME_SIZE - 1);
+        messagefilep = LLFile::fopen(filename, "r");    /* Flawfinder: ignore */
         if (messagefilep)
         {
 //              mName = gMessageStringTable.getString(filename); 
 
                 fseek(messagefilep, 0L, SEEK_SET );
-                while(fscanf(messagefilep, formatString, token) != EOF)
+                while(fscanf(messagefilep, formatString, token) != EOF) /* Flawfinder: ignore */
                 {
                         // skip comments
                         if (token[0] == '/')
@@ -1132,7 +1137,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 b_template = FALSE;
 
                                 // name first
-                                if (fscanf(messagefilep, formatString, template_name) == EOF)
+                                if (fscanf(messagefilep, formatString, template_name) == EOF)   /* Flawfinder: ignore */
                                 {
                                         // oops, file ended
                                         llerrs << "Expected message template name, but file ended"
@@ -1164,7 +1169,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 }
 
                                 // ok, now get Frequency ("High", "Medium", or "Low")
-                                if (fscanf(messagefilep, formatString, token) == EOF)
+                                if (fscanf(messagefilep, formatString, token) == EOF)   /* Flawfinder: ignore */
                                 {
                                         // oops, file ended
                                         llerrs << "Expected message template frequency, found EOF."
@@ -1245,7 +1250,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 else if (!strcmp(token, "Fixed"))
                                 {
                                         U32 message_num = 0;
-                                        if (fscanf(messagefilep, formatString, token) == EOF)
+                                        if (fscanf(messagefilep, formatString, token) == EOF)   /* Flawfinder: ignore */
                                         {
                                                 // oops, file ended
                                                 llerrs << "Expected message template number (fixed),"
@@ -1279,7 +1284,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 }
 
                                 // Now get trust ("Trusted", "NotTrusted")
-                                if (fscanf(messagefilep, formatString, token) == EOF)
+                                if (fscanf(messagefilep, formatString, token) == EOF)   /* Flawfinder: ignore */
                                 {
                                         // File ended
                                         llerrs << "Expected message template "
@@ -1316,7 +1321,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 }
 
                                 // get encoding
-                                if (fscanf(messagefilep, formatString, token) == EOF)
+                                if (fscanf(messagefilep, formatString, token) == EOF)   /* Flawfinder: ignore */
                                 {
                                         // File ended
                                         llerrs << "Expected message encoding, but file ended."
@@ -1362,7 +1367,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 // ok, need to pull header info
 
                                 // name first
-                                if (fscanf(messagefilep, formatString, block_name) == EOF)
+                                if (fscanf(messagefilep, formatString, block_name) == EOF)      /* Flawfinder: ignore */
                                 {
                                         // oops, file ended
                                         llerrs << "Expected block name, but file ended" << llendl;
@@ -1390,7 +1395,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 }
                                 
                                 // now, block type ("Single", "Multiple", or "Variable")
-                                if (fscanf(messagefilep, formatString, token) == EOF)
+                                if (fscanf(messagefilep, formatString, token) == EOF)   /* Flawfinder: ignore */
                                 {
                                         // oops, file ended
                                         llerrs << "Expected block type, but file ended." << llendl;
@@ -1415,7 +1420,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 else if (!strcmp(token, "Multiple"))
                                 {
                                         // need to get the number of repeats
-                                        if (fscanf(messagefilep, formatString, token) == EOF)
+                                        if (fscanf(messagefilep, formatString, token) == EOF)   /* Flawfinder: ignore */
                                         {
                                                 // oops, file ended
                                                 llerrs << "Expected block multiple count,"
@@ -1471,7 +1476,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 // ok, need to pull header info
 
                                 // name first
-                                if (fscanf(messagefilep, formatString, var_name) == EOF)
+                                if (fscanf(messagefilep, formatString, var_name) == EOF)        /* Flawfinder: ignore */
                                 {
                                         // oops, file ended
                                         llerrs << "Expected variable name, but file ended."
@@ -1500,7 +1505,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 }
                                 
                                 // now, variable type ("Fixed" or "Variable")
-                                if (fscanf(messagefilep, formatString, token) == EOF)
+                                if (fscanf(messagefilep, formatString, token) == EOF)   /* Flawfinder: ignore */
                                 {
                                         // oops, file ended
                                         llerrs << "Expected variable type, but file ended"
@@ -1594,7 +1599,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 else if (!strcmp(token, "Fixed"))
                                 {
                                         // need to get the variable size
-                                        if (fscanf(messagefilep, formatString, token) == EOF)
+                                        if (fscanf(messagefilep, formatString, token) == EOF)   /* Flawfinder: ignore */
                                         {
                                                 // oops, file ended
                                                 llerrs << "Expected variable size, but file ended"
@@ -1627,7 +1632,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                                 else if (!strcmp(token, "Variable"))
                                 {
                                         // need to get the variable size
-                                        if (fscanf(messagefilep, formatString, token) == EOF)
+                                        if (fscanf(messagefilep, formatString, token) == EOF)   /* Flawfinder: ignore */
                                         {
                                                 // oops, file ended
                                                 llerrs << "Expected variable size, but file ended"
@@ -1676,7 +1681,7 @@ void LLMessageSystem::loadTemplateFile(const char* filename)
                         if (!strcmp(token, "version"))
                         {
                                 // version number 
-                                if (fscanf(messagefilep, formatString, token) == EOF)
+                                if (fscanf(messagefilep, formatString, token) == EOF)   /* Flawfinder: ignore */
                                 {
                                         // oops, file ended
                                         llerrs << "Expected version number, but file ended" 
@@ -1815,14 +1820,27 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count )
                 else
                 {
                         LLHost host;
-                        LLCircuitData *cdp;
+                        LLCircuitData* cdp;
                         
                         // note if packet acks are appended.
                         if(buffer[0] & LL_ACK_FLAG)
                         {
                                 acks += buffer[--mReceiveSize];
                                 true_rcv_size = mReceiveSize;
-                                mReceiveSize -= acks * sizeof(TPACKETID);
+                                if(mReceiveSize >= ((S32)(acks * sizeof(TPACKETID) + LL_MINIMUM_VALID_PACKET_SIZE)))
+                                {
+                                        mReceiveSize -= acks * sizeof(TPACKETID);
+                                }
+                                else
+                                {
+                                        // mal-formed packet. ignore it and continue with
+                                        // the next one
+                                        llwarns << "Malformed packet received. Packet size "
+                                                << mReceiveSize << " with invalid no. of acks " << acks
+                                                << llendl;
+                                        valid_packet = FALSE;
+                                        continue;
+                                }
                         }
 
                         // process the message as normal
@@ -2734,7 +2752,7 @@ void LLMessageSystem::buildMessage()
                                 temp_block_number = (U8)mbci->mBlockNumber;
                                 if ((S32)(mSendSize + sizeof(U8)) < MAX_BUFFER_SIZE)
                                 {
-                                    memcpy(&mSendBuffer[mSendSize], &temp_block_number, sizeof(U8));
+                                    memcpy(&mSendBuffer[mSendSize], &temp_block_number, sizeof(U8));    /* Flawfinder: ignore */
                                     mSendSize += sizeof(U8);
                                 }
                                 else
@@ -2811,7 +2829,7 @@ void LLMessageSystem::buildMessage()
                                 {
                                         if(mSendSize + mvci.getSize() < (S32)sizeof(mSendBuffer))
                                         {
-                                            memcpy(
+                                            memcpy( /* Flawfinder: ignore */
                                                         &mSendBuffer[mSendSize],
                                                         mvci.getData(),
                                                         mvci.getSize());
@@ -3077,7 +3095,7 @@ S32 LLMessageSystem::sendMessage(const LLHost &host)
 
                         if((S32)(buffer_length + sizeof(TPACKETID)) < MAX_BUFFER_SIZE)
                         {
-                            memcpy(&buf_ptr[buffer_length], &packet_id, sizeof(TPACKETID));
+                            memcpy(&buf_ptr[buffer_length], &packet_id, sizeof(TPACKETID));     /* Flawfinder: ignore */
                             // Do the accounting
                             buffer_length += sizeof(TPACKETID);
                         }
@@ -3185,7 +3203,7 @@ BOOL LLMessageSystem::decodeTemplate(
                 // it appears that if there is a NULL in the message #, it won't copy it....
                 // what was the goal?
                 //if(header[2])
-                memcpy(&message_id_U16, &header[2], 2);
+                memcpy(&message_id_U16, &header[2], 2); /* Flawfinder: ignore */
 
                 // dependant on endian-ness:
                 //              U32     temp = (255 << 24) | (255 << 16) | header[2];
@@ -3343,7 +3361,7 @@ BOOL LLMessageSystem::decodeData(const U8* buffer, const LLHost& sender )
 
         // create base working data set
         mCurrentRMessageData = new LLMsgData(mCurrentRMessageTemplate->mName);
-
+        
         // loop through the template building the data structure as we go
         for (LLMessageTemplate::message_block_map_t::iterator iter = mCurrentRMessageTemplate->mMemberBlocks.begin();
                  iter != mCurrentRMessageTemplate->mMemberBlocks.end(); iter++)
@@ -3596,7 +3614,7 @@ void LLMessageSystem::getDataFast(const char *blockname, const char *varname, vo
                         ((U32*)datap)[1] = ((U32*)vardata.getData())[1];
                         break;
                 default:
-                        memcpy(datap, vardata.getData(), vardata_size);
+                        memcpy(datap, vardata.getData(), vardata_size); /* Flawfinder: ignore */
                         break;
                 }
         }
@@ -3608,7 +3626,7 @@ void LLMessageSystem::getDataFast(const char *blockname, const char *varname, vo
                         << " but truncated to max size of " << max_size
                         << llendl;
 
-                memcpy(datap, vardata.getData(), max_size);
+                memcpy(datap, vardata.getData(), max_size);     /* Flawfinder: ignore */
         }
 }
 
@@ -4403,33 +4421,6 @@ void process_secured_template_checksum_request(LLMessageSystem* msg, void**)
         send_template_reply(msg, token);
 }
 
-void process_log_control(LLMessageSystem* msg, void**)
-{
-        U8 level;
-        U32 mask;
-        BOOL time;
-        BOOL location;
-        BOOL remote_infos;
-
-        msg->getU8Fast(_PREHASH_Options, _PREHASH_Level, level);
-        msg->getU32Fast(_PREHASH_Options, _PREHASH_Mask, mask);
-        msg->getBOOLFast(_PREHASH_Options, _PREHASH_Time, time);
-        msg->getBOOLFast(_PREHASH_Options, _PREHASH_Location, location);
-        msg->getBOOLFast(_PREHASH_Options, _PREHASH_RemoteInfos, remote_infos);
-
-        gErrorStream.setLevel(LLErrorStream::ELevel(level));
-        gErrorStream.setDebugMask(mask);
-        gErrorStream.setTime(time);
-        gErrorStream.setPrintLocation(location);
-        gErrorStream.setElevatedRemote(remote_infos);
-
-        llinfos << "Logging set to level " << gErrorStream.getLevel() 
-                << " mask " << std::hex << gErrorStream.getDebugMask() << std::dec
-                << " time " << gErrorStream.getTime()
-                << " loc " << gErrorStream.getPrintLocation()
-                << llendl;
-}
-
 void process_log_messages(LLMessageSystem* msg, void**)
 {
         U8 log_message;
@@ -4475,7 +4466,7 @@ void process_create_trusted_circuit(LLMessageSystem *msg, void **)
                 return;
         }
 
-        char their_digest[MD5HEX_STR_SIZE];
+        char their_digest[MD5HEX_STR_SIZE];     /* Flawfinder: ignore */
         S32 size = msg->getSizeFast(_PREHASH_DataBlock, _PREHASH_Digest);
         if(size != MD5HEX_STR_BYTES)
         {
@@ -4555,7 +4546,7 @@ void encrypt_template(const char *src_name, const char *dest_name)
 BOOL decrypt_template(const char *src_name, const char *dest_name)
 {
         S32 buf_length = LL_ENCRYPT_BUF_LENGTH;
-        char buf[LL_ENCRYPT_BUF_LENGTH];
+        char buf[LL_ENCRYPT_BUF_LENGTH];        /* Flawfinder: ignore */
         
         FILE* infp = NULL;
         FILE* outfp = NULL;
@@ -4570,7 +4561,7 @@ BOOL decrypt_template(const char *src_name, const char *dest_name)
                  goto exit;
         }
 
-        infp = LLFile::fopen(src_name,"rb");
+        infp = LLFile::fopen(src_name,"rb");    /* Flawfinder: ignore */
         if (!infp)
         {
                 llwarns << "could not open " << src_name << " for reading" << llendl;
@@ -4583,7 +4574,7 @@ BOOL decrypt_template(const char *src_name, const char *dest_name)
                  goto exit;
         }
 
-        outfp = LLFile::fopen(dest_name,"w+b");
+        outfp = LLFile::fopen(dest_name,"w+b"); /* Flawfinder: ignore */
         if (!outfp)
         {
                 llwarns << "could not open " << src_name << " for writing" << llendl;
@@ -4618,7 +4609,7 @@ BOOL decrypt_template(const char *src_name, const char *dest_name)
 void dump_prehash_files()
 {
         U32 i;
-        FILE *fp = LLFile::fopen("../../indra/llmessage/message_prehash.h", "w");
+        FILE* fp = LLFile::fopen("../../indra/llmessage/message_prehash.h", "w");       /* Flawfinder: ignore */
         if (fp)
         {
                 fprintf(
@@ -4650,7 +4641,7 @@ void dump_prehash_files()
                 fprintf(fp, "\n\n#endif\n");
                 fclose(fp);
         }
-        fp = LLFile::fopen("../../indra/llmessage/message_prehash.cpp", "w");
+        fp = LLFile::fopen("../../indra/llmessage/message_prehash.cpp", "w");   /* Flawfinder: ignore */
         if (fp)
         {
                 fprintf(
@@ -4750,7 +4741,6 @@ BOOL start_messaging_system(
         gMessageSystem->setHandlerFuncFast(_PREHASH_PacketAck,             process_packet_ack,      NULL);
         gMessageSystem->setHandlerFuncFast(_PREHASH_TemplateChecksumRequest,  process_template_checksum_request,        NULL);
         gMessageSystem->setHandlerFuncFast(_PREHASH_SecuredTemplateChecksumRequest,  process_secured_template_checksum_request, NULL);
-        gMessageSystem->setHandlerFuncFast(_PREHASH_LogControl,                 process_log_control,    NULL);
         gMessageSystem->setHandlerFuncFast(_PREHASH_LogMessages,                        process_log_messages,   NULL);
         gMessageSystem->setHandlerFuncFast(_PREHASH_CreateTrustedCircuit,
                                        process_create_trusted_circuit,
@@ -5565,13 +5555,21 @@ void LLMessageSystem::getUUID(const char *block, const char *var, LLUUID &u, S32
         getDataFast(gMessageStringTable.getString(block), gMessageStringTable.getString(var), u.mData, sizeof(u.mData), blocknum);
 }
 
-bool LLMessageSystem::generateDigestForNumberAndUUIDs(char* digest, const U32 number, const LLUUID &id1, const LLUUID &id2) const
+bool LLMessageSystem::generateDigestForNumberAndUUIDs(
+        char* digest,
+        const U32 number,
+        const LLUUID& id1,
+        const LLUUID& id2) const
 {
+        // *NOTE: This method is needlessly inefficient. Instead of
+        // calling LLUUID::asString, it should just call
+        // LLUUID::toString().
+
         const char *colon = ":";
         char tbuf[16];  /* Flawfinder: ignore */ 
         LLMD5 d;
-        LLString id1string = id1.getString();
-        LLString id2string = id2.getString();
+        std::string id1string = id1.asString();
+        std::string id2string = id2.asString();
         std::string shared_secret = get_shared_secret();
         unsigned char * secret = (unsigned char*)shared_secret.c_str();
         unsigned char * id1str = (unsigned char*)id1string.c_str();
@@ -5581,7 +5579,7 @@ bool LLMessageSystem::generateDigestForNumberAndUUIDs(char* digest, const U32 nu
         
         if( secret != NULL)
         {
-                d.update(secret, (U32)strlen((char *) secret));
+                d.update(secret, (U32)strlen((char *) secret)); /* Flawfinder: ignore */
         }
 
         d.update((const unsigned char *) colon, (U32)strlen(colon));    /* Flawfinder: ignore */ 
@@ -5592,13 +5590,13 @@ bool LLMessageSystem::generateDigestForNumberAndUUIDs(char* digest, const U32 nu
         d.update((const unsigned char *) colon, (U32)strlen(colon));    /* Flawfinder: ignore */ 
         if( (char*) id1str != NULL)
         {
-                d.update(id1str, (U32)strlen((char *) id1str));  
+                d.update(id1str, (U32)strlen((char *) id1str)); /* Flawfinder: ignore */         
         }
         d.update((const unsigned char *) colon, (U32)strlen(colon));    /* Flawfinder: ignore */ 
         
         if( (char*) id2str != NULL)
         {
-                d.update(id2str, (U32)strlen((char *) id2str)); 
+                d.update(id2str, (U32)strlen((char *) id2str)); /* Flawfinder: ignore */        
         }
         
         d.finalize();
diff --git a/linden/indra/llmessage/message.h b/linden/indra/llmessage/message.h
index df062e7..5cc3ec1 100644
--- a/linden/indra/llmessage/message.h
+++ b/linden/indra/llmessage/message.h
@@ -206,6 +206,8 @@ class LLMessagePollInfo;
 
 class LLMessageSystem
 {
+        LOG_CLASS(LLMessageSystem);
+        
 public:
         U8                                                                              mSendBuffer[MAX_BUFFER_SIZE];
         // Encoded send buffer needs to be slightly larger since the zero
@@ -438,6 +440,7 @@ public:
         void    addStringFast( const char* varname, const std::string& s);                              // typed, checks storage space
         void    addString( const char* varname, const std::string& s);                          // typed, checks storage space
 
+        TPACKETID getCurrentRecvPacketID() { return mCurrentRecvPacketID; }
         S32 getCurrentSendTotal() const { return mCurrentSendTotal; }
 
         // This method checks for current send total and returns true if
@@ -776,7 +779,6 @@ BOOL start_messaging_system(
 void end_messaging_system();
 
 void null_message_callback(LLMessageSystem *msg, void **data);
-void process_log_control(LLMessageSystem* msg, void**);
 
 //
 // Inlines
diff --git a/linden/indra/llmessage/message_prehash.cpp b/linden/indra/llmessage/message_prehash.cpp
index 2753c87..ef01c82 100644
--- a/linden/indra/llmessage/message_prehash.cpp
+++ b/linden/indra/llmessage/message_prehash.cpp
@@ -508,7 +508,6 @@ char * _PREHASH_NVPair;
 char * _PREHASH_ObjectSpinStart;
 char * _PREHASH_UseEstateSun;
 char * _PREHASH_LogoutBlock;
-char * _PREHASH_RelayLogControl;
 char * _PREHASH_RegionID;
 char * _PREHASH_Creator;
 char * _PREHASH_ProposalText;
@@ -1313,7 +1312,6 @@ char * _PREHASH_AssetBlock;
 char * _PREHASH_AcceptNotices;
 char * _PREHASH_SetGroupAcceptNotices;
 char * _PREHASH_CloseCircuit;
-char * _PREHASH_LogControl;
 char * _PREHASH_TeleportFinish;
 char * _PREHASH_PathRevolutions;
 char * _PREHASH_ClassifiedInfoReply;
@@ -1982,7 +1980,6 @@ void init_prehash_data()
         _PREHASH_ObjectSpinStart = gMessageStringTable.getString("ObjectSpinStart");
         _PREHASH_UseEstateSun = gMessageStringTable.getString("UseEstateSun");
         _PREHASH_LogoutBlock = gMessageStringTable.getString("LogoutBlock");
-        _PREHASH_RelayLogControl = gMessageStringTable.getString("RelayLogControl");
         _PREHASH_RegionID = gMessageStringTable.getString("RegionID");
         _PREHASH_Creator = gMessageStringTable.getString("Creator");
         _PREHASH_ProposalText = gMessageStringTable.getString("ProposalText");
@@ -2787,7 +2784,6 @@ void init_prehash_data()
         _PREHASH_AcceptNotices = gMessageStringTable.getString("AcceptNotices");
         _PREHASH_SetGroupAcceptNotices = gMessageStringTable.getString("SetGroupAcceptNotices");
         _PREHASH_CloseCircuit = gMessageStringTable.getString("CloseCircuit");
-        _PREHASH_LogControl = gMessageStringTable.getString("LogControl");
         _PREHASH_TeleportFinish = gMessageStringTable.getString("TeleportFinish");
         _PREHASH_PathRevolutions = gMessageStringTable.getString("PathRevolutions");
         _PREHASH_ClassifiedInfoReply = gMessageStringTable.getString("ClassifiedInfoReply");
diff --git a/linden/indra/llmessage/message_prehash.h b/linden/indra/llmessage/message_prehash.h
index aee8045..9cb4884 100644
--- a/linden/indra/llmessage/message_prehash.h
+++ b/linden/indra/llmessage/message_prehash.h
@@ -508,7 +508,6 @@ extern char * _PREHASH_NVPair;
 extern char * _PREHASH_ObjectSpinStart;
 extern char * _PREHASH_UseEstateSun;
 extern char * _PREHASH_LogoutBlock;
-extern char * _PREHASH_RelayLogControl;
 extern char * _PREHASH_RegionID;
 extern char * _PREHASH_Creator;
 extern char * _PREHASH_ProposalText;
@@ -1313,7 +1312,6 @@ extern char * _PREHASH_AssetBlock;
 extern char * _PREHASH_AcceptNotices;
 extern char * _PREHASH_SetGroupAcceptNotices;
 extern char * _PREHASH_CloseCircuit;
-extern char * _PREHASH_LogControl;
 extern char * _PREHASH_TeleportFinish;
 extern char * _PREHASH_PathRevolutions;
 extern char * _PREHASH_ClassifiedInfoReply;
diff --git a/linden/indra/llmessage/message_string_table.cpp b/linden/indra/llmessage/message_string_table.cpp
index 88e073b..7fea048 100644
--- a/linden/indra/llmessage/message_string_table.cpp
+++ b/linden/indra/llmessage/message_string_table.cpp
@@ -76,7 +76,7 @@ char* LLMessageStringTable::getString(const char *str)
                 }
         }
         // not found, so add!
-        strncpy(mString[hash_value], str, MESSAGE_MAX_STRINGS_LENGTH);
+        strncpy(mString[hash_value], str, MESSAGE_MAX_STRINGS_LENGTH);  /* Flawfinder: ignore */
         mString[hash_value][MESSAGE_MAX_STRINGS_LENGTH - 1] = 0;
         mEmpty[hash_value] = FALSE;
         mUsed++;
diff --git a/linden/indra/llmessage/net.cpp b/linden/indra/llmessage/net.cpp
index d21165e..de19ef8 100644
--- a/linden/indra/llmessage/net.cpp
+++ b/linden/indra/llmessage/net.cpp
@@ -143,7 +143,7 @@ char *u32_to_ip_string(U32 ip, char *ip_string)
         if (result != NULL)
         {
                 //the function signature needs to change to pass in the lengfth of first and last.
-                strcpy(ip_string, result);
+                strcpy(ip_string, result);      /*Flawfinder: ignore*/
                 return ip_string;
         }
         else
diff --git a/linden/indra/llmessage/partsyspacket.cpp b/linden/indra/llmessage/partsyspacket.cpp
index d491540..d6ba11e 100644
--- a/linden/indra/llmessage/partsyspacket.cpp
+++ b/linden/indra/llmessage/partsyspacket.cpp
@@ -1265,7 +1265,7 @@ BOOL LLPartSysCompressedPacket::fromUnsignedBytes(U8 *in, U32 bytesUsed)
 {
         if ((in != NULL) && (bytesUsed <= sizeof(mData)))
         {
-                memcpy(mData, in, bytesUsed);
+                memcpy(mData, in, bytesUsed);   /* Flawfinder: ignore */
                 mNumBytes = bytesUsed;
                 return TRUE;
         }