Commit | Line | Data |
---|---|---|
5cea57f3 | 1 | #include "debug.h" |
7ed0958a | 2 | #include "util.h" |
e7f01d1e | 3 | #include <linux/kernel.h> |
07800601 IM |
4 | |
5 | int prefixcmp(const char *str, const char *prefix) | |
6 | { | |
7 | for (; ; str++, prefix++) | |
8 | if (!*prefix) | |
9 | return 0; | |
10 | else if (*str != *prefix) | |
11 | return (unsigned char)*prefix - (unsigned char)*str; | |
12 | } | |
13 | ||
14 | /* | |
15 | * Used as the default ->buf value, so that people can always assume | |
16 | * buf is non NULL and ->buf is NUL terminated even for a freshly | |
17 | * initialized strbuf. | |
18 | */ | |
19 | char strbuf_slopbuf[1]; | |
20 | ||
5cea57f3 | 21 | int strbuf_init(struct strbuf *sb, ssize_t hint) |
07800601 IM |
22 | { |
23 | sb->alloc = sb->len = 0; | |
24 | sb->buf = strbuf_slopbuf; | |
25 | if (hint) | |
5cea57f3 MH |
26 | return strbuf_grow(sb, hint); |
27 | return 0; | |
07800601 IM |
28 | } |
29 | ||
30 | void strbuf_release(struct strbuf *sb) | |
31 | { | |
32 | if (sb->alloc) { | |
74cf249d | 33 | zfree(&sb->buf); |
07800601 IM |
34 | strbuf_init(sb, 0); |
35 | } | |
36 | } | |
37 | ||
38 | char *strbuf_detach(struct strbuf *sb, size_t *sz) | |
39 | { | |
40 | char *res = sb->alloc ? sb->buf : NULL; | |
41 | if (sz) | |
42 | *sz = sb->len; | |
43 | strbuf_init(sb, 0); | |
44 | return res; | |
45 | } | |
46 | ||
5cea57f3 | 47 | int strbuf_grow(struct strbuf *sb, size_t extra) |
07800601 | 48 | { |
5cea57f3 MH |
49 | char *buf; |
50 | size_t nr = sb->len + extra + 1; | |
51 | ||
52 | if (nr < sb->alloc) | |
53 | return 0; | |
54 | ||
55 | if (nr <= sb->len) | |
56 | return -E2BIG; | |
57 | ||
58 | if (alloc_nr(sb->alloc) > nr) | |
59 | nr = alloc_nr(sb->alloc); | |
60 | ||
61 | /* | |
62 | * Note that sb->buf == strbuf_slopbuf if sb->alloc == 0, and it is | |
63 | * a static variable. Thus we have to avoid passing it to realloc. | |
64 | */ | |
65 | buf = realloc(sb->alloc ? sb->buf : NULL, nr * sizeof(*buf)); | |
66 | if (!buf) | |
67 | return -ENOMEM; | |
68 | ||
69 | sb->buf = buf; | |
70 | sb->alloc = nr; | |
71 | return 0; | |
07800601 IM |
72 | } |
73 | ||
5cea57f3 | 74 | int strbuf_addch(struct strbuf *sb, int c) |
0741208a | 75 | { |
5cea57f3 MH |
76 | int ret = strbuf_grow(sb, 1); |
77 | if (ret) | |
78 | return ret; | |
79 | ||
0741208a ACM |
80 | sb->buf[sb->len++] = c; |
81 | sb->buf[sb->len] = '\0'; | |
5cea57f3 | 82 | return 0; |
0741208a ACM |
83 | } |
84 | ||
5cea57f3 | 85 | int strbuf_add(struct strbuf *sb, const void *data, size_t len) |
07800601 | 86 | { |
5cea57f3 MH |
87 | int ret = strbuf_grow(sb, len); |
88 | if (ret) | |
89 | return ret; | |
90 | ||
07800601 | 91 | memcpy(sb->buf + sb->len, data, len); |
5cea57f3 | 92 | return strbuf_setlen(sb, sb->len + len); |
07800601 IM |
93 | } |
94 | ||
5cea57f3 | 95 | static int strbuf_addv(struct strbuf *sb, const char *fmt, va_list ap) |
07800601 | 96 | { |
5cea57f3 | 97 | int len, ret; |
c7118369 | 98 | va_list ap_saved; |
07800601 | 99 | |
5cea57f3 MH |
100 | if (!strbuf_avail(sb)) { |
101 | ret = strbuf_grow(sb, 64); | |
102 | if (ret) | |
103 | return ret; | |
104 | } | |
c7118369 NK |
105 | |
106 | va_copy(ap_saved, ap); | |
f787d951 | 107 | len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap); |
07800601 | 108 | if (len < 0) |
5cea57f3 | 109 | return len; |
07800601 | 110 | if (len > strbuf_avail(sb)) { |
5cea57f3 MH |
111 | ret = strbuf_grow(sb, len); |
112 | if (ret) | |
113 | return ret; | |
c7118369 NK |
114 | len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap_saved); |
115 | va_end(ap_saved); | |
07800601 | 116 | if (len > strbuf_avail(sb)) { |
5cea57f3 MH |
117 | pr_debug("this should not happen, your vsnprintf is broken"); |
118 | return -EINVAL; | |
07800601 IM |
119 | } |
120 | } | |
5cea57f3 | 121 | return strbuf_setlen(sb, sb->len + len); |
07800601 IM |
122 | } |
123 | ||
5cea57f3 | 124 | int strbuf_addf(struct strbuf *sb, const char *fmt, ...) |
c7118369 NK |
125 | { |
126 | va_list ap; | |
5cea57f3 | 127 | int ret; |
c7118369 NK |
128 | |
129 | va_start(ap, fmt); | |
5cea57f3 | 130 | ret = strbuf_addv(sb, fmt, ap); |
c7118369 | 131 | va_end(ap); |
5cea57f3 | 132 | return ret; |
c7118369 NK |
133 | } |
134 | ||
f37a291c | 135 | ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint) |
07800601 IM |
136 | { |
137 | size_t oldlen = sb->len; | |
138 | size_t oldalloc = sb->alloc; | |
5cea57f3 MH |
139 | int ret; |
140 | ||
141 | ret = strbuf_grow(sb, hint ? hint : 8192); | |
142 | if (ret) | |
143 | return ret; | |
07800601 | 144 | |
07800601 IM |
145 | for (;;) { |
146 | ssize_t cnt; | |
147 | ||
148 | cnt = read(fd, sb->buf + sb->len, sb->alloc - sb->len - 1); | |
149 | if (cnt < 0) { | |
150 | if (oldalloc == 0) | |
151 | strbuf_release(sb); | |
152 | else | |
153 | strbuf_setlen(sb, oldlen); | |
5cea57f3 | 154 | return cnt; |
07800601 IM |
155 | } |
156 | if (!cnt) | |
157 | break; | |
158 | sb->len += cnt; | |
5cea57f3 MH |
159 | ret = strbuf_grow(sb, 8192); |
160 | if (ret) | |
161 | return ret; | |
07800601 IM |
162 | } |
163 | ||
164 | sb->buf[sb->len] = '\0'; | |
165 | return sb->len - oldlen; | |
166 | } |