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  
16  #include "p2p_callback_impl.h"
17  #include <securec.h>
18  #include <hdf_base.h>
19  #include <hdf_log.h>
20  #include <osal_mem.h>
21  
P2pCallbackDeviceFound(struct IWpaCallback * self,const struct HdiP2pDeviceInfoParam * deviceInfoParam,const char * ifName)22  static int32_t P2pCallbackDeviceFound(struct IWpaCallback *self,
23      const struct HdiP2pDeviceInfoParam *deviceInfoParam, const char *ifName)
24  {
25      (void)self;
26      if (deviceInfoParam == NULL || ifName == NULL) {
27          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
28          return HDF_ERR_INVALID_PARAM;
29      }
30      HDF_LOGE("%{public}s: srcAddress=" MACSTR, __func__, MAC2STR(deviceInfoParam->srcAddress));
31      return HDF_SUCCESS;
32  }
33  
P2pCallbackDeviceLost(struct IWpaCallback * self,const struct HdiP2pDeviceLostParam * deviceLostParam,const char * ifName)34  static int32_t P2pCallbackDeviceLost(struct IWpaCallback *self,
35      const struct HdiP2pDeviceLostParam *deviceLostParam, const char *ifName)
36  {
37      (void)self;
38      if (deviceLostParam == NULL || ifName == NULL) {
39          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
40          return HDF_ERR_INVALID_PARAM;
41      }
42      HDF_LOGE("%{public}s: p2pDeviceAddress=" MACSTR, __func__, MAC2STR(deviceLostParam->p2pDeviceAddress));
43      return HDF_SUCCESS;
44  }
45  
P2pCallbackGoNegotiationRequest(struct IWpaCallback * self,const struct HdiP2pGoNegotiationRequestParam * goNegotiationRequestParam,const char * ifName)46  static int32_t P2pCallbackGoNegotiationRequest(struct IWpaCallback *self,
47      const struct HdiP2pGoNegotiationRequestParam *goNegotiationRequestParam, const char *ifName)
48  {
49      (void)self;
50      if (goNegotiationRequestParam == NULL || ifName == NULL) {
51          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
52          return HDF_ERR_INVALID_PARAM;
53      }
54      HDF_LOGE("%{public}s: srcAddress=" MACSTR, __func__, MAC2STR(goNegotiationRequestParam->srcAddress));
55      return HDF_SUCCESS;
56  }
57  
P2pCallbackGoNegotiationCompleted(struct IWpaCallback * self,const struct HdiP2pGoNegotiationCompletedParam * goNegotiationCompletedParam,const char * ifName)58  static int32_t P2pCallbackGoNegotiationCompleted(struct IWpaCallback *self,
59      const struct HdiP2pGoNegotiationCompletedParam *goNegotiationCompletedParam, const char *ifName)
60  {
61      (void)self;
62      if (goNegotiationCompletedParam == NULL || ifName == NULL) {
63          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
64          return HDF_ERR_INVALID_PARAM;
65      }
66      HDF_LOGE("%{public}s: status=%{public}d", __func__, goNegotiationCompletedParam->status);
67      return HDF_SUCCESS;
68  }
69  
P2pCallbackInvitationReceived(struct IWpaCallback * self,const struct HdiP2pInvitationReceivedParam * invitationReceivedParam,const char * ifName)70  static int32_t P2pCallbackInvitationReceived(struct IWpaCallback *self,
71      const struct HdiP2pInvitationReceivedParam *invitationReceivedParam, const char *ifName)
72  {
73      (void)self;
74      if (invitationReceivedParam == NULL || ifName == NULL) {
75          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
76          return HDF_ERR_INVALID_PARAM;
77      }
78      HDF_LOGE("%{public}s: srcAddress=" MACSTR, __func__, MAC2STR(invitationReceivedParam->srcAddress));
79      return HDF_SUCCESS;
80  }
81  
P2pCallbackInvitationResult(struct IWpaCallback * self,const struct HdiP2pInvitationResultParam * invitationResultParam,const char * ifName)82  static int32_t P2pCallbackInvitationResult(struct IWpaCallback *self,
83      const struct HdiP2pInvitationResultParam *invitationResultParam, const char *ifName)
84  {
85      (void)self;
86      if (invitationResultParam == NULL || ifName == NULL) {
87          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
88          return HDF_ERR_INVALID_PARAM;
89      }
90      HDF_LOGE("%{public}s: bssid=" MACSTR, __func__, MAC2STR(invitationResultParam->bssid));
91      return HDF_SUCCESS;
92  }
93  
P2pCallbackGroupFormationSuccess(struct IWpaCallback * self,const char * ifName)94  static int32_t P2pCallbackGroupFormationSuccess(struct IWpaCallback *self, const char *ifName)
95  {
96      (void)self;
97      if (ifName == NULL) {
98          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
99          return HDF_ERR_INVALID_PARAM;
100      }
101      HDF_LOGE("%{public}s: GroupFormationSuccess", __func__);
102      return HDF_SUCCESS;
103  }
104  
P2pCallbackGroupFormationFailure(struct IWpaCallback * self,const char * reason,const char * ifName)105  static int32_t P2pCallbackGroupFormationFailure(struct IWpaCallback *self,
106      const char *reason, const char *ifName)
107  {
108      (void)self;
109      if (reason == NULL || ifName == NULL) {
110          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
111          return HDF_ERR_INVALID_PARAM;
112      }
113  
114      HDF_LOGE("%{public}s: reason=%{public}s", __func__, reason);
115      return HDF_SUCCESS;
116  }
117  
P2pCallbackGroupStarted(struct IWpaCallback * self,const struct HdiP2pGroupStartedParam * groupStartedParam,const char * ifName)118  static int32_t P2pCallbackGroupStarted(struct IWpaCallback *self,
119      const struct HdiP2pGroupStartedParam *groupStartedParam, const char *ifName)
120  {
121      (void)self;
122      if (groupStartedParam == NULL || ifName == NULL) {
123          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
124          return HDF_ERR_INVALID_PARAM;
125      }
126      HDF_LOGE("%{public}s: goDeviceAddress=" MACSTR, __func__, MAC2STR(groupStartedParam->goDeviceAddress));
127      return HDF_SUCCESS;
128  }
129  
P2pCallbackGroupRemoved(struct IWpaCallback * self,const struct HdiP2pGroupRemovedParam * groupRemovedParam,const char * ifName)130  static int32_t P2pCallbackGroupRemoved(struct IWpaCallback *self,
131      const struct HdiP2pGroupRemovedParam *groupRemovedParam, const char *ifName)
132  {
133      (void)self;
134      if (groupRemovedParam == NULL || ifName == NULL) {
135          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
136          return HDF_ERR_INVALID_PARAM;
137      }
138      HDF_LOGE("%{public}s: isGo=%{public}d groupIfName=%{public}s", __func__, groupRemovedParam->isGo,
139          groupRemovedParam->groupIfName);
140      return HDF_SUCCESS;
141  }
142  
P2pCallbackProvisionDiscoveryCompleted(struct IWpaCallback * self,const struct HdiP2pProvisionDiscoveryCompletedParam * param,const char * ifName)143  static int32_t P2pCallbackProvisionDiscoveryCompleted(struct IWpaCallback *self,
144      const struct HdiP2pProvisionDiscoveryCompletedParam *param, const char *ifName)
145  {
146      (void)self;
147      if (param == NULL || ifName == NULL) {
148          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
149          return HDF_ERR_INVALID_PARAM;
150      }
151      HDF_LOGE("%{public}s: p2pDeviceAddress=" MACSTR, __func__, MAC2STR(param->p2pDeviceAddress));
152      return HDF_SUCCESS;
153  }
154  
P2pCallbackFindStopped(struct IWpaCallback * self,const char * ifName)155  static int32_t P2pCallbackFindStopped(struct IWpaCallback *self, const char *ifName)
156  {
157      (void)self;
158      if (ifName == NULL) {
159          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
160          return HDF_ERR_INVALID_PARAM;
161      }
162      HDF_LOGE("%{public}s: FindStopped", __func__);
163      return HDF_SUCCESS;
164  }
165  
P2pCallbackServDiscReq(struct IWpaCallback * self,const struct HdiP2pServDiscReqInfoParam * servDiscReqInfoParam,const char * ifName)166  static int32_t P2pCallbackServDiscReq(struct IWpaCallback *self,
167      const struct HdiP2pServDiscReqInfoParam *servDiscReqInfoParam, const char *ifName)
168  {
169      (void)self;
170      if (servDiscReqInfoParam == NULL || ifName == NULL) {
171          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
172          return HDF_ERR_INVALID_PARAM;
173      }
174      HDF_LOGE("%{public}s: mac=" MACSTR, __func__, MAC2STR(servDiscReqInfoParam->mac));
175      return HDF_SUCCESS;
176  }
177  
P2pCallbackServDiscResp(struct IWpaCallback * self,const struct HdiP2pServDiscRespParam * param,const char * ifName)178  static int32_t P2pCallbackServDiscResp(struct IWpaCallback *self,
179      const struct HdiP2pServDiscRespParam *param, const char *ifName)
180  {
181      (void)self;
182      if (param == NULL || ifName == NULL) {
183          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
184          return HDF_ERR_INVALID_PARAM;
185      }
186      HDF_LOGE("%{public}s: srcAddress=" MACSTR, __func__, MAC2STR(param->srcAddress));
187      return HDF_SUCCESS;
188  }
189  
P2pCallbackStaConnectState(struct IWpaCallback * self,const struct HdiP2pStaConnectStateParam * param,const char * ifName)190  static int32_t P2pCallbackStaConnectState(struct IWpaCallback *self,
191      const struct HdiP2pStaConnectStateParam *param, const char *ifName)
192  {
193      (void)self;
194      if (param == NULL || ifName == NULL) {
195          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
196          return HDF_ERR_INVALID_PARAM;
197      }
198      HDF_LOGE("%{public}s: srcAddress=" MACSTR "p2pDeviceAddress=" MACSTR, __func__, MAC2STR(param->srcAddress),
199          MAC2STR(param->p2pDeviceAddress));
200      return HDF_SUCCESS;
201  }
202  
P2pCallbackIfaceCreated(struct IWpaCallback * self,const struct HdiP2pIfaceCreatedParam * param,const char * ifName)203  static int32_t P2pCallbackIfaceCreated(struct IWpaCallback *self,
204      const struct HdiP2pIfaceCreatedParam *param, const char *ifName)
205  {
206      (void)self;
207      if (param == NULL || ifName == NULL) {
208          HDF_LOGE("%{public}s: input parameter invalid!", __func__);
209          return HDF_ERR_INVALID_PARAM;
210      }
211      HDF_LOGE("%{public}s: isGo=%{public}d", __func__, param->isGo);
212      return HDF_SUCCESS;
213  }
214  
P2pCallbackServiceGet(void)215  struct IWpaCallback *P2pCallbackServiceGet(void)
216  {
217      struct P2pCallbackService *service =
218          (struct P2pCallbackService *)OsalMemCalloc(sizeof(struct P2pCallbackService));
219      if (service == NULL) {
220          HDF_LOGE("%{public}s: malloc P2pCallbackService obj failed!", __func__);
221          return NULL;
222      }
223  
224      service->interface.OnEventDeviceFound = P2pCallbackDeviceFound;
225      service->interface.OnEventDeviceLost = P2pCallbackDeviceLost;
226      service->interface.OnEventGoNegotiationRequest = P2pCallbackGoNegotiationRequest;
227      service->interface.OnEventGoNegotiationCompleted = P2pCallbackGoNegotiationCompleted;
228      service->interface.OnEventInvitationReceived = P2pCallbackInvitationReceived;
229      service->interface.OnEventInvitationResult = P2pCallbackInvitationResult;
230      service->interface.OnEventGroupFormationSuccess = P2pCallbackGroupFormationSuccess;
231      service->interface.OnEventGroupFormationFailure = P2pCallbackGroupFormationFailure;
232      service->interface.OnEventGroupStarted = P2pCallbackGroupStarted;
233      service->interface.OnEventGroupRemoved = P2pCallbackGroupRemoved;
234      service->interface.OnEventProvisionDiscoveryCompleted = P2pCallbackProvisionDiscoveryCompleted;
235      service->interface.OnEventFindStopped = P2pCallbackFindStopped;
236      service->interface.OnEventServDiscReq = P2pCallbackServDiscReq;
237      service->interface.OnEventServDiscResp = P2pCallbackServDiscResp;
238      service->interface.OnEventStaConnectState = P2pCallbackStaConnectState;
239      service->interface.OnEventIfaceCreated = P2pCallbackIfaceCreated;
240      return &service->interface;
241  }
242  
P2pCallbackServiceRelease(struct IWpaCallback * instance)243  void P2pCallbackServiceRelease(struct IWpaCallback *instance)
244  {
245      struct P2pCallbackService *service = (struct P2pCallbackService *)instance;
246      if (service == NULL) {
247          return;
248      }
249  
250      OsalMemFree(service);
251  }
252