[linux-2.6-block.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/errno.h>
#include <linux/string.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.  @buf should have room for
 * at least 9 bytes and will always be zero terminated.
 *
 */
void string_get_size(u64 size, const enum string_size_units units,
		     char *buf, int len)
{
	static const char *const units_10[] = {
		"B", "kB", "MB", "GB", "TB", "PB", "EB"
	};
	static const char *const units_2[] = {
		"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"
	};
	static const char *const *const 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;
	u32 remainder = 0, sf_cap;
	char tmp[8];

	tmp[0] = '\0';
	i = 0;
	if (size >= divisor[units]) {
		while (size >= divisor[units]) {
			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;
			remainder /= divisor[units];
			snprintf(tmp, sizeof(tmp), ".%03u", remainder);
			tmp[j+1] = '\0';
		}
	}

	snprintf(buf, len, "%u%s %s", (u32)size,
		 tmp, units_str[units][i]);
}
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;
}

/**
 * string_unescape - unquote characters in the given string
 * @src:	source buffer (escaped)
 * @dst:	destination buffer (unescaped)
 * @size:	size of the destination buffer (0 to unlimit)
 * @flags:	combination of the flags (bitwise OR):
 *	%UNESCAPE_SPACE:
 *		'\f' - form feed
 *		'\n' - new line
 *		'\r' - carriage return
 *		'\t' - horizontal tab
 *		'\v' - vertical tab
 *	%UNESCAPE_OCTAL:
 *		'\NNN' - byte with octal value NNN (1 to 3 digits)
 *	%UNESCAPE_HEX:
 *		'\xHH' - byte with hexadecimal value HH (1 to 2 digits)
 *	%UNESCAPE_SPECIAL:
 *		'\"' - double quote
 *		'\\' - backslash
 *		'\a' - alert (BEL)
 *		'\e' - escape
 *	%UNESCAPE_ANY:
 *		all previous together
 *
 * Description:
 * The function unquotes characters in the given string.
 *
 * Because the size of the output will be the same as or less than the size of
 * the input, the transformation may be performed in place.
 *
 * Caller must provide valid source and destination pointers. Be aware that
 * destination buffer will always be NULL-terminated. Source string must be
 * NULL-terminated as well.
 *
 * Return:
 * The amount of the characters processed to the destination buffer excluding
 * trailing '\0' is returned.
 */
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);

static bool escape_passthrough(unsigned char c, char **dst, char *end)
{
	char *out = *dst;

	if (out < end)
		*out = c;
	*dst = out + 1;
	return true;
}

static bool escape_space(unsigned char c, char **dst, char *end)
{
	char *out = *dst;
	unsigned char to;

	switch (c) {
	case '\n':
		to = 'n';
		break;
	case '\r':
		to = 'r';
		break;
	case '\t':
		to = 't';
		break;
	case '\v':
		to = 'v';
		break;
	case '\f':
		to = 'f';
		break;
	default:
		return false;
	}

	if (out < end)
		*out = '\\';
	++out;
	if (out < end)
		*out = to;
	++out;

	*dst = out;
	return true;
}

static bool escape_special(unsigned char c, char **dst, char *end)
{
	char *out = *dst;
	unsigned char to;

	switch (c) {
	case '\\':
		to = '\\';
		break;
	case '\a':
		to = 'a';
		break;
	case '\e':
		to = 'e';
		break;
	default:
		return false;
	}

	if (out < end)
		*out = '\\';
	++out;
	if (out < end)
		*out = to;
	++out;

	*dst = out;
	return true;
}

static bool escape_null(unsigned char c, char **dst, char *end)
{
	char *out = *dst;

	if (c)
		return false;

	if (out < end)
		*out = '\\';
	++out;
	if (out < end)
		*out = '0';
	++out;

	*dst = out;
	return true;
}

static bool escape_octal(unsigned char c, char **dst, char *end)
{
	char *out = *dst;

	if (out < end)
		*out = '\\';
	++out;
	if (out < end)
		*out = ((c >> 6) & 0x07) + '0';
	++out;
	if (out < end)
		*out = ((c >> 3) & 0x07) + '0';
	++out;
	if (out < end)
		*out = ((c >> 0) & 0x07) + '0';
	++out;

	*dst = out;
	return true;
}

