Context Navigation

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

Last change on this file since 14265 was 14265, checked in by BrainSlayer, 3 years ago
fix
File size: 81.4 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	#ifdef HAVE_AOSS
1821	// must remove all aoss vap's if one of them is touched
1822	if (strlen(nvram_safe_get("aoss_vifs")))
1823	{
1824	nvram_set("ath0_vifs","");
1825	nvram_set("aoss_vifs","");
1826	}
1827	#endif
1828	}
1829
1830	void remove_vifs(webs_t wp)
1831	{
1832	char *prefix = websGetVar(wp, "iface", NULL);
1833
1834	remove_vifs_single(prefix);
1835	}
1836
1837	#ifdef HAVE_BONDING
1838	void add_bond(webs_t wp)
1839	{
1840	static char word[256];
1841	char next, wordlist;
1842	int count = 0;
1843	int realcount = atoi(nvram_safe_get("bonding_count"));
1844
1845	if (realcount == 0) {
1846	wordlist = nvram_safe_get("bondings");
1847	foreach(word, wordlist, next) {
1848	count++;
1849	}
1850	realcount = count;
1851	}
1852	realcount++;
1853	char var[32];
1854
1855	sprintf(var, "%d", realcount);
1856	nvram_set("bonding_count", var);
1857	nvram_commit();
1858	return;
1859	}
1860
1861	void del_bond(webs_t wp)
1862	{
1863	static char word[256];
1864	int realcount = 0;
1865	char next, wordlist, *newwordlist;
1866	char *val = websGetVar(wp, "del_value", NULL);
1867
1868	if (val == NULL)
1869	return;
1870	int todel = atoi(val);
1871
1872	wordlist = nvram_safe_get("bondings");
1873	newwordlist = (char *)malloc(strlen(wordlist));
1874	memset(newwordlist, 0, strlen(wordlist));
1875	int count = 0;
1876
1877	foreach(word, wordlist, next) {
1878	if (count != todel) {
1879	strcat(newwordlist, word);
1880	strcat(newwordlist, " ");
1881	}
1882	count++;
1883	}
1884
1885	char var[32];
1886
1887	realcount = atoi(nvram_safe_get("bonding_count")) - 1;
1888	sprintf(var, "%d", realcount);
1889	nvram_set("bonding_count", var);
1890	nvram_set("bondings", newwordlist);
1891	nvram_commit();
1892	free(newwordlist);
1893
1894	return;
1895	}
1896	#endif
1897
1898	#ifdef HAVE_OLSRD
1899	void add_olsrd(webs_t wp)
1900	{
1901	char *ifname = websGetVar(wp, "olsrd_ifname", NULL);
1902
1903	if (ifname == NULL)
1904	return;
1905	char *wordlist = nvram_safe_get("olsrd_interfaces");
1906	char *addition = ">5.0>90.0>2.0>270.0>15.0>90.0>15.0>90.0";
1907	char *newadd =
1908	(char *)malloc(strlen(wordlist) + strlen(addition) +
1909	strlen(ifname) + 2);
1910	if (strlen(wordlist) > 0) {
1911	strcpy(newadd, wordlist);
1912	strcat(newadd, " ");
1913	strcat(newadd, ifname);
1914	} else {
1915	strcpy(newadd, ifname);
1916	}
1917	strcat(newadd, addition);
1918	nvram_set("olsrd_interfaces", newadd);
1919	nvram_commit();
1920	free(newadd);
1921	return;
1922	}
1923
1924	void del_olsrd(webs_t wp)
1925	{
1926	char *del = websGetVar(wp, "olsrd_delcount", NULL);
1927
1928	if (del == NULL)
1929	return;
1930	int d = atoi(del);
1931	char *wordlist = nvram_safe_get("olsrd_interfaces");
1932	char newlist = (char )malloc(strlen(wordlist) + 1);
1933
1934	memset(newlist, 0, strlen(wordlist));
1935	char *next;
1936	char word[128];
1937	int count = 0;
1938
1939	foreach(word, wordlist, next) {
1940	if (count != d)
1941	sprintf(newlist, "%s %s", newlist, word);
1942	count++;
1943	}
1944	nvram_set("olsrd_interfaces", newlist);
1945	nvram_commit();
1946	free(newlist);
1947	return;
1948	}
1949
1950	void save_olsrd(webs_t wp)
1951	{
1952	char *wordlist = nvram_safe_get("olsrd_interfaces");
1953	char newlist = (char )malloc(strlen(wordlist) + 512);
1954
1955	memset(newlist, 0, strlen(wordlist) + 512);
1956	char *next;
1957	char word[64];
1958
1959	foreach(word, wordlist, next) {
1960	char *interface = word;
1961	char *dummy = interface;
1962
1963	strsep(&dummy, ">");
1964	char valuename[32];
1965
1966	sprintf(valuename, "%s_hellointerval", interface);
1967	char *hellointerval = websGetVar(wp, valuename, "0");
1968
1969	sprintf(valuename, "%s_hellovaliditytime", interface);
1970	char *hellovaliditytime = websGetVar(wp, valuename, "0");
1971
1972	sprintf(valuename, "%s_tcinterval", interface);
1973	char *tcinterval = websGetVar(wp, valuename, "0");
1974
1975	sprintf(valuename, "%s_tcvaliditytime", interface);
1976	char *tcvaliditytime = websGetVar(wp, valuename, "0");
1977
1978	sprintf(valuename, "%s_midinterval", interface);
1979	char *midinterval = websGetVar(wp, valuename, "0");
1980
1981	sprintf(valuename, "%s_midvaliditytime", interface);
1982	char *midvaliditytime = websGetVar(wp, valuename, "0");
1983
1984	sprintf(valuename, "%s_hnainterval", interface);
1985	char *hnainterval = websGetVar(wp, valuename, "0");
1986
1987	sprintf(valuename, "%s_hnavaliditytime", interface);
1988	char *hnavaliditytime = websGetVar(wp, valuename, "0");
1989
1990	sprintf(newlist, "%s %s>%s>%s>%s>%s>%s>%s>%s>%s", newlist,
1991	interface, hellointerval, hellovaliditytime, tcinterval,
1992	tcvaliditytime, midinterval, midvaliditytime,
1993	hnainterval, hnavaliditytime);
1994	}
1995	nvram_set("olsrd_interfaces", newlist);
1996	nvram_commit();
1997	free(newlist);
1998	return;
1999	}
2000	#endif
2001
2002	#ifdef HAVE_VLANTAGGING
2003
2004	void save_networking(webs_t wp)
2005	{
2006	char *value = websGetVar(wp, "action", "");
2007	int vlancount = atoi(nvram_safe_get("vlan_tagcount"));
2008	int bridgescount = atoi(nvram_safe_get("bridges_count"));
2009	int bridgesifcount = atoi(nvram_safe_get("bridgesif_count"));
2010	int mdhcpd_count = atoi(nvram_safe_get("mdhcpd_count"));
2011
2012	#ifdef HAVE_BONDING
2013	int bondcount = atoi(nvram_safe_get("bonding_count"));
2014	#endif
2015	int i;
2016
2017	// save vlan stuff
2018	char buffer[1024];
2019
2020	memset(buffer, 0, 1024);
2021	for (i = 0; i < vlancount; i++) {
2022	char ifname, tag, *prio;
2023	char var[32];
2024
2025	sprintf(var, "vlanifname%d", i);
2026	ifname = websGetVar(wp, var, NULL);
2027	if (!ifname)
2028	return;
2029	sprintf(var, "vlantag%d", i);
2030	tag = websGetVar(wp, var, NULL);
2031	if (!tag)
2032	return;
2033	sprintf(var, "vlanprio%d", i);
2034	prio = websGetVar(wp, var, NULL);
2035	if (!prio)
2036	return;
2037	strcat(buffer, ifname);
2038	strcat(buffer, ">");
2039	strcat(buffer, tag);
2040	strcat(buffer, ">");
2041	strcat(buffer, prio);
2042	if (i < vlancount - 1)
2043	strcat(buffer, " ");
2044	}
2045	nvram_set("vlan_tags", buffer);
2046	// save bonds
2047	memset(buffer, 0, 1024);
2048	#ifdef HAVE_BONDING
2049	char *bondingnumber = websGetVar(wp, "bonding_number", NULL);
2050
2051	if (bondingnumber)
2052	nvram_set("bonding_number", bondingnumber);
2053	char *bondingtype = websGetVar(wp, "bonding_type", NULL);
2054
2055	if (bondingtype)
2056	nvram_set("bonding_type", bondingtype);
2057	for (i = 0; i < bondcount; i++) {
2058	char ifname, tag;
2059	char var[32];
2060
2061	sprintf(var, "bondingifname%d", i);
2062	ifname = websGetVar(wp, var, NULL);
2063	if (!ifname)
2064	return;
2065	sprintf(var, "bondingattach%d", i);
2066	tag = websGetVar(wp, var, NULL);
2067	if (!tag)
2068	return;
2069	strcat(buffer, ifname);
2070	strcat(buffer, ">");
2071	strcat(buffer, tag);
2072	if (i < bondcount - 1)
2073	strcat(buffer, " ");
2074	}
2075	nvram_set("bondings", buffer);
2076	memset(buffer, 0, 1024);
2077	#endif
2078
2079	// save bridges
2080
2081	for (i = 0; i < bridgescount; i++) {
2082	char ifname, tag, prio, mtu;
2083	char var[32];
2084	char ipaddr[32];
2085	char netmask[32];
2086	char n[32];
2087
2088	memset(ipaddr, 0, 32);
2089	memset(netmask, 0, 32);
2090	sprintf(var, "bridgename%d", i);
2091	ifname = websGetVar(wp, var, NULL);
2092	if (!ifname)
2093	return;
2094	sprintf(var, "bridgestp%d", i);
2095	tag = websGetVar(wp, var, NULL);
2096	if (!tag)
2097	return;
2098	sprintf(var, "bridgeprio%d", i);
2099	prio = websGetVar(wp, var, NULL);
2100	if (!prio)
2101	prio = "32768";
2102	if (strlen(prio) == 0)
2103	prio = "32768";
2104
2105	sprintf(var, "bridgemtu%d", i);
2106	mtu = websGetVar(wp, var, NULL);
2107	if (!mtu)
2108	mtu = "1500";
2109	if (strlen(prio) == 0)
2110	mtu = "1500";
2111
2112	sprintf(n, "%s_ipaddr", ifname);
2113	if (get_merge_ipaddr(wp, n, ipaddr))
2114	nvram_set(n, ipaddr);
2115	sprintf(n, "%s_netmask", ifname);
2116	if (get_merge_ipaddr(wp, n, netmask))
2117	nvram_set(n, netmask);
2118
2119	strcat(buffer, ifname);
2120	strcat(buffer, ">");
2121	if (!strcmp(tag, "On"))
2122	strcat(buffer, "On");
2123	else
2124	strcat(buffer, "Off");
2125	strcat(buffer, ">");
2126	strcat(buffer, prio);
2127	strcat(buffer, ">");
2128	strcat(buffer, mtu);
2129	if (i < bridgescount - 1)
2130	strcat(buffer, " ");
2131	}
2132	nvram_set("bridges", buffer);
2133	// save bridge assignment
2134	memset(buffer, 0, 1024);
2135	for (i = 0; i < bridgesifcount; i++) {
2136	char ifname, tag, *prio;
2137	char var[32];
2138
2139	sprintf(var, "bridge%d", i);
2140	ifname = websGetVar(wp, var, NULL);
2141	if (!ifname)
2142	return;
2143	sprintf(var, "bridgeif%d", i);
2144	tag = websGetVar(wp, var, NULL);
2145	if (!tag)
2146	return;
2147	sprintf(var, "bridgeifprio%d", i);
2148	prio = websGetVar(wp, var, NULL);
2149	if (!prio)
2150	prio = "128";
2151	if (strlen(prio) == 0)
2152	prio = "128";
2153	strcat(buffer, ifname);
2154	strcat(buffer, ">");
2155	strcat(buffer, tag);
2156	strcat(buffer, ">");
2157	strcat(buffer, prio);
2158	if (i < bridgesifcount - 1)
2159	strcat(buffer, " ");
2160	}
2161	nvram_set("bridgesif", buffer);
2162	#ifdef HAVE_MDHCP
2163	// save multipe dhcp-servers
2164	memset(buffer, 0, 1024);
2165	// if (!interface \|\| !start \|\| !dhcpon \|\| !max \|\| !leasetime)
2166	for (i = 0; i < mdhcpd_count; i++) {
2167	char mdhcpinterface, mdhcpon, mdhcpstart, mdhcpmax,
2168	*mdhcpleasetime;
2169	char var[32];
2170
2171	sprintf(var, "mdhcpifname%d", i);
2172	mdhcpinterface = websGetVar(wp, var, NULL);
2173	if (!mdhcpinterface)
2174	return;
2175
2176	sprintf(var, "mdhcpon%d", i);
2177	mdhcpon = websGetVar(wp, var, NULL);
2178	if (!mdhcpon)
2179	return;
2180
2181	sprintf(var, "mdhcpstart%d", i);
2182	mdhcpstart = websGetVar(wp, var, NULL);
2183	if (!mdhcpstart)
2184	return;
2185
2186	sprintf(var, "mdhcpmax%d", i);
2187	mdhcpmax = websGetVar(wp, var, NULL);
2188	if (!mdhcpmax)
2189	return;
2190
2191	sprintf(var, "mdhcpleasetime%d", i);
2192	mdhcpleasetime = websGetVar(wp, var, NULL);
2193	if (!mdhcpleasetime)
2194	return;
2195
2196	strcat(buffer, mdhcpinterface);
2197	strcat(buffer, ">");
2198	strcat(buffer, mdhcpon);
2199	strcat(buffer, ">");
2200	strcat(buffer, mdhcpstart);
2201	strcat(buffer, ">");
2202	strcat(buffer, mdhcpmax);
2203	strcat(buffer, ">");
2204	strcat(buffer, mdhcpleasetime);
2205	if (i < mdhcpd_count - 1)
2206	strcat(buffer, " ");
2207	}
2208	nvram_set("mdhcpd", buffer);
2209	#endif
2210	#ifdef HAVE_PORTSETUP
2211	validate_portsetup(wp, NULL, NULL);
2212	#endif
2213
2214	applytake(value);
2215	}
2216
2217	void add_vlan(webs_t wp)
2218	{
2219	static char word[256];
2220	char next, wordlist;
2221	int count = 0;
2222	int realcount = atoi(nvram_safe_get("vlan_tagcount"));
2223
2224	if (realcount == 0) {
2225	wordlist = nvram_safe_get("vlan_tags");
2226	foreach(word, wordlist, next) {
2227	count++;
2228	}
2229	realcount = count;
2230	}
2231	realcount++;
2232	char var[32];
2233
2234	sprintf(var, "%d", realcount);
2235	nvram_set("vlan_tagcount", var);
2236	nvram_commit();
2237	return;
2238	}
2239
2240	void del_vlan(webs_t wp)
2241	{
2242	static char word[256];
2243	int realcount = 0;
2244	char next, wordlist, *newwordlist;
2245	char *val = websGetVar(wp, "del_value", NULL);
2246
2247	if (val == NULL)
2248	return;
2249	int todel = atoi(val);
2250
2251	wordlist = nvram_safe_get("vlan_tags");
2252	newwordlist = (char *)malloc(strlen(wordlist));
2253	memset(newwordlist, 0, strlen(wordlist));
2254	int count = 0;
2255
2256	foreach(word, wordlist, next) {
2257	if (count != todel) {
2258	strcat(newwordlist, word);
2259	strcat(newwordlist, " ");
2260	} else {
2261	char *port = word;
2262	char *tag = strsep(&port, ">");
2263
2264	if (!tag \|\| !port)
2265	break;
2266	char names[32];
2267
2268	sprintf(names, "%s.%s", tag, port);
2269	eval("ifconfig", names, "down");
2270	eval("vconfig", "rem", names);
2271	}
2272	count++;
2273	}
2274
2275	char var[32];
2276
2277	realcount = atoi(nvram_safe_get("vlan_tagcount")) - 1;
2278	sprintf(var, "%d", realcount);
2279	nvram_set("vlan_tagcount", var);
2280	nvram_set("vlan_tags", newwordlist);
2281	nvram_commit();
2282	free(newwordlist);
2283
2284	return;
2285	}
2286
2287	void add_mdhcp(webs_t wp)
2288	{
2289	static char word[256];
2290	char next, wordlist;
2291	int count = 0;
2292	int realcount = atoi(nvram_safe_get("mdhcpd_count"));
2293
2294	if (realcount == 0) {
2295	wordlist = nvram_safe_get("mdhcpd");
2296	foreach(word, wordlist, next) {
2297	count++;
2298	}
2299	realcount = count;
2300	}
2301	realcount++;
2302	char var[32];
2303
2304	sprintf(var, "%d", realcount);
2305	nvram_set("mdhcpd_count", var);
2306	nvram_commit();
2307	return;
2308	}
2309
2310	void del_mdhcp(webs_t wp)
2311	{
2312	static char word[256];
2313	int realcount = 0;
2314	char next, wordlist, *newwordlist;
2315	char *val = websGetVar(wp, "del_value", NULL);
2316
2317	if (val == NULL)
2318	return;
2319	int todel = atoi(val);
2320
2321	wordlist = nvram_safe_get("mdhcpd");
2322	newwordlist = (char *)malloc(strlen(wordlist));
2323	memset(newwordlist, 0, strlen(wordlist));
2324	int count = 0;
2325
2326	foreach(word, wordlist, next) {
2327	if (count != todel) {
2328	strcat(newwordlist, word);
2329	strcat(newwordlist, " ");
2330	}
2331	count++;
2332	}
2333
2334	char var[32];
2335
2336	realcount = atoi(nvram_safe_get("mdhcpd_count")) - 1;
2337	sprintf(var, "%d", realcount);
2338	nvram_set("mdhcpd_count", var);
2339	nvram_set("mdhcpd", newwordlist);
2340	nvram_commit();
2341	free(newwordlist);
2342
2343	return;
2344	}
2345
2346	void del_bridge(webs_t wp)
2347	{
2348	static char word[256];
2349	int realcount = 0;
2350	char next, wordlist, *newwordlist;
2351	char *val = websGetVar(wp, "del_value", NULL);
2352
2353	if (val == NULL)
2354	return;
2355	int todel = atoi(val);
2356
2357	wordlist = nvram_safe_get("bridges");
2358	newwordlist = (char *)malloc(strlen(wordlist));
2359	memset(newwordlist, 0, strlen(wordlist));
2360	int count = 0;
2361
2362	foreach(word, wordlist, next) {
2363	if (count != todel) {
2364	strcat(newwordlist, word);
2365	strcat(newwordlist, " ");
2366	} else {
2367	char *port = word;
2368	char *tag = strsep(&port, ">");
2369	char *prio = port;
2370
2371	strsep(&prio, ">");
2372	if (!tag \|\| !port)
2373	continue;
2374	eval("ifconfig", tag, "down");
2375	eval("brctl", "delbr", tag);
2376	}
2377	count++;
2378	}
2379
2380	realcount = atoi(nvram_safe_get("bridges_count")) - 1;
2381	char var[32];
2382
2383	sprintf(var, "%d", realcount);
2384	nvram_set("bridges_count", var);
2385	nvram_set("bridges", newwordlist);
2386	nvram_commit();
2387	free(newwordlist);
2388
2389	return;
2390	}
2391
2392	void add_bridge(webs_t wp)
2393	{
2394	static char word[256];
2395	char next, wordlist;
2396	int count = 0;
2397	int realcount = atoi(nvram_safe_get("bridges_count"));
2398
2399	if (realcount == 0) {
2400	wordlist = nvram_safe_get("bridges");
2401	foreach(word, wordlist, next) {
2402	count++;
2403	}
2404	realcount = count;
2405	}
2406	realcount++;
2407	char var[32];
2408
2409	sprintf(var, "%d", realcount);
2410	nvram_set("bridges_count", var);
2411	nvram_commit();
2412	return;
2413	}
2414
2415	void del_bridgeif(webs_t wp)
2416	{
2417	static char word[256];
2418	int realcount = 0;
2419	char next, wordlist, *newwordlist;
2420	char *val = websGetVar(wp, "del_value", NULL);
2421
2422	if (val == NULL)
2423	return;
2424	int todel = atoi(val);
2425
2426	wordlist = nvram_safe_get("bridgesif");
2427	newwordlist = (char *)malloc(strlen(wordlist));
2428	memset(newwordlist, 0, strlen(wordlist));
2429	int count = 0;
2430
2431	foreach(word, wordlist, next) {
2432	if (count != todel) {
2433	strcat(newwordlist, word);
2434	strcat(newwordlist, " ");
2435	}
2436	count++;
2437	}
2438
2439	char var[32];
2440
2441	realcount = atoi(nvram_safe_get("bridgesif_count")) - 1;
2442	sprintf(var, "%d", realcount);
2443	nvram_set("bridgesif_count", var);
2444	nvram_set("bridgesif", newwordlist);
2445	nvram_commit();
2446	free(newwordlist);
2447
2448	return;
2449	}
2450
2451	void add_bridgeif(webs_t wp)
2452	{
2453
2454	static char word[256];
2455	char next, wordlist;
2456	int count = 0;
2457	int realcount = atoi(nvram_safe_get("bridgesif_count"));
2458
2459	if (realcount == 0) {
2460	wordlist = nvram_safe_get("bridgesif");
2461	foreach(word, wordlist, next) {
2462	count++;
2463	}
2464	realcount = count;
2465	}
2466	realcount++;
2467	char var[32];
2468
2469	sprintf(var, "%d", realcount);
2470	nvram_set("bridgesif_count", var);
2471	nvram_commit();
2472	return;
2473	}
2474
2475	#endif
2476
2477	static void save_prefix(webs_t wp, char *prefix)
2478	{
2479	char n[80];
2480
2481	#ifdef HAVE_MADWIFI
2482	char sifs[80];
2483	char turbo[80];
2484	char chanbw[80];
2485	char preamble[80];
2486	int cbwchanged = 0;
2487	#endif
2488	sprintf(n, "%s_ssid", prefix);
2489	copytonv(wp, n);
2490	if (!strcmp(prefix, "wl0") \|\| !strcmp(prefix, "wl1")) {
2491	char *wl = websGetVar(wp, n, NULL);
2492
2493	cprintf("copy value %s which is [%s] to nvram\n", n, wl);
2494	if (wl) {
2495	if (!strcmp(prefix, "wl0"))
2496	nvram_set("wl_ssid", wl);
2497	else
2498	nvram_set("wl1_ssid", wl);
2499	}
2500	}
2501	copytonv(wp, "%s_distance", prefix);
2502	#ifdef HAVE_MADWIFI
2503	{
2504	sprintf(n, "%s_txpwrdbm", prefix);
2505	char *sl = websGetVar(wp, n, NULL);
2506
2507	if (sl) {
2508	int base = atoi(sl);
2509	#ifdef HAVE_WIKINGS
2510	if (base > 28)
2511	base = 28;
2512	#ifdef HAVE_SUB3
2513	if (base > 25)
2514	base = 25;
2515	#endif
2516	#ifdef HAVE_SUB6
2517	if (base > 22)
2518	base = 22;
2519	#endif
2520	#endif
2521	int txpower = base - wifi_gettxpoweroffset(prefix);
2522
2523	if (txpower < 1)
2524	txpower = 1;
2525	sprintf(turbo, "%d", txpower);
2526	nvram_set(n, turbo);
2527	}
2528	}
2529	copytonv(wp, "%s_antgain", prefix);
2530	copytonv(wp, "%s_regulatory", prefix);
2531	sprintf(n, "%s_scanlist", prefix);
2532	{
2533	char *sl = websGetVar(wp, n, NULL);
2534
2535	if (sl) {
2536	char slc = (char )malloc(strlen(sl) + 1);
2537
2538	strcpy(slc, sl);
2539	int i, sllen = strlen(slc);
2540
2541	for (i = 0; i < sllen; i++) {
2542	if (slc[i] == ';')
2543	slc[i] = ' ';
2544	if (slc[i] == ',')
2545	slc[i] = ' ';
2546	}
2547	nvram_set(n, slc);
2548	}
2549	}
2550	#ifdef HAVE_MAKSAT
2551	copytonv(wp, "ath_specialmode");
2552	#endif
2553	copytonv(wp, "%s_regdomain", prefix);
2554
2555	copytonv(wp, "%s_rts", prefix);
2556	if (nvram_nmatch("1", "%s_rts", prefix)) {
2557	sprintf(turbo, "%s_rtsvalue", prefix);
2558	char *tw = websGetVar(wp, turbo, NULL);
2559
2560	if (tw) {
2561	if (atoi(tw) < 1)
2562	tw = "1";
2563	if (atoi(tw) > 2346)
2564	tw = "2346";
2565	nvram_nset(tw, "%s_rtsvalue", prefix);
2566	}
2567	}
2568	copytonv(wp, "%s_protmode", prefix);
2569	copytonv(wp, "%s_minrate", prefix);
2570	copytonv(wp, "%s_maxrate", prefix);
2571	copytonv(wp, "%s_xr", prefix);
2572	copytonv(wp, "%s_outdoor", prefix);
2573	// copytonv( wp, "%s_compression", prefix ); // Atheros SuperG header
2574	// compression
2575	copytonv(wp, "%s_ff", prefix); // ff = 0, Atheros SuperG fast
2576	// framing disabled, 1 fast framing
2577	// enabled
2578	copytonv(wp, "%s_diversity", prefix);
2579	copytonv(wp, "%s_preamble", prefix);
2580	copytonv(wp, "%s_wmm", prefix);
2581	copytonv(wp, "%s_txantenna", prefix);
2582	copytonv(wp, "%s_rxantenna", prefix);
2583	copytonv(wp, "%s_intmit", prefix);
2584	copytonv(wp, "%s_csma", prefix);
2585	copytonv(wp, "%s_noise_immunity", prefix);
2586	copytonv(wp, "%s_ofdm_weak_det", prefix);
2587
2588	copytonv(wp, "%s_chanshift", prefix);
2589	copytonv(wp, "%s_doth", prefix);
2590	copytonv(wp, "%s_maxassoc", prefix);
2591
2592	sprintf(chanbw, "%s_channelbw", prefix);
2593	char *cbw = websGetVar(wp, chanbw, NULL);
2594
2595	if (cbw && !nvram_match(chanbw, cbw)) {
2596	cbwchanged = 1;
2597	}
2598	if (cbw)
2599	nvram_set(chanbw, cbw);
2600
2601	copytonv(wp, "%s_xr", prefix);
2602	copytonv(wp, "%s_sifstime", prefix);
2603	copytonv(wp, "%s_preambletime", prefix);
2604	copytonv(wp, "%s_mtikie", prefix);
2605	copytonv(wp, "%s_cardtype", prefix);
2606
2607	#endif
2608	copytonv(wp, "%s_closed", prefix);
2609
2610	#ifndef HAVE_MADWIFI
2611	char *ifname = "wl0";
2612
2613	#ifndef HAVE_RT2880
2614
2615	if (!strcmp(prefix, "wl0"))
2616	ifname = get_wl_instance_name(0);
2617	else if (!strcmp(prefix, "wl1"))
2618	ifname = get_wl_instance_name(1);
2619	else
2620	ifname = prefix;
2621	#else
2622	ifname = getRADev(prefix);
2623	#endif
2624	copytonv(wp, "%s_multicast", ifname);
2625	copytonv(wp, "%s_bridged", ifname);
2626	copytonv(wp, "%s_nat", prefix);
2627
2628	char addr[32];
2629
2630	sprintf(n, "%s_ipaddr", ifname);
2631	if (get_merge_ipaddr(wp, n, addr))
2632	nvram_set(n, addr);
2633
2634	sprintf(n, "%s_netmask", ifname);
2635	if (get_merge_ipaddr(wp, n, addr))
2636	nvram_set(n, addr);
2637	#else
2638
2639	copytonv(wp, "%s_multicast", prefix);
2640	copytonv(wp, "%s_bridged", prefix);
2641	copytonv(wp, "%s_nat", prefix);
2642	char addr[32];
2643
2644	sprintf(n, "%s_ipaddr", prefix);
2645	if (get_merge_ipaddr(wp, n, addr))
2646	nvram_set(n, addr);
2647
2648	sprintf(n, "%s_netmask", prefix);
2649	if (get_merge_ipaddr(wp, n, addr))
2650	nvram_set(n, addr);
2651
2652	copytonv(wp, "%s_duallink", prefix);
2653	sprintf(n, "%s_duallink_parent", prefix);
2654	if (get_merge_ipaddr(wp, n, addr))
2655	nvram_set(n, addr);
2656
2657	#endif
2658
2659	copytonv(wp, "%s_ap_isolate", prefix);
2660	sprintf(n, "%s_mode", prefix);
2661	if (nvram_match(n, "sta")) {
2662	char *wl = websGetVar(wp, n, NULL);
2663
2664	if (wl)
2665	if (!strcmp(wl, "ap") \|\| !strcmp(wl, "wdsap")
2666	\|\| !strcmp(wl, "infra") \|\| !strcmp(wl, "wdssta")) {
2667	nvram_set("wan_proto", "disabled");
2668	}
2669	}
2670	copytonv(wp, n);
2671	if (!strcmp(prefix, "wl0") \|\| !strcmp(prefix, "wl1")) {
2672	char *wl = websGetVar(wp, n, NULL);
2673
2674	cprintf("copy value %s which is [%s] to nvram\n", n, wl);
2675	if (wl && !strcmp(prefix, "wl0"))
2676	nvram_set("wl_mode", wl);
2677	#ifndef HAVE_MADWIFI
2678	if (strcmp(wl, "ap") && strcmp(wl, "apsta")
2679	&& strcmp(wl, "apstawet")) {
2680	nvram_nset("", "%s_vifs", prefix);
2681	}
2682	#endif
2683	}
2684	int chanchanged = 0;
2685
2686	#ifdef HAVE_RT2880
2687	copytonv(wp, "%s_greenfield", prefix);
2688	#endif
2689
2690	#ifndef HAVE_MADWIFI
2691	if (!strcmp(prefix, "wl0") \|\| !strcmp(prefix, "wl1"))
2692	#endif
2693	{
2694
2695	sprintf(n, "%s_net_mode", prefix);
2696	if (!nvram_match(n, websGetVar(wp, n, ""))) {
2697	chanchanged = 1;
2698	copytonv(wp, n);
2699	if (!strcmp(prefix, "wl0"))
2700	convert_wl_gmode(nvram_safe_get(n), "wl");
2701	else
2702	convert_wl_gmode(nvram_safe_get(n), prefix);
2703	}
2704	}
2705	#ifdef HAVE_MADWIFI
2706	if (cbwchanged \|\| chanchanged) {
2707	if (nvram_match(chanbw, "40")) {
2708	nvram_set(sifs, "8");
2709	nvram_set(preamble, "14");
2710	} else if (nvram_match(chanbw, "5")) {
2711	nvram_set(sifs, "64");
2712	nvram_set(preamble, "80");
2713	} else if (nvram_match(chanbw, "10")) {
2714	nvram_set(sifs, "32");
2715	nvram_set(preamble, "40");
2716	} else {
2717	nvram_set(sifs, "16");
2718	nvram_set(preamble, "20");
2719	}
2720
2721	}
2722	#endif
2723	copytonv(wp, "%s_nbw", prefix);
2724	copytonv(wp, "%s_nctrlsb", prefix);
2725
2726	sprintf(n, "%s_channel", prefix);
2727	if (!strcmp(prefix, "wl0") \|\| !strcmp(prefix, "wl1")) {
2728	char *wl = websGetVar(wp, n, NULL);
2729
2730	cprintf("copy value %s which is [%s] to nvram\n", n, wl);
2731	if (wl && !strcmp(prefix, "wl0"))
2732	nvram_set("wl_channel", wl);
2733	else if (wl)
2734	nvram_set("wl1_channel", wl);
2735	}
2736	copytonv(wp, n);
2737
2738	sprintf(n, "%s_wchannel", prefix);
2739	if (!strcmp(prefix, "wl0") \|\| !strcmp(prefix, "wl1")) {
2740	char *wl = websGetVar(wp, n, NULL);
2741
2742	cprintf("copy value %s which is [%s] to nvram\n", n, wl);
2743	if (wl && !strcmp(prefix, "wl0"))
2744	nvram_set("wl_wchannel", wl);
2745	else if (wl)
2746	nvram_set("wl1_wchannel", wl);
2747
2748	}
2749
2750	copytonv(wp, n);
2751
2752	}
2753
2754	void wireless_save(webs_t wp)
2755	{
2756	char *value = websGetVar(wp, "action", "");
2757
2758	char *next;
2759	char var[80];
2760
2761	#ifndef HAVE_MADWIFI
2762	int c = get_wl_instances();
2763	int i;
2764
2765	for (i = 0; i < c; i++) {
2766	char buf[16];
2767
2768	sprintf(buf, "wl%d", i);
2769	save_prefix(wp, buf);
2770	char *vifs = nvram_nget("wl%d_vifs", i);
2771	#else
2772	int c = getdevicecount();
2773	int i;
2774
2775	for (i = 0; i < c; i++) {
2776	char buf[16];
2777
2778	sprintf(buf, "ath%d", i);
2779	save_prefix(wp, buf);
2780	char *vifs = nvram_nget("ath%d_vifs", i);
2781
2782	#endif
2783	if (vifs == NULL)
2784	return;
2785	foreach(var, vifs, next) {
2786	save_prefix(wp, var);
2787	}
2788	}
2789	// nvram_commit ();
2790	applytake(value);
2791	}
2792
2793	#ifdef HAVE_WIVIZ
2794	void set_wiviz(webs_t wp)
2795	{
2796
2797	char *hopdwell = websGetVar(wp, "hopdwell", NULL);
2798	char *hopseq = websGetVar(wp, "hopseq", NULL);
2799	FILE *fp = fopen("/tmp/wiviz2-cfg", "wb");
2800
2801	if (strstr(hopseq, ","))
2802	fprintf(fp, "channelsel=hop&");
2803	else
2804	fprintf(fp, "channelsel=%s&", hopseq);
2805
2806	fprintf(fp, "hopdwell=%s&hopseq=%s\n", hopdwell, hopseq);
2807
2808	nvram_set("hopdwell", hopdwell);
2809	nvram_set("hopseq", hopseq);
2810
2811	fclose(fp);
2812	killall("wiviz", SIGUSR2);
2813
2814	}
2815	#endif
2816
2817	void ttraff_erase(webs_t wp)
2818	{
2819	char line[2048];
2820	char *name = NULL;
2821
2822	system2("nvram show \| grep traff- > /tmp/.ttraff");
2823	FILE *fp = fopen("/tmp/.ttraff", "r");
2824
2825	if (fp == NULL) {
2826	return;
2827	}
2828	while (fgets(line, sizeof(line), fp) != NULL) {
2829	if (startswith(line, "traff-")) {
2830	name = strtok(line, "=");
2831	if (strlen(name) == 13) //only unset ttraf-XX-XXXX
2832	{
2833	nvram_unset(name);
2834	}
2835	}
2836	}
2837	nvram_commit();
2838	unlink("/tmp/.ttraff");
2839	}
2840
2841	void changepass(webs_t wp)
2842	{
2843	char *value = websGetVar(wp, "http_username", NULL);
2844	char *pass = websGetVar(wp, "http_passwd", NULL);
2845
2846	if (value && pass && strcmp(value, TMP_PASSWD)
2847	&& valid_name(wp, value, NULL)) {
2848	nvram_set("http_username", zencrypt(value));
2849
2850	system2("/sbin/setpasswd");
2851	}
2852
2853	if (pass && value && strcmp(pass, TMP_PASSWD)
2854	&& valid_name(wp, pass, NULL)) {
2855	nvram_set("http_passwd", zencrypt(pass));
2856
2857	system2("/sbin/setpasswd");
2858	}
2859	nvram_commit();
2860	}
2861
2862	#ifdef HAVE_CHILLILOCAL
2863
2864	void user_remove(webs_t wp)
2865	{
2866	macro_rem("fon_usernames", "fon_userlist");
2867	}
2868
2869	void user_add(webs_t wp)
2870	{
2871	macro_add("fon_usernames");
2872	// validate_userlist(wp);
2873	}
2874	#endif
2875
2876	#ifdef HAVE_RADLOCAL
2877
2878	void raduser_add(webs_t wp)
2879	{
2880	int radcount = 0;
2881	char *radc = nvram_get("iradius_count");
2882
2883	if (radc != NULL)
2884	radcount = atoi(radc);
2885	radcount++;
2886	char count[16];
2887
2888	sprintf(count, "%d", radcount);
2889	nvram_set("iradius_count", count);
2890	}
2891	#endif
2892
2893	#ifdef HAVE_MILKFISH
2894	void milkfish_sip_message(webs_t wp)
2895	{
2896	char *message = websGetVar(wp, "sip_message", NULL);
2897	char *dest = websGetVar(wp, "sip_message_dest", NULL);
2898	int i;
2899	FILE *fp = fopen("/tmp/sipmessage", "wb");
2900
2901	if (fp == NULL)
2902	return;
2903	char *host_key = message;
2904
2905	i = 0;
2906	do {
2907	if (host_key[i] != 0x0D)
2908	fprintf(fp, "%c", host_key[i]);
2909	}
2910	while (host_key[++i]);
2911	putc(0xa, fp);
2912	fclose(fp);
2913	eval("milkfish_services", "simpledd", dest);
2914	return;
2915	}
2916	#endif
2917
2918	void set_security(webs_t wp)
2919	{
2920	char *var = websGetVar(wp, "security_varname", "security_mode");
2921
2922	cprintf("set security to %s\n", var);
2923	cprintf("security var = %s\n", websGetVar(wp, var, "disabled"));
2924	char *var2 = websGetVar(wp, var, "disabled");
2925
2926	// rep(var,'X','.');
2927	nvram_set(var, var2);
2928	}
2929
2930	void
2931	base64_encode(const unsigned char *in, size_t inlen,
2932	unsigned char *out, size_t outlen)
2933	{
2934	static const char b64str[64] =
2935	"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
2936
2937	while (inlen && outlen) {
2938	*out++ = b64str[(in[0] >> 2) & 0x3f];
2939	if (!--outlen)
2940	break;
2941	*out++ =
2942	b64str[((in[0] << 4) + (--inlen ? in[1] >> 4 : 0)) & 0x3f];
2943	if (!--outlen)
2944	break;
2945	*out++ =
2946	(inlen
2947	? b64str[((in[1] << 2) + (--inlen ? in[2] >> 6 : 0)) &
2948	0x3f] : '=');
2949	if (!--outlen)
2950	break;
2951	*out++ = inlen ? b64str[in[2] & 0x3f] : '=';
2952	if (!--outlen)
2953	break;
2954	if (inlen)
2955	inlen--;
2956	if (inlen)
2957	in += 3;
2958	}
2959
2960	if (outlen)
2961	*out = '\0';
2962	}
2963
2964	char request_freedns(char user, char *password)
2965	{
2966	unsigned char final[32];
2967	char un[128];
2968
2969	unlink("/tmp/.hash");
2970	sprintf(un, "%s\|%s", user, password);
2971	sha1_ctx_t context;
2972
2973	sha1_begin(&context);
2974	sha1_hash(un, strlen(un), &context);
2975	sha1_end(final, &context);
2976	char request[128] = { 0 };
2977	int i;
2978
2979	for (i = 0; i < 20; i++)
2980	sprintf(request, "%s%02x", request, final[i]);
2981	system2("rm -f /tmp/.hash");
2982	sysprintf
2983	("wget \"http://freedns.afraid.org/api/?action=getdyndns&sha=%s\" -O /tmp/.hash",
2984	request);
2985	FILE *in = fopen("/tmp/.hash", "rb");
2986
2987	if (in == NULL)
2988	return NULL;
2989	while (getc(in) != '?' && feof(in) == 0) ;
2990	i = 0;
2991	char *hash = malloc(64);
2992
2993	if (feof(in)) {
2994	free(hash);
2995	return NULL;
2996	}
2997	for (i = 0; i < 36; i++)
2998	hash[i] = getc(in);
2999	fclose(in);
3000	hash[i++] = 0;
3001	return hash;
3002	}
3003
3004	void ddns_save_value(webs_t wp)
3005	{
3006	char enable, username, passwd, hostname, dyndnstype, wildcard,
3007	custom, conf, url, force, *wan_ip;
3008	struct variable ddns_variables[] = {
3009	{argv:ARGV("0", "1", "2", "3", "4", "5", "6",
3010	"7", "8", "9")},
3011	{argv:ARGV("30")},
3012	}, *which;
3013	char _username[] = "ddns_username_X";
3014	char _passwd[] = "ddns_passwd_X";
3015	char _hostname[] = "ddns_hostname_X";
3016	char _dyndnstype[] = "ddns_dyndnstype_X";
3017	char _wildcard[] = "ddns_wildcard_X";
3018	char _custom[] = "ddns_custom_X";
3019	char _conf[] = "ddns_conf";
3020	char _url[] = "ddns_url";
3021	char _force[] = "ddns_force";
3022	char _wan_ip[] = "ddns_wan_ip";
3023
3024	which = &ddns_variables[0];
3025
3026	enable = websGetVar(wp, "ddns_enable", NULL);
3027	if (!enable && !valid_choice(wp, enable, &which[0])) {
3028	return;
3029	}
3030	int gethash = 0;
3031
3032	switch (atoi(enable)) {
3033	case 0:
3034	// Disable
3035	nvram_set("ddns_enable", enable);
3036	return;
3037	break;
3038	case 1:
3039	// dyndns
3040	snprintf(_username, sizeof(_username), "%s", "ddns_username");
3041	snprintf(_passwd, sizeof(_passwd), "%s", "ddns_passwd");
3042	snprintf(_hostname, sizeof(_hostname), "%s", "ddns_hostname");
3043	snprintf(_dyndnstype, sizeof(_dyndnstype), "%s",
3044	"ddns_dyndnstype");
3045	snprintf(_wildcard, sizeof(_wildcard), "%s", "ddns_wildcard");
3046	break;
3047	case 2:
3048	// afraid
3049	snprintf(_username, sizeof(_username), "ddns_username_%s",
3050	enable);
3051	snprintf(_passwd, sizeof(_passwd), "ddns_passwd_%s", enable);
3052	snprintf(_hostname, sizeof(_hostname), "ddns_hostname_%s",
3053	enable);
3054	gethash = 1;
3055	break;
3056	case 3: // zoneedit
3057	case 4: // no-ip
3058	case 8: // tzo
3059	case 9: // dynSIP
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	break;
3066	case 5:
3067	// custom
3068	snprintf(_username, sizeof(_username), "ddns_username_%s",
3069	enable);
3070	snprintf(_passwd, sizeof(_passwd), "ddns_passwd_%s", enable);
3071	snprintf(_hostname, sizeof(_hostname), "ddns_hostname_%s",
3072	enable);
3073	snprintf(_custom, sizeof(_custom), "ddns_custom_%s", enable);
3074	snprintf(_conf, sizeof(_conf), "%s", "ddns_conf");
3075	snprintf(_url, sizeof(_url), "%s", "ddns_url");
3076	break;
3077	case 6:
3078	// 3322 dynamic : added botho 30/07/06
3079	snprintf(_username, sizeof(_username), "ddns_username_%s",
3080	enable);
3081	snprintf(_passwd, sizeof(_passwd), "ddns_passwd_%s", enable);
3082	snprintf(_hostname, sizeof(_hostname), "ddns_hostname_%s",
3083	enable);
3084	snprintf(_dyndnstype, sizeof(_dyndnstype), "ddns_dyndnstype_%s",
3085	enable);
3086	snprintf(_wildcard, sizeof(_wildcard), "ddns_wildcard_%s",
3087	enable);
3088	break;
3089	case 7:
3090	// easydns
3091	snprintf(_username, sizeof(_username), "ddns_username_%s",
3092	enable);
3093	snprintf(_passwd, sizeof(_passwd), "ddns_passwd_%s", enable);
3094	snprintf(_hostname, sizeof(_hostname), "ddns_hostname_%s",
3095	enable);
3096	snprintf(_wildcard, sizeof(_wildcard), "ddns_wildcard_%s",
3097	enable);
3098	break;
3099	}
3100
3101	username = websGetVar(wp, _username, NULL);
3102	passwd = websGetVar(wp, _passwd, NULL);
3103	hostname = websGetVar(wp, _hostname, NULL);
3104	dyndnstype = websGetVar(wp, _dyndnstype, NULL);
3105	wildcard = websGetVar(wp, _wildcard, NULL);
3106	custom = websGetVar(wp, _custom, NULL);
3107	conf = websGetVar(wp, _conf, NULL);
3108	url = websGetVar(wp, _url, NULL);
3109	force = websGetVar(wp, _force, NULL);
3110	wan_ip = websGetVar(wp, _wan_ip, NULL);
3111
3112	if (!username \|\| !passwd \|\| !hostname \|\| !force \|\| !wan_ip) {
3113	return;
3114	}
3115
3116	if (atoi(force) < 1 \|\| atoi(force) > 60) {
3117	force = "10";
3118	}
3119
3120	nvram_set("ddns_enable", enable);
3121	nvram_set(_username, username);
3122	if (strcmp(passwd, TMP_PASSWD)) {
3123	nvram_set(_passwd, passwd);
3124	}
3125	if (gethash && !contains(hostname, ',')) {
3126	char hostn[128];
3127	char *hash = request_freedns(username, nvram_safe_get(_passwd));
3128
3129	if (hash) {
3130	sprintf(hostn, "%s,%s", hostname, hash);
3131	nvram_set(_hostname, hostn);
3132	free(hash);
3133	} else {
3134	nvram_set(_hostname, "User/Password wrong");
3135	}
3136	} else
3137	nvram_set(_hostname, hostname);
3138	nvram_set(_dyndnstype, dyndnstype);
3139	nvram_set(_wildcard, wildcard);
3140	nvram_set(_custom, custom);
3141	nvram_set(_conf, conf);
3142	nvram_set(_url, url);
3143	nvram_set(_force, force);
3144	nvram_set(_wan_ip, wan_ip);
3145
3146	}
3147
3148	void ddns_update_value(webs_t wp)
3149	{
3150
3151	}
3152
3153	void port_vlan_table_save(webs_t wp)
3154	{
3155	int port = 0, vlan = 0, vlans[21], i;
3156	char portid[32], portvlan[64], portval, buff[32], c, *next,
3157	br0vlans[64], br1vlans[64], br2vlans[64];
3158
3159	strcpy(portvlan, "");
3160
3161	for (vlan = 0; vlan < 21; vlan++)
3162	vlans[vlan] = 0;
3163
3164	vlans[16] = 1;
3165
3166	for (port = 0; port < 5; port++) {
3167	for (vlan = 0; vlan < 21; vlan++) {
3168	snprintf(portid, 31, "port%dvlan%d", port, vlan);
3169	portval = websGetVar(wp, portid, "");
3170
3171	if (vlan < 17 \|\| vlan > 20)
3172	i = (strcmp(portval, "on") == 0);
3173	else
3174	i = (strcmp(portval, "on") != 0);
3175
3176	if (i) {
3177	if (strlen(portvlan) > 0)
3178	strcat(portvlan, " ");
3179
3180	snprintf(buff, 4, "%d", vlan);
3181	strcat(portvlan, buff);
3182	vlans[vlan] = 1;
3183	}
3184	}
3185
3186	snprintf(portid, 31, "port%dvlans", port);
3187	nvram_set(portid, portvlan);
3188	strcpy(portvlan, "");
3189	}
3190
3191	/*
3192	* done with ports 0-4, now set up #5 automaticly
3193	*/
3194	/*
3195	* if a VLAN is used, it also gets assigned to port #5
3196	*/
3197	for (vlan = 0; vlan < 17; vlan++) {
3198	if (vlans[vlan]) {
3199	if (strlen(portvlan) > 0)
3200	strcat(portvlan, " ");
3201
3202	snprintf(buff, 4, "%d", vlan);
3203	strcat(portvlan, buff);
3204	}
3205	}
3206
3207	nvram_set("port5vlans", portvlan);
3208
3209	strcpy(br0vlans, "");
3210	c = nvram_safe_get("lan_ifnames");
3211	if (c) {
3212	foreach(portid, c, next) {
3213	if (!(strncmp(portid, "vlan", 4) == 0)
3214	&& !(strncmp(portid, "eth1", 4) == 0)) {
3215	if (strlen(br0vlans) > 0)
3216	strcat(br0vlans, " ");
3217	strcat(br0vlans, portid);
3218	}
3219	}
3220	}
3221
3222	strcpy(br1vlans, "");
3223	c = nvram_safe_get("ub1_ifnames");
3224	if (c) {
3225	foreach(portid, c, next) {
3226	if (!(strncmp(portid, "vlan", 4) == 0)
3227	&& !(strncmp(portid, "eth1", 4) == 0)) {
3228	if (strlen(br1vlans) > 0)
3229	strcat(br1vlans, " ");
3230	strcat(br1vlans, portid);
3231	}
3232	}
3233	}
3234
3235	strcpy(br2vlans, "");
3236	c = nvram_safe_get("ub2_ifnames");
3237	if (c) {
3238	foreach(portid, c, next) {
3239	if (!(strncmp(portid, "vlan", 4) == 0)
3240	&& !(strncmp(portid, "eth1", 4) == 0)) {
3241	if (strlen(br2vlans) > 0)
3242	strcat(br2vlans, " ");
3243	strcat(br2vlans, portid);
3244	}
3245	}
3246	}
3247
3248	for (i = 0; i < 16; i++) {
3249	snprintf(buff, 31, "vlan%d", i);
3250	portval = websGetVar(wp, buff, "");
3251
3252	switch (atoi(portval)) {
3253	case 0:
3254	if (strlen(br0vlans) > 0)
3255	strcat(br0vlans, " ");
3256	strcat(br0vlans, buff);
3257	break;
3258	case 1:
3259	if (strlen(br1vlans) > 0)
3260	strcat(br1vlans, " ");
3261	strcat(br1vlans, buff);
3262	break;
3263	case 2:
3264	if (strlen(br2vlans) > 0)
3265	strcat(br2vlans, " ");
3266	strcat(br2vlans, buff);
3267	break;
3268	}
3269	}
3270
3271	strcpy(buff, "");
3272
3273	switch (atoi(websGetVar(wp, "wireless", ""))) {
3274	case 0:
3275	if (strlen(br0vlans) > 0)
3276	strcat(br0vlans, " ");
3277	strcat(br0vlans, get_wdev());
3278	break;
3279	case 1:
3280	if (strlen(br1vlans) > 0)
3281	strcat(br1vlans, " ");
3282	strcat(br1vlans, get_wdev());
3283	break;
3284	case 2:
3285	if (strlen(br2vlans) > 0)
3286	strcat(br2vlans, " ");
3287	strcat(br2vlans, get_wdev());
3288	break;
3289	}
3290
3291	snprintf(buff, 3, "%s", websGetVar(wp, "trunking", ""));
3292
3293	nvram_set("lan_ifnames", br0vlans);
3294	// nvram_set("ub1_ifnames", br1vlans);
3295	// nvram_set("ub2_ifnames", br2vlans);
3296	nvram_set("trunking", buff);
3297	nvram_set("vlans", "1");
3298
3299	nvram_commit();
3300
3301	}
3302
3303	static void save_macmode_if(webs_t wp, char *ifname)
3304	{
3305
3306	char macmode[32];
3307	char macmode1[32];
3308
3309	sprintf(macmode, "%s_macmode", ifname);
3310	sprintf(macmode1, "%s_macmode1", ifname);
3311	rep(macmode1, '.', 'X');
3312	char wl_macmode1, wl_macmode;
3313
3314	wl_macmode = websGetVar(wp, macmode, NULL);
3315	wl_macmode1 = websGetVar(wp, macmode1, NULL);
3316
3317	if (!wl_macmode1)
3318	return;
3319
3320	if (!strcmp(wl_macmode1, "disabled")) {
3321	nvram_set(macmode1, "disabled");
3322	nvram_set(macmode, "disabled");
3323	} else if (!strcmp(wl_macmode1, "other")) {
3324	if (!wl_macmode)
3325	nvram_set(macmode, "deny");
3326	else
3327	nvram_set(macmode, wl_macmode);
3328	nvram_set(macmode1, "other");
3329	}
3330	}
3331
3332	void save_macmode(webs_t wp)
3333	{
3334	#ifndef HAVE_MADWIFI
3335	int c = get_wl_instances();
3336	char devs[32];
3337	int i;
3338
3339	for (i = 0; i < c; i++) {
3340	sprintf(devs, "wl%d", i);
3341	save_macmode_if(wp, devs);
3342	}
3343	#else
3344	int c = getdevicecount();
3345	char devs[32];
3346	int i;
3347
3348	for (i = 0; i < c; i++) {
3349	sprintf(devs, "ath%d", i);
3350	save_macmode_if(wp, devs);
3351	char vif[32];
3352
3353	sprintf(vif, "%s_vifs", devs);
3354	char var[80], *next;
3355	char *vifs = nvram_safe_get(vif);
3356
3357	if (vifs != NULL)
3358	foreach(var, vifs, next) {
3359	save_macmode_if(wp, var);
3360	}
3361	}
3362
3363	#endif
3364	return;
3365
3366	}
3367
3368	// handle UPnP.asp requests / added 10
3369	void tf_upnp(webs_t wp)
3370	{
3371	char *v;
3372	char s[64];
3373
3374	if (((v = websGetVar(wp, "remove", NULL)) != NULL) && (*v)) {
3375	if (strcmp(v, "all") == 0) {
3376	nvram_set("upnp_clear", "1");
3377	} else {
3378	int which = atoi(nvram_default_get("forward_cur", "0"));
3379	int i = atoi(v);
3380	char val[32];
3381
3382	sprintf(val, "forward_port%d", i);
3383	int a;
3384
3385	nvram_unset(val);
3386	for (a = i + 1; a < which; a++) {
3387	nvram_nset(nvram_nget("forward_port%d", a),
3388	"forward_port%d", a - 1);
3389	}
3390	which--;
3391	sprintf(val, "forward_port%d", which);
3392	nvram_unset(val);
3393	if (which < 0)
3394	which = 0;
3395	sprintf(val, "%d", which);
3396	nvram_set("forward_cur", val);
3397	}
3398	eval("stopservice", "firewall");
3399	eval("startservice", "firewall"); //restart firewall
3400	}
3401
3402	}
3403
3404	#ifdef HAVE_FREERADIUS
3405
3406	void radius_generate_certificate(webs_t wp)
3407	{
3408	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3409	nvram_set("radius_country", websGetVar(wp, "radius_country", ""));
3410	nvram_set("radius_state", websGetVar(wp, "radius_state", ""));
3411	nvram_set("radius_locality", websGetVar(wp, "radius_locality", ""));
3412	nvram_set("radius_expiration",
3413	websGetVar(wp, "radius_expiration", "365"));
3414	nvram_set("radius_passphrase",
3415	websGetVar(wp, "radius_passphrase", "whatever"));
3416	nvram_set("radius_organisation",
3417	websGetVar(wp, "radius_organisation", ""));
3418	nvram_set("radius_email", websGetVar(wp, "radius_email", ""));
3419	nvram_set("radius_common", websGetVar(wp, "radius_common", ""));
3420
3421	//system("rm /jffs/etc/freeradius/certs/dh");
3422	system("rm /jffs/etc/freeradius/certs/server.csr");
3423	system("rm /jffs/etc/freeradius/certs/server.key");
3424	system("rm /jffs/etc/freeradius/certs/ca.pem");
3425	system("rm /jffs/etc/freeradius/certs/ca.key");
3426	system("rm /jffs/etc/freeradius/certs/server.crt");
3427	system("rm /jffs/etc/freeradius/certs/server.p12");
3428	system("rm /jffs/etc/freeradius/certs/server.pem");
3429	system("rm /jffs/etc/freeradius/certs/ca.der");
3430	system("rm /jffs/etc/freeradius/certs/index.txt");
3431	system("rm /jffs/etc/freeradius/certs/serial");
3432	system("rm -rf /jffs/etc/freeradius/certs/clients"); //delete client certificates since they will become invalid
3433	system("startservice_f gen_radius_cert");
3434	}
3435
3436	/*struct radiususer {
3437	unsigned int fieldlen;
3438	unsigned int usersize;
3439	unsigned char *user;
3440	unsigned int passwordsize;
3441	unsigned char *passwd;
3442	unsigned int downstream;
3443	unsigned int upstream;
3444	//more fields can be added in future
3445	};
3446
3447	struct radiusdb {
3448	unsigned int usercount;
3449	struct radiususer *users;
3450	};
3451	*/
3452	#include <radiusdb.h>
3453	void add_radius_user(webs_t wp)
3454	{
3455	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3456	struct radiusdb *db = loadradiusdb();
3457	if (db == NULL) {
3458	db = malloc(sizeof(struct radiusdb));
3459	db->usercount = 0;
3460	db->users = malloc(sizeof(struct radiususer));
3461	} else {
3462	db->users =
3463	realloc(db->users,
3464	sizeof(struct radiususer) * (db->usercount + 1));
3465	}
3466	db->users[db->usercount].fieldlen = sizeof(struct radiususer) - 8;
3467	db->users[db->usercount].usersize = 0;
3468	db->users[db->usercount].user = NULL;
3469	db->users[db->usercount].passwd = NULL;
3470	db->users[db->usercount].passwordsize = 0;
3471	db->users[db->usercount].downstream = 0;
3472	db->users[db->usercount].upstream = 0;
3473	db->users[db->usercount].expiration = 0;
3474	db->usercount++;
3475	writeradiusdb(db);
3476	freeradiusdb(db);
3477	}
3478
3479	void del_radius_user(webs_t wp)
3480	{
3481	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3482	char *val = websGetVar(wp, "del_value", NULL);
3483	if (val == NULL)
3484	return;
3485	int todel = atoi(val);
3486	struct radiusdb *db = loadradiusdb();
3487	if (db == NULL)
3488	return;
3489	if (db->usercount == 0)
3490	return;
3491	if (db->usercount > 1)
3492	memcpy(&db->users[todel], &db->users[todel + 1],
3493	sizeof(struct radiususer) * ((db->usercount - 1) -
3494	todel));
3495	db->usercount--;
3496	if (db->usercount > 0)
3497	db->users =
3498	realloc(db->users,
3499	sizeof(struct radiususer) * (db->usercount));
3500	else {
3501	free(db->users);
3502	db->users = NULL;
3503	}
3504	writeradiusdb(db);
3505	freeradiusdb(db);
3506	}
3507
3508	void add_radius_client(webs_t wp)
3509	{
3510	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3511	struct radiusclientdb *db = loadradiusclientdb();
3512	if (db == NULL) {
3513	db = malloc(sizeof(struct radiusclientdb));
3514	db->usercount = 0;
3515	db->users = malloc(sizeof(struct radiusclient));
3516	} else {
3517	db->users =
3518	realloc(db->users,
3519	sizeof(struct radiusclient) * (db->usercount + 1));
3520	}
3521	db->users[db->usercount].fieldlen = sizeof(struct radiususer) - 8;
3522	db->users[db->usercount].clientsize = 0;
3523	db->users[db->usercount].client = NULL;
3524	db->users[db->usercount].passwd = NULL;
3525	db->users[db->usercount].passwordsize = 0;
3526	db->usercount++;
3527	writeradiusclientdb(db);
3528	freeradiusclientdb(db);
3529	}
3530
3531	void del_radius_client(webs_t wp)
3532	{
3533	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3534	char *val = websGetVar(wp, "del_value", NULL);
3535	if (val == NULL)
3536	return;
3537	int todel = atoi(val);
3538	struct radiusclientdb *db = loadradiusclientdb();
3539	if (db == NULL)
3540	return;
3541	if (db->usercount == 0)
3542	return;
3543	if (db->usercount > 1)
3544	memcpy(&db->users[todel], &db->users[todel + 1],
3545	sizeof(struct radiusclient) * ((db->usercount - 1) -
3546	todel));
3547	db->usercount--;
3548	if (db->usercount > 0)
3549	db->users =
3550	realloc(db->users,
3551	sizeof(struct radiusclient) * (db->usercount));
3552	else {
3553	free(db->users);
3554	db->users = NULL;
3555	}
3556	writeradiusclientdb(db);
3557	freeradiusclientdb(db);
3558	}
3559
3560	static void save_radius_clients(webs_t wp)
3561	{
3562	char passwd[] = { "passwordXXXXX" };
3563	char user[] = { "usernameXXXXX" };
3564	struct radiusclientdb *db = malloc(sizeof(struct radiusclientdb));
3565	db->usercount = 0;
3566	db->users = NULL;
3567	while (1) {
3568	sprintf(user, "client%d", db->usercount);
3569	sprintf(passwd, "shared%d", db->usercount);
3570	char *u = websGetVar(wp, user, NULL);
3571	if (!u)
3572	break;
3573	char *p = websGetVar(wp, passwd, NULL);
3574	if (!p)
3575	break;
3576
3577	db->users =
3578	realloc(db->users,
3579	sizeof(struct radiusclient) * (db->usercount + 1));
3580
3581	db->users[db->usercount].client = malloc(strlen(u) + 1);
3582	strcpy(db->users[db->usercount].client, u);
3583	db->users[db->usercount].clientsize = strlen(u) + 1;
3584	db->users[db->usercount].passwd = malloc(strlen(p) + 1);
3585	strcpy(db->users[db->usercount].passwd, p);
3586	db->users[db->usercount].passwordsize = strlen(p) + 1;
3587	db->usercount++;
3588	}
3589	writeradiusclientdb(db);
3590	freeradiusclientdb(db);
3591
3592	}
3593
3594	static void save_radius_users(webs_t wp)
3595	{
3596	char passwd[] = { "passwordXXXXX" };
3597	char user[] = { "usernameXXXXX" };
3598	char downstream[] = { "passwordXXXXX" };
3599	char upstream[] = { "usernameXXXXX" };
3600	char expiration[] = { "expirationXXXXX" };
3601	struct radiusdb *db = malloc(sizeof(struct radiusdb));
3602	char filename[128];
3603	db->usercount = 0;
3604	db->users = NULL;
3605	time_t tm;
3606	time(&tm);
3607	while (1) {
3608	sprintf(user, "username%d", db->usercount);
3609	sprintf(passwd, "password%d", db->usercount);
3610	sprintf(downstream, "downstream%d", db->usercount);
3611	sprintf(upstream, "upstream%d", db->usercount);
3612	sprintf(expiration, "expiration%d", db->usercount);
3613	char *u = websGetVar(wp, user, NULL);
3614	if (!u)
3615	break;
3616	sprintf(filename,
3617	"/jffs/etc/freeradius/certs/clients/%s-cert.pem", u);
3618	sysprintf("rm -f %s", filename);
3619	char *p = websGetVar(wp, passwd, NULL);
3620	if (!p)
3621	break;
3622
3623	char *d = websGetVar(wp, downstream, NULL);
3624	if (!d)
3625	break;
3626
3627	char *up = websGetVar(wp, upstream, NULL);
3628	if (!up)
3629	break;
3630
3631	char *e = websGetVar(wp, expiration, NULL);
3632	if (!e)
3633	break;
3634	db->users =
3635	realloc(db->users,
3636	sizeof(struct radiususer) * (db->usercount + 1));
3637
3638	db->users[db->usercount].user = malloc(strlen(u) + 1);
3639	strcpy(db->users[db->usercount].user, u);
3640	db->users[db->usercount].usersize = strlen(u) + 1;
3641	db->users[db->usercount].passwd = malloc(strlen(p) + 1);
3642	strcpy(db->users[db->usercount].passwd, p);
3643	db->users[db->usercount].passwordsize = strlen(p) + 1;
3644	db->users[db->usercount].downstream = atoi(d);
3645	db->users[db->usercount].upstream = atoi(up);
3646	long expiration = atoi(e);
3647	if (expiration) {
3648	long curtime = ((tm / 60) / 60) / 24; //in days
3649	expiration = expiration + curtime;
3650	}
3651	db->users[db->usercount].expiration = expiration;
3652	db->usercount++;
3653	}
3654	writeradiusdb(db);
3655	freeradiusdb(db);
3656
3657	}
3658
3659	void save_radius_user(webs_t wp)
3660	{
3661	nvram_set("radius_enabled", websGetVar(wp, "radius_enabled", "0"));
3662	nvram_set("radius_port", websGetVar(wp, "radius_port", "1812"));
3663	save_radius_users(wp);
3664	save_radius_clients(wp);
3665
3666	char *value = websGetVar(wp, "action", "");
3667	addAction("freeradius");
3668	applytake(value);
3669	}
3670
3671	#endif

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

Download in other formats: