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 "device_service_stub.h"
17 #include "devsvc_manager_clnt.h"
18 #include "hdf_base.h"
19 #include "hdf_log.h"
20 #include "hdf_sbuf.h"
21 #include "osal_mem.h"
22
DeviceServiceStubDispatch(struct HdfRemoteService * stub,int code,struct HdfSBuf * data,struct HdfSBuf * reply)23 int DeviceServiceStubDispatch(
24 struct HdfRemoteService *stub, int code, struct HdfSBuf *data, struct HdfSBuf *reply)
25 {
26 struct DeviceServiceStub *service = (struct DeviceServiceStub *)stub;
27 struct IDeviceIoService *ioService = service->super.deviceObject.service;
28 int ret = HDF_FAILURE;
29
30 if (ioService == NULL) {
31 return HDF_FAILURE;
32 }
33
34 struct HdfDeviceIoClient client = {
35 .device = &service->super.deviceObject,
36 .priv = NULL,
37 };
38
39 if (ioService->Dispatch != NULL) {
40 ret = ioService->Dispatch(&client, code, data, reply);
41 }
42 return ret;
43 }
44
45 static struct HdfRemoteDispatcher g_deviceServiceDispatcher = {
46 .Dispatch = DeviceServiceStubDispatch
47 };
48
DeviceServiceStubPublishService(struct HdfDeviceNode * service)49 int DeviceServiceStubPublishService(struct HdfDeviceNode *service)
50 {
51 int status = HDF_FAILURE;
52 struct DeviceServiceStub *fullService = (struct DeviceServiceStub *)service;
53
54 if (service->servName == NULL) {
55 HDF_LOGE("device %x miss service name", service->devId);
56 return HDF_ERR_INVALID_OBJECT;
57 }
58
59 if (fullService->remote != NULL) {
60 HDF_LOGE("%{public}s:service %{public}s already published", __func__, service->servName);
61 return HDF_ERR_INVALID_OBJECT;
62 }
63
64 if (service->policy != SERVICE_POLICY_PUBLIC && service->policy != SERVICE_POLICY_CAPACITY) {
65 return HDF_ERR_NOT_SUPPORT;
66 }
67
68 fullService->remote = HdfRemoteServiceObtain((struct HdfObject *)fullService, &g_deviceServiceDispatcher);
69 if (fullService->remote == NULL) {
70 return HDF_ERR_MALLOC_FAIL;
71 }
72
73 do {
74 if (service->interfaceDesc != NULL &&
75 !HdfRemoteServiceSetInterfaceDesc(fullService->remote, service->interfaceDesc)) {
76 HDF_LOGE("failed to set device service interface desc");
77 break;
78 }
79 struct DevSvcManagerClnt *serviceManager = DevSvcManagerClntGetInstance();
80 if (serviceManager == NULL) {
81 HDF_LOGE("device service stub failed to publish, svcmgr clnt invalid");
82 status = HDF_DEV_ERR_NO_DEVICE;
83 break;
84 }
85 struct HdfServiceInfo servInfo;
86 HdfServiceInfoInit(&servInfo, service);
87 status = DevSvcManagerClntAddService(&fullService->super.deviceObject, &servInfo);
88 if (status != HDF_SUCCESS) {
89 break;
90 }
91 service->servStatus = true;
92 return HDF_SUCCESS;
93 } while (0);
94
95 HdfRemoteServiceRecycle(fullService->remote);
96 fullService->remote = NULL;
97 return status;
98 }
99
DeviceServiceStubRemoveService(struct HdfDeviceNode * deviceNode)100 int DeviceServiceStubRemoveService(struct HdfDeviceNode *deviceNode)
101 {
102 struct DevSvcManagerClnt *serviceManager = DevSvcManagerClntGetInstance();
103 if (serviceManager == NULL) {
104 return HDF_FAILURE;
105 }
106 DevSvcManagerClntRemoveService(deviceNode->servName);
107 struct DeviceServiceStub *instance = (struct DeviceServiceStub *)deviceNode;
108 HdfRemoteServiceRecycle(instance->remote);
109 instance->remote = NULL;
110 return HDF_SUCCESS;
111 }
112
DeviceServiceStubConstruct(struct DeviceServiceStub * inst)113 void DeviceServiceStubConstruct(struct DeviceServiceStub *inst)
114 {
115 HdfDeviceNodeConstruct(&inst->super);
116 struct IDeviceNode *serviceIf = (struct IDeviceNode *)inst;
117 if (serviceIf != NULL) {
118 serviceIf->PublishService = DeviceServiceStubPublishService;
119 serviceIf->RemoveService = DeviceServiceStubRemoveService;
120 }
121 }
122
DeviceServiceStubCreate(void)123 struct HdfObject *DeviceServiceStubCreate(void)
124 {
125 struct DeviceServiceStub *instance =
126 (struct DeviceServiceStub *)OsalMemCalloc(sizeof(struct DeviceServiceStub));
127 if (instance != NULL) {
128 DeviceServiceStubConstruct(instance);
129 }
130 return (struct HdfObject *)instance;
131 }
132
DeviceServiceStubRelease(struct HdfObject * object)133 void DeviceServiceStubRelease(struct HdfObject *object)
134 {
135 struct DeviceServiceStub *instance = (struct DeviceServiceStub *)object;
136 if (instance != NULL) {
137 if (instance->remote != NULL) {
138 HdfRemoteServiceRecycle(instance->remote);
139 instance->remote = NULL;
140 }
141 HdfDeviceNodeDestruct(&instance->super);
142 OsalMemFree(instance);
143 }
144 }
145
HdfDeviceObjectCheckInterfaceDesc(struct HdfDeviceObject * dev,struct HdfSBuf * data)146 bool HdfDeviceObjectCheckInterfaceDesc(struct HdfDeviceObject *dev, struct HdfSBuf *data)
147 {
148 if (dev == NULL || data == NULL) {
149 return false;
150 }
151 struct HdfDeviceNode *devNode = CONTAINER_OF(dev, struct HdfDeviceNode, deviceObject);
152 struct DeviceServiceStub *instance = (struct DeviceServiceStub *)devNode;
153 return HdfRemoteServiceCheckInterfaceToken(instance->remote, data);
154 }