Fixed #if ENABLE_SSL for ssl_check_error
[yaz-moved-to-github.git] / src / wrbuf.c
1 /* This file is part of the YAZ toolkit.
2  * Copyright (C) 1995-2008 Index Data
3  * See the file LICENSE for details.
4  */
5
6 /**
7  * \file wrbuf.c
8  * \brief Implements WRBUF (growing buffer)
9  */
10
11 #if HAVE_CONFIG_H
12 #include <config.h>
13 #endif
14
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18 #include <stdarg.h>
19
20 #include <yaz/wrbuf.h>
21 #include <yaz/snprintf.h>
22 #include <yaz/yaz-iconv.h>
23
24 WRBUF wrbuf_alloc(void)
25 {
26     WRBUF n;
27
28     if (!(n = (WRBUF)xmalloc(sizeof(*n))))
29         abort();
30     n->buf = 0;
31     n->size = 0;
32     n->pos = 0;
33     return n;
34 }
35
36 void wrbuf_destroy(WRBUF b)
37 {
38     xfree(b->buf);
39     xfree(b);
40 }
41
42 void wrbuf_rewind(WRBUF b)
43 {
44     b->pos = 0;
45 }
46
47 int wrbuf_grow(WRBUF b, int minsize)
48 {
49     int togrow;
50
51     if (!b->size)
52         togrow = 1024;
53     else
54         togrow = b->size;
55     if (togrow < minsize)
56         togrow = minsize;
57     if (b->size && !(b->buf =(char *)xrealloc(b->buf, b->size += togrow)))
58         abort();
59     else if (!b->size && !(b->buf = (char *)xmalloc(b->size = togrow)))
60         abort();
61     return 0;
62 }
63
64 int wrbuf_write(WRBUF b, const char *buf, int size)
65 {
66     if (size <= 0)
67         return 0;
68     if (b->pos + size >= b->size)
69         wrbuf_grow(b, size);
70     memcpy(b->buf + b->pos, buf, size);
71     b->pos += size;
72     return 0;
73 }
74
75 int wrbuf_puts(WRBUF b, const char *buf)
76 {
77     wrbuf_write(b, buf, strlen(buf));
78     return 0;
79 }
80
81 int wrbuf_puts_replace_char(WRBUF b, const char *buf, 
82                             const char from, const char to)
83 {
84     while(*buf)
85     {
86         if (*buf == from)
87             wrbuf_putc(b, to);
88         else
89             wrbuf_putc(b, *buf);
90         buf++;
91     }
92     return 0;
93 }
94
95 void wrbuf_chop_right(WRBUF b)
96 {
97     while (b->pos && b->buf[b->pos-1] == ' ')
98     {
99         (b->pos)--;
100     }
101 }
102
103 int wrbuf_xmlputs(WRBUF b, const char *cp)
104 {
105     return wrbuf_xmlputs_n(b, cp, strlen(cp));
106 }
107
108 int wrbuf_xmlputs_n(WRBUF b, const char *cp, int size)
109 {
110     while (--size >= 0)
111     {
112         /* only TAB,CR,LF of ASCII CTRL are allowed in XML 1.0! */
113         if (*cp >= 0 && *cp <= 31)
114             if (*cp != 9 && *cp != 10 && *cp != 13)
115             {
116                 cp++;  /* we silently ignore (delete) these.. */
117                 continue;
118             }
119         switch(*cp)
120         {
121         case '<':
122             wrbuf_puts(b, "&lt;");
123             break;
124         case '>':
125             wrbuf_puts(b, "&gt;");
126             break;
127         case '&':
128             wrbuf_puts(b, "&amp;");
129             break;
130         case '"':
131             wrbuf_puts(b, "&quot;");
132             break;
133         case '\'':
134             wrbuf_puts(b, "&apos;");
135             break;
136         default:
137             wrbuf_putc(b, *cp);
138         }
139         cp++;
140     }
141     return 0;
142 }
143
144 void wrbuf_printf(WRBUF b, const char *fmt, ...)
145 {
146     va_list ap;
147     char buf[4096];
148
149     va_start(ap, fmt);
150     yaz_vsnprintf(buf, sizeof(buf)-1, fmt, ap);
151     wrbuf_puts (b, buf);
152
153     va_end(ap);
154 }
155
156 static int wrbuf_iconv_write_x(WRBUF b, yaz_iconv_t cd, const char *buf,
157                                int size, int cdata)
158 {
159     if (cd)
160     {
161         char outbuf[16];
162         size_t inbytesleft = size;
163         const char *inp = buf;
164         while (inbytesleft)
165         {
166             size_t outbytesleft = sizeof(outbuf);
167             char *outp = outbuf;
168             size_t r = yaz_iconv(cd, (char**) &inp,  &inbytesleft,
169                                  &outp, &outbytesleft);
170             if (r == (size_t) (-1))
171             {
172                 int e = yaz_iconv_error(cd);
173                 if (e != YAZ_ICONV_E2BIG)
174                     break;
175             }
176             if (cdata)
177                 wrbuf_xmlputs_n(b, outbuf, outp - outbuf);
178             else
179                 wrbuf_write(b, outbuf, outp - outbuf);
180         }
181     }
182     else
183     {
184         if (cdata)
185             wrbuf_xmlputs_n(b, buf, size);
186         else
187             wrbuf_write(b, buf, size);
188     }
189     return wrbuf_len(b);
190 }
191
192 int wrbuf_iconv_write(WRBUF b, yaz_iconv_t cd, const char *buf, int size)
193 {
194     return wrbuf_iconv_write_x(b, cd, buf, size, 0);
195 }
196
197 int wrbuf_iconv_puts(WRBUF b, yaz_iconv_t cd, const char *strz)
198 {
199     return wrbuf_iconv_write(b, cd, strz, strlen(strz));
200 }
201
202 int wrbuf_iconv_putchar(WRBUF b, yaz_iconv_t cd, int ch)
203 {
204     char buf[1];
205     buf[0] = ch;
206     return wrbuf_iconv_write(b, cd, buf, 1);
207 }
208
209 int wrbuf_iconv_write_cdata(WRBUF b, yaz_iconv_t cd, const char *buf, int size)
210 {
211     return wrbuf_iconv_write_x(b, cd, buf, size, 1);
212 }
213
214 int wrbuf_iconv_puts_cdata(WRBUF b, yaz_iconv_t cd, const char *strz)
215 {
216     return wrbuf_iconv_write_x(b, cd, strz, strlen(strz), 1);
217 }
218
219 void wrbuf_iconv_reset(WRBUF b, yaz_iconv_t cd)
220 {
221     if (cd)
222     {
223         char outbuf[16];
224         size_t outbytesleft = sizeof(outbuf);
225         char *outp = outbuf;
226         size_t r = yaz_iconv(cd, 0, 0, &outp, &outbytesleft);
227         if (r != (size_t) (-1))
228             wrbuf_write(b, outbuf, outp - outbuf);
229     }
230 }
231
232 const char *wrbuf_cstr(WRBUF b)
233 {
234     wrbuf_putc(b, '\0');   /* add '\0' */
235     (b->pos)--;           /* don't include '\0' in count */
236     return b->buf;
237 }
238
239 void wrbuf_cut_right(WRBUF b, size_t no_to_remove)
240 {
241     if (no_to_remove > b->pos)
242         no_to_remove = b->pos;
243     b->pos = b->pos - no_to_remove;
244 }
245
246 void wrbuf_puts_escaped(WRBUF b, const char *str)
247 {
248     wrbuf_write_escaped(b, str, strlen(str));
249 }
250
251 void wrbuf_write_escaped(WRBUF b, const char *str, size_t len)
252 {
253     size_t i;
254     for (i = 0; i < len; i++)
255         if (str[i] < ' ' || str[i] > 126)
256             wrbuf_printf(b, "\\x%02X", str[i] & 0xff);
257         else
258             wrbuf_putc(b, str[i]);
259 }
260
261 /*
262  * Local variables:
263  * c-basic-offset: 4
264  * indent-tabs-mode: nil
265  * End:
266  * vim: shiftwidth=4 tabstop=8 expandtab
267  */
268