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 /**
17  * @file att_receive.c
18  *
19  * @brief implement receive function to be called.
20  *
21  */
22 
23 #include "att_receive.h"
24 
25 #include <memory.h>
26 
27 #include "buffer.h"
28 #include "list.h"
29 #include "packet.h"
30 
31 #include "gap_le_if.h"
32 
33 #include "platform/include/allocator.h"
34 
35 #include "log.h"
36 
37 typedef struct SigedWriteCommandConfirmationContext {
38     AttConnectInfo *connect;
39     Buffer *bufferallPtr;
40     uint8_t *data;
41     uint16_t bufferSize;
42 } SigedWriteCommandConfirmationContext;
43 
44 typedef struct AttGapSignatureConfirmationAsync {
45     GAP_SignatureResult result;
46     void *context;
47 } AttGapSignatureConfirmationAsync;
48 
49 static void AttCount(uint8_t format, uint16_t *inforLenPtr, uint16_t *uuidLenPtr);
50 static int AttJudgeInfoLen(uint16_t inforLen, size_t dataLen, uint16_t *inforNum);
51 static void AttFindInformationResAssign(uint16_t inforNum, AttFind *attFindObj, const uint8_t *data, uint16_t inforLen);
52 static void AttReadFree(AttRead *valueList, uint16_t num, uint8_t type);
53 static void AttReadAttrAssign(const AttRead *attReadPtr, uint8_t len, const uint8_t *data);
54 static void AttSignWriteCommConfContextAssign(SigedWriteCommandConfirmationContext *sigedWriteCommandConfirmContextPtr,
55     const AttConnectInfo *connect, const uint8_t *data, const Buffer *bufferallPtr, size_t buffSize);
56 static void AttSignWriteCommConfDataAssign(
57     uint8_t *data, const uint8_t *dataBuffer, size_t buffSize, uint8_t signature[12]);
58 static void AttSignedWriteCommandBufferFree(Buffer *bufferNew, Buffer *sigedWriteBuffPtr, Buffer *bufferallPtr);
59 static void AttReadByTypeResErrorAssign(AttError *attErrorObjPtr, const AttConnectInfo *connect);
60 static void AttGapSignatureConfirmationResultAsync(const void *context);
61 static void AttGapSignatureConfirmationResultAsyncDestroy(const void *context);
62 static void FindInformationResponseErrorAssign(AttError *attErrorObjPtr, const AttConnectInfo *connect);
63 static void FindByTypeValueResponseErrorAssign(AttError *attErrorObjPtr, const AttConnectInfo *connect);
64 static void ReadByGroupTypeResponseErrorAssign(AttError *attErrorObjPtr, const AttConnectInfo *connect);
65 static void AttSignedWriteCommandGapRetErrorAssign(AttWrite *attWriteObjPtr, const uint8_t *data);
66 
67 /**
68  * @brief gap security confirmation result async.
69  *
70  * @param context Indicates the pointer to context.
71  */
AttGapSignatureConfirmationResultAsync(const void * context)72 static void AttGapSignatureConfirmationResultAsync(const void *context)
73 {
74     LOG_INFO("%{public}s enter", __FUNCTION__);
75     if (context == NULL) {
76         LOG_WARN("%{public}s:context == NULL, return.", __FUNCTION__);
77         return;
78     }
79 
80     AttGapSignatureConfirmationAsync *attGapSigConfirmationPtr = (AttGapSignatureConfirmationAsync *)context;
81     Buffer *bufferSig = (Buffer *)(attGapSigConfirmationPtr->context);
82     AttWrite attWriteObj;
83     Buffer *bufferNew = NULL;
84     AttServerDataCallback *attServerDataCallback = NULL;
85     SigedWriteCommandConfirmationContext *sigedWriteCommandConfirmContextPtr = NULL;
86 
87     if (bufferSig == NULL) {
88         goto GAPSIGNATURECONFIRMATIONRESULT_END;
89     }
90 
91     attServerDataCallback = AttGetATTServerCallback();
92     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
93         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
94         goto GAPSIGNATURECONFIRMATIONRESULT_END;
95     }
96 
97     sigedWriteCommandConfirmContextPtr = (SigedWriteCommandConfirmationContext *)BufferPtr(bufferSig);
98     attWriteObj.signedWriteCommand.attHandleValueObj.attHandle =
99         ((uint16_t *)(sigedWriteCommandConfirmContextPtr->data + 1))[0];
100     (void)memcpy_s(attWriteObj.signedWriteCommand.authSignature,
101         GAPSIGNATURESIZE,
102         sigedWriteCommandConfirmContextPtr->data + STEP_TWO + sigedWriteCommandConfirmContextPtr->bufferSize,
103         GAPSIGNATURESIZE);
104     attWriteObj.signedWriteCommand.authSignatureLen = GAPSIGNATURESIZE;
105     attWriteObj.signedWriteCommand.result = (AttSignedWriteCommandResult)attGapSigConfirmationPtr->result;
106     bufferNew = BufferSliceMalloc(
107         sigedWriteCommandConfirmContextPtr->bufferallPtr, STEP_THREE, sigedWriteCommandConfirmContextPtr->bufferSize);
108     attServerDataCallback->attServerCallback(sigedWriteCommandConfirmContextPtr->connect->retGattConnectHandle,
109         ATT_SIGNED_WRITE_COMMAND_ID,
110         &attWriteObj,
111         bufferNew,
112         attServerDataCallback->context);
113 
114     BufferFree(bufferNew);
115     BufferFree(sigedWriteCommandConfirmContextPtr->bufferallPtr);
116     BufferFree(bufferSig);
117 GAPSIGNATURECONFIRMATIONRESULT_END:
118     MEM_MALLOC.free(attGapSigConfirmationPtr);
119     return;
120 }
121 
122 /**
123  * @brief gap security confirmation result async destroy.
124  *
125  * @param context Indicates the pointer to context.
126  */
AttGapSignatureConfirmationResultAsyncDestroy(const void * context)127 static void AttGapSignatureConfirmationResultAsyncDestroy(const void *context)
128 {
129     LOG_INFO("%{public}s enter", __FUNCTION__);
130     if (context == NULL) {
131         LOG_WARN("%{public}s:context == NULL, return.", __FUNCTION__);
132         return;
133     }
134 
135     AttGapSignatureConfirmationAsync *attGapSigConfirmationPtr = (AttGapSignatureConfirmationAsync *)context;
136     MEM_MALLOC.free(attGapSigConfirmationPtr);
137     return;
138 }
139 
140 /**
141  * @brief gap security confirmation result.
142  *
143  * @param result Indicates the GAP_SignatureResult.
144  * @param context Indicates the pointer to context.
145  */
AttGapSignatureConfirmationResult(GAP_SignatureResult result,void * context)146 void AttGapSignatureConfirmationResult(GAP_SignatureResult result, void *context)
147 {
148     LOG_INFO("%{public}s enter, result = %{public}d", __FUNCTION__, result);
149 
150     AttGapSignatureConfirmationAsync *attGapSigConfirmationPtr =
151         MEM_MALLOC.alloc(sizeof(AttGapSignatureConfirmationAsync));
152     if (attGapSigConfirmationPtr == NULL) {
153         LOG_ERROR("point to NULL");
154         return;
155     }
156 
157     attGapSigConfirmationPtr->result = result;
158     attGapSigConfirmationPtr->context = context;
159 
160     AttAsyncProcess(AttGapSignatureConfirmationResultAsync,
161         AttGapSignatureConfirmationResultAsyncDestroy,
162         attGapSigConfirmationPtr);
163 
164     return;
165 }
166 
167 /**
168  * @brief count.
169  *
170  * @param1 format Indicates the format.
171  * @param2 inforLenPtr Indicates the pointer to inforLenPtr.
172  * @param3 uuidLenPtr Indicates the pointer to uuidLenPtr.
173  */
AttCount(uint8_t format,uint16_t * inforLenPtr,uint16_t * uuidLenPtr)174 static void AttCount(uint8_t format, uint16_t *inforLenPtr, uint16_t *uuidLenPtr)
175 {
176     if (inforLenPtr == NULL || uuidLenPtr == NULL) {
177         LOG_WARN("%{public}s:inforLenPtr or uuidLenPtr is null, return.", __FUNCTION__);
178         return;
179     }
180     LOG_INFO("%{public}s enter,format = %hhu,inforLenPtr = %hu,uuidLenPtr = %hu",
181         __FUNCTION__, format, *inforLenPtr, *uuidLenPtr);
182 
183     if (format == HANDLEAND16BITBLUETOOTHUUID) {
184         *inforLenPtr = FINDINFORRESINFOR16BITLEN;
185         *uuidLenPtr = UUID16BITTYPELEN;
186     } else if (format == HANDLEAND128BITUUID) {
187         *inforLenPtr = FINDINFORRESINFOR128BITLEN;
188         *uuidLenPtr = UUID128BITTYPELEN;
189     }
190     return;
191 }
192 
193 /**
194  * @brief judge information len.
195  *
196  * @param1 inforLen Indicates the inforLen.
197  * @param2 dataLen Indicates the dataLen.
198  * @param3 inforNum Indicates the pointer to inforNum.
199  * @return Returns <b>0</b> if the operation is successful; returns <b>!0</b> if the operation fails.
200  */
AttJudgeInfoLen(uint16_t inforLen,size_t dataLen,uint16_t * inforNum)201 static int AttJudgeInfoLen(uint16_t inforLen, size_t dataLen, uint16_t *inforNum)
202 {
203     if (inforNum == NULL) {
204         LOG_WARN("%{public}s:inforNum is null, return.", __FUNCTION__);
205         return BT_OPERATION_FAILED;
206     }
207     LOG_INFO("%{public}s enter,inforLen = %hu,dataLen = %zu,inforNum = %hu ",
208         __FUNCTION__, inforLen, dataLen, *inforNum);
209 
210     int ret = BT_OPERATION_FAILED;
211 
212     if (inforLen != 0) {
213         if ((dataLen - 1) % inforLen) {
214             ret = BT_OPERATION_FAILED;
215             goto ATTJUDGEINFOLEN_END;
216         } else {
217             *inforNum = (dataLen - 1) / inforLen;
218         }
219     } else {
220         ret = BT_OPERATION_FAILED;
221         goto ATTJUDGEINFOLEN_END;
222     }
223 
224     ret = BT_SUCCESS;
225 
226 ATTJUDGEINFOLEN_END:
227     return ret;
228 }
229 
230 /**
231  * @brief assign find information response.
232  *
233  * @param1 inforNum Indicates the inforNum.
234  * @param2 attFindObj Indicates the pointer to AttFind.
235  * @param3 data Indicates the pointer to data.
236  * @param4 inforLen Indicates the information len.
237  */
AttFindInformationResAssign(uint16_t inforNum,AttFind * attFindObj,const uint8_t * data,uint16_t inforLen)238 static void AttFindInformationResAssign(uint16_t inforNum, AttFind *attFindObj, const uint8_t *data, uint16_t inforLen)
239 {
240     LOG_INFO("%{public}s enter,inforNum = %hu, inforLen = %hu", __FUNCTION__, inforNum, inforLen);
241     if (attFindObj == NULL || data == NULL) {
242         LOG_WARN("%{public}s:attFindObj or data is null, return.", __FUNCTION__);
243         return;
244     }
245 
246     uint16_t index = 0;
247     for (; index < inforNum; ++index) {
248         attFindObj->findInforRsponse.handleUuidPairs[index].attHandle = ((uint16_t *)(data + 1 + index * inforLen))[0];
249         if (attFindObj->findInforRsponse.format == HANDLEAND16BITBLUETOOTHUUID) {
250             attFindObj->findInforRsponse.handleUuidPairs[index].uuid.type = BT_UUID_16;
251             attFindObj->findInforRsponse.handleUuidPairs[index].uuid.uuid16 =
252                 ((uint16_t *)(data + STEP_THREE + index * inforLen))[0];
253         } else if (attFindObj->findInforRsponse.format == HANDLEAND128BITUUID) {
254             attFindObj->findInforRsponse.handleUuidPairs[index].uuid.type = BT_UUID_128;
255             if (memcpy_s(&(attFindObj->findInforRsponse.handleUuidPairs[index].uuid.uuid128),
256                 UUID128LEN,
257                 data + STEP_THREE + index * inforLen,
258                 UUID128LEN) != EOK) {
259                     LOG_ERROR("%{public}s enter, memcpy_s fail", __FUNCTION__);
260                     return;
261                 }
262         }
263     }
264     return;
265 }
266 
267 /**
268  * @brief free read data memory.
269  *
270  * @param1 valueList Indicates the pointer to AttRead.
271  * @param2 num Indicates the num.
272  * @param3 type Indicates the type.
273  */
AttReadFree(AttRead * valueList,uint16_t num,uint8_t type)274 static void AttReadFree(AttRead *valueList, uint16_t num, uint8_t type)
275 {
276     LOG_INFO("%{public}s enter,num = %{public}d, type = %{public}d", __FUNCTION__, num, type);
277     if (valueList == NULL) {
278         LOG_WARN("%{public}s:valueList is null, return.", __FUNCTION__);
279         return;
280     }
281 
282     uint16_t index = 0;
283     for (; index < num; ++index) {
284         if (type == READBYTYPERESPONSEFREE) {
285             MEM_MALLOC.free(valueList->readHandleListNum.valueList[index].attributeValue);
286         } else if (type == READBYGROUPTYPERESPONSEFREE) {
287             MEM_MALLOC.free(valueList->readGroupResponse.attributeData[index].attributeValue);
288         }
289     }
290 
291     if (type == READBYTYPERESPONSEFREE) {
292         MEM_MALLOC.free(valueList->readHandleListNum.valueList);
293     } else if (type == READBYGROUPTYPERESPONSEFREE) {
294         MEM_MALLOC.free(valueList->readGroupResponse.attributeData);
295     }
296     return;
297 }
298 
299 /**
300  * @brief read data attribute assign.
301  *
302  * @param1 attReadPtr Indicates the pointer to AttRead.
303  * @param2 len Indicates the len.
304  * @param3 data Indicates the pointer to data.
305  */
AttReadAttrAssign(const AttRead * attReadPtr,uint8_t len,const uint8_t * data)306 static void AttReadAttrAssign(const AttRead *attReadPtr, uint8_t len, const uint8_t *data)
307 {
308     LOG_INFO("%{public}s enter,len = %hhu", __FUNCTION__, len);
309     if (attReadPtr == NULL || data == NULL) {
310         LOG_WARN("%{public}s:attReadPtr or data is null, return.", __FUNCTION__);
311         return;
312     }
313 
314     uint16_t indexNum = 0;
315     for (; indexNum < attReadPtr->readGroupResponse.num; ++indexNum) {
316         attReadPtr->readGroupResponse.attributeData[indexNum].attributeValue = MEM_MALLOC.alloc(len - STEP_FOUR);
317         attReadPtr->readGroupResponse.attributeData[indexNum].attHandle = ((uint16_t *)data)[0];
318         attReadPtr->readGroupResponse.attributeData[indexNum].groupEndHandle = ((uint16_t *)(data + STEP_TWO))[0];
319         (void)memcpy_s(attReadPtr->readGroupResponse.attributeData[indexNum].attributeValue,
320             len - STEP_FOUR,
321             data + STEP_FOUR,
322             len - STEP_FOUR);
323         data += len;
324     }
325     return;
326 }
327 
328 /**
329  * @brief received error response.
330  *
331  * @param1 connect Indicates the pointer to const AttConnectInfo.
332  * @param2 buffer Indicates the pointer to Buffer.
333  */
AttErrorResponse(AttConnectInfo * connect,const Buffer * buffer)334 void AttErrorResponse(AttConnectInfo *connect, const Buffer *buffer)
335 {
336     LOG_INFO("%{public}s enter", __FUNCTION__);
337     if (connect == NULL) {
338         LOG_WARN("%{public}s:connect == NULL, return.", __FUNCTION__);
339         return;
340     }
341 
342     AttError attErrorTObj;
343     uint8_t *data = NULL;
344     AttClientDataCallback *attClientDataCallback = NULL;
345 
346     AlarmCancel(connect->alarm);
347 
348     if (buffer == NULL) {
349         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
350         goto ATTERRORRESPONSE_END;
351     }
352 
353     attClientDataCallback = AttGetATTClientCallback();
354     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
355         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
356         goto ATTERRORRESPONSE_END;
357     }
358 
359     data = (uint8_t *)BufferPtr(buffer);
360     attErrorTObj.reqOpcode = data[0];
361     attErrorTObj.attHandleInError = ((uint16_t *)(data + 1))[0];
362     attErrorTObj.errorCode = data[STEP_THREE];
363     LOG_INFO("%{public}s connectHandle = %hu, callback para : reqOpcode = %{public}d, "
364         "attHandleInError = %{public}d, errorCode = %{public}d",
365         __FUNCTION__,
366         connect->retGattConnectHandle,
367         attErrorTObj.reqOpcode,
368         attErrorTObj.attHandleInError,
369         attErrorTObj.errorCode);
370 
371     attClientDataCallback->attClientCallback(
372         connect->retGattConnectHandle, ATT_ERROR_RESPONSE_ID, &attErrorTObj, NULL, attClientDataCallback->context);
373 
374 ATTERRORRESPONSE_END:
375     LOG_INFO("%{public}s return connect != NULL, connectHandle = %hu", __FUNCTION__, connect->retGattConnectHandle);
376     ListRemoveFirst(connect->instruct);
377     AttReceiveSequenceScheduling(connect);
378     return;
379 }
380 
381 /**
382  * @brief received exchangeMTU request.
383  *
384  * @param1 connect Indicates the pointer to const AttConnectInfo.
385  * @param2 buffer Indicates the pointer to Buffer.
386  */
AttExchangeMTURequest(AttConnectInfo * connect,const Buffer * buffer)387 void AttExchangeMTURequest(AttConnectInfo *connect, const Buffer *buffer)
388 {
389     LOG_INFO("%{public}s enter", __FUNCTION__);
390     if (connect == NULL) {
391         LOG_WARN("%{public}s:connect == NULL, return.", __FUNCTION__);
392         return;
393     }
394 
395     AttExchangeMTUType attExchangeMTUObj;
396     uint8_t *data = NULL;
397     AttServerDataCallback *attServerDataCallback = NULL;
398 
399     if (buffer == NULL) {
400         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
401         goto ATTEXCHANGEMTUREQUEST_END;
402     }
403 
404     attServerDataCallback = AttGetATTServerCallback();
405     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
406         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
407         goto ATTEXCHANGEMTUREQUEST_END;
408     }
409 
410     data = (uint8_t *)BufferPtr(buffer);
411     attExchangeMTUObj.mtuSize = ((uint16_t *)data)[0];
412     connect->receiveMtu = attExchangeMTUObj.mtuSize;
413     LOG_INFO("%{public}s connectHandle = %hu, callback para : mtuSize = %{public}d",
414         __FUNCTION__,
415         connect->retGattConnectHandle,
416         attExchangeMTUObj.mtuSize);
417 
418     attServerDataCallback->attServerCallback(connect->retGattConnectHandle,
419         ATT_EXCHANGE_MTU_REQUEST_ID,
420         &attExchangeMTUObj,
421         NULL,
422         attServerDataCallback->context);
423 
424 ATTEXCHANGEMTUREQUEST_END:
425     return;
426 }
427 
428 /**
429  * @brief received exchangeMTU response.
430  *
431  * @param1 connect Indicates the pointer to const AttConnectInfo.
432  * @param2 buffer Indicates the pointer to Buffer.
433  */
AttExchangeMTUResponse(AttConnectInfo * connect,const Buffer * buffer)434 void AttExchangeMTUResponse(AttConnectInfo *connect, const Buffer *buffer)
435 {
436     LOG_INFO("%{public}s enter", __FUNCTION__);
437     if (connect == NULL) {
438         LOG_WARN("%{public}s:connect == NULL, return.", __FUNCTION__);
439         return;
440     }
441 
442     AttExchangeMTUType attExchangeMTUObj;
443     uint16_t *data = NULL;
444     AttClientDataCallback *attClientDataCallback = NULL;
445 
446     AlarmCancel(connect->alarm);
447 
448     if (buffer == NULL) {
449         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
450         goto ATTEXCHANGEMTURESPONSE_END;
451     }
452 
453     attClientDataCallback = AttGetATTClientCallback();
454     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
455         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
456         goto ATTEXCHANGEMTURESPONSE_END;
457     }
458 
459     data = (uint16_t *)BufferPtr(buffer);
460     attExchangeMTUObj.mtuSize = data[0];
461     connect->mtu = Min(connect->sendMtu, attExchangeMTUObj.mtuSize);
462     LOG_INFO("%{public}s connectHandle = %hu,callback para : mtuSize = %{public}d",
463         __FUNCTION__,
464         connect->retGattConnectHandle,
465         attExchangeMTUObj.mtuSize);
466 
467     attClientDataCallback->attClientCallback(connect->retGattConnectHandle,
468         ATT_EXCHANGE_MTU_RESPONSE_ID,
469         &attExchangeMTUObj,
470         NULL,
471         attClientDataCallback->context);
472 
473 ATTEXCHANGEMTURESPONSE_END:
474     LOG_INFO("%{public}s return connect != NULL, connectHandle = %hu", __FUNCTION__, connect->retGattConnectHandle);
475     ListRemoveFirst(connect->instruct);
476     AttReceiveSequenceScheduling(connect);
477     return;
478 }
479 
480 /**
481  * @brief received findinformation request.
482  *
483  * @param1 connect Indicates the pointer to const AttConnectInfo.
484  * @param2 buffer Indicates the pointer to Buffer.
485  */
AttFindInformationRequest(AttConnectInfo * connect,const Buffer * buffer)486 void AttFindInformationRequest(AttConnectInfo *connect, const Buffer *buffer)
487 {
488     LOG_INFO("%{public}s enter", __FUNCTION__);
489     if (connect == NULL) {
490         LOG_WARN("%{public}s:connect == NULL, return.", __FUNCTION__);
491         return;
492     }
493 
494     AttFind attFindObj;
495     uint8_t *data = NULL;
496     AttServerDataCallback *attServerDataCallback = NULL;
497 
498     if (buffer == NULL) {
499         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
500         goto ATTFINDINFORMATIONREQUEST_END;
501     }
502 
503     if ((connect->transportType == BT_TRANSPORT_LE && connect->mtu == DEFAULTLEATTMTU) ||
504         (connect->transportType == BT_TRANSPORT_BR_EDR && connect->mtu == DEFAULTBREDRMTU)) {
505         ((AttConnectInfo *)connect)->mtuFlag = true;
506     }
507 
508     attServerDataCallback = AttGetATTServerCallback();
509     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
510         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
511         goto ATTFINDINFORMATIONREQUEST_END;
512     }
513 
514     data = (uint8_t *)BufferPtr(buffer);
515     attFindObj.findInformationRequest.startHandle = ((uint16_t *)data)[0];
516     attFindObj.findInformationRequest.endHandle = ((uint16_t *)(data + STEP_TWO))[0];
517     LOG_INFO("%{public}s connectHandle = %hu, callback para : startHandle = %{public}d, endHandle = %{public}d",
518         __FUNCTION__,
519         connect->retGattConnectHandle,
520         attFindObj.findInformationRequest.startHandle,
521         attFindObj.findInformationRequest.endHandle);
522     attServerDataCallback->attServerCallback(connect->retGattConnectHandle,
523         ATT_FIND_INFORMATION_REQUEST_ID,
524         &attFindObj,
525         NULL,
526         attServerDataCallback->context);
527 
528 ATTFINDINFORMATIONREQUEST_END:
529     return;
530 }
531 
532 /**
533  * @brief received findinformation response error assign.
534  *
535  * @param1 attErrorObjPtr Indicates the pointer to AttError.
536  * @param2 connect Indicates the pointer to AttConnectInfo.
537  */
FindInformationResponseErrorAssign(AttError * attErrorObjPtr,const AttConnectInfo * connect)538 static void FindInformationResponseErrorAssign(AttError *attErrorObjPtr, const AttConnectInfo *connect)
539 {
540     LOG_INFO("%{public}s enter", __FUNCTION__);
541     if (attErrorObjPtr == NULL || connect == NULL) {
542         LOG_WARN("%{public}s:attErrorObjPtr or connect is NULL, return.", __FUNCTION__);
543         return;
544     }
545 
546     attErrorObjPtr->reqOpcode = FIND_INFORMATION_REQUEST;
547     attErrorObjPtr->errorCode = ATT_INVALID_ATTRIBUTE_VALUE_LENGTH;
548     attErrorObjPtr->attHandleInError = connect->aclHandle;
549     return;
550 }
551 
552 /**
553  * @brief received findinformation response.
554  *
555  * @param1 connect Indicates the pointer to const AttConnectInfo.
556  * @param2 buffer Indicates the pointer to Buffer.
557  */
AttFindInformationResponse(AttConnectInfo * connect,const Buffer * buffer)558 void AttFindInformationResponse(AttConnectInfo *connect, const Buffer *buffer)
559 {
560     LOG_INFO("%{public}s enter", __FUNCTION__);
561     if (connect == NULL) {
562         LOG_WARN("%{public}s:connect == NULL and return", __FUNCTION__);
563         return;
564     }
565 
566     uint16_t inforLen = 0;
567     uint16_t inforNum = 0;
568     uint16_t uuidLen = 0;
569     AttFind attFindObj;
570     size_t dataLen;
571     uint8_t *data = NULL;
572     AttError attErrorObj;
573     AttClientDataCallback *attClientDataCallback = NULL;
574 
575     AlarmCancel(connect->alarm);
576 
577     if (buffer == NULL) {
578         LOG_WARN("%{public}s:buffer == NULL and goto ATTFINDINFORMATIONRESPONSE_END", __FUNCTION__);
579         goto ATTFINDINFORMATIONRESPONSE_END;
580     }
581 
582     attClientDataCallback = AttGetATTClientCallback();
583     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
584         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
585         goto ATTFINDINFORMATIONRESPONSE_END;
586     }
587     dataLen = BufferGetSize(buffer);
588     data = (uint8_t *)BufferPtr(buffer);
589     attFindObj.findInforRsponse.format = data[0];
590     AttCount(attFindObj.findInforRsponse.format, &inforLen, &uuidLen);
591 
592     if (AttJudgeInfoLen(inforLen, dataLen, &inforNum) < 0) {
593         FindInformationResponseErrorAssign(&attErrorObj, connect);
594         attClientDataCallback->attClientCallback(
595             connect->retGattConnectHandle, ATT_ERROR_RESPONSE_ID, &attErrorObj, NULL, attClientDataCallback->context);
596         goto ATTFINDINFORMATIONRESPONSE_END;
597     }
598 
599     attFindObj.findInforRsponse.handleUuidPairs = MEM_MALLOC.alloc(sizeof(AttHandleUuid) * inforNum);
600     attFindObj.findInforRsponse.pairNum = inforNum;
601     AttFindInformationResAssign(inforNum, &attFindObj, data, inforLen);
602     attClientDataCallback->attClientCallback(connect->retGattConnectHandle,
603         ATT_FIND_INFORMATION_RESPONSE_ID,
604         &attFindObj,
605         NULL,
606         attClientDataCallback->context);
607 
608     MEM_MALLOC.free(attFindObj.findInforRsponse.handleUuidPairs);
609 
610 ATTFINDINFORMATIONRESPONSE_END:
611     LOG_INFO("%{public}s return connect != NULL, connectHandle = %hu", __FUNCTION__, connect->retGattConnectHandle);
612     ListRemoveFirst(connect->instruct);
613     AttReceiveSequenceScheduling(connect);
614     return;
615 }
616 
617 /**
618  * @brief received findbytypevalue request.
619  *
620  * @param1 connect Indicates the pointer to const AttConnectInfo.
621  * @param2 buffer Indicates the pointer to Buffer.
622  */
AttFindByTypeValueRequest(AttConnectInfo * connect,const Buffer * buffer)623 void AttFindByTypeValueRequest(AttConnectInfo *connect, const Buffer *buffer)
624 {
625     LOG_INFO("%{public}s enter", __FUNCTION__);
626     if (connect == NULL) {
627         LOG_WARN("%{public}s:connect == NULL and return", __FUNCTION__);
628         return;
629     }
630 
631     AttFind attFindObj;
632     Buffer *bufferNew = NULL;
633     uint8_t *data = NULL;
634     size_t buffSize;
635     AttServerDataCallback *attServerDataCallback = NULL;
636 
637     if (buffer == NULL) {
638         LOG_WARN("%{public}s:buffer == NULL and goto ATTFINDBYTYPEVALUEREQUEST_END", __FUNCTION__);
639         goto ATTFINDBYTYPEVALUEREQUEST_END;
640     }
641 
642     if ((connect->transportType == BT_TRANSPORT_LE && connect->mtu == DEFAULTLEATTMTU) ||
643         (connect->transportType == BT_TRANSPORT_BR_EDR && connect->mtu == DEFAULTBREDRMTU)) {
644         connect->mtuFlag = true;
645     }
646 
647     attServerDataCallback = AttGetATTServerCallback();
648     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
649         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
650         goto ATTFINDBYTYPEVALUEREQUEST_END;
651     }
652 
653     buffSize = BufferGetSize(buffer);
654     data = (uint8_t *)BufferPtr(buffer);
655     if (data == NULL || buffSize < STEP_SIX) {
656         LOG_ERROR("%{public}s error request", __FUNCTION__);
657         return;
658     }
659     attFindObj.findByTypeValueRequest.handleRange.startHandle = ((uint16_t *)data)[0];
660     attFindObj.findByTypeValueRequest.handleRange.endHandle = ((uint16_t *)(data + STEP_TWO))[0];
661     attFindObj.findByTypeValueRequest.attType = ((uint16_t *)(data + STEP_FOUR))[0];
662 
663     if (buffSize - STEP_SIX > 0) {
664         bufferNew = BufferSliceMalloc(buffer, STEP_SIX, buffSize - STEP_SIX);
665         attServerDataCallback->attServerCallback(connect->retGattConnectHandle,
666             ATT_FIND_BY_TYPE_VALUE_REQUEST_ID,
667             &attFindObj,
668             bufferNew,
669             attServerDataCallback->context);
670         BufferFree(bufferNew);
671     } else {
672         attServerDataCallback->attServerCallback(connect->retGattConnectHandle,
673             ATT_FIND_BY_TYPE_VALUE_REQUEST_ID,
674             &attFindObj,
675             NULL,
676             attServerDataCallback->context);
677     }
678 
679 ATTFINDBYTYPEVALUEREQUEST_END:
680     return;
681 }
682 
683 /**
684  * @brief received findbytypevalue response error assign.
685  *
686  * @param1 attErrorObjPtr Indicates the pointer to AttError.
687  * @param2 connect Indicates the pointer to AttConnectInfo.
688  */
FindByTypeValueResponseErrorAssign(AttError * attErrorObjPtr,const AttConnectInfo * connect)689 static void FindByTypeValueResponseErrorAssign(AttError *attErrorObjPtr, const AttConnectInfo *connect)
690 {
691     LOG_INFO("%{public}s enter", __FUNCTION__);
692     if (attErrorObjPtr == NULL || connect == NULL) {
693         LOG_WARN("%{public}s:attErrorObjPtr or connect is NULL, return.", __FUNCTION__);
694         return;
695     }
696 
697     attErrorObjPtr->reqOpcode = FIND_BY_TYPE_VALUE_REQUEST;
698     attErrorObjPtr->errorCode = ATT_INVALID_ATTRIBUTE_VALUE_LENGTH;
699     attErrorObjPtr->attHandleInError = connect->aclHandle;
700     return;
701 }
702 
703 /**
704  * @brief received findbytypevalue response.
705  *
706  * @param1 connect Indicates the pointer to const AttConnectInfo.
707  * @param2 buffer Indicates the pointer to Buffer.
708  */
AttFindByTypeValueResponse(AttConnectInfo * connect,const Buffer * buffer)709 void AttFindByTypeValueResponse(AttConnectInfo *connect, const Buffer *buffer)
710 {
711     LOG_INFO("%{public}s enter", __FUNCTION__);
712     if (connect == NULL) {
713         LOG_WARN("%{public}s:connect == NULL and return", __FUNCTION__);
714         return;
715     }
716 
717     size_t dataLen;
718     uint16_t inforNum = 0;
719     AttFind attFindObj;
720     uint8_t *data = NULL;
721     AttClientDataCallback *attClientDataCallback = NULL;
722     AttError attErrorObj;
723 
724     AlarmCancel(connect->alarm);
725 
726     attClientDataCallback = AttGetATTClientCallback();
727     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL) || (buffer == NULL)) {
728         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
729         goto ATTFINDBYTYPEVALUERESPONSE_END;
730     }
731 
732     dataLen = BufferGetSize(buffer);
733     if (dataLen % STEP_FOUR) {
734         FindByTypeValueResponseErrorAssign(&attErrorObj, connect);
735         attClientDataCallback->attClientCallback(
736             connect->retGattConnectHandle, ATT_ERROR_RESPONSE_ID, &attErrorObj, NULL, attClientDataCallback->context);
737         goto ATTFINDBYTYPEVALUERESPONSE_END;
738     } else {
739         inforNum = dataLen / STEP_FOUR;
740     }
741 
742     attFindObj.findByTypeValueResponse.handleInfoList = MEM_MALLOC.alloc(sizeof(AttHandleInfo) * inforNum);
743     attFindObj.findByTypeValueResponse.listNum = inforNum;
744     data = (uint8_t *)BufferPtr(buffer);
745 
746     AttHandleInfo *handleInfoList = attFindObj.findByTypeValueResponse.handleInfoList;
747     for (uint16_t indexNumber = 0; indexNumber < inforNum; ++indexNumber) {
748         handleInfoList[indexNumber].attHandle = ((uint16_t *)(data + indexNumber * STEP_FOUR))[0];
749         handleInfoList[indexNumber].groupEndHandle = ((uint16_t *)(data + STEP_TWO + indexNumber * STEP_FOUR))[0];
750     }
751 
752     attClientDataCallback->attClientCallback(connect->retGattConnectHandle,
753         ATT_FIND_BY_TYPE_VALUE_RESPONSE_ID,
754         &attFindObj,
755         NULL,
756         attClientDataCallback->context);
757     MEM_MALLOC.free(attFindObj.findByTypeValueResponse.handleInfoList);
758 
759 ATTFINDBYTYPEVALUERESPONSE_END:
760     ListRemoveFirst(connect->instruct);
761     AttReceiveSequenceScheduling(connect);
762     return;
763 }
764 
765 /**
766  * @brief received readbytype request.
767  *
768  * @param1 connect Indicates the pointer to const AttConnectInfo.
769  * @param2 buffer Indicates the pointer to Buffer.
770  */
AttReadByTypeRequest(AttConnectInfo * connect,const Buffer * buffer)771 void AttReadByTypeRequest(AttConnectInfo *connect, const Buffer *buffer)
772 {
773     LOG_INFO("%{public}s enter", __FUNCTION__);
774     if (connect == NULL) {
775         LOG_WARN("%{public}s:connect == NULL and return", __FUNCTION__);
776         return;
777     }
778 
779     size_t buffSize;
780     AttRead attReadObj;
781     uint8_t *data = NULL;
782     uint16_t uuidLen;
783     AttServerDataCallback *attServerDataCallback = NULL;
784 
785     if (buffer == NULL) {
786         goto ATTREADBYTYPEREQUEST_END;
787     }
788 
789     if ((connect->transportType == BT_TRANSPORT_LE && connect->mtu == DEFAULTLEATTMTU) ||
790         (connect->transportType == BT_TRANSPORT_BR_EDR && connect->mtu == DEFAULTBREDRMTU)) {
791         connect->mtuFlag = true;
792     }
793 
794     attServerDataCallback = AttGetATTServerCallback();
795     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
796         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
797         goto ATTREADBYTYPEREQUEST_END;
798     }
799 
800     buffSize = BufferGetSize(buffer);
801     data = (uint8_t *)BufferPtr(buffer);
802     attReadObj.readHandleRangeUuid.handleRange.startHandle = ((uint16_t *)data)[0];
803     attReadObj.readHandleRangeUuid.handleRange.endHandle = ((uint16_t *)(data + STEP_TWO))[0];
804     uuidLen = buffSize - STEP_FOUR;
805     attReadObj.readHandleRangeUuid.uuid = MEM_MALLOC.alloc(sizeof(BtUuid));
806 
807     if (uuidLen == (uint16_t)UUID16BITTYPELEN) {
808         attReadObj.readHandleRangeUuid.uuid->type = BT_UUID_16;
809         attReadObj.readHandleRangeUuid.uuid->uuid16 = ((uint16_t *)(data + STEP_FOUR))[0];
810         LOG_INFO("%{public}s enter, callback para : type = %{public}d, uuid = %{public}d",
811             __FUNCTION__,
812             attReadObj.readHandleRangeUuid.uuid->type,
813             attReadObj.readHandleRangeUuid.uuid->uuid16);
814     } else if (uuidLen == (uint16_t)UUID128BITTYPELEN) {
815         attReadObj.readHandleRangeUuid.uuid->type = BT_UUID_128;
816         (void)memcpy_s(attReadObj.readHandleRangeUuid.uuid->uuid128, uuidLen, data + STEP_FOUR, uuidLen);
817     }
818 
819     attServerDataCallback->attServerCallback(
820         connect->retGattConnectHandle, ATT_READ_BY_TYPE_REQUEST_ID, &attReadObj, NULL, attServerDataCallback->context);
821 
822     MEM_MALLOC.free(attReadObj.readHandleRangeUuid.uuid);
823 
824 ATTREADBYTYPEREQUEST_END:
825     return;
826 }
827 
828 /**
829  * @brief received readbytype response.
830  *
831  * @param1 connect Indicates the pointer to const AttConnectInfo.
832  * @param2 buffer Indicates the pointer to Buffer.
833  */
AttReadByTypeResponse(AttConnectInfo * connect,const Buffer * buffer)834 void AttReadByTypeResponse(AttConnectInfo *connect, const Buffer *buffer)
835 {
836     LOG_INFO("%{public}s enter", __FUNCTION__);
837     if (connect == NULL) {
838         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
839         return;
840     }
841 
842     size_t dataLen;
843     AttRead attReadObj;
844     uint8_t len;
845     uint16_t indexNum = 0;
846     uint8_t *data = NULL;
847     AttClientDataCallback *attClientDataCallback = NULL;
848     AttError attErrorObj;
849 
850     AlarmCancel(connect->alarm);
851     attClientDataCallback = AttGetATTClientCallback();
852     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL || (buffer == NULL))) {
853         goto ATTREADBYTYPERESPONSE_END;
854     }
855 
856     dataLen = BufferGetSize(buffer);
857     attReadObj.readHandleListNum.len = *(uint8_t *)BufferPtr(buffer);
858     len = attReadObj.readHandleListNum.len;
859     LOG_INFO("%{public}s callback para : len = %hhu", __FUNCTION__, len);
860     if (len <= STEP_TWO) {
861         LOG_ERROR("%{public}s len is 0", __FUNCTION__);
862         attReadObj.readHandleListNum.valueNum = 0;
863     } else if ((dataLen - 1) % len) {
864         AttReadByTypeResErrorAssign(&attErrorObj, connect);
865         attClientDataCallback->attClientCallback(
866             connect->retGattConnectHandle, ATT_ERROR_RESPONSE_ID, &attErrorObj, NULL, attClientDataCallback->context);
867         goto ATTREADBYTYPERESPONSE_END;
868     } else {
869         attReadObj.readHandleListNum.valueNum = (dataLen - 1) / len;
870     }
871 
872     data = (uint8_t *)BufferPtr(buffer) + 1;
873     attReadObj.readHandleListNum.valueList =
874         MEM_MALLOC.alloc(sizeof(AttReadByTypeRspDataList) * attReadObj.readHandleListNum.valueNum);
875     for (; indexNum < attReadObj.readHandleListNum.valueNum; ++indexNum) {
876         attReadObj.readHandleListNum.valueList[indexNum].attributeValue = MEM_MALLOC.alloc(len - STEP_TWO);
877         (void)memcpy_s(
878             &attReadObj.readHandleListNum.valueList[indexNum], sizeof(AttReadByTypeRspDataList), data, STEP_TWO);
879         (void)memcpy_s(attReadObj.readHandleListNum.valueList[indexNum].attributeValue,
880             len - STEP_TWO,
881             data + STEP_TWO,
882             len - STEP_TWO);
883         data += len;
884     }
885     attClientDataCallback->attClientCallback(
886         connect->retGattConnectHandle, ATT_READ_BY_TYPE_RESPONSE_ID, &attReadObj, NULL, attClientDataCallback->context);
887     AttReadFree(&attReadObj, attReadObj.readHandleListNum.valueNum, READBYTYPERESPONSEFREE);
888 
889 ATTREADBYTYPERESPONSE_END:
890     ListRemoveFirst(connect->instruct);
891     AttReceiveSequenceScheduling(connect);
892     return;
893 }
894 
895 /**
896  * @brief received read request.
897  *
898  * @param1 connect Indicates the pointer to const AttConnectInfo.
899  * @param2 buffer Indicates the pointer to Buffer.
900  */
AttReadRequest(AttConnectInfo * connect,const Buffer * buffer)901 void AttReadRequest(AttConnectInfo *connect, const Buffer *buffer)
902 {
903     LOG_INFO("%{public}s enter", __FUNCTION__);
904     if (connect == NULL) {
905         LOG_WARN("%{public}s:connect == NULL and return", __FUNCTION__);
906         return;
907     }
908 
909     AttRead attReadObj;
910     uint8_t *data = NULL;
911     AttServerDataCallback *attServerDataCallback = NULL;
912 
913     if (buffer == NULL) {
914         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
915         goto ATTREADREQUEST_END;
916     }
917 
918     if ((connect->transportType == BT_TRANSPORT_LE && connect->mtu == DEFAULTLEATTMTU) ||
919         (connect->transportType == BT_TRANSPORT_BR_EDR && connect->mtu == DEFAULTBREDRMTU)) {
920         connect->mtuFlag = true;
921     }
922 
923     attServerDataCallback = AttGetATTServerCallback();
924     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
925         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
926         goto ATTREADREQUEST_END;
927     }
928 
929     data = (uint8_t *)BufferPtr(buffer);
930     attReadObj.readHandle.attHandle = ((uint16_t *)data)[0];
931 
932     LOG_INFO("%{public}s connectHandle = %hu, callback para : attHandle = %{public}d",
933         __FUNCTION__,
934         connect->retGattConnectHandle,
935         attReadObj.readHandle.attHandle);
936 
937     attServerDataCallback->attServerCallback(
938         connect->retGattConnectHandle, ATT_READ_REQUEST_ID, &attReadObj, NULL, attServerDataCallback->context);
939 
940 ATTREADREQUEST_END:
941     return;
942 }
943 
944 /**
945  * @brief received read response.
946  *
947  * @param1 connect Indicates the pointer to const AttConnectInfo.
948  * @param2 buffer Indicates the pointer to Buffer.
949  */
AttReadResponse(AttConnectInfo * connect,const Buffer * buffer)950 void AttReadResponse(AttConnectInfo *connect, const Buffer *buffer)
951 {
952     LOG_INFO("%{public}s enter", __FUNCTION__);
953     if (connect == NULL) {
954         LOG_WARN("%{public}s:connect == NULL and return", __FUNCTION__);
955         return;
956     }
957 
958     AttClientDataCallback *attClientDataCallback = NULL;
959 
960     if (buffer == NULL) {
961         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
962     }
963 
964     AlarmCancel(connect->alarm);
965 
966     attClientDataCallback = AttGetATTClientCallback();
967     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
968         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
969         goto ATTREADRESPONSE_END;
970     }
971 
972     attClientDataCallback->attClientCallback(
973         connect->retGattConnectHandle, ATT_READ_RESPONSE_ID, NULL, (Buffer *)buffer, attClientDataCallback->context);
974 
975 ATTREADRESPONSE_END:
976     LOG_INFO("%{public}s return connect != NULL, connectHandle = %hu", __FUNCTION__, connect->retGattConnectHandle);
977     ListRemoveFirst(connect->instruct);
978     AttReceiveSequenceScheduling(connect);
979     return;
980 }
981 
982 /**
983  * @brief received readblob request.
984  *
985  * @param1 connect Indicates the pointer to const AttConnectInfo.
986  * @param2 buffer Indicates the pointer to Buffer.
987  */
AttReadBlobRequest(AttConnectInfo * connect,const Buffer * buffer)988 void AttReadBlobRequest(AttConnectInfo *connect, const Buffer *buffer)
989 {
990     LOG_INFO("%{public}s enter", __FUNCTION__);
991     if (connect == NULL) {
992         LOG_WARN("%{public}s:connect == NULL and return", __FUNCTION__);
993         return;
994     }
995 
996     AttRead attReadObj;
997     uint8_t *data = NULL;
998     AttServerDataCallback *attServerDataCallback = NULL;
999 
1000     if (buffer == NULL) {
1001         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
1002         goto ATTREADBLOBREQUEST_END;
1003     }
1004 
1005     if ((connect->transportType == BT_TRANSPORT_LE && connect->mtu == DEFAULTLEATTMTU) ||
1006         (connect->transportType == BT_TRANSPORT_BR_EDR && connect->mtu == DEFAULTBREDRMTU)) {
1007         connect->mtuFlag = true;
1008     }
1009 
1010     attServerDataCallback = AttGetATTServerCallback();
1011     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
1012         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
1013         goto ATTREADBLOBREQUEST_END;
1014     }
1015     data = (uint8_t *)BufferPtr(buffer);
1016     attReadObj.readBlob.attHandle = ((uint16_t *)data)[0];
1017     attReadObj.readBlob.offset = ((uint16_t *)(data + STEP_TWO))[0];
1018 
1019     LOG_INFO("%{public}s connectHandle = %hu, callback para : attHandle = %{public}d, offset = %{public}d",
1020         __FUNCTION__,
1021         connect->retGattConnectHandle,
1022         attReadObj.readBlob.attHandle,
1023         attReadObj.readBlob.offset);
1024 
1025     attServerDataCallback->attServerCallback(
1026         connect->retGattConnectHandle, ATT_READ_BLOB_REQUEST_ID, &attReadObj, NULL, attServerDataCallback->context);
1027 
1028 ATTREADBLOBREQUEST_END:
1029     return;
1030 }
1031 
1032 /**
1033  * @brief received readblob response.
1034  *
1035  * @param1 connect Indicates the pointer to const AttConnectInfo.
1036  * @param2 buffer Indicates the pointer to Buffer.
1037  */
AttReadBlobResponse(AttConnectInfo * connect,const Buffer * buffer)1038 void AttReadBlobResponse(AttConnectInfo *connect, const Buffer *buffer)
1039 {
1040     LOG_INFO("%{public}s enter", __FUNCTION__);
1041     if (connect == NULL) {
1042         LOG_WARN("%{public}s:connect == NULL and return", __FUNCTION__);
1043         return;
1044     }
1045 
1046     if (buffer == NULL) {
1047         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
1048     }
1049 
1050     AttClientDataCallback *attClientDataCallback = NULL;
1051 
1052     AlarmCancel(connect->alarm);
1053 
1054     attClientDataCallback = AttGetATTClientCallback();
1055     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
1056         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
1057         goto ATTREADBLOBRESPONSE_END;
1058     }
1059 
1060     attClientDataCallback->attClientCallback(connect->retGattConnectHandle,
1061         ATT_READ_BLOB_RESPONSE_ID,
1062         NULL,
1063         (Buffer *)buffer,
1064         attClientDataCallback->context);
1065 
1066 ATTREADBLOBRESPONSE_END:
1067     LOG_INFO("%{public}s return connect != NULL, connectHandle = %hu", __FUNCTION__, connect->retGattConnectHandle);
1068     ListRemoveFirst(connect->instruct);
1069     AttReceiveSequenceScheduling(connect);
1070     return;
1071 }
1072 
1073 /**
1074  * @brief received readmultiple request.
1075  *
1076  * @param1 connect Indicates the pointer to const AttConnectInfo.
1077  * @param2 buffer Indicates the pointer to Buffer.
1078  */
AttReadMultipleRequest(AttConnectInfo * connect,const Buffer * buffer)1079 void AttReadMultipleRequest(AttConnectInfo *connect, const Buffer *buffer)
1080 {
1081     LOG_INFO("%{public}s enter", __FUNCTION__);
1082     if (connect == NULL) {
1083         LOG_WARN("%{public}s:connect == NULL and return", __FUNCTION__);
1084         return;
1085     }
1086 
1087     AttServerDataCallback *attServerDataCallback = NULL;
1088 
1089     if (buffer == NULL) {
1090         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
1091         goto ATTREADMULTIPLEREQUEST_END;
1092     }
1093 
1094     if ((connect->transportType == BT_TRANSPORT_LE && connect->mtu == DEFAULTLEATTMTU) ||
1095         (connect->transportType == BT_TRANSPORT_BR_EDR && connect->mtu == DEFAULTBREDRMTU)) {
1096         connect->mtuFlag = true;
1097     }
1098 
1099     attServerDataCallback = AttGetATTServerCallback();
1100     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
1101         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
1102         goto ATTREADMULTIPLEREQUEST_END;
1103     }
1104     LOG_INFO("%{public}s connectHandle = %hu", __FUNCTION__, connect->retGattConnectHandle);
1105     attServerDataCallback->attServerCallback(connect->retGattConnectHandle,
1106         ATT_READ_MULTIPLE_REQUEST_ID,
1107         NULL,
1108         (Buffer *)buffer,
1109         attServerDataCallback->context);
1110 
1111 ATTREADMULTIPLEREQUEST_END:
1112     return;
1113 }
1114 
1115 /**
1116  * @brief received readmultiple response.
1117  *
1118  * @param1 connect Indicates the pointer to const AttConnectInfo.
1119  * @param2 buffer Indicates the pointer to Buffer.
1120  */
AttReadMultipleResponse(AttConnectInfo * connect,const Buffer * buffer)1121 void AttReadMultipleResponse(AttConnectInfo *connect, const Buffer *buffer)
1122 {
1123     LOG_INFO("%{public}s enter", __FUNCTION__);
1124     if (connect == NULL) {
1125         LOG_WARN("%{public}s:connect == NULL and return", __FUNCTION__);
1126         return;
1127     }
1128 
1129     AttClientDataCallback *attClientDataCallback = NULL;
1130 
1131     AlarmCancel(connect->alarm);
1132 
1133     if (buffer == NULL) {
1134         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
1135     }
1136 
1137     attClientDataCallback = AttGetATTClientCallback();
1138     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
1139         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
1140         goto ATTREADMULTIPLERESPONSE_END;
1141     }
1142 
1143     attClientDataCallback->attClientCallback(connect->retGattConnectHandle,
1144         ATT_READ_MULTIPLE_RESPONSE_ID,
1145         NULL,
1146         (Buffer *)buffer,
1147         attClientDataCallback->context);
1148 
1149 ATTREADMULTIPLERESPONSE_END:
1150     LOG_INFO("%{public}s return connect != NULL, connectHandle = %hu", __FUNCTION__, connect->retGattConnectHandle);
1151     ListRemoveFirst(connect->instruct);
1152     AttReceiveSequenceScheduling(connect);
1153     return;
1154 }
1155 
1156 /**
1157  * @brief received readbygrouptype request.
1158  *
1159  * @param1 connect Indicates the pointer to const AttConnectInfo.
1160  * @param2 buffer Indicates the pointer to Buffer.
1161  */
AttReadByGroupTypeRequest(AttConnectInfo * connect,const Buffer * buffer)1162 void AttReadByGroupTypeRequest(AttConnectInfo *connect, const Buffer *buffer)
1163 {
1164     LOG_INFO("%{public}s enter", __FUNCTION__);
1165     if (connect == NULL) {
1166         LOG_WARN("%{public}s:connect == NULL and return", __FUNCTION__);
1167         return;
1168     }
1169 
1170     AttRead attReadObj;
1171     uint8_t *data = NULL;
1172     size_t buffSize;
1173     AttServerDataCallback *attServerDataCallback = NULL;
1174 
1175     if ((connect->transportType == BT_TRANSPORT_LE && connect->mtu == DEFAULTLEATTMTU) ||
1176         (connect->transportType == BT_TRANSPORT_BR_EDR && connect->mtu == DEFAULTBREDRMTU)) {
1177         connect->mtuFlag = true;
1178     }
1179 
1180     attServerDataCallback = AttGetATTServerCallback();
1181     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL) || (buffer == NULL)) {
1182         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
1183         goto ATTREADBYGROUPTYPEREQUEST_END;
1184     }
1185 
1186     data = (uint8_t *)BufferPtr(buffer);
1187     attReadObj.readGroupRequest.handleRange.startHandle = ((uint16_t *)data)[0];
1188     attReadObj.readGroupRequest.handleRange.endHandle = ((uint16_t *)(data + STEP_TWO))[0];
1189     buffSize = BufferGetSize(buffer);
1190     attReadObj.readGroupRequest.uuid = MEM_MALLOC.alloc(sizeof(BtUuid));
1191 
1192     if ((buffSize - STEP_FOUR) == UUID16BITTYPELEN) {
1193         attReadObj.readGroupRequest.uuid->type = BT_UUID_16;
1194         attReadObj.readGroupRequest.uuid->uuid16 = ((uint16_t *)(data + STEP_FOUR))[0];
1195         LOG_INFO("%{public}s enter, callback para : uuid_type = %{public}d, uuid = %{public}d",
1196             __FUNCTION__,
1197             attReadObj.readGroupRequest.uuid->type,
1198             attReadObj.readGroupRequest.uuid->uuid16);
1199     } else if ((buffSize - STEP_FOUR) == UUID128BITTYPELEN) {
1200         attReadObj.readGroupRequest.uuid->type = BT_UUID_128;
1201         (void)memcpy_s(
1202             attReadObj.readGroupRequest.uuid->uuid128, UUID128BITTYPELEN, data + STEP_FOUR, UUID128BITTYPELEN);
1203     }
1204 
1205     attServerDataCallback->attServerCallback(connect->retGattConnectHandle,
1206         ATT_READ_BY_GROUP_TYPE_REQUEST_ID,
1207         &attReadObj,
1208         NULL,
1209         attServerDataCallback->context);
1210     MEM_MALLOC.free(attReadObj.readGroupRequest.uuid);
1211 
1212 ATTREADBYGROUPTYPEREQUEST_END:
1213     return;
1214 }
1215 
1216 /**
1217  * @brief received readbygrouptype response error assign.
1218  *
1219  * @param1 attErrorObjPtr Indicates the pointer to AttError.
1220  * @param2 connect Indicates the pointer to AttConnectInfo.
1221  */
ReadByGroupTypeResponseErrorAssign(AttError * attErrorObjPtr,const AttConnectInfo * connect)1222 static void ReadByGroupTypeResponseErrorAssign(AttError *attErrorObjPtr, const AttConnectInfo *connect)
1223 {
1224     LOG_INFO("%{public}s enter", __FUNCTION__);
1225     if (attErrorObjPtr == NULL || connect == NULL) {
1226         LOG_WARN("%{public}s:attErrorObjPtr or connect is NULL, return", __FUNCTION__);
1227         return;
1228     }
1229     attErrorObjPtr->reqOpcode = READ_BY_GROUP_TYPE_REQUEST;
1230     attErrorObjPtr->errorCode = ATT_INVALID_ATTRIBUTE_VALUE_LENGTH;
1231     attErrorObjPtr->attHandleInError = connect->aclHandle;
1232 
1233     return;
1234 }
1235 
1236 /**
1237  * @brief received readbygrouptype response.
1238  *
1239  * @param1 connect Indicates the pointer to const AttConnectInfo.
1240  * @param2 buffer Indicates the pointer to Buffer.
1241  */
AttReadByGroupTypeResponse(AttConnectInfo * connect,const Buffer * buffer)1242 void AttReadByGroupTypeResponse(AttConnectInfo *connect, const Buffer *buffer)
1243 {
1244     LOG_INFO("%{public}s enter", __FUNCTION__);
1245     if (connect == NULL) {
1246         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1247         return;
1248     }
1249 
1250     size_t dataLen;
1251     AttRead attReadObj;
1252     uint8_t len;
1253     uint8_t *data = NULL;
1254     AttClientDataCallback *attClientDataCallback = NULL;
1255     AttError attErrorObj;
1256 
1257     AlarmCancel(connect->alarm);
1258 
1259     attClientDataCallback = AttGetATTClientCallback();
1260     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL) || (buffer == NULL)) {
1261         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
1262         goto ATTREADBYGROUPTYPERESPONSE_END;
1263     }
1264 
1265     dataLen = BufferGetSize(buffer);
1266     data = ((uint8_t *)BufferPtr(buffer) + 1);
1267     attReadObj.readGroupResponse.length = *(uint8_t *)BufferPtr(buffer);
1268     len = attReadObj.readGroupResponse.length;
1269     if (len == 0) {
1270         LOG_ERROR("%{public}s len is 0", __FUNCTION__);
1271         attReadObj.readGroupResponse.num = 0;
1272     } else if ((dataLen - 1) % len) {
1273         ReadByGroupTypeResponseErrorAssign(&attErrorObj, connect);
1274         attClientDataCallback->attClientCallback(
1275             connect->retGattConnectHandle, ATT_ERROR_RESPONSE_ID, &attErrorObj, NULL, attClientDataCallback->context);
1276         goto ATTREADBYGROUPTYPERESPONSE_END;
1277     } else {
1278         attReadObj.readGroupResponse.num = (dataLen - 1) / len;
1279     }
1280     attReadObj.readGroupResponse.attributeData = (AttReadGoupAttributeData *)MEM_MALLOC.alloc(
1281         sizeof(AttReadGoupAttributeData) * attReadObj.readGroupResponse.num);
1282     AttReadAttrAssign(&attReadObj, len, data);
1283     attClientDataCallback->attClientCallback(connect->retGattConnectHandle,
1284         ATT_READ_BY_GROUP_TYPE_RESPONSE_ID,
1285         &attReadObj,
1286         NULL,
1287         attClientDataCallback->context);
1288     AttReadFree(&attReadObj, attReadObj.readGroupResponse.num, READBYGROUPTYPERESPONSEFREE);
1289 
1290 ATTREADBYGROUPTYPERESPONSE_END:
1291     ListRemoveFirst(connect->instruct);
1292     AttReceiveSequenceScheduling(connect);
1293     return;
1294 }
1295 
1296 /**
1297  * @brief received write request.
1298  *
1299  * @param1 connect Indicates the pointer to const AttConnectInfo.
1300  * @param2 buffer Indicates the pointer to Buffer.
1301  */
AttWriteRequest(AttConnectInfo * connect,const Buffer * buffer)1302 void AttWriteRequest(AttConnectInfo *connect, const Buffer *buffer)
1303 {
1304     LOG_INFO("%{public}s enter", __FUNCTION__);
1305     if (connect == NULL) {
1306         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1307         return;
1308     }
1309 
1310     size_t buffSize;
1311     AttWrite attWriteObj;
1312     uint8_t *data = NULL;
1313     Buffer *bufferNew = NULL;
1314     AttServerDataCallback *attServerDataCallback = NULL;
1315 
1316     if ((connect->transportType == BT_TRANSPORT_LE && connect->mtu == DEFAULTLEATTMTU) ||
1317         (connect->transportType == BT_TRANSPORT_BR_EDR && connect->mtu == DEFAULTBREDRMTU)) {
1318         connect->mtuFlag = true;
1319     }
1320 
1321     attServerDataCallback = AttGetATTServerCallback();
1322     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
1323         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
1324         goto ATTWRITEREQUEST_END;
1325     }
1326 
1327     buffSize = BufferGetSize(buffer);
1328     data = (uint8_t *)BufferPtr(buffer);
1329     attWriteObj.writeRequest.attHandle = ((uint16_t *)data)[0];
1330     bufferNew = BufferSliceMalloc(buffer, STEP_TWO, buffSize - STEP_TWO);
1331     LOG_INFO("%{public}s connectHandle = %hu, callback para : attHandle = %{public}d",
1332         __FUNCTION__,
1333         connect->retGattConnectHandle,
1334         attWriteObj.writeRequest.attHandle);
1335 
1336     attServerDataCallback->attServerCallback(
1337         connect->retGattConnectHandle, ATT_WRITE_REQUEST_ID, &attWriteObj, bufferNew, attServerDataCallback->context);
1338 
1339     BufferFree(bufferNew);
1340 
1341 ATTWRITEREQUEST_END:
1342     return;
1343 }
1344 
1345 /**
1346  * @brief received write response.
1347  *
1348  * @param1 connect Indicates the pointer to const AttConnectInfo.
1349  * @param2 buffer Indicates the pointer to Buffer.
1350  */
AttWriteResponse(AttConnectInfo * connect,const Buffer * buffer)1351 void AttWriteResponse(AttConnectInfo *connect, const Buffer *buffer)
1352 {
1353     LOG_INFO("%{public}s enter", __FUNCTION__);
1354     if (connect == NULL) {
1355         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1356         return;
1357     }
1358 
1359     AttClientDataCallback *attClientDataCallback = NULL;
1360 
1361     AlarmCancel(connect->alarm);
1362 
1363     attClientDataCallback = AttGetATTClientCallback();
1364     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
1365         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
1366         goto ATTWRITERESPONSE_END;
1367     }
1368 
1369     attClientDataCallback->attClientCallback(
1370         connect->retGattConnectHandle, ATT_WRITE_RESPONSE_ID, NULL, (Buffer *)buffer, attClientDataCallback->context);
1371 
1372 ATTWRITERESPONSE_END:
1373     LOG_INFO("%{public}s return connect != NULL, connectHandle = %hu", __FUNCTION__, connect->retGattConnectHandle);
1374     ListRemoveFirst(connect->instruct);
1375     AttReceiveSequenceScheduling(connect);
1376     return;
1377 }
1378 
1379 /**
1380  * @brief received write command.
1381  *
1382  * @param1 connect Indicates the pointer to const AttConnectInfo.
1383  * @param2 buffer Indicates the pointer to Buffer.
1384  */
AttWriteCommand(AttConnectInfo * connect,const Buffer * buffer)1385 void AttWriteCommand(AttConnectInfo *connect, const Buffer *buffer)
1386 {
1387     LOG_INFO("%{public}s enter", __FUNCTION__);
1388     if (connect == NULL) {
1389         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1390         return;
1391     }
1392 
1393     size_t buffSize;
1394     AttWrite attWriteObj;
1395     uint8_t *data = NULL;
1396     AttServerDataCallback *attServerDataCallback = NULL;
1397 
1398     if (buffer == NULL) {
1399         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
1400         goto ATTWRITECOMMAND_END;
1401     }
1402 
1403     attServerDataCallback = AttGetATTServerCallback();
1404     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
1405         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
1406         goto ATTWRITECOMMAND_END;
1407     }
1408 
1409     buffSize = BufferGetSize(buffer);
1410     data = (uint8_t *)BufferPtr(buffer);
1411     attWriteObj.writeCommand.attHandle = ((uint16_t *)data)[0];
1412     Buffer *bufferNew = BufferSliceMalloc(buffer, STEP_TWO, buffSize - STEP_TWO);
1413     LOG_INFO("%{public}s connectHandle = %hu, callback para : attHandle = %{public}d",
1414         __FUNCTION__,
1415         connect->retGattConnectHandle,
1416         attWriteObj.writeCommand.attHandle);
1417     attServerDataCallback->attServerCallback(
1418         connect->retGattConnectHandle, ATT_WRITE_COMMAND_ID, &attWriteObj, bufferNew, attServerDataCallback->context);
1419 
1420     BufferFree(bufferNew);
1421 
1422 ATTWRITECOMMAND_END:
1423     return;
1424 }
1425 
1426 /**
1427  * @brief received signedwrite command gap return value error assign.
1428  *
1429  * @param1 attWriteObjPtr Indicates the pointer to AttWrite.
1430  * @param2 ret Indicates the ret.
1431  * @param3 data Indicates the pdata.
1432  */
AttSignedWriteCommandGapRetErrorAssign(AttWrite * attWriteObjPtr,const uint8_t * data)1433 static void AttSignedWriteCommandGapRetErrorAssign(AttWrite *attWriteObjPtr, const uint8_t *data)
1434 {
1435     LOG_INFO("%{public}s enter", __FUNCTION__);
1436     if (attWriteObjPtr == NULL || data == NULL) {
1437         LOG_WARN("%{public}s:attWriteObjPtr or data is NULL, return", __FUNCTION__);
1438         return;
1439     }
1440     attWriteObjPtr->signedWriteCommand.attHandleValueObj.attHandle = ((uint16_t *)(data + 1))[0];
1441     attWriteObjPtr->signedWriteCommand.authSignatureLen = GAPSIGNATURESIZE;
1442     return;
1443 }
1444 
1445 /**
1446  * @brief received signedwrite command.
1447  *
1448  * @param1 connect Indicates the pointer to const AttConnectInfo.
1449  * @param2 buffer Indicates the pointer to Buffer.
1450  */
AttSignedWriteCommand(AttConnectInfo * connect,const Buffer * buffer)1451 void AttSignedWriteCommand(AttConnectInfo *connect, const Buffer *buffer)
1452 {
1453     LOG_INFO("%{public}s enter", __FUNCTION__);
1454     if (connect == NULL) {
1455         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1456         return;
1457     }
1458 
1459     size_t buffSize;
1460     AttWrite attWriteObj;
1461     uint8_t *data = NULL;
1462     uint8_t *dataBuffer = NULL;
1463     Buffer *bufferNew = NULL;
1464     Buffer *bufferallPtr = NULL;
1465     Buffer *sigedWriteBuffPtr = NULL;
1466     int ret;
1467     GapSignatureData gapSignatureDataObj;
1468     uint8_t signature[12] = {0};
1469     AttServerDataCallback *attServerDataCallback = NULL;
1470     SigedWriteCommandConfirmationContext *sigedWriteCommandConfirmContextPtr = NULL;
1471 
1472     attServerDataCallback = AttGetATTServerCallback();
1473     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL) || (buffer == NULL)) {
1474         goto ATTSIGNEDWRITECOMMAND_END;
1475     }
1476 
1477     dataBuffer = (uint8_t *)BufferPtr(buffer);
1478     buffSize = BufferGetSize(buffer);
1479     bufferallPtr = BufferMalloc(buffSize + 1);
1480     data = (uint8_t *)BufferPtr(bufferallPtr);
1481     AttSignWriteCommConfDataAssign(data, dataBuffer, buffSize, signature);
1482     gapSignatureDataObj.data = data;
1483     if (buffSize < (sizeof(signature) - 1)) {
1484         LOG_ERROR("%{public}s buffSize is invalid", __FUNCTION__);
1485         goto ATTSIGNEDWRITECOMMAND_END;
1486     }
1487     gapSignatureDataObj.dataLen = buffSize - (sizeof(signature) - 1);
1488     sigedWriteBuffPtr = BufferMalloc(sizeof(SigedWriteCommandConfirmationContext));
1489     sigedWriteCommandConfirmContextPtr = (SigedWriteCommandConfirmationContext *)BufferPtr(sigedWriteBuffPtr);
1490     AttSignWriteCommConfContextAssign(sigedWriteCommandConfirmContextPtr, connect, data, bufferallPtr, buffSize);
1491 
1492     uint8_t *arrayPtr = signature;
1493     ret = GAPIF_LeDataSignatureConfirmationAsync(
1494         &(connect->addr), gapSignatureDataObj, arrayPtr, AttGapSignatureConfirmationResult, sigedWriteBuffPtr);
1495     if (ret != BT_SUCCESS) {
1496         AttSignedWriteCommandGapRetErrorAssign(&attWriteObj, data);
1497         attWriteObj.signedWriteCommand.result = GAP_REJECT;
1498         (void)memcpy_s(attWriteObj.signedWriteCommand.authSignature,
1499             sizeof(signature),
1500             data + (buffSize - sizeof(signature)),
1501             sizeof(signature));
1502         bufferNew = BufferSliceMalloc(buffer, STEP_TWO, buffSize - sizeof(signature) - sizeof(uint16_t));
1503         attServerDataCallback->attServerCallback(connect->retGattConnectHandle,
1504             ATT_SIGNED_WRITE_COMMAND_ID,
1505             &attWriteObj,
1506             bufferNew,
1507             attServerDataCallback->context);
1508         AttSignedWriteCommandBufferFree(bufferNew, sigedWriteBuffPtr, bufferallPtr);
1509     }
1510 
1511 ATTSIGNEDWRITECOMMAND_END:
1512     return;
1513 }
1514 
1515 /**
1516  * @brief received preparewrite request.
1517  *
1518  * @param1 connect Indicates the pointer to const AttConnectInfo.
1519  * @param2 buffer Indicates the pointer to Buffer.
1520  */
AttPrepareWriteRequest(AttConnectInfo * connect,const Buffer * buffer)1521 void AttPrepareWriteRequest(AttConnectInfo *connect, const Buffer *buffer)
1522 {
1523     LOG_INFO("%{public}s enter", __FUNCTION__);
1524     if (connect == NULL) {
1525         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1526         return;
1527     }
1528 
1529     size_t buffSize;
1530     AttWrite attWriteObj;
1531     uint8_t *data = NULL;
1532     Buffer *bufferNew = NULL;
1533     AttServerDataCallback *attServerDataCallback = NULL;
1534 
1535     if (buffer == NULL) {
1536         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
1537         goto ATTPREPAREWRITEREQUEST_END;
1538     }
1539 
1540     if ((connect->transportType == BT_TRANSPORT_LE && connect->mtu == DEFAULTLEATTMTU) ||
1541         (connect->transportType == BT_TRANSPORT_BR_EDR && connect->mtu == DEFAULTBREDRMTU)) {
1542         connect->mtuFlag = true;
1543     }
1544 
1545     attServerDataCallback = AttGetATTServerCallback();
1546     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
1547         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
1548         goto ATTPREPAREWRITEREQUEST_END;
1549     }
1550 
1551     buffSize = BufferGetSize(buffer);
1552     data = (uint8_t *)BufferPtr(buffer);
1553     attWriteObj.prepareWrite.handleValue.attHandle = ((uint16_t *)data)[0];
1554     attWriteObj.prepareWrite.offset = ((uint16_t *)(data + STEP_TWO))[0];
1555     bufferNew = BufferSliceMalloc(buffer, STEP_FOUR, buffSize - STEP_FOUR);
1556     LOG_INFO("%{public}s connectHandle = %hu, callback para : attHandle = %{public}d, offset = %{public}d",
1557         __FUNCTION__,
1558         connect->retGattConnectHandle,
1559         attWriteObj.prepareWrite.handleValue.attHandle,
1560         attWriteObj.prepareWrite.offset);
1561 
1562     attServerDataCallback->attServerCallback(connect->retGattConnectHandle,
1563         ATT_PREPARE_WRITE_REQUEST_ID,
1564         &attWriteObj,
1565         bufferNew,
1566         attServerDataCallback->context);
1567 
1568     BufferFree(bufferNew);
1569 
1570 ATTPREPAREWRITEREQUEST_END:
1571     return;
1572 }
1573 
1574 /**
1575  * @brief received preparewrite response.
1576  *
1577  * @param1 connect Indicates the pointer to const AttConnectInfo.
1578  * @param2 buffer Indicates the pointer to Buffer.
1579  */
AttPrepareWriteResponse(AttConnectInfo * connect,const Buffer * buffer)1580 void AttPrepareWriteResponse(AttConnectInfo *connect, const Buffer *buffer)
1581 {
1582     LOG_INFO("%{public}s enter", __FUNCTION__);
1583     if (connect == NULL) {
1584         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1585         return;
1586     }
1587 
1588     size_t buffSize;
1589     AttWrite attWriteObj;
1590     uint8_t *data = NULL;
1591     Buffer *bufferNew = NULL;
1592     AttClientDataCallback *attClientDataCallback = NULL;
1593 
1594     AlarmCancel(connect->alarm);
1595     if (buffer == NULL) {
1596         goto ATTPREPAREWRITERESPONSE_END;
1597     }
1598 
1599     attClientDataCallback = AttGetATTClientCallback();
1600     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
1601         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
1602         goto ATTPREPAREWRITERESPONSE_END;
1603     }
1604 
1605     buffSize = BufferGetSize(buffer);
1606     data = (uint8_t *)BufferPtr(buffer);
1607     attWriteObj.prepareWrite.handleValue.attHandle = ((uint16_t *)data)[0];
1608     attWriteObj.prepareWrite.offset = ((uint16_t *)(data + STEP_TWO))[0];
1609 
1610     if (buffSize - STEP_FOUR > 0) {
1611         bufferNew = BufferSliceMalloc(buffer, STEP_FOUR, buffSize - STEP_FOUR);
1612         attClientDataCallback->attClientCallback(connect->retGattConnectHandle,
1613             ATT_PREPARE_WRITE_RESPONSE_ID,
1614             &attWriteObj,
1615             bufferNew,
1616             attClientDataCallback->context);
1617         BufferFree(bufferNew);
1618     } else {
1619         attClientDataCallback->attClientCallback(connect->retGattConnectHandle,
1620             ATT_PREPARE_WRITE_RESPONSE_ID,
1621             &attWriteObj,
1622             NULL,
1623             attClientDataCallback->context);
1624     }
1625 
1626 ATTPREPAREWRITERESPONSE_END:
1627     LOG_INFO("%{public}s return connect != NULL, connectHandle = %hu", __FUNCTION__, connect->retGattConnectHandle);
1628     ListRemoveFirst(connect->instruct);
1629     AttReceiveSequenceScheduling(connect);
1630     return;
1631 }
1632 
1633 /**
1634  * @brief received executewrite request.
1635  *
1636  * @param1 connect Indicates the pointer to const AttConnectInfo.
1637  * @param2 buffer Indicates the pointer to Buffer.
1638  */
AttExecuteWriteRequest(AttConnectInfo * connect,const Buffer * buffer)1639 void AttExecuteWriteRequest(AttConnectInfo *connect, const Buffer *buffer)
1640 {
1641     LOG_INFO("%{public}s enter", __FUNCTION__);
1642     if (connect == NULL) {
1643         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1644         return;
1645     }
1646 
1647     AttWrite attWriteObj;
1648     uint8_t *data = NULL;
1649     AttServerDataCallback *attServerDataCallback = NULL;
1650 
1651     if (buffer == NULL) {
1652         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
1653         goto ATTEXECUTEWRITEREQUEST_END;
1654     }
1655 
1656     if ((connect->transportType == BT_TRANSPORT_LE && connect->mtu == DEFAULTLEATTMTU) ||
1657         (connect->transportType == BT_TRANSPORT_BR_EDR && connect->mtu == DEFAULTBREDRMTU)) {
1658         connect->mtuFlag = true;
1659     }
1660 
1661     attServerDataCallback = AttGetATTServerCallback();
1662     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
1663         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
1664         goto ATTEXECUTEWRITEREQUEST_END;
1665     }
1666 
1667     data = (uint8_t *)BufferPtr(buffer);
1668     attWriteObj.excuteWrite.flag = data[0];
1669 
1670     LOG_INFO("%{public}s connecthandle = %{public}d, callback para : flag = %{public}d",
1671         __FUNCTION__,
1672         connect->retGattConnectHandle,
1673         attWriteObj.excuteWrite.flag);
1674 
1675     attServerDataCallback->attServerCallback(connect->retGattConnectHandle,
1676         ATT_EXECUTE_WRITE_REQUEST_ID,
1677         &attWriteObj,
1678         NULL,
1679         attServerDataCallback->context);
1680 
1681 ATTEXECUTEWRITEREQUEST_END:
1682     return;
1683 }
1684 
1685 /**
1686  * @brief received executewrite response.
1687  *
1688  * @param1 connect Indicates the pointer to const AttConnectInfo.
1689  * @param2 buffer Indicates the pointer to Buffer.
1690  */
AttExecuteWriteResponse(AttConnectInfo * connect,const Buffer * buffer)1691 void AttExecuteWriteResponse(AttConnectInfo *connect, const Buffer *buffer)
1692 {
1693     LOG_INFO("%{public}s enter", __FUNCTION__);
1694     if (connect == NULL) {
1695         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1696         return;
1697     }
1698 
1699     AttClientDataCallback *attClientDataCallback = NULL;
1700 
1701     AlarmCancel(connect->alarm);
1702 
1703     if (buffer == NULL) {
1704         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
1705         goto ATTEXECUTEWRITERESPONSE_END;
1706     }
1707 
1708     attClientDataCallback = AttGetATTClientCallback();
1709     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
1710         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
1711         goto ATTEXECUTEWRITERESPONSE_END;
1712     }
1713 
1714     attClientDataCallback->attClientCallback(
1715         connect->retGattConnectHandle, ATT_EXECUTE_WRITE_RESPONSE_ID, NULL, NULL, attClientDataCallback->context);
1716 
1717 ATTEXECUTEWRITERESPONSE_END:
1718     LOG_INFO("%{public}s return connect != NULL, connectHandle = %hu", __FUNCTION__, connect->retGattConnectHandle);
1719     ListRemoveFirst(connect->instruct);
1720     AttReceiveSequenceScheduling(connect);
1721     return;
1722 }
1723 
1724 /**
1725  * @brief received handlevalue notification.
1726  *
1727  * @param1 connect Indicates the pointer to const AttConnectInfo.
1728  * @param2 buffer Indicates the pointer to Buffer.
1729  */
AttHandleValueNotification(AttConnectInfo * connect,const Buffer * buffer)1730 void AttHandleValueNotification(AttConnectInfo *connect, const Buffer *buffer)
1731 {
1732     LOG_INFO("%{public}s enter", __FUNCTION__);
1733     if (connect == NULL) {
1734         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1735         return;
1736     }
1737 
1738     size_t buffNotiSize;
1739     AttHandleValue AttHandleValueObj;
1740     uint8_t *data = NULL;
1741     Buffer *bufferNew = NULL;
1742     AttClientDataCallback *attClientDataCallback = NULL;
1743 
1744     if (buffer == NULL) {
1745         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
1746         goto ATTHANDLEVALUENOTIFICATION_END;
1747     }
1748 
1749     attClientDataCallback = AttGetATTClientCallback();
1750     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
1751         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
1752         goto ATTHANDLEVALUENOTIFICATION_END;
1753     }
1754 
1755     buffNotiSize = BufferGetSize(buffer);
1756     data = (uint8_t *)BufferPtr(buffer);
1757     AttHandleValueObj.attHandle = ((uint16_t *)data)[0];
1758     bufferNew = BufferSliceMalloc(buffer, STEP_TWO, buffNotiSize - STEP_TWO);
1759 
1760     LOG_INFO("%{public}s connectHandle = %hu, callback para : attHandle = %{public}d",
1761         __FUNCTION__,
1762         connect->retGattConnectHandle,
1763         AttHandleValueObj.attHandle);
1764 
1765     attClientDataCallback->attClientCallback(connect->retGattConnectHandle,
1766         ATT_HANDLE_VALUE_NOTIFICATION_ID,
1767         &AttHandleValueObj,
1768         bufferNew,
1769         attClientDataCallback->context);
1770 
1771     BufferFree(bufferNew);
1772 
1773 ATTHANDLEVALUENOTIFICATION_END:
1774     return;
1775 }
1776 
1777 /**
1778  * @brief received handlevalue indication.
1779  *
1780  * @param1 connect Indicates the pointer to const AttConnectInfo.
1781  * @param2 buffer Indicates the pointer to Buffer.
1782  */
AttHandleValueIndication(AttConnectInfo * connect,const Buffer * buffer)1783 void AttHandleValueIndication(AttConnectInfo *connect, const Buffer *buffer)
1784 {
1785     LOG_INFO("%{public}s enter", __FUNCTION__);
1786     if (connect == NULL) {
1787         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1788         return;
1789     }
1790 
1791     size_t buffIndiSize;
1792     AttHandleValue AttHandleValueObj;
1793     uint8_t *data = NULL;
1794     Buffer *bufferNew = NULL;
1795     AttClientDataCallback *attClientDataCallback = NULL;
1796 
1797     if (buffer == NULL) {
1798         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
1799         goto ATTHANDLEVALUEINDICATION_END;
1800     }
1801 
1802     attClientDataCallback = AttGetATTClientCallback();
1803     if ((attClientDataCallback == NULL) || (attClientDataCallback->attClientCallback == NULL)) {
1804         LOG_WARN("%{public}s attClientDataCallback or attClientDataCallback->attClientCallback is NULL", __FUNCTION__);
1805         goto ATTHANDLEVALUEINDICATION_END;
1806     }
1807 
1808     buffIndiSize = BufferGetSize(buffer);
1809     data = (uint8_t *)BufferPtr(buffer);
1810     AttHandleValueObj.attHandle = ((uint16_t *)data)[0];
1811     bufferNew = BufferSliceMalloc(buffer, STEP_TWO, buffIndiSize - STEP_TWO);
1812 
1813     LOG_INFO("%{public}s connectHandle = %hu, callback para : attHandle = %{public}d",
1814         __FUNCTION__,
1815         connect->retGattConnectHandle,
1816         AttHandleValueObj.attHandle);
1817 
1818     attClientDataCallback->attClientCallback(connect->retGattConnectHandle,
1819         ATT_HANDLE_VALUE_INDICATION_ID,
1820         &AttHandleValueObj,
1821         bufferNew,
1822         attClientDataCallback->context);
1823 
1824     BufferFree(bufferNew);
1825 
1826 ATTHANDLEVALUEINDICATION_END:
1827     return;
1828 }
1829 
1830 /**
1831  * @brief received handlevalue confirmation.
1832  *
1833  * @param1 connect Indicates the pointer to const AttConnectInfo.
1834  * @param2 buffer Indicates the pointer to Buffer.
1835  */
AttHandleValueConfirmation(AttConnectInfo * connect,const Buffer * buffer)1836 void AttHandleValueConfirmation(AttConnectInfo *connect, const Buffer *buffer)
1837 {
1838     LOG_INFO("%{public}s enter", __FUNCTION__);
1839     if (connect == NULL) {
1840         LOG_ERROR("%{public}s connect is NULL", __FUNCTION__);
1841         return;
1842     }
1843 
1844     AttServerDataCallback *attServerDataCallback = NULL;
1845     AttWrite attWrite;
1846     attWrite.confirmation.attHandle = 0x0000;
1847 
1848     AlarmCancel(connect->alarm);
1849 
1850     if (buffer == NULL) {
1851         LOG_WARN("%{public}s:buffer == NULL", __FUNCTION__);
1852         goto ATTHANDLEVALUECONFIRMATION_END;
1853     }
1854 
1855     attServerDataCallback = AttGetATTServerCallback();
1856     if ((attServerDataCallback == NULL) || (attServerDataCallback->attServerCallback == NULL)) {
1857         LOG_WARN("%{public}s attServerDataCallback or attServerDataCallback->attServerCallback is NULL", __FUNCTION__);
1858         goto ATTHANDLEVALUECONFIRMATION_END;
1859     }
1860 
1861     if (connect->serverSendFlag) {
1862         connect->serverSendFlag = false;
1863     }
1864 
1865     attServerDataCallback->attServerCallback(connect->retGattConnectHandle,
1866         ATT_HANDLE_VALUE_CONFIRMATION_ID,
1867         &attWrite,
1868         NULL,
1869         attServerDataCallback->context);
1870 
1871 ATTHANDLEVALUECONFIRMATION_END:
1872     LOG_INFO("%{public}s return connect != NULL, connectHandle = %hu", __FUNCTION__, connect->retGattConnectHandle);
1873     ListRemoveFirst(connect->instruct);
1874     AttReceiveSequenceScheduling(connect);
1875     return;
1876 }
1877 
1878 /**
1879  * @brief assign signedWriteCommand context.
1880  *
1881  * @param1 sigedWriteCommandConfirmContextPtr Indicates the pointer to SigedWriteCommandConfirmationContext.
1882  * @param2 connect Indicates the pointer to AttConnectInfo.
1883  * @param3 data Indicates the pointer to uint8_t.
1884  * @param4 bufferallPtr  Indicates the pointer to Buffer.
1885  * @param5 buffSize Indicates the size_t.
1886  */
AttSignWriteCommConfContextAssign(SigedWriteCommandConfirmationContext * sigedWriteCommandConfirmContextPtr,const AttConnectInfo * connect,const uint8_t * data,const Buffer * bufferallPtr,const size_t buffSize)1887 static void AttSignWriteCommConfContextAssign(SigedWriteCommandConfirmationContext *sigedWriteCommandConfirmContextPtr,
1888     const AttConnectInfo *connect, const uint8_t *data, const Buffer *bufferallPtr, const size_t buffSize)
1889 {
1890     LOG_INFO("%{public}s enter", __FUNCTION__);
1891     if (sigedWriteCommandConfirmContextPtr == NULL) {
1892         LOG_ERROR("%{public}s sigedWriteCommandConfirmContextPtr is NULL", __FUNCTION__);
1893         return;
1894     }
1895 
1896     sigedWriteCommandConfirmContextPtr->connect = (AttConnectInfo *)connect;
1897     sigedWriteCommandConfirmContextPtr->data = (uint8_t *)data;
1898     sigedWriteCommandConfirmContextPtr->bufferallPtr = (Buffer *)bufferallPtr;
1899     sigedWriteCommandConfirmContextPtr->bufferSize = buffSize - STEP_TWO - GAPSIGNATURESIZE;
1900 
1901     return;
1902 }
1903 
1904 /**
1905  * @brief assign signedWriteCommand data.
1906  *
1907  * @param1 data Indicates the pointer to uint8_t.
1908  * @param2 dataBuffer  Indicates the pointer to Buffer.
1909  * @param3 buffSize Indicates the size_t.
1910  * @param4 signature  Indicates the pointer to uint8_t.
1911  */
AttSignWriteCommConfDataAssign(uint8_t * data,const uint8_t * dataBuffer,size_t buffSize,uint8_t signature[12])1912 static void AttSignWriteCommConfDataAssign(
1913     uint8_t *data, const uint8_t *dataBuffer, size_t buffSize, uint8_t signature[12])
1914 {
1915     LOG_INFO("%{public}s enter", __FUNCTION__);
1916     if (data == NULL || dataBuffer == NULL) {
1917         LOG_ERROR("%{public}s data or dataBuffer is NULL", __FUNCTION__);
1918         return;
1919     }
1920     if (buffSize < STEP_TWO + GAPSIGNATURESIZE) {
1921         LOG_ERROR("%{public}s buffSize is small", __FUNCTION__);
1922         return;
1923     }
1924 
1925     data[0] = SIGNED_WRITE_COMMAND;
1926     (void)memcpy_s(data + 1, buffSize, dataBuffer, buffSize);
1927     (void)memcpy_s(signature,
1928         GAPSIGNATURESIZE,
1929         dataBuffer + STEP_TWO + (buffSize - STEP_TWO - GAPSIGNATURESIZE),
1930         GAPSIGNATURESIZE);
1931 
1932     return;
1933 }
1934 
1935 /**
1936  * @brief assign signedWriteCommand data.
1937  *
1938  * @param1 bufferNew  Indicates the pointer to Buffer.
1939  * @param2 sigedWriteBuffPtr  Indicates the pointer to Buffer.
1940  * @param3 bufferallPtr  Indicates the pointer to Buffer.
1941  */
AttSignedWriteCommandBufferFree(Buffer * bufferNew,Buffer * sigedWriteBuffPtr,Buffer * bufferallPtr)1942 static void AttSignedWriteCommandBufferFree(Buffer *bufferNew, Buffer *sigedWriteBuffPtr, Buffer *bufferallPtr)
1943 {
1944     LOG_INFO("%{public}s enter", __FUNCTION__);
1945 
1946     BufferFree(bufferNew);
1947     BufferFree(sigedWriteBuffPtr);
1948     BufferFree(bufferallPtr);
1949 
1950     return;
1951 }
1952 
1953 /**
1954  * @brief assign signedWriteCommand data.
1955  *
1956  * @param1 attErrorObjPtr  Indicates the pointer to AttError.
1957  * @param2 connect  Indicates the pointer to AttConnectInfo.
1958  */
AttReadByTypeResErrorAssign(AttError * attErrorObjPtr,const AttConnectInfo * connect)1959 static void AttReadByTypeResErrorAssign(AttError *attErrorObjPtr, const AttConnectInfo *connect)
1960 {
1961     LOG_INFO("%{public}s enter", __FUNCTION__);
1962     if (attErrorObjPtr == NULL || connect == NULL) {
1963         LOG_ERROR("%{public}s attErrorObjPtr or connect is NULL", __FUNCTION__);
1964         return;
1965     }
1966 
1967     attErrorObjPtr->reqOpcode = READ_BY_TYPE_REQUEST;
1968     attErrorObjPtr->errorCode = ATT_INVALID_ATTRIBUTE_VALUE_LENGTH;
1969     attErrorObjPtr->attHandleInError = connect->aclHandle;
1970 
1971     return;
1972 }
1973 
1974 /**
1975  * @brief function list init.
1976  *
1977  */
FunctionListInit()1978 void FunctionListInit()
1979 {
1980     LOG_INFO("%{public}s enter", __FUNCTION__);
1981 
1982     recvDataFunction *functionList = GetFunctionArrayDress();
1983 
1984     functionList[ERROR_RESPONSE] = AttErrorResponse;
1985     functionList[FIND_INFORMATION_REQUEST] = AttFindInformationRequest;
1986     functionList[FIND_INFORMATION_RESPONSE] = AttFindInformationResponse;
1987     functionList[FIND_BY_TYPE_VALUE_REQUEST] = AttFindByTypeValueRequest;
1988     functionList[FIND_BY_TYPE_VALUE_RESPONSE] = AttFindByTypeValueResponse;
1989     functionList[READ_BY_TYPE_REQUEST] = AttReadByTypeRequest;
1990     functionList[READ_BY_TYPE_RESPONSE] = AttReadByTypeResponse;
1991     functionList[READ_REQUEST] = AttReadRequest;
1992     functionList[READ_RESPONSE] = AttReadResponse;
1993     functionList[READ_BLOB_REQUEST] = AttReadBlobRequest;
1994     functionList[READ_BLOB_RESPONSE] = AttReadBlobResponse;
1995     functionList[READ_MULTIPLE_REQUEST] = AttReadMultipleRequest;
1996     functionList[READ_MULTIPLE_RESPONSE] = AttReadMultipleResponse;
1997     functionList[READ_BY_GROUP_TYPE_REQUEST] = AttReadByGroupTypeRequest;
1998     functionList[READ_BY_GROUP_TYPE_RESPONSE] = AttReadByGroupTypeResponse;
1999     functionList[WRITE_REQUEST] = AttWriteRequest;
2000     functionList[WRITE_RESPONSE] = AttWriteResponse;
2001     functionList[WRITE_COMMAND] = AttWriteCommand;
2002     functionList[SIGNED_WRITE_COMMAND] = AttSignedWriteCommand;
2003     functionList[PREPARE_WRITE_REQUEST] = AttPrepareWriteRequest;
2004     functionList[PREPARE_WRITE_RESPONSE] = AttPrepareWriteResponse;
2005     functionList[EXECUTE_WRITE_REQUEST] = AttExecuteWriteRequest;
2006     functionList[EXECUTE_WRITE_RESPONSE] = AttExecuteWriteResponse;
2007     functionList[HANDLE_VALUE_NOTIFICATION] = AttHandleValueNotification;
2008     functionList[HANDLE_VALUE_INDICATION] = AttHandleValueIndication;
2009     functionList[HANDLE_VALUE_CONFIRMATION] = AttHandleValueConfirmation;
2010     functionList[EXCHANGE_MTU_REQUEST] = AttExchangeMTURequest;
2011     functionList[EXCHANGE_MTU_RESPONSE] = AttExchangeMTUResponse;
2012 
2013     return;
2014 }
2015