1 files changed, 219 insertions, 54 deletions

diff --git a/linden/indra/newview/llviewerparcelmedia.cpp b/linden/indra/newview/llviewerparcelmedia.cpp
index a5d97f2..386a86e 100644
--- a/linden/indra/newview/llviewerparcelmedia.cpp
+++ b/linden/indra/newview/llviewerparcelmedia.cpp
@@ -49,6 +49,7 @@
 #include "llpluginclassmedia.h"
 #include "llnotify.h"
 #include "llsdserialize.h"
+#include "llmemory.h"
 
 #include "lloverlaybar.h"
 #include "slfloatermediafilter.h"
@@ -64,6 +65,7 @@ LLSD LLViewerParcelMedia::sMediaFilterList;
 std::set<std::string> LLViewerParcelMedia::sMediaQueries;
 std::set<std::string> LLViewerParcelMedia::sAllowedMedia;
 std::set<std::string> LLViewerParcelMedia::sDeniedMedia;
+LLPointer<LLViewerParcelMediaInfo> LLViewerParcelMedia::sSavedMediaInfo;
 
 // Local functions
 bool callback_play_media(const LLSD& notification, const LLSD& response, LLParcel* parcel);
@@ -186,7 +188,7 @@ void LLViewerParcelMedia::update(LLParcel* parcel)
 }
 
 // static
-void LLViewerParcelMedia::play(LLParcel* parcel, bool filter)
+void LLViewerParcelMedia::play(LLParcel* parcel, bool filter, const ECommandOrigin origin)
 {
         lldebugs << "LLViewerParcelMedia::play" << llendl;
 
@@ -198,12 +200,13 @@ void LLViewerParcelMedia::play(LLParcel* parcel, bool filter)
         std::string media_url = parcel->getMediaURL();
         LLStringUtil::trim(media_url);
 
-        if (!media_url.empty() && gSavedSettings.getBOOL("MediaEnableFilter") && (filter || !allowedMedia(media_url)))
+        if (!media_url.empty() && gSavedSettings.getBOOL("MediaEnableFilter") && filter
+                && (!allowedMedia(media_url) || origin == COMMAND_ORIGIN_REMOTE))
         {
                 // If filtering is needed or in case media_url just changed
                 // to something we did not yet approve.
                 LLViewerParcelMediaAutoPlay::playStarted();
-                filterMedia(parcel, 0);
+                filterMedia(parcel, 0, origin);
                 return;
         }
 
@@ -384,7 +387,7 @@ void LLViewerParcelMedia::processParcelMediaCommandMessage( LLMessageSystem *msg
                         else
                         {
                                 LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
-                                play(parcel);
+                                play(parcel, true, COMMAND_ORIGIN_REMOTE);
                         }
                 }
                 else
@@ -400,7 +403,7 @@ void LLViewerParcelMedia::processParcelMediaCommandMessage( LLMessageSystem *msg
                 if(sMediaImpl.isNull())
                 {
                         LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
-                        play(parcel);
+                        play(parcel, true, COMMAND_ORIGIN_REMOTE);
                 }
                 seek(time);
         }
@@ -437,33 +440,38 @@ void LLViewerParcelMedia::processParcelMediaUpdate( LLMessageSystem *msg, void *
         }
 
         LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
-        BOOL same = FALSE;
         if (parcel)
         {
-                same = ((parcel->getMediaURL() == media_url) &&
-                                (parcel->getMediaType() == media_type) &&
-                                (parcel->getMediaID() == media_id) &&
-                                (parcel->getMediaWidth() == media_width) &&
-                                (parcel->getMediaHeight() == media_height) &&
-                                (parcel->getMediaAutoScale() == media_auto_scale) &&
-                                (parcel->getMediaLoop() == media_loop));
-
-                if (!same)
+                LLViewerParcelMediaInfo* new_info = new LLViewerParcelMediaInfo(media_url, media_type, media_id, media_width, media_height, media_auto_scale, media_loop);
+                LLViewerParcelMediaInfo* current_info = new LLViewerParcelMediaInfo(parcel);
+                if (new_info != current_info)
                 {
+                        if (!sSavedMediaInfo || (sSavedMediaInfo && !sSavedMediaInfo->sameParcel(parcel)))
+                        {
+                                // only save if no previously saved media info, because
+                                // we want to remeber the original parcel media info.
+                                sSavedMediaInfo = current_info;
+                        }
                         // temporarily store these new values in the parcel
-                        parcel->setMediaURL(media_url);
-                        parcel->setMediaType(media_type);
-                        parcel->setMediaID(media_id);
-                        parcel->setMediaWidth(media_width);
-                        parcel->setMediaHeight(media_height);
-                        parcel->setMediaAutoScale(media_auto_scale);
-                        parcel->setMediaLoop(media_loop);
+                        new_info->applyToParcel(parcel);
 
-                        play(parcel);
+                        play(parcel, true, COMMAND_ORIGIN_REMOTE);
                 }
 
         }
 }
