libksba  1.6.0
About: KSBA is a library to make the tasks of working with X.509 certificates, CMS data and related objects more easy.
  Fossies Dox: libksba-1.6.0.tar.bz2  ("unofficial" and yet experimental doxygen-generated source code documentation)  

stringbuf.h
Go to the documentation of this file.
1 /* stringbuf.h - Inline functions for building strings.
2  * Copyright (C) 2001, 2002, 2007, 2008, 2012, 2020 g10 Code GmbH
3  *
4  * This file is part of KSBA.
5  *
6  * KSBA is free software; you can redistribute it and/or modify
7  * it under the terms of either
8  *
9  * - the GNU Lesser General Public License as published by the Free
10  * Software Foundation; either version 3 of the License, or (at
11  * your option) any later version.
12  *
13  * or
14  *
15  * - the GNU General Public License as published by the Free
16  * Software Foundation; either version 2 of the License, or (at
17  * your option) any later version.
18  *
19  * or both in parallel, as here.
20  *
21  * KSBA is distributed in the hope that it will be useful, but WITHOUT
22  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
23  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
24  * License for more details.
25  *
26  * You should have received a copies of the GNU General Public License
27  * and the GNU Lesser General Public License along with this program;
28  * if not, see <http://www.gnu.org/licenses/>.
29  */
30 
31 #ifndef STRINGBUF_H
32 #define STRINGBUF_H 1
33 
34 #include "util.h"
35 #include "errno.h"
36 
37 struct stringbuf
38 {
39  size_t len;
40  size_t size;
41  char *buf;
42  gpg_error_t out_of_core;
43 };
44 
45 
46 static inline void
47 init_stringbuf (struct stringbuf *sb, int initiallen)
48 {
49  sb->len = 0;
50  sb->size = initiallen;
51  sb->out_of_core = 0;
52  /* allocate one more, so that get_stringbuf can append a nul */
53  sb->buf = xtrymalloc (initiallen+1);
54  if (!sb->buf)
55  sb->out_of_core = errno? errno : ENOMEM;
56 }
57 
58 
59 static inline void
61 {
62  xfree (sb->buf);
63  sb->buf = NULL;
64  sb->out_of_core = ENOMEM; /* make sure the caller does an init before reuse */
65 }
66 
67 
68 static inline void
69 put_stringbuf_mem (struct stringbuf *sb, const char *text, size_t n)
70 {
71  if (sb->out_of_core)
72  return;
73 
74  if (sb->len + n >= sb->size)
75  {
76  char *p;
77 
78  sb->size += n + 100;
79  p = xtryrealloc (sb->buf, sb->size + 1);
80  if (!p)
81  {
82  sb->out_of_core = errno? errno : ENOMEM;
83  return;
84  }
85  sb->buf = p;
86  }
87  memcpy (sb->buf+sb->len, text, n);
88  sb->len += n;
89 }
90 
91 
92 static inline void
93 put_stringbuf_mem_skip (struct stringbuf *sb, const char *text, size_t n,
94  int skip)
95 {
96  char *p;
97 
98  if (!skip)
99  {
100  put_stringbuf_mem (sb, text, n);
101  return;
102  }
103  if (sb->out_of_core)
104  return;
105 
106  if (sb->len + n >= sb->size)
107  {
108  /* Note: we allocate too much here, but we don't care. */
109  sb->size += n + 100;
110  p = xtryrealloc (sb->buf, sb->size + 1);
111  if ( !p)
112  {
113  sb->out_of_core = errno? errno : ENOMEM;
114  return;
115  }
116  sb->buf = p;
117  }
118  p = sb->buf+sb->len;
119  while (n > skip)
120  {
121  text += skip;
122  n -= skip;
123  *p++ = *text++;
124  n--;
125  sb->len++;
126  }
127 }
128 
129 
130 static inline void
131 put_stringbuf (struct stringbuf *sb, const char *text)
132 {
133  put_stringbuf_mem (sb, text,strlen (text));
134 }
135 
136 
137 static inline void
138 put_stringbuf_mem_sexp (struct stringbuf *sb, const char *text, size_t length)
139 {
140  char buf[20];
141  sprintf (buf,"%u:", (unsigned int)length);
142  put_stringbuf (sb, buf);
143  put_stringbuf_mem (sb, text, length);
144 }
145 
146 
147 static inline void
148 put_stringbuf_sexp (struct stringbuf *sb, const char *text)
149 {
150  put_stringbuf_mem_sexp (sb, text, strlen (text));
151 }
152 
153 
154 static inline void
155 put_stringbuf_uint (struct stringbuf *sb, unsigned int value)
156 {
157  char buf[35];
158  snprintf (buf, sizeof buf, "%u", (unsigned int)value);
159  put_stringbuf_sexp (sb, buf);
160 }
161 
162 
163 static inline char *
165 {
166  char *p;
167 
168  if (sb->out_of_core)
169  {
170  xfree (sb->buf); sb->buf = NULL;
171  gpg_err_set_errno (sb->out_of_core);
172  return NULL;
173  }
174 
175  sb->buf[sb->len] = 0;
176  p = sb->buf;
177  sb->buf = NULL;
178  sb->out_of_core = ENOMEM; /* make sure the caller does an init before reuse */
179  return p;
180 }
181 
182 
183 #endif /*STRINGBUF_H*/
#define xtrymalloc(a)
Definition: gen-help.h:38
static void deinit_stringbuf(struct stringbuf *sb)
Definition: stringbuf.h:60
static void put_stringbuf_mem_sexp(struct stringbuf *sb, const char *text, size_t length)
Definition: stringbuf.h:138
static void init_stringbuf(struct stringbuf *sb, int initiallen)
Definition: stringbuf.h:47
static char * get_stringbuf(struct stringbuf *sb)
Definition: stringbuf.h:164
static void put_stringbuf_uint(struct stringbuf *sb, unsigned int value)
Definition: stringbuf.h:155
static void put_stringbuf_mem_skip(struct stringbuf *sb, const char *text, size_t n, int skip)
Definition: stringbuf.h:93
static void put_stringbuf(struct stringbuf *sb, const char *text)
Definition: stringbuf.h:131
static void put_stringbuf_sexp(struct stringbuf *sb, const char *text)
Definition: stringbuf.h:148
static void put_stringbuf_mem(struct stringbuf *sb, const char *text, size_t n)
Definition: stringbuf.h:69
size_t size
Definition: stringbuf.h:40
gpg_error_t out_of_core
Definition: stringbuf.h:42
size_t len
Definition: stringbuf.h:39
char * buf
Definition: stringbuf.h:41
#define xfree(a)
Definition: util.h:58
#define xtryrealloc(a, b)
Definition: util.h:56