cutils.c

   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 "cache-utils.h"
  27 #include <assert.h>
  28
  29 void pstrcpy(char *buf, int buf_size, const char *str)
  30 {
  31     int c;
  32     char *q = buf;
  33
  34     if (buf_size <= 0)
  35         return;
  36
  37     for(;;) {
  38         c = *str++;
  39         if (c == 0 || q >= buf + buf_size - 1)
  40             break;
  41         *q++ = c;
  42     }
  43     *q = '\0';
  44 }
  45
  46 /* strcat and truncate. */
  47 char *pstrcat(char *buf, int buf_size, const char *s)
  48 {
  49     int len;
  50     len = strlen(buf);
  51     if (len < buf_size)
  52         pstrcpy(buf + len, buf_size - len, s);
  53     return buf;
  54 }
  55
  56 int strstart(const char *str, const char *val, const char **ptr)
  57 {
  58     const char *p, *q;
  59     p = str;
  60     q = val;
  61     while (*q != '\0') {
  62         if (*p != *q)
  63             return 0;
  64         p++;
  65         q++;
  66     }
  67     if (ptr)
  68         *ptr = p;
  69     return 1;
  70 }
  71
  72 int stristart(const char *str, const char *val, const char **ptr)
  73 {
  74     const char *p, *q;
  75     p = str;
  76     q = val;
  77     while (*q != '\0') {
  78         if (qemu_toupper(*p) != qemu_toupper(*q))
  79             return 0;
  80         p++;
  81         q++;
  82     }
  83     if (ptr)
  84         *ptr = p;
  85     return 1;
  86 }
  87
  88 time_t mktimegm(struct tm *tm)
  89 {
  90     time_t t;
  91     int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
  92     if (m < 3) {
  93         m += 12;
  94         y--;
  95     }
  96     t = 86400 * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 +
  97                  y / 400 - 719469);
  98     t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
  99     return t;
 100 }
 101
 102 int hex2bin(char ch)
 103 {
 104     if (ch >= '0' && ch <= '9')
 105         return ch - '0';
 106     else if (ch >= 'A' && ch <= 'Z')
 107         return 10 + ch - 'A';
 108     else if (ch >= 'a' && ch <= 'z')
 109         return 10 + ch - 'a';
 110
 111     return -1;
 112 }
 113
 114 char *urldecode(const char *ptr)
 115 {
 116     char *ret;
 117     int i;
 118
 119     ret = qemu_mallocz(strlen(ptr) + 1);
 120     if (ret == NULL)
 121         return NULL;
 122
 123     for (i = 0; *ptr; ptr++, i++) {
 124         switch (*ptr) {
 125         case '%':
 126             if (ptr[1] == 0 || ptr[2] == 0)
 127                 break;
 128             ret[i] = hex2bin(ptr[1]) << 4 | hex2bin(ptr[2]);
 129             ptr += 2;
 130             break;
 131         default:
 132            ret[i] = *ptr;
 133            break;
 134         }
 135     }
 136     ret[i] = 0;
 137
 138     return ret;
 139 }
 140
 141 int qemu_fls(int i)
 142 {
 143     return 32 - clz32(i);
 144 }
 145
 146 /* io vectors */
 147
 148 void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint)
 149 {
 150     qiov->iov = qemu_malloc(alloc_hint * sizeof(struct iovec));
 151     qiov->niov = 0;
 152     qiov->nalloc = alloc_hint;
 153     qiov->size = 0;
 154 }
 155
 156 void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
 157 {
 158     int i;
 159
 160     qiov->iov = iov;
 161     qiov->niov = niov;
 162     qiov->nalloc = -1;
 163     qiov->size = 0;
 164     for (i = 0; i < niov; i++)
 165         qiov->size += iov[i].iov_len;
 166 }
 167
 168 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len)
 169 {
 170     assert(qiov->nalloc != -1);
 171
 172     if (qiov->niov == qiov->nalloc) {
 173         qiov->nalloc = 2 * qiov->nalloc + 1;
 174         qiov->iov = qemu_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec));
 175     }
 176     qiov->iov[qiov->niov].iov_base = base;
 177     qiov->iov[qiov->niov].iov_len = len;
 178     qiov->size += len;
 179     ++qiov->niov;
 180 }
 181
 182 void qemu_iovec_destroy(QEMUIOVector *qiov)
 183 {
 184     assert(qiov->nalloc != -1);
 185
 186     qemu_free(qiov->iov);
 187 }
 188
 189 void qemu_iovec_reset(QEMUIOVector *qiov)
 190 {
 191     assert(qiov->nalloc != -1);
 192
 193     qiov->niov = 0;
 194     qiov->size = 0;
 195 }
 196
 197 void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf)
 198 {
 199     uint8_t *p = (uint8_t *)buf;
 200     int i;
 201
 202     for (i = 0; i < qiov->niov; ++i) {
 203         memcpy(p, qiov->iov[i].iov_base, qiov->iov[i].iov_len);
 204         p += qiov->iov[i].iov_len;
 205     }
 206 }
 207
 208 void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count)
 209 {
 210     const uint8_t *p = (const uint8_t *)buf;
 211     size_t copy;
 212     int i;
 213
 214     for (i = 0; i < qiov->niov && count; ++i) {
 215         copy = count;
 216         if (copy > qiov->iov[i].iov_len)
 217             copy = qiov->iov[i].iov_len;
 218         memcpy(qiov->iov[i].iov_base, p, copy);
 219         qemu_sync_idcache((unsigned long)qiov->iov[i].iov_base,
 220                   (unsigned long)(qiov->iov[i].iov_base + copy));
 221         p     += copy;
 222         count -= copy;
 223     }
 224 }