| diff --git a/libavb/avb_crc32.c b/libavb/avb_crc32.c |
| index 9abed54..491fb36 100644 |
| --- a/libavb/avb_crc32.c |
| +++ b/libavb/avb_crc32.c |
| @@ -42,11 +42,12 @@ |
| * CRC32 code derived from work by Gary S. Brown. |
| */ |
| |
| -#include "avb_sysdeps.h" |
| +//#include "avb_sysdeps.h" |
| +#include "avb_util.h" |
| |
| /* Code taken from FreeBSD 8 */ |
| |
| -static uint32_t crc32_tab[] = { |
| +static uint32_t iavb_crc32_tab[] = { |
| 0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, |
| 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, |
| 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, |
| @@ -98,16 +99,16 @@ static uint32_t crc32_tab[] = { |
| * in sys/libkern.h, where it can be inlined. |
| */ |
| |
| -static uint32_t crc32(uint32_t crc_in, const uint8_t* buf, int size) { |
| +static uint32_t iavb_crc32(uint32_t crc_in, const uint8_t* buf, int size) { |
| const uint8_t* p = buf; |
| uint32_t crc; |
| |
| crc = crc_in ^ ~0U; |
| while (size--) |
| - crc = crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8); |
| + crc = iavb_crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8); |
| return crc ^ ~0U; |
| } |
| |
| uint32_t avb_crc32(const uint8_t* buf, size_t size) { |
| - return crc32(0, buf, size); |
| + return iavb_crc32(0, buf, size); |
| } |
| diff --git a/libavb/avb_util.c b/libavb/avb_util.c |
| index 43662b4..4105d38 100644 |
| --- a/libavb/avb_util.c |
| +++ b/libavb/avb_util.c |
| @@ -24,31 +24,7 @@ |
| |
| #include "avb_util.h" |
| |
| -#include <stdarg.h> |
| - |
| -uint32_t avb_be32toh(uint32_t in) { |
| - uint8_t* d = (uint8_t*)∈ |
| - uint32_t ret; |
| - ret = ((uint32_t)d[0]) << 24; |
| - ret |= ((uint32_t)d[1]) << 16; |
| - ret |= ((uint32_t)d[2]) << 8; |
| - ret |= ((uint32_t)d[3]); |
| - return ret; |
| -} |
| - |
| -uint64_t avb_be64toh(uint64_t in) { |
| - uint8_t* d = (uint8_t*)∈ |
| - uint64_t ret; |
| - ret = ((uint64_t)d[0]) << 56; |
| - ret |= ((uint64_t)d[1]) << 48; |
| - ret |= ((uint64_t)d[2]) << 40; |
| - ret |= ((uint64_t)d[3]) << 32; |
| - ret |= ((uint64_t)d[4]) << 24; |
| - ret |= ((uint64_t)d[5]) << 16; |
| - ret |= ((uint64_t)d[6]) << 8; |
| - ret |= ((uint64_t)d[7]); |
| - return ret; |
| -} |
| +//#include <stdarg.h> |
| |
| /* Converts a 32-bit unsigned integer from host to big-endian byte order. */ |
| uint32_t avb_htobe32(uint32_t in) { |
| @@ -63,341 +39,3 @@ uint32_t avb_htobe32(uint32_t in) { |
| return ret.word; |
| } |
| |
| -/* Converts a 64-bit unsigned integer from host to big-endian byte order. */ |
| -uint64_t avb_htobe64(uint64_t in) { |
| - union { |
| - uint64_t word; |
| - uint8_t bytes[8]; |
| - } ret; |
| - ret.bytes[0] = (in >> 56) & 0xff; |
| - ret.bytes[1] = (in >> 48) & 0xff; |
| - ret.bytes[2] = (in >> 40) & 0xff; |
| - ret.bytes[3] = (in >> 32) & 0xff; |
| - ret.bytes[4] = (in >> 24) & 0xff; |
| - ret.bytes[5] = (in >> 16) & 0xff; |
| - ret.bytes[6] = (in >> 8) & 0xff; |
| - ret.bytes[7] = in & 0xff; |
| - return ret.word; |
| -} |
| - |
| -int avb_safe_memcmp(const void* s1, const void* s2, size_t n) { |
| - const unsigned char* us1 = s1; |
| - const unsigned char* us2 = s2; |
| - int result = 0; |
| - |
| - if (0 == n) { |
| - return 0; |
| - } |
| - |
| - /* |
| - * Code snippet without data-dependent branch due to Nate Lawson |
| - * (nate@root.org) of Root Labs. |
| - */ |
| - while (n--) { |
| - result |= *us1++ ^ *us2++; |
| - } |
| - |
| - return result != 0; |
| -} |
| - |
| -bool avb_safe_add_to(uint64_t* value, uint64_t value_to_add) { |
| - uint64_t original_value; |
| - |
| - avb_assert(value != NULL); |
| - |
| - original_value = *value; |
| - |
| - *value += value_to_add; |
| - if (*value < original_value) { |
| - avb_error("Overflow when adding values.\n"); |
| - return false; |
| - } |
| - |
| - return true; |
| -} |
| - |
| -bool avb_safe_add(uint64_t* out_result, uint64_t a, uint64_t b) { |
| - uint64_t dummy; |
| - if (out_result == NULL) { |
| - out_result = &dummy; |
| - } |
| - *out_result = a; |
| - return avb_safe_add_to(out_result, b); |
| -} |
| - |
| -bool avb_validate_utf8(const uint8_t* data, size_t num_bytes) { |
| - size_t n; |
| - unsigned int num_cc; |
| - |
| - for (n = 0, num_cc = 0; n < num_bytes; n++) { |
| - uint8_t c = data[n]; |
| - |
| - if (num_cc > 0) { |
| - if ((c & (0x80 | 0x40)) == 0x80) { |
| - /* 10xx xxxx */ |
| - } else { |
| - goto fail; |
| - } |
| - num_cc--; |
| - } else { |
| - if (c < 0x80) { |
| - num_cc = 0; |
| - } else if ((c & (0x80 | 0x40 | 0x20)) == (0x80 | 0x40)) { |
| - /* 110x xxxx */ |
| - num_cc = 1; |
| - } else if ((c & (0x80 | 0x40 | 0x20 | 0x10)) == (0x80 | 0x40 | 0x20)) { |
| - /* 1110 xxxx */ |
| - num_cc = 2; |
| - } else if ((c & (0x80 | 0x40 | 0x20 | 0x10 | 0x08)) == |
| - (0x80 | 0x40 | 0x20 | 0x10)) { |
| - /* 1111 0xxx */ |
| - num_cc = 3; |
| - } else { |
| - goto fail; |
| - } |
| - } |
| - } |
| - |
| - if (num_cc != 0) { |
| - goto fail; |
| - } |
| - |
| - return true; |
| - |
| -fail: |
| - return false; |
| -} |
| - |
| -bool avb_str_concat(char* buf, |
| - size_t buf_size, |
| - const char* str1, |
| - size_t str1_len, |
| - const char* str2, |
| - size_t str2_len) { |
| - uint64_t combined_len; |
| - |
| - if (!avb_safe_add(&combined_len, str1_len, str2_len)) { |
| - avb_error("Overflow when adding string sizes.\n"); |
| - return false; |
| - } |
| - |
| - if (combined_len > buf_size - 1) { |
| - avb_error("Insufficient buffer space.\n"); |
| - return false; |
| - } |
| - |
| - avb_memcpy(buf, str1, str1_len); |
| - avb_memcpy(buf + str1_len, str2, str2_len); |
| - buf[combined_len] = '\0'; |
| - |
| - return true; |
| -} |
| - |
| -void* avb_malloc(size_t size) { |
| - void* ret = avb_malloc_(size); |
| - if (ret == NULL) { |
| - avb_error("Failed to allocate memory.\n"); |
| - return NULL; |
| - } |
| - return ret; |
| -} |
| - |
| -void* avb_calloc(size_t size) { |
| - void* ret = avb_malloc(size); |
| - if (ret == NULL) { |
| - return NULL; |
| - } |
| - |
| - avb_memset(ret, '\0', size); |
| - return ret; |
| -} |
| - |
| -char* avb_strdup(const char* str) { |
| - size_t len = avb_strlen(str); |
| - char* ret = avb_malloc(len + 1); |
| - if (ret == NULL) { |
| - return NULL; |
| - } |
| - |
| - avb_memcpy(ret, str, len); |
| - ret[len] = '\0'; |
| - |
| - return ret; |
| -} |
| - |
| -const char* avb_strstr(const char* haystack, const char* needle) { |
| - size_t n, m; |
| - |
| - /* Look through |haystack| and check if the first character of |
| - * |needle| matches. If so, check the rest of |needle|. |
| - */ |
| - for (n = 0; haystack[n] != '\0'; n++) { |
| - if (haystack[n] != needle[0]) { |
| - continue; |
| - } |
| - |
| - for (m = 1;; m++) { |
| - if (needle[m] == '\0') { |
| - return haystack + n; |
| - } |
| - |
| - if (haystack[n + m] != needle[m]) { |
| - break; |
| - } |
| - } |
| - } |
| - |
| - return NULL; |
| -} |
| - |
| -const char* avb_strv_find_str(const char* const* strings, |
| - const char* str, |
| - size_t str_size) { |
| - size_t n; |
| - for (n = 0; strings[n] != NULL; n++) { |
| - if (avb_strlen(strings[n]) == str_size && |
| - avb_memcmp(strings[n], str, str_size) == 0) { |
| - return strings[n]; |
| - } |
| - } |
| - return NULL; |
| -} |
| - |
| -char* avb_replace(const char* str, const char* search, const char* replace) { |
| - char* ret = NULL; |
| - size_t ret_len = 0; |
| - size_t search_len, replace_len; |
| - const char* str_after_last_replace; |
| - |
| - search_len = avb_strlen(search); |
| - replace_len = avb_strlen(replace); |
| - |
| - str_after_last_replace = str; |
| - while (*str != '\0') { |
| - const char* s; |
| - size_t num_before; |
| - size_t num_new; |
| - |
| - s = avb_strstr(str, search); |
| - if (s == NULL) { |
| - break; |
| - } |
| - |
| - num_before = s - str; |
| - |
| - if (ret == NULL) { |
| - num_new = num_before + replace_len + 1; |
| - ret = avb_malloc(num_new); |
| - if (ret == NULL) { |
| - goto out; |
| - } |
| - avb_memcpy(ret, str, num_before); |
| - avb_memcpy(ret + num_before, replace, replace_len); |
| - ret[num_new - 1] = '\0'; |
| - ret_len = num_new - 1; |
| - } else { |
| - char* new_str; |
| - num_new = ret_len + num_before + replace_len + 1; |
| - new_str = avb_malloc(num_new); |
| - if (ret == NULL) { |
| - goto out; |
| - } |
| - avb_memcpy(new_str, ret, ret_len); |
| - avb_memcpy(new_str + ret_len, str, num_before); |
| - avb_memcpy(new_str + ret_len + num_before, replace, replace_len); |
| - new_str[num_new - 1] = '\0'; |
| - avb_free(ret); |
| - ret = new_str; |
| - ret_len = num_new - 1; |
| - } |
| - |
| - str = s + search_len; |
| - str_after_last_replace = str; |
| - } |
| - |
| - if (ret == NULL) { |
| - ret = avb_strdup(str_after_last_replace); |
| - if (ret == NULL) { |
| - goto out; |
| - } |
| - } else { |
| - size_t num_remaining = avb_strlen(str_after_last_replace); |
| - size_t num_new = ret_len + num_remaining + 1; |
| - char* new_str = avb_malloc(num_new); |
| - if (ret == NULL) { |
| - goto out; |
| - } |
| - avb_memcpy(new_str, ret, ret_len); |
| - avb_memcpy(new_str + ret_len, str_after_last_replace, num_remaining); |
| - new_str[num_new - 1] = '\0'; |
| - avb_free(ret); |
| - ret = new_str; |
| - ret_len = num_new - 1; |
| - } |
| - |
| -out: |
| - return ret; |
| -} |
| - |
| -/* We only support a limited amount of strings in avb_strdupv(). */ |
| -#define AVB_STRDUPV_MAX_NUM_STRINGS 32 |
| - |
| -char* avb_strdupv(const char* str, ...) { |
| - va_list ap; |
| - const char* strings[AVB_STRDUPV_MAX_NUM_STRINGS]; |
| - size_t lengths[AVB_STRDUPV_MAX_NUM_STRINGS]; |
| - size_t num_strings, n; |
| - uint64_t total_length; |
| - char *ret = NULL, *dest; |
| - |
| - num_strings = 0; |
| - total_length = 0; |
| - va_start(ap, str); |
| - do { |
| - size_t str_len = avb_strlen(str); |
| - strings[num_strings] = str; |
| - lengths[num_strings] = str_len; |
| - if (!avb_safe_add_to(&total_length, str_len)) { |
| - avb_fatal("Overflow while determining total length.\n"); |
| - break; |
| - } |
| - num_strings++; |
| - if (num_strings == AVB_STRDUPV_MAX_NUM_STRINGS) { |
| - avb_fatal("Too many strings passed.\n"); |
| - break; |
| - } |
| - str = va_arg(ap, const char*); |
| - } while (str != NULL); |
| - va_end(ap); |
| - |
| - ret = avb_malloc(total_length + 1); |
| - if (ret == NULL) { |
| - goto out; |
| - } |
| - |
| - dest = ret; |
| - for (n = 0; n < num_strings; n++) { |
| - avb_memcpy(dest, strings[n], lengths[n]); |
| - dest += lengths[n]; |
| - } |
| - *dest = '\0'; |
| - avb_assert(dest == ret + total_length); |
| - |
| -out: |
| - return ret; |
| -} |
| - |
| -const char* avb_basename(const char* str) { |
| - int64_t n; |
| - size_t len; |
| - |
| - len = avb_strlen(str); |
| - if (len >= 2) { |
| - for (n = len - 2; n >= 0; n--) { |
| - if (str[n] == '/') { |
| - return str + n + 1; |
| - } |
| - } |
| - } |
| - return str; |
| -} |
| diff --git a/libavb/avb_util.h b/libavb/avb_util.h |
| index 07c3258..589e64c 100644 |
| --- a/libavb/avb_util.h |
| +++ b/libavb/avb_util.h |
| @@ -22,254 +22,20 @@ |
| * SOFTWARE. |
| */ |
| |
| -#if !defined(AVB_INSIDE_LIBAVB_H) && !defined(AVB_COMPILATION) |
| -#error "Never include this file directly, include libavb.h instead." |
| -#endif |
| - |
| #ifndef AVB_UTIL_H_ |
| #define AVB_UTIL_H_ |
| |
| -#include "avb_sysdeps.h" |
| - |
| +#include <stdint.h> |
| +#include <sys/types.h> |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| - |
| -#define AVB_STRINGIFY(x) #x |
| -#define AVB_TO_STRING(x) AVB_STRINGIFY(x) |
| - |
| -#ifdef AVB_ENABLE_DEBUG |
| -/* Aborts the program if |expr| is false. |
| - * |
| - * This has no effect unless AVB_ENABLE_DEBUG is defined. |
| - */ |
| -#define avb_assert(expr) \ |
| - do { \ |
| - if (!(expr)) { \ |
| - avb_fatal("assert fail: " #expr "\n"); \ |
| - } \ |
| - } while (0) |
| -#else |
| -#define avb_assert(expr) |
| -#endif |
| - |
| -/* Aborts the program if reached. |
| - * |
| - * This has no effect unless AVB_ENABLE_DEBUG is defined. |
| - */ |
| -#ifdef AVB_ENABLE_DEBUG |
| -#define avb_assert_not_reached() \ |
| - do { \ |
| - avb_fatal("assert_not_reached()\n"); \ |
| - } while (0) |
| -#else |
| -#define avb_assert_not_reached() |
| -#endif |
| - |
| -/* Aborts the program if |addr| is not word-aligned. |
| - * |
| - * This has no effect unless AVB_ENABLE_DEBUG is defined. |
| - */ |
| -#define avb_assert_aligned(addr) \ |
| - avb_assert((((uintptr_t)addr) & (AVB_ALIGNMENT_SIZE - 1)) == 0) |
| - |
| -#ifdef AVB_ENABLE_DEBUG |
| -/* Print functions, used for diagnostics. |
| - * |
| - * These have no effect unless AVB_ENABLE_DEBUG is defined. |
| - */ |
| -#define avb_debug(message) \ |
| - do { \ |
| - avb_printv(avb_basename(__FILE__), \ |
| - ":", \ |
| - AVB_TO_STRING(__LINE__), \ |
| - ": DEBUG: ", \ |
| - message, \ |
| - NULL); \ |
| - } while (0) |
| -#define avb_debugv(message, ...) \ |
| - do { \ |
| - avb_printv(avb_basename(__FILE__), \ |
| - ":", \ |
| - AVB_TO_STRING(__LINE__), \ |
| - ": DEBUG: ", \ |
| - message, \ |
| - ##__VA_ARGS__); \ |
| - } while (0) |
| -#else |
| -#define avb_debug(message) |
| -#define avb_debugv(message, ...) |
| -#endif |
| - |
| -/* Prints out a message. This is typically used if a runtime-error |
| - * occurs. |
| - */ |
| -#define avb_error(message) \ |
| - do { \ |
| - avb_printv(avb_basename(__FILE__), \ |
| - ":", \ |
| - AVB_TO_STRING(__LINE__), \ |
| - ": ERROR: ", \ |
| - message, \ |
| - NULL); \ |
| - } while (0) |
| -#define avb_errorv(message, ...) \ |
| - do { \ |
| - avb_printv(avb_basename(__FILE__), \ |
| - ":", \ |
| - AVB_TO_STRING(__LINE__), \ |
| - ": ERROR: ", \ |
| - message, \ |
| - ##__VA_ARGS__); \ |
| - } while (0) |
| - |
| -/* Prints out a message and calls avb_abort(). |
| - */ |
| -#define avb_fatal(message) \ |
| - do { \ |
| - avb_printv(avb_basename(__FILE__), \ |
| - ":", \ |
| - AVB_TO_STRING(__LINE__), \ |
| - ": FATAL: ", \ |
| - message, \ |
| - NULL); \ |
| - avb_abort(); \ |
| - } while (0) |
| -#define avb_fatalv(message, ...) \ |
| - do { \ |
| - avb_printv(avb_basename(__FILE__), \ |
| - ":", \ |
| - AVB_TO_STRING(__LINE__), \ |
| - ": FATAL: ", \ |
| - message, \ |
| - ##__VA_ARGS__); \ |
| - avb_abort(); \ |
| - } while (0) |
| - |
| -/* Converts a 32-bit unsigned integer from big-endian to host byte order. */ |
| -uint32_t avb_be32toh(uint32_t in) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| -/* Converts a 64-bit unsigned integer from big-endian to host byte order. */ |
| -uint64_t avb_be64toh(uint64_t in) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| /* Converts a 32-bit unsigned integer from host to big-endian byte order. */ |
| -uint32_t avb_htobe32(uint32_t in) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| -/* Converts a 64-bit unsigned integer from host to big-endian byte order. */ |
| -uint64_t avb_htobe64(uint64_t in) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| -/* Compare |n| bytes starting at |s1| with |s2| and return 0 if they |
| - * match, 1 if they don't. Returns 0 if |n|==0, since no bytes |
| - * mismatched. |
| - * |
| - * Time taken to perform the comparison is only dependent on |n| and |
| - * not on the relationship of the match between |s1| and |s2|. |
| - * |
| - * Note that unlike avb_memcmp(), this only indicates inequality, not |
| - * whether |s1| is less than or greater than |s2|. |
| - */ |
| -int avb_safe_memcmp(const void* s1, |
| - const void* s2, |
| - size_t n) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| -/* Adds |value_to_add| to |value| with overflow protection. |
| - * |
| - * Returns false if the addition overflows, true otherwise. In either |
| - * case, |value| is always modified. |
| - */ |
| -bool avb_safe_add_to(uint64_t* value, |
| - uint64_t value_to_add) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| -/* Adds |a| and |b| with overflow protection, returning the value in |
| - * |out_result|. |
| - * |
| - * It's permissible to pass NULL for |out_result| if you just want to |
| - * check that the addition would not overflow. |
| - * |
| - * Returns false if the addition overflows, true otherwise. |
| - */ |
| -bool avb_safe_add(uint64_t* out_result, |
| - uint64_t a, |
| - uint64_t b) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| -/* Checks if |num_bytes| data at |data| is a valid UTF-8 |
| - * string. Returns true if valid UTF-8, false otherwise. |
| - */ |
| -bool avb_validate_utf8(const uint8_t* data, |
| - size_t num_bytes) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| -/* Concatenates |str1| (of |str1_len| bytes) and |str2| (of |str2_len| |
| - * bytes) and puts the result in |buf| which holds |buf_size| |
| - * bytes. The result is also guaranteed to be NUL terminated. Fail if |
| - * there is not enough room in |buf| for the resulting string plus |
| - * terminating NUL byte. |
| - * |
| - * Returns true if the operation succeeds, false otherwise. |
| - */ |
| -bool avb_str_concat(char* buf, |
| - size_t buf_size, |
| - const char* str1, |
| - size_t str1_len, |
| - const char* str2, |
| - size_t str2_len); |
| - |
| -/* Like avb_malloc_() but prints a error using avb_error() if memory |
| - * allocation fails. |
| - */ |
| -void* avb_malloc(size_t size) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| -/* Like avb_malloc() but sets the memory with zeroes. */ |
| -void* avb_calloc(size_t size) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| -/* Duplicates a NUL-terminated string. Returns NULL on OOM. */ |
| -char* avb_strdup(const char* str) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| -/* Duplicates a NULL-terminated array of NUL-terminated strings by |
| - * concatenating them. The returned string will be |
| - * NUL-terminated. Returns NULL on OOM. |
| - */ |
| -char* avb_strdupv(const char* str, |
| - ...) AVB_ATTR_WARN_UNUSED_RESULT AVB_ATTR_SENTINEL; |
| - |
| -/* Finds the first occurrence of |needle| in the string |haystack| |
| - * where both strings are NUL-terminated strings. The terminating NUL |
| - * bytes are not compared. |
| - * |
| - * Returns NULL if not found, otherwise points into |haystack| for the |
| - * first occurrence of |needle|. |
| - */ |
| -const char* avb_strstr(const char* haystack, |
| - const char* needle) AVB_ATTR_WARN_UNUSED_RESULT; |
| - |
| -/* Finds the first occurrence of |str| in the NULL-terminated string |
| - * array |strings|. Each element in |strings| must be |
| - * NUL-terminated. The string given by |str| need not be |
| - * NUL-terminated but its size must be given in |str_size|. |
| - * |
| - * Returns NULL if not found, otherwise points into |strings| for the |
| - * first occurrence of |str|. |
| - */ |
| -const char* avb_strv_find_str(const char* const* strings, |
| - const char* str, |
| - size_t str_size); |
| - |
| -/* Replaces all occurrences of |search| with |replace| in |str|. |
| - * |
| - * Returns a newly allocated string or NULL if out of memory. |
| - */ |
| -char* avb_replace(const char* str, |
| - const char* search, |
| - const char* replace) AVB_ATTR_WARN_UNUSED_RESULT; |
| +uint32_t avb_htobe32(uint32_t in); |
| |
| /* Calculates the CRC-32 for data in |buf| of size |buf_size|. */ |
| uint32_t avb_crc32(const uint8_t* buf, size_t buf_size); |
| |
| -/* Returns the basename of |str|. This is defined as the last path |
| - * component, assuming the normal POSIX separator '/'. If there are no |
| - * separators, returns |str|. |
| - */ |
| -const char* avb_basename(const char* str); |
| - |
| #ifdef __cplusplus |
| } |
| #endif |