path: root/embed/mozilla/EphySingle.cpp

/*
 *  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"

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "EphySingle.h"

#include "ephy-debug.h"

#include <nsEmbedString.h>
#include <nsIURI.h>
#include <nsIPermissionManager.h>
#include <nsICookieManager.h>
#include <nsIServiceManager.h>
#include <nsICookie2.h>
#include <nsIServiceManager.h>

#ifdef ALLOW_PRIVATE_API
#include <nsIIDNService.h>
#endif

NS_IMPL_ISUPPORTS1(EphySingle, nsIObserver)

EphySingle::EphySingle()
: mOwner(nsnull)
{
    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);
    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, "network:offline-status-changed");
    }

    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;
}

/* 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, "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)
        {
            nsEmbedCString 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, "network:offline-status-changed") == 0)
    {
        /* aData is either (PRUnichar[]) "offline" or "online" */
        gboolean offline;

        offline = (aData[1] == 'f');

        g_signal_emit_by_name (mOwner, "network-status", offline);
    }
    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;

    nsEmbedCString transfer;

    cookie->GetHost (transfer);

    nsCOMPtr<nsIIDNService> idnService
        (do_GetService ("@mozilla.org/network/idn-service;1"));
    NS_ENSURE_TRUE (idnService, nsnull);

    nsEmbedCString 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;

    nsCookieStatus status;
    cookie->GetStatus (&status);
    info->p3p_state = status;

    nsCookiePolicy policy;
    cookie->GetPolicy (&policy);
    info->p3p_policy = policy;

    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;
    nsEmbedCString 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;
    }

    nsEmbedCString host;
    perm->GetHost(host);

    nsCOMPtr<nsIIDNService> idnService
        (do_GetService ("@mozilla.org/network/idn-service;1"));
    NS_ENSURE_TRUE (idnService, nsnull);

    nsEmbedCString decodedHost;
    idnService->ConvertACEtoUTF8 (host, decodedHost);

    return ephy_permission_info_new (decodedHost.get(), type.get(), permission);
}