Home | History | Annotate | Download | only in qemu 
      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_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
    116 {
    117     int i;
    118 
    119     qiov->iov = iov;
    120     qiov->niov = niov;
    121     qiov->nalloc = -1;
    122     qiov->size = 0;
    123     for (i = 0; i < niov; i++)
    124         qiov->size += iov[i].iov_len;
    125 }
    126 
    127 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len)
    128 {
    129     assert(qiov->nalloc != -1);
    130 
    131     if (qiov->niov == qiov->nalloc) {
    132         qiov->nalloc = 2 * qiov->nalloc + 1;
    133         qiov->iov = qemu_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec));
    134     }
    135     qiov->iov[qiov->niov].iov_base = base;
    136     qiov->iov[qiov->niov].iov_len = len;
    137     qiov->size += len;
    138     ++qiov->niov;
    139 }
    140 
    141 void qemu_iovec_destroy(QEMUIOVector *qiov)
    142 {
    143     assert(qiov->nalloc != -1);
    144 
    145     qemu_free(qiov->iov);
    146 }
    147 
    148 void qemu_iovec_reset(QEMUIOVector *qiov)
    149 {
    150     assert(qiov->nalloc != -1);
    151 
    152     qiov->niov = 0;
    153     qiov->size = 0;
    154 }
    155 
    156 void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf)
    157 {
    158     uint8_t *p = (uint8_t *)buf;
    159     int i;
    160 
    161     for (i = 0; i < qiov->niov; ++i) {
    162         memcpy(p, qiov->iov[i].iov_base, qiov->iov[i].iov_len);
    163         p += qiov->iov[i].iov_len;
    164     }
    165 }
    166 
    167 void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count)
    168 {
    169     const uint8_t *p = (const uint8_t *)buf;
    170     size_t copy;
    171     int i;
    172 
    173     for (i = 0; i < qiov->niov && count; ++i) {
    174         copy = count;
    175         if (copy > qiov->iov[i].iov_len)
    176             copy = qiov->iov[i].iov_len;
    177         memcpy(qiov->iov[i].iov_base, p, copy);
    178         p     += copy;
    179         count -= copy;
    180     }
    181 }
    182