]>
Commit | Line | Data |
---|---|---|
18607dcb FB |
1 | /* |
2 | * Simple C functions to supplement the C library | |
5fafdf24 | 3 | * |
18607dcb FB |
4 | * Copyright (c) 2006 Fabrice Bellard |
5 | * | |
6 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
7 | * of this software and associated documentation files (the "Software"), to deal | |
8 | * in the Software without restriction, including without limitation the rights | |
9 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
10 | * copies of the Software, and to permit persons to whom the Software is | |
11 | * furnished to do so, subject to the following conditions: | |
12 | * | |
13 | * The above copyright notice and this permission notice shall be included in | |
14 | * all copies or substantial portions of the Software. | |
15 | * | |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
22 | * THE SOFTWARE. | |
23 | */ | |
faf07963 | 24 | #include "qemu-common.h" |
8d371d4b | 25 | #include "host-utils.h" |
18607dcb | 26 | |
707c0dbc RP |
27 | /* |
28 | * fill first 'len' characters of 'buff' with pruned | |
29 | * contents of 'str' delimited by the character 'c'. | |
30 | * Escape character '\' is pruned off. | |
31 | * Return pointer to the delimiting character. | |
32 | */ | |
33 | const char *fill_token(char *buf, const int len, const char *str, const char c) | |
34 | { | |
35 | const char *p=str; | |
36 | char *q=buf; | |
37 | ||
38 | while (p < str+len-1) { | |
39 | if (*p == c) | |
40 | break; | |
41 | if (*p == '\\') { | |
42 | p++; | |
43 | if (*p == '\0') | |
44 | break; | |
45 | } | |
46 | *q++ = *p++; | |
47 | } | |
48 | *q='\0'; | |
49 | return p; | |
50 | } | |
51 | ||
52 | ||
18607dcb FB |
53 | void pstrcpy(char *buf, int buf_size, const char *str) |
54 | { | |
55 | int c; | |
56 | char *q = buf; | |
57 | ||
58 | if (buf_size <= 0) | |
59 | return; | |
60 | ||
61 | for(;;) { | |
62 | c = *str++; | |
63 | if (c == 0 || q >= buf + buf_size - 1) | |
64 | break; | |
65 | *q++ = c; | |
66 | } | |
67 | *q = '\0'; | |
68 | } | |
69 | ||
70 | /* strcat and truncate. */ | |
71 | char *pstrcat(char *buf, int buf_size, const char *s) | |
72 | { | |
73 | int len; | |
74 | len = strlen(buf); | |
5fafdf24 | 75 | if (len < buf_size) |
18607dcb FB |
76 | pstrcpy(buf + len, buf_size - len, s); |
77 | return buf; | |
78 | } | |
79 | ||
80 | int strstart(const char *str, const char *val, const char **ptr) | |
81 | { | |
82 | const char *p, *q; | |
83 | p = str; | |
84 | q = val; | |
85 | while (*q != '\0') { | |
86 | if (*p != *q) | |
87 | return 0; | |
88 | p++; | |
89 | q++; | |
90 | } | |
91 | if (ptr) | |
92 | *ptr = p; | |
93 | return 1; | |
94 | } | |
95 | ||
96 | int stristart(const char *str, const char *val, const char **ptr) | |
97 | { | |
98 | const char *p, *q; | |
99 | p = str; | |
100 | q = val; | |
101 | while (*q != '\0') { | |
cd390083 | 102 | if (qemu_toupper(*p) != qemu_toupper(*q)) |
18607dcb FB |
103 | return 0; |
104 | p++; | |
105 | q++; | |
106 | } | |
107 | if (ptr) | |
108 | *ptr = p; | |
109 | return 1; | |
110 | } | |
3c6b2088 | 111 | |
d43277c5 BS |
112 | /* XXX: use host strnlen if available ? */ |
113 | int qemu_strnlen(const char *s, int max_len) | |
114 | { | |
115 | int i; | |
116 | ||
117 | for(i = 0; i < max_len; i++) { | |
118 | if (s[i] == '\0') { | |
119 | break; | |
120 | } | |
121 | } | |
122 | return i; | |
123 | } | |
124 | ||
3c6b2088 FB |
125 | time_t mktimegm(struct tm *tm) |
126 | { | |
127 | time_t t; | |
128 | int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday; | |
129 | if (m < 3) { | |
130 | m += 12; | |
131 | y--; | |
132 | } | |
133 | t = 86400 * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + | |
134 | y / 400 - 719469); | |
135 | t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; | |
136 | return t; | |
137 | } | |
b39ade83 | 138 | |
ad46db9a | 139 | int qemu_fls(int i) |
b39ade83 | 140 | { |
8d371d4b | 141 | return 32 - clz32(i); |
b39ade83 | 142 | } |
44e3ee8a AL |
143 | |
144 | /* io vectors */ | |
145 | ||
146 | void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint) | |
147 | { | |
148 | qiov->iov = qemu_malloc(alloc_hint * sizeof(struct iovec)); | |
149 | qiov->niov = 0; | |
150 | qiov->nalloc = alloc_hint; | |
249aa745 | 151 | qiov->size = 0; |
44e3ee8a AL |
152 | } |
153 | ||
522584a5 AL |
154 | void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov) |
155 | { | |
156 | int i; | |
157 | ||
158 | qiov->iov = iov; | |
159 | qiov->niov = niov; | |
160 | qiov->nalloc = -1; | |
161 | qiov->size = 0; | |
162 | for (i = 0; i < niov; i++) | |
163 | qiov->size += iov[i].iov_len; | |
164 | } | |
165 | ||
44e3ee8a AL |
166 | void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len) |
167 | { | |
522584a5 AL |
168 | assert(qiov->nalloc != -1); |
169 | ||
44e3ee8a AL |
170 | if (qiov->niov == qiov->nalloc) { |
171 | qiov->nalloc = 2 * qiov->nalloc + 1; | |
172 | qiov->iov = qemu_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec)); | |
173 | } | |
174 | qiov->iov[qiov->niov].iov_base = base; | |
175 | qiov->iov[qiov->niov].iov_len = len; | |
249aa745 | 176 | qiov->size += len; |
44e3ee8a AL |
177 | ++qiov->niov; |
178 | } | |
179 | ||
180 | void qemu_iovec_destroy(QEMUIOVector *qiov) | |
181 | { | |
522584a5 AL |
182 | assert(qiov->nalloc != -1); |
183 | ||
44e3ee8a AL |
184 | qemu_free(qiov->iov); |
185 | } | |
186 | ||
be959463 AL |
187 | void qemu_iovec_reset(QEMUIOVector *qiov) |
188 | { | |
522584a5 AL |
189 | assert(qiov->nalloc != -1); |
190 | ||
be959463 AL |
191 | qiov->niov = 0; |
192 | qiov->size = 0; | |
193 | } | |
194 | ||
44e3ee8a AL |
195 | void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf) |
196 | { | |
197 | uint8_t *p = (uint8_t *)buf; | |
198 | int i; | |
199 | ||
200 | for (i = 0; i < qiov->niov; ++i) { | |
201 | memcpy(p, qiov->iov[i].iov_base, qiov->iov[i].iov_len); | |
202 | p += qiov->iov[i].iov_len; | |
203 | } | |
204 | } | |
205 | ||
249aa745 | 206 | void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count) |
44e3ee8a AL |
207 | { |
208 | const uint8_t *p = (const uint8_t *)buf; | |
249aa745 | 209 | size_t copy; |
44e3ee8a AL |
210 | int i; |
211 | ||
249aa745 AL |
212 | for (i = 0; i < qiov->niov && count; ++i) { |
213 | copy = count; | |
214 | if (copy > qiov->iov[i].iov_len) | |
215 | copy = qiov->iov[i].iov_len; | |
216 | memcpy(qiov->iov[i].iov_base, p, copy); | |
217 | p += copy; | |
218 | count -= copy; | |
44e3ee8a AL |
219 | } |
220 | } |