source: murachi/esteidfirefoxplugin/firefox/plugin-class.c @ 7d3ae3e

/*
 * Estonian ID card plugin for web browsers
 *
 * Copyright (C) 2010-2011 Codeborne <info@codeborne.com>
 *
 * This 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 of the License, or (at your option) any later version.
 *
 * This software 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#include <stdlib.h>
#include <string.h>
#include "plugin-class.h"
#include "version.h"
#include "cert-class.h"
#include "dialogs.h"
#include "esteid_sign.h"
#include "esteid_map.h"
#include "esteid_json.h"
#include "l10n.h"
#include "esteid_error.h"
#include "npapi.h"
#include "esteid_certinfo.h"
#ifdef _WIN32
#include "certselection-win.h"
#include "esteid_dialog_common.h"
#include "dialogs-win.h"
extern HINSTANCE pluginInstance;
#endif

extern NPNetscapeFuncs* browserFunctions;
extern char EstEID_error[1024];
extern int EstEID_errorCode;

bool allowedSite;
char pluginLanguage[3];

bool isAllowedSite() {
        if(!allowedSite) {
                sprintf(EstEID_error, "Site is not allowed");
                EstEID_errorCode = ESTEID_SITE_NOT_ALLOWED;
                EstEID_log("called from forbidden site");
                return false;
        }
        return true;
}

bool pluginInvokeDefault(PluginInstance *obj, NPVariant *args, unsigned argCount, NPVariant *result) {
        return false;
}

void pluginInvalidate() {
}

bool pluginSetProperty(PluginInstance *obj, NPIdentifier name, const NPVariant *variant) {
        LOG_LOCATION;
        if(isSameIdentifier(name, "pluginLanguage")) {
                memset(pluginLanguage, '\0', 3);
                if(NPVARIANT_IS_STRING(*variant)) {
                        strncpy(pluginLanguage, NPVARIANT_TO_STRING(*variant).UTF8Characters, 2);
                        return true;
                }
                return true;
        }
        return false;
}

bool pluginHasMethod(PluginInstance *obj, NPIdentifier name) {
        return 
                isSameIdentifier(name, "sign") ||
                isSameIdentifier(name, "getCertificate") ||             
                isSameIdentifier(name, "getVersion");
}

bool pluginHasProperty(NPClass *theClass, NPIdentifier name) {
        return 
                isSameIdentifier(name, "version") ||
                isSameIdentifier(name, "errorMessage") ||
                isSameIdentifier(name, "errorCode") ||
                isSameIdentifier(name, "authCert") ||
                isSameIdentifier(name, "pluginLanguage") ||
                isSameIdentifier(name, "signCert");
}

void *getNativeWindowHandle(PluginInstance *obj) {
        void *nativeWindowHandle = obj->nativeWindowHandle;
#ifdef _WIN32
        EstEID_log("_WIN32 detected, forcing nativeWindowHandle query from browser");
        nativeWindowHandle = 0;
#endif
        if (!nativeWindowHandle) {
                browserFunctions->getvalue(obj->npp, NPNVnetscapeWindow, &nativeWindowHandle);
                EstEID_log("reading nativeWindowHandle=%p from browserFunctions", nativeWindowHandle);
        }
        else {
                EstEID_log("reading nativeWindowHandle=%p from PluginInstance", nativeWindowHandle);
        }
        return nativeWindowHandle;
}

char *getLanguageFromOptions(PluginInstance *obj, NPVariant options) {
        LOG_LOCATION;
        NPObject *object = NPVARIANT_TO_OBJECT(options);
        NPIdentifier identifier = browserFunctions->getstringidentifier("language");
        NPVariant languageResult;
        if (browserFunctions->getproperty(obj->npp, object, identifier, &languageResult) && NPVARIANT_IS_STRING(languageResult)) {
                char *language = createStringFromNPVariant(&languageResult);
                EstEID_log("returning language '%s'", language);
                return language;
        }
        EstEID_log("unable to read language from options, returning empty string");
        return "";
}

bool doSign(PluginInstance *obj, NPVariant *args, unsigned argCount, NPVariant *result) {
        EstEID_log("obj=%p, name=sign argCount=%u", obj, argCount);

        FAIL_IF_NOT_ALLOWED_SITE;

        if (argCount < 2) {
                browserFunctions->setexception(&obj->header, "Missing arguments");
                return false;
        }
        
        if(argCount > 2 && NPVARIANT_IS_OBJECT(args[2])){
                strncpy(pluginLanguage, getLanguageFromOptions(obj, args[2]), 2);
        }
        //EstEID_setLocale(pluginLanguage);
        EstEID_setLocale("ru");

        void* wnd = getNativeWindowHandle(obj);

        EstEID_PINPromptData pinPromptData = {promptForPIN, showAlert, wnd};
        NPUTF8* certId = createStringFromNPVariant(&args[0]);
        NPUTF8* hash = createStringFromNPVariant(&args[1]);
        char *signature = NULL;

#ifdef _WIN32
        DialogData dialogData;
        dialogData.pin2[0] = '\0';
        dialogData.minPin2Length = 5;
        dialogData.certId = certId;
        dialogData.hash = hash;
        dialogData.signature[0] = '\0';

        CK_SLOT_ID slotId;      
        if(EstEID_getSlotId(certId, &slotId)){
                if(EstEID_isPinPad(slotId)) {
                        signature = EstEID_sign(certId, hash, pinPromptData);
                }
                else {
                        DialogBoxParam(pluginInstance, MAKEINTRESOURCEW(IDD_PIN_DIALOG), (HWND)wnd, Pin2DialogProc, (LPARAM)&dialogData);
                        LOG_LOCATION;
                        signature = (char*)malloc(SIGNATURE_BUFFER_SIZE); // check?
                        strcpy(signature, dialogData.signature);
                }
        }
        else {
                return false;
        }
#else
        signature = EstEID_sign(certId, hash, pinPromptData);
#endif
        LOG_LOCATION
        if (signature) {
                copyStringToNPVariant(signature, result);
                free(signature);
                return true;
        }
        else {
                EstEID_log("EstEID_error=%s", EstEID_error);
                browserFunctions->setexception(&obj->header, EstEID_error);
                return false;
        }
}

bool doGetCertificate(PluginInstance *obj, NPVariant *result) {
        LOG_LOCATION;
        FAIL_IF_NOT_ALLOWED_SITE;
        char selectedCertID[33];
        int dlg_result = 0;
        
#ifdef _WIN32
        HWND ownerWindowHandle = (HWND)getNativeWindowHandle(obj);
        EstEID_log("owner window handle passed to DialogBoxParam() = %08X", ownerWindowHandle);
        dlg_result = (int)DialogBoxParam(pluginInstance, MAKEINTRESOURCE(IDD_CERTIFICATESELECTIONDLG), ownerWindowHandle, CertSelectionDialogProc, (LPARAM)selectedCertID);
#else
        dlg_result = promptForCertificate(getNativeWindowHandle(obj), selectedCertID);
#endif
        EstEID_log("Certificate selection dialog result = %i", dlg_result);
        EstEID_log("Selected certificate ID = %s", selectedCertID);

        if(dlg_result == IDCANCEL) {
                sprintf(EstEID_error, "User canceled");
                EstEID_errorCode = ESTEID_USER_CANCEL;
                EstEID_log("EstEID_error = %s", EstEID_error);
                browserFunctions->setexception(&obj->header, EstEID_error);     
                return false;
        }
        
        CertInstance *certInstance = (CertInstance *)browserFunctions->createobject(obj->npp, certClass());
        certInstance->npp = obj->npp;
        certInstance->certInfo = EstEID_mapClone(EstEID_getNonRepudiationCertById(selectedCertID));
//      certInstance->certInfo = EstEID_mapClone(EstEID_getNonRepudiationCert());

        EstEID_log("certObject=%p", certInstance);
        OBJECT_TO_NPVARIANT((NPObject *)certInstance, *result);
        EstEID_log("result=%p", result);        
        return true;
}

bool doGetCertificates(PluginInstance *obj, NPVariant *result) {
        LOG_LOCATION;
        EstEID_log("obj=%p, name=doGetCertificates", obj);
        NPObject *windowObject = NULL;
        browserFunctions->getvalue(obj->npp, NPNVWindowNPObject, &windowObject);
        NPVariant array;
        browserFunctions->invoke(obj->npp, windowObject, browserFunctions->getstringidentifier("Array"), NULL, 0, &array);
        EstEID_Certs *certs = EstEID_loadCerts();
        for (int i = 0; i < certs->count; i++) {
                EstEID_Map cert = certs->certs[i];
                if (!EstEID_mapGet(cert, "usageNonRepudiation")) continue;
                CertInstance *certInstance = (CertInstance *)browserFunctions->createobject(obj->npp, certClass());
                certInstance->npp = obj->npp;
                certInstance->certInfo = EstEID_mapClone(cert);
                browserFunctions->retainobject((NPObject *)certInstance);
                EstEID_log("certObject=%p", certInstance);
                NPVariant *arg = (NPVariant *)browserFunctions->memalloc(sizeof(NPVariant));
                OBJECT_TO_NPVARIANT((NPObject *)certInstance, *arg);
                NPVariant ret;
                browserFunctions->invoke(obj->npp, array.value.objectValue, browserFunctions->getstringidentifier("push"), arg, 1, &ret);
        }
        browserFunctions->retainobject(array.value.objectValue);
        OBJECT_TO_NPVARIANT(array.value.objectValue, *result);
        return true;
}

bool pluginGetProperty(PluginInstance *obj, NPIdentifier name, NPVariant *variant) {
        LOG_LOCATION;
        if (isSameIdentifier(name, "version"))
                return copyStringToNPVariant(ESTEID_PLUGIN_VERSION, variant);
        else if (isSameIdentifier(name, "errorMessage")){
                EstEID_log("Reading error message: %s", EstEID_error);
                return copyStringToNPVariant(EstEID_error, variant);
        }
        else if (isSameIdentifier(name, "errorCode")) {
                INT32_TO_NPVARIANT(EstEID_errorCode, *variant);
                EstEID_log("returning errorCode=%i", EstEID_errorCode);
                return true;
        }
        else if (isSameIdentifier(name, "authCert") || isSameIdentifier(name, "signCert")){
                return doGetCertificate(obj, variant);
        }
        else if (isSameIdentifier(name, "pluginLanguage")){
                return copyStringToNPVariant(pluginLanguage, variant);
        }
        EstEID_log("returning false");
        return false;
}

bool pluginInvoke(PluginInstance *obj, NPIdentifier name, NPVariant *args, unsigned argCount, NPVariant *result) {      
        LOG_LOCATION;
        EstEID_clear_error();
        //EstEID_setLocale(pluginLanguage);
        EstEID_setLocale("ru");

        if (isSameIdentifier(name, "sign")) {
                return doSign(obj, args, argCount, result);
        }
        if (isSameIdentifier(name, "getCertificate")) {
                return doGetCertificate(obj, result);
        }
        if (isSameIdentifier(name, "getVersion")) {
                return pluginGetProperty(obj, browserFunctions->getstringidentifier("version"), result);
        }
        EstEID_log("obj=%p, name=%p, argCount=%u", obj, name, argCount);
        return false;
}

NPObject *pluginAllocate(NPP npp, NPClass *theClass) {
        return(NPObject *)malloc(sizeof(PluginInstance));
}

void pluginDeallocate(PluginInstance *obj) {
        free(obj);
}

static NPClass _class = {
        NP_CLASS_STRUCT_VERSION,
        (NPAllocateFunctionPtr)pluginAllocate,
        (NPDeallocateFunctionPtr)pluginDeallocate,
        (NPInvalidateFunctionPtr)pluginInvalidate,
        (NPHasMethodFunctionPtr)pluginHasMethod,
        (NPInvokeFunctionPtr)pluginInvoke,
        (NPInvokeDefaultFunctionPtr)pluginInvokeDefault,
        (NPHasPropertyFunctionPtr)pluginHasProperty,
        (NPGetPropertyFunctionPtr)pluginGetProperty,
        (NPSetPropertyFunctionPtr)pluginSetProperty,
};

NPClass *pluginClass() {
        return &_class;
}