Context Navigation

source: src/router/shared/utils.c @ 9830

Last change on this file since 9830 was 9830, checked in by BrainSlayer, 5 years ago
formating
File size: 102.3 KB

Line
1	//#define CDEBUG
2
3	#include <stdio.h>
4	#include <stdlib.h>
5	#include <string.h>
6	#include <errno.h>
7	#include <net/if.h>
8	#include <dirent.h>
9	#include <unistd.h>
10	#include <ctype.h>
11	#include <syslog.h>
12	#include <sys/socket.h>
13	#include <sys/stat.h>
14	#include <fcntl.h>
15	#include <netinet/in.h>
16	#include <stdarg.h>
17	#include <sys/ioctl.h>
18	#include <sys/sysinfo.h>
19	#include <arpa/inet.h>
20	#include <netdb.h>
21	#include <resolv.h>
22	#include <signal.h>
23
24
25
26	#include <utils.h>
27	#include <wlutils.h>
28	#include <bcmnvram.h>
29	#include <shutils.h>
30	#include <cy_conf.h>
31	#include <code_pattern.h>
32	#include <bcmdevs.h>
33	#include <net/route.h>
34	#include <cy_conf.h>
35	#include <bcmdevs.h>
36	#include <linux/if_ether.h>
37	//#include <linux/mii.h>
38	#include <linux/sockios.h>
39	#include <cymac.h>
40	#include <broadcom.h>
41
42	#define SIOCGMIIREG 0x8948 /* Read MII PHY register. */
43	#define SIOCSMIIREG 0x8949 /* Write MII PHY register. */
44	void show_hw_type (int type);
45
46	struct mii_ioctl_data
47	{
48	unsigned short phy_id;
49	unsigned short reg_num;
50	unsigned short val_in;
51	unsigned short val_out;
52	};
53
54
55	int
56	getcpurev (void)
57	{
58	FILE *fp = fopen ("/proc/cpuinfo", "rb");
59	if (fp == NULL)
60	{
61	return -1;
62	}
63	int cnt = 0;
64	int b = 0;
65	while (b != EOF)
66	{
67	b = getc (fp);
68	if (b == ':')
69	cnt++;
70	if (cnt == 3)
71	{
72	getc (fp);
73	char cpurev[13];
74	int i = 0;
75	for (i = 0; i < 12; i++)
76	cpurev[i] = getc (fp);
77	cpurev[i] = 0;
78	fclose (fp);
79	if (!strcmp (cpurev, "BCM4710 V0.0")) // BCM4702, BCM4710 (old 125 MHz)
80	return 0;
81	if (!strcmp (cpurev, "BCM3302 V0.6")) // BCM4704
82	return 6;
83	if (!strcmp (cpurev, "BCM3302 V0.7")) // BCM4712, BCM5365
84	return 7;
85	if (!strcmp (cpurev, "BCM3302 V0.8")) // BCM5350, BCM5352
86	return 8;
87	if (!strcmp (cpurev, "BCM3302 V2.9")) // BCM5354
88	return 29;
89	return -1;
90	}
91	}
92	fclose (fp);
93	return -1;
94	}
95
96	int
97	cpu_plltype (void)
98	{
99	int cpurev = getcpurev ();
100	int cputype = check_hw_type ();
101
102	if (cpurev == 0) // BCM4702, BCM4710 (old 125 MHz)
103	return 0;
104	if (cpurev == 6) // BCM4704
105	return 0;
106	if (cpurev == 7 && cputype == BCM5365_CHIP) // BCM5365 only supports fixed 200 MHz
107	return 0;
108	if (cpurev == 7 && cputype != BCM5365_CHIP) // BCM4712
109	return 4;
110	if (cpurev == 8 && cputype == BCM5350_CHIP) // BCM5350
111	return 3;
112	if (cpurev == 8 && cputype != BCM5350_CHIP) // BCM5352
113	return 7;
114	if (cpurev == 29) // BCM5354, only supports fixed 240 MHz
115	return 0;
116	if (cputype == BCM4705_BCM5397_EWC_CHIP) // BCM4705
117	return 0; // could use table 2
118
119	return 0;
120	}
121
122	int
123	startswith (char source, char cmp)
124	{
125	return !strncmp (source, cmp, strlen (cmp));
126	/* int i;
127	if (cmp == NULL)
128	return 0;
129	if (source == NULL)
130	return 0;
131	int slen = strlen (source);
132	int clen = strlen (cmp);
133	if (clen > slen)
134	return 0;
135
136	for (i = 0; i < clen; i++)
137	if (source[i] != cmp[i])
138	return 0;
139	return 1;*/
140	}
141
142	int
143	count_occurences (char *source, int cmp)
144	{
145	int i, cnt = 0;
146	int len = strlen (source);
147
148	for (i = 0; i < len; i++)
149	{
150	if (source[i] == cmp)
151	cnt++;
152	}
153	return cnt;
154	}
155
156	int
157	pos_nthoccurence (char *source, int cmp, int which)
158	{
159	int i, cnt = 0;
160	int len = strlen (source);
161
162	for (i = 0; i < len; i++)
163	{
164	if (source[i] == cmp)
165	cnt++;
166	if (cnt == which)
167	return i;
168	}
169	return -1;
170	}
171
172	char *
173	substring (int start, int stop, const char src, char dst)
174	{
175	int count = stop - start;
176
177	sprintf (dst, "%.*s", count, src + start);
178
179	return dst;
180	}
181
182	/* This function returns the number of days for the given month in the given year */
183	unsigned int
184	daysformonth (unsigned int month, unsigned int year)
185	{
186	return (30 + (((month & 9) == 8) \|\| ((month & 9) == 1)) - (month == 2) -
187	(!(((year % 4) == 0)
188	&& (((year % 100) != 0) \|\| ((year % 400) == 0)))
189	&& (month == 2)));
190	}
191
192	/* given month, day, year, returns day of week, eg. Monday = 0 etc. */
193	int
194	weekday (int month, int day, int year)
195	{
196	int ix, tx, vx;
197
198	switch (month)
199	{
200	case 2:
201	case 6:
202	vx = 0;
203	break;
204	case 8:
205	vx = 4;
206	break;
207	case 10:
208	vx = 8;
209	break;
210	case 9:
211	case 12:
212	vx = 12;
213	break;
214	case 3:
215	case 11:
216	vx = 16;
217	break;
218	case 1:
219	case 5:
220	vx = 20;
221	break;
222	case 4:
223	case 7:
224	vx = 24;
225	break;
226	}
227
228	if (year > 1900) // 1900 was not a leap year
229	year -= 1900;
230	ix = ((year - 21) % 28) + vx + (month > 2); // take care of February
231	tx = (ix + (ix / 4)) % 7 + day; // take care of leap year
232
233	return (tx % 7);
234
235	}
236
237	void
238	setRouter (char *name)
239	{
240	#ifdef HAVE_POWERNOC_WORT54G
241	nvram_set (NVROUTER, "WORT54G");
242	#elif HAVE_POWERNOC_WOAP54G
243	nvram_set (NVROUTER, "WOAP54G");
244	#elif HAVE_OMNI
245	nvram_set (NVROUTER, "Omni Wifi Router");
246	#elif HAVE_MAKSAT
247	nvram_set (NVROUTER, "MAKSAT");
248	#else
249	if (name)
250	nvram_set (NVROUTER, name);
251	#endif
252	}
253
254	char *
255	getRouter ()
256	{
257	char *n = nvram_get (NVROUTER);
258	return n != NULL ? n : "Unknown Model";
259	}
260
261
262
263	int
264	internal_getRouterBrand ()
265	{
266
267	#ifdef HAVE_RB500
268	setRouter ("Mikrotik RB500");
269	return ROUTER_BOARD_500;
270	#elif HAVE_GEMTEK
271	setRouter ("SuperGerry");
272	return ROUTER_SUPERGERRY;
273	#elif HAVE_TONZE
274	setRouter ("Tonze AP-425");
275	return ROUTER_BOARD_GATEWORX;
276	#elif HAVE_NOP8670
277	setRouter ("Senao NOP-8670");
278	return ROUTER_BOARD_GATEWORX;
279	#elif HAVE_WRT300NV2
280	setRouter ("Linksys WRT300N v2");
281	return ROUTER_BOARD_GATEWORX;
282	#elif HAVE_GATEWORX
283	char filename = "/sys/devices/platform/IXP4XX-I2C.0/i2c-adapter:i2c-0/0-0051/eeprom"; / bank2=0x100 */
284	FILE *file = fopen (filename, "r");
285	if (file) //new detection scheme
286	{
287	fseek (file, 32, SEEK_SET);
288	char gwid[7];
289	gwid[6] = 0;
290	int ret = fread (gwid, 6, 1, file);
291	if (ret < 1)
292	{
293	fclose (file);
294	goto old_way;
295	}
296	fclose (file);
297	if (!strcmp (gwid, "GW2347"))
298	{
299	setRouter ("Avila GW2347");
300	return ROUTER_BOARD_GATEWORX_SWAP;
301	}
302	if (!strcmp (gwid, "GW2357"))
303	{
304	setRouter ("Avila GW2357");
305	return ROUTER_BOARD_GATEWORX_SWAP;
306	}
307	if (!strcmp (gwid, "GW2353"))
308	{
309	setRouter ("Avila GW2343");
310	return ROUTER_BOARD_GATEWORX;
311	}
312	if (!strcmp (gwid, "GW2348"))
313	{
314	setRouter ("Avila GW2348-4/2");
315	return ROUTER_BOARD_GATEWORX;
316	}
317	if (!strcmp (gwid, "GW2358"))
318	{
319	setRouter ("Cambria GW2358-4");
320	return ROUTER_BOARD_GATEWORX;
321	}
322	if (!strcmp (gwid, "GW2355"))
323	{
324	setRouter ("Avila GW2355");
325	return ROUTER_BOARD_GATEWORX_GW2345;
326	}
327	if (!strcmp (gwid, "GW2345"))
328	{
329	setRouter ("Avila GW2345");
330	return ROUTER_BOARD_GATEWORX_GW2345;
331	}
332	}
333	old_way:;
334	struct mii_ioctl_data *data;
335	struct ifreq iwr;
336	int s = socket (AF_INET, SOCK_DGRAM, 0);
337	if (s < 0)
338	{
339	fprintf (stderr, "socket(SOCK_DRAGM)\n");
340	setRouter ("Avila Gateworks");
341	return ROUTER_BOARD_GATEWORX;
342	}
343	(void) strncpy (iwr.ifr_name, "ixp0", sizeof ("ixp0"));
344	data = (struct mii_ioctl_data *) &iwr.ifr_data;
345	data->phy_id = 1;
346	#define IX_ETH_ACC_MII_PHY_ID1_REG 0x2 /* PHY identifier 1 Register */
347	#define IX_ETH_ACC_MII_PHY_ID2_REG 0x3 /* PHY identifier 2 Register */
348	data->reg_num = IX_ETH_ACC_MII_PHY_ID1_REG;
349	ioctl (s, SIOCGMIIREG, &iwr);
350	data->phy_id = 1;
351	data->reg_num = IX_ETH_ACC_MII_PHY_ID1_REG;
352	ioctl (s, SIOCGMIIREG, &iwr);
353	int reg1 = data->val_out;
354	data->phy_id = 1;
355	data->reg_num = IX_ETH_ACC_MII_PHY_ID2_REG;
356	ioctl (s, SIOCGMIIREG, &iwr);
357	int reg2 = data->val_out;
358	close (s);
359	fprintf (stderr, "phy id %X:%X\n", reg1, reg2);
360	if (reg1 == 0x2000 && reg2 == 0x5c90)
361	{
362	setRouter ("Avila GW2347");
363	return ROUTER_BOARD_GATEWORX_SWAP;
364	}
365	else if (reg1 == 0x13 && reg2 == 0x7a11)
366	{
367	setRouter ("Avila GW2348-4/2");
368	return ROUTER_BOARD_GATEWORX;
369	}
370	else if (reg1 == 0x22 && reg2 == 0x1450) //kendin switch
371	{
372	setRouter ("Avila GW2345");
373	return ROUTER_BOARD_GATEWORX_GW2345;
374	}
375	else if (reg1 == 0x0 && reg2 == 0x8201) //realtek
376	{
377	setRouter ("Compex WP188");
378	return ROUTER_BOARD_GATEWORX;
379	}
380	else
381	{
382	setRouter ("Unknown");
383	return ROUTER_BOARD_GATEWORX;
384	}
385	#elif HAVE_X86
386	setRouter ("Generic X86");
387	return ROUTER_BOARD_X86;
388	#elif HAVE_XSCALE
389	setRouter ("NewMedia Dual A/B/G");
390	return ROUTER_BOARD_XSCALE;
391	#elif HAVE_MAGICBOX
392	setRouter ("MagicBox");
393	return ROUTER_BOARD_MAGICBOX;
394	#elif HAVE_WRT54GV7
395	setRouter ("Linksys WRT54G v7");
396	return ROUTER_BOARD_FONERA;
397	#elif HAVE_WRK54G
398	setRouter ("Linksys WRK54G v3");
399	return ROUTER_BOARD_FONERA;
400	#elif HAVE_MR3202A
401	setRouter ("MR3202A");
402	return ROUTER_BOARD_FONERA;
403	#elif HAVE_AR430W
404	setRouter ("Airlink-101 AR430W");
405	return ROUTER_BOARD_FONERA;
406	#elif HAVE_DIR400
407	setRouter ("D-Link DIR-400");
408	return ROUTER_BOARD_FONERA2200;
409	#elif HAVE_DIR300
410	setRouter ("D-Link DIR-300");
411	return ROUTER_BOARD_FONERA;
412	#elif HAVE_FONERA
413	struct mii_ioctl_data *data;
414	struct ifreq iwr;
415	int s = socket (AF_INET, SOCK_DGRAM, 0);
416	if (s < 0)
417	{
418	fprintf (stderr, "socket(SOCK_DRAGM)\n");
419	setRouter ("Fonera 2100/2200");
420	return ROUTER_BOARD_FONERA;
421	}
422	(void) strncpy (iwr.ifr_name, "eth0", sizeof ("eth0"));
423	data = (struct mii_ioctl_data *) &iwr.ifr_data;
424	data->phy_id = 0x10;
425	data->reg_num = 0x2;
426	ioctl (s, SIOCGMIIREG, &iwr);
427	data->phy_id = 0x10;
428	data->reg_num = 0x2;
429	ioctl (s, SIOCGMIIREG, &iwr);
430	if (data->val_out == 0x0141)
431	{
432	data->phy_id = 0x10;
433	data->reg_num = 0x3;
434	ioctl (s, SIOCGMIIREG, &iwr);
435	close (s);
436	if ((data->val_out & 0xfc00) != 0x0c00) // marvell phy
437	{
438	setRouter ("Fonera 2100/2200");
439	return ROUTER_BOARD_FONERA;
440	}
441	else
442	{
443	setRouter ("Fonera 2201");
444	return ROUTER_BOARD_FONERA2200;
445	}
446	}
447	else
448	{
449	setRouter ("Fonera 2100/2200");
450	return ROUTER_BOARD_FONERA;
451	}
452	#elif HAVE_MERAKI
453	setRouter ("Meraki Mini");
454	return ROUTER_BOARD_MERAKI;
455	#elif HAVE_NS2
456	setRouter ("Ubiquiti Nanostation 2");
457	return ROUTER_BOARD_LS2;
458	#elif HAVE_NS5
459	setRouter ("Ubiquiti Nanostation 5");
460	return ROUTER_BOARD_LS2;
461	#elif HAVE_PS2
462	setRouter ("Ubiquiti Powerstation 2");
463	return ROUTER_BOARD_LS2;
464	#elif HAVE_PS5
465	setRouter ("Ubiquiti Powerstation 5");
466	return ROUTER_BOARD_LS2;
467	#elif HAVE_LS2
468	setRouter ("Ubiquiti Litestation 2");
469	return ROUTER_BOARD_LS2;
470	#elif HAVE_LS5
471	setRouter ("Ubiquiti Litestation 5");
472	return ROUTER_BOARD_LS2;
473	#elif HAVE_WHRAG108
474	setRouter ("Buffalo WHR-HP-AG108");
475	return ROUTER_BOARD_WHRAG108;
476	#elif HAVE_PB42
477	setRouter ("Atheros PB42");
478	return ROUTER_BOARD_PB42;
479	#elif HAVE_LSX
480	setRouter ("Ubiquiti LSX");
481	return ROUTER_BOARD_PB42;
482	#elif HAVE_TW6600
483	setRouter ("AW-6600");
484	return ROUTER_BOARD_TW6600;
485	#elif HAVE_USR5453
486	setRouter ("US Robotics USR5453");
487	return ROUTER_BOARD_CA8;
488	#elif HAVE_CA8PRO
489	setRouter ("Wistron CA8-4 PRO");
490	return ROUTER_BOARD_CA8PRO;
491	#elif HAVE_CA8
492	setRouter ("Wistron CA8-4");
493	return ROUTER_BOARD_CA8;
494	#else
495
496	uint boardnum = strtoul (nvram_safe_get ("boardnum"), NULL, 0);
497
498	if (boardnum == 42 && nvram_match ("boardtype", "bcm94710ap"))
499	{
500	cprintf ("router is buffalo\n");
501	setRouter ("Buffalo WBR-G54 / WLA-G54");
502	return ROUTER_BUFFALO_WBR54G;
503	}
504	#ifndef HAVE_BUFFALO
505	if (nvram_match ("boardnum", "mn700") &&
506	nvram_match ("boardtype", "bcm94710ap"))
507	{
508	cprintf ("router is Microsoft MN-700\n");
509	setRouter ("Microsoft MN-700");
510	return ROUTER_MICROSOFT_MN700;
511	}
512
513	if (nvram_match ("boardnum", "asusX") &&
514	nvram_match ("boardtype", "bcm94710dev"))
515	{
516	cprintf ("router is Asus WL300g / WL500g\n");
517	setRouter ("Asus WL-300g / WL-500g");
518	return ROUTER_ASUS_WL500G;
519	}
520
521	if (boardnum == 44 && nvram_match ("boardtype", "bcm94710ap"))
522	{
523	cprintf ("router is Dell TrueMobile 2300\n");
524	setRouter ("Dell TrueMobile 2300");
525	return ROUTER_DELL_TRUEMOBILE_2300;
526	}
527	#endif
528
529	if (boardnum == 100 && nvram_match ("boardtype", "bcm94710dev"))
530	{
531	cprintf ("router is buffalo\n");
532	setRouter ("Buffalo WLA-G54C");
533	return ROUTER_BUFFALO_WLAG54C;
534	}
535
536	#ifndef HAVE_BUFFALO
537	if (boardnum == 45 && nvram_match ("boardtype", "bcm95365r"))
538	{
539	cprintf ("router is Asus WL-500GD\n");
540	setRouter ("Asus WL-500g Deluxe");
541	return ROUTER_ASUS_WL500GD;
542	}
543
544	if (boardnum == 45 && nvram_match ("boardtype", "0x0472")
545	&& nvram_match ("boardrev", "0x23") && nvram_match ("parkid", "1"))
546	{
547	cprintf ("router is Asus WL-500W\n");
548	setRouter ("Asus WL-500W");
549	return ROUTER_ASUS_WL500W;
550	}
551
552	if (boardnum == 45 && nvram_match ("boardtype", "0x467"))
553	{
554	cprintf ("router is Asus WL-550gE\n");
555	setRouter ("Asus WL-550gE");
556	return ROUTER_ASUS_WL550GE;
557	}
558	#endif
559	if (nvram_match ("boardnum", "00") &&
560	nvram_match ("boardtype", "0x0101") && nvram_match ("boardrev", "0x10"))
561	{
562	cprintf ("router is Buffalo wbr2\n");
563	setRouter ("Buffalo WBR2-G54 / WBR2-G54S");
564	return ROUTER_BUFFALO_WBR2G54S;
565	}
566
567	if (boardnum == 2 &&
568	nvram_match ("boardtype", "0x0101") && nvram_match ("boardrev", "0x10"))
569	{
570	cprintf ("router is buffalo wla2-g54c\n");
571	setRouter ("Buffalo WLA2-G54C / WLI3-TX1-G54");
572	return ROUTER_BUFFALO_WLA2G54C;
573	}
574	if (boardnum == 0 && nvram_match ("melco_id", "29090")
575	&& nvram_match ("boardflags", "0x0010")
576	&& nvram_match ("boardrev", "0x10"))
577	{
578	cprintf ("router is Buffalo WLAH-G54\n");
579	setRouter ("Buffalo WLAH-G54");
580	return ROUTER_BUFFALO_WLAH_G54;
581
582	}
583	if (boardnum == 0 && nvram_match ("melco_id", "31070")
584	&& nvram_match ("boardflags", "0x2288")
585	&& nvram_match ("boardrev", "0x10"))
586	{
587	cprintf ("router is Buffalo WAPM-HP-AM54G54\n");
588	setRouter ("Buffalo WAPM-HP-AM54G54");
589	return ROUTER_BUFFALO_WAPM_HP_AM54G54;
590	}
591	if (nvram_match ("boardnum", "00") && nvram_match ("boardrev", "0x11")
592	&& nvram_match ("boardtype", "0x048e")
593	&& nvram_match ("melco_id", "32093"))
594	{
595	cprintf ("router is Buffalo WHR-G125\n");
596	setRouter ("Buffalo WHR-G125");
597	return ROUTER_BUFFALO_WHRG54S;
598	}
599
600	if (nvram_match ("boardnum", "00") &&
601	nvram_match ("boardrev", "0x13") && nvram_match ("boardtype", "0x467"))
602	{
603	if (nvram_match ("boardflags", "0x1658")
604	\|\| nvram_match ("boardflags", "0x2658")
605	\|\| nvram_match ("boardflags", "0x3658"))
606	{
607	cprintf ("router is Buffalo WLI-TX4-G54HP\n");
608	setRouter ("Buffalo WLI-TX4-G54HP");
609	return ROUTER_BUFFALO_WLI_TX4_G54HP;
610	}
611	if (!nvram_match ("buffalo_hp", "1")
612	&& nvram_match ("boardflags", "0x2758"))
613	{
614	cprintf ("router is Buffalo WHR-G54S\n");
615	setRouter ("Buffalo WHR-G54S");
616	return ROUTER_BUFFALO_WHRG54S;
617	}
618	if (nvram_match ("buffalo_hp", "1")
619	\|\| nvram_match ("boardflags", "0x1758"))
620	{
621	#ifndef HAVE_BUFFALO
622	cprintf ("router is Buffalo WHR-HP-G54\n");
623	setRouter ("Buffalo WHR-HP-G54");
624	#else
625	cprintf ("router is Buffalo WHR-HP-G54DD\n");
626	#ifdef BUFFALO_JP
627	setRouter ("Buffalo AS-A100");
628	#else
629	setRouter ("Buffalo WHR-HP-G54DD");
630	#endif
631	#endif
632	return ROUTER_BUFFALO_WHRG54S;
633	}
634	}
635
636	if (nvram_match ("boardnum", "00") &&
637	nvram_match ("boardrev", "0x10") && nvram_match ("boardtype", "0x470"))
638	{
639	cprintf ("router is Buffalo WHR-AM54G54\n");
640	setRouter ("Buffalo WHR-AM54G54");
641	return ROUTER_BUFFALO_WHRAM54G54;
642	}
643
644
645	if (boardnum == 42 && nvram_match ("boardtype", "0x042f"))
646	{
647	uint melco_id = strtoul (nvram_safe_get ("melco_id"), NULL, 0);
648
649	if (nvram_match ("product_name", "WZR-RS-G54") \|\| melco_id == 30083)
650	{
651	cprintf ("router is Buffalo WZR-RS-G54\n");
652	setRouter ("Buffalo WZR-RS-G54");
653	return ROUTER_BUFFALO_WZRRSG54;
654	}
655	if (nvram_match ("product_name", "WZR-HP-G54") \|\| melco_id == 30026)
656	{
657	cprintf ("router is Buffalo WZR-HP-G54\n");
658	setRouter ("Buffalo WZR-HP-G54");
659	return ROUTER_BUFFALO_WZRRSG54;
660	}
661	if (nvram_match ("product_name", "WZR-G54") \|\| melco_id == 30061)
662	{
663	cprintf ("router is Buffalo WZR-G54\n");
664	setRouter ("Buffalo WZR-G54");
665	return ROUTER_BUFFALO_WZRRSG54;
666	}
667	if (nvram_match ("melco_id", "290441dd"))
668	{
669	cprintf ("router is Buffalo WHR2-A54G54\n");
670	setRouter ("Buffalo WHR2-A54G54");
671	return ROUTER_BUFFALO_WZRRSG54;
672	}
673	if (nvram_match ("product_name", "WHR3-AG54")
674	\|\| nvram_match ("product_name", "WHR3-B11") \|\| melco_id == 29130)
675	{
676	cprintf ("router is Buffalo WHR3-AG54\n");
677	setRouter ("Buffalo WHR3-AG54");
678	return ROUTER_BUFFALO_WZRRSG54;
679	}
680	if (nvram_match ("product_name", "WVR-G54-NF") \|\| melco_id == 28100)
681	{
682	cprintf ("router is Buffalo WVR-G54-NF\n");
683	setRouter ("Buffalo WVR-G54-NF");
684	return ROUTER_BUFFALO_WZRRSG54;
685	}
686	if (melco_id > 0) //e.g. 29115
687	{
688	cprintf ("router is Buffalo WZR series\n");
689	setRouter ("Buffalo WZR series");
690	return ROUTER_BUFFALO_WZRRSG54;
691	}
692	}
693
694	#ifndef HAVE_BUFFALO
695	if (boardnum == 42 &&
696	nvram_match ("boardtype", "0x042f") && nvram_match ("boardrev", "0x10"))
697	// nvram_match ("boardflags","0x0018"))
698	{
699	cprintf ("router is Linksys WRTSL54GS\n");
700	setRouter ("Linksys WRTSL54GS");
701	return ROUTER_WRTSL54GS;
702	}
703
704	if (boardnum == 42 && nvram_match ("boardtype", "0x0101")
705	&& nvram_match ("boardrev", "0x10") && nvram_match ("boot_ver", "v3.6"))
706	{
707	cprintf ("router is Linksys WRT54G3G\n");
708	setRouter ("Linksys WRT54G3G");
709	return ROUTER_WRT54G3G;
710	}
711
712	if (boardnum == 45 &&
713	nvram_match ("boardtype", "0x042f") && nvram_match ("boardrev", "0x10"))
714	{
715	cprintf ("router is Asus WL-500g Premium\n");
716	setRouter ("Asus WL-500g Premium");
717	return ROUTER_ASUS_WL500G_PRE;
718	}
719
720
721	char *et0 = nvram_safe_get ("et0macaddr");
722
723	if (boardnum == 100 && nvram_match ("boardtype", "bcm94710r4"))
724	{
725	if (startswith (et0, "00:11:50"))
726	{
727	cprintf ("router is Belkin F5D7130 / F5D7330\n");
728	setRouter ("Belkin F5D7130 / F5D7330");
729	return ROUTER_RT210W;
730	}
731	if (startswith (et0, "00:30:BD") \|\| startswith (et0, "00:30:bd"))
732	{
733	cprintf ("router is Belkin F5D7230 v1000\n");
734	setRouter ("Belkin F5D7230-4 v1000");
735	return ROUTER_RT210W;
736	}
737	if (startswith (et0, "00:01:E3") \|\|
738	startswith (et0, "00:01:e3") \|\| startswith (et0, "00:90:96"))
739	{
740	cprintf ("router is Siemens\n");
741	setRouter ("Siemens SE505 v1");
742	return ROUTER_RT210W;
743	}
744	else
745	{
746	cprintf ("router is Askey generic\n");
747	setRouter ("RT210W generic");
748	return ROUTER_RT210W;
749	}
750	}
751
752	if (nvram_match ("boardtype", "bcm94710r4") && nvram_match ("boardnum", ""))
753	{
754	cprintf ("router is Askey board RT2100W\n");
755	setRouter ("Askey board RT2100W-D65)");
756	return ROUTER_BRCM4702_GENERIC;
757	}
758
759	if (boardnum == 0 && nvram_match ("boardtype", "0x0100")
760	&& nvram_match ("boardrev", "0x10"))
761	{
762	cprintf ("router is Askey board RT2205(6)D-D56\n");
763	if (startswith (et0, "00:11:50") \|\|
764	startswith (et0, "00:30:BD") \|\| startswith (et0, "00:30:bd"))
765	{
766	setRouter ("Askey board RT2205(6)D-D56");
767	}
768	else
769	{
770	setRouter ("Belkin board F5D8230");
771	}
772	return ROUTER_ASKEY_RT220XD;
773	}
774
775	if (nvram_match ("boardtype", "0x0101"))
776	{
777	if (startswith (et0, "00:11:50") \|\|
778	startswith (et0, "00:30:BD") \|\| startswith (et0, "00:30:bd"))
779	{
780	if (nvram_match ("Belkin_ver", "2000"))
781	{
782	cprintf ("router is Belkin F5D7230-4 v2000\n");
783	setRouter ("Belkin F5D7230-4 v2000");
784	return ROUTER_BELKIN_F5D7230_V2000;
785	}
786	else
787	{
788	cprintf ("router is Belkin F5D7230-4 v1444\n");
789	setRouter ("Belkin F5D7230-4 v1444");
790	return ROUTER_RT480W;
791	}
792	}
793	if (startswith (et0, "00:01:E3") \|\|
794	startswith (et0, "00:01:e3") \|\| startswith (et0, "00:90:96"))
795	{
796	cprintf ("router is Siemens / Askey\n");
797	setRouter ("Siemens SE505 v2");
798	return ROUTER_RT480W;
799	}
800	}
801
802	if (nvram_match ("boardtype", "0x456")
803	&& nvram_match ("hw_model", "F5D7231-4"))
804	{
805	cprintf ("router is Belkin F5D7231-4 v1212UK\n");
806	setRouter ("Belkin F5D7231-4 v1212UK");
807	return ROUTER_BELKIN_F5D7231;
808	}
809
810	if (boardnum == 8 && nvram_match ("boardtype", "0x0467")) //fccid: K7SF5D7231B
811	{
812	cprintf ("router is Belkin F5D7231-4 v2000\n");
813	setRouter ("Belkin F5D7231-4 v2000");
814	return ROUTER_BELKIN_F5D7231;
815	}
816
817	if (nvram_match ("boardtype", "0x467"))
818	{
819	if (startswith (et0, "00:11:50") \|\|
820	startswith (et0, "00:30:BD") \|\| startswith (et0, "00:30:bd"))
821	{
822	cprintf ("router is Belkin F5D7231-4 v2000\n");
823	setRouter ("Belkin F5D7231-4 v2000");
824	return ROUTER_BELKIN_F5D7231;
825	}
826	}
827	#endif
828	if (boardnum == 2 && nvram_match ("boardtype", "bcm94710dev") && nvram_match ("melco_id", "29016")) //Buffalo WLI2-TX1-G54)
829	{
830	cprintf ("router is Buffalo WLI2-TX1-G54\n");
831	setRouter ("Buffalo WLI2-TX1-G54");
832	return ROUTER_BUFFALO_WLI2_TX1_G54;
833	}
834	#ifndef HAVE_BUFFALO
835
836	char *gemtek = nvram_safe_get ("GemtekPmonVer");
837	uint gemteknum = strtoul (gemtek, NULL, 0);
838
839	if (boardnum == 2 && gemteknum == 10 &&
840	(startswith (et0, "00:0C:E5") \|\|
841	startswith (et0, "00:0c:e5") \|\|
842	startswith (et0, "00:0C:10") \|\|
843	startswith (et0, "00:0c:10") \|\|
844	startswith (et0, "00:0C:11") \|\| startswith (et0, "00:0c:11")))
845	{
846	cprintf ("router Motorola WE800G v1\n");
847	setRouter ("Motorola WE800G v1");
848	return ROUTER_MOTOROLA_WE800G;
849	}
850
851	if (boardnum == 2
852	&& (startswith (gemtek, "RC") \|\| gemteknum == 1 \|\| gemteknum == 10))
853	{
854	cprintf ("router is Linksys wap54g v1.x\n");
855	setRouter ("Linksys WAP54G v1.x");
856	return ROUTER_WAP54G_V1;
857	}
858
859	if (boardnum == 2 && gemteknum == 1)
860	{
861	cprintf ("router is Sitecom wl-105b\n");
862	setRouter ("Sitecom WL-105(b)");
863	return ROUTER_SITECOM_WL105B;
864	}
865
866	if (boardnum == 2 && gemteknum == 7
867	&& nvram_match ("boardtype", "bcm94710dev"))
868	{
869	cprintf ("router is Sitecom wl-111\n");
870	setRouter ("Sitecom WL-111");
871	return ROUTER_SITECOM_WL111;
872	}
873
874	if (gemteknum == 9) //Must be Motorola wr850g v1 or we800g v1 or Linksys wrt55ag v1
875	{
876	if (startswith (et0, "00:0C:E5") \|\|
877	startswith (et0, "00:0c:e5") \|\|
878	startswith (et0, "00:0C:10") \|\|
879	startswith (et0, "00:0c:10") \|\|
880	startswith (et0, "00:0C:11") \|\|
881	startswith (et0, "00:0c:11") \|\|
882	startswith (et0, "00:11:22") \|\|
883	startswith (et0, "00:0C:90") \|\| startswith (et0, "00:0c:90"))
884	{
885	if (!strlen (nvram_safe_get ("phyid_num")))
886	{
887	eval ("insmod", "switch-core"); //get phy type
888	eval ("insmod", "switch-robo");
889	eval ("rmmod", "switch-robo");
890	eval ("rmmod", "switch-core");
891	nvram_set ("boardnum", "2");
892	nvram_set ("boardtype", "bcm94710dev");
893	}
894	if (nvram_match ("phyid_num", "0x00000000"))
895	{
896	cprintf ("router Motorola WE800G v1\n");
897	setRouter ("Motorola WE800G v1");
898	return ROUTER_MOTOROLA_WE800G;
899	}
900	else //phyid_num == 0xffffffff
901	{
902	cprintf ("router Motorola WR850G v1\n");
903	setRouter ("Motorola WR850G v1");
904	return ROUTER_MOTOROLA_V1;
905	}
906	}
907	else
908	{
909	cprintf ("router is linksys WRT55AG\n");
910	setRouter ("Linksys WRT55AG v1");
911	return ROUTER_LINKSYS_WRT55AG;
912	}
913	}
914	#endif
915	if (boardnum == 0 && nvram_match ("boardtype", "0x478")
916	&& nvram_match ("cardbus", "0") && nvram_match ("boardrev", "0x10")
917	&& nvram_match ("boardflags", "0x110")
918	&& nvram_match ("melco_id", "32027"))
919	{
920	setRouter ("Buffalo WZR-G144NH");
921	return ROUTER_BUFFALO_WZRG144NH;
922	}
923
924
925	if (boardnum == 20060330 && nvram_match ("boardtype", "0x0472"))
926	{
927	setRouter ("Buffalo WZR-G300N");
928	return ROUTER_BUFFALO_WZRG300N;
929	}
930	#ifndef HAVE_BUFFALO
931
932	if (boardnum == 8 &&
933	nvram_match ("boardtype", "0x0472") && nvram_match ("cardbus", "1"))
934	{
935	cprintf ("router is Netgear WNR834B\n");
936	setRouter ("Netgear WNR834B");
937	return ROUTER_NETGEAR_WNR834B;
938	}
939
940	if (boardnum == 1 &&
941	nvram_match ("boardtype", "0x0472") && nvram_match ("cardbus", "1"))
942	{
943	cprintf ("router is Netgear WNR834B v2\n");
944	setRouter ("Netgear WNR834B v2");
945	return ROUTER_NETGEAR_WNR834BV2;
946	}
947
948	if (boardnum == 1 &&
949	nvram_match ("boardtype", "0x0472") && nvram_match ("boardrev", "0x23"))
950	{
951	cprintf ("router is Netgear WNDR-3300\n");
952	setRouter ("Netgear WNDR3300");
953	return ROUTER_NETGEAR_WNDR3300;
954	}
955
956	if (boardnum == 42) //Get Linksys N models
957	{
958	if (nvram_match ("boot_hw_model", "WRT300N")
959	&& nvram_match ("boot_hw_ver", "1.1"))
960	{
961	setRouter ("Linksys WRT300N v1.1");
962	return ROUTER_WRT300NV11;
963	}
964	else if (nvram_match ("boot_hw_model", "WRT150N")
965	&& nvram_match ("boot_hw_ver", "1"))
966	{
967	setRouter ("Linksys WRT150N v1");
968	return ROUTER_WRT150N;
969	}
970	else if (nvram_match ("boot_hw_model", "WRT150N")
971	&& nvram_match ("boot_hw_ver", "1.1"))
972	{
973	setRouter ("Linksys WRT150N v1.1");
974	// return ROUTER_WRT150NV11;
975	return ROUTER_WRT150N;
976	}
977	else if (nvram_match ("boot_hw_model", "WRT150N")
978	&& nvram_match ("boot_hw_ver", "1.2"))
979	{
980	setRouter ("Linksys WRT150N v1.2");
981	// return ROUTER_WRT150NV12;
982	return ROUTER_WRT150N;
983	}
984	else if (nvram_match ("boot_hw_model", "WRT160N")
985	&& nvram_match ("boot_hw_ver", "1.0"))
986	{
987	setRouter ("Linksys WRT160N");
988	return ROUTER_WRT160N;
989	}
990	else if (nvram_match ("boot_hw_model", "WRT310N")
991	&& nvram_match ("boot_hw_ver", "1.0"))
992	{
993	setRouter ("Linksys WRT310N");
994	return ROUTER_WRT310N;
995	}
996	}
997
998	if (boardnum == 42 &&
999	nvram_match ("boardtype", "0x0472") && nvram_match ("cardbus", "1"))
1000	{
1001	setRouter ("Linksys WRT300N v1");
1002	return ROUTER_WRT300N;
1003	}
1004
1005
1006	if (boardnum == 42 &&
1007	nvram_match ("boardtype", "0x478") && nvram_match ("cardbus", "1"))
1008	{
1009	cprintf ("router is Linksys WRT350N\n");
1010	setRouter ("Linksys WRT350N");
1011	return ROUTER_WRT350N;
1012	}
1013
1014	if (nvram_match ("boardnum", "20070615") &&
1015	nvram_match ("boardtype", "0x478") && nvram_match ("cardbus", "0")
1016	&& nvram_match ("switch_type", "BCM5395"))
1017	{
1018	cprintf ("router is Linksys WRT600N v1.1\n");
1019	setRouter ("Linksys WRT600N v1.1");
1020	return ROUTER_WRT600N;
1021	}
1022	if (nvram_match ("boardnum", "20070615") &&
1023	nvram_match ("boardtype", "0x478") && nvram_match ("cardbus", "0"))
1024	{
1025	cprintf ("router is Linksys WRT600N\n");
1026	setRouter ("Linksys WRT600N");
1027	return ROUTER_WRT600N;
1028	}
1029
1030	if (boardnum == 42 && nvram_match ("boardtype", "bcm94710dev"))
1031	{
1032	cprintf ("router is Linksys WRT54G v1.x\n");
1033	setRouter ("Linksys WRT54G v1.x");
1034	return ROUTER_WRT54G1X;
1035	}
1036
1037	if ((boardnum == 1 \|\| boardnum == 0) && nvram_match ("boardtype", "0x0446"))
1038	{
1039	cprintf ("router is U.S. Robotics USR5430\n");
1040	setRouter ("U.S.Robotics USR5430");
1041	return ROUTER_USR_5430;
1042	}
1043
1044
1045	if (boardnum == 1 && nvram_match ("boardtype", "0x456"))
1046	{
1047	cprintf ("router is Netgear WG602 v3\n");
1048	setRouter ("Netgear WG602 v3");
1049	return ROUTER_NETGEAR_WG602_V3;
1050	}
1051
1052	if (boardnum == 10496 && nvram_match ("boardtype", "0x456"))
1053	{
1054	cprintf ("router is U.S. Robotics USR5461\n");
1055	setRouter ("U.S.Robotics USR5461");
1056	return ROUTER_USR_5461;
1057	}
1058
1059	if (boardnum == 10500 && nvram_match ("boardtype", "0x456"))
1060	{
1061	cprintf ("router is U.S. Robotics USR5432\n");
1062	setRouter ("U.S.Robotics USR5432");
1063	return ROUTER_USR_5461; //should work in the same way
1064	}
1065
1066	if (boardnum == 10506 && nvram_match ("boardtype", "0x456"))
1067	{
1068	cprintf ("router is U.S. Robotics USR5451\n");
1069	setRouter ("U.S.Robotics USR5451");
1070	return ROUTER_USR_5461; //should work in the same way
1071	}
1072
1073	if (boardnum == 1024 && nvram_match ("boardtype", "0x0446"))
1074	{
1075	char *cfe = nvram_safe_get ("cfe_version");
1076	if (strstr (cfe, "iewsonic"))
1077	{
1078	cprintf ("router is Viewsonic WAPBR-100\n");
1079	setRouter ("Viewsonic WAPBR-100");
1080	return ROUTER_VIEWSONIC_WAPBR_100;
1081	}
1082	else
1083	{
1084	cprintf ("router is Linksys WAP54G v2\n");
1085	setRouter ("Linksys WAP54G v2");
1086	return ROUTER_WAP54G_V2;
1087	}
1088	}
1089
1090	if (nvram_invmatch ("CFEver", ""))
1091	{
1092	char *cfe = nvram_safe_get ("CFEver");
1093	if (!strncmp (cfe, "MotoWR", 6))
1094	{
1095	cprintf ("router is motorola\n");
1096	setRouter ("Motorola WR850G v2/v3");
1097	return ROUTER_MOTOROLA;
1098	}
1099	}
1100
1101	if (boardnum == 44 &&
1102	(nvram_match ("boardtype", "0x0101")
1103	\|\| nvram_match ("boardtype", "0x0101\r")))
1104	{
1105	char *cfe = nvram_safe_get ("CFEver");
1106	if (!strncmp (cfe, "GW_WR110G", 9))
1107	{
1108	cprintf ("router is Sparklan WX-6615GT\n");
1109	setRouter ("Sparklan WX-6615GT");
1110	return ROUTER_DELL_TRUEMOBILE_2300_V2;
1111	}
1112	else
1113	{
1114	cprintf ("router is Dell TrueMobile 2300 v2\n");
1115	setRouter ("Dell TrueMobile 2300 v2");
1116	return ROUTER_DELL_TRUEMOBILE_2300_V2;
1117	}
1118	}
1119	#endif
1120	if (nvram_match ("boardtype", "bcm94710ap"))
1121	{
1122	cprintf ("router is Buffalo old 4710\n");
1123	setRouter ("Buffalo WBR-B11");
1124	return ROUTER_BUFFALO_WBR54G;
1125	}
1126	#ifndef HAVE_BUFFALO
1127	if (nvram_match ("boardtype", "0x048e") &&
1128	nvram_match ("boardrev", "0x35") &&
1129	nvram_match ("sdram_init", "0x000b"))
1130	{
1131	cprintf ("router is D-Link DIR-320\n");
1132	setRouter ("D-Link DIR-320");
1133	//apply some fixes
1134	if (nvram_get ("vlan2ports") != NULL)
1135	{
1136	nvram_unset ("vlan2ports");
1137	nvram_unset ("vlan2hwname");
1138	}
1139	return ROUTER_DLINK_DIR320;
1140	}
1141	if (nvram_match ("model_name", "DIR-330") &&
1142	nvram_match ("boardrev", "0x10"))
1143	{
1144	cprintf ("router is D-Link DIR-330\n");
1145	setRouter ("D-Link DIR-330");
1146	nvram_set ("wan_ifnames", "eth0"); // quirk
1147	nvram_set ("wan_ifname", "eth0");
1148	if (nvram_match ("et0macaddr", "00:90:4c:4e:00:0c"))
1149	{
1150	FILE *in = fopen ("/dev/mtdblock/1", "rb");
1151	fseek (in, 0x7a0022, SEEK_SET);
1152	char mac[32];
1153	fread (mac, 32, 1, in);
1154	fclose (in);
1155	mac[17] = 0;
1156	if (sv_valid_hwaddr (mac))
1157	{
1158	nvram_set ("et0macaddr", mac);
1159	fprintf (stderr, "restore D-Link MAC\n");
1160	nvram_commit ();
1161	sys_reboot ();
1162	}
1163	}
1164	/* if (nvram_get("vlan2ports")!=NULL)
1165	{
1166	nvram_unset("vlan2ports");
1167	nvram_unset("vlan2hwname");
1168	}*/
1169	return ROUTER_DLINK_DIR330;
1170	}
1171	if (boardnum == 42 &&
1172	nvram_match ("boardtype", "0x048e") && nvram_match ("boardrev", "0x10"))
1173	{
1174	cprintf ("router is wrt54g v8\n");
1175	setRouter ("Linksys WRT54Gv8 / GSv7");
1176	return ROUTER_WRT54G_V8;
1177	}
1178
1179	if (boardnum == 8 &&
1180	nvram_match ("boardtype", "0x048e") && nvram_match ("boardrev", "0x11"))
1181	{
1182	cprintf ("router is ALLNET01\n");
1183	setRouter ("ALLNET01");
1184	return ROUTER_ALLNET01;
1185	}
1186
1187	if (boardnum == 1 &&
1188	nvram_match ("boardtype", "0x048e") && nvram_match ("boardrev", "0x11"))
1189	{
1190	cprintf ("router is Netgear WG602 v4\n");
1191	setRouter ("Netgear WG602 v4");
1192	return ROUTER_NETGEAR_WG602_V4;
1193	}
1194
1195	if (boardnum == 1 &&
1196	nvram_match ("boardtype", "0x048e") && nvram_match ("boardrev", "0x35")
1197	&& nvram_match ("parefldovoltage", "0x28"))
1198	{
1199	cprintf ("router is netcore nw618\n");
1200	setRouter ("NetCore NW618");
1201	return ROUTER_WRT54G;
1202	}
1203
1204	if (boardnum == 42 &&
1205	nvram_match ("boardtype", "0x048E") && nvram_match ("boardrev", "0x10"))
1206	{
1207	cprintf ("router is Linksys WRH54G\n");
1208	setRouter ("Linksys WRH54G");
1209	return ROUTER_LINKSYS_WRH54G;
1210	}
1211
1212	if (nvram_match ("boardnum", "00") &&
1213	nvram_match ("boardtype", "0x048E") && nvram_match ("boardrev", "0x10"))
1214	{
1215	cprintf ("router is Linksys WRT54G v8.1\n");
1216	setRouter ("Linksys WRT54G v8.1");
1217	return ROUTER_WRT54G_V81;
1218	}
1219
1220	if (boardnum == 45 && nvram_match ("boardtype", "0x456"))
1221	{
1222	cprintf ("router is Asus WL-520G\n");
1223	setRouter ("Asus WL-520G");
1224	return ROUTER_ASUS_WL520G;
1225	}
1226
1227	if (boardnum == 45 &&
1228	nvram_match ("boardtype", "0x48E") && nvram_match ("boardrev", "0x10"))
1229	{
1230	char *hwver = nvram_safe_get ("hardware_version");
1231	if (startswith (hwver, "WL500GPV2"))
1232	{
1233	cprintf ("router is Asus WL-500G Premium V2\n");
1234	setRouter ("Asus WL-500G Premium V2");
1235	return ROUTER_ASUS_WL500G_PRE_V2;
1236	}
1237	else
1238	{
1239	cprintf ("router is Asus WL-520GU/GC\n");
1240	setRouter ("Asus WL-520GU/GC");
1241	return ROUTER_ASUS_WL520GUGC;
1242	}
1243	}
1244
1245	if (boardnum == 83258 &&
1246	nvram_match ("boardtype", "0x48E") && nvram_match ("boardrev", "0x10"))
1247	{
1248	cprintf ("router is Netgear WGR614L\n");
1249	setRouter ("Netgear WGR614L");
1250	return ROUTER_NETGEAR_WGR614L;
1251	}
1252
1253	if (boardnum == 56 &&
1254	nvram_match ("boardtype", "0x456") && nvram_match ("boardrev", "0x10"))
1255	{
1256	cprintf ("router is wtr54gs\n");
1257	setRouter ("Linksys WTR54GS");
1258	return ROUTER_LINKSYS_WTR54GS;
1259	}
1260
1261	if (nvram_match ("boardnum", "WAP54GV3_8M_0614")
1262	&& (nvram_match ("boardtype", "0x0467")
1263	\|\| nvram_match ("boardtype", "0x467"))
1264	&& nvram_match ("WAPver", "3"))
1265	{
1266	cprintf ("router is WAP54G v3.x\n");
1267	setRouter ("Linksys WAP54G v3.x");
1268	return ROUTER_WAP54G_V3;
1269	}
1270
1271	setRouter ("Linksys WRT54G/GL/GS");
1272	cprintf ("router is wrt54g\n");
1273	return ROUTER_WRT54G;
1274	#else
1275	eval ("event", "3", "1", "15");
1276	return 0;
1277	#endif
1278	#endif
1279
1280	}
1281
1282	int
1283	has_mimo (char *prefix)
1284	{
1285	if (nvram_nmatch ("n", "%s_phytypes", prefix))
1286	return 1;
1287	return 0;
1288	}
1289
1290	static int router_type = -1;
1291	int
1292	getRouterBrand ()
1293	{
1294	if (router_type == -1)
1295	router_type = internal_getRouterBrand ();
1296	return router_type;
1297	}
1298
1299
1300	int
1301	diag_led_4702 (int type, int act)
1302	{
1303
1304	#if defined(HAVE_GEMTEK) \|\| defined(HAVE_RB500) \|\| defined(HAVE_XSCALE) \|\| defined(HAVE_MAGICBOX) \|\| defined(HAVE_FONERA) \|\| defined(HAVE_MERAKI) \|\| defined(HAVE_LS2) \|\| defined(HAVE_WHRAG108) \|\| defined(HAVE_X86) \|\| defined(HAVE_CA8) \|\| defined(HAVE_TW6600) \|\| defined(HAVE_PB42) \|\| defined(HAVE_LS5) \|\| defined(HAVE_FONERA) \|\| defined(HAVE_LSX)
1305	return 0;
1306	#else
1307	if (act == START_LED)
1308	{
1309	switch (type)
1310	{
1311	case DMZ:
1312	system2 ("echo 1 > /proc/sys/diag");
1313	break;
1314	}
1315	}
1316	else
1317	{
1318	switch (type)
1319	{
1320	case DMZ:
1321	system2 ("echo 0 > /proc/sys/diag");
1322	break;
1323	}
1324	}
1325	return 0;
1326	#endif
1327	}
1328
1329	int
1330	C_led_4702 (int i)
1331	{
1332	#if defined(HAVE_GEMTEK) \|\| defined(HAVE_RB500) \|\| defined(HAVE_XSCALE) \|\| defined(HAVE_MAGICBOX) \|\| defined(HAVE_FONERA) \|\| defined(HAVE_MERAKI) \|\| defined(HAVE_LS2) \|\| defined(HAVE_WHRAG108) \|\| defined(HAVE_X86) \|\| defined(HAVE_CA8) \|\| defined(HAVE_TW6600) \|\| defined(HAVE_PB42) \|\| defined(HAVE_LS5) \|\| defined(HAVE_LSX)
1333	return 0;
1334	#else
1335	FILE *fp;
1336	char string[10];
1337	int flg;
1338
1339	memset (string, 0, 10);
1340	/* get diag before set */
1341	if ((fp = fopen ("/proc/sys/diag", "r")))
1342	{
1343	fgets (string, sizeof (string), fp);
1344	fclose (fp);
1345	}
1346	else
1347	perror ("/proc/sys/diag");
1348
1349	if (i)
1350	flg = atoi (string) \| 0x10;
1351	else
1352	flg = atoi (string) & 0xef;
1353
1354	memset (string, 0, 10);
1355	sprintf (string, "%d", flg);
1356	if ((fp = fopen ("/proc/sys/diag", "w")))
1357	{
1358	fputs (string, fp);
1359	fclose (fp);
1360	}
1361	else
1362	perror ("/proc/sys/diag");
1363
1364	return 0;
1365	#endif
1366	}
1367
1368	unsigned int
1369	read_gpio (char *device)
1370	{
1371	FILE *fp;
1372	unsigned int val;
1373
1374	if ((fp = fopen (device, "r")))
1375	{
1376	fread (&val, 4, 1, fp);
1377	fclose (fp);
1378	//fprintf(stderr, "----- gpio %s = [%X]\n",device,val);
1379	return val;
1380	}
1381	else
1382	{
1383	perror (device);
1384	return 0;
1385	}
1386	}
1387
1388	unsigned int
1389	write_gpio (char *device, unsigned int val)
1390	{
1391	FILE *fp;
1392
1393	if ((fp = fopen (device, "w")))
1394	{
1395	fwrite (&val, 4, 1, fp);
1396	fclose (fp);
1397	//fprintf(stderr, "----- set gpio %s = [%X]\n",device,val);
1398	return 1;
1399	}
1400	else
1401	{
1402	perror (device);
1403	return 0;
1404	}
1405	}
1406
1407	static char hw_error = 0;
1408	int
1409	diag_led_4704 (int type, int act)
1410	{
1411	#if defined(HAVE_GEMTEK) \|\| defined(HAVE_RB500) \|\| defined(HAVE_XSCALE) \|\| defined(HAVE_MAGICBOX) \|\| defined(HAVE_FONERA) \|\| defined(HAVE_MERAKI)\|\| defined(HAVE_LS2) \|\| defined(HAVE_WHRAG108) \|\| defined(HAVE_X86) \|\| defined(HAVE_CA8) \|\| defined(HAVE_TW6600) \|\| defined(HAVE_PB42) \|\| defined(HAVE_LS5) \|\| defined(HAVE_LSX)
1412	return 0;
1413	#else
1414	unsigned int control, in, outen, out;
1415
1416	#ifdef BCM94712AGR
1417	/* The router will crash, if we load the code into broadcom demo board. */
1418	return 1;
1419	#endif
1420	//int brand;
1421	control = read_gpio ("/dev/gpio/control");
1422	in = read_gpio ("/dev/gpio/in");
1423	out = read_gpio ("/dev/gpio/out");
1424	outen = read_gpio ("/dev/gpio/outen");
1425
1426	write_gpio ("/dev/gpio/outen", (outen & 0x7c) \| 0x83);
1427	switch (type)
1428	{
1429	case DIAG: // GPIO 1
1430	if (hw_error)
1431	{
1432	write_gpio ("/dev/gpio/out", (out & 0x7c) \| 0x00);
1433	return 1;
1434	}
1435
1436	if (act == STOP_LED)
1437	{ // stop blinking
1438	write_gpio ("/dev/gpio/out", (out & 0x7c) \| 0x83);
1439	//cprintf("tallest:=====( DIAG STOP_LED !!)=====\n");
1440	}
1441	else if (act == START_LED)
1442	{ // start blinking
1443	write_gpio ("/dev/gpio/out", (out & 0x7c) \| 0x81);
1444	//cprintf("tallest:=====( DIAG START_LED !!)=====\n");
1445	}
1446	else if (act == MALFUNCTION_LED)
1447	{ // start blinking
1448	write_gpio ("/dev/gpio/out", (out & 0x7c) \| 0x00);
1449	hw_error = 1;
1450	//cprintf("tallest:=====( DIAG MALFUNCTION_LED !!)=====\n");
1451	}
1452	break;
1453
1454	}
1455	return 1;
1456	#endif
1457	}
1458
1459	int
1460	diag_led_4712 (int type, int act)
1461	{
1462	unsigned int control, in, outen, out, ctr_mask, out_mask;
1463	#if defined(HAVE_GEMTEK) \|\| defined(HAVE_RB500) \|\| defined(HAVE_XSCALE) \|\| defined(HAVE_MAGICBOX) \|\| defined(HAVE_FONERA)\|\| defined(HAVE_MERAKI) \|\| defined(HAVE_LS2) \|\| defined(HAVE_WHRAG108) \|\| defined(HAVE_X86) \|\| defined(HAVE_CA8) \|\| defined(HAVE_TW6600) \|\| defined(HAVE_PB42) \|\| defined(HAVE_LS5) \|\| defined(HAVE_LSX)
1464	return 0;
1465	#else
1466
1467
1468	#ifdef BCM94712AGR
1469	/* The router will crash, if we load the code into broadcom demo board. */
1470	return 1;
1471	#endif
1472	control = read_gpio ("/dev/gpio/control");
1473	in = read_gpio ("/dev/gpio/in");
1474	out = read_gpio ("/dev/gpio/out");
1475	outen = read_gpio ("/dev/gpio/outen");
1476
1477	ctr_mask = ~(1 << type);
1478	out_mask = (1 << type);
1479
1480	write_gpio ("/dev/gpio/control", control & ctr_mask);
1481	write_gpio ("/dev/gpio/outen", outen \| out_mask);
1482
1483	if (act == STOP_LED)
1484	{ // stop blinking
1485	//cprintf("%s: Stop GPIO %d\n", __FUNCTION__, type);
1486	write_gpio ("/dev/gpio/out", out \| out_mask);
1487	}
1488	else if (act == START_LED)
1489	{ // start blinking
1490	//cprintf("%s: Start GPIO %d\n", __FUNCTION__, type);
1491	write_gpio ("/dev/gpio/out", out & ctr_mask);
1492	}
1493
1494	return 1;
1495	#endif
1496	}
1497
1498	int
1499	C_led_4712 (int i)
1500	{
1501	if (i == 1)
1502	return diag_led (DIAG, START_LED);
1503	else
1504	return diag_led (DIAG, STOP_LED);
1505	}
1506
1507	int
1508	C_led (int i)
1509	{
1510	//show_hw_type(check_hw_type());
1511	int brand = getRouterBrand ();
1512
1513	if (brand == ROUTER_WRT54G1X \|\| brand == ROUTER_LINKSYS_WRT55AG)
1514	return C_led_4702 (i);
1515	else if (brand == ROUTER_WRT54G)
1516	return C_led_4712 (i);
1517	else
1518	return 0;
1519	}
1520
1521	int
1522	diag_led (int type, int act)
1523	{
1524	int brand = getRouterBrand ();
1525
1526	if (brand == ROUTER_WRT54G \|\| brand == ROUTER_WRT54G3G
1527	\|\| brand == ROUTER_WRT300NV11)
1528	return diag_led_4712 (type, act);
1529	else if (brand == ROUTER_WRT54G1X \|\| brand == ROUTER_LINKSYS_WRT55AG)
1530	return diag_led_4702 (type, act);
1531	else
1532	if ((brand == ROUTER_WRTSL54GS \|\| brand == ROUTER_WRT350N
1533	\|\| brand == ROUTER_WRT310N
1534	\|\| brand == ROUTER_BUFFALO_WZRG144NH) && type == DIAG)
1535	return diag_led_4704 (type, act);
1536	else
1537	{
1538	if (type == DMZ)
1539	{
1540	if (act == START_LED)
1541	return led_control (LED_DMZ, LED_ON);
1542	if (act == STOP_LED)
1543	return led_control (LED_DMZ, LED_OFF);
1544	return 1;
1545	}
1546	}
1547	return 0;
1548	}
1549
1550	int
1551	led_control (int type, int act)
1552	/* type: LED_POWER, LED_DIAG, LED_DMZ, LED_CONNECTED, LED_BRIDGE, LED_VPN, LED_SES, LED_SES2, LED_WLAN
1553	* act: LED_ON, LED_OFF, LED_FLASH */
1554	{
1555	#if defined(HAVE_GEMTEK) \|\| defined(HAVE_RB500) \|\| defined(HAVE_MAGICBOX) \|\| defined(HAVE_MERAKI) \|\| defined(HAVE_LS2) \|\| defined(HAVE_X86) \|\| defined(HAVE_CA8) \|\| defined(HAVE_LS5) && !defined(HAVE_DIR300) && !defined(HAVE_DIR400)
1556	return 0;
1557	#else
1558
1559	int use_gpio = 0x0f;
1560	int gpio_value;
1561	int enable;
1562	int disable;
1563
1564	int power_gpio = 0x0f;
1565	int diag_gpio = 0x0f;
1566	int dmz_gpio = 0x0f;
1567	int connected_gpio = 0x0f;
1568	int bridge_gpio = 0x0f;
1569	int vpn_gpio = 0x0f;
1570	int ses_gpio = 0x0f; //use for SES1 (Linksys), AOSS (Buffalo) ....
1571	int ses2_gpio = 0x0f;
1572	int wlan_gpio = 0x0f; //use this only if wlan led is not controlled by hardware!
1573	int usb_gpio = 0x0f;
1574	int v1func = 0;
1575	switch (getRouterBrand ()) //gpio definitions here: 0xYZ, Y=0:normal, Y=1:inverted, Z:gpio number (f=disabled)
1576	{
1577	#ifndef HAVE_BUFFALO
1578	case ROUTER_BOARD_GATEWORX:
1579	connected_gpio = 0x3;
1580	break;
1581	case ROUTER_BOARD_GATEWORX_SWAP:
1582	connected_gpio = 0x4;
1583	break;
1584	case ROUTER_LINKSYS_WRH54G:
1585	diag_gpio = 0x11; //power led blink / off to indicate factory defaults
1586	break;
1587	case ROUTER_WRT54G:
1588	case ROUTER_WRT54G_V8:
1589	power_gpio = 0x01;
1590	dmz_gpio = 0x17;
1591	connected_gpio = 0x13; //ses orange
1592	ses_gpio = 0x12; //ses white
1593	ses2_gpio = 0x13; //ses orange
1594	break;
1595	case ROUTER_WRT54G_V81:
1596	power_gpio = 0x11;
1597	dmz_gpio = 0x12;
1598	connected_gpio = 0x14; //ses orange
1599	ses_gpio = 0x13; //ses white
1600	ses2_gpio = 0x14; //ses orange
1601	break;
1602	case ROUTER_WRT54G1X:
1603	connected_gpio = 0x13;
1604	v1func = 1;
1605	break;
1606	case ROUTER_WRT350N:
1607	connected_gpio = 0x13;
1608	power_gpio = 0x01;
1609	ses2_gpio = 0x13; //ses orange
1610	// usb_gpio = 0x04;
1611	break;
1612	case ROUTER_WRT600N:
1613	connected_gpio = 0x13;
1614	// power_gpio = 0x01;
1615	ses2_gpio = 0x18; //ses orange
1616	break;
1617	case ROUTER_LINKSYS_WRT55AG:
1618	connected_gpio = 0x13;
1619	break;
1620	case ROUTER_DLINK_DIR330:
1621	diag_gpio = 0x16;
1622	connected_gpio = 0x14;
1623	break;
1624	#endif
1625	case ROUTER_BUFFALO_WBR54G:
1626	diag_gpio = 0x17;
1627	break;
1628	case ROUTER_BUFFALO_WBR2G54S:
1629	diag_gpio = 0x01;
1630	ses_gpio = 0x06;
1631	break;
1632	case ROUTER_BUFFALO_WLA2G54C:
1633	diag_gpio = 0x14;
1634	ses_gpio = 0x13;
1635	break;
1636	case ROUTER_BUFFALO_WLAH_G54:
1637	diag_gpio = 0x17;
1638	ses_gpio = 0x16;
1639	break;
1640	case ROUTER_BUFFALO_WAPM_HP_AM54G54:
1641	diag_gpio = 0x17;
1642	ses_gpio = 0x11;
1643	break;
1644	case ROUTER_BOARD_WHRAG108:
1645	diag_gpio = 0x17;
1646	bridge_gpio = 0x14;
1647	ses_gpio = 0x10;
1648	break;
1649	case ROUTER_BUFFALO_WHRG54S:
1650	case ROUTER_BUFFALO_WLI_TX4_G54HP:
1651	diag_gpio = 0x17;
1652	bridge_gpio = 0x11;
1653	ses_gpio = 0x16;
1654	break;
1655	case ROUTER_BUFFALO_WZRRSG54:
1656	diag_gpio = 0x17;
1657	vpn_gpio = 0x11;
1658	ses_gpio = 0x16;
1659	break;
1660	case ROUTER_BUFFALO_WZRG300N:
1661	diag_gpio = 0x17;
1662	bridge_gpio = 0x11;
1663	break;
1664	case ROUTER_BUFFALO_WZRG144NH:
1665	diag_gpio = 0x13;
1666	bridge_gpio = 0x11;
1667	ses_gpio = 0x12;
1668	break;
1669	#ifndef HAVE_BUFFALO
1670	#ifdef HAVE_DIR300
1671	case ROUTER_BOARD_FONERA:
1672	diag_gpio = 0x03;
1673	bridge_gpio = 0x04;
1674	ses_gpio = 0x01;
1675	break;
1676	#endif
1677	#ifdef HAVE_DIR400
1678	case ROUTER_BOARD_FONERA2200:
1679	diag_gpio = 0x03;
1680	bridge_gpio = 0x04;
1681	ses_gpio = 0x01;
1682	break;
1683	#endif
1684	#ifdef HAVE_WRK54G
1685	case ROUTER_BOARD_FONERA:
1686	diag_gpio = 0x17;
1687	dmz_gpio = 0x05;
1688	break;
1689	#endif
1690	case ROUTER_BOARD_TW6600:
1691	diag_gpio = 0x17;
1692	bridge_gpio = 0x14;
1693	ses_gpio = 0x10;
1694	break;
1695	case ROUTER_MOTOROLA:
1696	power_gpio = 0x01;
1697	diag_gpio = 0x11; //power led blink / off to indicate factory defaults
1698	break;
1699	case ROUTER_RT210W:
1700	power_gpio = 0x15;
1701	diag_gpio = 0x05; //power led blink / off to indicate factory defaults
1702	connected_gpio = 0x10;
1703	wlan_gpio = 0x13;
1704	break;
1705	case ROUTER_RT480W:
1706	case ROUTER_BELKIN_F5D7230_V2000:
1707	case ROUTER_BELKIN_F5D7231:
1708	power_gpio = 0x15;
1709	diag_gpio = 0x05; //power led blink / off to indicate factory defaults
1710	connected_gpio = 0x10;
1711	break;
1712	case ROUTER_MICROSOFT_MN700:
1713	power_gpio = 0x06;
1714	diag_gpio = 0x16; //power led blink / off to indicate factory defaults
1715	break;
1716	case ROUTER_ASUS_WL500GD:
1717	case ROUTER_ASUS_WL520GUGC:
1718	diag_gpio = 0x00; //power led blink / off to indicate factory defaults
1719	break;
1720	case ROUTER_ASUS_WL500G_PRE:
1721	power_gpio = 0x11;
1722	diag_gpio = 0x01; //power led blink / off to indicate factory defaults
1723	break;
1724	case ROUTER_ASUS_WL550GE:
1725	power_gpio = 0x12;
1726	diag_gpio = 0x02; //power led blink / off to indicate factory defaults
1727	break;
1728	case ROUTER_WRT54G3G:
1729	case ROUTER_WRTSL54GS:
1730	power_gpio = 0x01;
1731	dmz_gpio = 0x10;
1732	connected_gpio = 0x17; //ses orange
1733	ses_gpio = 0x15; //ses white
1734	ses2_gpio = 0x17; //ses orange
1735	break;
1736	case ROUTER_MOTOROLA_WE800G:
1737	case ROUTER_MOTOROLA_V1:
1738	diag_gpio = 0x13;
1739	wlan_gpio = 0x11;
1740	bridge_gpio = 0x15;
1741	break;
1742	case ROUTER_DELL_TRUEMOBILE_2300:
1743	case ROUTER_DELL_TRUEMOBILE_2300_V2:
1744	power_gpio = 0x17;
1745	diag_gpio = 0x07; //power led blink / off to indicate factory defaults
1746	wlan_gpio = 0x16;
1747	break;
1748	case ROUTER_NETGEAR_WNR834B:
1749	power_gpio = 0x14;
1750	diag_gpio = 0x15;
1751	wlan_gpio = 0x16;
1752	break;
1753	case ROUTER_SITECOM_WL105B:
1754	power_gpio = 0x03;
1755	diag_gpio = 0x13; //power led blink / off to indicate factory defaults
1756	wlan_gpio = 0x14;
1757	break;
1758	case ROUTER_WRT150N:
1759	case ROUTER_WRT300N:
1760	power_gpio = 0x01;
1761	diag_gpio = 0x11; //power led blink / off to indicate fac.def.
1762	break;
1763	case ROUTER_WRT300NV11:
1764	ses_gpio = 0x15;
1765	// diag_gpio = 0x11; //power led blink / off to indicate fac.def.
1766	break;
1767	case ROUTER_WRT310N:
1768	connected_gpio = 0x13;
1769	power_gpio = 0x01;
1770	diag_gpio = 0x11; //power led blink / off to indicate fac.def.
1771	ses2_gpio = 0x13; //ses orange
1772	case ROUTER_WRT160N:
1773	power_gpio = 0x01;
1774	diag_gpio = 0x11; //power led blink / off to indicate fac.def.
1775	connected_gpio = 0x13; //ses orange
1776	ses_gpio = 0x15; //ses blue
1777	break;
1778	case ROUTER_ASUS_WL500G:
1779	power_gpio = 0x10;
1780	diag_gpio = 0x00; //power led blink /off to indicate factory defaults
1781	break;
1782	case ROUTER_ASUS_WL500W:
1783	power_gpio = 0x15;
1784	diag_gpio = 0x05; //power led blink /off to indicate factory defaults
1785	break;
1786	case ROUTER_LINKSYS_WTR54GS:
1787	diag_gpio = 0x01;
1788	break;
1789	case ROUTER_WAP54G_V1:
1790	diag_gpio = 0x13;
1791	wlan_gpio = 0x14; //LINK led
1792	break;
1793	case ROUTER_WAP54G_V3:
1794	ses_gpio = 0x1c;
1795	connected_gpio = 0x06;
1796	break;
1797	case ROUTER_NETGEAR_WNR834BV2:
1798	power_gpio = 0x02;
1799	diag_gpio = 0x03; //power led amber
1800	connected_gpio = 0x07; //WAN led green
1801	break;
1802	case ROUTER_ASKEY_RT220XD:
1803	wlan_gpio = 0x10;
1804	dmz_gpio = 0x11; //not soldered
1805	break;
1806	#endif
1807	}
1808	if (type == LED_DIAG && v1func == 1)
1809	{
1810	if (act == LED_ON)
1811	C_led (1);
1812	else
1813	C_led (0);
1814	}
1815
1816	switch (type)
1817	{
1818	case LED_POWER:
1819	use_gpio = power_gpio;
1820	break;
1821	case LED_DIAG:
1822	use_gpio = diag_gpio;
1823	break;
1824	case LED_DMZ:
1825	use_gpio = dmz_gpio;
1826	break;
1827	case LED_CONNECTED:
1828	use_gpio = connected_gpio;
1829	break;
1830	case LED_BRIDGE:
1831	use_gpio = bridge_gpio;
1832	break;
1833	case LED_VPN:
1834	use_gpio = vpn_gpio;
1835	break;
1836	case LED_SES:
1837	use_gpio = ses_gpio;
1838	break;
1839	case LED_SES2:
1840	use_gpio = ses2_gpio;
1841	break;
1842	case LED_WLAN:
1843	use_gpio = wlan_gpio;
1844	break;
1845	case LED_USB:
1846	use_gpio = usb_gpio;
1847	break;
1848	}
1849	if ((use_gpio & 0x0f) != 0x0f)
1850	{
1851	gpio_value = use_gpio & 0x0f;
1852	enable = (use_gpio & 0x10) == 0 ? 1 : 0;
1853	disable = (use_gpio & 0x10) == 0 ? 0 : 1;
1854	switch (act)
1855	{
1856	case LED_ON:
1857	set_gpio (gpio_value, enable);
1858	break;
1859	case LED_OFF:
1860	set_gpio (gpio_value, disable);
1861	break;
1862	case LED_FLASH: //will lit the led for 1 sec.
1863	set_gpio (gpio_value, enable);
1864	sleep (1);
1865	set_gpio (gpio_value, disable);
1866	break;
1867	}
1868	}
1869	return 1;
1870
1871	#endif
1872	}
1873
1874
1875	char *
1876	get_mac_from_ip (char *ip)
1877	{
1878	FILE *fp;
1879	char line[100];
1880	char ipa[50]; // ip address
1881	char hwa[50]; // HW address / MAC
1882	char mask[50]; // ntemask
1883	char dev[50]; // interface
1884	int type; // HW type
1885	int flags; // flags
1886	static char mac[20];
1887
1888
1889	if ((fp = fopen ("/proc/net/arp", "r")) == NULL)
1890	return NULL;
1891
1892	// Bypass header -- read until newline
1893	if (fgets (line, sizeof (line), fp) != (char *) NULL)
1894	{
1895	// Read the ARP cache entries.
1896	// IP address HW type Flags HW address Mask Device
1897	// 192.168.1.1 0x1 0x2 00:90:4C:21:00:2A * eth0
1898	for (; fgets (line, sizeof (line), fp);)
1899	{
1900	if (sscanf
1901	(line, "%s 0x%x 0x%x %100s %100s %100s\n", ipa, &type, &flags,
1902	hwa, mask, dev) != 6)
1903	continue;
1904	//cprintf("ip1=[%s] ip2=[%s] mac=[%s] (flags & ATF_COM)=%d\n", ip, ipa, hwa, (flags & ATF_COM));
1905	if (strcmp (ip, ipa))
1906	continue;
1907	//if (!(flags & ATF_COM)) { //ATF_COM = 0x02 completed entry (ha valid)
1908	strcpy (mac, hwa);
1909	fclose (fp);
1910	return mac;
1911	//}
1912	}
1913	}
1914
1915	fclose (fp);
1916	return "";
1917	}
1918
1919
1920	int
1921	isListed (char listname, char value)
1922	{
1923	char *next, word[32];
1924	char *list = nvram_get (listname);
1925	if (!list)
1926	return 0;
1927	foreach (word, list, next)
1928	{
1929	if (!strcmp (word, value))
1930	return 1;
1931	}
1932	return 0;
1933	}
1934
1935	void
1936	addList (char listname, char value)
1937	{
1938	int listlen = 0;
1939	if (isListed (listname, value))
1940	return;
1941	char *list = nvram_get (listname);
1942	char *newlist;
1943	if (list)
1944	listlen = strlen (list);
1945	newlist = malloc (strlen (value + 2) + listlen);
1946	if (list)
1947	sprintf (newlist, "%s %s", list, value);
1948	else
1949	sprintf (newlist, "%s", value);
1950	nvram_set (listname, newlist);
1951	free (newlist);
1952	}
1953
1954	struct dns_lists *
1955	get_dns_list (void)
1956	{
1957	char list[254];
1958	char *next, word[254];
1959	struct dns_lists *dns_list = NULL;
1960	int i, match = 0, altdns_index = 1;
1961
1962	dns_list = (struct dns_lists *) malloc (sizeof (struct dns_lists));
1963	memset (dns_list, 0, sizeof (struct dns_lists));
1964
1965	dns_list->num_servers = 0;
1966
1967	// nvram_safe_get("wan_dns") ==> Set by user
1968	// nvram_safe_get("wan_get_dns") ==> Get from DHCP, PPPoE or PPTP
1969	// The nvram_safe_get("wan_dns") priority is higher than nvram_safe_get("wan_get_dns")
1970	snprintf (list, sizeof (list), "%s %s %s", nvram_safe_get ("sv_localdns"),
1971	nvram_safe_get ("wan_dns"), nvram_safe_get ("wan_get_dns"));
1972	foreach (word, list, next)
1973	{
1974	if (strcmp (word, "0.0.0.0") && strcmp (word, ""))
1975	{
1976	match = 0;
1977	for (i = 0; i < dns_list->num_servers; i++)
1978	{ // Skip same DNS
1979	if (!strcmp (dns_list->dns_server[i], word))
1980	match = 1;
1981	}
1982	if (!match)
1983	{
1984	snprintf (dns_list->dns_server[dns_list->num_servers],
1985	sizeof (dns_list->dns_server[dns_list->num_servers]),
1986	"%s", word);
1987	dns_list->num_servers++;
1988	}
1989	}
1990	if (dns_list->num_servers == 3)
1991	break; // We only need 3 DNS entries
1992	}
1993
1994	/* if < 3 DNS servers found, try to insert alternates */
1995	while (dns_list->num_servers < 3 && altdns_index <= 3)
1996	{
1997	char altdnsvar[32] = {
1998	0
1999	};
2000
2001	snprintf (altdnsvar, 31, "altdns%d", altdns_index);
2002
2003	if (strlen (nvram_safe_get (altdnsvar)) > 0)
2004	{
2005	snprintf (dns_list->dns_server[dns_list->num_servers],
2006	sizeof (dns_list->dns_server[dns_list->num_servers]),
2007	"%s", nvram_safe_get (altdnsvar));
2008	dns_list->num_servers++;
2009	}
2010	altdns_index++;
2011	}
2012	return dns_list;
2013	}
2014
2015	int
2016	dns_to_resolv (void)
2017	{
2018	FILE *fp_w;
2019	struct dns_lists *dns_list = NULL;
2020	int i = 0;
2021
2022	/* Save DNS to resolv.conf */
2023	if (!(fp_w = fopen (RESOLV_FILE, "w")))
2024	{
2025	perror (RESOLV_FILE);
2026	return errno;
2027	}
2028	if (nvram_invmatch ("wan_get_domain", ""))
2029	{
2030	fprintf (fp_w, "search %s\n", nvram_safe_get ("wan_get_domain"));
2031	}
2032	else if (nvram_invmatch ("wan_domain", ""))
2033	{
2034	fprintf (fp_w, "search %s\n", nvram_safe_get ("wan_domain"));
2035	}
2036	if (nvram_invmatch ("lan_domain", ""))
2037	{
2038	fprintf (fp_w, "search %s\n", nvram_safe_get ("lan_domain"));
2039	}
2040	if (nvram_match ("dnsmasq_enable", "1"))
2041	{
2042	fprintf (fp_w, "nameserver %s\n", nvram_get ("lan_ipaddr"));
2043	fclose (fp_w);
2044	if (!(fp_w = fopen (RESOLV_FORW, "w")))
2045	{
2046	perror (RESOLV_FORW);
2047	return errno;
2048	}
2049	}
2050
2051	dns_list = get_dns_list ();
2052
2053	for (i = 0; i < dns_list->num_servers; i++)
2054	fprintf (fp_w, "nameserver %s\n", dns_list->dns_server[i]);
2055
2056	/* Put a pseudo DNS IP to trigger Connect On Demand */
2057	if (dns_list->num_servers == 0 &&
2058	(nvram_match ("wan_proto", "pppoe") \|\| nvram_match ("wan_proto", "pptp")
2059	\|\| nvram_match ("wan_proto", "l2tp"))
2060	&& nvram_match ("ppp_demand", "1"))
2061	fprintf (fp_w, "nameserver 1.1.1.1\n");
2062
2063	fclose (fp_w);
2064	if (dns_list)
2065	free (dns_list);
2066
2067	eval ("touch", "/tmp/hosts");
2068
2069	return 1;
2070	}
2071
2072	/* Example:
2073	* lan_ipaddr = 192.168.1.1
2074	* get_dns_ip("lan_ipaddr", 1); produces "168"
2075	*/
2076	int
2077	get_single_ip (char *ipaddr, int which)
2078	{
2079	int ip[4] = {
2080	0, 0, 0, 0
2081	};
2082	int ret;
2083
2084	ret = sscanf (ipaddr, "%d.%d.%d.%d", &ip[0], &ip[1], &ip[2], &ip[3]);
2085
2086	return ip[which];
2087	}
2088
2089	char *
2090	get_complete_lan_ip (char *ip)
2091	{
2092	static char ipaddr[20];
2093
2094	int i[4];
2095
2096	if (sscanf
2097	(nvram_safe_get ("lan_ipaddr"), "%d.%d.%d.%d", &i[0], &i[1], &i[2],
2098	&i[3]) != 4)
2099	return "0.0.0.0";
2100
2101	snprintf (ipaddr, sizeof (ipaddr), "%d.%d.%d.%s", i[0], i[1], i[2], ip);
2102
2103	return ipaddr;
2104	}
2105
2106	char *
2107	get_wan_face (void)
2108	{
2109	static char localwanface[IFNAMSIZ];
2110	/* if (nvram_match ("pptpd_client_enable", "1"))
2111	{
2112	strncpy (localwanface, "ppp0", IFNAMSIZ);
2113	return localwanface;
2114	}*/
2115	if (nvram_match ("wan_proto", "pptp") \|\| nvram_match ("wan_proto", "l2tp")
2116	\|\| nvram_match ("wan_proto", "pppoe"))
2117	{
2118	if (nvram_match ("pppd_pppifname", ""))
2119	strncpy (localwanface, "ppp0", IFNAMSIZ);
2120	else
2121	strncpy (localwanface, nvram_safe_get ("pppd_pppifname"), IFNAMSIZ);
2122	}
2123	#ifndef HAVE_MADWIFI
2124	else if (getSTA ())
2125	{
2126	strcpy (localwanface, getSTA ());
2127	}
2128	#else
2129	else if (getSTA ())
2130	{
2131	if (nvram_match ("wifi_bonding", "1"))
2132	strcpy (localwanface, "bond0");
2133	else
2134	strcpy (localwanface, getSTA ());
2135	}
2136	#endif
2137	else
2138	strncpy (localwanface, nvram_safe_get ("wan_ifname"), IFNAMSIZ);
2139
2140	return localwanface;
2141	}
2142
2143	int
2144	get_ppp_pid (char *file)
2145	{
2146	char buf[80];
2147	int pid = -1;
2148	if (file_to_buf (file, buf, sizeof (buf)))
2149	{
2150	char tmp[80], tmp1[80];
2151	snprintf (tmp, sizeof (tmp), "/var/run/%s.pid", buf);
2152	file_to_buf (tmp, tmp1, sizeof (tmp1));
2153	pid = atoi (tmp1);
2154	}
2155	return pid;
2156	}
2157
2158	/*
2159	=====================================================================================
2160	by tallest
2161	=====================================================================================
2162	*/
2163
2164
2165	int
2166	check_wan_link (int num)
2167	{
2168	int wan_link = 0;
2169
2170	if (nvram_match ("wan_proto", "pptp")
2171	\|\| nvram_match ("wan_proto", "l2tp")
2172	\|\| nvram_match ("wan_proto", "pppoe")
2173	\|\| nvram_match ("wan_proto", "heartbeat"))
2174	{
2175	FILE *fp;
2176	char filename[80];
2177	char *name;
2178
2179	if (num == 0)
2180	strcpy (filename, "/tmp/ppp/link");
2181	if ((fp = fopen (filename, "r")))
2182	{
2183	int pid = -1;
2184	fclose (fp);
2185	if (nvram_match ("wan_proto", "heartbeat"))
2186	{
2187	char buf[20];
2188	file_to_buf ("/tmp/ppp/link", buf, sizeof (buf));
2189	pid = atoi (buf);
2190	}
2191	else
2192	pid = get_ppp_pid (filename);
2193
2194	name = find_name_by_proc (pid);
2195	if (!strncmp (name, "pppoecd", 7) \|\| // for PPPoE
2196	!strncmp (name, "pppd", 4) \|\| // for PPTP
2197	!strncmp (name, "bpalogin", 8)) // for HeartBeat
2198	wan_link = 1; //connect
2199	else
2200	{
2201	printf ("The %s had been died, remove %s\n",
2202	nvram_safe_get ("wan_proto"), filename);
2203	wan_link = 0; // For some reason, the pppoed had been died, by link file still exist.
2204	unlink (filename);
2205	}
2206	}
2207	}
2208	else
2209	{
2210	if (nvram_invmatch ("wan_ipaddr", "0.0.0.0"))
2211	wan_link = 1;
2212	}
2213
2214	return wan_link;
2215	}
2216
2217	int
2218	get_int_len (int num)
2219	{
2220	char buf[80];
2221
2222	snprintf (buf, sizeof (buf), "%d", num);
2223
2224	return strlen (buf);
2225	}
2226
2227	int
2228	file_to_buf (char path, char buf, int len)
2229	{
2230	FILE *fp;
2231
2232	memset (buf, 0, len);
2233
2234	if ((fp = fopen (path, "r")))
2235	{
2236	fgets (buf, len, fp);
2237	fclose (fp);
2238	return 1;
2239	}
2240
2241	return 0;
2242	}
2243
2244	int
2245	buf_to_file (char path, char buf)
2246	{
2247	FILE *fp;
2248
2249	if ((fp = fopen (path, "w")))
2250	{
2251	fprintf (fp, "%s", buf);
2252	fclose (fp);
2253	return 1;
2254	}
2255
2256	return 0;
2257	}
2258
2259
2260	#define READ_BUF_SIZE 254
2261	/* from busybox find_pid_by_name.c */
2262	pid_t *
2263	find_pid_by_name (char *pidName)
2264	{
2265	DIR *dir;
2266	struct dirent *next;
2267	pid_t *pidList = NULL;
2268	int i = 0;
2269
2270	dir = opendir ("/proc");
2271
2272	while ((next = readdir (dir)) != NULL)
2273	{
2274	FILE *status;
2275	char filename[READ_BUF_SIZE];
2276	char buffer[READ_BUF_SIZE];
2277	char name[READ_BUF_SIZE];
2278
2279	/* Must skip ".." since that is outside /proc */
2280	if (strcmp (next->d_name, "..") == 0)
2281	continue;
2282
2283	/* If it isn't a number, we don't want it */
2284	if (!isdigit (*next->d_name))
2285	continue;
2286
2287	sprintf (filename, "/proc/%s/status", next->d_name);
2288	if (!(status = fopen (filename, "r")))
2289	{
2290	continue;
2291	}
2292	if (fgets (buffer, READ_BUF_SIZE - 1, status) == NULL)
2293	{
2294	fclose (status);
2295	continue;
2296	}
2297	fclose (status);
2298
2299	/* Buffer should contain a string like "Name: binary_name" */
2300	sscanf (buffer, "%*s %s", name);
2301	//printf("buffer=[%s] name=[%s]\n",buffer,name);
2302	if (strcmp (name, pidName) == 0)
2303	{
2304	pidList = realloc (pidList, sizeof (pid_t) * (i + 2));
2305	pidList[i++] = strtol (next->d_name, NULL, 0);
2306	}
2307	}
2308
2309	if (pidList)
2310	pidList[i] = 0;
2311	else
2312	{
2313	pidList = realloc (pidList, sizeof (pid_t));
2314	pidList[0] = -1;
2315	}
2316	return pidList;
2317
2318	}
2319
2320	/* Find first process pid with same name from ps command */
2321	int
2322	find_pid_by_ps (char *pidName)
2323	{
2324	FILE *fp;
2325	int pid = -1;
2326	char line[254];
2327
2328	if ((fp = popen ("ps", "r")))
2329	{
2330	while (fgets (line, sizeof (line), fp) != NULL)
2331	{
2332	if (strstr (line, pidName))
2333	{
2334	sscanf (line, "%d", &pid);
2335	printf ("%s pid is %d\n", pidName, pid);
2336	break;
2337	}
2338	}
2339	pclose (fp);
2340	}
2341
2342	return pid;
2343	}
2344
2345	/* Find process name by pid from /proc directory */
2346	char *
2347	find_name_by_proc (int pid)
2348	{
2349	FILE *fp;
2350	char line[254];
2351	char filename[80];
2352	static char name[80];
2353
2354	snprintf (filename, sizeof (filename), "/proc/%d/status", pid);
2355
2356	if ((fp = fopen (filename, "r")))
2357	{
2358	fgets (line, sizeof (line), fp);
2359	/* Buffer should contain a string like "Name: binary_name" */
2360	sscanf (line, "%*s %s", name);
2361	fclose (fp);
2362	return name;
2363	}
2364
2365	return "";
2366	}
2367
2368	/* Find all process pid with same name from ps command */
2369	int *
2370	find_all_pid_by_ps (char *pidName)
2371	{
2372	FILE *fp;
2373	int pid = -1;
2374	char line[254];
2375	int *pidList = NULL;
2376	int i = 0;
2377	cprintf ("Search for %s\n", pidName);
2378	if ((fp = popen ("ps", "r")))
2379	{
2380	while (fgets (line, sizeof (line), fp) != NULL)
2381	{
2382	if (strstr (line, pidName))
2383	{
2384	sscanf (line, "%d", &pid);
2385	cprintf ("%s pid is %d\n", pidName, pid);
2386	pidList = realloc (pidList, sizeof (int) * (i + 2));
2387	pidList[i++] = pid;
2388	}
2389	}
2390	pclose (fp);
2391	}
2392	if (pidList)
2393	pidList[i] = 0;
2394	else
2395	{
2396	pidList = realloc (pidList, sizeof (int));
2397	pidList[0] = -1;
2398	}
2399	cprintf ("Search done...\n");
2400
2401	return pidList;
2402	}
2403
2404
2405	int
2406	count_processes (char *pidName)
2407	{
2408	FILE *fp;
2409	char line[254];
2410	char safename[64];
2411	sprintf (safename, " %s ", pidName);
2412	char zombie[64];
2413	sprintf (zombie, "Z [%s]", pidName); // do not count zombies
2414	int i = 0;
2415	cprintf ("Search for %s\n", pidName);
2416	if ((fp = popen ("ps", "r")))
2417	{
2418	while (fgets (line, sizeof (line), fp) != NULL)
2419	{
2420	if (strstr (line, safename) && !strstr (line, zombie))
2421	{
2422	i++;
2423	}
2424	}
2425	pclose (fp);
2426	}
2427	cprintf ("Search done... %d\n", i);
2428
2429	return i;
2430	}
2431
2432	void
2433	encode (char *buf, int len)
2434	{
2435	int i;
2436	char ch;
2437
2438	for (i = 0; i < len; i++)
2439	{
2440	ch = (buf[i] & 0x03) << 6;
2441	buf[i] = (buf[i] >> 2);
2442	buf[i] &= 0x3f;
2443	buf[i] \|= ch;
2444	buf[i] = ~buf[i];
2445	}
2446	}
2447
2448	void
2449	decode (char *buf, int len)
2450	{
2451	int i;
2452	char ch;
2453
2454	for (i = 0; i < len; i++)
2455	{
2456	ch = (buf[i] & 0xC0) >> 6;
2457	buf[i] = (buf[i] << 2) \| ch;
2458	buf[i] = ~buf[i];
2459	}
2460	}
2461
2462	/* v1.41.7 => 014107
2463	* v1.2 => 0102
2464	*/
2465	long
2466	convert_ver (char *ver)
2467	{
2468	char buf[10];
2469	int v[3];
2470	int ret;
2471
2472	ret = sscanf (ver, "v%d.%d.%d", &v[0], &v[1], &v[2]);
2473
2474	if (ret == 2)
2475	{
2476	snprintf (buf, sizeof (buf), "%02d%02d", v[0], v[1]);
2477	return atol (buf);
2478	}
2479	else if (ret == 3)
2480	{
2481	snprintf (buf, sizeof (buf), "%02d%02d%02d", v[0], v[1], v[2]);
2482	return atol (buf);
2483	}
2484	else
2485	return -1;
2486	}
2487
2488	/* To avoid user to download old image that is not support intel flash to new hardware with intel flash.
2489	*/
2490	int
2491	check_flash (void)
2492	{
2493	// The V2 image can support intel flash completely, so we don't want to check.
2494	if (check_hw_type () == BCM4712_CHIP)
2495	return FALSE;
2496
2497	// The V1.X some images cann't support intel flash, so we want to avoid user to downgrade.
2498	if (nvram_match ("skip_amd_check", "1"))
2499	{
2500	if (strstr (nvram_safe_get ("flash_type"), "Intel")
2501	&& nvram_invmatch ("skip_intel_check", "1"))
2502	return TRUE;
2503	else
2504	return FALSE;
2505	}
2506	else // Cann't downgrade to old firmware version, no matter AMD or Intel flash
2507	return TRUE;
2508	}
2509
2510	int
2511	check_action (void)
2512	{
2513	char buf[80] = "";
2514
2515	if (file_to_buf (ACTION_FILE, buf, sizeof (buf)))
2516	{
2517	if (!strcmp (buf, "ACT_TFTP_UPGRADE"))
2518	{
2519	fprintf (stderr, "Upgrading from tftp now ...\n");
2520	return ACT_TFTP_UPGRADE;
2521	}
2522	#ifdef HAVE_HTTPS
2523	else if (!strcmp (buf, "ACT_WEBS_UPGRADE"))
2524	{
2525	fprintf (stderr, "Upgrading from web (https) now ...\n");
2526	return ACT_WEBS_UPGRADE;
2527	}
2528	#endif
2529	else if (!strcmp (buf, "ACT_WEB_UPGRADE"))
2530	{
2531	fprintf (stderr, "Upgrading from web (http) now ...\n");
2532	return ACT_WEB_UPGRADE;
2533	}
2534	else if (!strcmp (buf, "ACT_SW_RESTORE"))
2535	{
2536	fprintf (stderr, "Receiving restore command from web ...\n");
2537	return ACT_SW_RESTORE;
2538	}
2539	else if (!strcmp (buf, "ACT_HW_RESTORE"))
2540	{
2541	fprintf (stderr,
2542	"Receiving restore command from resetbutton ...\n");
2543	return ACT_HW_RESTORE;
2544	}
2545	else if (!strcmp (buf, "ACT_NVRAM_COMMIT"))
2546	{
2547	fprintf (stderr, "Committing nvram now ...\n");
2548	return ACT_NVRAM_COMMIT;
2549	}
2550	else if (!strcmp (buf, "ACT_ERASE_NVRAM"))
2551	{
2552	fprintf (stderr, "Erasing nvram now ...\n");
2553	return ACT_ERASE_NVRAM;
2554	}
2555	}
2556	//fprintf(stderr, "Waiting for upgrading....\n");
2557	return ACT_IDLE;
2558	}
2559
2560	int
2561	check_now_boot (void)
2562	{
2563	char *ver = nvram_safe_get ("pmon_ver");
2564	char *cfe = nvram_safe_get ("CFEver");
2565	// for 4712
2566	// The boot_ver value is lower v2.0 (no included)
2567	if (!strncmp (ver, "PMON", 4))
2568	{
2569	cprintf ("The boot is PMON\n");
2570	return PMON_BOOT;
2571	}
2572	// for 4712
2573	// The boot_ver value is higher v2.0 (included)
2574	else if (!strncmp (ver, "CFE", 3))
2575	{
2576	cprintf ("The boot is CFE\n");
2577	return CFE_BOOT;
2578	}
2579	else if (!strncmp (ver, "2", 1))
2580	{
2581	cprintf ("The boot is CFE %s\n", ver);
2582	return CFE_BOOT;
2583	}
2584	else if (!strncmp (cfe, "MotoWR", 6))
2585	{
2586	cprintf ("The boot is Motorola CFE\n");
2587	return CFE_BOOT;
2588	}
2589	else
2590	{
2591	cprintf ("The boot is UNKNOWN\n");
2592	return UNKNOWN_BOOT;
2593	}
2594	}
2595
2596	void
2597	show_hw_type (int type)
2598	{
2599	cprintf ("The chipset is ");
2600	if (type == BCM4702_CHIP)
2601	cprintf ("BCM4702\n");
2602	else if (type == BCM5325E_CHIP)
2603	cprintf ("BCM4712L + BCM5325E\n");
2604	else if (type == BCM5365_CHIP)
2605	cprintf ("BCM5365\n");
2606	else if (type == BCM5350_CHIP)
2607	cprintf ("BCM5350\n");
2608	else if (type == BCM4704_BCM5325F_CHIP)
2609	cprintf ("BCM4704 + BCM5325F\n");
2610	else if (type == BCM5352E_CHIP)
2611	cprintf ("BCM5352E\n");
2612	else if (type == BCM5354G_CHIP)
2613	cprintf ("BCM5354G\n");
2614	else if (type == BCM4712_CHIP)
2615	cprintf ("BCM4712 + ADMtek\n");
2616	else if (type == BCM4704_BCM5325F_EWC_CHIP)
2617	cprintf ("BCM4704 + BCM5325F for EWC\n");
2618	else if (type == BCM4705L_BCM5325E_EWC_CHIP)
2619	cprintf ("BCM4705L + BCM5325E for EWC\n");
2620	else if (type == BCM4705_BCM5397_EWC_CHIP)
2621	cprintf ("BCM4705 + BCM5397 for EWC\n");
2622	else if (type == BCM4705G_BCM5395S_EWC_CHIP)
2623	cprintf ("BCM4705G + BCM5395S for EWC\n");
2624	else if (type == BCM4704_BCM5325F_CHIP)
2625	cprintf ("BCM4704 + BCM5325F\n");
2626	else
2627	cprintf ("not defined\n");
2628
2629	}
2630
2631	int
2632	check_hw_type (void)
2633	{
2634
2635	char *boardtype = nvram_safe_get ("boardtype");
2636	uint boardflags = strtoul (nvram_safe_get ("boardflags"), NULL, 0);
2637	uint btype = strtoul (boardtype, NULL, 0);
2638	char *vlan0 = nvram_safe_get ("vlan0ports");
2639	char *vlan1 = nvram_safe_get ("vlan1ports");
2640
2641	if (!strncmp (boardtype, "bcm94710", 8))
2642	return BCM4702_CHIP;
2643	else if (btype == 0x0708 && !(boardflags & BFL_ENETADM))
2644	return BCM5325E_CHIP;
2645	else if (btype == 0x456 && getRouterBrand () == ROUTER_BELKIN_F5D7231) //stupid Belkin!
2646	return BCM5352E_CHIP;
2647	else if (btype == 0x456)
2648	return BCM5350_CHIP;
2649	else if (!strncmp (boardtype, "bcm95365", 8))
2650	return BCM5365_CHIP;
2651	else if (btype == 0x048e)
2652	return BCM5354G_CHIP;
2653	else if (btype == 0x042f && !(boardflags & BFL_ENETADM))
2654	return BCM4704_BCM5325F_CHIP;
2655	else if (btype == 0x478 && strstr (vlan0, "5")) / WRT300NV1.1 */
2656	return BCM4705L_BCM5325E_EWC_CHIP;
2657	else if ((btype == 0x478 && (strstr (vlan0, "8") \|\| strstr (vlan1, "8"))) \|\| nvram_match ("boot_hw_model", "WRT350N")) /* WRT350N */
2658	return BCM4705_BCM5397_EWC_CHIP;
2659	else if (btype == 0x489 \|\| nvram_match ("boot_hw_model", "WRT310N")) /* WRT310N, temporal boardtype 0x478, wait for braodcom's txt file */
2660	return BCM4705G_BCM5395S_EWC_CHIP;
2661	else if (btype == 0x0467)
2662	return BCM5352E_CHIP;
2663	else if (btype == 0x0101 && !(boardflags & BFL_ENETADM))
2664	return BCM4712_BCM5325E_CHIP;
2665	else if ((btype == 0x0101 \|\| btype == 0x0446) && (boardflags & BFL_ENETADM)) //0x446 is wap54g v2
2666	return BCM4712_CHIP;
2667	else if (btype == 0x0472 && !(boardflags & BFL_ENETADM))
2668	return BCM4704_BCM5325F_EWC_CHIP;
2669	else
2670	return NO_DEFINE_CHIP;
2671	}
2672
2673	int
2674	is_exist (char *filename)
2675	{
2676	FILE *fp;
2677
2678	if ((fp = fopen (filename, "r")))
2679	{
2680	fclose (fp);
2681	return 1;
2682	}
2683	return 0;
2684	}
2685
2686	int
2687	ct_openlog (const char ident, int option, int facility, char log_name)
2688	{
2689	int level = atoi (nvram_safe_get (log_name));
2690
2691	switch (level)
2692	{
2693	case CONSOLE_ONLY:
2694	break;
2695	}
2696	return level;
2697	}
2698
2699
2700	void
2701	ct_syslog (int level, int enable, const char *fmt, ...)
2702	{
2703	char buf[1000];
2704	va_list args;
2705
2706	va_start (args, fmt);
2707	vsnprintf (buf, sizeof (buf), fmt, args);
2708	va_end (args);
2709
2710	switch (enable)
2711	{
2712	case CONSOLE_ONLY:
2713	cprintf ("[%d] %s\n", getpid (), buf); // print to console
2714	break;
2715	}
2716	}
2717
2718	void
2719	ct_logger (int level, const char *fmt, ...)
2720	{
2721	}
2722
2723	void
2724	set_ip_forward (char c)
2725	{
2726	FILE *fp;
2727
2728	if ((fp = fopen ("/proc/sys/net/ipv4/ip_forward", "r+")))
2729	{
2730	fputc (c, fp);
2731	fclose (fp);
2732	}
2733	else
2734	{
2735	perror ("/proc/sys/net/ipv4/ip_forward");
2736	}
2737	}
2738
2739
2740	static char *device_name[] = {
2741	"eth0", "qos0"
2742	};
2743
2744	char *
2745	get_device_name (void)
2746	{
2747	int i;
2748
2749	switch (check_hw_type ())
2750	{
2751	case BCM5325E_CHIP:
2752	case BCM5350_CHIP:
2753	case BCM5365_CHIP:
2754	case BCM4704_BCM5325F_CHIP:
2755	case BCM4704_BCM5325F_EWC_CHIP:
2756	case BCM5352E_CHIP:
2757	case BCM5354G_CHIP:
2758	case BCM4712_BCM5325E_CHIP:
2759	case BCM4705L_BCM5325E_EWC_CHIP:
2760	i = 0;
2761	break;
2762	case BCM4702_CHIP:
2763	case BCM4712_CHIP:
2764	default:
2765	i = 1;
2766	break;
2767	}
2768
2769	return device_name[i];
2770	}
2771
2772	char *
2773	strncpyz (char dest, char const src, size_t size)
2774	{
2775	if (!size--)
2776	return dest;
2777	strncpy (dest, src, size);
2778	dest[size] = 0; /* Make sure the string is null terminated */
2779	return dest;
2780	}
2781
2782	static int
2783	sockets_open (int domain, int type, int protocol)
2784	{
2785	int fd = socket (domain, type, protocol);
2786
2787	if (fd < 0)
2788	cprintf ("sockets_open: no usable address was found.\n");
2789	return fd;
2790	}
2791
2792	int
2793	sys_netdev_ioctl (int family, int socket, char *if_name, int cmd,
2794	struct ifreq *ifr)
2795	{
2796	int rc, s;
2797
2798	if ((s = socket) < 0)
2799	{
2800	if ((s = sockets_open (family, family == AF_PACKET ? SOCK_PACKET :
2801	SOCK_DGRAM,
2802	family == AF_PACKET ? htons (ETH_P_ALL) : 0)) <
2803	0)
2804	{
2805	cprintf ("sys_netdev_ioctl: failed\n");
2806	return -1;
2807	}
2808	}
2809	strncpyz (ifr->ifr_name, if_name, IFNAMSIZ);
2810	rc = ioctl (s, cmd, ifr);
2811	if (socket < 0)
2812	close (s);
2813	return rc;
2814	}
2815
2816	int
2817	set_register_value (unsigned short port_addr, unsigned short option_content)
2818	{
2819	struct ifreq ifr;
2820	struct mii_ioctl_data stats;
2821
2822	stats.phy_id = port_addr;
2823	stats.val_in = option_content;
2824
2825	ifr.ifr_data = (void *) &stats;
2826
2827	if (sys_netdev_ioctl (AF_INET, -1, get_device_name (), SIOCSMIIREG, &ifr) <
2828	0)
2829	return -1;
2830
2831	return 0;
2832	}
2833
2834	unsigned long
2835	get_register_value (unsigned short id, unsigned short num)
2836	{
2837	struct ifreq ifr;
2838	struct mii_ioctl_data stats;
2839
2840	stats.phy_id = id;
2841	stats.reg_num = num;
2842	stats.val_in = 0;
2843	stats.val_out = 0;
2844
2845	ifr.ifr_data = (void *) &stats;
2846
2847	sys_netdev_ioctl (AF_INET, -1, get_device_name (), SIOCGMIIREG, &ifr);
2848
2849	return ((stats.val_in << 16) \| stats.val_out);
2850	}
2851
2852
2853	struct wl_assoc_mac *
2854	get_wl_assoc_mac (int *c)
2855	{
2856	FILE *fp;
2857	struct wl_assoc_mac *wlmac = NULL;
2858	int count;
2859	char line[80];
2860	char list[2][20];
2861
2862	wlmac = NULL;
2863	count = *c = 0;
2864
2865	#ifdef HAVE_MSSID
2866	char assoccmd[4][32] = {
2867	"wl assoclist", "wl -i wl0.1 assoclist", "wl -i wl0.2 assoclist",
2868	"wl -i wl0.3 assoclist"
2869	};
2870	int ifcnt = 4;
2871	#else
2872	char assoccmd[1][16] = {
2873	"wl assoclist"
2874	};
2875	int ifcnt = 1;
2876	#endif
2877	int i;
2878	int gotit = 0;
2879	// fprintf(stderr,"assoclist\n");
2880
2881	for (i = 0; i < ifcnt; i++)
2882	{
2883	if (i)
2884	{
2885	char checkif[12];
2886	sprintf (checkif, "wl0.%d", i);
2887	if (!ifexists (checkif))
2888	break;
2889	}
2890	if ((fp = popen (assoccmd[i], "r")))
2891	{
2892	gotit = 1;
2893	while (fgets (line, sizeof (line), fp) != NULL)
2894	{
2895	strcpy (list[0], "");
2896	strcpy (list[1], "");
2897
2898	if (sscanf (line, "%s %s", list[0], list[1]) != 2) // assoclist 00:11:22:33:44:55
2899	continue;
2900	if (strcmp (list[0], "assoclist"))
2901	continue;
2902
2903	wlmac =
2904	realloc (wlmac, sizeof (struct wl_assoc_mac) * (count + 1));
2905
2906	memset (&wlmac[count], 0, sizeof (struct wl_assoc_mac));
2907	strncpy (wlmac[count].mac, list[1], sizeof (wlmac[0].mac));
2908	count++;
2909	}
2910
2911	pclose (fp);
2912	}
2913	}
2914
2915	if (gotit)
2916	{
2917	//cprintf("Count of wl assoclist mac is %d\n", count);
2918	*c = count;
2919	return wlmac;
2920	}
2921	else
2922	return NULL;
2923	}
2924
2925	struct mtu_lists mtu_list[] = {
2926	#ifdef BUFFALO_JP
2927	{
2928	"pppoe", "576", "1454"},
2929	#else
2930	{
2931	"pppoe", "576", "1492"},
2932	#endif
2933	{
2934	"pptp", "576", "1460"},
2935	{
2936	"l2tp", "576", "1460"},
2937	{
2938	"dhcp", "576", "1500"},
2939	{
2940	"static", "576", "1500"},
2941	{
2942	"heartbeat", "576", "1500"},
2943	{
2944	"default", "576", "1500"}, // The value must be at last
2945	};
2946
2947	struct mtu_lists *
2948	get_mtu (char *proto)
2949	{
2950	struct mtu_lists *v = NULL;
2951
2952	for (v = mtu_list; v < &mtu_list[STRUCT_LEN (mtu_list)]; v++)
2953	{
2954	if (!strcmp (proto, v->proto))
2955	return v;
2956	}
2957	return v; // Use default settings
2958	}
2959
2960	void
2961	set_host_domain_name (void)
2962	{
2963	char *wan_hostname = nvram_safe_get ("wan_hostname");
2964	char *wan_domain = nvram_safe_get ("wan_domain");
2965
2966	/* Allow you to use gethostname to get Host Name */
2967	/* If wan_hostname is blank then we do nothing, we leave to what it was set at boot */
2968	if (strlen (wan_hostname) > 0)
2969	sethostname (wan_hostname, strlen (wan_hostname));
2970
2971	/* Allow you to use getdomainname to get Domain Name */
2972	if (strlen (wan_domain) > 0 && strlen (wan_domain) <= 64) //no more than 64
2973	setdomainname (wan_domain, strlen (wan_domain));
2974	else
2975	{
2976	char *wan_get_domain = nvram_safe_get ("wan_get_domain");
2977	setdomainname (wan_get_domain, strlen (wan_get_domain));
2978	}
2979	}
2980
2981	int
2982	first_time (void)
2983	{
2984	struct sysinfo info;
2985
2986	sysinfo (&info);
2987	if (info.uptime < 20L)
2988	return 1;
2989	return 0;
2990	}
2991
2992	int
2993	check_vlan_support (void)
2994	{
2995	#if defined(HAVE_GEMTEK) \|\| defined(HAVE_RB500) \|\| defined(HAVE_XSCALE) \|\| defined(HAVE_MAGICBOX) \|\| defined(HAVE_FONERA) \|\| defined(HAVE_MERAKI) \|\| defined(HAVE_LS2) \|\| defined(HAVE_WHRAG108) \|\| defined(HAVE_X86) \|\| defined(HAVE_CA8) \|\| defined(HAVE_TW6600) \|\| defined(HAVE_PB42) \|\| defined(HAVE_LS5) \|\| defined(HAVE_LSX)
2996	return 0;
2997	#else
2998
2999
3000	int brand = getRouterBrand ();
3001	switch (brand)
3002	{
3003	#ifndef HAVE_BUFFALO
3004	case ROUTER_ASUS_WL500GD:
3005	return 1;
3006	break;
3007	#endif
3008	case ROUTER_BUFFALO_WLAG54C:
3009	case ROUTER_BUFFALO_WLA2G54C:
3010	#ifndef HAVE_BUFFALO
3011	case ROUTER_LINKSYS_WRT55AG:
3012	case ROUTER_MOTOROLA_V1:
3013	case ROUTER_MOTOROLA_WE800G:
3014	case ROUTER_WAP54G_V1:
3015	case ROUTER_SITECOM_WL105B:
3016	case ROUTER_SITECOM_WL111:
3017	case ROUTER_BUFFALO_WLI2_TX1_G54:
3018	case ROUTER_BUFFALO_WLI_TX4_G54HP:
3019	case ROUTER_BRCM4702_GENERIC:
3020	case ROUTER_ASUS_WL500G:
3021	case ROUTER_BELKIN_F5D7230_V2000:
3022	#endif
3023	return 0;
3024	break;
3025	}
3026
3027	uint boardflags = strtoul (nvram_safe_get ("boardflags"), NULL, 0);
3028	if (boardflags & BFL_ENETVLAN)
3029	return 1;
3030
3031	if (nvram_match ("boardtype", "bcm94710dev")
3032	\|\| nvram_match ("boardtype", "0x0101") \|\| (boardflags & 0x0100))
3033	return 1;
3034	else
3035	return 0;
3036	#endif
3037	}
3038
3039	#ifdef CDEBUG
3040	int
3041	coreleft (void)
3042	{
3043	struct sysinfo info;
3044	sysinfo (&info);
3045	return info.freeram;
3046	}
3047
3048	int
3049	mcoreleft (void)
3050	{
3051	struct mallinfo minfo;
3052	minfo = mallinfo ();
3053	return minfo.uordblks;
3054	//int uordblks; /* total allocated space */
3055
3056	}
3057	#endif
3058
3059	#define sin_addr(s) (((struct sockaddr_in *)(s))->sin_addr)
3060
3061	//#define WDS_DEBUG 1
3062	#undef WDS_DEBUG
3063	#ifdef WDS_DEBUG
3064	FILE *fp;
3065	#endif
3066
3067
3068	int
3069	wds_dev_config (int dev, int up)
3070	{
3071	char wds_var[32] = "";
3072	char wds_enable_var[32] = "";
3073	char wds_dev[32] = "";
3074	char wds = (void ) 0;
3075	char wds_gw_var[32] = "";
3076	char gw = (void ) 0;
3077	int s = -1;
3078	struct ifreq ifr;
3079
3080	#ifdef WDS_DEBUG
3081	fp = fopen ("/tmp/.wds_debug.log", "a");
3082	#endif
3083
3084	memset (&ifr, 0, sizeof (struct ifreq));
3085
3086	snprintf (wds_var, 31, "wl_wds%d", dev);
3087	snprintf (wds_enable_var, 31, "%s_enable", wds_var);
3088
3089	if ((wds = nvram_safe_get (wds_enable_var)) == NULL \|\|
3090	strcmp (wds, "0") == 0)
3091	return -1;
3092	#ifdef HAVE_MSSID
3093	snprintf (wds_dev, 31, "wds0.%d", dev + 1);
3094	#else
3095	snprintf (wds_dev, 31, "wds0.491%d", 50 + dev + 1);
3096	#endif
3097	snprintf (ifr.ifr_name, IFNAMSIZ, wds_dev);
3098	#ifdef WDS_DEBUG
3099	fprintf (fp, "opening kernelsocket\n");
3100	#endif
3101	if ((s = socket (AF_INET, SOCK_RAW, IPPROTO_RAW)) < 0)
3102	return -1;
3103
3104	if (up)
3105	{
3106	char wds_hwaddr_var[32] = "";
3107	char wds_ip_var[32] = "";
3108	char wds_netmask_var[32] = "";
3109	char wds_list = (void ) 0;
3110	char hwaddr = (void ) 0;
3111	char ip = (void ) 0;
3112	char netmask = (void ) 0;
3113
3114	#ifdef WDS_DEBUG
3115	fprintf (fp, "running up\n");
3116	#endif
3117
3118	wds_list = nvram_safe_get ("wl0_wds");
3119	if (wds_list == (void *) 0 \|\| strlen (wds_list) <= 0)
3120	return 0;
3121
3122	snprintf (wds_hwaddr_var, 31, "%s_hwaddr", wds_var);
3123	snprintf (wds_ip_var, 31, "%s_ipaddr", wds_var);
3124	snprintf (wds_netmask_var, 31, "%s_netmask", wds_var);
3125
3126	hwaddr = nvram_safe_get (wds_hwaddr_var);
3127	ip = nvram_safe_get (wds_ip_var);
3128	netmask = nvram_safe_get (wds_netmask_var);
3129
3130	if (!strstr (wds_list, hwaddr))
3131	{
3132	close (s);
3133	return -1;
3134	}
3135
3136	#ifdef WDS_DEBUG
3137	fprintf (fp, "checking validity\n");
3138	#endif
3139
3140	if (!sv_valid_hwaddr (hwaddr) \|\| !sv_valid_ipaddr (ip)
3141	\|\| !sv_valid_ipaddr (netmask))
3142	{
3143	close (s);
3144	return -1;
3145	}
3146
3147	#ifdef WDS_DEBUG
3148	fprintf (fp, "valid mac %s ip %s nm %s\n", hwaddr, ip, netmask);
3149	#endif
3150
3151	sysprintf ("ifconfig %s down", wds_dev);
3152
3153	sysprintf ("ifconfig %s %s netmask %s up", wds_dev, ip, netmask);
3154
3155	snprintf (wds_gw_var, 31, "%s_gw", wds_var);
3156	gw = nvram_safe_get (wds_gw_var);
3157	if (strcmp (gw, "0.0.0.0") != 0)
3158	{
3159	get_network (ip, netmask);
3160	route_del (wds_dev, 0, ip, gw, netmask);
3161	route_add (wds_dev, 0, ip, gw, netmask);
3162	}
3163
3164	}
3165	else
3166	{
3167	#ifdef WDS_DEBUG
3168	fprintf (fp, "running down\n");
3169	#endif
3170	sysprintf ("ifconfig %s down", wds_dev);
3171
3172	}
3173
3174	#ifdef WDS_DEBUG
3175	fprintf (fp, "running ioctl\n");
3176	fclose (fp);
3177	#endif
3178
3179	close (s);
3180
3181	return 0;
3182	}
3183
3184
3185	int
3186	ishexit (char c)
3187	{
3188
3189	if (strchr ("01234567890abcdefABCDEF", c) != (char *) 0)
3190	return 1;
3191
3192	return 0;
3193	}
3194
3195
3196	/* Example:
3197	* legal_hwaddr("00:11:22:33:44:aB"); return true;
3198	* legal_hwaddr("00:11:22:33:44:5"); return false;
3199	* legal_hwaddr("00:11:22:33:44:HH"); return false;
3200	*/
3201	int
3202	sv_valid_hwaddr (char *value)
3203	{
3204	unsigned int hwaddr[6];
3205	int tag = TRUE;
3206	int i, count;
3207
3208	/* Check for bad, multicast, broadcast, or null address */
3209	for (i = 0, count = 0; *(value + i); i++)
3210	{
3211	if (*(value + i) == ':')
3212	{
3213	if ((i + 1) % 3 != 0)
3214	{
3215	tag = FALSE;
3216	break;
3217	}
3218	count++;
3219	}
3220	else if (ishexit ((value + i))) / one of 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F */
3221	continue;
3222	else
3223	{
3224	tag = FALSE;
3225	break;
3226	}
3227	}
3228
3229	if (!tag \|\| i != 17 \|\| count != 5) /* must have 17's characters and 5's ':' */
3230	tag = FALSE;
3231	else if (sscanf (value, "%x:%x:%x:%x:%x:%x",
3232	&hwaddr[0], &hwaddr[1], &hwaddr[2],
3233	&hwaddr[3], &hwaddr[4], &hwaddr[5]) != 6)
3234	{
3235	tag = FALSE;
3236	}
3237	else
3238	tag = TRUE;
3239	#ifdef WDS_DEBUG
3240	if (tag == FALSE)
3241	fprintf (fp, "failed valid_hwaddr\n");
3242	#endif
3243
3244	return tag;
3245	}
3246
3247
3248	int
3249	sv_valid_range (char *value, int low, int high)
3250	{
3251	if (!isdigit (value[0]) \|\| atoi (value) < low \|\| atoi (value) > high)
3252	return FALSE;
3253	else
3254	return TRUE;
3255
3256	}
3257
3258	int
3259	sv_valid_statics (char *value)
3260	{
3261	char ip[16] = {
3262	0
3263	}, mac[18] =
3264	{
3265	0}, hostname[255] =
3266	{
3267	0}, *p = value;
3268
3269	if (NULL == value)
3270	return FALSE;
3271
3272	do
3273	{
3274	while (isspace (*p++) && p - value < strlen (value))
3275	;
3276
3277	if (p - value >= strlen (value))
3278	return FALSE;
3279
3280	if (sscanf (p, "%15s%17s%254s", ip, mac, hostname) < 3)
3281	return FALSE;
3282
3283	if (!sv_valid_ipaddr (ip) \|\| !sv_valid_hwaddr (mac)
3284	\|\| strlen (hostname) <= 0)
3285	return FALSE;
3286
3287	}
3288	while ((p = strpbrk (p, "\n\r")) && p - value < strlen (value));
3289
3290	return TRUE;
3291	}
3292
3293	/* Example:
3294	* legal_ipaddr("192.168.1.1"); return true;
3295	* legal_ipaddr("192.168.1.1111"); return false;
3296	*/
3297	int
3298	sv_valid_ipaddr (char *value)
3299	{
3300	struct in_addr ipaddr;
3301	int ip[4], ret = 0;
3302
3303	ret = sscanf (value, "%d.%d.%d.%d", &ip[0], &ip[1], &ip[2], &ip[3]);
3304
3305	if (ret != 4 \|\| !inet_aton (value, &ipaddr))
3306	return FALSE;
3307	else
3308	return TRUE;
3309
3310	}
3311
3312	// note - network address returned in ipaddr
3313	void
3314	get_network (char ipaddr, char netmask)
3315	{
3316	int ip[4], mask[4];
3317
3318	if (!ipaddr \|\| !netmask)
3319	return;
3320
3321	sscanf (ipaddr, "%d.%d.%d.%d", &ip[0], &ip[1], &ip[2], &ip[3]);
3322	sscanf (netmask, "%d.%d.%d.%d", &mask[0], &mask[1], &mask[2], &mask[3]);
3323
3324	ip[0] &= mask[0];
3325	ip[1] &= mask[1];
3326	ip[2] &= mask[2];
3327	ip[3] &= mask[3];
3328
3329	sprintf (ipaddr, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
3330	#ifdef WDS_DEBUG
3331	fprintf (fp, "get_network return %s\n", ipaddr);
3332	#endif
3333
3334	}
3335
3336	// note - broadcast addr returned in ipaddr
3337	void
3338	get_broadcast (char ipaddr, char netmask)
3339	{
3340	int ip2[4], mask2[4];
3341	unsigned char ip[4], mask[4];
3342	if (!ipaddr \|\| !netmask)
3343	return;
3344
3345	sscanf (ipaddr, "%d.%d.%d.%d", &ip2[0], &ip2[1], &ip2[2], &ip2[3]);
3346	sscanf (netmask, "%d.%d.%d.%d", &mask2[0], &mask2[1], &mask2[2], &mask2[3]);
3347	int i = 0;
3348	for (i = 0; i < 4; i++)
3349	{
3350	ip[i] = ip2[i];
3351	mask[i] = mask2[i];
3352	// ip[i] = (ip[i] & mask[i]) \| !mask[i];
3353	ip[i] = (ip[i] & mask[i]) \| (0xff & ~mask[i]);
3354	}
3355
3356	sprintf (ipaddr, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
3357	#ifdef WDS_DEBUG
3358	fprintf (fp, "get_broadcast return %s\n", value);
3359	#endif
3360
3361	}
3362
3363	/* note: copied from Broadcom code and put in shared via this file */
3364
3365	int
3366	route_manip (int cmd, char name, int metric, char dst, char *gateway,
3367	char *genmask)
3368	{
3369	int s;
3370	struct rtentry rt;
3371
3372	//dprintf("cmd=[%d] name=[%s] ipaddr=[%s] netmask=[%s] gateway=[%s] metric=[%d]\n",cmd,name,dst,genmask,gateway,metric);
3373
3374	/* Open a raw socket to the kernel */
3375	if ((s = socket (AF_INET, SOCK_DGRAM, 0)) < 0)
3376	goto err;
3377
3378	/* Fill in rtentry */
3379	memset (&rt, 0, sizeof (rt));
3380	if (dst)
3381	inet_aton (dst, &sin_addr (&rt.rt_dst));
3382	if (gateway)
3383	inet_aton (gateway, &sin_addr (&rt.rt_gateway));
3384	if (genmask)
3385	inet_aton (genmask, &sin_addr (&rt.rt_genmask));
3386	rt.rt_metric = metric;
3387	rt.rt_flags = RTF_UP;
3388	if (sin_addr (&rt.rt_gateway).s_addr)
3389	rt.rt_flags \|= RTF_GATEWAY;
3390	if (sin_addr (&rt.rt_genmask).s_addr == INADDR_BROADCAST)
3391	rt.rt_flags \|= RTF_HOST;
3392	rt.rt_dev = name;
3393
3394	/* Force address family to AF_INET */
3395	rt.rt_dst.sa_family = AF_INET;
3396	rt.rt_gateway.sa_family = AF_INET;
3397	rt.rt_genmask.sa_family = AF_INET;
3398
3399	if (ioctl (s, cmd, &rt) < 0)
3400	goto err;
3401
3402	close (s);
3403	return 0;
3404
3405	err:close (s);
3406	perror (name);
3407	return errno;
3408	}
3409
3410	int
3411	route_add (char name, int metric, char dst, char gateway, char genmask)
3412	{
3413	return route_manip (SIOCADDRT, name, metric, dst, gateway, genmask);
3414	}
3415
3416	int
3417	route_del (char name, int metric, char dst, char gateway, char genmask)
3418	{
3419	return route_manip (SIOCDELRT, name, metric, dst, gateway, genmask);
3420	}
3421
3422	//#endif
3423
3424
3425	#ifdef HAVE_MADWIFI
3426	static char *stalist[] = {
3427	"ath0", "ath1", "ath2", "ath3", "ath4", "ath5", "ath6", "ath8", "ath9"
3428	};
3429	char *
3430	getSTA (void)
3431	{
3432
3433	#ifdef HAVE_WAVESAT
3434	if (nvram_match ("ofdm_mode", "sta"))
3435	return "ofdm";
3436	#endif
3437	int c = getifcount ("wifi");
3438	int i;
3439	for (i = 0; i < c; i++)
3440	{
3441	char mode[32];
3442	char netmode[32];
3443	sprintf (mode, "ath%d_mode", i);
3444	sprintf (netmode, "ath%d_net_mode", i);
3445	if (nvram_match (mode, "sta") && !nvram_match (netmode, "disabled"))
3446	{
3447	return stalist[i];
3448	}
3449
3450	}
3451	return NULL;
3452	}
3453
3454	char *
3455	getWET (void)
3456	{
3457	#ifdef HAVE_WAVESAT
3458	if (nvram_match ("ofdm_mode", "bridge"))
3459	return "ofdm";
3460	#endif
3461	int c = getifcount ("wifi");
3462	int i;
3463	for (i = 0; i < c; i++)
3464	{
3465	char mode[32];
3466	char netmode[32];
3467	sprintf (mode, "ath%d_mode", i);
3468	sprintf (netmode, "ath%d_net_mode", i);
3469	if (nvram_match (mode, "wet") && !nvram_match (netmode, "disabled"))
3470	{
3471	return stalist[i];
3472	}
3473
3474	}
3475	return NULL;
3476	}
3477	#else
3478	char *
3479	getSTA ()
3480	{
3481	int c = get_wl_instances ();
3482	int i;
3483	for (i = 0; i < c; i++)
3484	{
3485	if (nvram_nmatch ("sta", "wl%d_mode", i)
3486	\|\| nvram_nmatch ("apsta", "wl%d_mode", i))
3487	{
3488	if (!nvram_nmatch ("disabled", "wl%d_net_mode", i))
3489	return get_wl_instance_name (i);
3490	// else
3491	// return nvram_nget ("wl%d_ifname", i);
3492	}
3493
3494	}
3495	return NULL;
3496	}
3497
3498	char *
3499	getWET ()
3500	{
3501	int c = get_wl_instances ();
3502	int i;
3503	for (i = 0; i < c; i++)
3504	{
3505	if (nvram_nmatch ("wet", "wl%d_mode", i)
3506	\|\| nvram_nmatch ("apstawet", "wl%d_mode", i))
3507	{
3508	if (!nvram_nmatch ("disabled", "wl%d_net_mode", i))
3509	return get_wl_instance_name (i);
3510	// else
3511	// return nvram_nget ("wl%d_ifname", i);
3512
3513	}
3514
3515	}
3516	return NULL;
3517	}
3518
3519
3520	#endif
3521
3522
3523	int
3524	ifexists (const char *ifname)
3525	{
3526	return getifcount (ifname) > 0 ? 1 : 0;
3527	}
3528
3529	int
3530	getifcount (const char *ifprefix)
3531	{
3532	/* char devcall[128];
3533
3534	sprintf (devcall, "cat /proc/net/dev\|grep \"%s\"\|wc -l", ifprefix);
3535	FILE *in = popen (devcall, "rb");
3536	if (in == NULL)
3537	return 0;
3538	int count;
3539	fscanf (in, "%d", &count);
3540	pclose (in);
3541	return count;*/
3542	char *iflist = malloc (256);
3543	memset (iflist, 0, 256);
3544	int c = getIfList (iflist, ifprefix);
3545	free (iflist);
3546	return c;
3547	}
3548
3549	static void
3550	skipline (FILE * in)
3551	{
3552	while (1)
3553	{
3554	int c = getc (in);
3555	if (c == EOF)
3556	return;
3557	if (c == 0x0)
3558	return;
3559	if (c == 0xa)
3560	return;
3561	}
3562	}
3563
3564	//returns a physical interfacelist filtered by ifprefix. if ifprefix is NULL, all valid interfaces will be returned
3565	int
3566	getIfList (char buffer, const char ifprefix)
3567	{
3568	FILE *in = fopen ("/proc/net/dev", "rb");
3569	char ifname[32];
3570	//skip the first 2 lines
3571	skipline (in);
3572	skipline (in);
3573	int ifcount = 0;
3574	int count = 0;
3575	while (1)
3576	{
3577	int c = getc (in);
3578	if (c == EOF)
3579	{
3580	if (count)
3581	buffer[strlen (buffer) - 1] = 0; //fixup last space
3582	fclose (in);
3583	return count;
3584	}
3585	if (c == 0)
3586	{
3587	if (count)
3588	buffer[strlen (buffer) - 1] = 0; //fixup last space
3589	fclose (in);
3590	return count;
3591	}
3592	if (c == 0x20)
3593	continue;
3594	if (c == ':' \|\| ifcount == 30)
3595	{
3596	ifname[ifcount++] = 0;
3597	int skip = 0;
3598	if (ifprefix)
3599	{
3600	if (strncmp (ifname, ifprefix, strlen (ifprefix)))
3601	{
3602	skip = 1;
3603	}
3604	}
3605	else
3606	{
3607	if (!strncmp (ifname, "wifi", 4))
3608	skip = 1;
3609	if (!strncmp (ifname, "imq", 3))
3610	skip = 1;
3611	if (!strncmp (ifname, "lo", 2))
3612	skip = 1;
3613	if (!strncmp (ifname, "teql", 4))
3614	skip = 1;
3615	if (!strncmp (ifname, "gre", 3))
3616	skip = 1;
3617	if (!strncmp (ifname, "ppp", 3))
3618	skip = 1;
3619	if (!strncmp (ifname, "tun", 3))
3620	skip = 1;
3621	if (!strncmp (ifname, "tap", 3))
3622	skip = 1;
3623	}
3624	if (!skip)
3625	{
3626	strcat (buffer, ifname);
3627	strcat (buffer, " ");
3628	count++;
3629	}
3630	skip = 0;
3631	ifcount = 0;
3632	memset (ifname, 0, 32);
3633	skipline (in);
3634	continue;
3635	}
3636	if (ifcount < 30)
3637	ifname[ifcount++] = c;
3638	}
3639	}
3640	void
3641	getIfLists (char *eths, int size)
3642	{
3643	char eths2[256];
3644	memset (eths, 0, size);
3645	memset (eths2, 0, 256);
3646	#ifdef HAVE_XSCALE
3647	getIfList (eths, "ixp");
3648	getIfList (eths2, "eth");
3649	sprintf (eths, "%s %s", eths, eths2);
3650	#else
3651	getIfList (eths, "eth");
3652	#endif
3653	memset (eths2, 0, 256);
3654	getIfList (eths2, "vlan");
3655	sprintf (eths, "%s %s", eths, eths2);
3656	#ifdef HAVE_MADWIFI
3657	memset (eths2, 0, 256);
3658	getIfList (eths2, "ath");
3659	sprintf (eths, "%s %s", eths, eths2);
3660	#else
3661	memset (eths2, 0, 256);
3662	getIfList (eths2, "wl");
3663	sprintf (eths, "%s %s", eths, eths2);
3664	#endif
3665	#ifdef HAVE_WAVESAT
3666	memset (eths2, 0, 256);
3667	getIfList (eths2, "ofdm");
3668	sprintf (eths, "%s %s", eths, eths2);
3669	#endif
3670
3671	}
3672
3673	int
3674	contains (const char *string, char value)
3675	{
3676	if (string == NULL)
3677	return 0;
3678	int len = strlen (string);
3679	int i;
3680	for (i = 0; i < len; i++)
3681	{
3682	if (string[i] == value)
3683	return 1;
3684	}
3685	return 0;
3686	}
3687
3688	int
3689	haswifi (void)
3690	{
3691	#ifdef HAVE_NOWIFI
3692	return 0;
3693	#elif HAVE_MADWIFI
3694	return getifcount ("wifi") > 0 ? 1 : 0;
3695	#else
3696	return 1;
3697	#endif
3698	}
3699
3700	static uint32_t
3701	str_to_addr (const char *addr)
3702	{
3703	uint32_t split[4];
3704	uint32_t ip;
3705
3706	sscanf (addr, "%d.%d.%d.%d", &split[0], &split[1], &split[2], &split[3]);
3707
3708	ip = (split[0] << 24) \| (split[1] << 16) \| (split[2] << 8) \| (split[3]);
3709
3710	return htonl (ip);
3711	}
3712
3713	void
3714	getHostName (char buf, char ip)
3715	{
3716	struct hostent *host;
3717	struct in_addr addr;
3718	res_init ();
3719	addr.s_addr = str_to_addr (ip);
3720	host = gethostbyaddr ((char *) &addr, 4, AF_INET);
3721	if (!host \|\| !host->h_name)
3722	strcpy (buf, "unknown");
3723	else
3724	strcpy (buf, host->h_name);
3725	}
3726
3727	void
3728	getinterfacelist (const char ifprefix, char buffer)
3729	{
3730	int count = getifcount (ifprefix);
3731	int i;
3732	for (i = 0; i < count; i++)
3733	{
3734	char ifname[32];
3735	sprintf (ifname, "%s%d", ifprefix, i);
3736	strcat (buffer, ifname);
3737	if (i < count - 1)
3738	strcat (buffer, " ");
3739	}
3740	}
3741
3742	/*
3743	* the following code was taken from:
3744	*
3745	* Copyright (C) 2006 Jonathan Zarate
3746	*
3747	* Licensed under GNU GPL v2 or later.
3748	*/
3749
3750	int
3751	f_exists (const char *path) // note: anything but a directory
3752	{
3753	struct stat st;
3754	return (stat (path, &st) == 0) && (!S_ISDIR (st.st_mode));
3755	}
3756
3757	int
3758	f_read (const char path, void buffer, int max)
3759	{
3760	int f;
3761	int n;
3762
3763	if ((f = open (path, O_RDONLY)) < 0)
3764	return -1;
3765	n = read (f, buffer, max);
3766	close (f);
3767	return n;
3768	}
3769
3770
3771	int
3772	f_read_string (const char path, char buffer, int max)
3773	{
3774	if (max <= 0)
3775	return -1;
3776	int n = f_read (path, buffer, max - 1);
3777	buffer[(n > 0) ? n : 0] = 0;
3778	return n;
3779	}
3780
3781
3782	int
3783	wait_file_exists (const char *name, int max, int invert)
3784	{
3785	while (max-- > 0)
3786	{
3787	if (f_exists (name) ^ invert)
3788	return 1;
3789	sleep (1);
3790	}
3791	return 0;
3792	}
3793
3794	char *
3795	psname (int pid, char *buffer, int maxlen)
3796	{
3797	char buf[512];
3798	char path[64];
3799	char *p;
3800
3801	if (maxlen <= 0)
3802	return NULL;
3803	*buffer = 0;
3804	sprintf (path, "/proc/%d/stat", pid);
3805	if ((f_read_string (path, buf, sizeof (buf)) > 4)
3806	&& ((p = strrchr (buf, ')')) != NULL))
3807	{
3808	*p = 0;
3809	if (((p = strchr (buf, '(')) != NULL) && (atoi (buf) == pid))
3810	{
3811	strlcpy (buffer, p + 1, maxlen);
3812	}
3813	}
3814	return buffer;
3815	}
3816
3817	static int
3818	_pidof (const char name, pid_t * pids)
3819	{
3820	const char *p;
3821	char *e;
3822	DIR *dir;
3823	struct dirent *de;
3824	pid_t i;
3825	int count;
3826	char buf[256];
3827
3828	count = 0;
3829	*pids = NULL;
3830	if ((p = strchr (name, '/')) != NULL)
3831	name = p + 1;
3832	if ((dir = opendir ("/proc")) != NULL)
3833	{
3834	while ((de = readdir (dir)) != NULL)
3835	{
3836	i = strtol (de->d_name, &e, 10);
3837	if (*e != 0)
3838	continue;
3839	if (strcmp (name, psname (i, buf, sizeof (buf))) == 0)
3840	{
3841	if ((*pids =
3842	realloc (pids, sizeof (pid_t) (count + 1))) == NULL)
3843	{
3844	return -1;
3845	}
3846	(*pids)[count++] = i;
3847	}
3848	}
3849	}
3850	closedir (dir);
3851	return count;
3852	}
3853
3854	int
3855	pidof (const char *name)
3856	{
3857	pid_t *pids;
3858	pid_t p;
3859
3860	if (_pidof (name, &pids) > 0)
3861	{
3862	p = *pids;
3863	free (pids);
3864	return p;
3865	}
3866	return -1;
3867	}
3868
3869	int
3870	killall (const char *name, int sig)
3871	{
3872	pid_t *pids;
3873	int i;
3874	int r;
3875
3876	if ((i = _pidof (name, &pids)) > 0)
3877	{
3878	r = 0;
3879	do
3880	{
3881	r \|= kill (pids[--i], sig);
3882	}
3883	while (i > 0);
3884	free (pids);
3885	return r;
3886	}
3887	return -2;
3888	}
3889
3890	int
3891	isGrep (char string, char cmp)
3892	{
3893	char devcall[128];
3894	int res;
3895	sprintf (devcall, "%s\|grep \"%s\"\|/bin/wc -l", string, cmp);
3896	//system(devcall);
3897	FILE *in = popen (devcall, "rb");
3898	fscanf (in, "%d", &res);
3899	pclose (in);
3900	return res > 0 ? 1 : 0;
3901
3902	}
3903
3904	int
3905	softkill (char *name)
3906	{
3907	killall (name, SIGKILL);
3908	return 0;
3909	}
3910	static void
3911	to64 (char *s, long v, int n)
3912	{
3913
3914	unsigned char itoa64[] =
3915	"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
3916
3917	while (--n >= 0)
3918	{
3919	*s++ = itoa64[v & 0x3f];
3920	v >>= 6;
3921	}
3922	}
3923
3924	char *
3925	zencrypt (char *passwd)
3926	{
3927	char salt[6];
3928	struct timeval tv;
3929	char crypt (const char , const char *);
3930
3931	gettimeofday (&tv, 0);
3932
3933	to64 (&salt[0], random (), 3);
3934	to64 (&salt[3], tv.tv_usec, 3);
3935	salt[5] = '\0';
3936
3937	return crypt (passwd, salt);
3938	}
3939
3940	void
3941	getLANMac (char *newmac)
3942	{
3943	strcpy (newmac, nvram_safe_get ("et0macaddr"));
3944	#ifndef HAVE_BUFFALO
3945
3946	if (nvram_match ("port_swap", "1"))
3947	{
3948	if (strlen (nvram_safe_get ("et1macaddr")) != 0) //safe: maybe et1macaddr not there?
3949	{
3950	strcpy (newmac, nvram_safe_get ("et1macaddr"));
3951	}
3952	else
3953	{
3954	MAC_ADD (newmac); //et0macaddr +1
3955	}
3956	}
3957	#endif
3958	return;
3959	}
3960
3961	void
3962	getWirelessMac (char *newmac)
3963	{
3964	#ifdef HAVE_BUFFALO
3965	strcpy (newmac, nvram_safe_get ("il0macaddr"));
3966	#else
3967	// if (strlen(nvram_safe_get ("il0macaddr")) != 0)
3968	// {
3969	// strcpy (newmac, nvram_safe_get ("il0macaddr"));
3970	// }
3971	// else
3972	{
3973	if (nvram_match ("port_swap", "1"))
3974	{
3975	if (strlen (nvram_safe_get ("et1macaddr")) != 0) //safe: maybe et1macaddr not there?
3976	{
3977	strcpy (newmac, nvram_safe_get ("et1macaddr"));
3978	MAC_ADD (newmac); //et1macaddr +2
3979	MAC_ADD (newmac);
3980	}
3981	else
3982	{
3983	strcpy (newmac, nvram_safe_get ("et0macaddr"));
3984	MAC_ADD (newmac); //et0macaddr +3
3985	MAC_ADD (newmac);
3986	MAC_ADD (newmac);
3987	}
3988	}
3989	else
3990	{
3991	strcpy (newmac, nvram_safe_get ("et0macaddr"));
3992	MAC_ADD (newmac); //et0macaddr +2
3993	MAC_ADD (newmac);
3994	}
3995	}
3996	#endif
3997	return;
3998	}
3999
4000	void
4001	getWANMac (char *newmac)
4002	{
4003	strcpy (newmac, nvram_safe_get ("et0macaddr"));
4004	#ifndef HAVE_BUFFALO
4005	MAC_ADD (newmac); //et0macaddr +1
4006
4007	if (nvram_match ("port_swap", "1"))
4008	{
4009	if (strlen (nvram_safe_get ("et1macaddr")) != 0) //safe: maybe et1macaddr not there?
4010	{
4011	strcpy (newmac, nvram_safe_get ("et1macaddr"));
4012	MAC_ADD (newmac); //et1macaddr +1
4013	}
4014	else
4015	{
4016	MAC_ADD (newmac); //et0macaddr +2
4017	}
4018	}
4019	#endif
4020	return;
4021	}
4022
4023
4024
4025	#ifdef HAVE_AQOS
4026
4027	static char *
4028	get_wshaper_dev (void)
4029	{
4030	if (nvram_match ("wshaper_dev", "WAN"))
4031	return get_wan_face ();
4032	else
4033	return "br0";
4034	}
4035
4036	void
4037	add_userip (char ip, int idx, char upstream, char *downstream)
4038	{
4039	int base = 120 + idx;
4040	char up[32];
4041	char down[32];
4042	char ups[32];
4043	char downs[32];
4044	sprintf (up, "1:%d", base);
4045	sprintf (down, "1:%d", base + 1);
4046	sprintf (ups, "%skbit", upstream);
4047	sprintf (downs, "%skbit", downstream);
4048	if (nvram_match ("qos_type", "0"))
4049	{
4050	eval ("tc", "class", "add", "dev", get_wshaper_dev (), "parent", "1:",
4051	"classid", up, "htb", "rate", ups, "ceil", ups);
4052	eval ("tc", "filter", "add", "dev", get_wshaper_dev (), "parent", "1:",
4053	"protocol", "ip", "prio", "1", "u32", "match", "ip", "src", ip,
4054	"flowid", up);
4055	eval ("tc", "class", "add", "dev", "imq0", "parent", "1:", "classid",
4056	down, "htb", "rate", downs, "ceil", downs);
4057	eval ("tc", "filter", "add", "dev", "imq0", "parent", "1:", "protocol",
4058	"ip", "prio", "1", "u32", "match", "ip", "dst", ip, "flowid",
4059	down);
4060	}
4061	else
4062	{
4063	eval ("tc", "class", "add", "dev", get_wshaper_dev (), "parent", "1:",
4064	"classid", up, "htb", "rate", ups, "ceil", ups);
4065	eval ("tc", "filter", "add", "dev", get_wshaper_dev (), "parent", "1:",
4066	"protocol", "ip", "prio", "1", "u32", "match", "ip", "src", ip,
4067	"flowid", up);
4068	eval ("tc", "class", "add", "dev", "imq0", "parent", "1:", "classid",
4069	down, "htb", "rate", downs, "ceil", downs);
4070	eval ("tc", "filter", "add", "dev", "imq0", "parent", "1:", "protocol",
4071	"ip", "prio", "1", "u32", "match", "ip", "dst", ip, "flowid",
4072	down);
4073	}
4074
4075	}
4076
4077	void
4078	add_usermac (char mac, int idx, char upstream, char *downstream)
4079	{
4080	unsigned char octet[6];
4081	ether_atoe (mac, octet);
4082
4083	int base = 120 + idx;
4084	char up[32];
4085	char down[32];
4086	char ups[32];
4087	char downs[32];
4088	char oct2[32];
4089	char oct4[32];
4090	char doct2[32];
4091	char doct4[32];
4092	sprintf (up, "1:%d", base);
4093	sprintf (down, "1:%d", base + 1);
4094	sprintf (ups, "%skbit", upstream);
4095	sprintf (downs, "%skbit", downstream);
4096
4097	sprintf (oct2, "%X%X", octet[4], octet[5]);
4098	sprintf (oct4, "%X%X%X%X", octet[0], octet[1], octet[2], octet[3]);
4099
4100	sprintf (doct4, "%X%X%X%X", octet[2], octet[3], octet[4], octet[5]);
4101	sprintf (doct2, "%X%X", octet[0], octet[1]);
4102
4103	if (nvram_match ("qos_type", "0"))
4104	{
4105	eval ("tc", "class", "add", "dev", get_wshaper_dev (), "parent", "1:",
4106	"classid", up, "htb", "rate", ups, "ceil", ups);
4107	eval ("tc", "filter", "add", "dev", get_wshaper_dev (), "parent", "1:",
4108	"protocol", "ip", "prio", "1", "u32", "match", "u16", "0x0800",
4109	"0xFFFF", "at", "-2", "match", "u16", oct2, "0xFFFF", "at", "-4",
4110	"match", "u32", oct4, "0xFFFFFFFF", "at", "-8", "flowid", up);
4111	eval ("tc", "class", "add", "dev", "imq0", "parent", "1:", "classid",
4112	down, "htb", "rate", downs, "ceil", downs);
4113	eval ("tc", "filter", "add", "dev", "imq0", "parent", "1:", "protocol",
4114	"ip", "prio", "1", "u32", "match", "u16", "0x0800", "0xFFFF",
4115	"at", "-2", "match", "u32", doct4, "0xFFFFFFFF", "at", "-12",
4116	"match", "u16", doct2, "0xFFFF", "at", "-14", "flowid", down);
4117	}
4118	else
4119	{
4120	eval ("tc", "class", "add", "dev", get_wshaper_dev (), "parent", "1:",
4121	"classid", up, "htb", "rate", ups, "ceil", ups);
4122	eval ("tc", "filter", "add", "dev", get_wshaper_dev (), "parent", "1:",
4123	"protocol", "ip", "prio", "1", "u32", "match", "u16", "0x0800",
4124	"0xFFFF", "at", "-2", "match", "u16", oct2, "0xFFFF", "at", "-4",
4125	"match", "u32", oct4, "0xFFFFFFFF", "at", "-8", "flowid", up);
4126	eval ("tc", "class", "add", "dev", "imq0", "parent", "1:", "classid",
4127	down, "htb", "rate", downs, "ceil", downs);
4128	eval ("tc", "filter", "add", "dev", "imq0", "parent", "1:", "protocol",
4129	"ip", "prio", "1", "u32", "match", "u16", "0x0800", "0xFFFF",
4130	"at", "-2", "match", "u32", doct4, "0xFFFFFFFF", "at", "-12",
4131	"match", "u16", doct2, "0xFFFF", "at", "-14", "flowid", down);
4132	}
4133
4134	}
4135
4136
4137	#endif
4138
4139
4140
4141	#ifdef HAVE_X86
4142
4143	static int fd;
4144
4145	void
4146	SetEnvironment ()
4147	{
4148	system ("stty ispeed 2400 < /dev/tts/1");
4149	system ("stty raw < /dev/tts/1");
4150	}
4151
4152	int Cmd = 254; /* EZIO Command */
4153	int cls = 1; /* Clear screen */
4154	void
4155	Cls ()
4156	{
4157	write (fd, &Cmd, 1);
4158	write (fd, &cls, 1);
4159	}
4160
4161	int init = 0x28;
4162	void
4163	Init ()
4164	{
4165	write (fd, &Cmd, 1);
4166	write (fd, &init, 1);
4167	}
4168
4169	int stopsend = 0x37;
4170	void
4171	StopSend ()
4172	{
4173	write (fd, &Cmd, 1);
4174	write (fd, &init, 1);
4175	}
4176
4177	int home = 2; /* Home cursor */
4178	void
4179	Home ()
4180	{
4181	write (fd, &Cmd, 1);
4182	write (fd, &home, 1);
4183	}
4184
4185	int readkey = 6; /* Read key */
4186	void
4187	ReadKey ()
4188	{
4189	write (fd, &Cmd, 1);
4190	write (fd, &readkey, 1);
4191	}
4192
4193	int blank = 8; /* Blank display */
4194	void
4195	Blank ()
4196	{
4197	write (fd, &Cmd, 1);
4198	write (fd, &blank, 1);
4199	}
4200
4201	int hide = 12; /* Hide cursor & display blanked characters */
4202	void
4203	Hide ()
4204	{
4205	write (fd, &Cmd, 1);
4206	write (fd, &hide, 1);
4207	}
4208
4209	int turn = 13; /* Turn On (blinking block cursor) */
4210	void
4211	TurnOn ()
4212	{
4213	write (fd, &Cmd, 1);
4214	write (fd, &turn, 1);
4215	}
4216
4217	int show = 14; /* Show underline cursor */
4218	void
4219	Show ()
4220	{
4221	write (fd, &Cmd, 1);
4222	write (fd, &show, 1);
4223	}
4224
4225	int movel = 16; /* Move cursor 1 character left */
4226	void
4227	MoveL ()
4228	{
4229	write (fd, &Cmd, 1);
4230	write (fd, &movel, 1);
4231	}
4232
4233	int mover = 20; /* Move cursor 1 character right */
4234	void
4235	MoveR ()
4236	{
4237	write (fd, &Cmd, 1);
4238	write (fd, &mover, 1);
4239	}
4240
4241	int scl = 24; /* Scroll cursor 1 character left */
4242	void
4243	ScrollL ()
4244	{
4245	write (fd, &Cmd, 1);
4246	write (fd, &scl, 1);
4247	}
4248
4249	int scr = 28; /* Scroll cursor 1 character right */
4250	void
4251	ScrollR ()
4252	{
4253	write (fd, &Cmd, 1);
4254	write (fd, &scr, 1);
4255	}
4256
4257	int setdis = 64; /* Command */
4258	void
4259	SetDis ()
4260	{
4261	write (fd, &Cmd, 1);
4262	write (fd, &setdis, 1);
4263
4264	}
4265
4266
4267	int a, b;
4268	void
4269	ShowMessage (char str1, char str2)
4270	{
4271	char nul[] = " ";
4272	a = strlen (str1);
4273	b = 40 - a;
4274	write (fd, str1, a);
4275	write (fd, nul, b);
4276	write (fd, str2, strlen (str2));
4277	}
4278
4279	void
4280	initlcd ()
4281	{
4282
4283	fd = open ("/dev/tts/1", O_RDWR);
4284	/** Open Serial port (COM2) */
4285	if (fd > 0)
4286	{
4287	close (fd);
4288	SetEnvironment (); /* Set RAW mode */
4289	fd = open ("/dev/tts/1", O_RDWR);
4290	Init (); /* Initialize EZIO twice */
4291	Init ();
4292
4293	Cls (); /* Clear screen */
4294	}
4295	close (fd);
4296	}
4297
4298	void
4299	lcdmessage (char *message)
4300	{
4301	fd = open ("/dev/tts/1", O_RDWR);/** Open Serial port (COM2) */
4302
4303	if (fd > 0)
4304	{
4305	Init (); /* Initialize EZIO twice */
4306	Init ();
4307	SetDis ();
4308	Cls ();
4309	Home ();
4310	ShowMessage ("State", message);
4311	close (fd);
4312	}
4313	}
4314	void
4315	lcdmessaged (char dual, char message)
4316	{
4317
4318	fd = open ("/dev/tts/1", O_RDWR);
4319	/** Open Serial port (COM2) */
4320
4321	if (fd > 0)
4322	{
4323	Init (); /* Initialize EZIO twice */
4324	Init ();
4325	SetDis ();
4326	Cls (); /* Clear screen */
4327	Home ();
4328	ShowMessage (dual, message);
4329	close (fd);
4330	}
4331	}
4332
4333
4334	#endif
4335
4336
4337	int
4338	getmask (char *nmask)
4339	{
4340
4341	int loopmask = 0;
4342	int ip[4] = {
4343	0, 0, 0, 0
4344	};
4345
4346	sscanf (nmask, "%d.%d.%d.%d", &ip[0], &ip[1], &ip[2], &ip[3]);
4347
4348	int n = 8;
4349
4350	for (--n; n >= 0; --n) //test all 4 bytes in one pass
4351	{
4352	if (ip[0] & 1 << n)
4353	loopmask++;
4354	if (ip[1] & 1 << n)
4355	loopmask++;
4356	if (ip[2] & 1 << n)
4357	loopmask++;
4358	if (ip[3] & 1 << n)
4359	loopmask++;
4360	}
4361	return loopmask;
4362	}
4363
4364	int
4365	doMultiCast (void)
4366	{
4367	char name[80], *next;
4368	int ifcount = 0;
4369	if (nvram_match ("wan_proto", "disabled"))
4370	return 0;
4371	if (nvram_match ("block_multicast", "0"))
4372	{
4373	ifcount++;
4374	}
4375	foreach (name, nvram_safe_get ("lan_ifnames"), next)
4376	{
4377	if (nvram_nmatch ("1", "%s_multicast", name)
4378	&& nvram_nmatch ("0", "%s_bridged", name))
4379	{
4380	ifcount++;
4381	}
4382	}
4383	return ifcount;
4384	}
4385
4386	int
4387	getMTD (char *name)
4388	{
4389	char buf[128];
4390	int device;
4391	sprintf (buf, "cat /proc/mtd\|grep \"%s\"", name);
4392	FILE *fp = popen (buf, "rb");
4393	fscanf (fp, "%s", &buf[0]);
4394	device = buf[3] - '0';
4395	pclose (fp);
4396	return device;
4397	}
4398
4399	static int
4400	sockaddr_to_dotted (struct sockaddr saddr, char buf)
4401	{
4402	buf[0] = '\0';
4403	if (saddr->sa_family == AF_INET)
4404	{
4405	inet_ntop (AF_INET, &((struct sockaddr_in *) saddr)->sin_addr, buf,
4406	128);
4407	return 0;
4408	}
4409	if (saddr->sa_family == AF_INET6)
4410	{
4411	inet_ntop (AF_INET6, &((struct sockaddr_in6 *) saddr)->sin6_addr, buf,
4412	128);
4413	return 0;
4414	}
4415	return -1;
4416	}
4417
4418	void
4419	getIPFromName (char name, char ip)
4420	{
4421	struct addrinfo *result = NULL;
4422	int rc;
4423	struct addrinfo hint;
4424	memset (&hint, 0, sizeof (hint));
4425	hint.ai_socktype = SOCK_STREAM;
4426	rc = getaddrinfo (name, NULL, &hint, &result);
4427	if (!result) //give it a second try
4428	rc = getaddrinfo (name, NULL, &hint, &result);
4429
4430	if (result)
4431	{
4432	sockaddr_to_dotted (result->ai_addr, ip);
4433	}
4434	else
4435	sprintf (ip, "0.0.0.0");
4436	}
4437
4438	/* Example:
4439	* legal_ip_netmask("192.168.1.1","255.255.255.0","192.168.1.100"); return true;
4440	* legal_ip_netmask("192.168.1.1","255.255.255.0","192.168.2.100"); return false;
4441	*/
4442	int
4443	legal_ip_netmask (char sip, char smask, char *dip)
4444	{
4445	struct in_addr ipaddr, netaddr, netmask;
4446	int tag;
4447
4448	inet_aton (nvram_safe_get (sip), &netaddr);
4449	inet_aton (nvram_safe_get (smask), &netmask);
4450	inet_aton (dip, &ipaddr);
4451
4452	netaddr.s_addr &= netmask.s_addr;
4453
4454	if (netaddr.s_addr != (ipaddr.s_addr & netmask.s_addr))
4455	tag = FALSE;
4456	else
4457	tag = TRUE;
4458
4459
4460	return tag;
4461	}
4462
4463	/* Example:
4464	* ISDIGIT("", 0); return true;
4465	* ISDIGIT("", 1); return false;
4466	* ISDIGIT("123", 1); return true;
4467	*/
4468	int
4469	ISDIGIT (char *value, int flag)
4470	{
4471	int i, tag = TRUE;
4472
4473
4474	if (!strcmp (value, ""))
4475	{
4476	if (flag)
4477	return 0; // null
4478	else
4479	return 1;
4480	}
4481
4482	for (i = 0; *(value + i); i++)
4483	{
4484	if (!isdigit (*(value + i)))
4485	{
4486	tag = FALSE;
4487	break;
4488	}
4489	}
4490	return tag;
4491	}
4492
4493
4494	void
4495	addAction (char *action)
4496	{
4497	char *actionstack = "";
4498	char *next;
4499	char service[80];
4500	char *services = nvram_safe_get ("action_service");
4501	foreach (service, services, next)
4502	{
4503	if (!strcmp (service, action))
4504	{
4505	return;
4506	}
4507	}
4508	if (strlen (services) > 0)
4509	{
4510	actionstack = malloc (strlen (services) + strlen (action) + 2);
4511	memset (actionstack, 0, strlen (services) + strlen (action) + 2);
4512	strcpy (actionstack, action);
4513	strcat (actionstack, " ");
4514	strcat (actionstack, nvram_safe_get ("action_service"));
4515	nvram_set ("action_service", actionstack);
4516	free (actionstack);
4517	}
4518	else
4519	{
4520	nvram_set ("action_service", action);
4521	}
4522
4523
4524	}
4525
4526	void
4527	rep (char *in, char from, char to)
4528	{
4529	int i;
4530	int slen = strlen (in);
4531	for (i = 0; i < slen; i++)
4532	if (in[i] == from)
4533	in[i] = to;
4534
4535	}
4536
4537	#include "l7protocols.h"
4538	void
4539	get_filter_services (char *services)
4540	{
4541
4542	l7filters *filters = filters_list;
4543	int namelen, protolen;
4544	char temp[128] = "";
4545
4546	while (filters->name) //add l7 and p2p filters
4547	{
4548	namelen = strlen (filters->name);
4549	protolen = strlen (filters->protocol);
4550
4551	sprintf (temp, "$NAME:%03d:%s$PROT:%03d:%s$PORT:003:0:0< >",
4552	namelen, filters->name, protolen, filters->protocol);
4553	strcat (services, temp);
4554	filters++;
4555	}
4556
4557	strcat (services, nvram_safe_get ("filter_services")); //this is user defined filters
4558	strcat (services, nvram_safe_get ("filter_services_1"));
4559
4560	return;
4561	}
4562
4563
4564	int
4565	endswith (char str, char cmp)
4566	{
4567	int cmp_len, str_len, i;
4568	if (cmp == NULL)
4569	return 0;
4570	if (str == NULL)
4571	return 0;
4572	cmp_len = strlen (cmp);
4573	str_len = strlen (str);
4574	if (cmp_len > str_len)
4575	return (0);
4576	for (i = 0; i < cmp_len; i++)
4577	{
4578	if (str[(str_len - 1) - i] != cmp[(cmp_len - 1) - i])
4579	return (0);
4580	}
4581	return (1);
4582	}

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

Download in other formats: