sol-util.h

Go to the documentation of this file.

/*
 * This file is part of the Soletta (TM) Project
 *
 * Copyright (C) 2015 Intel Corporation. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#pragma once

#include <sol-buffer.h>
#include <sol-str-slice.h>

#include <ctype.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <stdarg.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>

#ifdef __cplusplus
extern "C" {
#endif

#define sol_util_array_size(arr) (sizeof(arr) / sizeof((arr)[0]))

#define SOL_UTIL_NSEC_PER_SEC 1000000000ULL

#define SOL_UTIL_MSEC_PER_SEC 1000ULL

#define SOL_UTIL_USEC_PER_SEC 1000000ULL

#define SOL_UTIL_NSEC_PER_MSEC 1000000ULL

#define SOL_UTIL_NSEC_PER_USEC 1000ULL

#define sol_util_min(x, y) \
    ({ \
        __typeof__(x)_min1 = (x); \
        __typeof__(y)_min2 = (y); \
        (void)(&_min1 == &_min2); \
        _min1 < _min2 ? _min1 : _min2; \
    })

#define sol_util_max(x, y) \
    ({ \
        __typeof__(x)_max1 = (x); \
        __typeof__(y)_max2 = (y); \
        (void)(&_max1 == &_max2); \
        _max1 > _max2 ? _max1 : _max2; \
    })

struct timespec sol_util_timespec_get_current(void);

int sol_util_timespec_get_realtime(struct timespec *t);

static inline void
sol_util_timespec_add(const struct timespec *t1, const struct timespec *t2, struct timespec *result)
{
    result->tv_nsec = t1->tv_nsec + t2->tv_nsec;
    result->tv_sec = t1->tv_sec + t2->tv_sec;
    if ((unsigned long long)result->tv_nsec >= SOL_UTIL_NSEC_PER_SEC) {
        result->tv_nsec -= SOL_UTIL_NSEC_PER_SEC;
        result->tv_sec++;
    }
}

static inline void
sol_util_timespec_sub(const struct timespec *t1, const struct timespec *t2, struct timespec *result)
{
    result->tv_nsec = t1->tv_nsec - t2->tv_nsec;
    result->tv_sec = t1->tv_sec - t2->tv_sec;
    if (result->tv_nsec < 0) {
        result->tv_nsec += SOL_UTIL_NSEC_PER_SEC;
        result->tv_sec--;
    }
}

static inline int
sol_util_timespec_compare(const struct timespec *t1, const struct timespec *t2)
{
    int retval = (t1->tv_sec > t2->tv_sec) - (t1->tv_sec < t2->tv_sec);

    if (retval != 0)
        return retval;
    return (t1->tv_nsec > t2->tv_nsec) - (t1->tv_nsec < t2->tv_nsec);
}

static inline struct timespec
sol_util_timespec_from_msec(int msec)
{
    struct timespec ts;

    ts.tv_sec = msec / SOL_UTIL_MSEC_PER_SEC;
    ts.tv_nsec = (msec % SOL_UTIL_MSEC_PER_SEC) * SOL_UTIL_NSEC_PER_MSEC;
    return ts;
}

static inline struct timespec
sol_util_timespec_from_usec(int usec)
{
    struct timespec ts;

    ts.tv_sec = usec / SOL_UTIL_USEC_PER_SEC;
    ts.tv_nsec = (usec % SOL_UTIL_USEC_PER_SEC) * SOL_UTIL_NSEC_PER_USEC;
    return ts;
}

static inline int
sol_util_msec_from_timespec(const struct timespec *ts)
{
    return ts->tv_sec * SOL_UTIL_MSEC_PER_SEC + ts->tv_nsec / SOL_UTIL_NSEC_PER_MSEC;
}

static inline int
sol_util_usec_from_timespec(const struct timespec *ts)
{
    return ts->tv_sec * SOL_UTIL_USEC_PER_SEC + ts->tv_nsec / SOL_UTIL_NSEC_PER_USEC;
}

char *sol_util_strerror(int errnum, struct sol_buffer *buf);

#define sol_util_strerrora(errnum) \
    ({ \
        SOL_BUFFER_DECLARE_STATIC(buf ## __COUNT__, 512); \
        sol_util_strerror((errnum), &buf ## __COUNT__); \
    })

int sol_util_ssize_mul(ssize_t op1, ssize_t op2, ssize_t *out);

int sol_util_size_mul(size_t op1, size_t op2, size_t *out);

int sol_util_size_add(size_t op1, size_t op2, size_t *out);

int sol_util_size_sub(size_t op1, size_t op2, size_t *out);

int sol_util_uint64_mul(uint64_t op1, uint64_t op2, uint64_t *out);

int sol_util_int64_mul(int64_t op1, int64_t op2, int64_t *out);

int sol_util_uint64_add(uint64_t op1, uint64_t op2, uint64_t *out);

int sol_util_int32_mul(int32_t op1, int32_t op2, int32_t *out);

int sol_util_uint32_mul(uint32_t op1, uint32_t op2, uint32_t *out);

int sol_util_uuid_gen(bool uppercase, bool with_hyphens, struct sol_buffer *uuid_buf);

bool sol_util_uuid_str_is_valid(const struct sol_str_slice uuid);

int sol_util_uuid_string_from_bytes(bool uppercase, bool with_hyphens, const uint8_t uuid_bytes[SOL_STATIC_ARRAY_SIZE(16)], struct sol_buffer *uuid_str);

int sol_util_uuid_bytes_from_string(struct sol_str_slice uuid_str, struct sol_buffer *uuid_bytes);

static inline int32_t
sol_util_int32_clamp(int32_t start, int32_t end, int32_t value)
{
    if (value < start)
        return start;
    if (value > end)
        return end;
    return value;
}

int sol_util_replace_str_if_changed(char **str, const char *new_str);

int sol_util_replace_str_from_slice_if_changed(char **str, const struct sol_str_slice slice);

ssize_t sol_util_base64_encode(void *buf, size_t buflen, const struct sol_str_slice slice, const char base64_map[SOL_STATIC_ARRAY_SIZE(65)]);

ssize_t sol_util_base64_decode(void *buf, size_t buflen, const struct sol_str_slice slice, const char base64_map[SOL_STATIC_ARRAY_SIZE(65)]);

static inline ssize_t
sol_util_base64_calculate_encoded_len(const struct sol_str_slice slice, const char base64_map[SOL_STATIC_ARRAY_SIZE(65)])
{
    ssize_t req_len = slice.len / 3;
    int err;

    if (slice.len % 3 != 0)
        req_len++;
    err = sol_util_ssize_mul(req_len, 4, &req_len);
    if (err < 0)
        return err;
    return req_len;
}

ssize_t
sol_util_base64_calculate_decoded_len(const struct sol_str_slice slice, const char base64_map[SOL_STATIC_ARRAY_SIZE(65)]);

ssize_t sol_util_base16_encode(void *buf, size_t buflen, const struct sol_str_slice slice, bool uppercase);

ssize_t sol_util_base16_decode(void *buf, size_t buflen, const struct sol_str_slice slice, enum sol_decode_case decode_case);

int8_t sol_util_utf8_from_unicode_code(uint8_t *buf, size_t buf_len, uint32_t unicode_code);

int32_t sol_util_unicode_code_from_utf8(const uint8_t *buf, size_t buf_len, uint8_t *bytes_read);

static inline ssize_t
sol_util_base16_calculate_encoded_len(const struct sol_str_slice slice)
{
    ssize_t req_len;
    int err = sol_util_ssize_mul(slice.len, 2, &req_len);

    if (err < 0)
        return err;
    return req_len;
}

static inline ssize_t
sol_util_base16_calculate_decoded_len(const struct sol_str_slice slice)
{
    return slice.len / 2;
}

static inline void
sol_util_clear_memory_secure(void *buf, size_t len)
{
    memset(buf, 0, len);

    /* Clobber memory pointed to by `buf` to prevent the optimizer from
     * eliding the memset() call.  */
    __asm__ __volatile__ ("" : : "g" (buf) : "memory");
}

double sol_util_strtod_n(const char *nptr, char **endptr, ssize_t len, bool use_locale);

long int sol_util_strtol_n(const char *nptr, char **endptr, ssize_t len, int base);

unsigned long int sol_util_strtoul_n(const char *nptr, char **endptr, ssize_t len, int base);

#define sol_util_uint16_bytes_swap(val) \
    ((uint16_t)((((val) >> 8) & 0xff) | (((val) & 0xff) << 8)))

static inline uint16_t
sol_util_cpu_to_be16(uint16_t val)
{
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    return sol_util_uint16_bytes_swap(val);
#else
    return val;
#endif
}

static inline uint16_t
sol_util_cpu_to_le16(uint16_t val)
{
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
    return sol_util_uint16_bytes_swap(val);
#else
    return val;
#endif
}

static inline uint16_t
sol_util_be16_to_cpu(uint16_t val)
{
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    return sol_util_uint16_bytes_swap(val);
#else
    return val;
#endif
}

static inline uint16_t
sol_util_le16_to_cpu(uint16_t val)
{
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
    return sol_util_uint16_bytes_swap(val);
#else
    return val;
#endif
}

#define sol_util_uint32_bytes_swap(val) \
    ((uint32_t)((((val) & 0xff000000) >> 24) | (((val) & 0x00ff0000) >>  8) | \
    (((val) & 0x0000ff00) <<  8) | (((val) & 0x000000ff) << 24)))

