Sylvain Munaut | 12ba778 | 2014-06-16 10:13:40 +0200 | [diff] [blame] | 1 | #pragma once |
Harald Welte | ec8b450 | 2010-02-20 20:34:29 +0100 | [diff] [blame] | 2 | |
Neels Hofmeyr | 4335bad | 2017-10-07 04:39:14 +0200 | [diff] [blame] | 3 | #include <stdbool.h> |
Vadim Yanitskiy | 5594430 | 2018-09-05 02:58:03 +0700 | [diff] [blame] | 4 | #include <stdint.h> |
| 5 | #include <stdio.h> |
Neels Hofmeyr | 823073a | 2019-10-28 04:58:04 +0100 | [diff] [blame] | 6 | #include <string.h> |
Neels Hofmeyr | 4335bad | 2017-10-07 04:39:14 +0200 | [diff] [blame] | 7 | |
Harald Welte | b8add36 | 2013-07-06 23:49:41 +0200 | [diff] [blame] | 8 | #include <osmocom/core/backtrace.h> |
Harald Welte | f3c7e85 | 2014-08-20 22:50:47 +0200 | [diff] [blame] | 9 | #include <osmocom/core/talloc.h> |
Harald Welte | 459a180 | 2018-06-28 09:24:17 +0200 | [diff] [blame] | 10 | #include <osmocom/core/panic.h> |
Neels Hofmeyr | 7c74989 | 2018-09-07 03:01:38 +0200 | [diff] [blame] | 11 | #include <osmocom/core/defs.h> |
Harald Welte | b8add36 | 2013-07-06 23:49:41 +0200 | [diff] [blame] | 12 | |
Harald Welte | 8598f18 | 2011-08-17 14:19:27 +0200 | [diff] [blame] | 13 | /*! \defgroup utils General-purpose utility functions |
| 14 | * @{ |
Neels Hofmeyr | 17518fe | 2017-06-20 04:35:06 +0200 | [diff] [blame] | 15 | * \file utils.h */ |
Harald Welte | 8598f18 | 2011-08-17 14:19:27 +0200 | [diff] [blame] | 16 | |
Neels Hofmeyr | 87e4550 | 2017-06-20 00:17:59 +0200 | [diff] [blame] | 17 | /*! Determine number of elements in an array of static size */ |
Kévin Redon | d1e220f | 2019-06-13 13:41:00 +0200 | [diff] [blame] | 18 | #ifndef ARRAY_SIZE |
Harald Welte | ec8b450 | 2010-02-20 20:34:29 +0100 | [diff] [blame] | 19 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) |
Kévin Redon | d1e220f | 2019-06-13 13:41:00 +0200 | [diff] [blame] | 20 | #endif |
Neels Hofmeyr | 87e4550 | 2017-06-20 00:17:59 +0200 | [diff] [blame] | 21 | /*! Return the maximum of two specified values */ |
Holger Hans Peter Freyther | 08b2862 | 2012-08-15 17:02:59 +0200 | [diff] [blame] | 22 | #define OSMO_MAX(a, b) ((a) >= (b) ? (a) : (b)) |
Neels Hofmeyr | 87e4550 | 2017-06-20 00:17:59 +0200 | [diff] [blame] | 23 | /*! Return the minimum of two specified values */ |
Holger Hans Peter Freyther | 08b2862 | 2012-08-15 17:02:59 +0200 | [diff] [blame] | 24 | #define OSMO_MIN(a, b) ((a) >= (b) ? (b) : (a)) |
Neels Hofmeyr | 002a51d | 2019-10-30 04:37:47 +0100 | [diff] [blame] | 25 | /*! Return a typical cmp result for comparable entities a and b. */ |
| 26 | #define OSMO_CMP(a, b) ((a) < (b)? -1 : ((a) > (b)? 1 : 0)) |
Neels Hofmeyr | dc75b11 | 2017-12-09 05:51:42 +0100 | [diff] [blame] | 27 | /*! Stringify the name of a macro x, e.g. an FSM event name. |
| 28 | * Note: if nested within another preprocessor macro, this will |
| 29 | * stringify the value of x instead of its name. */ |
Neels Hofmeyr | 1808096 | 2016-12-16 13:43:54 +0100 | [diff] [blame] | 30 | #define OSMO_STRINGIFY(x) #x |
Neels Hofmeyr | 84ea2e0 | 2017-12-09 05:53:18 +0100 | [diff] [blame] | 31 | /*! Stringify the value of a macro x, e.g. a port number. */ |
| 32 | #define OSMO_STRINGIFY_VAL(x) OSMO_STRINGIFY(x) |
Neels Hofmeyr | 87e4550 | 2017-06-20 00:17:59 +0200 | [diff] [blame] | 33 | /*! Make a value_string entry from an enum value name */ |
Neels Hofmeyr | 8a5d60b | 2017-03-09 23:01:37 +0100 | [diff] [blame] | 34 | #define OSMO_VALUE_STRING(x) { x, #x } |
Neels Hofmeyr | 87e4550 | 2017-06-20 00:17:59 +0200 | [diff] [blame] | 35 | /*! Number of bytes necessary to store given BITS */ |
Max | dd75bac | 2017-06-13 15:07:01 +0200 | [diff] [blame] | 36 | #define OSMO_BYTES_FOR_BITS(BITS) ((BITS + 8 - 1) / 8) |
Harald Welte | ec8b450 | 2010-02-20 20:34:29 +0100 | [diff] [blame] | 37 | |
Max | 18c014d | 2018-01-30 14:33:01 +0100 | [diff] [blame] | 38 | /*! Copy a C-string into a sized buffer using sizeof to detect buffer's size */ |
| 39 | #define OSMO_STRLCPY_ARRAY(array, src) osmo_strlcpy(array, src, sizeof(array)) |
| 40 | |
Neels Hofmeyr | 87e4550 | 2017-06-20 00:17:59 +0200 | [diff] [blame] | 41 | /*! A mapping between human-readable string and numeric value */ |
Harald Welte | d284cd9 | 2010-03-01 21:58:31 +0100 | [diff] [blame] | 42 | struct value_string { |
Pau Espin Pedrol | cc0b5d5 | 2020-02-03 11:18:51 +0100 | [diff] [blame] | 43 | int value; /*!< numeric value */ |
Neels Hofmeyr | 87e4550 | 2017-06-20 00:17:59 +0200 | [diff] [blame] | 44 | const char *str; /*!< human-readable string */ |
Harald Welte | d284cd9 | 2010-03-01 21:58:31 +0100 | [diff] [blame] | 45 | }; |
| 46 | |
| 47 | const char *get_value_string(const struct value_string *vs, uint32_t val); |
Neels Hofmeyr | 8d6dcd9 | 2016-06-06 18:05:23 +0200 | [diff] [blame] | 48 | const char *get_value_string_or_null(const struct value_string *vs, |
| 49 | uint32_t val); |
Harald Welte | bd598e3 | 2011-08-16 23:26:52 +0200 | [diff] [blame] | 50 | |
Harald Welte | d284cd9 | 2010-03-01 21:58:31 +0100 | [diff] [blame] | 51 | int get_string_value(const struct value_string *vs, const char *str); |
| 52 | |
Pablo Neira Ayuso | 87f7b25 | 2011-05-07 12:43:08 +0200 | [diff] [blame] | 53 | char osmo_bcd2char(uint8_t bcd); |
Kévin Redon | 77021c7 | 2019-06-13 18:12:33 +0200 | [diff] [blame] | 54 | /* only works for numbers in ASCII */ |
Pablo Neira Ayuso | 87f7b25 | 2011-05-07 12:43:08 +0200 | [diff] [blame] | 55 | uint8_t osmo_char2bcd(char c); |
Harald Welte | d284cd9 | 2010-03-01 21:58:31 +0100 | [diff] [blame] | 56 | |
Neels Hofmeyr | 7079e69 | 2018-12-05 21:02:36 +0100 | [diff] [blame] | 57 | int osmo_bcd2str(char *dst, size_t dst_size, const uint8_t *bcd, int start_nibble, int end_nibble, bool allow_hex); |
Neels Hofmeyr | 83025bf | 2020-05-26 02:45:23 +0200 | [diff] [blame] | 58 | int osmo_str2bcd(uint8_t *dst, size_t dst_size, const char *digits, int start_nibble, int end_nibble, bool allow_hex); |
Neels Hofmeyr | 7079e69 | 2018-12-05 21:02:36 +0100 | [diff] [blame] | 59 | |
Pablo Neira Ayuso | 87f7b25 | 2011-05-07 12:43:08 +0200 | [diff] [blame] | 60 | int osmo_hexparse(const char *str, uint8_t *b, int max_len); |
Harald Welte | bd598e3 | 2011-08-16 23:26:52 +0200 | [diff] [blame] | 61 | |
Harald Welte | 4a62eda | 2019-03-18 18:27:00 +0100 | [diff] [blame] | 62 | char *osmo_ubit_dump_buf(char *buf, size_t buf_len, const uint8_t *bits, unsigned int len); |
Pablo Neira Ayuso | 87f7b25 | 2011-05-07 12:43:08 +0200 | [diff] [blame] | 63 | char *osmo_ubit_dump(const uint8_t *bits, unsigned int len); |
Harald Welte | 8598f18 | 2011-08-17 14:19:27 +0200 | [diff] [blame] | 64 | char *osmo_hexdump(const unsigned char *buf, int len); |
Harald Welte | 179f357 | 2019-03-18 18:38:47 +0100 | [diff] [blame] | 65 | char *osmo_hexdump_c(const void *ctx, const unsigned char *buf, int len); |
Sylvain Munaut | ff23d24 | 2011-11-10 23:03:18 +0100 | [diff] [blame] | 66 | char *osmo_hexdump_nospc(const unsigned char *buf, int len); |
Harald Welte | 179f357 | 2019-03-18 18:38:47 +0100 | [diff] [blame] | 67 | char *osmo_hexdump_nospc_c(const void *ctx, const unsigned char *buf, int len); |
Neels Hofmeyr | 0423b61 | 2019-01-14 23:32:53 +0100 | [diff] [blame] | 68 | const char *osmo_hexdump_buf(char *out_buf, size_t out_buf_size, const unsigned char *buf, int len, const char *delim, |
| 69 | bool delim_after_last); |
| 70 | |
Sylvain Munaut | 4cfbae8 | 2011-11-13 23:04:00 +0100 | [diff] [blame] | 71 | char *osmo_osmo_hexdump_nospc(const unsigned char *buf, int len) __attribute__((__deprecated__)); |
Harald Welte | 3eba991 | 2010-07-30 10:37:29 +0200 | [diff] [blame] | 72 | |
Holger Hans Peter Freyther | 0f40ae1 | 2015-04-13 09:21:05 +0200 | [diff] [blame] | 73 | #define osmo_static_assert(exp, name) typedef int dummy##name [(exp) ? 1 : -1] __attribute__((__unused__)); |
Holger Hans Peter Freyther | 52c07ca | 2011-01-16 17:37:27 +0100 | [diff] [blame] | 74 | |
Neels Hofmeyr | 7c74989 | 2018-09-07 03:01:38 +0200 | [diff] [blame] | 75 | void osmo_str2lower(char *out, const char *in) |
| 76 | OSMO_DEPRECATED("Use osmo_str_tolower() or osmo_str_tolower_buf() instead," |
| 77 | " to properly check target memory bounds"); |
| 78 | void osmo_str2upper(char *out, const char *in) |
| 79 | OSMO_DEPRECATED("Use osmo_str_toupper() or osmo_str_toupper_buf() instead," |
| 80 | " to properly check target memory bounds"); |
| 81 | |
| 82 | size_t osmo_str_tolower_buf(char *dest, size_t dest_len, const char *src); |
| 83 | const char *osmo_str_tolower(const char *src); |
Harald Welte | 179f357 | 2019-03-18 18:38:47 +0100 | [diff] [blame] | 84 | char *osmo_str_tolower_c(const void *ctx, const char *src); |
Neels Hofmeyr | 7c74989 | 2018-09-07 03:01:38 +0200 | [diff] [blame] | 85 | |
| 86 | size_t osmo_str_toupper_buf(char *dest, size_t dest_len, const char *src); |
| 87 | const char *osmo_str_toupper(const char *src); |
Harald Welte | 179f357 | 2019-03-18 18:38:47 +0100 | [diff] [blame] | 88 | char *osmo_str_toupper_c(const void *ctx, const char *src); |
Harald Welte | 2822296 | 2011-02-18 20:37:04 +0100 | [diff] [blame] | 89 | |
Pablo Neira Ayuso | 3abad6a | 2011-03-28 19:24:22 +0200 | [diff] [blame] | 90 | #define OSMO_SNPRINTF_RET(ret, rem, offset, len) \ |
| 91 | do { \ |
| 92 | len += ret; \ |
| 93 | if (ret > rem) \ |
| 94 | ret = rem; \ |
| 95 | offset += ret; \ |
| 96 | rem -= ret; \ |
| 97 | } while (0) |
| 98 | |
Kévin Redon | 77021c7 | 2019-06-13 18:12:33 +0200 | [diff] [blame] | 99 | /*! Helper macro to terminate when an assertion fails |
Harald Welte | 2d2e2cc | 2016-04-25 12:11:20 +0200 | [diff] [blame] | 100 | * \param[in] exp Predicate to verify |
| 101 | * This function will generate a backtrace and terminate the program if |
| 102 | * the predicate evaluates to false (0). |
| 103 | */ |
Katerina Barone-Adesi | 008e53b | 2013-03-03 10:36:52 +0000 | [diff] [blame] | 104 | #define OSMO_ASSERT(exp) \ |
Vadim Yanitskiy | e242548 | 2019-07-09 13:56:24 +0700 | [diff] [blame] | 105 | if (!(exp)) { \ |
Neels Hofmeyr | 983dcb9 | 2018-08-20 12:33:22 +0200 | [diff] [blame] | 106 | osmo_panic("Assert failed %s %s:%d\n", #exp, __FILE__, __LINE__); \ |
Vadim Yanitskiy | e242548 | 2019-07-09 13:56:24 +0700 | [diff] [blame] | 107 | } |
Katerina Barone-Adesi | 008e53b | 2013-03-03 10:36:52 +0000 | [diff] [blame] | 108 | |
Harald Welte | 2d2e2cc | 2016-04-25 12:11:20 +0200 | [diff] [blame] | 109 | /*! duplicate a string using talloc and release its prior content (if any) |
| 110 | * \param[in] ctx Talloc context to use for allocation |
| 111 | * \param[out] dst pointer to string, will be updated with ptr to new string |
Kévin Redon | 77021c7 | 2019-06-13 18:12:33 +0200 | [diff] [blame] | 112 | * \param[in] newstr String that will be copied to newly allocated string */ |
Harald Welte | 881dcaf | 2016-07-28 08:02:48 +0200 | [diff] [blame] | 113 | static inline void osmo_talloc_replace_string(void *ctx, char **dst, const char *newstr) |
Harald Welte | f3c7e85 | 2014-08-20 22:50:47 +0200 | [diff] [blame] | 114 | { |
| 115 | if (*dst) |
| 116 | talloc_free(*dst); |
| 117 | *dst = talloc_strdup(ctx, newstr); |
| 118 | } |
Katerina Barone-Adesi | 008e53b | 2013-03-03 10:36:52 +0000 | [diff] [blame] | 119 | |
Neels Hofmeyr | abdd7a2 | 2017-10-19 02:40:01 +0200 | [diff] [blame] | 120 | /*! Append to a string and re-/allocate if necessary. |
| 121 | * \param[in] ctx Talloc context to use for initial allocation. |
| 122 | * \param[in,out] dest char* to re-/allocate and append to. |
| 123 | * \param[in] fmt printf-like string format. |
| 124 | * \param[in] args Arguments for fmt. |
| 125 | * |
| 126 | * \a dest may be passed in NULL, or a string previously allocated by talloc. |
| 127 | * If an existing string is passed in, it will remain associated with whichever |
| 128 | * ctx it was allocated before, regardless whether it matches \a ctx or not. |
| 129 | */ |
| 130 | #define osmo_talloc_asprintf(ctx, dest, fmt, args ...) \ |
| 131 | do { \ |
| 132 | if (!dest) \ |
| 133 | dest = talloc_asprintf(ctx, fmt, ## args); \ |
| 134 | else \ |
| 135 | dest = talloc_asprintf_append((char*)dest, fmt, ## args); \ |
| 136 | } while (0) |
| 137 | |
Harald Welte | 9709b2e | 2016-04-25 18:47:53 +0200 | [diff] [blame] | 138 | int osmo_constant_time_cmp(const uint8_t *exp, const uint8_t *rel, const int count); |
| 139 | uint64_t osmo_decode_big_endian(const uint8_t *data, size_t data_len); |
| 140 | uint8_t *osmo_encode_big_endian(uint64_t value, size_t data_len); |
| 141 | |
Harald Welte | aeecc48 | 2016-11-26 10:41:40 +0100 | [diff] [blame] | 142 | size_t osmo_strlcpy(char *dst, const char *src, size_t siz); |
Neels Hofmeyr | 06356fd | 2019-11-19 01:38:10 +0100 | [diff] [blame] | 143 | const char *osmo_strnchr(const char *str, size_t str_size, char c); |
Harald Welte | aeecc48 | 2016-11-26 10:41:40 +0100 | [diff] [blame] | 144 | |
Neels Hofmeyr | 4335bad | 2017-10-07 04:39:14 +0200 | [diff] [blame] | 145 | bool osmo_is_hexstr(const char *str, int min_digits, int max_digits, |
| 146 | bool require_even); |
| 147 | |
Harald Welte | febe83c | 2017-10-03 17:41:59 +0800 | [diff] [blame] | 148 | bool osmo_identifier_valid(const char *str); |
Neels Hofmeyr | 937ddea | 2017-12-16 00:46:50 +0100 | [diff] [blame] | 149 | bool osmo_separated_identifiers_valid(const char *str, const char *sep_chars); |
Neels Hofmeyr | b480b74 | 2019-04-11 06:58:44 +0200 | [diff] [blame] | 150 | void osmo_identifier_sanitize_buf(char *str, const char *sep_chars, char replace_with); |
Harald Welte | febe83c | 2017-10-03 17:41:59 +0800 | [diff] [blame] | 151 | |
Neels Hofmeyr | 8a7eed5 | 2019-11-21 00:12:10 +0100 | [diff] [blame] | 152 | size_t osmo_escape_cstr_buf(char *buf, size_t bufsize, const char *str, int in_len); |
| 153 | char *osmo_escape_cstr_c(void *ctx, const char *str, int in_len); |
| 154 | size_t osmo_quote_cstr_buf(char *buf, size_t bufsize, const char *str, int in_len); |
| 155 | char *osmo_quote_cstr_c(void *ctx, const char *str, int in_len); |
| 156 | |
Neels Hofmeyr | 9910bbc | 2017-12-16 00:54:52 +0100 | [diff] [blame] | 157 | const char *osmo_escape_str(const char *str, int len); |
Neels Hofmeyr | ecef7ec | 2019-03-05 16:42:50 +0100 | [diff] [blame] | 158 | char *osmo_escape_str_buf2(char *buf, size_t bufsize, const char *str, int in_len); |
| 159 | const char *osmo_escape_str_buf(const char *str, int in_len, char *buf, size_t bufsize); |
Harald Welte | 179f357 | 2019-03-18 18:38:47 +0100 | [diff] [blame] | 160 | char *osmo_escape_str_c(const void *ctx, const char *str, int in_len); |
Neels Hofmeyr | 04eb56f | 2018-04-09 00:41:28 +0200 | [diff] [blame] | 161 | const char *osmo_quote_str(const char *str, int in_len); |
Neels Hofmeyr | ecef7ec | 2019-03-05 16:42:50 +0100 | [diff] [blame] | 162 | char *osmo_quote_str_buf2(char *buf, size_t bufsize, const char *str, int in_len); |
| 163 | const char *osmo_quote_str_buf(const char *str, int in_len, char *buf, size_t bufsize); |
Harald Welte | 179f357 | 2019-03-18 18:38:47 +0100 | [diff] [blame] | 164 | char *osmo_quote_str_c(const void *ctx, const char *str, int in_len); |
Neels Hofmeyr | 9910bbc | 2017-12-16 00:54:52 +0100 | [diff] [blame] | 165 | |
Neels Hofmeyr | ecef7ec | 2019-03-05 16:42:50 +0100 | [diff] [blame] | 166 | int osmo_print_n(char *buf, size_t bufsize, const char *str, size_t n); |
| 167 | |
Harald Welte | 15a5f8d | 2018-06-06 16:58:17 +0200 | [diff] [blame] | 168 | uint32_t osmo_isqrt32(uint32_t x); |
| 169 | |
Vadim Yanitskiy | d9fc604 | 2019-06-12 15:49:03 +0700 | [diff] [blame] | 170 | char osmo_luhn(const char* in, int in_len); |
Oliver Smith | 894be2d | 2019-01-11 13:13:37 +0100 | [diff] [blame] | 171 | |
Neels Hofmeyr | 2cbe25f | 2019-02-11 20:32:06 +0100 | [diff] [blame] | 172 | /*! State for OSMO_STRBUF_APPEND() and OSMO_STRBUF_PRINTF(). See there for examples. */ |
| 173 | struct osmo_strbuf { |
| 174 | /*! Point to the start of a string buffer. */ |
| 175 | char *buf; |
| 176 | /*! Total sizeof() the buffer buf points at. */ |
| 177 | size_t len; |
| 178 | /*! Current writing position in buf (end of the string written so far). */ |
| 179 | char *pos; |
| 180 | /*! After all OSMO_STRBUF_APPEND operations, reflects the total number of characters that would be written had |
| 181 | * buf been large enough. Like snprintf()'s return value, this does not include the terminating nul character. |
| 182 | * Hence, to allocate an adequately sized buffer, add 1 to this number. */ |
| 183 | size_t chars_needed; |
| 184 | }; |
| 185 | |
| 186 | /*! Append a string to a buffer, as printed by an snprintf()-like function and with similar bounds checking. |
| 187 | * Make sure to never write past the end of the buffer, and collect the total size that would be needed. |
| 188 | * |
| 189 | * // an example function implementation to append: write N spaces. |
| 190 | * int print_spaces(char *dst, size_t dst_len, int n) |
| 191 | * { |
| 192 | * int i; |
| 193 | * if (n < 0) |
| 194 | * return -EINVAL; |
| 195 | * for (i = 0; i < n && i < dst_len; i++) |
| 196 | * dst[i] = ' '; |
| 197 | * if (dst_len) |
| 198 | * dst[OSMO_MIN(dst_len - 1, n)] = '\0'; |
| 199 | * // return the n that we would have liked to write if space were available: |
| 200 | * return n; |
| 201 | * } |
| 202 | * |
| 203 | * // append above spaces as well as an snprintf() |
| 204 | * void strbuf_example() |
| 205 | * { |
| 206 | * char buf[23]; |
| 207 | * struct osmo_strbuf sb = { .buf = buf, .len = sizeof(buf) }; |
| 208 | * |
| 209 | * OSMO_STRBUF_APPEND(sb, print_spaces, 5); |
| 210 | * OSMO_STRBUF_APPEND(sb, snprintf, "The answer is %d but what is the question?", 42); |
| 211 | * OSMO_STRBUF_APPEND(sb, print_spaces, 423423); |
| 212 | * |
| 213 | * printf("%s\n", buf); |
| 214 | * printf("would have needed %zu bytes\n", sb.chars_needed); |
| 215 | * } |
| 216 | * |
| 217 | * \param[inout] STRBUF A struct osmo_strbuf instance. |
| 218 | * \param[in] func A function with a signature of int func(char *dst, size_t dst_len [, args]) with semantics like |
| 219 | * snprintf(). |
| 220 | * \param[in] args Arguments passed to func, if any. |
| 221 | */ |
| 222 | #define OSMO_STRBUF_APPEND(STRBUF, func, args...) do { \ |
| 223 | if (!(STRBUF).pos) \ |
| 224 | (STRBUF).pos = (STRBUF).buf; \ |
Neels Hofmeyr | 8531d66 | 2019-04-11 07:16:02 +0200 | [diff] [blame] | 225 | size_t _sb_remain = (STRBUF).buf ? (STRBUF).len - ((STRBUF).pos - (STRBUF).buf) : 0; \ |
| 226 | int _sb_l = func((STRBUF).pos, _sb_remain, ##args); \ |
| 227 | if (_sb_l < 0 || _sb_l > _sb_remain) \ |
Neels Hofmeyr | 2cbe25f | 2019-02-11 20:32:06 +0100 | [diff] [blame] | 228 | (STRBUF).pos = (STRBUF).buf + (STRBUF).len; \ |
Neels Hofmeyr | 8531d66 | 2019-04-11 07:16:02 +0200 | [diff] [blame] | 229 | else if ((STRBUF).pos) \ |
| 230 | (STRBUF).pos += _sb_l; \ |
| 231 | if (_sb_l > 0) \ |
| 232 | (STRBUF).chars_needed += _sb_l; \ |
Neels Hofmeyr | 2cbe25f | 2019-02-11 20:32:06 +0100 | [diff] [blame] | 233 | } while(0) |
| 234 | |
| 235 | /*! Shortcut for OSMO_STRBUF_APPEND() invocation using snprintf(). |
| 236 | * |
| 237 | * int strbuf_example2(char *buf, size_t buflen) |
| 238 | * { |
| 239 | * int i; |
| 240 | * struct osmo_strbuf sb = { .buf = buf, .len = buflen }; |
| 241 | * |
| 242 | * OSMO_STRBUF_PRINTF(sb, "T minus"); |
| 243 | * for (i = 10; i; i--) |
| 244 | * OSMO_STRBUF_PRINTF(sb, " %d", i); |
| 245 | * OSMO_STRBUF_PRINTF(sb, " ... Lift off!"); |
| 246 | * |
| 247 | * return sb.chars_needed; |
| 248 | * } |
| 249 | * |
| 250 | * \param[inout] STRBUF A struct osmo_strbuf instance. |
| 251 | * \param[in] fmt Format string passed to snprintf. |
| 252 | * \param[in] args Additional arguments passed to snprintf, if any. |
| 253 | */ |
| 254 | #define OSMO_STRBUF_PRINTF(STRBUF, fmt, args...) \ |
| 255 | OSMO_STRBUF_APPEND(STRBUF, snprintf, fmt, ##args) |
| 256 | |
Neels Hofmeyr | 8531d66 | 2019-04-11 07:16:02 +0200 | [diff] [blame] | 257 | /*! Like OSMO_STRBUF_APPEND(), but for function signatures that return the char* buffer instead of a length. |
| 258 | * When using this function, the final STRBUF.chars_needed may not reflect the actual number of characters needed, since |
| 259 | * that number cannot be obtained from this kind of function signature. |
| 260 | * \param[inout] STRBUF A struct osmo_strbuf instance. |
| 261 | * \param[in] func A function with a signature of char *func(char *dst, size_t dst_len [, args]) where |
| 262 | * the returned string is always written to dst. |
| 263 | * \param[in] args Arguments passed to func, if any. |
| 264 | */ |
| 265 | #define OSMO_STRBUF_APPEND_NOLEN(STRBUF, func, args...) do { \ |
| 266 | if (!(STRBUF).pos) \ |
| 267 | (STRBUF).pos = (STRBUF).buf; \ |
| 268 | size_t _sb_remain = (STRBUF).buf ? (STRBUF).len - ((STRBUF).pos - (STRBUF).buf) : 0; \ |
| 269 | if (_sb_remain) { \ |
| 270 | func((STRBUF).pos, _sb_remain, ##args); \ |
| 271 | } \ |
| 272 | size_t _sb_l = (STRBUF).pos ? strnlen((STRBUF).pos, _sb_remain) : 0; \ |
| 273 | if (_sb_l > _sb_remain) \ |
| 274 | (STRBUF).pos = (STRBUF).buf + (STRBUF).len; \ |
| 275 | else if ((STRBUF).pos) \ |
| 276 | (STRBUF).pos += _sb_l; \ |
| 277 | (STRBUF).chars_needed += _sb_l; \ |
| 278 | } while(0) |
| 279 | |
Neels Hofmeyr | d79ccc6 | 2019-03-07 23:08:40 +0100 | [diff] [blame] | 280 | bool osmo_str_startswith(const char *str, const char *startswith_str); |
| 281 | |
Neels Hofmeyr | 87c3afb | 2020-09-30 21:47:47 +0000 | [diff] [blame] | 282 | int osmo_float_str_to_int(int64_t *val, const char *str, unsigned int precision); |
| 283 | int osmo_int_to_float_str_buf(char *buf, size_t buflen, int64_t val, unsigned int precision); |
| 284 | char *osmo_int_to_float_str_c(void *ctx, int64_t val, unsigned int precision); |
| 285 | |
Neels Hofmeyr | 823073a | 2019-10-28 04:58:04 +0100 | [diff] [blame] | 286 | /*! Translate a buffer function to a talloc context function. |
| 287 | * This is the full function body of a char *foo_name_c(void *ctx, val...) function, implemented by an |
| 288 | * int foo_name_buf(buf, buflen, val...) function: |
| 289 | * |
| 290 | * char *foo_name_c(void *ctx, example_t arg) |
| 291 | * { |
| 292 | * OSMO_NAME_C_IMPL(ctx, 64, "ERROR", foo_name_buf, arg) |
| 293 | * } |
| 294 | * |
| 295 | * Return a talloc'd string containing the result of the given foo_name_buf() function, or ON_ERROR on error in the called |
| 296 | * foo_name_buf() function. |
| 297 | * |
| 298 | * If ON_ERROR is NULL, the function returns NULL on error rc from FUNC_BUF. Take care: returning NULL in printf() like |
| 299 | * formats (LOGP()) makes the program crash. If ON_ERROR is non-NULL, it must be a string constant, which is not |
| 300 | * returned directly, but written to an allocated string buffer first. |
| 301 | * |
| 302 | * \param[in] INITIAL_BUFSIZE Which size to first talloc from ctx -- a larger size makes a reallocation less likely, a |
| 303 | * smaller size allocates less unused bytes, zero allocates once but still runs the string composition twice. |
| 304 | * \param[in] ON_ERROR String constant to copy on error rc returned by FUNC_BUF, or NULL to return NULL. |
Neels Hofmeyr | dacac99 | 2020-05-26 02:44:21 +0200 | [diff] [blame] | 305 | * \param[in] FUNC_BUF Name of a function with signature int foo_buf(char *buf, size_t buflen, ...). |
| 306 | * The function must return the strlen() that it would write to a sufficiently large buffer or |
| 307 | * negative on error, like snprintf(). |
Neels Hofmeyr | 823073a | 2019-10-28 04:58:04 +0100 | [diff] [blame] | 308 | * \param[in] FUNC_BUF_ARGS Additional arguments to pass to FUNC_BUF after the buf and buflen. |
| 309 | */ |
| 310 | #define OSMO_NAME_C_IMPL(CTX, INITIAL_BUFSIZE, ON_ERROR, FUNC_BUF, FUNC_BUF_ARGS...) \ |
| 311 | size_t _len = INITIAL_BUFSIZE; \ |
| 312 | int _needed; \ |
| 313 | char *_str = NULL; \ |
| 314 | if ((INITIAL_BUFSIZE) > 0) { \ |
| 315 | _str = (char*)talloc_named_const(CTX, _len, __func__); \ |
| 316 | OSMO_ASSERT(_str); \ |
| 317 | } \ |
| 318 | _needed = FUNC_BUF(_str, _len, ## FUNC_BUF_ARGS); \ |
| 319 | if (_needed < 0) \ |
| 320 | goto OSMO_NAME_C_on_error; \ |
| 321 | if (_needed < _len) \ |
| 322 | return _str; \ |
| 323 | _len = _needed + 1; \ |
| 324 | if (_str) \ |
| 325 | talloc_free(_str); \ |
| 326 | _str = (char*)talloc_named_const(CTX, _len, __func__); \ |
| 327 | OSMO_ASSERT(_str); \ |
| 328 | _needed = FUNC_BUF(_str, _len, ## FUNC_BUF_ARGS); \ |
| 329 | if (_needed < 0) \ |
| 330 | goto OSMO_NAME_C_on_error; \ |
| 331 | return _str; \ |
| 332 | OSMO_NAME_C_on_error: \ |
| 333 | /* Re-using and re-sizing above allocated buf ends up in very complex code. Just free and strdup. */ \ |
| 334 | if (_str) \ |
| 335 | talloc_free(_str); \ |
| 336 | if (!(ON_ERROR)) \ |
| 337 | return NULL; \ |
| 338 | _str = talloc_strdup(CTX, ON_ERROR); \ |
| 339 | OSMO_ASSERT(_str); \ |
| 340 | talloc_set_name_const(_str, __func__); \ |
| 341 | return _str; |
| 342 | |
Sylvain Munaut | dca7d2c | 2012-04-18 21:53:23 +0200 | [diff] [blame] | 343 | /*! @} */ |