1 #ifndef QEMU_CUTILS_H 2 #define QEMU_CUTILS_H 3 4 /** 5 * pstrcpy: 6 * @buf: buffer to copy string into 7 * @buf_size: size of @buf in bytes 8 * @str: string to copy 9 * 10 * Copy @str into @buf, including the trailing NUL, but do not 11 * write more than @buf_size bytes. The resulting buffer is 12 * always NUL terminated (even if the source string was too long). 13 * If @buf_size is zero or negative then no bytes are copied. 14 * 15 * This function is similar to strncpy(), but avoids two of that 16 * function's problems: 17 * * if @str fits in the buffer, pstrcpy() does not zero-fill the 18 * remaining space at the end of @buf 19 * * if @str is too long, pstrcpy() will copy the first @buf_size-1 20 * bytes and then add a NUL 21 */ 22 void pstrcpy(char *buf, int buf_size, const char *str); 23 /** 24 * strpadcpy: 25 * @buf: buffer to copy string into 26 * @buf_size: size of @buf in bytes 27 * @str: string to copy 28 * @pad: character to pad the remainder of @buf with 29 * 30 * Copy @str into @buf (but *not* its trailing NUL!), and then pad the 31 * rest of the buffer with the @pad character. If @str is too large 32 * for the buffer then it is truncated, so that @buf contains the 33 * first @buf_size characters of @str, with no terminator. 34 */ 35 void strpadcpy(char *buf, int buf_size, const char *str, char pad); 36 /** 37 * pstrcat: 38 * @buf: buffer containing existing string 39 * @buf_size: size of @buf in bytes 40 * @s: string to concatenate to @buf 41 * 42 * Append a copy of @s to the string already in @buf, but do not 43 * allow the buffer to overflow. If the existing contents of @buf 44 * plus @str would total more than @buf_size bytes, then write 45 * as much of @str as will fit followed by a NUL terminator. 46 * 47 * @buf must already contain a NUL-terminated string, or the 48 * behaviour is undefined. 49 * 50 * Returns: @buf. 51 */ 52 char *pstrcat(char *buf, int buf_size, const char *s); 53 /** 54 * strstart: 55 * @str: string to test 56 * @val: prefix string to look for 57 * @ptr: NULL, or pointer to be written to indicate start of 58 * the remainder of the string 59 * 60 * Test whether @str starts with the prefix @val. 61 * If it does (including the degenerate case where @str and @val 62 * are equal) then return true. If @ptr is not NULL then a 63 * pointer to the first character following the prefix is written 64 * to it. If @val is not a prefix of @str then return false (and 65 * @ptr is not written to). 66 * 67 * Returns: true if @str starts with prefix @val, false otherwise. 68 */ 69 int strstart(const char *str, const char *val, const char **ptr); 70 /** 71 * stristart: 72 * @str: string to test 73 * @val: prefix string to look for 74 * @ptr: NULL, or pointer to be written to indicate start of 75 * the remainder of the string 76 * 77 * Test whether @str starts with the case-insensitive prefix @val. 78 * This function behaves identically to strstart(), except that the 79 * comparison is made after calling qemu_toupper() on each pair of 80 * characters. 81 * 82 * Returns: true if @str starts with case-insensitive prefix @val, 83 * false otherwise. 84 */ 85 int stristart(const char *str, const char *val, const char **ptr); 86 /** 87 * qemu_strnlen: 88 * @s: string 89 * @max_len: maximum number of bytes in @s to scan 90 * 91 * Return the length of the string @s, like strlen(), but do not 92 * examine more than @max_len bytes of the memory pointed to by @s. 93 * If no NUL terminator is found within @max_len bytes, then return 94 * @max_len instead. 95 * 96 * This function has the same behaviour as the POSIX strnlen() 97 * function. 98 * 99 * Returns: length of @s in bytes, or @max_len, whichever is smaller. 100 */ 101 int qemu_strnlen(const char *s, int max_len); 102 /** 103 * qemu_strsep: 104 * @input: pointer to string to parse 105 * @delim: string containing delimiter characters to search for 106 * 107 * Locate the first occurrence of any character in @delim within 108 * the string referenced by @input, and replace it with a NUL. 109 * The location of the next character after the delimiter character 110 * is stored into @input. 111 * If the end of the string was reached without finding a delimiter 112 * character, then NULL is stored into @input. 113 * If @input points to a NULL pointer on entry, return NULL. 114 * The return value is always the original value of *@input (and 115 * so now points to a NUL-terminated string corresponding to the 116 * part of the input up to the first delimiter). 117 * 118 * This function has the same behaviour as the BSD strsep() function. 119 * 120 * Returns: the pointer originally in @input. 121 */ 122 char *qemu_strsep(char **input, const char *delim); 123 #ifdef HAVE_STRCHRNUL 124 static inline const char *qemu_strchrnul(const char *s, int c) 125 { 126 return strchrnul(s, c); 127 } 128 #else 129 const char *qemu_strchrnul(const char *s, int c); 130 #endif 131 time_t mktimegm(struct tm *tm); 132 int qemu_parse_fd(const char *param); 133 int qemu_strtoi(const char *nptr, const char **endptr, int base, 134 int *result); 135 int qemu_strtoui(const char *nptr, const char **endptr, int base, 136 unsigned int *result); 137 int qemu_strtol(const char *nptr, const char **endptr, int base, 138 long *result); 139 int qemu_strtoul(const char *nptr, const char **endptr, int base, 140 unsigned long *result); 141 int qemu_strtoi64(const char *nptr, const char **endptr, int base, 142 int64_t *result); 143 int qemu_strtou64(const char *nptr, const char **endptr, int base, 144 uint64_t *result); 145 int qemu_strtod(const char *nptr, const char **endptr, double *result); 146 int qemu_strtod_finite(const char *nptr, const char **endptr, double *result); 147 148 int parse_uint(const char *s, unsigned long long *value, char **endptr, 149 int base); 150 int parse_uint_full(const char *s, unsigned long long *value, int base); 151 152 int qemu_strtosz(const char *nptr, const char **end, uint64_t *result); 153 int qemu_strtosz_MiB(const char *nptr, const char **end, uint64_t *result); 154 int qemu_strtosz_metric(const char *nptr, const char **end, uint64_t *result); 155 156 char *size_to_str(uint64_t val); 157 158 /** 159 * freq_to_str: 160 * @freq_hz: frequency to stringify 161 * 162 * Return human readable string for frequency @freq_hz. 163 * Use SI units like KHz, MHz, and so forth. 164 * 165 * The caller is responsible for releasing the value returned 166 * with g_free() after use. 167 */ 168 char *freq_to_str(uint64_t freq_hz); 169 170 /* used to print char* safely */ 171 #define STR_OR_NULL(str) ((str) ? (str) : "null") 172 173 bool buffer_is_zero(const void *buf, size_t len); 174 bool test_buffer_is_zero_next_accel(void); 175 176 /* 177 * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128) 178 * Input is limited to 14-bit numbers 179 */ 180 181 int uleb128_encode_small(uint8_t *out, uint32_t n); 182 int uleb128_decode_small(const uint8_t *in, uint32_t *n); 183 184 /** 185 * qemu_pstrcmp0: 186 * @str1: a non-NULL pointer to a C string (*str1 can be NULL) 187 * @str2: a non-NULL pointer to a C string (*str2 can be NULL) 188 * 189 * Compares *str1 and *str2 with g_strcmp0(). 190 * 191 * Returns: an integer less than, equal to, or greater than zero, if 192 * *str1 is <, == or > than *str2. 193 */ 194 int qemu_pstrcmp0(const char **str1, const char **str2); 195 196 197 /** 198 * get_relocated_path: 199 * @dir: the directory (typically a `CONFIG_*DIR` variable) to be relocated. 200 * 201 * Returns a path for @dir that uses the directory of the running executable 202 * as the prefix. For example, if `bindir` is `/usr/bin` and @dir is 203 * `/usr/share/qemu`, the function will append `../share/qemu` to the 204 * directory that contains the running executable and return the result. 205 * The returned string should be freed by the caller. 206 */ 207 char *get_relocated_path(const char *dir); 208 209 static inline const char *yes_no(bool b) 210 { 211 return b ? "yes" : "no"; 212 } 213 214 /* 215 * helper to parse debug environment variables 216 */ 217 int parse_debug_env(const char *name, int max, int initial); 218 219 /* 220 * Hexdump a line of a byte buffer into a hexadecimal/ASCII buffer 221 */ 222 #define QEMU_HEXDUMP_LINE_BYTES 16 /* Number of bytes to dump */ 223 #define QEMU_HEXDUMP_LINE_LEN 75 /* Number of characters in line */ 224 void qemu_hexdump_line(char *line, unsigned int b, const void *bufptr, 225 unsigned int len, bool ascii); 226 227 /* 228 * Hexdump a buffer to a file. An optional string prefix is added to every line 229 */ 230 231 void qemu_hexdump(FILE *fp, const char *prefix, 232 const void *bufptr, size_t size); 233 234 #endif 235