utils.h File Reference

#include <stdint.h>
#include <stddef.h>

Go to the source code of this file.

Macros
#define	TO_UINT8_HEX_BUF_LEN   2048
#define	VARINT_LEN   20
#define	strlens(s)   (s == NULL ? 0 : strlen(s))

Functions
void	utils_clear_buffers (void)
void	utils_hex_to_bin (const char *str, unsigned char *out, int inLen, int *outLen)
void	utils_bin_to_hex (unsigned char *bin_in, size_t inlen, char *hex_out)
uint8_t *	utils_hex_to_uint8 (const char *str)
char *	utils_uint8_to_hex (const uint8_t *bin, size_t l)
void	utils_reverse_hex (char *h, int len)
void	utils_uint64_to_varint (char *vi, int *l, uint64_t i)
int	utils_varint_to_uint64 (const char *vi, uint64_t *i)

Macro Definition Documentation

#define strlens

(

s

)

(s == NULL ? 0 : strlen(s))

Definition at line 40 of file utils.h.

Referenced by btc_hd_generate_key(), and utils_hex_to_uint8().

#define TO_UINT8_HEX_BUF_LEN   2048

Definition at line 37 of file utils.h.

Referenced by utils_clear_buffers(), utils_hex_to_uint8(), and utils_uint8_to_hex().

#define VARINT_LEN   20

Definition at line 38 of file utils.h.

Referenced by utils_uint64_to_varint(), and utils_varint_to_uint64().

Function Documentation

void utils_bin_to_hex	(	unsigned char *	bin_in,
		size_t	inlen,
		char *	hex_out
	)

Definition at line 111 of file utils.c.

{
    static char digits[] = "0123456789abcdef";
    size_t i;
    for (i = 0; i < inlen; i++) {
        hex_out[i * 2] = digits[(bin_in[i] >> 4) & 0xF];
        hex_out[i * 2 + 1] = digits[bin_in[i] & 0xF];
    }
    hex_out[inlen * 2] = '\0';
}

void utils_clear_buffers

(

void

)

Definition at line 40 of file utils.c.

References buffer_hex_to_uint8, buffer_uint8_to_hex, and TO_UINT8_HEX_BUF_LEN.

{
    memset(buffer_hex_to_uint8, 0, TO_UINT8_HEX_BUF_LEN);
    memset(buffer_uint8_to_hex, 0, TO_UINT8_HEX_BUF_LEN);
}

void utils_hex_to_bin	(	const char *	str,
		unsigned char *	out,
		int	inLen,
		int *	outLen
	)

Definition at line 46 of file utils.c.

{
    int bLen = inLen / 2;
    memset(out, 0, bLen);
    uint8_t c;
    int i;
    for (i = 0; i < bLen; i++) {
        c = 0;
        if (str[i * 2] >= '0' && str[i * 2] <= '9') {
            *out = (str[i * 2] - '0') << 4;
        }
        if (str[i * 2] >= 'a' && str[i * 2] <= 'f') {
            *out = (10 + str[i * 2] - 'a') << 4;
        }
        if (str[i * 2] >= 'A' && str[i * 2] <= 'F') {
            *out = (10 + str[i * 2] - 'A') << 4;
        }
        if (str[i * 2 + 1] >= '0' && str[i * 2 + 1] <= '9') {
            *out |= (str[i * 2 + 1] - '0');
        }
        if (str[i * 2 + 1] >= 'a' && str[i * 2 + 1] <= 'f') {
            *out |= (10 + str[i * 2 + 1] - 'a');
        }
        if (str[i * 2 + 1] >= 'A' && str[i * 2 + 1] <= 'F') {
            *out |= (10 + str[i * 2 + 1] - 'A');
        }
        out++;
    }
    *outLen = i;
}

uint8_t* utils_hex_to_uint8

(

const char *

str

)

Definition at line 77 of file utils.c.

References buffer_hex_to_uint8, strlens, and TO_UINT8_HEX_BUF_LEN.

