sbMediaSniffer.cpp

Go to the documentation of this file.

/*
//
// BEGIN SONGBIRD GPL
// 
// This file is part of the Songbird web player.
//
// Copyright(c) 2005-2008 POTI, Inc.
// http://songbirdnest.com
// 
// This file may be licensed under the terms of of the
// GNU General Public License Version 2 (the "GPL").
// 
// Software distributed under the License is distributed 
// on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either 
// express or implied. See the GPL for the specific language 
// governing rights and limitations.
//
// You should have received a copy of the GPL along with this 
// program. If not, go to http://www.gnu.org/licenses/gpl.html
// or write to the Free Software Foundation, Inc., 
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
// 
// END SONGBIRD GPL
//
*/

#include "sbMediaSniffer.h"

#include <nsICategoryManager.h>
#include <nsIHttpChannel.h>
#include <nsIRequest.h>
#include <nsIServiceManager.h>
#include <nsIURI.h>
#include <sbIMediacoreTypeSniffer.h>
#include <sbIPlaylistReader.h>

#include <nsComponentManagerUtils.h>
#include <nsCOMPtr.h>
#include <nsNetCID.h>
#include <nsServiceManagerUtils.h>
#include <nsXPCOM.h>
#include <nsXPCOMCID.h>
#include <nsMemory.h>

NS_IMPL_ISUPPORTS1(sbMediaSniffer, nsIContentSniffer)

NS_IMETHODIMP
sbMediaSniffer::GetMIMETypeFromContent(nsIRequest* aRequest, 
                                       const PRUint8* aData, 
                                       PRUint32 aLength, 
                                       nsACString& aSniffedType)
{
  NS_ENSURE_ARG_POINTER(aRequest);

  nsresult rv;

  // This won't always succeed, so don't warn for this expected failure.
  nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aRequest, &rv);

  if (NS_SUCCEEDED(rv)) {
    nsCAutoString requestMethod;
    rv = httpChannel->GetRequestMethod(requestMethod);
    NS_ENSURE_SUCCESS(rv, rv);

    if (!requestMethod.EqualsLiteral("GET") &&
        !requestMethod.EqualsLiteral("POST")) {
        aSniffedType.Truncate();
        return NS_OK;
    }
  }

  nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  nsCAutoString contentType;
  rv = channel->GetContentType(contentType);
  NS_ENSURE_SUCCESS(rv, rv);

  // Never let a media core or playlist reader override the handling
  // of the basic web content types.
  if (contentType.EqualsLiteral("text/html")) {
    aSniffedType.Truncate();
    return NS_OK;
  }

  // There are apparently problems with 'view-source'... See nsFeedSniffer.
  nsCOMPtr<nsIURI> originalURI;
  rv = channel->GetOriginalURI(getter_AddRefs(originalURI));
  NS_ENSURE_SUCCESS(rv, rv);

  nsCAutoString scheme;
  rv = originalURI->GetScheme(scheme);
  NS_ENSURE_SUCCESS(rv, rv);

  if (scheme.EqualsLiteral("view-source")) {
    aSniffedType.Truncate();
    return NS_OK;
  }

  nsCOMPtr<nsIURI> uri;
  rv = channel->GetURI(getter_AddRefs(uri));
  NS_ENSURE_SUCCESS(rv, rv);

  nsCOMPtr<sbIMediacoreTypeSniffer> typeSniffer =
    do_GetService(SB_MEDIACORETYPESNIFFER_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  PRBool isMediaURL = PR_FALSE;
  rv = typeSniffer->IsValidMediaURL(uri, 
                                    &isMediaURL);
  
  if (NS_SUCCEEDED(rv) && isMediaURL) {
    
    // We seem to think this is media, make sure the content type that
    // the server handed us at least makes sense. If it doesn't we will
    // leave the contentType alone and let other sniffers have a go at
    // it.
    if( contentType.EqualsLiteral("text/html") ||
        contentType.EqualsLiteral("application/atom+xml") ||
        contentType.EqualsLiteral("application/rdf+xml") ||
        contentType.EqualsLiteral("application/rss+xml") ||
        contentType.EqualsLiteral("application/xml")) {
      return NS_ERROR_NOT_AVAILABLE;
    }

    aSniffedType.AssignLiteral(TYPE_MAYBE_MEDIA);
    return NS_OK;
  }

  PRBool isPlaylistURL = PR_FALSE;
  rv = typeSniffer->IsValidWebSafePlaylistURL(uri, 
                                              &isPlaylistURL);
  if (NS_SUCCEEDED(rv) && isPlaylistURL) {
    aSniffedType.AssignLiteral(TYPE_MAYBE_PLAYLIST);
    return NS_OK;
  }

  aSniffedType.Truncate();
  return NS_OK;
}

NS_METHOD
sbMediaSniffer::Register(nsIComponentManager* aCompMgr,
                         nsIFile* aPath, 
                         const char* aRegistryLocation,
                         const char* aComponentType, 
                         const nsModuleComponentInfo* aInfo)
{
  nsresult rv;
  nsCOMPtr<nsICategoryManager> catman =
    do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  rv = catman->AddCategoryEntry(NS_CONTENT_SNIFFER_CATEGORY,
                                SONGBIRD_MEDIASNIFFER_DESCRIPTION, 
                                SONGBIRD_MEDIASNIFFER_CONTRACTID,
                                PR_TRUE, PR_TRUE, nsnull);
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}

NS_METHOD
sbMediaSniffer::Unregister(nsIComponentManager* aCompMgr,
                           nsIFile* aPath, 
                           const char* aRegistryLocation,
                           const nsModuleComponentInfo* aInfo)
{
  nsresult rv;
  nsCOMPtr<nsICategoryManager> catman =
    do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  rv = catman->DeleteCategoryEntry(NS_CONTENT_SNIFFER_CATEGORY,
                                   SONGBIRD_MEDIASNIFFER_DESCRIPTION, 
                                   PR_TRUE);
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}