source3/lib/cbuf.c

   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 "includes.h"
  31 #include "cbuf.h"
  32
  33
  34 struct cbuf {
  35         char*  buf;
  36         size_t pos;
  37         size_t size;
  38 };
  39
  40
  41 cbuf* cbuf_clear(cbuf* b)
  42 {
  43         cbuf_setpos(b, 0);
  44         return b;
  45 }
  46
  47 cbuf* cbuf_new(const void* ctx)
  48 {
  49         cbuf* s = talloc(ctx, cbuf);
  50         if (s == NULL)
  51                 return NULL;
  52         s->size = 32;
  53         s->buf  = (char *)talloc_size(s, s->size);
  54         if (s->size && (s->buf == NULL)) {
  55                 talloc_free(s);
  56                 return NULL;
  57         }
  58         return cbuf_clear(s);
  59 }
  60
  61 cbuf* cbuf_copy(const cbuf* b)
  62 {
  63         cbuf* s = talloc(talloc_parent(b), cbuf);
  64         if (s == NULL) {
  65                 return NULL;
  66         }
  67
  68         s->buf = (char *)talloc_memdup(s, b->buf, b->size); /* only up to pos? */
  69
  70         /* XXX shallow did not work, because realloc */
  71         /* fails with multiple references */
  72         /* s->buf = talloc_reference(s, b->buf); */
  73
  74         if (s->buf == NULL) {
  75                 cbuf_delete(s);
  76                 return NULL;
  77         }
  78         s->size = b->size;
  79         s->pos  = b->pos;
  80         return s;
  81 }
  82
  83 void cbuf_delete(cbuf* b)
  84 {
  85         talloc_free(b);
  86 }
  87
  88 #define SWAP(A,B,T) do {                        \
  89                 T tmp = A; A = B; B = tmp;      \
  90         } while(0)
  91
  92
  93 void cbuf_swap(cbuf* b1, cbuf* b2)
  94 {
  95         if (b1 == b2) {
  96                 return;
  97         }
  98         talloc_reparent(b1, b2, b1->buf);
  99         talloc_reparent(b2, b1, b2->buf);
 100         SWAP(b1->buf,  b2->buf, char*);
 101         SWAP(b1->pos,  b2->pos, size_t);
 102         SWAP(b1->size, b2->size, size_t);
 103 }
 104
 105
 106
 107 cbuf* cbuf_takeover(cbuf* b1, cbuf* b2)
 108 {
 109         talloc_reparent(b2, b1, b2->buf);
 110         b1->buf = b2->buf;
 111         b1->pos = b2->pos;
 112         b1->size = b2->size;
 113         cbuf_delete(b2);
 114         return b1;
 115 }
 116
 117 cbuf* cbuf_swapptr(cbuf* b, char** ptr, size_t len)
 118 {
 119         SWAP(b->buf, *ptr, char*);
 120         talloc_steal(b, b->buf);
 121         b->size = talloc_get_size(b->buf);
 122         b->pos  = (len == -1) ? strlen(b->buf) : len;
 123
 124         assert(b->pos <= b->size);
 125         return b;
 126 }
 127
 128 cbuf* cbuf_resize(cbuf* b, size_t size)
 129 {
 130         char* save_buf = b->buf;
 131         b->buf = talloc_realloc(b, b->buf, char, size);
 132         if (b->buf == NULL) {
 133                 talloc_free(save_buf);
 134                 b->size = 0;
 135         } else {
 136                 b->size = size;
 137         }
 138         b->pos  = MIN(b->pos, b->size);
 139         return b->buf ? b : NULL;
 140 }
 141
 142 char* cbuf_reserve(cbuf* b, size_t len)
 143 {
 144         if(b->size < b->pos + len)
 145                 cbuf_resize(b, MAX(2*b->size, b->pos + len));
 146         return b->buf ? b->buf + b->pos : NULL;
 147 }
 148
 149 int cbuf_puts(cbuf* b, const char* str, size_t len)
 150 {
 151         char* dst;
 152
 153         if (b == NULL)
 154                 return 0;
 155
 156         if (len == -1) {
 157                 len=strlen(str);
 158         }
 159
 160         dst = cbuf_reserve(b, len+1);
 161         if (dst == NULL)
 162                 return -1;
 163
 164         memcpy(dst, str, len);
 165         dst[len] = '\0'; /* just to ease debugging */
 166
 167         b->pos += len;
 168         assert(b->pos < b->size);
 169
 170         return len;
 171 }
 172
 173 int cbuf_putc(cbuf* b, char c) {
 174         char* dst;
 175
 176         if (b == NULL)
 177                 return 0;
 178
 179         dst = cbuf_reserve(b, 2);
 180         if (dst == NULL) {
 181                 return -1;
 182         }
 183
 184         dst[0] = c;
 185         dst[1] = '\0'; /* just to ease debugging */
 186
 187         b->pos++;
 188         assert(b->pos < b->size);
 189
 190         return 1;
 191 }
 192
 193 int cbuf_putdw(cbuf* b, uint32_t u) {
 194         char* dst;
 195         static const size_t LEN = sizeof(uint32_t);
 196
 197         if (b == NULL)
 198                 return 0;
 199
 200         dst = cbuf_reserve(b, LEN);
 201         if (dst == NULL) {
 202                 return -1;
 203         }
 204
 205         SIVAL(dst, 0, u);
 206
 207         b->pos += LEN;
 208         assert(b->pos <= b->size); /* no NULL termination*/
 209
 210         return LEN;
 211 }
 212
 213 size_t cbuf_getpos(const cbuf* b) {
 214         assert(b->pos <= b->size);
 215         return b->pos;
 216 }
 217
 218 void cbuf_setpos(cbuf* b, size_t pos) {
 219         assert(pos <= b->size);
 220         b->pos = pos;
 221         if (pos < b->size)
 222                 b->buf[pos] = '\0'; /* just to ease debugging */
 223 }
 224
 225 char* cbuf_gets(cbuf* b, size_t idx) {
 226         assert(idx <= b->pos);
 227
 228         if (cbuf_reserve(b, 1) == NULL)
 229                 return NULL;
 230
 231         b->buf[b->pos] = '\0';
 232         return b->buf + idx;
 233 }
 234
 235 int cbuf_printf(cbuf* b, const char* fmt, ...)
 236 {
 237         va_list args, args2;
 238         int len;
 239         char* dst = b->buf + b->pos;
 240         const int avail = b->size - b->pos;
 241         assert(avail >= 0);
 242
 243         va_start(args, fmt);
 244         va_copy(args2, args);
 245
 246         len = vsnprintf(dst, avail, fmt, args);
 247
 248         if (len >= avail) {
 249                 dst = cbuf_reserve(b, len+1);
 250                 len = (dst != NULL) ? vsnprintf(dst, len+1, fmt, args2) : -1;
 251         }
 252
 253         if (len > 0) {
 254                 b->pos += len;
 255         }
 256
 257         va_end(args);
 258         va_end(args2);
 259         assert(b->pos <= b->size);
 260
 261         return len;
 262 }
 263
 264 int cbuf_print_quoted_string(cbuf* ost, const char* s)
 265 {
 266         int n = 1;
 267         cbuf_putc(ost,'"');
 268
 269         while(true) {
 270                 switch (*s) {
 271                 case '\0':
 272                         cbuf_putc(ost, '"');
 273                         return n+1;
 274
 275                 case '"':
 276                 case '\\':
 277                         cbuf_putc(ost, '\\');
 278                         n++;
 279                         /* no break */
 280                 default:
 281                         cbuf_putc(ost, *s);
 282                         n++;
 283                 }
 284                 s++;
 285         }
 286 }