1 /*
2 * Copyright (C) 2021-2022 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 "avdtp_message.h"
17 #include "avdtp_ctrl.h"
18 #include "l2cap_if.h"
19 #include "log.h"
20 #include "securec.h"
21
22 /**
23 *
24 * @brief AvdtSendSig
25 *
26 * @details Signaling message fragmented and built.
27 * Call L2CAP API to send the message to peer.
28 *
29 * @return void
30 *
31 */
AvdtSendSig(AvdtSigCtrl * sigCtrl)32 void AvdtSendSig(AvdtSigCtrl *sigCtrl)
33 {
34 if (sigCtrl == NULL) {
35 return;
36 }
37 uint16_t Len = PacketSize(sigCtrl->currentMsg);
38 LOG_DEBUG("[AVDT]%{public}s:len(%hu)", __func__, Len);
39 /* pkt data debug print */
40 AvdtPktDataPrint(sigCtrl->currentMsg);
41 AvdtTransChannel *transTbl = AvdtGetTransChTabByHandle(AVDT_CH_TYPE_SIG, sigCtrl->handle);
42 if (transTbl == NULL) {
43 /* Trace no resources parameter */
44 LOG_ERROR("[AVDT]%{public}s: AvdtGetTransChTabByHandle(%hu) Failedl", __func__, sigCtrl->handle);
45 return;
46 }
47 LOG_DEBUG("[AVDT]%{public}s: packetLen(%hu) peermtu(%hu) lcid (%hu)",
48 __func__, Len, transTbl->peerMtu, transTbl->lcid);
49 if (Len <= transTbl->peerMtu) {
50 if (L2CIF_SendData(transTbl->lcid, sigCtrl->currentMsg, NULL)) {
51 LOG_WARN("[AVDT]%{public}s: L2CIF_SendData() failed", __func__);
52 }
53 } else {
54 /* fragment */
55 AvdtSendFragPacket(transTbl->lcid, sigCtrl->currentMsg, transTbl->peerMtu);
56 }
57 PacketFree(sigCtrl->currentMsg);
58 sigCtrl->currentMsg = NULL;
59 return;
60 }
61
62 /**
63 *
64 * @brief AvdtSendFragPacket
65 *
66 * @details send fragment message
67 *
68 * @return void
69 *
70 */
AvdtSendFragPacket(uint16_t lcid,Packet * pkt,uint16_t peerMtu)71 void AvdtSendFragPacket(uint16_t lcid, Packet *pkt, uint16_t peerMtu)
72 {
73 LOG_DEBUG("[AVDT]%{public}s: lcid(0x%x) peerMtu(%hu)", __func__, lcid, peerMtu);
74 uint8_t pktType = AVDT_PKT_TYPE_START;
75 uint16_t PacketLen = PacketSize(pkt);
76 uint16_t Ret;
77 Packet *fragmentPacket = PacketMalloc(0, 0, 0);
78 Buffer *fragmentData = PacketContinuousPayload(pkt);
79 PacketPayloadAddLast(fragmentPacket, fragmentData);
80 uint8_t *p = (uint8_t *)BufferPtr(PacketHead(pkt));
81 uint8_t label = AvdtParseTransLabel(*p);
82 uint8_t msgType = AvdtParseMessageType(*p);
83 uint8_t signal = *(p + 1);
84 if (peerMtu <= AVDT_BUFFER_END) {
85 LOG_ERROR("[AVDT]%{public}s: The MTU is too small ", __func__);
86 PacketFree(fragmentPacket);
87 return;
88 }
89 uint8_t number = (PacketLen - (peerMtu - AVDT_BUFFER_START)) / (peerMtu - AVDT_BUFFER_END) + 1;
90 if ((PacketLen - (peerMtu - AVDT_BUFFER_START)) % (peerMtu - AVDT_BUFFER_END) != 0) {
91 number++;
92 }
93 do {
94 if (pktType == AVDT_PKT_TYPE_START) {
95 Ret = AvdtSendFragStart(lcid, fragmentPacket, signal, number, msgType, label, peerMtu);
96 PacketLen -= (peerMtu - AVDT_BUFFER_START);
97 LOG_DEBUG("[AVDT]%{public}s: The length of start fragment sent(%hu) ", __func__, PacketLen);
98 } else {
99 Ret = AvdtSendFragContinueEnd(lcid, fragmentPacket, pktType, msgType, label, peerMtu);
100 if (PacketLen > (peerMtu - AVDT_BUFFER_END)) {
101 PacketLen -= (peerMtu - AVDT_BUFFER_END);
102 } else {
103 PacketLen = 0;
104 }
105 LOG_DEBUG("[AVDT]%{public}s: The length of fragment sent(%hu) ", __func__, PacketLen);
106 }
107 if (PacketLen > (peerMtu - AVDT_BUFFER_END)) {
108 pktType = AVDT_PKT_TYPE_CONTINUE;
109 } else {
110 pktType = AVDT_PKT_TYPE_END;
111 }
112 } while ((PacketLen > 0) && (Ret == AVDT_SUCCESS));
113 return;
114 }
115
116 /**
117 *
118 * @brief AvdtSendFragStart
119 *
120 * @details send fragment start type message
121 *
122 * @return void
123 *
124 */
AvdtSendFragStart(uint16_t lcid,Packet * fragmentPacket,uint8_t signal,uint8_t number,uint8_t msgType,uint8_t label,uint16_t peerMtu)125 uint16_t AvdtSendFragStart(uint16_t lcid, Packet *fragmentPacket, uint8_t signal, uint8_t number, uint8_t msgType,
126 uint8_t label, uint16_t peerMtu)
127 {
128 LOG_DEBUG("[AVDT]%{public}s: number(%hhu) signal(0x%x) msgType(0x%x) label(0x%x)",
129 __func__, number, signal, msgType, label);
130 Packet *sendMsg = PacketMalloc(AVDT_BUFFER_START, 0, 0);
131 Buffer *packetHeader = PacketHead(sendMsg);
132 uint8_t *p = BufferPtr(packetHeader);
133 AvdtBuildSingleHeader(p, label, AVDT_PKT_TYPE_START, msgType);
134 p++;
135 *p++ = number;
136 *p = signal;
137 PacketFragment(fragmentPacket, sendMsg, (peerMtu - AVDT_BUFFER_START));
138 uint16_t Ret = L2CIF_SendData(lcid, sendMsg, NULL);
139 PacketFree(sendMsg);
140 return Ret;
141 }
142
143 /**
144 *
145 * @brief AvdtSendFragContinueEnd
146 *
147 * @details send fragment contitune/end type message
148 *
149 * @return void
150 *
151 */
AvdtSendFragContinueEnd(uint16_t lcid,Packet * fragmentPacket,uint8_t pktType,uint8_t msgType,uint8_t label,uint16_t peerMtu)152 uint16_t AvdtSendFragContinueEnd(
153 uint16_t lcid, Packet *fragmentPacket, uint8_t pktType, uint8_t msgType, uint8_t label, uint16_t peerMtu)
154 {
155 LOG_DEBUG("[AVDT]%{public}s: pktType(0x%x) msgType(0x%x) label(0x%x)", __func__, pktType, msgType, label);
156 Packet *sendMsg = PacketMalloc(AVDT_BUFFER_END, 0, 0);
157 Buffer *packetHeader = PacketHead(sendMsg);
158 uint8_t *p = BufferPtr(packetHeader);
159 AvdtBuildSingleHeader(p, label, pktType, msgType);
160 PacketFragment(fragmentPacket, sendMsg, (peerMtu - AVDT_BUFFER_END));
161 int16_t Ret = L2CIF_SendData(lcid, sendMsg, NULL);
162 PacketFree(sendMsg);
163 return Ret;
164 }
165
166 /**
167 *
168 * @brief AvdtMsgSendCmd
169 *
170 * @details Int send signaling command.
171 *
172 * @return void
173 *
174 */
AvdtMsgSendCmd(AvdtSigCtrl * sigCtrl,AvdtStreamCtrl * streamCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)175 void AvdtMsgSendCmd(AvdtSigCtrl *sigCtrl, AvdtStreamCtrl *streamCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
176 {
177 LOG_DEBUG("[AVDT]%{public}s:signal(0x%x)", __func__, sigId);
178 switch (sigId) {
179 case AVDT_SIG_DISCOVER:
180 AvdtBuildDiscoverCmd(sigCtrl, sigId, avdtMsgData);
181 break;
182 case AVDT_SIG_GET_ALLCAP:
183 case AVDT_SIG_GETCAP:
184 case AVDT_SIG_OPEN:
185 case AVDT_SIG_CLOSE:
186 case AVDT_SIG_GETCONFIG:
187 case AVDT_SIG_ABORT:
188 case AVDT_SIG_START:
189 case AVDT_SIG_SUSPEND:
190 AvdtBuildSingleCmd(sigCtrl, sigId, avdtMsgData);
191 break;
192 case AVDT_SIG_RECONFIG:
193 AvdtBuildReconfigureCmd(sigCtrl, streamCtrl, sigId, avdtMsgData);
194 break;
195 case AVDT_SIG_SETCONFIG:
196 AvdtBuildSetConfigureCmd(sigCtrl, streamCtrl, sigId, avdtMsgData);
197 break;
198 case AVDT_SIG_DELAY_RPT:
199 AvdtBuildDelayCmd(sigCtrl, sigId, avdtMsgData);
200 break;
201 default:
202 break;
203 }
204 AvdtSigProcEvent(sigCtrl, AVDT_SND_MSG_EVENT, NULL);
205 return;
206 }
207 /**
208 *
209 * @brief AvdtMsgSendRsp
210 *
211 * @details Acp send respond.
212 *
213 * @return void
214 *
215 */
AvdtMsgSendRsp(AvdtSigCtrl * sigCtrl,AvdtStreamCtrl * streamCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)216 void AvdtMsgSendRsp(AvdtSigCtrl *sigCtrl, AvdtStreamCtrl *streamCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
217 {
218 LOG_DEBUG("[AVDT]%{public}s:signal(0x%x)", __func__, sigId);
219 switch (sigId) {
220 case AVDT_SIG_DISCOVER:
221 AvdtBuildDiscoverRsp(sigCtrl, sigId, avdtMsgData);
222 break;
223 case AVDT_SIG_GET_ALLCAP:
224 case AVDT_SIG_GETCAP:
225 AvdtBuildGetCapRsp(sigCtrl, sigId, avdtMsgData);
226 break;
227 case AVDT_SIG_GETCONFIG:
228 AvdtBuildGetConfigureRsp(sigCtrl, streamCtrl, sigId, avdtMsgData);
229 break;
230 case AVDT_SIG_OPEN:
231 case AVDT_SIG_CLOSE:
232 case AVDT_SIG_ABORT:
233 case AVDT_SIG_START:
234 case AVDT_SIG_SUSPEND:
235 case AVDT_SIG_RECONFIG:
236 case AVDT_SIG_SETCONFIG:
237 case AVDT_SIG_DELAY_RPT:
238 AvdtBuildSingleRsp(sigCtrl, sigId, avdtMsgData);
239 break;
240 default:
241 break;
242 }
243 AvdtSigProcEvent(sigCtrl, AVDT_SND_MSG_EVENT, NULL);
244 return;
245 }
246
247 /**
248 *
249 * @brief AvdtMsgSendRej
250 *
251 * @details Acp reject the signaling.
252 *
253 * @return void
254 *
255 */
AvdtMsgSendRej(AvdtSigCtrl * sigCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)256 void AvdtMsgSendRej(AvdtSigCtrl *sigCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
257 {
258 LOG_DEBUG("[AVDT]%{public}s:signal(0x%x)", __func__, sigId);
259 switch (sigId) {
260 case AVDT_SIG_DISCOVER:
261 case AVDT_SIG_GET_ALLCAP:
262 case AVDT_SIG_GETCAP:
263 case AVDT_SIG_GETCONFIG:
264 case AVDT_SIG_OPEN:
265 case AVDT_SIG_CLOSE:
266 case AVDT_SIG_DELAY_RPT:
267 AvdtBuildCommonRej(sigCtrl, sigId, avdtMsgData->single.errCode);
268 break;
269 case AVDT_SIG_SUSPEND:
270 case AVDT_SIG_START:
271 AvdtBuildConfigureRej(sigCtrl, sigId, avdtMsgData->single.errParam, avdtMsgData->single.errCode);
272 break;
273 case AVDT_SIG_SETCONFIG:
274 AvdtBuildConfigureRej(
275 sigCtrl, sigId, avdtMsgData->configureCmd.hdr.errParam, avdtMsgData->configureCmd.hdr.errCode);
276 break;
277 case AVDT_SIG_RECONFIG:
278 AvdtBuildConfigureRej(
279 sigCtrl, sigId, avdtMsgData->reconfigureCmd.hdr.errParam, avdtMsgData->reconfigureCmd.hdr.errCode);
280 break;
281 default:
282 break;
283 }
284 AvdtSigProcEvent(sigCtrl, AVDT_SND_MSG_EVENT, NULL);
285 return;
286 }
287
288 /**
289 *
290 * @brief AvdtMsgSendGeneralRej
291 *
292 * @details Acp send the general rejection.
293 *
294 * @return void
295 *
296 */
AvdtMsgSendGeneralRej(AvdtSigCtrl * sigCtrl,uint8_t sigId)297 void AvdtMsgSendGeneralRej(AvdtSigCtrl *sigCtrl, uint8_t sigId)
298 {
299 if (sigCtrl == NULL) {
300 return;
301 }
302 LOG_DEBUG("[AVDT]%{public}s:signal(0x%x)", __func__, sigId);
303 Packet *pkt = PacketMalloc(AVDT_BUFFER_GENERAL_REJ, 0, 0);
304 Buffer *msgHeader = PacketHead(pkt);
305 uint8_t *p = BufferPtr(msgHeader);
306 AvdtBuildSingleHeader(p, sigCtrl->rcvLabel, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_GRJ);
307 AvdtBuildSignal(p + 1, sigId);
308 sigCtrl->currentMsg = pkt;
309 AvdtSigProcEvent(sigCtrl, AVDT_SND_MSG_EVENT, NULL);
310 return;
311 }
312
313 /**
314 *
315 * @brief AvdtBuildDelayCmd
316 *
317 * @details build delay command to message
318 *
319 * @return void
320 *
321 */
AvdtBuildDelayCmd(AvdtSigCtrl * sigCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)322 void AvdtBuildDelayCmd(AvdtSigCtrl *sigCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
323 {
324 if (sigCtrl == NULL || avdtMsgData == NULL) {
325 return;
326 }
327 LOG_DEBUG("[AVDT]%{public}s:signal(0x%x)", __func__, sigId);
328 uint8_t data = 0;
329 uint8_t offset = 0;
330 Packet *pkt = PacketMalloc(AVDT_BUFFER_SINGLE, 0, (AVDT_BUFFER_SEID + AVDT_BUFFER_SINGLE));
331 Buffer *msgHeader = PacketHead(pkt);
332 uint8_t *p = BufferPtr(msgHeader);
333 AvdtBuildSingleHeader(p, sigCtrl->label, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_CMD);
334 AvdtBuildSignal(p + 1, sigId);
335 AvdtBuildSignalSeid(&data, avdtMsgData->delayRptCmd.hdr.seid);
336 PacketPayloadWrite(pkt, &data, offset, AVDT_1BYTE);
337 offset++;
338 /* delay value */
339 data = (uint8_t)(avdtMsgData->delayRptCmd.delay >> AVDT_OFFSET_8BIT);
340 PacketPayloadWrite(pkt, &data, offset, AVDT_1BYTE);
341 offset++;
342 data = (uint8_t)(avdtMsgData->delayRptCmd.delay);
343 PacketPayloadWrite(pkt, &data, offset, AVDT_1BYTE);
344 sigCtrl->currentMsg = pkt;
345 return;
346 }
347
348 /**
349 *
350 * @brief AvdtBuildDiscoverCmd
351 *
352 * @details Build discover command to message.
353 *
354 * @return void
355 *
356 */
AvdtBuildDiscoverCmd(AvdtSigCtrl * sigCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)357 void AvdtBuildDiscoverCmd(AvdtSigCtrl *sigCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
358 {
359 if (sigCtrl == NULL) {
360 return;
361 }
362 LOG_DEBUG("[AVDT]%{public}s:signal(0x%x)", __func__, sigId);
363 Packet *pkt = PacketMalloc(AVDT_BUFFER_SINGLE, 0, 0);
364 Buffer *msgHeader = PacketHead(pkt);
365 uint8_t *p = (uint8_t *)BufferPtr(msgHeader);
366 AvdtBuildSingleHeader(p, sigCtrl->label, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_CMD);
367 AvdtBuildSignal(p + 1, sigId);
368 sigCtrl->currentMsg = pkt;
369 return;
370 }
371
372 /**
373 *
374 * @brief AvdtBuildDiscoverRsp
375 *
376 * @details Build discover respond to message.
377 *
378 * @return void
379 *
380 */
AvdtBuildDiscoverRsp(AvdtSigCtrl * sigCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)381 void AvdtBuildDiscoverRsp(AvdtSigCtrl *sigCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
382 {
383 if (sigCtrl == NULL || avdtMsgData == NULL) {
384 return;
385 }
386 LOG_DEBUG("[AVDT]%{public}s: signal(0x%x),sepnumber(%hhu)", __func__, sigId, avdtMsgData->discoverRsp.numSeps);
387 Packet *pkt = PacketMalloc(AVDT_BUFFER_SINGLE, 0, AVDT_BUFFER_SINGLE * avdtMsgData->discoverRsp.numSeps);
388 Buffer *msgHeader = PacketHead(pkt);
389 uint8_t *p = BufferPtr(msgHeader);
390 AvdtBuildSingleHeader(p, sigCtrl->rcvLabel, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_RSP);
391 AvdtBuildSignal(p + 1, sigId);
392 /* build seps */
393 AvdtBuildSeps(pkt, avdtMsgData);
394 sigCtrl->currentMsg = pkt;
395 return;
396 }
397
398 /**
399 *
400 * @brief AvdtBuildSeps
401 *
402 * @details Build seps content to message.
403 *
404 * @return void
405 *
406 */
AvdtBuildSeps(const Packet * pkt,const AvdtMsg * avdtMsgData)407 void AvdtBuildSeps(const Packet *pkt, const AvdtMsg *avdtMsgData)
408 {
409 if (avdtMsgData == NULL) {
410 return;
411 }
412 LOG_DEBUG("[AVDT]%{public}s:", __func__);
413 uint8_t count = avdtMsgData->discoverRsp.numSeps;
414 uint8_t data;
415 uint8_t offset = 0;
416 for (int i = 0; i < count; i++) {
417 LOG_DEBUG("[AVDT]%{public}s: discoverRsp acid(%hhu)", __func__, avdtMsgData->discoverRsp.seps[i].seid);
418 data = ((avdtMsgData->discoverRsp.seps[i].seid << AVDT_OFFSET_2BIT) |
419 (avdtMsgData->discoverRsp.seps[i].isUsed << AVDT_OFFSET_1BIT));
420 PacketPayloadWrite(pkt, &data, offset, AVDT_1BYTE);
421 LOG_DEBUG("[AVDT]%{public}s: discoverRsp write acid(%hhu) offset(%hhu)", __func__, data, offset);
422 offset++;
423 data = ((avdtMsgData->discoverRsp.seps[i].mediaType << AVDT_OFFSET_4BIT) |
424 (avdtMsgData->discoverRsp.seps[i].sepType << AVDT_OFFSET_3BIT));
425 PacketPayloadWrite(pkt, &data, offset, AVDT_1BYTE);
426 offset++;
427 }
428 return;
429 }
430
431 /**
432 *
433 * @brief AvdtBuildSingleCmd
434 *
435 * @details Only header(include ACPSeid) of cmd built to message.
436 *
437 * @return void
438 *
439 */
AvdtBuildSingleCmd(AvdtSigCtrl * sigCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)440 void AvdtBuildSingleCmd(AvdtSigCtrl *sigCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
441 {
442 LOG_DEBUG("[AVDT]%{public}s:signal(0x%x)", __func__, sigId);
443 if (sigCtrl == NULL || avdtMsgData == NULL) {
444 return;
445 }
446 uint8_t data = 0;
447 uint8_t transLabel;
448 if (sigId == AVDT_SIG_CLOSE) {
449 transLabel = AvdtCreateTransLabel(sigCtrl);
450 } else {
451 transLabel = sigCtrl->label;
452 }
453 Packet *pkt = PacketMalloc(AVDT_BUFFER_SINGLE, 0, AVDT_BUFFER_SEID);
454 Buffer *msgHeader = PacketHead(pkt);
455 uint8_t *p = BufferPtr(msgHeader);
456 AvdtBuildSingleHeader(p, transLabel, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_CMD);
457 AvdtBuildSignal(p + 1, sigId);
458 AvdtBuildSignalSeid(&data, avdtMsgData->single.seid);
459 PacketPayloadWrite(pkt, &data, 0, AVDT_1BYTE);
460 sigCtrl->currentMsg = pkt;
461 return;
462 }
463
464 /**
465 *
466 * @brief AvdtBuildSingleRsp
467 *
468 * @details Only header of respond built to message.
469 *
470 * @return void
471 *
472 */
AvdtBuildSingleRsp(AvdtSigCtrl * sigCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)473 void AvdtBuildSingleRsp(AvdtSigCtrl *sigCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
474 {
475 LOG_DEBUG("[AVDT]%{public}s:signal(0x%x)", __func__, sigId);
476 if (sigCtrl == NULL) {
477 return;
478 }
479 Packet *pkt = PacketMalloc(AVDT_BUFFER_SINGLE, 0, 0);
480 Buffer *msgHeader = PacketHead(pkt);
481 uint8_t *p = BufferPtr(msgHeader);
482 AvdtBuildSingleHeader(p, sigCtrl->rcvLabel, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_RSP);
483 AvdtBuildSignal(p + 1, sigId);
484 sigCtrl->currentMsg = pkt;
485 return;
486 }
487
488 /**
489 *
490 * @brief AvdtBuildCommonRej
491 *
492 * @details Only header of reject built to message.
493 *
494 * @return void
495 *
496 */
AvdtBuildCommonRej(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t errCode)497 void AvdtBuildCommonRej(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t errCode)
498 {
499 LOG_DEBUG("[AVDT]%{public}s:signal(0x%x)", __func__, sigId);
500 if (sigCtrl == NULL) {
501 return;
502 }
503 Packet *pkt = PacketMalloc(AVDT_BUFFER_REJECT, 0, 0);
504 Buffer *msgHeader = PacketHead(pkt);
505 uint8_t *p = BufferPtr(msgHeader);
506 AvdtBuildSingleHeader(p, sigCtrl->rcvLabel, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_REJ);
507 p++;
508 AvdtBuildSignal(p, sigId);
509 p++;
510 *p = errCode;
511 sigCtrl->currentMsg = pkt;
512 return;
513 }
514
515 /**
516 *
517 * @brief AvdtBuildConfigureRej
518 *
519 * @details Only header of reject built to message.
520 *
521 * @return void
522 *
523 */
AvdtBuildConfigureRej(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t category,uint8_t errCode)524 void AvdtBuildConfigureRej(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t category, uint8_t errCode)
525 {
526 LOG_DEBUG("[AVDT]%{public}s:signal(0x%x)", __func__, sigId);
527 if (sigCtrl == NULL) {
528 return;
529 }
530 Packet *pkt = PacketMalloc(AVDT_BUFFER_REJECT_4, 0, 0);
531 Buffer *msgHeader = PacketHead(pkt);
532 uint8_t *p = BufferPtr(msgHeader);
533 AvdtBuildSingleHeader(p, sigCtrl->rcvLabel, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_REJ);
534 p++;
535 AvdtBuildSignal(p, sigId);
536 p++;
537 *p = category;
538 p++;
539 *p = errCode;
540 sigCtrl->currentMsg = pkt;
541 return;
542 }
543
544 /**
545 *
546 * @brief AvdtBuildSetConfigureCmd
547 *
548 * @details Build setconfigure cmd to message.
549 *
550 * @return void
551 *
552 */
AvdtBuildSetConfigureCmd(AvdtSigCtrl * sigCtrl,AvdtStreamCtrl * streamCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)553 void AvdtBuildSetConfigureCmd(
554 AvdtSigCtrl *sigCtrl, AvdtStreamCtrl *streamCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
555 {
556 LOG_DEBUG("[AVDT]%{public}s:", __func__);
557 if (sigCtrl == NULL || streamCtrl == NULL || avdtMsgData == NULL) {
558 return;
559 }
560 uint8_t data = 0;
561 uint8_t offset = 0;
562 uint8_t payloadLen = 2;
563 if (streamCtrl->reqCfg.pscMask & AVDT_PSC_MSK_TRANS) {
564 payloadLen += AVDT_TRANS_LENGTH;
565 }
566 if (streamCtrl->reqCfg.pscMask & AVDT_PSC_MSK_DELAY_RPT) {
567 payloadLen += AVDT_DELAY_LENGTH;
568 }
569 payloadLen += streamCtrl->reqCfg.numCodec + AVDT_2BYTE;
570 LOG_DEBUG("[AVDT]%{public}s: payloadLen(%hhu), numcodec(%hhu)", __func__, payloadLen, streamCtrl->reqCfg.numCodec);
571 Packet *pkt = PacketMalloc(AVDT_BUFFER_SINGLE, 0, payloadLen);
572 Buffer *msgHeader = PacketHead(pkt);
573 uint8_t *p = (uint8_t *)BufferPtr(msgHeader);
574 AvdtBuildSingleHeader(p, sigCtrl->label, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_CMD);
575 AvdtBuildSignal(p + 1, sigId);
576 AvdtBuildSignalSeid(&data, avdtMsgData->configureCmd.acpSeid);
577 PacketPayloadWrite(pkt, &data, offset, AVDT_BUFFER_SEID);
578 offset++;
579 AvdtBuildSignalSeid(&data, avdtMsgData->configureCmd.intSeid);
580 PacketPayloadWrite(pkt, &data, offset, AVDT_BUFFER_SEID);
581 offset++;
582 AvdtBuildCapability(pkt, &(streamCtrl->reqCfg), offset, sigId);
583 sigCtrl->currentMsg = pkt;
584 return;
585 }
586
587 /**
588 *
589 * @brief AvdtBuildGetCapRsp
590 *
591 * @details Build getcapability respond to message.
592 *
593 * @return void
594 *
595 */
AvdtBuildGetCapRsp(AvdtSigCtrl * sigCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)596 void AvdtBuildGetCapRsp(AvdtSigCtrl *sigCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
597 {
598 LOG_DEBUG("[AVDT]%{public}s:", __func__);
599 if (sigCtrl == NULL || avdtMsgData == NULL) {
600 return;
601 }
602 uint8_t payloadLen = 0;
603 if (avdtMsgData->getcap.cfg->pscMask & AVDT_PSC_MSK_TRANS) {
604 payloadLen += AVDT_TRANS_LENGTH;
605 }
606 if ((avdtMsgData->getcap.cfg->pscMask & AVDT_PSC_MSK_DELAY_RPT) && (sigId != AVDT_SIG_GETCAP)) {
607 payloadLen += AVDT_DELAY_LENGTH;
608 }
609 payloadLen += avdtMsgData->getcap.cfg->numCodec + AVDT_2BYTE;
610 Packet *pkt = PacketMalloc(AVDT_BUFFER_SINGLE, 0, payloadLen);
611 Buffer *msgHeader = PacketHead(pkt);
612 uint8_t *p = BufferPtr(msgHeader);
613 AvdtBuildSingleHeader(p, sigCtrl->rcvLabel, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_RSP);
614 AvdtBuildSignal(p + 1, sigId);
615 /* buld seps */
616 AvdtBuildCapability(pkt, avdtMsgData->getcap.cfg, 0, sigId);
617 sigCtrl->currentMsg = pkt;
618 return;
619 }
620
621 /**
622 *
623 * @brief AvdtBuildGetConfigureRsp
624 *
625 * @details Build getconfigure respond to message.
626 *
627 * @return void
628 *
629 */
AvdtBuildGetConfigureRsp(AvdtSigCtrl * sigCtrl,AvdtStreamCtrl * streamCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)630 void AvdtBuildGetConfigureRsp(
631 AvdtSigCtrl *sigCtrl, AvdtStreamCtrl *streamCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
632 {
633 LOG_DEBUG("[AVDT]%{public}s:", __func__);
634 if (sigCtrl == NULL || streamCtrl == NULL) {
635 return;
636 }
637 uint8_t payloadLen = 0;
638 if (streamCtrl->currCfg.cfg.pscMask & AVDT_PSC_MSK_TRANS) {
639 payloadLen += AVDT_TRANS_LENGTH;
640 }
641 if (streamCtrl->currCfg.cfg.pscMask & AVDT_PSC_MSK_DELAY_RPT) {
642 payloadLen += AVDT_DELAY_LENGTH;
643 }
644 payloadLen += streamCtrl->currCfg.cfg.numCodec + AVDT_2BYTE;
645 Packet *pkt = PacketMalloc(AVDT_BUFFER_SINGLE, 0, payloadLen);
646 Buffer *msgHeader = PacketHead(pkt);
647 uint8_t *p = BufferPtr(msgHeader);
648 AvdtBuildSingleHeader(p, sigCtrl->rcvLabel, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_RSP);
649 AvdtBuildSignal(p + 1, sigId);
650 /* buld seps */
651 AvdtBuildCapability(pkt, &streamCtrl->currCfg.cfg, 0, sigId);
652 sigCtrl->currentMsg = pkt;
653 return;
654 }
655
656 /**
657 *
658 * @brief AvdtBuildReconfigureCmd
659 *
660 * @details Build reconfigure cmd to message.
661 *
662 * @return void
663 *
664 */
AvdtBuildReconfigureCmd(AvdtSigCtrl * sigCtrl,AvdtStreamCtrl * streamCtrl,uint8_t sigId,const AvdtMsg * avdtMsgData)665 void AvdtBuildReconfigureCmd(
666 AvdtSigCtrl *sigCtrl, AvdtStreamCtrl *streamCtrl, uint8_t sigId, const AvdtMsg *avdtMsgData)
667 {
668 LOG_DEBUG("[AVDT]%{public}s:", __func__);
669 if (sigCtrl == NULL || streamCtrl == NULL || avdtMsgData == NULL) {
670 return;
671 }
672 uint8_t data = 0;
673 uint8_t offset = 0;
674 uint8_t payloadLen = 1;
675 if (avdtMsgData->reconfigureCmd.cfg.pscMask & AVDT_PSC_MSK_TRANS) {
676 payloadLen += AVDT_TRANS_LENGTH;
677 }
678 if (avdtMsgData->reconfigureCmd.cfg.pscMask & AVDT_PSC_MSK_DELAY_RPT) {
679 payloadLen += AVDT_DELAY_LENGTH;
680 }
681 payloadLen += avdtMsgData->reconfigureCmd.cfg.numCodec + AVDT_2BYTE;
682 Packet *pkt = PacketMalloc(AVDT_BUFFER_SINGLE, 0, payloadLen);
683 Buffer *msgHeader = PacketHead(pkt);
684 uint8_t *p = BufferPtr(msgHeader);
685 AvdtBuildSingleHeader(p, sigCtrl->label, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_CMD);
686 AvdtBuildSignal(p + 1, sigId);
687 AvdtBuildSignalSeid(&data, avdtMsgData->reconfigureCmd.hdr.seid);
688 PacketPayloadWrite(pkt, &data, offset, AVDT_BUFFER_SEID);
689 offset++;
690 streamCtrl->reqCfg.pscMask = AVDT_PSC_MSK_CODEC; /* reconfigure is modify codec only */
691 AvdtBuildCapability(pkt, &avdtMsgData->reconfigureCmd.cfg, offset, sigId);
692 sigCtrl->currentMsg = pkt;
693 return;
694 }
695
696 /**
697 *
698 * @brief AvdtBuildSingleHeader
699 *
700 * @details Build the first octet of message.
701 *
702 * @return void
703 *
704 */
AvdtBuildSingleHeader(uint8_t * data,uint8_t label,uint8_t pktType,uint8_t msgType)705 void AvdtBuildSingleHeader(uint8_t *data, uint8_t label, uint8_t pktType, uint8_t msgType)
706 {
707 LOG_DEBUG("[AVDT]%{public}s:", __func__);
708 *(data) = (label << MOVE_4BIT) | (pktType << MOVE_2BIT) | (msgType);
709 return;
710 }
711
712 /**
713 *
714 * @brief AvdtBuildSignal
715 *
716 * @details Build the signalling of message.
717 *
718 * @return void
719 *
720 */
AvdtBuildSignal(uint8_t * data,uint8_t signal)721 void AvdtBuildSignal(uint8_t *data, uint8_t signal)
722 {
723 LOG_DEBUG("[AVDT]%{public}s: signal(0x%x)", __func__, signal);
724 *data = signal;
725 return;
726 }
727
728 /**
729 *
730 * @brief AvdtBuildSignalSeid
731 *
732 * @details Build the seid of message.
733 *
734 * @return void
735 *
736 */
AvdtBuildSignalSeid(uint8_t * data,uint8_t seid)737 void AvdtBuildSignalSeid(uint8_t *data, uint8_t seid)
738 {
739 LOG_DEBUG("[AVDT]%{public}s:", __func__);
740 *data = seid << MOVE_2BIT;
741 return;
742 }
743
744 /**
745 *
746 * @brief AvdtBuildCapability
747 *
748 * @details Build the service capability to message.
749 *
750 * @return The length of data.
751 *
752 */
AvdtBuildCapability(const Packet * pkt,const AvdtSepConfig * cfg,uint8_t off,uint8_t sigId)753 uint16_t AvdtBuildCapability(const Packet *pkt, const AvdtSepConfig *cfg, uint8_t off, uint8_t sigId)
754 {
755 LOG_DEBUG("[AVDT]%{public}s:", __func__);
756 uint16_t Offset = off;
757 uint8_t data;
758 if (cfg == NULL) {
759 return 0;
760 }
761 /* for now, just build media transport, codec and delayreport */
762 /* media transport */
763 if (cfg->pscMask & AVDT_PSC_MSK_TRANS) {
764 data = AVDT_PSC_TRANS;
765 PacketPayloadWrite(pkt, &data, Offset, AVDT_1BYTE);
766 Offset++;
767 data = 0;
768 PacketPayloadWrite(pkt, &data, Offset, AVDT_1BYTE); /* media transport length */
769 Offset++;
770 }
771 /* codec */
772 if (cfg->numCodec != 0) {
773 data = AVDT_PSC_CODEC;
774 PacketPayloadWrite(pkt, &data, Offset, AVDT_1BYTE);
775 Offset++;
776 PacketPayloadWrite(pkt, cfg->codecInfo, Offset, (cfg->numCodec + 1));
777 Offset += (cfg->numCodec + 1);
778 }
779 if (sigId != AVDT_SIG_GETCAP) {
780 /* delay report */
781 if (cfg->pscMask & AVDT_PSC_MSK_DELAY_RPT) {
782 data = AVDT_PSC_DELAY_RPT;
783 PacketPayloadWrite(pkt, &data, Offset, AVDT_1BYTE);
784 Offset++;
785 data = 0;
786 PacketPayloadWrite(pkt, &data, Offset, AVDT_1BYTE);
787 Offset++;
788 }
789 }
790 return Offset;
791 }
792
793 /**
794 *
795 * @brief AvdtParseMsg
796 *
797 * @details Parse the signalling data from L2CAP data read indication.
798 *
799 *
800 * @return void
801 *
802 */
AvdtParseMsg(AvdtSigCtrl * sigCtrl,Packet * pkt)803 void AvdtParseMsg(AvdtSigCtrl *sigCtrl, Packet *pkt)
804 {
805 if (sigCtrl == NULL) {
806 return;
807 }
808 uint8_t data = 0;
809 PacketExtractHead(pkt, &data, AVDT_1BYTE); /* Read first octet message */
810 uint8_t transLabel = AvdtParseTransLabel(data);
811 uint8_t pktType = AvdtParsePacketType(data);
812 uint8_t messageType = AvdtParseMessageType(data);
813 LOG_DEBUG("[AVDT]%{public}s: messageType(%hhu) transLabel(%hhu) pktType(%hhu)",
814 __func__, messageType, transLabel, pktType);
815 if (pktType == AVDT_PKT_TYPE_SINGLE) {
816 AvdtParseSingleMsg(sigCtrl, pkt, transLabel, messageType);
817 } else {
818 if (pktType == AVDT_PKT_TYPE_START) {
819 sigCtrl->rcvLabel = transLabel;
820 AvdtAssembleMsg(sigCtrl, messageType, pktType, pkt);
821 } else {
822 if (transLabel == sigCtrl->rcvLabel) {
823 AvdtAssembleMsg(sigCtrl, messageType, pktType, pkt);
824 } else {
825 /* Trace Error */
826 PacketFree(sigCtrl->rxMsg);
827 sigCtrl->rxMsg = NULL;
828 sigCtrl->rcvLabel = 0;
829 sigCtrl->numbPakcket = 0;
830 }
831 if (pktType == AVDT_PKT_TYPE_END && sigCtrl->numbPakcket == 0) {
832 AvdtParseMsgAssembled(sigCtrl, sigCtrl->rxMsg);
833 }
834 }
835 }
836 return;
837 }
838
839 /**
840 *
841 * @brief AvdtParseSingleMsg
842 *
843 * @details Parse the single type signalling data from L2CAP data read indication.
844 *
845 *
846 * @return void
847 *
848 */
AvdtParseSingleMsg(AvdtSigCtrl * sigCtrl,Packet * pkt,uint8_t transLabel,uint8_t messageType)849 void AvdtParseSingleMsg(AvdtSigCtrl *sigCtrl, Packet *pkt, uint8_t transLabel, uint8_t messageType)
850 {
851 if (sigCtrl == NULL) {
852 return;
853 }
854 uint8_t data = 0;
855 sigCtrl->rcvLabel = transLabel;
856 PacketExtractHead(pkt, &data, AVDT_1BYTE);
857 sigCtrl->rcvSignal = AvdtParseSignal(data);
858 switch (messageType) {
859 case AVDT_MSG_TYPE_CMD:
860 AvdtParseSignalInd(sigCtrl, sigCtrl->rcvSignal, transLabel, pkt);
861 break;
862 case AVDT_MSG_TYPE_RSP:
863 if (sigCtrl->label != sigCtrl->rcvLabel) {
864 LOG_ERROR("[AVDT]%{public}s: Response label not pair: sendLabel(%hhu)/ReceiveLabel(%hhu) ",
865 __func__,
866 sigCtrl->label,
867 sigCtrl->rcvLabel);
868 }
869 AvdtParseSignalRsp(sigCtrl, sigCtrl->rcvSignal, pkt);
870 break;
871 case AVDT_MSG_TYPE_REJ:
872 AvdtParseSignalRej(sigCtrl, sigCtrl->rcvSignal, transLabel, pkt);
873 break;
874 case AVDT_MSG_TYPE_GRJ:
875 LOG_ERROR("[AVDT]%{public}s: Invalid signaling(%hhu) sendLabel(%hhu), receiveLabel(%hhu)",
876 __func__,
877 sigCtrl->rcvSignal,
878 sigCtrl->label,
879 sigCtrl->rcvLabel);
880 break;
881 default:
882 LOG_ERROR("[AVDT]%{public}s: unsupported messageType(%hhu) ", __func__, messageType);
883 break;
884 }
885 return;
886 }
887 /**
888 *
889 * @brief AvdtAssembleMsg
890 *
891 * @details Assemble the fragment message.
892 *
893 *
894 * @return void
895 *
896 */
AvdtAssembleMsg(AvdtSigCtrl * sigCtrl,uint8_t msgType,uint8_t pktType,Packet * pkt)897 void AvdtAssembleMsg(AvdtSigCtrl *sigCtrl, uint8_t msgType, uint8_t pktType, Packet *pkt)
898 {
899 if (sigCtrl == NULL) {
900 return;
901 }
902 LOG_DEBUG("[AVDT]%{public}s:sendLabel(%hhu) ReceiveLabel(%hhu),msgType(%hhu),pktType(%hhu)",
903 __func__,
904 sigCtrl->label,
905 sigCtrl->rcvLabel,
906 msgType,
907 pktType);
908 uint8_t data = 0;
909 if (pktType == AVDT_PKT_TYPE_START) {
910 uint8_t sigId;
911 LOG_DEBUG("[AVDT]%{public}s: pktType(%hhu) msgType(%hhu)", __func__, pktType, msgType);
912 PacketExtractHead(pkt, &data, 1);
913 sigCtrl->numbPakcket = data;
914 sigCtrl->msgType = msgType;
915 PacketExtractHead(pkt, &data, 1);
916 sigId = AvdtParseSignal(data);
917 LOG_DEBUG("[AVDT]%{public}s: sigId(%hhu)", __func__, sigId);
918 if (sigCtrl->rxMsg != NULL) {
919 PacketFree(sigCtrl->rxMsg);
920 sigCtrl->rxMsg = NULL;
921 }
922 sigCtrl->rxMsg = PacketMalloc(AVDT_BUFFER_SINGLE, 0, 0);
923 if (sigCtrl->rxMsg != NULL) {
924 Buffer *packetHeader = PacketHead(sigCtrl->rxMsg);
925 uint8_t *p = BufferPtr(packetHeader);
926 AvdtBuildSingleHeader(p, sigCtrl->rcvLabel, AVDT_PKT_TYPE_SINGLE, msgType);
927 AvdtBuildSignal(p + 1, sigId);
928 sigCtrl->rcvSignal = sigId;
929 PacketAssemble(sigCtrl->rxMsg, pkt);
930 sigCtrl->numbPakcket--;
931 } else {
932 LOG_ERROR("[AVDT]%{public}s: Memory alloc for rxMsg failed", __func__);
933 }
934 } else {
935 PacketExtractHead(pkt, &data, 1);
936 PacketAssemble(sigCtrl->rxMsg, pkt);
937 sigCtrl->numbPakcket--;
938 }
939 LOG_DEBUG("[AVDT]%{public}s: sigCtrl->numbPakcket(%hhu)", __func__, sigCtrl->numbPakcket);
940 return;
941 }
942
943 /**
944 *
945 * @brief AvdtParseMsgAssembled
946 *
947 * @details Parse the message assembled.
948 *
949 *
950 * @return void
951 *
952 */
AvdtParseMsgAssembled(AvdtSigCtrl * sigCtrl,Packet * pkt)953 void AvdtParseMsgAssembled(AvdtSigCtrl *sigCtrl, Packet *pkt)
954 {
955 if (sigCtrl == NULL || pkt == NULL) {
956 return;
957 }
958 LOG_DEBUG("[AVDT]%{public}s: sigCtrl->rcvSignal(0x%x) sigCtrl->rcvLabel(0x%x) sigCtrl->msgType(0x%x)",
959 __func__,
960 sigCtrl->rcvSignal,
961 sigCtrl->rcvLabel,
962 sigCtrl->msgType);
963 uint8_t header[2] = {0};
964 PacketExtractHead(pkt, &header[0], AVDT_2BYTE);
965 switch (sigCtrl->msgType) {
966 case AVDT_MSG_TYPE_CMD:
967 if (AvdtCheckSignal(sigCtrl->rcvSignal) != AVDT_SUCCESS) {
968 /* Trace: invalid signal */
969 AvdtSignalGeneralRej(sigCtrl, sigCtrl->rcvSignal, sigCtrl->rcvLabel);
970 return;
971 }
972 AvdtParseSignalInd(sigCtrl, sigCtrl->rcvSignal, sigCtrl->rcvLabel, pkt);
973 break;
974 case AVDT_MSG_TYPE_RSP:
975 AvdtParseSignalRsp(sigCtrl, sigCtrl->rcvSignal, pkt);
976 break;
977 case AVDT_MSG_TYPE_REJ:
978 break;
979 case AVDT_MSG_TYPE_GRJ:
980 break;
981 default:
982 LOG_ERROR("[AVDT]%{public}s: unsupported messageType(%hhu) ", __func__, sigCtrl->msgType);
983 break;
984 }
985 return;
986 }
987
988 /**
989 *
990 * @brief AvdtParseTransLabel
991 *
992 * @details Parse the transport label from the first octet of message.
993 *
994 *
995 * @return Transport label
996 *
997 */
AvdtParseTransLabel(uint8_t header)998 uint8_t AvdtParseTransLabel(uint8_t header)
999 {
1000 return (uint8_t)(header >> AVDT_OFFSET_4BIT);
1001 }
1002
1003 /**
1004 *
1005 * @brief AvdtParsePacketType
1006 *
1007 * @details Parse the packet type from the first octet of message.
1008 *
1009 *
1010 * @return packet type
1011 *
1012 */
AvdtParsePacketType(uint8_t header)1013 uint8_t AvdtParsePacketType(uint8_t header)
1014 {
1015 return (header & 0x0D) >> AVDT_OFFSET_2BIT;
1016 }
1017
1018 /**
1019 *
1020 * @brief AvdtParseMessageType
1021 *
1022 * @details Parse the message type from the first octet of message.
1023 *
1024 *
1025 * @return message type
1026 *
1027 */
AvdtParseMessageType(uint8_t header)1028 uint8_t AvdtParseMessageType(uint8_t header)
1029 {
1030 return (uint8_t)(header & 0x03);
1031 }
1032
1033 /**
1034 *
1035 * @brief AvdtParseSignal
1036 *
1037 * @details Parse the signalling from message.
1038 *
1039 * @return Signalling id
1040 *
1041 */
AvdtParseSignal(uint8_t header)1042 uint8_t AvdtParseSignal(uint8_t header)
1043 {
1044 return (header & 0x3F);
1045 }
1046
1047 /**
1048 *
1049 * @brief AvdtCheckSignal
1050 *
1051 * @details Checkt the signalling is valid.
1052 *
1053 * @return valid:0 / invalid:1
1054 *
1055 */
AvdtCheckSignal(uint8_t sigId)1056 uint8_t AvdtCheckSignal(uint8_t sigId)
1057 {
1058 uint8_t Ret = AVDT_SUCCESS;
1059 if ((sigId > AVDT_SIG_MAX) || (sigId < AVDT_SIG_DISCOVER)) {
1060 Ret = AVDT_BAD_PARAMS;
1061 }
1062 return Ret;
1063 }
1064
1065 /**
1066 *
1067 * @brief AvdtParseSignalInd
1068 *
1069 * @details Parse and dispatch the command from remote peer.
1070 *
1071 * @return void
1072 *
1073 */
AvdtParseSignalInd(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t label,const Packet * pkt)1074 void AvdtParseSignalInd(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t label, const Packet *pkt)
1075 {
1076 if (sigCtrl == NULL) {
1077 return;
1078 }
1079 LOG_DEBUG("[AVDT]%{public}s:sendLabel(%hhu) ReceiveLabel(%hhu),sigId(0x%x),PaketSize(%u)",
1080 __func__,
1081 sigCtrl->label,
1082 sigCtrl->rcvLabel,
1083 sigId,
1084 PacketSize(pkt));
1085 uint8_t event = AvdtGetEventBySigidInd(sigId);
1086 if (AvdtIndPktLenCheck(sigCtrl, sigId, pkt) != AVDT_SUCCESS) {
1087 return;
1088 }
1089 switch (sigId) {
1090 case AVDT_SIG_DISCOVER:
1091 AvdtSigProcEvent(sigCtrl, event, NULL);
1092 break;
1093 case AVDT_SIG_GET_ALLCAP:
1094 case AVDT_SIG_GETCAP:
1095 case AVDT_SIG_OPEN:
1096 case AVDT_SIG_CLOSE:
1097 case AVDT_SIG_GETCONFIG:
1098 case AVDT_SIG_ABORT:
1099 case AVDT_SIG_START:
1100 case AVDT_SIG_SUSPEND:
1101 AvdtParseCommonInd(sigCtrl, sigId, label, pkt, event);
1102 break;
1103 case AVDT_SIG_RECONFIG:
1104 AvdtParseReconfigInd(sigCtrl, label, pkt, event);
1105 break;
1106 case AVDT_SIG_SETCONFIG:
1107 AvdtParseSetconfigInd(sigCtrl, label, pkt, event);
1108 break;
1109 case AVDT_SIG_DELAY_RPT:
1110 AvdtParseDelayRptInd(sigCtrl, label, pkt, event);
1111 break;
1112 default:
1113 AvdtMsgSendGeneralRej(sigCtrl, sigId);
1114 break;
1115 }
1116 return;
1117 }
AvdtParseCommonInd(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t label,const Packet * pkt,uint8_t event)1118 void AvdtParseCommonInd(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t label, const Packet *pkt, uint8_t event)
1119 {
1120 if (sigCtrl == NULL) {
1121 return;
1122 }
1123 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1124 uint8_t data = 0;
1125 AvdtEventData msg = {0};
1126 PacketPayloadRead(pkt, &data, 0, AVDT_1BYTE);
1127 uint8_t seid = AvdtIndSeidCheck(sigCtrl, sigId, data);
1128 if (seid == AVDT_SEID_INVLID) {
1129 return;
1130 }
1131 msg.msg.single.seid = seid;
1132 msg.msg.single.label = label;
1133 if (sigId == AVDT_SIG_GET_ALLCAP || sigId == AVDT_SIG_GETCAP) {
1134 AvdtSigProcEvent(sigCtrl, event, &msg);
1135 } else {
1136 AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle((uint16_t)seid);
1137 if (streamCtrl != NULL) {
1138 AvdtStreamProcEvent(streamCtrl, event, &msg);
1139 } else {
1140 LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle failed(%hhu)!", __func__, seid);
1141 AvdtMsg avdtMsgData = {0};
1142 avdtMsgData.single.errCode = AVDT_ERR_BAD_ACP_SEID;
1143 AvdtMsgSendRej(sigCtrl, sigId, &avdtMsgData);
1144 }
1145 }
1146 return;
1147 }
AvdtParseReconfigInd(AvdtSigCtrl * sigCtrl,uint8_t label,const Packet * pkt,uint8_t event)1148 void AvdtParseReconfigInd(AvdtSigCtrl *sigCtrl, uint8_t label, const Packet *pkt, uint8_t event)
1149 {
1150 uint8_t data = 0;
1151 uint16_t Offset = 0;
1152 AvdtEventData msg = {0};
1153 PacketPayloadRead(pkt, &data, Offset, AVDT_1BYTE);
1154 uint8_t seid = AvdtIndSeidCheck(sigCtrl, AVDT_SIG_RECONFIG, data);
1155 if (seid == AVDT_SEID_INVLID) {
1156 return;
1157 }
1158 Offset++;
1159 PacketPayloadRead(pkt, &data, Offset, AVDT_1BYTE);
1160 if (AvdtServiceCapCheck(sigCtrl, AVDT_SIG_RECONFIG, data) != AVDT_SUCCESS) {
1161 return;
1162 }
1163 AvdtParseReconfig(
1164 (uint16_t)seid, pkt, Offset, &msg.msg.reconfigureCmd.hdr.errCode, &msg.msg.reconfigureCmd.hdr.errParam);
1165
1166 if (msg.msg.reconfigureCmd.hdr.errCode != AVDT_SUCCESS) {
1167 AvdtIndReject(
1168 sigCtrl, AVDT_SIG_RECONFIG, msg.msg.reconfigureCmd.hdr.errCode, msg.msg.reconfigureCmd.hdr.errParam);
1169 return;
1170 }
1171 msg.msg.reconfigureCmd.hdr.seid = seid;
1172 msg.msg.reconfigureCmd.hdr.label = label;
1173 AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle((uint16_t)seid);
1174 if (streamCtrl != NULL) {
1175 AvdtStreamProcEvent(streamCtrl, event, &msg);
1176 } else {
1177 LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle failed(%hhu)!", __func__, seid);
1178 AvdtMsg avdtMsgData = {0};
1179 avdtMsgData.reconfigureCmd.hdr.errCode = AVDT_ERR_BAD_ACP_SEID;
1180 AvdtMsgSendRej(sigCtrl, AVDT_SIG_RECONFIG, &avdtMsgData);
1181 }
1182 return;
1183 }
1184
AvdtParseSetconfigInd(AvdtSigCtrl * sigCtrl,uint8_t label,const Packet * pkt,uint8_t event)1185 void AvdtParseSetconfigInd(AvdtSigCtrl *sigCtrl, uint8_t label, const Packet *pkt, uint8_t event)
1186 {
1187 uint8_t data = 0;
1188 uint16_t Offset = 0;
1189 AvdtEventData msg = {0};
1190 PacketPayloadRead(pkt, &data, Offset, AVDT_1BYTE);
1191 uint8_t seid = AvdtIndSeidCheck(sigCtrl, AVDT_SIG_SETCONFIG, data);
1192 if (seid == AVDT_SEID_INVLID) {
1193 return;
1194 }
1195 Offset++;
1196 PacketPayloadRead(pkt, &data, Offset, AVDT_1BYTE);
1197 uint8_t intSeid = AvdtParseSeid(data);
1198 Offset++;
1199 PacketPayloadRead(pkt, &data, Offset, AVDT_1BYTE);
1200 if (AvdtServiceCapCheck(sigCtrl, AVDT_SIG_SETCONFIG, data) != AVDT_SUCCESS) {
1201 return;
1202 }
1203 AvdtParseSetconfig(
1204 (uint16_t)seid, pkt, Offset, &msg.msg.configureCmd.hdr.errCode, &msg.msg.configureCmd.hdr.errParam);
1205 if (msg.msg.configureCmd.hdr.errCode != AVDT_SUCCESS) {
1206 AvdtIndReject(sigCtrl, AVDT_SIG_SETCONFIG, msg.msg.configureCmd.hdr.errCode, msg.msg.configureCmd.hdr.errParam);
1207 return;
1208 }
1209 msg.msg.configureCmd.acpSeid = seid;
1210 msg.msg.configureCmd.intSeid = intSeid;
1211 msg.msg.configureCmd.hdr.label = label;
1212 AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle((uint16_t)seid);
1213 if (streamCtrl != NULL) {
1214 AvdtStreamProcEvent(streamCtrl, event, &msg);
1215 } else {
1216 LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle failed(%hhu)!", __func__, seid);
1217 AvdtMsg avdtMsgData = {0};
1218 avdtMsgData.configureCmd.hdr.errCode = AVDT_ERR_BAD_ACP_SEID;
1219 AvdtMsgSendRej(sigCtrl, AVDT_SIG_SETCONFIG, &avdtMsgData);
1220 }
1221 return;
1222 }
AvdtParseDelayRptInd(AvdtSigCtrl * sigCtrl,uint8_t label,const Packet * pkt,uint8_t event)1223 void AvdtParseDelayRptInd(AvdtSigCtrl *sigCtrl, uint8_t label, const Packet *pkt, uint8_t event)
1224 {
1225 uint8_t data = 0;
1226 uint16_t Offset = 0;
1227 uint8_t maxSB = 0;
1228 uint8_t lowSB = 0;
1229 AvdtEventData msg = {0};
1230 PacketPayloadRead(pkt, &data, Offset, AVDT_1BYTE);
1231 Offset++;
1232 uint8_t seid = AvdtIndSeidCheck(sigCtrl, AVDT_SIG_DELAY_RPT, data);
1233 if (seid == AVDT_SEID_INVLID) {
1234 return;
1235 }
1236 PacketPayloadRead(pkt, &maxSB, Offset, AVDT_1BYTE);
1237 Offset++;
1238 PacketPayloadRead(pkt, &lowSB, Offset, AVDT_1BYTE);
1239 Offset++;
1240 PacketPayloadRead(pkt, &data, Offset, AVDT_1BYTE);
1241 if (AvdtServiceCapCheck(sigCtrl, AVDT_SIG_DELAY_RPT, data) != AVDT_SUCCESS) {
1242 return;
1243 }
1244 msg.msg.delayRptCmd.delay = AvdtParseDelayValue(maxSB, lowSB);
1245 msg.msg.delayRptCmd.hdr.seid = seid;
1246 msg.msg.delayRptCmd.hdr.label = label;
1247 AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle((uint16_t)seid);
1248 if (streamCtrl != NULL) {
1249 AvdtStreamProcEvent(streamCtrl, event, &msg);
1250 } else {
1251 LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle failed(%hhu)!", __func__, seid);
1252 AvdtMsg avdtMsgData = {0};
1253 avdtMsgData.discoverRsp.hdr.errCode = AVDT_ERR_BAD_ACP_SEID;
1254 AvdtMsgSendRej(sigCtrl, AVDT_SIG_DELAY_RPT, &avdtMsgData);
1255 }
1256 return;
1257 }
1258
1259 /**
1260 *
1261 * @brief AvdtGetEventBySigidInd
1262 *
1263 * @details Get event by signalling ID.
1264 *
1265 * @return void
1266 *
1267 */
AvdtGetEventBySigidInd(uint8_t sigId)1268 uint8_t AvdtGetEventBySigidInd(uint8_t sigId)
1269 {
1270 uint8_t event = 0;
1271 switch (sigId) {
1272 case AVDT_SIG_DISCOVER:
1273 event = AVDT_DISCOVER_CMD_IND_EVENT;
1274 break;
1275 case AVDT_SIG_GET_ALLCAP:
1276 event = AVDT_GETALLCAP_CMD_IND_EVENT;
1277 break;
1278 case AVDT_SIG_GETCAP:
1279 event = AVDT_GETCAP_CMD_IND_EVENT;
1280 break;
1281 case AVDT_SIG_OPEN:
1282 event = AVDT_OPEN_CMD_IND_EVENT;
1283 break;
1284 case AVDT_SIG_CLOSE:
1285 event = AVDT_CLOSE_CMD_IND_EVENT;
1286 break;
1287 case AVDT_SIG_GETCONFIG:
1288 event = AVDT_GETCONFIGURE_CMD_IND_EVENT;
1289 break;
1290 case AVDT_SIG_ABORT:
1291 event = AVDT_ABORT_CMD_IND_EVENT;
1292 break;
1293 case AVDT_SIG_START:
1294 event = AVDT_START_CMD_IND_EVENT;
1295 break;
1296 case AVDT_SIG_SUSPEND:
1297 event = AVDT_SUSPEND_CMD_IND_EVENT;
1298 break;
1299 case AVDT_SIG_RECONFIG:
1300 event = AVDT_RECONFIGURE_CMD_IND_EVENT;
1301 break;
1302 case AVDT_SIG_SETCONFIG:
1303 event = AVDT_SETCONFIGURE_CMD_IND_EVENT;
1304 break;
1305 case AVDT_SIG_DELAY_RPT:
1306 event = AVDT_DELAY_CMD_IND_EVENT;
1307 break;
1308 default:
1309 break;
1310 }
1311 return event;
1312 }
1313
1314 /**
1315 *
1316 * @brief AvdtGetEventBySigidCfm
1317 *
1318 * @details Get event by signalling ID.
1319 *
1320 * @return void
1321 *
1322 */
AvdtGetEventBySigidCfm(uint8_t sigId)1323 uint8_t AvdtGetEventBySigidCfm(uint8_t sigId)
1324 {
1325 uint8_t event = 0;
1326 switch (sigId) {
1327 case AVDT_SIG_DISCOVER:
1328 event = AVDT_DISCOVER_CMD_CFM_EVENT;
1329 break;
1330 case AVDT_SIG_GET_ALLCAP:
1331 event = AVDT_GETALLCAP_CMD_CFM_EVENT;
1332 break;
1333 case AVDT_SIG_GETCAP:
1334 event = AVDT_GETCAP_CMD_CFM_EVENT;
1335 break;
1336 case AVDT_SIG_OPEN:
1337 event = AVDT_OPEN_CMD_CFM_EVENT;
1338 break;
1339 case AVDT_SIG_CLOSE:
1340 event = AVDT_CLOSE_CMD_CFM_EVENT;
1341 break;
1342 case AVDT_SIG_GETCONFIG:
1343 event = AVDT_GETCONFIGURE_CMD_CFM_EVENT;
1344 break;
1345 case AVDT_SIG_ABORT:
1346 event = AVDT_ABORT_CMD_CFM_EVENT;
1347 break;
1348 case AVDT_SIG_START:
1349 event = AVDT_START_CMD_CFM_EVENT;
1350 break;
1351 case AVDT_SIG_SUSPEND:
1352 event = AVDT_SUSPEND_CMD_CFM_EVENT;
1353 break;
1354 case AVDT_SIG_RECONFIG:
1355 event = AVDT_RECONFIGURE_CMD_CFM_EVENT;
1356 break;
1357 case AVDT_SIG_SETCONFIG:
1358 event = AVDT_SETCONFIGURE_CMD_CFM_EVENT;
1359 break;
1360 case AVDT_SIG_DELAY_RPT:
1361 event = AVDT_DELAY_CMD_CFM_EVENT;
1362 break;
1363 default:
1364 break;
1365 }
1366 return event;
1367 }
1368
1369 /**
1370 *
1371 * @brief AvdtParseSignalRsp
1372 *
1373 * @details Parse the respond content from the message of remote peer.
1374 * Trigger the callback matched of A2DP profile.
1375 *
1376 * @return void
1377 *
1378 ******************************************************************************/
AvdtParseSignalRsp(AvdtSigCtrl * sigCtrl,uint8_t sigId,const Packet * pkt)1379 void AvdtParseSignalRsp(AvdtSigCtrl *sigCtrl, uint8_t sigId, const Packet *pkt)
1380 {
1381 if (sigCtrl == NULL) {
1382 return;
1383 }
1384 LOG_DEBUG("[AVDT]%{public}s:sendLabel(%hhu) ReceiveLabel(%hhu),sigId(%hhu)",
1385 __func__, sigCtrl->label, sigCtrl->rcvLabel, sigId);
1386 bool isSigType = false;
1387 uint8_t stEvent = AvdtGetEventBySigidCfm(sigId);
1388 AvdtEventData data = {0};
1389 switch (sigId) {
1390 case AVDT_SIG_DISCOVER:
1391 AvdtParseDiscoverRsp(sigCtrl, &data.ctrlData, pkt);
1392 isSigType = true;
1393 break;
1394 case AVDT_SIG_GET_ALLCAP:
1395 case AVDT_SIG_GETCAP:
1396 AvdtParseGetCapRsp(&data.ctrlData, pkt);
1397 isSigType = true;
1398 break;
1399 case AVDT_SIG_GETCONFIG:
1400 AvdtParseGetConfigRsp(&data.ctrlData, pkt);
1401 break;
1402 case AVDT_SIG_OPEN:
1403 case AVDT_SIG_CLOSE:
1404 case AVDT_SIG_ABORT:
1405 case AVDT_SIG_START:
1406 case AVDT_SIG_SUSPEND:
1407 case AVDT_SIG_RECONFIG:
1408 case AVDT_SIG_SETCONFIG:
1409 case AVDT_SIG_DELAY_RPT:
1410 break;
1411 default:
1412 LOG_ERROR("[AVDT]%{public}s:The Bad signal id(0x%x)", __func__, sigId);
1413 return;
1414 }
1415 if (isSigType) {
1416 AvdtSigProcEvent(sigCtrl, stEvent, &data);
1417 } else {
1418 AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle(sigCtrl->streamHandle);
1419 if (streamCtrl != NULL) {
1420 AvdtStreamProcEvent(streamCtrl, stEvent, &data);
1421 } else {
1422 LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle(%hu) Failed!", __func__, sigCtrl->streamHandle);
1423 }
1424 }
1425 return;
1426 }
1427
1428 /**
1429 *
1430 * @brief AvdtParseSignalRej
1431 *
1432 * @details Parse and dispatch the reject respond .
1433 *
1434 * @return void
1435 *
1436 ******************************************************************************/
AvdtParseSignalRej(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t label,Packet * pkt)1437 void AvdtParseSignalRej(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t label, Packet *pkt)
1438 {
1439 uint8_t data = 0;
1440 uint8_t errCode = 0;
1441 uint8_t stEvent = AvdtGetEventBySigidCfm(sigId);
1442 switch (sigId) {
1443 case AVDT_SIG_DISCOVER:
1444 case AVDT_SIG_GET_ALLCAP:
1445 case AVDT_SIG_GETCAP:
1446 case AVDT_SIG_GETCONFIG:
1447 case AVDT_SIG_OPEN:
1448 case AVDT_SIG_CLOSE:
1449 PacketExtractHead(pkt, &errCode, AVDT_1BYTE); /* Read first octet message */
1450 break;
1451 case AVDT_SIG_SUSPEND:
1452 case AVDT_SIG_START:
1453 case AVDT_SIG_RECONFIG:
1454 case AVDT_SIG_SETCONFIG:
1455 PacketExtractHead(pkt, &data, AVDT_1BYTE); /* Read first octet message */
1456 PacketExtractHead(pkt, &errCode, AVDT_1BYTE); /* Read second octet message */
1457 break;
1458 default:
1459 break;
1460 }
1461 LOG_DEBUG("[AVDT]%{public}s: sigId(%hhu) errCode(0x%x) categoryOrSeid(%hhu)", __func__, sigId, errCode, data);
1462 /* Do nothing, the timer of a2dp will be triggered */
1463 if (stEvent == AVDT_RECONFIGURE_CMD_CFM_EVENT) {
1464 AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle(sigCtrl->streamHandle);
1465 if (streamCtrl != NULL) {
1466 AvdtEventData eventData = {0};
1467 eventData.errCode = errCode;
1468 AvdtStreamProcEvent(streamCtrl, stEvent, &eventData);
1469 } else {
1470 LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle(%hu) Failed!", __func__, sigCtrl->streamHandle);
1471 }
1472 }
1473 return;
1474 }
1475
1476 /**
1477 *
1478 * @brief AvdtSignalGeneralRej
1479 *
1480 * @details ACP check the signalling is out of scope.
1481 * Then call this @brief to reject the require of remote peer.
1482 *
1483 * @return void
1484 *
1485 */
AvdtSignalGeneralRej(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t label)1486 void AvdtSignalGeneralRej(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t label)
1487 {
1488 if (sigCtrl == NULL) {
1489 return;
1490 }
1491 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1492 Packet *pkt = PacketMalloc(AVDT_BUFFER_SINGLE, 0, AVDT_BUFFER_CMD_MAX);
1493 Buffer *msgHeader = PacketHead(pkt);
1494 uint8_t *p = BufferPtr(msgHeader);
1495 AvdtBuildSingleHeader(p, sigCtrl->label, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_GRJ);
1496 AvdtBuildSignal(p + 1, sigId);
1497 sigCtrl->currentMsg = pkt;
1498 AvdtSigProcEvent(sigCtrl, AVDT_SND_MSG_EVENT, NULL);
1499 return;
1500 }
1501
1502 /**
1503 *
1504 * @brief AvdtParseGetCapRsp
1505 *
1506 * @details Parse the respond of get capability.
1507 *
1508 * @return void
1509 *
1510 */
AvdtParseGetCapRsp(AvdtCtrlData * data,const Packet * pkt)1511 void AvdtParseGetCapRsp(AvdtCtrlData *data, const Packet *pkt)
1512 {
1513 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1514 AvdtParseCategory(data, pkt);
1515 return;
1516 }
1517
1518 /**
1519 *
1520 * @brief AvdtParseGetConfigRsp
1521 *
1522 * @details Parse the respond of getconfigure.
1523 *
1524 * @return void
1525 *
1526 */
AvdtParseGetConfigRsp(AvdtCtrlData * data,const Packet * pkt)1527 void AvdtParseGetConfigRsp(AvdtCtrlData *data, const Packet *pkt)
1528 {
1529 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1530 AvdtParseCategory(data, pkt);
1531 return;
1532 }
1533
1534 /**
1535 *
1536 * @brief AvdtParseCategory
1537 *
1538 * @details Parse the category.
1539 *
1540 * @return void
1541 *
1542 */
AvdtParseCategory(AvdtCtrlData * data,const Packet * pkt)1543 void AvdtParseCategory(AvdtCtrlData *data, const Packet *pkt)
1544 {
1545 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1546 if (data == NULL) {
1547 return;
1548 }
1549 uint16_t TotalSize = PacketSize(pkt);
1550 uint16_t Len = TotalSize;
1551 uint16_t Offset = 0;
1552 uint8_t context = 0;
1553 uint8_t tmp;
1554 uint8_t count;
1555 do {
1556 PacketPayloadRead(pkt, &context, Offset, AVDT_1BYTE);
1557 Offset++;
1558 Len--;
1559 /* parse */
1560 switch (context) {
1561 case AVDT_PSC_TRANS: {
1562 count = AvdtParseCategoryTrans(&data->getconfigCfm.cfg, pkt, Offset, &tmp);
1563 break;
1564 }
1565 case AVDT_PSC_CODEC: {
1566 /* read codec parameter length */
1567 count = AvdtParseCategoryCodec(&data->getconfigCfm.cfg, pkt, Offset);
1568 break;
1569 }
1570 case AVDT_PSC_DELAY_RPT: {
1571 count = AvdtParseCategoryDelay(&data->getconfigCfm.cfg, pkt, Offset, &tmp);
1572 break;
1573 }
1574 default: {
1575 LOG_WARN("[AVDT]%{public}s: The category(0x%x) is not surport now!", __func__, context);
1576 count = AvdtParseCategorySkip(pkt, Offset);
1577 break;
1578 }
1579 }
1580 Offset += count;
1581 Len -= count;
1582 } while (Len > 0 && TotalSize > Offset);
1583 LOG_DEBUG("[AVDT]%{public}s:data->getconfigCfm.cfg.pscMask is (0x%x)", __func__, data->getconfigCfm.cfg.pscMask);
1584 return;
1585 }
1586
1587 /**
1588 *
1589 * @brief AvdtParseDiscoverRsp
1590 *
1591 * @details Parse the respond of discover.
1592 *
1593 * @return void
1594 *
1595 */
AvdtParseDiscoverRsp(AvdtSigCtrl * sigCtrl,AvdtCtrlData * data,const Packet * pkt)1596 void AvdtParseDiscoverRsp(AvdtSigCtrl *sigCtrl, AvdtCtrlData *data, const Packet *pkt)
1597 {
1598 if (sigCtrl == NULL || data == NULL) {
1599 return;
1600 }
1601 uint16_t TotalSize = PacketSize(pkt);
1602 uint16_t Len = TotalSize;
1603 uint8_t maxNumSeps = sigCtrl->procParam;
1604 uint16_t Offset = 0;
1605 uint8_t context = 0;
1606 uint8_t index = 0;
1607
1608 LOG_DEBUG("[AVDT]%{public}s: totalSize(%hu)", __func__, TotalSize);
1609 if (maxNumSeps == 0) {
1610 return;
1611 }
1612 do {
1613 (void)memset_s(&data->discoverCfm.seps[index], sizeof(AvdtSepInfo), 0, sizeof(AvdtSepInfo));
1614 PacketPayloadRead(pkt, &context, Offset, AVDT_1BYTE);
1615 Offset++;
1616 Len--;
1617 data->discoverCfm.seps[index].isUsed = (bool)(context & 0x02);
1618 data->discoverCfm.seps[index].seid = (context >> AVDT_OFFSET_2BIT);
1619 context = 0;
1620 PacketPayloadRead(pkt, &context, Offset, AVDT_1BYTE);
1621 Offset++;
1622 Len--;
1623 data->discoverCfm.seps[index].mediaType = (context >> AVDT_OFFSET_4BIT);
1624 data->discoverCfm.seps[index].sepType = ((context & 0x08) >> AVDT_OFFSET_3BIT);
1625 context = 0;
1626 maxNumSeps--;
1627 LOG_DEBUG("[AVDT]%{public}s: sigCtrl->role(%hhu) seps[index].sepType(%hhu) acpid(%hhu) "
1628 "mediaType(%hhu) index(%hhu) maxNumSeps(%hhu)",
1629 __func__,
1630 sigCtrl->role,
1631 data->discoverCfm.seps[index].sepType,
1632 data->discoverCfm.seps[index].seid,
1633 data->discoverCfm.seps[index].mediaType,
1634 index,
1635 maxNumSeps);
1636 if (sigCtrl->role != data->discoverCfm.seps[index].sepType && (data->discoverCfm.seps[index].seid > 0)) {
1637 index++;
1638 }
1639 } while (Len > 0 && maxNumSeps > 0 && TotalSize > Offset);
1640 data->discoverCfm.numSeps = index;
1641 return;
1642 }
1643
1644 /**
1645 *
1646 * @brief AvdtParseGetConfigRsp
1647 *
1648 * @details Parse the respond of getconfigure.
1649 *
1650 * @return void
1651 *
1652 */
AvdtParseSeid(uint8_t data)1653 uint8_t AvdtParseSeid(uint8_t data)
1654 {
1655 uint8_t seid = ((data >> AVDT_OFFSET_2BIT) & 0x3F);
1656 if (seid < AVDT_SEID_MIN || seid > AVDT_SEID_MAX) {
1657 seid = AVDT_SEID_INVLID;
1658 }
1659 LOG_DEBUG("[AVDT]%{public}s: seid(0x%x)", __func__, seid);
1660 return seid;
1661 }
1662
1663 /**
1664 *
1665 * @brief AvdtParseDelayValue
1666 *
1667 * @details Parse the delay value from message.
1668 *
1669 * @return delay value
1670 *
1671 */
AvdtParseDelayValue(uint8_t maxSB,uint8_t lowSB)1672 uint16_t AvdtParseDelayValue(uint8_t maxSB, uint8_t lowSB)
1673 {
1674 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1675 uint16_t Value = (uint16_t)((maxSB << AVDT_OFFSET_8BIT) | lowSB);
1676 return Value;
1677 }
1678
1679 /**
1680 *
1681 * @brief AvdtParseSetconfig
1682 *
1683 * @details Parse the content of setconfig. *
1684 *
1685 * @return 0:sccusse /other errcode
1686 *
1687 */
AvdtParseSetconfig(uint16_t streamHandle,const Packet * pkt,uint16_t off,uint8_t * errCode,uint8_t * errParam)1688 void AvdtParseSetconfig(uint16_t streamHandle, const Packet *pkt, uint16_t off, uint8_t *errCode, uint8_t *errParam)
1689 {
1690 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1691 uint16_t TotalSize = PacketSize(pkt);
1692 uint16_t Len = TotalSize;
1693 uint8_t data = 0;
1694 uint16_t Offset = off;
1695 uint8_t tmp;
1696 uint8_t count;
1697 AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle(streamHandle);
1698 if (streamCtrl == NULL) {
1699 LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle Failed", __func__);
1700 return;
1701 }
1702 do {
1703 PacketPayloadRead(pkt, &data, Offset, AVDT_1BYTE);
1704 Offset++;
1705 Len--;
1706 switch (data) {
1707 case AVDT_PSC_TRANS: {
1708 count = AvdtParseCategoryTrans(&streamCtrl->reqCfg, pkt, Offset, &tmp);
1709 if (tmp != 0) {
1710 *errCode = AVDT_ERR_BAD_MEDIA_TRANSPORT_FORMAT;
1711 *errParam = AVDT_PSC_TRANS;
1712 return;
1713 }
1714 break;
1715 }
1716 case AVDT_PSC_CODEC: {
1717 count = AvdtParseCategoryCodec(&streamCtrl->reqCfg, pkt, Offset);
1718 break;
1719 }
1720 case AVDT_PSC_DELAY_RPT: {
1721 count = AvdtParseCategoryDelay(&streamCtrl->reqCfg, pkt, Offset, &tmp);
1722 break;
1723 }
1724 default:
1725 LOG_ERROR("[AVDT]%{public}s: The category(0x%x) is not surport now!", __func__, data);
1726 *errCode = AVDT_ERR_INVALID_CAPABILITIES;
1727 *errParam = data;
1728 return;
1729 }
1730 Offset += count;
1731 Len -= count;
1732 } while (Len > 0 && TotalSize > Offset);
1733 return;
1734 }
1735
1736 /**
1737 *
1738 * @brief AvdtParseCategoryCodec
1739 *
1740 * @details Parse the codec content of setconfig.
1741 *
1742 * @return read data length
1743 *
1744 */
AvdtParseCategoryCodec(AvdtSepConfig * sepConfig,const Packet * pkt,uint16_t offset)1745 uint8_t AvdtParseCategoryCodec(AvdtSepConfig *sepConfig, const Packet *pkt, uint16_t offset)
1746 {
1747 if (sepConfig == NULL) {
1748 return 0;
1749 }
1750 uint8_t data = 0;
1751 uint8_t length = 0;
1752 PacketPayloadRead(pkt, &data, offset, AVDT_1BYTE);
1753
1754 /* now only surport sbc/aac */
1755 if (data > AVDT_CODEC_SIZE) {
1756 data = AVDT_CODEC_SIZE;
1757 }
1758 offset++;
1759 length++;
1760 sepConfig->codecInfo[0] = data;
1761 PacketPayloadRead(pkt, &(sepConfig->codecInfo[1]), offset, data);
1762 sepConfig->numCodec = data;
1763 offset += data;
1764 length += data;
1765 sepConfig->pscMask = (sepConfig->pscMask | AVDT_PSC_MSK_CODEC);
1766 LOG_DEBUG("[AVDT]%{public}s:offset=%{public}d,length=%{public}d", __func__, offset, length);
1767 return length;
1768 }
1769 /**
1770 *
1771 * @brief AvdtParseCategoryTrans
1772 *
1773 * @details Parse the trans media content of setconfig.
1774 *
1775 * @return read data length
1776 *
1777 */
AvdtParseCategoryTrans(AvdtSepConfig * sepConfig,const Packet * pkt,uint16_t offset,uint8_t * data)1778 uint8_t AvdtParseCategoryTrans(AvdtSepConfig *sepConfig, const Packet *pkt, uint16_t offset, uint8_t *data)
1779 {
1780 if (sepConfig == NULL) {
1781 return 0;
1782 }
1783 uint8_t length = 0;
1784 PacketPayloadRead(pkt, data, offset, AVDT_1BYTE);
1785 length++;
1786 sepConfig->pscMask = (sepConfig->pscMask | AVDT_PSC_MSK_TRANS);
1787 return length;
1788 }
1789 /**
1790 *
1791 * @brief AvdtParseCategoryDelay
1792 *
1793 * @details Parse the delay report content of setconfig.
1794 *
1795 * @return read data length
1796 *
1797 */
AvdtParseCategoryDelay(AvdtSepConfig * sepConfig,const Packet * pkt,uint16_t offset,uint8_t * data)1798 uint8_t AvdtParseCategoryDelay(AvdtSepConfig *sepConfig, const Packet *pkt, uint16_t offset, uint8_t *data)
1799 {
1800 if (sepConfig == NULL) {
1801 return 0;
1802 }
1803 uint8_t length = 0;
1804 PacketPayloadRead(pkt, data, offset, AVDT_1BYTE);
1805 length++;
1806 sepConfig->pscMask = (sepConfig->pscMask | AVDT_PSC_MSK_DELAY_RPT);
1807 return length;
1808 }
1809 /**
1810 *
1811 * @brief AvdtParseCategorySkip
1812 *
1813 * @details Skip unsurport type content of setconfig.
1814 *
1815 * @return read data length
1816 *
1817 */
AvdtParseCategorySkip(const Packet * pkt,uint16_t offset)1818 uint8_t AvdtParseCategorySkip(const Packet *pkt, uint16_t offset)
1819 {
1820 uint8_t data = 0;
1821 PacketPayloadRead(pkt, &data, offset, AVDT_1BYTE);
1822 uint8_t length = data + 1;
1823 return length;
1824 }
1825 /**
1826 *
1827 * @brief AvdtParseReconfig
1828 *
1829 * @details Parse the content of reconfig.
1830 *
1831 * @return void
1832 *
1833 */
AvdtParseReconfig(uint16_t streamHandle,const Packet * pkt,uint16_t off,uint8_t * errCode,uint8_t * errParam)1834 void AvdtParseReconfig(uint16_t streamHandle, const Packet *pkt, uint16_t off, uint8_t *errCode, uint8_t *errParam)
1835 {
1836 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1837 uint16_t TotalSize = PacketSize(pkt);
1838 uint16_t Len = TotalSize;
1839 uint16_t Offset = off;
1840 uint8_t data = 0;
1841 uint8_t tmp;
1842 uint8_t count;
1843 AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle(streamHandle);
1844 if (streamCtrl == NULL) {
1845 LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle Failed", __func__);
1846 return;
1847 }
1848 do {
1849 PacketPayloadRead(pkt, &data, Offset, AVDT_1BYTE);
1850 Offset++;
1851 Len--;
1852 switch (data) {
1853 case AVDT_PSC_TRANS: {
1854 count = AvdtParseCategoryTrans(&streamCtrl->reqCfg, pkt, Offset, &tmp);
1855 if (tmp != 0) {
1856 *errCode = AVDT_ERR_BAD_MEDIA_TRANSPORT_FORMAT;
1857 *errParam = AVDT_PSC_TRANS;
1858 return;
1859 }
1860 break;
1861 }
1862 case AVDT_PSC_CODEC: {
1863 count = AvdtParseCategoryCodec(&streamCtrl->reqCfg, pkt, Offset);
1864 break;
1865 }
1866 default:
1867 LOG_ERROR("[AVDT]%{public}s: The category(0x%x) is not surport now!", __func__, data);
1868 *errCode = AVDT_ERR_INVALID_CAPABILITIES;
1869 *errParam = data;
1870 return;
1871 }
1872 Offset += count;
1873 Len -= count;
1874 } while (Len > 0 && TotalSize > Offset);
1875 LOG_DEBUG("[AVDT]%{public}s:data->getCapCfm.cfg.pscMask is (0x%x)", __func__, streamCtrl->reqCfg.pscMask);
1876 return;
1877 }
1878
1879 /**
1880 *
1881 * @brief AvdtIndPktLenCheck
1882 *
1883 * @details Check packet length is valid for ind command.
1884 *
1885 * @return valid：0 / invalid: other
1886 *
1887 */
AvdtIndPktLenCheck(AvdtSigCtrl * sigCtrl,uint8_t sigId,const Packet * pkt)1888 uint8_t AvdtIndPktLenCheck(AvdtSigCtrl *sigCtrl, uint8_t sigId, const Packet *pkt)
1889 {
1890 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1891 uint8_t Ret = AVDT_SUCCESS;
1892 uint16_t Len = PacketSize(pkt);
1893 switch (sigId) {
1894 case AVDT_SIG_DISCOVER:
1895 break;
1896 case AVDT_SIG_GET_ALLCAP:
1897 case AVDT_SIG_GETCAP:
1898 case AVDT_SIG_GETCONFIG:
1899 case AVDT_SIG_RECONFIG:
1900 case AVDT_SIG_OPEN:
1901 case AVDT_SIG_CLOSE:
1902 case AVDT_SIG_ABORT:
1903 case AVDT_SIG_START:
1904 case AVDT_SIG_SUSPEND:
1905 if (Len < AVDT_SIG_LENGTH_COMM) {
1906 Ret = AVDT_BAD_PARAMS;
1907 }
1908 break;
1909 case AVDT_SIG_SETCONFIG:
1910 if (Len < AVDT_SIG_LENGTH_SETCONFIG) {
1911 Ret = AVDT_BAD_PARAMS;
1912 }
1913 break;
1914 case AVDT_SIG_DELAY_RPT:
1915 if (Len < AVDT_SIG_LENGTH_DELAY_RPT) {
1916 Ret = AVDT_BAD_PARAMS;
1917 }
1918 break;
1919 default:
1920 break;
1921 }
1922 if (Ret != AVDT_SUCCESS) {
1923 LOG_ERROR("[AVDT]%{public}s:BAD LENGTH of the cmd!", __func__);
1924 AvdtIndReject(sigCtrl, sigId, AVDT_ERR_BAD_LENGTH, 0);
1925 }
1926 return Ret;
1927 }
1928
1929 /**
1930 *
1931 * @brief AvdtIndSeidCheck
1932 *
1933 * @details Check se id is valid for ind command.
1934 *
1935 * @return valid：id / invalid: AVDT_SEID_INVLID
1936 *
1937 */
AvdtIndSeidCheck(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t data)1938 uint8_t AvdtIndSeidCheck(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t data)
1939 {
1940 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1941 uint8_t seid = AVDT_SEID_INVLID;
1942 switch (sigId) {
1943 case AVDT_SIG_DISCOVER:
1944 break;
1945 case AVDT_SIG_GET_ALLCAP:
1946 case AVDT_SIG_GETCAP:
1947 case AVDT_SIG_OPEN:
1948 case AVDT_SIG_CLOSE:
1949 case AVDT_SIG_GETCONFIG:
1950 case AVDT_SIG_ABORT:
1951 case AVDT_SIG_START:
1952 case AVDT_SIG_SUSPEND:
1953 case AVDT_SIG_RECONFIG:
1954 case AVDT_SIG_SETCONFIG:
1955 case AVDT_SIG_DELAY_RPT:
1956 seid = AvdtParseSeid(data);
1957 if (seid == AVDT_SEID_INVLID) {
1958 LOG_ERROR("[AVDT]%{public}s:BAD SEID of the cmd!", __func__);
1959 AvdtIndReject(sigCtrl, sigId, AVDT_ERR_BAD_ACP_SEID, 0);
1960 } else {
1961 AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle((uint16_t)seid);
1962 if (streamCtrl == NULL) {
1963 LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle failed(%hhu)!", __func__, seid);
1964 AvdtIndReject(sigCtrl, sigId, AVDT_ERR_BAD_ACP_SEID, 0);
1965 seid = AVDT_SEID_INVLID;
1966 }
1967 }
1968 break;
1969 default:
1970 break;
1971 }
1972 return seid;
1973 }
1974
1975 /**
1976 *
1977 * @brief AvdtMakeRejMsg
1978 *
1979 * @details Make reject message for received signal.
1980 *
1981 * @return valid：id / invalid: AVDT_SEID_INVLID
1982 *
1983 */
AvdtMakeRejMsg(uint8_t sigId,uint8_t errCode,uint8_t errParam,AvdtMsg * msg)1984 void AvdtMakeRejMsg(uint8_t sigId, uint8_t errCode, uint8_t errParam, AvdtMsg *msg)
1985 {
1986 LOG_DEBUG("[AVDT]%{public}s:", __func__);
1987 switch (sigId) {
1988 case AVDT_SIG_DISCOVER:
1989 break;
1990 case AVDT_SIG_GETCONFIG:
1991 case AVDT_SIG_OPEN:
1992 case AVDT_SIG_CLOSE:
1993 case AVDT_SIG_ABORT:
1994 case AVDT_SIG_START:
1995 case AVDT_SIG_SUSPEND:
1996 msg->single.errCode = errCode;
1997 msg->single.errParam = errParam;
1998 break;
1999 case AVDT_SIG_GETCAP:
2000 case AVDT_SIG_GET_ALLCAP:
2001 msg->getcap.single.errCode = errCode;
2002 msg->getcap.single.errParam = errParam;
2003 break;
2004 case AVDT_SIG_SETCONFIG:
2005 msg->configureCmd.hdr.errCode = errCode;
2006 msg->configureCmd.hdr.errParam = errParam;
2007 break;
2008 case AVDT_SIG_RECONFIG:
2009 msg->reconfigureCmd.hdr.errCode = errCode;
2010 msg->reconfigureCmd.hdr.errParam = errParam;
2011 break;
2012 case AVDT_SIG_DELAY_RPT:
2013 msg->delayRptCmd.hdr.errCode = errCode;
2014 msg->delayRptCmd.hdr.errParam = errParam;
2015 break;
2016 default:
2017 break;
2018 }
2019 return;
2020 }
2021
2022 /**
2023 *
2024 * @brief AvdtServiceCapCheck
2025 *
2026 * @details Service capabilities valid check.
2027 *
2028 * @return valid：0 / invalid: other
2029 *
2030 */
AvdtServiceCapCheck(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t data)2031 uint8_t AvdtServiceCapCheck(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t data)
2032 {
2033 LOG_DEBUG("[AVDT]%{public}s:", __func__);
2034 uint8_t Ret = AVDT_SUCCESS;
2035 uint8_t err = 0;
2036 if (data > AVDT_PSC_MAX_CUR) {
2037 err = AVDT_ERR_BAD_SERV_CATEGORY;
2038 } else if (sigId == AVDT_SIG_RECONFIG && data != AVDT_PSC_CODEC) {
2039 err = AVDT_ERR_INVALID_CAPABILITIES;
2040 } else if ((data != AVDT_PSC_TRANS) && (data != AVDT_PSC_CODEC) && (data != AVDT_PSC_DELAY_RPT)
2041 && (data != AVDT_PSC_PROTECT)) {
2042 err = AVDT_ERR_INVALID_CAPABILITIES;
2043 }
2044 if (err != 0) {
2045 LOG_ERROR("[AVDT]%{public}s:BAD Service Category of the cmd(0x%x)!", __func__, sigId);
2046 AvdtIndReject(sigCtrl, sigId, err, data);
2047 Ret = AVDT_BAD_PARAMS;
2048 }
2049 return Ret;
2050 }
2051
2052 /**
2053 *
2054 * @brief AvdtIndReject
2055 *
2056 * @details Send reject message by signal.
2057 *
2058 * @return void
2059 *
2060 */
AvdtIndReject(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t errCode,uint8_t errParam)2061 void AvdtIndReject(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t errCode, uint8_t errParam)
2062 {
2063 LOG_DEBUG("[AVDT]%{public}s:", __func__);
2064 AvdtMsg avdtMsgData = {0};
2065 AvdtMakeRejMsg(sigId, errCode, errParam, &avdtMsgData);
2066 AvdtMsgSendRej(sigCtrl, sigId, &avdtMsgData);
2067 return;
2068 }
2069