static bool escape_hex(unsigned char c, char **dst, char *end)
{
	char *out = *dst;

	if (out < end)
		*out = '\\';
	++out;
	if (out < end)
		*out = 'x';
	++out;
	if (out < end)
		*out = hex_asc_hi(c);
	++out;
	if (out < end)
		*out = hex_asc_lo(c);
	++out;

	*dst = out;
	return true;
}

/**
 * string_escape_mem - quote characters in the given memory buffer
 * @src:	source buffer (unescaped)
 * @isz:	source buffer size
 * @dst:	destination buffer (escaped)
 * @osz:	destination buffer size
 * @flags:	combination of the flags (bitwise OR):
 *	%ESCAPE_SPACE:
 *		'\f' - form feed
 *		'\n' - new line
 *		'\r' - carriage return
 *		'\t' - horizontal tab
 *		'\v' - vertical tab
 *	%ESCAPE_SPECIAL:
 *		'\\' - backslash
 *		'\a' - alert (BEL)
 *		'\e' - escape
 *	%ESCAPE_NULL:
 *		'\0' - null
 *	%ESCAPE_OCTAL:
 *		'\NNN' - byte with octal value NNN (3 digits)
 *	%ESCAPE_ANY:
 *		all previous together
 *	%ESCAPE_NP:
 *		escape only non-printable characters (checked by isprint)
 *	%ESCAPE_ANY_NP:
 *		all previous together
 *	%ESCAPE_HEX:
 *		'\xHH' - byte with hexadecimal value HH (2 digits)
 * @esc:	NULL-terminated string of characters any of which, if found in
 *		the source, has to be escaped
 *
 * Description:
 * The process of escaping byte buffer includes several parts. They are applied
 * in the following sequence.
 *	1. The character is matched to the printable class, if asked, and in
 *	   case of match it passes through to the output.
 *	2. The character is not matched to the one from @esc string and thus
 *	   must go as is to the output.
 *	3. The character is checked if it falls into the class given by @flags.
 *	   %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
 *	   character. Note that they actually can't go together, otherwise
 *	   %ESCAPE_HEX will be ignored.
 *
 * Caller must provide valid source and destination pointers. Be aware that
 * destination buffer will not be NULL-terminated, thus caller have to append
 * it if needs.
 *
 * Return:
 * The total size of the escaped output that would be generated for
 * the given input and flags. To check whether the output was
 * truncated, compare the return value to osz. There is room left in
 * dst for a '\0' terminator if and only if ret < osz.
 */
