[apple/syslog.git] / libsystem_asl.tproj / src / asl_string.c

/*
 * Copyright (c) 2007-2013 Apple Inc.  All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */

#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <asl.h>
#include <string.h>
#include <mach/kern_return.h>
#include <mach/mach_init.h>
#include <mach/mach_vm.h>
#include <mach/vm_map.h>
#include <mach/vm_param.h>
#include <libkern/OSAtomic.h>
#include <asl_string.h>
#include <asl_private.h>

#define ASL_STRING_QUANTUM 256
static const char *cvis_7_13 = "abtnvfr";

asl_string_t *
asl_string_new(uint32_t encoding)
{
	asl_string_t *str = (asl_string_t *)calloc(1, sizeof(asl_string_t));
	if (str == NULL) return NULL;

	str->asl_type = ASL_TYPE_STRING;
	str->refcount = 1;

	str->encoding = encoding;
	str->delta = ASL_STRING_QUANTUM;
	if (encoding & ASL_STRING_VM) str->delta = PAGE_SIZE;
	str->bufsize = 0;
	str->cursor = 0;

	if (encoding & ASL_STRING_LEN) asl_string_append_no_encoding(str, "         0 ");
	return str;
}

asl_string_t *
asl_string_retain(asl_string_t *str)
{
	if (str == NULL) return NULL;

	OSAtomicIncrement32Barrier(&(str->refcount));
	return str;
}

void
asl_string_release(asl_string_t *str)
{
	if (str == NULL) return;
	if (OSAtomicDecrement32Barrier(&(str->refcount)) != 0) return;

	if (str->encoding & ASL_STRING_VM)
	{
		vm_deallocate(mach_task_self(), (vm_address_t)str->buf, str->bufsize);
	}
	else
	{
		free(str->buf);
	}

	free(str);
}

char *
asl_string_release_return_bytes(asl_string_t *str)
{
	char *out;
	if (str == NULL) return NULL;

	if (OSAtomicDecrement32Barrier(&(str->refcount)) != 0)
	{
		/* string is still retained - copy buf */
		if (str->encoding & ASL_STRING_VM)
		{
			if (str->bufsize == 0) return NULL;

			vm_address_t new = 0;
			kern_return_t kstatus = vm_allocate(mach_task_self(), &new, str->bufsize, TRUE);
			if (kstatus != KERN_SUCCESS) return NULL;

			memcpy((void *)new, str->buf, str->bufsize);
			return (char *)new;
		}
		else
		{
			if (str->cursor == 0) return NULL;
			return strdup(str->buf);
		}
	}

	out = str->buf;
	free(str);
	return out;
}

char *
asl_string_bytes(asl_string_t *str)
{
	if (str == NULL) return NULL;
	return str->buf;
}

/* length includes trailing nul */
size_t
asl_string_length(asl_string_t *str)
{
	if (str == NULL) return 0;
	if (str->cursor == 0) return 0;

	return str->cursor + 1;
}

size_t
asl_string_allocated_size(asl_string_t *str)
{
	if (str == NULL) return 0;
	return str->bufsize;
}

static int
_asl_string_grow(asl_string_t *str, size_t len)
{
	size_t newlen = 0;

	if (str == NULL) return -1;
	if (len == 0) return 0;

	if (str->bufsize == 0)
	{
		newlen = ((len + str->delta - 1) / str->delta) * str->delta;
	}
	else
	{
		/* used size is (str->cursor + 1) including tailiing nul */
		if (len <= (str->bufsize - (str->cursor + 1))) return 0;

		/* really this is ((str->cursor + 1) + len + (str->delta - 1)) */
		newlen = ((str->cursor + len + str->delta) / str->delta) * str->delta;
	}

	if (str->encoding & ASL_STRING_VM)
	{
		kern_return_t kstatus;
		vm_address_t new = 0;

		kstatus = vm_allocate(mach_task_self(), &new, newlen, TRUE);
		if (kstatus != KERN_SUCCESS)
		{
			new = 0;
			newlen = 0;
			return -1;
		}

		if (str->buf != NULL)
		{
			memcpy((void *)new, str->buf, str->bufsize);
			vm_deallocate(mach_task_self(), (vm_address_t)str->buf, str->bufsize);
		}

		str->buf = (char *)new;
		str->bufsize = newlen;
	}
	else
	{
		str->buf = reallocf(str->buf, newlen);
		if (str->buf == NULL)
		{
			str->cursor = 0;
			str->bufsize = 0;
			return -1;
		}

		str->bufsize = newlen;
	}

	return 0;
}

