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 */ 24 void 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 */ 37 void 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 */ 54 char *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 */ 71 int 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 */ 87 int 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 */ 103 int 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 */ 124 char *qemu_strsep(char **input, const char *delim); 125 time_t mktimegm(struct tm *tm); 126 int qemu_fdatasync(int fd); 127 int fcntl_setfl(int fd, int flag); 128 int qemu_parse_fd(const char *param); 129 int qemu_strtol(const char *nptr, const char **endptr, int base, 130 long *result); 131 int qemu_strtoul(const char *nptr, const char **endptr, int base, 132 unsigned long *result); 133 int qemu_strtoll(const char *nptr, const char **endptr, int base, 134 int64_t *result); 135 int qemu_strtoull(const char *nptr, const char **endptr, int base, 136 uint64_t *result); 137 138 int parse_uint(const char *s, unsigned long long *value, char **endptr, 139 int base); 140 int 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' 156 int64_t qemu_strtosz(const char *nptr, char **end); 157 int64_t qemu_strtosz_suffix(const char *nptr, char **end, 158 const char default_suffix); 159 int64_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 171 bool can_use_buffer_find_nonzero_offset(const void *buf, size_t len); 172 size_t buffer_find_nonzero_offset(const void *buf, size_t len); 173 bool 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 180 int uleb128_encode_small(uint8_t *out, uint32_t n); 181 int uleb128_decode_small(const uint8_t *in, uint32_t *n); 182 183 #endif 184