int string_escape_mem(const char *src, size_t isz, char *dst, size_t osz,
		      unsigned int flags, const char *esc)
{
	char *p = dst;
	char *end = p + osz;
	bool is_dict = esc && *esc;

	while (isz--) {
		unsigned char c = *src++;

		/*
		 * Apply rules in the following sequence:
		 *	- the character is printable, when @flags has
		 *	  %ESCAPE_NP bit set
		 *	- the @esc string is supplied and does not contain a
		 *	  character under question
		 *	- the character doesn't fall into a class of symbols
		 *	  defined by given @flags
		 * In these cases we just pass through a character to the
		 * output buffer.
		 */
		if ((flags & ESCAPE_NP && isprint(c)) ||
		    (is_dict && !strchr(esc, c))) {
			/* do nothing */
		} else {
			if (flags & ESCAPE_SPACE && escape_space(c, &p, end))
				continue;

			if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end))
				continue;

			if (flags & ESCAPE_NULL && escape_null(c, &p, end))
				continue;

			/* ESCAPE_OCTAL and ESCAPE_HEX always go last */
			if (flags & ESCAPE_OCTAL && escape_octal(c, &p, end))
				continue;

			if (flags & ESCAPE_HEX && escape_hex(c, &p, end))
				continue;
		}

		escape_passthrough(c, &p, end);
	}

	return p - dst;
}
EXPORT_SYMBOL(string_escape_mem);
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>
c8250381 AS	11	#include <linux/errno.h>
c8250381 AS	12	#include <linux/string.h>
3c9f3681 JB	13	#include <linux/string_helpers.h>
	14
	15	/**
	16	* string_get_size - get the size in the specified units
	17	* @size: The size to be converted
	18	* @units: units to use (powers of 1000 or 1024)
	19	* @buf: buffer to format to
	20	* @len: length of buffer
	21	*
	22	* This function returns a string formatted to 3 significant figures
d1214c65 RV	23	* giving the size in the required units. @buf should have room for
d1214c65 RV	24	* at least 9 bytes and will always be zero terminated.
3c9f3681 JB	25	*
3c9f3681 JB	26	*/
d1214c65 RV	27	void string_get_size(u64 size, const enum string_size_units units,
d1214c65 RV	28	char *buf, int len)
3c9f3681	29	{
142cda5d	30	static const char *const units_10[] = {
7eed8fde	31	"B", "kB", "MB", "GB", "TB", "PB", "EB"
142cda5d MK	32	};
142cda5d MK	33	static const char *const units_2[] = {
7eed8fde	34	"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"
142cda5d MK	35	};
	36	static const char const const units_str[] = {
	37	[STRING_UNITS_10] = units_10,
3c9f3681 JB	38	[STRING_UNITS_2] = units_2,
3c9f3681 JB	39	};
68aecfb9	40	static const unsigned int divisor[] = {
3c9f3681 JB	41	[STRING_UNITS_10] = 1000,
	42	[STRING_UNITS_2] = 1024,
	43	};
	44	int i, j;
84b9fbed	45	u32 remainder = 0, sf_cap;
3c9f3681 JB	46	char tmp[8];
	47
	48	tmp[0] = '\0';
a8659597 PA	49	i = 0;
a8659597 PA	50	if (size >= divisor[units]) {
7eed8fde	51	while (size >= divisor[units]) {
a8659597 PA	52	remainder = do_div(size, divisor[units]);
	53	i++;
	54	}
3c9f3681	55
a8659597 PA	56	sf_cap = size;
	57	for (j = 0; sf_cap*10 < 1000; j++)
	58	sf_cap *= 10;
3c9f3681	59
a8659597 PA	60	if (j) {
a8659597 PA	61	remainder *= 1000;
84b9fbed RV	62	remainder /= divisor[units];
84b9fbed RV	63	snprintf(tmp, sizeof(tmp), ".%03u", remainder);
a8659597 PA	64	tmp[j+1] = '\0';
a8659597 PA	65	}
3c9f3681 JB	66	}
3c9f3681 JB	67
84b9fbed	68	snprintf(buf, len, "%u%s %s", (u32)size,
3c9f3681	69	tmp, units_str[units][i]);
3c9f3681 JB	70	}
3c9f3681 JB	71	EXPORT_SYMBOL(string_get_size);
16c7fa05 AS	72
	73	static bool unescape_space(char src, char dst)
	74	{
	75	char p = dst, q = src;
	76
	77	switch (*q) {
	78	case 'n':
	79	*p = '\n';
	80	break;
	81	case 'r':
	82	*p = '\r';
	83	break;
	84	case 't':
	85	*p = '\t';
	86	break;
	87	case 'v':
	88	*p = '\v';
	89	break;
	90	case 'f':
	91	*p = '\f';
	92	break;
	93	default:
	94	return false;
	95	}
	96	*dst += 1;
	97	*src += 1;
	98	return true;
	99	}
	100
	101	static bool unescape_octal(char src, char dst)
	102	{
	103	char p = dst, q = src;
	104	u8 num;
	105
	106	if (isodigit(*q) == 0)
	107	return false;
	108
	109	num = (*q++) & 7;
	110	while (num < 32 && isodigit(q) && (q - src < 3)) {
	111	num <<= 3;
	112	num += (*q++) & 7;
	113	}
	114	*p = num;
	115	*dst += 1;
	116	*src = q;
	117	return true;
	118	}
	119
	120	static bool unescape_hex(char src, char dst)
	121	{
	122	char p = dst, q = src;
	123	int digit;
	124	u8 num;
	125
	126	if (*q++ != 'x')
	127	return false;
	128
	129	num = digit = hex_to_bin(*q++);
	130	if (digit < 0)
	131	return false;
	132
	133	digit = hex_to_bin(*q);
	134	if (digit >= 0) {
	135	q++;
136	num = (num << 4) \| digit;
137	}
138	*p = num;
139	*dst += 1;
140	*src = q;
141	return true;
142	}
143
144	static bool unescape_special(char src, char dst)
145	{
146	char p = dst, q = src;
147
148	switch (*q) {
149	case '\"':
150	*p = '\"';
151	break;
152	case '\\':
153	*p = '\\';
154	break;
155	case 'a':
156	*p = '\a';
157	break;
158	case 'e':
159	*p = '\e';
160	break;
161	default:
162	return false;
163	}
164	*dst += 1;
165	*src += 1;
166	return true;
167	}
168
d295634e AS	169	/**
	170	* string_unescape - unquote characters in the given string
	171	* @src: source buffer (escaped)
	172	* @dst: destination buffer (unescaped)
	173	* @size: size of the destination buffer (0 to unlimit)
	174	* @flags: combination of the flags (bitwise OR):
	175	* %UNESCAPE_SPACE:
	176	* '\f' - form feed
	177	* '\n' - new line
	178	* '\r' - carriage return
	179	* '\t' - horizontal tab
	180	* '\v' - vertical tab
	181	* %UNESCAPE_OCTAL:
	182	* '\NNN' - byte with octal value NNN (1 to 3 digits)
	183	* %UNESCAPE_HEX:
	184	* '\xHH' - byte with hexadecimal value HH (1 to 2 digits)
	185	* %UNESCAPE_SPECIAL:
	186	* '\"' - double quote
	187	* '\\' - backslash
	188	* '\a' - alert (BEL)
	189	* '\e' - escape
	190	* %UNESCAPE_ANY:
	191	* all previous together
	192	*
	193	* Description:
	194	* The function unquotes characters in the given string.
	195	*
	196	* Because the size of the output will be the same as or less than the size of
	197	* the input, the transformation may be performed in place.
	198	*
	199	* Caller must provide valid source and destination pointers. Be aware that
	200	* destination buffer will always be NULL-terminated. Source string must be
	201	* NULL-terminated as well.
	202	*
	203	* Return:
	204	* The amount of the characters processed to the destination buffer excluding
	205	* trailing '\0' is returned.
	206	*/
