1 /******************************************************************************
2  *
3  *  Copyright (C) 2010-2014 Broadcom Corporation
4  *
5  *  Licensed under the Apache License, Version 2.0 (the "License");
6  *  you may not use this file except in compliance with the License.
7  *  You may obtain a copy of the License at:
8  *
9  *  http://www.apache.org/licenses/LICENSE-2.0
10  *
11  *  Unless required by applicable law or agreed to in writing, software
12  *  distributed under the License is distributed on an "AS IS" BASIS,
13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *  See the License for the specific language governing permissions and
15  *  limitations under the License.
16  *
17  ******************************************************************************/
18 
19 /******************************************************************************
20  *
21  *  Handle ndef messages
22  *
23  ******************************************************************************/
24 #include <string.h>
25 
26 #include <android-base/stringprintf.h>
27 #include <base/logging.h>
28 
29 #include "ndef_utils.h"
30 #include "nfa_api.h"
31 #include "nfa_dm_int.h"
32 
33 using android::base::StringPrintf;
34 
35 extern bool nfc_debug_enabled;
36 
37 /*******************************************************************************
38 * URI Well-known-type prefixes
39 *******************************************************************************/
40 const uint8_t* nfa_dm_ndef_wkt_uri_str_tbl[] = {
41     nullptr,                                         /* 0x00 */
42     (const uint8_t*)"http://www.",                /* 0x01 */
43     (const uint8_t*)"https://www.",               /* 0x02 */
44     (const uint8_t*)"http://",                    /* 0x03 */
45     (const uint8_t*)"https://",                   /* 0x04 */
46     (const uint8_t*)"tel:",                       /* 0x05 */
47     (const uint8_t*)"mailto:",                    /* 0x06 */
48     (const uint8_t*)"ftp://anonymous:anonymous@", /* 0x07 */
49     (const uint8_t*)"ftp://ftp.",                 /* 0x08 */
50     (const uint8_t*)"ftps://",                    /* 0x09 */
51     (const uint8_t*)"sftp://",                    /* 0x0A */
52     (const uint8_t*)"smb://",                     /* 0x0B */
53     (const uint8_t*)"nfs://",                     /* 0x0C */
54     (const uint8_t*)"ftp://",                     /* 0x0D */
55     (const uint8_t*)"dav://",                     /* 0x0E */
56     (const uint8_t*)"news:",                      /* 0x0F */
57     (const uint8_t*)"telnet://",                  /* 0x10 */
58     (const uint8_t*)"imap:",                      /* 0x11 */
59     (const uint8_t*)"rtsp://",                    /* 0x12 */
60     (const uint8_t*)"urn:",                       /* 0x13 */
61     (const uint8_t*)"pop:",                       /* 0x14 */
62     (const uint8_t*)"sip:",                       /* 0x15 */
63     (const uint8_t*)"sips:",                      /* 0x16 */
64     (const uint8_t*)"tftp:",                      /* 0x17 */
65     (const uint8_t*)"btspp://",                   /* 0x18 */
66     (const uint8_t*)"btl2cap://",                 /* 0x19 */
67     (const uint8_t*)"btgoep://",                  /* 0x1A */
68     (const uint8_t*)"tcpobex://",                 /* 0x1B */
69     (const uint8_t*)"irdaobex://",                /* 0x1C */
70     (const uint8_t*)"file://",                    /* 0x1D */
71     (const uint8_t*)"urn:epc:id:",                /* 0x1E */
72     (const uint8_t*)"urn:epc:tag:",               /* 0x1F */
73     (const uint8_t*)"urn:epc:pat:",               /* 0x20 */
74     (const uint8_t*)"urn:epc:raw:",               /* 0x21 */
75     (const uint8_t*)"urn:epc:",                   /* 0x22 */
76     (const uint8_t*)"urn:nfc:"                    /* 0x23 */
77 };
78 #define NFA_DM_NDEF_WKT_URI_STR_TBL_SIZE \
79   (sizeof(nfa_dm_ndef_wkt_uri_str_tbl) / sizeof(uint8_t*))
80 
81 /*******************************************************************************
82 **
83 ** Function         nfa_dm_ndef_dereg_hdlr_by_handle
84 **
85 ** Description      Deregister NDEF record type handler
86 **
87 ** Returns          TRUE (message buffer to be freed by caller)
88 **
89 *******************************************************************************/
nfa_dm_ndef_dereg_hdlr_by_handle(tNFA_HANDLE ndef_type_handle)90 void nfa_dm_ndef_dereg_hdlr_by_handle(tNFA_HANDLE ndef_type_handle) {
91   tNFA_DM_CB* p_cb = &nfa_dm_cb;
92   uint16_t hdlr_idx;
93   hdlr_idx = (uint16_t)(ndef_type_handle & NFA_HANDLE_MASK);
94 
95   if (p_cb->p_ndef_handler[hdlr_idx]) {
96     GKI_freebuf(p_cb->p_ndef_handler[hdlr_idx]);
97     p_cb->p_ndef_handler[hdlr_idx] = nullptr;
98   }
99 }
100 
101 /*******************************************************************************
102 **
103 ** Function         nfa_dm_ndef_dereg_all
104 **
105 ** Description      Deregister all NDEF record type handlers (called during
106 **                  shutdown(.
107 **
108 ** Returns          Nothing
109 **
110 *******************************************************************************/
nfa_dm_ndef_dereg_all(void)111 void nfa_dm_ndef_dereg_all(void) {
112   tNFA_DM_CB* p_cb = &nfa_dm_cb;
113   uint32_t i;
114 
115   for (i = 0; i < NFA_NDEF_MAX_HANDLERS; i++) {
116     /* If this is a free slot, then remember it */
117     if (p_cb->p_ndef_handler[i] != nullptr) {
118       GKI_freebuf(p_cb->p_ndef_handler[i]);
119       p_cb->p_ndef_handler[i] = nullptr;
120     }
121   }
122 }
123 
124 /*******************************************************************************
125 **
126 ** Function         nfa_dm_ndef_reg_hdlr
127 **
128 ** Description      Register NDEF record type handler
129 **
130 ** Returns          TRUE if message buffer is to be freed by caller
131 **
132 *******************************************************************************/
nfa_dm_ndef_reg_hdlr(tNFA_DM_MSG * p_data)133 bool nfa_dm_ndef_reg_hdlr(tNFA_DM_MSG* p_data) {
134   tNFA_DM_CB* p_cb = &nfa_dm_cb;
135   uint32_t hdlr_idx, i;
136   tNFA_DM_API_REG_NDEF_HDLR* p_reg_info = (tNFA_DM_API_REG_NDEF_HDLR*)p_data;
137   tNFA_NDEF_REGISTER ndef_register;
138 
139   /* If registering default handler, check to see if one is already registered
140    */
141   if (p_reg_info->tnf == NFA_TNF_DEFAULT) {
142     /* check if default handler is already registered */
143     if (p_cb->p_ndef_handler[NFA_NDEF_DEFAULT_HANDLER_IDX]) {
144       LOG(WARNING) << StringPrintf("Default NDEF handler being changed.");
145 
146       /* Free old registration info */
147       nfa_dm_ndef_dereg_hdlr_by_handle(
148           (tNFA_HANDLE)NFA_NDEF_DEFAULT_HANDLER_IDX);
149     }
150     DLOG_IF(INFO, nfc_debug_enabled)
151         << StringPrintf("Default NDEF handler successfully registered.");
152     hdlr_idx = NFA_NDEF_DEFAULT_HANDLER_IDX;
153   }
154   /* Get available entry in ndef_handler table, and check if requested type is
155      already registered */
156   else {
157     hdlr_idx = NFA_HANDLE_INVALID;
158 
159     /* Check if this type is already registered */
160     for (i = (NFA_NDEF_DEFAULT_HANDLER_IDX + 1); i < NFA_NDEF_MAX_HANDLERS;
161          i++) {
162       /* If this is a free slot, then remember it */
163       if (p_cb->p_ndef_handler[i] == nullptr) {
164         hdlr_idx = i;
165         break;
166       }
167     }
168   }
169 
170   if (hdlr_idx != NFA_HANDLE_INVALID) {
171     /* Update the table */
172     p_cb->p_ndef_handler[hdlr_idx] = p_reg_info;
173 
174     p_reg_info->ndef_type_handle =
175         (tNFA_HANDLE)(NFA_HANDLE_GROUP_NDEF_HANDLER | hdlr_idx);
176 
177     ndef_register.ndef_type_handle = p_reg_info->ndef_type_handle;
178     ndef_register.status = NFA_STATUS_OK;
179 
180     DLOG_IF(INFO, nfc_debug_enabled)
181         << StringPrintf("NDEF handler successfully registered. Handle=0x%08x",
182                         p_reg_info->ndef_type_handle);
183     tNFA_NDEF_EVT_DATA nfa_ndef_evt_data;
184     nfa_ndef_evt_data.ndef_reg = ndef_register;
185     (*(p_reg_info->p_ndef_cback))(NFA_NDEF_REGISTER_EVT, &nfa_ndef_evt_data);
186 
187     /* indicate that we will free message buffer when type_handler is
188      * deregistered */
189     return false;
190   } else {
191     /* Error */
192     LOG(ERROR) << StringPrintf("NDEF handler failed to register.");
193     ndef_register.ndef_type_handle = NFA_HANDLE_INVALID;
194     ndef_register.status = NFA_STATUS_FAILED;
195     tNFA_NDEF_EVT_DATA nfa_ndef_evt_data;
196     nfa_ndef_evt_data.ndef_reg = ndef_register;
197     (*(p_reg_info->p_ndef_cback))(NFA_NDEF_REGISTER_EVT, &nfa_ndef_evt_data);
198 
199     return true;
200   }
201 }
202 
203 /*******************************************************************************
204 **
205 ** Function         nfa_dm_ndef_dereg_hdlr
206 **
207 ** Description      Deregister NDEF record type handler
208 **
209 ** Returns          TRUE (message buffer to be freed by caller)
210 **
211 *******************************************************************************/
nfa_dm_ndef_dereg_hdlr(tNFA_DM_MSG * p_data)212 bool nfa_dm_ndef_dereg_hdlr(tNFA_DM_MSG* p_data) {
213   tNFA_DM_API_DEREG_NDEF_HDLR* p_dereginfo =
214       (tNFA_DM_API_DEREG_NDEF_HDLR*)p_data;
215 
216   /* Make sure this is a NDEF_HDLR handle */
217   if (((p_dereginfo->ndef_type_handle & NFA_HANDLE_GROUP_MASK) !=
218        NFA_HANDLE_GROUP_NDEF_HANDLER) ||
219       ((p_dereginfo->ndef_type_handle & NFA_HANDLE_MASK) >=
220        NFA_NDEF_MAX_HANDLERS)) {
221     LOG(ERROR) << StringPrintf("Invalid handle for NDEF type handler: 0x%08x",
222                                p_dereginfo->ndef_type_handle);
223   } else {
224     nfa_dm_ndef_dereg_hdlr_by_handle(p_dereginfo->ndef_type_handle);
225   }
226 
227   return true;
228 }
229 
230 /*******************************************************************************
231 **
232 ** Function         nfa_dm_ndef_find_next_handler
233 **
234 ** Description      Find next ndef handler for a given record type
235 **
236 ** Returns          void
237 **
238 *******************************************************************************/
nfa_dm_ndef_find_next_handler(tNFA_DM_API_REG_NDEF_HDLR * p_init_handler,uint8_t tnf,uint8_t * p_type_name,uint8_t type_name_len,uint8_t * p_payload,uint32_t payload_len)239 tNFA_DM_API_REG_NDEF_HDLR* nfa_dm_ndef_find_next_handler(
240     tNFA_DM_API_REG_NDEF_HDLR* p_init_handler, uint8_t tnf,
241     uint8_t* p_type_name, uint8_t type_name_len, uint8_t* p_payload,
242     uint32_t payload_len) {
243   tNFA_DM_CB* p_cb = &nfa_dm_cb;
244   uint8_t i;
245 
246   /* if init_handler is NULL, then start with the first non-default handler */
247   if (!p_init_handler)
248     i = NFA_NDEF_DEFAULT_HANDLER_IDX + 1;
249   else {
250     /* Point to handler index after p_init_handler */
251     i = (p_init_handler->ndef_type_handle & NFA_HANDLE_MASK) + 1;
252   }
253 
254   /* Look for next handler */
255   for (; i < NFA_NDEF_MAX_HANDLERS; i++) {
256     /* Check if TNF matches */
257     if ((p_cb->p_ndef_handler[i]) && (p_cb->p_ndef_handler[i]->tnf == tnf)) {
258       /* TNF matches. */
259       /* If handler is for a specific URI type, check if type is WKT URI, */
260       /* and that the URI prefix abrieviation for this handler matches */
261       if (p_cb->p_ndef_handler[i]->flags & NFA_NDEF_FLAGS_WKT_URI) {
262         /* This is a handler for a specific URI type */
263         /* Check if this recurd is WKT URI */
264         if ((p_payload) && (type_name_len == 1) && (*p_type_name == 'U')) {
265           /* Check if URI prefix abrieviation matches */
266           if ((payload_len > 1) &&
267               (p_payload[0] == p_cb->p_ndef_handler[i]->uri_id)) {
268             /* URI prefix abrieviation matches */
269             /* If handler does not specify an absolute URI, then match found. */
270             /* If absolute URI, then compare URI for match (skip over uri_id in
271              * ndef payload) */
272             if ((p_cb->p_ndef_handler[i]->uri_id != NFA_NDEF_URI_ID_ABSOLUTE) ||
273                 ((payload_len > p_cb->p_ndef_handler[i]->name_len) &&
274                  (memcmp(&p_payload[1], p_cb->p_ndef_handler[i]->name,
275                          p_cb->p_ndef_handler[i]->name_len) == 0))) {
276               /* Handler found. */
277               break;
278             }
279           }
280           /* Check if handler is absolute URI but NDEF is using prefix
281              abrieviation */
282           else if ((p_cb->p_ndef_handler[i]->uri_id ==
283                     NFA_NDEF_URI_ID_ABSOLUTE) &&
284                    (p_payload[0] != NFA_NDEF_URI_ID_ABSOLUTE)) {
285             /* Handler is absolute URI but NDEF is using prefix abrieviation.
286              * Compare URI prefix */
287             if ((p_payload[0] < NFA_DM_NDEF_WKT_URI_STR_TBL_SIZE) &&
288                 strlen(
289                     (const char*)nfa_dm_ndef_wkt_uri_str_tbl[p_payload[0]]) >=
290                     p_cb->p_ndef_handler[i]->name_len &&
291                 (memcmp(p_cb->p_ndef_handler[i]->name,
292                         (char*)nfa_dm_ndef_wkt_uri_str_tbl[p_payload[0]],
293                         p_cb->p_ndef_handler[i]->name_len) == 0)) {
294               /* Handler found. */
295               break;
296             }
297           }
298           /* Check if handler is using prefix abrieviation, but NDEF is using
299              absolute URI */
300           else if ((p_cb->p_ndef_handler[i]->uri_id !=
301                     NFA_NDEF_URI_ID_ABSOLUTE) &&
302                    (p_payload[0] == NFA_NDEF_URI_ID_ABSOLUTE)) {
303             /* Handler is using prefix abrieviation, but NDEF is using absolute
304              * URI. Compare URI prefix */
305             if ((p_cb->p_ndef_handler[i]->uri_id <
306                  NFA_DM_NDEF_WKT_URI_STR_TBL_SIZE) &&
307                 payload_len > strlen((const char*)nfa_dm_ndef_wkt_uri_str_tbl
308                                          [p_cb->p_ndef_handler[i]->uri_id]) &&
309                 (memcmp(&p_payload[1],
310                         nfa_dm_ndef_wkt_uri_str_tbl[p_cb->p_ndef_handler[i]
311                                                         ->uri_id],
312                         strlen((const char*)nfa_dm_ndef_wkt_uri_str_tbl
313                                    [p_cb->p_ndef_handler[i]->uri_id])) == 0)) {
314               /* Handler found. */
315               break;
316             }
317           }
318         }
319       }
320       /* Not looking for specific URI. Check if type_name for this handler
321          matches the NDEF record's type_name */
322       else if (p_cb->p_ndef_handler[i]->name_len == type_name_len) {
323         if ((type_name_len == 0) || (memcmp(p_cb->p_ndef_handler[i]->name,
324                                             p_type_name, type_name_len) == 0)) {
325           /* Handler found */
326           break;
327         }
328       }
329     }
330   }
331 
332   if (i < NFA_NDEF_MAX_HANDLERS)
333     return (p_cb->p_ndef_handler[i]);
334   else
335     return (nullptr);
336 }
337 
338 /*******************************************************************************
339 **
340 ** Function         nfa_dm_ndef_clear_notified_flag
341 **
342 ** Description      Clear 'whole_message_notified' flag for all the handlers
343 **                  (flag used to indicate that this handler has already
344 **                  handled the entire incoming NDEF message)
345 **
346 ** Returns          void
347 **
348 *******************************************************************************/
nfa_dm_ndef_clear_notified_flag(void)349 void nfa_dm_ndef_clear_notified_flag(void) {
350   tNFA_DM_CB* p_cb = &nfa_dm_cb;
351   uint8_t i;
352 
353   for (i = 0; i < NFA_NDEF_MAX_HANDLERS; i++) {
354     if (p_cb->p_ndef_handler[i]) {
355       p_cb->p_ndef_handler[i]->flags &= ~NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED;
356     }
357   }
358 }
359 
360 /*******************************************************************************
361 **
362 ** Function         nfa_dm_ndef_handle_message
363 **
364 ** Description      Handle incoming ndef message
365 **
366 ** Returns          void
367 **
368 *******************************************************************************/
nfa_dm_ndef_handle_message(tNFA_STATUS status,uint8_t * p_msg_buf,uint32_t len)369 void nfa_dm_ndef_handle_message(tNFA_STATUS status, uint8_t* p_msg_buf,
370                                 uint32_t len) {
371   tNFA_DM_CB* p_cb = &nfa_dm_cb;
372   tNDEF_STATUS ndef_status;
373   uint8_t *p_rec, *p_ndef_start, *p_type, *p_payload, *p_rec_end;
374   uint32_t payload_len;
375   uint8_t tnf, type_len, rec_hdr_flags, id_len;
376   tNFA_DM_API_REG_NDEF_HDLR* p_handler;
377   tNFA_NDEF_DATA ndef_data;
378   uint8_t rec_count = 0;
379   bool record_handled, entire_message_handled;
380 
381   DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
382       "nfa_dm_ndef_handle_message status=%i, len=%i", status, len);
383 
384   if (status != NFA_STATUS_OK) {
385     /* If problem reading NDEF message, then exit (no action required) */
386     return;
387   }
388 
389   /* If in exclusive RF mode is activer, then route NDEF message callback
390    * registered with NFA_StartExclusiveRfControl */
391   if ((p_cb->flags & NFA_DM_FLAGS_EXCL_RF_ACTIVE) &&
392       (p_cb->p_excl_ndef_cback)) {
393     /* No ndef-handler handle, since this callback is not from
394      * RegisterNDefHandler */
395     ndef_data.ndef_type_handle = 0;
396     ndef_data.p_data = p_msg_buf;
397     ndef_data.len = len;
398     tNFA_NDEF_EVT_DATA nfa_ndef_evt_data;
399     nfa_ndef_evt_data.ndef_data = ndef_data;
400     (*p_cb->p_excl_ndef_cback)(NFA_NDEF_DATA_EVT, &nfa_ndef_evt_data);
401     return;
402   }
403 
404   /* Handle zero length - notify default handler */
405   if (len == 0) {
406     p_handler = p_cb->p_ndef_handler[NFA_NDEF_DEFAULT_HANDLER_IDX];
407     if (p_handler != nullptr) {
408       DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
409           "Notifying default handler of zero-length NDEF message...");
410       ndef_data.ndef_type_handle = p_handler->ndef_type_handle;
411       ndef_data.p_data = nullptr; /* Start of record */
412       ndef_data.len = 0;
413       tNFA_NDEF_EVT_DATA nfa_ndef_evt_data;
414       nfa_ndef_evt_data.ndef_data = ndef_data;
415       (*p_handler->p_ndef_cback)(NFA_NDEF_DATA_EVT, &nfa_ndef_evt_data);
416     }
417     return;
418   }
419 
420   /* Validate the NDEF message */
421   ndef_status = NDEF_MsgValidate(p_msg_buf, len, true);
422   if (ndef_status != NDEF_OK) {
423     LOG(ERROR) << StringPrintf(
424         "Received invalid NDEF message. NDEF status=0x%x", ndef_status);
425     return;
426   }
427 
428   /* NDEF message received from backgound polling. Pass the NDEF message to the
429    * NDEF handlers */
430 
431   /* New NDEF message. Clear 'notified' flag for all the handlers */
432   nfa_dm_ndef_clear_notified_flag();
433 
434   /* Indicate that no handler has handled this entire NDEF message (e.g.
435    * connection-handover handler *) */
436   entire_message_handled = false;
437 
438   /* Get first record in message */
439   p_rec = p_ndef_start = p_msg_buf;
440 
441   /* Check each record in the NDEF message */
442   while (p_rec != nullptr) {
443     /* Get record type */
444     p_type = NDEF_RecGetType(p_rec, &tnf, &type_len);
445 
446     /* Indicate record not handled yet */
447     record_handled = false;
448 
449     /* Get pointer to record payload */
450     p_payload = NDEF_RecGetPayload(p_rec, &payload_len);
451 
452     /* Find first handler for this type */
453     p_handler = nfa_dm_ndef_find_next_handler(nullptr, tnf, p_type, type_len,
454                                               p_payload, payload_len);
455     if (p_handler == nullptr) {
456       /* Not a registered NDEF type. Use default handler */
457       p_handler = p_cb->p_ndef_handler[NFA_NDEF_DEFAULT_HANDLER_IDX];
458       if (p_handler != nullptr) {
459         DLOG_IF(INFO, nfc_debug_enabled)
460             << StringPrintf("No handler found. Using default handler...");
461       }
462     }
463 
464     while (p_handler) {
465       /* If handler is for whole NDEF message, and it has already been notified,
466        * then skip notification */
467       if (p_handler->flags & NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED) {
468         /* Look for next handler */
469         p_handler = nfa_dm_ndef_find_next_handler(
470             p_handler, tnf, p_type, type_len, p_payload, payload_len);
471         continue;
472       }
473 
474       /* Get pointer to record payload */
475       DLOG_IF(INFO, nfc_debug_enabled) << StringPrintf(
476           "Calling ndef type handler (%x)", p_handler->ndef_type_handle);
477 
478       ndef_data.ndef_type_handle = p_handler->ndef_type_handle;
479       ndef_data.p_data = p_rec; /* Start of record */
480 
481       /* Calculate length of NDEF record */
482       if (p_payload != nullptr)
483         ndef_data.len = payload_len + (uint32_t)(p_payload - p_rec);
484       else {
485         /* If no payload, calculate length of ndef record header */
486         p_rec_end = p_rec;
487 
488         /* First byte is the header flags */
489         rec_hdr_flags = *p_rec_end++;
490 
491         /* Next byte is the type field length */
492         type_len = *p_rec_end++;
493 
494         /* Next is the payload length (1 or 4 bytes) */
495         if (rec_hdr_flags & NDEF_SR_MASK) {
496           p_rec_end++;
497         } else {
498           p_rec_end += 4;
499         }
500 
501         /* ID field Length */
502         if (rec_hdr_flags & NDEF_IL_MASK)
503           id_len = *p_rec_end++;
504         else
505           id_len = 0;
506         p_rec_end += id_len;
507 
508         ndef_data.len = (uint32_t)(p_rec_end - p_rec);
509       }
510 
511       /* If handler wants entire ndef message, then pass pointer to start of
512        * message and  */
513       /* set 'notified' flag so handler won't get notified on subsequent records
514        * for this */
515       /* NDEF message. */
516       if (p_handler->flags & NFA_NDEF_FLAGS_HANDLE_WHOLE_MESSAGE) {
517         ndef_data.p_data = p_ndef_start; /* Start of NDEF message */
518         ndef_data.len = len;
519         p_handler->flags |= NFA_NDEF_FLAGS_WHOLE_MESSAGE_NOTIFIED;
520 
521         /* Indicate that at least one handler has received entire NDEF message
522          */
523         entire_message_handled = true;
524       }
525 
526       /* Notify NDEF type handler */
527       tNFA_NDEF_EVT_DATA nfa_ndef_evt_data;
528       nfa_ndef_evt_data.ndef_data = ndef_data;
529       (*p_handler->p_ndef_cback)(NFA_NDEF_DATA_EVT, &nfa_ndef_evt_data);
530 
531       /* Indicate that at lease one handler has received this record */
532       record_handled = true;
533 
534       /* Look for next handler */
535       p_handler = nfa_dm_ndef_find_next_handler(
536           p_handler, tnf, p_type, type_len, p_payload, payload_len);
537     }
538 
539     /* Check if at least one handler was notified of this record (only happens
540      * if no default handler was register) */
541     if ((!record_handled) && (!entire_message_handled)) {
542       /* Unregistered NDEF record type; no default handler */
543       LOG(WARNING) << StringPrintf("Unhandled NDEF record (#%i)", rec_count);
544     }
545 
546     rec_count++;
547     p_rec = NDEF_MsgGetNextRec(p_rec);
548   }
549 }
550