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 const char *interfaceDesc = servInfo->interfaceDesc != NULL ? servInfo->interfaceDesc : "";
63 if (!HdfSbufWriteString(data, interfaceDesc)) {
64 HDF_LOGE("Add service failed, failed to write interfaceDesc");
65 return HDF_FAILURE;
66 }
67
68 return HDF_SUCCESS;
69 }
70
DevSvcManagerProxyAddService(struct IDevSvcManager * inst,struct HdfDeviceObject * service,const struct HdfServiceInfo * servInfo)71 static int DevSvcManagerProxyAddService(
72 struct IDevSvcManager *inst, struct HdfDeviceObject *service, const struct HdfServiceInfo *servInfo)
73 {
74 struct DevSvcManagerProxy *serviceProxy = (struct DevSvcManagerProxy *)inst;
75 if (service == NULL || servInfo == NULL || servInfo->servName == NULL) {
76 HDF_LOGE("%{public}s:service or name is null", __func__);
77 return HDF_ERR_INVALID_PARAM;
78 }
79 if ((serviceProxy == NULL) || (serviceProxy->remote == NULL)) {
80 HDF_LOGE("Add service failed, serviceProxy is invalid");
81 return HDF_ERR_INVALID_PARAM;
82 }
83
84 if (servInfo->devClass >= DEVICE_CLASS_MAX) {
85 HDF_LOGE("Add service failed, devClass is invalid");
86 return HDF_ERR_INVALID_PARAM;
87 }
88
89 int status = HDF_FAILURE;
90 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
91 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
92 do {
93 if (data == NULL || reply == NULL) {
94 HDF_LOGE("Add service failed, failed to obtain sbuf");
95 break;
96 }
97 if (!HdfRemoteServiceWriteInterfaceToken(serviceProxy->remote, data) ||
98 WriteServiceInfo(data, service, servInfo) != HDF_SUCCESS) {
99 break;
100 }
101 status =
102 serviceProxy->remote->dispatcher->Dispatch(serviceProxy->remote, DEVSVC_MANAGER_ADD_SERVICE, data, reply);
103 HDF_LOGI("servmgr add service %{public}s, result is %{public}d", servInfo->servName, status);
104 } while (0);
105
106 HdfSbufRecycle(reply);
107 HdfSbufRecycle(data);
108 return status;
109 }
110
DevSvcManagerProxyUpdateService(struct IDevSvcManager * inst,struct HdfDeviceObject * service,const struct HdfServiceInfo * servInfo)111 static int DevSvcManagerProxyUpdateService(struct IDevSvcManager *inst,
112 struct HdfDeviceObject *service, const struct HdfServiceInfo *servInfo)
113 {
114 struct DevSvcManagerProxy *serviceProxy = (struct DevSvcManagerProxy *)inst;
115 if (service == NULL || servInfo == NULL || servInfo->servName == NULL) {
116 HDF_LOGE("%{public}s:service or name is null", __func__);
117 return HDF_ERR_INVALID_PARAM;
118 }
119 if ((serviceProxy == NULL) || (serviceProxy->remote == NULL)) {
120 HDF_LOGE("update service failed, serviceProxy is invalid");
121 return HDF_ERR_INVALID_PARAM;
122 }
123
124 if (servInfo->devClass >= DEVICE_CLASS_MAX) {
125 HDF_LOGE("update service failed, devClass is invalid");
126 return HDF_ERR_INVALID_PARAM;
127 }
128
129 int status = HDF_FAILURE;
130 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
131 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
132 do {
133 if (data == NULL || reply == NULL) {
134 HDF_LOGE("update service failed, failed to obtain sbuf");
135 break;
136 }
137 if (!HdfRemoteServiceWriteInterfaceToken(serviceProxy->remote, data) ||
138 WriteServiceInfo(data, service, servInfo) != HDF_SUCCESS) {
139 break;
140 }
141 status = serviceProxy->remote->dispatcher->Dispatch(
142 serviceProxy->remote, DEVSVC_MANAGER_UPDATE_SERVICE, data, reply);
143 HDF_LOGI("servmgr update service %{public}s, result is %{public}d", servInfo->servName, status);
144 } while (0);
145
146 HdfSbufRecycle(reply);
147 HdfSbufRecycle(data);
148 return status;
149 }
150
DevSvcManagerProxyGetService(struct IDevSvcManager * inst,const char * svcName)151 struct HdfObject *DevSvcManagerProxyGetService(struct IDevSvcManager *inst, const char *svcName)
152 {
153 int status = HDF_FAILURE;
154 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
155 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
156 struct HdfRemoteDispatcher *dispatcher = NULL;
157 struct HdfRemoteService *remoteService = NULL;
158 struct DevSvcManagerProxy *serviceProxy = (struct DevSvcManagerProxy *)inst;
159 do {
160 if ((serviceProxy->remote == NULL) || (data == NULL) || (reply == NULL)) {
161 HDF_LOGE("Get service failed, serviceProxy->remote or data or reply is null");
162 break;
163 }
164 dispatcher = serviceProxy->remote->dispatcher;
165 if (!HdfRemoteServiceWriteInterfaceToken(serviceProxy->remote, data) || !HdfSbufWriteString(data, svcName)) {
166 break;
167 }
168 status = dispatcher->Dispatch(serviceProxy->remote, DEVSVC_MANAGER_GET_SERVICE, data, reply);
169 if (status == HDF_SUCCESS) {
170 remoteService = HdfSbufReadRemoteService(reply);
171 }
172 } while (0);
173
174 HdfSbufRecycle(reply);
175 HdfSbufRecycle(data);
176 HDF_LOGI("DevSvcManagerProxyGetService finish, and status is %{public}d", status);
177 return (remoteService == NULL) ? NULL : &remoteService->object;
178 }
179
DevSvcManagerProxyRemoveService(struct IDevSvcManager * inst,const char * svcName,const struct HdfDeviceObject * devObj)180 void DevSvcManagerProxyRemoveService(struct IDevSvcManager *inst, const char *svcName,
181 const struct HdfDeviceObject *devObj)
182 {
183 (void)devObj;
184 if (inst == NULL || svcName == NULL) {
185 return;
186 }
187 struct HdfSBuf *data = HdfSbufTypedObtain(SBUF_IPC);
188 struct HdfSBuf *reply = HdfSbufTypedObtain(SBUF_IPC);
189 struct HdfRemoteDispatcher *dispatcher = NULL;
190 struct HdfRemoteService *remoteService = NULL;
191 struct DevSvcManagerProxy *serviceProxy = (struct DevSvcManagerProxy *)inst;
192
193 do {
194 if ((serviceProxy->remote == NULL) || (data == NULL) || (reply == NULL)) {
195 HDF_LOGE("Remove service failed, serviceProxy->remote or data or reply is null");
196 break;
197 }
198 remoteService = serviceProxy->remote;
199 dispatcher = remoteService->dispatcher;
200 if (!HdfRemoteServiceWriteInterfaceToken(serviceProxy->remote, data) || !HdfSbufWriteString(data, svcName)) {
201 break;
202 }
203 int status = dispatcher->Dispatch(remoteService, DEVSVC_MANAGER_REMOVE_SERVICE, data, reply);
204 HDF_LOGW("Device service manager proxy remove service status is %{public}d", status);
205 } while (0);
206
207 HdfSbufRecycle(reply);
208 HdfSbufRecycle(data);
209 }
210
DevSvcManagerProxyOnRemoteDied(struct HdfDeathRecipient * recipient,struct HdfRemoteService * service)211 static void DevSvcManagerProxyOnRemoteDied(struct HdfDeathRecipient *recipient, struct HdfRemoteService *service)
212 {
213 struct IDevHostService *instance = DevHostServiceNewInstance(0, NULL);
214
215 if (recipient == NULL || service == NULL || instance == NULL) {
216 HDF_LOGE("%{public}s parameter is null", __func__);
217 return;
218 }
219 (void)recipient;
220 struct DevHostServiceFull *fullService = (struct DevHostServiceFull *)instance;
221 struct HdfMessageLooper *looper = &fullService->looper;
222 HDF_LOGW("%{public}s: DevSvcManager dead, host %{public}d stop", __func__, fullService->super.hostId);
223 if ((looper != NULL) && (looper->Stop != NULL)) {
224 looper->Stop(looper);
225 }
226 }
227
DevSvcManagerProxyConstruct(struct DevSvcManagerProxy * inst,struct HdfRemoteService * remote)228 void DevSvcManagerProxyConstruct(struct DevSvcManagerProxy *inst, struct HdfRemoteService *remote)
229 {
230 inst->pvtbl.AddService = DevSvcManagerProxyAddService;
231 inst->pvtbl.UpdateService = DevSvcManagerProxyUpdateService;
232 inst->pvtbl.GetService = DevSvcManagerProxyGetService;
233 inst->pvtbl.RemoveService = DevSvcManagerProxyRemoveService;
234 inst->remote = remote;
235 inst->recipient.OnRemoteDied = DevSvcManagerProxyOnRemoteDied;
236 HdfRemoteServiceAddDeathRecipient(remote, &inst->recipient);
237 }
238
DevSvcManagerProxyObtain(struct HdfRemoteService * remote)239 static struct IDevSvcManager *DevSvcManagerProxyObtain(struct HdfRemoteService *remote)
240 {
241 struct DevSvcManagerProxy *instance = (struct DevSvcManagerProxy *)OsalMemCalloc(sizeof(struct DevSvcManagerProxy));
242 if (instance != NULL) {
243 DevSvcManagerProxyConstruct(instance, remote);
244 }
245 return (struct IDevSvcManager *)instance;
246 }
247
DevSvcManagerProxyCreate(void)248 struct HdfObject *DevSvcManagerProxyCreate(void)
249 {
250 static struct IDevSvcManager *instance = NULL;
251 if (instance == NULL) {
252 struct HdfRemoteService *remote = HdfRemoteServiceGet(DEVICE_SERVICE_MANAGER_SA_ID);
253 if (remote != NULL) {
254 if (!HdfRemoteServiceSetInterfaceDesc(remote, "HDI.IServiceManager.V1_0")) {
255 HDF_LOGE("%{public}s: failed to init interface desc", __func__);
256 HdfRemoteServiceRecycle(remote);
257 return NULL;
258 }
259 instance = DevSvcManagerProxyObtain(remote);
260 }
261 }
262 return (struct HdfObject *)instance;
263 }
264
DevSvcManagerProxyRelease(struct HdfObject * object)265 void DevSvcManagerProxyRelease(struct HdfObject *object)
266 {
267 struct DevSvcManagerProxy *instance = (struct DevSvcManagerProxy *)object;
268 if (instance != NULL) {
269 if (instance->remote != NULL) {
270 HdfRemoteServiceRecycle(instance->remote);
271 instance->remote = NULL;
272 }
273 OsalMemFree(instance);
274 }
275 }
276