LCOV - code coverage report
Current view: top level - source3/lib - cbuf.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 123 163 75.5 %
Date: 2021-09-23 10:06:22 Functions: 15 18 83.3 %

          Line data    Source code
       1             : /*
       2             :  * Samba Unix/Linux SMB client library
       3             :  *
       4             :  * Copyright (C) Gregor Beck 2010
       5             :  *
       6             :  * This program is free software; you can redistribute it and/or modify
       7             :  * it under the terms of the GNU General Public License as published by
       8             :  * the Free Software Foundation; either version 3 of the License, or
       9             :  * (at your option) any later version.
      10             :  *
      11             :  * This program is distributed in the hope that it will be useful,
      12             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             :  * GNU General Public License for more details.
      15             :  *
      16             :  * You should have received a copy of the GNU General Public License
      17             :  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
      18             :  */
      19             : 
      20             : /**
      21             :  * @file   cbuf.c
      22             :  * @author Gregor Beck <gb@sernet.de>
      23             :  * @date   Aug 2010
      24             :  *
      25             :  * @brief  A talloced character buffer.
      26             :  *
      27             :  */
      28             : 
      29             : 
      30             : #include "replace.h"
      31             : #include "system/locale.h"
      32             : #include "cbuf.h"
      33             : #include <talloc.h>
      34             : #include <assert.h>
      35             : #include "lib/util/byteorder.h"
      36             : 
      37             : 
      38             : struct cbuf {
      39             :         char*  buf;
      40             :         size_t pos;
      41             :         size_t size;
      42             : };
      43             : 
      44             : 
      45        6758 : cbuf* cbuf_clear(cbuf* b)
      46             : {
      47        6758 :         cbuf_setpos(b, 0);
      48        6758 :         return b;
      49             : }
      50             : 
      51        2738 : cbuf* cbuf_new(const void* ctx)
      52             : {
      53        2738 :         cbuf* s = talloc(ctx, cbuf);
      54        2738 :         if (s == NULL)
      55           0 :                 return NULL;
      56        2738 :         s->size = 32;
      57        2738 :         s->buf  = (char *)talloc_size(s, s->size);
      58        2738 :         if (s->size && (s->buf == NULL)) {
      59           0 :                 talloc_free(s);
      60           0 :                 return NULL;
      61             :         }
      62        2738 :         return cbuf_clear(s);
      63             : }
      64             : 
      65           0 : cbuf* cbuf_copy(const cbuf* b)
      66             : {
      67           0 :         cbuf* s = talloc(talloc_parent(b), cbuf);
      68           0 :         if (s == NULL) {
      69           0 :                 return NULL;
      70             :         }
      71             : 
      72           0 :         s->buf = (char *)talloc_memdup(s, b->buf, b->size); /* only up to pos? */
      73             : 
      74             :         /* XXX shallow did not work, because realloc */
      75             :         /* fails with multiple references */
      76             :         /* s->buf = talloc_reference(s, b->buf); */
      77             : 
      78           0 :         if (s->buf == NULL) {
      79           0 :                 cbuf_delete(s);
      80           0 :                 return NULL;
      81             :         }
      82           0 :         s->size = b->size;
      83           0 :         s->pos  = b->pos;
      84           0 :         return s;
      85             : }
      86             : 
      87           0 : void cbuf_delete(cbuf* b)
      88             : {
      89           0 :         talloc_free(b);
      90           0 : }
      91             : 
      92             : #define SWAP(A,B,T) do {                        \
      93             :                 T tmp = A; A = B; B = tmp;      \
      94             :         } while(0)
      95             : 
      96             : 
      97        2158 : void cbuf_swap(cbuf* b1, cbuf* b2)
      98             : {
      99        2158 :         if (b1 == b2) {
     100           0 :                 return;
     101             :         }
     102        2158 :         talloc_reparent(b1, b2, b1->buf);
     103        2158 :         talloc_reparent(b2, b1, b2->buf);
     104        2158 :         SWAP(b1->buf,  b2->buf, char*);
     105        2158 :         SWAP(b1->pos,  b2->pos, size_t);
     106        2158 :         SWAP(b1->size, b2->size, size_t);
     107             : }
     108             : 
     109             : 
     110             : 
     111           0 : cbuf* cbuf_takeover(cbuf* b1, cbuf* b2)
     112             : {
     113           0 :         talloc_reparent(b2, b1, b2->buf);
     114           0 :         b1->buf = b2->buf;
     115           0 :         b1->pos = b2->pos;
     116           0 :         b1->size = b2->size;
     117           0 :         cbuf_delete(b2);
     118           0 :         return b1;
     119             : }
     120             : 
     121         980 : cbuf* cbuf_swapptr(cbuf* b, char** ptr, size_t len)
     122             : {
     123         980 :         void* p = talloc_parent(*ptr);
     124         980 :         SWAP(b->buf, *ptr, char*);
     125         980 :         talloc_steal(b, b->buf);
     126         980 :         talloc_steal(p, *ptr);
     127         980 :         b->size = talloc_get_size(b->buf);
     128         980 :         b->pos  = (len == -1) ? strlen(b->buf) : len;
     129             : 
     130         980 :         assert(b->pos <= b->size);
     131         980 :         return b;
     132             : }
     133             : 
     134        3085 : cbuf* cbuf_resize(cbuf* b, size_t size)
     135             : {
     136        3085 :         char* save_buf = b->buf;
     137        3085 :         b->buf = talloc_realloc(b, b->buf, char, size);
     138        3085 :         if (b->buf == NULL) {
     139           0 :                 talloc_free(save_buf);
     140           0 :                 b->size = 0;
     141             :         } else {
     142        3085 :                 b->size = size;
     143             :         }
     144        3085 :         b->pos  = MIN(b->pos, b->size);
     145        3085 :         return b->buf ? b : NULL;
     146             : }
     147             : 
     148      223408 : char* cbuf_reserve(cbuf* b, size_t len)
     149             : {
     150      223408 :         if(b->size < b->pos + len)
     151        3085 :                 cbuf_resize(b, MAX(2*b->size, b->pos + len));
     152      223408 :         return b->buf ? b->buf + b->pos : NULL;
     153             : }
     154             : 
     155        6216 : int cbuf_puts(cbuf* b, const char* str, size_t len)
     156             : {
     157             :         char* dst;
     158             : 
     159        6216 :         if (b == NULL)
     160           0 :                 return 0;
     161             : 
     162        6216 :         if (len == -1) {
     163        2808 :                 len=strlen(str);
     164             :         }
     165             : 
     166        6216 :         dst = cbuf_reserve(b, len+1);
     167        6216 :         if (dst == NULL)
     168           0 :                 return -1;
     169             : 
     170        6216 :         memcpy(dst, str, len);
     171        6216 :         dst[len] = '\0'; /* just to ease debugging */
     172             : 
     173        6216 :         b->pos += len;
     174        6216 :         assert(b->pos < b->size);
     175             : 
     176        6216 :         return len;
     177             : }
     178             : 
     179      206534 : int cbuf_putc(cbuf* b, char c) {
     180             :         char* dst;
     181             : 
     182      206534 :         if (b == NULL)
     183           0 :                 return 0;
     184             : 
     185      206534 :         dst = cbuf_reserve(b, 2);
     186      206534 :         if (dst == NULL) {
     187           0 :                 return -1;
     188             :         }
     189             : 
     190      206534 :         dst[0] = c;
     191      206534 :         dst[1] = '\0'; /* just to ease debugging */
     192             : 
     193      206534 :         b->pos++;
     194      206534 :         assert(b->pos < b->size);
     195             : 
     196      206534 :         return 1;
     197             : }
     198             : 
     199          10 : int cbuf_putdw(cbuf* b, uint32_t u) {
     200             :         char* dst;
     201             :         static const size_t LEN = sizeof(uint32_t);
     202             : 
     203          10 :         if (b == NULL)
     204           0 :                 return 0;
     205             : 
     206          10 :         dst = cbuf_reserve(b, LEN);
     207          10 :         if (dst == NULL) {
     208           0 :                 return -1;
     209             :         }
     210             : 
     211          10 :         SIVAL(dst, 0, u);
     212             : 
     213          10 :         b->pos += LEN;
     214          10 :         assert(b->pos <= b->size); /* no NULL termination*/
     215             : 
     216          10 :         return LEN;
     217             : }
     218             : 
     219        9661 : size_t cbuf_getpos(const cbuf* b) {
     220        9661 :         assert(b->pos <= b->size);
     221        9661 :         return b->pos;
     222             : }
     223             : 
     224        7031 : void cbuf_setpos(cbuf* b, size_t pos) {
     225        7031 :         assert(pos <= b->size);
     226        7031 :         b->pos = pos;
     227        7031 :         if (pos < b->size)
     228        7031 :                 b->buf[pos] = '\0'; /* just to ease debugging */
     229        7031 : }
     230             : 
     231       10640 : char* cbuf_gets(cbuf* b, size_t idx) {
     232       10640 :         assert(idx <= b->pos);
     233             : 
     234       10640 :         if (cbuf_reserve(b, 1) == NULL)
     235           0 :                 return NULL;
     236             : 
     237       10640 :         b->buf[b->pos] = '\0';
     238       10640 :         return b->buf + idx;
     239             : }
     240             : 
     241          62 : int cbuf_printf(cbuf* b, const char* fmt, ...)
     242             : {
     243             :         va_list args, args2;
     244             :         int len;
     245          62 :         char* dst = b->buf + b->pos;
     246          62 :         const int avail = b->size - b->pos;
     247          62 :         assert(avail >= 0);
     248             : 
     249          62 :         va_start(args, fmt);
     250          62 :         va_copy(args2, args);
     251             : 
     252          62 :         len = vsnprintf(dst, avail, fmt, args);
     253             : 
     254          62 :         if (len >= avail) {
     255           0 :                 dst = cbuf_reserve(b, len+1);
     256           0 :                 len = (dst != NULL) ? vsnprintf(dst, len+1, fmt, args2) : -1;
     257             :         }
     258             : 
     259          62 :         if (len > 0) {
     260          62 :                 b->pos += len;
     261             :         }
     262             : 
     263          62 :         va_end(args);
     264          62 :         va_end(args2);
     265          62 :         assert(b->pos <= b->size);
     266             : 
     267          62 :         return len;
     268             : }
     269             : 
     270        3914 : int cbuf_print_quoted_string(cbuf* ost, const char* s)
     271             : {
     272        3914 :         int n = 1;
     273        3914 :         cbuf_putc(ost,'"');
     274             : 
     275             :         while(true) {
     276      172722 :                 switch (*s) {
     277        3914 :                 case '\0':
     278        3914 :                         cbuf_putc(ost, '"');
     279        7828 :                         return n+1;
     280             : 
     281          56 :                 case '"':
     282             :                 case '\\':
     283          56 :                         cbuf_putc(ost, '\\');
     284          56 :                         n++;
     285             : 
     286             :                         FALL_THROUGH;
     287       84404 :                 default:
     288       84404 :                         cbuf_putc(ost, *s);
     289       84404 :                         n++;
     290             :                 }
     291       84404 :                 s++;
     292             :         }
     293             : }
     294             : 
     295             : 
     296           8 : int cbuf_print_quoted(cbuf* ost, const char* s, size_t len)
     297             : {
     298           8 :         int n = 1;
     299             :         int ret;
     300           8 :         cbuf_reserve(ost, len+2);
     301             : 
     302           8 :         cbuf_putc(ost,'"');
     303             : 
     304         180 :         while(len--) {
     305         164 :                 switch (*s) {
     306           0 :                 case '"':
     307             :                 case '\\':
     308           0 :                         ret = cbuf_printf(ost, "\\%c", *s);
     309           0 :                         break;
     310         164 :                 default:
     311         164 :                         if (isprint(*s) && ((*s == ' ') || !isspace(*s))) {
     312         116 :                                 ret = cbuf_putc(ost, *s);
     313             :                         } else {
     314          48 :                                 ret = cbuf_printf(ost,
     315             :                                                   "\\%02x",
     316          48 :                                                   (unsigned char)*s);
     317             :                         }
     318             :                 }
     319         164 :                 s++;
     320         164 :                 if (ret == -1) {
     321           0 :                         return -1;
     322             :                 }
     323         164 :                 n += ret;
     324             :         }
     325           8 :         ret = cbuf_putc(ost,'"');
     326             : 
     327           8 :         return (ret == -1) ? -1 : (n + ret);
     328             : }

Generated by: LCOV version 1.13