asl_string_t *
asl_string_append_char_no_encoding(asl_string_t *str, const char c)
{
	size_t len;

	if (str == NULL) return NULL;

	len = 1;
	if (str->bufsize == 0) len++;

	if (_asl_string_grow(str, len) < 0) return str;

	str->buf[str->cursor] = c;
	str->cursor++;
	str->buf[str->cursor] = '\0';

	if (str->encoding & ASL_STRING_LEN)
	{
		char tmp[11];
		snprintf(tmp, sizeof(tmp), "%10lu", str->cursor - 10);
		memcpy(str->buf, tmp, 10);
	}

	return str;
}

asl_string_t *
asl_string_append_no_encoding(asl_string_t *str, const char *app)
{
	size_t len, applen;

	if (str == NULL) return NULL;
	if (app == NULL) return str;

	applen = strlen(app);
	len = applen;
	if (str->bufsize == 0) len++;

	if (_asl_string_grow(str, len) < 0) return str;

	memcpy(str->buf + str->cursor, app, applen);

	str->cursor += applen;
	str->buf[str->cursor] = '\0';

	if (str->encoding & ASL_STRING_LEN)
	{
		char tmp[11];
		snprintf(tmp, sizeof(tmp), "%10lu", str->cursor - 10);
		memcpy(str->buf, tmp, 10);
	}

	return str;
}

