1  /*
2   * Generic XML helper functions
3   * Copyright (c) 2012-2013, Qualcomm Atheros, Inc.
4   *
5   * This software may be distributed under the terms of the BSD license.
6   * See README for more details.
7   */
8  
9  #include "includes.h"
10  
11  #include "common.h"
12  #include "xml-utils.h"
13  
14  
get_node_uri_iter(struct xml_node_ctx * ctx,xml_node_t * root,char * uri)15  static xml_node_t * get_node_uri_iter(struct xml_node_ctx *ctx,
16  				      xml_node_t *root, char *uri)
17  {
18  	char *end;
19  	xml_node_t *node;
20  	const char *name;
21  
22  	end = strchr(uri, '/');
23  	if (end)
24  		*end++ = '\0';
25  
26  	node = root;
27  	xml_node_for_each_sibling(ctx, node) {
28  		xml_node_for_each_check(ctx, node);
29  		name = xml_node_get_localname(ctx, node);
30  		if (strcasecmp(name, uri) == 0)
31  			break;
32  	}
33  
34  	if (node == NULL)
35  		return NULL;
36  
37  	if (end) {
38  		return get_node_uri_iter(ctx, xml_node_first_child(ctx, node),
39  					 end);
40  	}
41  
42  	return node;
43  }
44  
45  
get_node_uri(struct xml_node_ctx * ctx,xml_node_t * root,const char * uri)46  xml_node_t * get_node_uri(struct xml_node_ctx *ctx, xml_node_t *root,
47  			  const char *uri)
48  {
49  	char *search;
50  	xml_node_t *node;
51  
52  	search = os_strdup(uri);
53  	if (search == NULL)
54  		return NULL;
55  
56  	node = get_node_uri_iter(ctx, root, search);
57  
58  	os_free(search);
59  	return node;
60  }
61  
62  
get_node_iter(struct xml_node_ctx * ctx,xml_node_t * root,const char * path)63  static xml_node_t * get_node_iter(struct xml_node_ctx *ctx,
64  				  xml_node_t *root, const char *path)
65  {
66  	char *end;
67  	xml_node_t *node;
68  	const char *name;
69  
70  	end = os_strchr(path, '/');
71  	if (end)
72  		*end++ = '\0';
73  
74  	xml_node_for_each_child(ctx, node, root) {
75  		xml_node_for_each_check(ctx, node);
76  		name = xml_node_get_localname(ctx, node);
77  		if (os_strcasecmp(name, path) == 0)
78  			break;
79  	}
80  
81  	if (node == NULL)
82  		return NULL;
83  	if (end)
84  		return get_node_iter(ctx, node, end);
85  	return node;
86  }
87  
88  
get_node(struct xml_node_ctx * ctx,xml_node_t * root,const char * path)89  xml_node_t * get_node(struct xml_node_ctx *ctx, xml_node_t *root,
90  		      const char *path)
91  {
92  	char *search;
93  	xml_node_t *node;
94  
95  	search = os_strdup(path);
96  	if (search == NULL)
97  		return NULL;
98  
99  	node = get_node_iter(ctx, root, search);
100  
101  	os_free(search);
102  	return node;
103  }
104  
105  
get_child_node(struct xml_node_ctx * ctx,xml_node_t * root,const char * path)106  xml_node_t * get_child_node(struct xml_node_ctx *ctx, xml_node_t *root,
107  			    const char *path)
108  {
109  	xml_node_t *node;
110  	xml_node_t *match;
111  
112  	xml_node_for_each_child(ctx, node, root) {
113  		xml_node_for_each_check(ctx, node);
114  		match = get_node(ctx, node, path);
115  		if (match)
116  			return match;
117  	}
118  
119  	return NULL;
120  }
121  
122  
node_from_file(struct xml_node_ctx * ctx,const char * name)123  xml_node_t * node_from_file(struct xml_node_ctx *ctx, const char *name)
124  {
125  	xml_node_t *node;
126  	char *buf, *buf2, *start;
127  	size_t len;
128  
129  	buf = os_readfile(name, &len);
130  	if (buf == NULL)
131  		return NULL;
132  	buf2 = os_realloc(buf, len + 1);
133  	if (buf2 == NULL) {
134  		os_free(buf);
135  		return NULL;
136  	}
137  	buf = buf2;
138  	buf[len] = '\0';
139  
140  	start = os_strstr(buf, "<!DOCTYPE ");
141  	if (start) {
142  		char *pos = start + 1;
143  		int count = 1;
144  		while (*pos) {
145  			if (*pos == '<')
146  				count++;
147  			else if (*pos == '>') {
148  				count--;
149  				if (count == 0) {
150  					pos++;
151  					break;
152  				}
153  			}
154  			pos++;
155  		}
156  		if (count == 0) {
157  			/* Remove DOCTYPE to allow the file to be parsed */
158  			os_memset(start, ' ', pos - start);
159  		}
160  	}
161  
162  	node = xml_node_from_buf(ctx, buf);
163  	os_free(buf);
164  
165  	return node;
166  }
167  
168  
node_to_file(struct xml_node_ctx * ctx,const char * fname,xml_node_t * node)169  int node_to_file(struct xml_node_ctx *ctx, const char *fname, xml_node_t *node)
170  {
171  	FILE *f;
172  	char *str;
173  
174  	str = xml_node_to_str(ctx, node);
175  	if (str == NULL)
176  		return -1;
177  
178  	f = fopen(fname, "w");
179  	if (!f) {
180  		os_free(str);
181  		return -1;
182  	}
183  
184  	fprintf(f, "%s\n", str);
185  	os_free(str);
186  	fclose(f);
187  
188  	return 0;
189  }
190  
191  
get_val(struct xml_node_ctx * ctx,xml_node_t * node)192  static char * get_val(struct xml_node_ctx *ctx, xml_node_t *node)
193  {
194  	char *val, *pos;
195  
196  	val = xml_node_get_text(ctx, node);
197  	if (val == NULL)
198  		return NULL;
199  	pos = val;
200  	while (*pos) {
201  		if (*pos != ' ' && *pos != '\t' && *pos != '\r' && *pos != '\n')
202  			return val;
203  		pos++;
204  	}
205  
206  	return NULL;
207  }
208  
209  
add_path(const char * prev,const char * leaf)210  static char * add_path(const char *prev, const char *leaf)
211  {
212  	size_t len;
213  	char *new_uri;
214  
215  	if (prev == NULL)
216  		return NULL;
217  
218  	len = os_strlen(prev) + 1 + os_strlen(leaf) + 1;
219  	new_uri = os_malloc(len);
220  	if (new_uri)
221  		os_snprintf(new_uri, len, "%s/%s", prev, leaf);
222  
223  	return new_uri;
224  }
225  
226  
node_to_tnds(struct xml_node_ctx * ctx,xml_node_t * out,xml_node_t * in,const char * uri)227  static void node_to_tnds(struct xml_node_ctx *ctx, xml_node_t *out,
228  			 xml_node_t *in, const char *uri)
229  {
230  	xml_node_t *node;
231  	xml_node_t *tnds;
232  	const char *name;
233  	char *val;
234  	char *new_uri;
235  
236  	xml_node_for_each_child(ctx, node, in) {
237  		xml_node_for_each_check(ctx, node);
238  		name = xml_node_get_localname(ctx, node);
239  
240  		tnds = xml_node_create(ctx, out, NULL, "Node");
241  		if (tnds == NULL)
242  			return;
243  		xml_node_create_text(ctx, tnds, NULL, "NodeName", name);
244  
245  		if (uri)
246  			xml_node_create_text(ctx, tnds, NULL, "Path", uri);
247  
248  		val = get_val(ctx, node);
249  		if (val || !xml_node_first_child(ctx, node))
250  			xml_node_create_text(ctx, tnds, NULL, "Value",
251  					     val ? val : "");
252  		xml_node_get_text_free(ctx, val);
253  
254  		new_uri = add_path(uri, name);
255  		node_to_tnds(ctx, new_uri ? out : tnds, node, new_uri);
256  		os_free(new_uri);
257  	}
258  }
259  
260  
add_ddfname(struct xml_node_ctx * ctx,xml_node_t * parent,const char * urn)261  static int add_ddfname(struct xml_node_ctx *ctx, xml_node_t *parent,
262  		       const char *urn)
263  {
264  	xml_node_t *node;
265  
266  	node = xml_node_create(ctx, parent, NULL, "RTProperties");
267  	if (node == NULL)
268  		return -1;
269  	node = xml_node_create(ctx, node, NULL, "Type");
270  	if (node == NULL)
271  		return -1;
272  	xml_node_create_text(ctx, node, NULL, "DDFName", urn);
273  	return 0;
274  }
275  
276  
mo_to_tnds(struct xml_node_ctx * ctx,xml_node_t * mo,int use_path,const char * urn,const char * ns_uri)277  xml_node_t * mo_to_tnds(struct xml_node_ctx *ctx, xml_node_t *mo,
278  			int use_path, const char *urn, const char *ns_uri)
279  {
280  	xml_node_t *root;
281  	xml_node_t *node;
282  	const char *name;
283  
284  	root = xml_node_create_root(ctx, ns_uri, NULL, NULL, "MgmtTree");
285  	if (root == NULL)
286  		return NULL;
287  
288  	xml_node_create_text(ctx, root, NULL, "VerDTD", "1.2");
289  
290  	name = xml_node_get_localname(ctx, mo);
291  
292  	node = xml_node_create(ctx, root, NULL, "Node");
293  	if (node == NULL)
294  		goto fail;
295  	xml_node_create_text(ctx, node, NULL, "NodeName", name);
296  	if (urn)
297  		add_ddfname(ctx, node, urn);
298  
299  	node_to_tnds(ctx, use_path ? root : node, mo, use_path ? name : NULL);
300  
301  	return root;
302  
303  fail:
304  	xml_node_free(ctx, root);
305  	return NULL;
306  }
307  
308  
get_first_child_node(struct xml_node_ctx * ctx,xml_node_t * node,const char * name)309  static xml_node_t * get_first_child_node(struct xml_node_ctx *ctx,
310  					 xml_node_t *node,
311  					 const char *name)
312  {
313  	const char *lname;
314  	xml_node_t *child;
315  
316  	xml_node_for_each_child(ctx, child, node) {
317  		xml_node_for_each_check(ctx, child);
318  		lname = xml_node_get_localname(ctx, child);
319  		if (os_strcasecmp(lname, name) == 0)
320  			return child;
321  	}
322  
323  	return NULL;
324  }
325  
326  
get_node_text(struct xml_node_ctx * ctx,xml_node_t * node,const char * node_name)327  static char * get_node_text(struct xml_node_ctx *ctx, xml_node_t *node,
328  			    const char *node_name)
329  {
330  	node = get_first_child_node(ctx, node, node_name);
331  	if (node == NULL)
332  		return NULL;
333  	return xml_node_get_text(ctx, node);
334  }
335  
336  
add_mo_node(struct xml_node_ctx * ctx,xml_node_t * root,xml_node_t * node,const char * uri)337  static xml_node_t * add_mo_node(struct xml_node_ctx *ctx, xml_node_t *root,
338  				xml_node_t *node, const char *uri)
339  {
340  	char *nodename, *value, *path;
341  	xml_node_t *parent;
342  
343  	nodename = get_node_text(ctx, node, "NodeName");
344  	if (nodename == NULL)
345  		return NULL;
346  	value = get_node_text(ctx, node, "Value");
347  
348  	if (root == NULL) {
349  		root = xml_node_create_root(ctx, NULL, NULL, NULL,
350  					    nodename);
351  		if (root && value)
352  			xml_node_set_text(ctx, root, value);
353  	} else {
354  		if (uri == NULL) {
355  			xml_node_get_text_free(ctx, nodename);
356  			xml_node_get_text_free(ctx, value);
357  			return NULL;
358  		}
359  		path = get_node_text(ctx, node, "Path");
360  		if (path)
361  			uri = path;
362  		parent = get_node_uri(ctx, root, uri);
363  		xml_node_get_text_free(ctx, path);
364  		if (parent == NULL) {
365  			printf("Could not find URI '%s'\n", uri);
366  			xml_node_get_text_free(ctx, nodename);
367  			xml_node_get_text_free(ctx, value);
368  			return NULL;
369  		}
370  		if (value)
371  			xml_node_create_text(ctx, parent, NULL, nodename,
372  					     value);
373  		else
374  			xml_node_create(ctx, parent, NULL, nodename);
375  	}
376  
377  	xml_node_get_text_free(ctx, nodename);
378  	xml_node_get_text_free(ctx, value);
379  
380  	return root;
381  }
382  
383  
tnds_to_mo_iter(struct xml_node_ctx * ctx,xml_node_t * root,xml_node_t * node,const char * uri)384  static xml_node_t * tnds_to_mo_iter(struct xml_node_ctx *ctx, xml_node_t *root,
385  				    xml_node_t *node, const char *uri)
386  {
387  	xml_node_t *child;
388  	const char *name;
389  	char *nodename;
390  
391  	xml_node_for_each_sibling(ctx, node) {
392  		xml_node_for_each_check(ctx, node);
393  
394  		nodename = get_node_text(ctx, node, "NodeName");
395  		if (nodename == NULL)
396  			return NULL;
397  
398  		name = xml_node_get_localname(ctx, node);
399  		if (strcmp(name, "Node") == 0) {
400  			if (root && !uri) {
401  				printf("Invalid TNDS tree structure - "
402  				       "multiple top level nodes\n");
403  				xml_node_get_text_free(ctx, nodename);
404  				return NULL;
405  			}
406  			root = add_mo_node(ctx, root, node, uri);
407  		}
408  
409  		child = get_first_child_node(ctx, node, "Node");
410  		if (child) {
411  			if (uri == NULL)
412  				tnds_to_mo_iter(ctx, root, child, nodename);
413  			else {
414  				char *new_uri;
415  				new_uri = add_path(uri, nodename);
416  				tnds_to_mo_iter(ctx, root, child, new_uri);
417  				os_free(new_uri);
418  			}
419  		}
420  		xml_node_get_text_free(ctx, nodename);
421  	}
422  
423  	return root;
424  }
425  
426  
tnds_to_mo(struct xml_node_ctx * ctx,xml_node_t * tnds)427  xml_node_t * tnds_to_mo(struct xml_node_ctx *ctx, xml_node_t *tnds)
428  {
429  	const char *name;
430  	xml_node_t *node;
431  
432  	name = xml_node_get_localname(ctx, tnds);
433  	if (name == NULL || os_strcmp(name, "MgmtTree") != 0)
434  		return NULL;
435  
436  	node = get_first_child_node(ctx, tnds, "Node");
437  	if (!node)
438  		return NULL;
439  	return tnds_to_mo_iter(ctx, NULL, node, NULL);
440  }
441