File:  [Qemu by Fabrice Bellard] / qemu / cutils.c
Revision 1.1.1.3 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 16:50:24 2018 UTC (18 months, 2 weeks ago) by root
Branches: qemu, MAIN
CVS tags: qemu0105, qemu0104, qemu0103, qemu0102, qemu0101, qemu0100, HEAD
qemu 0.10.0

    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: 
   27: void pstrcpy(char *buf, int buf_size, const char *str)
   28: {
   29:     int c;
   30:     char *q = buf;
   31: 
   32:     if (buf_size <= 0)
   33:         return;
   34: 
   35:     for(;;) {
   36:         c = *str++;
   37:         if (c == 0 || q >= buf + buf_size - 1)
   38:             break;
   39:         *q++ = c;
   40:     }
   41:     *q = '\0';
   42: }
   43: 
   44: /* strcat and truncate. */
   45: char *pstrcat(char *buf, int buf_size, const char *s)
   46: {
   47:     int len;
   48:     len = strlen(buf);
   49:     if (len < buf_size)
   50:         pstrcpy(buf + len, buf_size - len, s);
   51:     return buf;
   52: }
   53: 
   54: int strstart(const char *str, const char *val, const char **ptr)
   55: {
   56:     const char *p, *q;
   57:     p = str;
   58:     q = val;
   59:     while (*q != '\0') {
   60:         if (*p != *q)
   61:             return 0;
   62:         p++;
   63:         q++;
   64:     }
   65:     if (ptr)
   66:         *ptr = p;
   67:     return 1;
   68: }
   69: 
   70: int stristart(const char *str, const char *val, const char **ptr)
   71: {
   72:     const char *p, *q;
   73:     p = str;
   74:     q = val;
   75:     while (*q != '\0') {
   76:         if (qemu_toupper(*p) != qemu_toupper(*q))
   77:             return 0;
   78:         p++;
   79:         q++;
   80:     }
   81:     if (ptr)
   82:         *ptr = p;
   83:     return 1;
   84: }
   85: 
   86: time_t mktimegm(struct tm *tm)
   87: {
   88:     time_t t;
   89:     int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
   90:     if (m < 3) {
   91:         m += 12;
   92:         y--;
   93:     }
   94:     t = 86400 * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 + 
   95:                  y / 400 - 719469);
   96:     t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
   97:     return t;
   98: }
   99: 
  100: int qemu_fls(int i)
  101: {
  102:     return 32 - clz32(i);
  103: }
  104: 
  105: /* io vectors */
  106: 
  107: void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint)
  108: {
  109:     qiov->iov = qemu_malloc(alloc_hint * sizeof(struct iovec));
  110:     qiov->niov = 0;
  111:     qiov->nalloc = alloc_hint;
  112:     qiov->size = 0;
  113: }
  114: 
  115: void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len)
  116: {
  117:     if (qiov->niov == qiov->nalloc) {
  118:         qiov->nalloc = 2 * qiov->nalloc + 1;
  119:         qiov->iov = qemu_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec));
  120:     }
  121:     qiov->iov[qiov->niov].iov_base = base;
  122:     qiov->iov[qiov->niov].iov_len = len;
  123:     qiov->size += len;
  124:     ++qiov->niov;
  125: }
  126: 
  127: void qemu_iovec_destroy(QEMUIOVector *qiov)
  128: {
  129:     qemu_free(qiov->iov);
  130: }
  131: 
  132: void qemu_iovec_reset(QEMUIOVector *qiov)
  133: {
  134:     qiov->niov = 0;
  135:     qiov->size = 0;
  136: }
  137: 
  138: void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf)
  139: {
  140:     uint8_t *p = (uint8_t *)buf;
  141:     int i;
  142: 
  143:     for (i = 0; i < qiov->niov; ++i) {
  144:         memcpy(p, qiov->iov[i].iov_base, qiov->iov[i].iov_len);
  145:         p += qiov->iov[i].iov_len;
  146:     }
  147: }
  148: 
  149: void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count)
  150: {
  151:     const uint8_t *p = (const uint8_t *)buf;
  152:     size_t copy;
  153:     int i;
  154: 
  155:     for (i = 0; i < qiov->niov && count; ++i) {
  156:         copy = count;
  157:         if (copy > qiov->iov[i].iov_len)
  158:             copy = qiov->iov[i].iov_len;
  159:         memcpy(qiov->iov[i].iov_base, p, copy);
  160:         p     += copy;
  161:         count -= copy;
  162:     }
  163: }

unix.superglobalmegacorp.com