1  /*
2   * Copyright (c) 2021 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 "bus_center_client_stub.h"
17  
18  #include <stdint.h>
19  
20  #include "client_bus_center_manager.h"
21  #include "ipc_skeleton.h"
22  #include "lnn_log.h"
23  #include "softbus_def.h"
24  #include "softbus_errcode.h"
25  
ClientOnJoinLNNResult(IpcIo * data,IpcIo * reply)26  int32_t ClientOnJoinLNNResult(IpcIo *data, IpcIo *reply)
27  {
28      if (data == NULL) {
29          LNN_LOGE(LNN_EVENT, "invalid param");
30          return SOFTBUS_ERR;
31      }
32  
33      uint32_t addrSize;
34      ReadUint32(data, &addrSize);
35      if (addrSize != sizeof(ConnectionAddr)) {
36          LNN_LOGE(LNN_EVENT, "read addr failed. addrSize=%{public}d", addrSize);
37          return SOFTBUS_ERR;
38      }
39      void *addr = (void *)ReadBuffer(data, addrSize);
40      if (addr == NULL) {
41          LNN_LOGE(LNN_EVENT, "read addr failed");
42          return SOFTBUS_ERR;
43      }
44      int32_t retCode = 0;
45      ReadInt32(data, &retCode);
46      size_t networkIdLen;
47      const char *networkId = NULL;
48      if (retCode == 0) {
49          networkId = (const char *)ReadString(data, &networkIdLen);
50          if (networkId == NULL) {
51              LNN_LOGE(LNN_EVENT, "read networkId failed");
52              return SOFTBUS_ERR;
53          }
54      }
55      int32_t retReply = LnnOnJoinResult(addr, networkId, retCode);
56      if (retReply != SOFTBUS_OK) {
57          LNN_LOGE(LNN_EVENT, "LnnOnJoinResult failed");
58          return SOFTBUS_ERR;
59      }
60      return SOFTBUS_OK;
61  }
62  
ClientOnJoinMetaNodeResult(IpcIo * data,IpcIo * reply)63  int32_t ClientOnJoinMetaNodeResult(IpcIo *data, IpcIo *reply)
64  {
65      (void)data;
66      (void)reply;
67      return SOFTBUS_OK;
68  }
69  
ClientOnLeaveLNNResult(IpcIo * data,IpcIo * reply)70  int32_t ClientOnLeaveLNNResult(IpcIo *data, IpcIo *reply)
71  {
72      if (data == NULL) {
73          LNN_LOGE(LNN_EVENT, "invalid param");
74          return SOFTBUS_ERR;
75      }
76      size_t networkIdLen;
77      const char *networkId = (const char *)ReadString(data, &networkIdLen);
78      if (networkId == NULL) {
79          LNN_LOGE(LNN_EVENT, "read networkId failed");
80          return SOFTBUS_ERR;
81      }
82      int32_t retCode = 0;
83      ReadInt32(data, &retCode);
84      int32_t retReply = LnnOnLeaveResult(networkId, retCode);
85      if (retReply != SOFTBUS_OK) {
86          LNN_LOGE(LNN_EVENT, "LnnOnLeaveResult failed");
87          return SOFTBUS_ERR;
88      }
89      return SOFTBUS_OK;
90  }
91  
ClientOnLeaveMetaNodeResult(IpcIo * data,IpcIo * reply)92  int32_t ClientOnLeaveMetaNodeResult(IpcIo *data, IpcIo *reply)
93  {
94      (void)data;
95      (void)reply;
96      return SOFTBUS_OK;
97  }
98  
ClientOnNodeOnlineStateChanged(IpcIo * data,IpcIo * reply)99  int32_t ClientOnNodeOnlineStateChanged(IpcIo *data, IpcIo *reply)
100  {
101      if (data== NULL) {
102          LNN_LOGE(LNN_EVENT, "invalid param");
103          return SOFTBUS_ERR;
104      }
105      bool isOnline;
106      ReadBool(data, &isOnline);
107      uint32_t infoSize = 0;
108      ReadUint32(data, &infoSize);
109      if (infoSize != sizeof(NodeBasicInfo)) {
110          LNN_LOGE(LNN_EVENT,
111              "read basic info failed. infoSize=%{public}d", infoSize);
112          return SOFTBUS_ERR;
113      }
114      void *info = (void *)ReadBuffer(data, infoSize);
115      if (info == NULL) {
116          LNN_LOGE(LNN_EVENT, "read basic info failed");
117          return SOFTBUS_ERR;
118      }
119      int32_t retReply = LnnOnNodeOnlineStateChanged("", isOnline, info);
120      if (retReply != SOFTBUS_OK) {
121          LNN_LOGE(LNN_EVENT, "LnnOnNodeOnlineStateChanged failed");
122          return SOFTBUS_ERR;
123      }
124      return SOFTBUS_OK;
125  }
126  
ClientOnNodeBasicInfoChanged(IpcIo * data,IpcIo * reply)127  int32_t ClientOnNodeBasicInfoChanged(IpcIo *data, IpcIo *reply)
128  {
129      if (data == NULL) {
130          LNN_LOGE(LNN_EVENT, "invalid param");
131          return SOFTBUS_ERR;
132      }
133  
134      int32_t type = 0;
135      ReadInt32(data, &type);
136      uint32_t infoSize = 0;
137      ReadUint32(data, &infoSize);
138      if (infoSize != sizeof(NodeBasicInfo)) {
139          LNN_LOGE(LNN_EVENT,
140              "read basic info failed. infoSize=%{public}d", infoSize);
141          return SOFTBUS_ERR;
142      }
143      void *info = (void *)ReadBuffer(data, infoSize);
144      if (info == NULL) {
145          LNN_LOGE(LNN_EVENT, "read basic info failed");
146          return SOFTBUS_ERR;
147      }
148      int32_t retReply = LnnOnNodeBasicInfoChanged("", info, type);
149      if (retReply != SOFTBUS_OK) {
150          LNN_LOGE(LNN_EVENT,
151              "LnnOnNodeBasicInfoChanged failed");
152          return SOFTBUS_ERR;
153      }
154      return SOFTBUS_OK;
155  }
156  
ClientOnTimeSyncResult(IpcIo * data,IpcIo * reply)157  int32_t ClientOnTimeSyncResult(IpcIo *data, IpcIo *reply)
158  {
159      if (data == NULL) {
160          LNN_LOGE(LNN_EVENT, "invalid param");
161          return SOFTBUS_ERR;
162      }
163  
164      uint32_t infoSize = 0;
165      ReadUint32(data, &infoSize);
166      if (infoSize != sizeof(TimeSyncResultInfo)) {
167          LNN_LOGE(LNN_EVENT, "read info failed. infoSize=%{public}d", infoSize);
168          return SOFTBUS_ERR;
169      }
170      void *info = (void *)ReadBuffer(data, infoSize);
171      if (info == NULL) {
172          LNN_LOGE(LNN_EVENT, "read info failed");
173          return SOFTBUS_ERR;
174      }
175      int32_t retCode = 0;
176      ReadInt32(data, &retCode);
177  
178      int32_t retReply = LnnOnTimeSyncResult(info, retCode);
179      if (retReply != SOFTBUS_OK) {
180          LNN_LOGE(LNN_EVENT, "LnnOnTimeSyncResult failed");
181          return SOFTBUS_ERR;
182      }
183      return SOFTBUS_OK;
184  }
185  
ClientOnPublishLNNResult(IpcIo * data,IpcIo * reply)186  void ClientOnPublishLNNResult(IpcIo *data, IpcIo *reply)
187  {
188      if (reply == NULL) {
189          LNN_LOGE(LNN_EVENT, "invalid param");
190          return;
191      }
192      int32_t publishId;
193      ReadInt32(data, &publishId);
194      int32_t reason;
195      ReadInt32(data, &reason);
196      LnnOnPublishLNNResult(publishId, reason);
197  }
198  
ClientOnRefreshLNNResult(IpcIo * data,IpcIo * reply)199  void ClientOnRefreshLNNResult(IpcIo *data, IpcIo *reply)
200  {
201      if (data == NULL) {
202          LNN_LOGE(LNN_EVENT, "invalid param");
203          return;
204      }
205      int32_t refreshId;
206      ReadInt32(data, &refreshId);
207      int32_t reason;
208      ReadInt32(data, &reason);
209      LnnOnRefreshLNNResult(refreshId, reason);
210  }
211  
ClientOnRefreshDeviceFound(IpcIo * data,IpcIo * reply)212  void ClientOnRefreshDeviceFound(IpcIo *data, IpcIo *reply)
213  {
214      if (data == NULL) {
215          LNN_LOGE(LNN_EVENT, "invalid param");
216          return;
217      }
218      uint32_t infoSize;
219      ReadUint32(data, &infoSize);
220      if (infoSize != sizeof(DeviceInfo)) {
221          LNN_LOGE(LNN_EVENT,
222              "read info failed. infoSize=%{public}d", infoSize);
223          return;
224      }
225      void *info = (void *)ReadBuffer(data, infoSize);
226      if (info == NULL) {
227          LNN_LOGE(LNN_EVENT, "read info failed");
228          return;
229      }
230      LnnOnRefreshDeviceFound(info);
231  }
232