common/ByteArray.cpp

   1 /*
   2  * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (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://www.apache.org/licenses/LICENSE-2.0
   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 /* standard library header */
  18 #include <cstdio>
  19 #include <cstring>
  20 #include <cerrno>
  21 #include <sstream>
  22
  23 /* SLP library header */
  24
  25 /* local header */
  26 #include "Debug.h"
  27 #include "ByteArray.h"
  28
  29 namespace smartcard_service_api
  30 {
  31         ByteArray ByteArray::EMPTY = ByteArray();
  32
  33         ByteArray::ByteArray() : buffer(NULL), length(0)
  34         {
  35         }
  36
  37         ByteArray::ByteArray(const uint8_t *array, size_t size) :
  38                 buffer(NULL), length(0)
  39         {
  40                 assign(array, size);
  41         }
  42
  43         ByteArray::ByteArray(const ByteArray &T) : buffer(NULL), length(0)
  44         {
  45                 assign(T.buffer, T.length);
  46         }
  47
  48         ByteArray::~ByteArray()
  49         {
  50                 clear();
  51         }
  52
  53         bool ByteArray::assign(const uint8_t *array, size_t size)
  54         {
  55                 if (array == NULL || size == 0)
  56                 {
  57                         return false;
  58                 }
  59
  60                 clear();
  61
  62                 buffer = new uint8_t[size];
  63                 if (buffer == NULL)
  64                 {
  65                 /* LCOV_EXCL_START */
  66                         _ERR("alloc failed");
  67                         return false;
  68                 }
  69                 /* LCOV_EXCL_STOP */
  70
  71                 memcpy(buffer, array, size);
  72                 length = size;
  73
  74                 return true;
  75         }
  76
  77         /* LCOV_EXCL_START */
  78         bool ByteArray::_assign(uint8_t *array, size_t size)
  79         {
  80                 if (array == NULL || size == 0)
  81                 {
  82                         return false;
  83                 }
  84
  85                 clear();
  86
  87                 buffer = array;
  88                 length = size;
  89
  90                 return true;
  91         }
  92
  93         size_t ByteArray::size() const
  94         {
  95                 return length;
  96         }
  97
  98         uint8_t *ByteArray::getBuffer()
  99         {
 100                 return getBuffer(0);
 101         }
 102
 103         const uint8_t *ByteArray::getBuffer() const
 104         {
 105                 return getBuffer(0);
 106         }
 107
 108         uint8_t *ByteArray::getBuffer(size_t offset)
 109         {
 110                 if (length == 0)
 111                         return NULL;
 112
 113                 if (offset >= length)
 114                 {
 115                         _ERR("buffer overflow, offset [%zu], length [%zu]", offset, length);
 116                         return NULL;
 117                 }
 118
 119                 return buffer + offset;
 120         }
 121
 122         const uint8_t *ByteArray::getBuffer(size_t offset) const
 123         {
 124                 if (length == 0)
 125                         return NULL;
 126
 127                 if (offset >= length)
 128                 {
 129                         _ERR("buffer overflow, offset [%zu], length [%zu]", offset, length);
 130                         return NULL;
 131                 }
 132
 133                 return buffer + offset;
 134         }
 135
 136         uint8_t ByteArray::at(size_t index) const
 137         {
 138                 if (index >= length)
 139                 {
 140                         _ERR("buffer overflow, index [%zu], length [%zu]", index, length);
 141                         if (length > 0) {
 142                                 return buffer[length - 1];
 143                         } else {
 144                                 return 0;
 145                         }
 146                 }
 147
 148                 return buffer[index];
 149         }
 150
 151         uint8_t ByteArray::reverseAt(size_t index) const
 152         {
 153                 if (index >= length)
 154                 {
 155                         _ERR("buffer underflow, index [%zu], length [%zu]", index, length);
 156                         if (length > 0) {
 157                                 return buffer[0];
 158                         } else {
 159                                 return 0;
 160                         }
 161                 }
 162
 163                 return buffer[length - index - 1];
 164         }
 165
 166         size_t ByteArray::extract(uint8_t *array, size_t size) const
 167         {
 168                 uint32_t min_len = 0;
 169
 170                 if (array == NULL || size == 0)
 171                 {
 172                         _ERR("invalid param");
 173                         return min_len;
 174                 }
 175
 176                 min_len = (size < length) ? size : length;
 177
 178                 memcpy(array, buffer, min_len);
 179
 180                 return min_len;
 181         }
 182
 183         const ByteArray ByteArray::sub(size_t offset, size_t size) const
 184         {
 185                 if (length == 0 || offset >= length || (offset + size) > length)
 186                 {
 187                         _DBG("length is zero");
 188
 189                         return ByteArray();
 190                 }
 191
 192                 return ByteArray(buffer + offset, size);
 193         }
 194
 195         void ByteArray::clear()
 196         {
 197                 if (buffer != NULL)
 198                 {
 199                         delete []buffer;
 200                         buffer = NULL;
 201                 }
 202                 length = 0;
 203         }
 204
 205         /* operator overloading */
 206         ByteArray ByteArray::operator +(const ByteArray &T)
 207         {
 208                 size_t newLen;
 209                 uint8_t *newBuffer;
 210                 ByteArray newArray;
 211
 212                 if (length == 0)
 213                 {
 214                         _DBG("length is zero");
 215
 216                         return T;
 217                 }
 218
 219                 newLen = T.length;
 220
 221                 if (newLen == 0)
 222                         return *this;
 223
 224                 newLen += length;
 225
 226                 newBuffer = new uint8_t[newLen];
 227                 if (newBuffer == NULL)
 228                 {
 229                         /* assert.... */
 230                         _ERR("alloc failed");
 231
 232                         return *this;
 233                 }
 234
 235                 memcpy(newBuffer, buffer, length);
 236                 memcpy(newBuffer + length, T.buffer, T.length);
 237
 238                 newArray._assign(newBuffer, newLen);
 239
 240                 return newArray;
 241         }
 242
 243         ByteArray &ByteArray::operator =(const ByteArray &T)
 244         {
 245                 if (this != &T)
 246                 {
 247                         assign(T.buffer, T.length);
 248                 }
 249
 250                 return *this;
 251         }
 252
 253         ByteArray &ByteArray::operator +=(const ByteArray &T)
 254         {
 255                 *this = *this + T;
 256
 257                 return *this;
 258         }
 259
 260         bool ByteArray::operator ==(const ByteArray &T) const
 261         {
 262                 if (length != T.length)
 263                         return false;
 264
 265                 return (memcmp(buffer, T.buffer, length) == 0);
 266         }
 267
 268         bool ByteArray::operator !=(const ByteArray &T) const
 269         {
 270                 return !(*this == T);
 271         }
 272
 273         bool ByteArray::operator <(const ByteArray &T) const
 274         {
 275                 return (memcmp(buffer, T.buffer, (length < T.length) ? length : T.length) < 0);
 276         }
 277
 278         bool ByteArray::operator >(const ByteArray &T) const
 279         {
 280                 return (memcmp(buffer, T.buffer, (length < T.length) ? length : T.length) > 0);
 281         }
 282
 283         uint8_t ByteArray::operator[](size_t index) const
 284         {
 285                 if (index >= length)
 286                 {
 287                         _ERR("buffer overflow, index [%zu], length [%zu]", index, length);
 288                         if (length > 0) {
 289                                 return buffer[length -1];
 290                         } else {
 291                                 return 0;
 292                         }
 293                 }
 294
 295                 return buffer[index];
 296         }
 297
 298         const string ByteArray::toString() const
 299         {
 300 #ifdef TO_STRING_ALL
 301                 return toString(true);
 302 #else
 303                 return toString(false);
 304 #endif
 305         }
 306
 307         const string ByteArray::toString(bool entire) const
 308         {
 309                 stringstream ss;
 310
 311                 if (length > 0) {
 312                         char temp[20];
 313                         int count;
 314                         int i = 0;
 315                         bool ellipsis = false;
 316
 317                         count = length;
 318                         if (entire == false && count > 20)
 319                         {
 320                                 count = 20;
 321                                 ellipsis = true;
 322                         }
 323
 324                         ss << "{ ";
 325
 326                         for (i = 0; i < count; i++)
 327                         {
 328                                 snprintf(temp, sizeof(temp), "%02X ", buffer[i]);
 329                                 ss << temp;
 330                         }
 331
 332                         if (ellipsis)
 333                         {
 334                                 ss << "... ";
 335                         }
 336
 337                         ss << "}";
 338                 } else {
 339                         ss << "buffer is empty";
 340                 }
 341
 342                 return ss.str();
 343         }
 344
 345         void ByteArray::save(const char *filePath)
 346         {
 347                 FILE *file = NULL;
 348
 349                 if (filePath == NULL || buffer == NULL || length == 0)
 350                         return;
 351
 352                 if ((file = fopen(filePath, "w")) != NULL) {
 353                         fwrite(buffer, 1, length, file);
 354                         fflush(file);
 355                         fclose(file);
 356
 357                         SECURE_LOGD("file has written, file [%s], length[%zu]", filePath, length);
 358                 } else {
 359                         _ERR("file open failed, [%d]", errno);
 360                 }
 361         }
 362
 363         /* LCOV_EXCL_STOP */
 364 } /* namespace smartcard_service_api */