023e2fe1b9107a655a0389fa4b5d828b2f885643
[dragonfly.git] / sys / kern / subr_sbuf.c
1 /*-
2  * Copyright (c) 2000 Poul-Henning Kamp and Dag-Erling Coïdan Smørgrav
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  *    in this position and unchanged.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  *
28  *      $FreeBSD: src/sys/kern/subr_sbuf.c,v 1.11.2.2 2002/03/12 01:01:07 archie Exp $
29  */
30
31 #include <sys/param.h>
32
33 #ifdef _KERNEL
34 #include <sys/ctype.h>
35 #include <sys/kernel.h>
36 #include <sys/malloc.h>
37 #include <sys/systm.h>
38 #include <sys/uio.h>
39 #include <machine/stdarg.h>
40 #else /* _KERNEL */
41 #include <ctype.h>
42 #include <stdarg.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #endif /* _KERNEL */
47
48 #include <sys/sbuf.h>
49
50 #ifdef _KERNEL
51 MALLOC_DEFINE(M_SBUF, "sbuf", "string buffers");
52 #define SBMALLOC(size)          kmalloc(size, M_SBUF, M_WAITOK)
53 #define SBFREE(buf)             kfree(buf, M_SBUF)
54 #else /* _KERNEL */
55 #define KASSERT(e, m)
56 #define SBMALLOC(size)          malloc(size)
57 #define SBFREE(buf)             free(buf)
58 #define kvsnprintf              vsnprintf
59 #endif /* _KERNEL */
60
61 /*
62  * Predicates
63  */
64 #define SBUF_ISDYNAMIC(s)       ((s)->s_flags & SBUF_DYNAMIC)
65 #define SBUF_ISDYNSTRUCT(s)     ((s)->s_flags & SBUF_DYNSTRUCT)
66 #define SBUF_ISFINISHED(s)      ((s)->s_flags & SBUF_FINISHED)
67 #define SBUF_HASOVERFLOWED(s)   ((s)->s_flags & SBUF_OVERFLOWED)
68 #define SBUF_HASROOM(s)         ((s)->s_len < (s)->s_size - 1)
69 #define SBUF_FREESPACE(s)       ((s)->s_size - (s)->s_len - 1)
70 #define SBUF_CANEXTEND(s)       ((s)->s_flags & SBUF_AUTOEXTEND)
71
72 /*
73  * Set / clear flags
74  */
75 #define SBUF_SETFLAG(s, f)      do { (s)->s_flags |= (f); } while (0)
76 #define SBUF_CLEARFLAG(s, f)    do { (s)->s_flags &= ~(f); } while (0)
77
78 #define SBUF_MINEXTENDSIZE      16              /* Should be power of 2. */
79 #define SBUF_MAXEXTENDSIZE      PAGE_SIZE
80 #define SBUF_MAXEXTENDINCR      PAGE_SIZE
81
82 /*
83  * Debugging support
84  */
85 #if defined(_KERNEL) && defined(INVARIANTS)
86 static void
87 _assert_sbuf_integrity(const char *fun, struct sbuf *s)
88 {
89         KASSERT(s != NULL,
90             ("%s called with a NULL sbuf pointer", fun));
91         KASSERT(s->s_buf != NULL,
92             ("%s called with uninitialized or corrupt sbuf", fun));
93         KASSERT(s->s_len < s->s_size,
94             ("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size));
95 }
96
97 static void
98 _assert_sbuf_state(const char *fun, struct sbuf *s, int state)
99 {
100         KASSERT((s->s_flags & SBUF_FINISHED) == state,
101             ("%s called with %sfinished or corrupt sbuf", fun,
102             (state ? "un" : "")));
103 }
104 #define assert_sbuf_integrity(s) _assert_sbuf_integrity(__func__, (s))
105 #define assert_sbuf_state(s, i)  _assert_sbuf_state(__func__, (s), (i))
106 #else /* _KERNEL && INVARIANTS */
107 #define assert_sbuf_integrity(s) do { } while (0)
108 #define assert_sbuf_state(s, i)  do { } while (0)
109 #endif /* _KERNEL && INVARIANTS */
110
111 static int
112 sbuf_extendsize(int size)
113 {
114         int newsize;
115
116         newsize = SBUF_MINEXTENDSIZE;
117         while (newsize < size) {
118                 if (newsize < SBUF_MAXEXTENDSIZE)
119                         newsize *= 2;
120                 else
121                         newsize += SBUF_MAXEXTENDINCR;
122         }
123
124         return (newsize);
125 }
126
127
128 /*
129  * Extend an sbuf.
130  */
131 static int
132 sbuf_extend(struct sbuf *s, int addlen)
133 {
134         char *newbuf;
135         int newsize;
136
137         if (!SBUF_CANEXTEND(s))
138                 return (-1);
139
140         newsize = sbuf_extendsize(s->s_size + addlen);
141         newbuf = (char *)SBMALLOC(newsize);
142         if (newbuf == NULL)
143                 return (-1);
144         bcopy(s->s_buf, newbuf, s->s_size);
145         if (SBUF_ISDYNAMIC(s))
146                 SBFREE(s->s_buf);
147         else
148                 SBUF_SETFLAG(s, SBUF_DYNAMIC);
149         s->s_buf = newbuf;
150         s->s_size = newsize;
151         return (0);
152 }
153
154 /*
155  * Initialize an sbuf.
156  * If buf is non-NULL, it points to a static or already-allocated string
157  * big enough to hold at least length characters.
158  */
159 struct sbuf *
160 sbuf_new(struct sbuf *s, char *buf, int length, int flags)
161 {
162         KASSERT(length >= 0,
163             ("attempt to create an sbuf of negative length (%d)", length));
164         KASSERT((flags & ~SBUF_USRFLAGMSK) == 0,
165             ("%s called with invalid flags", __func__));
166
167         flags &= SBUF_USRFLAGMSK;
168         if (s == NULL) {
169                 s = (struct sbuf *)SBMALLOC(sizeof *s);
170                 if (s == NULL)
171                         return (NULL);
172                 bzero(s, sizeof *s);
173                 s->s_flags = flags;
174                 SBUF_SETFLAG(s, SBUF_DYNSTRUCT);
175         } else {
176                 bzero(s, sizeof *s);
177                 s->s_flags = flags;
178         }
179         s->s_size = length;
180         if (buf) {
181                 s->s_buf = buf;
182                 return (s);
183         }
184         if (flags & SBUF_AUTOEXTEND)
185                 s->s_size = sbuf_extendsize(s->s_size);
186         s->s_buf = (char *)SBMALLOC(s->s_size);
187         if (s->s_buf == NULL) {
188                 if (SBUF_ISDYNSTRUCT(s))
189                         SBFREE(s);
190                 return (NULL);
191         }
192         SBUF_SETFLAG(s, SBUF_DYNAMIC);
193         return (s);
194 }
195
196 #ifdef _KERNEL
197 /*
198  * Create an sbuf with uio data
199  */
200 struct sbuf *
201 sbuf_uionew(struct sbuf *s, struct uio *uio, int *error)
202 {
203         KASSERT(uio != NULL,
204             ("%s called with NULL uio pointer", __func__));
205         KASSERT(error != NULL,
206             ("%s called with NULL error pointer", __func__));
207
208         s = sbuf_new(s, NULL, uio->uio_resid + 1, 0);
209         if (s == NULL) {
210                 *error = ENOMEM;
211                 return (NULL);
212         }
213         *error = uiomove(s->s_buf, uio->uio_resid, uio);
214         if (*error != 0) {
215                 sbuf_delete(s);
216                 return (NULL);
217         }
218         s->s_len = s->s_size - 1;
219         *error = 0;
220         return (s);
221 }
222 #endif
223
224 /*
225  * Clear an sbuf and reset its position.
226  */
227 void
228 sbuf_clear(struct sbuf *s)
229 {
230         assert_sbuf_integrity(s);
231         /* don't care if it's finished or not */
232
233         SBUF_CLEARFLAG(s, SBUF_FINISHED);
234         SBUF_CLEARFLAG(s, SBUF_OVERFLOWED);
235         s->s_len = 0;
236 }
237
238 /*
239  * Set the sbuf's end position to an arbitrary value.
240  * Effectively truncates the sbuf at the new position.
241  */
242 int
243 sbuf_setpos(struct sbuf *s, int pos)
244 {
245         assert_sbuf_integrity(s);
246         assert_sbuf_state(s, 0);
247         
248         KASSERT(pos >= 0,
249             ("attempt to seek to a negative position (%d)", pos));
250         KASSERT(pos < s->s_size,
251             ("attempt to seek past end of sbuf (%d >= %d)", pos, s->s_size));
252                
253         if (pos < 0 || pos > s->s_len)
254                 return (-1);
255         s->s_len = pos;
256         return (0);
257 }
258
259 /*
260  * Append a byte string to an sbuf.
261  */
262 int
263 sbuf_bcat(struct sbuf *s, const char *str, size_t len)
264 {
265         assert_sbuf_integrity(s);
266         assert_sbuf_state(s, 0);
267         
268         if (SBUF_HASOVERFLOWED(s))
269                 return (-1);
270         
271         for (; len; len--) {
272                 if (!SBUF_HASROOM(s) && sbuf_extend(s, len) < 0)
273                         break;
274                 s->s_buf[s->s_len++] = *str++;
275         }
276         if (len) {
277                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
278                 return (-1);
279         }
280         return (0);
281 }
282
283 #ifdef _KERNEL
284 /*
285  * Copy a byte string from userland into an sbuf.
286  */
287 int
288 sbuf_bcopyin(struct sbuf *s, const void *uaddr, size_t len)
289 {
290         assert_sbuf_integrity(s);
291         assert_sbuf_state(s, 0);
292
293         if (SBUF_HASOVERFLOWED(s))
294                 return (-1);
295
296         if (len == 0)
297                 return (0);
298         if (len > SBUF_FREESPACE(s)) {
299                 sbuf_extend(s, len - SBUF_FREESPACE(s));
300                 len = MIN(len, SBUF_FREESPACE(s));
301         }
302         if (copyin(uaddr, s->s_buf + s->s_len, len) != 0)
303                 return (-1);
304         s->s_len += len;
305         
306         return (0);
307 }
308 #endif
309
310 /*
311  * Copy a byte string into an sbuf.
312  */
313 int
314 sbuf_bcpy(struct sbuf *s, const char *str, size_t len)
315 {
316         assert_sbuf_integrity(s);
317         assert_sbuf_state(s, 0);
318         
319         sbuf_clear(s);
320         return (sbuf_bcat(s, str, len));
321 }
322
323 /*
324  * Append a string to an sbuf.
325  */
326 int
327 sbuf_cat(struct sbuf *s, const char *str)
328 {
329         assert_sbuf_integrity(s);
330         assert_sbuf_state(s, 0);
331         
332         if (SBUF_HASOVERFLOWED(s))
333                 return (-1);
334         
335         while (*str) {
336                 if (!SBUF_HASROOM(s) && sbuf_extend(s, strlen(str)) < 0)
337                         break;
338                 s->s_buf[s->s_len++] = *str++;
339         }
340         if (*str) {
341                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
342                 return (-1);
343         }
344         return (0);
345 }
346
347 #ifdef _KERNEL
348 /*
349  * Append a string from userland to an sbuf.
350  */
351 int
352 sbuf_copyin(struct sbuf *s, const void *uaddr, size_t len)
353 {
354         size_t done;
355         
356         assert_sbuf_integrity(s);
357         assert_sbuf_state(s, 0);
358
359         if (SBUF_HASOVERFLOWED(s))
360                 return (-1);
361
362         if (len == 0)
363                 len = SBUF_FREESPACE(s);        /* XXX return 0? */
364         if (len > SBUF_FREESPACE(s)) {
365                 sbuf_extend(s, len);
366                 len = MIN(len, SBUF_FREESPACE(s));
367         }
368         switch (copyinstr(uaddr, s->s_buf + s->s_len, len + 1, &done)) {
369         case ENAMETOOLONG:
370                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
371                 /* fall through */
372         case 0:
373                 s->s_len += done - 1;
374                 break;
375         default:
376                 return (-1);    /* XXX */
377         }
378         
379         return (0);
380 }
381 #endif
382
383 /*
384  * Copy a string into an sbuf.
385  */
386 int
387 sbuf_cpy(struct sbuf *s, const char *str)
388 {
389         assert_sbuf_integrity(s);
390         assert_sbuf_state(s, 0);
391         
392         sbuf_clear(s);
393         return (sbuf_cat(s, str));
394 }
395
396 /*
397  * Format the given argument list and append the resulting string to an sbuf.
398  */
399 int
400 sbuf_vprintf(struct sbuf *s, const char *fmt, __va_list ap)
401 {
402         int len;
403         __va_list ap_copy;
404         assert_sbuf_integrity(s);
405         assert_sbuf_state(s, 0);
406
407         KASSERT(fmt != NULL,
408             ("%s called with a NULL format string", __func__));
409
410         if (SBUF_HASOVERFLOWED(s))
411                 return (-1);
412
413         do {
414                 __va_copy(ap_copy, ap);
415                 len = kvsnprintf(&s->s_buf[s->s_len], SBUF_FREESPACE(s) + 1,
416                                  fmt, ap_copy);
417                 __va_end(ap_copy);
418         } while (len > SBUF_FREESPACE(s) &&
419             sbuf_extend(s, len - SBUF_FREESPACE(s)) == 0);
420
421         /*
422          * s->s_len is the length of the string, without the terminating nul.
423          * When updating s->s_len, we must subtract 1 from the length that
424          * we passed into kvsnprintf() because that length includes the
425          * terminating nul.
426          *
427          * kvsnprintf() returns the amount that would have been copied,
428          * given sufficient space, hence the min() calculation below.
429          */
430         s->s_len += MIN(len, SBUF_FREESPACE(s));
431         if (!SBUF_HASROOM(s) && !SBUF_CANEXTEND(s))
432                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
433
434         KASSERT(s->s_len < s->s_size,
435             ("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size));
436
437         if (SBUF_HASOVERFLOWED(s))
438                 return (-1);
439         return (0);
440 }
441
442 /*
443  * Format the given arguments and append the resulting string to an sbuf.
444  */
445 int
446 sbuf_printf(struct sbuf *s, const char *fmt, ...)
447 {
448         __va_list ap;
449         int result;
450
451         __va_start(ap, fmt);
452         result = sbuf_vprintf(s, fmt, ap);
453         __va_end(ap);
454         return(result);
455 }
456
457 /*
458  * Append a character to an sbuf.
459  */
460 int
461 sbuf_putc(struct sbuf *s, int c)
462 {
463         assert_sbuf_integrity(s);
464         assert_sbuf_state(s, 0);
465         
466         if (SBUF_HASOVERFLOWED(s))
467                 return (-1);
468         
469         if (!SBUF_HASROOM(s) && sbuf_extend(s, 1) < 0) {
470                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
471                 return (-1);
472         }
473         if (c != '\0')
474             s->s_buf[s->s_len++] = c;
475         return (0);
476 }
477
478 /*
479  * Trim whitespace characters from end of an sbuf.
480  */
481 int
482 sbuf_trim(struct sbuf *s)
483 {
484         assert_sbuf_integrity(s);
485         assert_sbuf_state(s, 0);
486         
487         if (SBUF_HASOVERFLOWED(s))
488                 return (-1);
489         
490         while (s->s_len && isspace(s->s_buf[s->s_len-1]))
491                 --s->s_len;
492
493         return (0);
494 }
495
496 /*
497  * Check if an sbuf overflowed
498  */
499 int
500 sbuf_overflowed(struct sbuf *s)
501 {
502     return SBUF_HASOVERFLOWED(s);
503 }
504
505 /*
506  * Finish off an sbuf.
507  */
508 void
509 sbuf_finish(struct sbuf *s)
510 {
511         assert_sbuf_integrity(s);
512         assert_sbuf_state(s, 0);
513         
514         s->s_buf[s->s_len] = '\0';
515         SBUF_CLEARFLAG(s, SBUF_OVERFLOWED);
516         SBUF_SETFLAG(s, SBUF_FINISHED);
517 }
518
519 /*
520  * Return a pointer to the sbuf data.
521  */
522 char *
523 sbuf_data(struct sbuf *s)
524 {
525         assert_sbuf_integrity(s);
526         assert_sbuf_state(s, SBUF_FINISHED);
527         
528         return s->s_buf;
529 }
530
531 /*
532  * Return the length of the sbuf data.
533  */
534 int
535 sbuf_len(struct sbuf *s)
536 {
537         assert_sbuf_integrity(s);
538         /* don't care if it's finished or not */
539         
540         if (SBUF_HASOVERFLOWED(s))
541                 return (-1);
542         return s->s_len;
543 }
544
545 /*
546  * Clear an sbuf, free its buffer if necessary.
547  */
548 void
549 sbuf_delete(struct sbuf *s)
550 {
551         int isdyn;
552
553         assert_sbuf_integrity(s);
554         /* don't care if it's finished or not */
555         
556         if (SBUF_ISDYNAMIC(s))
557                 SBFREE(s->s_buf);
558         isdyn = SBUF_ISDYNSTRUCT(s);
559         bzero(s, sizeof *s);
560         if (isdyn)
561                 SBFREE(s);
562 }
563
564 /*
565  * Check if an sbuf has been finished.
566  */
567 int
568 sbuf_done(struct sbuf *s)
569 {
570         return(SBUF_ISFINISHED(s));
571 }