* Copyright (c) 2024 Huawei Device Co., Ltd.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "socket_common.h"
static int32_t g_currentSocket4Data = -1;
static int32_t g_waitFlag = WAIT_DEF_VALUE;
static int32_t g_waitFlag4Shutdown = WAIT_DEF_VALUE;
static int32_t g_waitFlag4Byte = WAIT_DEF_VALUE;
static int32_t g_waitFlag4Message = WAIT_DEF_VALUE;
static int32_t g_waitFlagStream = WAIT_DEF_VALUE;
static int32_t g_waitFlag4File = WAIT_DEF_VALUE;
static volatile int32_t g_socketFileEventCount = SOCKET_FILE_EVENT_COUNT_NONE;
static volatile uint64_t g_socketFileLastEventTime = SOCKET_FILE_NO_EVENT_TIME;
static volatile int32_t g_socketFileEventType = SOCKET_FILE_EVENT_TYPE_INVALID;
#define SOCKET_FILE_STALL_TIMEOUT_SEC 60
#define SOCKET_FILE_CREEP_WINDOW_SEC 600
#define SOCKET_FILE_CREEP_MIN_EVENTS 1
#define SOCKET_FILE_SAFETY_TIMEOUT_SEC 7200
static int32_t g_nodeOnlineCount = 0;
static int32_t g_nodeOfflineCount = 0;
static ISocketListener* g_socketlistenerdata = NULL;
static char g_networkId[NETWORK_ID_BUF_LEN] = { 0 };
static INodeStateCb g_defNodeStateCallback;
static char g_fillContentChar = 'd';
static unsigned int g_expectDataSize = 0;
static char* g_expectDataContent = NULL;
static uint64_t g_tokenId;
void ResetwaitCount4Online(void)
{
g_nodeOnlineCount = 0;
}
void ResetwaitCount4Offline(void)
{
g_nodeOfflineCount = 0;
}
void Sleepn(int n)
{
for(int i = 0; i < n; i++) {
sleep(1);
LOG("sleeped %d", i);
}
}
char* GetSoftbusPid(void)
{
FILE* file = NULL;
int buffSize = 20;
char* buffer = (char*)malloc(buffSize);
if (buffer == NULL) {
LOG("malloc fail");
return NULL;
}
file = popen(CMD_PIDOF_SOFTBUS, "r");
if (file == NULL) {
LOG("call popen fail");
free(buffer);
return NULL;
}
(void)fgets(buffer, buffSize, file);
LOG("##################Softbus PID:%s", buffer);
pclose(file);
return buffer;
}
static void OnDefNodeOnline(NodeBasicInfo* info)
{
if (info == NULL) {
LOG("[cb]Online: info is null");
return;
}
(void)strncpy_s(g_networkId, NETWORK_ID_BUF_LEN, info->networkId, NETWORK_ID_BUF_LEN);
LOG("[cb]Online id:%s, name:%s, type id:%u", info->networkId, info->deviceName, info->deviceTypeId);
g_nodeOnlineCount++;
}
static void OnDefNodeOffline(NodeBasicInfo* info)
{
if (info == NULL) {
LOG("[cb]Offline: info is null");
return;
}
LOG("[cb]Offline id:%s, name:%s, type id:%u", info->networkId, info->deviceName, info->deviceTypeId);
g_nodeOfflineCount++;
}
static void OnDefNodeBasicInfoChanged(NodeBasicInfoType type, NodeBasicInfo* info)
{
if (info == NULL) {
LOG("[cb]InfoChanged: info is null, type[%d]", type);
return;
}
LOG("[cb]InfoChanged id: %s,name: %s", info->networkId, info->deviceName);
}
static void onDefNodeStatusChanged(NodeStatusType type, NodeStatus *status)
{
if (status == NULL) {
LOG("[cb]StatusChanged: info is null, type[%d]", type);
return;
}
LOG("[cb]StatusChanged id: %s,status: %d", status->basicInfo.networkId, status->authStatus);
}
int RegisterDeviceStateDefCallback(void)
{
return RegNodeDeviceStateCb(DEF_PKG_NAME, &g_defNodeStateCallback);
}
int UnRegisterDeviceStateDefCallback(void)
{
return UnregNodeDeviceStateCb(&g_defNodeStateCallback);
}
int WaitNodeCount(int timeout, WaitNodeStateType state, int expectCount)
{
LOG("Wait4Node,timeout:%d, type:%d, exp count:%d", timeout, state, expectCount);
int hitFlag = -1;
while (timeout > 0) {
sleep(ONE_SECOND);
switch (state) {
case STATE_ONLINE:
if (g_nodeOnlineCount == expectCount) {
LOG("Wait4Node[online] succ,timeout:%d", timeout);
hitFlag = 1;
}
break;
case STATE_OFFLINE:
if (g_nodeOfflineCount == expectCount) {
LOG("Wait4Node[offline] succ,timeout:%d", timeout);
hitFlag = 1;
}
break;
default:
LOG("Wait4Node state error");
hitFlag = 1;
break;
}
if (hitFlag != -1) {
break;
}
timeout--;
}
switch (state) {
case STATE_ONLINE:
if (g_nodeOnlineCount != expectCount) {
LOG("Wait4Node[online] fail[exp:%d, real:%d]", expectCount, g_nodeOnlineCount);
return SOFTBUS_ERR;
}
break;
case STATE_OFFLINE:
if (g_nodeOfflineCount != expectCount) {
LOG("Wait4Node[offline] fail[exp:%d, real:%d]", expectCount, g_nodeOfflineCount);
return SOFTBUS_ERR;
}
break;
default:
return SOFTBUS_ERR;
}
return SOFTBUS_OK;
}
static void OnBindData(int32_t socket, PeerSocketInfo info)
{
int successcount = 0;
LOG("[cb][Ctrl]OnBind success {socket:%d, name:%s, deviceId:%s, pkgName:%s, dataType:%d}", socket,
info.name, info.networkId, info.pkgName, info.dataType);
if (strcmp(info.networkId, g_networkId) != 0)
{
LOG("PeerSocket Info peer deviceId and check remote networkId are diff");
successcount++;
}
if (strcmp(info.name, SOCKET_NAME_BYTE) != 0)
{
LOG("PeerSocket Info peer name and local name are diff");
successcount++;
}
if (strcmp(info.pkgName, DEF_PKG_NAME) != 0)
{
LOG("PeerSocket Info peer pkgName and local pkgName are diff");
successcount++;
}
if(successcount == 3)
{
g_waitFlag = WAIT_SUCCESS_VALUE;
}else{
g_waitFlag = WAIT_FAIL_VALUE;
}
}
static void OnShutdownData(int32_t socket, ShutdownReason reason)
{
LOG("[cb][Ctrl]OnShutdownData success {socket:%d, reason:%u}", socket, reason);
if (reason == SHUTDOWN_REASON_PEER || reason == SHUTDOWN_REASON_LOCAL)
{
g_waitFlag4Shutdown = WAIT_SUCCESS_VALUE;
}else{
g_waitFlag4Shutdown = WAIT_FAIL_VALUE;
}
}
static int CheckReceiveSocketData(int socket, const void *data, unsigned int dataLen)
{
if (socket == g_currentSocket4Data && dataLen == g_expectDataSize)
{
LOG("[check]socket/size ok socket:%d, size:%d", socket, dataLen);
}else
{
LOG("[check]socket/size failed socket :%d, expectsocket:%d, size:%d, expectsize:%d",
socket, g_currentSocket4Data, dataLen, g_expectDataSize);
return SOFTBUS_ERR;
}
if (g_expectDataContent == NULL)
{
LOG("[check]socket Datacunt is null !!!");
return SOFTBUS_ERR;
}else
{
int cmpRst = strncmp(g_expectDataContent, (char*)data, dataLen);
if (cmpRst == 0) {
LOG("[check] cmp content ok");
return SOFTBUS_OK;
} else {
LOG("[check] cmp content fail[exp:%s,real:%s]", g_expectDataContent, (char*)data);
return SOFTBUS_ERR;
}
}
}
static void OnByteData(int32_t socket, const void *data, uint32_t dataLen)
{
LOG("[cb] OnByteData socket:%d", socket);
int ret = CheckReceiveSocketData(socket, data, dataLen);
if (ret == SOFTBUS_OK)
{
g_waitFlag4Byte = WAIT_SUCCESS_VALUE;
LOG("[cb] OnByteData data recv success");
}else
{
g_waitFlag4Byte = WAIT_FAIL_VALUE;
LOG("[cb] OnByteData data recv failed");
}
}
static void OnMessageData(int32_t socket, const void *data, uint32_t dataLen)
{
LOG("[cb] OnMessageData socket:%d", socket);
int ret = CheckReceiveSocketData(socket, data, dataLen);
if (ret == SOFTBUS_OK)
{
g_waitFlag4Message = WAIT_SUCCESS_VALUE;
LOG("[cb] OnMessageData data recv success");
}else
{
g_waitFlag4Message = WAIT_FAIL_VALUE;
LOG("[cb] OnMessageData data recv failed");
}
}
static void OnStreamData(int32_t socket, const StreamData *data, const StreamData *ext, const StreamFrameInfo *param)
{
if (socket < 0) {
LOG("[cb][data]OnStream invalid socket id[%d]", socket);
return;
}
if (data == NULL) {
LOG("[cb][data]OnStream socket id[%d], data is NULL", socket);
return;
}
if (ext == NULL) {
LOG("[cb][data]OnStream socket id[%d], ext is NULL", socket);
return;
}
if (param == NULL) {
LOG("[cb][data]OnStream socket id[%d], param is NULL", socket);
return;
}
LOG("[cb][data]OnStream Success socket:%d,", socket);
LOG("[cb][data]OnStream Success buf:%s,", (data->buf != NULL ? data->buf : "null"));
LOG("[cb][data]OnStream Success buflen:%d", data->bufLen);
LOG("[cb][data]OnStream Success buf:%s,", (ext->buf != NULL ? ext->buf : "null"));
g_waitFlagStream = WAIT_SUCCESS_VALUE;
}
static const char *ClientUpdataRecvFilePath() {
return "/data/";
}
static void OnFileData(int32_t socket, FileEvent *event)
{
if (socket < 0) {
LOG("[cb][data]OnFile invalid socket id[%d]", socket);
return;
}
if (event == NULL) {
LOG("[cb][data]OnFile socket id[%d], event is nullptr", socket);
return;
}
g_socketFileEventCount++;
g_socketFileLastEventTime = (uint64_t)time(NULL);
g_socketFileEventType = event->type;
if (event->type == FILE_EVENT_RECV_UPDATE_PATH) {
LOG("[cb][data]OnFile event type:%d,", event->type);
event->UpdateRecvPath = ClientUpdataRecvFilePath;
return;
}
LOG("[cb][data]OnFile, event type:%d, fileCnt:%u", event->type, event->fileCnt);
for (uint32_t i = 0; i < event->fileCnt; i++) {
LOG("[cb][data] %s", (event->files[i] == NULL ? "null" : event->files[i]));
}
if (event->type == FILE_EVENT_SEND_FINISH) {
LOG("[cb][data]OnFile send finished, eventCount:%d", g_socketFileEventCount);
g_waitFlag4File = WAIT_SUCCESS_VALUE;
return;
}
if (event->type == FILE_EVENT_SEND_PROCESS) {
LOG("[cb][data]OnFile send process, eventCount:%d", g_socketFileEventCount);
return;
}
if (event->type == FILE_EVENT_RECV_FINISH) {
LOG("[cb][data]OnFile recv finished, eventCount:%d", g_socketFileEventCount);
g_waitFlag4File = WAIT_SUCCESS_VALUE;
return;
}
if (event->type == FILE_EVENT_RECV_PROCESS) {
LOG("[cb][data]OnFile recv process, eventCount:%d", g_socketFileEventCount);
return;
}
if (event->type == FILE_EVENT_SEND_ERROR) {
LOG("[cb][data]OnFile send error!!, eventCount:%d", g_socketFileEventCount);
g_waitFlag4File = WAIT_FAIL_VALUE;
return;
}
if (event->type == FILE_EVENT_RECV_ERROR) {
LOG("[cb][data]OnFile recv error!!, eventCount:%d", g_socketFileEventCount);
g_waitFlag4File = WAIT_FAIL_VALUE;
return;
}
}
static void OnQosData(int32_t socket, QoSEvent eventId, const QosTV *qos, uint32_t qosCunt)
{
if (qos == NULL || qosCunt == 0) {
LOG("[cb][data] OnQos Invalid qos data or count");
}
LOG("[cb][data] OnQos {socket:%d, event:%d}", socket, eventId);
}
int Wait4Socket(int timeout, WaitSocketType type)
{
int hitFlag = -1;
int t = timeout;
while (t > 0) {
sleep(1);
switch (type) {
case SOCKET_BYTES:
if (g_waitFlag4Byte != WAIT_DEF_VALUE) {
LOG("Wait4socket[Byte] succ, flag:%d", g_waitFlag4Byte);
hitFlag = 1;
}
break;
case SOCKET_MSG:
if (g_waitFlag4Message != WAIT_DEF_VALUE) {
LOG("Wait4socket[Message] succ,flag:%d", g_waitFlag4Message);
hitFlag = 1;
}
break;
case SOCKET_FILE:
if (g_waitFlag4File != WAIT_DEF_VALUE) {
LOG("Wait4socket[File] succ,flag:%d", g_waitFlag4File);
hitFlag = 1;
}
break;
case SOCKET_STREAM:
if (g_waitFlagStream != WAIT_DEF_VALUE) {
LOG("Wait4socket[Stream] succ,flag:%d", g_waitFlagStream);
hitFlag = 1;
}
break;
case SOCKET_SHUTDOWN:
if (g_waitFlag4Shutdown != WAIT_DEF_VALUE) {
LOG("Wait4socket[SHUTDOWN] succ,flag:%d", g_waitFlag4Shutdown);
hitFlag = 1;
}
break;
default:
LOG("Wait4socket type error");
hitFlag = 1;
break;
}
if (hitFlag != -1) {
break;
}
t--;
}
switch (type) {
case SOCKET_BYTES:
if (g_waitFlag4Byte != WAIT_SUCCESS_VALUE) {
LOG("Wait4socket[Byte] fail[exp:%d, real:%d]", WAIT_SUCCESS_VALUE, g_waitFlag4Byte);
return SOFTBUS_ERR;
}
break;
case SOCKET_MSG:
if (g_waitFlag4Message != WAIT_SUCCESS_VALUE) {
LOG("Wait4socket[Message] fail[exp:%d, real:%d]", WAIT_SUCCESS_VALUE, g_waitFlag4Message);
return SOFTBUS_ERR;
}
break;
case SOCKET_FILE:
if (g_waitFlag4File != WAIT_SUCCESS_VALUE) {
LOG("Wait4socket[File] fail[exp:%d, real:%d]", WAIT_SUCCESS_VALUE, g_waitFlag4File);
return SOFTBUS_ERR;
}
break;
case SOCKET_STREAM:
if (g_waitFlagStream != WAIT_SUCCESS_VALUE) {
LOG("Wait4socket[Stream] fail[exp:%d, real:%d]", WAIT_SUCCESS_VALUE, g_waitFlagStream);
return SOFTBUS_ERR;
}
break;
case SOCKET_SHUTDOWN:
if (g_waitFlag4Shutdown != WAIT_SUCCESS_VALUE) {
LOG("Wait4socket[SHUTDOWN] fail[exp:%d, real:%d]", WAIT_SUCCESS_VALUE, g_waitFlag4Shutdown);
return SOFTBUS_ERR;
}
break;
default:
return SOFTBUS_ERR;
}
return SOFTBUS_OK;
}
int SendSocket4Data(DataType type, int size)
{
int ret;
LOG("###SendSocket4Data g_currentSocket4Data = %d ", g_currentSocket4Data );
if (size > 0) {
g_expectDataContent = (char*)calloc(1, size);
if (g_expectDataContent == NULL) {
LOG("[send data]calloc fail");
return SOFTBUS_ERR;
}
(void)memset_s(g_expectDataContent, size, g_fillContentChar, size);
} else {
LOG("[send data]invalid param[size>=1]");
return SOFTBUS_ERR;
}
g_expectDataSize = size;
if (type == DATA_TYPE_MSG) {
ret = SendMessage(g_currentSocket4Data, g_expectDataContent, size);
if (ret != SOFTBUS_OK) {
LOG("[send data]call SendX fail, ret:%d", ret);
free(g_expectDataContent);
return SOFTBUS_ERR;
}
} else if (type == DATA_TYPE_BYTE) {
ResetWaitFlag4Byte();
ret = SendBytes(g_currentSocket4Data, g_expectDataContent, size);
int timeout;
if (size < SIZE_1K * SIZE_1K) {
timeout = 30;
}else if (size >= SIZE_1K * SIZE_1K && size < 2 * SIZE_1K * SIZE_1K)
{
timeout = 60;
}else
{
timeout = 80;
}
ret = Wait4Socket(timeout, SOCKET_BYTES);
return ret;
} else {
LOG("[send data]invalid param[DataType]");
free(g_expectDataContent);
return SOFTBUS_ERR;
}
LOG("[send data]call SendX success");
free(g_expectDataContent);
g_expectDataContent = NULL;
return ret;
}
void ResetWaitFlag(void)
{
g_waitFlag = WAIT_DEF_VALUE;
}
void ResetWaitFlag4Shutdown(void)
{
g_waitFlag4Shutdown = WAIT_DEF_VALUE;
}
void ResetWaitFlag4Byte(void)
{
g_waitFlag4Byte = WAIT_DEF_VALUE;
}
void ResetWaitFlag4Message(void)
{
g_waitFlag4Message = WAIT_DEF_VALUE;
}
void ResetWaitFlag4Stream(void)
{
g_waitFlagStream = WAIT_DEF_VALUE;
}
void ResetWaitFlag4File(void)
{
g_waitFlag4File = WAIT_DEF_VALUE;
}
void ResetSocketFileProgress(void)
{
g_socketFileEventCount = SOCKET_FILE_EVENT_COUNT_NONE;
g_socketFileLastEventTime = SOCKET_FILE_NO_EVENT_TIME;
g_socketFileEventType = SOCKET_FILE_EVENT_TYPE_INVALID;
}
int Wait4SocketWithProgress(int timeout)
{
int elapsedSec = 0;
int stallSec = 0;
int lastEventCount = SOCKET_FILE_EVENT_COUNT_NONE;
int windowStartEventCount = SOCKET_FILE_EVENT_COUNT_NONE;
int windowStartSec = 0;
int safetyMax = (timeout > 0) ? timeout : SOCKET_FILE_SAFETY_TIMEOUT_SEC;
LOG("Wait4SocketWithProgress start, safetyMax:%ds, stallTimeout:%ds, creepWindow:%ds",
safetyMax, SOCKET_FILE_STALL_TIMEOUT_SEC, SOCKET_FILE_CREEP_WINDOW_SEC);
while (elapsedSec < safetyMax) {
sleep(1);
elapsedSec++;
if (g_waitFlag4File == WAIT_SUCCESS_VALUE) {
LOG("Wait4SocketWithProgress SUCCESS, elapsed:%ds, eventCount:%d, lastEventType:%d",
elapsedSec, g_socketFileEventCount, g_socketFileEventType);
return SOFTBUS_OK;
}
if (g_waitFlag4File == WAIT_FAIL_VALUE) {
LOG("Wait4SocketWithProgress FAIL(error), elapsed:%ds, eventCount:%d, lastEventType:%d",
elapsedSec, g_socketFileEventCount, g_socketFileEventType);
return SOFTBUS_ERR;
}
int currentEventCount = g_socketFileEventCount;
if (currentEventCount != lastEventCount) {
LOG("Wait4SocketWithProgress event: count %d->%d, lastType:%d, elapsed:%ds",
lastEventCount, currentEventCount, g_socketFileEventType, elapsedSec);
lastEventCount = currentEventCount;
stallSec = 0;
} else {
stallSec++;
if (g_socketFileLastEventTime == SOCKET_FILE_NO_EVENT_TIME && stallSec >= SOCKET_FILE_STALL_TIMEOUT_SEC) {
LOG("Wait4SocketWithProgress FAIL(no event), no FileEvent received for %ds, elapsed:%ds",
SOCKET_FILE_STALL_TIMEOUT_SEC, elapsedSec);
return SOFTBUS_ERR;
}
if (g_socketFileLastEventTime != SOCKET_FILE_NO_EVENT_TIME && stallSec >= SOCKET_FILE_STALL_TIMEOUT_SEC) {
LOG("Wait4SocketWithProgress FAIL(stalled), no new event for %ds, lastEventCount:%d, elapsed:%ds",
SOCKET_FILE_STALL_TIMEOUT_SEC, lastEventCount, elapsedSec);
return SOFTBUS_ERR;
}
}
if (elapsedSec - windowStartSec >= SOCKET_FILE_CREEP_WINDOW_SEC) {
int eventDelta = currentEventCount - windowStartEventCount;
if (eventDelta < SOCKET_FILE_CREEP_MIN_EVENTS && windowStartEventCount > SOCKET_FILE_EVENT_COUNT_NONE) {
LOG("Wait4SocketWithProgress FAIL(creeping), only %d events in %ds, stuck at %d events",
eventDelta, SOCKET_FILE_CREEP_WINDOW_SEC, currentEventCount);
return SOFTBUS_ERR;
}
LOG("Wait4SocketWithProgress creep check: %d events in %ds, ok",
eventDelta, SOCKET_FILE_CREEP_WINDOW_SEC);
windowStartEventCount = currentEventCount;
windowStartSec = elapsedSec;
}
}
LOG("Wait4SocketWithProgress FAIL(safety timeout), elapsed:%ds, eventCount:%d, lastEventType:%d, "
"this indicates a code bug, not a slow transfer",
elapsedSec, g_socketFileEventCount, g_socketFileEventType);
return SOFTBUS_ERR;
}
char* GetNetworkId(void)
{
return g_networkId;
}
int CheckRemoteDeviceIsNull(int isSetNetId)
{
int nodeNum = 0;
NodeBasicInfo* nodeInfo = NULL;
int ret = GetAllNodeDeviceInfo(DEF_PKG_NAME, &nodeInfo, &nodeNum);
LOG("[check]get node number is:%d, ret:%d", nodeNum, ret);
if (nodeInfo != NULL && nodeNum > 0) {
LOG("[check]get netid is:%s", nodeInfo->networkId);
if (isSetNetId == BOOL_TRUE) {
(void)strncpy_s(g_networkId, NETWORK_ID_BUF_LEN, nodeInfo->networkId, NETWORK_ID_BUF_LEN);
}
FreeNodeInfo(nodeInfo);
return SOFTBUS_OK;
} else {
LOG("[check]get nodeInfo is null");
return SOFTBUS_ERR;
}
}
ISocketListener* GetSocketListnerData(void)
{
return g_socketlistenerdata;
}
void SetCurrentSocket4Data(int socket)
{
g_currentSocket4Data = socket;
}
int GetCurrentSocket4Data(void)
{
return g_currentSocket4Data;
}
void TestSetUp(void)
{
g_defNodeStateCallback.events = EVENT_NODE_STATE_MASK;
g_defNodeStateCallback.onNodeOnline = OnDefNodeOnline;
g_defNodeStateCallback.onNodeOffline = OnDefNodeOffline;
g_defNodeStateCallback.onNodeBasicInfoChanged = OnDefNodeBasicInfoChanged;
g_defNodeStateCallback.onNodeStatusChanged = onDefNodeStatusChanged;
if (g_socketlistenerdata == NULL) {
g_socketlistenerdata = (ISocketListener*)calloc(1, sizeof(ISocketListener));
g_socketlistenerdata->OnBind = OnBindData;
g_socketlistenerdata->OnShutdown = OnShutdownData;
g_socketlistenerdata->OnBytes = OnByteData;
g_socketlistenerdata->OnMessage = OnMessageData;
g_socketlistenerdata->OnStream = OnStreamData;
g_socketlistenerdata->OnFile = OnFileData;
g_socketlistenerdata->OnQos = OnQosData;
};
}
void TestTearDown(void)
{
if (g_socketlistenerdata != NULL) {
free(g_socketlistenerdata);
g_socketlistenerdata = NULL;
}
}
uint64_t GetTestTokenId(void)
{
return g_tokenId;
}
void AddPermission(void)
{
const char *perms[2];
perms[0] = OHOS_PERMISSION_DISTRIBUTED_SOFTBUS_CENTER;
perms[1] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
NativeTokenInfoParams infoTnstance = {
.dcapsNum = 0,
.permsNum = 2,
.aclsNum = 0,
.dcaps = NULL,
.perms = perms,
.acls = NULL,
.processName = "dsoftbus_test_service",
.aplStr = "system_core",
};
g_tokenId = GetAccessTokenId(&infoTnstance);
SetSelfTokenID(g_tokenId);
}