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 #include "param_message.h"
16
17 static const uint32_t RECV_BUFFER_MAX = 5 * 1024;
18
19 static RecvMessage g_recvMessage;
OnReceiveRequest(const TaskHandle task,const uint8_t * buffer,uint32_t nread)20 static void OnReceiveRequest(const TaskHandle task, const uint8_t *buffer, uint32_t nread)
21 {
22 if (nread == 0 || buffer == NULL || g_recvMessage == NULL) {
23 return;
24 }
25 uint32_t curr = 0;
26 while (curr < nread) {
27 const ParamMessage *msg = (const ParamMessage *)(buffer + curr);
28 if (((msg->msgSize + curr) > nread)
29 || ((sizeof(ParamMessage) + curr) > nread)
30 || (msg->msgSize < sizeof(ParamMessage))) {
31 break;
32 }
33 curr += msg->msgSize;
34 g_recvMessage(task, msg);
35 }
36 }
37
ParamServerCreate(ParamTaskPtr * stream,const ParamStreamInfo * streamInfo)38 int ParamServerCreate(ParamTaskPtr *stream, const ParamStreamInfo *streamInfo)
39 {
40 PARAM_CHECK(stream != NULL && streamInfo != NULL, return -1, "Invalid param");
41 PARAM_CHECK(streamInfo->incomingConnect != NULL, return -1, "Invalid incomingConnect");
42 LE_StreamServerInfo info = {};
43 info.baseInfo.flags = TASK_STREAM | TASK_PIPE | TASK_SERVER;
44 info.server = streamInfo->server;
45 info.baseInfo.close = streamInfo->close;
46 info.incommingConntect = streamInfo->incomingConnect;
47 return LE_CreateStreamServer(LE_GetDefaultLoop(), stream, &info);
48 }
49
ParamStreamCreate(ParamTaskPtr * stream,ParamTaskPtr server,const ParamStreamInfo * streamInfo,uint16_t userDataSize)50 int ParamStreamCreate(ParamTaskPtr *stream, ParamTaskPtr server,
51 const ParamStreamInfo *streamInfo, uint16_t userDataSize)
52 {
53 PARAM_CHECK(stream != NULL && streamInfo != NULL, return -1, "Invalid stream");
54 PARAM_CHECK(streamInfo->recvMessage != NULL, return -1, "Invalid recvMessage");
55 PARAM_CHECK(streamInfo->close != NULL, return -1, "Invalid close");
56 LE_StreamInfo info = {};
57 info.baseInfo.userDataSize = userDataSize;
58 info.baseInfo.flags = TASK_STREAM | TASK_PIPE | TASK_CONNECT;
59 if (streamInfo->flags & PARAM_TEST_FLAGS) {
60 info.baseInfo.flags |= TASK_TEST;
61 }
62 info.baseInfo.close = streamInfo->close;
63 info.disConntectComplete = NULL;
64 info.sendMessageComplete = NULL;
65 info.recvMessage = OnReceiveRequest;
66 g_recvMessage = streamInfo->recvMessage;
67 LE_STATUS status = LE_AcceptStreamClient(LE_GetDefaultLoop(), server, stream, &info);
68 PARAM_CHECK(status == 0, return -1, "Failed to create client");
69 return 0;
70 }
71
ParamGetTaskUserData(const ParamTaskPtr stream)72 void *ParamGetTaskUserData(const ParamTaskPtr stream)
73 {
74 PARAM_CHECK(stream != NULL, return NULL, "Invalid stream");
75 return LE_GetUserData(stream);
76 }
77
ParamTaskSendMsg(const ParamTaskPtr stream,const ParamMessage * msg)78 int ParamTaskSendMsg(const ParamTaskPtr stream, const ParamMessage *msg)
79 {
80 PARAM_CHECK(msg != NULL, return -1, "Invalid stream");
81 PARAM_CHECK(stream != NULL, free((void *)msg);
82 return -1, "Invalid stream");
83 uint32_t dataSize = msg->msgSize;
84 BufferHandle bufferHandle = LE_CreateBuffer(LE_GetDefaultLoop(), dataSize);
85 PARAM_CHECK(bufferHandle != NULL, return -1, "Failed to create request");
86 uint8_t *buffer = LE_GetBufferInfo(bufferHandle, NULL, NULL);
87 int ret = memcpy_s(buffer, dataSize, msg, dataSize);
88 free((void *)msg);
89 PARAM_CHECK(ret == EOK, LE_FreeBuffer(LE_GetDefaultLoop(), NULL, buffer);
90 return -1, "Failed to fill name");
91 return LE_Send(LE_GetDefaultLoop(), stream, bufferHandle, dataSize);
92 }
93
ParamEventTaskCreate(ParamTaskPtr * stream,LE_ProcessAsyncEvent eventProcess)94 int ParamEventTaskCreate(ParamTaskPtr *stream, LE_ProcessAsyncEvent eventProcess)
95 {
96 PARAM_CHECK(stream != NULL && eventProcess != NULL, return -1, "Invalid info or stream");
97 return LE_CreateAsyncTask(LE_GetDefaultLoop(), stream, eventProcess);
98 }
99
ParamEventSend(const ParamTaskPtr stream,uint64_t eventId,const char * content,uint32_t size)100 int ParamEventSend(const ParamTaskPtr stream, uint64_t eventId, const char *content, uint32_t size)
101 {
102 PARAM_CHECK(stream != NULL, return -1, "Invalid stream");
103 PARAM_CHECK(size <= RECV_BUFFER_MAX, return -1, "Invalid stream");
104 return LE_StartAsyncEvent(LE_GetDefaultLoop(), stream, eventId, (const uint8_t *)content, size);
105 }
106
ParamTaskClose(const ParamTaskPtr stream)107 int ParamTaskClose(const ParamTaskPtr stream)
108 {
109 PARAM_CHECK(stream != NULL, return -1, "Invalid param");
110 LE_CloseTask(LE_GetDefaultLoop(), stream);
111 return 0;
112 }
113
ParamTimerCreate(ParamTaskPtr * timer,LE_ProcessTimer process,void * context)114 int ParamTimerCreate(ParamTaskPtr *timer, LE_ProcessTimer process, void *context)
115 {
116 PARAM_CHECK(timer != NULL && process != NULL, return -1, "Invalid timer");
117 LE_STATUS status = LE_CreateTimer(LE_GetDefaultLoop(), timer, process, context);
118 return (int)status;
119 }
120
ParamTimerStart(const ParamTaskPtr timer,uint64_t timeout,uint64_t repeat)121 int ParamTimerStart(const ParamTaskPtr timer, uint64_t timeout, uint64_t repeat)
122 {
123 PARAM_CHECK(timer != NULL, return -1, "Invalid timer");
124 return LE_StartTimer(LE_GetDefaultLoop(), timer, timeout, repeat);
125 }
126
ParamServiceStart(void)127 int ParamServiceStart(void)
128 {
129 LE_RunLoop(LE_GetDefaultLoop());
130 return 0;
131 }
132
ParamServiceStop(void)133 int ParamServiceStop(void)
134 {
135 LE_StopLoop(LE_GetDefaultLoop());
136 return 0;
137 }
138