Context Navigation

source: src/router/httpd/validate/webs.c @ 14241

Last change on this file since 14241 was 14241, checked in by BrainSlayer, 3 years ago
cosmetic fixes and special settings for buffalo
File size: 81.2 KB

Line
1	#define VALIDSOURCE 1
2
3	#ifdef WEBS
4	#include <webs.h>
5	#include <uemf.h>
6	#include <ej.h>
7	#else /* !WEBS */
8	#include <stdio.h>
9	#include <stdlib.h>
10	#include <string.h>
11	#include <ctype.h>
12	#include <unistd.h>
13	#include <limits.h>
14	#include <sys/types.h>
15	#include <sys/stat.h>
16	#include <sys/socket.h>
17	#include <netinet/in.h>
18	#include <arpa/inet.h>
19	#include <httpd.h>
20	#include <errno.h>
21	#endif /* WEBS */
22
23	#include <proto/ethernet.h>
24	#include <fcntl.h>
25	#include <signal.h>
26	#include <time.h>
27	#include <sys/klog.h>
28	#include <sys/wait.h>
29	#include <cyutils.h>
30	#include <support.h>
31	#include <cy_conf.h>
32	// #ifdef EZC_SUPPORT
33	#include <ezc.h>
34	// #endif
35	#include <broadcom.h>
36	#include <wlutils.h>
37	#include <netdb.h>
38	#include <utils.h>
39	#include <stdarg.h>
40	#include <sha1.h>
41
42	extern char (websGetVar) (webs_t wp, char var, char d);
43
44	void wan_proto(webs_t wp)
45	{
46	char *enable;
47
48	enable = websGetVar(wp, "wan_proto", NULL);
49	nvram_set("wan_proto", enable);
50	}
51
52	#ifdef FILTER_DEBUG
53	extern FILE *debout;
54
55	#define D(a) fprintf(debout,"%s\n",a); fflush(debout);
56	#else
57	#define D(a)
58	#endif
59
60	void dhcpfwd(webs_t wp)
61	{
62	char *enable;
63
64	enable = websGetVar(wp, "dhcpfwd_enable", NULL);
65	nvram_set("dhcpfwd_enable", enable);
66
67	}
68
69	#ifdef HAVE_CCONTROL
70
71	void execute(webs_t wp);
72
73	{
74	char command[256];
75	char *var = websGetVar(wp, "command", "");
76
77	sysprintf("%s > /tmp/.result");
78	}
79
80	#endif
81	void clone_mac(webs_t wp)
82	{
83	nvram_set("clone_wan_mac", "1");
84	}
85
86	/*
87	* Delete lease
88	*/
89	void delete_leases(webs_t wp)
90	{
91	char *iface;
92	char *ip;
93	char *mac;
94
95	if (nvram_match("lan_proto", "static"))
96	return;
97
98	if (nvram_match("fon_enable", "1")
99	\|\| (nvram_match("chilli_nowifibridge", "1")
100	&& nvram_match("chilli_enable", "1"))) {
101	iface = nvram_safe_get("wl0_ifname");
102	} else {
103	if (nvram_match("chilli_enable", "1"))
104	iface = nvram_safe_get("wl0_ifname");
105	else
106	iface = nvram_safe_get("lan_ifname");
107	}
108	//todo. detect correct interface
109
110	ip = websGetVar(wp, "ip_del", NULL);
111	mac = websGetVar(wp, "mac_del", NULL);
112
113	sysprintf("dhcp_release %s %s %s", iface, ip, mac);
114	}
115
116	#if defined(HAVE_PPTPD) \|\| defined(HAVE_PPPOESERVER)
117	void delete_pptp(webs_t wp)
118	{
119	char *iface;
120	iface = websGetVar(wp, "if_del", NULL);
121	if (iface)
122	sysprintf("kill %s", iface);
123	}
124	#endif
125	void save_wifi(webs_t wp)
126	{
127	// fprintf (stderr, "save wifi\n");
128	char *var = websGetVar(wp, "wifi_display", NULL);
129
130	if (var) {
131	nvram_set("wifi_display", var);
132	}
133	}
134
135	void dhcp_renew(webs_t wp)
136	{
137	killall("igmprt", SIGTERM);
138	killall("udhcpc", SIGUSR1);
139	}
140
141	void dhcp_release(webs_t wp)
142	{
143
144	killall("igmprt", SIGTERM);
145	nvram_set("wan_ipaddr", "0.0.0.0");
146	nvram_set("wan_netmask", "0.0.0.0");
147	nvram_set("wan_gateway", "0.0.0.0");
148	nvram_set("wan_get_dns", "");
149	nvram_set("wan_lease", "0");
150
151	unlink("/tmp/get_lease_time");
152	unlink("/tmp/lease_time");
153
154	}
155
156	void stop_ppp(webs_t wp)
157	{
158	unlink("/tmp/ppp/log");
159	unlink("/tmp/ppp/link");
160	}
161
162	void validate_filter_tod(webs_t wp)
163	{
164	char buf[256] = "";
165	char tod_buf[20];
166	struct variable filter_tod_variables[] = {
167	{argv:ARGV("20")},
168	{argv:ARGV("0", "1", "2")},
169
170	}, *which;
171
172	char day_all, week0, week1, week2, week3, week4, week5, week6;
173	char time_all, start_hour, start_min, end_hour, *end_min;
174	int _start_hour, _start_min, _end_hour, _end_min;
175	char time[20];
176	int week[7];
177	int i, flag = -1, dash = 0;
178	char filter_tod[] = "filter_todXXX";
179	char filter_tod_buf[] = "filter_tod_bufXXX";
180
181	which = &filter_tod_variables[0];
182
183	day_all = websGetVar(wp, "day_all", "0");
184	week0 = websGetVar(wp, "week0", "0");
185	week1 = websGetVar(wp, "week1", "0");
186	week2 = websGetVar(wp, "week2", "0");
187	week3 = websGetVar(wp, "week3", "0");
188	week4 = websGetVar(wp, "week4", "0");
189	week5 = websGetVar(wp, "week5", "0");
190	week6 = websGetVar(wp, "week6", "0");
191	time_all = websGetVar(wp, "time_all", "0");
192	start_hour = websGetVar(wp, "start_hour", "0");
193	start_min = websGetVar(wp, "start_min", "0");
194	// start_time = websGetVar (wp, "start_time", "0");
195	end_hour = websGetVar(wp, "end_hour", "0");
196	end_min = websGetVar(wp, "end_min", "0");
197	// end_time = websGetVar (wp, "end_time", "0");
198
199	// if(atoi(time_all) == 0)
200	// if(!start_hour \|\| !start_min \|\| !start_time \|\| !end_hour \|\| !end_min
201	// \|\| !end_time)
202	// return 1;
203
204	if (atoi(day_all) == 1) {
205	strcpy(time, "0-6");
206	strcpy(tod_buf, "7");
207	} else {
208	week[0] = atoi(week0);
209	week[1] = atoi(week1);
210	week[2] = atoi(week2);
211	week[3] = atoi(week3);
212	week[4] = atoi(week4);
213	week[5] = atoi(week5);
214	week[6] = atoi(week6);
215	strcpy(time, "");
216
217	for (i = 0; i < 7; i++) {
218	if (week[i] == 1) {
219	if (i == 6) {
220	if (dash == 0 && flag == 1)
221	sprintf(time + strlen(time),
222	"%c", '-');
223	sprintf(time + strlen(time), "%d", i);
224	} else if (flag == 1 && dash == 0) {
225	sprintf(time + strlen(time), "%c", '-');
226	dash = 1;
227	} else if (dash == 0) {
228	sprintf(time + strlen(time), "%d", i);
229	flag = 1;
230	dash = 0;
231	}
232	} else {
233	if (!strcmp(time, ""))
234	continue;
235	if (dash == 1)
236	sprintf(time + strlen(time), "%d",
237	i - 1);
238	if (flag != 0)
239	sprintf(time + strlen(time), "%c", ',');
240	flag = 0;
241	dash = 0;
242	}
243	}
244	if (time[strlen(time) - 1] == ',')
245	time[strlen(time) - 1] = '\0';
246
247	snprintf(tod_buf, sizeof(tod_buf), "%s %s %s %s %s %s %s",
248	week0, week1, week2, week3, week4, week5, week6);
249	}
250	if (atoi(time_all) == 1) {
251	_start_hour = 0;
252	_start_min = 0;
253	_end_hour = 23;
254	_end_min = 59;
255	} else {
256	_start_hour = atoi(start_hour);
257	_start_min = atoi(start_min);
258	_end_hour = atoi(end_hour);
259	_end_min = atoi(end_min);
260	}
261
262	sprintf(buf, "%d:%d %d:%d %s", _start_hour, _start_min, _end_hour,
263	_end_min, time);
264	snprintf(filter_tod, sizeof(filter_tod), "filter_tod%s",
265	nvram_safe_get("filter_id"));
266	snprintf(filter_tod_buf, sizeof(filter_tod_buf), "filter_tod_buf%s",
267	nvram_safe_get("filter_id"));
268
269	nvram_set(filter_tod, buf);
270	nvram_set(filter_tod_buf, tod_buf);
271	D("everything okay");
272
273	}
274
275	static void applytake(char *value)
276	{
277	if (value && !strcmp(value, "ApplyTake")) {
278	nvram_commit();
279	service_restart();
280	}
281	}
282
283	void save_policy(webs_t wp)
284	{
285	char f_id, f_name, f_status, f_status2;
286	char buf[256] = "";
287	char *value = websGetVar(wp, "action", "");
288	struct variable filter_variables[] = {
289	{argv:ARGV("1", "10")},
290	{argv:ARGV("0", "1", "2")},
291	{argv:ARGV("deny", "allow")},
292
293	}, *which;
294	char filter_buf[] = "filter_ruleXXX";
295
296	D("save policy");
297	which = &filter_variables[0];
298	f_id = websGetVar(wp, "f_id", NULL);
299	f_name = websGetVar(wp, "f_name", NULL);
300	f_status = websGetVar(wp, "f_status", NULL); // 0=>Disable /
301	// 1,2=>Enable
302	f_status2 = websGetVar(wp, "f_status2", NULL); // deny=>Deny /
303	// allow=>Allow
304	if (!f_id \|\| !f_name \|\| !f_status \|\| !f_status2) {
305	D("invalid");
306	return;
307	}
308	if (!valid_range(wp, f_id, &which[0])) {
309	D("invalid");
310	return;
311	}
312	if (!valid_choice(wp, f_status, &which[1])) {
313	D("invalid");
314	return;
315	}
316	if (!valid_choice(wp, f_status2, &which[2])) {
317	D("invalid");
318	return;
319	}
320
321	validate_filter_tod(wp);
322
323	snprintf(filter_buf, sizeof(filter_buf), "filter_rule%s",
324	nvram_safe_get("filter_id"));
325
326	// Add $DENY to decide that users select Allow or Deny, if status is
327	// Disable // 2003/10/21
328	snprintf(buf, sizeof(buf), "$STAT:%s$NAME:%s$DENY:%d$$", f_status,
329	f_name, !strcmp(f_status2, "deny") ? 1 : 0);
330
331	nvram_set(filter_buf, buf);
332	applytake(value);
333
334	D("okay");
335	}
336
337	void validate_filter_policy(webs_t wp, char value, struct variable v)
338	{
339	char *f_id = websGetVar(wp, "f_id", NULL);
340
341	if (f_id)
342	nvram_set("filter_id", f_id);
343	else
344	nvram_set("filter_id", "1");
345
346	save_policy(wp);
347	}
348
349	char *num_to_protocol(int num)
350	{
351	switch (num) {
352	case 1:
353	return "icmp";
354	case 6:
355	return "tcp";
356	case 17:
357	return "udp";
358	case 23:
359	return "both";
360	case 99:
361	return "l7";
362	case 100:
363	return "p2p";
364	default:
365	return "unknown";
366	}
367	}
368
369	/*
370	* Format: 21:21:tcp:FTP( )500:1000:both:TEST1
371	*/
372
373	void validate_services_port(webs_t wp)
374	{
375	char buf = (char )malloc(8192);
376	char services = (char )malloc(8192);
377	memset(buf, 0, 8192);
378	memset(services, 0, 8192);
379	char cur = buf, svcs = NULL;
380
381	char *services_array = websGetVar(wp, "services_array0", NULL);
382
383	// char *services_length = websGetVar (wp, "services_length0", NULL);
384	char word[1026], *next;
385	char delim[] = "( )";
386	char var[32] = "";
387	int index = 0;
388	do {
389	snprintf(var, 31, "services_array%d", index++);
390	svcs = websGetVar(wp, var, NULL);
391	if (svcs)
392	strcat(services, svcs);
393
394	}
395	while (svcs);
396
397	services_array = services;
398
399	split(word, services_array, next, delim) {
400	int from, to, proto;
401	char name[80];
402
403	if (sscanf(word, "%d:%d:%d:%s", &from, &to, &proto, name) != 4)
404	continue;
405
406	cur +=
407	snprintf(cur, buf + 8192 - cur,
408	"%s$NAME:%03d:%s$PROT:%03d:%s$PORT:%03d:%d:%d",
409	cur == buf ? "" : "< >", strlen(name), name,
410	strlen(num_to_protocol(proto)),
411	num_to_protocol(proto),
412	(int)(get_int_len(from) + get_int_len(to) +
413	strlen(":")), from, to);
414	}
415
416	// segment filter_services into <= 1024 byte lengths
417	cur = buf;
418	// fprintf (stderr, "cur=%s\n", cur);
419
420	memcpy(word, cur, 1024);
421	word[1025] = 0;
422	nvram_set("filter_services", word);
423	cur += 1024;
424
425	if (strlen(cur) > 0) {
426	nvram_set("filter_services_1", cur);
427	}
428	free(services);
429	free(buf);
430	// nvram_set ("filter_services", cur);
431	D("okay");
432	}
433
434	void save_services_port(webs_t wp)
435	{
436	validate_services_port(wp);
437	char *value = websGetVar(wp, "action", "");
438	applytake(value);
439	}
440
441	void delete_policy(webs_t wp, int which)
442	{
443	D("delete policy");
444
445	nvram_nset("", "filter_rule%d", which);
446	nvram_nset("", "filter_tod%d", which);
447	nvram_nset("", "filter_tod_buf%d", which);
448	nvram_nset("", "filter_web_host%d", which);
449	nvram_nset("", "filter_web_url%d", which);
450	nvram_nset("", "filter_ip_grp%d", which);
451	nvram_nset("", "filter_mac_grp%d", which);
452	nvram_nset("", "filter_port_grp%d", which);
453	nvram_nset("", "filter_dport_grp%d", which);
454
455	D("okay");
456	}
457
458	void single_delete_policy(webs_t wp)
459	{
460	char *id = nvram_safe_get("filter_id");
461
462	D("single delete policy");
463	delete_policy(wp, atoi(id));
464	D("okay");
465	return;
466	}
467
468	void summary_delete_policy(webs_t wp)
469	{
470	int i;
471
472	D("summary delete policy");
473	for (i = 1; i <= 10; i++) {
474	char filter_sum[] = "sumXXX";
475	char *sum;
476
477	snprintf(filter_sum, sizeof(filter_sum), "sum%d", i);
478	sum = websGetVar(wp, filter_sum, NULL);
479	if (sum)
480	delete_policy(wp, i);
481	}
482	D("okay");
483	}
484
485	void addDeletion(char *word)
486	{
487	char *oldarg = nvram_get("action_service_arg1");
488
489	if (oldarg && strlen(oldarg) > 0) {
490	char *newarg = malloc(strlen(oldarg) + strlen(word) + 2);
491
492	sprintf(newarg, "%s %s", oldarg, word);
493	nvram_set("action_service_arg1", newarg);
494	free(newarg);
495	} else
496	nvram_set("action_service_arg1", word);
497	}
498
499	void delete_static_route(webs_t wp)
500	{
501	addAction("routing");
502	char *buf = malloc(1000);
503	char *buf_name = malloc(1000);
504
505	memset(buf, 0, 1000);
506	memset(buf_name, 0, 1000);
507	char *cur = buf;
508	char *cur_name = buf_name;
509	static char word[256], *next;
510	static char word_name[256], *next_name;
511	char *page = websGetVar(wp, "route_page", NULL);
512	char *value = websGetVar(wp, "action", "");
513	int i = 0;
514	char *performance = nvram_safe_get("static_route");
515	char *performance2 = nvram_safe_get("static_route_name");
516
517	foreach(word, performance, next) {
518	if (i == atoi(page)) {
519	addDeletion(word);
520	i++;
521	continue;
522	}
523
524	cur += snprintf(cur, buf + 1000 - cur, "%s%s",
525	cur == buf ? "" : " ", word);
526
527	i++;
528	}
529
530	i = 0;
531	foreach(word_name, performance2, next_name) {
532	if (i == atoi(page)) {
533	i++;
534	continue;
535	}
536	cur_name +=
537	snprintf(cur_name, buf_name + 1000 - cur_name, "%s%s",
538	cur_name == buf_name ? "" : " ", word_name);
539
540	i++;
541	}
542
543	nvram_set("static_route", buf);
544	nvram_set("static_route_name", buf_name);
545	free(buf_name);
546	free(buf);
547	applytake(value);
548	return;
549	}
550
551	extern void gen_key(char *genstr, int weptype);
552
553	extern unsigned char key128[4][13];
554	extern unsigned char key64[4][5];
555
556	void generate_wep_key(webs_t wp)
557	{
558	int i;
559	char buf[256];
560	char prefix, passphrase, bit, tx;
561
562	#ifdef HAVE_MADWIFI
563	prefix = websGetVar(wp, "security_varname", "ath0");
564	#else
565	prefix = websGetVar(wp, "security_varname", "wl");
566	#endif
567	char var[80];
568
569	sprintf(var, "%s_wep_bit", prefix);
570	bit = websGetVar(wp, var, NULL);
571	if (bit != NULL)
572	nvram_set("wl_wep_bit", bit);
573	sprintf(var, "%s_passphrase", prefix);
574	passphrase = websGetVar(wp, var, NULL);
575	sprintf(var, "%s_key", prefix);
576	tx = websGetVar(wp, var, NULL);
577	cprintf("gen wep key: bits = %s\n", bit);
578	if (!prefix \|\| !bit \|\| !passphrase \|\| !tx)
579	return;
580
581	gen_key(passphrase, atoi(bit));
582
583	nvram_set("generate_key", "1");
584
585	if (atoi(bit) == 64) {
586	char key1[27] = "";
587	char key2[27] = "";
588	char key3[27] = "";
589	char key4[27] = "";
590
591	for (i = 0; i < 5; i++)
592	sprintf(key1 + (i << 1), "%02X", key64[0][i]);
593	for (i = 0; i < 5; i++)
594	sprintf(key2 + (i << 1), "%02X", key64[1][i]);
595	for (i = 0; i < 5; i++)
596	sprintf(key3 + (i << 1), "%02X", key64[2][i]);
597	for (i = 0; i < 5; i++)
598	sprintf(key4 + (i << 1), "%02X", key64[3][i]);
599
600	snprintf(buf, sizeof(buf), "%s:%s:%s:%s:%s:%s", passphrase,
601	key1, key2, key3, key4, tx);
602	// nvram_set("wl_wep_gen_64",buf);
603	cprintf("buf = %s\n", buf);
604	sprintf(var, "%s_wep_gen", prefix);
605
606	nvram_set(var, buf);
607	nvram_nset(key1, "%s_key1", prefix);
608	nvram_nset(key2, "%s_key2", prefix);
609	nvram_nset(key3, "%s_key3", prefix);
610	nvram_nset(key4, "%s_key4", prefix);
611	} else if (atoi(bit) == 128) {
612	char key1[27] = "";
613	char key2[27] = "";
614	char key3[27] = "";
615	char key4[27] = "";
616
617	for (i = 0; i < 13; i++)
618	sprintf(key1 + (i << 1), "%02X", key128[0][i]);
619	key1[26] = 0;
620
621	for (i = 0; i < 13; i++)
622	sprintf(key2 + (i << 1), "%02X", key128[1][i]);
623	key2[26] = 0;
624
625	for (i = 0; i < 13; i++)
626	sprintf(key3 + (i << 1), "%02X", key128[2][i]);
627	key3[26] = 0;
628
629	for (i = 0; i < 13; i++)
630	sprintf(key4 + (i << 1), "%02X", key128[3][i]);
631	key4[26] = 0;
632	// cprintf("passphrase[%s]\n", passphrase);
633	// filter_name(passphrase, new_passphrase, sizeof(new_passphrase),
634	// SET);
635	// cprintf("new_passphrase[%s]\n", new_passphrase);
636	cprintf("key1 = %s\n", key1);
637	cprintf("key2 = %s\n", key2);
638	cprintf("key3 = %s\n", key3);
639	cprintf("key4 = %s\n", key4);
640
641	snprintf(buf, sizeof(buf), "%s:%s:%s:%s:%s:%s", passphrase,
642	key1, key2, key3, key4, tx);
643	cprintf("buf = %s\n", buf);
644	// nvram_set("wl_wep_gen_128",buf);
645	sprintf(var, "%s_wep_gen", prefix);
646	nvram_set(var, buf);
647	nvram_nset(key1, "%s_key1", prefix);
648	nvram_nset(key2, "%s_key2", prefix);
649	nvram_nset(key3, "%s_key3", prefix);
650	nvram_nset(key4, "%s_key4", prefix);
651	}
652
653	return;
654	}
655
656	void copytonv(webs_t wp, const char *fmt, ...)
657	{
658	char varbuf[64];
659	va_list args;
660
661	va_start(args, (char *)fmt);
662	vsnprintf(varbuf, sizeof(varbuf), fmt, args);
663	va_end(args);
664
665	char *wl = websGetVar(wp, varbuf, NULL);
666
667	if (wl)
668	nvram_set(varbuf, wl);
669	}
670
671	void copytonv2(webs_t wp, char prefix_get, char prefix_set, char *name)
672	{
673	char tmpname[64];
674
675	sprintf(tmpname, "%s_%s", prefix_get, name);
676
677	char *wl = websGetVar(wp, tmpname, NULL);
678
679	sprintf(tmpname, "%s_%s", prefix_set, name);
680
681	if (wl)
682	nvram_set(tmpname, wl);
683	}
684
685	void copytonv2_wme(webs_t wp, char prefix_get, char prefix_set, char *name,
686	int maxindex)
687	{
688	char tmpvalue[128] = "";
689	char tmpname[64];
690	char *next;
691	char *wl;
692	int i;
693
694	for (i = 0; i <= maxindex; i++) {
695	sprintf(tmpname, "%s_%s%d", prefix_get, name, i);
696	wl = websGetVar(wp, tmpname, NULL);
697	if (wl) {
698	strcat(tmpvalue, wl);
699	strcat(tmpvalue, " ");
700	}
701	}
702
703	sprintf(tmpname, "%s_%s", prefix_set, name);
704	strtrim_right(tmpvalue, ' ');
705	nvram_set(tmpname, tmpvalue);
706	}
707
708	extern int get_merge_ipaddr(webs_t wp, char name, char ipaddr);
709
710	static void save_secprefix(webs_t wp, char *prefix)
711	{
712	char n[80];
713	char radius[80];
714	char p2[80];
715
716	strcpy(p2, prefix);
717	if (contains(prefix, '.'))
718	rep(p2, '.', 'X'); // replace invalid characters for sub ifs
719
720	#ifdef HAVE_WPA_SUPPLICANT
721
722	/*_8021xtype
723	_8021xuser
724	_8021xpasswd
725	_8021xca
726	_8021xpem
727	_8021xprv
728	*/
729	copytonv(wp, "%s_8021xtype", prefix);
730	copytonv(wp, "%s_tls8021xuser", prefix);
731	copytonv(wp, "%s_tls8021xanon", prefix);
732	copytonv(wp, "%s_tls8021xpasswd", prefix);
733	copytonv(wp, "%s_tls8021xphase2", prefix);
734	copytonv(wp, "%s_tls8021xca", prefix);
735	copytonv(wp, "%s_tls8021xpem", prefix);
736	copytonv(wp, "%s_tls8021xprv", prefix);
737	copytonv(wp, "%s_tls8021xaddopt", prefix);
738	copytonv(wp, "%s_peap8021xuser", prefix);
739	copytonv(wp, "%s_peap8021xanon", prefix);
740	copytonv(wp, "%s_peap8021xpasswd", prefix);
741	copytonv(wp, "%s_peap8021xphase2", prefix);
742	copytonv(wp, "%s_peap8021xca", prefix);
743	copytonv(wp, "%s_peap8021xaddopt", prefix);
744	copytonv(wp, "%s_ttls8021xuser", prefix);
745	copytonv(wp, "%s_ttls8021xanon", prefix);
746	copytonv(wp, "%s_ttls8021xpasswd", prefix);
747	copytonv(wp, "%s_ttls8021xphase2", prefix);
748	copytonv(wp, "%s_ttls8021xca", prefix);
749	copytonv(wp, "%s_ttls8021xaddopt", prefix);
750	copytonv(wp, "%s_leap8021xuser", prefix);
751	copytonv(wp, "%s_leap8021xanon", prefix);
752	copytonv(wp, "%s_leap8021xpasswd", prefix);
753	copytonv(wp, "%s_leap8021xphase2", prefix);
754	copytonv(wp, "%s_leap8021xaddopt", prefix);
755
756	#endif
757
758	copytonv(wp, "%s_crypto", prefix);
759	copytonv(wp, "%s_wpa_psk", prefix);
760	copytonv(wp, "%s_wpa_gtk_rekey", prefix);
761	sprintf(n, "%s_radius_ipaddr", prefix);
762	if (get_merge_ipaddr(wp, n, radius))
763	nvram_set(n, radius);
764	copytonv(wp, "%s_radius_port", prefix);
765	copytonv(wp, "%s_radius_key", prefix);
766
767	sprintf(n, "%s_radius2_ipaddr", prefix);
768	if (get_merge_ipaddr(wp, n, radius))
769	nvram_set(n, radius);
770	copytonv(wp, "%s_radius2_port", prefix);
771	copytonv(wp, "%s_radius2_key", prefix);
772	#ifdef HAVE_MADWIFI
773	copytonv(wp, "%s_acct", prefix);
774	sprintf(n, "%s_acct_ipaddr", prefix);
775	if (get_merge_ipaddr(wp, n, radius))
776	nvram_set(n, radius);
777	copytonv(wp, "%s_acct_port", prefix);
778	copytonv(wp, "%s_acct_key", prefix);
779	#endif
780
781	copytonv(wp, "%s_radmactype", prefix);
782
783	sprintf(n, "%s_authmode", prefix);
784	char *authmode = websGetVar(wp, n, "");
785	if (strlen(authmode) == 0) {
786	nvram_set(n, "open");
787	} else {
788	copytonv(wp, n);
789	}
790	sprintf(n, "%s_key1", prefix);
791	char *key1 = websGetVar(wp, n, "");
792
793	copytonv(wp, n);
794	sprintf(n, "%s_key2", prefix);
795	char *key2 = websGetVar(wp, n, "");
796
797	copytonv(wp, n);
798	sprintf(n, "%s_key3", prefix);
799	char *key3 = websGetVar(wp, n, "");
800
801	copytonv(wp, n);
802	sprintf(n, "%s_key4", prefix);
803	char *key4 = websGetVar(wp, n, "");
804
805	copytonv(wp, n);
806	sprintf(n, "%s_passphrase", prefix);
807	char *pass = websGetVar(wp, n, "");
808
809	copytonv(wp, n);
810	sprintf(n, "%s_key", prefix);
811	char *tx = websGetVar(wp, n, "");
812	if (strlen(tx) == 0) {
813	nvram_set(n, "1");
814	} else {
815	copytonv(wp, n);
816	}
817	sprintf(n, "%s_wep_bit", prefix);
818	copytonv(wp, n);
819	char buf[128];
820
821	snprintf(buf, sizeof(buf), "%s:%s:%s:%s:%s:%s", pass,
822	key1, key2, key3, key4, tx);
823	sprintf(n, "%s_wep_buf", prefix);
824	nvram_set(n, buf);
825
826	sprintf(n, "%s_security_mode", p2);
827	char n2[80];
828
829	sprintf(n2, "%s_akm", prefix);
830	char *v = websGetVar(wp, n, NULL);
831
832	if (v) {
833	char auth[32];
834	char wep[32];
835
836	sprintf(auth, "%s_auth_mode", prefix);
837	sprintf(wep, "%s_wep", prefix);
838	if (!strcmp(v, "wep")) {
839	nvram_set(auth, "none");
840	nvram_set(wep, "enabled");
841	} else if (!strcmp(v, "radius")) {
842	nvram_set(auth, "radius");
843	nvram_set(wep, "enabled");
844	} else {
845	nvram_set(auth, "none");
846	nvram_set(wep, "disabled");
847	}
848	nvram_set(n2, v);
849	}
850
851	copytonv(wp, n);
852
853	}
854
855	static int security_save_prefix(webs_t wp, char *prefix)
856	{
857
858	save_secprefix(wp, prefix);
859	char *next;
860	char var[80];
861	char *vifs = nvram_nget("%s_vifs", prefix);
862
863	if (vifs == NULL)
864	return 0;
865	foreach(var, vifs, next) {
866	save_secprefix(wp, var);
867	}
868	// nvram_commit ();
869	return 0;
870	}
871
872	void security_save(webs_t wp)
873	{
874	char *value = websGetVar(wp, "action", "");
875
876	#ifdef HAVE_MADWIFI
877	int dc = getdevicecount();
878	int i;
879
880	for (i = 0; i < dc; i++) {
881	char b[16];
882
883	sprintf(b, "ath%d", i);
884	security_save_prefix(wp, b);
885	}
886	#else
887	int dc = get_wl_instances();
888	int i;
889
890	for (i = 0; i < dc; i++) {
891	char b[16];
892
893	sprintf(b, "wl%d", i);
894	security_save_prefix(wp, b);
895	}
896	#endif
897	applytake(value);
898	}
899
900	extern struct wl_client_mac *wl_client_macs;
901
902	void add_active_mac(webs_t wp)
903	{
904	char buf[1000] = "", *cur = buf;
905	int i, count = 0;
906
907	char *ifname = websGetVar(wp, "ifname", NULL);
908
909	nvram_set("wl_active_add_mac", "1");
910
911	for (i = 0; i < MAX_LEASES; i++) {
912	char active_mac[] = "onXXX";
913	char *index = NULL;
914
915	snprintf(active_mac, sizeof(active_mac), "%s%d", "on", i);
916	index = websGetVar(wp, active_mac, NULL);
917	if (!index)
918	continue;
919
920	count++;
921
922	cur += snprintf(cur, buf + sizeof(buf) - cur, "%s%s",
923	cur == buf ? "" : " ",
924	wl_client_macs[atoi(index)].hwaddr);
925	}
926	for (i = 0; i < MAX_LEASES; i++) {
927	char active_mac[] = "offXXX";
928	char *index;
929
930	snprintf(active_mac, sizeof(active_mac), "%s%d", "off", i);
931	index = websGetVar(wp, active_mac, NULL);
932	if (!index)
933	continue;
934
935	count++;
936	cur += snprintf(cur, buf + sizeof(buf) - cur, "%s%s",
937	cur == buf ? "" : " ",
938	wl_client_macs[atoi(index)].hwaddr);
939	}
940	char acmac[32];
941	sprintf(acmac, "%s_active_mac", ifname);
942	nvram_set(acmac, buf);
943	if (!strcmp(ifname, "wl0"))
944	nvram_set("wl_active_mac", buf);
945
946	}
947
948	void removeLineBreak(char *startup)
949	{
950	int i = 0;
951	int c = 0;
952
953	for (i = 0; i < strlen(startup); i++) {
954	if (startup[i] == '\r')
955	continue;
956	startup[c++] = startup[i];
957	}
958	startup[c++] = 0;
959
960	}
961
962	void ping_startup(webs_t wp)
963	{
964	char *startup = websGetVar(wp, "ping_ip", NULL);
965
966	// filter Windows <cr>ud
967	removeLineBreak(startup);
968
969	nvram_set("rc_startup", startup);
970	nvram_commit();
971	nvram2file("rc_startup", "/tmp/.rc_startup");
972	chmod("/tmp/.rc_startup", 0700);
973
974	return;
975
976	}
977
978	void ping_shutdown(webs_t wp)
979	{
980	char *shutdown = websGetVar(wp, "ping_ip", NULL);
981
982	// filter Windows <cr>ud
983	removeLineBreak(shutdown);
984
985	nvram_set("rc_shutdown", shutdown);
986	nvram_commit();
987	nvram2file("rc_shutdown", "/tmp/.rc_shutdown");
988	chmod("/tmp/.rc_shutdown", 0700);
989
990	return;
991
992	}
993
994	void ping_firewall(webs_t wp)
995	{
996	char *firewall = websGetVar(wp, "ping_ip", NULL);
997
998	// filter Windows <cr>ud
999	removeLineBreak(firewall);
1000	nvram_set("rc_firewall", firewall);
1001	nvram_commit();
1002	nvram2file("rc_firewall", "/tmp/.rc_firewall");
1003	chmod("/tmp/.rc_firewall", 0700);
1004
1005	return;
1006	}
1007
1008	void ping_custom(webs_t wp)
1009	{
1010	char *custom = websGetVar(wp, "ping_ip", NULL);
1011
1012	// filter Windows <cr>ud
1013	unlink("/tmp/custom.sh");
1014	removeLineBreak(custom);
1015	nvram_set("rc_custom", custom);
1016	nvram_commit();
1017	if (nvram_invmatch("rc_custom", "")) {
1018	nvram2file("rc_custom", "/tmp/custom.sh");
1019	chmod("/tmp/custom.sh", 0700);
1020	}
1021
1022	return;
1023	}
1024
1025	void ping_wol(webs_t wp)
1026	{
1027	char *wol_type = websGetVar(wp, "wol_type", NULL);
1028
1029	unlink(PING_TMP);
1030
1031	if (!wol_type \|\| !strcmp(wol_type, ""))
1032	return;
1033
1034	if (!strcmp(wol_type, "update")) {
1035	char *wol_hosts = websGetVar(wp, "wol_hosts", NULL);
1036
1037	if (!wol_hosts \|\| !strcmp(wol_hosts, ""))
1038	return;
1039
1040	nvram_set("wol_hosts", wol_hosts);
1041	nvram_set("wol_cmd", "");
1042	return;
1043	}
1044
1045	char *manual_wol_mac = websGetVar(wp, "manual_wol_mac", NULL);
1046	char *manual_wol_network = websGetVar(wp, "manual_wol_network", NULL);
1047	char *manual_wol_port = websGetVar(wp, "manual_wol_port", NULL);
1048
1049	if (!strcmp(wol_type, "manual")) {
1050	nvram_set("manual_wol_mac", manual_wol_mac);
1051	nvram_set("manual_wol_network", manual_wol_network);
1052	nvram_set("manual_wol_port", manual_wol_port);
1053	}
1054
1055	char wol_cmd[256] = { 0 };
1056	snprintf(wol_cmd, sizeof(wol_cmd), "/usr/sbin/wol -v -i %s -p %s %s",
1057	manual_wol_network, manual_wol_port, manual_wol_mac);
1058	nvram_set("wol_cmd", wol_cmd);
1059
1060	// use Wol.asp as a debugging console
1061	#ifdef HAVE_REGISTER
1062	if (!isregistered_real())
1063	return;
1064	#endif
1065	sysprintf("%s > %s 2>&1 &", wol_cmd, PING_TMP);
1066
1067	}
1068
1069	void diag_ping_start(webs_t wp)
1070	{
1071	char *ip = websGetVar(wp, "ping_ip", NULL);
1072
1073	if (!ip \|\| !strcmp(ip, ""))
1074	return;
1075
1076	unlink(PING_TMP);
1077	nvram_set("ping_ip", ip);
1078
1079	setenv("PATH", "/sbin:/bin:/usr/sbin:/usr/bin", 1);
1080	#ifdef HAVE_REGISTER
1081	if (!isregistered_real())
1082	return;
1083	#endif
1084	sysprintf("alias ping=\'ping -c 3\'; eval \"%s\" > %s 2>&1 &", ip,
1085	PING_TMP);
1086
1087	return;
1088	}
1089
1090	void diag_ping_stop(webs_t wp)
1091	{
1092	killall("ping", SIGKILL);
1093	}
1094
1095	void diag_ping_clear(webs_t wp)
1096	{
1097	unlink(PING_TMP);
1098	}
1099
1100	void save_wireless_advanced(webs_t wp)
1101	{
1102	char set_prefix[8];
1103	char prefix[8];
1104	char *wlface = websGetVar(wp, "interface", NULL);
1105
1106	if (!strcmp(wlface, "wl0"))
1107	sprintf(set_prefix, "%s", "wl");
1108	else
1109	sprintf(set_prefix, "%s", wlface);
1110
1111	sprintf(prefix, wlface);
1112
1113	copytonv2(wp, prefix, set_prefix, "auth");
1114	copytonv2(wp, prefix, set_prefix, "rateset");
1115	copytonv2(wp, prefix, set_prefix, "rate");
1116	copytonv2(wp, prefix, set_prefix, "gmode_protection");
1117	copytonv2(wp, prefix, set_prefix, "frameburst");
1118	copytonv2(wp, prefix, set_prefix, "bcn");
1119	copytonv2(wp, prefix, set_prefix, "dtim");
1120	copytonv2(wp, prefix, set_prefix, "frag");
1121	copytonv2(wp, prefix, set_prefix, "rts");
1122	copytonv2(wp, prefix, set_prefix, "maxassoc");
1123	copytonv2(wp, prefix, set_prefix, "ap_isolate");
1124	copytonv2(wp, prefix, set_prefix, "plcphdr");
1125	copytonv2(wp, prefix, set_prefix, "shortslot");
1126	copytonv2(wp, prefix, set_prefix, "afterburner");
1127	copytonv2(wp, prefix, set_prefix, "btc_mode");
1128	copytonv2(wp, prefix, set_prefix, "wme");
1129	copytonv2(wp, prefix, set_prefix, "wme_no_ack");
1130	copytonv2_wme(wp, prefix, set_prefix, "wme_ap_bk", 5);
1131	copytonv2_wme(wp, prefix, set_prefix, "wme_ap_be", 5);
1132	copytonv2_wme(wp, prefix, set_prefix, "wme_ap_vi", 5);
1133	copytonv2_wme(wp, prefix, set_prefix, "wme_ap_vo", 5);
1134	copytonv2_wme(wp, prefix, set_prefix, "wme_sta_bk", 5);
1135	copytonv2_wme(wp, prefix, set_prefix, "wme_sta_be", 5);
1136	copytonv2_wme(wp, prefix, set_prefix, "wme_sta_vi", 5);
1137	copytonv2_wme(wp, prefix, set_prefix, "wme_sta_vo", 5);
1138	copytonv2_wme(wp, prefix, set_prefix, "wme_txp_bk", 4);
1139	copytonv2_wme(wp, prefix, set_prefix, "wme_txp_be", 4);
1140	copytonv2_wme(wp, prefix, set_prefix, "wme_txp_vi", 4);
1141	copytonv2_wme(wp, prefix, set_prefix, "wme_txp_vo", 4);
1142
1143	return;
1144
1145	}
1146
1147	void save_wds(webs_t wp)
1148	{
1149	char *wds_enable_val, wds_enable_var[32] = { 0 };
1150	int h = 0;
1151	char *interface = websGetVar(wp, "interface", NULL);
1152
1153	for (h = 1; h <= MAX_WDS_DEVS; h++) {
1154	sprintf(wds_enable_var, "%s_wds%d_enable", interface, h);
1155	wds_enable_val = websGetVar(wp, wds_enable_var, NULL);
1156	nvram_set(wds_enable_var, wds_enable_val);
1157	}
1158	sprintf(wds_enable_var, "%s_br1_enable", interface);
1159	wds_enable_val = websGetVar(wp, wds_enable_var, NULL);
1160	nvram_set(wds_enable_var, wds_enable_val);
1161
1162	sprintf(wds_enable_var, "%s_br1_nat", interface);
1163	wds_enable_val = websGetVar(wp, wds_enable_var, NULL);
1164	nvram_set(wds_enable_var, wds_enable_val);
1165
1166	return;
1167
1168	}
1169
1170	int get_svc(char svc, char protocol, char *ports)
1171	{
1172	char word[1024], *next;
1173	char delim[] = "< >";
1174	char services[11000];
1175
1176	// services = nvram_safe_get("filter_services");
1177	memset(services, 0, sizeof(services));
1178	get_filter_services(services, 16384);
1179
1180	split(word, services, next, delim) {
1181	int len = 0;
1182	char name, prot, *port;
1183	int from = 0, to = 0;
1184
1185	if ((name = strstr(word, "$NAME:")) == NULL \|\|
1186	(prot = strstr(word, "$PROT:")) == NULL \|\|
1187	(port = strstr(word, "$PORT:")) == NULL)
1188	continue;
1189
1190	/*
1191	* $NAME
1192	*/
1193	if (sscanf(name, "$NAME:%3d:", &len) != 1)
1194	return -1;
1195
1196	strncpy(name, name + sizeof("$NAME:nnn:") - 1, len);
1197	name[len] = '\0';
1198
1199	if (strcasecmp(svc, name))
1200	continue;
1201
1202	/*
1203	* $PROT
1204	*/
1205	if (sscanf(prot, "$PROT:%3d:", &len) != 1)
1206	return -1;
1207
1208	strncpy(protocol, prot + sizeof("$PROT:nnn:") - 1, len);
1209	protocol[len] = '\0';
1210
1211	/*
1212	* $PORT
1213	*/
1214	if (sscanf(port, "$PORT:%3d:", &len) != 1)
1215	return -1;
1216
1217	strncpy(ports, port + sizeof("$PORT:nnn:") - 1, len);
1218	ports[len] = '\0';
1219
1220	if (sscanf(ports, "%d:%d", &from, &to) != 2)
1221	return -1;
1222
1223	if (strcasecmp(svc, name) == 0)
1224	return 0;
1225	}
1226
1227	return -1;
1228	}
1229
1230	void qos_add_svc(webs_t wp)
1231	{
1232	char *var = websGetVar(wp, "wshaper_enable", NULL);
1233
1234	if (var != NULL)
1235	nvram_set("wshaper_enable", var);
1236
1237	char protocol[100] = { 0 }, ports[100] = {
1238	0};
1239	char *add_svc = websGetVar(wp, "add_svc", NULL);
1240	char *svqos_svcs = nvram_safe_get("svqos_svcs");
1241	char new_svcs[4096] = { 0 };
1242	int i = 0;
1243
1244	memset(new_svcs, 0, sizeof(new_svcs));
1245
1246	if (get_svc(add_svc, protocol, ports))
1247	return;
1248
1249	if (strcmp(protocol, "l7") == 0) {
1250	int slen = strlen(add_svc);
1251
1252	for (i = 0; i < slen; i++)
1253	add_svc[i] = tolower(add_svc[i]);
1254	}
1255
1256	/*
1257	* if this service exists, return an error
1258	*/
1259	if (strstr(svqos_svcs, add_svc))
1260	return;
1261
1262	if (strlen(svqos_svcs) > 0)
1263	snprintf(new_svcs, 4095, "%s %s %s %s 30 \|", svqos_svcs,
1264	add_svc, protocol, ports);
1265	else
1266	snprintf(new_svcs, 4095, "%s %s %s 30 \|", add_svc, protocol,
1267	ports);
1268
1269	if (strlen(new_svcs) >= sizeof(new_svcs))
1270	return;
1271
1272	nvram_set("svqos_svcs", new_svcs);
1273	nvram_commit();
1274	}
1275
1276	void qos_add_ip(webs_t wp)
1277	{
1278	char *var = websGetVar(wp, "wshaper_enable", NULL);
1279
1280	if (var != NULL)
1281	nvram_set("wshaper_enable", var);
1282
1283	char *add_ip0 = websGetVar(wp, "svqos_ipaddr0", NULL);
1284	char *add_ip1 = websGetVar(wp, "svqos_ipaddr1", NULL);
1285	char *add_ip2 = websGetVar(wp, "svqos_ipaddr2", NULL);
1286	char *add_ip3 = websGetVar(wp, "svqos_ipaddr3", NULL);
1287	char *add_nm = websGetVar(wp, "svqos_netmask", NULL);
1288	char add_ip[19] = { 0 };
1289	char *svqos_ips = nvram_safe_get("svqos_ips");
1290	char new_ip[4096] = { 0 };
1291
1292	memset(new_ip, 0, sizeof(new_ip));
1293
1294	snprintf(add_ip, 19, "%s.%s.%s.%s/%s", add_ip0, add_ip1, add_ip2,
1295	add_ip3, add_nm);
1296
1297	/*
1298	* if this ip exists, return an error
1299	*/
1300	if (strstr(svqos_ips, add_ip))
1301	return;
1302	#ifdef HAVE_AQOS
1303	snprintf(new_ip, 4095, "%s %s 100 100 \|", svqos_ips, add_ip);
1304	#else
1305	snprintf(new_ip, 4095, "%s %s 30 \|", svqos_ips, add_ip);
1306	#endif
1307	if (strlen(new_ip) >= sizeof(new_ip))
1308	return;
1309
1310	nvram_set("svqos_ips", new_ip);
1311	nvram_commit();
1312
1313	}
1314
1315	void qos_add_mac(webs_t wp)
1316	{
1317	char *var = websGetVar(wp, "wshaper_enable", NULL);
1318
1319	if (var != NULL)
1320	nvram_set("wshaper_enable", var);
1321
1322	char *add_mac0 = websGetVar(wp, "svqos_hwaddr0", NULL);
1323	char *add_mac1 = websGetVar(wp, "svqos_hwaddr1", NULL);
1324	char *add_mac2 = websGetVar(wp, "svqos_hwaddr2", NULL);
1325	char *add_mac3 = websGetVar(wp, "svqos_hwaddr3", NULL);
1326	char *add_mac4 = websGetVar(wp, "svqos_hwaddr4", NULL);
1327	char *add_mac5 = websGetVar(wp, "svqos_hwaddr5", NULL);
1328	char add_mac[19] = { 0 };
1329	char *svqos_macs = nvram_safe_get("svqos_macs");
1330	char new_mac[4096] = { 0 };
1331
1332	memset(new_mac, 0, sizeof(new_mac));
1333
1334	snprintf(add_mac, 18, "%s:%s:%s:%s:%s:%s", add_mac0, add_mac1, add_mac2,
1335	add_mac3, add_mac4, add_mac5);
1336
1337	/*
1338	* if this mac exists, return an error
1339	*/
1340	if (strstr(svqos_macs, add_mac))
1341	return;
1342	#ifdef HAVE_AQOS
1343	snprintf(new_mac, 4095, "%s %s 100 100 user \|", svqos_macs, add_mac);
1344	#else
1345	snprintf(new_mac, 4095, "%s %s 30 \|", svqos_macs, add_mac);
1346	#endif
1347	if (strlen(new_mac) >= sizeof(new_mac))
1348	return;
1349
1350	nvram_set("svqos_macs", new_mac);
1351	nvram_commit();
1352
1353	}
1354
1355	void qos_save(webs_t wp)
1356	{
1357	char *value = websGetVar(wp, "action", "");
1358	char svqos_var[4096] = { 0 };
1359	char field[32] = { 0 };
1360	char name, data, level, level2, *delete;
1361	int no_svcs = atoi(websGetVar(wp, "svqos_nosvcs", NULL));
1362	int no_ips = atoi(websGetVar(wp, "svqos_noips", NULL));
1363	int no_macs = atoi(websGetVar(wp, "svqos_nomacs", NULL));
1364	int i = 0, j = 0;
1365
1366	/*
1367	* reused wshaper fields - see src/router/rc/wshaper.c
1368	*/
1369
1370	data = websGetVar(wp, "wshaper_enable", NULL);
1371	nvram_set("wshaper_enable", data);
1372
1373	if (strcmp(data, "0") == 0) {
1374	addAction("qos");
1375	applytake(value);
1376	return;
1377	}
1378
1379	nvram_set("enable_game", websGetVar(wp, "enable_game", NULL));
1380	nvram_set("default_uplevel", websGetVar(wp, "default_uplevel", NULL));
1381	nvram_set("default_downlevel",
1382	websGetVar(wp, "default_downlevel", NULL));
1383	nvram_set("wshaper_downlink", websGetVar(wp, "wshaper_downlink", NULL));
1384	nvram_set("wshaper_uplink", websGetVar(wp, "wshaper_uplink", NULL));
1385	nvram_set("wshaper_dev", websGetVar(wp, "wshaper_dev", NULL));
1386	nvram_set("qos_type", websGetVar(wp, "qos_type", NULL));
1387
1388	// nvram_commit ();
1389
1390	memset(svqos_var, 0, sizeof(svqos_var));
1391
1392	/*
1393	* services priorities
1394	*/
1395	for (i = 0; i < no_svcs; i++) {
1396	char protocol[100], ports[100];
1397
1398	memset(protocol, 0, 100);
1399	memset(ports, 0, 10);
1400
1401	snprintf(field, 31, "svqos_svcdel%d", i);
1402	delete = websGetVar(wp, field, NULL);
1403
1404	if (delete && strlen(delete) > 0)
1405	continue;
1406
1407	snprintf(field, 31, "svqos_svcname%d", i);
1408	name = websGetVar(wp, field, NULL);
1409
1410	snprintf(field, 31, "svqos_svcprio%d", i);
1411	level = websGetVar(wp, field, NULL);
1412
1413	if (get_svc(name, protocol, ports))
1414	continue;
1415
1416	if (strcmp(protocol, "l7") == 0) {
1417	int slen = strlen(name);
1418
1419	for (j = 0; j < slen; j++)
1420	name[j] = tolower(name[j]);
1421	}
1422
1423	if (strlen(svqos_var) > 0)
1424	sprintf(svqos_var, "%s %s %s %s %s \|", svqos_var, name,
1425	protocol, ports, level);
1426	else
1427	sprintf(svqos_var, "%s %s %s %s \|", name, protocol,
1428	ports, level);
1429
1430	}
1431
1432	if (strlen(svqos_var) <= sizeof(svqos_var))
1433	nvram_set("svqos_svcs", svqos_var);
1434	// nvram_commit ();
1435	memset(svqos_var, 0, sizeof(svqos_var));
1436
1437	/*
1438	* IP priorities
1439	*/
1440	for (i = 0; i < no_ips; i++) {
1441
1442	snprintf(field, 31, "svqos_ipdel%d", i);
1443	delete = websGetVar(wp, field, NULL);
1444
1445	if (delete && strlen(delete) > 0)
1446	continue;
1447
1448	snprintf(field, 31, "svqos_ip%d", i);
1449	data = websGetVar(wp, field, NULL);
1450
1451	#ifndef HAVE_AQOS
1452	snprintf(field, 31, "svqos_ipprio%d", i);
1453	level = websGetVar(wp, field, NULL);
1454	if (strlen(svqos_var) > 0)
1455	sprintf(svqos_var, "%s %s %s \|", svqos_var, data,
1456	level);
1457	else
1458	sprintf(svqos_var, "%s %s \|", data, level);
1459	#else
1460	snprintf(field, 31, "svqos_ipup%d", i);
1461	level = websGetVar(wp, field, NULL);
1462	snprintf(field, 31, "svqos_ipdown%d", i);
1463	level2 = websGetVar(wp, field, NULL);
1464	if (strlen(svqos_var) > 0)
1465	sprintf(svqos_var, "%s %s %s %s \|", svqos_var, data,
1466	level, level2);
1467	else
1468	sprintf(svqos_var, "%s %s %s \|", data, level, level2);
1469
1470	#endif
1471
1472	}
1473
1474	if (strlen(svqos_var) <= sizeof(svqos_var))
1475	nvram_set("svqos_ips", svqos_var);
1476	// nvram_commit ();
1477	memset(svqos_var, 0, sizeof(svqos_var));
1478
1479	/*
1480	* MAC priorities
1481	*/
1482	for (i = 0; i < no_macs; i++) {
1483	snprintf(field, 31, "svqos_macdel%d", i);
1484	delete = websGetVar(wp, field, NULL);
1485
1486	if (delete && strlen(delete) > 0)
1487	continue;
1488
1489	snprintf(field, 31, "svqos_mac%d", i);
1490	data = websGetVar(wp, field, NULL);
1491
1492	#ifndef HAVE_AQOS
1493	snprintf(field, 31, "svqos_macprio%d", i);
1494	level = websGetVar(wp, field, NULL);
1495
1496	if (strlen(svqos_var) > 0)
1497	sprintf(svqos_var, "%s %s %s \|", svqos_var, data,
1498	level);
1499	else
1500	sprintf(svqos_var, "%s %s \|", data, level);
1501	#else
1502	snprintf(field, 31, "svqos_macup%d", i);
1503	level = websGetVar(wp, field, NULL);
1504	snprintf(field, 31, "svqos_macdown%d", i);
1505	level2 = websGetVar(wp, field, NULL);
1506
1507	if (strlen(svqos_var) > 0)
1508	sprintf(svqos_var, "%s %s %s %s user \|", svqos_var,
1509	data, level, level2);
1510	else
1511	sprintf(svqos_var, "%s %s %s user \|", data, level,
1512	level2);
1513	#endif
1514
1515	}
1516
1517	if (strlen(svqos_var) <= sizeof(svqos_var))
1518	nvram_set("svqos_macs", svqos_var);
1519	// nvram_commit ();
1520
1521	/*
1522	* adm6996 LAN port priorities
1523	*/
1524	nvram_set("svqos_port1prio", websGetVar(wp, "svqos_port1prio", NULL));
1525	nvram_set("svqos_port2prio", websGetVar(wp, "svqos_port2prio", NULL));
1526	nvram_set("svqos_port3prio", websGetVar(wp, "svqos_port3prio", NULL));
1527	nvram_set("svqos_port4prio", websGetVar(wp, "svqos_port4prio", NULL));
1528
1529	nvram_set("svqos_port1bw", websGetVar(wp, "svqos_port1bw", NULL));
1530	nvram_set("svqos_port2bw", websGetVar(wp, "svqos_port2bw", NULL));
1531	nvram_set("svqos_port3bw", websGetVar(wp, "svqos_port3bw", NULL));
1532	nvram_set("svqos_port4bw", websGetVar(wp, "svqos_port4bw", NULL));
1533
1534	addAction("qos");
1535	applytake(value);
1536
1537	}
1538
1539	void macro_add(char *a)
1540	{
1541	cprintf("adding %s\n", a);
1542
1543	char *count;
1544	int c;
1545	char buf[20];
1546
1547	count = nvram_safe_get(a);
1548	cprintf("count = %s\n", count);
1549	if (count != NULL && strlen(count) > 0) {
1550	c = atoi(count);
1551	if (c > -1) {
1552	c++;
1553	sprintf(buf, "%d", c);
1554	cprintf("set %s to %s\n", a, buf);
1555	nvram_set(a, buf);
1556	}
1557	}
1558	return;
1559	}
1560
1561	void macro_rem(char a, char nv)
1562	{
1563	char *count;
1564	int c, i, cnt;
1565	char buf[20];
1566	char buffer, b;
1567
1568	cnt = 0;
1569	count = nvram_safe_get(a);
1570	if (count != NULL && strlen(count) > 0) {
1571	c = atoi(count);
1572	if (c > 0) {
1573	c--;
1574	sprintf(buf, "%d", c);
1575	nvram_set(a, buf);
1576	buffer = nvram_safe_get(nv);
1577	if (buffer != NULL) {
1578	int slen = strlen(buffer);
1579
1580	b = malloc(slen + 1);
1581
1582	for (i = 0; i < slen; i++) {
1583	if (buffer[i] == ' ')
1584	cnt++;
1585	if (cnt == c)
1586	break;
1587	b[i] = buffer[i];
1588	}
1589	b[i] = 0;
1590	nvram_set(nv, b);
1591	}
1592
1593	}
1594	}
1595	return;
1596	}
1597
1598	void forward_remove(webs_t wp)
1599	{
1600	macro_rem("forward_entries", "forward_port");
1601	}
1602
1603	void forward_add(webs_t wp)
1604	{
1605	macro_add("forward_entries");
1606	}
1607
1608	void lease_remove(webs_t wp)
1609	{
1610	macro_rem("static_leasenum", "static_leases");
1611	}
1612
1613	void lease_add(webs_t wp)
1614	{
1615	macro_add("static_leasenum");
1616	}
1617
1618	#ifdef HAVE_PPPOESERVER
1619	void chap_user_add(webs_t wp)
1620	{
1621	char *var = websGetVar(wp, "pppoeserver_enabled", NULL);
1622
1623	if (var != NULL)
1624	nvram_set("pppoeserver_enabled", var);
1625	macro_add("pppoeserver_chapsnum");
1626	}
1627
1628	void chap_user_remove(webs_t wp)
1629	{
1630	char *var = websGetVar(wp, "pppoeserver_enabled", NULL);
1631
1632	if (var != NULL)
1633	nvram_set("pppoeserver_enabled", var);
1634	macro_rem("pppoeserver_chapsnum", "pppoeserver_chaps");
1635	}
1636	#endif
1637
1638	#ifdef HAVE_MILKFISH
1639	void milkfish_user_add(webs_t wp)
1640	{
1641	macro_add("milkfish_ddsubscribersnum");
1642	}
1643
1644	void milkfish_user_remove(webs_t wp)
1645	{
1646	macro_rem("milkfish_ddsubscribersnum", "milkfish_ddsubscribers");
1647	}
1648
1649	void milkfish_alias_add(webs_t wp)
1650	{
1651	macro_add("milkfish_ddaliasesnum");
1652	}
1653
1654	void milkfish_alias_remove(webs_t wp)
1655	{
1656	macro_rem("milkfish_ddaliasesnum", "milkfish_ddaliases");
1657	}
1658	#endif
1659
1660	void forwardspec_remove(webs_t wp)
1661	{
1662	macro_rem("forwardspec_entries", "forward_spec");
1663	}
1664
1665	void forwardspec_add(webs_t wp)
1666	{
1667	macro_add("forwardspec_entries");
1668	}
1669
1670	void trigger_remove(webs_t wp)
1671	{
1672	macro_rem("trigger_entries", "port_trigger");
1673	}
1674
1675	void trigger_add(webs_t wp)
1676	{
1677	macro_add("trigger_entries");
1678	}
1679
1680	int get_vifcount(char *prefix)
1681	{
1682	char *next;
1683	char var[80];
1684	char wif[16];
1685
1686	sprintf(wif, "%s_vifs", prefix);
1687	char *vifs = nvram_safe_get(wif);
1688
1689	if (vifs == NULL)
1690	return 0;
1691	int count = 0;
1692
1693	foreach(var, vifs, next) {
1694	count++;
1695	}
1696	return count;
1697	}
1698
1699	void add_vifs_single(char *prefix, int device)
1700	{
1701	int count = get_vifcount(prefix);
1702
1703	if (count == 16)
1704	return;
1705	char vif[16];
1706
1707	sprintf(vif, "%s_vifs", prefix);
1708	char *vifs = nvram_safe_get(vif);
1709
1710	if (vifs == NULL)
1711	return;
1712	char n = (char )malloc(strlen(vifs) + 8);
1713	char v[80];
1714	char v2[80];
1715
1716	#ifdef HAVE_MADWIFI
1717	// char *cou[] = { "a", "b", "c", "d", "e", "f" };
1718	sprintf(v, "ath%d.%d", device, count + 1);
1719	#else
1720	sprintf(v, "wl%d.%d", device, count + 1);
1721	#endif
1722	if (strlen(vifs) == 0)
1723	sprintf(n, "%s", v);
1724	else
1725	sprintf(n, "%s %s", vifs, v);
1726	sprintf(v2, "%s_closed", v);
1727	nvram_set(v2, "0");
1728	sprintf(v2, "%s_mode", v);
1729	nvram_set(v2, "ap");
1730
1731	sprintf(v2, "%s_ap_isolate", v);
1732	nvram_set(v2, "0");
1733	sprintf(v2, "%s_ssid", v);
1734	#ifdef HAVE_MAKSAT
1735	#ifdef HAVE_MAKSAT_BLANK
1736	nvram_set(v2, "default_vap");
1737	#else
1738	nvram_set(v2, "maksat_vap");
1739	#endif
1740	#elif defined(HAVE_TRIMAX)
1741	nvram_set(v2, "trimax_vap");
1742	#elif defined(HAVE_WIKINGS)
1743	nvram_set(v2, "Excel Networks_vap");
1744	#elif defined(HAVE_NEXTMEDIA)
1745	nvram_set(v2, "nextmedia_vap");
1746	#elif defined(HAVE_TMK)
1747	nvram_set(v2, "KMT_vap");
1748	#elif defined(HAVE_CORENET)
1749	nvram_set(v2, "corenet.ap");
1750	#else
1751	nvram_set(v2, "dd-wrt_vap");
1752	#endif
1753	sprintf(v2, "%s_vifs", prefix);
1754	nvram_set(v2, n);
1755	sprintf(v2, "%s_bridged", v);
1756	nvram_set(v2, "1");
1757	sprintf(v2, "%s_nat", v);
1758	nvram_set(v2, "1");
1759	sprintf(v2, "%s_ipaddr", v);
1760	nvram_set(v2, "0.0.0.0");
1761	sprintf(v2, "%s_netmask", v);
1762	nvram_set(v2, "0.0.0.0");
1763
1764	sprintf(v2, "%s_gtk_rekey", v);
1765	nvram_set(v2, "3600");
1766
1767	sprintf(v2, "%s_radius_port", v);
1768	nvram_set(v2, "1812");
1769
1770	sprintf(v2, "%s_radius_ipaddr", v);
1771	nvram_set(v2, "0.0.0.0");
1772	#ifdef HAVE_MADWIFI
1773	sprintf(v2, "%s_radius2_ipaddr", v);
1774	nvram_set(v2, "0.0.0.0");
1775
1776	sprintf(v2, "%s_radius2_port", v);
1777	nvram_set(v2, "1812");
1778
1779	#endif
1780
1781	// nvram_commit ();
1782	free(n);
1783	}
1784
1785	void add_vifs(webs_t wp)
1786	{
1787	char *prefix = websGetVar(wp, "iface", NULL);
1788
1789	if (prefix == NULL)
1790	return;
1791	int devcount = prefix[strlen(prefix) - 1] - '0';
1792
1793	add_vifs_single(prefix, devcount);
1794	}
1795
1796	void remove_vifs_single(char *prefix)
1797	{
1798	char wif[16];
1799
1800	sprintf(wif, "%s_vifs", prefix);
1801	int o = -1;
1802	char *vifs = nvram_safe_get(wif);
1803	char copy[128];
1804
1805	strcpy(copy, vifs);
1806	int i;
1807	int slen = strlen(copy);
1808
1809	for (i = 0; i < slen; i++) {
1810	if (copy[i] == 0x20)
1811	o = i;
1812	}
1813	if (o == -1) {
1814	nvram_set(wif, "");
1815	} else {
1816	copy[o] = 0;
1817	nvram_set(wif, copy);
1818	}
1819	// nvram_commit ();
1820	}
1821
1822	void remove_vifs(webs_t wp)
1823	{
1824	char *prefix = websGetVar(wp, "iface", NULL);
1825
1826	remove_vifs_single(prefix);
1827	}
1828
1829	#ifdef HAVE_BONDING
1830	void add_bond(webs_t wp)
1831	{
1832	static char word[256];
1833	char next, wordlist;
1834	int count = 0;
1835	int realcount = atoi(nvram_safe_get("bonding_count"));
1836
1837	if (realcount == 0) {
1838	wordlist = nvram_safe_get("bondings");
1839	foreach(word, wordlist, next) {
1840	count++;
1841	}
1842	realcount = count;
1843	}
1844	realcount++;
1845	char var[32];
1846
1847	sprintf(var, "%d", realcount);
1848	nvram_set("bonding_count", var);
1849	nvram_commit();
1850	return;
1851	}
1852
1853	void del_bond(webs_t wp)
1854	{
1855	static char word[256];
1856	int realcount = 0;
1857	char next, wordlist, *newwordlist;
1858	char *val = websGetVar(wp, "del_value", NULL);
1859
1860	if (val == NULL)
1861	return;
1862	int todel = atoi(val);
1863
1864	wordlist = nvram_safe_get("bondings");
1865	newwordlist = (char *)malloc(strlen(wordlist));
1866	memset(newwordlist, 0, strlen(wordlist));
1867	int count = 0;
1868
1869	foreach(word, wordlist, next) {
1870	if (count != todel) {
1871	strcat(newwordlist, word);
1872	strcat(newwordlist, " ");
1873	}
1874	count++;
1875	}
1876
1877	char var[32];
1878
1879	realcount = atoi(nvram_safe_get("bonding_count")) - 1;
1880	sprintf(var, "%d", realcount);
1881	nvram_set("bonding_count", var);
1882	nvram_set("bondings", newwordlist);
1883	nvram_commit();
1884	free(newwordlist);
1885
1886	return;
1887	}
1888	#endif
1889
1890	#ifdef HAVE_OLSRD
1891	void add_olsrd(webs_t wp)
1892	{
1893	char *ifname = websGetVar(wp, "olsrd_ifname", NULL);
1894
1895	if (ifname == NULL)
1896	return;
1897	char *wordlist = nvram_safe_get("olsrd_interfaces");
1898	char *addition = ">5.0>90.0>2.0>270.0>15.0>90.0>15.0>90.0";
1899	char *newadd =
1900	(char *)malloc(strlen(wordlist) + strlen(addition) +
1901	strlen(ifname) + 2);
1902	if (strlen(wordlist) > 0) {
1903	strcpy(newadd, wordlist);
1904	strcat(newadd, " ");
1905	strcat(newadd, ifname);
1906	} else {
1907	strcpy(newadd, ifname);
1908	}
1909	strcat(newadd, addition);
1910	nvram_set("olsrd_interfaces", newadd);
1911	nvram_commit();
1912	free(newadd);
1913	return;
1914	}
1915
1916	void del_olsrd(webs_t wp)
1917	{
1918	char *del = websGetVar(wp, "olsrd_delcount", NULL);
1919
1920	if (del == NULL)
1921	return;
1922	int d = atoi(del);
1923	char *wordlist = nvram_safe_get("olsrd_interfaces");
1924	char newlist = (char )malloc(strlen(wordlist) + 1);
1925
1926	memset(newlist, 0, strlen(wordlist));
1927	char *next;
1928	char word[128];
1929	int count = 0;
1930
1931	foreach(word, wordlist, next) {
1932	if (count != d)
1933	sprintf(newlist, "%s %s", newlist, word);
1934	count++;
1935	}
1936	nvram_set("olsrd_interfaces", newlist);
1937	nvram_commit();
1938	free(newlist);
1939	return;
1940	}
1941
1942	void save_olsrd(webs_t wp)
1943	{
1944	char *wordlist = nvram_safe_get("olsrd_interfaces");
1945	char newlist = (char )malloc(strlen(wordlist) + 512);
1946
1947	memset(newlist, 0, strlen(wordlist) + 512);
1948	char *next;
1949	char word[64];
1950
1951	foreach(word, wordlist, next) {
1952	char *interface = word;
1953	char *dummy = interface;
1954
1955	strsep(&dummy, ">");
1956	char valuename[32];
1957
1958	sprintf(valuename, "%s_hellointerval", interface);
1959	char *hellointerval = websGetVar(wp, valuename, "0");
1960
1961	sprintf(valuename, "%s_hellovaliditytime", interface);
1962	char *hellovaliditytime = websGetVar(wp, valuename, "0");
1963
1964	sprintf(valuename, "%s_tcinterval", interface);
1965	char *tcinterval = websGetVar(wp, valuename, "0");
1966
1967	sprintf(valuename, "%s_tcvaliditytime", interface);
1968	char *tcvaliditytime = websGetVar(wp, valuename, "0");
1969
1970	sprintf(valuename, "%s_midinterval", interface);
1971	char *midinterval = websGetVar(wp, valuename, "0");
1972
1973	sprintf(valuename, "%s_midvaliditytime", interface);
1974	char *midvaliditytime = websGetVar(wp, valuename, "0");
1975
1976	sprintf(valuename, "%s_hnainterval", interface);
1977	char *hnainterval = websGetVar(wp, valuename, "0");
1978
1979	sprintf(valuename, "%s_hnavaliditytime", interface);
1980	char *hnavaliditytime = websGetVar(wp, valuename, "0");
1981
1982	sprintf(newlist, "%s %s>%s>%s>%s>%s>%s>%s>%s>%s", newlist,
1983	interface, hellointerval, hellovaliditytime, tcinterval,
1984	tcvaliditytime, midinterval, midvaliditytime,
1985	hnainterval, hnavaliditytime);
1986	}
1987	nvram_set("olsrd_interfaces", newlist);
1988	nvram_commit();
1989	free(newlist);
1990	return;
1991	}
1992	#endif
1993
1994	#ifdef HAVE_VLANTAGGING
1995
1996	void save_networking(webs_t wp)
1997	{
1998	char *value = websGetVar(wp, "action", "");
1999	int vlancount = atoi(nvram_safe_get("vlan_tagcount"));
2000	int bridgescount = atoi(nvram_safe_get("bridges_count"));
2001	int bridgesifcount = atoi(nvram_safe_get("bridgesif_count"));
2002	int mdhcpd_count = atoi(nvram_safe_get("mdhcpd_count"));
2003
2004	#ifdef HAVE_BONDING
2005	int bondcount = atoi(nvram_safe_get("bonding_count"));
2006	#endif
2007	int i;
2008
2009	// save vlan stuff
2010	char buffer[1024];
2011
2012	memset(buffer, 0, 1024);
2013	for (i = 0; i < vlancount; i++) {
2014	char ifname, tag, *prio;
2015	char var[32];
2016
2017	sprintf(var, "vlanifname%d", i);
2018	ifname = websGetVar(wp, var, NULL);
2019	if (!ifname)
2020	return;
2021	sprintf(var, "vlantag%d", i);
2022	tag = websGetVar(wp, var, NULL);
2023	if (!tag)
2024	return;
2025	sprintf(var, "vlanprio%d", i);
2026	prio = websGetVar(wp, var, NULL);
2027	if (!prio)
2028	return;
2029	strcat(buffer, ifname);
2030	strcat(buffer, ">");
2031	strcat(buffer, tag);
2032	strcat(buffer, ">");
2033	strcat(buffer, prio);
2034	if (i < vlancount - 1)
2035	strcat(buffer, " ");
2036	}
2037	nvram_set("vlan_tags", buffer);
2038	// save bonds
2039	memset(buffer, 0, 1024);
2040	#ifdef HAVE_BONDING
2041	char *bondingnumber = websGetVar(wp, "bonding_number", NULL);
2042
2043	if (bondingnumber)
2044	nvram_set("bonding_number", bondingnumber);
2045	char *bondingtype = websGetVar(wp, "bonding_type", NULL);
2046
2047	if (bondingtype)
2048	nvram_set("bonding_type", bondingtype);
2049	for (i = 0; i < bondcount; i++) {
2050	char ifname, tag;
2051	char var[32];
2052
2053	sprintf(var, "bondingifname%d", i);
2054	ifname = websGetVar(wp, var, NULL);
2055	if (!ifname)
2056	return;
2057	sprintf(var, "bondingattach%d", i);
2058	tag = websGetVar(wp, var, NULL);
2059	if (!tag)
2060	return;
2061	strcat(buffer, ifname);
2062	strcat(buffer, ">");
2063	strcat(buffer, tag);
2064	if (i < bondcount - 1)
2065	strcat(buffer, " ");
2066	}
2067	nvram_set("bondings", buffer);
2068	memset(buffer, 0, 1024);
2069	#endif
2070
2071	// save bridges
2072
2073	for (i = 0; i < bridgescount; i++) {
2074	char ifname, tag, prio, mtu;
2075	char var[32];
2076	char ipaddr[32];
2077	char netmask[32];
2078	char n[32];
2079
2080	memset(ipaddr, 0, 32);
2081	memset(netmask, 0, 32);
2082	sprintf(var, "bridgename%d", i);
2083	ifname = websGetVar(wp, var, NULL);
2084	if (!ifname)
2085	return;
2086	sprintf(var, "bridgestp%d", i);
2087	tag = websGetVar(wp, var, NULL);
2088	if (!tag)
2089	return;
2090	sprintf(var, "bridgeprio%d", i);
2091	prio = websGetVar(wp, var, NULL);
2092	if (!prio)
2093	prio = "32768";
2094	if (strlen(prio) == 0)
2095	prio = "32768";
2096
2097	sprintf(var, "bridgemtu%d", i);
2098	mtu = websGetVar(wp, var, NULL);
2099	if (!mtu)
2100	mtu = "1500";
2101	if (strlen(prio) == 0)
2102	mtu = "1500";
2103
2104	sprintf(n, "%s_ipaddr", ifname);
2105	if (get_merge_ipaddr(wp, n, ipaddr))
2106	nvram_set(n, ipaddr);
2107	sprintf(n, "%s_netmask", ifname);
2108	if (get_merge_ipaddr(wp, n, netmask))
2109	nvram_set(n, netmask);
2110
2111	strcat(buffer, ifname);
2112	strcat(buffer, ">");
2113	if (!strcmp(tag, "On"))
2114	strcat(buffer, "On");
2115	else
2116	strcat(buffer, "Off");
2117	strcat(buffer, ">");
2118	strcat(buffer, prio);
2119	strcat(buffer, ">");
2120	strcat(buffer, mtu);
2121	if (i < bridgescount - 1)
2122	strcat(buffer, " ");
2123	}
2124	nvram_set("bridges", buffer);
2125	// save bridge assignment
2126	memset(buffer, 0, 1024);
2127	for (i = 0; i < bridgesifcount; i++) {
2128	char ifname, tag, *prio;
2129	char var[32];
2130
2131	sprintf(var, "bridge%d", i);
2132	ifname = websGetVar(wp, var, NULL);
2133	if (!ifname)
2134	return;
2135	sprintf(var, "bridgeif%d", i);
2136	tag = websGetVar(wp, var, NULL);
2137	if (!tag)
2138	return;
2139	sprintf(var, "bridgeifprio%d", i);
2140	prio = websGetVar(wp, var, NULL);
2141	if (!prio)
2142	prio = "128";
2143	if (strlen(prio) == 0)
2144	prio = "128";
2145	strcat(buffer, ifname);
2146	strcat(buffer, ">");
2147	strcat(buffer, tag);
2148	strcat(buffer, ">");
2149	strcat(buffer, prio);
2150	if (i < bridgesifcount - 1)
2151	strcat(buffer, " ");
2152	}
2153	nvram_set("bridgesif", buffer);
2154	#ifdef HAVE_MDHCP
2155	// save multipe dhcp-servers
2156	memset(buffer, 0, 1024);
2157	// if (!interface \|\| !start \|\| !dhcpon \|\| !max \|\| !leasetime)
2158	for (i = 0; i < mdhcpd_count; i++) {
2159	char mdhcpinterface, mdhcpon, mdhcpstart, mdhcpmax,
2160	*mdhcpleasetime;
2161	char var[32];
2162
2163	sprintf(var, "mdhcpifname%d", i);
2164	mdhcpinterface = websGetVar(wp, var, NULL);
2165	if (!mdhcpinterface)
2166	return;
2167
2168	sprintf(var, "mdhcpon%d", i);
2169	mdhcpon = websGetVar(wp, var, NULL);
2170	if (!mdhcpon)
2171	return;
2172
2173	sprintf(var, "mdhcpstart%d", i);
2174	mdhcpstart = websGetVar(wp, var, NULL);
2175	if (!mdhcpstart)
2176	return;
2177
2178	sprintf(var, "mdhcpmax%d", i);
2179	mdhcpmax = websGetVar(wp, var, NULL);
2180	if (!mdhcpmax)
2181	return;
2182
2183	sprintf(var, "mdhcpleasetime%d", i);
2184	mdhcpleasetime = websGetVar(wp, var, NULL);
2185	if (!mdhcpleasetime)
2186	return;
2187
2188	strcat(buffer, mdhcpinterface);
2189	strcat(buffer, ">");
2190	strcat(buffer, mdhcpon);
2191	strcat(buffer, ">");
2192	strcat(buffer, mdhcpstart);
2193	strcat(buffer, ">");
2194	strcat(buffer, mdhcpmax);
2195	strcat(buffer, ">");
2196	strcat(buffer, mdhcpleasetime);
2197	if (i < mdhcpd_count - 1)
2198	strcat(buffer, " ");
2199	}
2200	nvram_set("mdhcpd", buffer);
2201	#endif
2202	#ifdef HAVE_PORTSETUP
2203	validate_portsetup(wp, NULL, NULL);
2204	#endif
2205
2206	applytake(value);
2207	}
2208
2209	void add_vlan(webs_t wp)
2210	{
2211	static char word[256];
2212	char next, wordlist;
2213	int count = 0;
2214	int realcount = atoi(nvram_safe_get("vlan_tagcount"));
2215
2216	if (realcount == 0) {
2217	wordlist = nvram_safe_get("vlan_tags");
2218	foreach(word, wordlist, next) {
2219	count++;
2220	}
2221	realcount = count;
2222	}
2223	realcount++;
2224	char var[32];
2225
2226	sprintf(var, "%d", realcount);
2227	nvram_set("vlan_tagcount", var);
2228	nvram_commit();
2229	return;
2230	}
2231
2232	void del_vlan(webs_t wp)
2233	{
2234	static char word[256];
2235	int realcount = 0;
2236	char next, wordlist, *newwordlist;
2237	char *val = websGetVar(wp, "del_value", NULL);
2238
2239	if (val == NULL)
2240	return;
2241	int todel = atoi(val);
2242
2243	wordlist = nvram_safe_get("vlan_tags");
2244	newwordlist = (char *)malloc(strlen(wordlist));
2245	memset(newwordlist, 0, strlen(wordlist));
2246	int count = 0;
2247
2248	foreach(word, wordlist, next) {
2249	if (count != todel) {
2250	strcat(newwordlist, word);
2251	strcat(newwordlist, " ");
2252	} else {
2253	char *port = word;
2254	char *tag = strsep(&port, ">");
2255
2256	if (!tag \|\| !port)
2257	break;
2258	char names[32];
2259
2260	sprintf(names, "%s.%s", tag, port);
2261	eval("ifconfig", names, "down");
2262	eval("vconfig", "rem", names);
2263	}
2264	count++;
2265	}
2266
2267	char var[32];
2268
2269	realcount = atoi(nvram_safe_get("vlan_tagcount")) - 1;
2270	sprintf(var, "%d", realcount);
2271	nvram_set("vlan_tagcount", var);
2272	nvram_set("vlan_tags", newwordlist);
2273	nvram_commit();
2274	free(newwordlist);
2275
2276	return;
2277	}
2278
2279	void add_mdhcp(webs_t wp)
2280	{
2281	static char word[256];
2282	char next, wordlist;
2283	int count = 0;
2284	int realcount = atoi(nvram_safe_get("mdhcpd_count"));
2285
2286	if (realcount == 0) {
2287	wordlist = nvram_safe_get("mdhcpd");
2288	foreach(word, wordlist, next) {
2289	count++;
2290	}
2291	realcount = count;
2292	}
2293	realcount++;
2294	char var[32];
2295
2296	sprintf(var, "%d", realcount);
2297	nvram_set("mdhcpd_count", var);
2298	nvram_commit();
2299	return;
2300	}
2301
2302	void del_mdhcp(webs_t wp)
2303	{
2304	static char word[256];
2305	int realcount = 0;
2306	char next, wordlist, *newwordlist;
2307	char *val = websGetVar(wp, "del_value", NULL);
2308
2309	if (val == NULL)
2310	return;
2311	int todel = atoi(val);
2312
2313	wordlist = nvram_safe_get("mdhcpd");
2314	newwordlist = (char *)malloc(strlen(wordlist));
2315	memset(newwordlist, 0, strlen(wordlist));
2316	int count = 0;
2317
2318	foreach(word, wordlist, next) {
2319	if (count != todel) {
2320	strcat(newwordlist, word);
2321	strcat(newwordlist, " ");
2322	}
2323	count++;
2324	}
2325
2326	char var[32];
2327
2328	realcount = atoi(nvram_safe_get("mdhcpd_count")) - 1;
2329	sprintf(var, "%d", realcount);
2330	nvram_set("mdhcpd_count", var);
2331	nvram_set("mdhcpd", newwordlist);
2332	nvram_commit();
2333	free(newwordlist);
2334
2335	return;
2336	}
2337
2338	void del_bridge(webs_t wp)
2339	{
2340	static char word[256];
2341	int realcount = 0;
2342	char next, wordlist, *newwordlist;
2343	char *val = websGetVar(wp, "del_value", NULL);
2344
2345	if (val == NULL)
2346	return;
2347	int todel = atoi(val);
2348
2349	wordlist = nvram_safe_get("bridges");
2350	newwordlist = (char *)malloc(strlen(wordlist));
2351	memset(newwordlist, 0, strlen(wordlist));
2352	int count = 0;
2353
2354	foreach(word, wordlist, next) {
2355	if (count != todel) {
2356	strcat(newwordlist, word);
2357	strcat(newwordlist, " ");
2358	} else {
2359	char *port = word;
2360	char *tag = strsep(&port, ">");
2361	char *prio = port;
2362
2363	strsep(&prio, ">");
2364	if (!tag \|\| !port)
2365	continue;
2366	eval("ifconfig", tag, "down");
2367	eval("brctl", "delbr", tag);
2368	}
2369	count++;
2370	}
2371
2372	realcount = atoi(nvram_safe_get("bridges_count")) - 1;
2373	char var[32];
2374
2375	sprintf(var, "%d", realcount);
2376	nvram_set("bridges_count", var);
2377	nvram_set("bridges", newwordlist);
2378	nvram_commit();
2379	free(newwordlist);
2380
2381	return;
2382	}
2383
2384	void add_bridge(webs_t wp)
2385	{
2386	static char word[256];
2387	char next, wordlist;
2388	int count = 0;
2389	int realcount = atoi(nvram_safe_get("bridges_count"));
2390
2391	if (realcount == 0) {
2392	wordlist = nvram_safe_get("bridges");
2393	foreach(word, wordlist, next) {
2394	count++;
2395	}
2396	realcount = count;
2397	}
2398	realcount++;
2399	char var[32];
2400
2401	sprintf(var, "%d", realcount);
2402	nvram_set("bridges_count", var);
2403	nvram_commit();
2404	return;
2405	}
2406
2407	void del_bridgeif(webs_t wp)
2408	{
2409	static char word[256];
2410	int realcount = 0;
2411	char next, wordlist, *newwordlist;
2412	char *val = websGetVar(wp, "del_value", NULL);
2413
2414	if (val == NULL)
2415	return;
2416	int todel = atoi(val);
2417
2418	wordlist = nvram_safe_get("bridgesif");
2419	newwordlist = (char *)malloc(strlen(wordlist));
2420	memset(newwordlist, 0, strlen(wordlist));
2421	int count = 0;
2422
2423	foreach(word, wordlist, next) {
2424	if (count != todel) {
2425	strcat(newwordlist, word);
2426	strcat(newwordlist, " ");
2427	}
2428	count++;
2429	}
2430
2431	char var[32];
2432
2433	realcount = atoi(nvram_safe_get("bridgesif_count")) - 1;
2434	sprintf(var, "%d", realcount);
2435	nvram_set("bridgesif_count", var);
2436	nvram_set("bridgesif", newwordlist);
2437	nvram_commit();
2438	free(newwordlist);
2439
2440	return;
2441	}
2442
2443	void add_bridgeif(webs_t wp)
2444	{
2445
2446	static char word[256];
2447	char next, wordlist;
2448	int count = 0;
2449	int realcount = atoi(nvram_safe_get("bridgesif_count"));
2450
2451	if (realcount == 0) {
2452	wordlist = nvram_safe_get("bridgesif");
2453	foreach(word, wordlist, next) {
2454	count++;
2455	}
2456	realcount = count;
2457	}
2458	realcount++;
2459	char var[32];
2460
2461	sprintf(var, "%d", realcount);
2462	nvram_set("bridgesif_count", var);
2463	nvram_commit();
2464	return;
2465	}
2466
2467	#endif
2468
2469	static void save_prefix(webs_t wp, char *prefix)
2470	{
2471	char n[80];
2472
2473	#ifdef HAVE_MADWIFI
2474	char sifs[80];
2475	char turbo[80];
2476	char chanbw[80];
2477	char preamble[80];
2478	int cbwchanged = 0;
2479	#endif
2480	sprintf(n, "%s_ssid", prefix);
2481	copytonv(wp, n);
2482	if (!strcmp(prefix, "wl0") \|\| !strcmp(prefix, "wl1")) {
2483	char *wl = websGetVar(wp, n, NULL);
2484
2485	cprintf("copy value %s which is [%s] to nvram\n", n, wl);
2486	if (wl) {
2487	if (!strcmp(prefix, "wl0"))
2488	nvram_set("wl_ssid", wl);
2489	else
2490	nvram_set("wl1_ssid", wl);
2491	}
2492	}
2493	copytonv(wp, "%s_distance", prefix);
2494	#ifdef HAVE_MADWIFI
2495	{
2496	sprintf(n, "%s_txpwrdbm", prefix);
2497	char *sl = websGetVar(wp, n, NULL);
2498
2499	if (sl) {
2500	int base = atoi(sl);
2501	#ifdef HAVE_WIKINGS
2502	if (base > 28)
2503	base = 28;
2504	#ifdef HAVE_SUB3
2505	if (base > 25)
2506	base = 25;
2507	#endif
2508	#ifdef HAVE_SUB6
2509	if (base > 22)
2510	base = 22;
2511	#endif
2512	#endif
2513	int txpower = base - wifi_gettxpoweroffset(prefix);
2514
2515	if (txpower < 1)
2516	txpower = 1;
2517	sprintf(turbo, "%d", txpower);
2518	nvram_set(n, turbo);
2519	}
2520	}
2521	copytonv(wp, "%s_antgain", prefix);
2522	copytonv(wp, "%s_regulatory", prefix);
2523	sprintf(n, "%s_scanlist", prefix);
2524	{
2525	char *sl = websGetVar(wp, n, NULL);
2526
2527	if (sl) {
2528	char slc = (char )malloc(strlen(sl) + 1);
2529
2530	strcpy(slc, sl);
2531	int i, sllen = strlen(slc);
2532
2533	for (i = 0; i < sllen; i++) {
2534	if (slc[i] == ';')
2535	slc[i] = ' ';
2536	if (slc[i] == ',')
2537	slc[i] = ' ';
2538	}
2539	nvram_set(n, slc);
2540	}
2541	}
2542	#ifdef HAVE_MAKSAT
2543	copytonv(wp, "ath_specialmode");
2544	#endif
2545	copytonv(wp, "%s_regdomain", prefix);
2546
2547	copytonv(wp, "%s_rts", prefix);
2548	if (nvram_nmatch("1", "%s_rts", prefix)) {
2549	sprintf(turbo, "%s_rtsvalue", prefix);
2550	char *tw = websGetVar(wp, turbo, NULL);
2551
2552	if (tw) {
2553	if (atoi(tw) < 1)
2554	tw = "1";
2555	if (atoi(tw) > 2346)
2556	tw = "2346";
2557	nvram_nset(tw, "%s_rtsvalue", prefix);
2558	}
2559	}
2560	copytonv(wp, "%s_protmode", prefix);
2561	copytonv(wp, "%s_minrate", prefix);
2562	copytonv(wp, "%s_maxrate", prefix);
2563	copytonv(wp, "%s_xr", prefix);
2564	copytonv(wp, "%s_outdoor", prefix);
2565	// copytonv( wp, "%s_compression", prefix ); // Atheros SuperG header
2566	// compression
2567	copytonv(wp, "%s_ff", prefix); // ff = 0, Atheros SuperG fast
2568	// framing disabled, 1 fast framing
2569	// enabled
2570	copytonv(wp, "%s_diversity", prefix);
2571	copytonv(wp, "%s_preamble", prefix);
2572	copytonv(wp, "%s_wmm", prefix);
2573	copytonv(wp, "%s_txantenna", prefix);
2574	copytonv(wp, "%s_rxantenna", prefix);
2575	copytonv(wp, "%s_intmit", prefix);
2576	copytonv(wp, "%s_csma", prefix);
2577	copytonv(wp, "%s_noise_immunity", prefix);
2578	copytonv(wp, "%s_ofdm_weak_det", prefix);
2579
2580	copytonv(wp, "%s_chanshift", prefix);
2581	copytonv(wp, "%s_doth", prefix);
2582	copytonv(wp, "%s_maxassoc", prefix);
2583
2584	sprintf(chanbw, "%s_channelbw", prefix);
2585	char *cbw = websGetVar(wp, chanbw, NULL);
2586
2587	if (cbw && !nvram_match(chanbw, cbw)) {
2588	cbwchanged = 1;
2589	}
2590	if (cbw)
2591	nvram_set(chanbw, cbw);
2592
2593	copytonv(wp, "%s_xr", prefix);
2594	copytonv(wp, "%s_sifstime", prefix);
2595	copytonv(wp, "%s_preambletime", prefix);
2596	copytonv(wp, "%s_mtikie", prefix);
2597	copytonv(wp, "%s_cardtype", prefix);
2598
2599	#endif
2600	copytonv(wp, "%s_closed", prefix);
2601
2602	#ifndef HAVE_MADWIFI
2603	char *ifname = "wl0";
2604
2605	#ifndef HAVE_RT2880
2606
2607	if (!strcmp(prefix, "wl0"))
2608	ifname = get_wl_instance_name(0);
2609	else if (!strcmp(prefix, "wl1"))
2610	ifname = get_wl_instance_name(1);
2611	else
2612	ifname = prefix;
2613	#else
2614	ifname = getRADev(prefix);
2615	#endif
2616	copytonv(wp, "%s_multicast", ifname);
2617	copytonv(wp, "%s_bridged", ifname);
2618	copytonv(wp, "%s_nat", prefix);
2619
2620	char addr[32];
2621
2622	sprintf(n, "%s_ipaddr", ifname);
2623	if (get_merge_ipaddr(wp, n, addr))
2624	nvram_set(n, addr);
2625
2626	sprintf(n, "%s_netmask", ifname);
2627	if (get_merge_ipaddr(wp, n, addr))
2628	nvram_set(n, addr);
2629	#else
2630
2631	copytonv(wp, "%s_multicast", prefix);
2632	copytonv(wp, "%s_bridged", prefix);
2633	copytonv(wp, "%s_nat", prefix);
2634	char addr[32];
2635
2636	sprintf(n, "%s_ipaddr", prefix);
2637	if (get_merge_ipaddr(wp, n, addr))
2638	nvram_set(n, addr);
2639
2640	sprintf(n, "%s_netmask", prefix);
2641	if (get_merge_ipaddr(wp, n, addr))
2642	nvram_set(n, addr);
2643
2644	copytonv(wp, "%s_duallink", prefix);
2645	sprintf(n, "%s_duallink_parent", prefix);
2646	if (get_merge_ipaddr(wp, n, addr))
2647	nvram_set(n, addr);
2648
2649	#endif
2650
2651	copytonv(wp, "%s_ap_isolate", prefix);
2652	sprintf(n, "%s_mode", prefix);
2653	if (nvram_match(n, "sta")) {
2654	char *wl = websGetVar(wp, n, NULL);
2655
2656	if (wl)
2657	if (!strcmp(wl, "ap") \|\| !strcmp(wl, "wdsap")
2658	\|\| !strcmp(wl, "infra") \|\| !strcmp(wl, "wdssta")) {
2659	nvram_set("wan_proto", "disabled");
2660	}
2661	}
2662	copytonv(wp, n);
2663	if (!strcmp(prefix, "wl0") \|\| !strcmp(prefix, "wl1")) {
2664	char *wl = websGetVar(wp, n, NULL);
2665
2666	cprintf("copy value %s which is [%s] to nvram\n", n, wl);
2667	if (wl && !strcmp(prefix, "wl0"))
2668	nvram_set("wl_mode", wl);
2669	#ifndef HAVE_MADWIFI
2670	if (strcmp(wl, "ap") && strcmp(wl, "apsta")
2671	&& strcmp(wl, "apstawet")) {
2672	nvram_nset("", "%s_vifs", prefix);
2673	}
2674	#endif
2675	}
2676	int chanchanged = 0;
2677
2678	#ifdef HAVE_RT2880
2679	copytonv(wp, "%s_greenfield", prefix);
2680	#endif
2681
2682	#ifndef HAVE_MADWIFI
2683	if (!strcmp(prefix, "wl0") \|\| !strcmp(prefix, "wl1"))
2684	#endif
2685	{
2686
2687	sprintf(n, "%s_net_mode", prefix);
2688	if (!nvram_match(n, websGetVar(wp, n, ""))) {
2689	chanchanged = 1;
2690	copytonv(wp, n);
2691	if (!strcmp(prefix, "wl0"))
2692	convert_wl_gmode(nvram_safe_get(n), "wl");
2693	else
2694	convert_wl_gmode(nvram_safe_get(n), prefix);
2695	}
2696	}
2697	#ifdef HAVE_MADWIFI
2698	if (cbwchanged \|\| chanchanged) {
2699	if (nvram_match(chanbw, "40")) {
2700	nvram_set(sifs, "8");
2701	nvram_set(preamble, "14");
2702	} else if (nvram_match(chanbw, "5")) {
2703	nvram_set(sifs, "64");
2704	nvram_set(preamble, "80");
2705	} else if (nvram_match(chanbw, "10")) {
2706	nvram_set(sifs, "32");
2707	nvram_set(preamble, "40");
2708	} else {
2709	nvram_set(sifs, "16");
2710	nvram_set(preamble, "20");
2711	}
2712
2713	}
2714	#endif
2715	copytonv(wp, "%s_nbw", prefix);
2716	copytonv(wp, "%s_nctrlsb", prefix);
2717
2718	sprintf(n, "%s_channel", prefix);
2719	if (!strcmp(prefix, "wl0") \|\| !strcmp(prefix, "wl1")) {
2720	char *wl = websGetVar(wp, n, NULL);
2721
2722	cprintf("copy value %s which is [%s] to nvram\n", n, wl);
2723	if (wl && !strcmp(prefix, "wl0"))
2724	nvram_set("wl_channel", wl);
2725	else if (wl)
2726	nvram_set("wl1_channel", wl);
2727	}
2728	copytonv(wp, n);
2729
2730	sprintf(n, "%s_wchannel", prefix);
2731	if (!strcmp(prefix, "wl0") \|\| !strcmp(prefix, "wl1")) {
2732	char *wl = websGetVar(wp, n, NULL);
2733
2734	cprintf("copy value %s which is [%s] to nvram\n", n, wl);
2735	if (wl && !strcmp(prefix, "wl0"))
2736	nvram_set("wl_wchannel", wl);
2737	else if (wl)
2738	nvram_set("wl1_wchannel", wl);
2739
2740	}
2741
2742	copytonv(wp, n);
2743
2744	}
2745
2746	void wireless_save(webs_t wp)
2747	{
2748	char *value = websGetVar(wp, "action", "");
2749
2750	char *next;
2751	char var[80];
2752
2753	#ifndef HAVE_MADWIFI
2754	int c = get_wl_instances();
2755	int i;
2756
2757	for (i = 0; i < c; i++) {
2758	char buf[16];
2759
2760	sprintf(buf, "wl%d", i);
2761	save_prefix(wp, buf);
2762	char *vifs = nvram_nget("wl%d_vifs", i);
2763	#else
2764	int c = getdevicecount();
2765	int i;
2766
2767	for (i = 0; i < c; i++) {
2768	char buf[16];
2769
2770	sprintf(buf, "ath%d", i);
2771	save_prefix(wp, buf);
2772	char *vifs = nvram_nget("ath%d_vifs", i);
2773
2774	#endif
2775	if (vifs == NULL)
2776	return;
2777	foreach(var, vifs, next) {
2778	save_prefix(wp, var);
2779	}
2780	}
2781	// nvram_commit ();
2782	applytake(value);
2783	}
2784
2785	#ifdef HAVE_WIVIZ
2786	void set_wiviz(webs_t wp)
2787	{
2788
2789	char *hopdwell = websGetVar(wp, "hopdwell", NULL);
2790	char *hopseq = websGetVar(wp, "hopseq", NULL);
2791	FILE *fp = fopen("/tmp/wiviz2-cfg", "wb");
2792
2793	if (strstr(hopseq, ","))
2794	fprintf(fp, "channelsel=hop&");
2795	else
2796	fprintf(fp, "channelsel=%s&", hopseq);
2797
2798	fprintf(fp, "hopdwell=%s&hopseq=%s\n", hopdwell, hopseq);
2799
2800	nvram_set("hopdwell", hopdwell);
2801	nvram_set("hopseq", hopseq);
2802
2803	fclose(fp);
2804	killall("wiviz", SIGUSR2);
2805
2806	}
2807	#endif
2808
2809	void ttraff_erase(webs_t wp)
2810	{
2811	char line[2048];
2812	char *name = NULL;
2813
2814	system2("nvram show \| grep traff- > /tmp/.ttraff");
2815	FILE *fp = fopen("/tmp/.ttraff", "r");
2816
2817	if (fp == NULL) {
2818	return;
2819	}
2820	while (fgets(line, sizeof(line), fp) != NULL) {
2821	if (startswith(line, "traff-")) {
2822	name = strtok(line, "=");
2823	if (strlen(name) == 13) //only unset ttraf-XX-XXXX
2824	{
2825	nvram_unset(name);
2826	}
2827	}
2828	}
2829	nvram_commit();
2830	unlink("/tmp/.ttraff");
2831	}
2832
2833	void changepass(webs_t wp)
2834	{
2835	char *value = websGetVar(wp, "http_username", NULL);
2836	char *pass = websGetVar(wp, "http_passwd", NULL);
2837
2838	if (value && pass && strcmp(value, TMP_PASSWD)
2839	&& valid_name(wp, value, NULL)) {
2840	nvram_set("http_username", zencrypt(value));
2841
2842	system2("/sbin/setpasswd");
2843	}
2844
2845	if (pass && value && strcmp(pass, TMP_PASSWD)
2846	&& valid_name(wp, pass, NULL)) {
2847	nvram_set("http_passwd", zencrypt(pass));
2848
2849	system2("/sbin/setpasswd");
2850	}
2851	nvram_commit();
2852	}
2853
2854	#ifdef HAVE_CHILLILOCAL
2855
2856	void user_remove(webs_t wp)
2857	{
2858	macro_rem("fon_usernames", "fon_userlist");
2859	}
2860
2861	void user_add(webs_t wp)
2862	{
2863	macro_add("fon_usernames");
2864	// validate_userlist(wp);
2865	}
2866	#endif
2867
2868	#ifdef HAVE_RADLOCAL
2869
2870	void raduser_add(webs_t wp)
2871	{
2872	int radcount = 0;
2873	char *radc = nvram_get("iradius_count");
2874
2875	if (radc != NULL)
2876	radcount = atoi(radc);
2877	radcount++;
2878	char count[16];
2879
2880	sprintf(count, "%d", radcount);
2881	nvram_set("iradius_count", count);
2882	}
2883	#endif
2884
2885	#ifdef HAVE_MILKFISH
2886	void milkfish_sip_message(webs_t wp)
2887	{
2888	char *message = websGetVar(wp, "sip_message", NULL);
2889	char *dest = websGetVar(wp, "sip_message_dest", NULL);
2890	int i;
2891	FILE *fp = fopen("/tmp/sipmessage", "wb");
2892
2893	if (fp == NULL)
2894	return;
2895	char *host_key = message;
2896
2897	i = 0;
2898	do {
2899	if (host_key[i] != 0x0D)
2900	fprintf(fp, "%c", host_key[i]);
2901	}
2902	while (host_key[++i]);
2903	putc(0xa, fp);
2904	fclose(fp);
2905	eval("milkfish_services", "simpledd", dest);
2906	return;
2907	}
2908	#endif
2909
2910	void set_security(webs_t wp)
2911	{
2912	char *var = websGetVar(wp, "security_varname", "security_mode");
2913
2914	cprintf("set security to %s\n", var);
2915	cprintf("security var = %s\n", websGetVar(wp, var, "disabled"));
2916	char *var2 = websGetVar(wp, var, "disabled");
2917
2918	// rep(var,'X','.');
2919	nvram_set(var, var2);
2920	}
2921
2922	void
2923	base64_encode(const unsigned char *in, size_t inlen,
2924	unsigned char *out, size_t outlen)
2925	{
2926	static const char b64str[64] =
2927	"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
2928
2929	while (inlen && outlen) {
2930	*out++ = b64str[(in[0] >> 2) & 0x3f];
2931	if (!--outlen)
2932	break;
2933	*out++ =
2934	b64str[((in[0] << 4) + (--inlen ? in[1] >> 4 : 0)) & 0x3f];
2935	if (!--outlen)
2936	break;
2937	*out++ =
2938	(inlen
2939	? b64str[((in[1] << 2) + (--inlen ? in[2] >> 6 : 0)) &
2940	0x3f] : '=');
2941	if (!--outlen)
2942	break;
2943	*out++ = inlen ? b64str[in[2] & 0x3f] : '=';
2944	if (!--outlen)
2945	break;
2946	if (inlen)
2947	inlen--;
2948	if (inlen)
2949	in += 3;
2950	}
2951
2952	if (outlen)
2953	*out = '\0';
2954	}
2955
2956	char request_freedns(char user, char *password)
2957	{
2958	unsigned char final[32];
2959	char un[128];
2960
2961	unlink("/tmp/.hash");
2962	sprintf(un, "%s\|%s", user, password);
2963	sha1_ctx_t context;
2964
2965	sha1_begin(&context);
2966	sha1_hash(un, strlen(un), &context);
2967	sha1_end(final, &context);
2968	char request[128] = { 0 };
2969	int i;
2970
2971	for (i = 0; i < 20; i++)
2972	sprintf(request, "%s%02x", request, final[i]);
2973	system2("rm -f /tmp/.hash");
2974	sysprintf
2975	("wget \"http://freedns.afraid.org/api/?action=getdyndns&sha=%s\" -O /tmp/.hash",
2976	request);
2977	FILE *in = fopen("/tmp/.hash", "rb");
2978
2979	if (in == NULL)
2980	return NULL;
2981	while (getc(in) != '?' && feof(in) == 0) ;
2982	i = 0;
2983	char *hash = malloc(64);
2984
2985	if (feof(in)) {
2986	free(hash);
2987	return NULL;
2988	}
2989	for (i = 0; i < 36; i++)
2990	hash[i] = getc(in);
2991	fclose(in);
2992	hash[i++] = 0;
2993	return hash;
2994	}
2995
2996	void ddns_save_value(webs_t wp)
2997	{
2998	char enable, username, passwd, hostname, dyndnstype, wildcard,
2999	custom, conf, url, force, *wan_ip;
3000	struct variable ddns_variables[] = {
3001	{argv:ARGV("0", "1", "2", "3", "4", "5", "6",
3002	"7", "8", "9")},
3003	{argv:ARGV("30")},
3004	}, *which;
3005	char _username[] = "ddns_username_X";
3006	char _passwd[] = "ddns_passwd_X";
3007	char _hostname[] = "ddns_hostname_X";
3008	char _dyndnstype[] = "ddns_dyndnstype_X";
3009	char _wildcard[] = "ddns_wildcard_X";
3010	char _custom[] = "ddns_custom_X";
3011	char _conf[] = "ddns_conf";
3012	char _url[] = "ddns_url";
3013	char _force[] = "ddns_force";
3014	char _wan_ip[] = "ddns_wan_ip";
3015
3016	which = &ddns_variables[0];
3017
3018	enable = websGetVar(wp, "ddns_enable", NULL);
3019	if (!enable && !valid_choice(wp, enable, &which[0])) {
3020	return;
3021	}
3022	int gethash = 0;
3023
3024	switch (atoi(enable)) {
3025	case 0:
3026	// Disable
3027	nvram_set("ddns_enable", enable);
3028	return;
3029	break;
3030	case 1:
3031	// dyndns
3032	snprintf(_username, sizeof(_username), "%s", "ddns_username");
3033	snprintf(_passwd, sizeof(_passwd), "%s", "ddns_passwd");
3034	snprintf(_hostname, sizeof(_hostname), "%s", "ddns_hostname");
3035	snprintf(_dyndnstype, sizeof(_dyndnstype), "%s",
3036	"ddns_dyndnstype");
3037	snprintf(_wildcard, sizeof(_wildcard), "%s", "ddns_wildcard");
3038	break;
3039	case 2:
3040	// afraid
3041	snprintf(_username, sizeof(_username), "ddns_username_%s",
3042	enable);
3043	snprintf(_passwd, sizeof(_passwd), "ddns_passwd_%s", enable);
3044	snprintf(_hostname, sizeof(_hostname), "ddns_hostname_%s",
3045	enable);
3046	gethash = 1;
3047	break;
3048	case 3: // zoneedit
3049	case 4: // no-ip
3050	case 8: // tzo
3051	case 9: // dynSIP
3052	snprintf(_username, sizeof(_username), "ddns_username_%s",
3053	enable);
3054	snprintf(_passwd, sizeof(_passwd), "ddns_passwd_%s", enable);
3055	snprintf(_hostname, sizeof(_hostname), "ddns_hostname_%s",
3056	enable);
3057	break;
3058	case 5:
3059	// custom
3060	snprintf(_username, sizeof(_username), "ddns_username_%s",
3061	enable);
3062	snprintf(_passwd, sizeof(_passwd), "ddns_passwd_%s", enable);
3063	snprintf(_hostname, sizeof(_hostname), "ddns_hostname_%s",
3064	enable);
3065	snprintf(_custom, sizeof(_custom), "ddns_custom_%s", enable);
3066	snprintf(_conf, sizeof(_conf), "%s", "ddns_conf");
3067	snprintf(_url, sizeof(_url), "%s", "ddns_url");
3068	break;
3069	case 6:
3070	// 3322 dynamic : added botho 30/07/06
3071	snprintf(_username, sizeof(_username), "ddns_username_%s",
3072	enable);
3073	snprintf(_passwd, sizeof(_passwd), "ddns_passwd_%s", enable);
3074	snprintf(_hostname, sizeof(_hostname), "ddns_hostname_%s",
3075	enable);
3076	snprintf(_dyndnstype, sizeof(_dyndnstype), "ddns_dyndnstype_%s",
3077	enable);
3078	snprintf(_wildcard, sizeof(_wildcard), "ddns_wildcard_%s",
3079	enable);
3080	break;
3081	case 7:
3082	// easydns
3083	snprintf(_username, sizeof(_username), "ddns_username_%s",
3084	enable);
3085	snprintf(_passwd, sizeof(_passwd), "ddns_passwd_%s", enable);
3086	snprintf(_hostname, sizeof(_hostname), "ddns_hostname_%s",
3087	enable);
3088	snprintf(_wildcard, sizeof(_wildcard), "ddns_wildcard_%s",
3089	enable);
3090	break;
3091	}
3092
3093	username = websGetVar(wp, _username, NULL);
3094	passwd = websGetVar(wp, _passwd, NULL);
3095	hostname = websGetVar(wp, _hostname, NULL);
3096	dyndnstype = websGetVar(wp, _dyndnstype, NULL);
3097	wildcard = websGetVar(wp, _wildcard, NULL);
3098	custom = websGetVar(wp, _custom, NULL);
3099	conf = websGetVar(wp, _conf, NULL);
3100	url = websGetVar(wp, _url, NULL);
3101	force = websGetVar(wp, _force, NULL);
3102	wan_ip = websGetVar(wp, _wan_ip, NULL);
3103
3104	if (!username \|\| !passwd \|\| !hostname \|\| !force \|\| !wan_ip) {
3105	return;
3106	}
3107
3108	if (atoi(force) < 1 \|\| atoi(force) > 60) {
3109	force = "10";
3110	}
3111
3112	nvram_set("ddns_enable", enable);
3113	nvram_set(_username, username);
3114	if (strcmp(passwd, TMP_PASSWD)) {
3115	nvram_set(_passwd, passwd);
3116	}
3117	if (gethash && !contains(hostname, ',')) {
3118	char hostn[128];
3119	char *hash = request_freedns(username, nvram_safe_get(_passwd));
3120
3121	if (hash) {
3122	sprintf(hostn, "%s,%s", hostname, hash);
3123	nvram_set(_hostname, hostn);
3124	free(hash);
3125	} else {
3126	nvram_set(_hostname, "User/Password wrong");
3127	}
3128	} else
3129	nvram_set(_hostname, hostname);
3130	nvram_set(_dyndnstype, dyndnstype);
3131	nvram_set(_wildcard, wildcard);
3132	nvram_set(_custom, custom);
3133	nvram_set(_conf, conf);
3134	nvram_set(_url, url);
3135	nvram_set(_force, force);
3136	nvram_set(_wan_ip, wan_ip);
3137
3138	}
3139
3140	void ddns_update_value(webs_t wp)
3141	{
3142
3143	}
3144
3145	void port_vlan_table_save(webs_t wp)
3146	{
3147	int port = 0, vlan = 0, vlans[21], i;
3148	char portid[32], portvlan[64], portval, buff[32], c, *next,
3149	br0vlans[64], br1vlans[64], br2vlans[64];
3150
3151	strcpy(portvlan, "");
3152
3153	for (vlan = 0; vlan < 21; vlan++)
3154	vlans[vlan] = 0;
3155
3156	vlans[16] = 1;
3157
3158	for (port = 0; port < 5; port++) {
3159	for (vlan = 0; vlan < 21; vlan++) {
3160	snprintf(portid, 31, "port%dvlan%d", port, vlan);
3161	portval = websGetVar(wp, portid, "");
3162
3163	if (vlan < 17 \|\| vlan > 20)
3164	i = (strcmp(portval, "on") == 0);
3165	else
3166	i = (strcmp(portval, "on") != 0);
3167
3168	if (i) {
3169	if (strlen(portvlan) > 0)
3170	strcat(portvlan, " ");
3171
3172	snprintf(buff, 4, "%d", vlan);
3173	strcat(portvlan, buff);
3174	vlans[vlan] = 1;
3175	}
3176	}
3177
3178	snprintf(portid, 31, "port%dvlans", port);
3179	nvram_set(portid, portvlan);
3180	strcpy(portvlan, "");
3181	}
3182
3183	/*
3184	* done with ports 0-4, now set up #5 automaticly
3185	*/
3186	/*
3187	* if a VLAN is used, it also gets assigned to port #5
3188	*/
3189	for (vlan = 0; vlan < 17; vlan++) {
3190	if (vlans[vlan]) {
3191	if (strlen(portvlan) > 0)
3192	strcat(portvlan, " ");
3193
3194	snprintf(buff, 4, "%d", vlan);
3195	strcat(portvlan, buff);
3196	}
3197	}
3198
3199	nvram_set("port5vlans", portvlan);
3200
3201	strcpy(br0vlans, "");
3202	c = nvram_safe_get("lan_ifnames");
3203	if (c) {
3204	foreach(portid, c, next) {
3205	if (!(strncmp(portid, "vlan", 4) == 0)
3206	&& !(strncmp(portid, "eth1", 4) == 0)) {
3207	if (strlen(br0vlans) > 0)
3208	strcat(br0vlans, " ");
3209	strcat(br0vlans, portid);
3210	}
3211	}
3212	}
3213
3214	strcpy(br1vlans, "");
3215	c = nvram_safe_get("ub1_ifnames");
3216	if (c) {
3217	foreach(portid, c, next) {
3218	if (!(strncmp(portid, "vlan", 4) == 0)
3219	&& !(strncmp(portid, "eth1", 4) == 0)) {
3220	if (strlen(br1vlans) > 0)
3221	strcat(br1vlans, " ");
3222	strcat(br1vlans, portid);
3223	}
3224	}
3225	}
3226
3227	strcpy(br2vlans, "");
3228	c = nvram_safe_get("ub2_ifnames");
3229	if (c) {
3230	foreach(portid, c, next) {
3231	if (!(strncmp(portid, "vlan", 4) == 0)
3232	&& !(strncmp(portid, "eth1", 4) == 0)) {
3233	if (strlen(br2vlans) > 0)
3234	strcat(br2vlans, " ");
3235	strcat(br2vlans, portid);
3236	}
3237	}
3238	}
3239
3240	for (i = 0; i < 16; i++) {
3241	snprintf(buff, 31, "vlan%d", i);
3242	portval = websGetVar(wp, buff, "");
3243
3244	switch (atoi(portval)) {
3245	case 0:
3246	if (strlen(br0vlans) > 0)
3247	strcat(br0vlans, " ");
3248	strcat(br0vlans, buff);
3249	break;
3250	case 1:
3251	if (strlen(br1vlans) > 0)
3252	strcat(br1vlans, " ");
3253	strcat(br1vlans, buff);
3254	break;
3255	case 2:
3256	if (strlen(br2vlans) > 0)
3257	strcat(br2vlans, " ");
3258	strcat(br2vlans, buff);
3259	break;
3260	}
3261	}
3262
3263	strcpy(buff, "");
3264
3265	switch (atoi(websGetVar(wp, "wireless", ""))) {
3266	case 0:
3267	if (strlen(br0vlans) > 0)
3268	strcat(br0vlans, " ");
3269	strcat(br0vlans, get_wdev());
3270	break;
3271	case 1:
3272	if (strlen(br1vlans) > 0)
3273	strcat(br1vlans, " ");
3274	strcat(br1vlans, get_wdev());
3275	break;
3276	case 2:
3277	if (strlen(br2vlans) > 0)
3278	strcat(br2vlans, " ");
3279	strcat(br2vlans, get_wdev());
3280	break;
3281	}
3282
3283	snprintf(buff, 3, "%s", websGetVar(wp, "trunking", ""));
3284
3285	nvram_set("lan_ifnames", br0vlans);
3286	// nvram_set("ub1_ifnames", br1vlans);
3287	// nvram_set("ub2_ifnames", br2vlans);
3288	nvram_set("trunking", buff);
3289	nvram_set("vlans", "1");
3290
3291	nvram_commit();
3292
3293	}
3294
3295	static void save_macmode_if(webs_t wp, char *ifname)
3296	{
3297
3298	char macmode[32];
3299	char macmode1[32];
3300
3301	sprintf(macmode, "%s_macmode", ifname);
3302	sprintf(macmode1, "%s_macmode1", ifname);
3303	rep(macmode1, '.', 'X');
3304	char wl_macmode1, wl_macmode;
3305
3306	wl_macmode = websGetVar(wp, macmode, NULL);
3307	wl_macmode1 = websGetVar(wp, macmode1, NULL);
3308
3309	if (!wl_macmode1)
3310	return;
3311
3312	if (!strcmp(wl_macmode1, "disabled")) {
3313	nvram_set(macmode1, "disabled");
3314	nvram_set(macmode, "disabled");
3315	} else if (!strcmp(wl_macmode1, "other")) {
3316	if (!wl_macmode)
3317	nvram_set(macmode, "deny");
3318	else
3319	nvram_set(macmode, wl_macmode);
3320	nvram_set(macmode1, "other");
3321	}
3322	}
3323
3324	void save_macmode(webs_t wp)
3325	{
3326	#ifndef HAVE_MADWIFI
3327	int c = get_wl_instances();
3328	char devs[32];
3329	int i;
3330
3331	for (i = 0; i < c; i++) {
3332	sprintf(devs, "wl%d", i);
3333	save_macmode_if(wp, devs);
3334	}
3335	#else
3336	int c = getdevicecount();
3337	char devs[32];
3338	int i;
3339
3340	for (i = 0; i < c; i++) {
3341	sprintf(devs, "ath%d", i);
3342	save_macmode_if(wp, devs);
3343	char vif[32];
3344
3345	sprintf(vif, "%s_vifs", devs);
3346	char var[80], *next;
3347	char *vifs = nvram_safe_get(vif);
3348
3349	if (vifs != NULL)
3350	foreach(var, vifs, next) {
3351	save_macmode_if(wp, var);
3352	}
3353	}
3354
3355	#endif
3356	return;
3357
3358	}
3359
3360	// handle UPnP.asp requests / added 10
3361	void tf_upnp(webs_t wp)
3362	{
3363	char *v;
3364	char s[64];
3365
3366	if (((v = websGetVar(wp, "remove", NULL)) != NULL) && (*v)) {
3367	if (strcmp(v, "all") == 0) {
3368	nvram_set("upnp_clear", "1");
3369	} else {
3370	int which = atoi(nvram_default_get("forward_cur", "0"));
3371	int i = atoi(v);
3372	char val[32];
3373
3374	sprintf(val, "forward_port%d", i);
3375	int a;
3376
3377	nvram_unset(val);
3378	for (a = i + 1; a < which; a++) {
3379	nvram_nset(nvram_nget("forward_port%d", a),
3380	"forward_port%d", a - 1);
3381	}
3382	which--;
3383	sprintf(val, "forward_port%d", which);
3384	nvram_unset(val);
3385	if (which < 0)
3386	which = 0;
3387	sprintf(val, "%d", which);
3388	nvram_set("forward_cur", val);
3389	}
3390	eval("stopservice", "firewall");
3391	eval("startservice", "firewall"); //restart firewall
3392	}
3393
3394	}
3395
3396	#ifdef HAVE_FREERADIUS
3397
3398	void radius_generate_certificate(webs_t wp)
3399	{
3400	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3401	nvram_set("radius_country", websGetVar(wp, "radius_country", ""));
3402	nvram_set("radius_state", websGetVar(wp, "radius_state", ""));
3403	nvram_set("radius_locality", websGetVar(wp, "radius_locality", ""));
3404	nvram_set("radius_expiration",
3405	websGetVar(wp, "radius_expiration", "365"));
3406	nvram_set("radius_passphrase",
3407	websGetVar(wp, "radius_passphrase", "whatever"));
3408	nvram_set("radius_organisation",
3409	websGetVar(wp, "radius_organisation", ""));
3410	nvram_set("radius_email", websGetVar(wp, "radius_email", ""));
3411	nvram_set("radius_common", websGetVar(wp, "radius_common", ""));
3412
3413	//system("rm /jffs/etc/freeradius/certs/dh");
3414	system("rm /jffs/etc/freeradius/certs/server.csr");
3415	system("rm /jffs/etc/freeradius/certs/server.key");
3416	system("rm /jffs/etc/freeradius/certs/ca.pem");
3417	system("rm /jffs/etc/freeradius/certs/ca.key");
3418	system("rm /jffs/etc/freeradius/certs/server.crt");
3419	system("rm /jffs/etc/freeradius/certs/server.p12");
3420	system("rm /jffs/etc/freeradius/certs/server.pem");
3421	system("rm /jffs/etc/freeradius/certs/ca.der");
3422	system("rm /jffs/etc/freeradius/certs/index.txt");
3423	system("rm /jffs/etc/freeradius/certs/serial");
3424	system("rm -rf /jffs/etc/freeradius/certs/clients"); //delete client certificates since they will become invalid
3425	system("startservice_f gen_radius_cert");
3426	}
3427
3428	/*struct radiususer {
3429	unsigned int fieldlen;
3430	unsigned int usersize;
3431	unsigned char *user;
3432	unsigned int passwordsize;
3433	unsigned char *passwd;
3434	unsigned int downstream;
3435	unsigned int upstream;
3436	//more fields can be added in future
3437	};
3438
3439	struct radiusdb {
3440	unsigned int usercount;
3441	struct radiususer *users;
3442	};
3443	*/
3444	#include <radiusdb.h>
3445	void add_radius_user(webs_t wp)
3446	{
3447	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3448	struct radiusdb *db = loadradiusdb();
3449	if (db == NULL) {
3450	db = malloc(sizeof(struct radiusdb));
3451	db->usercount = 0;
3452	db->users = malloc(sizeof(struct radiususer));
3453	} else {
3454	db->users =
3455	realloc(db->users,
3456	sizeof(struct radiususer) * (db->usercount + 1));
3457	}
3458	db->users[db->usercount].fieldlen = sizeof(struct radiususer) - 8;
3459	db->users[db->usercount].usersize = 0;
3460	db->users[db->usercount].user = NULL;
3461	db->users[db->usercount].passwd = NULL;
3462	db->users[db->usercount].passwordsize = 0;
3463	db->users[db->usercount].downstream = 0;
3464	db->users[db->usercount].upstream = 0;
3465	db->users[db->usercount].expiration = 0;
3466	db->usercount++;
3467	writeradiusdb(db);
3468	freeradiusdb(db);
3469	}
3470
3471	void del_radius_user(webs_t wp)
3472	{
3473	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3474	char *val = websGetVar(wp, "del_value", NULL);
3475	if (val == NULL)
3476	return;
3477	int todel = atoi(val);
3478	struct radiusdb *db = loadradiusdb();
3479	if (db == NULL)
3480	return;
3481	if (db->usercount == 0)
3482	return;
3483	if (db->usercount > 1)
3484	memcpy(&db->users[todel], &db->users[todel + 1],
3485	sizeof(struct radiususer) * ((db->usercount - 1) -
3486	todel));
3487	db->usercount--;
3488	if (db->usercount > 0)
3489	db->users =
3490	realloc(db->users,
3491	sizeof(struct radiususer) * (db->usercount));
3492	else {
3493	free(db->users);
3494	db->users = NULL;
3495	}
3496	writeradiusdb(db);
3497	freeradiusdb(db);
3498	}
3499
3500	void add_radius_client(webs_t wp)
3501	{
3502	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3503	struct radiusclientdb *db = loadradiusclientdb();
3504	if (db == NULL) {
3505	db = malloc(sizeof(struct radiusclientdb));
3506	db->usercount = 0;
3507	db->users = malloc(sizeof(struct radiusclient));
3508	} else {
3509	db->users =
3510	realloc(db->users,
3511	sizeof(struct radiusclient) * (db->usercount + 1));
3512	}
3513	db->users[db->usercount].fieldlen = sizeof(struct radiususer) - 8;
3514	db->users[db->usercount].clientsize = 0;
3515	db->users[db->usercount].client = NULL;
3516	db->users[db->usercount].passwd = NULL;
3517	db->users[db->usercount].passwordsize = 0;
3518	db->usercount++;
3519	writeradiusclientdb(db);
3520	freeradiusclientdb(db);
3521	}
3522
3523	void del_radius_client(webs_t wp)
3524	{
3525	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3526	char *val = websGetVar(wp, "del_value", NULL);
3527	if (val == NULL)
3528	return;
3529	int todel = atoi(val);
3530	struct radiusclientdb *db = loadradiusclientdb();
3531	if (db == NULL)
3532	return;
3533	if (db->usercount == 0)
3534	return;
3535	if (db->usercount > 1)
3536	memcpy(&db->users[todel], &db->users[todel + 1],
3537	sizeof(struct radiusclient) * ((db->usercount - 1) -
3538	todel));
3539	db->usercount--;
3540	if (db->usercount > 0)
3541	db->users =
3542	realloc(db->users,
3543	sizeof(struct radiusclient) * (db->usercount));
3544	else {
3545	free(db->users);
3546	db->users = NULL;
3547	}
3548	writeradiusclientdb(db);
3549	freeradiusclientdb(db);
3550	}
3551
3552	static void save_radius_clients(webs_t wp)
3553	{
3554	char passwd[] = { "passwordXXXXX" };
3555	char user[] = { "usernameXXXXX" };
3556	struct radiusclientdb *db = malloc(sizeof(struct radiusclientdb));
3557	db->usercount = 0;
3558	db->users = NULL;
3559	while (1) {
3560	sprintf(user, "client%d", db->usercount);
3561	sprintf(passwd, "shared%d", db->usercount);
3562	char *u = websGetVar(wp, user, NULL);
3563	if (!u)
3564	break;
3565	char *p = websGetVar(wp, passwd, NULL);
3566	if (!p)
3567	break;
3568
3569	db->users =
3570	realloc(db->users,
3571	sizeof(struct radiusclient) * (db->usercount + 1));
3572
3573	db->users[db->usercount].client = malloc(strlen(u) + 1);
3574	strcpy(db->users[db->usercount].client, u);
3575	db->users[db->usercount].clientsize = strlen(u) + 1;
3576	db->users[db->usercount].passwd = malloc(strlen(p) + 1);
3577	strcpy(db->users[db->usercount].passwd, p);
3578	db->users[db->usercount].passwordsize = strlen(p) + 1;
3579	db->usercount++;
3580	}
3581	writeradiusclientdb(db);
3582	freeradiusclientdb(db);
3583
3584	}
3585
3586	static void save_radius_users(webs_t wp)
3587	{
3588	char passwd[] = { "passwordXXXXX" };
3589	char user[] = { "usernameXXXXX" };
3590	char downstream[] = { "passwordXXXXX" };
3591	char upstream[] = { "usernameXXXXX" };
3592	char expiration[] = { "expirationXXXXX" };
3593	struct radiusdb *db = malloc(sizeof(struct radiusdb));
3594	char filename[128];
3595	db->usercount = 0;
3596	db->users = NULL;
3597	time_t tm;
3598	time(&tm);
3599	while (1) {
3600	sprintf(user, "username%d", db->usercount);
3601	sprintf(passwd, "password%d", db->usercount);
3602	sprintf(downstream, "downstream%d", db->usercount);
3603	sprintf(upstream, "upstream%d", db->usercount);
3604	sprintf(expiration, "expiration%d", db->usercount);
3605	char *u = websGetVar(wp, user, NULL);
3606	if (!u)
3607	break;
3608	sprintf(filename,
3609	"/jffs/etc/freeradius/certs/clients/%s-cert.pem", u);
3610	sysprintf("rm -f %s", filename);
3611	char *p = websGetVar(wp, passwd, NULL);
3612	if (!p)
3613	break;
3614
3615	char *d = websGetVar(wp, downstream, NULL);
3616	if (!d)
3617	break;
3618
3619	char *up = websGetVar(wp, upstream, NULL);
3620	if (!up)
3621	break;
3622
3623	char *e = websGetVar(wp, expiration, NULL);
3624	if (!e)
3625	break;
3626	db->users =
3627	realloc(db->users,
3628	sizeof(struct radiususer) * (db->usercount + 1));
3629
3630	db->users[db->usercount].user = malloc(strlen(u) + 1);
3631	strcpy(db->users[db->usercount].user, u);
3632	db->users[db->usercount].usersize = strlen(u) + 1;
3633	db->users[db->usercount].passwd = malloc(strlen(p) + 1);
3634	strcpy(db->users[db->usercount].passwd, p);
3635	db->users[db->usercount].passwordsize = strlen(p) + 1;
3636	db->users[db->usercount].downstream = atoi(d);
3637	db->users[db->usercount].upstream = atoi(up);
3638	long expiration = atoi(e);
3639	if (expiration) {
3640	long curtime = ((tm / 60) / 60) / 24; //in days
3641	expiration = expiration + curtime;
3642	}
3643	db->users[db->usercount].expiration = expiration;
3644	db->usercount++;
3645	}
3646	writeradiusdb(db);
3647	freeradiusdb(db);
3648
3649	}
3650
3651	void save_radius_user(webs_t wp)
3652	{
3653	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3654	nvram_set("radius_port", websGetVar(wp, "radius_port", "1812"));
3655	save_radius_users(wp);
3656	save_radius_clients(wp);
3657
3658	char *value = websGetVar(wp, "action", "");
3659	addAction("freeradius");
3660	applytake(value);
3661	}
3662
3663	#endif

Note: See TracBrowser for help on using the repository browser.

Download in other formats: