LCOV - code coverage report
Current view: top level - src - simpletlv.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 123 136 90.4 %
Date: 2021-08-16 08:15:35 Functions: 11 11 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 71 94 75.5 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * simpletlv.c: Simple TLV encoding and decoding functions
       3                 :            :  *
       4                 :            :  * Copyright (C) 2016 - 2018 Red Hat, Inc.
       5                 :            :  *
       6                 :            :  * Authors: Robert Relyea <rrelyea@redhat.com>
       7                 :            :  *          Jakub Jelen <jjelen@redhat.com>
       8                 :            :  *
       9                 :            :  * This library is free software; you can redistribute it and/or
      10                 :            :  * modify it under the terms of the GNU Lesser General Public
      11                 :            :  * License as published by the Free Software Foundation; either
      12                 :            :  * version 2.1 of the License, or (at your option) any later version.
      13                 :            :  *
      14                 :            :  * This library is distributed in the hope that it will be useful,
      15                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      16                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      17                 :            :  * Lesser General Public License for more details.
      18                 :            :  *
      19                 :            :  * You should have received a copy of the GNU Lesser General Public
      20                 :            :  * License along with this library; if not, write to the Free Software
      21                 :            :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      22                 :            :  */
      23                 :            : 
      24                 :            : #include "config.h"
      25                 :            : 
      26                 :            : #include <glib.h>
      27                 :            : #include <stdio.h>
      28                 :            : #include <string.h>
      29                 :            : #include <ctype.h>
      30                 :            : #include <stdlib.h>
      31                 :            : 
      32                 :            : #include "simpletlv.h"
      33                 :            : #include "common.h"
      34                 :            : 
      35                 :            : int
      36                 :        703 : simpletlv_get_length(struct simpletlv_member *tlv, size_t tlv_len,
      37                 :            :                      enum simpletlv_buffer_type buffer_type)
      38                 :            : {
      39                 :            :     size_t i, len = 0;
      40                 :            :     int child_length;
      41                 :            : 
      42         [ +  + ]:       4669 :     for (i = 0; i < tlv_len; i++) {
      43                 :            :         /* This TLV is skipped */
      44         [ +  + ]:       3970 :         if (tlv[i].type == SIMPLETLV_TYPE_NONE)
      45                 :        162 :             continue;
      46                 :            : 
      47                 :            :         /* We can not unambiguously split the buffers
      48                 :            :          * for recursive structures
      49                 :            :          */
      50         [ +  + ]:       3808 :         if (tlv[i].type == SIMPLETLV_TYPE_COMPOUND
      51         [ +  + ]:        108 :             && buffer_type != SIMPLETLV_BOTH)
      52                 :            :             return -1;
      53                 :            : 
      54                 :       3804 :         child_length = tlv[i].length;
      55         [ +  + ]:       3804 :         if (tlv[i].type == SIMPLETLV_TYPE_COMPOUND) {
      56                 :        104 :             child_length = simpletlv_get_length(tlv[i].value.child,
      57                 :            :                 tlv[i].length, SIMPLETLV_BOTH);
      58                 :            :         }
      59         [ +  + ]:       3804 :         if (buffer_type & SIMPLETLV_TL) {
      60                 :            :             len += 1/*TAG*/;
      61         [ +  + ]:       3459 :             if (child_length < 255)
      62                 :       3433 :                 len += 1;
      63                 :            :             else
      64                 :         26 :                 len += 3;
      65                 :            :         }
      66         [ +  + ]:       3804 :         if (buffer_type & SIMPLETLV_VALUE) {
      67                 :       3459 :             len += child_length;
      68                 :            :         }
      69                 :            :     }
      70                 :        699 :     return len;
      71                 :            : }
      72                 :            : 
      73                 :            : static int
      74                 :        453 : simpletlv_encode_internal(struct simpletlv_member *tlv, size_t tlv_len,
      75                 :            :                           unsigned char **out, size_t outlen,
      76                 :            :                           unsigned char **newptr, int buffer_type)
      77                 :            : {
      78                 :        453 :     unsigned char *tmp = NULL, *a = NULL, *p = NULL, *newp = NULL;
      79                 :            :     size_t tmp_len = 0, p_len, i;
      80                 :            :     int expect_len = 0, rv;
      81                 :            : 
      82                 :        453 :     expect_len = simpletlv_get_length(tlv, tlv_len, buffer_type);
      83   [ -  +  -  - ]:        453 :     if (expect_len == 0 && newptr != NULL && out != NULL)
      84                 :          0 :         *newptr = *out; /* Corner case for zero-length values */
      85         [ +  + ]:        453 :     if (expect_len <= 0)
      86                 :            :         return expect_len;
      87                 :            : 
      88         [ +  + ]:        451 :     if (outlen == 0 && out != NULL) {
      89                 :            :         /* allocate a new buffer */
      90                 :        312 :         a = g_malloc(expect_len);
      91                 :            :         tmp = a;
      92                 :            :         tmp_len = expect_len;
      93   [ +  +  +  - ]:        139 :     } else if ((int)outlen >= expect_len && out != NULL) {
      94                 :        137 :         tmp = *out;
      95                 :        137 :         tmp_len = outlen;
      96                 :            :     } else {
      97                 :            :         /* we can not fit the data */
      98                 :            :         return -1;
      99                 :            :     }
     100                 :        449 :     p = tmp;
     101                 :            :     p_len = tmp_len;
     102         [ +  + ]:       3320 :     for (i = 0; i < tlv_len; i++) {
     103                 :       2871 :         size_t child_length = tlv[i].length;
     104                 :            : 
     105                 :            :         /* This TLV is skipped */
     106         [ +  + ]:       2871 :         if (tlv[i].type == SIMPLETLV_TYPE_NONE)
     107                 :         81 :             continue;
     108                 :            : 
     109         [ +  + ]:       2790 :         if (tlv[i].type == SIMPLETLV_TYPE_COMPOUND) {
     110                 :        102 :             child_length = simpletlv_get_length(tlv[i].value.child,
     111                 :            :                 tlv[i].length, SIMPLETLV_BOTH);
     112                 :            :         }
     113         [ +  + ]:       2790 :         if (buffer_type & SIMPLETLV_TL) {
     114                 :       2618 :             rv = simpletlv_put_tag(tlv[i].tag, child_length,
     115                 :            :                 p, p_len, &newp);
     116         [ -  + ]:       2618 :             if (rv < 0)
     117                 :          0 :                 goto failure;
     118                 :       2618 :             p = newp;
     119                 :            :         }
     120         [ +  + ]:       2790 :         if (buffer_type & SIMPLETLV_VALUE) {
     121         [ +  + ]:       2618 :             if (tlv[i].type == SIMPLETLV_TYPE_LEAF) {
     122                 :       2516 :                 memcpy(p, tlv[i].value.value, tlv[i].length);
     123                 :       2516 :                 p += tlv[i].length;
     124                 :            :             } else {
     125                 :            :                 /* recurse */
     126                 :        102 :                 rv = simpletlv_encode_internal(tlv[i].value.child,
     127                 :        102 :                     tlv[i].length, &p, p_len, &newp, buffer_type);
     128         [ -  + ]:        102 :                 if (rv < 0)
     129                 :          0 :                     goto failure;
     130                 :        102 :                 p = newp;
     131                 :            :             }
     132                 :            :         }
     133                 :       2790 :         p_len = tmp_len - (p - tmp);
     134                 :            :     }
     135         [ +  + ]:        449 :     if (newptr)
     136                 :        102 :         *newptr = p;
     137                 :            :     if (out)
     138                 :        449 :         *out = tmp;
     139                 :        449 :     return tmp_len - p_len;
     140                 :            : 
     141                 :          0 : failure:
     142                 :          0 :     g_free(a);
     143                 :          0 :     return -1;
     144                 :            : }
     145                 :            : 
     146                 :            : int
     147                 :        313 : simpletlv_encode(struct simpletlv_member *tlv, size_t tlv_len,
     148                 :            :                  unsigned char **out, size_t outlen, unsigned char **newptr)
     149                 :            : {
     150                 :        313 :     return simpletlv_encode_internal(tlv, tlv_len, out, outlen, newptr,
     151                 :            :         SIMPLETLV_BOTH);
     152                 :            : }
     153                 :            : 
     154                 :            : int
     155                 :         19 : simpletlv_encode_tl(struct simpletlv_member *tlv, size_t tlv_len,
     156                 :            :                     unsigned char **out, size_t outlen, unsigned char **newptr)
     157                 :            : {
     158                 :         19 :     return simpletlv_encode_internal(tlv, tlv_len, out, outlen, newptr,
     159                 :            :         SIMPLETLV_TL);
     160                 :            : }
     161                 :            : 
     162                 :            : int
     163                 :         19 : simpletlv_encode_val(struct simpletlv_member *tlv, size_t tlv_len,
     164                 :            :                      unsigned char **out, size_t outlen, unsigned char **newptr)
     165                 :            : {
     166                 :         19 :     return simpletlv_encode_internal(tlv, tlv_len, out, outlen, newptr,
     167                 :            :         SIMPLETLV_VALUE);
     168                 :            : }
     169                 :            : 
     170                 :            : 
     171                 :            : /*
     172                 :            :  * Put a tag/length record to a file in Simple TLV based on the  datalen
     173                 :            :  * content length.
     174                 :            :  */
     175                 :            : int
     176                 :       2618 : simpletlv_put_tag(unsigned char tag, size_t datalen, unsigned char *out,
     177                 :            :                   size_t outlen, unsigned char **ptr)
     178                 :            : {
     179                 :            :     unsigned char *p = out;
     180                 :            : 
     181   [ +  -  +  - ]:       2618 :     if (outlen < 2 || (outlen < 4 && datalen >= 0xff))
     182                 :            :         return -1;
     183                 :            : 
     184                 :            :     /* tag is just number between 0x01 and 0xFE */
     185         [ +  - ]:       2618 :     if (tag == 0x00 || tag == 0xff)
     186                 :            :         return -1;
     187                 :            : 
     188                 :       2618 :     *p++ = tag; /* tag is single byte */
     189         [ +  + ]:       2618 :     if (datalen < 0xff) {
     190                 :            :         /* short value up to 255 */
     191                 :       2605 :         *p++ = (unsigned char)datalen; /* is in the second byte */
     192         [ +  - ]:         13 :     } else if (datalen < 0xffff) {
     193                 :            :         /* longer values up to 65535 */
     194                 :         13 :         *p++ = (unsigned char)0xff; /* first byte is 0xff */
     195                 :         13 :         *p++ = (unsigned char)datalen & 0xff;
     196                 :         13 :         *p++ = (unsigned char)(datalen >> 8) & 0xff; /* LE */
     197                 :            :     } else {
     198                 :            :         /* we can't store more than two bytes in Simple TLV */
     199                 :            :         return -1;
     200                 :            :     }
     201         [ +  - ]:       2618 :     if (ptr != NULL)
     202                 :       2618 :         *ptr = p;
     203                 :            :     return 0;
     204                 :            : }
     205                 :            : 
     206                 :            : /* Read the TL file and return appropriate tag and the length of associated
     207                 :            :  * content.
     208                 :            :  */
     209                 :            : int
     210                 :        766 : simpletlv_read_tag(unsigned char **buf, size_t buflen, unsigned char *tag_out,
     211                 :            :                    size_t *taglen)
     212                 :            : {
     213                 :            :     size_t len;
     214                 :        766 :     unsigned char *p = *buf;
     215                 :            : 
     216         [ +  + ]:        766 :     if (buflen < 2) {
     217                 :          1 :         *buf = p+buflen;
     218                 :          1 :         return -1;
     219                 :            :     }
     220                 :            : 
     221                 :        765 :     *tag_out = *p++;
     222                 :        765 :     len = *p++;
     223         [ +  + ]:        765 :     if (len == 0xff) {
     224                 :            :         /* don't crash on bad data */
     225         [ +  + ]:          2 :         if (buflen < 4) {
     226                 :          1 :             *taglen = 0;
     227                 :          1 :             return -1;
     228                 :            :         }
     229                 :            :         /* skip two bytes (the size) */
     230                 :          1 :         len = lebytes2ushort(p);
     231                 :          1 :         p+=2;
     232                 :            :     }
     233                 :        764 :     *taglen = len;
     234                 :        764 :     *buf = p;
     235                 :        764 :     return 0;
     236                 :            : }
     237                 :            : 
     238                 :            : /*
     239                 :            :  * Merges two structures into one, creating a new shallow copy of both
     240                 :            :  * of the structures.
     241                 :            :  * Resulting length is the sum of  a_len  and  b_len  arguments.
     242                 :            :  */
     243                 :            : struct simpletlv_member *
     244                 :         93 : simpletlv_merge(const struct simpletlv_member *a, size_t a_len,
     245                 :            :                 const struct simpletlv_member *b, size_t b_len)
     246                 :            : {
     247                 :            :     int offset;
     248                 :            :     struct simpletlv_member *r;
     249                 :         93 :     size_t r_len = a_len + b_len;
     250                 :            : 
     251   [ -  +  -  - ]:         93 :     r = g_new(struct simpletlv_member, r_len);
     252                 :            : 
     253                 :            :     /* the ugly way */
     254                 :         93 :     offset = a_len * sizeof(struct simpletlv_member);
     255                 :         93 :     memcpy(r, a, offset);
     256                 :         93 :     memcpy(&r[a_len], b, b_len * sizeof(struct simpletlv_member));
     257                 :         93 :     return r;
     258                 :            : }
     259                 :            : 
     260                 :            : void
     261                 :        246 : simpletlv_free(struct simpletlv_member *tlv, size_t tlvlen)
     262                 :            : {
     263                 :            :     size_t i;
     264         [ +  - ]:        246 :     if (tlv == NULL)
     265                 :            :         return;
     266                 :            : 
     267         [ +  + ]:       2650 :     for (i = 0; i < tlvlen; i++) {
     268         [ +  + ]:       2404 :         if (tlv[i].type == SIMPLETLV_TYPE_COMPOUND) {
     269                 :         52 :             simpletlv_free(tlv[i].value.child, tlv[i].length);
     270                 :            :         } else {
     271                 :       2352 :             g_free(tlv[i].value.value);
     272                 :            :         }
     273                 :            :     }
     274                 :        246 :     g_free(tlv);
     275                 :            : }
     276                 :            : 
     277                 :            : struct simpletlv_member *
     278                 :        178 : simpletlv_clone(struct simpletlv_member *tlv, size_t tlvlen)
     279                 :            : {
     280                 :            :     size_t i = 0, j;
     281                 :            :     struct simpletlv_member *new = NULL;
     282                 :            : 
     283   [ -  +  -  - ]:        178 :     new = g_new(struct simpletlv_member, tlvlen);
     284                 :            : 
     285         [ +  + ]:        744 :     for (i = 0; i < tlvlen; i++) {
     286                 :        566 :         new[i].type = tlv[i].type;
     287                 :        566 :         new[i].tag = tlv[i].tag;
     288                 :        566 :         new[i].length = tlv[i].length;
     289         [ +  + ]:        566 :         if (tlv[i].type == SIMPLETLV_TYPE_COMPOUND) {
     290                 :         66 :             new[i].value.child = simpletlv_clone(
     291                 :            :                 tlv[i].value.child, tlv[i].length);
     292         [ -  + ]:         66 :             if (new[i].value.child == NULL)
     293                 :          0 :                 goto failure;
     294                 :            :         } else {
     295                 :        500 :             new[i].value.value = g_memdup2(tlv[i].value.value, tlv[i].length);
     296                 :            :         }
     297                 :            :     }
     298                 :            :     return new;
     299                 :            : 
     300                 :            : failure:
     301         [ #  # ]:          0 :     for (j = 0; j < i; j++) {
     302         [ #  # ]:          0 :         if (tlv[i].type == SIMPLETLV_TYPE_COMPOUND) {
     303                 :          0 :             simpletlv_free(new[j].value.child, new[j].length);
     304                 :            :         } else {
     305                 :          0 :             g_free(new[j].value.value);
     306                 :            :         }
     307                 :            :     }
     308                 :          0 :     g_free(new);
     309                 :          0 :     return NULL;
     310                 :            : }
     311                 :            : 
     312                 :            : struct simpletlv_member *
     313                 :          5 : simpletlv_parse(unsigned char *data, size_t data_len, size_t *outtlv_len)
     314                 :            : {
     315                 :            :     unsigned char *p, *p_end;
     316                 :            :     unsigned char tag;
     317                 :            :     size_t vlen;
     318                 :          5 :     GArray *tlv = g_array_new(FALSE, FALSE, sizeof(struct simpletlv_member));
     319                 :            : 
     320                 :          5 :     p = data;
     321                 :          5 :     p_end = p + data_len;
     322         [ +  + ]:        521 :     while (p < p_end) {
     323                 :            :         struct simpletlv_member tlvp;
     324                 :            : 
     325                 :            :         /* we can return what was parsed successfully */
     326         [ +  + ]:        519 :         if (simpletlv_read_tag(&p, p_end - p, &tag, &vlen) < 0) {
     327                 :            :             break;
     328                 :            :         }
     329         [ +  + ]:        517 :         if (vlen > (size_t) (p_end - p)) {
     330                 :            :             break;
     331                 :            :         }
     332                 :            : 
     333                 :        516 :         tlvp.tag = tag;
     334                 :        516 :         tlvp.length = vlen;
     335                 :        516 :         tlvp.value.value = g_memdup2(p, vlen);
     336                 :        516 :         tlvp.type = SIMPLETLV_TYPE_LEAF;
     337                 :        516 :         g_array_append_val(tlv, tlvp);
     338                 :            : 
     339                 :        516 :         p += vlen;
     340                 :            :     }
     341                 :            : 
     342                 :          5 :     *outtlv_len = tlv->len;
     343                 :          5 :     return (struct simpletlv_member *)(void *)g_array_free(tlv, FALSE);
     344                 :            : }
     345                 :            : 
     346                 :            : /* vim: set ts=4 sw=4 tw=0 noet expandtab: */

Generated by: LCOV version 1.14