- Check number of free TX descs before trying to xmit packets
[dragonfly.git] / contrib / libarchive-2 / libarchive / archive_string.c
1 /*-
2  * Copyright (c) 2003-2007 Tim Kientzle
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "archive_platform.h"
27 __FBSDID("$FreeBSD: src/lib/libarchive/archive_string.c,v 1.11 2007/07/15 19:13:59 kientzle Exp $");
28
29 /*
30  * Basic resizable string support, to simplify manipulating arbitrary-sized
31  * strings while minimizing heap activity.
32  */
33
34 #ifdef HAVE_STDLIB_H
35 #include <stdlib.h>
36 #endif
37 #ifdef HAVE_STRING_H
38 #include <string.h>
39 #endif
40 #ifdef HAVE_WCHAR_H
41 #include <wchar.h>
42 #endif
43
44 #ifdef __sgi
45 /*
46  * The following prototype is missing on IRXI,
47  * even though the function is implemented in libc.
48  */
49 size_t wcrtomb(char *, wchar_t, mbstate_t *);
50 #endif
51
52 #include "archive_private.h"
53 #include "archive_string.h"
54
55 struct archive_string *
56 __archive_string_append(struct archive_string *as, const char *p, size_t s)
57 {
58         if (__archive_string_ensure(as, as->length + s + 1) == NULL)
59                 __archive_errx(1, "Out of memory");
60         memcpy(as->s + as->length, p, s);
61         as->s[as->length + s] = 0;
62         as->length += s;
63         return (as);
64 }
65
66 void
67 __archive_string_copy(struct archive_string *dest, struct archive_string *src)
68 {
69         if (src->length == 0)
70                 dest->length = 0;
71         else {
72                 if (__archive_string_ensure(dest, src->length + 1) == NULL)
73                         __archive_errx(1, "Out of memory");
74                 memcpy(dest->s, src->s, src->length);
75                 dest->length = src->length;
76                 dest->s[dest->length] = 0;
77         }
78 }
79
80 void
81 __archive_string_free(struct archive_string *as)
82 {
83         as->length = 0;
84         as->buffer_length = 0;
85         if (as->s != NULL) {
86                 free(as->s);
87                 as->s = NULL;
88         }
89 }
90
91 /* Returns NULL on any allocation failure. */
92 struct archive_string *
93 __archive_string_ensure(struct archive_string *as, size_t s)
94 {
95         /* If buffer is already big enough, don't reallocate. */
96         if (as->s && (s <= as->buffer_length))
97                 return (as);
98
99         /*
100          * Growing the buffer at least exponentially ensures that
101          * append operations are always linear in the number of
102          * characters appended.  Using a smaller growth rate for
103          * larger buffers reduces memory waste somewhat at the cost of
104          * a larger constant factor.
105          */
106         if (as->buffer_length < 32)
107                 /* Start with a minimum 32-character buffer. */
108                 as->buffer_length = 32;
109         else if (as->buffer_length < 8192)
110                 /* Buffers under 8k are doubled for speed. */
111                 as->buffer_length *= 2;
112         else {
113                 /* Buffers 8k and over grow by at least 25% each time. */
114                 size_t old_length = as->buffer_length;
115                 as->buffer_length = (as->buffer_length * 5) / 4;
116                 /* Be safe: If size wraps, release buffer and return NULL. */
117                 if (as->buffer_length < old_length) {
118                         free(as->s);
119                         as->s = NULL;
120                         return (NULL);
121                 }
122         }
123         /*
124          * The computation above is a lower limit to how much we'll
125          * grow the buffer.  In any case, we have to grow it enough to
126          * hold the request.
127          */
128         if (as->buffer_length < s)
129                 as->buffer_length = s;
130         /* Now we can reallocate the buffer. */
131         as->s = (char *)realloc(as->s, as->buffer_length);
132         if (as->s == NULL)
133                 return (NULL);
134         return (as);
135 }
136
137 struct archive_string *
138 __archive_strncat(struct archive_string *as, const char *p, size_t n)
139 {
140         size_t s;
141         const char *pp;
142
143         /* Like strlen(p), except won't examine positions beyond p[n]. */
144         s = 0;
145         pp = p;
146         while (*pp && s < n) {
147                 pp++;
148                 s++;
149         }
150         return (__archive_string_append(as, p, s));
151 }
152
153 struct archive_string *
154 __archive_strappend_char(struct archive_string *as, char c)
155 {
156         return (__archive_string_append(as, &c, 1));
157 }
158
159 struct archive_string *
160 __archive_strappend_int(struct archive_string *as, int d, int base)
161 {
162         static const char *digits = "0123456789abcdef";
163
164         if (d < 0) {
165                 __archive_strappend_char(as, '-');
166                 d = -d;
167         }
168         if (d >= base)
169                 __archive_strappend_int(as, d/base, base);
170         __archive_strappend_char(as, digits[d % base]);
171         return (as);
172 }
173
174 /*
175  * Home-grown wcrtomb for UTF-8.
176  */
177 static size_t
178 my_wcrtomb_utf8(char *p, wchar_t wc, mbstate_t *s)
179 {
180         (void)s; /* UNUSED */
181
182         if (p == NULL)
183                 return (0);
184         if (wc <= 0x7f) {
185                 p[0] = (char)wc;
186                 return (1);
187         }
188         if (wc <= 0x7ff) {
189                 p[0] = 0xc0 | ((wc >> 6) & 0x1f);
190                 p[1] = 0x80 | (wc & 0x3f);
191                 return (2);
192         }
193         if (wc <= 0xffff) {
194                 p[0] = 0xe0 | ((wc >> 12) & 0x0f);
195                 p[1] = 0x80 | ((wc >> 6) & 0x3f);
196                 p[2] = 0x80 | (wc & 0x3f);
197                 return (3);
198         }
199         if (wc <= 0x1fffff) {
200                 p[0] = 0xf0 | ((wc >> 18) & 0x07);
201                 p[1] = 0x80 | ((wc >> 12) & 0x3f);
202                 p[2] = 0x80 | ((wc >> 6) & 0x3f);
203                 p[3] = 0x80 | (wc & 0x3f);
204                 return (4);
205         }
206         /* Unicode has no codes larger than 0x1fffff. */
207         /*
208          * Awkward point:  UTF-8 <-> wchar_t conversions
209          * can actually fail.
210          */
211         return ((size_t)-1);
212 }
213
214 static int
215 my_wcstombs(struct archive_string *as, const wchar_t *w,
216     size_t (*func)(char *, wchar_t, mbstate_t *))
217 {
218         size_t n;
219         char *p;
220         mbstate_t shift_state;
221         char buff[256];
222
223         /*
224          * Convert one wide char at a time into 'buff', whenever that
225          * fills, append it to the string.
226          */
227         p = buff;
228         wcrtomb(NULL, L'\0', &shift_state);
229         while (*w != L'\0') {
230                 /* Flush the buffer when we have <=16 bytes free. */
231                 /* (No encoding has a single character >16 bytes.) */
232                 if ((size_t)(p - buff) >= (size_t)(sizeof(buff) - 16)) {
233                         *p = '\0';
234                         archive_strcat(as, buff);
235                         p = buff;
236                 }
237                 n = (*func)(p, *w++, &shift_state);
238                 if (n == (size_t)-1)
239                         return (-1);
240                 p += n;
241         }
242         *p = '\0';
243         archive_strcat(as, buff);
244         return (0);
245 }
246
247 /*
248  * Translates a wide character string into UTF-8 and appends
249  * to the archive_string.  Note: returns NULL if conversion fails.
250  */
251 struct archive_string *
252 __archive_strappend_w_utf8(struct archive_string *as, const wchar_t *w)
253 {
254         if (my_wcstombs(as, w, my_wcrtomb_utf8))
255                 return (NULL);
256         return (as);
257 }
258
259 /*
260  * Translates a wide character string into current locale character set
261  * and appends to the archive_string.  Note: returns NULL if conversion
262  * fails.
263  *
264  * TODO: use my_wcrtomb_utf8 if !HAVE_WCRTOMB (add configure logic first!)
265  */
266 struct archive_string *
267 __archive_strappend_w_mbs(struct archive_string *as, const wchar_t *w)
268 {
269         if (my_wcstombs(as, w, wcrtomb))
270                 return (NULL);
271         return (as);
272 }
273
274
275 /*
276  * Home-grown mbrtowc for UTF-8.  Some systems lack UTF-8
277  * (or even lack mbrtowc()) and we need UTF-8 support for pax
278  * format.  So please don't replace this with a call to the
279  * standard mbrtowc() function!
280  */
281 static size_t
282 my_mbrtowc_utf8(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps)
283 {
284         int ch;
285
286         /*
287          * This argument is here to make the prototype identical to the
288          * standard mbrtowc(), so I can build generic string processors
289          * that just accept a pointer to a suitable mbrtowc() function.
290          */
291         (void)ps; /* UNUSED */
292
293         /* Standard behavior:  a NULL value for 's' just resets shift state. */
294         if (s == NULL)
295                 return (0);
296         /* If length argument is zero, don't look at the first character. */
297         if (n <= 0)
298                 return ((size_t)-2);
299
300         /*
301          * Decode 1-4 bytes depending on the value of the first byte.
302          */
303         ch = (unsigned char)*s;
304         if (ch == 0) {
305                 return (0); /* Standard:  return 0 for end-of-string. */
306         }
307         if ((ch & 0x80) == 0) {
308                 *pwc = ch & 0x7f;
309                 return (1);
310         }
311         if ((ch & 0xe0) == 0xc0) {
312                 if (n < 2)
313                         return ((size_t)-2);
314                 if ((s[1] & 0xc0) != 0x80) return (size_t)-1;
315                 *pwc = ((ch & 0x1f) << 6) | (s[1] & 0x3f);
316                 return (2);
317         }
318         if ((ch & 0xf0) == 0xe0) {
319                 if (n < 3)
320                         return ((size_t)-2);
321                 if ((s[1] & 0xc0) != 0x80) return (size_t)-1;
322                 if ((s[2] & 0xc0) != 0x80) return (size_t)-1;
323                 *pwc = ((ch & 0x0f) << 12)
324                     | ((s[1] & 0x3f) << 6)
325                     | (s[2] & 0x3f);
326                 return (3);
327         }
328         if ((ch & 0xf8) == 0xf0) {
329                 if (n < 4)
330                         return ((size_t)-2);
331                 if ((s[1] & 0xc0) != 0x80) return (size_t)-1;
332                 if ((s[2] & 0xc0) != 0x80) return (size_t)-1;
333                 if ((s[3] & 0xc0) != 0x80) return (size_t)-1;
334                 *pwc = ((ch & 0x07) << 18)
335                     | ((s[1] & 0x3f) << 12)
336                     | ((s[2] & 0x3f) << 6)
337                     | (s[3] & 0x3f);
338                 return (4);
339         }
340         /* Invalid first byte. */
341         return ((size_t)-1);
342 }
343
344 /*
345  * Return a wide-character string by converting this archive_string
346  * from UTF-8.
347  */
348 wchar_t *
349 __archive_string_utf8_w(struct archive_string *as)
350 {
351         wchar_t *ws, *dest;
352         const char *src;
353         size_t n;
354         int err;
355
356         ws = (wchar_t *)malloc((as->length + 1) * sizeof(wchar_t));
357         if (ws == NULL)
358                 __archive_errx(1, "Out of memory");
359         err = 0;
360         dest = ws;
361         src = as->s;
362         while (*src != '\0') {
363                 n = my_mbrtowc_utf8(dest, src, 8, NULL);
364                 if (n == 0)
365                         break;
366                 if (n == (size_t)-1 || n == (size_t)-2) {
367                         free(ws);
368                         return (NULL);
369                 }
370                 dest++;
371                 src += n;
372         }
373         *dest++ = L'\0';
374         return (ws);
375 }