[linux.git] / lib / string_helpers.c

/*
 * Helpers for formatting and printing strings
 *
 * Copyright 31 August 2008 James Bottomley
 * Copyright (C) 2013, Intel Corporation
 */
#include <linux/kernel.h>
#include <linux/math64.h>
#include <linux/export.h>
#include <linux/ctype.h>
#include <linux/string_helpers.h>

/**
 * string_get_size - get the size in the specified units
 * @size:	The size to be converted
 * @units:	units to use (powers of 1000 or 1024)
 * @buf:	buffer to format to
 * @len:	length of buffer
 *
 * This function returns a string formatted to 3 significant figures
 * giving the size in the required units.  Returns 0 on success or
 * error on failure.  @buf is always zero terminated.
 *
 */
int string_get_size(u64 size, const enum string_size_units units,
		    char *buf, int len)
{
	static const char *units_10[] = { "B", "kB", "MB", "GB", "TB", "PB",
				   "EB", "ZB", "YB", NULL};
	static const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB",
				 "EiB", "ZiB", "YiB", NULL };
	static const char **units_str[] = {
		[STRING_UNITS_10] =  units_10,
		[STRING_UNITS_2] = units_2,
	};
	static const unsigned int divisor[] = {
		[STRING_UNITS_10] = 1000,
		[STRING_UNITS_2] = 1024,
	};
	int i, j;
	u64 remainder = 0, sf_cap;
	char tmp[8];

	tmp[0] = '\0';
	i = 0;
	if (size >= divisor[units]) {
		while (size >= divisor[units] && units_str[units][i]) {
			remainder = do_div(size, divisor[units]);
			i++;
		}

		sf_cap = size;
		for (j = 0; sf_cap*10 < 1000; j++)
			sf_cap *= 10;

		if (j) {
			remainder *= 1000;
			do_div(remainder, divisor[units]);
			snprintf(tmp, sizeof(tmp), ".%03lld",
				 (unsigned long long)remainder);
			tmp[j+1] = '\0';
		}
	}

	snprintf(buf, len, "%lld%s %s", (unsigned long long)size,
		 tmp, units_str[units][i]);

	return 0;
}
EXPORT_SYMBOL(string_get_size);

static bool unescape_space(char **src, char **dst)
{
	char *p = *dst, *q = *src;

	switch (*q) {
	case 'n':
		*p = '\n';
		break;
	case 'r':
		*p = '\r';
		break;
	case 't':
		*p = '\t';
		break;
	case 'v':
		*p = '\v';
		break;
	case 'f':
		*p = '\f';
		break;
	default:
		return false;
	}
	*dst += 1;
	*src += 1;
	return true;
}

static bool unescape_octal(char **src, char **dst)
{
	char *p = *dst, *q = *src;
	u8 num;

	if (isodigit(*q) == 0)
		return false;

	num = (*q++) & 7;
	while (num < 32 && isodigit(*q) && (q - *src < 3)) {
		num <<= 3;
		num += (*q++) & 7;
	}
	*p = num;
	*dst += 1;
	*src = q;
	return true;
}

static bool unescape_hex(char **src, char **dst)
{
	char *p = *dst, *q = *src;
	int digit;
	u8 num;

	if (*q++ != 'x')
		return false;

	num = digit = hex_to_bin(*q++);
	if (digit < 0)
		return false;

	digit = hex_to_bin(*q);
	if (digit >= 0) {
		q++;
		num = (num << 4) | digit;
	}
	*p = num;
	*dst += 1;
	*src = q;
	return true;
}

static bool unescape_special(char **src, char **dst)
{
	char *p = *dst, *q = *src;

	switch (*q) {
	case '\"':
		*p = '\"';
		break;
	case '\\':
		*p = '\\';
		break;
	case 'a':
		*p = '\a';
		break;
	case 'e':
		*p = '\e';
		break;
	default:
		return false;
	}
	*dst += 1;
	*src += 1;
	return true;
}

int string_unescape(char *src, char *dst, size_t size, unsigned int flags)
{
	char *out = dst;

	while (*src && --size) {
		if (src[0] == '\\' && src[1] != '\0' && size > 1) {
			src++;
			size--;

			if (flags & UNESCAPE_SPACE &&
					unescape_space(&src, &out))
				continue;

			if (flags & UNESCAPE_OCTAL &&
					unescape_octal(&src, &out))
				continue;

			if (flags & UNESCAPE_HEX &&
					unescape_hex(&src, &out))
				continue;

			if (flags & UNESCAPE_SPECIAL &&
					unescape_special(&src, &out))
				continue;

			*out++ = '\\';
		}
		*out++ = *src++;
	}
	*out = '\0';

	return out - dst;
}
EXPORT_SYMBOL(string_unescape);
Commit	Line	Data
3c9f3681 JB	1	/*
	2	* Helpers for formatting and printing strings
	3	*
	4	* Copyright 31 August 2008 James Bottomley
16c7fa05	5	* Copyright (C) 2013, Intel Corporation
3c9f3681 JB	6	*/
	7	#include <linux/kernel.h>
	8	#include <linux/math64.h>
