From 72c4d73706267a32bb31d93e14425b1c0c8a5715 Mon Sep 17 00:00:00 2001 From: RevolutionSmythe Date: Sat, 23 Oct 2010 20:51:07 -0500 Subject: Merges the Message log and Message builder from Inertia in. --- linden/indra/llmessage/llcircuit.cpp | 11 + linden/indra/llmessage/llcircuit.h | 3 + linden/indra/llmessage/llmessagelog.cpp | 54 ++ linden/indra/llmessage/llmessagelog.h | 41 + linden/indra/llmessage/llpacketring.cpp | 5 + linden/indra/llmessage/lltemplatemessagereader.cpp | 50 +- linden/indra/llmessage/lltemplatemessagereader.h | 16 +- linden/indra/llmessage/message.cpp | 18 +- linden/indra/llmessage/message.h | 18 +- linden/indra/llui/llscrolllistctrl.cpp | 17 + linden/indra/llui/llscrolllistctrl.h | 11 + linden/indra/newview/llfloatermessagebuilder.cpp | 978 +++++++++++++++++++++ linden/indra/newview/llfloatermessagebuilder.h | 55 ++ linden/indra/newview/llfloatermessagelog.cpp | 962 ++++++++++++++++++++ linden/indra/newview/llfloatermessagelog.h | 84 ++ linden/indra/newview/llviewermenu.cpp | 45 + .../skins/default/xui/en-us/menu_viewer.xml | 9 + 17 files changed, 2358 insertions(+), 19 deletions(-) create mode 100644 linden/indra/llmessage/llmessagelog.cpp create mode 100644 linden/indra/llmessage/llmessagelog.h create mode 100644 linden/indra/newview/llfloatermessagebuilder.cpp create mode 100644 linden/indra/newview/llfloatermessagebuilder.h create mode 100644 linden/indra/newview/llfloatermessagelog.cpp create mode 100644 linden/indra/newview/llfloatermessagelog.h (limited to 'linden') 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); } +// +std::vector LLCircuit::getCircuitDataList() +{ + std::vector 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; +} +// + 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 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 @@ +// +#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 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 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 LLMessageLog::getDeque() +{ + return sDeque; +} +// 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 @@ +// +#ifndef LL_LLMESSAGELOG_H +#define LL_LLMESSAGELOG_H +#include "stdtypes.h" +#include "llhost.h" +#include +#include + +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 data, S32 data_size); + ~LLMessageLogEntry(); + EType mType; + LLHost mFromHost; + LLHost mToHost; + S32 mDataSize; + std::vector 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 getDeque(); +private: + static U32 sMaxSize; + static void (*sCallback)(LLMessageLogEntry); + static std::deque sDeque; +}; +#endif +// 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) { + // + LLMessageLog::log(LLHost(16777343, gMessageSystem->getListenPort()), host, (U8*)send_buffer, buf_size); + // 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 + // + //LLMessageTemplate** msg_template ) // outputs + LLMessageTemplate** msg_template, BOOL custom) + // { const U8* header = buffer + LL_PACKET_ID_SIZE; @@ -491,6 +494,9 @@ BOOL LLTemplateMessageReader::decodeTemplate( } else // bogus packet received (too short) { + // + if(!custom) + // llwarns << "Packet with unusable length received (too short): " << buffer_size << llendl; return(FALSE); @@ -503,9 +509,16 @@ BOOL LLTemplateMessageReader::decodeTemplate( } else { + // + if(!custom) + { + // llwarns << "Message #" << std::hex << num << std::dec << " received but not registered!" << llendl; gMessageSystem->callExceptionFunc(MX_UNREGISTERED_MESSAGE); + // + } + // 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) +// { llassert( mReceiveSize >= 0 ); llassert( mCurrentRMessageTemplate); @@ -594,6 +608,9 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender } else { + // + if(!custom) + // 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) { + // + if(!custom) + // 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) { + // + if(!custom) + // 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; } - + + // + if(!custom) + // { static LLTimer decode_timer; @@ -756,14 +782,26 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender return TRUE; } +// +LLMessageTemplate* LLTemplateMessageReader::getTemplate() +{ + return mCurrentRMessageTemplate; +} +// + 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) + // + //BOOL valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate ); + BOOL valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate, custom ); + //if(result) + if(valid && !custom) + // { 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; + // + LLMessageTemplate* getTemplate(); + // + 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(); + // + if(mTrueReceiveSize && receive_size > (S32) LL_MINIMUM_VALID_PACKET_SIZE) + { + LLMessageLog::log(mLastSender, LLHost(16777343, mPort), buffer, mTrueReceiveSize); + } + // + receive_size = mTrueReceiveSize; mLastSender = mPacketRing.getLastSender(); @@ -1549,6 +1557,12 @@ U32 LLMessageSystem::getOurCircuitCode() return mOurCircuitCode; } +// +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 message_template_name_map_t; typedef std::map message_template_number_map_t; -private: +// +//private: +// message_template_name_map_t mMessageTemplates; message_template_number_map_t mMessageNumbers; - -public: +// +//public: +// 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; + // + LLCircuit* getCircuit(); + // + 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; diff --git a/linden/indra/llui/llscrolllistctrl.cpp b/linden/indra/llui/llscrolllistctrl.cpp index 3c2293f..9635f99 100644 --- a/linden/indra/llui/llscrolllistctrl.cpp +++ b/linden/indra/llui/llscrolllistctrl.cpp @@ -103,6 +103,10 @@ struct SortScrollListItem LLScrollListIcon::LLScrollListIcon(LLUIImagePtr icon, S32 width) : LLScrollListCell(width), mIcon(icon), + // + mCallback(NULL), + mUserData(NULL), + // mColor(LLColor4::white) { } @@ -145,6 +149,19 @@ void LLScrollListIcon::setValue(const LLSD& value) } } +// +void LLScrollListIcon::setClickCallback(BOOL (*callback)(void*), void* user_data) +{ + mCallback = callback; + mUserData = user_data; +} + +BOOL LLScrollListIcon::handleClick() +{ + if(mCallback) return mCallback(mUserData); + return FALSE; +} +// void LLScrollListIcon::setColor(const LLColor4& color) { diff --git a/linden/indra/llui/llscrolllistctrl.h b/linden/indra/llui/llscrolllistctrl.h index 516e4f1..e875d7a 100644 --- a/linden/indra/llui/llscrolllistctrl.h +++ b/linden/indra/llui/llscrolllistctrl.h @@ -163,10 +163,18 @@ public: virtual void setColor(const LLColor4&); virtual BOOL isText()const { return FALSE; } virtual void setValue(const LLSD& value); + // + void setClickCallback(BOOL (*callback)(void*), void* user_data); + virtual BOOL handleClick(); + // private: LLUIImagePtr mIcon; LLColor4 mColor; + // + BOOL (*mCallback)(void*); + void* mUserData; + // }; /* @@ -493,6 +501,9 @@ public: virtual S32 getScrollPos() const; virtual void setScrollPos( S32 pos ); + // + S32 getPageLines() { return mPageLines; } + // S32 getSearchColumn(); void setSearchColumn(S32 column) { mSearchColumn = column; } S32 getColumnIndexFromOffset(S32 x); diff --git a/linden/indra/newview/llfloatermessagebuilder.cpp b/linden/indra/newview/llfloatermessagebuilder.cpp new file mode 100644 index 0000000..90c0f9e --- /dev/null +++ b/linden/indra/newview/llfloatermessagebuilder.cpp @@ -0,0 +1,978 @@ +// +#include "llviewerprecompiledheaders.h" +#include "llfloatermessagebuilder.h" +#include "lluictrlfactory.h" +#include "llmessagetemplate.h" +#include "llagent.h" +#include "llchat.h" +#include "llfloaterchat.h" +#include "llviewerregion.h" // getHandle +#include "llcombobox.h" +#include "llselectmgr.h" // fill in stuff about selected object +#include "llparcel.h" +#include "llviewerparcelmgr.h" // same for parcel +#include "llscrolllistctrl.h" +#include "llworld.h" +#include "lltemplatemessagebuilder.h" + +//////////////////////////////// +// LLNetListItem +//////////////////////////////// +LLNetListItem::LLNetListItem(LLUUID id) +: mID(id), + mAutoName(TRUE), + mName("No name"), + mPreviousRegionName(""), + mCircuitData(NULL) +{ +} + +//////////////////////////////// +// LLFloaterMessageBuilder +//////////////////////////////// +std::list LLFloaterMessageBuilder::sNetListItems; + +LLFloaterMessageBuilder::LLFloaterMessageBuilder(std::string initial_text) +: LLFloater(), + LLEventTimer(1.0f), + mNetInfoMode(NI_NET), + mInitialText(initial_text) +{ + LLUICtrlFactory::getInstance()->buildFloater(this, "floater_message_builder.xml"); +} +LLFloaterMessageBuilder::~LLFloaterMessageBuilder() +{ +} +void LLFloaterMessageBuilder::show(std::string initial_text) +{ + (new LLFloaterMessageBuilder(initial_text))->open(); +} +BOOL LLFloaterMessageBuilder::tick() +{ + refreshNetList(); + return FALSE; +} +LLNetListItem* LLFloaterMessageBuilder::findNetListItem(LLHost host) +{ + std::list::iterator end = sNetListItems.end(); + for(std::list::iterator iter = sNetListItems.begin(); iter != end; ++iter) + if((*iter)->mCircuitData && (*iter)->mCircuitData->getHost() == host) + return (*iter); + return NULL; +} +LLNetListItem* LLFloaterMessageBuilder::findNetListItem(LLUUID id) +{ + std::list::iterator end = sNetListItems.end(); + for(std::list::iterator iter = sNetListItems.begin(); iter != end; ++iter) + if((*iter)->mID == id) + return (*iter); + return NULL; +} +void LLFloaterMessageBuilder::refreshNetList() +{ + LLScrollListCtrl* scrollp = getChild("net_list"); + // Update circuit data of net list items + std::vector circuits = gMessageSystem->getCircuit()->getCircuitDataList(); + std::vector::iterator circuits_end = circuits.end(); + for(std::vector::iterator iter = circuits.begin(); iter != circuits_end; ++iter) + { + LLNetListItem* itemp = findNetListItem((*iter)->getHost()); + if(!itemp) + { + LLUUID id; id.generate(); + itemp = new LLNetListItem(id); + sNetListItems.push_back(itemp); + } + itemp->mCircuitData = (*iter); + } + // Clear circuit data of items whose circuits are gone + std::list::iterator items_end = sNetListItems.end(); + for(std::list::iterator iter = sNetListItems.begin(); iter != items_end; ++iter) + { + if(std::find(circuits.begin(), circuits.end(), (*iter)->mCircuitData) == circuits.end()) + (*iter)->mCircuitData = NULL; + } + // Remove net list items that are totally useless now + for(std::list::iterator iter = sNetListItems.begin(); iter != sNetListItems.end();) + { + if((*iter)->mCircuitData == NULL) + iter = sNetListItems.erase(iter); + else ++iter; + } + // Update names of net list items + items_end = sNetListItems.end(); + for(std::list::iterator iter = sNetListItems.begin(); iter != items_end; ++iter) + { + LLNetListItem* itemp = (*iter); + if(itemp->mAutoName) + { + if(itemp->mCircuitData) + { + LLViewerRegion* regionp = LLWorld::getInstance()->getRegion(itemp->mCircuitData->getHost()); + if(regionp) + { + std::string name = regionp->getName(); + if(name == "") name = llformat("%s (awaiting region name)", itemp->mCircuitData->getHost().getString().c_str()); + itemp->mName = name; + itemp->mPreviousRegionName = name; + } + else + { + itemp->mName = itemp->mCircuitData->getHost().getString(); + if(itemp->mPreviousRegionName != "") + itemp->mName.append(llformat(" (was %s)", itemp->mPreviousRegionName.c_str())); + } + } + else + { + // an item just for an event queue, not handled yet + itemp->mName = "Something else"; + } + } + } + // Rebuild scroll list from scratch + LLUUID selected_id = scrollp->getFirstSelected() ? scrollp->getFirstSelected()->getUUID() : LLUUID::null; + S32 scroll_pos = scrollp->getScrollPos(); + scrollp->clearRows(); + for(std::list::iterator iter = sNetListItems.begin(); iter != items_end; ++iter) + { + LLNetListItem* itemp = (*iter); + LLSD element; + element["id"] = itemp->mID; + LLSD& text_column = element["columns"][0]; + text_column["column"] = "text"; + text_column["value"] = itemp->mName + (itemp->mCircuitData->getHost() == gAgent.getRegionHost() ? " (main)" : ""); + + LLSD& state_column = element["columns"][ 1]; + state_column["column"] = "state"; + state_column["value"] = ""; + + LLScrollListItem* scroll_itemp = scrollp->addElement(element); + BOOL has_live_circuit = itemp->mCircuitData && itemp->mCircuitData->isAlive(); + + LLScrollListText* state = (LLScrollListText*)scroll_itemp->getColumn(1); + + if(has_live_circuit) + state->setText(std::string("Alive")); + else + state->setText(std::string("Alive")); + } + if(selected_id.notNull()) scrollp->selectByID(selected_id); + if(scroll_pos < scrollp->getItemCount()) scrollp->setScrollPos(scroll_pos); +} +BOOL LLFloaterMessageBuilder::postBuild() +{ + childSetText("message_edit", mInitialText); + childSetAction("send_btn", onClickSend, this); + std::vector names; + LLComboBox* combo; + LLMessageSystem::message_template_name_map_t::iterator temp_end = gMessageSystem->mMessageTemplates.end(); + LLMessageSystem::message_template_name_map_t::iterator temp_iter; + std::vector::iterator names_end; + std::vector::iterator names_iter; + for(temp_iter = gMessageSystem->mMessageTemplates.begin(); temp_iter != temp_end; ++temp_iter) + if((*temp_iter).second->getTrust() == MT_NOTRUST) + names.push_back((*temp_iter).second->mName); + std::sort(names.begin(), names.end()); + combo = getChild("untrusted_message_combo"); + names_end = names.end(); + for(names_iter = names.begin(); names_iter != names_end; ++names_iter) + combo->add((*names_iter)); + names.clear(); + for(temp_iter = gMessageSystem->mMessageTemplates.begin(); temp_iter != temp_end; ++temp_iter) + if((*temp_iter).second->getTrust() == MT_TRUST) + names.push_back((*temp_iter).second->mName); + std::sort(names.begin(), names.end()); + combo = getChild("trusted_message_combo"); + names_end = names.end(); + for(names_iter = names.begin(); names_iter != names_end; ++names_iter) + combo->add((*names_iter)); + childSetCommitCallback("untrusted_message_combo", onCommitPacketCombo, this); + childSetCommitCallback("trusted_message_combo", onCommitPacketCombo, this); + return TRUE; +} +inline std::vector split(std::string input, std::string separator) +{ + S32 size = input.length(); + char* buffer = new char[size + 1]; + strncpy(buffer, input.c_str(), size); + buffer[size] = '\0'; + std::vector lines; + char* result = strtok(buffer, separator.c_str()); + while(result) + { + lines.push_back(result); + result = strtok(NULL, separator.c_str()); + } + delete[] buffer; + return lines; +} +std::string mvtstr(e_message_variable_type var_type) +{ + switch(var_type) + { + case MVT_U8: + return "U8"; + break; + case MVT_U16: + return "U16"; + break; + case MVT_U32: + return "U32"; + break; + case MVT_U64: + return "U64"; + break; + case MVT_S8: + return "S8"; + break; + case MVT_S16: + return "S16"; + break; + case MVT_S32: + return "S32"; + break; + case MVT_S64: + return "S64"; + break; + case MVT_F32: + return "F32"; + break; + case MVT_F64: + return "F64"; + break; + case MVT_LLVector3: + return "LLVector3"; + break; + case MVT_LLVector3d: + return "LLVector3d"; + break; + case MVT_LLVector4: + return "LLVector4"; + break; + case MVT_LLQuaternion: + return "LLQuaternion"; + break; + case MVT_LLUUID: + return "LLUUID"; + break; + case MVT_BOOL: + return "BOOL"; + break; + case MVT_IP_ADDR: + return "IPADDR"; + break; + case MVT_IP_PORT: + return "IPPORT"; + break; + case MVT_VARIABLE: + return "Variable"; + break; + case MVT_FIXED: + return "Fixed"; + break; + default: + return "Missingno."; + break; + } +} +// static +BOOL LLFloaterMessageBuilder::addField(e_message_variable_type var_type, const char* var_name, std::string input, BOOL hex) +{ + LLStringUtil::trim(input); + if(input.length() < 1 && var_type != MVT_VARIABLE) + return FALSE; + U8 valueU8; + U16 valueU16; + U32 valueU32; + U64 valueU64; + S8 valueS8; + S16 valueS16; + S32 valueS32; + // S64 valueS64; + F32 valueF32; + F64 valueF64; + LLVector3 valueVector3; + LLVector3d valueVector3d; + LLVector4 valueVector4; + LLQuaternion valueQuaternion; + LLUUID valueLLUUID; + BOOL valueBOOL; + std::string input_lower = input; + LLStringUtil::toLower(input_lower); + if(input_lower == "$agentid") + input = gAgent.getID().asString(); + else if(input_lower == "$sessionid") + input = gAgent.getSessionID().asString(); + else if(input_lower == "$uuid") + { + LLUUID id; + id.generate(); + input = id.asString(); + } + else if(input_lower == "$circuitcode") + { + std::stringstream temp_stream; + temp_stream << gMessageSystem->mOurCircuitCode; + input = temp_stream.str(); + } + else if(input_lower == "$regionhandle") + { + std::stringstream temp_stream; + temp_stream << (gAgent.getRegion() ? gAgent.getRegion()->getHandle() : 0); + input = temp_stream.str(); + } + else if(input_lower == "$position" || input_lower == "$pos") + { + std::stringstream temp_stream; + valueVector3 = gAgent.getPositionAgent(); + temp_stream << "<" << valueVector3[0] << ", " << valueVector3[1] << ", " << valueVector3[2] << ">"; + input = temp_stream.str(); + } + if(hex) + { + if(var_type != MVT_VARIABLE && var_type != MVT_FIXED) + return FALSE; + int len = input_lower.length(); + const char* cstr = input_lower.c_str(); + std::string new_input(""); + BOOL nibble = FALSE; + char byte = 0; + for(int i = 0; i < len; i++) + { + char c = cstr[i]; + if(c >= 0x30 && c <= 0x39) + c -= 0x30; + else if(c >= 0x61 && c <= 0x66) + c -= 0x57; + else if(c != 0x20) + return FALSE; + else + continue; + if(!nibble) + byte = c << 4; + else + new_input.push_back(byte | c); + nibble = !nibble; + } + if(nibble) + return FALSE; + input = new_input; + } + std::stringstream stream(input); + std::vector tokens; + switch(var_type) + { + case MVT_U8: + if(input.substr(0, 1) == "-") + return FALSE; + if((stream >> valueU32).fail()) + return FALSE; + valueU8 = (U8)valueU32; + gMessageSystem->addU8(var_name, valueU8); + return TRUE; + break; + case MVT_U16: + if(input.substr(0, 1) == "-") + return FALSE; + if((stream >> valueU16).fail()) + return FALSE; + gMessageSystem->addU16(var_name, valueU16); + return TRUE; + break; + case MVT_U32: + if(input.substr(0, 1) == "-") + return FALSE; + if((stream >> valueU32).fail()) + return FALSE; + gMessageSystem->addU32(var_name, valueU32); + return TRUE; + break; + case MVT_U64: + if(input.substr(0, 1) == "-") + return FALSE; + if((stream >> valueU64).fail()) + return FALSE; + gMessageSystem->addU64(var_name, valueU64); + return TRUE; + break; + case MVT_S8: + if((stream >> valueS8).fail()) + return FALSE; + gMessageSystem->addS8(var_name, valueS8); + return TRUE; + break; + case MVT_S16: + if((stream >> valueS16).fail()) + return FALSE; + gMessageSystem->addS16(var_name, valueS16); + return TRUE; + break; + case MVT_S32: + if((stream >> valueS32).fail()) + return FALSE; + gMessageSystem->addS32(var_name, valueS32); + return TRUE; + break; + /* + case MVT_S64: + if((stream >> valueS64).fail()) + return FALSE; + gMessageSystem->addS64(var_name, valueS64); + return TRUE; + break; + */ + case MVT_F32: + if((stream >> valueF32).fail()) + return FALSE; + gMessageSystem->addF32(var_name, valueF32); + return TRUE; + break; + case MVT_F64: + if((stream >> valueF64).fail()) + return FALSE; + gMessageSystem->addF64(var_name, valueF64); + return TRUE; + break; + case MVT_LLVector3: + LLStringUtil::trim(input); + if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">") + return FALSE; + tokens = split(input.substr(1, input.length() - 2), ","); + if(tokens.size() != 3) + return FALSE; + for(int i = 0; i < 3; i++) + { + stream.clear(); + stream.str(tokens[i]); + if((stream >> valueF32).fail()) + return FALSE; + valueVector3.mV[i] = valueF32; + } + gMessageSystem->addVector3(var_name, valueVector3); + return TRUE; + break; + case MVT_LLVector3d: + LLStringUtil::trim(input); + if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">") + return FALSE; + tokens = split(input.substr(1, input.length() - 2), ","); + if(tokens.size() != 3) + return FALSE; + for(int i = 0; i < 3; i++) + { + stream.clear(); + stream.str(tokens[i]); + if((stream >> valueF64).fail()) + return FALSE; + valueVector3d.mdV[i] = valueF64; + } + gMessageSystem->addVector3d(var_name, valueVector3d); + return TRUE; + break; + case MVT_LLVector4: + LLStringUtil::trim(input); + if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">") + return FALSE; + tokens = split(input.substr(1, input.length() - 2), ","); + if(tokens.size() != 4) + return FALSE; + for(int i = 0; i < 4; i++) + { + stream.clear(); + stream.str(tokens[i]); + if((stream >> valueF32).fail()) + return FALSE; + valueVector4.mV[i] = valueF32; + } + gMessageSystem->addVector4(var_name, valueVector4); + return TRUE; + break; + case MVT_LLQuaternion: + LLStringUtil::trim(input); + if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">") + return FALSE; + tokens = split(input.substr(1, input.length() - 2), ","); + if(tokens.size() != 3) + return FALSE; + for(int i = 0; i < 3; i++) + { + stream.clear(); + stream.str(tokens[i]); + if((stream >> valueF32).fail()) + return FALSE; + valueVector3.mV[i] = valueF32; + } + valueQuaternion.unpackFromVector3(valueVector3); + gMessageSystem->addQuat(var_name, valueQuaternion); + return TRUE; + break; + case MVT_LLUUID: + if((stream >> valueLLUUID).fail()) + return FALSE; + gMessageSystem->addUUID(var_name, valueLLUUID); + return TRUE; + break; + case MVT_BOOL: + if(input_lower == "true") + valueBOOL = TRUE; + else if(input_lower == "false") + valueBOOL = FALSE; + else if((stream >> valueBOOL).fail()) + return FALSE; + //gMessageSystem->addBOOL(var_name, valueBOOL); + gMessageSystem->addU8(var_name, (U8)valueBOOL); + return TRUE; + break; + case MVT_IP_ADDR: + if((stream >> valueU32).fail()) + return FALSE; + gMessageSystem->addIPAddr(var_name, valueU32); + return TRUE; + break; + case MVT_IP_PORT: + if((stream >> valueU16).fail()) + return FALSE; + gMessageSystem->addIPPort(var_name, valueU16); + return TRUE; + break; + case MVT_VARIABLE: + if(!hex) + { + char* buffer = new char[input.size() + 1]; + strncpy(buffer, input.c_str(), input.size()); + buffer[input.size()] = '\0'; + gMessageSystem->addBinaryData(var_name, buffer, input.size() + 1); + delete[] buffer; + } + else + gMessageSystem->addBinaryData(var_name, input.c_str(), input.size()); + return TRUE; + break; + case MVT_FIXED: + if(!hex) + { + char* buffer = new char[input.size() + 1]; + strncpy(buffer, input.c_str(), input.size()); + buffer[input.size()] = '\0'; + gMessageSystem->addBinaryData(var_name, buffer, input.size()); + delete[] buffer; + } + else + gMessageSystem->addBinaryData(var_name, input.c_str(), input.size()); + return TRUE; + break; + default: + break; + } + return FALSE; +} +// static +void LLFloaterMessageBuilder::onCommitPacketCombo(LLUICtrl* ctrl, void* user_data) +{ + LLFloaterMessageBuilder* floaterp = (LLFloaterMessageBuilder*)user_data; + LLViewerObject* selected_objectp = LLSelectMgr::getInstance()->getSelection()->getPrimaryObject(); + LLParcel* agent_parcelp = LLViewerParcelMgr::getInstance()->getAgentParcel(); + std::string message = ctrl->getValue(); + std::map::iterator template_iter; + template_iter = gMessageSystem->mMessageTemplates.find( LLMessageStringTable::getInstance()->getString(message.c_str()) ); + if(template_iter == gMessageSystem->mMessageTemplates.end()) + { + floaterp->childSetText("message_edit", std::string("")); + return; + } + std::string text(llformat((*template_iter).second->getTrust() == MT_NOTRUST ? "out %s\n" : "in %s\n", message.c_str())); + LLMessageTemplate* temp = (*template_iter).second; + LLMessageTemplate::message_block_map_t::iterator blocks_end = temp->mMemberBlocks.end(); + for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin(); + blocks_iter != blocks_end; ++blocks_iter) + { + LLMessageBlock* block = (*blocks_iter); + const char* block_name = block->mName; + std::string block_name_string = std::string(block_name); + S32 num_blocks = 1; + if(block->mType == MBT_MULTIPLE) + num_blocks = block->mNumber; + else if(("ObjectLink" == message && "ObjectData" == block_name_string)) + num_blocks = 2; + for(S32 i = 0; i < num_blocks; i++) + { + text.append(llformat("[%s]\n", block_name)); + LLMessageBlock::message_variable_map_t::iterator var_end = block->mMemberVariables.end(); + for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin(); + var_iter != var_end; ++var_iter) + { + LLMessageVariable* variable = (*var_iter); + const char* var_name = variable->getName(); + std::string var_name_string = std::string(var_name); + text.append(llformat("%s = ", var_name)); + std::string value(""); + S32 size = variable->getSize(); + switch(variable->getType()) + { + case MVT_U8: + case MVT_U16: + case MVT_U32: + case MVT_U64: + case MVT_S8: + case MVT_S16: + case MVT_S32: + case MVT_IP_ADDR: + case MVT_IP_PORT: + if("RegionHandle" == var_name_string || "Handle" == var_name_string) + value = "$RegionHandle"; + else if("CircuitCode" == var_name_string || "ViewerCircuitCode" == var_name_string + || ("Code" == var_name_string && "CircuitCode" == block_name_string) ) + { + value = "$CircuitCode"; + } + else if(selected_objectp && + ( + "ObjectLocalID" == var_name_string + || "TaskLocalID" == var_name_string + || ("LocalID" == var_name_string && + ( + "ObjectData" == block_name_string + || "UpdateData" == block_name_string + || "InventoryData" == block_name_string + ) + ) + ) + ) + { + std::stringstream temp_stream; + temp_stream << selected_objectp->getLocalID(); + value = temp_stream.str(); + } + else if( agent_parcelp && + "LocalID" == var_name_string && + ( + "ParcelData" == block_name_string + || message.find("Parcel") != message.npos + ) + ) + { + std::stringstream temp_stream; + temp_stream << agent_parcelp->getLocalID(); + value = temp_stream.str(); + } + else if("PCode" == var_name_string) + value = "9"; + else if("PathCurve" == var_name_string) + value = "16"; + else if("ProfileCurve" == var_name_string) + value = "1"; + else if("PathScaleX" == var_name_string || "PathScaleY" == var_name_string) + value = "100"; + else if("BypassRaycast" == var_name_string) + value = "1"; + else + value = "0"; + break; + case MVT_F32: + case MVT_F64: + value = "0.0"; + break; + case MVT_LLVector3: + case MVT_LLVector3d: + case MVT_LLQuaternion: + if("Position" == var_name_string || "RayStart" == var_name_string || "RayEnd" == var_name_string) + value = "$Position"; + else if("Scale" == var_name_string) + value = "<0.5, 0.5, 0.5>"; + else + value = "<0, 0, 0>"; + break; + case MVT_LLVector4: + value = "<0, 0, 0, 0>"; + break; + case MVT_LLUUID: + if("AgentID" == var_name_string) + value = "$AgentID"; + else if("SessionID" == var_name_string) + value = "$SessionID"; + else if("ObjectID" == var_name_string && selected_objectp) + value = selected_objectp->getID().asString(); + else if("ParcelID" == var_name_string && agent_parcelp) + value = agent_parcelp->getID().asString(); + else + value = "00000000-0000-0000-0000-000000000000"; + break; + case MVT_BOOL: + value = "false"; + break; + case MVT_VARIABLE: + value = "Hello, world!"; + break; + case MVT_FIXED: + for(S32 si = 0; si < size; si++) + //value.append(std::string("0123456789abcdef").substr(si & 0xf, 1)); + value.append("a"); + break; + default: + value = ""; + break; + } + text.append(llformat("%s\n", value.c_str())); + } + } + } + text = text.substr(0, text.length() - 1); + floaterp->childSetText("message_edit", text); +} +// static +void LLFloaterMessageBuilder::onClickSend(void* user_data) +{ + LLFloaterMessageBuilder* floaterp = (LLFloaterMessageBuilder*)user_data; + std::vector lines = split(floaterp->childGetText("message_edit"), "\n"); + if(!lines.size()) + { + LLFloaterChat::addChat(LLChat("Not enough information :O")); + return; + } + std::vector tokens = split(lines[0], " "); + if(!tokens.size()) + { + LLFloaterChat::addChat(LLChat("Not enough information :O")); + return; + } + std::string dir_str = tokens[0]; + LLStringUtil::toLower(dir_str); + // Direction + BOOL outgoing; + if(dir_str == "out") + outgoing = TRUE; + else if(dir_str == "in") + outgoing = FALSE; + else + { + LLFloaterChat::addChat(LLChat("Expected direction 'in' or 'out'")); + return; + } + // Message + std::string message = "Invalid"; + if(tokens.size() > 1) + { + if(tokens.size() > 2) + { + LLFloaterChat::addChat(LLChat("Unexpected extra stuff at the top")); + return; + } + message = tokens[1]; + LLStringUtil::trim(message); + } + // Body + std::vector parts; + if(lines.size() > 1) + { + std::vector::iterator line_end = lines.end(); + std::vector::iterator line_iter = lines.begin(); + ++line_iter; + std::string current_block(""); + int current_block_index = -1; + for( ; line_iter != line_end; ++line_iter) + { + std::string line = (*line_iter); + LLStringUtil::trim(line); + if(!line.length()) + continue; + if(line.substr(0, 1) == "[" && line.substr(line.size() - 1, 1) == "]") + { + current_block = line.substr(1, line.length() - 2); + LLStringUtil::trim(current_block); + ++current_block_index; + parts_block pb; + pb.name = current_block; + parts.push_back(pb); + } + else + { + if(current_block.empty()) + { + LLFloaterChat::addChat(LLChat("Unexpected field when no block yet")); + return; + } + int eqpos = line.find("="); + if(eqpos == line.npos) + { + LLFloaterChat::addChat(LLChat("Missing an equal sign")); + return; + } + std::string field = line.substr(0, eqpos); + LLStringUtil::trim(field); + if(!field.length()) + { + LLFloaterChat::addChat(LLChat("Missing name of field")); + return; + } + std::string value = line.substr(eqpos + 1); + LLStringUtil::trim(value); + parts_var pv; + if(value.substr(0, 1) == "|") + { + pv.hex = TRUE; + value = value.substr(1); + LLStringUtil::trim(value); + } + else + pv.hex = FALSE; + pv.name = field; + pv.value = value; + parts[current_block_index].vars.push_back(pv); + } + } + } + // Verification + std::map::iterator template_iter; + template_iter = gMessageSystem->mMessageTemplates.find( LLMessageStringTable::getInstance()->getString(message.c_str()) ); + if(template_iter == gMessageSystem->mMessageTemplates.end()) + { + LLFloaterChat::addChat(LLChat(llformat("Don't know how to build a '%s' message", message.c_str()))); + return; + } + LLMessageTemplate* temp = (*template_iter).second; + std::vector::iterator parts_end = parts.end(); + std::vector::iterator parts_iter = parts.begin(); + LLMessageTemplate::message_block_map_t::iterator blocks_end = temp->mMemberBlocks.end(); + for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin(); + blocks_iter != blocks_end; ) + { + LLMessageBlock* block = (*blocks_iter); + const char* block_name = block->mName; + if(parts_iter == parts_end) + { + if(block->mType != MBT_VARIABLE) + LLFloaterChat::addChat(LLChat(llformat("Expected '%s' block", block_name))); + else + { + ++blocks_iter; + continue; + } + return; + } + else if((*parts_iter).name != block_name) + { + if(block->mType != MBT_VARIABLE) + LLFloaterChat::addChat(LLChat(llformat("Expected '%s' block", block_name))); + else + { + ++blocks_iter; + continue; + } + return; + } + std::vector::iterator part_var_end = (*parts_iter).vars.end(); + std::vector::iterator part_var_iter = (*parts_iter).vars.begin(); + LLMessageBlock::message_variable_map_t::iterator var_end = block->mMemberVariables.end(); + for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin(); + var_iter != var_end; ++var_iter) + { + LLMessageVariable* variable = (*var_iter); + const char* var_name = variable->getName(); + if(part_var_iter == part_var_end) + { + LLFloaterChat::addChat(LLChat(llformat("Expected '%s' field under '%s' block", var_name, block_name))); + return; + } + else if((*part_var_iter).name != var_name) + { + LLFloaterChat::addChat(LLChat(llformat("Expected '%s' field under '%s' block", var_name, block_name))); + return; + } + (*part_var_iter).var_type = variable->getType(); + ++part_var_iter; + } + if(part_var_iter != part_var_end) + { + LLFloaterChat::addChat(LLChat(llformat("Unexpected field(s) at end of '%s' block", block_name))); + return; + } + ++parts_iter; + // test + if((block->mType != MBT_SINGLE) && (parts_iter != parts_end) && ((*parts_iter).name == block_name)) + { + // block will repeat + } + else ++blocks_iter; + } + if(parts_iter != parts_end) + { + LLFloaterChat::addChat(LLChat("Unexpected block(s) at end")); + return; + } + // Build and send + gMessageSystem->newMessage( message.c_str() ); + for(parts_iter = parts.begin(); parts_iter != parts_end; ++parts_iter) + { + const char* block_name = (*parts_iter).name.c_str(); + gMessageSystem->nextBlock(block_name); + std::vector::iterator part_var_end = (*parts_iter).vars.end(); + for(std::vector::iterator part_var_iter = (*parts_iter).vars.begin(); + part_var_iter != part_var_end; ++part_var_iter) + { + parts_var pv = (*part_var_iter); + if(!addField(pv.var_type, pv.name.c_str(), pv.value, pv.hex)) + { + LLFloaterChat::addChat(LLChat(llformat("Error adding the provided data for %s '%s' to '%s' block", mvtstr(pv.var_type).c_str(), pv.name.c_str(), block_name))); + gMessageSystem->clearMessage(); + return; + } + } + } + + LLScrollListCtrl* scrollp = floaterp->getChild("net_list"); + LLScrollListItem* selected_itemp = scrollp->getFirstSelected(); + + //if a specific circuit is selected, send it to that, otherwise send it to the current sim + if(selected_itemp) + { + LLNetListItem* itemp = findNetListItem(selected_itemp->getUUID()); + LLScrollListText* textColumn = (LLScrollListText*)selected_itemp->getColumn(1); + + //why would you send data through a dead circuit? + if(textColumn->getValue().asString() == "Dead") + { + LLFloaterChat::addChat(LLChat("No sending messages through dead circuits!")); + return; + } + if(outgoing) + { + gMessageSystem->sendMessage(itemp->mCircuitData->getHost()); + } else { + U8 builtMessageBuffer[MAX_BUFFER_SIZE]; + + S32 message_size = gMessageSystem->mTemplateMessageBuilder->buildMessage(builtMessageBuffer, MAX_BUFFER_SIZE, 0); + gMessageSystem->clearMessage(); + gMessageSystem->checkMessages(0, true, builtMessageBuffer, itemp->mCircuitData->getHost(), message_size); + + } + } else { + if(outgoing) + { + gMessageSystem->sendMessage(gAgent.getRegionHost()); + } else { + U8 builtMessageBuffer[MAX_BUFFER_SIZE]; + + S32 message_size = gMessageSystem->mTemplateMessageBuilder->buildMessage(builtMessageBuffer, MAX_BUFFER_SIZE, 0); + gMessageSystem->clearMessage(); + gMessageSystem->checkMessages(0, true, builtMessageBuffer, gAgent.getRegionHost(), message_size); + + } + } +} + +BOOL LLFloaterMessageBuilder::handleKeyHere(KEY key, MASK mask) +{ + if(key == KEY_RETURN && (mask & MASK_CONTROL)) + { + onClickSend(this); + return TRUE; + } + if(key == KEY_ESCAPE) + { + releaseFocus(); + return TRUE; + } + return FALSE; +} +// diff --git a/linden/indra/newview/llfloatermessagebuilder.h b/linden/indra/newview/llfloatermessagebuilder.h new file mode 100644 index 0000000..5dc9b42 --- /dev/null +++ b/linden/indra/newview/llfloatermessagebuilder.h @@ -0,0 +1,55 @@ +// ] +#ifndef LL_LLFLOATERMESSAGEBUILDER_H +#define LL_LLFLOATERMESSAGEBUILDER_H +#include "llfloater.h" +#include "lltemplatemessagereader.h" +#include "llmessagelog.h" + +class LLNetListItem +{ +public: + LLNetListItem(LLUUID id); + LLUUID mID; + BOOL mAutoName; + std::string mName; + std::string mPreviousRegionName; + LLCircuitData* mCircuitData; +}; + +class LLFloaterMessageBuilder : public LLFloater, public LLEventTimer +{ +public: + LLFloaterMessageBuilder(std::string initial_text); + ~LLFloaterMessageBuilder(); + static void show(std::string initial_text); + static std::list sNetListItems; + BOOL postBuild(); + BOOL tick(); + static BOOL addField(e_message_variable_type var_type, const char* var_name, std::string input, BOOL hex); + static void onClickSend(void* user_data); + static void onCommitPacketCombo(LLUICtrl* ctrl, void* user_data); + static LLFloaterMessageBuilder* sInstance; + BOOL handleKeyHere(KEY key, MASK mask); + std::string mInitialText; + struct parts_var + { + std::string name; + std::string value; + BOOL hex; + e_message_variable_type var_type; + }; + struct parts_block + { + std::string name; + std::vector vars; + }; + static LLNetListItem* findNetListItem(LLHost host); + static LLNetListItem* findNetListItem(LLUUID id); + void refreshNetList(); + enum ENetInfoMode { NI_NET, NI_LOG }; + ENetInfoMode mNetInfoMode; + static void onCommitMessageLog(LLUICtrl* ctrl, void* user_data); + static void onCommitFilter(LLUICtrl* ctrl, void* user_data); +}; +#endif +// diff --git a/linden/indra/newview/llfloatermessagelog.cpp b/linden/indra/newview/llfloatermessagelog.cpp new file mode 100644 index 0000000..161779b --- /dev/null +++ b/linden/indra/newview/llfloatermessagelog.cpp @@ -0,0 +1,962 @@ +// +#include "llviewerprecompiledheaders.h" +#include "llfloatermessagelog.h" +#include "lluictrlfactory.h" +#include "llworld.h" +#include "llviewerregion.h" +#include "llscrolllistctrl.h" +#include "lltexteditor.h" +#include "llviewerwindow.h" // alertXml +#include "llmessagetemplate.h" +#include +#include "llmenugl.h" +#include "llfloatermessagebuilder.h" +#include "llagent.h" +//////////////////////////////// +// LLFloaterMessageLogItem +//////////////////////////////// +#define MAX_PACKET_LEN (0x2000) +LLTemplateMessageReader* LLFloaterMessageLogItem::sTemplateMessageReader = NULL; +LLFloaterMessageLogItem::LLFloaterMessageLogItem(LLMessageLogEntry entry) +: LLMessageLogEntry(entry.mType, entry.mFromHost, entry.mToHost, entry.mData, entry.mDataSize) +{ + if(!sTemplateMessageReader) + { + sTemplateMessageReader = new LLTemplateMessageReader(gMessageSystem->mMessageNumbers); + } + mID.generate(); + mSequenceID = 0; + if(mType == TEMPLATE) + { + BOOL decode_invalid = FALSE; + S32 decode_len = mDataSize; + std::vector DecodeBuffer(MAX_PACKET_LEN,0); + memcpy(&(DecodeBuffer[0]),&(mData[0]),decode_len); + U8* decodep = &(DecodeBuffer[0]); + mFlags = DecodeBuffer[0]; + gMessageSystem->zeroCodeExpand(&decodep, &decode_len); + if(decode_len < 7) + decode_invalid = TRUE; + else + { + mSequenceID = ntohl(*((U32*)(&decodep[1]))); + sTemplateMessageReader->clearMessage(); + if(!sTemplateMessageReader->validateMessage(decodep, decode_len, mFromHost, TRUE)) + decode_invalid = TRUE; + else + { + if(!sTemplateMessageReader->decodeData(decodep, mFromHost, TRUE)) + decode_invalid = TRUE; + else + { + LLMessageTemplate* temp = sTemplateMessageReader->getTemplate(); + mName = temp->mName; + mSummary = ""; + + if(mFlags) + { + mSummary.append(" [ "); + if(mFlags & LL_ZERO_CODE_FLAG) + mSummary.append(" Zer "); + if(mFlags & LL_RELIABLE_FLAG) + mSummary.append(" Rel "); + if(mFlags & LL_RESENT_FLAG) + mSummary.append(" Rsd "); + if(mFlags & LL_ACK_FLAG) + mSummary.append(" Ack "); + mSummary.append(" ] "); + } + + LLMessageTemplate::message_block_map_t::iterator blocks_end = temp->mMemberBlocks.end(); + for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin(); + blocks_iter != blocks_end; ++blocks_iter) + { + LLMessageBlock* block = (*blocks_iter); + const char* block_name = block->mName; + S32 num_blocks = sTemplateMessageReader->getNumberOfBlocks(block_name); + if(!num_blocks) + mSummary.append(" { } "); + else if(num_blocks > 1) + mSummary.append(llformat(" %s [ %d ] { ... } ", block_name, num_blocks)); + else for(S32 i = 0; i < 1; i++) + { + mSummary.append(" { "); + LLMessageBlock::message_variable_map_t::iterator var_end = block->mMemberVariables.end(); + for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin(); + var_iter != var_end; ++var_iter) + { + LLMessageVariable* variable = (*var_iter); + const char* var_name = variable->getName(); + BOOL returned_hex; + std::string value = getString(sTemplateMessageReader, block_name, i, var_name, variable->getType(), returned_hex, TRUE); + mSummary.append(llformat(" %s=%s ", var_name, value.c_str())); + } + mSummary.append(" } "); + if(mSummary.length() > 255) break; + } + if(mSummary.length() > 255) + { + mSummary.append(" ... "); + break; + } + } // blocks_iter + } // decode_valid + } + } + if(decode_invalid) + { + mName = "Invalid"; + mSummary = ""; + for(S32 i = 0; i < mDataSize; i++) + mSummary.append(llformat("%02X ", mData[i])); + } + } + else // not template + { + mName = "SOMETHING ELSE"; + mSummary = "TODO: SOMETHING ELSE"; + } +} +LLFloaterMessageLogItem::~LLFloaterMessageLogItem() +{ +} +BOOL LLFloaterMessageLogItem::isOutgoing() +{ + return mFromHost == LLHost(16777343, gMessageSystem->getListenPort()); +} +std::string LLFloaterMessageLogItem::getFull(BOOL show_header) +{ + std::string full(""); + if(mType == TEMPLATE) + { + BOOL decode_invalid = FALSE; + S32 decode_len = mDataSize; + std::vector DecodeBuffer(MAX_PACKET_LEN,0); + memcpy(&(DecodeBuffer[0]),&(mData[0]),decode_len); + U8* decodep = &(DecodeBuffer[0]); + gMessageSystem->zeroCodeExpand(&decodep, &decode_len); + if(decode_len < 7) + decode_invalid = TRUE; + else + { + sTemplateMessageReader->clearMessage(); + if(!sTemplateMessageReader->validateMessage(decodep, decode_len, mFromHost, TRUE)) + decode_invalid = TRUE; + else + { + if(!sTemplateMessageReader->decodeData(decodep, mFromHost, TRUE)) + decode_invalid = TRUE; + else + { + LLMessageTemplate* temp = sTemplateMessageReader->getTemplate(); + full.append(isOutgoing() ? "out " : "in "); + full.append(llformat("%s\n", temp->mName)); + if(show_header) + { + full.append("[Header]\n"); + full.append(llformat("SequenceID = %u\n", mSequenceID)); + full.append(llformat("LL_ZERO_CODE_FLAG = %s\n", (mFlags & LL_ZERO_CODE_FLAG) ? "True" : "False")); + full.append(llformat("LL_RELIABLE_FLAG = %s\n", (mFlags & LL_RELIABLE_FLAG) ? "True" : "False")); + full.append(llformat("LL_RESENT_FLAG = %s\n", (mFlags & LL_RESENT_FLAG) ? "True" : "False")); + full.append(llformat("LL_ACK_FLAG = %s\n", (mFlags & LL_ACK_FLAG) ? "True" : "False")); + } + LLMessageTemplate::message_block_map_t::iterator blocks_end = temp->mMemberBlocks.end(); + for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin(); + blocks_iter != blocks_end; ++blocks_iter) + { + LLMessageBlock* block = (*blocks_iter); + const char* block_name = block->mName; + S32 num_blocks = sTemplateMessageReader->getNumberOfBlocks(block_name); + for(S32 i = 0; i < num_blocks; i++) + { + full.append(llformat("[%s]\n", block->mName)); + LLMessageBlock::message_variable_map_t::iterator var_end = block->mMemberVariables.end(); + for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin(); + var_iter != var_end; ++var_iter) + { + LLMessageVariable* variable = (*var_iter); + const char* var_name = variable->getName(); + BOOL returned_hex; + std::string value = getString(sTemplateMessageReader, block_name, i, var_name, variable->getType(), returned_hex); + if(returned_hex) + full.append(llformat("%s =| ", var_name)); + else + full.append(llformat("%s = ", var_name)); + // llformat has a 1024 char limit!? + full.append(value); + full.append("\n"); + } + } + } // blocks_iter + } // decode_valid + } + } + if(decode_invalid) + { + full = isOutgoing() ? "out" : "in"; + full.append("\n"); + for(S32 i = 0; i < mDataSize; i++) + full.append(llformat("%02X ", mData[i])); + } + } + else // not template + { + full = "FIXME"; + } + return full; +} +// static +std::string LLFloaterMessageLogItem::getString(LLTemplateMessageReader* readerp, const char* block_name, S32 block_num, const char* var_name, e_message_variable_type var_type, BOOL &returned_hex, BOOL summary_mode) +{ + returned_hex = FALSE; + std::stringstream stream; + char* value; + U32 valueU32; + U16 valueU16; + LLVector3 valueVector3; + LLVector3d valueVector3d; + LLVector4 valueVector4; + LLQuaternion valueQuaternion; + LLUUID valueLLUUID; + switch(var_type) + { + case MVT_U8: + U8 valueU8; + readerp->getU8(block_name, var_name, valueU8, block_num); + stream << U32(valueU8); + break; + case MVT_U16: + readerp->getU16(block_name, var_name, valueU16, block_num); + stream << valueU16; + break; + case MVT_U32: + readerp->getU32(block_name, var_name, valueU32, block_num); + stream << valueU32; + break; + case MVT_U64: + U64 valueU64; + readerp->getU64(block_name, var_name, valueU64, block_num); + stream << valueU64; + break; + case MVT_S8: + S8 valueS8; + readerp->getS8(block_name, var_name, valueS8, block_num); + stream << S32(valueS8); + break; + case MVT_S16: + S16 valueS16; + readerp->getS16(block_name, var_name, valueS16, block_num); + stream << valueS16; + break; + case MVT_S32: + S32 valueS32; + readerp->getS32(block_name, var_name, valueS32, block_num); + stream << valueS32; + break; + /*case MVT_S64: + S64 valueS64; + readerp->getS64(block_name, var_name, valueS64, block_num); + stream << valueS64; + break;*/ + case MVT_F32: + F32 valueF32; + readerp->getF32(block_name, var_name, valueF32, block_num); + stream << valueF32; + break; + case MVT_F64: + F64 valueF64; + readerp->getF64(block_name, var_name, valueF64, block_num); + stream << valueF64; + break; + case MVT_LLVector3: + readerp->getVector3(block_name, var_name, valueVector3, block_num); + //stream << valueVector3; + stream << "<" << valueVector3.mV[0] << ", " << valueVector3.mV[1] << ", " << valueVector3.mV[2] << ">"; + break; + case MVT_LLVector3d: + readerp->getVector3d(block_name, var_name, valueVector3d, block_num); + //stream << valueVector3d; + stream << "<" << valueVector3d.mdV[0] << ", " << valueVector3d.mdV[1] << ", " << valueVector3d.mdV[2] << ">"; + break; + case MVT_LLVector4: + readerp->getVector4(block_name, var_name, valueVector4, block_num); + //stream << valueVector4; + stream << "<" << valueVector4.mV[0] << ", " << valueVector4.mV[1] << ", " << valueVector4.mV[2] << ", " << valueVector4.mV[3] << ">"; + break; + case MVT_LLQuaternion: + readerp->getQuat(block_name, var_name, valueQuaternion, block_num); + //stream << valueQuaternion; + stream << "<" << valueQuaternion.mQ[0] << ", " << valueQuaternion.mQ[1] << ", " << valueQuaternion.mQ[2] << ", " << valueQuaternion.mQ[3] << ">"; + break; + case MVT_LLUUID: + readerp->getUUID(block_name, var_name, valueLLUUID, block_num); + stream << valueLLUUID; + break; + case MVT_BOOL: + BOOL valueBOOL; + readerp->getBOOL(block_name, var_name, valueBOOL, block_num); + stream << valueBOOL; + break; + case MVT_IP_ADDR: + readerp->getIPAddr(block_name, var_name, valueU32, block_num); + stream << LLHost(valueU32, 0).getIPString(); + break; + case MVT_IP_PORT: + readerp->getIPPort(block_name, var_name, valueU16, block_num); + stream << valueU16; + case MVT_VARIABLE: + case MVT_FIXED: + default: + S32 size = readerp->getSize(block_name, block_num, var_name); + if(size) + { + value = new char[size + 1]; + readerp->getBinaryData(block_name, var_name, value, size, block_num); + value[size] = '\0'; + S32 readable = 0; + S32 unreadable = 0; + S32 end = (summary_mode && (size > 64)) ? 64 : size; + for(S32 i = 0; i < end; i++) + { + if(!value[i]) + { + if(i != (end - 1)) + { // don't want null terminator hiding data + unreadable = S32_MAX; + break; + } + } + else if(value[i] < 0x20 || value[i] >= 0x7F) + { + if(summary_mode) + unreadable++; + else + { // never want any wrong characters outside of summary mode + unreadable = S32_MAX; + break; + } + } + else readable++; + } + if(readable >= unreadable) + { + if(summary_mode && (size > 64)) + { + for(S32 i = 60; i < 63; i++) + value[i] = '.'; + value[63] = '\0'; + } + stream << value; + + delete[] value; + } + else + { + returned_hex = TRUE; + S32 end = (summary_mode && (size > 8)) ? 8 : size; + for(S32 i = 0; i < end; i++) + //stream << std::uppercase << std::hex << U32(value[i]) << " "; + stream << llformat("%02X ", (U8)value[i]); + if(summary_mode && (size > 8)) + stream << " ... "; + } + } + break; + } + + return stream.str(); +} +LLMessageLogFilter::LLMessageLogFilter() +{ +} +LLMessageLogFilter::~LLMessageLogFilter() +{ +} +BOOL LLMessageLogFilter::set(std::string filter) +{ + mPositiveNames.clear(); + mNegativeNames.clear(); + typedef boost::tokenizer > tokenizer; + boost::char_separator sep(" ","",boost::keep_empty_tokens); + boost::tokenizer > tokens(filter, sep); + boost::tokenizer >::iterator end = tokens.end(); + for(boost::tokenizer >::iterator iter = tokens.begin(); iter != end; ++iter) + { + std::string token = (*iter); + LLStringUtil::trim(token); + LLStringUtil::toLower(token); + BOOL negative = token.find("!") == 0; + if(negative) + { + token = token.substr(1); + mNegativeNames.push_back(token); + } + else + mPositiveNames.push_back(token); + } + return TRUE; +} +//////////////////////////////// +// LLMessageLogFilterApply +//////////////////////////////// +LLMessageLogFilterApply::LLMessageLogFilterApply() +: LLEventTimer(0.1f), + mFinished(FALSE), + mProgress(0) +{ + mIter = LLFloaterMessageLog::sMessageLogEntries.begin(); +} +void LLMessageLogFilterApply::cancel() +{ + mFinished = TRUE; +} +BOOL LLMessageLogFilterApply::tick() +{ + std::deque::iterator end = LLFloaterMessageLog::sMessageLogEntries.end(); + if(mIter == end || !LLFloaterMessageLog::sInstance) + { + mFinished = TRUE; + if(LLFloaterMessageLog::sInstance) + { + if(LLFloaterMessageLog::sInstance->mMessageLogFilterApply == this) + { + LLFloaterMessageLog::sInstance->stopApplyingFilter(); + } + } + return TRUE; + } + for(S32 i = 0; i < 256; i++) + { + if(mIter == end) + { + mFinished = TRUE; + if(LLFloaterMessageLog::sInstance) + { + if(LLFloaterMessageLog::sInstance->mMessageLogFilterApply == this) + { + LLFloaterMessageLog::sInstance->stopApplyingFilter(); + + //we're done messing with the deque, push all queued items to the main deque + std::deque::iterator queueIter = mQueuedMessages.begin(); + std::deque::iterator queueEnd = mQueuedMessages.end(); + + while(queueIter != queueEnd) + { + LLFloaterMessageLog::sInstance->conditionalLog(LLFloaterMessageLogItem((*queueIter))); + ++queueIter; + } + + mQueuedMessages.clear(); + } + } + + return TRUE; + } + + LLFloaterMessageLog::sInstance->conditionalLog(LLFloaterMessageLogItem((*mIter))); + + mIter++; + mProgress++; + } + LLFloaterMessageLog::sInstance->updateFilterStatus(); + return FALSE; +} +//////////////////////////////// +// LLFloaterMessageLog +//////////////////////////////// +LLFloaterMessageLog* LLFloaterMessageLog::sInstance; +std::list LLFloaterMessageLog::sNetListItems; +std::deque LLFloaterMessageLog::sMessageLogEntries; +std::vector LLFloaterMessageLog::sFloaterMessageLogItems; +LLMessageLogFilter LLFloaterMessageLog::sMessageLogFilter = LLMessageLogFilter(); +std::string LLFloaterMessageLog::sMessageLogFilterString("!StartPingCheck !CompletePingCheck !PacketAck !SimulatorViewerTimeMessage !SimStats !AgentUpdate !AgentAnimation !AvatarAnimation !ViewerEffect !CoarseLocationUpdate !LayerData !CameraConstraint !ObjectUpdateCached !RequestMultipleObjects !ObjectUpdate !ObjectUpdateCompressed !ImprovedTerseObjectUpdate !KillObject !ImagePacket !SendXferPacket !ConfirmXferPacket !TransferPacket !SoundTrigger !AttachedSound !PreloadSound"); +BOOL LLFloaterMessageLog::sBusyApplyingFilter = FALSE; +LLFloaterMessageLog::LLFloaterMessageLog() +: LLFloater(), + LLEventTimer(1.0f), + mNetInfoMode(NI_NET), + mMessageLogFilterApply(NULL) +{ + sInstance = this; + LLMessageLog::setCallback(onLog); + sMessageLogEntries = LLMessageLog::getDeque(); + LLUICtrlFactory::getInstance()->buildFloater(this, "floater_message_log.xml"); +} +LLFloaterMessageLog::~LLFloaterMessageLog() +{ + LLMessageLog::setCallback(NULL); + stopApplyingFilter(); + sInstance = NULL; + sNetListItems.clear(); + sMessageLogEntries.clear(); + sFloaterMessageLogItems.clear(); +} +// static +void LLFloaterMessageLog::show() +{ + if(!sInstance) sInstance = new LLFloaterMessageLog(); + sInstance->open(); +} +BOOL LLFloaterMessageLog::postBuild() +{ + childSetCommitCallback("net_list", onCommitNetList, this); + childSetCommitCallback("message_log", onCommitMessageLog, this); + childSetAction("filter_choice_btn", onClickFilterChoice, this); + childSetAction("filter_apply_btn", onClickFilterApply, this); + childSetCommitCallback("filter_edit", onCommitFilter, this); + childSetAction("clear_log_btn", onClickClearLog, this); + childSetAction("send_to_message_builder_btn", onClickSendToMessageBuilder, this); + childSetText("filter_edit", sMessageLogFilterString); + refreshNetList(); + refreshNetInfo(TRUE); + startApplyingFilter(sMessageLogFilterString, TRUE); + return TRUE; +} +BOOL LLFloaterMessageLog::tick() +{ + refreshNetList(); + refreshNetInfo(FALSE); + return FALSE; +} +LLNetListItem* LLFloaterMessageLog::findNetListItem(LLHost host) +{ + std::list::iterator end = sNetListItems.end(); + for(std::list::iterator iter = sNetListItems.begin(); iter != end; ++iter) + if((*iter)->mCircuitData && (*iter)->mCircuitData->getHost() == host) + return (*iter); + return NULL; +} +LLNetListItem* LLFloaterMessageLog::findNetListItem(LLUUID id) +{ + std::list::iterator end = sNetListItems.end(); + for(std::list::iterator iter = sNetListItems.begin(); iter != end; ++iter) + if((*iter)->mID == id) + return (*iter); + return NULL; +} +void LLFloaterMessageLog::refreshNetList() +{ + LLScrollListCtrl* scrollp = getChild("net_list"); + // Update circuit data of net list items + std::vector circuits = gMessageSystem->getCircuit()->getCircuitDataList(); + std::vector::iterator circuits_end = circuits.end(); + for(std::vector::iterator iter = circuits.begin(); iter != circuits_end; ++iter) + { + LLNetListItem* itemp = findNetListItem((*iter)->getHost()); + if(!itemp) + { + LLUUID id; id.generate(); + itemp = new LLNetListItem(id); + sNetListItems.push_back(itemp); + } + itemp->mCircuitData = (*iter); + } + // Clear circuit data of items whose circuits are gone + std::list::iterator items_end = sNetListItems.end(); + for(std::list::iterator iter = sNetListItems.begin(); iter != items_end; ++iter) + { + if(std::find(circuits.begin(), circuits.end(), (*iter)->mCircuitData) == circuits.end()) + (*iter)->mCircuitData = NULL; + } + // Remove net list items that are totally useless now + for(std::list::iterator iter = sNetListItems.begin(); iter != sNetListItems.end();) + { + if((*iter)->mCircuitData == NULL) + iter = sNetListItems.erase(iter); + else ++iter; + } + // Update names of net list items + items_end = sNetListItems.end(); + for(std::list::iterator iter = sNetListItems.begin(); iter != items_end; ++iter) + { + LLNetListItem* itemp = (*iter); + if(itemp->mAutoName) + { + if(itemp->mCircuitData) + { + LLViewerRegion* regionp = LLWorld::getInstance()->getRegion(itemp->mCircuitData->getHost()); + if(regionp) + { + std::string name = regionp->getName(); + if(name == "") name = llformat("%s (awaiting region name)", itemp->mCircuitData->getHost().getString().c_str()); + itemp->mName = name; + itemp->mPreviousRegionName = name; + } + else + { + itemp->mName = itemp->mCircuitData->getHost().getString(); + if(itemp->mPreviousRegionName != "") + itemp->mName.append(llformat(" (was %s)", itemp->mPreviousRegionName.c_str())); + } + } + else + { + // an item just for an event queue, not handled yet + itemp->mName = "Something else"; + } + } + } + // Rebuild scroll list from scratch + LLUUID selected_id = scrollp->getFirstSelected() ? scrollp->getFirstSelected()->getUUID() : LLUUID::null; + S32 scroll_pos = scrollp->getScrollPos(); + scrollp->clearRows(); + for(std::list::iterator iter = sNetListItems.begin(); iter != items_end; ++iter) + { + LLNetListItem* itemp = (*iter); + LLSD element; + element["id"] = itemp->mID; + LLSD& text_column = element["columns"][0]; + text_column["column"] = "text"; + text_column["value"] = itemp->mName + (itemp->mCircuitData->getHost() == gAgent.getRegionHost() ? " (main)" : ""); + for(int i = 0; i < 2; i++) + { + LLSD& icon_column = element["columns"][i + 1]; + icon_column["column"] = llformat("icon%d", i); + icon_column["type"] = "icon"; + icon_column["value"] = ""; + } + LLScrollListItem* scroll_itemp = scrollp->addElement(element); + BOOL has_live_circuit = itemp->mCircuitData && itemp->mCircuitData->isAlive(); + if(has_live_circuit) + { + LLScrollListIcon* icon = (LLScrollListIcon*)scroll_itemp->getColumn(1); + icon->setValue("icon_net_close_circuit.tga"); + icon->setClickCallback(onClickCloseCircuit, itemp); + } + else + { + LLScrollListIcon* icon = (LLScrollListIcon*)scroll_itemp->getColumn(1); + icon->setValue("icon_net_close_circuit_gray.tga"); + icon->setClickCallback(NULL, NULL); + } + // Event queue isn't even supported yet... FIXME + LLScrollListIcon* icon = (LLScrollListIcon*)scroll_itemp->getColumn(2); + icon->setValue("icon_net_close_eventpoll_gray.tga"); + icon->setClickCallback(NULL, NULL); + } + if(selected_id.notNull()) scrollp->selectByID(selected_id); + if(scroll_pos < scrollp->getItemCount()) scrollp->setScrollPos(scroll_pos); +} +void LLFloaterMessageLog::refreshNetInfo(BOOL force) +{ + if(mNetInfoMode != NI_NET) return; + LLScrollListCtrl* scrollp = getChild("net_list"); + LLScrollListItem* selected_itemp = scrollp->getFirstSelected(); + if(selected_itemp) + { + if(!force) if(getChild("net_info")->hasSelection()) return; + LLNetListItem* itemp = findNetListItem(selected_itemp->getUUID()); + if(itemp) + { + std::string info(llformat("%s\n--------------------------------\n\n", itemp->mName.c_str())); + if(itemp->mCircuitData) + { + LLCircuitData* cdp = itemp->mCircuitData; + info.append("Circuit\n--------------------------------\n"); + info.append(llformat(" * Host: %s\n", cdp->getHost().getString().c_str())); + S32 seconds = (S32)cdp->getAgeInSeconds(); + S32 minutes = seconds / 60; + seconds = seconds % 60; + S32 hours = minutes / 60; + minutes = minutes % 60; + info.append(llformat(" * Age: %dh %dm %ds\n", hours, minutes, seconds)); + info.append(llformat(" * Alive: %s\n", cdp->isAlive() ? "yes" : "no")); + info.append(llformat(" * Blocked: %s\n", cdp->isBlocked() ? "yes" : "no")); + info.append(llformat(" * Allow timeout: %s\n", cdp->getAllowTimeout() ? "yes" : "no")); + info.append(llformat(" * Trusted: %s\n", cdp->getTrusted() ? "yes" : "no")); + info.append(llformat(" * Ping delay: %d\n", cdp->getPingDelay())); + info.append(llformat(" * Packets out: %d\n", cdp->getPacketsOut())); + info.append(llformat(" * Bytes out: %d\n", cdp->getBytesOut())); + info.append(llformat(" * Packets in: %d\n", cdp->getPacketsIn())); + info.append(llformat(" * Bytes in: %d\n", cdp->getBytesIn())); + info.append(llformat(" * Endpoint ID: %s\n", cdp->getLocalEndPointID().asString().c_str())); + info.append(llformat(" * Remote ID: %s\n", cdp->getRemoteID().asString().c_str())); + info.append(llformat(" * Remote session ID: %s\n", cdp->getRemoteSessionID().asString().c_str())); + } + childSetText("net_info", info); + } + else childSetText("net_info", std::string("")); + } + else childSetText("net_info", std::string("")); +} +void LLFloaterMessageLog::setNetInfoMode(ENetInfoMode mode) +{ + mNetInfoMode = mode; + if(mNetInfoMode == NI_NET) + refreshNetInfo(TRUE); + childSetEnabled("send_to_message_builder_btn", mNetInfoMode == NI_LOG); +} +// static +void LLFloaterMessageLog::onLog(LLMessageLogEntry entry) +{ + //don't mess with the queue while a filter's being applied, or face invalid iterators + if(!sBusyApplyingFilter) + { + sMessageLogEntries.push_back(entry); + conditionalLog(LLFloaterMessageLogItem(entry)); + } +} +// static +void LLFloaterMessageLog::conditionalLog(LLFloaterMessageLogItem item) +{ + if(!sBusyApplyingFilter) + sInstance->childSetText("log_status_text", llformat("Showing %d messages from %d", sFloaterMessageLogItems.size(), sMessageLogEntries.size())); + std::string find_name = item.mName; + LLStringUtil::toLower(find_name); + if(sMessageLogFilter.mPositiveNames.size()) + if(std::find(sMessageLogFilter.mPositiveNames.begin(), sMessageLogFilter.mPositiveNames.end(), find_name) == sMessageLogFilter.mPositiveNames.end()) + return; + if(std::find(sMessageLogFilter.mNegativeNames.begin(), sMessageLogFilter.mNegativeNames.end(), find_name) != sMessageLogFilter.mNegativeNames.end()) + return; + sFloaterMessageLogItems.push_back(item); // moved from beginning... + BOOL outgoing = item.isOutgoing(); + std::string net_name("\?\?\?"); + if(item.mType == LLFloaterMessageLogItem::TEMPLATE) + { + LLHost find_host = outgoing ? item.mToHost : item.mFromHost; + net_name = find_host.getIPandPort(); + std::list::iterator end = sNetListItems.end(); + for(std::list::iterator iter = sNetListItems.begin(); iter != end; ++iter) + { + if((*iter)->mCircuitData->getHost() == find_host) + { + net_name = (*iter)->mName; + break; + } + } + } + LLSD element; + element["id"] = item.mID; + LLSD& sequence_column = element["columns"][0]; + sequence_column["column"] = "sequence"; + sequence_column["value"] = llformat("%u", item.mSequenceID); + LLSD& type_column = element["columns"][1]; + type_column["column"] = "type"; + type_column["value"] = item.mType == LLFloaterMessageLogItem::TEMPLATE ? "UDP" : "\?\?\?"; + LLSD& direction_column = element["columns"][2]; + direction_column["column"] = "direction"; + direction_column["value"] = outgoing ? "to" : "from"; + LLSD& net_column = element["columns"][3]; + net_column["column"] = "net"; + net_column["value"] = net_name; + LLSD& name_column = element["columns"][4]; + name_column["column"] = "name"; + name_column["value"] = item.mName; + /* + LLSD& zer_column = element["columns"][5]; + zer_column["column"] = "flag_zer"; + zer_column["type"] = "icon"; + zer_column["value"] = (item.mFlags & LL_ZERO_CODE_FLAG) ? "flag_zer.tga" : ""; + LLSD& rel_column = element["columns"][6]; + rel_column["column"] = "flag_rel"; + rel_column["type"] = "icon"; + rel_column["value"] = (item.mFlags & LL_RELIABLE_FLAG) ? "flag_rel.tga" : ""; + LLSD& rsd_column = element["columns"][7]; + rsd_column["column"] = "flag_rsd"; + rsd_column["type"] = "icon"; + rsd_column["value"] = (item.mFlags & LL_RESENT_FLAG) ? "flag_rsd.tga" : ""; + LLSD& ack_column = element["columns"][8]; + ack_column["column"] = "flag_ack"; + ack_column["type"] = "icon"; + ack_column["value"] = (item.mFlags & LL_ACK_FLAG) ? "flag_ack.tga" : ""; + */ + LLSD& summary_column = element["columns"][5]; + summary_column["column"] = "summary"; + summary_column["value"] = item.mSummary; + LLScrollListCtrl* scrollp = sInstance->getChild("message_log"); + S32 scroll_pos = scrollp->getScrollPos(); + scrollp->addElement(element); + if(scroll_pos > scrollp->getItemCount() - scrollp->getPageLines() - 4) + scrollp->setScrollPos(scrollp->getItemCount()); +} +// static +void LLFloaterMessageLog::onCommitNetList(LLUICtrl* ctrl, void* user_data) +{ + LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data; + floaterp->setNetInfoMode(NI_NET); + floaterp->refreshNetInfo(TRUE); +} +// static +void LLFloaterMessageLog::onCommitMessageLog(LLUICtrl* ctrl, void* user_data) +{ + LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data; + LLScrollListCtrl* scrollp = floaterp->getChild("message_log"); + LLScrollListItem* selected_itemp = scrollp->getFirstSelected(); + if(!selected_itemp) return; + LLUUID id = selected_itemp->getUUID(); + std::vector::iterator end = sFloaterMessageLogItems.end(); + for(std::vector::iterator iter = sFloaterMessageLogItems.begin(); iter != end; ++iter) + { + if(iter->mID == id) + { + floaterp->setNetInfoMode(NI_LOG); + floaterp->childSetText("net_info", iter->getFull(FALSE)); + break; + } + } +} +// static +BOOL LLFloaterMessageLog::onClickCloseCircuit(void* user_data) +{ + LLNetListItem* itemp = (LLNetListItem*)user_data; + LLCircuitData* cdp = (LLCircuitData*)itemp->mCircuitData; + if(!cdp) return FALSE; + LLHost myhost = cdp->getHost(); + LLSD args; + args["MESSAGE"] = "This will delete local circuit data.\nDo you want to tell the remote host to close the circuit too?"; + LLSD payload; + payload["circuittoclose"] = myhost.getString(); + LLNotifications::instance().add("GenericAlertYesCancel", args, payload, onConfirmCloseCircuit); + return TRUE; +} +// static +bool LLFloaterMessageLog::onConfirmCloseCircuit(const LLSD& notification, const LLSD& response ) +{ + S32 option = LLNotification::getSelectedOption(notification, response); + LLCircuitData* cdp = gMessageSystem->mCircuitInfo.findCircuit(LLHost(notification["payload"]["circuittoclose"].asString())); + if(!cdp) return false; + LLViewerRegion* regionp = LLWorld::getInstance()->getRegion(cdp->getHost()); + switch(option) + { + case 0: // yes + gMessageSystem->newMessageFast(_PREHASH_CloseCircuit); + gMessageSystem->sendReliable(cdp->getHost()); + break; + case 2: // cancel + return false; + break; + case 1: // no + default: + break; + } + if(gMessageSystem->findCircuitCode(cdp->getHost())) + gMessageSystem->disableCircuit(cdp->getHost()); + else + gMessageSystem->getCircuit()->removeCircuitData(cdp->getHost()); + if(regionp) + { + LLHost myhost = regionp->getHost(); + LLSD args; + args["MESSAGE"] = "That host had a region associated with it.\nDo you want to clean that up?"; + LLSD payload; + payload["regionhost"] = myhost.getString(); + LLNotifications::instance().add("GenericAlertYesCancel", args, payload, onConfirmRemoveRegion); + } + return false; +} +// static +bool LLFloaterMessageLog::onConfirmRemoveRegion(const LLSD& notification, const LLSD& response ) +{ + S32 option = LLNotification::getSelectedOption(notification, response); + if(option == 0) // yes + LLWorld::getInstance()->removeRegion(LLHost(notification["payload"]["regionhost"].asString())); + return false; +} +// static +void LLFloaterMessageLog::onClickFilterApply(void* user_data) +{ + LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data; + floaterp->startApplyingFilter(floaterp->childGetValue("filter_edit"), FALSE); +} +void LLFloaterMessageLog::startApplyingFilter(std::string filter, BOOL force) +{ + LLMessageLogFilter new_filter = LLMessageLogFilter(); + sMessageLogFilterString = filter; + new_filter.set(sMessageLogFilterString); + if(!filter.length() || filter.at(filter.length()-1) != ' ') + childSetText("filter_edit", filter + " "); + if(force + || (new_filter.mNegativeNames != sMessageLogFilter.mNegativeNames) + || (new_filter.mPositiveNames != sMessageLogFilter.mPositiveNames)) + { + stopApplyingFilter(); + sMessageLogFilter = new_filter; + sFloaterMessageLogItems.clear(); + getChild("message_log")->clearRows(); + sBusyApplyingFilter = TRUE; + childSetVisible("message_log", false); + //childSetVisible("log_status_text", true); + mMessageLogFilterApply = new LLMessageLogFilterApply(); + } +} +void LLFloaterMessageLog::stopApplyingFilter() +{ + if(mMessageLogFilterApply) + { + if(!(mMessageLogFilterApply->mFinished)) + mMessageLogFilterApply->cancel(); + //delete mMessageLogFilterApply; + sBusyApplyingFilter = FALSE; + //childSetVisible("log_status_text", false); + childSetVisible("message_log", true); + childSetText("log_status_text", llformat("Showing %d messages from %d", sFloaterMessageLogItems.size(), sMessageLogEntries.size())); + } +} +void LLFloaterMessageLog::updateFilterStatus() +{ + if(!mMessageLogFilterApply || !sBusyApplyingFilter) return; + S32 progress = mMessageLogFilterApply->mProgress; + S32 packets = sMessageLogEntries.size(); + S32 matches = sFloaterMessageLogItems.size(); + std::string text = llformat("Applying filter ( %d / %d ), %d matches ...", progress, packets, matches); + childSetText("log_status_text", text); +} +// static +void LLFloaterMessageLog::onCommitFilter(LLUICtrl* ctrl, void* user_data) +{ + LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data; + floaterp->startApplyingFilter(floaterp->childGetValue("filter_edit"), FALSE); +} +// static +void LLFloaterMessageLog::onClickClearLog(void* user_data) +{ + LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data; + floaterp->stopApplyingFilter(); + floaterp->getChild("message_log")->clearRows(); + floaterp->setNetInfoMode(NI_NET); + sMessageLogEntries.clear(); + sFloaterMessageLogItems.clear(); +} +// static +void LLFloaterMessageLog::onClickFilterChoice(void* user_data) +{ + LLMenuGL* menu = new LLMenuGL(LLStringUtil::null); + menu->append(new LLMenuItemCallGL("No filter", onClickFilterMenu, NULL, (void*)"")); + menu->append(new LLMenuItemCallGL("Fewer spammy messages", onClickFilterMenu, NULL, (void*)"!StartPingCheck !CompletePingCheck !PacketAck !SimulatorViewerTimeMessage !SimStats !AgentUpdate !AgentAnimation !AvatarAnimation !ViewerEffect !CoarseLocationUpdate !LayerData !CameraConstraint !ObjectUpdateCached !RequestMultipleObjects !ObjectUpdate !ObjectUpdateCompressed !ImprovedTerseObjectUpdate !KillObject !ImagePacket !SendXferPacket !ConfirmXferPacket !TransferPacket")); + menu->append(new LLMenuItemCallGL("Fewer spammy messages (minus sound crap)", onClickFilterMenu, NULL, (void*)"!StartPingCheck !CompletePingCheck !PacketAck !SimulatorViewerTimeMessage !SimStats !AgentUpdate !AgentAnimation !AvatarAnimation !ViewerEffect !CoarseLocationUpdate !LayerData !CameraConstraint !ObjectUpdateCached !RequestMultipleObjects !ObjectUpdate !ObjectUpdateCompressed !ImprovedTerseObjectUpdate !KillObject !ImagePacket !SendXferPacket !ConfirmXferPacket !TransferPacket !SoundTrigger !AttachedSound !PreloadSound")); + menu->append(new LLMenuItemCallGL("Object updates", onClickFilterMenu, NULL, (void*)"ObjectUpdateCached ObjectUpdate ObjectUpdateCompressed ImprovedTerseObjectUpdate KillObject RequestMultipleObjects")); + menu->append(new LLMenuItemCallGL("Abnormal", onClickFilterMenu, NULL, (void*)"Invalid TestMessage AddCircuitCode NeighborList AvatarTextureUpdate SimulatorMapUpdate SimulatorSetMap SubscribeLoad UnsubscribeLoad SimulatorReady SimulatorPresentAtLocation SimulatorLoad SimulatorShutdownRequest RegionPresenceRequestByRegionID RegionPresenceRequestByHandle RegionPresenceResponse UpdateSimulator LogDwellTime FeatureDisabled LogFailedMoneyTransaction UserReportInternal SetSimStatusInDatabase SetSimPresenceInDatabase OpenCircuit CloseCircuit DirFindQueryBackend DirPlacesQueryBackend DirClassifiedQueryBackend DirLandQueryBackend DirPopularQueryBackend GroupNoticeAdd DataHomeLocationRequest DataHomeLocationReply DerezContainer ObjectCategory ObjectExportSelected StateSave ReportAutosaveCrash AgentAlertMessage NearestLandingRegionRequest NearestLandingRegionReply NearestLandingRegionUpdated TeleportLandingStatusChanged ConfirmEnableSimulator KickUserAck SystemKickUser AvatarPropertiesRequestBackend UpdateParcel RemoveParcel MergeParcel LogParcelChanges CheckParcelSales ParcelSales StartAuction ConfirmAuctionStart CompleteAuction CancelAuction CheckParcelAuctions ParcelAuctions ChatPass EdgeDataPacket SimStatus ChildAgentUpdate ChildAgentAlive ChildAgentPositionUpdate ChildAgentDying ChildAgentUnknown AtomicPassObject KillChildAgents ScriptSensorRequest ScriptSensorReply DataServerLogout RequestInventoryAsset InventoryAssetResponse TransferInventory TransferInventoryAck EventLocationRequest EventLocationReply MoneyTransferBackend RoutedMoneyBalanceReply SetStartLocation NetTest SetCPURatio SimCrashed NameValuePair RemoveNameValuePair UpdateAttachment RemoveAttachment EmailMessageRequest EmailMessageReply InternalScriptMail ScriptDataRequest ScriptDataReply InviteGroupResponse TallyVotes LiveHelpGroupRequest LiveHelpGroupReply GroupDataUpdate LogTextMessage CreateTrustedCircuit ParcelRename SystemMessage RpcChannelRequest RpcChannelReply RpcScriptRequestInbound RpcScriptRequestInboundForward RpcScriptReplyInbound ScriptMailRegistration Error")); + menu->updateParent(LLMenuGL::sMenuContainer); + menu->setCanTearOff(FALSE); + LLView* buttonp = sInstance->getChild("filter_choice_btn"); + S32 x = buttonp->getRect().mLeft; + S32 y = buttonp->getRect().mBottom; + LLMenuGL::showPopup(sInstance, menu, x, y); +} +// static +void LLFloaterMessageLog::onClickFilterMenu(void* user_data) +{ + std::string filter = std::string((char*)user_data); + sInstance->childSetText("filter_edit", filter); + sInstance->startApplyingFilter(filter, FALSE); +} +// static +void LLFloaterMessageLog::onClickSendToMessageBuilder(void* user_data) +{ + LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data; + LLScrollListCtrl* scrollp = floaterp->getChild("message_log"); + LLScrollListItem* selected_itemp = scrollp->getFirstSelected(); + if(!selected_itemp) return; + LLUUID id = selected_itemp->getUUID(); + std::vector::iterator end = sFloaterMessageLogItems.end(); + for(std::vector::iterator iter = sFloaterMessageLogItems.begin(); iter != end; ++iter) + { + if(iter->mID == id) + { + std::string message_text = iter->getFull(FALSE); + LLFloaterMessageBuilder::show(message_text); + break; + } + } +} +// diff --git a/linden/indra/newview/llfloatermessagelog.h b/linden/indra/newview/llfloatermessagelog.h new file mode 100644 index 0000000..ebc4f2a --- /dev/null +++ b/linden/indra/newview/llfloatermessagelog.h @@ -0,0 +1,84 @@ +// +#include "llfloater.h" +#include "llmessagelog.h" +#include "lltemplatemessagereader.h" +#include "llfloatermessagebuilder.h" + +class LLFloaterMessageLogItem : public LLMessageLogEntry +{ +public: + LLFloaterMessageLogItem(LLMessageLogEntry entry); + ~LLFloaterMessageLogItem(); + LLUUID mID; + U32 mSequenceID; + std::string mName; + std::string mSummary; + U32 mFlags; + std::string getFull(BOOL show_header = TRUE); + BOOL isOutgoing(); +private: + static LLTemplateMessageReader* sTemplateMessageReader; + static std::string getString(LLTemplateMessageReader* readerp, const char* block_name, S32 block_num, const char* var_name, e_message_variable_type var_type, BOOL &returned_hex, BOOL summary_mode = FALSE); +}; +class LLMessageLogFilter +{ +public: + LLMessageLogFilter(); + ~LLMessageLogFilter(); + BOOL set(std::string filter); + std::list mPositiveNames; + std::list mNegativeNames; +}; +class LLMessageLogFilterApply : public LLEventTimer +{ +public: + LLMessageLogFilterApply(); + void cancel(); + BOOL tick(); + S32 mProgress; + BOOL mFinished; +private: + std::deque mQueuedMessages; + std::deque::iterator mIter; +}; +class LLFloaterMessageLog : public LLFloater, public LLEventTimer +{ +public: + LLFloaterMessageLog(); + ~LLFloaterMessageLog(); + static void show(); + BOOL postBuild(); + BOOL tick(); + LLNetListItem* findNetListItem(LLHost host); + LLNetListItem* findNetListItem(LLUUID id); + void refreshNetList(); + void refreshNetInfo(BOOL force); + enum ENetInfoMode { NI_NET, NI_LOG }; + void setNetInfoMode(ENetInfoMode mode); + static void onLog(LLMessageLogEntry entry); + static void conditionalLog(LLFloaterMessageLogItem item); + static void onCommitNetList(LLUICtrl* ctrl, void* user_data); + static void onCommitMessageLog(LLUICtrl* ctrl, void* user_data); + static void onCommitFilter(LLUICtrl* ctrl, void* user_data); + static BOOL onClickCloseCircuit(void* user_data); + static bool onConfirmCloseCircuit(const LLSD& notification, const LLSD& response ); + static bool onConfirmRemoveRegion(const LLSD& notification, const LLSD& response ); + static void onClickFilterApply(void* user_data); + void startApplyingFilter(std::string filter, BOOL force); + void stopApplyingFilter(); + void updateFilterStatus(); + static BOOL sBusyApplyingFilter; + LLMessageLogFilterApply* mMessageLogFilterApply; + static void onClickClearLog(void* user_data); + static LLFloaterMessageLog* sInstance; + static std::list sNetListItems; + static std::deque sMessageLogEntries; + static std::vector sFloaterMessageLogItems; + static LLMessageLogFilter sMessageLogFilter; + static std::string sMessageLogFilterString; + ENetInfoMode mNetInfoMode; + static void onClickFilterChoice(void* user_data); + static void onClickFilterMenu(void* user_data); + static void onClickSendToMessageBuilder(void* user_data); +}; +// diff --git a/linden/indra/newview/llviewermenu.cpp b/linden/indra/newview/llviewermenu.cpp index 524654a..3e502c0 100644 --- a/linden/indra/newview/llviewermenu.cpp +++ b/linden/indra/newview/llviewermenu.cpp @@ -121,6 +121,8 @@ #include "llfloaterland.h" #include "llfloaterlandholdings.h" #include "llfloatermap.h" +#include "llfloatermessagebuilder.h" +#include "llfloatermessagelog.h" #include "llfloatermute.h" #include "llfloateropenobject.h" #include "llfloaterpermissionsmgr.h" @@ -394,6 +396,8 @@ void handle_god_mode(void*); // God menu void handle_leave_god_mode(void*); +void handle_open_message_log(void*); +void handle_open_message_builder(void*); BOOL is_inventory_visible( void* user_data ); void handle_reset_view(); @@ -778,6 +782,11 @@ void init_client_menu(LLMenuGL* menu) sub->appendSeparator(); + sub->append(new LLMenuItemCallGL( "Message Log", &handle_open_message_log, NULL)); + sub->append(new LLMenuItemCallGL( "Message Builder", &handle_open_message_builder, NULL)); + + sub->appendSeparator(); + sub->append(new LLMenuItemCallGL("Region Info to Debug Console", &handle_region_dump_settings, NULL)); sub->append(new LLMenuItemCallGL("Group Info to Debug Console", @@ -3280,6 +3289,16 @@ void process_grant_godlike_powers(LLMessageSystem* msg, void**) } } + +void handle_open_message_log(void*) +{ + LLFloaterMessageLog::show(); +} + +void handle_open_message_builder(void*) +{ + LLFloaterMessageBuilder::show(""); +} /* class LLHaveCallingcard : public LLInventoryCollectFunctor { @@ -8672,6 +8691,30 @@ class LLAdvancedDumpInfoToConsole : public view_listener_t +///////////////////////// +// MESSAGE LOG/BUILDER // +///////////////////////// + + +class LLMessageLogBuilder : public view_listener_t +{ + bool handleEvent(LLPointer event, const LLSD& userdata) + { + std::string info_type = userdata.asString(); + if ("MessageLog" == info_type) + { + handle_open_message_log(NULL); + } + else if ("MessageBuilder" == info_type) + { + handle_open_message_builder(NULL); + } + return true; + } +}; + + + /////////////////////////////// // RELOAD SETTINGS OVERRIDES // /////////////////////////////// @@ -11260,6 +11303,8 @@ void initialize_menus() addMenu(new LLAdvancedToggleConsole(), "Advanced.ToggleConsole"); addMenu(new LLAdvancedCheckConsole(), "Advanced.CheckConsole"); addMenu(new LLAdvancedDumpInfoToConsole(), "Advanced.DumpInfoToConsole"); + addMenu(new LLMessageLogBuilder(), "Advanced.MessageLog"); + addMenu(new LLMessageLogBuilder(), "Advanced.MessageBuilder"); addMenu(new LLAdvancedReloadSettingsOverrides(), "Advanced.ReloadSettingsOverrides"); addMenu(new LLAdvancedToggleSit(), "Advanced.ToggleSit"); addMenu(new LLAdvancedCheckSit(), "Advanced.CheckSit"); diff --git a/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml b/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml index c85dd47..53e9e2d 100644 --- a/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml +++ b/linden/indra/newview/skins/default/xui/en-us/menu_viewer.xml @@ -908,6 +908,15 @@ userdata="notifications" /> + + + + + + +