static asl_string_t *
asl_string_append_internal(asl_string_t *str, const char *app, int encode_space)
{
	uint8_t x;
	const char *p;

	if (str == NULL) return NULL;
	if (app == NULL) return str;

	switch (str->encoding & ASL_ENCODE_MASK)
	{
		case ASL_ENCODE_NONE:
		{
			return asl_string_append_no_encoding(str, app);
		}
		case ASL_ENCODE_SAFE:
		{
			/* minor encoding to reduce the likelyhood of spoof attacks */
			const char *p;

			for (p = app; *p != '\0'; p++)
			{
				if ((*p == 10) || (*p == 13))
				{
					asl_string_append_no_encoding(str, "\n\t");
				}
				else if (*p == 8)
				{
					asl_string_append_no_encoding(str, "^H");
				}
				else
				{
					asl_string_append_char_no_encoding(str, *p);
				}
			}

			return str;
		}
		case ASL_ENCODE_ASL:
		{
			for (p = app; *p != '\0'; p++)
			{
				int meta = 0;

				x = *p;

				/* Meta chars get \M prefix */
				if (x >= 128)
				{
					/* except meta-space, which is \240 */
					if (x == 160)
					{
						asl_string_append_no_encoding(str, "\\240");
						continue;
					}

					asl_string_append_no_encoding(str, "\\M");
					x &= 0x7f;
					meta = 1;
				}

				/* space is either ' ' or \s */
				if (x == 32)
				{
					if (encode_space == 0)
					{
						asl_string_append_char_no_encoding(str, ' ');
						continue;
					}

					asl_string_append_no_encoding(str, "\\s");
					continue;
				}

				/* \ is escaped */
				if ((meta == 0) && (x == 92))
				{
					asl_string_append_no_encoding(str, "\\\\");
					continue;
				}

				/* [ and ] are escaped in ASL encoding */
				if ((str->encoding & ASL_ENCODE_ASL) && (meta == 0) && ((*p == 91) || (*p == 93)))
				{
					if (*p == '[') asl_string_append_no_encoding(str, "\\[");
					else asl_string_append_no_encoding(str, "\\]");
					continue;
				}

				/* DEL is \^? */
				if (x == 127)
				{
					if (meta == 0)
					{
						asl_string_append_char_no_encoding(str, '\\');
					}

					asl_string_append_no_encoding(str, "^?");
					continue;
				}

				/* 33-126 are printable (add a '-' prefix for meta) */
				if ((x >= 33) && (x <= 126))
				{
					if (meta == 1)
					{
						asl_string_append_char_no_encoding(str, '-');
					}

					asl_string_append_char_no_encoding(str, x);
					continue;
				}

				/* non-meta BEL, BS, HT, NL, VT, NP, CR (7-13) are \a, \b, \t, \n, \v, \f, and \r */
				if ((meta == 0) && (x >= 7) && (x <= 13))
				{
					asl_string_append_char_no_encoding(str, '\\');
					asl_string_append_char_no_encoding(str, cvis_7_13[x - 7]);
					continue;
				}

				/* 0 - 31 are ^@ - ^_ (non-meta get a leading \) */
				if (x <= 31)
				{
					if (meta == 0)
					{
						asl_string_append_char_no_encoding(str, '\\');
					}

					asl_string_append_char_no_encoding(str, '^');
					asl_string_append_char_no_encoding(str, 64 + x);
					continue;
				}

				asl_string_append_char_no_encoding(str, x);
			}

			return str;
		}
		case ASL_ENCODE_XML:
		{
			for (p = app; *p != '\0'; p++)
			{
				x = *p;

				if (x == '&')
				{
					asl_string_append_no_encoding(str, "&amp;");
				}
				else if (x == '<')
				{
					asl_string_append_no_encoding(str, "&lt;");
				}
				else if (x == '>')
				{
					asl_string_append_no_encoding(str, "&gt;");
				}
				else if (x == '"')
				{
					asl_string_append_no_encoding(str, "&quot;");
				}
				else if (x == '\'')
				{
					asl_string_append_no_encoding(str, "&apos;");
				}
				else if (iscntrl(x))
				{
					char tmp[8];
					snprintf(tmp, sizeof(tmp), "&#x%02hhx;", x);
					asl_string_append_no_encoding(str, tmp);
				}
				else
				{
					asl_string_append_char_no_encoding(str, x);
				}
			}
		}
		default:
		{
			return str;
		}
	}

	return str;
}

asl_string_t *
asl_string_append(asl_string_t *str, const char *app)
{
	return asl_string_append_internal(str, app, 0);
}

asl_string_t *
asl_string_append_asl_key(asl_string_t *str, const char *app)
{
	return asl_string_append_internal(str, app, 1);
}

asl_string_t *
asl_string_append_op(asl_string_t *str, uint32_t op)
{
	char opstr[8];
	uint32_t i;

	if (str == NULL) return NULL;

	if (op == ASL_QUERY_OP_NULL)
	{
		return asl_string_append_char_no_encoding(str, '.');
	}

	i = 0;
	if (op & ASL_QUERY_OP_CASEFOLD) opstr[i++] = 'C';

	if (op & ASL_QUERY_OP_REGEX) opstr[i++] = 'R';

	if (op & ASL_QUERY_OP_NUMERIC) opstr[i++] = 'N';

	if (op & ASL_QUERY_OP_PREFIX)
	{
		if (op & ASL_QUERY_OP_SUFFIX) opstr[i++] = 'S';
		else opstr[i++] = 'A';
	}
	if (op & ASL_QUERY_OP_SUFFIX) opstr[i++] = 'Z';

	switch (op & ASL_QUERY_OP_TRUE)
	{
		case ASL_QUERY_OP_EQUAL:
			opstr[i++] = '=';
			break;
		case ASL_QUERY_OP_GREATER:
			opstr[i++] = '>';
			break;
		case ASL_QUERY_OP_GREATER_EQUAL:
			opstr[i++] = '>';
			opstr[i++] = '=';
			break;
		case ASL_QUERY_OP_LESS:
			opstr[i++] = '<';
			break;
		case ASL_QUERY_OP_LESS_EQUAL:
			opstr[i++] = '<';
			opstr[i++] = '=';
			break;
		case ASL_QUERY_OP_NOT_EQUAL:
			opstr[i++] = '!';
			break;
		case ASL_QUERY_OP_TRUE:
			opstr[i++] = 'T';
			break;
		default:
			break;
	}

	if (i == 0)
	{
		return asl_string_append_char_no_encoding(str, '.');
	}

	opstr[i] = '\0';
	return asl_string_append_no_encoding(str, opstr);
}