static inline uint32_t
sol_util_cpu_to_be32(uint32_t val)
{
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    return sol_util_uint32_bytes_swap(val);
#else
    return val;
#endif
}

static inline uint32_t
sol_util_cpu_to_le32(uint32_t val)
{
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
    return sol_util_uint32_bytes_swap(val);
#else
    return val;
#endif
}

static inline uint32_t
sol_util_be32_to_cpu(uint32_t val)
{
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    return sol_util_uint32_bytes_swap(val);
#else
    return val;
#endif
}

static inline uint32_t
sol_util_le32_to_cpu(uint32_t val)
{
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
    return sol_util_uint32_bytes_swap(val);
#else
    return val;
#endif
}

#define sol_util_uint64_bytes_swap(val) \
    ((uint64_t)((((val) & 0xff00000000000000ull) >> 56) \
    | (((val) & 0x00ff000000000000ull) >> 40) | (((val) & 0x0000ff0000000000ull) >> 24) \
    | (((val) & 0x000000ff00000000ull) >> 8) | (((val) & 0x00000000ff000000ull) << 8) \
    | (((val) & 0x0000000000ff0000ull) << 24) | (((val) & 0x000000000000ff00ull) << 40) \
    | (((val) & 0x00000000000000ffull) << 56)))

static inline uint64_t
sol_util_cpu_to_be64(uint64_t val)
{
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    return sol_util_uint64_bytes_swap(val);
#else
    return val;
#endif
}

static inline uint64_t
sol_util_cpu_to_le64(uint64_t val)
{
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
    return sol_util_uint64_bytes_swap(val);
#else
    return val;
#endif
}

static inline uint64_t
sol_util_be64_to_cpu(uint64_t val)
{
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
    return sol_util_uint64_bytes_swap(val);
#else
    return val;
#endif
}

static inline uint64_t
sol_util_le64_to_cpu(uint64_t val)
{
#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
    return sol_util_uint64_bytes_swap(val);
#else
    return val;
#endif
}

int sol_util_unescape_quotes(const struct sol_str_slice slice, struct sol_buffer *buf);


ssize_t sol_util_strftime(struct sol_buffer *buf, const char *format, const struct tm *timeptr, bool use_locale) SOL_ATTR_STRFTIME(2);

bool sol_util_double_eq(double var0, double var1);

void *sol_util_memdup(const void *data, size_t len);

#ifdef __cplusplus
}
#endif