Henri Beauchamps version of Sione Lomus media filter patch.

from http://sldev.free.fr/ : "MediaFilter_v3: based on code by Sione Lomu with a couple of bugfixes by Tonya Souther, this improved patch brings media and streaming audio URLs filtering (to prevent IP ripping by so-called security systems which violate the SL TOS by catching your IP and associating your various avatars with it, thus violating your anonimity). Beside empowering your viewer with allow/deny/blacklist/whitelist functions per domain, this improved patch makes the difference between external servers (domains names filtering) and in-world servers (scripted objects with built-in HTTP servers). I also fixed various bugs, security holes and shortcomings, refactored the code and improved it, and added a whitelist/blacklist erasing function."

Imprudence changes: added "MediaFilter" debug to be able to inspect the full url and media texture uuid

1 files changed, 393 insertions, 4 deletions

diff --git a/linden/indra/newview/llviewerparcelmedia.cpp b/linden/indra/newview/llviewerparcelmedia.cpp
index d4ebbd9..a5d97f2 100644
--- a/linden/indra/newview/llviewerparcelmedia.cpp
+++ b/linden/indra/newview/llviewerparcelmedia.cpp
@@ -33,6 +33,7 @@
 #include "llviewerprecompiledheaders.h"
 #include "llviewerparcelmedia.h"
 
+#include "kokuastreamingaudio.h"
 #include "llagent.h"
 #include "llviewercontrol.h"
 #include "llviewermedia.h"
@@ -46,17 +47,27 @@
 #include "llviewerwindow.h"
 #include "llfirstuse.h"
 #include "llpluginclassmedia.h"
+#include "llnotify.h"
+#include "llsdserialize.h"
 
+#include "lloverlaybar.h"
+#include "slfloatermediafilter.h"
+#include "llinventorymodel.h"
 // Static Variables
 
 S32 LLViewerParcelMedia::sMediaParcelLocalID = 0;
 LLUUID LLViewerParcelMedia::sMediaRegionID;
 viewer_media_t LLViewerParcelMedia::sMediaImpl;
-
+bool LLViewerParcelMedia::sIsUserAction = false;
+bool LLViewerParcelMedia::sMediaFilterListLoaded = false;
+LLSD LLViewerParcelMedia::sMediaFilterList;
+std::set<std::string> LLViewerParcelMedia::sMediaQueries;
+std::set<std::string> LLViewerParcelMedia::sAllowedMedia;
+std::set<std::string> LLViewerParcelMedia::sDeniedMedia;
 
 // Local functions
 bool callback_play_media(const LLSD& notification, const LLSD& response, LLParcel* parcel);
-
+void callback_media_alert(const LLSD& notification, const LLSD& response, LLParcel* parcel, U32 type, std::string domain);
 
 // static
 void LLViewerParcelMedia::initClass()
@@ -175,7 +186,7 @@ void LLViewerParcelMedia::update(LLParcel* parcel)
 }
 
 // static
-void LLViewerParcelMedia::play(LLParcel* parcel)
+void LLViewerParcelMedia::play(LLParcel* parcel, bool filter)
 {
         lldebugs << "LLViewerParcelMedia::play" << llendl;
 
@@ -185,7 +196,17 @@ void LLViewerParcelMedia::play(LLParcel* parcel)
                 return;
 
         std::string media_url = parcel->getMediaURL();
-        std::string media_current_url = parcel->getMediaCurrentURL();
+        LLStringUtil::trim(media_url);
+
+        if (!media_url.empty() && gSavedSettings.getBOOL("MediaEnableFilter") && (filter || !allowedMedia(media_url)))
+        {
+                // If filtering is needed or in case media_url just changed
+                // to something we did not yet approve.
+                LLViewerParcelMediaAutoPlay::playStarted();
+                filterMedia(parcel, 0);
+                return;
+        }
+
         std::string mime_type = parcel->getMediaType();
         LLUUID placeholder_texture_id = parcel->getMediaID();
         U8 media_auto_scale = parcel->getMediaAutoScale();
@@ -403,6 +424,8 @@ void LLViewerParcelMedia::processParcelMediaUpdate( LLMessageSystem *msg, void *
         media_url = media_url_buffer;
         msg->getU8("DataBlock", "MediaAutoScale", media_auto_scale);
 
+        LL_DEBUGS("MediaFilter") << "New media texture id: " << media_id << LL_ENDL;
+
         if (msg->has("DataBlockExtended")) // do we have the extended data?
         {
                 char media_type_buffer[257];
@@ -438,6 +461,7 @@ void LLViewerParcelMedia::processParcelMediaUpdate( LLMessageSystem *msg, void *
 
                         play(parcel);
                 }
+
         }
 }
 // Static
@@ -586,3 +610,368 @@ void LLViewerParcelMediaNavigationObserver::onNavigateComplete( const EventType&
 
 }
 */
+
+void LLViewerParcelMedia::playStreamingMusic(LLParcel* parcel, bool filter)
+{
+        std::string music_url = parcel->getMusicURL();
+        LLStringUtil::trim(music_url);
+        if (!music_url.empty() && gSavedSettings.getBOOL("MediaEnableFilter") && (filter || !allowedMedia(music_url)))
+        {
+                // If filtering is needed or in case music_url just changed
+                // to something we did not yet approve.
+                filterMedia(parcel, 1);
+        }
+        else if (gAudioStream)
+        {
+                LLStringUtil::trim(music_url);
+                gAudioStream->startInternetStream(music_url);
+                if (music_url.empty())
+                {
+                        LLOverlayBar::audioFilterStop();
+                }
+                else
+                {
+                        LLOverlayBar::audioFilterPlay();
+                }
+        }
+}
+
+void LLViewerParcelMedia::stopStreamingMusic()
+{
+        if (gAudioStream)
+        {
+                gAudioStream->stopInternetStream();
+                LLOverlayBar::audioFilterStop();
+        }
+}
+
+bool LLViewerParcelMedia::allowedMedia(std::string media_url)
+{
+        LLStringUtil::trim(media_url);
+        std::string domain = extractDomain(media_url);
+        if (sAllowedMedia.count(domain))
+        {
+                return true;
+        }
+        for (S32 i = 0; i < (S32)sMediaFilterList.size(); i++)
+        {
+                if (sMediaFilterList[i]["domain"].asString() == domain)
+                {
+                        if (sMediaFilterList[i]["action"].asString() == "allow")
+                        {
+                                return true;
+                        }
+                        else
+                        {
+                                return false;
+                        }
+                }
+        }
+        return false;
+}
+
+void LLViewerParcelMedia::filterMedia(LLParcel* parcel, U32 type)
+{
+        std::string media_action;
+        std::string media_url;
+        std::string domain;
+
+        if (parcel != LLViewerParcelMgr::getInstance()->getAgentParcel())
+        {
+                // The parcel just changed (may occur right out after a TP)
+                sIsUserAction = false;
+                return;
+        }               
+
+        if (type == 0)
+        {
+                media_url = parcel->getMediaURL();
+        }
+        else
+        {
+                media_url = parcel->getMusicURL();
+        }
+        LLStringUtil::trim(media_url);
+
+        LL_DEBUGS("MediaFilter") << "Requested " << (type == 0 ? "media" : "music") << "-URL: " << media_url << LL_ENDL;
+
+        domain = extractDomain(media_url);
+
+        if (sMediaQueries.count(domain) > 0)
+        {
+                sIsUserAction = false;
+                return;
+        }
+
+        if (sIsUserAction)
+        {
+                // This was a user manual request to play this media, so give
+                // it another chance...
+                sIsUserAction = false;
+                if (sDeniedMedia.count(domain))
+                {
+                        sDeniedMedia.erase(domain);
+                        SLFloaterMediaFilter::setDirty();
+                }
+        }
+
+        if (!sMediaFilterListLoaded || sDeniedMedia.count(domain))
+        {
+                media_action = "ignore";
+        }
+        else if (sAllowedMedia.count(domain))
+        {
+                media_action = "allow";
+        }
+        else
+        {
+                for (S32 i = 0; i < (S32)sMediaFilterList.size(); i++)
+                {
+                        if (sMediaFilterList[i]["domain"].asString() == domain)
+                        {
+                                media_action = sMediaFilterList[i]["action"].asString();
+                                break;
+                        }
+                }
+        }
+
+        if (media_action == "allow" || media_url.empty())
+        {
+                if (type == 0)
+                {
+                        play(parcel, false);
+                }
+                else
+                {
+                        playStreamingMusic(parcel, false);
+                }
+        }
+        else if (media_action == "deny")
+        {
+                LLSD args;
+                args["DOMAIN"] = domain;
+                LLNotifications::instance().add("MediaBlocked", args);
+                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);
+        }
+        else if (media_action == "ignore")
+        {
+                if (type == 1)
+                {
+                        LLViewerParcelMedia::stopStreamingMusic();
+                }
+        }
+        else
+        {
+                sMediaQueries.insert(domain);
+                LLSD args;
+                args["DOMAIN"] = domain;
+                if (media_url.find('?') != std::string::npos)
+                {
+                        args["WARNING"] = " (WARNING: this URL also contains parameter(s) that could potentially be used to correlate your avatar name with your IP)";
+                }
+                else
+                {
+                        args["WARNING"] = "";
+                }
+                if (type == 0)
+                {
+                        args["TYPE"] = "a media";
+                }
+                else
+                {
+                        args["TYPE"] = "an audio";
+                }
+                LLNotifications::instance().add("MediaAlert", args, LLSD(), boost::bind(callback_media_alert, _1, _2, parcel, type, domain));
+        }
+}
+
+void callback_media_alert(const LLSD &notification, const LLSD &response, LLParcel* parcel, U32 type, std::string domain)
+{
+        S32 option = LLNotification::getSelectedOption(notification, response);
+
+        LLSD args;
+        args["DOMAIN"] = domain;
+
+        if (option == 0 || option == 3) // Allow or Whitelist
+        {
+                LLViewerParcelMedia::sAllowedMedia.insert(domain);
+                if (option == 3) // Whitelist
+                {
+                        LLSD newmedia;
+                        newmedia["domain"] = domain;
+                        newmedia["action"] = "allow";
+                        LLViewerParcelMedia::sMediaFilterList.append(newmedia);
+                        LLViewerParcelMedia::saveDomainFilterList();
+                        args["LISTED"] = "whitelisted";
+                        LLNotifications::instance().add("MediaListed", args);
+                }
+                if (type == 0)
+                {
+                        LLViewerParcelMedia::play(parcel, false);
+                }
+                else
+                {
+                        LLViewerParcelMedia::playStreamingMusic(parcel, false);
+                }
+        }
+        else if (option == 1 || option == 2) // Deny or Blacklist
+        {
+                LLViewerParcelMedia::sDeniedMedia.insert(domain);
+                if (type == 1)
+                {
+                        LLViewerParcelMedia::stopStreamingMusic();
+                }
+                if (option == 1) // Deny
+                {
+                        LLNotifications::instance().add("MediaBlocked", args);
+                }
+                else // Blacklist
+                {
+                        LLSD newmedia;
+                        newmedia["domain"] = domain;
+                        newmedia["action"] = "deny";
+                        LLViewerParcelMedia::sMediaFilterList.append(newmedia);
+                        LLViewerParcelMedia::saveDomainFilterList();
+                        args["LISTED"] = "blacklisted";
+                        LLNotifications::instance().add("MediaListed", args);
+                }
+        }
+
+        LLViewerParcelMedia::sMediaQueries.erase(domain);
+        SLFloaterMediaFilter::setDirty();
+}
+
+void LLViewerParcelMedia::saveDomainFilterList()
+{
+        std::string medialist_filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "media_filter.xml");
+
+        llofstream medialistFile(medialist_filename);
+        LLSDSerialize::toPrettyXML(sMediaFilterList, medialistFile);
+        medialistFile.close();
+}
+
+bool LLViewerParcelMedia::loadDomainFilterList()
+{
+        sMediaFilterListLoaded = true;
+
+        std::string medialist_filename = gDirUtilp->getExpandedFilename(LL_PATH_PER_SL_ACCOUNT, "media_filter.xml");
+
+        if (!LLFile::isfile(medialist_filename))
+        {
+                LLSD emptyllsd;
+                llofstream medialistFile(medialist_filename);
+                LLSDSerialize::toPrettyXML(emptyllsd, medialistFile);
+                medialistFile.close();
+        }
+
+        if (LLFile::isfile(medialist_filename))
+        {
+                llifstream medialistFile(medialist_filename);
+                LLSDSerialize::fromXML(sMediaFilterList, medialistFile);
+                medialistFile.close();
+                SLFloaterMediaFilter::setDirty();
+                return true;
+        }
+        else
+        {
+                return false;
+        }
+}
+
+void LLViewerParcelMedia::clearDomainFilterList()
+{
+        sMediaFilterList.clear();
+        sAllowedMedia.clear();
+        sDeniedMedia.clear();
+        saveDomainFilterList();
+        LLNotifications::instance().add("MediaFiltersCleared");
+        SLFloaterMediaFilter::setDirty();
+}
+
+std::string LLViewerParcelMedia::extractDomain(std::string url)
+{
+        static std::string last_region = "@";
+
+        if (url.empty())
+        {
+                return url;
+        }
+
+        LLStringUtil::toLower(url);
+
+        size_t pos = url.find("//");
+
+        if (pos != std::string::npos)
+        {
+                size_t count = url.size() - pos + 2;
+                url = url.substr(pos + 2, count);
+        }
+
+        // Check that there is at least one slash in the URL and add a trailing
+        // one if not (for media/audio URLs such as http://mydomain.net)
+        if (url.find('/') == std::string::npos)
+        {
+                url += '/';
+        }
+
+        // If there's a user:password@ part, remove it
+        pos = url.find('@');
+        if (pos != std::string::npos && pos < url.find('/'))    // if '@' is not before the first '/', then it's not a user:password
+        {
+                size_t count = url.size() - pos + 1;
+                url = url.substr(pos + 1, count);
+        }
+
+        if (url.find(gAgent.getRegion()->getHost().getHostName()) == 0 || url.find(last_region) == 0)
+        {
+                // This must be a scripted object rezzed in the region:
+                // extend the concept of "domain" to encompass the
+                // scripted object server id and avoid blocking all other
+                // objects at once in this region...
+
+                // 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);
+
+                pos = url.find('?');
+                if (pos != std::string::npos)
+                {
+                        // Get rid of any parameter
+                        url = url.substr(0, pos);
+                }
+
+                pos = url.rfind('/');
+                if (pos != std::string::npos)
+                {
+                        // Get rid of the filename, if any, keeping only the server + path
+                        url = url.substr(0, pos);
+                }
+        }
+        else
+        {
+                pos = url.find(':');  
+                if (pos != std::string::npos && pos < url.find('/'))
+                {
+                        // Keep anything before the port number and strip the rest off
+                        url = url.substr(0, pos);
+                }
+                else
+                {
+                        pos = url.find('/');    // We earlier made sure that there's one
+                        url = url.substr(0, pos);
+                }
+        }
+
+                
+        // Remember this region, so to cope with requests occuring just after a
+        // TP out of it.
+        last_region = gAgent.getRegion()->getHost().getHostName();
+
+        return url;
+}