1 /*
2  * Copyright (C) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "hci_evt.h"
17 
18 #include <securec.h>
19 
20 #include "btstack.h"
21 #include "platform/include/allocator.h"
22 #include "platform/include/list.h"
23 #include "platform/include/mutex.h"
24 
25 #include "hci/acl/hci_acl.h"
26 #include "hci/cmd/hci_cmd.h"
27 #include "hci/hci.h"
28 #include "hci/hci_error.h"
29 
30 #include "hci_evt_cmd_complete.h"
31 #include "hci_evt_le.h"
32 
33 #define COD_SIZE 3
34 
35 #pragma pack(1)
36 typedef struct {
37     uint8_t eventCode;
38     uint8_t parameterTotalLength;
39 } HciEventHeader;
40 #pragma pack()
41 
42 typedef void (*HciEventFunc)(Packet *packet);
43 
44 static List *g_eventCallbackList = NULL;
45 static Mutex *g_lockCallbackList = NULL;
46 
HciInitEvent()47 void HciInitEvent()
48 {
49     g_eventCallbackList = ListCreate(NULL);
50     g_lockCallbackList = MutexCreate();
51 }
52 
HciCloseEvent()53 void HciCloseEvent()
54 {
55     if (g_lockCallbackList != NULL) {
56         MutexDelete(g_lockCallbackList);
57         g_lockCallbackList = NULL;
58     }
59 
60     if (g_eventCallbackList != NULL) {
61         ListDelete(g_eventCallbackList);
62         g_eventCallbackList = NULL;
63     }
64 }
65 
HciEventOnInquiryCompleteEvent(Packet * packet)66 static void HciEventOnInquiryCompleteEvent(Packet *packet)
67 {
68     Buffer *payloadBuffer = PacketContinuousPayload(packet);
69     if (payloadBuffer == NULL) {
70         return;
71     }
72     HciInquiryCompleteEventParam *param = (HciInquiryCompleteEventParam *)BufferPtr(payloadBuffer);
73     if (param == NULL) {
74         return;
75     }
76 
77     HciEventCallbacks *callbacks = NULL;
78     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
79     if (callbacks->inquiryComplete != NULL) {
80         callbacks->inquiryComplete(param);
81     }
82     HCI_FOREACH_EVT_CALLBACKS_END;
83 }
84 
HciEventOnInquiryResultEvent(Packet * packet)85 static void HciEventOnInquiryResultEvent(Packet *packet)
86 {
87     Buffer *payloadBuffer = PacketContinuousPayload(packet);
88     if (payloadBuffer == NULL) {
89         return;
90     }
91     uint8_t *param = BufferPtr(payloadBuffer);
92     if (param == NULL) {
93         return;
94     }
95 
96     int offset = 0;
97     HciInquiryResultEventParam eventParam = {
98         .numResponses = param[0],
99     };
100     offset += sizeof(uint8_t);
101 
102     if ((sizeof(HciInquiryResult) * eventParam.numResponses + 1) != BufferGetSize(payloadBuffer)) {
103         return;
104     }
105 
106     HciInquiryResult *responses = NULL;
107     if (eventParam.numResponses) {
108         responses = MEM_MALLOC.alloc(sizeof(HciInquiryResult) * eventParam.numResponses);
109         if (responses != NULL) {
110             for (uint8_t i = 0; i < eventParam.numResponses; i++) {
111                 (void)memcpy_s(responses[i].bdAddr.raw, BT_ADDRESS_SIZE, param + offset, sizeof(HciBdAddr));
112                 offset += sizeof(HciBdAddr);
113 
114                 responses[i].pageScanRepetitionMode = param[offset];
115                 offset += sizeof(uint8_t);
116 
117                 responses[i].reserved1 = param[offset];
118                 offset += sizeof(uint8_t);
119 
120                 responses[i].reserved2 = param[offset];
121                 offset += sizeof(uint8_t);
122 
123                 (void)memcpy_s(responses[i].classOfDevice, COD_SIZE, param + offset, COD_SIZE);
124                 offset += COD_SIZE;
125 
126                 (void)memcpy_s(&responses[i].clockOffset, sizeof(uint16_t), param + offset, sizeof(uint16_t));
127                 offset += sizeof(uint16_t);
128             }
129         }
130 
131         eventParam.responses = responses;
132     }
133 
134     HciEventCallbacks *callbacks = NULL;
135     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
136     if (callbacks->inquiryResult != NULL) {
137         callbacks->inquiryResult(&eventParam);
138     }
139     HCI_FOREACH_EVT_CALLBACKS_END;
140 
141     if (responses != NULL) {
142         MEM_MALLOC.free(responses);
143     }
144 }
145 
HciEventOnCommandStatusEvent(Packet * packet)146 static void HciEventOnCommandStatusEvent(Packet *packet)
147 {
148     Buffer *payloadBuffer = PacketContinuousPayload(packet);
149     if (payloadBuffer == NULL) {
150         return;
151     }
152 
153     HciCommandStatusEventParam *param = (HciCommandStatusEventParam *)BufferPtr(payloadBuffer);
154     if (param == NULL) {
155         return;
156     }
157 
158     size_t length = BufferGetSize(payloadBuffer);
159     if (length != sizeof(HciCommandStatusEventParam)) {
160         return;
161     }
162 
163     HciSetNumberOfHciCmd(param->numHciCommandPackets);
164     HciCmdOnCommandStatus(param->commandOpcode, param->status);
165 
166     HciEventCallbacks *callbacks = NULL;
167     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
168     if (callbacks->commandStatus != NULL) {
169         callbacks->commandStatus(param->status, param->commandOpcode);
170     }
171     HCI_FOREACH_EVT_CALLBACKS_END;
172 }
173 
HciEventOnConnectionCompleteEvent(Packet * packet)174 static void HciEventOnConnectionCompleteEvent(Packet *packet)
175 {
176     Buffer *payloadBuffer = PacketContinuousPayload(packet);
177     if (payloadBuffer == NULL) {
178         return;
179     }
180     HciConnectionCompleteEventParam *param = (HciConnectionCompleteEventParam *)BufferPtr(payloadBuffer);
181     if (param == NULL) {
182         return;
183     }
184     size_t length = BufferGetSize(payloadBuffer);
185     if (length != sizeof(HciConnectionCompleteEventParam)) {
186         return;
187     }
188 
189     if (param->status == HCI_SUCCESS) {
190         HciAclOnConnectionComplete(param->connectionHandle, TRANSPORT_BREDR);
191     }
192 
193     HciEventCallbacks *callbacks = NULL;
194     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
195     if (callbacks->connectionComplete != NULL) {
196         callbacks->connectionComplete(param);
197     }
198     HCI_FOREACH_EVT_CALLBACKS_END;
199 }
200 
HciEventOnConnectionRequestEvent(Packet * packet)201 static void HciEventOnConnectionRequestEvent(Packet *packet)
202 {
203     Buffer *payloadBuffer = PacketContinuousPayload(packet);
204     if (payloadBuffer == NULL) {
205         return;
206     }
207     HciConnectionRequestEventParam *param = (HciConnectionRequestEventParam *)BufferPtr(payloadBuffer);
208     if (param == NULL) {
209         return;
210     }
211     size_t length = BufferGetSize(payloadBuffer);
212     if (length != sizeof(HciConnectionRequestEventParam)) {
213         return;
214     }
215 
216     HciEventCallbacks *callbacks = NULL;
217     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
218     if (callbacks->connectionRequest != NULL) {
219         callbacks->connectionRequest(param);
220     }
221     HCI_FOREACH_EVT_CALLBACKS_END;
222 }
223 
HciEventOnRemoteNameRequestCompleteEvent(Packet * packet)224 static void HciEventOnRemoteNameRequestCompleteEvent(Packet *packet)
225 {
226     Buffer *payloadBuffer = PacketContinuousPayload(packet);
227     if (payloadBuffer == NULL) {
228         return;
229     }
230     HciRemoteNameRequestCompleteEventParam *param = (HciRemoteNameRequestCompleteEventParam *)BufferPtr(payloadBuffer);
231     if (param == NULL) {
232         return;
233     }
234     size_t length = BufferGetSize(payloadBuffer);
235     if (length != sizeof(HciRemoteNameRequestCompleteEventParam)) {
236         return;
237     }
238 
239     HciEventCallbacks *callbacks = NULL;
240     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
241     if (callbacks->remoteNameRequestComplete != NULL) {
242         callbacks->remoteNameRequestComplete(param);
243     }
244     HCI_FOREACH_EVT_CALLBACKS_END;
245 }
246 
HciEventOnEncryptionChangeEvent(Packet * packet)247 static void HciEventOnEncryptionChangeEvent(Packet *packet)
248 {
249     Buffer *payloadBuffer = PacketContinuousPayload(packet);
250     if (payloadBuffer == NULL) {
251         return;
252     }
253     HciEncryptionChangeEventParam *param = (HciEncryptionChangeEventParam *)BufferPtr(payloadBuffer);
254     if (param == NULL) {
255         return;
256     }
257     size_t length = BufferGetSize(payloadBuffer);
258     if (length != sizeof(HciEncryptionChangeEventParam)) {
259         return;
260     }
261 
262     HciEventCallbacks *callbacks = NULL;
263     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
264     if (callbacks->encryptionChange != NULL) {
265         callbacks->encryptionChange(param);
266     }
267     HCI_FOREACH_EVT_CALLBACKS_END;
268 }
269 
HciEventOnReadRemoteSupportedFeaturesCompleteEvent(Packet * packet)270 static void HciEventOnReadRemoteSupportedFeaturesCompleteEvent(Packet *packet)
271 {
272     Buffer *payloadBuffer = PacketContinuousPayload(packet);
273     if (payloadBuffer == NULL) {
274         return;
275     }
276     HciReadRemoteSupportedFeaturesCompleteEventParam *param =
277         (HciReadRemoteSupportedFeaturesCompleteEventParam *)BufferPtr(payloadBuffer);
278     if (param == NULL) {
279         return;
280     }
281     size_t length = BufferGetSize(payloadBuffer);
282     if (length != sizeof(HciReadRemoteSupportedFeaturesCompleteEventParam)) {
283         return;
284     }
285 
286     HciEventCallbacks *callbacks = NULL;
287     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
288     if (callbacks->readRemoteSupportedFeaturesComplete != NULL) {
289         callbacks->readRemoteSupportedFeaturesComplete(param);
290     }
291     HCI_FOREACH_EVT_CALLBACKS_END;
292 }
293 
HciEventOnReadRemoteVersionInformationCompleteEvent(Packet * packet)294 static void HciEventOnReadRemoteVersionInformationCompleteEvent(Packet *packet)
295 {
296     Buffer *payloadBuffer = PacketContinuousPayload(packet);
297     if (payloadBuffer == NULL) {
298         return;
299     }
300     HciReadRemoteVersionInformationCompleteEventParam *param =
301         (HciReadRemoteVersionInformationCompleteEventParam *)BufferPtr(payloadBuffer);
302     if (param == NULL) {
303         return;
304     }
305     size_t length = BufferGetSize(payloadBuffer);
306     if (length != sizeof(HciReadRemoteVersionInformationCompleteEventParam)) {
307         return;
308     }
309 
310     HciEventCallbacks *callbacks = NULL;
311     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
312     if (callbacks->readRemoteVersionInformationComplete != NULL) {
313         callbacks->readRemoteVersionInformationComplete(param);
314     }
315     HCI_FOREACH_EVT_CALLBACKS_END;
316 }
317 
HciEventOnRemoteHostSupportedFeaturesNotificationEvent(Packet * packet)318 static void HciEventOnRemoteHostSupportedFeaturesNotificationEvent(Packet *packet)
319 {
320     Buffer *payloadBuffer = PacketContinuousPayload(packet);
321     if (payloadBuffer == NULL) {
322         return;
323     }
324     HciRemoteHostSupportedFeaturesNotificationEventParam *param =
325         (HciRemoteHostSupportedFeaturesNotificationEventParam *)BufferPtr(payloadBuffer);
326     if (param == NULL) {
327         return;
328     }
329     size_t length = BufferGetSize(payloadBuffer);
330     if (length != sizeof(HciRemoteHostSupportedFeaturesNotificationEventParam)) {
331         return;
332     }
333 
334     HciEventCallbacks *callbacks = NULL;
335     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
336     if (callbacks->remoteHostSupportedFeaturesNotification != NULL) {
337         callbacks->remoteHostSupportedFeaturesNotification(param);
338     }
339     HCI_FOREACH_EVT_CALLBACKS_END;
340 }
341 
HciEventOnNumberOfCompletedPacketsEvent(Packet * packet)342 static void HciEventOnNumberOfCompletedPacketsEvent(Packet *packet)
343 {
344     Buffer *payloadBuffer = PacketContinuousPayload(packet);
345     if (payloadBuffer == NULL) {
346         return;
347     }
348     size_t length = BufferGetSize(payloadBuffer);
349     if (length < 1) {
350         return;
351     }
352     uint8_t *buf = BufferPtr(payloadBuffer);
353     if (buf == NULL) {
354         return;
355     }
356     int offset = 0;
357     uint8_t numberOfHandles = buf[0];
358     offset += sizeof(uint8_t);
359 
360     if (numberOfHandles == 0) {
361         return;
362     }
363     if ((sizeof(uint8_t) + numberOfHandles * (sizeof(uint16_t) + sizeof(uint16_t))) != length) {
364         return;
365     }
366 
367     HciNumberOfCompletedPackets *list = MEM_MALLOC.alloc(sizeof(HciNumberOfCompletedPackets) * numberOfHandles);
368     if (list != NULL) {
369         for (int i = 0; i < numberOfHandles; i++) {
370             (void)memcpy_s(&list[i].connectionHandle, sizeof(uint16_t), buf + offset, sizeof(uint16_t));
371             offset += sizeof(uint16_t);
372 
373             (void)memcpy_s(&list[i].numOfCompletedPackets, sizeof(uint16_t), buf + offset, sizeof(uint16_t));
374             offset += sizeof(uint16_t);
375         }
376 
377         HciAclOnNumberOfCompletedPacket(numberOfHandles, list);
378         MEM_MALLOC.free(list);
379     }
380 }
381 
HciEventOnModeChangeEvent(Packet * packet)382 static void HciEventOnModeChangeEvent(Packet *packet)
383 {
384     Buffer *payloadBuffer = PacketContinuousPayload(packet);
385     if (payloadBuffer == NULL) {
386         return;
387     }
388     HciModeChangeEventParam *param = (HciModeChangeEventParam *)BufferPtr(payloadBuffer);
389     if (param == NULL) {
390         return;
391     }
392     size_t length = BufferGetSize(payloadBuffer);
393     if (length != sizeof(HciModeChangeEventParam)) {
394         return;
395     }
396 
397     HciEventCallbacks *callbacks = NULL;
398     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
399     if (callbacks->modeChange != NULL) {
400         callbacks->modeChange(param);
401     }
402     HCI_FOREACH_EVT_CALLBACKS_END;
403 }
404 
HciEventOnPINCodeRequestEvent(Packet * packet)405 static void HciEventOnPINCodeRequestEvent(Packet *packet)
406 {
407     Buffer *payloadBuffer = PacketContinuousPayload(packet);
408     if (payloadBuffer == NULL) {
409         return;
410     }
411 
412     HciPinCodeRequestEventParam *param = (HciPinCodeRequestEventParam *)BufferPtr(payloadBuffer);
413     if (param == NULL) {
414         return;
415     }
416     size_t length = BufferGetSize(payloadBuffer);
417     if (length != sizeof(HciPinCodeRequestEventParam)) {
418         return;
419     }
420 
421     HciEventCallbacks *callbacks = NULL;
422     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
423     if (callbacks->pinCodeRequest != NULL) {
424         callbacks->pinCodeRequest(param);
425     }
426     HCI_FOREACH_EVT_CALLBACKS_END;
427 }
428 
HciEventOnLinkKeyRequestEvent(Packet * packet)429 static void HciEventOnLinkKeyRequestEvent(Packet *packet)
430 {
431     Buffer *payloadBuffer = PacketContinuousPayload(packet);
432     if (payloadBuffer == NULL) {
433         return;
434     }
435     HciLinkKeyRequestEventParam *param = (HciLinkKeyRequestEventParam *)BufferPtr(payloadBuffer);
436     if (param == NULL) {
437         return;
438     }
439     size_t length = BufferGetSize(payloadBuffer);
440     if (length != sizeof(HciLinkKeyRequestEventParam)) {
441         return;
442     }
443 
444     HciEventCallbacks *callbacks = NULL;
445     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
446     if (callbacks->linkKeyRequest != NULL) {
447         callbacks->linkKeyRequest(param);
448     }
449     HCI_FOREACH_EVT_CALLBACKS_END;
450 }
451 
HciEventOnLinkKeyNotificationEvent(Packet * packet)452 static void HciEventOnLinkKeyNotificationEvent(Packet *packet)
453 {
454     Buffer *payloadBuffer = PacketContinuousPayload(packet);
455     if (payloadBuffer == NULL) {
456         return;
457     }
458     HciLinkKeyNotificationEventParam *param = (HciLinkKeyNotificationEventParam *)BufferPtr(payloadBuffer);
459     if (param == NULL) {
460         return;
461     }
462     size_t length = BufferGetSize(payloadBuffer);
463     if (length != sizeof(HciLinkKeyNotificationEventParam)) {
464         return;
465     }
466 
467     HciEventCallbacks *callbacks = NULL;
468     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
469     if (callbacks->linkKeyNotification != NULL) {
470         callbacks->linkKeyNotification(param);
471     }
472     HCI_FOREACH_EVT_CALLBACKS_END;
473 }
474 
HciEventOnSynchronousConnectionCompleteEvent(Packet * packet)475 static void HciEventOnSynchronousConnectionCompleteEvent(Packet *packet)
476 {
477     Buffer *payloadBuffer = PacketContinuousPayload(packet);
478     if (payloadBuffer == NULL) {
479         return;
480     }
481     HciSynchronousConnectionCompleteEventParam *param =
482         (HciSynchronousConnectionCompleteEventParam *)BufferPtr(payloadBuffer);
483     if (param == NULL) {
484         return;
485     }
486     size_t length = BufferGetSize(payloadBuffer);
487     if (length != sizeof(HciSynchronousConnectionCompleteEventParam)) {
488         return;
489     }
490 
491     HciEventCallbacks *callbacks = NULL;
492     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
493     if (callbacks->synchronousConnectionComplete != NULL) {
494         callbacks->synchronousConnectionComplete(param);
495     }
496     HCI_FOREACH_EVT_CALLBACKS_END;
497 }
498 
HciEventOnSynchronousConnectionChangedEvent(Packet * packet)499 static void HciEventOnSynchronousConnectionChangedEvent(Packet *packet)
500 {
501     Buffer *payloadBuffer = PacketContinuousPayload(packet);
502     if (payloadBuffer == NULL) {
503         return;
504     }
505     HciSynchronousConnectionChangedEventParam *param =
506         (HciSynchronousConnectionChangedEventParam *)BufferPtr(payloadBuffer);
507     if (param == NULL) {
508         return;
509     }
510     size_t length = BufferGetSize(payloadBuffer);
511     if (length != sizeof(HciSynchronousConnectionChangedEventParam)) {
512         return;
513     }
514 
515     HciEventCallbacks *callbacks = NULL;
516     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
517     if (callbacks->synchronousConnectionChanged != NULL) {
518         callbacks->synchronousConnectionChanged(param);
519     }
520     HCI_FOREACH_EVT_CALLBACKS_END;
521 }
522 
HciEventOnDisconnectCompeteEvent(Packet * packet)523 static void HciEventOnDisconnectCompeteEvent(Packet *packet)
524 {
525     Buffer *payloadBuffer = PacketContinuousPayload(packet);
526     if (payloadBuffer == NULL) {
527         return;
528     }
529     HciDisconnectCompleteEventParam *param = (HciDisconnectCompleteEventParam *)BufferPtr(payloadBuffer);
530     if (param == NULL) {
531         return;
532     }
533     size_t length = BufferGetSize(payloadBuffer);
534     if (length != sizeof(HciDisconnectCompleteEventParam)) {
535         return;
536     }
537 
538     if (param->status == HCI_SUCCESS) {
539         HciAclOnDisconnectComplete(param->connectionHandle);
540     }
541 
542     HciEventCallbacks *callbacks = NULL;
543     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
544     if (callbacks->disconnectComplete != NULL) {
545         callbacks->disconnectComplete(param);
546     }
547     HCI_FOREACH_EVT_CALLBACKS_END;
548 }
549 
HciEventOnAuthencationCompleteEvent(Packet * packet)550 static void HciEventOnAuthencationCompleteEvent(Packet *packet)
551 {
552     Buffer *payloadBuffer = PacketContinuousPayload(packet);
553     if (payloadBuffer == NULL) {
554         return;
555     }
556     HciAuthenticationCompleteEventParam *param = (HciAuthenticationCompleteEventParam *)BufferPtr(payloadBuffer);
557     if (param == NULL) {
558         return;
559     }
560     size_t length = BufferGetSize(payloadBuffer);
561     if (length != sizeof(HciAuthenticationCompleteEventParam)) {
562         return;
563     }
564 
565     HciEventCallbacks *callbacks = NULL;
566     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
567     if (callbacks->authenticationComplete != NULL) {
568         callbacks->authenticationComplete(param);
569     }
570     HCI_FOREACH_EVT_CALLBACKS_END;
571 }
572 
HciEventOnInquiryResultWithRSSIEvent(Packet * packet)573 static void HciEventOnInquiryResultWithRSSIEvent(Packet *packet)
574 {
575     Buffer *payloadBuffer = PacketContinuousPayload(packet);
576     if (payloadBuffer == NULL) {
577         return;
578     }
579     uint8_t *param = BufferPtr(payloadBuffer);
580     if (param == NULL) {
581         return;
582     }
583 
584     int offset = 0;
585     HciInquiryResultWithRssiEventParam eventParam = {
586         .numResponses = param[0],
587     };
588     offset += sizeof(uint8_t);
589 
590     if ((sizeof(HciInquiryResultWithRssi) * eventParam.numResponses + 1) != BufferGetSize(payloadBuffer)) {
591         return;
592     }
593 
594     HciInquiryResultWithRssi *responses = NULL;
595     if (eventParam.numResponses > 0) {
596         responses = MEM_MALLOC.alloc(sizeof(HciInquiryResultWithRssi) * eventParam.numResponses);
597         if (responses != NULL) {
598             for (uint8_t i = 0; i < eventParam.numResponses; i++) {
599                 (void)memcpy_s(responses[i].bdAddr.raw, BT_ADDRESS_SIZE, param + offset, sizeof(HciBdAddr));
600                 offset += sizeof(HciBdAddr);
601 
602                 responses[i].pageScanRepetitionMode = param[offset];
603                 offset += sizeof(uint8_t);
604 
605                 responses[i].reserved = param[offset];
606                 offset += sizeof(uint8_t);
607 
608                 (void)memcpy_s(responses[i].classOfDevice, COD_SIZE, param + offset, COD_SIZE);
609                 offset += COD_SIZE;
610 
611                 (void)memcpy_s(&responses[i].clockOffset, sizeof(uint16_t), param + offset, sizeof(uint16_t));
612                 offset += sizeof(uint16_t);
613 
614                 responses[i].rssi = param[offset];
615                 offset += sizeof(uint8_t);
616             }
617         }
618 
619         eventParam.responses = responses;
620     }
621 
622     HciEventCallbacks *callbacks = NULL;
623     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
624     if (callbacks->inquiryResultWithRSSI != NULL) {
625         callbacks->inquiryResultWithRSSI(&eventParam);
626     }
627     HCI_FOREACH_EVT_CALLBACKS_END;
628 
629     if (responses != NULL) {
630         MEM_MALLOC.free(responses);
631     }
632 }
633 
HciEventOnReadRemoteExtendedFeaturesCompleteEvent(Packet * packet)634 static void HciEventOnReadRemoteExtendedFeaturesCompleteEvent(Packet *packet)
635 {
636     Buffer *payloadBuffer = PacketContinuousPayload(packet);
637     if (payloadBuffer == NULL) {
638         return;
639     }
640     HciReadRemoteExtendedFeaturesCompleteEventParam *param =
641         (HciReadRemoteExtendedFeaturesCompleteEventParam *)BufferPtr(payloadBuffer);
642     if (param == NULL) {
643         return;
644     }
645     size_t length = BufferGetSize(payloadBuffer);
646     if (length != sizeof(HciReadRemoteExtendedFeaturesCompleteEventParam)) {
647         return;
648     }
649 
650     HciEventCallbacks *callbacks = NULL;
651     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
652     if (callbacks->readRemoteExtendedFeaturesComplete != NULL) {
653         callbacks->readRemoteExtendedFeaturesComplete(param);
654     }
655     HCI_FOREACH_EVT_CALLBACKS_END;
656 }
657 
HciEventOnExtendedInquiryResultEvent(Packet * packet)658 static void HciEventOnExtendedInquiryResultEvent(Packet *packet)
659 {
660     Buffer *payloadBuffer = PacketContinuousPayload(packet);
661     if (payloadBuffer == NULL) {
662         return;
663     }
664 
665     if (BufferGetSize(payloadBuffer) != sizeof(HciExtendedInquiryResultEventParam)) {
666         return;
667     }
668 
669     HciExtendedInquiryResultEventParam *param = (HciExtendedInquiryResultEventParam *)BufferPtr(payloadBuffer);
670     if (param == NULL) {
671         return;
672     }
673 
674     HciEventCallbacks *callbacks = NULL;
675     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
676     if (callbacks->extendedInquiryResult != NULL) {
677         callbacks->extendedInquiryResult(param);
678     }
679     HCI_FOREACH_EVT_CALLBACKS_END;
680 }
681 
HciEventOnEncryptionKeyRefreshCompleteEvent(Packet * packet)682 static void HciEventOnEncryptionKeyRefreshCompleteEvent(Packet *packet)
683 {
684     Buffer *payloadBuffer = PacketContinuousPayload(packet);
685     if (payloadBuffer == NULL) {
686         return;
687     }
688 
689     if (BufferGetSize(payloadBuffer) != sizeof(HciEncryptionKeyRefreshCompleteEventParam)) {
690         return;
691     }
692 
693     HciEncryptionKeyRefreshCompleteEventParam *param =
694         (HciEncryptionKeyRefreshCompleteEventParam *)BufferPtr(payloadBuffer);
695     if (param == NULL) {
696         return;
697     }
698 
699     HciEventCallbacks *callbacks = NULL;
700     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
701     if (callbacks->encryptionKeyRefreshComplete != NULL) {
702         callbacks->encryptionKeyRefreshComplete(param);
703     }
704     HCI_FOREACH_EVT_CALLBACKS_END;
705 }
706 
HciEventOnIOCapabilityRequestEvent(Packet * packet)707 static void HciEventOnIOCapabilityRequestEvent(Packet *packet)
708 {
709     Buffer *payloadBuffer = PacketContinuousPayload(packet);
710     if (payloadBuffer == NULL) {
711         return;
712     }
713 
714     if (BufferGetSize(payloadBuffer) != sizeof(HciIoCapabilityRequestEventParam)) {
715         return;
716     }
717 
718     HciIoCapabilityRequestEventParam *param = (HciIoCapabilityRequestEventParam *)BufferPtr(payloadBuffer);
719     if (param == NULL) {
720         return;
721     }
722 
723     HciEventCallbacks *callbacks = NULL;
724     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
725     if (callbacks->ioCapabilityRequest != NULL) {
726         callbacks->ioCapabilityRequest(param);
727     }
728     HCI_FOREACH_EVT_CALLBACKS_END;
729 }
730 
HciEventOnIOCapabilityResponseEvent(Packet * packet)731 static void HciEventOnIOCapabilityResponseEvent(Packet *packet)
732 {
733     Buffer *payloadBuffer = PacketContinuousPayload(packet);
734     if (payloadBuffer == NULL) {
735         return;
736     }
737 
738     if (BufferGetSize(payloadBuffer) != sizeof(HciIoCapabilityResponseEventParam)) {
739         return;
740     }
741 
742     HciIoCapabilityResponseEventParam *param = (HciIoCapabilityResponseEventParam *)BufferPtr(payloadBuffer);
743     if (param == NULL) {
744         return;
745     }
746 
747     HciEventCallbacks *callbacks = NULL;
748     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
749     if (callbacks->ioCapabilityResponse != NULL) {
750         callbacks->ioCapabilityResponse(param);
751     }
752     HCI_FOREACH_EVT_CALLBACKS_END;
753 }
754 
HciEventOnUserConfirmationRequestEvent(Packet * packet)755 static void HciEventOnUserConfirmationRequestEvent(Packet *packet)
756 {
757     Buffer *payloadBuffer = PacketContinuousPayload(packet);
758     if (payloadBuffer == NULL) {
759         return;
760     }
761 
762     if (BufferGetSize(payloadBuffer) != sizeof(HciUserConfirmationRequestEventParam)) {
763         return;
764     }
765 
766     HciUserConfirmationRequestEventParam *param = (HciUserConfirmationRequestEventParam *)BufferPtr(payloadBuffer);
767     if (param == NULL) {
768         return;
769     }
770 
771     HciEventCallbacks *callbacks = NULL;
772     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
773     if (callbacks->userConfirmationRequest != NULL) {
774         callbacks->userConfirmationRequest(param);
775     }
776     HCI_FOREACH_EVT_CALLBACKS_END;
777 }
778 
HciEventOnUserPasskeyRequestEvent(Packet * packet)779 static void HciEventOnUserPasskeyRequestEvent(Packet *packet)
780 {
781     Buffer *payloadBuffer = PacketContinuousPayload(packet);
782     if (payloadBuffer == NULL) {
783         return;
784     }
785 
786     if (BufferGetSize(payloadBuffer) != sizeof(HciUserPasskeyRequestEventParam)) {
787         return;
788     }
789 
790     HciUserPasskeyRequestEventParam *param = (HciUserPasskeyRequestEventParam *)BufferPtr(payloadBuffer);
791     if (param == NULL) {
792         return;
793     }
794 
795     HciEventCallbacks *callbacks = NULL;
796     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
797     if (callbacks->userPasskeyRequest != NULL) {
798         callbacks->userPasskeyRequest(param);
799     }
800     HCI_FOREACH_EVT_CALLBACKS_END;
801 }
802 
HciEventOnRemoteOOBDataRequestEvent(Packet * packet)803 static void HciEventOnRemoteOOBDataRequestEvent(Packet *packet)
804 {
805     Buffer *payloadBuffer = PacketContinuousPayload(packet);
806     if (payloadBuffer == NULL) {
807         return;
808     }
809 
810     if (BufferGetSize(payloadBuffer) != sizeof(HciRemoteOobDataRequestEventParam)) {
811         return;
812     }
813 
814     HciRemoteOobDataRequestEventParam *param = (HciRemoteOobDataRequestEventParam *)BufferPtr(payloadBuffer);
815     if (param == NULL) {
816         return;
817     }
818 
819     HciEventCallbacks *callbacks = NULL;
820     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
821     if (callbacks->remoteOOBDataRequest != NULL) {
822         callbacks->remoteOOBDataRequest(param);
823     }
824     HCI_FOREACH_EVT_CALLBACKS_END;
825 }
826 
HciEventOnSimplePairingCompleteEvent(Packet * packet)827 static void HciEventOnSimplePairingCompleteEvent(Packet *packet)
828 {
829     Buffer *payloadBuffer = PacketContinuousPayload(packet);
830     if (payloadBuffer == NULL) {
831         return;
832     }
833 
834     if (BufferGetSize(payloadBuffer) != sizeof(HciSimplePairingCompleteEventParam)) {
835         return;
836     }
837 
838     HciSimplePairingCompleteEventParam *param = (HciSimplePairingCompleteEventParam *)BufferPtr(payloadBuffer);
839     if (param == NULL) {
840         return;
841     }
842 
843     HciEventCallbacks *callbacks = NULL;
844     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
845     if (callbacks->simplePairingComplete != NULL) {
846         callbacks->simplePairingComplete(param);
847     }
848     HCI_FOREACH_EVT_CALLBACKS_END;
849 }
850 
HciEventOnUserPasskeyNotificationEvent(Packet * packet)851 static void HciEventOnUserPasskeyNotificationEvent(Packet *packet)
852 {
853     Buffer *payloadBuffer = PacketContinuousPayload(packet);
854     if (payloadBuffer == NULL) {
855         return;
856     }
857 
858     if (BufferGetSize(payloadBuffer) != sizeof(HciUserPasskeyNotificationEventParam)) {
859         return;
860     }
861 
862     HciUserPasskeyNotificationEventParam *param = (HciUserPasskeyNotificationEventParam *)BufferPtr(payloadBuffer);
863     if (param == NULL) {
864         return;
865     }
866 
867     HciEventCallbacks *callbacks = NULL;
868     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
869     if (callbacks->userPasskeyNotification != NULL) {
870         callbacks->userPasskeyNotification(param);
871     }
872     HCI_FOREACH_EVT_CALLBACKS_END;
873 }
874 
HciEventOnKeypressNotificationEvent(Packet * packet)875 static void HciEventOnKeypressNotificationEvent(Packet *packet)
876 {
877     Buffer *payloadBuffer = PacketContinuousPayload(packet);
878     if (payloadBuffer == NULL) {
879         return;
880     }
881 
882     if (BufferGetSize(payloadBuffer) != sizeof(HciKeypressNotificationEventParam)) {
883         return;
884     }
885 
886     HciKeypressNotificationEventParam *param = (HciKeypressNotificationEventParam *)BufferPtr(payloadBuffer);
887     if (param == NULL) {
888         return;
889     }
890 
891     HciEventCallbacks *callbacks = NULL;
892     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
893     if (callbacks->keypressNotification != NULL) {
894         callbacks->keypressNotification(param);
895     }
896     HCI_FOREACH_EVT_CALLBACKS_END;
897 }
898 
HciEventOnAuthenticatedPayloadTimeoutExpiredEvent(Packet * packet)899 static void HciEventOnAuthenticatedPayloadTimeoutExpiredEvent(Packet *packet)
900 {
901     Buffer *payloadBuffer = PacketContinuousPayload(packet);
902     if (payloadBuffer == NULL) {
903         return;
904     }
905     HciAuthenticatedPayloadTimeoutExpiredEventParam *param =
906         (HciAuthenticatedPayloadTimeoutExpiredEventParam *)BufferPtr(payloadBuffer);
907     if (param == NULL) {
908         return;
909     }
910     size_t length = BufferGetSize(payloadBuffer);
911     if (length != sizeof(HciAuthenticatedPayloadTimeoutExpiredEventParam)) {
912         return;
913     }
914 
915     HciEventCallbacks *callbacks = NULL;
916     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
917     if (callbacks->authenticatedPayloadTimeoutExpired != NULL) {
918         callbacks->authenticatedPayloadTimeoutExpired(param);
919     }
920     HCI_FOREACH_EVT_CALLBACKS_END;
921 }
922 
HciEventOnChangeConnectionLinkKeyCompleteEvent(Packet * packet)923 static void HciEventOnChangeConnectionLinkKeyCompleteEvent(Packet *packet)
924 {
925     Buffer *payloadBuffer = PacketContinuousPayload(packet);
926     if (payloadBuffer == NULL) {
927         return;
928     }
929 
930     if (BufferGetSize(payloadBuffer) != sizeof(HciChangeConnectionLinkKeyCompleteEventParam)) {
931         return;
932     }
933 
934     HciChangeConnectionLinkKeyCompleteEventParam *param =
935         (HciChangeConnectionLinkKeyCompleteEventParam *)BufferPtr(payloadBuffer);
936     if (param == NULL) {
937         return;
938     }
939 
940     HciEventCallbacks *callbacks = NULL;
941     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
942     if (callbacks->changeConnectionLinkKeyComplete != NULL) {
943         callbacks->changeConnectionLinkKeyComplete(param);
944     }
945     HCI_FOREACH_EVT_CALLBACKS_END;
946 }
947 
HciEventOnMasterLinkKeyCompleteEvent(Packet * packet)948 static void HciEventOnMasterLinkKeyCompleteEvent(Packet *packet)
949 {
950     Buffer *payloadBuffer = PacketContinuousPayload(packet);
951     if (payloadBuffer == NULL) {
952         return;
953     }
954 
955     if (BufferGetSize(payloadBuffer) != sizeof(HciMasterLinkKeyCompleteEventParam)) {
956         return;
957     }
958 
959     HciMasterLinkKeyCompleteEventParam *param = (HciMasterLinkKeyCompleteEventParam *)BufferPtr(payloadBuffer);
960     if (param == NULL) {
961         return;
962     }
963 
964     HciEventCallbacks *callbacks = NULL;
965     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
966     if (callbacks->masterLinkKeyComplete != NULL) {
967         callbacks->masterLinkKeyComplete(param);
968     }
969     HCI_FOREACH_EVT_CALLBACKS_END;
970 }
971 
HciEventOnQoSSetupCompleteEvent(Packet * packet)972 static void HciEventOnQoSSetupCompleteEvent(Packet *packet)
973 {
974     Buffer *payloadBuffer = PacketContinuousPayload(packet);
975     if (payloadBuffer == NULL) {
976         return;
977     }
978 
979     if (BufferGetSize(payloadBuffer) != sizeof(HciQosSetupCompleteEventParam)) {
980         return;
981     }
982 
983     HciQosSetupCompleteEventParam *param = (HciQosSetupCompleteEventParam *)BufferPtr(payloadBuffer);
984     if (param == NULL) {
985         return;
986     }
987 
988     HciEventCallbacks *callbacks = NULL;
989     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
990     if (callbacks->qosSetupComplete != NULL) {
991         callbacks->qosSetupComplete(param);
992     }
993     HCI_FOREACH_EVT_CALLBACKS_END;
994 }
995 
HciEventOnHardwareErrorEvent(Packet * packet)996 static void HciEventOnHardwareErrorEvent(Packet *packet)
997 {
998     Buffer *payloadBuffer = PacketContinuousPayload(packet);
999     if (payloadBuffer == NULL) {
1000         return;
1001     }
1002 
1003     if (BufferGetSize(payloadBuffer) != sizeof(HciHardwareErrorEventParam)) {
1004         return;
1005     }
1006 
1007     HciHardwareErrorEventParam *param = (HciHardwareErrorEventParam *)BufferPtr(payloadBuffer);
1008     if (param == NULL) {
1009         return;
1010     }
1011 
1012     HciEventCallbacks *callbacks = NULL;
1013     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1014     if (callbacks->hardwareError != NULL) {
1015         callbacks->hardwareError(param);
1016     }
1017     HCI_FOREACH_EVT_CALLBACKS_END;
1018 }
1019 
HciEventOnFlushOccurredEvent(Packet * packet)1020 static void HciEventOnFlushOccurredEvent(Packet *packet)
1021 {
1022     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1023     if (payloadBuffer == NULL) {
1024         return;
1025     }
1026 
1027     if (BufferGetSize(payloadBuffer) != sizeof(HciFlushOccurredEventParam)) {
1028         return;
1029     }
1030 
1031     HciFlushOccurredEventParam *param = (HciFlushOccurredEventParam *)BufferPtr(payloadBuffer);
1032     if (param == NULL) {
1033         return;
1034     }
1035 
1036     HciEventCallbacks *callbacks = NULL;
1037     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1038     if (callbacks->flushOccurred != NULL) {
1039         callbacks->flushOccurred(param);
1040     }
1041     HCI_FOREACH_EVT_CALLBACKS_END;
1042 }
1043 
HciEventOnRoleChangeEvent(Packet * packet)1044 static void HciEventOnRoleChangeEvent(Packet *packet)
1045 {
1046     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1047     if (payloadBuffer == NULL) {
1048         return;
1049     }
1050 
1051     if (BufferGetSize(payloadBuffer) != sizeof(HciRoleChangeEventParam)) {
1052         return;
1053     }
1054 
1055     HciRoleChangeEventParam *param = (HciRoleChangeEventParam *)BufferPtr(payloadBuffer);
1056     if (param == NULL) {
1057         return;
1058     }
1059 
1060     HciEventCallbacks *callbacks = NULL;
1061     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1062     if (callbacks->roleChange != NULL) {
1063         callbacks->roleChange(param);
1064     }
1065     HCI_FOREACH_EVT_CALLBACKS_END;
1066 }
1067 
HciEventOnReturnLinkKeysEvent(Packet * packet)1068 static void HciEventOnReturnLinkKeysEvent(Packet *packet)
1069 {
1070     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1071     if (payloadBuffer == NULL) {
1072         return;
1073     }
1074 
1075     if (BufferGetSize(payloadBuffer) != sizeof(HciReturnLinkKeysEventParam)) {
1076         return;
1077     }
1078 
1079     HciReturnLinkKeysEventParam *param = (HciReturnLinkKeysEventParam *)BufferPtr(payloadBuffer);
1080     if (param == NULL) {
1081         return;
1082     }
1083 
1084     HciEventCallbacks *callbacks = NULL;
1085     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1086     if (callbacks->returnLinkKeys != NULL) {
1087         callbacks->returnLinkKeys(param);
1088     }
1089     HCI_FOREACH_EVT_CALLBACKS_END;
1090 }
1091 
HciEventOnDataBufferOverflowEvent(Packet * packet)1092 static void HciEventOnDataBufferOverflowEvent(Packet *packet)
1093 {
1094     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1095     if (payloadBuffer == NULL) {
1096         return;
1097     }
1098 
1099     if (BufferGetSize(payloadBuffer) != sizeof(HciDataBufferOverflowEventParam)) {
1100         return;
1101     }
1102 
1103     HciDataBufferOverflowEventParam *param = (HciDataBufferOverflowEventParam *)BufferPtr(payloadBuffer);
1104     if (param == NULL) {
1105         return;
1106     }
1107 
1108     HciEventCallbacks *callbacks = NULL;
1109     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1110     if (callbacks->dataBufferOverflow != NULL) {
1111         callbacks->dataBufferOverflow(param);
1112     }
1113     HCI_FOREACH_EVT_CALLBACKS_END;
1114 }
1115 
HciEventOnMaxSlotsChangeEvent(Packet * packet)1116 static void HciEventOnMaxSlotsChangeEvent(Packet *packet)
1117 {
1118     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1119     if (payloadBuffer == NULL) {
1120         return;
1121     }
1122 
1123     if (BufferGetSize(payloadBuffer) != sizeof(HciMaxSlotsChangeEventParam)) {
1124         return;
1125     }
1126 
1127     HciMaxSlotsChangeEventParam *param = (HciMaxSlotsChangeEventParam *)BufferPtr(payloadBuffer);
1128     if (param == NULL) {
1129         return;
1130     }
1131 
1132     HciEventCallbacks *callbacks = NULL;
1133     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1134     if (callbacks->maxSlotsChange != NULL) {
1135         callbacks->maxSlotsChange(param);
1136     }
1137     HCI_FOREACH_EVT_CALLBACKS_END;
1138 }
1139 
HciEventOnReadClockOffsetCompleteEvent(Packet * packet)1140 static void HciEventOnReadClockOffsetCompleteEvent(Packet *packet)
1141 {
1142     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1143     if (payloadBuffer == NULL) {
1144         return;
1145     }
1146 
1147     if (BufferGetSize(payloadBuffer) != sizeof(HciReadClockOffsetCompleteEventParam)) {
1148         return;
1149     }
1150 
1151     HciReadClockOffsetCompleteEventParam *param = (HciReadClockOffsetCompleteEventParam *)BufferPtr(payloadBuffer);
1152     if (param == NULL) {
1153         return;
1154     }
1155 
1156     HciEventCallbacks *callbacks = NULL;
1157     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1158     if (callbacks->readClockOffsetComplete != NULL) {
1159         callbacks->readClockOffsetComplete(param);
1160     }
1161     HCI_FOREACH_EVT_CALLBACKS_END;
1162 }
1163 
HciEventOnConnectionPacketTypeChangedEvent(Packet * packet)1164 static void HciEventOnConnectionPacketTypeChangedEvent(Packet *packet)
1165 {
1166     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1167     if (payloadBuffer == NULL) {
1168         return;
1169     }
1170 
1171     if (BufferGetSize(payloadBuffer) != sizeof(HciConnectionPacketTypeChangedEventParam)) {
1172         return;
1173     }
1174 
1175     HciConnectionPacketTypeChangedEventParam *param =
1176         (HciConnectionPacketTypeChangedEventParam *)BufferPtr(payloadBuffer);
1177     if (param == NULL) {
1178         return;
1179     }
1180 
1181     HciEventCallbacks *callbacks = NULL;
1182     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1183     if (callbacks->connectionPacketTypeChanged != NULL) {
1184         callbacks->connectionPacketTypeChanged(param);
1185     }
1186     HCI_FOREACH_EVT_CALLBACKS_END;
1187 }
1188 
HciEventOnQoSViolationEvent(Packet * packet)1189 static void HciEventOnQoSViolationEvent(Packet *packet)
1190 {
1191     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1192     if (payloadBuffer == NULL) {
1193         return;
1194     }
1195 
1196     if (BufferGetSize(payloadBuffer) != sizeof(HciQosViolationEventParam)) {
1197         return;
1198     }
1199 
1200     HciQosViolationEventParam *param = (HciQosViolationEventParam *)BufferPtr(payloadBuffer);
1201     if (param == NULL) {
1202         return;
1203     }
1204 
1205     HciEventCallbacks *callbacks = NULL;
1206     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1207     if (callbacks->qoSViolation != NULL) {
1208         callbacks->qoSViolation(param);
1209     }
1210     HCI_FOREACH_EVT_CALLBACKS_END;
1211 }
1212 
HciEventOnPageScanRepetitionModeChangeEvent(Packet * packet)1213 static void HciEventOnPageScanRepetitionModeChangeEvent(Packet *packet)
1214 {
1215     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1216     if (payloadBuffer == NULL) {
1217         return;
1218     }
1219 
1220     if (BufferGetSize(payloadBuffer) != sizeof(HciPageScanRepetitionModeChangeEventParam)) {
1221         return;
1222     }
1223 
1224     HciPageScanRepetitionModeChangeEventParam *param =
1225         (HciPageScanRepetitionModeChangeEventParam *)BufferPtr(payloadBuffer);
1226     if (param == NULL) {
1227         return;
1228     }
1229 
1230     HciEventCallbacks *callbacks = NULL;
1231     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1232     if (callbacks->pageScanRepetitionModeChange != NULL) {
1233         callbacks->pageScanRepetitionModeChange(param);
1234     }
1235     HCI_FOREACH_EVT_CALLBACKS_END;
1236 }
1237 
HciEventOnFlowSpecificationCompleteEvent(Packet * packet)1238 static void HciEventOnFlowSpecificationCompleteEvent(Packet *packet)
1239 {
1240     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1241     if (payloadBuffer == NULL) {
1242         return;
1243     }
1244 
1245     if (BufferGetSize(payloadBuffer) != sizeof(HciFlowSpecificationCompleteEventParam)) {
1246         return;
1247     }
1248 
1249     HciFlowSpecificationCompleteEventParam *param = (HciFlowSpecificationCompleteEventParam *)BufferPtr(payloadBuffer);
1250     if (param == NULL) {
1251         return;
1252     }
1253 
1254     HciEventCallbacks *callbacks = NULL;
1255     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1256     if (callbacks->flowSpecificationComplete != NULL) {
1257         callbacks->flowSpecificationComplete(param);
1258     }
1259     HCI_FOREACH_EVT_CALLBACKS_END;
1260 }
1261 
HciEventOnSniffSubratingEvent(Packet * packet)1262 static void HciEventOnSniffSubratingEvent(Packet *packet)
1263 {
1264     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1265     if (payloadBuffer == NULL) {
1266         return;
1267     }
1268 
1269     if (BufferGetSize(payloadBuffer) != sizeof(HciSniffSubratingEventParam)) {
1270         return;
1271     }
1272 
1273     HciSniffSubratingEventParam *param = (HciSniffSubratingEventParam *)BufferPtr(payloadBuffer);
1274     if (param == NULL) {
1275         return;
1276     }
1277 
1278     HciEventCallbacks *callbacks = NULL;
1279     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1280     if (callbacks->sniffSubrating != NULL) {
1281         callbacks->sniffSubrating(param);
1282     }
1283     HCI_FOREACH_EVT_CALLBACKS_END;
1284 }
1285 
HciEventOnLinkSupervisionTimeoutChangedEvent(Packet * packet)1286 static void HciEventOnLinkSupervisionTimeoutChangedEvent(Packet *packet)
1287 {
1288     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1289     if (payloadBuffer == NULL) {
1290         return;
1291     }
1292 
1293     if (BufferGetSize(payloadBuffer) != sizeof(HciLinkSupervisionTimeoutChangedEventParam)) {
1294         return;
1295     }
1296 
1297     HciLinkSupervisionTimeoutChangedEventParam *param =
1298         (HciLinkSupervisionTimeoutChangedEventParam *)BufferPtr(payloadBuffer);
1299     if (param == NULL) {
1300         return;
1301     }
1302 
1303     HciEventCallbacks *callbacks = NULL;
1304     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1305     if (callbacks->linkSupervisionTimeoutChanged != NULL) {
1306         callbacks->linkSupervisionTimeoutChanged(param);
1307     }
1308     HCI_FOREACH_EVT_CALLBACKS_END;
1309 }
1310 
HciEventOnEnhancedFlushCompleteEvent(Packet * packet)1311 static void HciEventOnEnhancedFlushCompleteEvent(Packet *packet)
1312 {
1313     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1314     if (payloadBuffer == NULL) {
1315         return;
1316     }
1317 
1318     if (BufferGetSize(payloadBuffer) != sizeof(HciEnhancedFlushCompleteEventParam)) {
1319         return;
1320     }
1321 
1322     HciEnhancedFlushCompleteEventParam *param = (HciEnhancedFlushCompleteEventParam *)BufferPtr(payloadBuffer);
1323     if (param == NULL) {
1324         return;
1325     }
1326 
1327     HciEventCallbacks *callbacks = NULL;
1328     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1329     if (callbacks->enhancedFlushComplete != NULL) {
1330         callbacks->enhancedFlushComplete(param);
1331     }
1332     HCI_FOREACH_EVT_CALLBACKS_END;
1333 }
1334 
HciEventOnPhysicalLinkCompleteEvent(Packet * packet)1335 static void HciEventOnPhysicalLinkCompleteEvent(Packet *packet)
1336 {
1337     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1338     if (payloadBuffer == NULL) {
1339         return;
1340     }
1341 
1342     if (BufferGetSize(payloadBuffer) != sizeof(HciPhysicalLinkCompleteEventParam)) {
1343         return;
1344     }
1345 
1346     HciPhysicalLinkCompleteEventParam *param = (HciPhysicalLinkCompleteEventParam *)BufferPtr(payloadBuffer);
1347     if (param == NULL) {
1348         return;
1349     }
1350 
1351     HciEventCallbacks *callbacks = NULL;
1352     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1353     if (callbacks->physicalLinkComplete != NULL) {
1354         callbacks->physicalLinkComplete(param);
1355     }
1356     HCI_FOREACH_EVT_CALLBACKS_END;
1357 }
1358 
HciEventOnChannelSelectedEvent(Packet * packet)1359 static void HciEventOnChannelSelectedEvent(Packet *packet)
1360 {
1361     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1362     if (payloadBuffer == NULL) {
1363         return;
1364     }
1365 
1366     if (BufferGetSize(payloadBuffer) != sizeof(HciChannelSelectedEventParam)) {
1367         return;
1368     }
1369 
1370     HciChannelSelectedEventParam *param = (HciChannelSelectedEventParam *)BufferPtr(payloadBuffer);
1371     if (param == NULL) {
1372         return;
1373     }
1374 
1375     HciEventCallbacks *callbacks = NULL;
1376     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1377     if (callbacks->channelSelected != NULL) {
1378         callbacks->channelSelected(param);
1379     }
1380     HCI_FOREACH_EVT_CALLBACKS_END;
1381 }
1382 
HciEventOnDisconnectionPhysicalLinkCompleteEvent(Packet * packet)1383 static void HciEventOnDisconnectionPhysicalLinkCompleteEvent(Packet *packet)
1384 {
1385     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1386     if (payloadBuffer == NULL) {
1387         return;
1388     }
1389 
1390     if (BufferGetSize(payloadBuffer) != sizeof(HciDisconnectionPhysicalLinkCompleteEventParam)) {
1391         return;
1392     }
1393 
1394     HciDisconnectionPhysicalLinkCompleteEventParam *param =
1395         (HciDisconnectionPhysicalLinkCompleteEventParam *)BufferPtr(payloadBuffer);
1396     if (param == NULL) {
1397         return;
1398     }
1399 
1400     HciEventCallbacks *callbacks = NULL;
1401     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1402     if (callbacks->disconnectionPhysicalLinkComplete != NULL) {
1403         callbacks->disconnectionPhysicalLinkComplete(param);
1404     }
1405     HCI_FOREACH_EVT_CALLBACKS_END;
1406 }
1407 
HciEventOnPhysicalLinkLossEarlyWarningEvent(Packet * packet)1408 static void HciEventOnPhysicalLinkLossEarlyWarningEvent(Packet *packet)
1409 {
1410     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1411     if (payloadBuffer == NULL) {
1412         return;
1413     }
1414 
1415     if (BufferGetSize(payloadBuffer) != sizeof(HciPhysicalLinkLossEarlyWarningEventParam)) {
1416         return;
1417     }
1418 
1419     HciPhysicalLinkLossEarlyWarningEventParam *param =
1420         (HciPhysicalLinkLossEarlyWarningEventParam *)BufferPtr(payloadBuffer);
1421     if (param == NULL) {
1422         return;
1423     }
1424 
1425     HciEventCallbacks *callbacks = NULL;
1426     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1427     if (callbacks->physicalLinkLossEarlyWarning != NULL) {
1428         callbacks->physicalLinkLossEarlyWarning(param);
1429     }
1430     HCI_FOREACH_EVT_CALLBACKS_END;
1431 }
1432 
HciEventOnPhysicalLinkRecoveryEvent(Packet * packet)1433 static void HciEventOnPhysicalLinkRecoveryEvent(Packet *packet)
1434 {
1435     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1436     if (payloadBuffer == NULL) {
1437         return;
1438     }
1439 
1440     if (BufferGetSize(payloadBuffer) != sizeof(HciPhysicalLinkRecoveryEventParam)) {
1441         return;
1442     }
1443 
1444     HciPhysicalLinkRecoveryEventParam *param = (HciPhysicalLinkRecoveryEventParam *)BufferPtr(payloadBuffer);
1445     if (param == NULL) {
1446         return;
1447     }
1448 
1449     HciEventCallbacks *callbacks = NULL;
1450     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1451     if (callbacks->physicalLinkRecovery != NULL) {
1452         callbacks->physicalLinkRecovery(param);
1453     }
1454     HCI_FOREACH_EVT_CALLBACKS_END;
1455 }
1456 
HciEventOnLogicalLinkCompleteEvent(Packet * packet)1457 static void HciEventOnLogicalLinkCompleteEvent(Packet *packet)
1458 {
1459     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1460     if (payloadBuffer == NULL) {
1461         return;
1462     }
1463 
1464     if (BufferGetSize(payloadBuffer) != sizeof(HciLogicalLinkCompleteEventParam)) {
1465         return;
1466     }
1467 
1468     HciLogicalLinkCompleteEventParam *param = (HciLogicalLinkCompleteEventParam *)BufferPtr(payloadBuffer);
1469     if (param == NULL) {
1470         return;
1471     }
1472 
1473     HciEventCallbacks *callbacks = NULL;
1474     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1475     if (callbacks->logicalLinkComplete != NULL) {
1476         callbacks->logicalLinkComplete(param);
1477     }
1478     HCI_FOREACH_EVT_CALLBACKS_END;
1479 }
1480 
HciEventOnDisconnectionLogicalLinkCompleteEvent(Packet * packet)1481 static void HciEventOnDisconnectionLogicalLinkCompleteEvent(Packet *packet)
1482 {
1483     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1484     if (payloadBuffer == NULL) {
1485         return;
1486     }
1487 
1488     if (BufferGetSize(payloadBuffer) != sizeof(HciDisconnectionLogicalLinkCompleteEventParam)) {
1489         return;
1490     }
1491 
1492     HciDisconnectionLogicalLinkCompleteEventParam *param =
1493         (HciDisconnectionLogicalLinkCompleteEventParam *)BufferPtr(payloadBuffer);
1494     if (param == NULL) {
1495         return;
1496     }
1497 
1498     HciEventCallbacks *callbacks = NULL;
1499     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1500     if (callbacks->disconnectionLogicalLinkComplete != NULL) {
1501         callbacks->disconnectionLogicalLinkComplete(param);
1502     }
1503     HCI_FOREACH_EVT_CALLBACKS_END;
1504 }
1505 
HciEventOnFlowSpecModifyCompleteEvent(Packet * packet)1506 static void HciEventOnFlowSpecModifyCompleteEvent(Packet *packet)
1507 {
1508     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1509     if (payloadBuffer == NULL) {
1510         return;
1511     }
1512 
1513     if (BufferGetSize(payloadBuffer) != sizeof(HciFlowSpecModifyCompleteEventParam)) {
1514         return;
1515     }
1516 
1517     HciFlowSpecModifyCompleteEventParam *param = (HciFlowSpecModifyCompleteEventParam *)BufferPtr(payloadBuffer);
1518     if (param == NULL) {
1519         return;
1520     }
1521 
1522     HciEventCallbacks *callbacks = NULL;
1523     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1524     if (callbacks->flowSpecModifyComplete != NULL) {
1525         callbacks->flowSpecModifyComplete(param);
1526     }
1527     HCI_FOREACH_EVT_CALLBACKS_END;
1528 }
1529 
HciEventOnNumberOfCompletedDataBlocksEvent(Packet * packet)1530 static void HciEventOnNumberOfCompletedDataBlocksEvent(Packet *packet)
1531 {
1532     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1533     if (payloadBuffer == NULL) {
1534         return;
1535     }
1536 
1537     if (BufferGetSize(payloadBuffer) != sizeof(HciNumberOfCompletedDataBlocksEventParam)) {
1538         return;
1539     }
1540 
1541     HciNumberOfCompletedDataBlocksEventParam *param =
1542         (HciNumberOfCompletedDataBlocksEventParam *)BufferPtr(payloadBuffer);
1543     if (param == NULL) {
1544         return;
1545     }
1546 
1547     HciEventCallbacks *callbacks = NULL;
1548     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1549     if (callbacks->numberOfCompletedDataBlocks != NULL) {
1550         callbacks->numberOfCompletedDataBlocks(param);
1551     }
1552     HCI_FOREACH_EVT_CALLBACKS_END;
1553 }
1554 
HciEventOnShortRangeModeChangeCompleteEvent(Packet * packet)1555 static void HciEventOnShortRangeModeChangeCompleteEvent(Packet *packet)
1556 {
1557     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1558     if (payloadBuffer == NULL) {
1559         return;
1560     }
1561 
1562     if (BufferGetSize(payloadBuffer) != sizeof(HciShortRangeModeChangeCompleteEventParam)) {
1563         return;
1564     }
1565 
1566     HciShortRangeModeChangeCompleteEventParam *param =
1567         (HciShortRangeModeChangeCompleteEventParam *)BufferPtr(payloadBuffer);
1568     if (param == NULL) {
1569         return;
1570     }
1571 
1572     HciEventCallbacks *callbacks = NULL;
1573     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1574     if (callbacks->shortRangeModeChangeComplete != NULL) {
1575         callbacks->shortRangeModeChangeComplete(param);
1576     }
1577     HCI_FOREACH_EVT_CALLBACKS_END;
1578 }
1579 
HciEventOnAMPStatusChangeEvent(Packet * packet)1580 static void HciEventOnAMPStatusChangeEvent(Packet *packet)
1581 {
1582     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1583     if (payloadBuffer == NULL) {
1584         return;
1585     }
1586 
1587     if (BufferGetSize(payloadBuffer) != sizeof(HciAmpStatusChangeEventParam)) {
1588         return;
1589     }
1590 
1591     HciAmpStatusChangeEventParam *param = (HciAmpStatusChangeEventParam *)BufferPtr(payloadBuffer);
1592     if (param == NULL) {
1593         return;
1594     }
1595 
1596     HciEventCallbacks *callbacks = NULL;
1597     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1598     if (callbacks->ampStatusChange != NULL) {
1599         callbacks->ampStatusChange(param);
1600     }
1601     HCI_FOREACH_EVT_CALLBACKS_END;
1602 }
1603 
HciEventOnAMPStartTestEvent(Packet * packet)1604 static void HciEventOnAMPStartTestEvent(Packet *packet)
1605 {
1606     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1607     if (payloadBuffer == NULL) {
1608         return;
1609     }
1610 
1611     if (BufferGetSize(payloadBuffer) != sizeof(HciAmpStartTestEventParam)) {
1612         return;
1613     }
1614 
1615     HciAmpStartTestEventParam *param = (HciAmpStartTestEventParam *)BufferPtr(payloadBuffer);
1616     if (param == NULL) {
1617         return;
1618     }
1619 
1620     HciEventCallbacks *callbacks = NULL;
1621     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1622     if (callbacks->ampStartTest != NULL) {
1623         callbacks->ampStartTest(param);
1624     }
1625     HCI_FOREACH_EVT_CALLBACKS_END;
1626 }
1627 
HciEventOnAMPTestEndEvent(Packet * packet)1628 static void HciEventOnAMPTestEndEvent(Packet *packet)
1629 {
1630     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1631     if (payloadBuffer == NULL) {
1632         return;
1633     }
1634 
1635     if (BufferGetSize(payloadBuffer) != sizeof(HciAmpTestEndEventParam)) {
1636         return;
1637     }
1638 
1639     HciAmpTestEndEventParam *param = (HciAmpTestEndEventParam *)BufferPtr(payloadBuffer);
1640     if (param == NULL) {
1641         return;
1642     }
1643 
1644     HciEventCallbacks *callbacks = NULL;
1645     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1646     if (callbacks->ampTestEnd != NULL) {
1647         callbacks->ampTestEnd(param);
1648     }
1649     HCI_FOREACH_EVT_CALLBACKS_END;
1650 }
1651 
HciEventOnAMPReceiverReportEvent(Packet * packet)1652 static void HciEventOnAMPReceiverReportEvent(Packet *packet)
1653 {
1654     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1655     if (payloadBuffer == NULL) {
1656         return;
1657     }
1658 
1659     if (BufferGetSize(payloadBuffer) != sizeof(HciAmpReceiverReportEventParam)) {
1660         return;
1661     }
1662 
1663     HciAmpReceiverReportEventParam *param = (HciAmpReceiverReportEventParam *)BufferPtr(payloadBuffer);
1664     if (param == NULL) {
1665         return;
1666     }
1667 
1668     HciEventCallbacks *callbacks = NULL;
1669     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1670     if (callbacks->ampReceiverReport != NULL) {
1671         callbacks->ampReceiverReport(param);
1672     }
1673     HCI_FOREACH_EVT_CALLBACKS_END;
1674 }
1675 
HciEventOnTriggeredClockCaptureEvent(Packet * packet)1676 static void HciEventOnTriggeredClockCaptureEvent(Packet *packet)
1677 {
1678     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1679     if (payloadBuffer == NULL) {
1680         return;
1681     }
1682 
1683     if (BufferGetSize(payloadBuffer) != sizeof(HciTriggeredClockCaptureEventParam)) {
1684         return;
1685     }
1686 
1687     HciTriggeredClockCaptureEventParam *param = (HciTriggeredClockCaptureEventParam *)BufferPtr(payloadBuffer);
1688     if (param == NULL) {
1689         return;
1690     }
1691 
1692     HciEventCallbacks *callbacks = NULL;
1693     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1694     if (callbacks->triggeredClockCapture != NULL) {
1695         callbacks->triggeredClockCapture(param);
1696     }
1697     HCI_FOREACH_EVT_CALLBACKS_END;
1698 }
1699 
HciEventOnSynchronizationTrainCompleteEvent(Packet * packet)1700 static void HciEventOnSynchronizationTrainCompleteEvent(Packet *packet)
1701 {
1702     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1703     if (payloadBuffer == NULL) {
1704         return;
1705     }
1706 
1707     if (BufferGetSize(payloadBuffer) != sizeof(HciSynchronizationTrainCompleteEventParam)) {
1708         return;
1709     }
1710 
1711     HciSynchronizationTrainCompleteEventParam *param =
1712         (HciSynchronizationTrainCompleteEventParam *)BufferPtr(payloadBuffer);
1713     if (param == NULL) {
1714         return;
1715     }
1716 
1717     HciEventCallbacks *callbacks = NULL;
1718     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1719     if (callbacks->synchronizationTrainComplete != NULL) {
1720         callbacks->synchronizationTrainComplete(param);
1721     }
1722     HCI_FOREACH_EVT_CALLBACKS_END;
1723 }
1724 
HciEventOnSynchronizationTrainReceivedEvent(Packet * packet)1725 static void HciEventOnSynchronizationTrainReceivedEvent(Packet *packet)
1726 {
1727     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1728     if (payloadBuffer == NULL) {
1729         return;
1730     }
1731 
1732     if (BufferGetSize(payloadBuffer) != sizeof(HciSynchronizationTrainReceivedEventParam)) {
1733         return;
1734     }
1735 
1736     HciSynchronizationTrainReceivedEventParam *param =
1737         (HciSynchronizationTrainReceivedEventParam *)BufferPtr(payloadBuffer);
1738     if (param == NULL) {
1739         return;
1740     }
1741 
1742     HciEventCallbacks *callbacks = NULL;
1743     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1744     if (callbacks->synchronizationTrainReceived != NULL) {
1745         callbacks->synchronizationTrainReceived(param);
1746     }
1747     HCI_FOREACH_EVT_CALLBACKS_END;
1748 }
1749 
HciEventOnConnectionlessSlaveBroadcastReceiveEvent(Packet * packet)1750 static void HciEventOnConnectionlessSlaveBroadcastReceiveEvent(Packet *packet)
1751 {
1752     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1753     if (payloadBuffer == NULL) {
1754         return;
1755     }
1756 
1757     if (BufferGetSize(payloadBuffer) != sizeof(HciConnectionlessSlaveBroadcastReceiveEventParam)) {
1758         return;
1759     }
1760 
1761     HciConnectionlessSlaveBroadcastReceiveEventParam *param =
1762         (HciConnectionlessSlaveBroadcastReceiveEventParam *)BufferPtr(payloadBuffer);
1763     if (param == NULL) {
1764         return;
1765     }
1766 
1767     HciEventCallbacks *callbacks = NULL;
1768     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1769     if (callbacks->connectionlessSlaveBroadcastReceive != NULL) {
1770         callbacks->connectionlessSlaveBroadcastReceive(param);
1771     }
1772     HCI_FOREACH_EVT_CALLBACKS_END;
1773 }
1774 
HciEventOnConnectionlessSlaveBroadcastTimeoutEvent(Packet * packet)1775 static void HciEventOnConnectionlessSlaveBroadcastTimeoutEvent(Packet *packet)
1776 {
1777     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1778     if (payloadBuffer == NULL) {
1779         return;
1780     }
1781 
1782     if (BufferGetSize(payloadBuffer) != sizeof(HciConnectionlessSlaveBroadcastTimeoutEventParam)) {
1783         return;
1784     }
1785 
1786     HciConnectionlessSlaveBroadcastTimeoutEventParam *param =
1787         (HciConnectionlessSlaveBroadcastTimeoutEventParam *)BufferPtr(payloadBuffer);
1788     if (param == NULL) {
1789         return;
1790     }
1791 
1792     HciEventCallbacks *callbacks = NULL;
1793     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1794     if (callbacks->connectionlessSlaveBroadcastTimeout != NULL) {
1795         callbacks->connectionlessSlaveBroadcastTimeout(param);
1796     }
1797     HCI_FOREACH_EVT_CALLBACKS_END;
1798 }
1799 
HciEventOnTruncatedPageCompleteEvent(Packet * packet)1800 static void HciEventOnTruncatedPageCompleteEvent(Packet *packet)
1801 {
1802     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1803     if (payloadBuffer == NULL) {
1804         return;
1805     }
1806 
1807     if (BufferGetSize(payloadBuffer) != sizeof(HciTruncatedPageCompleteEventParam)) {
1808         return;
1809     }
1810 
1811     HciTruncatedPageCompleteEventParam *param = (HciTruncatedPageCompleteEventParam *)BufferPtr(payloadBuffer);
1812     if (param == NULL) {
1813         return;
1814     }
1815 
1816     HciEventCallbacks *callbacks = NULL;
1817     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1818     if (callbacks->truncatedPageComplete != NULL) {
1819         callbacks->truncatedPageComplete(param);
1820     }
1821     HCI_FOREACH_EVT_CALLBACKS_END;
1822 }
1823 
HciEventOnConnectionlessSlaveBroadcastChannelMapChangeEvent(Packet * packet)1824 static void HciEventOnConnectionlessSlaveBroadcastChannelMapChangeEvent(Packet *packet)
1825 {
1826     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1827     if (payloadBuffer == NULL) {
1828         return;
1829     }
1830 
1831     if (BufferGetSize(payloadBuffer) != sizeof(HciConnectionlessSlaveBroadcastChannelMapChangeEventParam)) {
1832         return;
1833     }
1834 
1835     HciConnectionlessSlaveBroadcastChannelMapChangeEventParam *param =
1836         (HciConnectionlessSlaveBroadcastChannelMapChangeEventParam *)BufferPtr(payloadBuffer);
1837     if (param == NULL) {
1838         return;
1839     }
1840 
1841     HciEventCallbacks *callbacks = NULL;
1842     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1843     if (callbacks->connectionlessSlaveBroadcastChannelMapChange != NULL) {
1844         callbacks->connectionlessSlaveBroadcastChannelMapChange(param);
1845     }
1846     HCI_FOREACH_EVT_CALLBACKS_END;
1847 }
1848 
HciEventOnInquiryResponseNotificationEvent(Packet * packet)1849 static void HciEventOnInquiryResponseNotificationEvent(Packet *packet)
1850 {
1851     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1852     if (payloadBuffer == NULL) {
1853         return;
1854     }
1855 
1856     if (BufferGetSize(payloadBuffer) != sizeof(HciInquiryResponseNotificationEventParam)) {
1857         return;
1858     }
1859 
1860     HciInquiryResponseNotificationEventParam *param =
1861         (HciInquiryResponseNotificationEventParam *)BufferPtr(payloadBuffer);
1862     if (param == NULL) {
1863         return;
1864     }
1865 
1866     HciEventCallbacks *callbacks = NULL;
1867     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1868     if (callbacks->inquiryResponseNotification != NULL) {
1869         callbacks->inquiryResponseNotification(param);
1870     }
1871     HCI_FOREACH_EVT_CALLBACKS_END;
1872 }
1873 
HciEventOnSAMStatusChangeEvent(Packet * packet)1874 static void HciEventOnSAMStatusChangeEvent(Packet *packet)
1875 {
1876     Buffer *payloadBuffer = PacketContinuousPayload(packet);
1877     if (payloadBuffer == NULL) {
1878         return;
1879     }
1880 
1881     if (BufferGetSize(payloadBuffer) != sizeof(HciSamStatusChangeEventParam)) {
1882         return;
1883     }
1884 
1885     HciSamStatusChangeEventParam *param = (HciSamStatusChangeEventParam *)BufferPtr(payloadBuffer);
1886     if (param == NULL) {
1887         return;
1888     }
1889 
1890     HciEventCallbacks *callbacks = NULL;
1891     HCI_FOREACH_EVT_CALLBACKS_START(callbacks);
1892     if (callbacks->samStatusChange != NULL) {
1893         callbacks->samStatusChange(param);
1894     }
1895     HCI_FOREACH_EVT_CALLBACKS_END;
1896 }
1897 
1898 static HciEventFunc g_eventFuncMap[] = {
1899     NULL,                                                         // 0x00
1900     HciEventOnInquiryCompleteEvent,                               // 0x01
1901     HciEventOnInquiryResultEvent,                                 // 0x02
1902     HciEventOnConnectionCompleteEvent,                            // 0x03
1903     HciEventOnConnectionRequestEvent,                             // 0x04
1904     HciEventOnDisconnectCompeteEvent,                             // 0x05
1905     HciEventOnAuthencationCompleteEvent,                          // 0x06
1906     HciEventOnRemoteNameRequestCompleteEvent,                     // 0x07
1907     HciEventOnEncryptionChangeEvent,                              // 0x08
1908     HciEventOnChangeConnectionLinkKeyCompleteEvent,               // 0x09
1909     HciEventOnMasterLinkKeyCompleteEvent,                         // 0x0A
1910     HciEventOnReadRemoteSupportedFeaturesCompleteEvent,           // 0x0B
1911     HciEventOnReadRemoteVersionInformationCompleteEvent,          // 0x0C
1912     HciEventOnQoSSetupCompleteEvent,                              // 0x0D
1913     HciEventOnCommandCompleteEvent,                               // 0x0E
1914     HciEventOnCommandStatusEvent,                                 // 0x0F
1915     HciEventOnHardwareErrorEvent,                                 // 0x10
1916     HciEventOnFlushOccurredEvent,                                 // 0x11
1917     HciEventOnRoleChangeEvent,                                    // 0x12
1918     HciEventOnNumberOfCompletedPacketsEvent,                      // 0x13
1919     HciEventOnModeChangeEvent,                                    // 0x14
1920     HciEventOnReturnLinkKeysEvent,                                // 0x15
1921     HciEventOnPINCodeRequestEvent,                                // 0x16
1922     HciEventOnLinkKeyRequestEvent,                                // 0x17
1923     HciEventOnLinkKeyNotificationEvent,                           // 0x18
1924     HciEventOnReturnLinkKeysEvent,                                // 0x19
1925     HciEventOnDataBufferOverflowEvent,                            // 0x1A
1926     HciEventOnMaxSlotsChangeEvent,                                // 0x1B
1927     HciEventOnReadClockOffsetCompleteEvent,                       // 0x1C
1928     HciEventOnConnectionPacketTypeChangedEvent,                   // 0x1D
1929     HciEventOnQoSViolationEvent,                                  // 0x1E
1930     NULL,                                                         // 0x1F
1931     HciEventOnPageScanRepetitionModeChangeEvent,                  // 0x20
1932     HciEventOnFlowSpecificationCompleteEvent,                     // 0x21
1933     HciEventOnInquiryResultWithRSSIEvent,                         // 0x22
1934     HciEventOnReadRemoteExtendedFeaturesCompleteEvent,            // 0x23
1935     NULL,                                                         // 0x24
1936     NULL,                                                         // 0x25
1937     NULL,                                                         // 0x26
1938     NULL,                                                         // 0x27
1939     NULL,                                                         // 0x28
1940     NULL,                                                         // 0x29
1941     NULL,                                                         // 0x2A
1942     NULL,                                                         // 0x2B
1943     HciEventOnSynchronousConnectionCompleteEvent,                 // 0x2C
1944     HciEventOnSynchronousConnectionChangedEvent,                  // 0x2D
1945     HciEventOnSniffSubratingEvent,                                // 0x2E
1946     HciEventOnExtendedInquiryResultEvent,                         // 0x2F
1947     HciEventOnEncryptionKeyRefreshCompleteEvent,                  // 0x30
1948     HciEventOnIOCapabilityRequestEvent,                           // 0x31
1949     HciEventOnIOCapabilityResponseEvent,                          // 0x32
1950     HciEventOnUserConfirmationRequestEvent,                       // 0x33
1951     HciEventOnUserPasskeyRequestEvent,                            // 0x34
1952     HciEventOnRemoteOOBDataRequestEvent,                          // 0x35
1953     HciEventOnSimplePairingCompleteEvent,                         // 0x36
1954     NULL,                                                         // 0x37
1955     HciEventOnLinkSupervisionTimeoutChangedEvent,                 // 0x38
1956     HciEventOnEnhancedFlushCompleteEvent,                         // 0x39
1957     NULL,                                                         // 0x3A
1958     HciEventOnUserPasskeyNotificationEvent,                       // 0x3B
1959     HciEventOnKeypressNotificationEvent,                          // 0x3C
1960     HciEventOnRemoteHostSupportedFeaturesNotificationEvent,       // 0x3D
1961     HciEventOnLeMetaEvent,                                        // 0x3E
1962     NULL,                                                         // 0x3F
1963     HciEventOnPhysicalLinkCompleteEvent,                          // 0x40
1964     HciEventOnChannelSelectedEvent,                               // 0x41
1965     HciEventOnDisconnectionPhysicalLinkCompleteEvent,             // 0x42
1966     HciEventOnPhysicalLinkLossEarlyWarningEvent,                  // 0x43
1967     HciEventOnPhysicalLinkRecoveryEvent,                          // 0x44
1968     HciEventOnLogicalLinkCompleteEvent,                           // 0x45
1969     HciEventOnDisconnectionLogicalLinkCompleteEvent,              // 0x46
1970     HciEventOnFlowSpecModifyCompleteEvent,                        // 0x47
1971     HciEventOnNumberOfCompletedDataBlocksEvent,                   // 0x48
1972     HciEventOnAMPStartTestEvent,                                  // 0x49
1973     HciEventOnAMPTestEndEvent,                                    // 0x4A
1974     HciEventOnAMPReceiverReportEvent,                             // 0x4B
1975     HciEventOnShortRangeModeChangeCompleteEvent,                  // 0x4C
1976     HciEventOnAMPStatusChangeEvent,                               // 0x4D
1977     HciEventOnTriggeredClockCaptureEvent,                         // 0x4E
1978     HciEventOnSynchronizationTrainCompleteEvent,                  // 0x4F
1979     HciEventOnSynchronizationTrainReceivedEvent,                  // 0x50
1980     HciEventOnConnectionlessSlaveBroadcastReceiveEvent,           // 0x51
1981     HciEventOnConnectionlessSlaveBroadcastTimeoutEvent,           // 0x52
1982     HciEventOnTruncatedPageCompleteEvent,                         // 0x53
1983     HciEventOnConnectionlessSlaveBroadcastTimeoutEvent,           // 0x54
1984     HciEventOnConnectionlessSlaveBroadcastChannelMapChangeEvent,  // 0x55
1985     HciEventOnInquiryResponseNotificationEvent,                   // 0x56
1986     HciEventOnAuthenticatedPayloadTimeoutExpiredEvent,            // 0x57
1987     HciEventOnSAMStatusChangeEvent,                               // 0x58
1988 };
1989 
1990 #define EVENTCODE_MAX 0x58
1991 
HciOnEvent(Packet * packet)1992 void HciOnEvent(Packet *packet)
1993 {
1994     HciEventHeader header;
1995     PacketExtractHead(packet, (uint8_t *)&header, sizeof(header));
1996     size_t payloadLength = PacketPayloadSize(packet);
1997     if (payloadLength == header.parameterTotalLength) {
1998         if (header.eventCode > EVENTCODE_MAX) {
1999             return;
2000         }
2001 
2002         HciEventFunc func = g_eventFuncMap[header.eventCode];
2003         if (func != NULL) {
2004             func(packet);
2005         }
2006     }
2007 }
2008 
HCI_RegisterEventCallbacks(const HciEventCallbacks * callbacks)2009 int HCI_RegisterEventCallbacks(const HciEventCallbacks *callbacks)
2010 {
2011     MutexLock(g_lockCallbackList);
2012 
2013     ListAddLast(g_eventCallbackList, (void *)callbacks);
2014 
2015     MutexUnlock(g_lockCallbackList);
2016     return BT_SUCCESS;
2017 }
2018 
HCI_DeregisterEventCallbacks(const HciEventCallbacks * callbacks)2019 int HCI_DeregisterEventCallbacks(const HciEventCallbacks *callbacks)
2020 {
2021     MutexLock(g_lockCallbackList);
2022 
2023     ListRemoveNode(g_eventCallbackList, (void *)callbacks);
2024 
2025     MutexUnlock(g_lockCallbackList);
2026     return BT_SUCCESS;
2027 }
2028 
HciGetEventCallbackList()2029 List *HciGetEventCallbackList()
2030 {
2031     return g_eventCallbackList;
2032 }
2033 
HciGetEventCallbackListLock()2034 Mutex *HciGetEventCallbackListLock()
2035 {
2036     return g_lockCallbackList;
2037 }
2038