8bc3bcc9	9	#include <linux/export.h>
16c7fa05	10	#include <linux/ctype.h>
3c9f3681 JB	11	#include <linux/string_helpers.h>
	12
	13	/**
	14	* string_get_size - get the size in the specified units
	15	* @size: The size to be converted
	16	* @units: units to use (powers of 1000 or 1024)
	17	* @buf: buffer to format to
	18	* @len: length of buffer
	19	*
	20	* This function returns a string formatted to 3 significant figures
	21	* giving the size in the required units. Returns 0 on success or
	22	* error on failure. @buf is always zero terminated.
	23	*
	24	*/
	25	int string_get_size(u64 size, const enum string_size_units units,
	26	char *buf, int len)
	27	{
68aecfb9	28	static const char *units_10[] = { "B", "kB", "MB", "GB", "TB", "PB",
3c9f3681	29	"EB", "ZB", "YB", NULL};
68aecfb9	30	static const char *units_2[] = {"B", "KiB", "MiB", "GiB", "TiB", "PiB",
3c9f3681	31	"EiB", "ZiB", "YiB", NULL };
68aecfb9	32	static const char **units_str[] = {
3c9f3681 JB	33	[STRING_UNITS_10] = units_10,
	34	[STRING_UNITS_2] = units_2,
	35	};
68aecfb9	36	static const unsigned int divisor[] = {
3c9f3681 JB	37	[STRING_UNITS_10] = 1000,
	38	[STRING_UNITS_2] = 1024,
	39	};
	40	int i, j;
	41	u64 remainder = 0, sf_cap;
	42	char tmp[8];
	43
	44	tmp[0] = '\0';
a8659597 PA	45	i = 0;
	46	if (size >= divisor[units]) {
	47	while (size >= divisor[units] && units_str[units][i]) {
	48	remainder = do_div(size, divisor[units]);
	49	i++;
	50	}
3c9f3681	51
a8659597 PA	52	sf_cap = size;
	53	for (j = 0; sf_cap*10 < 1000; j++)
	54	sf_cap *= 10;
3c9f3681	55
a8659597 PA	56	if (j) {
	57	remainder *= 1000;
	58	do_div(remainder, divisor[units]);
	59	snprintf(tmp, sizeof(tmp), ".%03lld",
	60	(unsigned long long)remainder);
	61	tmp[j+1] = '\0';
	62	}
3c9f3681 JB	63	}
3c9f3681 JB	64
a8659597	65	snprintf(buf, len, "%lld%s %s", (unsigned long long)size,
3c9f3681 JB	66	tmp, units_str[units][i]);
	67
	68	return 0;
	69	}
	70	EXPORT_SYMBOL(string_get_size);
16c7fa05 AS	71
	72	static bool unescape_space(char src, char dst)
	73	{
	74	char p = dst, q = src;
	75
	76	switch (*q) {
	77	case 'n':
	78	*p = '\n';
	79	break;
	80	case 'r':
	81	*p = '\r';
	82	break;
	83	case 't':
	84	*p = '\t';
	85	break;
	86	case 'v':
	87	*p = '\v';
	88	break;
	89	case 'f':
	90	*p = '\f';
	91	break;
	92	default:
	93	return false;
	94	}
	95	*dst += 1;
	96	*src += 1;
	97	return true;
	98	}
	99
	100	static bool unescape_octal(char src, char dst)
	101	{
	102	char p = dst, q = src;
	103	u8 num;
	104
	105	if (isodigit(*q) == 0)
	106	return false;
	107
	108	num = (*q++) & 7;
	109	while (num < 32 && isodigit(q) && (q - src < 3)) {
	110	num <<= 3;
	111	num += (*q++) & 7;
	112	}
	113	*p = num;
	114	*dst += 1;
	115	*src = q;
	116	return true;
	117	}
	118
	119	static bool unescape_hex(char src, char dst)
	120	{
	121	char p = dst, q = src;
	122	int digit;
	123	u8 num;
	124
	125	if (*q++ != 'x')
	126	return false;
	127
	128	num = digit = hex_to_bin(*q++);
	129	if (digit < 0)
	130	return false;
	131
	132	digit = hex_to_bin(*q);
	133	if (digit >= 0) {
	134	q++;
135	num = (num << 4) \| digit;
136	}
137	*p = num;
138	*dst += 1;
139	*src = q;
140	return true;
141	}
142
143	static bool unescape_special(char src, char dst)
144	{
145	char p = dst, q = src;
146
147	switch (*q) {
148	case '\"':
149	*p = '\"';
150	break;
151	case '\\':
152	*p = '\\';
153	break;
154	case 'a':
155	*p = '\a';
156	break;
157	case 'e':
158	*p = '\e';
159	break;
160	default:
161	return false;
162	}
163	*dst += 1;
164	*src += 1;
165	return true;
166	}
167
168	int string_unescape(char src, char dst, size_t size, unsigned int flags)
169	{
170	char *out = dst;
171
172	while (*src && --size) {
173	if (src[0] == '\\' && src[1] != '\0' && size > 1) {
174	src++;
175	size--;
176
177	if (flags & UNESCAPE_SPACE &&
178	unescape_space(&src, &out))
179	continue;
180
181	if (flags & UNESCAPE_OCTAL &&
182	unescape_octal(&src, &out))
183	continue;
184
185	if (flags & UNESCAPE_HEX &&
186	unescape_hex(&src, &out))
187	continue;
188
189	if (flags & UNESCAPE_SPECIAL &&
190	unescape_special(&src, &out))
191	continue;
192
193	*out++ = '\\';
194	}
195	out++ = src++;
196	}
197	*out = '\0';
198
199	return out - dst;
200	}
201	EXPORT_SYMBOL(string_unescape);