src/net_nfc_client_ndef_message.c

   1 /*
   2   * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
   3   *
   4   * Licensed under the Flora License, Version 1.1 (the "License");
   5   * you may not use this file except in compliance with the License.
   6   * You may obtain a copy of the License at
   7
   8   *     http://floralicense.org/license/
   9   *
  10   * Unless required by applicable law or agreed to in writing, software
  11   * distributed under the License is distributed on an "AS IS" BASIS,
  12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13   * See the License for the specific language governing permissions and
  14   * limitations under the License.
  15   */
  16
  17 #include <linux/limits.h>
  18
  19 #include "net_nfc_debug_internal.h"
  20 #include "net_nfc_util_internal.h"
  21 #include "net_nfc_util_ndef_message.h"
  22 #include "net_nfc_ndef_message.h"
  23 #include "net_nfc_data.h"
  24
  25 #ifndef NET_NFC_EXPORT_API
  26 #define NET_NFC_EXPORT_API __attribute__((visibility("default")))
  27 #endif
  28
  29
  30 #ifndef NET_NFC_MANAGER_DATA_PATH
  31 #define NET_NFC_MANAGER_DATA_PATH               "/opt/usr/share/nfc-manager-daemon"
  32 #endif
  33
  34 #ifndef NET_NFC_MANAGER_DATA_PATH_MESSAGE
  35 #define NET_NFC_MANAGER_DATA_PATH_MESSAGE       "message"
  36 #endif
  37
  38 #ifndef NET_NFC_MANAGER_NDEF_FILE_NAME
  39 #define NET_NFC_MANAGER_NDEF_FILE_NAME          "ndef-message.txt"
  40 #endif
  41
  42
  43 /* public functions */
  44 NET_NFC_EXPORT_API
  45 net_nfc_error_e net_nfc_create_ndef_message(ndef_message_h *ndef_message)
  46 {
  47         return net_nfc_util_create_ndef_message(
  48                 (ndef_message_s **)ndef_message);
  49 }
  50
  51 NET_NFC_EXPORT_API
  52 net_nfc_error_e net_nfc_create_rawdata_from_ndef_message(
  53         ndef_message_h ndef_message, data_h *rawdata)
  54 {
  55         uint32_t count;
  56         net_nfc_error_e result;
  57         data_h data;
  58
  59         if (ndef_message == NULL || rawdata == NULL) {
  60                 return NET_NFC_NULL_PARAMETER;
  61         }
  62
  63         *rawdata = NULL;
  64
  65         result = net_nfc_get_ndef_message_byte_length(ndef_message, &count);
  66         if (result != NET_NFC_OK) {
  67                 return result;
  68         }
  69
  70         result = net_nfc_create_data(&data ,NULL, count);
  71         if (result != NET_NFC_OK) {
  72                 return result;
  73         }
  74
  75         result = net_nfc_util_convert_ndef_message_to_rawdata(
  76                 (ndef_message_s *)ndef_message, (data_s *)data);
  77         if (result == NET_NFC_OK) {
  78                 *rawdata = data;
  79         } else {
  80                 net_nfc_free_data(data);
  81         }
  82
  83         return result;
  84 }
  85
  86 NET_NFC_EXPORT_API
  87 net_nfc_error_e net_nfc_create_ndef_message_from_rawdata(
  88         ndef_message_h *ndef_message, data_h rawdata)
  89 {
  90         net_nfc_error_e result;
  91         ndef_message_h msg;
  92
  93         if (ndef_message == NULL || rawdata == NULL) {
  94                 return NET_NFC_NULL_PARAMETER;
  95         }
  96
  97         *ndef_message = NULL;
  98
  99         result = net_nfc_create_ndef_message(&msg);
 100         if (result != NET_NFC_OK) {
 101                 return result;
 102         }
 103
 104         result = net_nfc_util_convert_rawdata_to_ndef_message(
 105                 (data_s *)rawdata, (ndef_message_s *)msg);
 106         if (result == NET_NFC_OK) {
 107                 *ndef_message = msg;
 108         } else {
 109                 net_nfc_free_ndef_message(msg);
 110         }
 111
 112         return result;
 113 }
 114
 115 NET_NFC_EXPORT_API
 116 net_nfc_error_e net_nfc_get_ndef_message_byte_length(
 117         ndef_message_h ndef_message, uint32_t *length)
 118 {
 119         net_nfc_error_e result;
 120
 121         if (ndef_message == NULL || length == NULL){
 122                 return NET_NFC_NULL_PARAMETER;
 123         }
 124
 125         *length = net_nfc_util_get_ndef_message_length(
 126                 (ndef_message_s *)ndef_message);
 127         if (*length > 0) {
 128                 result = NET_NFC_OK;
 129         } else {
 130                 result = NET_NFC_INVALID_PARAM;
 131         }
 132
 133         return result;
 134 }
 135
 136 NET_NFC_EXPORT_API
 137 net_nfc_error_e net_nfc_append_record_to_ndef_message(
 138         ndef_message_h ndef_message, ndef_record_h record)
 139 {
 140         if (ndef_message == NULL || record == NULL) {
 141                 return NET_NFC_NULL_PARAMETER;
 142         }
 143
 144         return net_nfc_util_append_record((ndef_message_s *)ndef_message,
 145                 (ndef_record_s *)record);
 146 }
 147
 148 NET_NFC_EXPORT_API
 149 net_nfc_error_e net_nfc_free_ndef_message(ndef_message_h ndef_message)
 150 {
 151         if (ndef_message == NULL) {
 152                 return NET_NFC_NULL_PARAMETER;
 153         }
 154
 155         return net_nfc_util_free_ndef_message((ndef_message_s *)ndef_message);
 156 }
 157
 158 NET_NFC_EXPORT_API
 159 net_nfc_error_e net_nfc_get_ndef_message_record_count(
 160         ndef_message_h ndef_message, int *count)
 161 {
 162         ndef_message_s *msg = (ndef_message_s *)ndef_message;
 163
 164         if (ndef_message == NULL || count == NULL) {
 165                 return NET_NFC_NULL_PARAMETER;
 166         }
 167
 168         *count = msg->recordCount;
 169
 170         return NET_NFC_OK;
 171 }
 172
 173 NET_NFC_EXPORT_API void net_nfc_ndef_print_message(ndef_message_h ndef_message)
 174 {
 175         net_nfc_util_print_ndef_message((ndef_message_s *)ndef_message);
 176 }
 177
 178
 179 NET_NFC_EXPORT_API
 180 net_nfc_error_e net_nfc_search_record_by_type(ndef_message_h ndef_message,
 181         net_nfc_record_tnf_e tnf, data_h type, ndef_record_h *record)
 182 {
 183         return net_nfc_util_search_record_by_type(
 184                 (ndef_message_s *)ndef_message, tnf,
 185                 (data_s *)type, (ndef_record_s **)record);
 186 }
 187
 188 NET_NFC_EXPORT_API
 189 net_nfc_error_e net_nfc_append_record_by_index(ndef_message_h ndef_message,
 190         int index, ndef_record_h record)
 191 {
 192         return net_nfc_util_append_record_by_index(
 193                 (ndef_message_s *)ndef_message, index,
 194                 (ndef_record_s *) record);
 195 }
 196
 197 NET_NFC_EXPORT_API
 198 net_nfc_error_e net_nfc_get_record_by_index(ndef_message_h ndef_message,
 199         int index, ndef_record_h *record)
 200 {
 201         return net_nfc_util_get_record_by_index(
 202                 (ndef_message_s *)ndef_message, index,
 203                 (ndef_record_s **)record);
 204 }
 205
 206 NET_NFC_EXPORT_API
 207 net_nfc_error_e net_nfc_remove_record_by_index(ndef_message_h ndef_message,
 208         int index)
 209 {
 210         return net_nfc_util_remove_record_by_index(
 211                 (ndef_message_s*)ndef_message, index);
 212 }
 213
 214 NET_NFC_EXPORT_API
 215 net_nfc_error_e net_nfc_retrieve_current_ndef_message(
 216         ndef_message_h *ndef_message)
 217 {
 218         net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
 219         char file_path[PATH_MAX] = { 0, };
 220         FILE *fp = NULL;
 221
 222         if (ndef_message == NULL)
 223         {
 224                 return NET_NFC_NULL_PARAMETER;
 225         }
 226
 227         snprintf(file_path, sizeof(file_path), "%s/%s/%s",
 228                 NET_NFC_MANAGER_DATA_PATH,
 229                 NET_NFC_MANAGER_DATA_PATH_MESSAGE,
 230                 NET_NFC_MANAGER_NDEF_FILE_NAME);
 231
 232         if ((fp = fopen(file_path, "r")) != NULL)
 233         {
 234                 long int size = 0;
 235
 236                 /* rewind to start of file */
 237                 fseek(fp, 0, SEEK_END);
 238                 size = ftell(fp);
 239                 fseek(fp, 0, SEEK_SET);
 240
 241                 DEBUG_CLIENT_MSG("message length = [%ld]", size);
 242
 243                 if (size > 0)
 244                 {
 245                         data_s data = { NULL, 0 };
 246
 247                         if (net_nfc_util_init_data(&data, size) == true)
 248                         {
 249                                 int current;
 250                                 size_t offset = 0;
 251
 252                                 /* read fully */
 253                                 do {
 254                                         current = fread(data.buffer + offset, 1,
 255                                                 data.length - offset, fp);
 256                                         if (current > 0)
 257                                                 offset += current;
 258                                         else
 259                                                 break;
 260                                 } while (offset < data.length);
 261
 262                                 if (offset == data.length) {
 263                                         result = net_nfc_create_ndef_message_from_rawdata(ndef_message, &data);
 264                                 } else {
 265                                         DEBUG_ERR_MSG("failed to read ndef message");
 266                                 }
 267
 268                                 net_nfc_util_clear_data(&data);
 269                         }
 270                         else
 271                         {
 272                                 result = NET_NFC_ALLOC_FAIL;
 273                         }
 274                 }
 275                 else
 276                 {
 277                         result = NET_NFC_NO_NDEF_MESSAGE;
 278                 }
 279
 280                 fclose(fp);
 281         }
 282         else
 283         {
 284                 result = NET_NFC_NO_NDEF_MESSAGE;
 285         }
 286
 287         return result;
 288 }