16c7fa05 AS	207	int string_unescape(char src, char dst, size_t size, unsigned int flags)
	208	{
	209	char *out = dst;
	210
	211	while (*src && --size) {
	212	if (src[0] == '\\' && src[1] != '\0' && size > 1) {
	213	src++;
	214	size--;
	215
	216	if (flags & UNESCAPE_SPACE &&
	217	unescape_space(&src, &out))
	218	continue;
	219
	220	if (flags & UNESCAPE_OCTAL &&
	221	unescape_octal(&src, &out))
	222	continue;
	223
	224	if (flags & UNESCAPE_HEX &&
	225	unescape_hex(&src, &out))
	226	continue;
	227
	228	if (flags & UNESCAPE_SPECIAL &&
	229	unescape_special(&src, &out))
	230	continue;
	231
	232	*out++ = '\\';
	233	}
	234	out++ = src++;
	235	}
	236	*out = '\0';
	237
	238	return out - dst;
	239	}
	240	EXPORT_SYMBOL(string_unescape);
c8250381	241
3aeddc7d	242	static bool escape_passthrough(unsigned char c, char *dst, char end)
c8250381 AS	243	{
	244	char out = dst;
	245
3aeddc7d RV	246	if (out < end)
	247	*out = c;
	248	*dst = out + 1;
	249	return true;
c8250381 AS	250	}
c8250381 AS	251
3aeddc7d	252	static bool escape_space(unsigned char c, char *dst, char end)
c8250381 AS	253	{
	254	char out = dst;
	255	unsigned char to;
	256
c8250381 AS	257	switch (c) {
	258	case '\n':
	259	to = 'n';
	260	break;
	261	case '\r':
	262	to = 'r';
	263	break;
	264	case '\t':
	265	to = 't';
	266	break;
	267	case '\v':
	268	to = 'v';
	269	break;
	270	case '\f':
	271	to = 'f';
	272	break;
	273	default:
3aeddc7d	274	return false;
c8250381 AS	275	}
c8250381 AS	276
3aeddc7d RV	277	if (out < end)
	278	*out = '\\';
	279	++out;
	280	if (out < end)
	281	*out = to;
	282	++out;
c8250381	283
3aeddc7d RV	284	*dst = out;
3aeddc7d RV	285	return true;
c8250381 AS	286	}
c8250381 AS	287
3aeddc7d	288	static bool escape_special(unsigned char c, char *dst, char end)
c8250381 AS	289	{
	290	char out = dst;
	291	unsigned char to;
	292
c8250381 AS	293	switch (c) {
	294	case '\\':
	295	to = '\\';
	296	break;
	297	case '\a':
	298	to = 'a';
	299	break;
	300	case '\e':
	301	to = 'e';
	302	break;
	303	default:
3aeddc7d	304	return false;
c8250381 AS	305	}
c8250381 AS	306
3aeddc7d RV	307	if (out < end)
	308	*out = '\\';
	309	++out;
	310	if (out < end)
	311	*out = to;
	312	++out;
c8250381	313
3aeddc7d RV	314	*dst = out;
3aeddc7d RV	315	return true;
c8250381 AS	316	}
c8250381 AS	317
3aeddc7d	318	static bool escape_null(unsigned char c, char *dst, char end)
c8250381 AS	319	{
	320	char out = dst;
	321
c8250381	322	if (c)
3aeddc7d	323	return false;
c8250381	324
3aeddc7d RV	325	if (out < end)
	326	*out = '\\';
	327	++out;
	328	if (out < end)
	329	*out = '0';
	330	++out;
c8250381	331
3aeddc7d RV	332	*dst = out;
3aeddc7d RV	333	return true;
c8250381 AS	334	}
c8250381 AS	335
3aeddc7d	336	static bool escape_octal(unsigned char c, char *dst, char end)
c8250381 AS	337	{
	338	char out = dst;
	339
3aeddc7d RV	340	if (out < end)
	341	*out = '\\';
	342	++out;
	343	if (out < end)
	344	*out = ((c >> 6) & 0x07) + '0';
	345	++out;
	346	if (out < end)
	347	*out = ((c >> 3) & 0x07) + '0';
	348	++out;
	349	if (out < end)
	350	*out = ((c >> 0) & 0x07) + '0';
	351	++out;
c8250381 AS	352
c8250381 AS	353	*dst = out;
3aeddc7d	354	return true;
c8250381 AS	355	}
c8250381 AS	356
3aeddc7d	357	static bool escape_hex(unsigned char c, char *dst, char end)
c8250381 AS	358	{
	359	char out = dst;
	360
3aeddc7d RV	361	if (out < end)
	362	*out = '\\';
	363	++out;
	364	if (out < end)
	365	*out = 'x';
	366	++out;
	367	if (out < end)
	368	*out = hex_asc_hi(c);
	369	++out;
	370	if (out < end)
	371	*out = hex_asc_lo(c);
	372	++out;
c8250381 AS	373
c8250381 AS	374	*dst = out;
3aeddc7d	375	return true;
c8250381 AS	376	}
	377
	378	/**
	379	* string_escape_mem - quote characters in the given memory buffer
	380	* @src: source buffer (unescaped)
	381	* @isz: source buffer size
	382	* @dst: destination buffer (escaped)
	383	* @osz: destination buffer size
	384	* @flags: combination of the flags (bitwise OR):
	385	* %ESCAPE_SPACE:
	386	* '\f' - form feed
	387	* '\n' - new line
	388	* '\r' - carriage return
	389	* '\t' - horizontal tab
	390	* '\v' - vertical tab
	391	* %ESCAPE_SPECIAL:
	392	* '\\' - backslash
	393	* '\a' - alert (BEL)
	394	* '\e' - escape
	395	* %ESCAPE_NULL:
	396	* '\0' - null
	397	* %ESCAPE_OCTAL:
	398	* '\NNN' - byte with octal value NNN (3 digits)
	399	* %ESCAPE_ANY:
	400	* all previous together
	401	* %ESCAPE_NP:
	402	* escape only non-printable characters (checked by isprint)
	403	* %ESCAPE_ANY_NP:
	404	* all previous together
	405	* %ESCAPE_HEX:
	406	* '\xHH' - byte with hexadecimal value HH (2 digits)
	407	* @esc: NULL-terminated string of characters any of which, if found in
	408	* the source, has to be escaped
	409	*
	410	* Description:
	411	* The process of escaping byte buffer includes several parts. They are applied
	412	* in the following sequence.
	413	* 1. The character is matched to the printable class, if asked, and in
	414	* case of match it passes through to the output.
	415	* 2. The character is not matched to the one from @esc string and thus
	416	* must go as is to the output.
	417	* 3. The character is checked if it falls into the class given by @flags.
	418	* %ESCAPE_OCTAL and %ESCAPE_HEX are going last since they cover any
	419	* character. Note that they actually can't go together, otherwise
	420	* %ESCAPE_HEX will be ignored.
	421	*
	422	* Caller must provide valid source and destination pointers. Be aware that
	423	* destination buffer will not be NULL-terminated, thus caller have to append
	424	* it if needs.
	425	*
	426	* Return:
41416f23 RV	427	* The total size of the escaped output that would be generated for
	428	* the given input and flags. To check whether the output was
	429	* truncated, compare the return value to osz. There is room left in
	430	* dst for a '\0' terminator if and only if ret < osz.
c8250381	431	*/
41416f23	432	int string_escape_mem(const char src, size_t isz, char dst, size_t osz,
c8250381 AS	433	unsigned int flags, const char *esc)
c8250381 AS	434	{
41416f23	435	char *p = dst;
3aeddc7d	436	char *end = p + osz;
c8250381	437	bool is_dict = esc && *esc;
c8250381 AS	438
	439	while (isz--) {
	440	unsigned char c = *src++;
	441
	442	/*
	443	* Apply rules in the following sequence:
	444	* - the character is printable, when @flags has
	445	* %ESCAPE_NP bit set
	446	* - the @esc string is supplied and does not contain a
	447	* character under question
	448	* - the character doesn't fall into a class of symbols
	449	* defined by given @flags
	450	* In these cases we just pass through a character to the
	451	* output buffer.
	452	*/
	453	if ((flags & ESCAPE_NP && isprint(c)) \|\|
	454	(is_dict && !strchr(esc, c))) {
	455	/* do nothing */
	456	} else {
3aeddc7d RV	457	if (flags & ESCAPE_SPACE && escape_space(c, &p, end))
	458	continue;
	459
	460	if (flags & ESCAPE_SPECIAL && escape_special(c, &p, end))
	461	continue;
	462
	463	if (flags & ESCAPE_NULL && escape_null(c, &p, end))
	464	continue;
c8250381 AS	465
c8250381 AS	466	/* ESCAPE_OCTAL and ESCAPE_HEX always go last */
3aeddc7d	467	if (flags & ESCAPE_OCTAL && escape_octal(c, &p, end))
c8250381	468	continue;
3aeddc7d RV	469
3aeddc7d RV	470	if (flags & ESCAPE_HEX && escape_hex(c, &p, end))
c8250381	471	continue;
c8250381 AS	472	}
c8250381 AS	473
3aeddc7d	474	escape_passthrough(c, &p, end);
c8250381 AS	475	}
c8250381 AS	476
41416f23	477	return p - dst;
c8250381 AS	478	}
c8250381 AS	479	EXPORT_SYMBOL(string_escape_mem);