1/* 2 * Simple C functions to supplement the C library 3 * 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 */ 24#include "qemu-common.h" 25#include "host-utils.h" 26#include <math.h> 27 28void pstrcpy(char *buf, int buf_size, const char *str) 29{ 30 int c; 31 char *q = buf; 32 33 if (buf_size <= 0) 34 return; 35 36 for(;;) { 37 c = *str++; 38 if (c == 0 || q >= buf + buf_size - 1) 39 break; 40 *q++ = c; 41 } 42 *q = '\0'; 43} 44 45/* strcat and truncate. */ 46char *pstrcat(char *buf, int buf_size, const char *s) 47{ 48 int len; 49 len = strlen(buf); 50 if (len < buf_size) 51 pstrcpy(buf + len, buf_size - len, s); 52 return buf; 53} 54 55int strstart(const char *str, const char *val, const char **ptr) 56{ 57 const char *p, *q; 58 p = str; 59 q = val; 60 while (*q != '\0') { 61 if (*p != *q) 62 return 0; 63 p++; 64 q++; 65 } 66 if (ptr) 67 *ptr = p; 68 return 1; 69} 70 71int stristart(const char *str, const char *val, const char **ptr) 72{ 73 const char *p, *q; 74 p = str; 75 q = val; 76 while (*q != '\0') { 77 if (qemu_toupper(*p) != qemu_toupper(*q)) 78 return 0; 79 p++; 80 q++; 81 } 82 if (ptr) 83 *ptr = p; 84 return 1; 85} 86 87/* XXX: use host strnlen if available ? */ 88int qemu_strnlen(const char *s, int max_len) 89{ 90 int i; 91 92 for(i = 0; i < max_len; i++) { 93 if (s[i] == '\0') { 94 break; 95 } 96 } 97 return i; 98} 99 100time_t mktimegm(struct tm *tm) 101{ 102 time_t t; 103 int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday; 104 if (m < 3) { 105 m += 12; 106 y--; 107 } 108 t = 86400 * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + 109 y / 400 - 719469); 110 t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec; 111 return t; 112} 113 114int qemu_fls(int i) 115{ 116 return 32 - clz32(i); 117} 118 119/* 120 * Make sure data goes on disk, but if possible do not bother to 121 * write out the inode just for timestamp updates. 122 * 123 * Unfortunately even in 2009 many operating systems do not support 124 * fdatasync and have to fall back to fsync. 125 */ 126int qemu_fdatasync(int fd) 127{ 128#ifdef CONFIG_FDATASYNC 129 return fdatasync(fd); 130#else 131 return fsync(fd); 132#endif 133} 134 135/* io vectors */ 136 137void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint) 138{ 139 qiov->iov = qemu_malloc(alloc_hint * sizeof(struct iovec)); 140 qiov->niov = 0; 141 qiov->nalloc = alloc_hint; 142 qiov->size = 0; 143} 144 145void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov) 146{ 147 int i; 148 149 qiov->iov = iov; 150 qiov->niov = niov; 151 qiov->nalloc = -1; 152 qiov->size = 0; 153 for (i = 0; i < niov; i++) 154 qiov->size += iov[i].iov_len; 155} 156 157void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len) 158{ 159 assert(qiov->nalloc != -1); 160 161 if (qiov->niov == qiov->nalloc) { 162 qiov->nalloc = 2 * qiov->nalloc + 1; 163 qiov->iov = qemu_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec)); 164 } 165 qiov->iov[qiov->niov].iov_base = base; 166 qiov->iov[qiov->niov].iov_len = len; 167 qiov->size += len; 168 ++qiov->niov; 169} 170 171/* 172 * Copies iovecs from src to the end of dst. It starts copying after skipping 173 * the given number of bytes in src and copies until src is completely copied 174 * or the total size of the copied iovec reaches size.The size of the last 175 * copied iovec is changed in order to fit the specified total size if it isn't 176 * a perfect fit already. 177 */ 178void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip, 179 size_t size) 180{ 181 int i; 182 size_t done; 183 void *iov_base; 184 uint64_t iov_len; 185 186 assert(dst->nalloc != -1); 187 188 done = 0; 189 for (i = 0; (i < src->niov) && (done != size); i++) { 190 if (skip >= src->iov[i].iov_len) { 191 /* Skip the whole iov */ 192 skip -= src->iov[i].iov_len; 193 continue; 194 } else { 195 /* Skip only part (or nothing) of the iov */ 196 iov_base = (uint8_t*) src->iov[i].iov_base + skip; 197 iov_len = src->iov[i].iov_len - skip; 198 skip = 0; 199 } 200 201 if (done + iov_len > size) { 202 qemu_iovec_add(dst, iov_base, size - done); 203 break; 204 } else { 205 qemu_iovec_add(dst, iov_base, iov_len); 206 } 207 done += iov_len; 208 } 209} 210 211void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size) 212{ 213 qemu_iovec_copy(dst, src, 0, size); 214} 215 216void qemu_iovec_destroy(QEMUIOVector *qiov) 217{ 218 assert(qiov->nalloc != -1); 219 220 qemu_free(qiov->iov); 221} 222 223void qemu_iovec_reset(QEMUIOVector *qiov) 224{ 225 assert(qiov->nalloc != -1); 226 227 qiov->niov = 0; 228 qiov->size = 0; 229} 230 231void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf) 232{ 233 uint8_t *p = (uint8_t *)buf; 234 int i; 235 236 for (i = 0; i < qiov->niov; ++i) { 237 memcpy(p, qiov->iov[i].iov_base, qiov->iov[i].iov_len); 238 p += qiov->iov[i].iov_len; 239 } 240} 241 242void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count) 243{ 244 const uint8_t *p = (const uint8_t *)buf; 245 size_t copy; 246 int i; 247 248 for (i = 0; i < qiov->niov && count; ++i) { 249 copy = count; 250 if (copy > qiov->iov[i].iov_len) 251 copy = qiov->iov[i].iov_len; 252 memcpy(qiov->iov[i].iov_base, p, copy); 253 p += copy; 254 count -= copy; 255 } 256} 257 258void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count) 259{ 260 size_t n; 261 int i; 262 263 for (i = 0; i < qiov->niov && count; ++i) { 264 n = MIN(count, qiov->iov[i].iov_len); 265 memset(qiov->iov[i].iov_base, c, n); 266 count -= n; 267 } 268} 269 270void qemu_iovec_memset_skip(QEMUIOVector *qiov, int c, size_t count, 271 size_t skip) 272{ 273 int i; 274 size_t done; 275 void *iov_base; 276 uint64_t iov_len; 277 278 done = 0; 279 for (i = 0; (i < qiov->niov) && (done != count); i++) { 280 if (skip >= qiov->iov[i].iov_len) { 281 /* Skip the whole iov */ 282 skip -= qiov->iov[i].iov_len; 283 continue; 284 } else { 285 /* Skip only part (or nothing) of the iov */ 286 iov_base = (uint8_t*) qiov->iov[i].iov_base + skip; 287 iov_len = qiov->iov[i].iov_len - skip; 288 skip = 0; 289 } 290 291 if (done + iov_len > count) { 292 memset(iov_base, c, count - done); 293 break; 294 } else { 295 memset(iov_base, c, iov_len); 296 } 297 done += iov_len; 298 } 299} 300 301#ifndef _WIN32 302/* Sets a specific flag */ 303int fcntl_setfl(int fd, int flag) 304{ 305 int flags; 306 307 flags = fcntl(fd, F_GETFL); 308 if (flags == -1) 309 return -errno; 310 311 if (fcntl(fd, F_SETFL, flags | flag) == -1) 312 return -errno; 313 314 return 0; 315} 316#endif 317 318/* 319 * Convert string to bytes, allowing either B/b for bytes, K/k for KB, 320 * M/m for MB, G/g for GB or T/t for TB. Default without any postfix 321 * is MB. End pointer will be returned in *end, if not NULL. A valid 322 * value must be terminated by whitespace, ',' or '\0'. Return -1 on 323 * error. 324 */ 325int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix) 326{ 327 int64_t retval = -1; 328 char *endptr; 329 unsigned char c, d; 330 int mul_required = 0; 331 double val, mul, integral, fraction; 332 333 errno = 0; 334 val = strtod(nptr, &endptr); 335 if (isnan(val) || endptr == nptr || errno != 0) { 336 goto fail; 337 } 338 fraction = modf(val, &integral); 339 if (fraction != 0) { 340 mul_required = 1; 341 } 342 /* 343 * Any whitespace character is fine for terminating the number, 344 * in addition we accept ',' to handle strings where the size is 345 * part of a multi token argument. 346 */ 347 c = *endptr; 348 d = c; 349 if (qemu_isspace(c) || c == '\0' || c == ',') { 350 c = 0; 351 if (default_suffix) { 352 d = default_suffix; 353 } else { 354 d = c; 355 } 356 } 357 switch (qemu_toupper(d)) { 358 case STRTOSZ_DEFSUFFIX_B: 359 mul = 1; 360 if (mul_required) { 361 goto fail; 362 } 363 break; 364 case STRTOSZ_DEFSUFFIX_KB: 365 mul = 1 << 10; 366 break; 367 case 0: 368 if (mul_required) { 369 goto fail; 370 } 371 case STRTOSZ_DEFSUFFIX_MB: 372 mul = 1ULL << 20; 373 break; 374 case STRTOSZ_DEFSUFFIX_GB: 375 mul = 1ULL << 30; 376 break; 377 case STRTOSZ_DEFSUFFIX_TB: 378 mul = 1ULL << 40; 379 break; 380 default: 381 goto fail; 382 } 383 /* 384 * If not terminated by whitespace, ',', or \0, increment endptr 385 * to point to next character, then check that we are terminated 386 * by an appropriate separating character, ie. whitespace, ',', or 387 * \0. If not, we are seeing trailing garbage, thus fail. 388 */ 389 if (c != 0) { 390 endptr++; 391 if (!qemu_isspace(*endptr) && *endptr != ',' && *endptr != 0) { 392 goto fail; 393 } 394 } 395 if ((val * mul >= INT64_MAX) || val < 0) { 396 goto fail; 397 } 398 retval = val * mul; 399 400fail: 401 if (end) { 402 *end = endptr; 403 } 404 405 return retval; 406} 407 408int64_t strtosz(const char *nptr, char **end) 409{ 410 return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB); 411} 412