+
+//static
+void LLViewerParcelMedia::undoParcelMediaUpdate()
+{
+        LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
+        if (sSavedMediaInfo.notNull() && parcel)
+        {
+                sSavedMediaInfo->applyToParcel(parcel);
+        }
+        sSavedMediaInfo = NULL;
+}
+
 // Static
 /////////////////////////////////////////////////////////////////////////////////////////
 void LLViewerParcelMedia::sendMediaNavigateMessage(const std::string& url)
@@ -619,7 +627,7 @@ void LLViewerParcelMedia::playStreamingMusic(LLParcel* parcel, bool filter)
         {
                 // If filtering is needed or in case music_url just changed
                 // to something we did not yet approve.
-                filterMedia(parcel, 1);
+                filterMedia(parcel, 1, COMMAND_ORIGIN_LOCAL);
         }
         else if (gAudioStream)
         {
@@ -649,13 +657,18 @@ bool LLViewerParcelMedia::allowedMedia(std::string media_url)
 {
         LLStringUtil::trim(media_url);
         std::string domain = extractDomain(media_url);
+        LLHost host;
+        host.setHostByName(domain);
+        std::string ip = host.getIPString();
         if (sAllowedMedia.count(domain))
         {
                 return true;
         }
+        std::string server;
         for (S32 i = 0; i < (S32)sMediaFilterList.size(); i++)
         {
-                if (sMediaFilterList[i]["domain"].asString() == domain)
+                server = sMediaFilterList[i]["domain"].asString();
+                if (server == domain || server == ip)
                 {
                         if (sMediaFilterList[i]["action"].asString() == "allow")
                         {
@@ -670,12 +683,13 @@ bool LLViewerParcelMedia::allowedMedia(std::string media_url)
         return false;
 }
 
-void LLViewerParcelMedia::filterMedia(LLParcel* parcel, U32 type)
+void LLViewerParcelMedia::filterMedia(LLParcel* parcel, U32 type, const ECommandOrigin origin)
 {
         std::string media_action;
         std::string media_url;
         std::string domain;
-
+        std::string ip;
+        
         if (parcel != LLViewerParcelMgr::getInstance()->getAgentParcel())
         {
                 // The parcel just changed (may occur right out after a TP)
@@ -703,31 +717,51 @@ void LLViewerParcelMedia::filterMedia(LLParcel* parcel, U32 type)
                 return;
         }
 
+        LLHost host;
+        host.setHostByName(domain);
+        ip = host.getIPString();
+
         if (sIsUserAction)
         {
                 // This was a user manual request to play this media, so give
                 // it another chance...
                 sIsUserAction = false;
+                bool dirty = false;
                 if (sDeniedMedia.count(domain))
                 {
                         sDeniedMedia.erase(domain);
+                        dirty = true;
+                }
+                if (sDeniedMedia.count(ip))
+                {
+                        sDeniedMedia.erase(ip);
+                        dirty = true;
+                }
+                if (dirty)
+                {
                         SLFloaterMediaFilter::setDirty();
                 }
         }
 
-        if (!sMediaFilterListLoaded || sDeniedMedia.count(domain))
+        if (media_url.empty())
+        {
+                media_action == "allow";
+        }
+        else if (!sMediaFilterListLoaded || sDeniedMedia.count(domain) || sDeniedMedia.count(ip))
         {
                 media_action = "ignore";
         }
-        else if (sAllowedMedia.count(domain))
+        else if (sAllowedMedia.count(domain) || sAllowedMedia.count(ip))
         {
                 media_action = "allow";
         }
         else
         {
+                std::string server;
                 for (S32 i = 0; i < (S32)sMediaFilterList.size(); i++)
                 {
-                        if (sMediaFilterList[i]["domain"].asString() == domain)
+                        server = sMediaFilterList[i]["domain"].asString();
+                        if (server == domain || server == ip)
                         {
                                 media_action = sMediaFilterList[i]["action"].asString();
                                 break;
@@ -735,7 +769,7 @@ void LLViewerParcelMedia::filterMedia(LLParcel* parcel, U32 type)
                 }
         }
 
-        if (media_action == "allow" || media_url.empty())
+        if (media_action == "allow")
         {
                 if (type == 0)
                 {
@@ -745,47 +779,76 @@ void LLViewerParcelMedia::filterMedia(LLParcel* parcel, U32 type)
                 {
                         playStreamingMusic(parcel, false);
                 }
+                return;
         }
-        else if (media_action == "deny")
+        if (media_action == "ignore")
         {
-                LLSD args;
-                args["DOMAIN"] = domain;
-                LLNotifications::instance().add("MediaBlocked", args);
-                if (type == 1)
+                if (type == 0)
+                {
+                        undoParcelMediaUpdate();
+                }
+                else if (type == 1)
                 {
                         LLViewerParcelMedia::stopStreamingMusic();
                 }
-                // So to avoid other "blocked" messages later in the session
-                // for this url should it be requested again by a script.
-                sDeniedMedia.insert(domain);
+                return;
         }
-        else if (media_action == "ignore")
+        // skip local-originating play commands, unless the url is blacklisted.
+        if (gSavedSettings.getBOOL("MediaFilterOnlyRemoteCommands")
+                && (origin != COMMAND_ORIGIN_REMOTE)
+                && (media_action != "ignore"))
         {
-                if (type == 1)
+                sAllowedMedia.insert(domain);
+                SLFloaterMediaFilter::setDirty();
+                if (type == 0)
                 {
-                        LLViewerParcelMedia::stopStreamingMusic();
+                        play(parcel, false);
                 }
+                else
+                {
+                        playStreamingMusic(parcel, false);
+                }
+                return;
+        }
+
+        LLSD args;
+        if (ip != domain && domain.find('/') == std::string::npos)
+        {
+                args["DOMAIN"] = domain + " (" + ip + ")";
         }
         else
         {
-                sMediaQueries.insert(domain);
-                LLSD args;
                 args["DOMAIN"] = domain;
-                if (media_url.find('?') != std::string::npos)
+        }
+
+        if (media_action == "deny")
+        {
+                LLNotifications::instance().add("MediaBlocked", args);
+                if (type == 0)
                 {
-                        args["WARNING"] = " (WARNING: this URL also contains parameter(s) that could potentially be used to correlate your avatar name with your IP)";
+                        undoParcelMediaUpdate();
                 }
-                else
+                if (type == 1)
                 {
-                        args["WARNING"] = "";
+                        LLViewerParcelMedia::stopStreamingMusic();
                 }
+                // So to avoid other "blocked" messages later in the session
+                // for this url should it be requested again by a script.
+                // We don't add the IP, on purpose (want to show different
+                // blocks for different domains pointing to the same IP).
+                sDeniedMedia.insert(domain);
+        }
+        else
+        {
+                sMediaQueries.insert(domain);
+                args["URL"] = media_url;
                 if (type == 0)
                 {
-                        args["TYPE"] = "a media";
+                        args["TYPE"] = "media";
                 }
                 else
                 {
-                        args["TYPE"] = "an audio";
+                        args["TYPE"] = "audio";
                 }
                 LLNotifications::instance().add("MediaAlert", args, LLSD(), boost::bind(callback_media_alert, _1, _2, parcel, type, domain));
         }
@@ -795,8 +858,19 @@ void callback_media_alert(const LLSD &notification, const LLSD &response, LLParc
 {
         S32 option = LLNotification::getSelectedOption(notification, response);
 
+        LLHost host;
+        host.setHostByName(domain);
+        std::string ip = host.getIPString();
+
         LLSD args;
-        args["DOMAIN"] = domain;
+        if (ip != domain && domain.find('/') == std::string::npos)
+        {
+                args["DOMAIN"] = domain + " (" + ip + ")";
+        }
+        else
+        {
+                args["DOMAIN"] = domain;
+        }
 
         if (option == 0 || option == 3) // Allow or Whitelist
         {
@@ -807,6 +881,11 @@ void callback_media_alert(const LLSD &notification, const LLSD &response, LLParc
                         newmedia["domain"] = domain;
                         newmedia["action"] = "allow";
                         LLViewerParcelMedia::sMediaFilterList.append(newmedia);
+                        if (ip != domain && domain.find('/') == std::string::npos)
+                        {
+                                newmedia["domain"] = ip;
+                                LLViewerParcelMedia::sMediaFilterList.append(newmedia);
+                        }
                         LLViewerParcelMedia::saveDomainFilterList();
                         args["LISTED"] = "whitelisted";
                         LLNotifications::instance().add("MediaListed", args);
@@ -823,10 +902,19 @@ void callback_media_alert(const LLSD &notification, const LLSD &response, LLParc
         else if (option == 1 || option == 2) // Deny or Blacklist
         {
                 LLViewerParcelMedia::sDeniedMedia.insert(domain);
-                if (type == 1)
+                if (ip != domain && domain.find('/') == std::string::npos)
+                {
+                        LLViewerParcelMedia::sDeniedMedia.insert(ip);
+                }
+                if (type == 0)
+                {
+                        LLViewerParcelMedia::undoParcelMediaUpdate();
+                }
+                else if (type == 1)
                 {
                         LLViewerParcelMedia::stopStreamingMusic();
                 }
+                
                 if (option == 1) // Deny
                 {
                         LLNotifications::instance().add("MediaBlocked", args);
@@ -837,6 +925,11 @@ void callback_media_alert(const LLSD &notification, const LLSD &response, LLParc
                         newmedia["domain"] = domain;
                         newmedia["action"] = "deny";
                         LLViewerParcelMedia::sMediaFilterList.append(newmedia);
+                        if (ip != domain && domain.find('/') == std::string::npos)
+                        {
+                                newmedia["domain"] = ip;
+                                LLViewerParcelMedia::sMediaFilterList.append(newmedia);
+                        }
                         LLViewerParcelMedia::saveDomainFilterList();
                         args["LISTED"] = "blacklisted";
                         LLNotifications::instance().add("MediaListed", args);
@@ -928,7 +1021,12 @@ std::string LLViewerParcelMedia::extractDomain(std::string url)
                 url = url.substr(pos + 1, count);
         }
 
-        if (url.find(gAgent.getRegion()->getHost().getHostName()) == 0 || url.find(last_region) == 0)
+        std::string current_region = gAgent.getRegion()->getHost().getHostName();
+        if (!current_region.size())
+        {
+                current_region = gAgent.getRegion()->getHost().getIPString();
+        }
+        if (url.find(current_region) == 0 || url.find(last_region) == 0)
         {
                 // This must be a scripted object rezzed in the region:
                 // extend the concept of "domain" to encompass the
@@ -937,7 +1035,7 @@ std::string LLViewerParcelMedia::extractDomain(std::string url)
 
                 // Get rid of any port number
                 pos = url.find('/');            // We earlier made sure that there's one
-                url = gAgent.getRegion()->getHost().getHostName() + url.substr(pos);
+                url = current_region + url.substr(pos);
 
                 pos = url.find('?');
                 if (pos != std::string::npos)
@@ -972,6 +1070,73 @@ std::string LLViewerParcelMedia::extractDomain(std::string url)
         // Remember this region, so to cope with requests occuring just after a
         // TP out of it.
         last_region = gAgent.getRegion()->getHost().getHostName();
+        if (!last_region.size())
+        {
+                last_region = gAgent.getRegion()->getHost().getIPString();
+        }
 
         return url;
 }
+
+LLViewerParcelMediaInfo::LLViewerParcelMediaInfo(const std::string url,
+                                                                                                 const std::string type,
+                                                                                                 const LLUUID media_id,
+                                                                                                 const S32 width,
+                                                                                                 const S32 height,
+                                                                                                 const U8 scale,
+                                                                                                 const U8 loop)
+        :
+        mMediaURL(url),
+        mMediaType(type),
+        mMediaID(media_id),
+        mMediaWidth(width),
+        mMediaHeight(height),
+        mMediaAutoScale(scale),
+        mMediaLoop(loop)
+{
+        LLParcel *parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
+        mParcelLocalID = parcel ? parcel->getLocalID() : 0;
+}
+
+LLViewerParcelMediaInfo::LLViewerParcelMediaInfo(const LLParcel* parcel)
+{
+        mMediaURL = parcel->getMediaURL();
+        mMediaType = parcel->getMediaType();
+        mMediaID = parcel->getMediaID();
+        mMediaWidth = parcel->getMediaWidth();
+        mMediaHeight = parcel->getMediaHeight();
+        mMediaAutoScale = parcel->getMediaAutoScale();
+        mMediaLoop = parcel->getMediaLoop();
+        mParcelLocalID = parcel->getLocalID();
+}
+
+void LLViewerParcelMediaInfo::applyToParcel(LLParcel* parcel)
+{
+        if (parcel && sameParcel(parcel))
+        {
+                parcel->setMediaURL(mMediaURL);
+                parcel->setMediaType(mMediaType);
+                parcel->setMediaID(mMediaID);
+                parcel->setMediaWidth(mMediaWidth);
+                parcel->setMediaHeight(mMediaHeight);
+                parcel->setMediaAutoScale(mMediaAutoScale);
+                parcel->setMediaLoop(mMediaLoop);
+        }
+}
+
+bool LLViewerParcelMediaInfo::sameParcel(const LLParcel* parcel) const
+{
+        return parcel && (parcel->getLocalID() == mParcelLocalID);
+}
+
+bool LLViewerParcelMediaInfo::operator==(const LLViewerParcelMediaInfo &rhs) const
+{
+        return  (mMediaURL == rhs.mMediaURL) &&
+                        (mMediaType == rhs.mMediaType) &&
+                        (mMediaID == rhs.mMediaID) &&
+                        (mMediaWidth == rhs.mMediaWidth) &&
+                        (mMediaHeight == rhs.mMediaHeight) &&
+                        (mMediaAutoScale == rhs.mMediaAutoScale) &&
+                        (mMediaLoop == rhs.mMediaLoop) &&
+                        (mParcelLocalID == rhs.mParcelLocalID);
+}
\ No newline at end of file