1 /*
2 * Copyright (c) 2020-2022 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 <ohos_errno.h>
17 #include <ohos_init.h>
18 #include <pthread.h>
19 #include <string.h>
20
21 #include "log.h"
22
23 #include "feature.h"
24 #include "iproxy_client.h"
25 #include "iproxy_server.h"
26 #include "iunknown.h"
27 #include "ipc_skeleton.h"
28 #include "samgr_lite.h"
29 #include "service.h"
30
31 #include "pms.h"
32 #include "pms_common.h"
33 #include "pms_types.h"
34
35 typedef struct InnerPermLiteApi {
36 INHERIT_SERVER_IPROXY;
37 int (*CheckPermission)(int uid, const char *permissionName);
38 int (*GrantPermission)(const char *identifier, const char *permName);
39 int (*RevokePermission)(const char *identifier, const char *permName);
40 int (*GrantRuntimePermission)(int uid, const char *permissionName);
41 int (*RevokeRuntimePermission)(int uid, const char *permissionName);
42 int (*UpdatePermissionFlags)(const char *identifier, const char *permissionName, const int flags);
43 } InnerPermLiteApi;
44
45 typedef struct InnerPermLite {
46 INHERIT_FEATURE;
47 INHERIT_IUNKNOWNENTRY(InnerPermLiteApi);
48 Identity identity;
49 } InnerPermLite;
50
51 enum INNERFUNCID {
52 ID_CHECK = 10,
53 ID_GRANT,
54 ID_REVOKE,
55 ID_GRANT_RUNTIME,
56 ID_REVOKE_RUNTIME,
57 ID_UPDATE_PERMS_FLAGS,
58 };
59
60 static void Init(void);
61 static const char *GetName(Feature *feature);
62 static void OnInitialize(Feature *feature, Service *parent, Identity identity);
63 static void OnStop(Feature *feature, Identity identity);
64 static BOOL OnMessage(const Feature *feature, const Request *request);
65 static int32 Invoke(IServerProxy *iProxy, int funcId, void *origin, IpcIo *req, IpcIo *reply);
66
67 static InnerPermLite g_permlite = {
68 .GetName = GetName,
69 .OnInitialize = OnInitialize,
70 .OnStop = OnStop,
71 .OnMessage = OnMessage,
72 SERVER_IPROXY_IMPL_BEGIN,
73 .Invoke = Invoke,
74 .CheckPermission = CheckPermissionStat,
75 .GrantPermission = GrantPermission,
76 .RevokePermission = RevokePermission,
77 .GrantRuntimePermission = GrantRuntimePermission,
78 .RevokeRuntimePermission = RevokeRuntimePermission,
79 .UpdatePermissionFlags = UpdatePermissionFlags,
80 IPROXY_END,
81 .identity = {-1, -1, NULL},
82 };
83
Init(void)84 static void Init(void)
85 {
86 SAMGR_GetInstance()->RegisterFeature(PERMISSION_SERVICE, (Feature *)&g_permlite);
87 SAMGR_GetInstance()->RegisterFeatureApi(PERMISSION_SERVICE, PERM_INNER_FEATURE, GET_IUNKNOWN(g_permlite));
88 HILOG_INFO(HILOG_MODULE_APP, "Init pms lite inner feature success");
89 }
90 APP_FEATURE_INIT(Init);
91
GetName(Feature * feature)92 static const char *GetName(Feature *feature)
93 {
94 (void)feature;
95 return PERM_INNER_FEATURE;
96 }
97
OnInitialize(Feature * feature,Service * parent,Identity identity)98 static void OnInitialize(Feature *feature, Service *parent, Identity identity)
99 {
100 (void)parent;
101 if (feature == NULL) {
102 return;
103 }
104 InnerPermLite *permlite = (InnerPermLite *)feature;
105 permlite->identity = identity;
106 HILOG_INFO(HILOG_MODULE_APP, "onInitialize pms lite inner feature");
107 }
108
OnStop(Feature * feature,Identity identity)109 static void OnStop(Feature *feature, Identity identity)
110 {
111 (void)feature;
112 (void)identity;
113 }
114
OnMessage(const Feature * feature,const Request * request)115 static BOOL OnMessage(const Feature *feature, const Request *request)
116 {
117 if (feature == NULL || request == NULL) {
118 return FALSE;
119 }
120 // call func
121 return TRUE;
122 }
123
ReplyCheckPermission(const void * origin,IpcIo * req,IpcIo * reply,InnerPermLiteApi * api)124 static void ReplyCheckPermission(const void *origin, IpcIo *req, IpcIo *reply, InnerPermLiteApi* api)
125 {
126 pid_t callingPid = GetCallingPid();
127 uid_t callingUid = GetCallingUid();
128 HILOG_INFO(HILOG_MODULE_APP, "Enter ID_CHECK, [callerPid: %d][callerUid: %u]", callingPid, callingUid);
129
130 size_t permLen = 0;
131 int64_t uid;
132 ReadInt64(req, &uid);
133 char *permName = (char *)ReadString(req, &permLen);
134 int32_t ret = api->CheckPermission(uid, permName);
135 HILOG_INFO(HILOG_MODULE_APP, "check permission, [uid: %lld][perm: %s][ret: %d]", uid, permName, ret);
136 WriteInt32(reply, ret);
137 }
138
ReplyGrantPermission(const void * origin,IpcIo * req,IpcIo * reply,InnerPermLiteApi * api)139 static void ReplyGrantPermission(const void *origin, IpcIo *req, IpcIo *reply, InnerPermLiteApi* api)
140 {
141 pid_t callingPid = GetCallingPid();
142 uid_t callingUid = GetCallingUid();
143 HILOG_INFO(HILOG_MODULE_APP, "Enter ID_GRANT, [callerPid: %d][callerUid: %u]", callingPid, callingUid);
144 size_t permLen = 0;
145 size_t idLen = 0;
146 char *identifier = (char *)ReadString(req, &idLen);
147 char *permName = (char *)ReadString(req, &permLen);
148 int32_t ret = api->GrantPermission(identifier, permName);
149 HILOG_INFO(HILOG_MODULE_APP, "grant permission, [id: %s][perm: %s][ret: %d]", identifier, permName, ret);
150 WriteInt32(reply, ret);
151 }
152
ReplyRevokePermission(const void * origin,IpcIo * req,IpcIo * reply,InnerPermLiteApi * api)153 static void ReplyRevokePermission(const void *origin, IpcIo *req, IpcIo *reply, InnerPermLiteApi* api)
154 {
155 pid_t callingPid = GetCallingPid();
156 uid_t callingUid = GetCallingUid();
157 HILOG_INFO(HILOG_MODULE_APP, "Enter ID_REVOKE, [callerPid: %d][callerUid: %u]", callingPid, callingUid);
158 size_t permLen = 0;
159 size_t idLen = 0;
160 char *identifier = (char *)ReadString(req, &idLen);
161 char *permName = (char *)ReadString(req, &permLen);
162 int32_t ret = api->RevokePermission(identifier, permName);
163 HILOG_INFO(HILOG_MODULE_APP, "revoke permission, [id: %s][perm: %s][ret: %d]", identifier, permName, ret);
164 WriteInt32(reply, ret);
165 }
166
ReplyGrantRuntimePermission(const void * origin,IpcIo * req,IpcIo * reply,InnerPermLiteApi * api)167 static void ReplyGrantRuntimePermission(const void *origin, IpcIo *req, IpcIo *reply, InnerPermLiteApi* api)
168 {
169 pid_t callingPid = GetCallingPid();
170 uid_t callingUid = GetCallingUid();
171 HILOG_INFO(HILOG_MODULE_APP, "Enter ID_GRANTRUNTIME, [callerPid: %d][callerUid: %u]", callingPid, callingUid);
172 size_t permLen = 0;
173 int64_t uid;
174 ReadInt64(req, &uid);
175 char *permName = (char *)ReadString(req, &permLen);
176 int32_t ret = api->GrantRuntimePermission(uid, permName);
177 HILOG_INFO(HILOG_MODULE_APP, "grant runtime permission, [uid: %lld][perm: %s][ret: %d]", uid, permName, ret);
178 WriteInt32(reply, ret);
179 }
180
ReplyRevokeRuntimePermission(const void * origin,IpcIo * req,IpcIo * reply,InnerPermLiteApi * api)181 static void ReplyRevokeRuntimePermission(const void *origin, IpcIo *req, IpcIo *reply, InnerPermLiteApi* api)
182 {
183 pid_t callingPid = GetCallingPid();
184 uid_t callingUid = GetCallingUid();
185 HILOG_INFO(HILOG_MODULE_APP, "Enter ID_REVOKERUNTIME, [callerPid: %d][callerUid: %u]", callingPid, callingUid);
186 size_t permLen = 0;
187 int64_t uid;
188 ReadInt64(req, &uid);
189 char *permName = (char *)ReadString(req, &permLen);
190 int32_t ret = api->RevokeRuntimePermission(uid, permName);
191 HILOG_INFO(HILOG_MODULE_APP, "revoke runtime permission, [uid: %lld][perm: %s][ret: %d]", uid, permName, ret);
192 WriteInt32(reply, ret);
193 }
194
ReplyUpdatePermissionFlags(const void * origin,IpcIo * req,IpcIo * reply,const InnerPermLiteApi * api)195 static void ReplyUpdatePermissionFlags(const void *origin, IpcIo *req, IpcIo *reply, const InnerPermLiteApi *api)
196 {
197 pid_t callingPid = GetCallingPid();
198 uid_t callingUid = GetCallingUid();
199 HILOG_INFO(HILOG_MODULE_APP, "Enter ID_UPDATE_PERMS_FLAGS, [callerPid: %d][callerUid: %u]", callingPid, callingUid);
200 size_t permLen = 0;
201 size_t idLen = 0;
202 char *identifier = (char *)ReadString(req, &idLen);
203 char *permName = (char *)ReadString(req, &permLen);
204 int32_t flags;
205 ReadInt32(req, &flags);
206 int32_t ret = api->UpdatePermissionFlags(identifier, permName, flags);
207 HILOG_INFO(HILOG_MODULE_APP, "update runtime permission flags, [identifier: %s][perm: %s][flags:%d][ret: %d]",
208 identifier, permName, flags, ret);
209 WriteInt32(reply, ret);
210 }
211
Invoke(IServerProxy * iProxy,int funcId,void * origin,IpcIo * req,IpcIo * reply)212 static int32 Invoke(IServerProxy *iProxy, int funcId, void *origin, IpcIo *req, IpcIo *reply)
213 {
214 InnerPermLiteApi *api = (InnerPermLiteApi *)iProxy;
215 switch (funcId) {
216 case ID_CHECK:
217 ReplyCheckPermission(origin, req, reply, api);
218 break;
219 case ID_GRANT:
220 ReplyGrantPermission(origin, req, reply, api);
221 break;
222 case ID_REVOKE:
223 ReplyRevokePermission(origin, req, reply, api);
224 break;
225 case ID_GRANT_RUNTIME:
226 ReplyGrantRuntimePermission(origin, req, reply, api);
227 break;
228 case ID_REVOKE_RUNTIME:
229 ReplyRevokeRuntimePermission(origin, req, reply, api);
230 break;
231 case ID_UPDATE_PERMS_FLAGS:
232 ReplyUpdatePermissionFlags(origin, req, reply, api);
233 break;
234 default:
235 break;
236 }
237 return EC_SUCCESS;
238 }
239