1 /*
2  * Hotspot 2.0 - OMA DM client
3  * Copyright (c) 2013-2014, 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 "wpa_helpers.h"
13 #include "xml-utils.h"
14 #include "http-utils.h"
15 #include "utils/browser.h"
16 #include "osu_client.h"
17 
18 
19 #define DM_SERVER_INITIATED_MGMT 1200
20 #define DM_CLIENT_INITIATED_MGMT 1201
21 #define DM_GENERIC_ALERT 1226
22 
23 /* OMA-TS-SyncML-RepPro-V1_2_2 - 10. Response Status Codes */
24 #define DM_RESP_OK 200
25 #define DM_RESP_AUTH_ACCEPTED 212
26 #define DM_RESP_CHUNKED_ITEM_ACCEPTED 213
27 #define DM_RESP_NOT_EXECUTED 215
28 #define DM_RESP_ATOMIC_ROLL_BACK_OK 216
29 #define DM_RESP_NOT_MODIFIED 304
30 #define DM_RESP_BAD_REQUEST 400
31 #define DM_RESP_UNAUTHORIZED 401
32 #define DM_RESP_FORBIDDEN 403
33 #define DM_RESP_NOT_FOUND 404
34 #define DM_RESP_COMMAND_NOT_ALLOWED 405
35 #define DM_RESP_OPTIONAL_FEATURE_NOT_SUPPORTED 406
36 #define DM_RESP_MISSING_CREDENTIALS 407
37 #define DM_RESP_CONFLICT 409
38 #define DM_RESP_GONE 410
39 #define DM_RESP_INCOMPLETE_COMMAND 412
40 #define DM_RESP_REQ_ENTITY_TOO_LARGE 413
41 #define DM_RESP_URI_TOO_LONG 414
42 #define DM_RESP_UNSUPPORTED_MEDIA_TYPE_OR_FORMAT 415
43 #define DM_RESP_REQ_TOO_BIG 416
44 #define DM_RESP_ALREADY_EXISTS 418
45 #define DM_RESP_DEVICE_FULL 420
46 #define DM_RESP_SIZE_MISMATCH 424
47 #define DM_RESP_PERMISSION_DENIED 425
48 #define DM_RESP_COMMAND_FAILED 500
49 #define DM_RESP_COMMAND_NOT_IMPLEMENTED 501
50 #define DM_RESP_ATOMIC_ROLL_BACK_FAILED 516
51 
52 #define DM_HS20_SUBSCRIPTION_CREATION \
53 	"org.wi-fi.hotspot2dot0.SubscriptionCreation"
54 #define DM_HS20_SUBSCRIPTION_PROVISIONING \
55 	"org.wi-fi.hotspot2dot0.SubscriptionProvisioning"
56 #define DM_HS20_SUBSCRIPTION_REMEDIATION \
57 	"org.wi-fi.hotspot2dot0.SubscriptionRemediation"
58 #define DM_HS20_POLICY_UPDATE \
59 	"org.wi-fi.hotspot2dot0.PolicyUpdate"
60 
61 #define DM_URI_PPS "./Wi-Fi/org.wi-fi/PerProviderSubscription"
62 #define DM_URI_LAUNCH_BROWSER \
63 	"./DevDetail/Ext/org.wi-fi/Wi-Fi/Ops/launchBrowserToURI"
64 
65 
66 static void add_item(struct hs20_osu_client *ctx, xml_node_t *parent,
67 		     const char *locuri, const char *data);
68 
69 
int2str(int val)70 static const char * int2str(int val)
71 {
72 	static char buf[20];
73 	snprintf(buf, sizeof(buf), "%d", val);
74 	return buf;
75 }
76 
77 
oma_dm_get_target_locuri(struct hs20_osu_client * ctx,xml_node_t * node)78 static char * oma_dm_get_target_locuri(struct hs20_osu_client *ctx,
79 				       xml_node_t *node)
80 {
81 	xml_node_t *locuri;
82 	char *uri, *ret = NULL;
83 
84 	locuri = get_node(ctx->xml, node, "Item/Target/LocURI");
85 	if (locuri == NULL)
86 		return NULL;
87 
88 	uri = xml_node_get_text(ctx->xml, locuri);
89 	if (uri)
90 		ret = os_strdup(uri);
91 	xml_node_get_text_free(ctx->xml, uri);
92 	return ret;
93 }
94 
95 
oma_dm_add_locuri(struct hs20_osu_client * ctx,xml_node_t * parent,const char * element,const char * uri)96 static void oma_dm_add_locuri(struct hs20_osu_client *ctx, xml_node_t *parent,
97 			      const char *element, const char *uri)
98 {
99 	xml_node_t *node;
100 
101 	node = xml_node_create(ctx->xml, parent, NULL, element);
102 	if (node == NULL)
103 		return;
104 	xml_node_create_text(ctx->xml, node, NULL, "LocURI", uri);
105 }
106 
107 
oma_dm_build_hdr(struct hs20_osu_client * ctx,const char * url,int msgid)108 static xml_node_t * oma_dm_build_hdr(struct hs20_osu_client *ctx,
109 				     const char *url, int msgid)
110 {
111 	xml_node_t *syncml, *synchdr;
112 	xml_namespace_t *ns;
113 
114 	if (!ctx->devid) {
115 		wpa_printf(MSG_ERROR,
116 			   "DevId from devinfo.xml is not available - cannot use OMA DM");
117 		return NULL;
118 	}
119 
120 	syncml = xml_node_create_root(ctx->xml, "SYNCML:SYNCML1.2", NULL, &ns,
121 				      "SyncML");
122 
123 	synchdr = xml_node_create(ctx->xml, syncml, NULL, "SyncHdr");
124 	xml_node_create_text(ctx->xml, synchdr, NULL, "VerDTD", "1.2");
125 	xml_node_create_text(ctx->xml, synchdr, NULL, "VerProto", "DM/1.2");
126 	xml_node_create_text(ctx->xml, synchdr, NULL, "SessionID", "1");
127 	xml_node_create_text(ctx->xml, synchdr, NULL, "MsgID", int2str(msgid));
128 
129 	oma_dm_add_locuri(ctx, synchdr, "Target", url);
130 	oma_dm_add_locuri(ctx, synchdr, "Source", ctx->devid);
131 
132 	return syncml;
133 }
134 
135 
oma_dm_add_cmdid(struct hs20_osu_client * ctx,xml_node_t * parent,int cmdid)136 static void oma_dm_add_cmdid(struct hs20_osu_client *ctx, xml_node_t *parent,
137 			     int cmdid)
138 {
139 	xml_node_create_text(ctx->xml, parent, NULL, "CmdID", int2str(cmdid));
140 }
141 
142 
add_alert(struct hs20_osu_client * ctx,xml_node_t * parent,int cmdid,int data)143 static xml_node_t * add_alert(struct hs20_osu_client *ctx, xml_node_t *parent,
144 			      int cmdid, int data)
145 {
146 	xml_node_t *node;
147 
148 	node = xml_node_create(ctx->xml, parent, NULL, "Alert");
149 	if (node == NULL)
150 		return NULL;
151 	oma_dm_add_cmdid(ctx, node, cmdid);
152 	xml_node_create_text(ctx->xml, node, NULL, "Data", int2str(data));
153 
154 	return node;
155 }
156 
157 
add_status(struct hs20_osu_client * ctx,xml_node_t * parent,int msgref,int cmdref,int cmdid,const char * cmd,int data,const char * targetref)158 static xml_node_t * add_status(struct hs20_osu_client *ctx, xml_node_t *parent,
159 			       int msgref, int cmdref, int cmdid,
160 			       const char *cmd, int data, const char *targetref)
161 {
162 	xml_node_t *node;
163 
164 	node = xml_node_create(ctx->xml, parent, NULL, "Status");
165 	if (node == NULL)
166 		return NULL;
167 	oma_dm_add_cmdid(ctx, node, cmdid);
168 	xml_node_create_text(ctx->xml, node, NULL, "MsgRef", int2str(msgref));
169 	if (cmdref)
170 		xml_node_create_text(ctx->xml, node, NULL, "CmdRef",
171 				     int2str(cmdref));
172 	xml_node_create_text(ctx->xml, node, NULL, "Cmd", cmd);
173 	xml_node_create_text(ctx->xml, node, NULL, "Data", int2str(data));
174 	if (targetref) {
175 		xml_node_create_text(ctx->xml, node, NULL, "TargetRef",
176 				     targetref);
177 	}
178 
179 	return node;
180 }
181 
182 
add_results(struct hs20_osu_client * ctx,xml_node_t * parent,int msgref,int cmdref,int cmdid,const char * locuri,const char * data)183 static xml_node_t * add_results(struct hs20_osu_client *ctx, xml_node_t *parent,
184 				int msgref, int cmdref, int cmdid,
185 				const char *locuri, const char *data)
186 {
187 	xml_node_t *node;
188 
189 	node = xml_node_create(ctx->xml, parent, NULL, "Results");
190 	if (node == NULL)
191 		return NULL;
192 
193 	oma_dm_add_cmdid(ctx, node, cmdid);
194 	xml_node_create_text(ctx->xml, node, NULL, "MsgRef", int2str(msgref));
195 	xml_node_create_text(ctx->xml, node, NULL, "CmdRef", int2str(cmdref));
196 	add_item(ctx, node, locuri, data);
197 
198 	return node;
199 }
200 
201 
mo_str(struct hs20_osu_client * ctx,const char * urn,const char * fname)202 static char * mo_str(struct hs20_osu_client *ctx, const char *urn,
203 		     const char *fname)
204 {
205 	xml_node_t *fnode, *tnds;
206 	char *str;
207 
208 	fnode = node_from_file(ctx->xml, fname);
209 	if (!fnode)
210 		return NULL;
211 	tnds = mo_to_tnds(ctx->xml, fnode, 0, urn, "syncml:dmddf1.2");
212 	xml_node_free(ctx->xml, fnode);
213 	if (!tnds)
214 		return NULL;
215 
216 	str = xml_node_to_str(ctx->xml, tnds);
217 	xml_node_free(ctx->xml, tnds);
218 	if (str == NULL)
219 		return NULL;
220 	wpa_printf(MSG_INFO, "MgmtTree: %s", str);
221 
222 	return str;
223 }
224 
225 
add_item(struct hs20_osu_client * ctx,xml_node_t * parent,const char * locuri,const char * data)226 static void add_item(struct hs20_osu_client *ctx, xml_node_t *parent,
227 		     const char *locuri, const char *data)
228 {
229 	xml_node_t *item, *node;
230 
231 	item = xml_node_create(ctx->xml, parent, NULL, "Item");
232 	oma_dm_add_locuri(ctx, item, "Source", locuri);
233 	node = xml_node_create(ctx->xml, item, NULL, "Meta");
234 	xml_node_create_text_ns(ctx->xml, node, "syncml:metinf", "Format",
235 				"Chr");
236 	xml_node_create_text_ns(ctx->xml, node, "syncml:metinf", "Type",
237 				"text/plain");
238 	xml_node_create_text(ctx->xml, item, NULL, "Data", data);
239 }
240 
241 
add_replace_devinfo(struct hs20_osu_client * ctx,xml_node_t * parent,int cmdid)242 static void add_replace_devinfo(struct hs20_osu_client *ctx, xml_node_t *parent,
243 				int cmdid)
244 {
245 	xml_node_t *info, *child, *replace;
246 	const char *name;
247 	char locuri[200], *txt;
248 
249 	info = node_from_file(ctx->xml, "devinfo.xml");
250 	if (info == NULL) {
251 		wpa_printf(MSG_INFO, "Could not read devinfo.xml");
252 		return;
253 	}
254 
255 	replace = xml_node_create(ctx->xml, parent, NULL, "Replace");
256 	if (replace == NULL) {
257 		xml_node_free(ctx->xml, info);
258 		return;
259 	}
260 	oma_dm_add_cmdid(ctx, replace, cmdid);
261 
262 	xml_node_for_each_child(ctx->xml, child, info) {
263 		xml_node_for_each_check(ctx->xml, child);
264 		name = xml_node_get_localname(ctx->xml, child);
265 		os_snprintf(locuri, sizeof(locuri), "./DevInfo/%s", name);
266 		txt = xml_node_get_text(ctx->xml, child);
267 		if (txt) {
268 			add_item(ctx, replace, locuri, txt);
269 			xml_node_get_text_free(ctx->xml, txt);
270 		}
271 	}
272 
273 	xml_node_free(ctx->xml, info);
274 }
275 
276 
oma_dm_add_hs20_generic_alert(struct hs20_osu_client * ctx,xml_node_t * syncbody,int cmdid,const char * oper,const char * data)277 static void oma_dm_add_hs20_generic_alert(struct hs20_osu_client *ctx,
278 					  xml_node_t *syncbody,
279 					  int cmdid, const char *oper,
280 					  const char *data)
281 {
282 	xml_node_t *node, *item;
283 	char buf[200];
284 
285 	node = add_alert(ctx, syncbody, cmdid, DM_GENERIC_ALERT);
286 
287 	item = xml_node_create(ctx->xml, node, NULL, "Item");
288 	oma_dm_add_locuri(ctx, item, "Source", DM_URI_PPS);
289 	node = xml_node_create(ctx->xml, item, NULL, "Meta");
290 	snprintf(buf, sizeof(buf), "Reversed-Domain-Name: %s", oper);
291 	xml_node_create_text_ns(ctx->xml, node, "syncml:metinf", "Type", buf);
292 	xml_node_create_text_ns(ctx->xml, node, "syncml:metinf", "Format",
293 				"xml");
294 	xml_node_create_text(ctx->xml, item, NULL, "Data", data);
295 }
296 
297 
build_oma_dm_1(struct hs20_osu_client * ctx,const char * url,int msgid,const char * oper)298 static xml_node_t * build_oma_dm_1(struct hs20_osu_client *ctx,
299 				   const char *url, int msgid, const char *oper)
300 {
301 	xml_node_t *syncml, *syncbody;
302 	char *str;
303 	int cmdid = 0;
304 
305 	syncml = oma_dm_build_hdr(ctx, url, msgid);
306 	if (syncml == NULL)
307 		return NULL;
308 
309 	syncbody = xml_node_create(ctx->xml, syncml, NULL, "SyncBody");
310 	if (syncbody == NULL) {
311 		xml_node_free(ctx->xml, syncml);
312 		return NULL;
313 	}
314 
315 	cmdid++;
316 	add_alert(ctx, syncbody, cmdid, DM_CLIENT_INITIATED_MGMT);
317 
318 	str = mo_str(ctx, NULL, "devdetail.xml");
319 	if (str == NULL) {
320 		xml_node_free(ctx->xml, syncml);
321 		return NULL;
322 	}
323 	cmdid++;
324 	oma_dm_add_hs20_generic_alert(ctx, syncbody, cmdid, oper, str);
325 	os_free(str);
326 
327 	cmdid++;
328 	add_replace_devinfo(ctx, syncbody, cmdid);
329 
330 	xml_node_create(ctx->xml, syncbody, NULL, "Final");
331 
332 	return syncml;
333 }
334 
335 
build_oma_dm_1_sub_reg(struct hs20_osu_client * ctx,const char * url,int msgid)336 static xml_node_t * build_oma_dm_1_sub_reg(struct hs20_osu_client *ctx,
337 					   const char *url, int msgid)
338 {
339 	xml_node_t *syncml;
340 
341 	syncml = build_oma_dm_1(ctx, url, msgid, DM_HS20_SUBSCRIPTION_CREATION);
342 	if (syncml)
343 		debug_dump_node(ctx, "OMA-DM Package 1 (sub reg)", syncml);
344 
345 	return syncml;
346 }
347 
348 
build_oma_dm_1_sub_prov(struct hs20_osu_client * ctx,const char * url,int msgid)349 static xml_node_t * build_oma_dm_1_sub_prov(struct hs20_osu_client *ctx,
350 					    const char *url, int msgid)
351 {
352 	xml_node_t *syncml;
353 
354 	syncml = build_oma_dm_1(ctx, url, msgid,
355 				DM_HS20_SUBSCRIPTION_PROVISIONING);
356 	if (syncml)
357 		debug_dump_node(ctx, "OMA-DM Package 1 (sub prov)", syncml);
358 
359 	return syncml;
360 }
361 
362 
build_oma_dm_1_pol_upd(struct hs20_osu_client * ctx,const char * url,int msgid)363 static xml_node_t * build_oma_dm_1_pol_upd(struct hs20_osu_client *ctx,
364 					   const char *url, int msgid)
365 {
366 	xml_node_t *syncml;
367 
368 	syncml = build_oma_dm_1(ctx, url, msgid, DM_HS20_POLICY_UPDATE);
369 	if (syncml)
370 		debug_dump_node(ctx, "OMA-DM Package 1 (pol upd)", syncml);
371 
372 	return syncml;
373 }
374 
375 
build_oma_dm_1_sub_rem(struct hs20_osu_client * ctx,const char * url,int msgid)376 static xml_node_t * build_oma_dm_1_sub_rem(struct hs20_osu_client *ctx,
377 					   const char *url, int msgid)
378 {
379 	xml_node_t *syncml;
380 
381 	syncml = build_oma_dm_1(ctx, url, msgid,
382 				DM_HS20_SUBSCRIPTION_REMEDIATION);
383 	if (syncml)
384 		debug_dump_node(ctx, "OMA-DM Package 1 (sub rem)", syncml);
385 
386 	return syncml;
387 }
388 
389 
oma_dm_exec_browser(struct hs20_osu_client * ctx,xml_node_t * exec)390 static int oma_dm_exec_browser(struct hs20_osu_client *ctx, xml_node_t *exec)
391 {
392 	xml_node_t *node;
393 	char *data;
394 	int res;
395 
396 	node = get_node(ctx->xml, exec, "Item/Data");
397 	if (node == NULL) {
398 		wpa_printf(MSG_INFO, "No Data node found");
399 		return DM_RESP_BAD_REQUEST;
400 	}
401 
402 	data = xml_node_get_text(ctx->xml, node);
403 	if (data == NULL) {
404 		wpa_printf(MSG_INFO, "Invalid data");
405 		return DM_RESP_BAD_REQUEST;
406 	}
407 	wpa_printf(MSG_INFO, "Data: %s", data);
408 	wpa_printf(MSG_INFO, "Launch browser to URI '%s'", data);
409 	write_summary(ctx, "Launch browser to URI '%s'", data);
410 	res = hs20_web_browser(data);
411 	xml_node_get_text_free(ctx->xml, data);
412 	if (res > 0) {
413 		wpa_printf(MSG_INFO, "User response in browser completed successfully");
414 		write_summary(ctx, "User response in browser completed successfully");
415 		return DM_RESP_OK;
416 	} else {
417 		wpa_printf(MSG_INFO, "Failed to receive user response");
418 		write_summary(ctx, "Failed to receive user response");
419 		return DM_RESP_COMMAND_FAILED;
420 	}
421 }
422 
423 
oma_dm_exec_get_cert(struct hs20_osu_client * ctx,xml_node_t * exec)424 static int oma_dm_exec_get_cert(struct hs20_osu_client *ctx, xml_node_t *exec)
425 {
426 	xml_node_t *node, *getcert;
427 	char *data;
428 	const char *name;
429 	int res;
430 
431 	wpa_printf(MSG_INFO, "Client certificate enrollment");
432 	write_summary(ctx, "Client certificate enrollment");
433 
434 	node = get_node(ctx->xml, exec, "Item/Data");
435 	if (node == NULL) {
436 		wpa_printf(MSG_INFO, "No Data node found");
437 		return DM_RESP_BAD_REQUEST;
438 	}
439 
440 	data = xml_node_get_text(ctx->xml, node);
441 	if (data == NULL) {
442 		wpa_printf(MSG_INFO, "Invalid data");
443 		return DM_RESP_BAD_REQUEST;
444 	}
445 	wpa_printf(MSG_INFO, "Data: %s", data);
446 	getcert = xml_node_from_buf(ctx->xml, data);
447 	xml_node_get_text_free(ctx->xml, data);
448 
449 	if (getcert == NULL) {
450 		wpa_printf(MSG_INFO, "Could not parse Item/Data node contents");
451 		return DM_RESP_BAD_REQUEST;
452 	}
453 
454 	debug_dump_node(ctx, "OMA-DM getCertificate", getcert);
455 
456 	name = xml_node_get_localname(ctx->xml, getcert);
457 	if (name == NULL || os_strcasecmp(name, "getCertificate") != 0) {
458 		wpa_printf(MSG_INFO, "Unexpected getCertificate node name '%s'",
459 			   name);
460 		return DM_RESP_BAD_REQUEST;
461 	}
462 
463 	res = osu_get_certificate(ctx, getcert);
464 
465 	xml_node_free(ctx->xml, getcert);
466 
467 	return res == 0 ? DM_RESP_OK : DM_RESP_COMMAND_FAILED;
468 }
469 
470 
oma_dm_exec(struct hs20_osu_client * ctx,xml_node_t * exec)471 static int oma_dm_exec(struct hs20_osu_client *ctx, xml_node_t *exec)
472 {
473 	char *locuri;
474 	int ret;
475 
476 	locuri = oma_dm_get_target_locuri(ctx, exec);
477 	if (locuri == NULL) {
478 		wpa_printf(MSG_INFO, "No Target LocURI node found");
479 		return DM_RESP_BAD_REQUEST;
480 	}
481 
482 	wpa_printf(MSG_INFO, "Target LocURI: %s", locuri);
483 
484 	if (os_strcasecmp(locuri, "./DevDetail/Ext/org.wi-fi/Wi-Fi/Ops/"
485 			  "launchBrowserToURI") == 0) {
486 		ret = oma_dm_exec_browser(ctx, exec);
487 	} else if (os_strcasecmp(locuri, "./DevDetail/Ext/org.wi-fi/Wi-Fi/Ops/"
488 			  "getCertificate") == 0) {
489 		ret = oma_dm_exec_get_cert(ctx, exec);
490 	} else {
491 		wpa_printf(MSG_INFO, "Unsupported exec Target LocURI");
492 		ret = DM_RESP_NOT_FOUND;
493 	}
494 	os_free(locuri);
495 
496 	return ret;
497 }
498 
499 
oma_dm_run_add(struct hs20_osu_client * ctx,const char * locuri,xml_node_t * add,xml_node_t * pps,const char * pps_fname)500 static int oma_dm_run_add(struct hs20_osu_client *ctx, const char *locuri,
501 			  xml_node_t *add, xml_node_t *pps,
502 			  const char *pps_fname)
503 {
504 	const char *pos;
505 	size_t fqdn_len;
506 	xml_node_t *node, *tnds, *unode, *pps_node;
507 	char *data, *uri, *upos, *end;
508 	int use_tnds = 0;
509 	size_t uri_len;
510 
511 	wpa_printf(MSG_INFO, "Add command target LocURI: %s", locuri);
512 
513 	if (os_strncasecmp(locuri, "./Wi-Fi/", 8) != 0) {
514 		wpa_printf(MSG_INFO, "Do not allow Add outside ./Wi-Fi");
515 		return DM_RESP_PERMISSION_DENIED;
516 	}
517 	pos = locuri + 8;
518 
519 	if (ctx->fqdn == NULL)
520 		return DM_RESP_COMMAND_FAILED;
521 	fqdn_len = os_strlen(ctx->fqdn);
522 	if (os_strncasecmp(pos, ctx->fqdn, fqdn_len) != 0 ||
523 	    pos[fqdn_len] != '/') {
524 		wpa_printf(MSG_INFO, "Do not allow Add outside ./Wi-Fi/%s",
525 			   ctx->fqdn);
526 		return DM_RESP_PERMISSION_DENIED;
527 	}
528 	pos += fqdn_len + 1;
529 
530 	if (os_strncasecmp(pos, "PerProviderSubscription/", 24) != 0) {
531 		wpa_printf(MSG_INFO,
532 			   "Do not allow Add outside ./Wi-Fi/%s/PerProviderSubscription",
533 			   ctx->fqdn);
534 		return DM_RESP_PERMISSION_DENIED;
535 	}
536 	pos += 24;
537 
538 	wpa_printf(MSG_INFO, "Add command for PPS node %s", pos);
539 
540 	pps_node = get_node(ctx->xml, pps, pos);
541 	if (pps_node) {
542 		wpa_printf(MSG_INFO, "Specified PPS node exists already");
543 		return DM_RESP_ALREADY_EXISTS;
544 	}
545 
546 	uri = os_strdup(pos);
547 	if (uri == NULL)
548 		return DM_RESP_COMMAND_FAILED;
549 	while (!pps_node) {
550 		upos = os_strrchr(uri, '/');
551 		if (!upos)
552 			break;
553 		upos[0] = '\0';
554 		pps_node = get_node(ctx->xml, pps, uri);
555 		wpa_printf(MSG_INFO, "Node %s %s", uri,
556 			   pps_node ? "exists" : "does not exist");
557 	}
558 
559 	wpa_printf(MSG_INFO, "Parent URI: %s", uri);
560 
561 	if (!pps_node) {
562 		/* Add at root of PPS MO */
563 		pps_node = pps;
564 	}
565 
566 	uri_len = os_strlen(uri);
567 	os_strlcpy(uri, pos + uri_len, os_strlen(pos));
568 	upos = uri;
569 	while (*upos == '/')
570 		upos++;
571 	wpa_printf(MSG_INFO, "Nodes to add: %s", upos);
572 
573 	for (;;) {
574 		end = os_strchr(upos, '/');
575 		if (!end)
576 			break;
577 		*end = '\0';
578 		wpa_printf(MSG_INFO, "Adding interim node %s", upos);
579 		pps_node = xml_node_create(ctx->xml, pps_node, NULL, upos);
580 		if (pps_node == NULL) {
581 			os_free(uri);
582 			return DM_RESP_COMMAND_FAILED;
583 		}
584 		upos = end + 1;
585 	}
586 
587 	wpa_printf(MSG_INFO, "Adding node %s", upos);
588 
589 	node = get_node(ctx->xml, add, "Item/Meta/Type");
590 	if (node) {
591 		char *type;
592 		type = xml_node_get_text(ctx->xml, node);
593 		if (type == NULL) {
594 			wpa_printf(MSG_ERROR, "Could not find type text");
595 			os_free(uri);
596 			return DM_RESP_BAD_REQUEST;
597 		}
598 		use_tnds = node &&
599 			os_strstr(type, "application/vnd.syncml.dmtnds+xml");
600 	}
601 
602 	node = get_node(ctx->xml, add, "Item/Data");
603 	if (node == NULL) {
604 		wpa_printf(MSG_INFO, "No Add/Item/Data found");
605 		os_free(uri);
606 		return DM_RESP_BAD_REQUEST;
607 	}
608 
609 	data = xml_node_get_text(ctx->xml, node);
610 	if (data == NULL) {
611 		wpa_printf(MSG_INFO, "Could not get Add/Item/Data text");
612 		os_free(uri);
613 		return DM_RESP_BAD_REQUEST;
614 	}
615 
616 	wpa_printf(MSG_DEBUG, "Add/Item/Data: %s", data);
617 
618 	if (use_tnds) {
619 		tnds = xml_node_from_buf(ctx->xml, data);
620 		xml_node_get_text_free(ctx->xml, data);
621 		if (tnds == NULL) {
622 			wpa_printf(MSG_INFO,
623 				   "Could not parse Add/Item/Data text");
624 			os_free(uri);
625 			return DM_RESP_BAD_REQUEST;
626 		}
627 
628 		unode = tnds_to_mo(ctx->xml, tnds);
629 		xml_node_free(ctx->xml, tnds);
630 		if (unode == NULL) {
631 			wpa_printf(MSG_INFO, "Could not parse TNDS text");
632 			os_free(uri);
633 			return DM_RESP_BAD_REQUEST;
634 		}
635 
636 		debug_dump_node(ctx, "Parsed TNDS", unode);
637 
638 		xml_node_add_child(ctx->xml, pps_node, unode);
639 	} else {
640 		/* TODO: What to do here? */
641 		os_free(uri);
642 		return DM_RESP_BAD_REQUEST;
643 	}
644 
645 	os_free(uri);
646 
647 	if (update_pps_file(ctx, pps_fname, pps) < 0)
648 		return DM_RESP_COMMAND_FAILED;
649 
650 	ctx->pps_updated = 1;
651 
652 	return DM_RESP_OK;
653 }
654 
655 
oma_dm_add(struct hs20_osu_client * ctx,xml_node_t * add,xml_node_t * pps,const char * pps_fname)656 static int oma_dm_add(struct hs20_osu_client *ctx, xml_node_t *add,
657 		      xml_node_t *pps, const char *pps_fname)
658 {
659 	xml_node_t *node;
660 	char *locuri;
661 	char fname[300];
662 	int ret;
663 
664 	node = get_node(ctx->xml, add, "Item/Target/LocURI");
665 	if (node == NULL) {
666 		wpa_printf(MSG_INFO, "No Target LocURI node found");
667 		return DM_RESP_BAD_REQUEST;
668 	}
669 	locuri = xml_node_get_text(ctx->xml, node);
670 	if (locuri == NULL) {
671 		wpa_printf(MSG_ERROR, "No LocURI node text found");
672 		return DM_RESP_BAD_REQUEST;
673 	}
674 	wpa_printf(MSG_INFO, "Target LocURI: %s", locuri);
675 	if (os_strncasecmp(locuri, "./Wi-Fi/", 8) != 0) {
676 		wpa_printf(MSG_INFO, "Unsupported Add Target LocURI");
677 		xml_node_get_text_free(ctx->xml, locuri);
678 		return DM_RESP_PERMISSION_DENIED;
679 	}
680 
681 	node = get_node(ctx->xml, add, "Item/Data");
682 	if (node == NULL) {
683 		wpa_printf(MSG_INFO, "No Data node found");
684 		xml_node_get_text_free(ctx->xml, locuri);
685 		return DM_RESP_BAD_REQUEST;
686 	}
687 
688 	if (pps_fname && os_file_exists(pps_fname)) {
689 		ret = oma_dm_run_add(ctx, locuri, add, pps, pps_fname);
690 		if (ret != DM_RESP_OK) {
691 			xml_node_get_text_free(ctx->xml, locuri);
692 			return ret;
693 		}
694 		ret = 0;
695 		os_strlcpy(fname, pps_fname, sizeof(fname));
696 	} else
697 		ret = hs20_add_pps_mo(ctx, locuri, node, fname, sizeof(fname));
698 	xml_node_get_text_free(ctx->xml, locuri);
699 	if (ret < 0)
700 		return ret == -2 ? DM_RESP_ALREADY_EXISTS :
701 			DM_RESP_COMMAND_FAILED;
702 
703 	if (ctx->no_reconnect == 2) {
704 		os_snprintf(ctx->pps_fname, sizeof(ctx->pps_fname), "%s",
705 			    fname);
706 		ctx->pps_cred_set = 1;
707 		return DM_RESP_OK;
708 	}
709 
710 	wpa_printf(MSG_INFO, "Updating wpa_supplicant credentials");
711 	cmd_set_pps(ctx, fname);
712 
713 	if (ctx->no_reconnect)
714 		return DM_RESP_OK;
715 
716 	wpa_printf(MSG_INFO, "Requesting reconnection with updated configuration");
717 	if (wpa_command(ctx->ifname, "INTERWORKING_SELECT auto") < 0)
718 		wpa_printf(MSG_INFO, "Failed to request wpa_supplicant to reconnect");
719 
720 	return DM_RESP_OK;
721 }
722 
723 
oma_dm_replace(struct hs20_osu_client * ctx,xml_node_t * replace,xml_node_t * pps,const char * pps_fname)724 static int oma_dm_replace(struct hs20_osu_client *ctx, xml_node_t *replace,
725 			  xml_node_t *pps, const char *pps_fname)
726 {
727 	char *locuri, *pos;
728 	size_t fqdn_len;
729 	xml_node_t *node, *tnds, *unode, *pps_node, *parent;
730 	char *data;
731 	int use_tnds = 0;
732 
733 	locuri = oma_dm_get_target_locuri(ctx, replace);
734 	if (locuri == NULL)
735 		return DM_RESP_BAD_REQUEST;
736 
737 	wpa_printf(MSG_INFO, "Replace command target LocURI: %s", locuri);
738 	if (os_strncasecmp(locuri, "./Wi-Fi/", 8) != 0) {
739 		wpa_printf(MSG_INFO, "Do not allow Replace outside ./Wi-Fi");
740 		os_free(locuri);
741 		return DM_RESP_PERMISSION_DENIED;
742 	}
743 	pos = locuri + 8;
744 
745 	if (ctx->fqdn == NULL) {
746 		os_free(locuri);
747 		return DM_RESP_COMMAND_FAILED;
748 	}
749 	fqdn_len = os_strlen(ctx->fqdn);
750 	if (os_strncasecmp(pos, ctx->fqdn, fqdn_len) != 0 ||
751 	    pos[fqdn_len] != '/') {
752 		wpa_printf(MSG_INFO, "Do not allow Replace outside ./Wi-Fi/%s",
753 			   ctx->fqdn);
754 		os_free(locuri);
755 		return DM_RESP_PERMISSION_DENIED;
756 	}
757 	pos += fqdn_len + 1;
758 
759 	if (os_strncasecmp(pos, "PerProviderSubscription/", 24) != 0) {
760 		wpa_printf(MSG_INFO,
761 			   "Do not allow Replace outside ./Wi-Fi/%s/PerProviderSubscription",
762 			   ctx->fqdn);
763 		os_free(locuri);
764 		return DM_RESP_PERMISSION_DENIED;
765 	}
766 	pos += 24;
767 
768 	wpa_printf(MSG_INFO, "Replace command for PPS node %s", pos);
769 
770 	pps_node = get_node(ctx->xml, pps, pos);
771 	if (pps_node == NULL) {
772 		wpa_printf(MSG_INFO, "Specified PPS node not found");
773 		os_free(locuri);
774 		return DM_RESP_NOT_FOUND;
775 	}
776 
777 	node = get_node(ctx->xml, replace, "Item/Meta/Type");
778 	if (node) {
779 		char *type;
780 		type = xml_node_get_text(ctx->xml, node);
781 		if (type == NULL) {
782 			wpa_printf(MSG_INFO, "Could not find type text");
783 			os_free(locuri);
784 			return DM_RESP_BAD_REQUEST;
785 		}
786 		use_tnds = node &&
787 			os_strstr(type, "application/vnd.syncml.dmtnds+xml");
788 	}
789 
790 	node = get_node(ctx->xml, replace, "Item/Data");
791 	if (node == NULL) {
792 		wpa_printf(MSG_INFO, "No Replace/Item/Data found");
793 		os_free(locuri);
794 		return DM_RESP_BAD_REQUEST;
795 	}
796 
797 	data = xml_node_get_text(ctx->xml, node);
798 	if (data == NULL) {
799 		wpa_printf(MSG_INFO, "Could not get Replace/Item/Data text");
800 		os_free(locuri);
801 		return DM_RESP_BAD_REQUEST;
802 	}
803 
804 	wpa_printf(MSG_DEBUG, "Replace/Item/Data: %s", data);
805 
806 	if (use_tnds) {
807 		tnds = xml_node_from_buf(ctx->xml, data);
808 		xml_node_get_text_free(ctx->xml, data);
809 		if (tnds == NULL) {
810 			wpa_printf(MSG_INFO,
811 				   "Could not parse Replace/Item/Data text");
812 			os_free(locuri);
813 			return DM_RESP_BAD_REQUEST;
814 		}
815 
816 		unode = tnds_to_mo(ctx->xml, tnds);
817 		xml_node_free(ctx->xml, tnds);
818 		if (unode == NULL) {
819 			wpa_printf(MSG_INFO, "Could not parse TNDS text");
820 			os_free(locuri);
821 			return DM_RESP_BAD_REQUEST;
822 		}
823 
824 		debug_dump_node(ctx, "Parsed TNDS", unode);
825 
826 		parent = xml_node_get_parent(ctx->xml, pps_node);
827 		xml_node_detach(ctx->xml, pps_node);
828 		xml_node_add_child(ctx->xml, parent, unode);
829 	} else {
830 		xml_node_set_text(ctx->xml, pps_node, data);
831 		xml_node_get_text_free(ctx->xml, data);
832 	}
833 
834 	os_free(locuri);
835 
836 	if (update_pps_file(ctx, pps_fname, pps) < 0)
837 		return DM_RESP_COMMAND_FAILED;
838 
839 	ctx->pps_updated = 1;
840 
841 	return DM_RESP_OK;
842 }
843 
844 
oma_dm_get(struct hs20_osu_client * ctx,xml_node_t * get,xml_node_t * pps,const char * pps_fname,char ** value)845 static int oma_dm_get(struct hs20_osu_client *ctx, xml_node_t *get,
846 		      xml_node_t *pps, const char *pps_fname, char **value)
847 {
848 	char *locuri, *pos;
849 	size_t fqdn_len;
850 	xml_node_t *pps_node;
851 	const char *name;
852 
853 	*value = NULL;
854 
855 	locuri = oma_dm_get_target_locuri(ctx, get);
856 	if (locuri == NULL)
857 		return DM_RESP_BAD_REQUEST;
858 
859 	wpa_printf(MSG_INFO, "Get command target LocURI: %s", locuri);
860 	if (os_strncasecmp(locuri, "./Wi-Fi/", 8) != 0) {
861 		wpa_printf(MSG_INFO, "Do not allow Get outside ./Wi-Fi");
862 		os_free(locuri);
863 		return DM_RESP_PERMISSION_DENIED;
864 	}
865 	pos = locuri + 8;
866 
867 	if (ctx->fqdn == NULL)
868 		return DM_RESP_COMMAND_FAILED;
869 	fqdn_len = os_strlen(ctx->fqdn);
870 	if (os_strncasecmp(pos, ctx->fqdn, fqdn_len) != 0 ||
871 	    pos[fqdn_len] != '/') {
872 		wpa_printf(MSG_INFO, "Do not allow Get outside ./Wi-Fi/%s",
873 			   ctx->fqdn);
874 		os_free(locuri);
875 		return DM_RESP_PERMISSION_DENIED;
876 	}
877 	pos += fqdn_len + 1;
878 
879 	if (os_strncasecmp(pos, "PerProviderSubscription/", 24) != 0) {
880 		wpa_printf(MSG_INFO,
881 			   "Do not allow Get outside ./Wi-Fi/%s/PerProviderSubscription",
882 			   ctx->fqdn);
883 		os_free(locuri);
884 		return DM_RESP_PERMISSION_DENIED;
885 	}
886 	pos += 24;
887 
888 	wpa_printf(MSG_INFO, "Get command for PPS node %s", pos);
889 
890 	pps_node = get_node(ctx->xml, pps, pos);
891 	if (pps_node == NULL) {
892 		wpa_printf(MSG_INFO, "Specified PPS node not found");
893 		os_free(locuri);
894 		return DM_RESP_NOT_FOUND;
895 	}
896 
897 	name = xml_node_get_localname(ctx->xml, pps_node);
898 	wpa_printf(MSG_INFO, "Get command returned node with name '%s'", name);
899 	if (os_strcasecmp(name, "Password") == 0) {
900 		wpa_printf(MSG_INFO, "Do not allow Get for Password node");
901 		os_free(locuri);
902 		return DM_RESP_PERMISSION_DENIED;
903 	}
904 
905 	/*
906 	 * TODO: No support for DMTNDS, so if interior node, reply with a
907 	 * list of children node names in Results element. The child list type is
908 	 * defined in [DMTND].
909 	 */
910 
911 	*value = xml_node_get_text(ctx->xml, pps_node);
912 	if (*value == NULL)
913 		return DM_RESP_COMMAND_FAILED;
914 
915 	return DM_RESP_OK;
916 }
917 
918 
oma_dm_get_cmdid(struct hs20_osu_client * ctx,xml_node_t * node)919 static int oma_dm_get_cmdid(struct hs20_osu_client *ctx, xml_node_t *node)
920 {
921 	xml_node_t *cnode;
922 	char *str;
923 	int ret;
924 
925 	cnode = get_node(ctx->xml, node, "CmdID");
926 	if (cnode == NULL)
927 		return 0;
928 
929 	str = xml_node_get_text(ctx->xml, cnode);
930 	if (str == NULL)
931 		return 0;
932 	ret = atoi(str);
933 	xml_node_get_text_free(ctx->xml, str);
934 	return ret;
935 }
936 
937 
oma_dm_send_recv(struct hs20_osu_client * ctx,const char * url,xml_node_t * syncml,const char * ext_hdr,const char * username,const char * password,const char * client_cert,const char * client_key)938 static xml_node_t * oma_dm_send_recv(struct hs20_osu_client *ctx,
939 				     const char *url, xml_node_t *syncml,
940 				     const char *ext_hdr,
941 				     const char *username, const char *password,
942 				     const char *client_cert,
943 				     const char *client_key)
944 {
945 	xml_node_t *resp;
946 	char *str, *res;
947 	char *resp_uri = NULL;
948 
949 	str = xml_node_to_str(ctx->xml, syncml);
950 	xml_node_free(ctx->xml, syncml);
951 	if (str == NULL)
952 		return NULL;
953 
954 	wpa_printf(MSG_INFO, "Send OMA DM Package");
955 	write_summary(ctx, "Send OMA DM Package");
956 	os_free(ctx->server_url);
957 	ctx->server_url = os_strdup(url);
958 	res = http_post(ctx->http, url, str, "application/vnd.syncml.dm+xml",
959 			ext_hdr, ctx->ca_fname, username, password,
960 			client_cert, client_key, NULL);
961 	os_free(str);
962 	os_free(resp_uri);
963 	resp_uri = NULL;
964 
965 	if (res == NULL) {
966 		const char *err = http_get_err(ctx->http);
967 		if (err) {
968 			wpa_printf(MSG_INFO, "HTTP error: %s", err);
969 			write_result(ctx, "HTTP error: %s", err);
970 		} else {
971 			write_summary(ctx, "Failed to send OMA DM Package");
972 		}
973 		return NULL;
974 	}
975 	wpa_printf(MSG_DEBUG, "Server response: %s", res);
976 
977 	wpa_printf(MSG_INFO, "Process OMA DM Package");
978 	write_summary(ctx, "Process received OMA DM Package");
979 	resp = xml_node_from_buf(ctx->xml, res);
980 	os_free(res);
981 	if (resp == NULL) {
982 		wpa_printf(MSG_INFO, "Failed to parse OMA DM response");
983 		return NULL;
984 	}
985 
986 	debug_dump_node(ctx, "OMA DM Package", resp);
987 
988 	return resp;
989 }
990 
991 
oma_dm_process(struct hs20_osu_client * ctx,const char * url,xml_node_t * resp,int msgid,char ** ret_resp_uri,xml_node_t * pps,const char * pps_fname)992 static xml_node_t * oma_dm_process(struct hs20_osu_client *ctx, const char *url,
993 				   xml_node_t *resp, int msgid,
994 				   char **ret_resp_uri,
995 				   xml_node_t *pps, const char *pps_fname)
996 {
997 	xml_node_t *syncml, *syncbody, *hdr, *body, *child;
998 	const char *name;
999 	char *resp_uri = NULL;
1000 	int server_msgid = 0;
1001 	int cmdid = 0;
1002 	int server_cmdid;
1003 	int resp_needed = 0;
1004 	char *tmp;
1005 	int final = 0;
1006 	char *locuri;
1007 
1008 	*ret_resp_uri = NULL;
1009 
1010 	name = xml_node_get_localname(ctx->xml, resp);
1011 	if (name == NULL || os_strcasecmp(name, "SyncML") != 0) {
1012 		wpa_printf(MSG_INFO, "SyncML node not found");
1013 		return NULL;
1014 	}
1015 
1016 	hdr = get_node(ctx->xml, resp, "SyncHdr");
1017 	body = get_node(ctx->xml, resp, "SyncBody");
1018 	if (hdr == NULL || body == NULL) {
1019 		wpa_printf(MSG_INFO, "Could not find SyncHdr or SyncBody");
1020 		return NULL;
1021 	}
1022 
1023 	xml_node_for_each_child(ctx->xml, child, hdr) {
1024 		xml_node_for_each_check(ctx->xml, child);
1025 		name = xml_node_get_localname(ctx->xml, child);
1026 		wpa_printf(MSG_INFO, "SyncHdr %s", name);
1027 		if (os_strcasecmp(name, "RespURI") == 0) {
1028 			tmp = xml_node_get_text(ctx->xml, child);
1029 			if (tmp)
1030 				resp_uri = os_strdup(tmp);
1031 			xml_node_get_text_free(ctx->xml, tmp);
1032 		} else if (os_strcasecmp(name, "MsgID") == 0) {
1033 			tmp = xml_node_get_text(ctx->xml, child);
1034 			if (tmp)
1035 				server_msgid = atoi(tmp);
1036 			xml_node_get_text_free(ctx->xml, tmp);
1037 		}
1038 	}
1039 
1040 	wpa_printf(MSG_INFO, "Server MsgID: %d", server_msgid);
1041 	if (resp_uri)
1042 		wpa_printf(MSG_INFO, "RespURI: %s", resp_uri);
1043 
1044 	syncml = oma_dm_build_hdr(ctx, resp_uri ? resp_uri : url, msgid);
1045 	if (syncml == NULL) {
1046 		os_free(resp_uri);
1047 		return NULL;
1048 	}
1049 
1050 	syncbody = xml_node_create(ctx->xml, syncml, NULL, "SyncBody");
1051 	cmdid++;
1052 	add_status(ctx, syncbody, server_msgid, 0, cmdid, "SyncHdr",
1053 		   DM_RESP_AUTH_ACCEPTED, NULL);
1054 
1055 	xml_node_for_each_child(ctx->xml, child, body) {
1056 		xml_node_for_each_check(ctx->xml, child);
1057 		server_cmdid = oma_dm_get_cmdid(ctx, child);
1058 		name = xml_node_get_localname(ctx->xml, child);
1059 		wpa_printf(MSG_INFO, "SyncBody CmdID=%d - %s",
1060 			   server_cmdid, name);
1061 		if (os_strcasecmp(name, "Exec") == 0) {
1062 			int res = oma_dm_exec(ctx, child);
1063 			cmdid++;
1064 			locuri = oma_dm_get_target_locuri(ctx, child);
1065 			if (locuri == NULL)
1066 				res = DM_RESP_BAD_REQUEST;
1067 			add_status(ctx, syncbody, server_msgid, server_cmdid,
1068 				   cmdid, name, res, locuri);
1069 			os_free(locuri);
1070 			resp_needed = 1;
1071 		} else if (os_strcasecmp(name, "Add") == 0) {
1072 			int res = oma_dm_add(ctx, child, pps, pps_fname);
1073 			cmdid++;
1074 			locuri = oma_dm_get_target_locuri(ctx, child);
1075 			if (locuri == NULL)
1076 				res = DM_RESP_BAD_REQUEST;
1077 			add_status(ctx, syncbody, server_msgid, server_cmdid,
1078 				   cmdid, name, res, locuri);
1079 			os_free(locuri);
1080 			resp_needed = 1;
1081 		} else if (os_strcasecmp(name, "Replace") == 0) {
1082 			int res;
1083 			res = oma_dm_replace(ctx, child, pps, pps_fname);
1084 			cmdid++;
1085 			locuri = oma_dm_get_target_locuri(ctx, child);
1086 			if (locuri == NULL)
1087 				res = DM_RESP_BAD_REQUEST;
1088 			add_status(ctx, syncbody, server_msgid, server_cmdid,
1089 				   cmdid, name, res, locuri);
1090 			os_free(locuri);
1091 			resp_needed = 1;
1092 		} else if (os_strcasecmp(name, "Status") == 0) {
1093 			/* TODO: Verify success */
1094 		} else if (os_strcasecmp(name, "Get") == 0) {
1095 			int res;
1096 			char *value;
1097 			res = oma_dm_get(ctx, child, pps, pps_fname, &value);
1098 			cmdid++;
1099 			locuri = oma_dm_get_target_locuri(ctx, child);
1100 			if (locuri == NULL)
1101 				res = DM_RESP_BAD_REQUEST;
1102 			add_status(ctx, syncbody, server_msgid, server_cmdid,
1103 				   cmdid, name, res, locuri);
1104 			if (res == DM_RESP_OK && value) {
1105 				cmdid++;
1106 				add_results(ctx, syncbody, server_msgid,
1107 					    server_cmdid, cmdid, locuri, value);
1108 			}
1109 			os_free(locuri);
1110 			xml_node_get_text_free(ctx->xml, value);
1111 			resp_needed = 1;
1112 #if 0 /* TODO: MUST support */
1113 		} else if (os_strcasecmp(name, "Delete") == 0) {
1114 #endif
1115 #if 0 /* TODO: MUST support */
1116 		} else if (os_strcasecmp(name, "Sequence") == 0) {
1117 #endif
1118 		} else if (os_strcasecmp(name, "Final") == 0) {
1119 			final = 1;
1120 			break;
1121 		} else {
1122 			locuri = oma_dm_get_target_locuri(ctx, child);
1123 			add_status(ctx, syncbody, server_msgid, server_cmdid,
1124 				   cmdid, name, DM_RESP_COMMAND_NOT_IMPLEMENTED,
1125 				   locuri);
1126 			os_free(locuri);
1127 			resp_needed = 1;
1128 		}
1129 	}
1130 
1131 	if (!final) {
1132 		wpa_printf(MSG_INFO, "Final node not found");
1133 		xml_node_free(ctx->xml, syncml);
1134 		os_free(resp_uri);
1135 		return NULL;
1136 	}
1137 
1138 	if (!resp_needed) {
1139 		wpa_printf(MSG_INFO, "Exchange completed - no response needed");
1140 		xml_node_free(ctx->xml, syncml);
1141 		os_free(resp_uri);
1142 		return NULL;
1143 	}
1144 
1145 	xml_node_create(ctx->xml, syncbody, NULL, "Final");
1146 
1147 	debug_dump_node(ctx, "OMA-DM Package 3", syncml);
1148 
1149 	*ret_resp_uri = resp_uri;
1150 	return syncml;
1151 }
1152 
1153 
cmd_oma_dm_prov(struct hs20_osu_client * ctx,const char * url)1154 int cmd_oma_dm_prov(struct hs20_osu_client *ctx, const char *url)
1155 {
1156 	xml_node_t *syncml, *resp;
1157 	char *resp_uri = NULL;
1158 	int msgid = 0;
1159 
1160 	if (url == NULL) {
1161 		wpa_printf(MSG_INFO, "Invalid prov command (missing URL)");
1162 		return -1;
1163 	}
1164 
1165 	wpa_printf(MSG_INFO, "OMA-DM credential provisioning requested");
1166 	write_summary(ctx, "OMA-DM credential provisioning");
1167 
1168 	msgid++;
1169 	syncml = build_oma_dm_1_sub_reg(ctx, url, msgid);
1170 	if (syncml == NULL)
1171 		return -1;
1172 
1173 	while (syncml) {
1174 		resp = oma_dm_send_recv(ctx, resp_uri ? resp_uri : url,
1175 					syncml, NULL, NULL, NULL, NULL, NULL);
1176 		if (resp == NULL)
1177 			return -1;
1178 
1179 		msgid++;
1180 		syncml = oma_dm_process(ctx, url, resp, msgid, &resp_uri,
1181 					NULL, NULL);
1182 		xml_node_free(ctx->xml, resp);
1183 	}
1184 
1185 	os_free(resp_uri);
1186 
1187 	return ctx->pps_cred_set ? 0 : -1;
1188 }
1189 
1190 
cmd_oma_dm_sim_prov(struct hs20_osu_client * ctx,const char * url)1191 int cmd_oma_dm_sim_prov(struct hs20_osu_client *ctx, const char *url)
1192 {
1193 	xml_node_t *syncml, *resp;
1194 	char *resp_uri = NULL;
1195 	int msgid = 0;
1196 
1197 	if (url == NULL) {
1198 		wpa_printf(MSG_INFO, "Invalid prov command (missing URL)");
1199 		return -1;
1200 	}
1201 
1202 	wpa_printf(MSG_INFO, "OMA-DM SIM provisioning requested");
1203 	ctx->no_reconnect = 2;
1204 
1205 	wpa_printf(MSG_INFO, "Wait for IP address before starting SIM provisioning");
1206 	write_summary(ctx, "Wait for IP address before starting SIM provisioning");
1207 
1208 	if (wait_ip_addr(ctx->ifname, 15) < 0) {
1209 		wpa_printf(MSG_INFO, "Could not get IP address for WLAN - try connection anyway");
1210 	}
1211 	write_summary(ctx, "OMA-DM SIM provisioning");
1212 
1213 	msgid++;
1214 	syncml = build_oma_dm_1_sub_prov(ctx, url, msgid);
1215 	if (syncml == NULL)
1216 		return -1;
1217 
1218 	while (syncml) {
1219 		resp = oma_dm_send_recv(ctx, resp_uri ? resp_uri : url,
1220 					syncml, NULL, NULL, NULL, NULL, NULL);
1221 		if (resp == NULL)
1222 			return -1;
1223 
1224 		msgid++;
1225 		syncml = oma_dm_process(ctx, url, resp, msgid, &resp_uri,
1226 					NULL, NULL);
1227 		xml_node_free(ctx->xml, resp);
1228 	}
1229 
1230 	os_free(resp_uri);
1231 
1232 	if (ctx->pps_cred_set) {
1233 		wpa_printf(MSG_INFO, "Updating wpa_supplicant credentials");
1234 		cmd_set_pps(ctx, ctx->pps_fname);
1235 
1236 		wpa_printf(MSG_INFO, "Requesting reconnection with updated configuration");
1237 		write_summary(ctx, "Requesting reconnection with updated configuration");
1238 		if (wpa_command(ctx->ifname, "INTERWORKING_SELECT auto") < 0) {
1239 			wpa_printf(MSG_INFO, "Failed to request wpa_supplicant to reconnect");
1240 			write_summary(ctx, "Failed to request wpa_supplicant to reconnect");
1241 			return -1;
1242 		}
1243 	}
1244 
1245 	return ctx->pps_cred_set ? 0 : -1;
1246 }
1247 
1248 
oma_dm_pol_upd(struct hs20_osu_client * ctx,const char * address,const char * pps_fname,const char * client_cert,const char * client_key,const char * cred_username,const char * cred_password,xml_node_t * pps)1249 void oma_dm_pol_upd(struct hs20_osu_client *ctx, const char *address,
1250 		    const char *pps_fname,
1251 		    const char *client_cert, const char *client_key,
1252 		    const char *cred_username, const char *cred_password,
1253 		    xml_node_t *pps)
1254 {
1255 	xml_node_t *syncml, *resp;
1256 	char *resp_uri = NULL;
1257 	int msgid = 0;
1258 
1259 	wpa_printf(MSG_INFO, "OMA-DM policy update");
1260 	write_summary(ctx, "OMA-DM policy update");
1261 
1262 	msgid++;
1263 	syncml = build_oma_dm_1_pol_upd(ctx, address, msgid);
1264 	if (syncml == NULL)
1265 		return;
1266 
1267 	while (syncml) {
1268 		resp = oma_dm_send_recv(ctx, resp_uri ? resp_uri : address,
1269 					syncml, NULL, cred_username,
1270 					cred_password, client_cert, client_key);
1271 		if (resp == NULL)
1272 			return;
1273 
1274 		msgid++;
1275 		syncml = oma_dm_process(ctx, address, resp, msgid, &resp_uri,
1276 					pps, pps_fname);
1277 		xml_node_free(ctx->xml, resp);
1278 	}
1279 
1280 	os_free(resp_uri);
1281 
1282 	if (ctx->pps_updated) {
1283 		wpa_printf(MSG_INFO, "Update wpa_supplicant credential based on updated PPS MO");
1284 		write_summary(ctx, "Update wpa_supplicant credential based on updated PPS MO and request connection");
1285 		cmd_set_pps(ctx, pps_fname);
1286 		if (wpa_command(ctx->ifname, "INTERWORKING_SELECT auto") < 0) {
1287 			wpa_printf(MSG_INFO,
1288 				   "Failed to request wpa_supplicant to reconnect");
1289 			write_summary(ctx,
1290 				      "Failed to request wpa_supplicant to reconnect");
1291 		}
1292 	}
1293 }
1294 
1295 
oma_dm_sub_rem(struct hs20_osu_client * ctx,const char * address,const char * pps_fname,const char * client_cert,const char * client_key,const char * cred_username,const char * cred_password,xml_node_t * pps)1296 void oma_dm_sub_rem(struct hs20_osu_client *ctx, const char *address,
1297 		    const char *pps_fname,
1298 		    const char *client_cert, const char *client_key,
1299 		    const char *cred_username, const char *cred_password,
1300 		    xml_node_t *pps)
1301 {
1302 	xml_node_t *syncml, *resp;
1303 	char *resp_uri = NULL;
1304 	int msgid = 0;
1305 
1306 	wpa_printf(MSG_INFO, "OMA-DM subscription remediation");
1307 	write_summary(ctx, "OMA-DM subscription remediation");
1308 
1309 	msgid++;
1310 	syncml = build_oma_dm_1_sub_rem(ctx, address, msgid);
1311 	if (syncml == NULL)
1312 		return;
1313 
1314 	while (syncml) {
1315 		resp = oma_dm_send_recv(ctx, resp_uri ? resp_uri : address,
1316 					syncml, NULL, cred_username,
1317 					cred_password, client_cert, client_key);
1318 		if (resp == NULL)
1319 			return;
1320 
1321 		msgid++;
1322 		syncml = oma_dm_process(ctx, address, resp, msgid, &resp_uri,
1323 					pps, pps_fname);
1324 		xml_node_free(ctx->xml, resp);
1325 	}
1326 
1327 	os_free(resp_uri);
1328 
1329 	wpa_printf(MSG_INFO, "Update wpa_supplicant credential based on updated PPS MO and request reconnection");
1330 	write_summary(ctx, "Update wpa_supplicant credential based on updated PPS MO and request reconnection");
1331 	cmd_set_pps(ctx, pps_fname);
1332 	if (wpa_command(ctx->ifname, "INTERWORKING_SELECT auto") < 0) {
1333 		wpa_printf(MSG_INFO, "Failed to request wpa_supplicant to reconnect");
1334 		write_summary(ctx, "Failed to request wpa_supplicant to reconnect");
1335 	}
1336 }
1337 
1338 
cmd_oma_dm_add(struct hs20_osu_client * ctx,const char * pps_fname,const char * add_fname)1339 void cmd_oma_dm_add(struct hs20_osu_client *ctx, const char *pps_fname,
1340 		    const char *add_fname)
1341 {
1342 	xml_node_t *pps, *add;
1343 	int res;
1344 
1345 	ctx->fqdn = os_strdup("wi-fi.org");
1346 
1347 	pps = node_from_file(ctx->xml, pps_fname);
1348 	if (pps == NULL) {
1349 		wpa_printf(MSG_INFO, "PPS file %s could not be parsed",
1350 			   pps_fname);
1351 		return;
1352 	}
1353 
1354 	add = node_from_file(ctx->xml, add_fname);
1355 	if (add == NULL) {
1356 		wpa_printf(MSG_INFO, "Add file %s could not be parsed",
1357 			   add_fname);
1358 		xml_node_free(ctx->xml, pps);
1359 		return;
1360 	}
1361 
1362 	res = oma_dm_add(ctx, add, pps, pps_fname);
1363 	wpa_printf(MSG_INFO, "oma_dm_add --> %d", res);
1364 
1365 	xml_node_free(ctx->xml, pps);
1366 	xml_node_free(ctx->xml, add);
1367 }
1368 
1369 
cmd_oma_dm_replace(struct hs20_osu_client * ctx,const char * pps_fname,const char * replace_fname)1370 void cmd_oma_dm_replace(struct hs20_osu_client *ctx, const char *pps_fname,
1371 			const char *replace_fname)
1372 {
1373 	xml_node_t *pps, *replace;
1374 	int res;
1375 
1376 	ctx->fqdn = os_strdup("wi-fi.org");
1377 
1378 	pps = node_from_file(ctx->xml, pps_fname);
1379 	if (pps == NULL) {
1380 		wpa_printf(MSG_INFO, "PPS file %s could not be parsed",
1381 			   pps_fname);
1382 		return;
1383 	}
1384 
1385 	replace = node_from_file(ctx->xml, replace_fname);
1386 	if (replace == NULL) {
1387 		wpa_printf(MSG_INFO, "Replace file %s could not be parsed",
1388 			   replace_fname);
1389 		xml_node_free(ctx->xml, pps);
1390 		return;
1391 	}
1392 
1393 	res = oma_dm_replace(ctx, replace, pps, pps_fname);
1394 	wpa_printf(MSG_INFO, "oma_dm_replace --> %d", res);
1395 
1396 	xml_node_free(ctx->xml, pps);
1397 	xml_node_free(ctx->xml, replace);
1398 }
1399