Merges the Message log and Message builder from Inertia in.

9 files changed, 197 insertions, 19 deletions

diff --git a/linden/indra/llmessage/llcircuit.cpp b/linden/indra/llmessage/llcircuit.cpp
index 725425c..0ff5093 100644
--- a/linden/indra/llmessage/llcircuit.cpp
+++ b/linden/indra/llmessage/llcircuit.cpp
@@ -1231,6 +1231,17 @@ void LLCircuit::getCircuitRange(
         first = mCircuitData.upper_bound(key);
 }
 
+// <edit>
+std::vector<LLCircuitData*> LLCircuit::getCircuitDataList()
+{
+        std::vector<LLCircuitData*> list;
+        circuit_data_map::iterator end = mCircuitData.end();
+        for(circuit_data_map::iterator iter = mCircuitData.begin(); iter != end; ++iter)
+                list.push_back((*iter).second);
+        return list;
+}
+// </edit>
+
 TPACKETID LLCircuitData::nextPacketOutID()
 {
         mPacketsOut++;
diff --git a/linden/indra/llmessage/llcircuit.h b/linden/indra/llmessage/llcircuit.h
index e373cb1..379453e 100644
--- a/linden/indra/llmessage/llcircuit.h
+++ b/linden/indra/llmessage/llcircuit.h
@@ -336,6 +336,9 @@ public:
         // HACK - this should become protected eventually, but stupid !@$@# message system/circuit classes are jumbling things up.
         circuit_data_map mUnackedCircuitMap; // Map of circuits with unacked data
         circuit_data_map mSendAckMap; // Map of circuits which need to send acks
+
+        std::vector<LLCircuitData*> getCircuitDataList();
+
 protected:
         circuit_data_map mCircuitData;
 
diff --git a/linden/indra/llmessage/llmessagelog.cpp b/linden/indra/llmessage/llmessagelog.cpp
new file mode 100644
index 0000000..965b8c0
--- /dev/null
+++ b/linden/indra/llmessage/llmessagelog.cpp
@@ -0,0 +1,54 @@
+// <edit>
+#include "llmessagelog.h"
+
+LLMessageLogEntry::LLMessageLogEntry(EType type, LLHost from_host, LLHost to_host, U8* data, S32 data_size)
+:       mType(type),
+        mFromHost(from_host),
+        mToHost(to_host),
+        mDataSize(data_size)
+{
+        if(data)
+        {
+                mData.resize(data_size);
+                memcpy(&(mData[0]), data, data_size);
+        }
+}
+LLMessageLogEntry::LLMessageLogEntry(EType type, LLHost from_host, LLHost to_host, std::vector<U8> data, S32 data_size)
+:       mType(type),
+        mFromHost(from_host),
+        mToHost(to_host),
+        mDataSize(data_size),
+        mData(data)
+{
+}
+LLMessageLogEntry::~LLMessageLogEntry()
+{
+}
+U32 LLMessageLog::sMaxSize = 4096; // testzone fixme todo boom
+std::deque<LLMessageLogEntry> LLMessageLog::sDeque;
+void (*(LLMessageLog::sCallback))(LLMessageLogEntry);
+void LLMessageLog::setMaxSize(U32 size)
+{
+        sMaxSize = size;
+        while(sDeque.size() > sMaxSize)
+                sDeque.pop_front();
+}
+void LLMessageLog::setCallback(void (*callback)(LLMessageLogEntry))
+{
+        sCallback = callback;
+}
+void LLMessageLog::log(LLHost from_host, LLHost to_host, U8* data, S32 data_size)
+{
+        LLMessageLogEntry entry = LLMessageLogEntry(LLMessageLogEntry::TEMPLATE, from_host, to_host, data, data_size);
+        if(!entry.mDataSize || !entry.mData.size()) return;
+        if(sCallback) sCallback(entry);
+        if(!sMaxSize) return;
+        sDeque.push_back(entry);
+        if(sDeque.size() > sMaxSize)
+                sDeque.pop_front();
+}
+std::deque<LLMessageLogEntry> LLMessageLog::getDeque()
+{
+        return sDeque;
+}
+// </edit>
diff --git a/linden/indra/llmessage/llmessagelog.h b/linden/indra/llmessage/llmessagelog.h
new file mode 100644
index 0000000..5046d80
--- /dev/null
+++ b/linden/indra/llmessage/llmessagelog.h
@@ -0,0 +1,41 @@
+// <edit>
+#ifndef LL_LLMESSAGELOG_H
+#define LL_LLMESSAGELOG_H
+#include "stdtypes.h"
+#include "llhost.h"
+#include <queue>
+#include <string.h>
+
+class LLMessageSystem;
+class LLMessageLogEntry
+{
+public:
+        enum EType
+        {
+                TEMPLATE,
+                HTTP_REQUEST,
+                HTTP_RESPONSE
+        };
+        LLMessageLogEntry(EType type, LLHost from_host, LLHost to_host, U8* data, S32 data_size);
+        LLMessageLogEntry(EType type, LLHost from_host, LLHost to_host, std::vector<U8> data, S32 data_size);
+        ~LLMessageLogEntry();
+        EType mType;
+        LLHost mFromHost;
+        LLHost mToHost;
+        S32 mDataSize;
+        std::vector<U8> mData;
+};
+class LLMessageLog
+{
+public:
+        static void setMaxSize(U32 size);
+        static void setCallback(void (*callback)(LLMessageLogEntry));
+        static void log(LLHost from_host, LLHost to_host, U8* data, S32 data_size);
+        static std::deque<LLMessageLogEntry> getDeque();
+private:
+        static U32 sMaxSize;
+        static void (*sCallback)(LLMessageLogEntry);
+        static std::deque<LLMessageLogEntry> sDeque;
+};
+#endif
+// </edit>
diff --git a/linden/indra/llmessage/llpacketring.cpp b/linden/indra/llmessage/llpacketring.cpp
index 35d5aac..7dcb606 100644
--- a/linden/indra/llmessage/llpacketring.cpp
+++ b/linden/indra/llmessage/llpacketring.cpp
@@ -40,6 +40,8 @@
 #include "timing.h"
 #include "llrand.h"
 #include "u64.h"
+#include "llmessagelog.h"
+#include "message.h"
 
 ///////////////////////////////////////////////////////////
 LLPacketRing::LLPacketRing () :
@@ -246,6 +248,9 @@ S32 LLPacketRing::receivePacket (S32 socket, char *datap)
 
 BOOL LLPacketRing::sendPacket(int h_socket, char * send_buffer, S32 buf_size, LLHost host)
 {
+        //<edit>
+        LLMessageLog::log(LLHost(16777343, gMessageSystem->getListenPort()), host, (U8*)send_buffer, buf_size);
+        //</edit>
         BOOL status = TRUE;
         if (!mUseOutThrottle)
         {
diff --git a/linden/indra/llmessage/lltemplatemessagereader.cpp b/linden/indra/llmessage/lltemplatemessagereader.cpp
index d8904a9..9f68fe9 100644
--- a/linden/indra/llmessage/lltemplatemessagereader.cpp
+++ b/linden/indra/llmessage/lltemplatemessagereader.cpp
@@ -449,7 +449,10 @@ S32 LLTemplateMessageReader::getMessageSize() const
 // Returns template for the message contained in buffer
 BOOL LLTemplateMessageReader::decodeTemplate(  
                 const U8* buffer, S32 buffer_size,  // inputs
-                LLMessageTemplate** msg_template ) // outputs
+                // <edit>
+                //LLMessageTemplate** msg_template ) // outputs
+                LLMessageTemplate** msg_template, BOOL custom)
+                // </edit>
 {
         const U8* header = buffer + LL_PACKET_ID_SIZE;
 
@@ -491,6 +494,9 @@ BOOL LLTemplateMessageReader::decodeTemplate(
         }
         else // bogus packet received (too short)
         {
+                // <edit>
+                if(!custom)
+                // </edit>
                 llwarns << "Packet with unusable length received (too short): "
                                 << buffer_size << llendl;
                 return(FALSE);
@@ -503,9 +509,16 @@ BOOL LLTemplateMessageReader::decodeTemplate(
         }
         else
         {
+                // <edit>
+                if(!custom)
+                {
+                // </edit>
                 llwarns << "Message #" << std::hex << num << std::dec
                         << " received but not registered!" << llendl;
                 gMessageSystem->callExceptionFunc(MX_UNREGISTERED_MESSAGE);
+                // <edit>
+                }
+                // </edit>
                 return(FALSE);
         }
 
@@ -532,7 +545,8 @@ void LLTemplateMessageReader::logRanOffEndOfPacket( const LLHost& host, const S3
 }
 
 // decode a given message
-BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender )
+BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender, BOOL custom)
+// </edit>
 {
         llassert( mReceiveSize >= 0 );
         llassert( mCurrentRMessageTemplate);
@@ -594,6 +608,9 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender
                 }
                 else
                 {
+                        // <edit>
+                        if(!custom)
+                        // </edit>
                         llerrs << "Unknown block type" << llendl;
                         return FALSE;
                 }
@@ -640,6 +657,9 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender
 
                                         if ((decode_pos + data_size) > mReceiveSize)
                                         {
+                                                // <edit>
+                                                if(!custom)
+                                                // </edit>
                                                 logRanOffEndOfPacket(sender, decode_pos, data_size);
 
                                                 // default to 0 length variable blocks
@@ -676,6 +696,9 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender
                                         // so, copy data pointer and set data size to fixed size
                                         if ((decode_pos + mvci.getSize()) > mReceiveSize)
                                         {
+                                                // <edit>
+                                                if(!custom)
+                                                // </edit>
                                                 logRanOffEndOfPacket(sender, decode_pos, mvci.getSize());
 
                                                 // default to 0s.
@@ -703,7 +726,10 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender
                 lldebugs << "Empty message '" << mCurrentRMessageTemplate->mName << "' (no blocks)" << llendl;
                 return FALSE;
         }
-
+        
+        // <edit>
+        if(!custom)
+        // </edit>
         {
                 static LLTimer decode_timer;
 
@@ -756,14 +782,26 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender
         return TRUE;
 }
 
+// <edit>
+LLMessageTemplate* LLTemplateMessageReader::getTemplate()
+{
+        return mCurrentRMessageTemplate;
+}
+// </edit>
+
 BOOL LLTemplateMessageReader::validateMessage(const U8* buffer, 
                                                                                           S32 buffer_size, 
                                                                                           const LLHost& sender,
-                                                                                          bool trusted)
+                                                                                          bool trusted,
+                                                                                          BOOL custom)
 {
         mReceiveSize = buffer_size;
-        BOOL valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate );
-        if(valid)
+        // <edit>
+        //BOOL valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate );
+        BOOL valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate, custom );
+        //if(result)
+        if(valid && !custom)
+        // </edit>
         {
                 mCurrentRMessageTemplate->mReceiveCount++;
                 //lldebugs << "MessageRecvd:"
diff --git a/linden/indra/llmessage/lltemplatemessagereader.h b/linden/indra/llmessage/lltemplatemessagereader.h
index ab06ab4..0eef93a 100644
--- a/linden/indra/llmessage/lltemplatemessagereader.h
+++ b/linden/indra/llmessage/lltemplatemessagereader.h
@@ -102,28 +102,32 @@ public:
         virtual const char* getMessageName() const;
         virtual S32 getMessageSize() const;
 
+        // <edit>
+        LLMessageTemplate* getTemplate();
+        // </edit>
+
         virtual void copyToBuilder(LLMessageBuilder&) const;
 
         BOOL validateMessage(const U8* buffer, S32 buffer_size, 
-                                                 const LLHost& sender, bool trusted = false);
+                                                 const LLHost& sender, bool trusted = false, BOOL custom = FALSE);
         BOOL readMessage(const U8* buffer, const LLHost& sender);
 
         bool isTrusted() const;
         bool isBanned(bool trusted_source) const;
         bool isUdpBanned() const;
+
+        BOOL decodeData(const U8* buffer, const LLHost& sender, BOOL custom = FALSE);
+
+        BOOL decodeTemplate(const U8* buffer, S32 buffer_size,  // inputs
+                                                LLMessageTemplate** msg_template, BOOL custom = FALSE); // outputs
         
 private:
 
         void getData(const char *blockname, const char *varname, void *datap, 
                                  S32 size = 0, S32 blocknum = 0, S32 max_size = S32_MAX);
 
-        BOOL decodeTemplate(const U8* buffer, S32 buffer_size,  // inputs
-                                                LLMessageTemplate** msg_template ); // outputs
-
         void logRanOffEndOfPacket( const LLHost& host, const S32 where, const S32 wanted );
 
-        BOOL decodeData(const U8* buffer, const LLHost& sender );
-
         S32     mReceiveSize;
         LLMessageTemplate* mCurrentRMessageTemplate;
         LLMsgData* mCurrentRMessageData;
diff --git a/linden/indra/llmessage/message.cpp b/linden/indra/llmessage/message.cpp
index 78af35b..7e8aff1 100644
--- a/linden/indra/llmessage/message.cpp
+++ b/linden/indra/llmessage/message.cpp
@@ -86,6 +86,7 @@
 #include "v3math.h"
 #include "v4math.h"
 #include "lltransfertargetvfile.h"
+#include "llmessagelog.h"
 
 // Constants
 //const char* MESSAGE_LOG_FILENAME = "message.log";
@@ -524,10 +525,10 @@ LLCircuitData* LLMessageSystem::findCircuit(const LLHost& host,
 }
 
 // Returns TRUE if a valid, on-circuit message has been received.
-BOOL LLMessageSystem::checkMessages( S64 frame_count )
+BOOL LLMessageSystem::checkMessages( S64 frame_count, bool faked_message, U8 fake_buffer[MAX_BUFFER_SIZE], LLHost fake_host, S32 fake_size )
 {
         // Pump 
-        BOOL    valid_packet = FALSE;
+        BOOL valid_packet = FALSE;
         mMessageReader = mTemplateMessageReader;
 
         LLTransferTargetVFile::updateQueue();
@@ -557,6 +558,13 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count )
                 mTrueReceiveSize = mPacketRing.receivePacket(mSocket, (char *)mTrueReceiveBuffer);
                 // If you want to dump all received packets into SecondLife.log, uncomment this
                 //dumpPacketToLog();
+                // <edit>
+                if(mTrueReceiveSize && receive_size > (S32) LL_MINIMUM_VALID_PACKET_SIZE)
+                {
+                        LLMessageLog::log(mLastSender, LLHost(16777343, mPort), buffer, mTrueReceiveSize);
+                }
+                // </edit>
+
                 
                 receive_size = mTrueReceiveSize;
                 mLastSender = mPacketRing.getLastSender();
@@ -1549,6 +1557,12 @@ U32 LLMessageSystem::getOurCircuitCode()
         return mOurCircuitCode;
 }
 
