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 #include <fcntl.h>
16 #include <hdf_base.h>
17 #include <hdf_device_desc.h>
18 #include <hdf_device_object.h>
19 #include <hdf_log.h>
20 #include <sys/ioctl.h>
21 #include <pthread.h>
22 #include <sys/stat.h>
23 #include <osal_mem.h>
24 #include <stub_collector.h>
25 #include "v2_0/iwpa_interface.h"
26 #include "wpa_impl.h"
27 #include <signal.h>
28
29 struct HdfWpaInterfaceHost {
30 struct IDeviceIoService ioService;
31 struct IWpaInterface *service;
32 struct HdfRemoteService **stubObject;
33 };
34
35 static pthread_rwlock_t g_rwLock = PTHREAD_RWLOCK_INITIALIZER;
36 static int g_stop = 0;
37
WpaInterfaceDriverDispatch(struct HdfDeviceIoClient * client,int cmdId,struct HdfSBuf * data,struct HdfSBuf * reply)38 static int32_t WpaInterfaceDriverDispatch(
39 struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply)
40 {
41 HDF_LOGI("WpaInterfaceDriverDispatch enter.");
42 pthread_rwlock_rdlock(&g_rwLock);
43 if (g_stop == 1 || client == NULL || client->device == NULL ||
44 client->device->service == NULL) {
45 pthread_rwlock_unlock(&g_rwLock);
46 HDF_LOGE("%{public}s: client or client.device or service is nullptr", __func__);
47 return HDF_FAILURE;
48 }
49 struct HdfWpaInterfaceHost *wpainterfaceHost = CONTAINER_OF(
50 client->device->service, struct HdfWpaInterfaceHost, ioService);
51 if (wpainterfaceHost == NULL || wpainterfaceHost->service == NULL || wpainterfaceHost->stubObject == NULL) {
52 HDF_LOGE("%{public}s: invalid service obj", __func__);
53 pthread_rwlock_unlock(&g_rwLock);
54 return HDF_ERR_INVALID_OBJECT;
55 }
56
57 struct HdfRemoteService *stubObj = *wpainterfaceHost->stubObject;
58 if (stubObj == NULL || stubObj->dispatcher == NULL || stubObj->dispatcher->Dispatch == NULL) {
59 pthread_rwlock_unlock(&g_rwLock);
60 return HDF_ERR_INVALID_OBJECT;
61 }
62 int ret = stubObj->dispatcher->Dispatch((struct HdfRemoteService *)stubObj->target, cmdId, data, reply);
63 pthread_rwlock_unlock(&g_rwLock);
64 return ret;
65 }
66
HdfWpaInterfaceDriverInit(struct HdfDeviceObject * deviceObject)67 static int HdfWpaInterfaceDriverInit(struct HdfDeviceObject *deviceObject)
68 {
69 int32_t ret;
70 HDF_LOGI("HdfWpaInterfaceDriverInit enter.");
71 struct HdfWpaStubData *stubData = HdfWpaStubDriver();
72 DListHeadInit(&stubData->remoteListHead);
73 ret = OsalMutexInit(&stubData->mutex);
74 if (ret != HDF_SUCCESS) {
75 HDF_LOGE("%{public}s: Mutex init failed, error code: %{public}d", __func__, ret);
76 return HDF_FAILURE;
77 }
78 return HDF_SUCCESS;
79 }
80
HdfWpaInterfaceDriverBind(struct HdfDeviceObject * deviceObject)81 static int HdfWpaInterfaceDriverBind(struct HdfDeviceObject *deviceObject)
82 {
83 HDF_LOGI("HdfWpaInterfaceDriverBind enter.");
84
85 int32_t ret = HdfDeviceObjectSetInterfaceDesc(deviceObject, IWPAINTERFACE_INTERFACE_DESC);
86 if (ret != HDF_SUCCESS) {
87 HDF_LOGE("failed to set interface descriptor of device object");
88 return ret;
89 }
90
91 struct HdfWpaInterfaceHost *wpainterfaceHost =
92 (struct HdfWpaInterfaceHost *)OsalMemAlloc(sizeof(struct HdfWpaInterfaceHost));
93 if (wpainterfaceHost == NULL) {
94 HDF_LOGE("HdfWpaInterfaceDriverBind OsalMemAlloc HdfWpaInterfaceHost failed!");
95 return HDF_FAILURE;
96 }
97
98 struct IWpaInterface *serviceImpl = IWpaInterfaceGet(true);
99 struct HdfRemoteService **stubObj = StubCollectorGetOrNewObject(IWPAINTERFACE_INTERFACE_DESC, serviceImpl);
100 if (stubObj == NULL) {
101 OsalMemFree(wpainterfaceHost);
102 wpainterfaceHost = NULL;
103 IWpaInterfaceRelease(serviceImpl, true);
104 return HDF_FAILURE;
105 }
106
107 wpainterfaceHost->ioService.Dispatch = WpaInterfaceDriverDispatch;
108 wpainterfaceHost->ioService.Open = NULL;
109 wpainterfaceHost->ioService.Release = NULL;
110 wpainterfaceHost->service = serviceImpl;
111 wpainterfaceHost->stubObject = stubObj;
112 deviceObject->service = &wpainterfaceHost->ioService;
113 return HDF_SUCCESS;
114 }
115
HdfWpaInterfaceDriverRelease(struct HdfDeviceObject * deviceObject)116 static void HdfWpaInterfaceDriverRelease(struct HdfDeviceObject *deviceObject)
117 {
118 HDF_LOGI("HdfWpaInterfaceDriverRelease enter.");
119 void (*result)(int) = signal(SIGTERM, SIG_DFL);
120 if (result == SIG_ERR) {
121 HDF_LOGE("Failed to set signal ignore handler for SIGTERM");
122 }
123 struct HdfWpaRemoteNode *pos = NULL;
124 struct HdfWpaRemoteNode *tmp = NULL;
125 pthread_rwlock_wrlock(&g_rwLock);
126 if (deviceObject == NULL) {
127 HDF_LOGI("deviceObject is NULL.");
128 pthread_rwlock_unlock(&g_rwLock);
129 return;
130 }
131 g_stop = 1;
132 struct HdfWpaStubData *stubData = HdfWpaStubDriver();
133 if (stubData == NULL) {
134 HDF_LOGE("%{public}s: stubData is NUll!", __func__);
135 pthread_rwlock_unlock(&g_rwLock);
136 return;
137 }
138
139 DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &stubData->remoteListHead, struct HdfWpaRemoteNode, node) {
140 DListRemove(&(pos->node));
141 OsalMemFree(pos);
142 pos = NULL;
143 }
144 OsalMutexDestroy(&stubData->mutex);
145 struct HdfWpaInterfaceHost *wpainterfaceHost = CONTAINER_OF(
146 deviceObject->service, struct HdfWpaInterfaceHost, ioService);
147 StubCollectorRemoveObject(IWPAINTERFACE_INTERFACE_DESC, wpainterfaceHost->service);
148 wpainterfaceHost->stubObject = NULL;
149 IWpaInterfaceRelease(wpainterfaceHost->service, true);
150 OsalMemFree(wpainterfaceHost);
151 wpainterfaceHost = NULL;
152 if (deviceObject->service != NULL) {
153 deviceObject->service = NULL;
154 }
155 pthread_rwlock_unlock(&g_rwLock);
156 }
157
158 struct HdfDriverEntry g_wpainterfaceDriverEntry = {
159 .moduleVersion = 1,
160 .moduleName = "wpa_service",
161 .Bind = HdfWpaInterfaceDriverBind,
162 .Init = HdfWpaInterfaceDriverInit,
163 .Release = HdfWpaInterfaceDriverRelease,
164 };
165
166 HDF_INIT(g_wpainterfaceDriverEntry);
167