1#ifndef QEMU_CUTILS_H 2#define QEMU_CUTILS_H 3 4#include "qemu/fprintf-fn.h" 5 6/** 7 * pstrcpy: 8 * @buf: buffer to copy string into 9 * @buf_size: size of @buf in bytes 10 * @str: string to copy 11 * 12 * Copy @str into @buf, including the trailing NUL, but do not 13 * write more than @buf_size bytes. The resulting buffer is 14 * always NUL terminated (even if the source string was too long). 15 * If @buf_size is zero or negative then no bytes are copied. 16 * 17 * This function is similar to strncpy(), but avoids two of that 18 * function's problems: 19 * * if @str fits in the buffer, pstrcpy() does not zero-fill the 20 * remaining space at the end of @buf 21 * * if @str is too long, pstrcpy() will copy the first @buf_size-1 22 * bytes and then add a NUL 23 */ 24void pstrcpy(char *buf, int buf_size, const char *str); 25/** 26 * strpadcpy: 27 * @buf: buffer to copy string into 28 * @buf_size: size of @buf in bytes 29 * @str: string to copy 30 * @pad: character to pad the remainder of @buf with 31 * 32 * Copy @str into @buf (but *not* its trailing NUL!), and then pad the 33 * rest of the buffer with the @pad character. If @str is too large 34 * for the buffer then it is truncated, so that @buf contains the 35 * first @buf_size characters of @str, with no terminator. 36 */ 37void strpadcpy(char *buf, int buf_size, const char *str, char pad); 38/** 39 * pstrcat: 40 * @buf: buffer containing existing string 41 * @buf_size: size of @buf in bytes 42 * @s: string to concatenate to @buf 43 * 44 * Append a copy of @s to the string already in @buf, but do not 45 * allow the buffer to overflow. If the existing contents of @buf 46 * plus @str would total more than @buf_size bytes, then write 47 * as much of @str as will fit followed by a NUL terminator. 48 * 49 * @buf must already contain a NUL-terminated string, or the 50 * behaviour is undefined. 51 * 52 * Returns: @buf. 53 */ 54char *pstrcat(char *buf, int buf_size, const char *s); 55/** 56 * strstart: 57 * @str: string to test 58 * @val: prefix string to look for 59 * @ptr: NULL, or pointer to be written to indicate start of 60 * the remainder of the string 61 * 62 * Test whether @str starts with the prefix @val. 63 * If it does (including the degenerate case where @str and @val 64 * are equal) then return true. If @ptr is not NULL then a 65 * pointer to the first character following the prefix is written 66 * to it. If @val is not a prefix of @str then return false (and 67 * @ptr is not written to). 68 * 69 * Returns: true if @str starts with prefix @val, false otherwise. 70 */ 71int strstart(const char *str, const char *val, const char **ptr); 72/** 73 * stristart: 74 * @str: string to test 75 * @val: prefix string to look for 76 * @ptr: NULL, or pointer to be written to indicate start of 77 * the remainder of the string 78 * 79 * Test whether @str starts with the case-insensitive prefix @val. 80 * This function behaves identically to strstart(), except that the 81 * comparison is made after calling qemu_toupper() on each pair of 82 * characters. 83 * 84 * Returns: true if @str starts with case-insensitive prefix @val, 85 * false otherwise. 86 */ 87int stristart(const char *str, const char *val, const char **ptr); 88/** 89 * qemu_strnlen: 90 * @s: string 91 * @max_len: maximum number of bytes in @s to scan 92 * 93 * Return the length of the string @s, like strlen(), but do not 94 * examine more than @max_len bytes of the memory pointed to by @s. 95 * If no NUL terminator is found within @max_len bytes, then return 96 * @max_len instead. 97 * 98 * This function has the same behaviour as the POSIX strnlen() 99 * function. 100 * 101 * Returns: length of @s in bytes, or @max_len, whichever is smaller. 102 */ 103int qemu_strnlen(const char *s, int max_len); 104/** 105 * qemu_strsep: 106 * @input: pointer to string to parse 107 * @delim: string containing delimiter characters to search for 108 * 109 * Locate the first occurrence of any character in @delim within 110 * the string referenced by @input, and replace it with a NUL. 111 * The location of the next character after the delimiter character 112 * is stored into @input. 113 * If the end of the string was reached without finding a delimiter 114 * character, then NULL is stored into @input. 115 * If @input points to a NULL pointer on entry, return NULL. 116 * The return value is always the original value of *@input (and 117 * so now points to a NUL-terminated string corresponding to the 118 * part of the input up to the first delimiter). 119 * 120 * This function has the same behaviour as the BSD strsep() function. 121 * 122 * Returns: the pointer originally in @input. 123 */ 124char *qemu_strsep(char **input, const char *delim); 125time_t mktimegm(struct tm *tm); 126int qemu_fdatasync(int fd); 127int fcntl_setfl(int fd, int flag); 128int qemu_parse_fd(const char *param); 129int qemu_strtol(const char *nptr, const char **endptr, int base, 130 long *result); 131int qemu_strtoul(const char *nptr, const char **endptr, int base, 132 unsigned long *result); 133int qemu_strtoll(const char *nptr, const char **endptr, int base, 134 int64_t *result); 135int qemu_strtoull(const char *nptr, const char **endptr, int base, 136 uint64_t *result); 137 138int parse_uint(const char *s, unsigned long long *value, char **endptr, 139 int base); 140int parse_uint_full(const char *s, unsigned long long *value, int base); 141 142/* 143 * qemu_strtosz() suffixes used to specify the default treatment of an 144 * argument passed to qemu_strtosz() without an explicit suffix. 145 * These should be defined using upper case characters in the range 146 * A-Z, as qemu_strtosz() will use qemu_toupper() on the given argument 147 * prior to comparison. 148 */ 149#define QEMU_STRTOSZ_DEFSUFFIX_EB 'E' 150#define QEMU_STRTOSZ_DEFSUFFIX_PB 'P' 151#define QEMU_STRTOSZ_DEFSUFFIX_TB 'T' 152#define QEMU_STRTOSZ_DEFSUFFIX_GB 'G' 153#define QEMU_STRTOSZ_DEFSUFFIX_MB 'M' 154#define QEMU_STRTOSZ_DEFSUFFIX_KB 'K' 155#define QEMU_STRTOSZ_DEFSUFFIX_B 'B' 156int64_t qemu_strtosz(const char *nptr, char **end); 157int64_t qemu_strtosz_suffix(const char *nptr, char **end, 158 const char default_suffix); 159int64_t qemu_strtosz_suffix_unit(const char *nptr, char **end, 160 const char default_suffix, int64_t unit); 161#define K_BYTE (1ULL << 10) 162#define M_BYTE (1ULL << 20) 163#define G_BYTE (1ULL << 30) 164#define T_BYTE (1ULL << 40) 165#define P_BYTE (1ULL << 50) 166#define E_BYTE (1ULL << 60) 167 168/* used to print char* safely */ 169#define STR_OR_NULL(str) ((str) ? (str) : "null") 170 171bool can_use_buffer_find_nonzero_offset(const void *buf, size_t len); 172size_t buffer_find_nonzero_offset(const void *buf, size_t len); 173bool buffer_is_zero(const void *buf, size_t len); 174 175/* 176 * Implementation of ULEB128 (http://en.wikipedia.org/wiki/LEB128) 177 * Input is limited to 14-bit numbers 178 */ 179 180int uleb128_encode_small(uint8_t *out, uint32_t n); 181int uleb128_decode_small(const uint8_t *in, uint32_t *n); 182 183#endif 184