Branch data     Line data    Source code

       1                 :            : /*
       2                 :            :  * Copyright (c) 2022 Eriptic Technologies.
       3                 :            :  *
       4                 :            :  * SPDX-License-Identifier: Apache-2.0 or MIT
       5                 :            :  */
       6                 :            : 
       7                 :            : #include "common/oscore_edhoc_error.h"
       8                 :            : #include "common/byte_array.h"
       9                 :            : 
      10                 :            : #include "cbor/edhoc_encode_int_type.h"
      11                 :            : #include "cbor/edhoc_decode_int_type.h"
      12                 :            : 
      13                 :          6 : bool c_x_is_encoded_int(const struct byte_array *c_i)
      14                 :            : {
      15   [ +  -  +  - ]:          6 :         if (c_i->len == 1 && ((0x00 <= c_i->ptr[0] && c_i->ptr[0] < 0x18) ||
      16   [ +  +  +  - ]:          6 :                               (0x1F < c_i->ptr[0] && c_i->ptr[0] <= 0x37))) {
      17                 :          5 :                 return true;
      18                 :            :         } else {
      19                 :          1 :                 return false;
      20                 :            :         }
      21                 :            : }
      22                 :            : 
      23                 :            : 
      24                 :          6 : bool c_r_is_raw_int(const struct byte_array *c_r)
      25                 :            : {
      26   [ +  -  -  + ]:          6 :         if (c_r->len == 1 && c_r->ptr[0] >= -24 && c_r->ptr[0] <= 23) {
      27                 :          0 :                 return true;
      28                 :            :         } else {
      29                 :          6 :                 return false;
      30                 :            :         }
      31                 :            : }
      32                 :            : 
      33                 :            : 
      34                 :          2 : enum err encode_int(const int32_t *in, uint32_t in_len, struct byte_array *out)
      35                 :            : {
      36                 :            :         size_t payload_len_out;
      37         [ -  + ]:          2 :         TRY_EXPECT(cbor_encode_int_type_i(out->ptr, out->len, in,
      38                 :            :                                           &payload_len_out),
      39                 :            :                    0);
      40                 :          2 :         out->len = (uint32_t)payload_len_out;
      41                 :          2 :         return ok;
      42                 :            : }
      43                 :            : 
      44                 :          3 : enum err decode_int(const struct byte_array *in, int32_t *out)
      45                 :            : {
      46                 :          3 :         size_t decode_len = 0;
      47         [ -  + ]:          3 :         TRY_EXPECT(cbor_decode_int_type_i(in->ptr, in->len, out, &decode_len),
      48                 :            :                    0);
      49         [ -  + ]:          3 :         if (decode_len != 1) {
      50                 :          0 :                 return cbor_decoding_error;
      51                 :            :         }
      52                 :          3 :         return ok;
      53                 :            : }