+// <edit>
+LLCircuit* LLMessageSystem::getCircuit()
+{
+        return &mCircuitInfo;
+}
+
 void LLMessageSystem::getCircuitInfo(LLSD& info) const
 {
         mCircuitInfo.getInfo(info);
diff --git a/linden/indra/llmessage/message.h b/linden/indra/llmessage/message.h
index b25b27e..e6391d9 100644
--- a/linden/indra/llmessage/message.h
+++ b/linden/indra/llmessage/message.h
@@ -230,11 +230,14 @@ class LLMessageSystem : public LLMessageSenderInterface
         typedef std::map<const char *, LLMessageTemplate*> message_template_name_map_t;
         typedef std::map<U32, LLMessageTemplate*> message_template_number_map_t;
 
-private:
+// <edit>
+//private:
+// </edit>
         message_template_name_map_t             mMessageTemplates;
         message_template_number_map_t           mMessageNumbers;
-
-public:
+// <edit>
+//public:
+// </edit>
         S32                                     mSystemVersionMajor;
         S32                                     mSystemVersionMinor;
         S32                                     mSystemVersionPatch;
@@ -341,7 +344,7 @@ public:
         bool addCircuitCode(U32 code, const LLUUID& session_id);
 
         BOOL    poll(F32 seconds); // Number of seconds that we want to block waiting for data, returns if data was received
-        BOOL    checkMessages( S64 frame_count = 0 );
+        BOOL    checkMessages( S64 frame_count = 0, bool faked_message = false, U8 fake_buffer[MAX_BUFFER_SIZE] = NULL, LLHost fake_host = LLHost(), S32 fake_size = 0 );
         void    processAcks();
 
         BOOL    isMessageFast(const char *msg);
@@ -569,6 +572,10 @@ public:
         void    showCircuitInfo();
         void getCircuitInfo(LLSD& info) const;
 
+        // <edit>
+        LLCircuit* getCircuit();
+        // </edit>
+
         U32 getOurCircuitCode();
         
         void    enableCircuit(const LLHost &host, BOOL trusted);
@@ -733,6 +740,8 @@ public:
         // This will cause all trust queries to return true until the next message
         // is read: use with caution!
         void receivedMessageFromTrustedSender();
+
+        LLTemplateMessageBuilder* mTemplateMessageBuilder;
         
 private:
 
@@ -807,7 +816,6 @@ private:
         TPACKETID mCurrentRecvPacketID;       // packet ID of current receive packet (for reporting)
 
         LLMessageBuilder* mMessageBuilder;
-        LLTemplateMessageBuilder* mTemplateMessageBuilder;
         LLSDMessageBuilder* mLLSDMessageBuilder;
         LLMessageReader* mMessageReader;
         LLTemplateMessageReader* mTemplateMessageReader;