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     msg.msg.delayRptCmd.delay = AvdtParseDelayValue(maxSB, lowSB);
1240     msg.msg.delayRptCmd.hdr.seid = seid;
1241     msg.msg.delayRptCmd.hdr.label = label;
1242     AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle((uint16_t)seid);
1243     if (streamCtrl != NULL) {
1244         AvdtStreamProcEvent(streamCtrl, event, &msg);
1245     } else {
1246         LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle failed(%hhu)!", __func__, seid);
1247         AvdtMsg avdtMsgData = {0};
1248         avdtMsgData.discoverRsp.hdr.errCode = AVDT_ERR_BAD_ACP_SEID;
1249         AvdtMsgSendRej(sigCtrl, AVDT_SIG_DELAY_RPT, &avdtMsgData);
1250     }
1251     return;
1252 }
1253 
1254 /**
1255  *
1256  * @brief        AvdtGetEventBySigidInd
1257  *
1258  * @details      Get event by signalling ID.
1259  *
1260  * @return       void
1261  *
1262  */
AvdtGetEventBySigidInd(uint8_t sigId)1263 uint8_t AvdtGetEventBySigidInd(uint8_t sigId)
1264 {
1265     uint8_t event = 0;
1266     switch (sigId) {
1267         case AVDT_SIG_DISCOVER:
1268             event = AVDT_DISCOVER_CMD_IND_EVENT;
1269             break;
1270         case AVDT_SIG_GET_ALLCAP:
1271             event = AVDT_GETALLCAP_CMD_IND_EVENT;
1272             break;
1273         case AVDT_SIG_GETCAP:
1274             event = AVDT_GETCAP_CMD_IND_EVENT;
1275             break;
1276         case AVDT_SIG_OPEN:
1277             event = AVDT_OPEN_CMD_IND_EVENT;
1278             break;
1279         case AVDT_SIG_CLOSE:
1280             event = AVDT_CLOSE_CMD_IND_EVENT;
1281             break;
1282         case AVDT_SIG_GETCONFIG:
1283             event = AVDT_GETCONFIGURE_CMD_IND_EVENT;
1284             break;
1285         case AVDT_SIG_ABORT:
1286             event = AVDT_ABORT_CMD_IND_EVENT;
1287             break;
1288         case AVDT_SIG_START:
1289             event = AVDT_START_CMD_IND_EVENT;
1290             break;
1291         case AVDT_SIG_SUSPEND:
1292             event = AVDT_SUSPEND_CMD_IND_EVENT;
1293             break;
1294         case AVDT_SIG_RECONFIG:
1295             event = AVDT_RECONFIGURE_CMD_IND_EVENT;
1296             break;
1297         case AVDT_SIG_SETCONFIG:
1298             event = AVDT_SETCONFIGURE_CMD_IND_EVENT;
1299             break;
1300         case AVDT_SIG_DELAY_RPT:
1301             event = AVDT_DELAY_CMD_IND_EVENT;
1302             break;
1303         default:
1304             break;
1305     }
1306     return event;
1307 }
1308 
1309 /**
1310  *
1311  * @brief        AvdtGetEventBySigidCfm
1312  *
1313  * @details      Get event by signalling ID.
1314  *
1315  * @return       void
1316  *
1317  */
AvdtGetEventBySigidCfm(uint8_t sigId)1318 uint8_t AvdtGetEventBySigidCfm(uint8_t sigId)
1319 {
1320     uint8_t event = 0;
1321     switch (sigId) {
1322         case AVDT_SIG_DISCOVER:
1323             event = AVDT_DISCOVER_CMD_CFM_EVENT;
1324             break;
1325         case AVDT_SIG_GET_ALLCAP:
1326             event = AVDT_GETALLCAP_CMD_CFM_EVENT;
1327             break;
1328         case AVDT_SIG_GETCAP:
1329             event = AVDT_GETCAP_CMD_CFM_EVENT;
1330             break;
1331         case AVDT_SIG_OPEN:
1332             event = AVDT_OPEN_CMD_CFM_EVENT;
1333             break;
1334         case AVDT_SIG_CLOSE:
1335             event = AVDT_CLOSE_CMD_CFM_EVENT;
1336             break;
1337         case AVDT_SIG_GETCONFIG:
1338             event = AVDT_GETCONFIGURE_CMD_CFM_EVENT;
1339             break;
1340         case AVDT_SIG_ABORT:
1341             event = AVDT_ABORT_CMD_CFM_EVENT;
1342             break;
1343         case AVDT_SIG_START:
1344             event = AVDT_START_CMD_CFM_EVENT;
1345             break;
1346         case AVDT_SIG_SUSPEND:
1347             event = AVDT_SUSPEND_CMD_CFM_EVENT;
1348             break;
1349         case AVDT_SIG_RECONFIG:
1350             event = AVDT_RECONFIGURE_CMD_CFM_EVENT;
1351             break;
1352         case AVDT_SIG_SETCONFIG:
1353             event = AVDT_SETCONFIGURE_CMD_CFM_EVENT;
1354             break;
1355         case AVDT_SIG_DELAY_RPT:
1356             event = AVDT_DELAY_CMD_CFM_EVENT;
1357             break;
1358         default:
1359             break;
1360     }
1361     return event;
1362 }
1363 
1364 /**
1365  *
1366  * @brief        AvdtParseSignalRsp
1367  *
1368  * @details      Parse the respond content from the message of remote peer.
1369  *               Trigger the callback matched of A2DP profile.
1370  *
1371  * @return       void
1372  *
1373  ******************************************************************************/
AvdtParseSignalRsp(AvdtSigCtrl * sigCtrl,uint8_t sigId,const Packet * pkt)1374 void AvdtParseSignalRsp(AvdtSigCtrl *sigCtrl, uint8_t sigId, const Packet *pkt)
1375 {
1376     if (sigCtrl == NULL) {
1377         return;
1378     }
1379     LOG_DEBUG("[AVDT]%{public}s:sendLabel(%hhu) ReceiveLabel(%hhu),sigId(%hhu)",
1380         __func__, sigCtrl->label, sigCtrl->rcvLabel, sigId);
1381     bool isSigType = false;
1382     uint8_t stEvent = AvdtGetEventBySigidCfm(sigId);
1383     AvdtEventData data = {0};
1384     switch (sigId) {
1385         case AVDT_SIG_DISCOVER:
1386             AvdtParseDiscoverRsp(sigCtrl, &data.ctrlData, pkt);
1387             isSigType = true;
1388             break;
1389         case AVDT_SIG_GET_ALLCAP:
1390         case AVDT_SIG_GETCAP:
1391             AvdtParseGetCapRsp(&data.ctrlData, pkt);
1392             isSigType = true;
1393             break;
1394         case AVDT_SIG_GETCONFIG:
1395             AvdtParseGetConfigRsp(&data.ctrlData, pkt);
1396             break;
1397         case AVDT_SIG_OPEN:
1398         case AVDT_SIG_CLOSE:
1399         case AVDT_SIG_ABORT:
1400         case AVDT_SIG_START:
1401         case AVDT_SIG_SUSPEND:
1402         case AVDT_SIG_RECONFIG:
1403         case AVDT_SIG_SETCONFIG:
1404         case AVDT_SIG_DELAY_RPT:
1405             break;
1406         default:
1407             LOG_ERROR("[AVDT]%{public}s:The Bad signal id(0x%x)", __func__, sigId);
1408             return;
1409     }
1410     if (isSigType) {
1411         AvdtSigProcEvent(sigCtrl, stEvent, &data);
1412     } else {
1413         AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle(sigCtrl->streamHandle);
1414         if (streamCtrl != NULL) {
1415             AvdtStreamProcEvent(streamCtrl, stEvent, &data);
1416         } else {
1417             LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle(%hu) Failed!", __func__, sigCtrl->streamHandle);
1418         }
1419     }
1420     return;
1421 }
1422 
1423 /**
1424  *
1425  * @brief        AvdtParseSignalRej
1426  *
1427  * @details      Parse and dispatch the reject respond .
1428  *
1429  * @return       void
1430  *
1431  ******************************************************************************/
AvdtParseSignalRej(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t label,Packet * pkt)1432 void AvdtParseSignalRej(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t label, Packet *pkt)
1433 {
1434     uint8_t data = 0;
1435     uint8_t errCode = 0;
1436     uint8_t stEvent = AvdtGetEventBySigidCfm(sigId);
1437     switch (sigId) {
1438         case AVDT_SIG_DISCOVER:
1439         case AVDT_SIG_GET_ALLCAP:
1440         case AVDT_SIG_GETCAP:
1441         case AVDT_SIG_GETCONFIG:
1442         case AVDT_SIG_OPEN:
1443         case AVDT_SIG_CLOSE:
1444             PacketExtractHead(pkt, &errCode, AVDT_1BYTE); /* Read first octet message */
1445             break;
1446         case AVDT_SIG_SUSPEND:
1447         case AVDT_SIG_START:
1448         case AVDT_SIG_RECONFIG:
1449         case AVDT_SIG_SETCONFIG:
1450             PacketExtractHead(pkt, &data, AVDT_1BYTE);    /* Read first octet message */
1451             PacketExtractHead(pkt, &errCode, AVDT_1BYTE); /* Read second octet message */
1452             break;
1453         default:
1454             break;
1455     }
1456     LOG_DEBUG("[AVDT]%{public}s: sigId(%hhu) errCode(0x%x) categoryOrSeid(%hhu)", __func__, sigId, errCode, data);
1457     /* Do nothing, the timer of a2dp will be triggered */
1458     if (stEvent == AVDT_RECONFIGURE_CMD_CFM_EVENT) {
1459         AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle(sigCtrl->streamHandle);
1460         if (streamCtrl != NULL) {
1461             AvdtEventData eventData = {0};
1462             eventData.errCode = errCode;
1463             AvdtStreamProcEvent(streamCtrl, stEvent, &eventData);
1464         } else {
1465             LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle(%hu) Failed!", __func__, sigCtrl->streamHandle);
1466         }
1467     }
1468     return;
1469 }
1470 
1471 /**
1472  *
1473  * @brief        AvdtSignalGeneralRej
1474  *
1475  * @details      ACP check the signalling is out of scope.
1476  *               Then call this @brief to reject the require of remote peer.
1477  *
1478  * @return       void
1479  *
1480  */
AvdtSignalGeneralRej(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t label)1481 void AvdtSignalGeneralRej(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t label)
1482 {
1483     if (sigCtrl == NULL) {
1484         return;
1485     }
1486     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1487     Packet *pkt = PacketMalloc(AVDT_BUFFER_SINGLE, 0, AVDT_BUFFER_CMD_MAX);
1488     Buffer *msgHeader = PacketHead(pkt);
1489     uint8_t *p = BufferPtr(msgHeader);
1490     AvdtBuildSingleHeader(p, sigCtrl->label, AVDT_PKT_TYPE_SINGLE, AVDT_MSG_TYPE_GRJ);
1491     AvdtBuildSignal(p + 1, sigId);
1492     sigCtrl->currentMsg = pkt;
1493     AvdtSigProcEvent(sigCtrl, AVDT_SND_MSG_EVENT, NULL);
1494     return;
1495 }
1496 
1497 /**
1498  *
1499  * @brief        AvdtParseGetCapRsp
1500  *
1501  * @details      Parse the respond of get capability.
1502  *
1503  * @return       void
1504  *
1505  */
AvdtParseGetCapRsp(AvdtCtrlData * data,const Packet * pkt)1506 void AvdtParseGetCapRsp(AvdtCtrlData *data, const Packet *pkt)
1507 {
1508     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1509     AvdtParseCategory(data, pkt);
1510     return;
1511 }
1512 
1513 /**
1514  *
1515  * @brief        AvdtParseGetConfigRsp
1516  *
1517  * @details      Parse the respond of getconfigure.
1518  *
1519  * @return       void
1520  *
1521  */
AvdtParseGetConfigRsp(AvdtCtrlData * data,const Packet * pkt)1522 void AvdtParseGetConfigRsp(AvdtCtrlData *data, const Packet *pkt)
1523 {
1524     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1525     AvdtParseCategory(data, pkt);
1526     return;
1527 }
1528 
1529 /**
1530  *
1531  * @brief        AvdtParseCategory
1532  *
1533  * @details      Parse the category.
1534  *
1535  * @return       void
1536  *
1537  */
AvdtParseCategory(AvdtCtrlData * data,const Packet * pkt)1538 void AvdtParseCategory(AvdtCtrlData *data, const Packet *pkt)
1539 {
1540     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1541     if (data == NULL) {
1542         return;
1543     }
1544     uint16_t TotalSize = PacketSize(pkt);
1545     uint16_t Len = TotalSize;
1546     uint16_t Offset = 0;
1547     uint8_t context = 0;
1548     uint8_t tmp;
1549     uint8_t count;
1550     do {
1551         PacketPayloadRead(pkt, &context, Offset, AVDT_1BYTE);
1552         Offset++;
1553         Len--;
1554         /* parse */
1555         switch (context) {
1556             case AVDT_PSC_TRANS: {
1557                 count = AvdtParseCategoryTrans(&data->getconfigCfm.cfg, pkt, Offset, &tmp);
1558                 break;
1559             }
1560             case AVDT_PSC_CODEC: {
1561                 /* read codec parameter length */
1562                 count = AvdtParseCategoryCodec(&data->getconfigCfm.cfg, pkt, Offset);
1563                 break;
1564             }
1565             case AVDT_PSC_DELAY_RPT: {
1566                 count = AvdtParseCategoryDelay(&data->getconfigCfm.cfg, pkt, Offset, &tmp);
1567                 break;
1568             }
1569             default: {
1570                 LOG_WARN("[AVDT]%{public}s: The category(0x%x) is not surport now!", __func__, context);
1571                 count = AvdtParseCategorySkip(pkt, Offset);
1572                 break;
1573             }
1574         }
1575         Offset += count;
1576         Len -= count;
1577     } while (Len > 0 && TotalSize > Offset);
1578     LOG_DEBUG("[AVDT]%{public}s:data->getconfigCfm.cfg.pscMask is (0x%x)", __func__, data->getconfigCfm.cfg.pscMask);
1579     return;
1580 }
1581 
1582 /**
1583  *
1584  * @brief        AvdtParseDiscoverRsp
1585  *
1586  * @details      Parse the respond of discover.
1587  *
1588  * @return       void
1589  *
1590  */
AvdtParseDiscoverRsp(AvdtSigCtrl * sigCtrl,AvdtCtrlData * data,const Packet * pkt)1591 void AvdtParseDiscoverRsp(AvdtSigCtrl *sigCtrl, AvdtCtrlData *data, const Packet *pkt)
1592 {
1593     if (sigCtrl == NULL || data == NULL) {
1594         return;
1595     }
1596     uint16_t TotalSize = PacketSize(pkt);
1597     uint16_t Len = TotalSize;
1598     uint8_t maxNumSeps = sigCtrl->procParam;
1599     uint16_t Offset = 0;
1600     uint8_t context = 0;
1601     uint8_t index = 0;
1602 
1603     LOG_DEBUG("[AVDT]%{public}s: totalSize(%hu)", __func__, TotalSize);
1604     if (maxNumSeps == 0) {
1605         return;
1606     }
1607     do {
1608         (void)memset_s(&data->discoverCfm.seps[index], sizeof(AvdtSepInfo), 0, sizeof(AvdtSepInfo));
1609         PacketPayloadRead(pkt, &context, Offset, AVDT_1BYTE);
1610         Offset++;
1611         Len--;
1612         data->discoverCfm.seps[index].isUsed = (bool)(context & 0x02);
1613         data->discoverCfm.seps[index].seid = (context >> AVDT_OFFSET_2BIT);
1614         context = 0;
1615         PacketPayloadRead(pkt, &context, Offset, AVDT_1BYTE);
1616         Offset++;
1617         Len--;
1618         data->discoverCfm.seps[index].mediaType = (context >> AVDT_OFFSET_4BIT);
1619         data->discoverCfm.seps[index].sepType = ((context & 0x08) >> AVDT_OFFSET_3BIT);
1620         context = 0;
1621         maxNumSeps--;
1622         LOG_DEBUG("[AVDT]%{public}s: sigCtrl->role(%hhu) seps[index].sepType(%hhu) acpid(%hhu) "
1623             "mediaType(%hhu) index(%hhu) maxNumSeps(%hhu)",
1624             __func__,
1625             sigCtrl->role,
1626             data->discoverCfm.seps[index].sepType,
1627             data->discoverCfm.seps[index].seid,
1628             data->discoverCfm.seps[index].mediaType,
1629             index,
1630             maxNumSeps);
1631         if (sigCtrl->role != data->discoverCfm.seps[index].sepType && (data->discoverCfm.seps[index].seid > 0)) {
1632             index++;
1633         }
1634     } while (Len > 0 && maxNumSeps > 0 && TotalSize > Offset);
1635     data->discoverCfm.numSeps = index;
1636     return;
1637 }
1638 
1639 /**
1640  *
1641  * @brief        AvdtParseGetConfigRsp
1642  *
1643  * @details      Parse the respond of getconfigure.
1644  *
1645  * @return       void
1646  *
1647  */
AvdtParseSeid(uint8_t data)1648 uint8_t AvdtParseSeid(uint8_t data)
1649 {
1650     uint8_t seid = ((data >> AVDT_OFFSET_2BIT) & 0x3F);
1651     if (seid < AVDT_SEID_MIN || seid > AVDT_SEID_MAX) {
1652         seid = AVDT_SEID_INVLID;
1653     }
1654     LOG_DEBUG("[AVDT]%{public}s: seid(0x%x)", __func__, seid);
1655     return seid;
1656 }
1657 
1658 /**
1659  *
1660  * @brief        AvdtParseDelayValue
1661  *
1662  * @details      Parse the delay value from message.
1663  *
1664  * @return       delay value
1665  *
1666  */
AvdtParseDelayValue(uint8_t maxSB,uint8_t lowSB)1667 uint16_t AvdtParseDelayValue(uint8_t maxSB, uint8_t lowSB)
1668 {
1669     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1670     uint16_t Value = (uint16_t)((maxSB << AVDT_OFFSET_8BIT) | lowSB);
1671     return Value;
1672 }
1673 
1674 /**
1675  *
1676  * @brief        AvdtParseSetconfig
1677  *
1678  * @details      Parse the content of setconfig. *
1679  *
1680  * @return       0:sccusse /other errcode
1681  *
1682  */
AvdtParseSetconfig(uint16_t streamHandle,const Packet * pkt,uint16_t off,uint8_t * errCode,uint8_t * errParam)1683 void AvdtParseSetconfig(uint16_t streamHandle, const Packet *pkt, uint16_t off, uint8_t *errCode, uint8_t *errParam)
1684 {
1685     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1686     uint16_t TotalSize = PacketSize(pkt);
1687     uint16_t Len = TotalSize;
1688     uint8_t data = 0;
1689     uint16_t Offset = off;
1690     uint8_t tmp;
1691     uint8_t count;
1692     AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle(streamHandle);
1693     if (streamCtrl == NULL) {
1694         LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle Failed", __func__);
1695         return;
1696     }
1697     do {
1698         PacketPayloadRead(pkt, &data, Offset, AVDT_1BYTE);
1699         Offset++;
1700         Len--;
1701         switch (data) {
1702             case AVDT_PSC_TRANS: {
1703                 count = AvdtParseCategoryTrans(&streamCtrl->reqCfg, pkt, Offset, &tmp);
1704                 if (tmp != 0) {
1705                     *errCode = AVDT_ERR_BAD_MEDIA_TRANSPORT_FORMAT;
1706                     *errParam = AVDT_PSC_TRANS;
1707                     return;
1708                 }
1709                 break;
1710             }
1711             case AVDT_PSC_CODEC: {
1712                 count = AvdtParseCategoryCodec(&streamCtrl->reqCfg, pkt, Offset);
1713                 break;
1714             }
1715             case AVDT_PSC_DELAY_RPT: {
1716                 count = AvdtParseCategoryDelay(&streamCtrl->reqCfg, pkt, Offset, &tmp);
1717                 break;
1718             }
1719             default:
1720                 LOG_ERROR("[AVDT]%{public}s: The category(0x%x) is not surport now!", __func__, data);
1721                 *errCode = AVDT_ERR_INVALID_CAPABILITIES;
1722                 *errParam = data;
1723                 return;
1724         }
1725         Offset += count;
1726         Len -= count;
1727     } while (Len > 0 && TotalSize > Offset);
1728     return;
1729 }
1730 
1731 /**
1732  *
1733  * @brief        AvdtParseCategoryCodec
1734  *
1735  * @details      Parse the codec content of setconfig.
1736  *
1737  * @return       read data length
1738  *
1739  */
AvdtParseCategoryCodec(AvdtSepConfig * sepConfig,const Packet * pkt,uint16_t offset)1740 uint8_t AvdtParseCategoryCodec(AvdtSepConfig *sepConfig, const Packet *pkt, uint16_t offset)
1741 {
1742     if (sepConfig == NULL) {
1743         return 0;
1744     }
1745     uint8_t data = 0;
1746     uint8_t length = 0;
1747     PacketPayloadRead(pkt, &data, offset, AVDT_1BYTE);
1748 
1749     /* now only surport sbc/aac */
1750     if (data > AVDT_CODEC_SIZE) {
1751         data = AVDT_CODEC_SIZE;
1752     }
1753     offset++;
1754     length++;
1755     sepConfig->codecInfo[0] = data;
1756     PacketPayloadRead(pkt, &(sepConfig->codecInfo[1]), offset, data);
1757     sepConfig->numCodec = data;
1758     offset += data;
1759     length += data;
1760     sepConfig->pscMask = (sepConfig->pscMask | AVDT_PSC_MSK_CODEC);
1761     LOG_DEBUG("[AVDT]%{public}s:offset=%{public}d,length=%{public}d", __func__, offset, length);
1762     return length;
1763 }
1764 /**
1765  *
1766  * @brief        AvdtParseCategoryTrans
1767  *
1768  * @details      Parse the trans media content of setconfig.
1769  *
1770  * @return       read data length
1771  *
1772  */
AvdtParseCategoryTrans(AvdtSepConfig * sepConfig,const Packet * pkt,uint16_t offset,uint8_t * data)1773 uint8_t AvdtParseCategoryTrans(AvdtSepConfig *sepConfig, const Packet *pkt, uint16_t offset, uint8_t *data)
1774 {
1775     if (sepConfig == NULL) {
1776         return 0;
1777     }
1778     uint8_t length = 0;
1779     PacketPayloadRead(pkt, data, offset, AVDT_1BYTE);
1780     length++;
1781     sepConfig->pscMask = (sepConfig->pscMask | AVDT_PSC_MSK_TRANS);
1782     return length;
1783 }
1784 /**
1785  *
1786  * @brief        AvdtParseCategoryDelay
1787  *
1788  * @details      Parse the delay report content of setconfig.
1789  *
1790  * @return       read data length
1791  *
1792  */
AvdtParseCategoryDelay(AvdtSepConfig * sepConfig,const Packet * pkt,uint16_t offset,uint8_t * data)1793 uint8_t AvdtParseCategoryDelay(AvdtSepConfig *sepConfig, const Packet *pkt, uint16_t offset, uint8_t *data)
1794 {
1795     if (sepConfig == NULL) {
1796         return 0;
1797     }
1798     uint8_t length = 0;
1799     PacketPayloadRead(pkt, data, offset, AVDT_1BYTE);
1800     length++;
1801     sepConfig->pscMask = (sepConfig->pscMask | AVDT_PSC_MSK_DELAY_RPT);
1802     return length;
1803 }
1804 /**
1805  *
1806  * @brief        AvdtParseCategorySkip
1807  *
1808  * @details      Skip unsurport type content of setconfig.
1809  *
1810  * @return       read data length
1811  *
1812  */
AvdtParseCategorySkip(const Packet * pkt,uint16_t offset)1813 uint8_t AvdtParseCategorySkip(const Packet *pkt, uint16_t offset)
1814 {
1815     uint8_t data = 0;
1816     PacketPayloadRead(pkt, &data, offset, AVDT_1BYTE);
1817     uint8_t length = data + 1;
1818     return length;
1819 }
1820 /**
1821  *
1822  * @brief        AvdtParseReconfig
1823  *
1824  * @details      Parse the content of reconfig.
1825  *
1826  * @return       void
1827  *
1828  */
AvdtParseReconfig(uint16_t streamHandle,const Packet * pkt,uint16_t off,uint8_t * errCode,uint8_t * errParam)1829 void AvdtParseReconfig(uint16_t streamHandle, const Packet *pkt, uint16_t off, uint8_t *errCode, uint8_t *errParam)
1830 {
1831     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1832     uint16_t TotalSize = PacketSize(pkt);
1833     uint16_t Len = TotalSize;
1834     uint16_t Offset = off;
1835     uint8_t data = 0;
1836     uint8_t tmp;
1837     uint8_t count;
1838     AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle(streamHandle);
1839     if (streamCtrl == NULL) {
1840         LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle Failed", __func__);
1841         return;
1842     }
1843     do {
1844         PacketPayloadRead(pkt, &data, Offset, AVDT_1BYTE);
1845         Offset++;
1846         Len--;
1847         switch (data) {
1848             case AVDT_PSC_TRANS: {
1849                 count = AvdtParseCategoryTrans(&streamCtrl->reqCfg, pkt, Offset, &tmp);
1850                 if (tmp != 0) {
1851                     *errCode = AVDT_ERR_BAD_MEDIA_TRANSPORT_FORMAT;
1852                     *errParam = AVDT_PSC_TRANS;
1853                     return;
1854                 }
1855                 break;
1856             }
1857             case AVDT_PSC_CODEC: {
1858                 count = AvdtParseCategoryCodec(&streamCtrl->reqCfg, pkt, Offset);
1859                 break;
1860             }
1861             default:
1862                 LOG_ERROR("[AVDT]%{public}s: The category(0x%x) is not surport now!", __func__, data);
1863                 *errCode = AVDT_ERR_INVALID_CAPABILITIES;
1864                 *errParam = data;
1865                 return;
1866         }
1867         Offset += count;
1868         Len -= count;
1869     } while (Len > 0 && TotalSize > Offset);
1870     LOG_DEBUG("[AVDT]%{public}s:data->getCapCfm.cfg.pscMask is (0x%x)", __func__, streamCtrl->reqCfg.pscMask);
1871     return;
1872 }
1873 
1874 /**
1875  *
1876  * @brief        AvdtIndPktLenCheck
1877  *
1878  * @details      Check packet length is valid for ind command.
1879  *
1880  * @return       valid：0 / invalid: other
1881  *
1882  */
AvdtIndPktLenCheck(AvdtSigCtrl * sigCtrl,uint8_t sigId,const Packet * pkt)1883 uint8_t AvdtIndPktLenCheck(AvdtSigCtrl *sigCtrl, uint8_t sigId, const Packet *pkt)
1884 {
1885     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1886     uint8_t Ret = AVDT_SUCCESS;
1887     uint16_t Len = PacketSize(pkt);
1888     switch (sigId) {
1889         case AVDT_SIG_DISCOVER:
1890             break;
1891         case AVDT_SIG_GET_ALLCAP:
1892         case AVDT_SIG_GETCAP:
1893         case AVDT_SIG_GETCONFIG:
1894         case AVDT_SIG_RECONFIG:
1895         case AVDT_SIG_OPEN:
1896         case AVDT_SIG_CLOSE:
1897         case AVDT_SIG_ABORT:
1898         case AVDT_SIG_START:
1899         case AVDT_SIG_SUSPEND:
1900             if (Len < AVDT_SIG_LENGTH_COMM) {
1901                 Ret = AVDT_BAD_PARAMS;
1902             }
1903             break;
1904         case AVDT_SIG_SETCONFIG:
1905             if (Len < AVDT_SIG_LENGTH_SETCONFIG) {
1906                 Ret = AVDT_BAD_PARAMS;
1907             }
1908             break;
1909         case AVDT_SIG_DELAY_RPT:
1910             if (Len < AVDT_SIG_LENGTH_DELAY_RPT) {
1911                 Ret = AVDT_BAD_PARAMS;
1912             }
1913             break;
1914         default:
1915             break;
1916     }
1917     if (Ret != AVDT_SUCCESS) {
1918         LOG_ERROR("[AVDT]%{public}s:BAD LENGTH of the cmd!", __func__);
1919         AvdtIndReject(sigCtrl, sigId, AVDT_ERR_BAD_LENGTH, 0);
1920     }
1921     return Ret;
1922 }
1923 
1924 /**
1925  *
1926  * @brief        AvdtIndSeidCheck
1927  *
1928  * @details      Check se id is valid for ind command.
1929  *
1930  * @return       valid：id / invalid: AVDT_SEID_INVLID
1931  *
1932  */
AvdtIndSeidCheck(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t data)1933 uint8_t AvdtIndSeidCheck(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t data)
1934 {
1935     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1936     uint8_t seid = AVDT_SEID_INVLID;
1937     switch (sigId) {
1938         case AVDT_SIG_DISCOVER:
1939             break;
1940         case AVDT_SIG_GET_ALLCAP:
1941         case AVDT_SIG_GETCAP:
1942         case AVDT_SIG_OPEN:
1943         case AVDT_SIG_CLOSE:
1944         case AVDT_SIG_GETCONFIG:
1945         case AVDT_SIG_ABORT:
1946         case AVDT_SIG_START:
1947         case AVDT_SIG_SUSPEND:
1948         case AVDT_SIG_RECONFIG:
1949         case AVDT_SIG_SETCONFIG:
1950         case AVDT_SIG_DELAY_RPT:
1951             seid = AvdtParseSeid(data);
1952             if (seid == AVDT_SEID_INVLID) {
1953                 LOG_ERROR("[AVDT]%{public}s:BAD SEID of the cmd!", __func__);
1954                 AvdtIndReject(sigCtrl, sigId, AVDT_ERR_BAD_ACP_SEID, 0);
1955             } else {
1956                 AvdtStreamCtrl *streamCtrl = AvdtGetStreamCtrlByHandle((uint16_t)seid);
1957                 if (streamCtrl == NULL) {
1958                     LOG_ERROR("[AVDT]%{public}s:AvdtGetStreamCtrlByHandle failed(%hhu)!", __func__, seid);
1959                     AvdtIndReject(sigCtrl, sigId, AVDT_ERR_BAD_ACP_SEID, 0);
1960                     seid = AVDT_SEID_INVLID;
1961                 }
1962             }
1963             break;
1964         default:
1965             break;
1966     }
1967     return seid;
1968 }
1969 
1970 /**
1971  *
1972  * @brief        AvdtMakeRejMsg
1973  *
1974  * @details      Make reject message for received signal.
1975  *
1976  * @return       valid：id / invalid: AVDT_SEID_INVLID
1977  *
1978  */
AvdtMakeRejMsg(uint8_t sigId,uint8_t errCode,uint8_t errParam,AvdtMsg * msg)1979 void AvdtMakeRejMsg(uint8_t sigId, uint8_t errCode, uint8_t errParam, AvdtMsg *msg)
1980 {
1981     LOG_DEBUG("[AVDT]%{public}s:", __func__);
1982     switch (sigId) {
1983         case AVDT_SIG_DISCOVER:
1984             break;
1985         case AVDT_SIG_GETCONFIG:
1986         case AVDT_SIG_OPEN:
1987         case AVDT_SIG_CLOSE:
1988         case AVDT_SIG_ABORT:
1989         case AVDT_SIG_START:
1990         case AVDT_SIG_SUSPEND:
1991             msg->single.errCode = errCode;
1992             msg->single.errParam = errParam;
1993             break;
1994         case AVDT_SIG_GETCAP:
1995         case AVDT_SIG_GET_ALLCAP:
1996             msg->getcap.single.errCode = errCode;
1997             msg->getcap.single.errParam = errParam;
1998             break;
1999         case AVDT_SIG_SETCONFIG:
2000             msg->configureCmd.hdr.errCode = errCode;
2001             msg->configureCmd.hdr.errParam = errParam;
2002             break;
2003         case AVDT_SIG_RECONFIG:
2004             msg->reconfigureCmd.hdr.errCode = errCode;
2005             msg->reconfigureCmd.hdr.errParam = errParam;
2006             break;
2007         case AVDT_SIG_DELAY_RPT:
2008             msg->delayRptCmd.hdr.errCode = errCode;
2009             msg->delayRptCmd.hdr.errParam = errParam;
2010             break;
2011         default:
2012             break;
2013     }
2014     return;
2015 }
2016 
2017 /**
2018  *
2019  * @brief        AvdtServiceCapCheck
2020  *
2021  * @details      Service capabilities valid check.
2022  *
2023  * @return       valid：0 / invalid: other
2024  *
2025  */
AvdtServiceCapCheck(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t data)2026 uint8_t AvdtServiceCapCheck(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t data)
2027 {
2028     LOG_DEBUG("[AVDT]%{public}s:", __func__);
2029     uint8_t Ret = AVDT_SUCCESS;
2030     uint8_t err = 0;
2031     if (data > AVDT_PSC_MAX_CUR) {
2032         err = AVDT_ERR_BAD_SERV_CATEGORY;
2033     } else if (sigId == AVDT_SIG_RECONFIG && data != AVDT_PSC_CODEC) {
2034         err = AVDT_ERR_INVALID_CAPABILITIES;
2035     } else if ((data != AVDT_PSC_TRANS) && (data != AVDT_PSC_CODEC) && (data != AVDT_PSC_DELAY_RPT)
2036         && (data != AVDT_PSC_PROTECT)) {
2037         err = AVDT_ERR_INVALID_CAPABILITIES;
2038     }
2039     if (err != 0) {
2040         LOG_ERROR("[AVDT]%{public}s:BAD Service Category of the cmd(0x%x)!", __func__, sigId);
2041         AvdtIndReject(sigCtrl, sigId, err, data);
2042         Ret = AVDT_BAD_PARAMS;
2043     }
2044     return Ret;
2045 }
2046 
2047 /**
2048  *
2049  * @brief        AvdtIndReject
2050  *
2051  * @details      Send reject message by signal.
2052  *
2053  * @return       void
2054  *
2055  */
AvdtIndReject(AvdtSigCtrl * sigCtrl,uint8_t sigId,uint8_t errCode,uint8_t errParam)2056 void AvdtIndReject(AvdtSigCtrl *sigCtrl, uint8_t sigId, uint8_t errCode, uint8_t errParam)
2057 {
2058     LOG_DEBUG("[AVDT]%{public}s:", __func__);
2059     AvdtMsg avdtMsgData = {0};
2060     AvdtMakeRejMsg(sigId, errCode, errParam, &avdtMsgData);
2061     AvdtMsgSendRej(sigCtrl, sigId, &avdtMsgData);
2062     return;
2063 }
2064