File Coverage

_hex.c

Criterion	Covered	Total	%
statement	74	93	79.5
branch	49	72	68.0
condition			n/a
subroutine			n/a
pod			n/a
total	123	165	74.5

/* hex.c - conversion for hexadecimal and base32 strings.
 *
 * Copyright (c) 2008, Aleksey Kravchenko
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE  INCLUDING ALL IMPLIED WARRANTIES OF  MERCHANTABILITY
 * AND FITNESS.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT,  OR CONSEQUENTIAL DAMAGES  OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE,  DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT,  NEGLIGENCE
 * OR OTHER TORTIOUS ACTION,  ARISING OUT OF  OR IN CONNECTION  WITH THE USE  OR
 * PERFORMANCE OF THIS SOFTWARE.
 */
#include "hex.h"
#include
#include
#include

/**
 * Store hexadecimal representation of a binary string to given buffer.
 *
 * @param dst the buffer to receive hexadecimal representation
 * @param src binary string
 * @param length string length
 * @param upper_case flag to print string in uppercase
 */
void rhash_byte_to_hex(char* dst, const unsigned char* src, size_t length, int upper_case)
{
	const char hex_add = (upper_case ? 'A' - 10 : 'a' - 10);
	for (; length > 0; src++, length--) {
		const unsigned char hi = (*src >> 4) & 15;
		const unsigned char lo = *src & 15;
		*dst++ = (hi > 9 ? hi + hex_add : hi + '0');
		*dst++ = (lo > 9 ? lo + hex_add : lo + '0');
	}
	*dst = '\0';
}

/**
 * Encode a binary string to base32.
 *
 * @param dst the buffer to store result
 * @param src binary string
 * @param length string length
 * @param upper_case flag to print string in uppercase
 */
void rhash_byte_to_base32(char* dst, const unsigned char* src, size_t length, int upper_case)
{
	const char a = (upper_case ? 'A' : 'a');
	unsigned shift = 0;
	unsigned char word;
	const unsigned char* e = src + length;
	while (src < e) {
		if (shift > 3) {
			word = (*src & (0xFF >> shift));
			shift = (shift + 5) % 8;
			word <<= shift;
			if (src + 1 < e)
				word |= *(src + 1) >> (8 - shift);
			++src;
		} else {
			shift = (shift + 5) % 8;
			word = ( *src >> ( (8 - shift) & 7 ) ) & 0x1F;
			if (shift == 0) src++;
		}
		*dst++ = ( word < 26 ? word + a : word + '2' - 26 );
	}
	*dst = '\0';
}

/**
 * Encode a binary string to base64.
 * Encoded output length is always a multiple of 4 bytes.
 *
 * @param dst the buffer to store result
 * @param src binary string
 * @param length string length
 */
void rhash_byte_to_base64(char* dst, const unsigned char* src, size_t length)
{
	static const char* tail = "0123456789+/";
	unsigned shift = 0;
	unsigned char word;
	const unsigned char* e = src + length;
	while (src < e) {
		if (shift > 2) {
			word = (*src & (0xFF >> shift));
			shift = (shift + 6) % 8;
			word <<= shift;
			if (src + 1 < e)
				word |= *(src + 1) >> (8 - shift);
			++src;
		} else {
			shift = (shift + 6) % 8;
			word = ( *src >> ( (8 - shift) & 7 ) ) & 0x3F;
			if (shift == 0) src++;
		}
		*dst++ = ( word < 52 ? (word < 26 ? word + 'A' : word - 26 + 'a') : tail[word - 52]);
	}
	if (shift > 0) {
		*dst++ = '=';
		if (shift == 4) *dst++ = '=';
	}
	*dst = '\0';
}

size_t rhash_base64_url_encoded_helper(char* dst, const unsigned char* src, size_t length, int url_encode, int upper_case)
{
#define B64_CHUNK_SIZE 120
	char buffer[164];
	assert((BASE64_LENGTH(B64_CHUNK_SIZE) + 4) <= sizeof(buffer));
	assert((B64_CHUNK_SIZE % 6) == 0);
	if (url_encode) {
		size_t result_length = 0;
		for (; length > 0; src += B64_CHUNK_SIZE) {
			size_t chunk_size = (length < B64_CHUNK_SIZE ? length : B64_CHUNK_SIZE);
			size_t encoded_length;
			rhash_byte_to_base64(buffer, src, chunk_size);
			encoded_length = rhash_urlencode(dst, buffer, BASE64_LENGTH(chunk_size), upper_case);
			result_length += encoded_length;
			dst += encoded_length;
			length -= chunk_size;
		}
		return result_length;
	}
	rhash_byte_to_base64(dst, src, length);
	return BASE64_LENGTH(length);
}

/* RFC 3986: safe url characters are ascii alpha-numeric and "-._~", other characters should be percent-encoded */
static unsigned url_safe_char_mask[4] = { 0, 0x03ff6000, 0x87fffffe, 0x47fffffe };
#define IS_URL_GOOD_CHAR(c) ((unsigned)(c) < 128 && (url_safe_char_mask[c >> 5] & (1 << (c & 31))))

/**
 * URL-encode specified binary string.
 *
 * @param dst (nullable) buffer to output encoded string to,
 *            NULL to just calculate the lengths of encoded string
 * @param src binary string to encode
 * @param size size of the binary string
 * @param upper_case flag to output hex-codes in uppercase
 * @return the length of the result string
 */
size_t rhash_urlencode(char* dst, const char* src, size_t size, int upper_case)
{
	const char* start;
	size_t i;
	if (!dst) {
		size_t length = size;
		for (i = 0; i < size; i++)
			if (!IS_URL_GOOD_CHAR(src[i]))
				length += 2;
		return length;
	} else {
		const char hex_add = (upper_case ? 'A' - 10 : 'a' - 10);
		start = dst;
		/* percent-encode all but unreserved URL characters */
		for (i = 0; i < size; i++) {
			if (IS_URL_GOOD_CHAR(src[i])) {
				*dst++ = src[i];
			} else {
				unsigned char hi = ((unsigned char)(src[i]) >> 4) & 0x0f;
				unsigned char lo = (unsigned char)(src[i]) & 0x0f;
				*dst++ = '%';
				*dst++ = (hi > 9 ? hi + hex_add : hi + '0');
				*dst++ = (lo > 9 ? lo + hex_add : lo + '0');
			}
		}
		*dst = 0;
	}
	return dst - start;
}

/**
 * Print 64-bit number with trailing '\0' to a string buffer.
 * if dst is NULL, then just return the length of the number.
 *
 * @param dst output buffer
 * @param number the number to print
 * @return length of the printed number (without trailing '\0')
 */
int rhash_sprintI64(char* dst, uint64_t number)
{
	/* The biggest number has 20 digits: 2^64 = 18 446 744 073 709 551 616 */
	char buf[24];
	char* p;
	size_t length;

	if (dst == NULL) {
		/* just calculate the length of the number */
		if (number == 0) return 1;
		for (length = 0; number != 0; number /= 10) length++;
		return (int)length;
	}

	p = buf + 23;
	*p = '\0'; /* last symbol should be '\0' */
	if (number == 0) {
		*(--p) = '0';
	} else {
		for (; p >= buf && number != 0; number /= 10) {
			*(--p) = '0' + (char)(number % 10);
		}
	}
	length = buf + 23 - p;
	memcpy(dst, p, length + 1);
	return (int)length;
}