1 /*
2  * Copyright (c) 2021-2024 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 "trans_server_proxy_standard.h"
17 
18 #include "anonymizer.h"
19 #include "ipc_skeleton.h"
20 #include "ipc_types.h"
21 #include "message_parcel.h"
22 #include "softbus_errcode.h"
23 #include "softbus_server_ipc_interface_code.h"
24 #include "trans_log.h"
25 
26 #define WRITE_PARCEL_WITH_RET(parcel, type, data, retval)                              \
27     do {                                                                               \
28         if (!(parcel).Write##type(data)) {                                             \
29             TRANS_LOGE(TRANS_SDK, "write data failed.");                               \
30             return (retval);                                                           \
31         }                                                                              \
32     } while (false)
33 
34 #define CHANNEL_TYPE_UNDEFINED (-1)
35 
36 namespace OHOS {
37 static uint32_t g_getSystemAbilityId = 2;
38 const std::u16string SAMANAGER_INTERFACE_TOKEN = u"ohos.samgr.accessToken";
GetSystemAbility()39 static sptr<IRemoteObject> GetSystemAbility()
40 {
41     MessageParcel data;
42 
43     if (!data.WriteInterfaceToken(SAMANAGER_INTERFACE_TOKEN)) {
44         return nullptr;
45     }
46 
47     data.WriteInt32(SOFTBUS_SERVER_SA_ID_INNER);
48     MessageParcel reply;
49     MessageOption option;
50     sptr<IRemoteObject> samgr = IPCSkeleton::GetContextObject();
51     if (samgr == nullptr) {
52         TRANS_LOGE(TRANS_SDK, "Get samgr failed!");
53         return nullptr;
54     }
55     int32_t err = samgr->SendRequest(g_getSystemAbilityId, data, reply, option);
56     if (err != SOFTBUS_OK) {
57         TRANS_LOGE(TRANS_SDK, "Get GetSystemAbility failed!");
58         return nullptr;
59     }
60     return reply.ReadRemoteObject();
61 }
62 
SoftbusRegisterService(const char * clientPkgName,const sptr<IRemoteObject> & object)63 int32_t TransServerProxy::SoftbusRegisterService(const char *clientPkgName, const sptr<IRemoteObject> &object)
64 {
65     (void)clientPkgName;
66     (void)object;
67     return SOFTBUS_OK;
68 }
69 
CreateSessionServer(const char * pkgName,const char * sessionName)70 int32_t TransServerProxy::CreateSessionServer(const char *pkgName, const char *sessionName)
71 {
72     if (pkgName == nullptr || sessionName == nullptr) {
73         return SOFTBUS_INVALID_PARAM;
74     }
75     sptr<IRemoteObject> remote = GetSystemAbility();
76     if (remote == nullptr) {
77         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
78         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
79     }
80 
81     MessageParcel data;
82     if (!data.WriteInterfaceToken(GetDescriptor())) {
83         TRANS_LOGE(TRANS_SDK, "write InterfaceToken failed!");
84         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
85     }
86     if (!data.WriteCString(pkgName)) {
87         TRANS_LOGE(TRANS_SDK, "write pkg name failed!");
88         return SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED;
89     }
90     if (!data.WriteCString(sessionName)) {
91         TRANS_LOGE(TRANS_SDK, "write session name failed!");
92         return SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED;
93     }
94     MessageParcel reply;
95     MessageOption option;
96     int32_t ret = remote->SendRequest(SERVER_CREATE_SESSION_SERVER, data, reply, option);
97     if (ret != SOFTBUS_OK) {
98         TRANS_LOGE(TRANS_SDK, "send request failed! ret=%{public}d", ret);
99         return ret;
100     }
101     int32_t serverRet = 0;
102     if (!reply.ReadInt32(serverRet)) {
103         TRANS_LOGE(TRANS_SDK, "read serverRet failed!");
104         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
105     }
106     return serverRet;
107 }
108 
RemoveSessionServer(const char * pkgName,const char * sessionName)109 int32_t TransServerProxy::RemoveSessionServer(const char *pkgName, const char *sessionName)
110 {
111     if (pkgName == nullptr || sessionName == nullptr) {
112         return SOFTBUS_INVALID_PARAM;
113     }
114     sptr<IRemoteObject> remote = GetSystemAbility();
115     if (remote == nullptr) {
116         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
117         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
118     }
119 
120     MessageParcel data;
121     if (!data.WriteInterfaceToken(GetDescriptor())) {
122         TRANS_LOGE(TRANS_SDK, "write InterfaceToken failed!");
123         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
124     }
125     if (!data.WriteCString(pkgName)) {
126         TRANS_LOGE(TRANS_SDK, "write pkg name failed!");
127         return SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED;
128     }
129     if (!data.WriteCString(sessionName)) {
130         TRANS_LOGE(TRANS_SDK, "session name failed!");
131         return SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED;
132     }
133     MessageParcel reply;
134     MessageOption option;
135     int32_t ret = remote->SendRequest(SERVER_REMOVE_SESSION_SERVER, data, reply, option);
136     if (ret != SOFTBUS_OK) {
137         TRANS_LOGE(TRANS_SDK, "send request failed! ret=%{public}d", ret);
138         return ret;
139     }
140     int32_t serverRet = 0;
141     if (!reply.ReadInt32(serverRet)) {
142         TRANS_LOGE(TRANS_SDK, "read serverRet failed!");
143         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
144     }
145     return serverRet;
146 }
147 
ReleaseResources(int32_t channelId)148 int32_t TransServerProxy::ReleaseResources(int32_t channelId)
149 {
150     sptr<IRemoteObject> remote = GetSystemAbility();
151     if (remote == nullptr) {
152         TRANS_LOGD(TRANS_SDK, "remote is nullptr!");
153         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
154     }
155     MessageParcel data;
156     if (!data.WriteInterfaceToken(GetDescriptor())) {
157         TRANS_LOGE(TRANS_SDK, "failed to write InterfaceToken");
158         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
159     }
160     if (!data.WriteInt32(channelId)) {
161         TRANS_LOGE(TRANS_SDK, "failed to write channelId");
162         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
163     }
164 
165     MessageParcel reply;
166     MessageOption option;
167     int32_t ret = remote->SendRequest(SERVER_RELEASE_RESOURCES, data, reply, option);
168     if (ret != SOFTBUS_OK) {
169         TRANS_LOGE(TRANS_SDK, "failed to send request ret=%{public}d", ret);
170         return ret;
171     }
172     int32_t serverRet = 0;
173     if (!reply.ReadInt32(serverRet)) {
174         TRANS_LOGE(TRANS_SDK, "failed to read serverRet failed");
175         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
176     }
177     return SOFTBUS_OK;
178 }
179 
TransWriteSessionAttrs(const SessionAttribute * attrs,MessageParcel & data)180 static bool TransWriteSessionAttrs(const SessionAttribute *attrs, MessageParcel &data)
181 {
182     if (attrs == nullptr) {
183         TRANS_LOGE(TRANS_SDK, "attrs is nullptr!");
184         return false;
185     }
186 
187     if (!data.WriteInt32(attrs->dataType)) {
188         TRANS_LOGE(TRANS_SDK, "OpenSession write my attrs dataType failed!");
189         return false;
190     }
191 
192     if (!data.WriteInt32(attrs->linkTypeNum)) {
193         TRANS_LOGE(TRANS_SDK, "OpenSession write my attrs linkTypeNum failed!");
194         return false;
195     }
196 
197     if (attrs->linkTypeNum > 0) {
198         if (!data.WriteBuffer(attrs->linkType, sizeof(LinkType) * attrs->linkTypeNum)) {
199             TRANS_LOGE(TRANS_SDK, "OpenSession write my attrs linkType failed!");
200             return false;
201         }
202     }
203 
204     if (!data.WriteInt32(attrs->attr.streamAttr.streamType)) {
205         TRANS_LOGE(TRANS_SDK, "OpenSession write my attrs streamAttr failed!");
206         return false;
207     }
208 
209     if (attrs->fastTransData != nullptr) {
210         if (!data.WriteUint16(attrs->fastTransDataSize)) {
211             TRANS_LOGE(TRANS_SDK, "OpenSession write my attrs fastTransDataSize failed!");
212             return false;
213         }
214         if (!data.WriteRawData(attrs->fastTransData, attrs->fastTransDataSize)) {
215             TRANS_LOGE(TRANS_SDK, "OpenSession write my attrs fastTransData failed!");
216             return false;
217         }
218     } else {
219         if (!data.WriteUint16(0)) {
220             TRANS_LOGE(TRANS_SDK, "OpenSession write my attrs fastTransDataSize failed!");
221             return false;
222         }
223     }
224 
225     return true;
226 }
227 
WriteQosInfo(const SessionParam * param,MessageParcel & data)228 static bool WriteQosInfo(const SessionParam *param, MessageParcel &data)
229 {
230     if (!data.WriteBool(param->isQosLane)) {
231         TRANS_LOGE(TRANS_SDK, "OpenSession write qos flag failed!");
232         return false;
233     }
234 
235     if (!param->isQosLane) {
236         return true;
237     }
238 
239     if (!data.WriteUint32(param->qosCount)) {
240         TRANS_LOGE(TRANS_SDK, "OpenSession write count of qos failed!");
241         return false;
242     }
243 
244     if (param->qosCount > 0) {
245         if (!data.WriteBuffer(param->qos, sizeof(QosTV) * param->qosCount)) {
246             TRANS_LOGE(TRANS_SDK, "OpenSession write qos info failed!");
247             return false;
248         }
249     }
250 
251     return true;
252 }
253 
OpenSession(const SessionParam * param,TransInfo * info)254 int32_t TransServerProxy::OpenSession(const SessionParam *param, TransInfo *info)
255 {
256     if (param->sessionName == nullptr || param->peerSessionName == nullptr ||
257         param->peerDeviceId == nullptr || param->groupId == nullptr) {
258         return SOFTBUS_INVALID_PARAM;
259     }
260     sptr<IRemoteObject> remote = GetSystemAbility();
261     if (remote == nullptr) {
262         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
263         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
264     }
265 
266     MessageParcel data;
267     if (!data.WriteInterfaceToken(GetDescriptor())) {
268         TRANS_LOGE(TRANS_SDK, "OpenSession write InterfaceToken failed!");
269         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
270     }
271     WRITE_PARCEL_WITH_RET(data, CString, param->sessionName, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
272     WRITE_PARCEL_WITH_RET(data, CString, param->peerSessionName, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
273     WRITE_PARCEL_WITH_RET(data, CString, param->peerDeviceId, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
274     WRITE_PARCEL_WITH_RET(data, CString, param->groupId, SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED);
275     WRITE_PARCEL_WITH_RET(data, Bool, param->isAsync, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
276     WRITE_PARCEL_WITH_RET(data, Int32, param->sessionId, SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED);
277     WRITE_PARCEL_WITH_RET(data, Uint32, param->actionId, SOFTBUS_TRANS_PROXY_WRITEINT_FAILED);
278     if (!TransWriteSessionAttrs(param->attr, data)) {
279         TRANS_LOGE(TRANS_SDK, "OpenSession write attr failed!");
280         return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
281     }
282 
283     if (!WriteQosInfo(param, data)) {
284         TRANS_LOGE(TRANS_SDK, "OpenSession write qos failed!");
285         return SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED;
286     }
287 
288     MessageParcel reply;
289     MessageOption option;
290     int32_t ret = remote->SendRequest(SERVER_OPEN_SESSION, data, reply, option);
291     if (ret != SOFTBUS_OK) {
292         TRANS_LOGE(TRANS_SDK, "OpenSession send request failed! ret=%{public}d", ret);
293         return ret;
294     }
295     TransSerializer *transSerializer = (TransSerializer *)reply.ReadRawData(sizeof(TransSerializer));
296     if (transSerializer == nullptr) {
297         TRANS_LOGE(TRANS_SDK, "OpenSession read TransSerializer failed!");
298         return SOFTBUS_TRANS_PROXY_READRAWDATA_FAILED;
299     }
300     if (param->isAsync) {
301         return transSerializer->ret;
302     }
303     info->channelId = transSerializer->transInfo.channelId;
304     info->channelType = transSerializer->transInfo.channelType;
305     return transSerializer->ret;
306 }
307 
OpenAuthSession(const char * sessionName,const ConnectionAddr * addrInfo)308 int32_t TransServerProxy::OpenAuthSession(const char *sessionName, const ConnectionAddr *addrInfo)
309 {
310     if (sessionName == nullptr || addrInfo == nullptr) {
311         return SOFTBUS_INVALID_PARAM;
312     }
313     char *tmpName = nullptr;
314     Anonymize(sessionName, &tmpName);
315     TRANS_LOGI(TRANS_SDK, "ServerIpcOpenAuthSession begin. sessionName=%{public}s", tmpName);
316     AnonymizeFree(tmpName);
317     sptr<IRemoteObject> remote = Remote();
318     if (remote == nullptr) {
319         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
320         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
321     }
322 
323     MessageParcel data;
324     if (!data.WriteInterfaceToken(GetDescriptor())) {
325         TRANS_LOGE(TRANS_SDK, "OpenSession write InterfaceToken failed!");
326         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
327     }
328     if (!data.WriteCString(sessionName)) {
329         TRANS_LOGE(TRANS_SDK, "OpenSession write my session name failed!");
330         return SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED;
331     }
332     if (!data.WriteRawData((void *)addrInfo, sizeof(ConnectionAddr))) {
333         TRANS_LOGE(TRANS_SDK, "OpenSession write ConnectionAddr failed!");
334         return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
335     }
336 
337     MessageParcel reply;
338     MessageOption option;
339     int32_t ret = remote->SendRequest(SERVER_OPEN_AUTH_SESSION, data, reply, option);
340     if (ret != SOFTBUS_OK) {
341         TRANS_LOGE(TRANS_SDK, "OpenSession send request failed! ret=%{public}d", ret);
342         return ret;
343     }
344     int32_t channelId = 0;
345     if (!reply.ReadInt32(channelId)) {
346         TRANS_LOGE(TRANS_SDK, "OpenSession read channelId failed!");
347         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
348     }
349     return channelId;
350 }
351 
NotifyAuthSuccess(int32_t channelId,int32_t channelType)352 int32_t TransServerProxy::NotifyAuthSuccess(int32_t channelId, int32_t channelType)
353 {
354     sptr<IRemoteObject> remote = GetSystemAbility();
355     if (remote == nullptr) {
356         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
357         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
358     }
359     MessageParcel data;
360     if (!data.WriteInterfaceToken(GetDescriptor())) {
361         TRANS_LOGE(TRANS_SDK, "ServerIpcNotifyAuthSuccess write InterfaceToken failed!");
362         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
363     }
364     if (!data.WriteInt32(channelId)) {
365         TRANS_LOGE(TRANS_SDK, "ServerIpcNotifyAuthSuccess write channel id failed!");
366         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
367     }
368     if (!data.WriteInt32(channelType)) {
369         TRANS_LOGE(TRANS_SDK, "ServerIpcNotifyAuthSuccess write channel type failed!");
370         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
371     }
372 
373     MessageParcel reply;
374     MessageOption option;
375     int32_t ret = remote->SendRequest(SERVER_NOTIFY_AUTH_SUCCESS, data, reply, option);
376     if (ret != SOFTBUS_OK) {
377         TRANS_LOGE(TRANS_SDK, "ServerIpcNotifyAuthSuccess send request failed! ret=%{public}d", ret);
378         return ret;
379     }
380     int32_t serverRet = 0;
381     if (!reply.ReadInt32(serverRet)) {
382         TRANS_LOGE(TRANS_SDK, "ServerIpcNotifyAuthSuccess read serverRet failed!");
383         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
384     }
385     return serverRet;
386 }
387 
CloseChannel(const char * sessionName,int32_t channelId,int32_t channelType)388 int32_t TransServerProxy::CloseChannel(const char *sessionName, int32_t channelId, int32_t channelType)
389 {
390     sptr<IRemoteObject> remote = GetSystemAbility();
391     if (remote == nullptr) {
392         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
393         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
394     }
395     MessageParcel data;
396     if (!data.WriteInterfaceToken(GetDescriptor())) {
397         TRANS_LOGE(TRANS_SDK, "CloseChannel write InterfaceToken failed!");
398         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
399     }
400     if (!data.WriteInt32(channelId)) {
401         TRANS_LOGE(TRANS_SDK, "CloseChannel write channel id failed!");
402         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
403     }
404     if (!data.WriteInt32(channelType)) {
405         TRANS_LOGE(TRANS_SDK, "CloseChannel write channel type failed!");
406         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
407     }
408     if (channelType == CHANNEL_TYPE_UNDEFINED) {
409         if (!data.WriteCString(sessionName)) {
410             TRANS_LOGE(TRANS_SDK, "CloseChannel write session name failed!");
411             return SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED;
412         }
413     }
414     MessageParcel reply;
415     MessageOption option;
416     int32_t ret = remote->SendRequest(SERVER_CLOSE_CHANNEL, data, reply, option);
417     if (ret != SOFTBUS_OK) {
418         TRANS_LOGE(TRANS_SDK, "CloseChannel send request failed! ret=%{public}d", ret);
419         return ret;
420     }
421     int32_t serverRet = 0;
422     if (!reply.ReadInt32(serverRet)) {
423         TRANS_LOGE(TRANS_SDK, "CloseChannel read serverRet failed!");
424         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
425     }
426     return serverRet;
427 }
428 
CloseChannelWithStatistics(int32_t channelId,int32_t channelType,uint64_t laneId,const void * dataInfo,uint32_t len)429 int32_t TransServerProxy::CloseChannelWithStatistics(int32_t channelId, int32_t channelType, uint64_t laneId,
430     const void *dataInfo, uint32_t len)
431 {
432     if (dataInfo == nullptr) {
433         TRANS_LOGE(TRANS_SDK, "invalid param");
434         return SOFTBUS_INVALID_PARAM;
435     }
436     sptr<IRemoteObject> remote = GetSystemAbility();
437     if (remote == nullptr) {
438         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
439         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
440     }
441     MessageParcel data;
442     if (!data.WriteInterfaceToken(GetDescriptor())) {
443         TRANS_LOGE(TRANS_SDK, "CloseChannelWithStatistics write InterfaceToken failed!");
444         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
445     }
446     if (!data.WriteInt32(channelId)) {
447         TRANS_LOGE(TRANS_SDK, "CloseChannelWithStatistics write channel id failed!");
448         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
449     }
450     if (!data.WriteInt32(channelType)) {
451         TRANS_LOGE(TRANS_SDK, "CloseChannelWithStatistics write channel type failed!");
452         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
453     }
454     if (!data.WriteUint64(laneId)) {
455         TRANS_LOGE(TRANS_SDK, "CloseChannelWithStatistics write lane id failed!");
456         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
457     }
458     if (!data.WriteUint32(len)) {
459         TRANS_LOGE(TRANS_SDK, "CloseChannelWithStatistics write dataInfo len failed!");
460         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
461     }
462     if (!data.WriteRawData(dataInfo, len)) {
463         TRANS_LOGE(TRANS_SDK, "CloseChannelWithStatistics write dataInfo failed!");
464         return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
465     }
466     MessageParcel reply;
467     MessageOption option;
468     int32_t ret = remote->SendRequest(SERVER_CLOSE_CHANNEL_STATISTICS, data, reply, option);
469     if (ret != SOFTBUS_OK) {
470         TRANS_LOGE(TRANS_SDK, "CloseChannelWithStatistics send request failed! ret=%{public}d", ret);
471         return ret;
472     }
473     int32_t serverRet = 0;
474     if (!reply.ReadInt32(serverRet)) {
475         TRANS_LOGE(TRANS_SDK, "CloseChannelWithStatistics read serverRet failed!");
476         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
477     }
478     return serverRet;
479 }
480 
SendMessage(int32_t channelId,int32_t channelType,const void * dataInfo,uint32_t len,int32_t msgType)481 int32_t TransServerProxy::SendMessage(int32_t channelId, int32_t channelType, const void *dataInfo,
482     uint32_t len, int32_t msgType)
483 {
484     sptr<IRemoteObject> remote = Remote();
485     if (remote == nullptr) {
486         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
487         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
488     }
489     MessageParcel data;
490     if (!data.WriteInterfaceToken(GetDescriptor())) {
491         TRANS_LOGE(TRANS_SDK, "SendMessage write InterfaceToken failed!");
492         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
493     }
494     if (!data.WriteInt32(channelId)) {
495         TRANS_LOGE(TRANS_SDK, "SendMessage write channel id failed!");
496         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
497     }
498     if (!data.WriteInt32(channelType)) {
499         TRANS_LOGE(TRANS_SDK, "SendMessage write channel type failed!");
500         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
501     }
502     if (!data.WriteUint32(len)) {
503         TRANS_LOGE(TRANS_SDK, "SendMessage write dataInfo len failed!");
504         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
505     }
506     if (!data.WriteRawData(dataInfo, len)) {
507         TRANS_LOGE(TRANS_SDK, "SendMessage write dataInfo failed!");
508         return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
509     }
510     if (!data.WriteInt32(msgType)) {
511         TRANS_LOGE(TRANS_SDK, "SendMessage msgType failed!");
512         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
513     }
514 
515     MessageParcel reply;
516     MessageOption option;
517     int32_t ret = remote->SendRequest(SERVER_SESSION_SENDMSG, data, reply, option);
518     if (ret != SOFTBUS_OK) {
519         TRANS_LOGE(TRANS_SDK, "SendMessage send request failed! ret=%{public}d", ret);
520         return ret;
521     }
522     int32_t serverRet = 0;
523     if (!reply.ReadInt32(serverRet)) {
524         TRANS_LOGE(TRANS_SDK, "SendMessage read serverRet failed!");
525         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
526     }
527     return serverRet;
528 }
529 
QosReport(int32_t channelId,int32_t chanType,int32_t appType,int32_t quality)530 int32_t TransServerProxy::QosReport(int32_t channelId, int32_t chanType, int32_t appType, int32_t quality)
531 {
532     sptr<IRemoteObject> remote = GetSystemAbility();
533     if (remote == nullptr) {
534         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
535         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
536     }
537     MessageParcel data;
538     if (!data.WriteInterfaceToken(GetDescriptor())) {
539         TRANS_LOGE(TRANS_SDK, "QosReport write InterfaceToken failed!");
540         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
541     }
542     if (!data.WriteInt32(channelId)) {
543         TRANS_LOGE(TRANS_SDK, "QosReport channelId failed!");
544         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
545     }
546     if (!data.WriteInt32(chanType)) {
547         TRANS_LOGE(TRANS_SDK, "QosReport chanType failed!");
548         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
549     }
550     if (!data.WriteInt32(appType)) {
551         TRANS_LOGE(TRANS_SDK, "QosReport appType failed!");
552         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
553     }
554     if (!data.WriteInt32(quality)) {
555         TRANS_LOGE(TRANS_SDK, "QosReport quality failed!");
556         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
557     }
558 
559     MessageParcel reply;
560     MessageOption option;
561     int32_t ret = remote->SendRequest(SERVER_QOS_REPORT, data, reply, option);
562     if (ret != SOFTBUS_OK) {
563         TRANS_LOGE(TRANS_SDK, "QosReport send request failed! ret=%{public}d", ret);
564         return ret;
565     }
566     int32_t serverRet = 0;
567     if (!reply.ReadInt32(serverRet)) {
568         TRANS_LOGE(TRANS_SDK, "QosReport read serverRet failed!");
569         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
570     }
571     return serverRet;
572 }
573 
StreamStats(int32_t channelId,int32_t channelType,const StreamSendStats * statsData)574 int32_t TransServerProxy::StreamStats(int32_t channelId, int32_t channelType, const StreamSendStats *statsData)
575 {
576     sptr<IRemoteObject> remote = GetSystemAbility();
577     if (remote == nullptr) {
578         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
579         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
580     }
581     MessageParcel data;
582     if (!data.WriteInterfaceToken(GetDescriptor())) {
583         TRANS_LOGE(TRANS_SDK, "StreamStats write InterfaceToken failed!");
584         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
585     }
586     if (!data.WriteInt32(channelId)) {
587         TRANS_LOGE(TRANS_SDK, "StreamStats channelId failed!");
588         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
589     }
590     if (!data.WriteInt32(channelType)) {
591         TRANS_LOGE(TRANS_SDK, "StreamStats channelType failed!");
592         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
593     }
594     if (!data.WriteRawData((void *)statsData, sizeof(StreamSendStats))) {
595         TRANS_LOGE(TRANS_SDK, "write streamSendStats failed!");
596         return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
597     }
598     MessageParcel reply;
599     MessageOption option;
600     int32_t ret = remote->SendRequest(SERVER_STREAM_STATS, data, reply, option);
601     if (ret != SOFTBUS_OK) {
602         TRANS_LOGE(TRANS_SDK, "StreamStats send request failed, ret=%{public}d", ret);
603         return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
604     }
605     if (!reply.ReadInt32(ret)) {
606         TRANS_LOGE(TRANS_SDK, "StreamStats read serverRet failed");
607         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
608     }
609     return ret;
610 }
611 
RippleStats(int32_t channelId,int32_t channelType,const TrafficStats * statsData)612 int32_t TransServerProxy::RippleStats(int32_t channelId, int32_t channelType, const TrafficStats *statsData)
613 {
614     sptr<IRemoteObject> remote = GetSystemAbility();
615     if (remote == nullptr) {
616         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
617         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
618     }
619     MessageParcel data;
620     if (!data.WriteInterfaceToken(GetDescriptor())) {
621         TRANS_LOGE(TRANS_SDK, "RippleStats write InterfaceToken failed!");
622         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
623     }
624     if (!data.WriteInt32(channelId)) {
625         TRANS_LOGE(TRANS_SDK, "RippleStats channelId failed!");
626         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
627     }
628     if (!data.WriteInt32(channelType)) {
629         TRANS_LOGE(TRANS_SDK, "RippleStats channelType failed!");
630         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
631     }
632     if (!data.WriteRawData((void *)statsData, sizeof(TrafficStats))) {
633         TRANS_LOGE(TRANS_SDK, "write RippleStats failed!");
634         return SOFTBUS_TRANS_PROXY_WRITERAWDATA_FAILED;
635     }
636     MessageParcel reply;
637     MessageOption option;
638     int32_t ret = remote->SendRequest(SERVER_RIPPLE_STATS, data, reply, option);
639     if (ret != SOFTBUS_OK) {
640         TRANS_LOGE(TRANS_SDK, "RippleStats send request failed, ret=%{public}d", ret);
641         return ret;
642     }
643     if (!reply.ReadInt32(ret)) {
644         TRANS_LOGE(TRANS_SDK, "RippleStats read serverRet failed");
645         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
646     }
647     return ret;
648 }
649 
GrantPermission(int32_t uid,int32_t pid,const char * sessionName)650 int32_t TransServerProxy::GrantPermission(int32_t uid, int32_t pid, const char *sessionName)
651 {
652     sptr<IRemoteObject> remote = GetSystemAbility();
653     if (remote == nullptr) {
654         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
655         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
656     }
657     MessageParcel data;
658     if (!data.WriteInterfaceToken(GetDescriptor())) {
659         TRANS_LOGE(TRANS_SDK, "GrantPermission write InterfaceToken failed!");
660         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
661     }
662     if (!data.WriteInt32(uid)) {
663         TRANS_LOGE(TRANS_SDK, "GrantPermission write uid failed!");
664         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
665     }
666     if (!data.WriteInt32(pid)) {
667         TRANS_LOGE(TRANS_SDK, "GrantPermission write pid failed!");
668         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
669     }
670     if (!data.WriteCString(sessionName)) {
671         TRANS_LOGE(TRANS_SDK, "GrantPermission write sessionName failed!");
672         return SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED;
673     }
674 
675     MessageParcel reply;
676     MessageOption option;
677     int32_t ret = remote->SendRequest(SERVER_GRANT_PERMISSION, data, reply, option);
678     if (ret != ERR_NONE) {
679         TRANS_LOGE(TRANS_SDK, "GrantPermission send request failed, ret=%{public}d", ret);
680         return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
681     }
682     if (!reply.ReadInt32(ret)) {
683         TRANS_LOGE(TRANS_SDK, "GrantPermission read serverRet failed!");
684         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
685     }
686     return ret;
687 }
688 
RemovePermission(const char * sessionName)689 int32_t TransServerProxy::RemovePermission(const char *sessionName)
690 {
691     sptr<IRemoteObject> remote = GetSystemAbility();
692     if (remote == nullptr) {
693         TRANS_LOGE(TRANS_SDK, "remote is nullptr!");
694         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
695     }
696     MessageParcel data;
697     if (!data.WriteInterfaceToken(GetDescriptor())) {
698         TRANS_LOGE(TRANS_SDK, "RemovePermission write InterfaceToken failed!");
699         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
700     }
701     if (!data.WriteCString(sessionName)) {
702         TRANS_LOGE(TRANS_SDK, "RemovePermission write sessionName failed!");
703         return SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED;
704     }
705 
706     MessageParcel reply;
707     MessageOption option;
708     int32_t ret = remote->SendRequest(SERVER_REMOVE_PERMISSION, data, reply, option);
709     if (ret != ERR_NONE) {
710         TRANS_LOGE(TRANS_SDK, "RemovePermission send request failed, ret=%{public}d", ret);
711         return SOFTBUS_TRANS_PROXY_SEND_REQUEST_FAILED;
712     }
713     if (!reply.ReadInt32(ret)) {
714         TRANS_LOGE(TRANS_SDK, "RemovePermission read serverRet failed!");
715         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
716     }
717     return ret;
718 }
719 
JoinLNN(const char * pkgName,void * addr,uint32_t addrTypeLen)720 int32_t TransServerProxy::JoinLNN(const char *pkgName, void *addr, uint32_t addrTypeLen)
721 {
722     (void)pkgName;
723     (void)addr;
724     (void)addrTypeLen;
725     return SOFTBUS_OK;
726 }
727 
LeaveLNN(const char * pkgName,const char * networkId)728 int32_t TransServerProxy::LeaveLNN(const char *pkgName, const char *networkId)
729 {
730     (void)pkgName;
731     (void)networkId;
732     return SOFTBUS_OK;
733 }
734 
GetAllOnlineNodeInfo(const char * pkgName,void ** info,uint32_t infoTypeLen,int32_t * infoNum)735 int32_t TransServerProxy::GetAllOnlineNodeInfo(const char *pkgName, void **info, uint32_t infoTypeLen, int32_t *infoNum)
736 {
737     (void)pkgName;
738     (void)info;
739     (void)infoTypeLen;
740     (void)infoNum;
741     return SOFTBUS_OK;
742 }
743 
GetLocalDeviceInfo(const char * pkgName,void * info,uint32_t infoTypeLen)744 int32_t TransServerProxy::GetLocalDeviceInfo(const char *pkgName, void *info, uint32_t infoTypeLen)
745 {
746     (void)pkgName;
747     (void)info;
748     (void)infoTypeLen;
749     return SOFTBUS_OK;
750 }
751 
GetNodeKeyInfo(const char * pkgName,const char * networkId,int32_t key,unsigned char * buf,uint32_t len)752 int32_t TransServerProxy::GetNodeKeyInfo(const char *pkgName, const char *networkId, int32_t key, unsigned char *buf,
753     uint32_t len)
754 {
755     (void)pkgName;
756     (void)networkId;
757     (void)key;
758     (void)buf;
759     (void)len;
760     return SOFTBUS_OK;
761 }
762 
SetNodeDataChangeFlag(const char * pkgName,const char * networkId,uint16_t dataChangeFlag)763 int32_t TransServerProxy::SetNodeDataChangeFlag(const char *pkgName, const char *networkId, uint16_t dataChangeFlag)
764 {
765     (void)pkgName;
766     (void)networkId;
767     (void)dataChangeFlag;
768     return SOFTBUS_OK;
769 }
770 
RegDataLevelChangeCb(const char * pkgName)771 int32_t TransServerProxy::RegDataLevelChangeCb(const char *pkgName)
772 {
773     (void)pkgName;
774     return SOFTBUS_OK;
775 }
776 
UnregDataLevelChangeCb(const char * pkgName)777 int32_t TransServerProxy::UnregDataLevelChangeCb(const char *pkgName)
778 {
779     (void)pkgName;
780     return SOFTBUS_OK;
781 }
782 
SetDataLevel(const DataLevel * dataLevel)783 int32_t TransServerProxy::SetDataLevel(const DataLevel *dataLevel)
784 {
785     (void)dataLevel;
786     return SOFTBUS_OK;
787 }
788 
StartTimeSync(const char * pkgName,const char * targetNetworkId,int32_t accuracy,int32_t period)789 int32_t TransServerProxy::StartTimeSync(const char *pkgName, const char *targetNetworkId, int32_t accuracy,
790     int32_t period)
791 {
792     (void)pkgName;
793     (void)targetNetworkId;
794     (void)accuracy;
795     (void)period;
796     return SOFTBUS_OK;
797 }
798 
StopTimeSync(const char * pkgName,const char * targetNetworkId)799 int32_t TransServerProxy::StopTimeSync(const char *pkgName, const char *targetNetworkId)
800 {
801     (void)pkgName;
802     (void)targetNetworkId;
803     return SOFTBUS_OK;
804 }
805 
GetSoftbusSpecObject(sptr<IRemoteObject> & object)806 int32_t TransServerProxy::GetSoftbusSpecObject(sptr<IRemoteObject> &object)
807 {
808     sptr<IRemoteObject> remote = GetSystemAbility();
809     if (remote == nullptr) {
810         TRANS_LOGE(TRANS_SDK, "remote is null");
811         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
812     }
813     MessageParcel data;
814     if (!data.WriteInterfaceToken(GetDescriptor())) {
815         TRANS_LOGE(TRANS_SDK, "GetSoftbusSpecObject write InterfaceToken failed!");
816         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
817     }
818     MessageParcel reply;
819     MessageOption option;
820     int32_t ret = remote->SendRequest(SERVER_GET_SOFTBUS_SPEC_OBJECT, data, reply, option);
821     if (ret != ERR_NONE) {
822         TRANS_LOGE(TRANS_SDK, "GetSoftbusSpecObject send request failed, ret=%{public}d", ret);
823         return ret;
824     }
825     if (!reply.ReadInt32(ret)) {
826         TRANS_LOGE(TRANS_SDK, "GetSoftbusSpecObject send ret failed");
827         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
828     }
829     if (ret == SOFTBUS_OK) {
830         object = reply.ReadRemoteObject();
831     }
832     return ret;
833 }
834 
EvaluateQos(const char * peerNetworkId,TransDataType dataType,const QosTV * qos,uint32_t qosCount)835 int32_t TransServerProxy::EvaluateQos(const char *peerNetworkId, TransDataType dataType, const QosTV *qos,
836     uint32_t qosCount)
837 {
838     sptr<IRemoteObject> remote = GetSystemAbility();
839     if (remote == nullptr) {
840         TRANS_LOGE(TRANS_SDK, "remote is null");
841         return SOFTBUS_TRANS_PROXY_REMOTE_NULL;
842     }
843 
844     MessageParcel data;
845     if (!data.WriteInterfaceToken(GetDescriptor())) {
846         TRANS_LOGE(TRANS_SDK, "EvaluateQos write InterfaceToken failed!");
847         return SOFTBUS_TRANS_PROXY_WRITETOKEN_FAILED;
848     }
849 
850     if (!data.WriteCString(peerNetworkId)) {
851         TRANS_LOGE(TRANS_SDK, "EvaluateQos write peerNetworkId failed!");
852         return SOFTBUS_TRANS_PROXY_WRITECSTRING_FAILED;
853     }
854 
855     if (!data.WriteInt32(dataType)) {
856         TRANS_LOGE(TRANS_SDK, "EvaluateQos write dataType failed!");
857         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
858     }
859 
860     if (!data.WriteUint32(qosCount)) {
861         TRANS_LOGE(TRANS_SDK, "EvaluateQos write count of qos failed!");
862         return SOFTBUS_TRANS_PROXY_WRITEINT_FAILED;
863     }
864 
865     if (qosCount > 0) {
866         if (!data.WriteBuffer(qos, sizeof(QosTV) * qosCount)) {
867             TRANS_LOGE(TRANS_SDK, "EvaluateQos write qos info failed!");
868             return SOFTBUS_IPC_ERR;
869         }
870     }
871 
872     MessageParcel reply;
873     MessageOption option;
874     int32_t ret = remote->SendRequest(SERVER_EVALUATE_QOS, data, reply, option);
875     if (ret != ERR_NONE) {
876         TRANS_LOGE(TRANS_SDK, "EvaluateQos request failed, ret=%{public}d", ret);
877         return ret;
878     }
879 
880     if (!reply.ReadInt32(ret)) {
881         TRANS_LOGE(TRANS_SDK, "EvaluateQos read ret failed");
882         return SOFTBUS_TRANS_PROXY_READINT_FAILED;
883     }
884 
885     return ret;
886 }
887 } // namespace OHOS
888