asl_string_t *
asl_string_append_xml_tag(asl_string_t *str, const char *tag, const char *s)
{
	asl_string_append_no_encoding(str, "\t\t<");
	asl_string_append_no_encoding(str, tag);
	asl_string_append_no_encoding(str, ">");
	asl_string_append_internal(str, s, 0);
	asl_string_append_no_encoding(str, "</");
	asl_string_append_no_encoding(str, tag);
	asl_string_append_no_encoding(str, ">\n");
	return str;
}
Commit	Line	Data
f3df4c03 A	1	/*
	2	* Copyright (c) 2007-2013 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23
	24	#include <ctype.h>
	25	#include <stdlib.h>
	26	#include <stdio.h>
	27	#include <asl.h>
	28	#include <string.h>
	29	#include <mach/kern_return.h>
	30	#include <mach/mach_init.h>
	31	#include <mach/mach_vm.h>
	32	#include <mach/vm_map.h>
	33	#include <mach/vm_param.h>
	34	#include <libkern/OSAtomic.h>
	35	#include <asl_string.h>
	36	#include <asl_private.h>
	37
	38	#define ASL_STRING_QUANTUM 256
	39	static const char *cvis_7_13 = "abtnvfr";
	40
	41	asl_string_t *
	42	asl_string_new(uint32_t encoding)
	43	{
	44	asl_string_t str = (asl_string_t )calloc(1, sizeof(asl_string_t));
	45	if (str == NULL) return NULL;
	46
	47	str->asl_type = ASL_TYPE_STRING;
	48	str->refcount = 1;
	49
	50	str->encoding = encoding;
	51	str->delta = ASL_STRING_QUANTUM;
	52	if (encoding & ASL_STRING_VM) str->delta = PAGE_SIZE;
	53	str->bufsize = 0;
	54	str->cursor = 0;
	55
	56	if (encoding & ASL_STRING_LEN) asl_string_append_no_encoding(str, " 0 ");
	57	return str;
	58	}
	59
	60	asl_string_t *
	61	asl_string_retain(asl_string_t *str)
	62	{
	63	if (str == NULL) return NULL;
	64
65	OSAtomicIncrement32Barrier(&(str->refcount));
66	return str;
67	}
68
69	void
70	asl_string_release(asl_string_t *str)
71	{
72	if (str == NULL) return;
73	if (OSAtomicDecrement32Barrier(&(str->refcount)) != 0) return;
74
75	if (str->encoding & ASL_STRING_VM)
76	{
77	vm_deallocate(mach_task_self(), (vm_address_t)str->buf, str->bufsize);
78	}
79	else
80	{
81	free(str->buf);
82	}
83
84	free(str);
85	}
86
87	char *
88	asl_string_release_return_bytes(asl_string_t *str)
89	{
90	char *out;
91	if (str == NULL) return NULL;
92
93	if (OSAtomicDecrement32Barrier(&(str->refcount)) != 0)
94	{
95	/* string is still retained - copy buf */
96	if (str->encoding & ASL_STRING_VM)
97	{
98	if (str->bufsize == 0) return NULL;
99
100	vm_address_t new = 0;
101	kern_return_t kstatus = vm_allocate(mach_task_self(), &new, str->bufsize, TRUE);
102	if (kstatus != KERN_SUCCESS) return NULL;
103
104	memcpy((void *)new, str->buf, str->bufsize);
105	return (char *)new;
106	}
107	else
108	{
109	if (str->cursor == 0) return NULL;
110	return strdup(str->buf);
111	}
112	}
113
114	out = str->buf;
115	free(str);
116	return out;
117	}
118
119	char *
120	asl_string_bytes(asl_string_t *str)
121	{
122	if (str == NULL) return NULL;
123	return str->buf;
124	}
125
126	/* length includes trailing nul */
127	size_t
128	asl_string_length(asl_string_t *str)
129	{
130	if (str == NULL) return 0;
131	if (str->cursor == 0) return 0;
132
133	return str->cursor + 1;
134	}
135
136	size_t
137	asl_string_allocated_size(asl_string_t *str)
138	{
139	if (str == NULL) return 0;
140	return str->bufsize;
141	}
142
143	static int
144	_asl_string_grow(asl_string_t *str, size_t len)
145	{
146	size_t newlen = 0;
147
148	if (str == NULL) return -1;
149	if (len == 0) return 0;
150
151	if (str->bufsize == 0)
152	{
153	newlen = ((len + str->delta - 1) / str->delta) * str->delta;
154	}
155	else
156	{
157	/* used size is (str->cursor + 1) including tailiing nul */
158	if (len <= (str->bufsize - (str->cursor + 1))) return 0;
159
160	/* really this is ((str->cursor + 1) + len + (str->delta - 1)) */
161	newlen = ((str->cursor + len + str->delta) / str->delta) * str->delta;
162	}
163
164	if (str->encoding & ASL_STRING_VM)
165	{
166	kern_return_t kstatus;
167	vm_address_t new = 0;
168
169	kstatus = vm_allocate(mach_task_self(), &new, newlen, TRUE);
170	if (kstatus != KERN_SUCCESS)
171	{
172	new = 0;
173	newlen = 0;
174	return -1;
175	}
176
177	if (str->buf != NULL)
178	{
179	memcpy((void *)new, str->buf, str->bufsize);
180	vm_deallocate(mach_task_self(), (vm_address_t)str->buf, str->bufsize);
181	}
182
183	str->buf = (char *)new;
184	str->bufsize = newlen;
185	}
186	else
187	{
188	str->buf = reallocf(str->buf, newlen);
189	if (str->buf == NULL)
190	{
191	str->cursor = 0;
192	str->bufsize = 0;
193	return -1;
194	}
195
196	str->bufsize = newlen;
197	}
198
199	return 0;
200	}
201
202	asl_string_t *
203	asl_string_append_char_no_encoding(asl_string_t *str, const char c)
204	{
205	size_t len;
206
207	if (str == NULL) return NULL;
208
209	len = 1;
210	if (str->bufsize == 0) len++;
211
212	if (_asl_string_grow(str, len) < 0) return str;
213
214	str->buf[str->cursor] = c;
215	str->cursor++;
216	str->buf[str->cursor] = '\0';
217
218	if (str->encoding & ASL_STRING_LEN)
219	{
220	char tmp[11];
221	snprintf(tmp, sizeof(tmp), "%10lu", str->cursor - 10);
222	memcpy(str->buf, tmp, 10);
223	}
224
225	return str;
226	}
227
228	asl_string_t *
229	asl_string_append_no_encoding(asl_string_t str, const char app)
230	{
231	size_t len, applen;
232
233	if (str == NULL) return NULL;
234	if (app == NULL) return str;
235
236	applen = strlen(app);
237	len = applen;
238	if (str->bufsize == 0) len++;
239
240	if (_asl_string_grow(str, len) < 0) return str;
241
242	memcpy(str->buf + str->cursor, app, applen);
243
244	str->cursor += applen;
245	str->buf[str->cursor] = '\0';
246
247	if (str->encoding & ASL_STRING_LEN)
248	{
249	char tmp[11];
250	snprintf(tmp, sizeof(tmp), "%10lu", str->cursor - 10);
251	memcpy(str->buf, tmp, 10);
252	}
253
254	return str;
255	}
256
257	static asl_string_t *
258	asl_string_append_internal(asl_string_t str, const char app, int encode_space)
259	{
260	uint8_t x;
261	const char *p;
262
263	if (str == NULL) return NULL;
264	if (app == NULL) return str;
265
266	switch (str->encoding & ASL_ENCODE_MASK)
267	{
268	case ASL_ENCODE_NONE:
269	{
270	return asl_string_append_no_encoding(str, app);
271	}
272	case ASL_ENCODE_SAFE:
273	{
274	/* minor encoding to reduce the likelyhood of spoof attacks */
275	const char *p;
276
277	for (p = app; *p != '\0'; p++)
278	{
279	if ((p == 10) \|\| (p == 13))
280	{
281	asl_string_append_no_encoding(str, "\n\t");
282	}
283	else if (*p == 8)
284	{
285	asl_string_append_no_encoding(str, "^H");
286	}
287	else
288	{
289	asl_string_append_char_no_encoding(str, *p);
290	}
291	}
292
293	return str;
294	}
295	case ASL_ENCODE_ASL:
296	{
297	for (p = app; *p != '\0'; p++)
298	{
299	int meta = 0;
300
301	x = *p;
302
303	/* Meta chars get \M prefix */
304	if (x >= 128)
305	{
306	/* except meta-space, which is \240 */
307	if (x == 160)
308	{
309	asl_string_append_no_encoding(str, "\\240");
310	continue;
311	}
312
313	asl_string_append_no_encoding(str, "\\M");
314	x &= 0x7f;
315	meta = 1;
316	}
317
318	/* space is either ' ' or \s */
319	if (x == 32)
320	{
321	if (encode_space == 0)
322	{
323	asl_string_append_char_no_encoding(str, ' ');
324	continue;
325	}
326
327	asl_string_append_no_encoding(str, "\\s");
328	continue;
329	}
330
331	/* \ is escaped */
332	if ((meta == 0) && (x == 92))
333	{
334	asl_string_append_no_encoding(str, "\\\\");
335	continue;
336	}
337
338	/* [ and ] are escaped in ASL encoding */
339	if ((str->encoding & ASL_ENCODE_ASL) && (meta == 0) && ((p == 91) \|\| (p == 93)))
340	{
341	if (*p == '[') asl_string_append_no_encoding(str, "\\[");
342	else asl_string_append_no_encoding(str, "\\]");
343	continue;
344	}
345
346	/* DEL is \^? */
347	if (x == 127)
348	{
349	if (meta == 0)
350	{
351	asl_string_append_char_no_encoding(str, '\\');
352	}
353
354	asl_string_append_no_encoding(str, "^?");
355	continue;
356	}
357
358	/* 33-126 are printable (add a '-' prefix for meta) */
359	if ((x >= 33) && (x <= 126))
360	{
361	if (meta == 1)
362	{
363	asl_string_append_char_no_encoding(str, '-');
364	}
365
366	asl_string_append_char_no_encoding(str, x);
367	continue;
368	}
369
370	/* non-meta BEL, BS, HT, NL, VT, NP, CR (7-13) are \a, \b, \t, \n, \v, \f, and \r */
371	if ((meta == 0) && (x >= 7) && (x <= 13))
372	{
373	asl_string_append_char_no_encoding(str, '\\');
374	asl_string_append_char_no_encoding(str, cvis_7_13[x - 7]);
375	continue;
376	}
377
378	/* 0 - 31 are ^@ - ^_ (non-meta get a leading \) */
379	if (x <= 31)
380	{
381	if (meta == 0)
382	{
383	asl_string_append_char_no_encoding(str, '\\');
384	}
385
386	asl_string_append_char_no_encoding(str, '^');
387	asl_string_append_char_no_encoding(str, 64 + x);
388	continue;
389	}
390
391	asl_string_append_char_no_encoding(str, x);
392	}
393
394	return str;
395	}
396	case ASL_ENCODE_XML:
397	{
398	for (p = app; *p != '\0'; p++)
399	{
400	x = *p;
401
402	if (x == '&')
403	{
404	asl_string_append_no_encoding(str, "&");
405	}
406	else if (x == '<')
407	{
408	asl_string_append_no_encoding(str, "<");
409	}
410	else if (x == '>')
411	{
412	asl_string_append_no_encoding(str, ">");
413	}
414	else if (x == '"')
415	{
416	asl_string_append_no_encoding(str, """);
417	}
418	else if (x == '\'')
419	{
420	asl_string_append_no_encoding(str, "'");
421	}
422	else if (iscntrl(x))
423	{
424	char tmp[8];
425	snprintf(tmp, sizeof(tmp), "&#x%02hhx;", x);
426	asl_string_append_no_encoding(str, tmp);
427	}
428	else
429	{
430	asl_string_append_char_no_encoding(str, x);
431	}
432	}
433	}
434	default:
435	{
436	return str;
437	}
438	}
439
440	return str;
441	}
442
443	asl_string_t *
444	asl_string_append(asl_string_t str, const char app)
445	{
446	return asl_string_append_internal(str, app, 0);
447	}
448
449	asl_string_t *
450	asl_string_append_asl_key(asl_string_t str, const char app)
451	{
452	return asl_string_append_internal(str, app, 1);
453	}
454
455	asl_string_t *
456	asl_string_append_op(asl_string_t *str, uint32_t op)
457	{
458	char opstr[8];
459	uint32_t i;
460
461	if (str == NULL) return NULL;
462
463	if (op == ASL_QUERY_OP_NULL)
464	{
465	return asl_string_append_char_no_encoding(str, '.');
466	}
467
468	i = 0;
469	if (op & ASL_QUERY_OP_CASEFOLD) opstr[i++] = 'C';
470
471	if (op & ASL_QUERY_OP_REGEX) opstr[i++] = 'R';
472
473	if (op & ASL_QUERY_OP_NUMERIC) opstr[i++] = 'N';
474
475	if (op & ASL_QUERY_OP_PREFIX)
476	{
477	if (op & ASL_QUERY_OP_SUFFIX) opstr[i++] = 'S';
478	else opstr[i++] = 'A';
479	}
480	if (op & ASL_QUERY_OP_SUFFIX) opstr[i++] = 'Z';
481
482	switch (op & ASL_QUERY_OP_TRUE)
483	{
484	case ASL_QUERY_OP_EQUAL:
485	opstr[i++] = '=';
486	break;
487	case ASL_QUERY_OP_GREATER:
488	opstr[i++] = '>';
489	break;
490	case ASL_QUERY_OP_GREATER_EQUAL:
491	opstr[i++] = '>';
492	opstr[i++] = '=';
493	break;
494	case ASL_QUERY_OP_LESS:
495	opstr[i++] = '<';
496	break;
497	case ASL_QUERY_OP_LESS_EQUAL:
498	opstr[i++] = '<';
499	opstr[i++] = '=';
500	break;
501	case ASL_QUERY_OP_NOT_EQUAL:
502	opstr[i++] = '!';
503	break;
504	case ASL_QUERY_OP_TRUE:
505	opstr[i++] = 'T';
506	break;
507	default:
508	break;
509	}
510
511	if (i == 0)
512	{
513	return asl_string_append_char_no_encoding(str, '.');
514	}
515
516	opstr[i] = '\0';
517	return asl_string_append_no_encoding(str, opstr);
518	}
519
520	asl_string_t *
521	asl_string_append_xml_tag(asl_string_t str, const char tag, const char *s)
522	{
523	asl_string_append_no_encoding(str, "\t\t<");
524	asl_string_append_no_encoding(str, tag);
525	asl_string_append_no_encoding(str, ">");
526	asl_string_append_internal(str, s, 0);
527	asl_string_append_no_encoding(str, "</");
528	asl_string_append_no_encoding(str, tag);
529	asl_string_append_no_encoding(str, ">\n");
530	return str;
531	}
532