1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "browser_addon.h"
17 
18 #include "browser_proxy.h"
19 #include "edm_constants.h"
20 #include "edm_log.h"
21 
22 using namespace OHOS::EDM;
23 
Init(napi_env env,napi_value exports)24 napi_value BrowserAddon::Init(napi_env env, napi_value exports)
25 {
26     napi_property_descriptor property[] = {
27         DECLARE_NAPI_FUNCTION("setPolicies", SetPolicies),
28         DECLARE_NAPI_FUNCTION("getPolicies", GetPolicies),
29         DECLARE_NAPI_FUNCTION("setPolicySync", SetPolicy),
30         DECLARE_NAPI_FUNCTION("getPoliciesSync", GetPoliciesSync),
31     };
32     NAPI_CALL(env, napi_define_properties(env, exports, sizeof(property) / sizeof(property[0]), property));
33     return exports;
34 }
35 
SetPolicies(napi_env env,napi_callback_info info)36 napi_value BrowserAddon::SetPolicies(napi_env env, napi_callback_info info)
37 {
38     EDMLOGI("NAPI_SetPolicies called");
39     auto asyncCallbackInfo = new (std::nothrow) AsyncBrowserCallbackInfo();
40     if (asyncCallbackInfo == nullptr) {
41         return nullptr;
42     }
43     std::unique_ptr<AsyncBrowserCallbackInfo> callbackPtr{asyncCallbackInfo};
44     napi_value ret = SetPolicyCommon(env, info, asyncCallbackInfo);
45     int32_t errCode = -1;
46     napi_get_value_int32(env, ret, &errCode);
47     if (ret == nullptr || errCode != ERR_OK) {
48         return nullptr;
49     }
50     if (asyncCallbackInfo->value != nullptr) {
51         ASSERT_AND_THROW_PARAM_ERROR(env,
52             MatchValueType(env, asyncCallbackInfo->value, napi_function), "Parameter callback error");
53         napi_create_reference(env, asyncCallbackInfo->value, NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
54     }
55     napi_value asyncWorkReturn =
56         HandleAsyncWork(env, asyncCallbackInfo, "setPolicies", NativeSetPolicies, NativeVoidCallbackComplete);
57     callbackPtr.release();
58     return asyncWorkReturn;
59 }
60 
NativeSetPolicies(napi_env env,void * data)61 void BrowserAddon::NativeSetPolicies(napi_env env, void *data)
62 {
63     EDMLOGI("NAPI_NativeSetPolicies called");
64     if (data == nullptr) {
65         EDMLOGE("data is nullptr");
66         return;
67     }
68     AsyncBrowserCallbackInfo *asyncCallbackInfo = static_cast<AsyncBrowserCallbackInfo *>(data);
69     asyncCallbackInfo->ret = BrowserProxy::GetBrowserProxy()->SetPolicies(asyncCallbackInfo->elementName,
70         asyncCallbackInfo->appId, asyncCallbackInfo->policies);
71 }
72 
GetPolicies(napi_env env,napi_callback_info info)73 napi_value BrowserAddon::GetPolicies(napi_env env, napi_callback_info info)
74 {
75     EDMLOGI("NAPI_GetPolicies called");
76     auto asyncCallbackInfo = new (std::nothrow) AsyncBrowserCallbackInfo();
77     if (asyncCallbackInfo == nullptr) {
78         return nullptr;
79     }
80     std::unique_ptr<AsyncBrowserCallbackInfo> callbackPtr{asyncCallbackInfo};
81     napi_value ret = GetPoliciesCommon(env, info, asyncCallbackInfo);
82     int32_t errCode = -1;
83     napi_get_value_int32(env, ret, &errCode);
84     if (ret == nullptr || errCode != ERR_OK) {
85         return nullptr;
86     }
87     if (asyncCallbackInfo->value != nullptr) {
88         ASSERT_AND_THROW_PARAM_ERROR(env,
89             MatchValueType(env, asyncCallbackInfo->value, napi_function), "Parameter callback error");
90         napi_create_reference(env, asyncCallbackInfo->value, NAPI_RETURN_ONE, &asyncCallbackInfo->callback);
91     }
92     napi_value asyncWorkReturn =
93         HandleAsyncWork(env, asyncCallbackInfo, "getPolicies", NativeGetPolicies, NativeStringCallbackComplete);
94     callbackPtr.release();
95     return asyncWorkReturn;
96 }
97 
NativeGetPolicies(napi_env env,void * data)98 void BrowserAddon::NativeGetPolicies(napi_env env, void *data)
99 {
100     EDMLOGI("NativeGetPolicies called");
101     if (data == nullptr) {
102         EDMLOGE("data is nullptr");
103         return;
104     }
105     AsyncBrowserCallbackInfo *asyncCallbackInfo = static_cast<AsyncBrowserCallbackInfo *>(data);
106     asyncCallbackInfo->ret = BrowserProxy::GetBrowserProxy()->GetPolicies(asyncCallbackInfo->elementName,
107         asyncCallbackInfo->appId, asyncCallbackInfo->stringRet);
108 }
109 
SetPolicy(napi_env env,napi_callback_info info)110 napi_value BrowserAddon::SetPolicy(napi_env env, napi_callback_info info)
111 {
112     EDMLOGI("NAPI_SetPolicy called");
113     std::string policyValue;
114     auto asyncCallbackInfo = new (std::nothrow) AsyncBrowserCallbackInfo();
115     if (asyncCallbackInfo == nullptr) {
116         return nullptr;
117     }
118     std::unique_ptr<AsyncBrowserCallbackInfo> callbackPtr{asyncCallbackInfo};
119     napi_value ret = SetPolicyCommon(env, info, asyncCallbackInfo);
120     int32_t errCode = -1;
121     napi_get_value_int32(env, ret, &errCode);
122     if (ret == nullptr || errCode != ERR_OK) {
123         return nullptr;
124     }
125     ASSERT_AND_THROW_PARAM_ERROR(env,
126         ParseString(env, policyValue, asyncCallbackInfo->value), "Parameter policyValue error");
127 
128     int32_t retCode = BrowserProxy::GetBrowserProxy()->SetPolicy(asyncCallbackInfo->elementName,
129         asyncCallbackInfo->appId, asyncCallbackInfo->policies, policyValue);
130     if (FAILED(retCode)) {
131         napi_throw(env, CreateError(env, retCode));
132     }
133     return nullptr;
134 }
135 
GetPoliciesSync(napi_env env,napi_callback_info info)136 napi_value BrowserAddon::GetPoliciesSync(napi_env env, napi_callback_info info)
137 {
138     EDMLOGI("NAPI_GetPoliciesSync called");
139     auto asyncCallbackInfo = new (std::nothrow) AsyncBrowserCallbackInfo();
140     if (asyncCallbackInfo == nullptr) {
141         return nullptr;
142     }
143     std::unique_ptr<AsyncBrowserCallbackInfo> callbackPtr{asyncCallbackInfo};
144     napi_value ret = GetPoliciesCommon(env, info, asyncCallbackInfo);
145     int32_t errCode = -1;
146     napi_get_value_int32(env, ret, &errCode);
147     if (ret == nullptr || errCode != ERR_OK) {
148         return nullptr;
149     }
150     std::string policies;
151     int32_t retCode = BrowserProxy::GetBrowserProxy()->GetPolicies(asyncCallbackInfo->elementName,
152         asyncCallbackInfo->appId, policies);
153     if (FAILED(retCode)) {
154         napi_throw(env, CreateError(env, retCode));
155     }
156     napi_value res;
157     napi_create_string_utf8(env, policies.c_str(), NAPI_AUTO_LENGTH, &res);
158     return res;
159 }
160 
SetPolicyCommon(napi_env env,napi_callback_info info,AsyncBrowserCallbackInfo * callbackInfo)161 napi_value BrowserAddon::SetPolicyCommon(napi_env env, napi_callback_info info, AsyncBrowserCallbackInfo* callbackInfo)
162 {
163     size_t argc = ARGS_SIZE_FOUR;
164     napi_value argv[ARGS_SIZE_FOUR] = {nullptr};
165     napi_value thisArg = nullptr;
166     void *data = nullptr;
167     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
168     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_THREE, "Parameter count error");
169     bool matchFlag = MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object) &&
170         MatchValueType(env, argv[ARR_INDEX_ONE], napi_string) && MatchValueType(env, argv[ARR_INDEX_TWO], napi_string);
171 
172     ASSERT_AND_THROW_PARAM_ERROR(env, matchFlag, "parameter type error");
173     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, callbackInfo->elementName, argv[ARR_INDEX_ZERO]),
174         "element name param error");
175     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, callbackInfo->appId, argv[ARR_INDEX_ONE]),
176         "Parameter appId error");
177     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, callbackInfo->policies, argv[ARR_INDEX_TWO]),
178         "Parameter policyName error");
179 
180     EDMLOGD(
181         "setBrowserPolicy: elementName.bundlename %{public}s, "
182         "elementName.abilityname:%{public}s",
183         callbackInfo->elementName.GetBundleName().c_str(),
184         callbackInfo->elementName.GetAbilityName().c_str());
185 
186     if (argc > ARGS_SIZE_THREE) {
187         callbackInfo->value = argv[ARR_INDEX_THREE];
188     }
189 
190     napi_value ret;
191     napi_create_int32(env, ERR_OK, &ret);
192     return ret;
193 }
194 
GetPoliciesCommon(napi_env env,napi_callback_info info,AsyncBrowserCallbackInfo * asyncCallbackInfo)195 napi_value BrowserAddon::GetPoliciesCommon(napi_env env, napi_callback_info info,
196     AsyncBrowserCallbackInfo* asyncCallbackInfo)
197 {
198     size_t argc = ARGS_SIZE_THREE;
199     napi_value argv[ARGS_SIZE_THREE] = {nullptr};
200     napi_value thisArg = nullptr;
201     void *data = nullptr;
202     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, &thisArg, &data));
203     ASSERT_AND_THROW_PARAM_ERROR(env, argc >= ARGS_SIZE_TWO, "Parameter count error");
204     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ZERO], napi_object), "admin type error");
205     ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_ONE], napi_string), "appId type error");
206 
207     ASSERT_AND_THROW_PARAM_ERROR(env, ParseElementName(env, asyncCallbackInfo->elementName, argv[ARR_INDEX_ZERO]),
208         "Parameter want error");
209     ASSERT_AND_THROW_PARAM_ERROR(env, ParseString(env, asyncCallbackInfo->appId, argv[ARR_INDEX_ONE]),
210         "Parameter appId error");
211     EDMLOGD(
212         "GetPolicies::asyncCallbackInfo->elementName.bundlename %{public}s, "
213         "asyncCallbackInfo->abilityname:%{public}s",
214         asyncCallbackInfo->elementName.GetBundleName().c_str(),
215         asyncCallbackInfo->elementName.GetAbilityName().c_str());
216 
217     if (argc > ARGS_SIZE_TWO) {
218         ASSERT_AND_THROW_PARAM_ERROR(env, MatchValueType(env, argv[ARR_INDEX_TWO], napi_function),
219             "callback type error");
220         asyncCallbackInfo->value = argv[ARR_INDEX_TWO];
221     }
222     napi_value ret;
223     napi_create_int32(env, ERR_OK, &ret);
224     return ret;
225 }
226 
227 static napi_module g_browserModule = {
228     .nm_version = 1,
229     .nm_flags = 0,
230     .nm_filename = nullptr,
231     .nm_register_func = BrowserAddon::Init,
232     .nm_modname = "enterprise.browser",
233     .nm_priv = ((void *)0),
234     .reserved = {0},
235 };
236 
BrowserRegister()237 extern "C" __attribute__((constructor)) void BrowserRegister()
238 {
239     napi_module_register(&g_browserModule);
240 }