1 /*
2 * Copyright (c) 2021-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 "devsvc_manager_proxy.h"
17 #include "devhost_service.h"
18 #include "devhost_service_full.h"
19 #include "device_service_stub.h"
20 #include "devsvc_manager_stub.h"
21 #include "hdf_base.h"
22 #include "hdf_log.h"
23 #include "hdf_sbuf.h"
24 #include "osal_mem.h"
25
26 #define HDF_LOG_TAG devsvc_manager_proxy
27
WriteServiceInfo(struct HdfSBuf * data,struct HdfDeviceObject * service,const struct HdfServiceInfo * servInfo)28 static int WriteServiceInfo(
29 struct HdfSBuf *data, struct HdfDeviceObject *service, const struct HdfServiceInfo *servInfo)
30 {
31 int ret = HDF_FAILURE;
32 if (!HdfSbufWriteString(data, servInfo->servName)) {
33 HDF_LOGE("Add service failed, failed to write service name");
34 return ret;
35 }
36
37 if (!HdfSbufWriteUint16(data, servInfo->devClass)) {
38 HDF_LOGE("Add service failed, failed to write devClass");
39 return ret;
40 }
41 if (!HdfSbufWriteUint32(data, servInfo->devId)) {
42 HDF_LOGE("Add service failed, failed to write devId");
43 return ret;
44 }
45 struct HdfDeviceNode *devNode =
46 HDF_SLIST_CONTAINER_OF(struct HdfDeviceObject, service, struct HdfDeviceNode, deviceObject);
47 struct DeviceServiceStub *deviceFullService = (struct DeviceServiceStub *)devNode;
48 if (deviceFullService->remote == NULL) {
49 HDF_LOGE("%{public}s: device service is broken", __func__);
50 return ret;
51 }
52
53 if (HdfSbufWriteRemoteService(data, deviceFullService->remote) != HDF_SUCCESS) {
54 HDF_LOGE("Add service failed, failed to write remote object");
55 return ret;
56 }
57 const char *info = servInfo->servInfo != NULL ? servInfo->servInfo : "";
58 if (!HdfSbufWriteString(data, info)) {
59 HDF_LOGE("Add service failed, failed to write serv info");
60 return HDF_FAILURE;
61 }
62
63 return HDF_SUCCESS;
64 }
65
DevSvcManagerProxyAddService(struct IDevSvcManager * inst,struct HdfDeviceObject * service,const struct HdfServiceInfo * servInfo)66 static int DevSvcManagerProxyAddService(
67 struct IDevSvcManager *inst, struct HdfDeviceObject *service, const struct HdfServiceInfo *servInfo)
68 {
69 struct DevSvcManagerProxy *serviceProxy = (struct DevSvcManagerProxy *)inst;
70 if (service == NULL || servInfo->servName == NULL) {
71 HDF_LOGE("%{public}s:service or name is null", __func__);
72 return HDF_ERR_INVALID_PARAM;
73 }
74 if ((serviceProxy == NULL) || (serviceProxy->remote == NULL)) {
75 HDF_LOGE("Add service failed, serviceProxy is invalid");
76 return HDF_ERR_INVALID_PARAM;
77 }
78
79 if (servInfo->devClass >= DEVICE_CLASS_MAX) {
80 HDF_LOGE("Add service failed, devClass is invalid");
81 return HDF_ERR_INVALID_PARAM;
82 }
83
84 int status = HDF_FAILURE;
85 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
86 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
87 do {
88 if (data == NULL || reply == NULL) {
89 HDF_LOGE("Add service failed, failed to obtain sbuf");
90 break;
91 }
92 if (!HdfRemoteServiceWriteInterfaceToken(serviceProxy->remote, data) ||
93 WriteServiceInfo(data, service, servInfo) != HDF_SUCCESS) {
94 break;
95 }
96 status =
97 serviceProxy->remote->dispatcher->Dispatch(serviceProxy->remote, DEVSVC_MANAGER_ADD_SERVICE, data, reply);
98 HDF_LOGI("servmgr add service %{public}s, result is %{public}d", servInfo->servName, status);
99 } while (0);
100
101 if (reply != NULL) {
102 HdfSbufRecycle(reply);
103 }
104 if (data != NULL) {
105 HdfSbufRecycle(data);
106 }
107 return status;
108 }
109
DevSvcManagerProxyUpdateService(struct IDevSvcManager * inst,struct HdfDeviceObject * service,const struct HdfServiceInfo * servInfo)110 static int DevSvcManagerProxyUpdateService(struct IDevSvcManager *inst,
111 struct HdfDeviceObject *service, const struct HdfServiceInfo *servInfo)
112 {
113 struct DevSvcManagerProxy *serviceProxy = (struct DevSvcManagerProxy *)inst;
114 if (service == NULL || servInfo->servName == NULL) {
115 HDF_LOGE("%{public}s:service or name is null", __func__);
116 return HDF_ERR_INVALID_PARAM;
117 }
118 if ((serviceProxy == NULL) || (serviceProxy->remote == NULL)) {
119 HDF_LOGE("update service failed, serviceProxy is invalid");
120 return HDF_ERR_INVALID_PARAM;
121 }
122
123 if (servInfo->devClass >= DEVICE_CLASS_MAX) {
124 HDF_LOGE("update service failed, devClass is invalid");
125 return HDF_ERR_INVALID_PARAM;
126 }
127
128 int status = HDF_FAILURE;
129 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
130 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
131 do {
132 if (data == NULL || reply == NULL) {
133 HDF_LOGE("update service failed, failed to obtain sbuf");
134 break;
135 }
136 if (!HdfRemoteServiceWriteInterfaceToken(serviceProxy->remote, data) ||
137 WriteServiceInfo(data, service, servInfo) != HDF_SUCCESS) {
138 break;
139 }
140 status = serviceProxy->remote->dispatcher->Dispatch(
141 serviceProxy->remote, DEVSVC_MANAGER_UPDATE_SERVICE, data, reply);
142 HDF_LOGI("servmgr update service %{public}s, result is %{public}d", servInfo->servName, status);
143 } while (0);
144
145 if (reply != NULL) {
146 HdfSbufRecycle(reply);
147 }
148 if (data != NULL) {
149 HdfSbufRecycle(data);
150 }
151 return status;
152 }
153
DevSvcManagerProxyGetService(struct IDevSvcManager * inst,const char * svcName)154 struct HdfObject *DevSvcManagerProxyGetService(struct IDevSvcManager *inst, const char *svcName)
155 {
156 int status = HDF_FAILURE;
157 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
158 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
159 struct HdfRemoteDispatcher *dispatcher = NULL;
160 struct HdfRemoteService *remoteService = NULL;
161 struct DevSvcManagerProxy *serviceProxy = (struct DevSvcManagerProxy *)inst;
162 do {
163 if ((serviceProxy->remote == NULL) || (data == NULL) || (reply == NULL)) {
164 HDF_LOGE("Get service failed, serviceProxy->remote or data or reply is null");
165 break;
166 }
167 dispatcher = serviceProxy->remote->dispatcher;
168 if (!HdfRemoteServiceWriteInterfaceToken(serviceProxy->remote, data) || !HdfSbufWriteString(data, svcName)) {
169 break;
170 }
171 status = dispatcher->Dispatch(serviceProxy->remote, DEVSVC_MANAGER_GET_SERVICE, data, reply);
172 if (status == HDF_SUCCESS) {
173 remoteService = HdfSbufReadRemoteService(reply);
174 }
175 } while (0);
176
177 if (reply != NULL) {
178 HdfSbufRecycle(reply);
179 }
180 if (data != NULL) {
181 HdfSbufRecycle(data);
182 }
183 HDF_LOGI("DevSvcManagerProxyGetService finish, and status is %{public}d", status);
184 return (remoteService == NULL) ? NULL : &remoteService->object_;
185 }
186
DevSvcManagerProxyRemoveService(struct IDevSvcManager * inst,const char * svcName,const struct HdfDeviceObject * devObj)187 void DevSvcManagerProxyRemoveService(struct IDevSvcManager *inst, const char *svcName,
188 const struct HdfDeviceObject *devObj)
189 {
190 (void)devObj;
191 if (inst == NULL || svcName == NULL) {
192 return;
193 }
194 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
195 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
196 struct HdfRemoteDispatcher *dispatcher = NULL;
197 struct HdfRemoteService *remoteService = NULL;
198 struct DevSvcManagerProxy *serviceProxy = (struct DevSvcManagerProxy *)inst;
199
200 do {
201 if ((serviceProxy->remote == NULL) || (data == NULL) || (reply == NULL)) {
202 HDF_LOGE("Remove service failed, serviceProxy->remote or data or reply is null");
203 break;
204 }
205 remoteService = serviceProxy->remote;
206 dispatcher = remoteService->dispatcher;
207 if (!HdfRemoteServiceWriteInterfaceToken(serviceProxy->remote, data) || !HdfSbufWriteString(data, svcName)) {
208 break;
209 }
210 int status = dispatcher->Dispatch(remoteService, DEVSVC_MANAGER_REMOVE_SERVICE, data, reply);
211 HDF_LOGW("Device service manager proxy remove service status is %{public}d", status);
212 } while (0);
213
214 if (reply != NULL) {
215 HdfSbufRecycle(reply);
216 }
217 if (data != NULL) {
218 HdfSbufRecycle(data);
219 }
220 }
221
DevSvcManagerProxyOnRemoteDied(struct HdfDeathRecipient * recipient,struct HdfRemoteService * service)222 static void DevSvcManagerProxyOnRemoteDied(struct HdfDeathRecipient *recipient, struct HdfRemoteService *service)
223 {
224 struct IDevHostService *instance = DevHostServiceNewInstance(0, NULL);
225
226 if (recipient == NULL || service == NULL || instance == NULL) {
227 HDF_LOGE("%{public}s parameter is null", __func__);
228 return;
229 }
230 (void)recipient;
231 struct DevHostServiceFull *fullService = (struct DevHostServiceFull *)instance;
232 struct HdfMessageLooper *looper = &fullService->looper;
233 HDF_LOGW("%{public}s: DevSvcManager dead, host %{public}d stop", __func__, fullService->super.hostId);
234 if ((looper != NULL) && (looper->Stop != NULL)) {
235 looper->Stop(looper);
236 }
237 }
238
DevSvcManagerProxyConstruct(struct DevSvcManagerProxy * inst,struct HdfRemoteService * remote)239 void DevSvcManagerProxyConstruct(struct DevSvcManagerProxy *inst, struct HdfRemoteService *remote)
240 {
241 inst->pvtbl.AddService = DevSvcManagerProxyAddService;
242 inst->pvtbl.UpdateService = DevSvcManagerProxyUpdateService;
243 inst->pvtbl.GetService = DevSvcManagerProxyGetService;
244 inst->pvtbl.RemoveService = DevSvcManagerProxyRemoveService;
245 inst->remote = remote;
246 inst->recipient.OnRemoteDied = DevSvcManagerProxyOnRemoteDied;
247 HdfRemoteServiceAddDeathRecipient(remote, &inst->recipient);
248 }
249
DevSvcManagerProxyObtain(struct HdfRemoteService * remote)250 static struct IDevSvcManager *DevSvcManagerProxyObtain(struct HdfRemoteService *remote)
251 {
252 struct DevSvcManagerProxy *instance = (struct DevSvcManagerProxy *)OsalMemCalloc(sizeof(struct DevSvcManagerProxy));
253 if (instance != NULL) {
254 DevSvcManagerProxyConstruct(instance, remote);
255 }
256 return (struct IDevSvcManager *)instance;
257 }
258
DevSvcManagerProxyCreate(void)259 struct HdfObject *DevSvcManagerProxyCreate(void)
260 {
261 static struct IDevSvcManager *instance = NULL;
262 if (instance == NULL) {
263 struct HdfRemoteService *remote = HdfRemoteServiceGet(DEVICE_SERVICE_MANAGER_SA_ID);
264 if (remote != NULL) {
265 if (!HdfRemoteServiceSetInterfaceDesc(remote, "HDI.IServiceManager.V1_0")) {
266 HDF_LOGE("%{public}s: failed to init interface desc", __func__);
267 HdfRemoteServiceRecycle(remote);
268 return NULL;
269 }
270 instance = DevSvcManagerProxyObtain(remote);
271 }
272 }
273 return (struct HdfObject *)instance;
274 }
275
DevSvcManagerProxyRelease(struct HdfObject * object)276 void DevSvcManagerProxyRelease(struct HdfObject *object)
277 {
278 struct DevSvcManagerProxy *instance = (struct DevSvcManagerProxy *)object;
279 if (instance != NULL) {
280 if (instance->remote != NULL) {
281 HdfRemoteServiceRecycle(instance->remote);
282 instance->remote = NULL;
283 }
284 OsalMemFree(instance);
285 }
286 }
287