{
    if (strlens(str) > TO_UINT8_HEX_BUF_LEN) {
        return NULL;
    }
    memset(buffer_hex_to_uint8, 0, TO_UINT8_HEX_BUF_LEN);
    uint8_t c;
    size_t i;
    for (i = 0; i < strlens(str) / 2; i++) {
        c = 0;
        if (str[i * 2] >= '0' && str[i * 2] <= '9') {
            c += (str[i * 2] - '0') << 4;
        }
        if (str[i * 2] >= 'a' && str[i * 2] <= 'f') {
            c += (10 + str[i * 2] - 'a') << 4;
        }
        if (str[i * 2] >= 'A' && str[i * 2] <= 'F') {
            c += (10 + str[i * 2] - 'A') << 4;
        }
        if (str[i * 2 + 1] >= '0' && str[i * 2 + 1] <= '9') {
            c += (str[i * 2 + 1] - '0');
        }
        if (str[i * 2 + 1] >= 'a' && str[i * 2 + 1] <= 'f') {
            c += (10 + str[i * 2 + 1] - 'a');
        }
        if (str[i * 2 + 1] >= 'A' && str[i * 2 + 1] <= 'F') {
            c += (10 + str[i * 2 + 1] - 'A');
        }
        buffer_hex_to_uint8[i] = c;
    }
    return buffer_hex_to_uint8;
}

void utils_reverse_hex	(	char *	h,
		int	len
	)

Definition at line 140 of file utils.c.

References const_buffer::len.

Referenced by utils_uint64_to_varint(), and utils_varint_to_uint64().

{
    char copy[len];
    strncpy(copy, h, len);
    int i;
    for (i = 0; i < len; i += 2) {
        h[i] = copy[len - i - 2];
        h[i + 1] = copy[len - i - 1];
    }
}

void utils_uint64_to_varint	(	char *	vi,
		int *	l,
		uint64_t	i
	)

Definition at line 152 of file utils.c.

References const_buffer::len, utils_reverse_hex(), and VARINT_LEN.

{
    int len;
    char v[VARINT_LEN];

    if (i < 0xfd) {
        sprintf(v, "%02" PRIx64, i);
        len = 2;
    } else if (i <= 0xffff) {
        sprintf(v, "%04" PRIx64, i);
        sprintf(vi, "fd");
        len = 4;
    } else if (i <= 0xffffffff) {
        sprintf(v, "%08" PRIx64, i);
        sprintf(vi, "fe");
        len = 8;
    } else {
        sprintf(v, "%016" PRIx64, i);
        sprintf(vi, "ff");
        len = 16;
    }

    /* reverse order */
    if (len > 2) {
        utils_reverse_hex(v, len);
        strncat(vi, v, len);
    } else {
        strncpy(vi, v, len);
    }

    *l = len;
}

char* utils_uint8_to_hex	(	const uint8_t *	bin,
		size_t	l
	)

Definition at line 123 of file utils.c.

References buffer_uint8_to_hex, and TO_UINT8_HEX_BUF_LEN.

{
    if (l > (TO_UINT8_HEX_BUF_LEN / 2 - 1)) {
        return NULL;
    }
    static char digits[] = "0123456789abcdef";
    memset(buffer_uint8_to_hex, 0, TO_UINT8_HEX_BUF_LEN);
    size_t i;
    for (i = 0; i < l; i++) {
        buffer_uint8_to_hex[i * 2] = digits[(bin[i] >> 4) & 0xF];
        buffer_uint8_to_hex[i * 2 + 1] = digits[bin[i] & 0xF];
    }
    buffer_uint8_to_hex[l * 2] = '\0';
    return buffer_uint8_to_hex;
}

int utils_varint_to_uint64	(	const char *	vi,
		uint64_t *	i
	)

Definition at line 186 of file utils.c.

References const_buffer::len, utils_reverse_hex(), and VARINT_LEN.

{
    char v[VARINT_LEN] = {0};
    int len;

    if (!vi) {
        len = 0;
    } else if (!strncmp(vi, "ff", 2)) {
        len = 16;
    } else if (!strncmp(vi, "fe", 2)) {
        len = 8;
    } else if (!strncmp(vi, "fd", 2)) {
        len = 4;
    } else {
        len = 2;
    }

    if (len == 0) {
        /* continue */
    } else if (len > 2) {
        strncpy(v, vi + 2, len);
        utils_reverse_hex(v, len);
    } else {
        strncpy(v, vi, len);
    }
    *i = strtoull(v, NULL, 16);

    return len;
}