src/view/webkit/view_logic_certificate_confirm_support.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /**
  17  * @file    view_logic_certificate_confirm_support.cpp
  18  * @author  Leerang Song (leerang.song@samsung.com)
  19  */
  20
  21 #include "view_logic_certificate_confirm_support.h"
  22
  23 #include <string>
  24 #include <sstream>
  25 #include <dpl/log/wrt_log.h>
  26 #include <dpl/availability.h>
  27 #include <dpl/assert.h>
  28 #include <wrt-commons/certificate-dao/certificate_dao_types.h>
  29 #include <wrt-commons/certificate-dao/certificate_dao.h>
  30 #include <EWebKit.h>
  31 #include <EWebKit_internal.h>
  32 #include <common/view_logic_certificate_support.h>
  33 #include <Elementary.h>
  34 #include <widget_string.h>
  35
  36 namespace ViewModule {
  37 namespace CertificateConfirmSupport {
  38 using namespace CertificateDB;
  39 using namespace ViewModule::CertificateSupportUtil;
  40
  41 namespace {
  42
  43 // function declare
  44 void askUserForCertificatePermission(
  45     Evas_Object* window,
  46     PermissionData* data);
  47 void setPermissionResult(PermissionData* permData, Result result);
  48 static void popupCallback(void* data, Evas_Object* obj, void* eventInfo);
  49 static void eaKeyCallback(void* data, Evas_Object* obj, void* eventInfo);
  50
  51 void askUserForCertificatePermission(
  52     Evas_Object* window,
  53     PermissionData* data)
  54 {
  55     WrtLogD("askUserForCertificatePermission called");
  56     Ewk_Certificate_Policy_Decision* certificatePolicyDecision =
  57         static_cast<Ewk_Certificate_Policy_Decision*>(data->m_data);
  58     Assert(certificatePolicyDecision);
  59
  60     std::string msg = std::string(WRT_POP_CERTIFICATE_PERMISSION)
  61         + " " + ewk_certificate_policy_decision_url_get(certificatePolicyDecision);
  62     Evas_Object* popup = createPopup(window,
  63                                      msg.c_str(),
  64                                      WRT_BODY_REMEMBER_PREFERENCE_IDS,
  65                                      popupCallback,
  66                                      eaKeyCallback,
  67                                      data);
  68
  69     if (popup == NULL) {
  70         WrtLogE("Fail to create popup object");
  71         delete data;
  72         return;
  73     } else {
  74         evas_object_show(popup);
  75     }
  76 }
  77
  78 void setPermissionResult(PermissionData* permData, Result result)
  79 {
  80     Assert(permData);
  81     Ewk_Certificate_Policy_Decision* certificatePolicyDecision =
  82         static_cast<Ewk_Certificate_Policy_Decision*>(permData->m_data);
  83
  84     if (result != RESULT_UNKNOWN) {
  85         permData->m_certiDao->setCertificateData(permData->m_certiData, result);
  86     }
  87
  88     Eina_Bool ret = (result == RESULT_ALLOW_ALWAYS || result == RESULT_ALLOW_ONCE) ? EINA_TRUE : EINA_FALSE;
  89     ewk_certificate_policy_decision_allowed_set(certificatePolicyDecision, ret);
  90 }
  91
  92 void popupCallback(void* data, Evas_Object* obj, void* eventInfo)
  93 {
  94     WrtLogD("called");
  95
  96     Assert(data);
  97     Assert(obj);
  98
  99     DPL_UNUSED_PARAM(eventInfo);
 100
 101     PermissionData* permData = static_cast<PermissionData*>(data);
 102     setPermissionResult(permData, getResult(obj));
 103     delete permData;
 104
 105     Evas_Object* popup = getPopup(obj);
 106     evas_object_hide(popup);
 107     evas_object_del(popup);
 108 }
 109
 110 void eaKeyCallback(void* data, Evas_Object* obj, void* eventInfo)
 111 {
 112     WrtLogD("called");
 113
 114     Assert(data);
 115     Assert(obj);
 116
 117     DPL_UNUSED_PARAM(eventInfo);
 118
 119     PermissionData* permData = static_cast<PermissionData*>(data);
 120     setPermissionResult(permData, RESULT_DENY_ONCE);
 121     delete permData;
 122
 123     evas_object_hide(obj);
 124     evas_object_del(obj);
 125 }
 126 } // namespace
 127
 128 void certificatePermissionRequest(
 129     Evas_Object* window,
 130     CertificateDB::CertificateDAO* certificateDAO,
 131     void* data)
 132 {
 133     WrtLogD("certificationPermissionRequest called");
 134     Assert(certificateDAO);
 135     Assert(data);
 136
 137     Ewk_Certificate_Policy_Decision* certificatePolicyDecision =
 138         static_cast<Ewk_Certificate_Policy_Decision*>(data);
 139     ewk_certificate_policy_decision_suspend(certificatePolicyDecision);
 140     Assert(certificatePolicyDecision);
 141
 142     CertificateData certificateData(
 143              DPL::FromUTF8String(
 144                 ewk_certificate_policy_decision_certificate_pem_get(
 145                      certificatePolicyDecision)));
 146
 147     // check cache database
 148     Result result = certificateDAO->getResult(certificateData);
 149
 150     if (RESULT_ALLOW_ONCE == result || RESULT_ALLOW_ALWAYS == result) {
 151         WrtLogD("allow");
 152         ewk_certificate_policy_decision_allowed_set(
 153             certificatePolicyDecision,
 154             EINA_TRUE);
 155          return;
 156    } else if (RESULT_DENY_ONCE == result || RESULT_DENY_ALWAYS == result) {
 157         WrtLogD("Deny");
 158         ewk_certificate_policy_decision_allowed_set(
 159             certificatePolicyDecision,
 160             EINA_FALSE);
 161          return;
 162     }
 163     // ask to user
 164     PermissionData* permissionData =
 165         new PermissionData(certificateDAO,
 166                            certificateData,
 167                            certificatePolicyDecision);
 168     askUserForCertificatePermission(window, permissionData);
 169     return;
 170 }
 171 }
 172 } // namespace ViewModule