/*
* Copyright (C) 2003 Christian Persch
* Copyright (C) 2003 Marco Pesenti Gritti
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 2.1, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* $Id$
*/
#include "mozilla-config.h"
#include "config.h"
#include <nsStringAPI.h>
#include <nsICookie.h>
#include <nsICookie2.h>
#include <nsICookieManager.h>
#include <nsIHttpChannel.h>
#include <nsIObserverService.h>
#include <nsIPermission.h>
#include <nsIPermissionManager.h>
#include <nsIPropertyBag2.h>
#include <nsIServiceManager.h>
#include <nsIURI.h>
#include <nsServiceManagerUtils.h>
#include <nsWeakReference.h>
#ifdef ALLOW_PRIVATE_API
#include <nsIIDNService.h>
#endif
#include "ephy-debug.h"
#include "EphySingle.h"
NS_IMPL_ISUPPORTS1(EphySingle, nsIObserver)
EphySingle::EphySingle()
: mOwner(nsnull)
, mIsOnline(PR_TRUE) /* nsIOService doesn't send an initial notification, assume we start on-line */
{
LOG ("EphySingle ctor");
}
nsresult
EphySingle::Init (EphyEmbedSingle *aOwner)
{
mObserverService = do_GetService ("@mozilla.org/observer-service;1");
NS_ENSURE_TRUE (mObserverService, NS_ERROR_FAILURE);
nsresult rv;
rv = mObserverService->AddObserver (this, "cookie-changed", PR_FALSE);
rv |= mObserverService->AddObserver (this, "cookie-rejected", PR_FALSE);
rv |= mObserverService->AddObserver (this, "perm-changed", PR_FALSE);
rv |= mObserverService->AddObserver (this, "network:offline-status-changed", PR_FALSE);
rv |= mObserverService->AddObserver (this, "signonChanged", PR_FALSE);
rv |= mObserverService->AddObserver (this, "http-on-examine-response", PR_FALSE);
rv |= mObserverService->AddObserver (this, "http-on-modify-request", PR_FALSE);
NS_ENSURE_SUCCESS (rv, NS_ERROR_FAILURE);
mOwner = aOwner;
LOG ("EphySingle::Init");
return NS_OK;
}
nsresult
EphySingle::Detach ()
{
LOG ("EphySingle::Detach");
if (mObserverService)
{
mObserverService->RemoveObserver (this, "cookie-changed");
mObserverService->RemoveObserver (this, "cookie-rejected");
mObserverService->RemoveObserver (this, "perm-changed");
mObserverService->RemoveObserver (this, "signonChanged");
mObserverService->RemoveObserver (this, "network:offline-status-changed");
mObserverService->RemoveObserver (this, "http-on-examine-response");
mObserverService->RemoveObserver (this, "http-on-modify-request");
#if 1
/* HACK: Work around https://bugzilla.mozilla.org/show_bug.cgi?id=292699 */
mObserverService->NotifyObservers(nsnull, "profile-change-net-teardown", nsnull);
#endif
}
return NS_OK;
}
EphySingle::~EphySingle()
{
LOG ("EphySingle dtor");
mOwner = nsnull;
}
nsresult
EphySingle::EmitCookieNotification (const char *name,
nsISupports *aSubject)
{
LOG ("EmitCookieNotification %s", name);
nsCOMPtr<nsICookie> cookie = do_QueryInterface (aSubject);
NS_ENSURE_TRUE (cookie, NS_ERROR_FAILURE);
EphyCookie *info = mozilla_cookie_to_ephy_cookie (cookie);
g_signal_emit_by_name (EPHY_COOKIE_MANAGER (mOwner), name, info);
ephy_cookie_free (info);
return NS_OK;
}
nsresult
EphySingle::EmitPermissionNotification (const char *name,
nsISupports *aSubject)
{
LOG ("EmitPermissionNotification %s", name);
nsCOMPtr<nsIPermission> perm = do_QueryInterface (aSubject);
NS_ENSURE_TRUE (perm, NS_ERROR_FAILURE);
EphyPermissionInfo *info =
mozilla_permission_to_ephy_permission (perm);
g_signal_emit_by_name (EPHY_PERMISSION_MANAGER (mOwner), name, info);
ephy_permission_info_free (info);
return NS_OK;
}
nsresult
EphySingle::ExamineCookies (nsISupports *aSubject)
{
nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
NS_ENSURE_TRUE (props, NS_ERROR_FAILURE);
PRBool isBlockingCookiesChannel = PR_FALSE;
props->GetPropertyAsBool(
NS_LITERAL_STRING("epiphany-blocking-cookies"),
&isBlockingCookiesChannel);
if (isBlockingCookiesChannel)
{
nsCOMPtr<nsIHttpChannel> channel = do_QueryInterface(aSubject);
NS_ENSURE_TRUE (channel, NS_ERROR_FAILURE);
channel->SetRequestHeader(NS_LITERAL_CSTRING("Cookie"),
EmptyCString(), PR_FALSE);
}
return NS_OK;
}
nsresult
EphySingle::ExamineResponse (nsISupports *aSubject)
{
return ExamineCookies (aSubject);
}
nsresult
EphySingle::ExamineRequest (nsISupports *aSubject)
{
return ExamineCookies (aSubject);
}
/* void observe (in nsISupports aSubject, in string aTopic, in wstring aData); */
NS_IMETHODIMP EphySingle::Observe(nsISupports *aSubject,
const char *aTopic,
const PRUnichar *aData)
{
nsresult rv = NS_OK;
LOG ("EphySingle::Observe topic %s", aTopic);
if (strcmp (aTopic, "http-on-examine-response") == 0)
{
rv = ExamineResponse (aSubject);
}
else if (strcmp (aTopic, "http-on-modify-request") == 0)
{
rv = ExamineRequest (aSubject);
}
else if (strcmp (aTopic, "cookie-changed") == 0)
{
/* "added" */
if (aData[0] == 'a')
{
rv = EmitCookieNotification ("cookie-added", aSubject);
}
/* "deleted" */
else if (aData[0] == 'd')
{
rv = EmitCookieNotification ("cookie-deleted", aSubject);
}
/* "changed" */
else if (aData[0] == 'c' && aData[1] == 'h')
{
rv = EmitCookieNotification ("cookie-changed", aSubject);
}
/* "cleared" */
else if (aData[0] == 'c' && aData[1] == 'l')
{
LOG ("EphySingle::cookie-changed::cleared");
g_signal_emit_by_name (EPHY_COOKIE_MANAGER (mOwner), "cookies-cleared");
}
else
{
g_warning ("EphySingle unexpected data!\n");
rv = NS_ERROR_FAILURE;
}
}
else if (strcmp (aTopic, "cookie-rejected") == 0)
{
LOG ("EphySingle::cookie-rejected");
nsCOMPtr<nsIURI> uri = do_QueryInterface (aSubject);
if (uri)
{
nsCString spec;
uri->GetSpec (spec);
g_signal_emit_by_name (EPHY_COOKIE_MANAGER (mOwner), "cookie-rejected", spec.get());
}
else
{
rv = NS_ERROR_FAILURE;
}
}
else if (strcmp (aTopic, "perm-changed") == 0)
{
/* "added" */
if (aData[0] == 'a')
{
rv = EmitPermissionNotification ("permission-added", aSubject);
}
/* "deleted" */
else if (aData[0] == 'd')
{
rv = EmitPermissionNotification ("permission-deleted", aSubject);
}
/* "changed" */
else if (aData[0] == 'c' && aData[1] == 'h')
{
rv = EmitPermissionNotification ("permission-changed", aSubject);
}
/* "cleared" */
else if (aData[0] == 'c' && aData[1] == 'l')
{
LOG ("EphySingle::perm-changed::cleared");
g_signal_emit_by_name (EPHY_PERMISSION_MANAGER (mOwner), "permissions-cleared");
}
else
{
g_warning ("EphySingle unexpected data!\n");
rv = NS_ERROR_FAILURE;
}
}
else if (strcmp (aTopic, "signonChanged") == 0)
{
/* aData can be PRUnichar[] "signons", "rejects", "nocaptures" and "nopreviews" */
if (aData[0] == 's')
{
g_signal_emit_by_name (mOwner, "passwords-changed");
}
}
else if (strcmp (aTopic, "network:offline-status-changed") == 0)
{
/* aData is either (PRUnichar[]) "offline" or "online" */
mIsOnline = (aData && aData[0] == 'o' && aData[1] == 'n');
g_object_notify (G_OBJECT (mOwner), "network-status");
}
else
{
g_warning ("EphySingle observed unknown topic '%s'!\n", aTopic);
rv = NS_ERROR_FAILURE;
}
LOG ("EphySingle::Observe %s", NS_SUCCEEDED (rv) ? "success" : "FAILURE");
return rv;
}
EphyCookie *
mozilla_cookie_to_ephy_cookie (nsICookie *cookie)
{
EphyCookie *info;
nsCString transfer;
cookie->GetHost (transfer);
nsCOMPtr<nsIIDNService> idnService
(do_GetService ("@mozilla.org/network/idn-service;1"));
NS_ENSURE_TRUE (idnService, nsnull);
nsCString decoded;
/* ToUTF8 never fails, no need to check return value */
idnService->ConvertACEtoUTF8 (transfer, decoded);
info = ephy_cookie_new ();
info->domain = g_strdup (decoded.get());
cookie->GetName (transfer);
info->name = g_strdup (transfer.get());
cookie->GetValue (transfer);
info->value = g_strdup (transfer.get());
cookie->GetPath (transfer);
info->path = g_strdup (transfer.get());
PRBool isSecure;
cookie->GetIsSecure (&isSecure);
info->is_secure = isSecure != PR_FALSE;
PRUint64 dateTime;
cookie->GetExpires (&dateTime);
info->expires = dateTime;
nsCOMPtr<nsICookie2> cookie2 = do_QueryInterface (cookie);
NS_ENSURE_TRUE (cookie2, info);
PRBool isSession;
cookie2->GetIsSession (&isSession);
info->is_session = isSession != PR_FALSE;
if (!isSession)
{
PRInt64 expiry;
cookie2->GetExpiry (&expiry);
info->real_expires = expiry;
}
return info;
}
EphyPermissionInfo *
mozilla_permission_to_ephy_permission (nsIPermission *perm)
{
nsresult rv;
nsCString type;
rv = perm->GetType(type);
NS_ENSURE_SUCCESS (rv, NULL);
PRUint32 cap;
perm->GetCapability(&cap);
EphyPermission permission;
switch (cap)
{
case nsIPermissionManager::ALLOW_ACTION:
permission = EPHY_PERMISSION_ALLOWED;
break;
case nsIPermissionManager::DENY_ACTION:
permission = EPHY_PERMISSION_DENIED;
break;
case nsIPermissionManager::UNKNOWN_ACTION:
default :
permission = EPHY_PERMISSION_DEFAULT;
break;
}
nsCString host;
perm->GetHost(host);
nsCOMPtr<nsIIDNService> idnService
(do_GetService ("@mozilla.org/network/idn-service;1"));
NS_ENSURE_TRUE (idnService, nsnull);
nsCString decodedHost;
idnService->ConvertACEtoUTF8 (host, decodedHost);
return ephy_permission_info_new (decodedHost.get(), type.get(), permission);
}
