Context Navigation

source: titan/titan/global.h @ 23976

Last change on this file since 23976 was 23976, checked in by nit, 10 years ago
[titan] fix colorformat
File size: 125.3 KB

Line
1	#ifndef GLOBAL_H
2	#define GLOBAL_H
3
4	int osystem(char* cmd, int timeout)
5	{
6	int ret = 0;
7	char* tmpstr = NULL;
8
9	tmpstr = ostrcat(tmpstr, "timeout -t ", 1, 0);
10	tmpstr = ostrcat(tmpstr, oitoa(timeout), 1, 1);
11	tmpstr = ostrcat(tmpstr, " -s 9 ", 1, 0);
12	tmpstr = ostrcat(tmpstr, cmd, 1, 0);
13	ret = system(tmpstr);
14	free(tmpstr); tmpstr = NULL;
15
16	return ret;
17	}
18
19	int wlanlinkquality()
20	{
21	char dev[20];
22	int tmp = 0, linkquality = 0;
23	FILE *fd = NULL;
24	char *fileline = NULL;
25
26	struct inetwork* wlandev = getinetworkfirstwlan();
27	if(wlandev == NULL) return 0;
28
29	fileline = malloc(MINMALLOC);
30	if(fileline == NULL)
31	{
32	err("no memory");
33	return 0;
34	}
35
36	fd = fopen("/proc/net/wireless", "r");
37	if(fd == NULL)
38	{
39	perr("can't open /proc/net/wireless");
40	free(fileline);
41	return 0;
42	}
43
44	while(fgets(fileline, MINMALLOC, fd) != NULL)
45	{
46	if(ostrstr(fileline, wlandev->device) != NULL)
47	sscanf(fileline, "%[^:]: %d %d", dev, &tmp, &linkquality);
48	}
49
50	free(fileline);
51	fclose(fd);
52	return linkquality;
53	}
54
55	char* getispip()
56	{
57	char* tmpstr = NULL;
58	char* ip = NULL;
59	tmpstr = gethttp("checkip.dyndns.org", "", 80, NULL, NULL, 10000, NULL, 0);
60
61	if(oregex(".<body>Current IP Address: ([0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3})</body>.", tmpstr))
62	{
63	ip = oregex(".<body>Current IP Address: ([0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3})</body>.", tmpstr);
64	}
65	free(tmpstr), tmpstr = NULL;
66	return ip;
67	}
68
69	//flag 0: leave standby
70	//flag 1: set standby
71	int setcecstandby(int flag)
72	{
73	if(getconfigint("usecec", NULL) == 1)
74	{
75	if(flag == 0)
76	writesys("/proc/stb/cec/onetouchplay", "0", 1);
77	else
78	{
79	char* tmpstr = readsys("/proc/stb/cec/state_cecaddress", 1);
80	char* tmpstr1 = readsys("/proc/stb/cec/state_activesource", 1);
81
82	if(ostrcmp(tmpstr, tmpstr1) == 0)
83	writesys("/proc/stb/cec/systemstandby", "0", 1);
84
85	free(tmpstr); tmpstr = NULL;
86	free(tmpstr1); tmpstr1 = NULL;
87	}
88	}
89
90	return 0;
91	}
92
93	char* mask(char* input, int count, char* maskchar)
94	{
95	char* tmpstr = NULL;
96	int i = 0;
97
98	tmpstr = ostrcat(input, NULL, 1, 0);
99
100	if(tmpstr != NULL)
101	{
102	int len = strlen(tmpstr);
103	for(i = 0; i < count - len; i++)
104	tmpstr = ostrcat(maskchar, tmpstr, 0, 1);
105	}
106	else
107	{
108	for(i = 0; i < count; i++)
109	tmpstr = ostrcat(maskchar, tmpstr, 0, 1);
110	}
111
112	return tmpstr;
113	}
114
115	int checkinternet()
116	{
117	int skip = 0, i = 0;
118	char* tmp = NULL, *cmd = NULL;
119
120	cmd = ostrcat(cmd, "google.de", 1, 0);
121
122	//if(system(cmd) != 0)
123	for(i = 0; i < 3; i++)
124	{
125	free(tmp); tmp = NULL;
126	tmp = gethttp(cmd, "/", 80, NULL, NULL, 5000, NULL, 0);
127	if(tmp != NULL) break;
128	}
129	if(tmp == NULL)
130	skip = 1;
131
132	free(tmp); tmp = NULL;
133	free(cmd), cmd = NULL;
134
135	return skip;
136	}
137
138	int checkpng(char* filename)
139	{
140	FILE* fd = NULL;
141	int ret = 0;
142	png_bytep sig = NULL;
143
144	fd = fopen(filename, "rb");
145	if(fd == NULL)
146	{
147	perr("open file %s", filename);
148	return 0;
149	}
150
151	sig = malloc(8);
152	if(sig == NULL)
153	{
154	err("no memory");
155	fclose(fd);
156	return 0;
157	}
158
159	fread(sig, 1, 8, fd);
160	ret = png_check_sig(sig, 8);
161	if(ret == 0)
162	{
163	free(sig);
164	fclose(fd);
165	return 0;
166	}
167
168	free(sig);
169	fclose(fd);
170	return 1;
171	}
172
173	char *str_split(char string, char *delim) {
174	char **tokens = NULL;
175	char *working = NULL;
176	char *token = NULL;
177	int idx = 0;
178
179	tokens = malloc(sizeof(char ) MAXTOKENS);
180	if(tokens == NULL)
181	return NULL;
182
183	working = malloc(sizeof(char) * strlen(string) + 1);
184	if(working == NULL)
185	return NULL;
186
187	/* to make sure, copy string to a safe place */
188	strcpy(working, string);
189	for(idx = 0; idx < MAXTOKENS; idx++)
190	tokens[idx] = NULL;
191
192	token = strtok(working, delim);
193	idx = 0;
194
195	/* always keep the last entry NULL termindated */
196	while((idx < (MAXTOKENS - 1)) && (token != NULL)) {
197	tokens[idx] = malloc(sizeof(char) * strlen(token) + 1);
198	if(tokens[idx] != NULL) {
199	strcpy(tokens[idx], token);
200	idx++;
201	token = strtok(NULL, delim);
202	}
203	}
204
205	free(working);
206	return tokens;
207	}
208
209	char* readfromlinetoline(char* str, int start, int end, int flag)
210	{
211	if(str == NULL) return str;
212
213	char* tmpstr = NULL;
214	int count = 0;
215	int i = 0;
216	struct splitstr* ret = NULL;
217	ret = strsplit(str, "\n", &count);
218
219	for(i = 0; i < count; i++)
220	{
221	if(i >= start && i <= end)
222	{
223	tmpstr = ostrcat(tmpstr, (&ret[i])->part, 1, 0);
224	tmpstr = ostrcat(tmpstr, "\n", 1, 0);
225	}
226	}
227	free(ret), ret = NULL;
228
229	if(flag == 1)
230	{
231	free(str), str = NULL;
232	}
233	return tmpstr;
234	}
235
236	char* ltostr(char* str, long val, unsigned base)
237	{
238	ldiv_t r;
239
240	if(base > 36 \|\| str == NULL)
241	return NULL;
242
243	if(val < 0) *str++ = '-';
244	r = ldiv(labs(val), base);
245
246	if(r.quot > 0) str = ltostr(str, r.quot, base);
247
248	*str++ = "0123456789abcdefghijklmnopqrstuvwxyz"[(int)r.rem];
249	*str = '\0';
250	return str;
251	}
252
253	char* oltostr(long val, unsigned base)
254	{
255	char* str = NULL;
256
257	str = calloc(1, MINMALLOC);
258	if(str == NULL)
259	{
260	err("no mem");
261	return NULL;
262	}
263
264	ltostr(str, val, base);
265
266	return ostrshrink(str);
267	}
268
269	int checklowflash()
270	{
271	char* tmpstr = NULL;
272	char* cmd = NULL;
273	cmd = ostrcat(cmd, "cat", 1, 0);
274	cmd = ostrcat(cmd, " ", 1, 0);
275	cmd = ostrcat(cmd, "/", 1, 0);
276	cmd = ostrcat(cmd, "proc", 1, 0);
277	cmd = ostrcat(cmd, "/", 1, 0);
278	cmd = ostrcat(cmd, "mtd", 1, 0);
279	cmd = ostrcat(cmd, " ", 1, 0);
280	cmd = ostrcat(cmd, "\|", 1, 0);
281	cmd = ostrcat(cmd, " ", 1, 0);
282	cmd = ostrcat(cmd, "grep", 1, 0);
283	cmd = ostrcat(cmd, " ", 1, 0);
284	cmd = ostrcat(cmd, "mtd2", 1, 0);
285	cmd = ostrcat(cmd, " ", 1, 0);
286	cmd = ostrcat(cmd, "\|", 1, 0);
287	cmd = ostrcat(cmd, " ", 1, 0);
288	cmd = ostrcat(cmd, "awk '{print ", 1, 0);
289	cmd = ostrcat(cmd, "$2}'", 1, 0);
290
291	tmpstr = string_newline(command(cmd));
292	free(cmd), cmd = NULL;
293
294	if(tmpstr == NULL)
295	{
296	return 1;
297	}
298
299	if(ostrcmp(tmpstr, "00960000") == 0)
300	{
301	free(tmpstr), tmpstr = NULL;
302	return 0;
303	}
304	return 1;
305	}
306
307	int checkhighflash()
308	{
309	char* tmpstr = NULL;
310	char* cmd = NULL;
311	cmd = ostrcat(cmd, "cat", 1, 0);
312	cmd = ostrcat(cmd, " ", 1, 0);
313	cmd = ostrcat(cmd, "/", 1, 0);
314	cmd = ostrcat(cmd, "proc", 1, 0);
315	cmd = ostrcat(cmd, "/", 1, 0);
316	cmd = ostrcat(cmd, "mtd", 1, 0);
317	cmd = ostrcat(cmd, " ", 1, 0);
318	cmd = ostrcat(cmd, "\|", 1, 0);
319	cmd = ostrcat(cmd, " ", 1, 0);
320	cmd = ostrcat(cmd, "grep", 1, 0);
321	cmd = ostrcat(cmd, " ", 1, 0);
322	cmd = ostrcat(cmd, "mtd5", 1, 0);
323	cmd = ostrcat(cmd, " ", 1, 0);
324	cmd = ostrcat(cmd, "\|", 1, 0);
325	cmd = ostrcat(cmd, " ", 1, 0);
326	cmd = ostrcat(cmd, "awk '{print ", 1, 0);
327	cmd = ostrcat(cmd, "$2}'", 1, 0);
328
329	tmpstr = string_newline(command(cmd));
330	free(cmd), cmd = NULL;
331
332	if(tmpstr == NULL)
333	{
334	return 1;
335	}
336
337	if(ostrcmp(tmpstr, "1ce40000") == 0)
338	{
339	free(tmpstr), tmpstr = NULL;
340	return 0;
341	}
342	return 1;
343	}
344
345	char* unhexlify(char *hexstr)
346	{
347	int len = 0, tmpint = 0;
348	char p, q, *binstr = NULL;
349
350	if(hexstr == NULL) return NULL;
351
352	len = strlen(hexstr);
353	if(len == 0 \|\| len % 2 != 0) return NULL;
354
355	binstr = calloc(1, (len / 2) + 1);
356	if(binstr == NULL)
357	{
358	err("no mem");
359	return NULL;
360	}
361
362	for(p = hexstr, q = binstr; *p; p += 2, q++)
363	{
364	sscanf(p, "%2x", &tmpint);
365	*q = tmpint;
366	}
367
368	return binstr;
369	}
370
371	int getsupermagic(char* filename)
372	{
373	struct statfs64 s;
374
375	if(statfs64(filename, &s) >= 0)
376	return s.f_type;
377
378	return 0;
379	}
380
381	int getrandom(int max)
382	{
383	srand(time(NULL));
384	return (rand() % max);
385	}
386
387	char* delmountpart(char* filename, int free1)
388	{
389	struct mntent ent;
390	FILE *fd = NULL;
391	char* ret = NULL, buf = NULL, treffer = NULL, *rpath = NULL;
392	int mntdirlen = 0;
393
394	if(filename == NULL) return NULL;
395
396	buf = malloc(MINMALLOC);
397	if(buf == NULL)
398	{
399	err("no mem");
400	return NULL;
401	}
402
403	rpath = realpath(filename, NULL);
404	if(rpath == NULL) return NULL;
405
406	fd = setmntent("/proc/mounts", "r");
407	if(fd != NULL)
408	{
409	while(getmntent_r(fd, &ent, buf, MINMALLOC) != 0)
410	{
411	if(ent.mnt_dir != NULL)
412	{
413	mntdirlen = strlen(ent.mnt_dir);
414	if(mntdirlen > 1 && ostrstr(rpath, ent.mnt_dir) == rpath)
415	{
416	if(treffer == NULL \|\| strlen(treffer) < mntdirlen)
417	{
418	free(treffer); treffer = NULL;
419	treffer = ostrcat(ent.mnt_dir, NULL, 0, 0);
420	}
421	}
422	}
423	}
424	}
425
426	if(treffer != NULL)
427	ret = string_replace(treffer, NULL, rpath, 0);
428
429	endmntent(fd);
430	if(free1 == 1) free(filename);
431	free(buf);
432	free(treffer);
433	free(rpath);
434	return ret;
435	}
436
437	char* addmountpart(char* filename, int free1)
438	{
439	struct mntent ent;
440	FILE *fd = NULL;
441	char* ret = NULL, *buf = NULL;
442
443	if(filename == NULL) return NULL;
444
445	buf = malloc(MINMALLOC);
446	if(buf == NULL)
447	{
448	err("no mem");
449	return NULL;
450	}
451
452	fd = setmntent("/proc/mounts", "r");
453	if(fd != NULL)
454	{
455	while(getmntent_r(fd, &ent, buf, MINMALLOC))
456	{
457	if(ent.mnt_dir != NULL && strlen(ent.mnt_dir) > 1)
458	{
459	ret = ostrcat(ent.mnt_dir, filename, 0, 0);
460	if(file_exist(ret))
461	{
462	if(free1 == 1) free(filename);
463	endmntent(fd);
464	free(buf);
465	return ret;
466	}
467	free(ret); ret = NULL;
468	}
469	}
470	}
471
472	endmntent(fd);
473	free(buf);
474	return ret;
475	}
476
477	struct blacklist* readblacklist(char* filename)
478	{
479	char* tmpstr = NULL;
480	struct splitstr* ret = NULL;
481	struct blacklist* newnode = NULL;
482	int count = 0;
483
484	newnode = (struct blacklist*)calloc(1, sizeof(struct blacklist));
485	if(newnode == NULL)
486	{
487	err("no memory");
488	return NULL;
489	}
490
491	tmpstr = readfiletomem(filename, 1);
492	if(tmpstr == NULL)
493	{
494	free(newnode); newnode = NULL;
495	return NULL;
496	}
497
498	ret = strsplit(tmpstr, "\n", &count);
499	if(ret == NULL)
500	{
501	free(tmpstr); tmpstr = NULL;
502	free(newnode); newnode = NULL;
503	return NULL;
504	}
505
506	newnode->count = count;
507	newnode->splitstr = ret;
508	newnode->file = tmpstr;
509
510	return newnode;
511	}
512
513	void freeblacklist(struct blacklist* node)
514	{
515	if(node != NULL)
516	{
517	free(node->file); node->file = NULL;
518	free(node->splitstr); node->splitstr = NULL;
519	node->count = 0;
520	free(node); node = NULL;
521	}
522	}
523
524	unsigned int gethash(char* str)
525	{
526	unsigned int hash = 0;
527	int c = 0;
528
529	if(str == NULL) return 0;
530
531	while((c = *str++))
532	hash = ((hash << 5) + hash) ^ c;
533
534	return hash;
535	}
536
537	void freeregexstruct(struct regex* node)
538	{
539	if(node == NULL) return;
540
541	free(node->match1); node->match1 = NULL;
542	free(node->match2); node->match2 = NULL;
543	free(node->match3); node->match3 = NULL;
544	free(node->match4); node->match4 = NULL;
545	free(node->match5); node->match5 = NULL;
546	free(node->match6); node->match6 = NULL;
547	free(node->match7); node->match7 = NULL;
548	free(node->match8); node->match8 = NULL;
549	free(node->match9); node->match9 = NULL;
550	free(node->match10); node->match10 = NULL;
551
552	free(node); node = NULL;
553	}
554
555	struct regex* regexstruct(char* regex, char* str)
556	{
557	regex_t preg = {NULL};
558	regmatch_t pmatch[11] = {{0}};
559	size_t rm = 0, i = 0, len = 0;
560	char* ret = NULL;
561	struct regex* node = NULL;
562
563	if(regex == NULL \|\| str == NULL) return NULL;
564
565	rm = regcomp(&preg, regex, REG_EXTENDED);
566	if(rm != 0) //error in regex
567	{
568	regfree(&preg);
569	return NULL;
570	}
571
572	rm = regexec(&preg, str, 11, pmatch, 0);
573	if(rm != 0) //no match
574	{
575	regfree(&preg);
576	return NULL;
577	}
578
579	node = (struct regex*)calloc(1, sizeof(struct regex));
580	if(node == NULL)
581	{
582	err("no mem");
583	regfree(&preg);
584	return NULL;
585	}
586
587	for(i = 1; !rm && i <= preg.re_nsub; i++)
588	{
589	len = pmatch[i].rm_eo - pmatch[i].rm_so;
590	if(len < 1) continue;
591
592	ret = malloc(len + 1);
593	if(ret != NULL)
594	{
595	memcpy(ret, str + pmatch[i].rm_so, len);
596	ret[len] = '\0';
597	}
598
599	if(i == 1) node->match1 = ret;
600	else if(i == 2) node->match2 = ret;
601	else if(i == 3) node->match3 = ret;
602	else if(i == 4) node->match4 = ret;
603	else if(i == 5) node->match5 = ret;
604	else if(i == 6) node->match6 = ret;
605	else if(i == 7) node->match7 = ret;
606	else if(i == 8) node->match8 = ret;
607	else if(i == 9) node->match9 = ret;
608	else if(i == 10) node->match10 = ret;
609
610	ret = NULL;
611	}
612
613	regfree(&preg);
614	return node;
615	}
616
617	char* oregex(char* regex, char* str)
618	{
619	regex_t preg = {NULL};
620	regmatch_t pmatch[2] = {{0}};
621	size_t rm = 0, len = 0;
622	char* ret = NULL;
623
624	if(regex == NULL \|\| str == NULL) return NULL;
625
626	rm = regcomp(&preg, regex, REG_EXTENDED);
627	if(rm != 0) //error in regex
628	{
629	regfree(&preg);
630	return NULL;
631	}
632
633	rm = regexec(&preg, str, 2, pmatch, 0);
634	if(rm != 0) //no match
635	{
636	regfree(&preg);
637	return NULL;
638	}
639
640	len = pmatch[1].rm_eo - pmatch[1].rm_so;
641	if(len < 1)
642	{
643	regfree(&preg);
644	return NULL;
645	}
646
647	ret = malloc(len + 1);
648	if(ret != NULL)
649	{
650	memcpy(ret, str + pmatch[1].rm_so, len);
651	ret[len] = '\0';
652	}
653
654	regfree(&preg);
655	return ret;
656	}
657
658	int oregexint(char* regex, char* str)
659	{
660	int iret = 0;
661	char* ret = NULL;
662
663	ret = oregex(regex, str);
664	if(ret != NULL) iret = atoi(ret);
665	free(ret);
666
667	return iret;
668	}
669
670	struct splitstr* oregexsplit(char* regex, char str, char tok, int* count)
671	{
672	char *tmpstr = NULL;
673	struct splitstr *tmparray = NULL;
674	*count = 0;
675
676	if(str == NULL \|\| tok == NULL)
677	return NULL;
678
679	tmpstr = strtok(str, tok);
680	while(tmpstr != NULL)
681	{
682	count = count + 1;
683	tmparray = (struct splitstr)realloc(tmparray, sizeof(struct splitstr) * (*count));
684	if(tmparray == NULL)
685	return NULL;
686
687	(&tmparray[(*count) - 1])->part = oregex(regex, tmpstr);
688	tmpstr = strtok(NULL, tok);
689	}
690
691	return tmparray;
692	}
693
694	void freeoregexsplit(struct splitstr* tmparray, int len)
695	{
696	if(tmparray == NULL) return;
697	int i = 0;
698
699	for(i = 0; i < len; i++)
700	{
701	free(tmparray[i].part);
702	tmparray[i].part = NULL;
703	}
704
705	free(tmparray);
706	}
707
708	void ckeckkillnetthread()
709	{
710	// if(checkbox("ATEMIO510") == 1)
711	// {
712	int count = 0;
713	while(count < 12)
714	{
715	count++;
716	sleep(5);
717	if(status.security == 0)
718	killnet();
719	else
720	count = 12;
721	}
722	// }
723	}
724
725	int checkreseller()
726	{
727	if(checkbox("UFS910") == 1 \|\| checkbox("UFS922") == 1)
728	{
729	debug(10, "ResellerId: skipped");
730	debug(10, "boxtype: %s", getboxtype());
731	return 0;
732	}
733
734	FILE* fd = NULL;
735	char mtd[10];
736	char* buf = NULL;
737
738	// /dev/mtd0
739	mtd[0] = 0x2f;
740	mtd[1] = 0x64;
741	mtd[2] = 0x65;
742	mtd[3] = 0x76;
743	mtd[4] = 0x2f;
744	mtd[5] = 0x6d;
745	mtd[6] = 0x74;
746	mtd[7] = 0x64;
747	mtd[8] = 0x30;
748	mtd[9] = '\0';
749
750	if((fd = fopen(mtd, "r")) == NULL)
751	return 1;
752
753	buf = malloc(1080);
754	if(buf == NULL)
755	{
756	fclose(fd);
757	return 1;
758	}
759
760	fread(buf, 1080, 1, fd);
761
762	if(checkbox("ATEMIO510") == 1)
763	{
764	if((buf[1072] & 0xff) == 0x25 && (buf[1073] & 0xff) == 0x29 && (buf[1074] & 0xff) == 0x02 && (buf[1075] & 0xff) == 0xA0)
765	{
766	debug(10, "ResellerId: found (%s) reseller !", getboxtype());
767	free(buf);
768	fclose(fd);
769	return 0;
770	}
771	}
772	else if(checkbox("ATEMIO520") == 1 \|\| checkbox("ATEMIO530") == 1)
773	{
774	if((buf[1072] & 0xff) == 0x25 && (buf[1073] & 0xff) == 0x29 && (buf[1074] & 0xff) == 0x02 && (buf[1075] & 0xff) == 0xA5)
775	{
776	debug(10, "ResellerId: found (%s) reseller !", getboxtype());
777	free(buf);
778	fclose(fd);
779	return 0;
780	}
781	}
782	else if(checkbox("ATEMIO7600") == 1)
783	{
784	if((buf[1072] & 0xff) == 0x23 && (buf[1073] & 0xff) == 0x03 && (buf[1074] & 0xff) == 0x00 && (buf[1075] & 0xff) == 0xA0)
785	{
786	debug(10, "ResellerId: found (%s) reseller !", getboxtype());
787	free(buf);
788	fclose(fd);
789	return 0;
790	}
791	}
792	else if(checkbox("UFS910") == 1)
793	{
794	if((buf[1072] & 0xff) == 0x03 && (buf[1073] & 0xff) == 0x00 && (buf[1074] & 0xff) == 0x00 && (buf[1075] & 0xff) == 0x00)
795	{
796	debug(10, "ResellerId: found (%s) reseller !", getboxtype());
797	free(buf);
798	fclose(fd);
799	return 0;
800	}
801	}
802	else if(checkbox("UFS912") == 1)
803	{
804	if((buf[1072] & 0xff) == 0x2d && (buf[1073] & 0xff) == 0x41 && (buf[1074] & 0xff) == 0x04 && (buf[1075] & 0xff) == 0xd2)
805	{
806	debug(10, "ResellerId: found (%s) reseller !", getboxtype());
807	free(buf);
808	fclose(fd);
809	return 0;
810	}
811	}
812	else if(checkbox("AT7000") == 1)
813	{
814	if((buf[1072] & 0xff) == 0x02 && (buf[1073] & 0xff) == 0x27 && (buf[1074] & 0xff) == 0x12 && (buf[1075] & 0xff) == 0x22)
815	{
816	debug(10, "ResellerId: found (%s) reseller !", getboxtype());
817	free(buf);
818	fclose(fd);
819	return 0;
820	}
821	}
822	else if(checkbox("SKYSAT") == 1)
823	{
824	if((buf[1072] & 0xff) == 0x25 && (buf[1073] & 0xff) == 0x22 && (buf[1074] & 0xff) == 0x00 && (buf[1075] & 0xff) == 0xa0)
825	{
826	debug(10, "ResellerId: found (%s) reseller !", getboxtype());
827	free(buf);
828	fclose(fd);
829	return 0;
830	}
831	}
832	else if(checkbox("ATEVIO7000") == 1)
833	{
834	if((buf[240] & 0xff) == 0x20 && (buf[241] & 0xff) == 0x9 && (buf[242] & 0xff) == 0x00 && (buf[243] & 0xff) == 0x00)
835	{
836	debug(10, "ResellerId: found (%s) reseller !", getboxtype());
837	free(buf);
838	fclose(fd);
839	return 0;
840	}
841	}
842	else if(checkbox("ATEVIO700") == 1)
843	{
844	if((buf[240] & 0xff) == 0x20 && (buf[241] & 0xff) == 0x9 && (buf[242] & 0xff) == 0x03 && (buf[243] & 0xff) == 0x00)
845	{
846	debug(10, "ResellerId: found (%s) reseller !", getboxtype());
847	free(buf);
848	fclose(fd);
849	return 0;
850	}
851	}
852	else
853	{
854	// dummy for other boxes
855	/*
856	not working why ?
857
858	printf("ResellerId: check\n");
859	printf("ResellerId1: %x\n", buf[1072]);
860	printf("ResellerId2: %x\n", buf[1073]);
861	printf("ResellerId3: %x\n", buf[1074]);
862	printf("ResellerId4: %x\n", buf[1075]);
863	printf("ResellerId: %x %x %x %x\n", buf[1072], buf[1073], buf[1074], buf[1075]);
864	*/
865	debug(10, "ResellerId: not supported");
866	debug(10, "boxtype: %s", getboxtype());
867	// disable for test
868	return 1;
869	}
870
871	free(buf);
872	fclose(fd);
873	return 1;
874	}
875
876	int checkflash()
877	{
878	char* tmpstr = NULL;
879	char* cmd = NULL;
880	char* dev = NULL;
881	char* dir = NULL;
882
883	if((checkbox("ATEMIO7600") == 1) \|\| (checkbox("ATEMIO510") == 1) \|\| (checkbox("ATEVIO700") == 1) \|\| (checkbox("ATEVIO7000") == 1) \|\| (checkbox("UFS910") == 1) \|\| (checkbox("UFS922") == 1) \|\| (checkbox("ATEMIO520") == 1) \|\| (checkbox("ATEMIO530") == 1))
884	{
885	dev = ostrcat(dev, "3", 1, 0);
886	dir = ostrcat(dir, "var", 1, 0);
887	}
888	else if((checkbox("IPBOX91") == 1) \|\| (checkbox("IPBOX900") == 1) \|\| (checkbox("IPBOX910") == 1) \|\| (checkbox("IPBOX9000") == 1) \|\| (checkbox("WHITEBOX") == 1))
889	{
890	dev = ostrcat(dev, "4", 1, 0);
891	dir = ostrcat(dir, "var", 1, 0);
892	}
893	else if(checkbox("UFS912") == 1)
894	{
895	// dev = ostrcat(dev, "5", 1, 0);
896	dev = ostrcat(dev, "4", 1, 0);
897	dir = ostrcat(dir, "var", 1, 0);
898	}
899	else
900	{
901	dev = ostrcat(dev, "9", 1, 0);
902	dir = ostrcat(dir, "var", 1, 0);
903	}
904
905	cmd = ostrcat(cmd, "mount", 1, 0);
906	cmd = ostrcat(cmd, " \| ", 1, 0);
907	cmd = ostrcat(cmd, "grep", 1, 0);
908	cmd = ostrcat(cmd, " /dev/", 1, 0);
909	cmd = ostrcat(cmd, "mtdblock", 1, 0);
910	cmd = ostrcat(cmd, dev, 1, 1);
911	cmd = ostrcat(cmd, " \| ", 1, 0);
912	cmd = ostrcat(cmd, "grep", 1, 0);
913	cmd = ostrcat(cmd, " /", 1, 0);
914	cmd = ostrcat(cmd, dir, 1, 0);
915	cmd = ostrcat(cmd, " \| ", 1, 0);
916	cmd = ostrcat(cmd, "awk {'print $3'}", 1, 0);
917
918	tmpstr = string_newline(command(cmd));
919	free(cmd), cmd = NULL;
920
921	if(tmpstr == NULL)
922	{
923	free(dir), dir = NULL;
924	return 1;
925	}
926
927	dir = ostrcat("/", dir, 0, 1);
928
929	if(ostrcmp(tmpstr, dir) == 0)
930	{
931	free(dir), dir = NULL;
932	free(tmpstr), tmpstr = NULL;
933	return 0;
934	}
935
936	free(dir), dir = NULL;
937	free(tmpstr), tmpstr = NULL;
938	return 1;
939	}
940
941	char* getmacfromcmdline()
942	{
943	char* cmdline = NULL;
944	char* tmpstr = NULL;
945	char* mac = NULL;
946
947	cmdline = readsys("/proc/cmdline", 1);
948	if(cmdline != NULL)
949	{
950	tmpstr = strstr(cmdline, "ethaddr:");
951	if(tmpstr != NULL && strlen(tmpstr) >= 25)
952	{
953	tmpstr[25] = '\0';
954	tmpstr += 8;
955	mac = ostrcat(tmpstr, NULL, 0, 0);
956	}
957	}
958
959	return mac;
960	}
961
962	char* getcpuid()
963	{
964	char* serial = NULL;
965	char* buffer = NULL;
966	struct inetwork* net = getinetworkbydevice("eth0");
967
968	if(net != NULL)
969	{
970	int mac_int = 0;
971	int mac1_int = 0;
972	int mac2_int = 0;
973
974	char* mac = NULL;
975
976	if(checkbox("ATEMIO510") == 1 \|\| checkbox("ATEMIO520") == 1 \|\| checkbox("ATEMIO530") == 1 \|\| checkbox("ATEMIO7600") == 1)
977	mac = getmacfromcmdline();
978	else
979	mac = ostrcat(mac, net->mac, 1, 0);
980
981	int count = 0;
982	char* mac1 = NULL;
983	char* mac2 = NULL;
984	char* tmpstr = NULL;
985
986	tmpstr = ostrcat(mac, NULL, 0, 0);
987
988	struct splitstr* ret = NULL;
989	ret = strsplit(tmpstr, ":", &count);
990
991	if(ret != NULL && count == 6)
992	{
993	mac1 = ostrcat(mac1, (&ret[0])->part, 1, 0);
994	mac1 = ostrcat(mac1, (&ret[1])->part, 1, 0);
995	mac1 = ostrcat(mac1, (&ret[2])->part, 1, 0);
996	mac2 = ostrcat(mac2, (&ret[3])->part, 1, 0);
997	mac2 = ostrcat(mac2, (&ret[4])->part, 1, 0);
998	mac2 = ostrcat(mac2, (&ret[5])->part, 1, 0);
999	}
1000
1001	free(ret); ret = NULL;
1002
1003	if(mac1 != NULL)
1004	{
1005	sscanf(mac1, "%X", &mac1_int);
1006	mac1_int = strtol(mac1 , NULL, 16);
1007	free(mac1), mac1 = NULL;
1008	}
1009
1010	if(mac2 != NULL)
1011	{
1012	sscanf(mac2, "%X", &mac2_int);
1013	mac2_int = strtol(mac2 , NULL, 16);
1014	free(mac2), mac2 = NULL;
1015	}
1016
1017	free(tmpstr); tmpstr = NULL;
1018	free(mac); mac = NULL;
1019
1020	mac_int = mac1_int + mac2_int;
1021	int cpuid = 7594;
1022	mac_int += cpuid;
1023
1024	buffer = malloc(50);
1025	if(buffer == NULL)
1026	return NULL;
1027	sprintf(buffer, "%d", mac_int);
1028	serial = ostrcat("AA040127", buffer, 0, 0);
1029	free(buffer);
1030	}
1031
1032	return string_newline(serial);
1033	}
1034
1035	char* gettimeinfo()
1036	{
1037	char* cmd = NULL;
1038	cmd = ostrcat(cmd, "cat", 1, 0);
1039	cmd = ostrcat(cmd, " /", 1, 0);
1040	cmd = ostrcat(cmd, "etc", 1, 0);
1041	cmd = ostrcat(cmd, "/", 1, 0);
1042	cmd = ostrcat(cmd, "image-version", 1, 0);
1043	cmd = ostrcat(cmd, " \| ", 1, 0);
1044	cmd = ostrcat(cmd, "cut", 1, 0);
1045	cmd = ostrcat(cmd, " -d= ", 1, 0);
1046	cmd = ostrcat(cmd, "-f2", 1, 0);
1047	return command(cmd);
1048	}
1049
1050	char* gettimeinfovar()
1051	{
1052	char* cmd = NULL;
1053	cmd = ostrcat(cmd, "cat", 1, 0);
1054	cmd = ostrcat(cmd, " /", 1, 0);
1055	cmd = ostrcat(cmd, "var", 1, 0);
1056	cmd = ostrcat(cmd, "/", 1, 0);
1057	cmd = ostrcat(cmd, "etc", 1, 0);
1058	cmd = ostrcat(cmd, "/", 1, 0);
1059	cmd = ostrcat(cmd, ".image-version", 1, 0);
1060	cmd = ostrcat(cmd, " \| ", 1, 0);
1061	cmd = ostrcat(cmd, "cut", 1, 0);
1062	cmd = ostrcat(cmd, " -d= ", 1, 0);
1063	cmd = ostrcat(cmd, "-f2", 1, 0);
1064	return command(cmd);
1065	}
1066
1067	char* getserialpw()
1068	{
1069	char* pw = NULL;
1070
1071	pw = ostrcat(pw, "/", 1, 0);
1072	pw = ostrcat(pw, "?", 1, 0);
1073	pw = ostrcat(pw, "*", 1, 0);
1074	pw = ostrcat(pw, "x", 1, 0);
1075	pw = ostrcat(pw, "4", 1, 0);
1076	pw = ostrcat(pw, "(", 1, 0);
1077	pw = ostrcat(pw, "$", 1, 0);
1078	pw = ostrcat(pw, "!", 1, 0);
1079	pw = ostrcat(pw, "r", 1, 0);
1080	pw = ostrcat(pw, "%", 1, 0);
1081	pw = ostrcat(pw, "6", 1, 0);
1082	pw = ostrcat(pw, "=", 1, 0);
1083	pw = ostrcat(pw, "9", 1, 0);
1084	pw = ostrcat(pw, "}", 1, 0);
1085
1086	return pw;
1087	}
1088
1089	int writeserial(char* cpuid)
1090	{
1091	char* filename = "/var/etc/codepages/codepage.868", *pw = NULL;
1092	unsigned char* buf = NULL;
1093	FILE *fd = NULL;
1094	int ret = 0;
1095
1096	pw = getserialpw();
1097	buf = oencrypt(pw, cpuid, strlen(cpuid));
1098	free(pw); pw = NULL;
1099	if(buf == NULL) return 1;
1100
1101	fd = fopen(filename, "wbt");
1102	if(fd == NULL)
1103	{
1104	perr("can't open %s", filename);
1105	free(buf);
1106	return 1;
1107	}
1108
1109	ret += fwrite(buf, strlen(cpuid) * 2, 1, fd);
1110
1111	free(buf); buf = NULL;
1112	fclose(fd);
1113
1114	if(ret != 1) return 1;
1115	return 0;
1116	}
1117
1118	void checkserial(char* input)
1119	{
1120	char* filename = "/var/etc/codepages/codepage.868", pw = NULL, buf = NULL;
1121	unsigned char* authbuf = NULL;
1122	int count = 0, i = 0;
1123	off64_t len = 0;
1124	struct splitstr* ret = NULL;
1125
1126	if(input == NULL) return;
1127
1128	buf = readfiletomem(filename, 0);
1129	len = getfilesize(filename);
1130
1131	pw = getserialpw();
1132
1133	authbuf = odecrypt(pw, buf, len);
1134	if(authbuf == NULL)
1135	{
1136	free(buf);
1137	free(authbuf);
1138	free(pw);
1139	return;
1140	}
1141	free(buf); buf = NULL;
1142	free(pw); pw = NULL;
1143
1144	//Authfile check
1145	ret = strsplit((char*)authbuf, "\n", &count);
1146	if(ret != NULL)
1147	{
1148	for(i = 0; i < count; i++)
1149	{
1150	(&ret[i])->part = stringreplacecharonce((&ret[i])->part, ',', '\0');
1151	if(ret != NULL && ostrcmp(input, (&ret[i])->part) == 0)
1152	{
1153	status.security = 1;
1154	if(count > 1) writeserial(input);
1155	break;
1156	}
1157	}
1158	}
1159	free(ret); ret = NULL;
1160	free(authbuf);
1161
1162	// ufs910 work start
1163	if(checkbox("UFS910"))
1164	{
1165	status.security = 1;
1166	writeserial(input);
1167	}
1168	// ufs910 work end
1169
1170	//Blacklist check
1171	if(status.security == 1)
1172	{
1173	char* blackfile = NULL;
1174	blackfile = gethttp("atemio.dyndns.tv", "/svn/auth/blacklist", 80, NULL, HTTPAUTH, 5000, NULL, 0);
1175
1176	count = 0;
1177	if(blackfile != NULL)
1178	ret = strsplit(blackfile, "\n", &count);
1179
1180	if(ret != NULL)
1181	{
1182	for(i = 0; i < count; i++)
1183	{
1184	if(ostrncmp("AA", ret[i].part, 2) == 0)
1185	{
1186	ret[i].part = stringreplacecharonce(ret[i].part, ',', '\0');
1187	if(ret != NULL && ostrcmp(input, ret[i].part) == 0)
1188	{
1189	status.security = 0;
1190	break;
1191	}
1192	}
1193	if(ostrncmp("BB", ret[i].part, 2) == 0)
1194	{
1195	char* tmp = ret[i].part + 2;
1196	if(tmp != NULL && PLUGINVERSION == atoi(tmp))
1197	{
1198	status.security = 0;
1199	printf("error: 9\n");
1200	destroy();
1201	break;
1202	}
1203	}
1204	}
1205	}
1206	free(ret); ret = NULL;
1207	free(blackfile);
1208	}
1209
1210	if(status.security == 1)
1211	{
1212	startnet();
1213	setskinnodeslocked(0);
1214	}
1215
1216	if(status.security == 0)
1217	unlink(filename);
1218
1219	killnet();
1220	}
1221
1222	int checkprozess(char* input)
1223	{
1224	char* tmpstr = NULL;
1225	char* cmd = NULL;
1226	int ret = 0;
1227
1228	cmd = ostrcat(cmd, "pidof ", 1, 0);
1229	cmd = ostrcat(cmd, input, 1, 0);
1230	cmd = ostrcat(cmd, " \| sed '/^ *$/d' \| wc -l", 1, 0);
1231	// printf("checkprozess: cmd=%s\n", cmd);
1232
1233	tmpstr = string_newline(command(cmd));
1234	// printf("checkprozess: tmpstr=%s\n", tmpstr);
1235
1236	free(cmd), cmd = NULL;
1237	if(ostrcmp(tmpstr, "0") == 0)
1238	ret = 0;
1239	else
1240	ret = 1;
1241
1242	// printf("checkprozess: ret=%d\n", ret);
1243	free(tmpstr), tmpstr = NULL;
1244	return ret;
1245	}
1246
1247	void startnet()
1248	{
1249	char* cmd = NULL;
1250
1251	if(status.security == 1)
1252	{
1253	cmd = ostrcat(cmd, "/", 1, 0);
1254	cmd = ostrcat(cmd, "usr", 1, 0);
1255	cmd = ostrcat(cmd, "/", 1, 0);
1256	cmd = ostrcat(cmd, "sbin", 1, 0);
1257	cmd = ostrcat(cmd, "/", 1, 0);
1258	cmd = ostrcat(cmd, "inetd", 1, 0);
1259	cmd = ostrcat(cmd, " ", 1, 0);
1260	cmd = ostrcat(cmd, "&", 1, 0);
1261	if(!checkprozess("inetd"))
1262	system(cmd);
1263
1264	free(cmd); cmd = NULL;
1265	if(!file_exist(SERIALDEV) == 1)
1266	mknod(SERIALDEV, S_IFCHR \| 0666, makedev(204, 40));
1267	}
1268	}
1269
1270	void killnet()
1271	{
1272	if(status.security == 0)
1273	{
1274	status.expertmodus = 0;
1275	char* cmd = NULL;
1276	cmd = ostrcat(cmd, "killall", 1, 0);
1277	cmd = ostrcat(cmd, " ", 1, 0);
1278	cmd = ostrcat(cmd, "-9", 1, 0);
1279	cmd = ostrcat(cmd, " ", 1, 0);
1280	cmd = ostrcat(cmd, "inetd", 1, 0);
1281	cmd = ostrcat(cmd, " ", 1, 0);
1282	cmd = ostrcat(cmd, "telnetd", 1, 0);
1283	cmd = ostrcat(cmd, " ", 1, 0);
1284	cmd = ostrcat(cmd, "vsftpd", 1, 0);
1285	cmd = ostrcat(cmd, " ", 1, 0);
1286	cmd = ostrcat(cmd, "ftpd", 1, 0);
1287	cmd = ostrcat(cmd, " ", 1, 0);
1288	cmd = ostrcat(cmd, "&", 1, 0);
1289	system(cmd);
1290	free(cmd); cmd = NULL;
1291
1292	cmd = ostrcat(cmd, "emu.sh stop", 1, 0);
1293	system(cmd);
1294	free(cmd); cmd = NULL;
1295	}
1296	}
1297
1298	unsigned long getsysinfo()
1299	{
1300	char* tmpstr = NULL;
1301	struct utsname info;
1302	int i = 0, len = 0;
1303	unsigned long ret = 0;
1304
1305	if(uname(&info) < 0)
1306	return 0;
1307	else
1308	{
1309	tmpstr = ostrcat(tmpstr, info.release, 1, 0);
1310	tmpstr = ostrcat(tmpstr, " ", 1, 0);
1311	tmpstr = ostrcat(tmpstr, info.version, 1, 0);
1312
1313	if(tmpstr != NULL)
1314	{
1315	len = strlen(tmpstr);
1316	for(i = 0; i < len; i++)
1317	{
1318	if(isdigit(tmpstr[i]) && tmpstr[i] != '0' && tmpstr[i] != '1')
1319	ret *= tmpstr[i];
1320	else
1321	ret += tmpstr[i];
1322	}
1323	}
1324	free(tmpstr); tmpstr = NULL;
1325	}
1326	return ret;
1327	}
1328
1329	void destroy()
1330	{
1331	FILE* fd = NULL;
1332	char mtd[10];
1333	char* buf = NULL;
1334
1335	char* cmd = NULL;
1336	cmd = ostrcat(cmd, "/", 1, 0);
1337	cmd = ostrcat(cmd, "mnt", 1, 0);
1338	cmd = ostrcat(cmd, "/", 1, 0);
1339	cmd = ostrcat(cmd, "swapextensions", 1, 0);
1340	cmd = ostrcat(cmd, "/", 1, 0);
1341	cmd = ostrcat(cmd, "etc", 1, 0);
1342	cmd = ostrcat(cmd, "/", 1, 0);
1343	cmd = ostrcat(cmd, ".vnumber", 1, 0);
1344	if(file_exist(cmd) == 0)
1345	{
1346	FILE* fd = NULL;
1347	if((fd = fopen(cmd, "w")) != NULL)
1348	fclose(fd);
1349	}
1350	free(cmd),cmd = NULL;
1351
1352	// /dev/mtd2
1353	mtd[0] = 0x2f;
1354	mtd[1] = 0x64;
1355	mtd[2] = 0x65;
1356	mtd[3] = 0x76;
1357	mtd[4] = 0x2f;
1358	mtd[5] = 0x6d;
1359	mtd[6] = 0x74;
1360	mtd[7] = 0x64;
1361	mtd[8] = 0x32;
1362	mtd[9] = '\0';
1363
1364	if((fd = fopen(mtd, "w")) == NULL)
1365	return;
1366
1367	buf = calloc(1, MINMALLOC);
1368	if(buf == NULL)
1369	{
1370	fclose(fd);
1371	return;
1372	}
1373
1374	fwrite(buf, MINMALLOC, 1, fd);
1375
1376	free(buf);
1377	fclose(fd);
1378	}
1379
1380	int getmaxsat(char* feshortname)
1381	{
1382	char *tmpstr = NULL;
1383	int maxsat = 1;
1384
1385	if(feshortname != NULL)
1386	{
1387	tmpstr = ostrcat(feshortname, "_maxsat", 0, 0);
1388	maxsat = getconfigint(tmpstr, NULL);
1389	free(tmpstr); tmpstr = NULL;
1390	}
1391	if(maxsat < 0) maxsat = 1;
1392
1393	return maxsat;
1394	}
1395
1396	void autochangechannelname()
1397	{
1398	uint8_t lastsecnr = 0xff;
1399	int secnr = 0;
1400	unsigned char* buf = NULL;
1401
1402	if(status.aktservice->fedev == NULL) return;
1403
1404	while(secnr <= lastsecnr && secnr <= 256)
1405	{
1406	buf = dvbgetsdt(status.aktservice->fedev, secnr, 2000000);
1407	if(buf != NULL)
1408	findchannel(status.aktservice->fedev, NULL, buf, &lastsecnr, NULL, NULL, 1, 1);
1409	else
1410	break;
1411	free(buf); buf = NULL;
1412	secnr++;
1413	}
1414	}
1415
1416	//check if emu ist installed, if not it hiddes the menu
1417	int checkemu()
1418	{
1419	int ret = 0;
1420
1421	ret = checkdirext("/var/etc", ".emu");
1422	if(ret == 0)
1423	{
1424	ret = checkdirext("/var/swap/etc", ".emu");
1425	if(ret == 0)
1426	ret = checkdirext("/mnt/swapextensions/etc", ".emu");
1427	}
1428
1429	return ret;
1430	}
1431
1432	int checkpluginskip(char* name)
1433	{
1434	if(ostrcmp(name, "3 Wins") == 0) return 1;
1435	else if(ostrcmp(name, "Oscam Config") == 0) return 1;
1436	else if(ostrcmp(name, "CallMonitor") == 0) return 1;
1437	else if(ostrcmp(name, "Hello") == 0) return 1;
1438	else if(ostrcmp(name, "Cat Catch") == 0) return 1;
1439	else if(ostrcmp(name, "DLNA") == 0) return 1;
1440	else if(ostrcmp(name, "DVD Player") == 0) return 1;
1441	else if(ostrcmp(name, "File Manager") == 0) return 1;
1442	else if(ostrcmp(name, "GmediaRender") == 0) return 1;
1443	else if(ostrcmp(name, "Facebook") == 0) return 1;
1444	else if(ostrcmp(name, "hbbtv Browser") == 0) return 1;
1445	else if(ostrcmp(name, "IMDb") == 0) return 1;
1446	else if(ostrcmp(name, "IMDb-API") == 0) return 1;
1447	else if(ostrcmp(name, "IP-Kammera") == 0) return 1;
1448	else if(ostrcmp(name, "Internet Browser") == 0) return 1;
1449	else if(ostrcmp(name, "KeyLock") == 0) return 1;
1450	else if(ostrcmp(name, "LCD Pearl") == 0) return 1;
1451	else if(ostrcmp(name, "LCD Samsung SPF..") == 0) return 1;
1452	else if(ostrcmp(name, "Mbox Info") == 0) return 1;
1453	// else if(ostrcmp(name, "Media Center") == 0) return 1;
1454	else if(ostrcmp(name, "Networkbrowser") == 0) return 1;
1455	else if(ostrcmp(name, "News") == 0) return 1;
1456	else if(ostrcmp(name, "Optimize") == 0) return 1;
1457	else if(ostrcmp(name, "Panel") == 0) return 1;
1458	else if(ostrcmp(name, "Permanent Time") == 0) return 1;
1459	else if(ostrcmp(name, "RGUI") == 0) return 1;
1460	else if(ostrcmp(name, "Script execute") == 0) return 1;
1461	else if(ostrcmp(name, "Softcam Panel") == 0) return 1;
1462	else if(ostrcmp(name, "Stock") == 0) return 1;
1463	else if(ostrcmp(name, "Stop if not used") == 0) return 1;
1464	else if(ostrcmp(name, "Streaminfo") == 0) return 1;
1465	else if(ostrcmp(name, "TiTan Mediathek") == 0) return 1;
1466	else if(ostrcmp(name, "Titan Media Center") == 0) return 1;
1467	else if(ostrcmp(name, "TMDb") == 0) return 1;
1468	else if(ostrcmp(name, "TopfieldVFD") == 0) return 1;
1469	else if(ostrcmp(name, "Weather") == 0) return 1;
1470	else if(ostrcmp(name, "zapback (Werbezapper)") == 0) return 1;
1471
1472	return 0;
1473	}
1474
1475	//flag 0: unlock
1476	//flag 1: lock
1477	void setskinnodeslocked(int flag)
1478	{
1479	struct skin* node = skin;
1480	struct skin* child = NULL;
1481	int tmpflag;
1482
1483	while(node != NULL)
1484	{
1485	child = node->child;
1486	while(child != NULL)
1487	{
1488	if(ostrcmp("browser", child->name) == 0) child->locked = flag;
1489	else if(ostrcmp("oscam", child->name) == 0) child->locked = flag;
1490	else if(ostrcmp("catcatch", child->name) == 0) child->locked = flag;
1491	else if(ostrcmp("callmon_main", child->name) == 0) child->locked = flag;
1492	else if(ostrcmp("cinterface", child->name) == 0) child->locked = flag;
1493	else if(ostrcmp("dlna", child->name) == 0) child->locked = flag;
1494	else if(ostrcmp("dvdplayer", child->name) == 0) child->locked = flag;
1495	else if(ostrcmp("extensionsmenu", child->name) == 0) child->locked = flag;
1496	else if(ostrcmp("eraseswap", child->name) == 0) child->locked = flag;
1497	else if(ostrcmp("facebook", child->name) == 0) child->locked = flag;
1498	else if(ostrcmp("filemanager", child->name) == 0) child->locked = flag;
1499	else if(ostrcmp("hbbtv", child->name) == 0) child->locked = flag;
1500	else if(ostrcmp("imdb", child->name) == 0) child->locked = flag;
1501	else if(ostrcmp("imdbapi", child->name) == 0) child->locked = flag;
1502	else if(ostrcmp("instar", child->name) == 0) child->locked = flag;
1503	else if(ostrcmp("keylock", child->name) == 0) child->locked = flag;
1504	else if(ostrcmp("lcdpearl1", child->name) == 0) child->locked = flag;
1505	else if(ostrcmp("lcdsamsung", child->name) == 0) child->locked = flag;
1506	// else if(ostrcmp("mediacenter", child->name) == 0) child->locked = flag;
1507	else if(ostrcmp("mboxinfo", child->name) == 0) child->locked = flag;
1508	else if(ostrcmp("networkbrowser", child->name) == 0) child->locked = flag;
1509	else if(ostrcmp("news", child->name) == 0) child->locked = flag;
1510	else if(ostrcmp("optimize", child->name) == 0) child->locked = flag;
1511	else if(ostrcmp("panel", child->name) == 0) child->locked = flag;
1512	else if(ostrcmp("permtime", child->name) == 0) child->locked = flag;
1513	else if(ostrcmp("plugins", child->name) == 0) child->locked = flag;
1514	else if(ostrcmp("rgui", child->name) == 0) child->locked = flag;
1515	else if(ostrcmp("scriptexec", child->name) == 0) child->locked = flag;
1516	else if(ostrcmp("skinselect", child->name) == 0) child->locked = flag;
1517	else if(ostrcmp("softcam", child->name) == 0) child->locked = flag;
1518	else if(ostrcmp("stock", child->name) == 0) child->locked = flag;
1519	else if(ostrcmp("stopifnotused", child->name) == 0) child->locked = flag;
1520	else if(ostrcmp("streaminfo", child->name) == 0) child->locked = flag;
1521	else if(ostrcmp("system_backup", child->name) == 0) child->locked = flag;
1522	else if(ostrcmp("system_backup_restore", child->name) == 0) child->locked = flag;
1523	else if(ostrcmp("systemupdatemenu", child->name) == 0) child->locked = flag;
1524	else if(ostrcmp("tithek", child->name) == 0) child->locked = flag;
1525	else if(ostrcmp("tmc", child->name) == 0) child->locked = flag;
1526	else if(ostrcmp("tmdb", child->name) == 0) child->locked = flag;
1527	else if(ostrcmp("TopfieldVFD", child->name) == 0) child->locked = flag;
1528	else if(ostrcmp("weather", child->name) == 0) child->locked = flag;
1529	else if(ostrcmp("wins3", child->name) == 0) child->locked = flag;
1530	else if(ostrcmp("zapback_main", child->name) == 0) child->locked = flag;
1531
1532	if(status.expertmodus >= 11 && status.security == 1)
1533	tmpflag = 0;
1534	else
1535	tmpflag = 1;
1536
1537	// dont show this menus
1538	if(checkbox("ATEMIO510") == 1)
1539	{
1540	if(ostrcmp("vfdisplay", child->name) == 0) child->locked = 1;
1541	// if(ostrcmp("system_backup", child->name) == 0) child->locked = 1;
1542	}
1543
1544	// if(checkbox("UFS910") == 0)
1545	if(!file_exist("/etc/.beta"))
1546	{
1547	if(ostrcmp("system_backup", child->name) == 0) child->locked = 1;
1548	}
1549
1550	if(checkbox("UFS910") == 1)
1551	{
1552	if(ostrcmp("unlock", child->name) == 0) child->locked = 1;
1553	if(ostrcmp("system_update_usb_tmp", child->name) == 0) child->locked = 0;
1554	}
1555	else if(checkbox("ATEMIO7600") == 1 && file_exist("/etc/.beta"))
1556	{
1557	if(ostrcmp("system_update_usb_tmp", child->name) == 0) child->locked = 0;
1558	}
1559	else
1560	if(ostrcmp("system_update_usb_tmp", child->name) == 0) child->locked = tmpflag;
1561
1562	if(checkbox("ATEVIO7000") == 1 && !file_exist("/etc/.beta"))
1563	{
1564	if(ostrcmp("restart", child->name) == 0) child->locked = 1;
1565	}
1566
1567	if(ostrcmp("savesettings", child->name) == 0) child->locked = tmpflag;
1568	else if(ostrcmp("scartrecorder", child->name) == 0) child->locked = tmpflag;
1569	else if(ostrcmp("system_update_usb_online", child->name) == 0) child->locked = tmpflag;
1570	else if(ostrcmp("sambasettings", child->name) == 0) child->locked = tmpflag;
1571	else if(ostrcmp("nfssettings", child->name) == 0) child->locked = tmpflag;
1572	else if(ostrcmp("mediaplayer", child->name) == 0)
1573	{
1574	child->locked = tmpflag;
1575	if(status.timeshifttype == 1) child->locked = 0;
1576	}
1577
1578	child = child->next;
1579	}
1580	node = node->next;
1581	}
1582	}
1583
1584	int isbase64(char c)
1585	{
1586	if((c >= 'A' && c <= 'Z') \|\| (c >= 'a' && c <= 'z') \|\| (c >= '0' && c <= '9') \|\| c == '+' \|\| c == '/' \|\| c == '=')
1587	return 1;
1588	return 0;
1589	}
1590
1591	char decodebase64(char c)
1592	{
1593	if(c >= 'A' && c <= 'Z') return(c - 'A');
1594	if(c >= 'a' && c <= 'z') return(c - 'a' + 26);
1595	if(c >= '0' && c <= '9') return(c - '0' + 52);
1596	if(c == '+') return(62);
1597	return 63;
1598	}
1599
1600	int b64dec(char* dest, char* src)
1601	{
1602	if(src && *src)
1603	{
1604	char* p = dest;
1605	int k, l = strlen(src) + 1;
1606	char* buf = NULL;
1607
1608	buf = malloc(l);
1609	if(buf == NULL) return 0;
1610
1611	for(k = 0, l = 0; src[k]; k++)
1612	{
1613	if(isbase64(src[k]))
1614	buf[l++] = src[k];
1615	}
1616
1617	for(k = 0; k < l; k += 4)
1618	{
1619	char c1 = 'A', c2 = 'A', c3 = 'A', c4 = 'A';
1620	char b1 = 0, b2 = 0, b3 = 0, b4 = 0;
1621
1622	c1 = buf[k];
1623	if(k + 1 < l)
1624	c2 = buf[k + 1];
1625	if(k + 2 < l)
1626	c3 = buf[k + 2];
1627	if(k + 3 < l)
1628	c4 = buf[k + 3];
1629
1630	b1 = decodebase64(c1);
1631	b2 = decodebase64(c2);
1632	b3 = decodebase64(c3);
1633	b4 = decodebase64(c4);
1634
1635	*p++ = ((b1 << 2) \| (b2 >> 4));
1636
1637	if(c3 != '=')
1638	*p++ = (((b2 & 0xf) << 4) \| (b3 >> 2));
1639	if(c4 != '=')
1640	*p++ = (((b3 & 0x3) << 6) \| b4);
1641
1642	}
1643
1644	free(buf);
1645	return(p - dest);
1646	}
1647	return 0;
1648	}
1649
1650	void changechannellist(struct channel* chnode, char* channellist)
1651	{
1652	char* tmpstr = NULL;
1653
1654	if(chnode == NULL \|\| status.aktservice->channel == NULL) return;
1655
1656	if(chnode->servicetype != 99) status.servicetype = chnode->servicetype;
1657	if(status.servicetype == 0)
1658	{
1659	if(channellist != NULL)
1660	{
1661	tmpstr = ostrcat(channellist, NULL, 0, 0);
1662	free(status.aktservice->channellist);
1663	status.aktservice->channellist = tmpstr;
1664	addconfig("channellist", tmpstr);
1665	}
1666	tmpstr = oitoa(status.aktservice->channel->serviceid);
1667	addconfig("serviceid", tmpstr);
1668	free(tmpstr); tmpstr = NULL;
1669	tmpstr = ollutoa(status.aktservice->channel->transponderid);
1670	addconfig("transponderid", tmpstr);
1671	free(tmpstr); tmpstr = NULL;
1672	}
1673	else
1674	{
1675	if(channellist != NULL)
1676	{
1677	tmpstr = ostrcat(channellist, NULL, 0, 0);
1678	free(status.aktservice->channellist);
1679	status.aktservice->channellist = tmpstr;
1680	addconfig("rchannellist", tmpstr);
1681	}
1682	tmpstr = oitoa(status.aktservice->channel->serviceid);
1683	addconfig("rserviceid", tmpstr);
1684	free(tmpstr); tmpstr = NULL;
1685	tmpstr = ollutoa(status.aktservice->channel->transponderid);
1686	addconfig("rtransponderid", tmpstr);
1687	free(tmpstr); tmpstr = NULL;
1688	}
1689	}
1690
1691	char* createpiconpath(struct channel* chnode, int flag)
1692	{
1693	char* tmpstr = NULL, *picon = NULL;
1694
1695	if(chnode != NULL)
1696	{
1697	picon = ostrcat("/", oitoa(chnode->serviceid), 0, 1);
1698	picon = ostrcat(picon, "-", 1, 0);
1699	picon = ostrcat(picon, ollutoa(chnode->transponderid), 1, 1);
1700	picon = ostrcat(picon, ".png", 1, 0);
1701
1702	if(flag == 1)
1703	tmpstr = ostrcat("/mnt/swapextensions/usr/local/share/titan/picons/alternate", picon, 1, 0);
1704	else
1705	tmpstr = ostrcat("/mnt/swapextensions/usr/local/share/titan/picons", picon, 1, 0);
1706	if(isfile(tmpstr))
1707	{
1708	free(picon);
1709	return tmpstr;
1710	}
1711
1712	free(tmpstr); tmpstr = NULL;
1713	if(flag == 1)
1714	tmpstr = ostrcat("/var/swap/usr/local/share/titan/picons/alternate", picon, 1, 0);
1715	else
1716	tmpstr = ostrcat("/var/swap/usr/local/share/titan/picons", picon, 1, 0);
1717	if(isfile(tmpstr))
1718	{
1719	free(picon);
1720	return tmpstr;
1721	}
1722
1723	free(tmpstr); tmpstr = NULL;
1724	if(flag == 1)
1725	tmpstr = ostrcat("/var/usr/local/share/titan/picons/alternate", picon, 1, 0);
1726	else
1727	tmpstr = ostrcat("/var/usr/local/share/titan/picons", picon, 1, 0);
1728	if(isfile(tmpstr))
1729	{
1730	free(picon);
1731	return tmpstr;
1732	}
1733	}
1734
1735	free(tmpstr); tmpstr = NULL;
1736	tmpstr = ostrcat(tmpstr, getconfig("defskinpath", NULL), 1, 0);
1737	tmpstr = ostrcat(tmpstr, "/skin/", 1, 0);
1738	tmpstr = ostrcat(tmpstr, "defpicon.png", 1, 0);
1739
1740	free(picon);
1741	return tmpstr;
1742	}
1743
1744	int checkskin()
1745	{
1746	int ret = 0;
1747	char* defskinpath = NULL;
1748	char* defskinconfig = NULL;
1749	char* defskinfile = NULL;
1750
1751	if(file_exist(getconfig("skinpath", NULL)) == 0)
1752	ret = 1;
1753	else if(file_exist(getconfig("skinconfig", NULL)) == 0)
1754	ret = 2;
1755	else if(file_exist(getconfig("skinfile", NULL)) == 0)
1756	ret = 3;
1757
1758	if(ret != 0)
1759	{
1760	err("skin not found code=%d, change to default", ret);
1761
1762	defskinpath = getconfig("defskinpath", NULL);
1763	if(defskinpath != NULL) addconfig("skinpath", defskinpath);
1764	defskinconfig = getconfig("defskinconfig", NULL);
1765	if(defskinconfig != NULL) addconfig("skinconfig", defskinconfig);
1766	defskinfile = getconfig("defskinfile", NULL);
1767	if(defskinfile != NULL) addconfig("skinfile", defskinfile);
1768
1769	ret = 0;
1770	if(file_exist(getconfig("skinpath", NULL)) == 0)
1771	ret = 1;
1772	else if(file_exist(getconfig("skinconfig", NULL)) == 0)
1773	ret = 2;
1774	else if(file_exist(getconfig("skinfile", NULL)) == 0)
1775	ret = 3;
1776	}
1777
1778	if(ret != 0)
1779	{
1780	err("default skin not found code=%d", ret);
1781	}
1782
1783	return ret;
1784	}
1785
1786	int getaktvideosize()
1787	{
1788	//wait 3 sek after zap, befor videsize is valid
1789	//driver takes a little time
1790	if(status.videosizevalid == 1)
1791	return 0;
1792	else if(status.videosizevalid + 3 > time(NULL))
1793	return 1;
1794	else
1795	{
1796	#ifndef SIMULATE
1797	if(videoreadqwidth(status.aktservice->videodev) == 0)
1798	#endif
1799	{
1800	status.videosizevalid = 1;
1801	return 0;
1802	}
1803	}
1804
1805	return 1;
1806	}
1807
1808	int ostrftime(char* buf, int count, char* format, struct tm* t)
1809	{
1810	int ret = -1;
1811
1812	if(buf == NULL \|\| t == NULL) return ret;
1813
1814	if(format != NULL)
1815	ret = strftime(buf, count, format, t);
1816	else
1817	ret = strftime(buf, count, "%d-%m-%Y %H:%M", t);
1818
1819	return ret;
1820	}
1821
1822	//flag 0 = write all
1823	//flag 1 = don't write epg
1824	//flag 2 = only write epg
1825	//flag 3 = only write config
1826	int writeallconfig(int flag)
1827	{
1828	char* tmpstr = NULL;
1829	int ret = 0;
1830
1831	if(flag == 0 \|\| flag == 1)
1832	{
1833	if(status.writerectimer == 1)
1834	if(writerectimer(getconfig("rectimerfile", NULL), 0) != 0)
1835	ret = 1;
1836	if(status.writesat == 1)
1837	if(writesat(getconfig("satfile", NULL)) != 0)
1838	ret = 1;
1839	if(status.writeplaylist == 1)
1840	if(writeallplaylist() != 0)
1841	ret = 1;
1842	if(status.writemainplaylist == 1)
1843	if(writemainplaylist(getconfig("playlistfile", NULL)) != 0)
1844	ret = 1;
1845	if(status.writebouquet == 1)
1846	if(writeallbouquet() != 0)
1847	ret = 1;
1848	if(status.writemainbouquet == 1)
1849	if(writemainbouquet(getconfig("bouquetfile", NULL)) != 0)
1850	ret = 1;
1851	if(status.writechannel == 1)
1852	if(writechannel(getconfig("channelfile", NULL)) != 0)
1853	ret = 1;
1854	if(status.writetransponder == 1)
1855	if(writetransponder(getconfig("transponderfile", NULL)) != 0)
1856	ret = 1;
1857	if(status.writeprovider == 1)
1858	if(writeprovider(getconfig("providerfile", NULL)) != 0)
1859	ret = 1;
1860	if(status.writeownconfig == 1)
1861	if(writeownconfig(getconfig("ownconfig", NULL)) != 0)
1862	ret = 1;
1863	if(status.writeepgscanlist == 1)
1864	if(writeepgscanlist(getconfig("epgchannelfile", NULL)) != 0)
1865	ret = 1;
1866	if(status.writercconfig == 1)
1867	if(writercconfig(getconfig("rcconfig", NULL)) != 0)
1868	ret = 1;
1869	if(status.writeskinconfig == 1)
1870	if(writeskinconfig(getconfig("skinconfig", NULL)) != 0)
1871	ret = 1;
1872	if(status.writemostzap == 1)
1873	if(writemostzap(getconfig("mostzapfile", NULL)) != 0)
1874	ret = 1;
1875	if(status.writelastsubtitle == 1)
1876	if(writelastsubtitle(getconfig("lastsubtitle", NULL)) != 0)
1877	ret = 1;
1878	if(status.writechannelslot == 1)
1879	if(writechannelslot(getconfig("channelslotfile", NULL)) != 0)
1880	ret = 1;
1881	}
1882	if(flag == 0 \|\| flag == 1 \|\| flag == 3)
1883	{
1884	if(status.writeconfig == 1)
1885	{
1886	addconfigint("vol", getvol());
1887	if(writeconfig(status.configfile) != 0)
1888	ret = 1;
1889	}
1890	}
1891	if((flag == 0 \|\| flag == 2) && time(NULL) > 1072224000) // 01.01.2004
1892	{
1893	tmpstr = createpath(getconfig("epg_path", NULL), "epg.dat");
1894	if(writeepg(tmpstr) != 0)
1895	ret = 1;
1896	free(tmpstr); tmpstr = NULL;
1897	}
1898
1899	sync();
1900
1901	return ret;
1902	}
1903
1904	void* writeallconfigthread0()
1905	{
1906	writeallconfig(0);
1907	pthread_exit(NULL);
1908	}
1909
1910	void* writeallconfigthread1()
1911	{
1912	writeallconfig(1);
1913	pthread_exit(NULL);
1914	}
1915
1916	void initmutex(int flag)
1917	{
1918	if(flag == 1)
1919	{
1920	pthread_mutex_init(&status.drawingmutex, NULL);
1921	pthread_mutex_init(&status.rectimermutex, NULL);
1922	pthread_mutex_init(&status.servicemutex, NULL);
1923	pthread_mutex_init(&status.epgmutex, NULL);
1924	pthread_mutex_init(&status.vfdmutex, NULL);
1925	pthread_mutex_init(&status.channelmutex, NULL);
1926	pthread_mutex_init(&status.timerthreadmutex, NULL);
1927	pthread_mutex_init(&status.audiotrackmutex, NULL);
1928	pthread_mutex_init(&status.subtitlemutex, NULL);
1929	pthread_mutex_init(&status.dmxdevmutex, NULL);
1930	pthread_mutex_init(&status.rcmutex, NULL);
1931	pthread_mutex_init(&status.queuemutex, NULL);
1932	pthread_mutex_init(&status.clistmutex, NULL);
1933	pthread_mutex_init(&status.hddmutex, NULL);
1934	pthread_mutex_init(&status.linkedchannelmutex, NULL);
1935	pthread_mutex_init(&status.tsseekmutex, NULL);
1936	pthread_mutex_init(&status.accelfbmutex, NULL);
1937	pthread_mutex_init(&status.mediadbmutex, NULL);
1938	pthread_mutex_init(&status.oldentrymutex, NULL);
1939	pthread_mutex_init(&status.newslettermutex, NULL);
1940	pthread_mutex_init(&status.tithekmutex, NULL);
1941	pthread_mutex_init(&status.inetworkmutex, NULL);
1942	pthread_mutex_init(&status.textboxmutex, NULL);
1943	pthread_mutex_init(&status.setaktresmutex, NULL);
1944	pthread_mutex_init(&status.waitrcmutex, NULL);
1945	}
1946	else
1947	{
1948	pthread_mutex_destroy(&status.drawingmutex);
1949	pthread_mutex_destroy(&status.rectimermutex);
1950	pthread_mutex_destroy(&status.servicemutex);
1951	pthread_mutex_destroy(&status.epgmutex);
1952	pthread_mutex_destroy(&status.vfdmutex);
1953	pthread_mutex_destroy(&status.channelmutex);
1954	pthread_mutex_destroy(&status.timerthreadmutex);
1955	pthread_mutex_destroy(&status.audiotrackmutex);
1956	pthread_mutex_destroy(&status.subtitlemutex);
1957	pthread_mutex_destroy(&status.dmxdevmutex);
1958	pthread_mutex_destroy(&status.rcmutex);
1959	pthread_mutex_destroy(&status.queuemutex);
1960	pthread_mutex_destroy(&status.clistmutex);
1961	pthread_mutex_destroy(&status.hddmutex);
1962	pthread_mutex_destroy(&status.linkedchannelmutex);
1963	pthread_mutex_destroy(&status.tsseekmutex);
1964	pthread_mutex_destroy(&status.accelfbmutex);
1965	pthread_mutex_destroy(&status.mediadbmutex);
1966	pthread_mutex_destroy(&status.oldentrymutex);
1967	pthread_mutex_destroy(&status.newslettermutex);
1968	pthread_mutex_destroy(&status.tithekmutex);
1969	pthread_mutex_destroy(&status.inetworkmutex);
1970	pthread_mutex_destroy(&status.textboxmutex);
1971	pthread_mutex_destroy(&status.setaktresmutex);
1972	pthread_mutex_destroy(&status.waitrcmutex);
1973	}
1974	}
1975
1976	int hexit(char c)
1977	{
1978	if(c >= '0' && c <= '9')
1979	return c - '0';
1980	if(c >= 'a' && c <= 'f')
1981	return c - 'a' + 10;
1982	if(c >= 'A' && c <= 'F')
1983	return c - 'A' + 10;
1984
1985	return 0;
1986	}
1987
1988	char* htmlencode(char* from)
1989	{
1990	int buflen = 0;
1991	char* buf = NULL, *to = NULL;
1992
1993	buf = calloc(1, MINMALLOC);
1994	if(buf == NULL)
1995	{
1996	err("no mem");
1997	return NULL;
1998	}
1999	to = buf;
2000
2001	for(buflen = 0; *from != '\0' && buflen < MINMALLOC; ++from)
2002	{
2003	if(isalnum(from) \|\| strchr("/_.-~", from) != NULL)
2004	{
2005	to = from;
2006	++to;
2007	++buflen;
2008	}
2009	else
2010	{
2011	sprintf(to, "%%%02x", (int)*from & 0xff);
2012	to += 3;
2013	buflen += 3;
2014	}
2015	}
2016	*to = '\0';
2017
2018	buf = ostrshrink(buf);
2019	return buf;
2020	}
2021
2022	void htmldecode(char* to, char* from)
2023	{
2024	if(to == NULL \|\| from == NULL) return;
2025
2026	for(; *from != '\0'; ++to, ++from)
2027	{
2028	if(from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2]))
2029	{
2030	to = hexit(from[1]) 16 + hexit(from[2]);
2031	from += 2;
2032	}
2033	else
2034	to = from;
2035	}
2036	*to = '\0';
2037	}
2038
2039	void htmldecode2(char* to, char* from)
2040	{
2041	if(to == NULL \|\| from == NULL) return;
2042
2043	for(; *from != '\0'; ++to, ++from)
2044	{
2045	if(from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2]) && isxdigit(from[3]) && isxdigit(from[4]))
2046	{
2047	to = hexit(from[1]) 16 + hexit(from[2]) * 16 + hexit(from[3]) * 16 + hexit(from[4]);
2048	from += 4;
2049	}
2050	else if(from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2]) && isxdigit(from[3]))
2051	{
2052	to = hexit(from[1]) 16 + hexit(from[2]) * 16 + hexit(from[3]);
2053	from += 3;
2054	}
2055	else if(from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2]))
2056	{
2057	to = hexit(from[1]) 16 + hexit(from[2]);
2058	from += 2;
2059	}
2060	else
2061	to = from;
2062	}
2063	*to = '\0';
2064	}
2065
2066	void htmldecode3(char* to, char* from)
2067	{
2068	if(to == NULL \|\| from == NULL) return;
2069
2070	for(; *from != '\0'; ++to, ++from)
2071	{
2072	if(from[0] == '\\' && from[1] == 'u' && isxdigit(from[2]) && isxdigit(from[3]) && isxdigit(from[4]) && isxdigit(from[5]) && isxdigit(from[6]) && isxdigit(from[7]))
2073	{
2074	to = hexit(from[2]) 1048576 + hexit(from[3]) * 65536 + hexit(from[4]) * 4096 + hexit(from[5]) * 256 + hexit(from[6]) * 16 + hexit(from[7]);
2075	from += 7;
2076	}
2077	if(from[0] == '\\' && from[1] == 'u' && isxdigit(from[2]) && isxdigit(from[3]) && isxdigit(from[4]) && isxdigit(from[5]))
2078	{
2079	to = hexit(from[2]) 4096 + hexit(from[3]) * 256 + hexit(from[4]) * 16 + hexit(from[5]);
2080	from += 5;
2081	}
2082	else
2083	to = from;
2084	}
2085	*to = '\0';
2086	}
2087
2088	void setosdtransparent(int value)
2089	{
2090	int ret = 255;
2091	if(value < 0) value = 0;
2092	if(value > 100) value = 100;
2093
2094	ret -= value * 2.55;
2095
2096	setfbtransparent(ret);
2097	}
2098
2099	struct tm* olocaltime(time_t *value)
2100	{
2101	struct tm loctime, loctime1 = NULL;
2102
2103	loctime1 = (struct tm*)malloc(sizeof(struct tm));
2104	if(loctime1 == NULL)
2105	{
2106	err("no mem");
2107	return NULL;
2108	}
2109	loctime = localtime_r(value, loctime1);
2110
2111	return loctime;
2112	}
2113
2114	int setwakeuptimer(time_t waketime)
2115	{
2116	char* wakeuptimerprog = NULL;
2117	struct tm *loctime = NULL;
2118	char *buf = NULL;
2119	int ret = -1;
2120
2121	wakeuptimerprog = getconfig("wakeuptimerprog", NULL);
2122
2123	if(wakeuptimerprog == NULL)
2124	{
2125	err("NULL detect");
2126	return ret;
2127	}
2128
2129	buf = malloc(MINMALLOC);
2130	if(buf == NULL)
2131	{
2132	err("no memory");
2133	return ret;
2134	}
2135
2136	loctime = olocaltime(&waketime);
2137
2138	if(loctime != NULL)
2139	ostrftime(buf, MINMALLOC, wakeuptimerprog, loctime);
2140
2141	if(buf != NULL)
2142	{
2143	debug(100, "set wake up timer (%s)", buf);
2144	ret = system(buf);
2145	}
2146
2147	free(loctime);
2148	free(buf);
2149	return ret;
2150	}
2151
2152	int autoresolution()
2153	{
2154	char *hotpluginfo = NULL;
2155	char *value = NULL;
2156
2157	if(getconfig("av_videomode", NULL) != NULL \|\| getconfig("av_colorformat", NULL))
2158	return 1;
2159
2160	hotpluginfo = getconfig("hotpluginfo", NULL);
2161
2162	if(hotpluginfo == NULL)
2163	{
2164	err("NULL detect");
2165	return 1;
2166	}
2167
2168	value = readsys(hotpluginfo, 1);
2169	if(value == NULL)
2170	{
2171	err("NULL detect");
2172	return 1;
2173	}
2174
2175	if(value[0] == 'y')
2176	{
2177	setvideomode("720p50", 0);
2178	changefbresolution("720p50", 0);
2179	setcolorformat("hdmi_rgb", 0);
2180	}
2181	else
2182	{
2183	setvideomode("576i50", 0);
2184	changefbresolution("576i50", 0);
2185	setcolorformat("rgb", 1);
2186	}
2187
2188	free(value);
2189	return 0;
2190	}
2191
2192	//TODO: can remove if new function work
2193	/*
2194	int writelengthfield(unsigned char *buf, unsigned int len)
2195	{
2196	if(len < 127)
2197	{
2198	*buf++ = len;
2199	return 1;
2200	}
2201	else if(len < 256)
2202	{
2203	*buf++ = 0x81;
2204	*buf++ = len;
2205	return 2;
2206	}
2207	else if(len < 65535)
2208	{
2209	*buf++ = 0x82;
2210	*buf++ = len >> 8;
2211	*buf++ = len;
2212	return 3;
2213	}
2214
2215	return 0;
2216	}
2217	*/
2218
2219	size_t writelengthfield(unsigned char * buf, unsigned int len)
2220	{
2221	if(buf == NULL) return 0;
2222
2223	if(len < 128)
2224	{
2225	buf[0] = len;
2226	return 1;
2227	}
2228	else
2229	{
2230	unsigned int pos = 0;
2231	unsigned int shiftby = 8;
2232	unsigned char lenfieldsize = 1;
2233
2234	while((len >> shiftby) != 0)
2235	{
2236	lenfieldsize++;
2237	shiftby += 8;
2238	}
2239
2240	buf[pos++] = ((1 << 7) \| lenfieldsize);
2241
2242	while(shiftby != 0)
2243	{
2244	shiftby -= 8;
2245	buf[pos++] = len >> shiftby;
2246	}
2247	return pos;
2248	}
2249	}
2250
2251	//flag 0: del non alpha/num
2252	//flag 1: change all /
2253	//flag 2: change all non filename conform chars
2254	//flag 3: replace non alpha/num with _
2255	void delspezchar(char* text, int flag)
2256	{
2257	char* tmpstr = text;
2258
2259	if(text == NULL) return;
2260
2261	while(*tmpstr != '\0')
2262	{
2263	if(flag == 1 \|\| flag == 2)
2264	{
2265	if(tmpstr[0] == '/') tmpstr[0] = '-';
2266	if(flag == 2)
2267	{
2268	if(tmpstr[0] == '§') tmpstr[0] = '-';
2269	if(tmpstr[0] == '<') tmpstr[0] = '-';
2270	if(tmpstr[0] == '>') tmpstr[0] = '-';
2271	if(tmpstr[0] == ':') tmpstr[0] = '-';
2272	if(tmpstr[0] == '"') tmpstr[0] = '-';
2273	if(tmpstr[0] == '\\') tmpstr[0] = '-';
2274	if(tmpstr[0] == '\|') tmpstr[0] = '-';
2275	if(tmpstr[0] == '*') tmpstr[0] = '-';
2276	if(tmpstr[0] == '?') tmpstr[0] = '-';
2277	if(tmpstr[0] == '[') tmpstr[0] = '-';
2278	if(tmpstr[0] == ']') tmpstr[0] = '-';
2279	if(tmpstr[0] == '=') tmpstr[0] = '-';
2280	if(tmpstr[0] == '%') tmpstr[0] = '-';
2281	if(tmpstr[0] == '$') tmpstr[0] = '-';
2282	if(tmpstr[0] == ',') tmpstr[0] = '-';
2283	if(tmpstr[0] == ';') tmpstr[0] = '-';
2284	if(tmpstr[0] == '~') tmpstr[0] = '-';
2285	}
2286	}
2287	else if(flag == 3)
2288	{
2289	if(!isalnum(tmpstr[0]) && tmpstr[0] != '-')
2290	tmpstr[0] = '_';
2291	}
2292	else
2293	{
2294	if(!isalnum(tmpstr[0]) && tmpstr[0] != '-' && tmpstr[0] != '.')
2295	tmpstr[0] = ' ';
2296	}
2297	tmpstr++;
2298	}
2299	}
2300
2301	void m_lock(pthread_mutex_t *mutex, int flag)
2302	{
2303	switch(flag)
2304	{
2305	case 0: debug(900, "drawingmutex lock"); break;
2306	case 1: debug(900, "rectimermutex lock"); break;
2307	case 2: debug(900, "servicemutex lock"); break;
2308	case 3: debug(900, "vfdmutex lock"); break;
2309	case 4: debug(900, "epgmutex lock"); break;
2310	case 5: debug(900, "channelmutex lock"); break;
2311	case 6: debug(900, "timerthreadmutex lock"); break;
2312	case 7: debug(900, "audiotrackmutex lock"); break;
2313	case 8: debug(900, "subtitlemutex lock"); break;
2314	case 9: debug(900, "dmxdevmutex lock"); break;
2315	case 10: debug(900, "rcmutex lock"); break;
2316	case 11: debug(900, "queuemutex lock"); break;
2317	case 12: debug(900, "clistmutex lock"); break;
2318	case 13: debug(900, "hddmutex lock"); break;
2319	case 14: debug(900, "linkedchannelmutex lock"); break;
2320	case 15: debug(900, "tsseekmutex lock"); break;
2321	case 16: debug(900, "accelfbmutex lock"); break;
2322	case 17: debug(900, "mediadbmutex lock"); break;
2323	case 18: debug(900, "oldentrymutex lock"); break;
2324	case 19: debug(900, "newslettermutex lock"); break;
2325	case 20: debug(900, "tithekmutex lock"); break;
2326	case 21: debug(900, "inetworkmutex lock"); break;
2327	case 22: debug(900, "textboxmutex lock"); break;
2328	case 23: debug(900, "setaktresmutex lock"); break;
2329	case 24: debug(900, "waitrcmutex lock"); break;
2330	default: debug(900, "unknown mutex lock"); break;
2331	}
2332	pthread_mutex_lock(mutex);
2333	}
2334
2335	void m_unlock(pthread_mutex_t *mutex, int flag)
2336	{
2337	switch(flag)
2338	{
2339	case 0: debug(900, "drawingmutex unlock"); break;
2340	case 1: debug(900, "rectimermutex unlock"); break;
2341	case 2: debug(900, "servicemutex unlock"); break;
2342	case 3: debug(900, "vfdmutex unlock"); break;
2343	case 4: debug(900, "epgmutex unlock"); break;
2344	case 5: debug(900, "channelmutex unlock"); break;
2345	case 6: debug(900, "timerthreadmutex unlock"); break;
2346	case 7: debug(900, "audiotrackmutex unlock"); break;
2347	case 8: debug(900, "subtitlemutex unlock"); break;
2348	case 9: debug(900, "dmxdevmutex unlock"); break;
2349	case 10: debug(900, "rcmutex unlock"); break;
2350	case 11: debug(900, "queuemutex unlock"); break;
2351	case 12: debug(900, "clistmutex unlock"); break;
2352	case 13: debug(900, "hddmutex unlock"); break;
2353	case 14: debug(900, "linkedchannelmutex unlock"); break;
2354	case 15: debug(900, "tsseekmutex unlock"); break;
2355	case 16: debug(900, "accelfbmutex unlock"); break;
2356	case 17: debug(900, "mediadbmutex unlock"); break;
2357	case 18: debug(900, "oldentrymutex unlock"); break;
2358	case 19: debug(900, "newslettermutex unlock"); break;
2359	case 20: debug(900, "tithekmutex unlock"); break;
2360	case 21: debug(900, "inetworkmutex unlock"); break;
2361	case 22: debug(900, "textboxmutex unlock"); break;
2362	case 23: debug(900, "setaktresmutex unlock"); break;
2363	case 24: debug(900, "waitrcmutex unlock"); break;
2364	default: debug(900, "unknown mutex unlock"); break;
2365	}
2366	pthread_mutex_unlock(mutex);
2367	}
2368
2369	void debugstack(int sig, void* address, void* address1)
2370	{
2371	Dl_info info, info1, info2;
2372	void* trace[20];
2373	size_t size;
2374	size = backtrace(trace, 20);
2375
2376	FILE* fd = NULL;
2377	void* akttrace[2];
2378	int i = 0, y = 0;
2379	char **strings;
2380	char **aktstring;
2381	time_t rawtime;
2382
2383	char* imgversion = NULL;
2384	struct stimerthread* tnode = NULL;
2385
2386	if(isfile(getconfig("imagenamefile", NULL)) != 0)
2387	imgversion = readsys(getconfig("imagenamefile", NULL), 1);
2388	else
2389	imgversion = ostrcat("unknown", NULL, 0, 0);
2390
2391	tnode = gettimerbythread(pthread_self());
2392	if(tnode != NULL)
2393	dladdr(tnode->func, &info);
2394
2395	dladdr(address, &info1);
2396
2397	strings = backtrace_symbols(trace, size);
2398	akttrace[0] = (void*)address1;
2399	akttrace[1] = (void*)address;
2400	aktstring = backtrace_symbols(akttrace, 2); //get fault funktion name
2401
2402	fprintf(stderr, "--------------------------------------\n");
2403	fprintf(stderr, "Box: %s\n", getboxtype());
2404	fprintf(stderr, "Image: %s\n", imgversion);
2405	fprintf(stderr, "Signal: %d (%s)\n", sig, strsignal(sig));
2406	if(info1.dli_fname != NULL)
2407	fprintf(stderr, "Error in File: %s\n", info1.dli_fname);
2408	fprintf(stderr, "MainThread: %x\n", (unsigned int)status.mainthread);
2409	if(tnode != NULL && info.dli_sname != NULL)
2410	fprintf(stderr, "Error in Thread: %x (%s)\n", (unsigned int)pthread_self(), info.dli_sname);
2411	else
2412	fprintf(stderr, "Error in Thread: %x\n", (unsigned int)pthread_self());
2413
2414	fprintf(stderr, "\nObtaining %zd stack frames:\n\n", size);
2415	for(i = 0; i < size; i++)
2416	fprintf(stderr, "%s\n", strings[i]);
2417
2418	fprintf(stderr, "\nLast functions:\n\n");
2419	fprintf(stderr, "%s\n", aktstring[0]);
2420	fprintf(stderr, "%s\n", aktstring[1]);
2421
2422	#ifdef BETA
2423	for(i = 0; i < MAXSTACKTRACE; i++)
2424	{
2425	if(stacktrace[i].pos > 0)
2426	{
2427	fprintf(stderr, "\nObtaining %d Thread Stack frames [%p]:\n\n", stacktrace[i].pos, (void*)stacktrace[i].thread);
2428	for(y = stacktrace[i].pos - 1; y >= 0; y--)
2429	{
2430	dladdr(stacktrace[i].func[y], &info2);
2431	fprintf(stderr, "%s(%s) [%p]\n", info2.dli_fname, info2.dli_sname, stacktrace[i].func[y]);
2432	}
2433	}
2434	}
2435	#endif
2436
2437	fprintf(stderr, "--------------------------------------\n");
2438
2439	char* logdir = ostrcat(getconfig("tracelog", NULL), NULL, 0, 0);
2440	if(logdir != NULL)
2441	{
2442	char* tmplogdir = dirname(logdir);
2443	if(tmplogdir != NULL)
2444	{
2445	if(!file_exist(tmplogdir))
2446	mkdir(tmplogdir, 0777);
2447	}
2448	free(logdir); logdir = NULL;
2449	}
2450
2451	//del file if greater 100KB
2452	if(getfilesize(getconfig("tracelog", NULL)) > 102400)
2453	unlink(getconfig("tracelog", NULL));
2454
2455	fd = fopen(getconfig("tracelog", NULL), "a");
2456	if(fd != NULL)
2457	{
2458	time(&rawtime);
2459	fprintf(fd, "Date: %s", ctime(&rawtime));
2460	fprintf(fd, "Box: %s\n", getboxtype());
2461	fprintf(fd, "Image: %s\n", imgversion);
2462	fprintf(fd, "Signal: %d (%s)\n", sig, strsignal(sig));
2463	if(info1.dli_fname != NULL)
2464	fprintf(fd, "Error in File: %s\n", info1.dli_fname);
2465	fprintf(fd, "MainThread: %x\n", (unsigned int)status.mainthread);
2466	if(tnode != NULL && info.dli_sname != NULL)
2467	fprintf(fd, "Error in Thread: %x (%s)\n", (unsigned int)pthread_self(), info.dli_sname);
2468	else
2469	fprintf(fd, "Error in Thread: %x\n", (unsigned int)pthread_self());
2470
2471	fprintf(fd, "\nObtaining %zd stack frames:\n\n", size);
2472	for(i = 0; i < size; i++)
2473	fprintf(fd, "%s\n", strings[i]);
2474
2475	fprintf(fd, "\nLast functions:\n\n");
2476	fprintf(fd, "%s\n", aktstring[0]);
2477	fprintf(fd, "%s\n", aktstring[1]);
2478
2479	#ifdef BETA
2480	for(i = 0; i < MAXSTACKTRACE; i++)
2481	{
2482	if(stacktrace[i].pos > 0)
2483	{
2484	fprintf(fd, "\nObtaining %d Thread Stack frames [%p]:\n\n", stacktrace[i].pos, (void*)stacktrace[i].thread);
2485	for(y = stacktrace[i].pos - 1; y >= 0; y--)
2486	{
2487	dladdr(stacktrace[i].func[y], &info2);
2488	fprintf(fd, "%s(%s) [%p]\n", info2.dli_fname, info2.dli_sname, stacktrace[i].func[y]);
2489	}
2490	}
2491	}
2492	#endif
2493
2494	fprintf(fd, "--------------------------------------\n\n");
2495	fclose(fd);
2496	sync();
2497	}
2498	else
2499	perr("open %s", getconfig("tracelog", NULL));
2500
2501	free(imgversion);
2502	free(strings);
2503	free(aktstring);
2504	}
2505
2506	int mountauto(const char file, const char dir, unsigned long int flag, const void *data)
2507	{
2508	int ret = -1;
2509	char* saveptr = NULL, filesystems = NULL, tmpfilesystems = NULL, *token = NULL;
2510
2511	filesystems = getconfig("filesystems", NULL);
2512	tmpfilesystems = ostrcat(tmpfilesystems, filesystems, 0, 0);
2513
2514	token = strtok_r(tmpfilesystems, ";", &saveptr);
2515	while(token != NULL)
2516	{
2517	ret = mount(file, dir, token, flag, data);
2518	if(ret == 0) break;
2519	token = strtok_r(NULL, ";", &saveptr);
2520	}
2521
2522	free(tmpfilesystems);
2523	return ret;
2524	}
2525
2526	int setwaswakuptimer(int value)
2527	{
2528	char waswakeuptimerdev = NULL, tmpstr = NULL;
2529	int ret = 0;
2530
2531	waswakeuptimerdev = getconfig("waswakeuptimerdev", NULL);
2532
2533	if(waswakeuptimerdev != NULL)
2534	{
2535	debug(100, "set %s to %d", waswakeuptimerdev, value);
2536	tmpstr = oitoa(value);
2537	ret = writesys(waswakeuptimerdev, tmpstr, 0);
2538	free(tmpstr); tmpstr = NULL;
2539	return ret;
2540	}
2541
2542	return 0;
2543	}
2544
2545	int getwaswakuptimer()
2546	{
2547	int ret = 0;
2548	char *waswakeuptimerdev = NULL;
2549	char *value = NULL;
2550
2551	waswakeuptimerdev = getconfig("waswakeuptimerdev", NULL);
2552
2553	if(waswakeuptimerdev == NULL)
2554	{
2555	err("NULL detect");
2556	return 0;
2557	}
2558
2559	value = readsys(waswakeuptimerdev, 1);
2560	if(value == NULL)
2561	{
2562	err("NULL detect");
2563	return 0;
2564	}
2565
2566	// start from timer
2567	if(atoi(value) == 1) ret = 1;
2568
2569	free(value);
2570	return ret;
2571	}
2572
2573	void checkboxstart()
2574	{
2575	struct rectimer* node = rectimer;
2576	int timediff = getconfigint("rectimer_timediff", NULL);
2577
2578	if(node == NULL) return; //no record
2579
2580	while(node != NULL)
2581	{
2582	if(node->status < 2)
2583	{
2584	time_t akttime = time(NULL);
2585	time_t begin = node->begin - getconfigint("wakeuptimerdevdiff", NULL);
2586
2587	debug(400, "begin=%ld akttime1=%ld akttime2=%ld", begin, akttime - timediff, akttime + timediff);
2588
2589	if(begin > akttime - timediff && begin < akttime + timediff)
2590	{
2591	debug(400, "found rectimer who has start the box");
2592	setwaswakuptimer(1);
2593	setcecstandby(1);
2594	}
2595	}
2596	node = node->next;
2597	}
2598	}
2599
2600	int setwakeuptimerdev(time_t value)
2601	{
2602	char* wakeuptimerdev, *tmpstr = NULL;
2603	int ret = 0;
2604	int diff = getconfigint("wakeuptimerdevdiff", NULL);
2605
2606	if(value != 0x7FFFFFFF && value - diff > time(NULL))
2607	value -= diff;
2608
2609	wakeuptimerdev = getconfig("wakeuptimerdev", NULL);
2610
2611	if(wakeuptimerdev != NULL && value >= time(NULL))
2612	{
2613	debug(100, "set %s to %ld", wakeuptimerdev, value);
2614	tmpstr = olutoa(value);
2615	ret = writesys(wakeuptimerdev, tmpstr, 0);
2616	free(tmpstr); tmpstr = NULL;
2617	return ret;
2618	}
2619
2620	return 0;
2621	}
2622
2623	int changepolicy()
2624	{
2625	char tmppolicy = NULL, tmpstr = NULL;
2626
2627	tmppolicy = getpolicy();
2628
2629	if(!ostrncmp("letterbox", tmppolicy, 8))
2630	tmpstr = ostrcat(tmpstr, "panscan", 1, 0);
2631	else if(!ostrncmp("panscan", tmppolicy, 7))
2632	tmpstr = ostrcat(tmpstr, "non", 1, 0);
2633	else if(!ostrncmp("non", tmppolicy, 3))
2634	tmpstr = ostrcat(tmpstr, "bestfit", 1, 0);
2635	else if(!ostrncmp("bestfit", tmppolicy, 7))
2636	tmpstr = ostrcat(tmpstr, "letterbox", 1, 0);
2637
2638	setpolicy(tmpstr);
2639
2640	free(tmpstr); tmpstr = NULL;
2641	free(tmppolicy); tmppolicy = NULL;
2642	return 0;
2643	}
2644
2645	char* getmac(char* dev)
2646	{
2647	int sock = -1, i = 0;
2648	struct ifreq buf;
2649	char* tmpstr = NULL;
2650	char tmpbuf[4] = {};
2651
2652	if(dev == NULL) return NULL;
2653
2654	sock = socket(PF_INET, SOCK_DGRAM, 0);
2655	if(sock >= 0)
2656	{
2657	memset(&buf, 0x00, sizeof(buf));
2658	strcpy(buf.ifr_name, dev);
2659	ioctl(sock, SIOCGIFHWADDR, &buf);
2660	close(sock);
2661
2662	for(i = 0; i < 6; i++)
2663	{
2664	snprintf(tmpbuf, 4, "%.2X:", (unsigned char)buf.ifr_hwaddr.sa_data[i]);
2665	tmpstr = ostrcat(tmpstr, tmpbuf, 1, 0);
2666	}
2667	if(tmpbuf != NULL)
2668	tmpstr[strlen(tmpstr) - 1] = '\0';
2669	}
2670
2671	return tmpstr;
2672	}
2673
2674	char* getdefaultgw()
2675	{
2676	char* name = NULL;
2677	unsigned long def, gw, m;
2678	int flags, ref, use, metric, mtu, win, ir;
2679	struct in_addr ip;
2680
2681	FILE *fd = fopen("/proc/net/route", "r");
2682	if(fd == NULL)
2683	return NULL;
2684
2685	if(fscanf(fd, "%*[^\n]\n") < 0)
2686	{
2687	fclose(fd);
2688	return NULL;
2689	}
2690
2691	name = malloc(64);
2692	if(name == NULL)
2693	{
2694	err("no mem");
2695	return NULL;
2696	}
2697
2698	while(1)
2699	{
2700	int r = fscanf(fd, "%63s%lx%lx%x%d%d%d%lx%d%d%d\n", name, &def, &gw, &flags, &ref, &use, &metric, &m, &mtu, &win, &ir);
2701	if(def == 0) break;
2702	if(r != 11)
2703	{
2704	fclose(fd);
2705	free(name);
2706	return NULL;
2707	}
2708	if(!(flags & 0x0001)) continue; //is interface down
2709	}
2710
2711	fclose(fd);
2712	free(name);
2713
2714	ip.s_addr = gw;
2715	if(def == 0)
2716	return inet_ntoa(ip);
2717
2718	return NULL;
2719	}
2720
2721	char* changefilenameext(char* filename, char* ext)
2722	{
2723	char* newfilename = NULL;
2724	char* zeichen = NULL;
2725
2726	if(filename == NULL) return NULL;
2727
2728	newfilename = ostrcat(filename, NULL, 0, 0);
2729
2730	zeichen = strrchr(newfilename, '.');
2731	if(zeichen != NULL)
2732	{
2733	zeichen[0] = '\0';
2734	newfilename = ostrcat(newfilename, ext, 1, 0);
2735	}
2736
2737	return newfilename;
2738	}
2739
2740	int cmpfilenameext(char* filename, char* ext)
2741	{
2742	char* zeichen = NULL;
2743
2744	if(filename == NULL) return 1;
2745
2746	zeichen = strrchr(filename, '.');
2747	if(zeichen != NULL)
2748	{
2749	if(ostrcasecmp(zeichen, ext) == 0) return 0;
2750	}
2751
2752	return 1;
2753	}
2754
2755	char* getfilenameext(char* filename)
2756	{
2757	char* zeichen = NULL;
2758
2759	if(filename == NULL) return NULL;
2760
2761	zeichen = strrchr(filename, '.');
2762	if(zeichen != NULL)
2763	{
2764	return ostrcat(zeichen + 1, NULL, 0, 0);
2765	}
2766
2767	return NULL;
2768	}
2769
2770	char* getfilenamepng(char* filename)
2771	{
2772	char* tmpstr = NULL;
2773
2774	if(filename == NULL) return NULL;
2775
2776	if(!filelistflt(".avi .dat .divx .flv .mkv .m4v .mp4 .mov .mpg .mpeg .mts .m2ts .trp .ts .vdr .vob .wmv .rm", filename))
2777	tmpstr = ostrcat("movie", NULL, 0, 0);
2778	else if(!filelistflt(".mp3 .flac .ogg .wma .ra .wav", filename))
2779	tmpstr = ostrcat("musik", NULL, 0, 0);
2780	else if(!filelistflt(".jpg .png", filename))
2781	tmpstr = ostrcat("picture", NULL, 0, 0);
2782	else
2783	tmpstr = ostrcat(getfilenameext(filename), NULL, 1, 0);
2784
2785	if(tmpstr != NULL)
2786	{
2787	return tmpstr;
2788	}
2789
2790	return NULL;
2791	}
2792
2793	char* getcurrentdir(char* path)
2794	{
2795	char* zeichen = NULL;
2796
2797	if(path == NULL) return NULL;
2798
2799	zeichen = strrchr(path, '/');
2800	if(zeichen != NULL)
2801	{
2802	return ostrcat(zeichen + 1, NULL, 0, 0);
2803	}
2804
2805	return NULL;
2806	}
2807
2808	char* convert_timesec(int sec)
2809	{
2810	int hour = 0, min = 0, seconds = 0;
2811	char* buf = NULL;
2812
2813	buf = malloc(9);
2814	if(buf == NULL)
2815	{
2816	err("no mem");
2817	return NULL;
2818	}
2819
2820	seconds = sec % 60;
2821	min = (sec / 60) % 60;
2822	hour = sec / 3600;
2823
2824	if(seconds < 0) seconds = 0;
2825	if(min < 0) min = 0;
2826	if(hour < 0 \|\| hour > 23)
2827	{
2828	hour = 0;
2829	min = 0;
2830	seconds = 0;
2831	}
2832
2833	snprintf(buf, 9, "%02d:%02d:%02d", hour, min, seconds);
2834
2835	return buf;
2836	}
2837
2838	int checkdate()
2839	{
2840	time_t dvbtime = 0;
2841
2842	if(time(NULL) < 1072224000 \|\| status.timeupdatecount > 3600) // 01.01.2004
2843	{
2844	if(dvbgetdate(&dvbtime, 10000000) == 0) //10 sek
2845	{
2846	setsystime(&dvbtime);
2847	status.timeupdatecount = 0;
2848	return 0;
2849	}
2850	return 1;
2851	}
2852	return 0;
2853	}
2854
2855	void closeonexec(int fd)
2856	{
2857	if(fd > -1)
2858	fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) \| FD_CLOEXEC);
2859	}
2860
2861	void startnewsletter(flag)
2862	{
2863	if(flag == 1)
2864	{
2865	if(getconfigint("newsletter", NULL) == 1 && status.newsletterthread == NULL)
2866	status.newsletterthread = addtimer(&newsletterthreadfunc, START, 1000, 1, NULL, NULL, NULL);
2867	}
2868	else if(status.newsletterthread != NULL)
2869	{
2870	status.newsletterthread->aktion = STOP;
2871	status.newsletterthread = NULL;
2872	}
2873	}
2874
2875	void startthumb(flag)
2876	{
2877	if(flag == 1)
2878	{
2879	if(getconfigint("createthumb", NULL) == 1 && status.thumbthread == NULL)
2880	status.thumbthread = addtimer(&thumbthread, START, 1000, 1, NULL, NULL, NULL);
2881	}
2882	else if(status.thumbthread != NULL)
2883	{
2884	status.thumbthread->aktion = STOP;
2885	status.thumbthread = NULL;
2886	}
2887	}
2888
2889	void starthttpd(flag)
2890	{
2891	if(flag == 1)
2892	{
2893	if(getconfigint("httpdstart", NULL) == 1 && status.httpthread == NULL)
2894	{
2895	status.httpthread = addtimer(&httpdthreadfunc, START, 10000, -1, NULL, NULL, NULL);
2896	if(status.httpthread != NULL)
2897	status.httpthread->flag = setbit(status.httpthread->flag, 0);
2898	}
2899	}
2900	else if(status.httpthread != NULL)
2901	{
2902	status.httpthread->aktion = STOP;
2903	status.httpthread = NULL;
2904	}
2905	}
2906
2907	void startrguid(flag)
2908	{
2909	if(flag == 1)
2910	{
2911	if(getconfigint("rguidstart", NULL) == 1 && status.rguithread == NULL)
2912	{
2913	status.rguithread = addtimer(&rguidthreadfunc, START, 10000, -1, NULL, NULL, NULL);
2914	if(status.rguithread != NULL)
2915	status.rguithread->flag = setbit(status.rguithread->flag, 0);
2916	}
2917	}
2918	else if(status.rguithread != NULL)
2919	{
2920	status.rguithread->aktion = STOP;
2921	status.rguithread = NULL;
2922	}
2923	}
2924
2925	char* getboxtype()
2926	{
2927	if(status.boxtype == NULL)
2928	{
2929	if(isfile("/etc/model") == 0) return NULL;
2930	status.boxtype = string_toupper(readsys("/etc/model", 1));
2931	}
2932
2933	return status.boxtype;
2934	}
2935
2936	int checkbox(char* box)
2937	{
2938	char* boxversion = NULL;
2939	int ret = 0;
2940
2941	if(status.boxtype == NULL)
2942	{
2943	if(isfile("/etc/model") == 0) return 0;
2944	boxversion = string_toupper(readsys("/etc/model", 1));
2945	}
2946	else
2947	boxversion = status.boxtype;
2948
2949	if(ostrcmp(boxversion, box) == 0)
2950	{
2951	status.boxtype = boxversion;
2952	ret = 1;
2953	}
2954
2955	box = ostrcat(box, "\n", 0, 0);
2956	if(ostrcmp(boxversion, box) == 0)
2957	{
2958	status.boxtype = boxversion;
2959	ret = 1;
2960	}
2961
2962	if(status.boxtype == NULL)
2963	free(boxversion); boxversion = NULL;
2964	free(box); box = NULL;
2965
2966	return ret;
2967	}
2968
2969	int setoverclockfreq(int mode)
2970	{
2971	// mode 0 = Set Standby Freq
2972	// mode 1 = Set Freq
2973
2974	if(ostrcmp(getownconfig("standby_overclock"), "0") == 0)
2975	return 1;
2976
2977	if(isfile("/proc/cpu_frequ/pll0_ndiv_mdiv") == 0)
2978	return 1;
2979
2980	char* tmpstr = NULL;
2981
2982	if(mode == 0)
2983	tmpstr = getownconfig("standby_freq");
2984	else
2985	tmpstr = getownconfig("pll0_ndiv_mdiv");
2986
2987	return writesys("/proc/cpu_frequ/pll0_ndiv_mdiv", tmpstr, 1);
2988	}
2989
2990	int setvmpeg(struct dvbdev* node, int posx, int posy, int width, int height)
2991	{
2992	if(status.tvpic == 1 && (posx != 0 \|\| posy != 0 \|\| width != 0 \|\| height != 0))
2993	return 0;
2994
2995	if(getconfigint("minitv", NULL) == 1)
2996	return 0;
2997
2998	char* vmpegdev = NULL, tmpstr = NULL, buf = NULL;
2999	int ret = 0;
3000
3001	if(node == NULL) return 1;
3002	vmpegdev = getconfig("vmpegalldev", NULL);
3003
3004	if(vmpegdev != NULL)
3005	{
3006	buf = malloc(MINMALLOC);
3007	if(buf == NULL)
3008	{
3009	err("no mem");
3010	return 1;
3011	}
3012
3013	tmpstr = malloc(MINMALLOC);
3014	if(tmpstr == NULL)
3015	{
3016	err("no mem");
3017	free(buf);
3018	return 1;
3019	}
3020
3021	snprintf(buf, MINMALLOC, vmpegdev, node->devnr);
3022	snprintf(tmpstr, MINMALLOC, "%x %x %x %x", posx, posy, width, height);
3023	debug(100, "set %s to %s", buf, tmpstr);
3024
3025	status.tvpic = 1;
3026	ret = writesys(buf, tmpstr, 1);
3027
3028	//reset
3029	if(posx == 0 && posy == 0 && width == 0 && height == 0)
3030	status.tvpic = 0;
3031
3032	free(tmpstr);
3033	free(buf);
3034	return ret;
3035	}
3036
3037	return 0;
3038	}
3039
3040	//flag 0: wh = width
3041	//flag 1: wh = height
3042	int setvmpegrect(struct dvbdev* node, int posx, int posy, int wh, int flag)
3043	{
3044	int ret = 0;
3045	int leftoffset = status.leftoffset;
3046	int rightoffset = status.rightoffset;
3047	int topoffset = status.topoffset;
3048	int bottomoffset = status.bottomoffset;
3049
3050	float rx = (float)fb->width / 720;
3051	float ry = (float)fb->height / 576;
3052
3053	leftoffset = (float)leftoffset / rx;
3054	rightoffset = (float)rightoffset / rx;
3055	topoffset = (float)topoffset / ry;
3056	bottomoffset = (float)bottomoffset / ry;
3057
3058	rx = (float)720 / (float)(720 - leftoffset - rightoffset);
3059	ry = (float)576 / (float)(576 - topoffset - bottomoffset);
3060
3061	posx = (float)posx / rx;
3062	posx += leftoffset;
3063
3064	posy = (float)posy / ry;
3065	posy += topoffset;
3066
3067	if(flag == 0)
3068	{
3069	wh = ((float)wh / rx);
3070	ret = setvmpeg(node, posx, posy, wh, (int)((float)wh / 1.2));
3071	}
3072
3073	if(flag == 1)
3074	{
3075	wh = ((float)wh / ry);
3076	ret = setvmpeg(node, posx, posy, (int)((float)wh * 1.2), wh);
3077	}
3078
3079	return ret;
3080	}
3081
3082	int resettvpic()
3083	{
3084	int ret = 0;
3085
3086	if(status.tvpic > 0 && status.aktservice != NULL)
3087	ret = setvmpeg(status.aktservice->videodev, 0, 0, 0, 0);
3088
3089	return ret;
3090	}
3091
3092	/*
3093	int checkdev(char* dev)
3094	{
3095	char* cmd = NULL;
3096	cmd = ostrcat(cmd, "cat ", 1, 0);
3097	cmd = ostrcat(cmd, dev, 1, 0);
3098
3099	char* tmpstr = NULL;
3100	tmpstr = string_newline(command(cmd));
3101	free(cmd), cmd = NULL;
3102
3103	if(tmpstr == NULL)
3104	{
3105	return 0;
3106	}
3107
3108	if(ostrcmp(tmpstr, "Segmentation fault") == 0)
3109	{
3110	return 0;
3111	}
3112
3113	free(tmpstr), tmpstr = NULL;
3114	return 1;
3115	}
3116	*/
3117
3118	int setsaturation(int value)
3119	{
3120	char* saturationdev;
3121
3122	saturationdev = getconfig("saturationdev", NULL);
3123
3124	if(saturationdev != NULL /&& checkdev(saturationdev)/)
3125	{
3126	debug(100, "set %s to %d", saturationdev, value);
3127	return writesysint(saturationdev, value, 1);
3128	}
3129
3130	return 0;
3131	}
3132
3133	int setbrightness(int value)
3134	{
3135	char* brightnessdev;
3136
3137	brightnessdev = getconfig("brightnessdev", NULL);
3138
3139	if(brightnessdev != NULL /&& checkdev(brightnessdev)/)
3140	{
3141	debug(100, "set %s to %d", brightnessdev, value);
3142	return writesysint(brightnessdev, value, 1);
3143	}
3144
3145	return 0;
3146	}
3147
3148	int setcontrast(int value)
3149	{
3150	char* contrastdev;
3151
3152	contrastdev = getconfig("contrastdev", NULL);
3153
3154	if(contrastdev != NULL /&& checkdev(contrastdev)/)
3155	{
3156	debug(100, "set %s to %d", contrastdev, value);
3157	return writesysint(contrastdev, value, 1);
3158	}
3159
3160	return 0;
3161	}
3162
3163	int settint(int value)
3164	{
3165	char* tintdev;
3166
3167	tintdev = getconfig("tintdev", NULL);
3168
3169	if(tintdev != NULL /&& checkdev(tintdev)/)
3170	{
3171	debug(100, "set %s to %d", tintdev, value);
3172	return writesysint(tintdev, value, 1);
3173	}
3174
3175	return 0;
3176	}
3177
3178	int ozip(char* inbuf, int inlen, char** outbuf, int* outlen, int level)
3179	{
3180	int ret = 0;
3181	z_stream stream;
3182
3183	if(inbuf == NULL \|\| outbuf == NULL) return 1;
3184
3185	stream.zalloc = Z_NULL;
3186	stream.zfree = Z_NULL;
3187	stream.opaque = Z_NULL;
3188	stream.avail_in = 0;
3189	stream.next_in = Z_NULL;
3190	stream.avail_out = 0;
3191	stream.next_out = Z_NULL;
3192
3193	ret = deflateInit(&stream, level);
3194	if(ret != Z_OK)
3195	return 1;
3196
3197	*outbuf = malloc(inlen);
3198	if(*outbuf == NULL)
3199	{
3200	err("no mem");
3201	(void)deflateEnd(&stream);
3202	return 1;
3203	}
3204
3205	stream.avail_in = inlen;
3206	stream.next_in = (void*)inbuf;
3207
3208	do
3209	{
3210	stream.avail_out = inlen;
3211	stream.next_out = (void)outbuf;
3212
3213	ret = deflate(&stream, Z_FINISH);
3214	if(ret == Z_STREAM_ERROR)
3215	{
3216	free(outbuf); outbuf = NULL;
3217	(void)deflateEnd(&stream);
3218	return 1;
3219	}
3220
3221	}
3222	while(stream.avail_out == 0);
3223	*outlen = inlen - stream.avail_out;
3224	outbuf = realloc(outbuf, *outlen);
3225
3226	(void)deflateEnd(&stream);
3227	return 0;
3228	}
3229
3230	//flag 0: malloc mem
3231	//flag 1: don't malloc mem
3232	int ounzip(char* inbuf, int inlen, char** outbuf, int* outlen, int maxbuf, int flag)
3233	{
3234	int ret = 0;
3235	z_stream stream;
3236
3237	if(inbuf == NULL \|\| outbuf == NULL) return 1;
3238	if(flag == 1 && *outbuf == NULL) return 1;
3239
3240	stream.zalloc = Z_NULL;
3241	stream.zfree = Z_NULL;
3242	stream.opaque = Z_NULL;
3243	stream.avail_in = 0;
3244	stream.next_in = Z_NULL;
3245	stream.avail_out = 0;
3246	stream.next_out = Z_NULL;
3247
3248	ret = inflateInit(&stream);
3249	if(ret != Z_OK)
3250	return 1;
3251
3252	if(flag == 0)
3253	{
3254	*outbuf = malloc(maxbuf);
3255	if(*outbuf == NULL)
3256	{
3257	err("no mem");
3258	(void)inflateEnd(&stream);
3259	return 1;
3260	}
3261	}
3262
3263	stream.avail_in = inlen;
3264	stream.next_in = (void*)inbuf;
3265
3266	do
3267	{
3268	stream.avail_out = maxbuf;
3269	stream.next_out = (void)outbuf;
3270
3271	ret = inflate(&stream, Z_NO_FLUSH);
3272	if(ret == Z_NEED_DICT \|\| ret == Z_DATA_ERROR \|\| ret == Z_MEM_ERROR)
3273	{
3274	free(outbuf); outbuf = NULL;
3275	(void)inflateEnd(&stream);
3276	return 1;
3277	}
3278
3279	}
3280	while(stream.avail_out == 0);
3281	*outlen = maxbuf - stream.avail_out;
3282	if(flag == 0) outbuf = realloc(outbuf, *outlen);
3283
3284	(void)inflateEnd(&stream);
3285	return 0;
3286	}
3287
3288	void endianswapshort(unsigned short* value)
3289	{
3290	value = (value >> 8) \| (*value << 8);
3291	}
3292
3293	int rcnumber(int rcret)
3294	{
3295	if(rcret == getrcconfigint("rc0", NULL) \|\|
3296	rcret == getrcconfigint("rc1", NULL) \|\|
3297	rcret == getrcconfigint("rc2", NULL) \|\|
3298	rcret == getrcconfigint("rc3", NULL) \|\|
3299	rcret == getrcconfigint("rc4", NULL) \|\|
3300	rcret == getrcconfigint("rc5", NULL) \|\|
3301	rcret == getrcconfigint("rc6", NULL) \|\|
3302	rcret == getrcconfigint("rc7", NULL) \|\|
3303	rcret == getrcconfigint("rc8", NULL) \|\|
3304	rcret == getrcconfigint("rc9", NULL))
3305	return rcret;
3306	else
3307	return -9999;
3308	}
3309
3310	int checkdirext(char* dir, char* ext)
3311	{
3312	struct dirent *dirent = NULL;
3313	DIR *pdir = NULL;
3314
3315	pdir = opendir(dir);
3316	if(pdir != NULL)
3317	{
3318	while((dirent = readdir(pdir)) != NULL)
3319	{
3320	if(ostrcmp(".", dirent->d_name) != 0 && ostrcmp("..", dirent->d_name) != 0)
3321	{
3322	if(ostrstr(dirent->d_name, ext) != NULL)
3323	{
3324	closedir(pdir);
3325	return 1;
3326	}
3327	}
3328	}
3329
3330	closedir(pdir);
3331	}
3332
3333	return 0;
3334	}
3335
3336	int delallfiles(char* dir, char* ext)
3337	{
3338	struct dirent *dirent = NULL;
3339	DIR *pdir = NULL;
3340	char* tmpstr = NULL;
3341
3342	pdir = opendir(dir);
3343	if(pdir != NULL)
3344	{
3345	while((dirent = readdir(pdir)) != NULL)
3346	{
3347	if(ostrcmp(".", dirent->d_name) != 0 && ostrcmp("..", dirent->d_name) != 0)
3348	{
3349	if(ext == NULL \|\| ostrstr(dirent->d_name, ext) != NULL)
3350	{
3351	tmpstr = ostrcat(dir, "/", 0, 0);
3352	tmpstr = ostrcat(tmpstr, dirent->d_name, 1, 0);
3353	unlink(tmpstr);
3354	free(tmpstr); tmpstr = NULL;
3355	}
3356	}
3357	}
3358
3359	closedir(pdir);
3360	}
3361
3362	return 0;
3363	}
3364
3365	unsigned long getfilecount(char* dir)
3366	{
3367	unsigned long count = 0;
3368	struct dirent *dirent = NULL;
3369	DIR *pdir = NULL;
3370
3371	pdir = opendir(dir);
3372	if(pdir != NULL)
3373	{
3374	while((dirent = readdir(pdir)) != NULL)
3375	count++;
3376
3377	closedir(pdir);
3378	}
3379
3380	return count;
3381	}
3382
3383	int getfiletype(char* filename)
3384	{
3385	struct stat64 s;
3386
3387	if(filename == NULL) return -1;
3388
3389	if(stat64(filename, &s) >= 0)
3390	{
3391	if(S_ISREG(s.st_mode)) return DT_REG;
3392	if(S_ISDIR(s.st_mode)) return DT_DIR;
3393	if(S_ISCHR(s.st_mode)) return DT_CHR;
3394	if(S_ISBLK(s.st_mode)) return DT_BLK;
3395	if(S_ISFIFO(s.st_mode)) return DT_FIFO;
3396	if(S_ISLNK(s.st_mode)) return DT_LNK;
3397	}
3398
3399	return DT_UNKNOWN;
3400	}
3401
3402	int getlfiletype(char* filename)
3403	{
3404	struct stat64 s;
3405
3406	if(filename == NULL) return -1;
3407
3408	if(lstat64(filename, &s) >= 0)
3409	{
3410	if(S_ISREG(s.st_mode)) return DT_REG;
3411	if(S_ISDIR(s.st_mode)) return DT_DIR;
3412	if(S_ISCHR(s.st_mode)) return DT_CHR;
3413	if(S_ISBLK(s.st_mode)) return DT_BLK;
3414	if(S_ISFIFO(s.st_mode)) return DT_FIFO;
3415	if(S_ISLNK(s.st_mode)) return DT_LNK;
3416	}
3417
3418	return DT_UNKNOWN;
3419	}
3420
3421	unsigned long long getfullspace(char* dir)
3422	{
3423	struct statfs64 s;
3424	unsigned long long fullsize = 0;
3425
3426	if(statfs64(dir, &s) >= 0)
3427	{
3428	fullsize = s.f_blocks;
3429	fullsize *= s.f_bsize;
3430	}
3431
3432	return fullsize;
3433	}
3434
3435	unsigned long long getfreespace(char* dir)
3436	{
3437	struct statfs64 s;
3438	unsigned long long freesize = 0;
3439
3440	if(statfs64(dir, &s) >= 0)
3441	{
3442	freesize = s.f_bfree;
3443	freesize *= s.f_bsize;
3444	}
3445
3446	return freesize;
3447	}
3448
3449	int checkbit(int value, int bitpos)
3450	{
3451	int ret = 0;
3452
3453	ret = value & (1 << bitpos) ? 1: 0;
3454	return ret;
3455	}
3456
3457	int tooglebit(int value, int bitpos)
3458	{
3459	value ^= 1 << bitpos;
3460	return value;
3461	}
3462
3463	int clearbit(int value, int bitpos)
3464	{
3465	value &= ~(1 << bitpos);
3466	return value;
3467	}
3468
3469	int setbit(int value, int bitpos)
3470	{
3471	value \|= 1 << bitpos;
3472	return value;
3473	}
3474
3475	int setsystime(time_t* newtime)
3476	{
3477	if (stime(newtime))
3478	{
3479	err("can't set system time");
3480	return 1;
3481	}
3482	return 0;
3483	}
3484
3485	off64_t getfilesize(char* name)
3486	{
3487	struct stat64 sbuf;
3488
3489	if(lstat64(name, &sbuf) == -1)
3490	return 0;
3491
3492	return sbuf.st_size;
3493	}
3494
3495	time_t getfiletime(char* name, int type)
3496	{
3497	struct stat64 sbuf;
3498
3499	if(lstat64(name, &sbuf) == -1)
3500	return 0;
3501
3502	switch(type)
3503	{
3504	case 1: return sbuf.st_mtime;
3505	case 2: return sbuf.st_ctime;
3506	default: return sbuf.st_atime;
3507	}
3508	}
3509
3510	int isfile(char* name)
3511	{
3512	struct stat64 sbuf;
3513
3514	if(lstat64(name, &sbuf) == -1)
3515	return 0;
3516
3517	if(S_ISREG(sbuf.st_mode))
3518	return 1;
3519
3520	return 0;
3521	}
3522
3523	int isdir(char* name)
3524	{
3525	struct stat64 sbuf;
3526	char *rpath = NULL;
3527
3528	if(lstat64(name, &sbuf) == -1)
3529	return 0;
3530
3531	if(S_ISDIR(sbuf.st_mode))
3532	return 1;
3533
3534	if(S_ISLNK(sbuf.st_mode))
3535	{
3536	rpath = realpath(name, NULL);
3537	if(lstat64(rpath, &sbuf) == -1)
3538	{
3539	free(rpath);
3540	return 0;
3541	}
3542	free(rpath);
3543	if(S_ISDIR(sbuf.st_mode))
3544	return 1;
3545	}
3546
3547	return 0;
3548	}
3549
3550	char* getmaxsatstring(int maxsat)
3551	{
3552	char* tmpstr = NULL, *tmpnr = NULL;
3553	int i;
3554
3555	tmpstr = ostrcat(tmpstr, "1", 1, 0);
3556	for(i = 2; i <= maxsat; i++)
3557	{
3558	tmpnr = oitoa(i);
3559	tmpstr = ostrcat(tmpstr, "\n", 1, 0);
3560	tmpstr = ostrcat(tmpstr, tmpnr, 1, 1);
3561	}
3562	return tmpstr;
3563	}
3564
3565	void ostrcatbig(char** value1, char* value2, int* maxlen, int* pos)
3566	{
3567	int len = 0;
3568
3569	if(value2 == NULL)
3570	return;
3571
3572	len = strlen(value2);
3573
3574	if(len > MINMALLOC)
3575	{
3576	err("string to long");
3577	return;
3578	}
3579
3580	if(*value1 != NULL && maxlen == 0)
3581	maxlen = strlen(value1);
3582
3583	if(value1 == NULL \|\| pos + len + 1 > *maxlen)
3584	{
3585	maxlen = maxlen + (MINMALLOC * 10);
3586	value1 = realloc(value1, *maxlen);
3587	if(*value1 == NULL)
3588	{
3589	err("no memory");
3590	return;
3591	}
3592	}
3593
3594	memcpy(value1 + pos, value2, len + 1);
3595	pos = pos + len;
3596	}
3597
3598	char* ostrshrink(char* value)
3599	{
3600	int len = 0;
3601	char* buf = NULL;
3602
3603	if(value == NULL) return NULL;
3604
3605	len = strlen(value);
3606	if(len == 0) return value;
3607
3608	buf = malloc(len + 1);
3609	if(buf == NULL)
3610	return value;
3611
3612	memcpy(buf, value, len);
3613	free(value);
3614	buf[len] = '\0';
3615
3616	return buf;
3617	}
3618
3619	char* ostrcat(char* value1, char* value2, int free1, int free2)
3620	{
3621	int len = 0, len1 = 0, len2 = 0;
3622	char* buf = NULL;
3623
3624	if(value1 == NULL && value2 == NULL) return NULL;
3625
3626	if(value1 != NULL) len1 = strlen(value1);
3627	if(value2 != NULL) len2 = strlen(value2);
3628
3629	len = len1 + len2 + 1;
3630
3631	if(free1 == 1)
3632	buf = realloc(value1, len);
3633	else
3634	buf = malloc(len);
3635	if(buf == NULL)
3636	{
3637	if(free1 == 1) free(value1);
3638	if(free2 == 1) free(value2);
3639	return NULL;
3640	}
3641
3642	if(free1 == 0 && len1 > 0) memcpy(buf, value1, len1);
3643	if(len2 > 0) memcpy(buf + len1, value2, len2);
3644	buf[len - 1] = '\0';
3645
3646	if(free2 == 1) free(value2);
3647
3648	//helpfull for memleak detect
3649	//if(buf != NULL && strlen(buf) == 0x0b - 0x01)
3650	// printf("****** memleak string (%s) (%p) ******\n", buf, buf);
3651
3652	return buf;
3653	}
3654
3655	char* ollutoa(uint64_t value)
3656	{
3657	char *buf = NULL;
3658
3659	buf = malloc(MINMALLOC);
3660	if(buf == NULL)
3661	{
3662	err("no memory");
3663	return NULL;
3664	}
3665
3666	sprintf(buf, "%llu", value);
3667	buf = ostrshrink(buf);
3668
3669	return buf;
3670	}
3671
3672	char* olutoa(unsigned long value)
3673	{
3674	char *buf = NULL;
3675
3676	buf = malloc(MINMALLOC);
3677	if(buf == NULL)
3678	{
3679	err("no memory");
3680	return NULL;
3681	}
3682
3683	sprintf(buf, "%lu", value);
3684	buf = ostrshrink(buf);
3685
3686	return buf;
3687	}
3688
3689	char* oitoax(int value)
3690	{
3691	char *buf = NULL;
3692
3693	buf = malloc(MINMALLOC);
3694	if(buf == NULL)
3695	{
3696	err("no memory");
3697	return NULL;
3698	}
3699
3700	sprintf(buf, "%x", value);
3701	buf = ostrshrink(buf);
3702
3703	return buf;
3704	}
3705
3706	char* oitoa(int value)
3707	{
3708	char *buf = NULL;
3709
3710	buf = malloc(MINMALLOC);
3711	if(buf == NULL)
3712	{
3713	err("no memory");
3714	return NULL;
3715	}
3716
3717	sprintf(buf, "%d", value);
3718	buf = ostrshrink(buf);
3719
3720	return buf;
3721	}
3722
3723	char* oitoa64(off64_t value)
3724	{
3725	char *buf = NULL;
3726
3727	buf = malloc(MINMALLOC);
3728	if(buf == NULL)
3729	{
3730	err("no memory");
3731	return NULL;
3732	}
3733
3734	sprintf(buf, "%lld", value);
3735	buf = ostrshrink(buf);
3736
3737	return buf;
3738	}
3739
3740	char* oftoa64(double value, char* count)
3741	{
3742	char *buf = NULL;
3743	char* tmpstr = NULL;
3744
3745	buf = malloc(MINMALLOC);
3746	if(buf == NULL)
3747	{
3748	err("no memory");
3749	return NULL;
3750	}
3751
3752	tmpstr = ostrcat("%.", count, 0, 0);
3753	tmpstr = ostrcat(tmpstr, "f", 1, 0);
3754
3755	sprintf(buf, tmpstr, value);
3756	buf = ostrshrink(buf);
3757
3758	free(tmpstr);
3759	return buf;
3760	}
3761
3762	int ostrncmp(char* value1, char* value2, int count)
3763	{
3764	int ret = 1;
3765
3766	if(value1 != NULL && value2 != NULL)
3767	ret = strncmp(value1, value2, count);
3768
3769	return ret;
3770	}
3771
3772	int ostrcmp(char* value1, char* value2)
3773	{
3774	int ret = 1;
3775
3776	if(value1 != NULL && value2 != NULL)
3777	ret = strcmp(value1, value2);
3778
3779	return ret;
3780	}
3781
3782	int ostrcasecmp(char* value1, char* value2)
3783	{
3784	int ret = 1;
3785
3786	if(value1 != NULL && value2 != NULL)
3787	ret = strcasecmp(value1, value2);
3788
3789	return ret;
3790	}
3791
3792	char* createpath(char* dir, char* file)
3793	{
3794	char *absdir = NULL;
3795	char *pos = NULL;
3796	char* tmpdir = NULL;
3797
3798	if(dir == NULL \|\| file == NULL)
3799	{
3800	err("NULL detect");
3801	return NULL;
3802	}
3803
3804	tmpdir = ostrcat(dir, NULL, 0, 0);
3805	if(tmpdir == NULL)
3806	{
3807	err("NULL detect");
3808	return NULL;
3809	}
3810
3811	while((tmpdir[strlen(tmpdir) - 1] == '.' && tmpdir[strlen(tmpdir) - 2] != '.') \|\| tmpdir[strlen(tmpdir) - 1] == '/')
3812	tmpdir[strlen(tmpdir) - 1] = '\0';
3813
3814	while(tmpdir[strlen(tmpdir) - 1] == '.' && tmpdir[strlen(tmpdir) - 2] == '.')
3815	{
3816	tmpdir[strlen(tmpdir) - 1] = '\0';
3817	tmpdir[strlen(tmpdir) - 1] = '\0';
3818	if(tmpdir[strlen(tmpdir) - 1] == '/')
3819	tmpdir[strlen(tmpdir) - 1] = '\0';
3820	pos = strrchr(tmpdir, '/');
3821	if(pos != NULL)
3822	pos[0] = '\0';
3823	}
3824
3825	absdir = malloc(strlen(tmpdir) + strlen(file) + 2);
3826	if(absdir == NULL)
3827	{
3828	free(tmpdir);
3829	err("no memory");
3830	return NULL;
3831	}
3832
3833	if(strlen(file) > 0 \|\| strlen(tmpdir) == 0)
3834	sprintf(absdir, "%s/%s", tmpdir, file);
3835	else
3836	sprintf(absdir, "%s", tmpdir);
3837
3838	free(tmpdir);
3839	return absdir;
3840	}
3841
3842	int settimezone(char* zone)
3843	{
3844	int ret = 0;
3845	char* tmpzone = NULL, *zonepath = NULL;
3846
3847	zonepath = getconfig("zonepath", NULL);
3848	if(zonepath == NULL)
3849	{
3850	err("config zonepath not defined");
3851	return 1;
3852	}
3853
3854	tmpzone = createpath(zonepath, zone);
3855	if(tmpzone == NULL)
3856	return 1;
3857
3858	setenv("TZ", zone, 1);
3859
3860	ret = unlink(getconfig("localtimefile", NULL));
3861	if(ret != 0)
3862	perr("unlink");
3863	ret = symlink(tmpzone, getconfig("localtimefile", NULL));
3864	if(ret != 0)
3865	perr("link");
3866
3867	free(tmpzone);
3868	return ret;
3869	}
3870
3871	int delchar(char** text, int pos)
3872	{
3873	char *tmptext = NULL;
3874	int i = 0, y = 0, len = 0;
3875
3876	if(text == NULL \|\| *text == NULL)
3877	return pos;
3878
3879	len = strlen(*text);
3880	if(len == 0) return pos;
3881
3882	tmptext = malloc(strlen(*text));
3883	if(tmptext == NULL)
3884	{
3885	err("no memory");
3886	return pos;
3887	}
3888
3889	for(i = 0; i < strlen(*text); i++)
3890	{
3891	if(i == pos - 1)
3892	y++;
3893
3894	tmptext[i] = (*text)[y];
3895	y++;
3896	}
3897
3898	if(i > 0) tmptext[i - 1] = '\0';
3899	if(pos >= strlen(tmptext)) pos = strlen(tmptext);
3900
3901	free(*text);
3902	*text = tmptext;
3903	return pos;
3904	}
3905
3906
3907	int insertchar(char** text, char zeichen, int pos)
3908	{
3909	char *tmptext = NULL;
3910	int i, y = 0;
3911
3912	if(text == NULL \|\| *text == NULL)
3913	return pos;
3914
3915	tmptext = malloc(strlen(*text) + 2);
3916	if(tmptext == NULL)
3917	{
3918	err("no memory");
3919	return pos;
3920	}
3921
3922	if(strlen(*text) == 0)
3923	{
3924	tmptext[0] = zeichen;
3925	i = 1;
3926	pos = 0;
3927	}
3928	else
3929	{
3930	for(i = 0; i < strlen(*text) + 1; i++)
3931	{
3932	if(i == pos)
3933	tmptext[i] = zeichen;
3934	else
3935	{
3936	tmptext[i] = (*text)[y];
3937	y++;
3938	}
3939	}
3940	}
3941	tmptext[i] = '\0';
3942
3943	free(*text);
3944	*text = tmptext;
3945	return pos + 1;
3946	}
3947
3948	void calctext(char* buf, char* buf1, unsigned int* linecount, unsigned int* pagecount, unsigned int* poscount, int pagelen, int page)
3949	{
3950	unsigned int tmpposcount = 0;
3951
3952	*poscount = 0;
3953	*linecount = 1;
3954	*pagecount = 1;
3955
3956	page--;
3957	if(page < 0) page = 0;
3958
3959	if(buf != NULL)
3960	{
3961	while(*buf != '\0')
3962	{
3963	if(*buf == '\n')
3964	{
3965	if(*(buf + 1) == '\0') break;
3966	(*linecount)++;
3967
3968	if(linecount - 1 == pagelen page)
3969	*poscount = tmpposcount + 1;
3970	}
3971	buf++;
3972	tmpposcount++;
3973	}
3974	}
3975
3976	if(buf1 != NULL)
3977	{
3978	while(*buf1 != '\0')
3979	{
3980	if(*buf1 == '\n')
3981	{
3982	if(*(buf1 + 1) == '\0') break;
3983	(*linecount)++;
3984
3985	if(linecount - 1 == pagelen page)
3986	*poscount = tmpposcount + 1;
3987	}
3988	buf1++;
3989	tmpposcount++;
3990	}
3991	}
3992
3993	if(pagelen > 0)
3994	pagecount = (int)ceil(((float)linecount / pagelen));
3995	}
3996
3997	int initlocale(char *localepath)
3998	{
3999	setlocale(LC_ALL, "");
4000	if(bindtextdomain(PROGNAME, localepath) == NULL)
4001	{
4002	err("set bindtextdomain");
4003	return 1;
4004	}
4005	if(textdomain(PROGNAME) == NULL)
4006	{
4007	err("set textdomain");
4008	return 1;
4009	}
4010	return 0;
4011	}
4012
4013	//for langage you must
4014	//mkdir /usr/lib/locale
4015	//ln -s %titanpath%/po /usr/lib/locale/po
4016	//copy SYS_LC_MESSAGES from other language into LC_MESSAGE
4017	int setlang(char *lang)
4018	{
4019	char *ret;
4020
4021	setenv("LANG", lang, 1);
4022	setenv("LANGUAGE", lang, 1);
4023	ret = setlocale(LC_MESSAGES, lang);
4024	if(ret == NULL)
4025	{
4026	err("can't set LC_MESSAGES to %s", lang);
4027	return 1;
4028	}
4029	return 0;
4030	}
4031
4032	unsigned long readsysul(const char *filename, int line)
4033	{
4034	int i = 0, len = 0;
4035	unsigned long ret = 0;
4036	FILE *fd = NULL;
4037	char *fileline = NULL;
4038	char *buf1 = NULL;
4039
4040	fileline = malloc(MINMALLOC);
4041	if(fileline == NULL)
4042	{
4043	err("no memory");
4044	return 0;
4045	}
4046
4047	fd = fopen(filename, "r");
4048	if(fd == NULL)
4049	{
4050	perr("can't open %s", filename);
4051	free(fileline);
4052	return 0;
4053	}
4054
4055	for(i = 0; i < line; i++)
4056	{
4057	memset(fileline, 0, MINMALLOC);
4058	fgets(fileline, MINMALLOC, fd);
4059	}
4060
4061	len = strlen(fileline) - 1;
4062	if(len >= 0 && fileline[len] == '\n')
4063	fileline[len] = '\0';
4064	buf1 = ostrshrink(fileline);
4065
4066	fclose(fd);
4067
4068	if(buf1 != NULL)
4069	{
4070	ret = strtoul(buf1, NULL, 10);
4071	free(buf1); buf1 = NULL;
4072	}
4073
4074	return ret;
4075	}
4076
4077
4078	char* readsys(const char *filename, int line)
4079	{
4080	int i = 0, len = 0;
4081	FILE *fd = NULL;
4082	char *fileline = NULL;
4083	char *buf1 = NULL;
4084
4085	fileline = malloc(MINMALLOC);
4086	if(fileline == NULL)
4087	{
4088	err("no memory");
4089	return NULL;
4090	}
4091
4092	fd = fopen(filename, "r");
4093	if(fd == NULL)
4094	{
4095	perr("can't open %s", filename);
4096	free(fileline);
4097	return NULL;
4098	}
4099
4100	for(i = 0; i < line; i++)
4101	{
4102	memset(fileline, 0, MINMALLOC);
4103	fgets(fileline, MINMALLOC, fd);
4104	}
4105
4106	len = strlen(fileline) - 1;
4107	if(len >= 0 && fileline[len] == '\n')
4108	fileline[len] = '\0';
4109	buf1 = ostrshrink(fileline);
4110
4111	fclose(fd);
4112	return buf1;
4113	}
4114
4115	//flag 0: without \n
4116	//flag 1: with \n
4117	//flag 2: append without \n
4118	//flag 3: append with \n
4119	int writesys(const char filename, char value, int flag)
4120	{
4121	FILE *fd = NULL;
4122	char* tmpstr = NULL;
4123	int ret;
4124
4125	if(value == NULL)
4126	{
4127	err("NULL detect");
4128	return 1;
4129	}
4130
4131	if(flag == 2 \|\| flag == 3)
4132	fd = fopen(filename, "a");
4133	else
4134	fd = fopen(filename, "w");
4135	if(fd == NULL)
4136	{
4137	perr("can't open %s", filename);
4138	return 1;
4139	}
4140
4141	if(flag == 1 \|\| flag == 3)
4142	tmpstr = ostrcat(value, "\n", 0, 0);
4143	else
4144	tmpstr = ostrcat(value, NULL, 0, 0);
4145
4146	ret = fwrite(tmpstr, strlen(tmpstr), 1, fd);
4147	if(ret != 1)
4148	{
4149	perr("writting to %s", filename);
4150	free(tmpstr);
4151	fclose(fd);
4152	return 1;
4153	}
4154
4155	free(tmpstr);
4156	fclose(fd);
4157	return 0;
4158	}
4159
4160	//flag 0: without \n
4161	//flag 1: with \n
4162	//flag 2: append without \n
4163	//flag 3: append with \n
4164	int writesysint(const char *filename, int value, int flag)
4165	{
4166	char* tmpstr = NULL;
4167	int ret = 0;
4168
4169	tmpstr = oitoa(value);
4170	ret = writesys(filename, tmpstr, flag);
4171
4172	free(tmpstr);
4173	return ret;
4174	}
4175
4176	char* getdevcontent(char* devconfig)
4177	{
4178	char *dev = NULL;
4179	char *value = NULL;
4180
4181	dev = getconfig(devconfig, NULL);
4182
4183	if(dev == NULL)
4184	{
4185	err("NULL detect");
4186	return NULL;
4187	}
4188
4189	value = readsys(dev, 1);
4190	if(value == NULL)
4191	{
4192	err("NULL detect");
4193	return NULL;
4194	}
4195
4196	return value;
4197	}
4198
4199	char* convertspacetolf(char* value)
4200	{
4201	int i = 0;
4202
4203	while(value[i] != '\0')
4204	{
4205	if(value[i] == ' ')
4206	value[i] = '\n';
4207	i++;
4208	}
4209
4210	return value;
4211	}
4212
4213	//flag 0: all
4214	//flag 1: hdmi
4215	//flag 2: not hdmi
4216	char* getcolorformatchoices(int flag)
4217	{
4218	char *colorformatchoicesdev = NULL;
4219	char *value = NULL;
4220
4221	colorformatchoicesdev = getconfig("colorformatchoicesdev", NULL);
4222
4223	if(colorformatchoicesdev == NULL)
4224	{
4225	err("NULL detect");
4226	return NULL;
4227	}
4228
4229	value = readsys(colorformatchoicesdev, 1);
4230	if(value == NULL)
4231	{
4232	err("NULL detect");
4233	return NULL;
4234	}
4235
4236	if(flag == 1)
4237	{
4238	value = string_replace("rgb", NULL, value, 1);
4239	value = string_replace(" ", " ", value, 1);
4240	value = string_replace("cvbs", NULL, value, 1);
4241	value = string_replace(" ", " ", value, 1);
4242	value = string_replace("svideo", NULL, value, 1);
4243	value = string_replace(" ", " ", value, 1);
4244	value = string_replace("yuv", NULL, value, 1);
4245	value = string_replace(" ", " ", value, 1);
4246	}
4247	else if(flag == 2)
4248	{
4249	value = string_replace("hdmi_rgb", NULL, value, 1);
4250	value = string_replace(" ", " ", value, 1);
4251	value = string_replace("hdmi_yuv", NULL, value, 1);
4252	value = string_replace(" ", " ", value, 1);
4253	value = string_replace("hdmi_422", NULL, value, 1);
4254	value = string_replace(" ", " ", value, 1);
4255	}
4256
4257	value = strstrip(value);
4258	value = convertspacetolf(value);
4259
4260	return value;
4261	}
4262
4263	char* getaudiosourcechoices()
4264	{
4265	char *audiosourcechoicesdev = NULL;
4266	char *value = NULL;
4267
4268	audiosourcechoicesdev = getconfig("audiosourcechoicesdev", NULL);
4269
4270	if(audiosourcechoicesdev == NULL)
4271	{
4272	err("NULL detect");
4273	return NULL;
4274	}
4275
4276	value = readsys(audiosourcechoicesdev, 1);
4277	if(value == NULL)
4278	{
4279	err("NULL detect");
4280	return NULL;
4281	}
4282
4283	value = convertspacetolf(value);
4284
4285	return value;
4286	}
4287
4288	char* getac3choices()
4289	{
4290	char *ac3choicesdev = NULL;
4291	char *value = NULL;
4292
4293	ac3choicesdev = getconfig("ac3choicesdev", NULL);
4294
4295	if(ac3choicesdev == NULL)
4296	{
4297	err("NULL detect");
4298	return NULL;
4299	}
4300
4301	value = readsys(ac3choicesdev, 1);
4302	if(value == NULL)
4303	{
4304	err("NULL detect");
4305	return NULL;
4306	}
4307
4308	value = convertspacetolf(value);
4309
4310	return value;
4311	}
4312
4313	int setciclock(int slotnr, char* value)
4314	{
4315	char* ciclockdev = NULL, *tmpstr = NULL;
4316	int ret = 0;
4317
4318	ciclockdev = getconfig("ciclockdev", NULL);
4319
4320	if(ciclockdev != NULL && value != NULL)
4321	{
4322	tmpstr = malloc(MINMALLOC);
4323	if(tmpstr == NULL)
4324	{
4325	err("no mem");
4326	return 1;
4327	}
4328
4329	snprintf(tmpstr, MINMALLOC, ciclockdev, slotnr);
4330	debug(100, "set %s to %s", tmpstr, value);
4331	ret = writesys(tmpstr, value, 0);
4332
4333	free(tmpstr); tmpstr = NULL;
4334	return ret;
4335	}
4336
4337	return 0;
4338	}
4339
4340	//routes stream from tuner to ci or ci to ci
4341	int setciinput(int slotnr, char* value)
4342	{
4343	char* ciinputdev = NULL, *tmpstr = NULL;
4344	int ret = 0;
4345
4346	ciinputdev = getconfig("ciinputdev", NULL);
4347
4348	if(ciinputdev != NULL && value != NULL)
4349	{
4350	tmpstr = malloc(MINMALLOC);
4351	if(tmpstr == NULL)
4352	{
4353	err("no mem");
4354	return 1;
4355	}
4356
4357	snprintf(tmpstr, MINMALLOC, ciinputdev, slotnr);
4358	debug(100, "set %s to %s", tmpstr, value);
4359	ret = writesys(tmpstr, value, 0);
4360
4361	free(tmpstr); tmpstr = NULL;
4362	return ret;
4363	}
4364
4365	return 0;
4366	}
4367
4368	//routes stream from tuner or ci to linux
4369	int setcisource(int tunernr, char* value)
4370	{
4371	char* cisourcedev = NULL, *tmpstr = NULL;
4372	int ret = 0;
4373
4374	cisourcedev = getconfig("cisourcedev", NULL);
4375
4376	if(cisourcedev != NULL && value != NULL)
4377	{
4378	tmpstr = malloc(MINMALLOC);
4379	if(tmpstr == NULL)
4380	{
4381	err("no mem");
4382	return 1;
4383	}
4384
4385	snprintf(tmpstr, MINMALLOC, cisourcedev, tunernr);
4386	debug(100, "set %s to %s", tmpstr, value);
4387	ret = writesys(tmpstr, value, 0);
4388
4389	free(tmpstr); tmpstr = NULL;
4390	return ret;
4391	}
4392
4393	return 0;
4394	}
4395
4396	int setinput(char* value)
4397	{
4398	char* inputdev = NULL;
4399	int ret = 0;
4400
4401	inputdev = getconfig("inputdev", NULL);
4402
4403	if(inputdev != NULL && value != NULL)
4404	{
4405	debug(100, "set %s to %s", inputdev, value);
4406	ret = writesys(inputdev, value, 0);
4407	return ret;
4408	}
4409
4410	return 0;
4411	}
4412
4413	char* getinput()
4414	{
4415	char *inputdev = NULL;
4416	char *value = NULL;
4417
4418	inputdev = getconfig("inputdev", NULL);
4419
4420	if(inputdev == NULL)
4421	{
4422	err("NULL detect");
4423	return NULL;
4424	}
4425
4426	value = readsys(inputdev, 1);
4427	if(value == NULL)
4428	{
4429	err("NULL detect");
4430	return NULL;
4431	}
4432
4433	return value;
4434	}
4435
4436	int setac3(char* value)
4437	{
4438	char* ac3dev = NULL;
4439	int ret = 0;
4440
4441	ac3dev = getconfig("ac3dev", NULL);
4442
4443	if(ac3dev != NULL && value != NULL)
4444	{
4445	debug(100, "set %s to %s", ac3dev, value);
4446	ret = writesys(ac3dev, value, 0);
4447	if(ret == 0) addconfig("av_ac3mode", value);
4448	return ret;
4449	}
4450
4451	return 0;
4452	}
4453
4454	char* getac3()
4455	{
4456	char *ac3dev = NULL;
4457	char *value = NULL;
4458
4459	ac3dev = getconfig("ac3dev", NULL);
4460
4461	if(ac3dev == NULL)
4462	{
4463	err("NULL detect");
4464	return NULL;
4465	}
4466
4467	value = readsys(ac3dev, 1);
4468	if(value == NULL)
4469	{
4470	err("NULL detect");
4471	return NULL;
4472	}
4473
4474	return value;
4475	}
4476
4477	int setaudiodelaybitstream(char* value)
4478	{
4479	char* audiodelaybitstreamdev = NULL;
4480	int ret = 0;
4481
4482	audiodelaybitstreamdev = getconfig("audiodelaybitstreamdev", NULL);
4483
4484	if(audiodelaybitstreamdev != NULL && value != NULL)
4485	{
4486	debug(100, "set %s to %s", audiodelaybitstreamdev, value);
4487	ret = writesys(audiodelaybitstreamdev, value, 0);
4488	if(ret == 0) addconfig("audiodelaybitstream", value);
4489	return ret;
4490	}
4491
4492	return 0;
4493	}
4494
4495	char* getaudiodelaybitstream()
4496	{
4497	char *audiodelaybitstreamdev = NULL;
4498	char *value = NULL;
4499
4500	audiodelaybitstreamdev = getconfig("audiodelaybitstreamdev", NULL);
4501
4502	if(audiodelaybitstreamdev == NULL)
4503	{
4504	err("NULL detect");
4505	return NULL;
4506	}
4507
4508	value = readsys(audiodelaybitstreamdev, 1);
4509	if(value == NULL)
4510	{
4511	err("NULL detect");
4512	return NULL;
4513	}
4514
4515	return value;
4516	}
4517
4518	char* getpolicychoices()
4519	{
4520	char *policychoicesdev = NULL;
4521	char *value = NULL;
4522
4523	policychoicesdev = getconfig("policychoicesdev", NULL);
4524
4525	if(policychoicesdev == NULL)
4526	{
4527	err("NULL detect");
4528	return NULL;
4529	}
4530
4531	value = readsys(policychoicesdev, 1);
4532	if(value == NULL)
4533	{
4534	err("NULL detect");
4535	return NULL;
4536	}
4537
4538	value = convertspacetolf(value);
4539
4540	return value;
4541	}
4542
4543	char* getpolicy()
4544	{
4545	char *policydev = NULL;
4546	char *value = NULL;
4547
4548	policydev = getconfig("policydev", NULL);
4549
4550	if(policydev == NULL)
4551	{
4552	err("NULL detect");
4553	return NULL;
4554	}
4555
4556	value = readsys(policydev, 1);
4557	if(value == NULL)
4558	{
4559	err("NULL detect");
4560	return NULL;
4561	}
4562
4563	return value;
4564	}
4565
4566	int setpolicy(char* value)
4567	{
4568	char* policydev;
4569	int ret = 0;
4570
4571	policydev = getconfig("policydev", NULL);
4572
4573	if(policydev != NULL && value != NULL)
4574	{
4575	debug(100, "set %s to %s", policydev, value);
4576	ret = writesys(policydev, value, 0);
4577	if(ret == 0) addconfig("av_policy", value);
4578	return ret;
4579	}
4580
4581	return 0;
4582	}
4583
4584	char* getaspectchoices()
4585	{
4586	char *aspectchoicesdev = NULL;
4587	char *value = NULL;
4588
4589	aspectchoicesdev = getconfig("aspectchoicesdev", NULL);
4590
4591	if(aspectchoicesdev == NULL)
4592	{
4593	err("NULL detect");
4594	return NULL;
4595	}
4596
4597	value = readsys(aspectchoicesdev, 1);
4598	if(value == NULL)
4599	{
4600	err("NULL detect");
4601	return NULL;
4602	}
4603
4604	value = convertspacetolf(value);
4605
4606	return value;
4607	}
4608
4609	char* getaspect()
4610	{
4611	char *aspectdev = NULL;
4612	char *value = NULL;
4613
4614	aspectdev = getconfig("aspectdev", NULL);
4615
4616	if(aspectdev == NULL)
4617	{
4618	err("NULL detect");
4619	return NULL;
4620	}
4621
4622	value = readsys(aspectdev, 1);
4623	if(value == NULL)
4624	{
4625	err("NULL detect");
4626	return NULL;
4627	}
4628
4629	return value;
4630	}
4631
4632	int setaspect(char* value)
4633	{
4634	char* aspectdev;
4635	int ret = 0;
4636
4637	aspectdev = getconfig("aspectdev", NULL);
4638
4639	if(aspectdev != NULL && value != NULL)
4640	{
4641	debug(100, "set %s to %s", aspectdev, value);
4642	ret = writesys(aspectdev, value, 0);
4643	if(ret == 0)
4644	{
4645	addconfig("av_aspect", value);
4646
4647	//set policy new after change aspect
4648	char* tmpstr = getpolicy();
4649	setpolicy(tmpstr);
4650	free(tmpstr); tmpstr = NULL;
4651	}
4652	return ret;
4653	}
4654
4655	return 0;
4656	}
4657
4658	char* getvideomodechoices()
4659	{
4660	char *videomodechoicesdev = NULL;
4661	char *value = NULL;
4662
4663	videomodechoicesdev = getconfig("videomodechoicesdev", NULL);
4664
4665	if(videomodechoicesdev == NULL)
4666	{
4667	err("NULL detect");
4668	return NULL;
4669	}
4670
4671	value = readsys(videomodechoicesdev, 1);
4672	if(value == NULL)
4673	{
4674	err("NULL detect");
4675	return NULL;
4676	}
4677
4678	value = string_replace("pal", NULL, value, 1);
4679	value = string_replace(" ", " ", value, 1);
4680
4681	if(status.mcaktiv == 0)
4682	{
4683	value = string_replace("1080p60", NULL, value, 1);
4684	value = string_replace(" ", " ", value, 1);
4685	value = string_replace("1080p59", NULL, value, 1);
4686	value = string_replace(" ", " ", value, 1);
4687	value = string_replace("1080p30", NULL, value, 1);
4688	value = string_replace(" ", " ", value, 1);
4689	value = string_replace("1080p25", NULL, value, 1);
4690	value = string_replace(" ", " ", value, 1);
4691	value = string_replace("1080p24", NULL, value, 1);
4692	value = string_replace(" ", " ", value, 1);
4693	value = string_replace("1080i60", NULL, value, 1);
4694	value = string_replace(" ", " ", value, 1);
4695	value = string_replace("720p60", NULL, value, 1);
4696	value = string_replace(" ", " ", value, 1);
4697	}
4698
4699	value = strstrip(value);
4700	value = convertspacetolf(value);
4701
4702	return value;
4703	}
4704
4705	char* getmode3dchoices()
4706	{
4707	char *mode3dchoicesdev = NULL;
4708	char *value = NULL;
4709
4710	mode3dchoicesdev = getconfig("mode3dchoicesdev", NULL);
4711
4712	if(mode3dchoicesdev == NULL)
4713	{
4714	return ostrcat("off\nsbs\ntab", "", 0, 0);
4715	}
4716
4717	value = readsys(mode3dchoicesdev, 1);
4718	if(value == NULL)
4719	{
4720	err("NULL detect");
4721	return NULL;
4722	}
4723
4724	value = convertspacetolf(value);
4725
4726	return value;
4727	}
4728
4729	char* getmode3d()
4730	{
4731	char *mode3ddev = NULL;
4732	char *value = NULL;
4733
4734	mode3ddev = getconfig("mode3ddev", NULL);
4735
4736	if(mode3ddev == NULL)
4737	{
4738	err("NULL detect");
4739	return NULL;
4740	}
4741
4742	value = readsys(mode3ddev, 1);
4743	if(value == NULL)
4744	{
4745	err("NULL detect");
4746	return NULL;
4747	}
4748
4749	return value;
4750	}
4751
4752	int setmode3d(char* value)
4753	{
4754	char* mode3ddev;
4755	int ret = 0;
4756
4757	mode3ddev = getconfig("mode3ddev", NULL);
4758
4759	if(mode3ddev != NULL && value != NULL)
4760	{
4761	debug(100, "set %s to %s", mode3ddev, value);
4762	ret = writesys(mode3ddev, value, 0);
4763	if(ret == 0) addconfig("av_mode3d", value);
4764	return ret;
4765	}
4766
4767	return 0;
4768	}
4769
4770	char* getvideomode()
4771	{
4772	char *videomodedev = NULL;
4773	char *value = NULL;
4774
4775	videomodedev = getconfig("videomodedev", NULL);
4776
4777	if(videomodedev == NULL)
4778	{
4779	err("NULL detect");
4780	return NULL;
4781	}
4782
4783	value = readsys(videomodedev, 1);
4784	if(value == NULL)
4785	{
4786	err("NULL detect");
4787	return NULL;
4788	}
4789
4790	return value;
4791	}
4792
4793	void switchvideomode()
4794	{
4795	int rcret = 0;
4796	char* tmpstr = NULL;
4797	tmpstr = getvideomode();
4798	struct skin* playpolicy = getscreen("playpolicy");
4799
4800	if(tmpstr != NULL)
4801	{
4802	if(ostrcmp("pal", tmpstr) == 0 \|\| ostrncmp("576", tmpstr, 3) == 0)
4803	{
4804	setvideomode("720p50", 0);
4805	changefbresolution("720p50", 0);
4806	changetext(playpolicy, "720p50");
4807	writevfdmenu("720p50");
4808	unlink("/var/etc/.scart");
4809	}
4810	else if(ostrncmp("720", tmpstr, 3) == 0)
4811	{
4812	setvideomode("1080i50", 0);
4813	changefbresolution("1080i50", 0);
4814	changetext(playpolicy, "1080i50");
4815	writevfdmenu("1080i50");
4816	unlink("/var/etc/.scart");
4817	}
4818	else if(ostrncmp("1080", tmpstr, 4) == 0)
4819	{
4820	setvideomode("576i50", 0);
4821	changefbresolution("576i50", 0);
4822	changetext(playpolicy, "576i50");
4823	writevfdmenu("576i50 / pal");
4824	writesys("/var/etc/.scart", "0", 0);
4825	}
4826	/*
4827	int ret = textbox(_("Message"), _("Is this Videomode ok ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 10, 0);
4828	if(ret == 1 \|\| ret == 2)
4829	{
4830	setvideomode(tmpstr, 0);
4831	changefbresolution(tmpstr, 0);
4832	}
4833	*/
4834	drawscreen(playpolicy, 0, 0);
4835	while(1)
4836	{
4837	rcret = waitrc(playpolicy, 5000, 0);
4838	break;
4839	}
4840	clearscreen(playpolicy);
4841	}
4842	free(tmpstr);
4843	}
4844
4845	//flag 0: write videomode to config
4846	//flag 1: don't write videomode to config
4847	int setvideomode(char* value, int flag)
4848	{
4849	char* videomodedev;
4850	int ret = 0;
4851
4852	videomodedev = getconfig("videomodedev", NULL);
4853
4854	if(videomodedev != NULL && value != NULL)
4855	{
4856	debug(100, "set %s to %s", videomodedev, value);
4857	ret = writesys(videomodedev, value, 0);
4858	if(ret == 0 && flag == 0) addconfig("av_videomode", value);
4859	return ret;
4860	}
4861
4862	return 0;
4863	}
4864
4865	//flag 0 = hdmi
4866	//flag 1 = scart
4867	int setcolorformat(char* value, int flag)
4868	{
4869	char* colorformatdev;
4870	int ret = 0;
4871
4872	colorformatdev = getconfig("colorformatdev", NULL);
4873
4874	if(colorformatdev != NULL && value != NULL)
4875	{
4876	debug(100, "set %s to %s", colorformatdev, value);
4877	ret = writesys(colorformatdev, value, 0);
4878	if(ret == 0)
4879	{
4880	if(flag == 0)
4881	addconfig("av_colorformat", value);
4882	else
4883	addconfig("av_colorformatscart", value);
4884	}
4885	return ret;
4886	}
4887
4888	return 0;
4889	}
4890
4891	char* getcolorformat(int line)
4892	{
4893	char *colorformatdev = NULL;
4894	char *value = NULL;
4895
4896	colorformatdev = getconfig("colorformatdev", NULL);
4897
4898	if(colorformatdev == NULL)
4899	{
4900	err("NULL detect");
4901	return NULL;
4902	}
4903
4904	value = readsys(colorformatdev, line);
4905	if(value == NULL)
4906	{
4907	err("NULL detect");
4908	return NULL;
4909	}
4910
4911	return value;
4912	}
4913
4914	int setaudiosource(char* value)
4915	{
4916	char* audiosourcedev;
4917	int ret = 1;
4918
4919	audiosourcedev = getconfig("audiosourcedev", NULL);
4920
4921	if(audiosourcedev != NULL && value != NULL)
4922	{
4923	debug(100, "set %s to %s", audiosourcedev, value);
4924	ret = writesys(audiosourcedev, value, 0);
4925	if(ret == 0) addconfig("av_audiosource", value);
4926	return ret;
4927	}
4928
4929	return 0;
4930	}
4931
4932	char* getaudiosource()
4933	{
4934	char *audiosourcedev = NULL;
4935	char *value = NULL;
4936
4937	audiosourcedev = getconfig("audiosourcedev", NULL);
4938
4939	if(audiosourcedev == NULL)
4940	{
4941	err("NULL detect");
4942	return NULL;
4943	}
4944
4945	value = readsys(audiosourcedev, 1);
4946	if(value == NULL)
4947	{
4948	err("NULL detect");
4949	return NULL;
4950	}
4951
4952	return value;
4953	}
4954
4955	char* getsataswitch()
4956	{
4957	char *sataswitchdev = NULL;
4958	char *value = NULL;
4959
4960	sataswitchdev = getconfig("sataswitchdev", NULL);
4961
4962	if(sataswitchdev == NULL)
4963	{
4964	err("NULL detect");
4965	return NULL;
4966	}
4967
4968	value = readsys(sataswitchdev, 1);
4969	if(value == NULL)
4970	{
4971	err("NULL detect");
4972	return NULL;
4973	}
4974
4975	return value;
4976	}
4977
4978	int setsataswitch(char* value)
4979	{
4980	char* sataswitchdev;
4981	int ret = 1;
4982
4983	sataswitchdev = getconfig("sataswitchdev", NULL);
4984
4985	if(sataswitchdev != NULL && value != NULL)
4986	{
4987	debug(100, "set %s to %s", sataswitchdev, value);
4988	ret = writesys(sataswitchdev, value, 0);
4989	return ret;
4990	}
4991
4992	return 0;
4993	}
4994
4995	int setprogress(value)
4996	{
4997	char *progressdev;
4998
4999	progressdev = getconfig("progressdev", NULL);
5000
5001	if(progressdev != NULL)
5002	{
5003	debug(100, "set %s to %d",progressdev, value);
5004	return writesysint(progressdev, value, 0);
5005	}
5006
5007	return 0;
5008	}
5009
5010	int setmute(int value)
5011	{
5012	char* mutedev;
5013	int tmpvol, ret = 0;
5014
5015	//don't set mute 2x
5016	if(value == 1 && status.mute == 1) return 0;
5017
5018	if(value == 2)
5019	{
5020	tmpvol = getvol();
5021	tmpvol = tmpvol * 50 / 100;
5022	status.mute = value;
5023	setvol(tmpvol);
5024	}
5025	else
5026	{
5027	mutedev = getconfig("mutedev", NULL);
5028
5029	if(mutedev != NULL)
5030	{
5031	debug(100, "set %s to %d", mutedev, value);
5032	//if(status.volautochangevalue != 0 && value == 0) setvol(getvol());
5033	ret = writesysint(mutedev, value, 0);
5034	if(ret == 0) status.mute = value;
5035	if(status.volautochangevalue != 0 && value == 0) setvol(getvol());
5036	return ret;
5037	}
5038	}
5039	return 0;
5040	}
5041
5042	int setvol(int value)
5043	{
5044	char* voldev;
5045	int ret = 0, tmpvol = value;
5046
5047	voldev = getconfig("voldev", NULL);
5048
5049	if(voldev != NULL)
5050	{
5051	if(value > 100) value = 100;
5052	if(value < 0) value = 0;
5053	if(status.volautochangevalue != 0 && value != 0)
5054	{
5055	if(status.volautochange == 0)
5056	value = value - (status.volautochangevalue * value / 100);
5057	}
5058	value = 63 - value * 63 / 100;
5059	debug(100, "set %s to %d", voldev, value);
5060	ret = 0;
5061	if(status.mute == 1)
5062	status.volmute = value;
5063	else
5064	{
5065	status.volmute = -1;
5066	ret = writesysint(voldev, value, 0);
5067	}
5068	if(ret == 0 && status.mute != 2) addconfigint("vol", tmpvol);
5069	return ret;
5070	}
5071
5072	return 0;
5073	}
5074
5075	int getvol()
5076	{
5077	char *voldev = NULL;
5078	char *value = NULL;
5079	int tmpvol = -1;
5080
5081	voldev = getconfig("voldev", NULL);
5082
5083	if(voldev == NULL)
5084	{
5085	err("NULL detect");
5086	return 0;
5087	}
5088	if(status.volmute == -1)
5089	value = readsys(voldev, 1);
5090	else
5091	tmpvol = status.volmute;
5092	if(value == NULL && tmpvol == -1)
5093	{
5094	err("NULL detect");
5095	return 0;
5096	}
5097	if(status.volmute == -1)
5098	tmpvol = atoi(value);
5099	free(value);
5100	tmpvol = 100 - tmpvol * 100 / 63;
5101	if(status.volautochangevalue != 0)
5102	{
5103	if(status.volautochange == 0 && status.volautochangevalue < 100)
5104	tmpvol = tmpvol + ((tmpvol * status.volautochangevalue) / (100 - status.volautochangevalue));
5105	}
5106	return tmpvol;
5107	}
5108
5109	void setdebuglevel()
5110	{
5111	debug_level = getconfigint("debuglevel", NULL);
5112	debug(0, "set debug level to %d", debug_level);
5113	}
5114
5115	char* getxmlentry(char line, char searchstr)
5116	{
5117	char buf = NULL, buf1 = NULL, *buf2 = NULL;
5118
5119	buf = ostrstr(line, searchstr);
5120	if(buf == NULL)
5121	return NULL;
5122
5123	buf = buf + strlen(searchstr);
5124	if(buf[0] == '"')
5125	{
5126	buf = buf + 1;
5127	buf1 = ostrcat(buf, NULL, 0, 0);
5128	if(buf1 == NULL)
5129	{
5130	err("ostrcat failed");
5131	return NULL;
5132	}
5133	buf2 = strchr(buf1, '"');
5134	if(buf2 == NULL)
5135	{
5136	err("strchr returns NULL");
5137	free(buf1);
5138	return NULL;
5139	}
5140	buf2[0] = '\0';
5141	}
5142	else
5143	{
5144	buf1 = ostrcat(buf, NULL, 0, 0);
5145	if(buf1 == NULL)
5146	{
5147	err("ostrcat failed");
5148	return NULL;
5149	}
5150	buf2 = strchr(buf1, ' ');
5151	if(buf2 == NULL)
5152	{
5153	buf2 = ostrstr(buf1, "/>");
5154	if(buf2 == NULL)
5155	{
5156	buf2 = strchr(buf1, '>');
5157	if(buf2 == NULL)
5158	{
5159	err("strchr returns NULL");
5160	free(buf1);
5161	return NULL;
5162	}
5163	}
5164	}
5165	buf2[0] = '\0';
5166	}
5167
5168	return buf1;
5169	}
5170
5171	char* readbintomem(const char* filename, size_t size)
5172	{
5173	FILE *fd = NULL;
5174	char *fileline = NULL;
5175
5176	fileline = calloc(1, size + 1);
5177	if(fileline == NULL)
5178	{
5179	err("no memory");
5180	return NULL;
5181	}
5182
5183	fd = fopen(filename, "rb");
5184	if(fd == NULL)
5185	{
5186	perr("can't open %s", filename);
5187	free(fileline);
5188	return NULL;
5189	}
5190
5191	fread(fileline, size, 1, fd);
5192
5193	fclose(fd);
5194	return fileline;
5195	}
5196
5197	char* readfiletomem(const char* filename, int flag)
5198	{
5199	FILE *fd = NULL;
5200	char fileline = NULL, buf = NULL, *buf1 = NULL;
5201	int buf1size = 0, buf1oldsize = 0;
5202
5203	fileline = malloc(MINMALLOC);
5204	if(fileline == NULL)
5205	{
5206	err("no memory");
5207	return NULL;
5208	}
5209
5210	fd = fopen(filename, "r");
5211	if(fd == NULL)
5212	{
5213	perr("can't open %s", filename);
5214	free(fileline);
5215	return NULL;
5216	}
5217
5218	while(fgets(fileline, MINMALLOC, fd) != NULL)
5219	{
5220	buf = fileline;
5221
5222	if(flag == 1)
5223	if(buf[0] == '#' \|\| buf[0] == '\n')
5224	continue;
5225
5226	buf1oldsize = buf1size;
5227	buf1size += strlen(buf);
5228	buf1 = realloc(buf1, buf1size + 1);
5229	if(buf1 == NULL)
5230	{
5231	err("no memory");
5232	free(fileline);
5233	fclose(fd);
5234	return NULL;
5235	}
5236
5237	sprintf(buf1 + buf1oldsize, "%s", buf);
5238	}
5239
5240	free(fileline);
5241	fclose(fd);
5242	return buf1;
5243	}
5244
5245	char* readeittomem(const char* filename)
5246	{
5247	unsigned char byte;
5248	FILE *fil = NULL;
5249	char zeichen = NULL, buf = NULL, *buf1 = NULL;
5250	int buf1size = 0, buf1oldsize = 0;
5251	int Beschreibung;
5252	int len;
5253
5254	zeichen = malloc(255);
5255	if(zeichen == NULL)
5256	{
5257	err("no memory");
5258	return NULL;
5259	}
5260	buf = malloc(255);
5261	if(buf == NULL)
5262	{
5263	free(zeichen);
5264	err("no memory");
5265	return NULL;
5266	}
5267
5268	fil = fopen(filename, "r");
5269	if(fil == NULL)
5270	{
5271	err("can't open %s", filename);
5272	free(zeichen);
5273	free(buf);
5274	return NULL;
5275	}
5276	Beschreibung = 0;
5277	fseek(fil, 12, SEEK_SET); //ersten 12 Byte nicht relevant
5278	while(!feof(fil)) {
5279	byte=fgetc(fil);
5280
5281	if (byte == 0x4D) {
5282	fseek(fil, 4,SEEK_CUR);
5283	byte=fgetc(fil);
5284	len = byte + 0;
5285	byte=fgetc(fil);
5286	fgets(zeichen,len,fil);
5287	if (byte != 0x05)
5288	sprintf(buf,"%c%s\n", byte,zeichen);
5289	else
5290	sprintf(buf,"%s\n", zeichen);
5291
5292	buf1oldsize = buf1size;
5293	buf1size += strlen(buf);
5294	buf1 = realloc(buf1, buf1size + 1);
5295	if(buf1 == NULL)
5296	{
5297	err("no memory");
5298	free(zeichen);
5299	free(buf);
5300	fclose(fil);
5301	return NULL;
5302	}
5303	sprintf(buf1 + buf1oldsize, "%s", buf);
5304
5305	//printf("T %s\n", zeichen);
5306	byte=fgetc(fil);
5307	len = byte + 0;
5308	byte=fgetc(fil);
5309	fgets(zeichen,len,fil);
5310	if (byte != 0x05)
5311	sprintf(buf,"%c%s\n\n", byte,zeichen);
5312	else
5313	sprintf(buf,"%s\n\n", zeichen);
5314
5315	buf1oldsize = buf1size;
5316	buf1size += strlen(buf);
5317	buf1 = realloc(buf1, buf1size + 1);
5318	if(buf1 == NULL)
5319	{
5320	err("no memory");
5321	free(zeichen);
5322	free(buf);
5323	fclose(fil);
5324	return NULL;
5325	}
5326	sprintf(buf1 + buf1oldsize, "%s", buf);
5327
5328	}
5329	else if (byte == 0x4E) {
5330	fseek(fil, 6,SEEK_CUR);
5331	byte=fgetc(fil);
5332	len = byte;
5333	byte=fgetc(fil);
5334	fgets(zeichen,len,fil);
5335	if (Beschreibung == 0) {
5336	if (byte != 0x05)
5337	sprintf(buf,"%c%s", byte,zeichen);
5338	else
5339	sprintf(buf,"%s", zeichen);
5340	Beschreibung = 1;
5341	}
5342	else
5343	{
5344	if (byte != 0x05)
5345	sprintf(buf,"%c%s", byte,zeichen);
5346	else
5347	sprintf(buf,"%s", zeichen);
5348	}
5349
5350	buf1oldsize = buf1size;
5351	buf1size += strlen(buf);
5352	buf1 = realloc(buf1, buf1size + 1);
5353	if(buf1 == NULL)
5354	{
5355	err("no memory");
5356	free(zeichen);
5357	free(buf);
5358	fclose(fil);
5359	return NULL;
5360	}
5361	sprintf(buf1 + buf1oldsize, "%s", buf);
5362
5363	}
5364	else {
5365	byte=fgetc(fil);
5366	len= byte;
5367	fgets(zeichen,len+1,fil);
5368	}
5369	}
5370	free(zeichen);
5371	free(buf);
5372	fclose(fil);
5373	return buf1;
5374	}
5375
5376	char* command(char* input)
5377	{
5378	char* tmpstr = NULL, *fileline = NULL;
5379	FILE *iopipe = NULL;
5380
5381	if(input == NULL) return NULL;
5382
5383	fileline = malloc(MINMALLOC);
5384	if(fileline == NULL)
5385	{
5386	err("no memory");
5387	return NULL;
5388	}
5389
5390	if((iopipe = popen(input, "r")) == NULL)
5391	{
5392	free(fileline);
5393	return NULL;
5394	}
5395
5396	while(!feof(iopipe))
5397	{
5398	if(fgets(fileline, MINMALLOC, iopipe) != NULL)
5399	tmpstr = ostrcat(tmpstr, fileline, 1, 0);
5400	}
5401
5402	free(fileline);
5403	pclose(iopipe);
5404	return tmpstr;
5405	}
5406
5407	char* string_tolower(char *str)
5408	{
5409	char *p1 = str;
5410
5411	if(str == NULL) return NULL;
5412
5413	while(*p1 != '\0')
5414	p1++ = tolower(p1);
5415
5416	return str;
5417	}
5418
5419	char* string_toupper(char *str)
5420	{
5421	char *p1 = str;
5422
5423	if(str == NULL) return NULL;
5424
5425	while(*p1 != '\0')
5426	p1++ = toupper(p1);
5427
5428	return str;
5429	}
5430
5431	char* stringreplacecharonce(char *str, char c1, char c2)
5432	{
5433	char *p1 = str;
5434
5435	if(str == NULL) return NULL;
5436
5437	while(*p1 != '\0')
5438	{
5439	if(*p1 == c1)
5440	{
5441	*p1 = c2;
5442	break;
5443	}
5444	p1++;
5445	}
5446
5447	return str;
5448	}
5449
5450	char* stringreplacechar(char *str, char c1, char c2)
5451	{
5452	char *p1 = str;
5453
5454	if(str == NULL) return NULL;
5455
5456	while(*p1 != '\0')
5457	{
5458	if(p1 == c1) p1 = c2;
5459	p1++;
5460	}
5461
5462	return str;
5463	}
5464
5465
5466	char* string_removechar(char *str)
5467	{
5468	char *p1 = str;
5469
5470	if(str == NULL) return NULL;
5471
5472	while(*p1 != '\0')
5473	{
5474	if(p1 == '.') p1 = ' ';
5475	else if(p1 == '-') p1 = ' ';
5476	else if(p1 == '_') p1 = ' ';
5477	else if(p1 == '/') p1 = ' ';
5478	p1++;
5479	}
5480
5481	return str;
5482	}
5483
5484	char* string_withchars2return(char *str)
5485	{
5486	char *p1 = str;
5487
5488	if(str == NULL) return NULL;
5489
5490	while(*p1 != '\0')
5491	{
5492	if(p1 == ' ') p1 = '\n';
5493	p1++;
5494	}
5495
5496	return str;
5497	}
5498
5499	char* string_remove_whitechars(char *text)
5500	{
5501	char p1 = text, p2 = text;
5502
5503	if(text == NULL) return NULL;
5504
5505	while(*p1 != '\0')
5506	{
5507	if(*p1 == ' ')
5508	++p1;
5509	else
5510	p2++ = p1++;
5511	}
5512	*p2 = '\0';
5513
5514	return text;
5515	}
5516
5517	char* strstrip(char *text)
5518	{
5519	char* tmpstr = text;
5520
5521	if(text == NULL) return NULL;
5522	int len = strlen(text);
5523
5524	while(isspace(tmpstr[len - 1])) tmpstr[--len] = '\0';
5525	while(tmpstr && isspace(tmpstr)) ++tmpstr, --len;
5526
5527	memmove(text, tmpstr, len + 1);
5528
5529	return text;
5530	}
5531
5532	char* string_strip_whitechars(char *text)
5533	{
5534	char p1 = text, p2 = text;
5535
5536	if(text == NULL)
5537	return NULL;
5538
5539	while(*p1 != '\0')
5540	{
5541	if(p1 == ' ' && (p1 + 1) == ' ')
5542	++p1;
5543	else
5544	p2++ = p1++;
5545	}
5546	*p2 = '\0';
5547
5548	return text;
5549	}
5550
5551	char* string_replace_all(char search, char replace, char *string, int free1)
5552	{
5553	char* tmpstr = NULL;
5554	char* searchpos = NULL;
5555
5556	if(string == NULL \|\| search == NULL)
5557	{
5558	tmpstr = ostrcat(tmpstr, string, 1, 0);
5559	if(free1 == 1) free(string);
5560	return tmpstr;
5561	}
5562
5563	searchpos = strstr(string, search);
5564	if(searchpos == NULL)
5565	{
5566	tmpstr = ostrcat(tmpstr, string, 1, 0);
5567	if(free1 == 1) free(string);
5568	return tmpstr;
5569	}
5570
5571	int count = 0;
5572	int stringlen = strlen(string);
5573	int searchlen = strlen(search);
5574	int replacelen = strlen(replace);
5575
5576	while(searchpos != NULL)
5577	{
5578	count++;
5579	searchpos = strstr(searchpos + searchlen, search);
5580	}
5581
5582	int len = stringlen - (searchlen * count) + (replacelen * count);
5583	tmpstr = calloc(1, len + 1);
5584	if(tmpstr == NULL)
5585	{
5586	err("no mem");
5587	tmpstr = ostrcat(tmpstr, string, 1, 0);
5588	if(free1 == 1) free(string);
5589	return tmpstr;
5590	}
5591
5592	len = 0;
5593	char* str = string;
5594	char* tmp = tmpstr;
5595	searchpos = strstr(str, search);
5596	while(searchpos != NULL)
5597	{
5598	len = searchpos - str;
5599	memcpy(tmp, str, len);
5600	memcpy(tmp + len, replace, replacelen);
5601	tmp += len + replacelen;
5602	str += len + searchlen;
5603	searchpos = strstr(str, search);
5604	}
5605	memcpy(tmp, str, strlen(str));
5606
5607	if(free1 == 1) free(string);
5608
5609	return tmpstr;
5610	}
5611
5612	char* string_replace_remove_last_chars(char search, char replace, char *string, int free1)
5613	{
5614	char* searchpos = NULL;
5615	char* tmpstr = NULL;
5616
5617	if(string == NULL \|\| search == NULL)
5618	{
5619	tmpstr = ostrcat(tmpstr, string, 1, 0);
5620	if(free1 == 1) free(string);
5621	return tmpstr;
5622	}
5623
5624	searchpos = ostrstr(string, search);
5625
5626	if(searchpos == NULL)
5627	{
5628	tmpstr = ostrcat(tmpstr, string, 1, 0);
5629	if(free1 == 1) free(string);
5630	return tmpstr;
5631	}
5632
5633	tmpstr = strndup(string, searchpos - string);
5634	if(replace != NULL)
5635	tmpstr = ostrcat(tmpstr, replace, 1, 0);
5636
5637	if(free1 == 1) free(string);
5638
5639	return tmpstr;
5640	}
5641
5642	char* string_replace(char search, char replace, char *string, int free1)
5643	{
5644	char* searchpos = NULL;
5645	char* tmpstr = NULL;
5646
5647	if(string == NULL \|\| search == NULL)
5648	{
5649	tmpstr = ostrcat(tmpstr, string, 1, 0);
5650	if(free1 == 1) free(string);
5651	return tmpstr;
5652	}
5653
5654	searchpos = ostrstr(string, search);
5655
5656	if(searchpos == NULL)
5657	{
5658	tmpstr = ostrcat(tmpstr, string, 1, 0);
5659	if(free1 == 1) free(string);
5660	return tmpstr;
5661	}
5662
5663	tmpstr = strndup(string, searchpos - string);
5664	if(replace != NULL)
5665	tmpstr = ostrcat(tmpstr, replace, 1, 0);
5666	tmpstr = ostrcat(tmpstr, string + (searchpos - string) + strlen(search), 1, 0);
5667
5668	if(free1 == 1) free(string);
5669
5670	return tmpstr;
5671	}
5672
5673	//flag 0: search full str
5674	//flag 1: search only end of string
5675	char* ostrrstrcase(char* str, char* search, int len, int flag)
5676	{
5677	int slen = 0;
5678	char* tmpstr = NULL;
5679
5680	if(str == NULL \|\| search == NULL) return NULL;
5681
5682	if(len == -1) len = strlen(str);
5683	slen = strlen(search);
5684	if(slen > len) return NULL;
5685
5686	for(tmpstr = str + len - slen; tmpstr >= str; tmpstr--)
5687	{
5688	if(strncasecmp(tmpstr, search, slen) == 0)
5689	return tmpstr;
5690	if(flag == 1) return NULL;
5691	}
5692
5693	return NULL;
5694	}
5695
5696	//flag 0: search full str
5697	//flag 1: search only end of string
5698	char* ostrrstr(char* str, char* search, int len, int flag)
5699	{
5700	int slen = 0;
5701	char* tmpstr = NULL;
5702
5703	if(str == NULL \|\| search == NULL) return NULL;
5704
5705	if(len == -1) len = strlen(str);
5706	slen = strlen(search);
5707	if(slen > len) return NULL;
5708
5709	for(tmpstr = str + len - slen; tmpstr >= str; tmpstr--)
5710	{
5711	if(strncmp(tmpstr, search, slen) == 0)
5712	return tmpstr;
5713	if(flag == 1) return NULL;
5714	}
5715
5716	return NULL;
5717	}
5718
5719	char* ostrstr(char* str, char* search)
5720	{
5721	char* ret = NULL;
5722
5723	if(str == NULL \|\| search == NULL) return NULL;
5724	ret = strstr(str, search);
5725
5726	return ret;
5727	}
5728
5729	int file_exist(char* filename)
5730	{
5731	if(access(filename, F_OK) == 0)
5732	return 1;
5733	else
5734	return 0;
5735	}
5736
5737	char* string_newline(char* str)
5738	{
5739	if(str == NULL) return NULL;
5740
5741	int size = strlen(str);
5742
5743	if(str[size - 1] == '\n')
5744	str[size - 1] = '\0';
5745
5746	return str;
5747	}
5748
5749	char* string_quote(char* str)
5750	{
5751	char* tmpstr = NULL;
5752
5753	tmpstr = ostrcat("\"", str, 0, 0);
5754	tmpstr = ostrcat(tmpstr, "\"", 1, 0);
5755
5756	return tmpstr;
5757	}
5758
5759	struct splitstr* strsplit(char str, char tok, int* count)
5760	{
5761	char *tmpstr = NULL;
5762	struct splitstr *tmparray = NULL;
5763	*count = 0;
5764
5765	if(str == NULL \|\| tok == NULL)
5766	return NULL;
5767
5768	tmpstr = strtok(str, tok);
5769	while(tmpstr != NULL)
5770	{
5771	count = count + 1;
5772	tmparray = (struct splitstr)realloc(tmparray, sizeof(struct splitstr) * (*count));
5773	if(tmparray == NULL)
5774	return NULL;
5775	(&tmparray[(*count) - 1])->part = tmpstr;
5776	tmpstr = strtok(NULL, tok);
5777	}
5778
5779	return tmparray;
5780	}
5781
5782	char* string_shortname(char *tmpfilename, int mode)
5783	{
5784	debug(50, "in %s",tmpfilename);
5785
5786	// char replacelist[] = "avi mkv x264 se disc0 disc1 disc2 disc3 disc4 0disc 1disc 2disc 3disc 4disc season0 season1 season2 season3 season4 season5 season6 season7 season8 season9 hdtv 720p 1080i 1080p uncut cd0 cd1 cd2 cd3 cd4 cd5 cd6 cd7 cd8 cd9 dvd0 dvd1 dvd2 dvd3 dvd4 ac3d ac3 bdrip bluray cam camrip complete custom cut dc directors dl doku dts dvdr dvdrip dvdscr dvdscreener extended french finnish german hd hddvd hddvdrip hdtv int internal int ld limited multi multisubs nordic ntsc pal pl r1 r5 recut remastered repack rip screener se see special.edition sse stv subbed swedish staffel tc telecine telesync ts unrated ws xxx italian";
5787	char* str = NULL;
5788
5789	if (mode==1)
5790	{
5791	char* replacelist = "avi mkv x264 xvid se uncut ac3d ac3hd ac3 bdrip bluray cam camrip complete custom cut dc directors dl doku dts dvdr dvdrip dvdscr dvdscreener ecc extended french finnish german hd hddvd hddvdrip hdtv int internal int ld limited multi multisubs nordic ntsc pal pl r1 r5 recut remastered repack rip screener se see sse stv subbed swedish staffel tc telecine telesync ts unrated ws xxx italian";
5792	str = ostrcat(str, replacelist, 1, 0);
5793	}
5794	else if (mode==2)
5795	{
5796	char* replacelist = "1080i 1080p 720p ac3 ac3d ac3hd avi bdrip bluray cam camrip complete custom cut dat dc directors divx dl doku dts dvdr dvdrip dvdscr dvdscreener ecc ed extended finnish flv french german hd hddvd hddvdrip hdtv int internal ld limited linedubbed m2ts m4v md mkv mov mp4 mpeg mpg mts multi multisubs nordic ntsc pal pl proper r1 r3 r5 recut remastered repack rip rm screener se sse staffel stv subbed svcd swedish tc telecine telesync trp ts uc uncut unrated ur vcd vdr vob wmv ws x264 xvid xxx";
5797	str = ostrcat(str, replacelist, 1, 0);
5798	}
5799	else
5800	{
5801	char* replacelist = "disc0 disc1 disc2 disc3 disc4 0disc 1disc 2disc 3disc 4disc season0 season1 season2 season3 season4 season5 season6 season7 season8 season9 hdtv 720p 1080i 1080p cd0 cd1 cd2 cd3 cd4 cd5 cd6 cd7 cd8 cd9 dvd0 dvd1 dvd2 dvd3 dvd4";
5802	str = ostrcat(str, replacelist, 1, 0);
5803	}
5804
5805	char* replace = NULL;
5806	struct splitstr* ret1 = NULL;
5807	int count = 0;
5808	int i = 0;
5809	ret1 = strsplit(str, " ", &count);
5810	int max = count - 1;
5811	int first = 1;
5812
5813	for(i = 0; i < max; i++)
5814	{
5815	struct splitstr* ret2 = NULL;
5816	int count2 = 0;
5817	int j = 0;
5818	char *tmpstr = NULL;
5819	tmpstr = ostrcat(tmpstr, tmpfilename, 1, 0);
5820	ret2 = strsplit(tmpstr, " ,.-_", &count2);
5821
5822	for(j = 0; j < count2; j++)
5823	{
5824	if(j > 0)
5825	{
5826	if(ostrcmp((&ret1[i])->part, (&ret2[j])->part) == 0)
5827	{
5828	if (mode==1)
5829	{
5830	tmpfilename = string_replace((&ret2[j])->part, replace, tmpfilename, 1);
5831	continue;
5832	}
5833	else if (mode==2)
5834	{
5835	tmpfilename = string_replace_remove_last_chars((&ret2[j])->part, replace, tmpfilename, 1);
5836	//break;
5837	continue;
5838	}
5839	else
5840	{
5841	tmpfilename = string_replace((&ret2[j])->part, replace, tmpfilename, 1);
5842	continue;
5843	}
5844	}
5845	else if (first == 1 && mode == 2)
5846	{
5847	// printf("zahl: %s\n", (&ret2[j])->part);
5848	int theCharacter = atoi((&ret2[j])->part);
5849	if(theCharacter != 0)
5850	{
5851	// printf("found zahl: %s\n", (&ret2[j])->part);
5852	if(theCharacter > 1800 && theCharacter < 2100)
5853	{
5854	// printf("found year: %s\n", (&ret2[j])->part);
5855	tmpfilename = string_replace_remove_last_chars((&ret2[j])->part, "", tmpfilename, 1);
5856	break;
5857	}
5858	}
5859	}
5860	}
5861	}
5862	free(ret2); ret2 = NULL;
5863	first = 0;
5864	free(tmpstr), tmpstr = NULL;
5865	}
5866
5867	free(ret1); ret1 = NULL;
5868	free(replace); replace = NULL;
5869	free(str); str = NULL;
5870
5871	debug(50, "out %s", tmpfilename);
5872	return tmpfilename;
5873	}
5874
5875	char* get_uuid(char* device)
5876	{
5877	debug(60, "in %s", device);
5878	char* cmd = NULL, *tmpstr = NULL;
5879
5880	if(device == NULL) return NULL;
5881
5882	cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s UUID /dev/", 1, 0);
5883	cmd = ostrcat(cmd, device, 1, 0);
5884	cmd = ostrcat(cmd, " \| cut -d'\"' -f2", 1, 0);
5885
5886	tmpstr = string_newline(command(cmd));
5887
5888	if(ostrcmp(string_newline(tmpstr), "") == 0)
5889	{
5890	free(tmpstr); tmpstr = NULL;
5891	}
5892
5893	debug(60, "out %s", cmd);
5894	free(cmd); cmd = NULL;
5895	return tmpstr;
5896	}
5897
5898	char* get_label(char* device)
5899	{
5900	debug(60, "in %s", device);
5901	char* cmd = NULL, *tmpstr = NULL;
5902
5903	if(device == NULL) return NULL;
5904
5905	cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s LABEL /dev/", 1, 0);
5906	cmd = ostrcat(cmd, device, 1, 0);
5907	cmd = ostrcat(cmd, " \| cut -d'\"' -f2", 1, 0);
5908
5909	tmpstr = string_newline(command(cmd));
5910
5911	if(tmpstr == NULL)
5912	tmpstr = ostrcat(tmpstr, "NONLABEL", 1, 0);
5913
5914	if(ostrcmp(string_newline(tmpstr), "") == 0)
5915	tmpstr = ostrcat(tmpstr, "NONLABEL", 1, 0);
5916
5917	debug(60, "out %s", cmd);
5918	free(cmd); cmd = NULL;
5919	return tmpstr;
5920	}
5921
5922	char* get_filesystem(char* device)
5923	{
5924	debug(60, "in %s", device);
5925	char* cmd = NULL, *tmpstr = NULL;
5926
5927	if(device == NULL) return NULL;
5928
5929	cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s TYPE /dev/", 1, 0);
5930	cmd = ostrcat(cmd, device, 1, 0);
5931	cmd = ostrcat(cmd, " \| cut -d'\"' -f2", 1, 0);
5932
5933	tmpstr = string_newline(command(cmd));
5934
5935	if(tmpstr == NULL)
5936	tmpstr = ostrcat(tmpstr, "NONTYPE", 1, 0);
5937
5938	if(ostrcmp(string_newline(tmpstr), "") == 0)
5939	tmpstr = ostrcat(tmpstr, "NONTYPE", 1, 0);
5940
5941	debug(60, "out %s", cmd);
5942	free(cmd); cmd = NULL;
5943	return tmpstr;
5944	}
5945
5946	//flag 0: convert ip to 000.000.000.000
5947	//flag 1: convert ip to 0.0.0.0
5948	char* fixip(char* ipinput, int flag)
5949	{
5950	debug(60, "in %s", ipinput);
5951	int ret = 0;
5952	char* ipout = NULL;
5953	unsigned char ip[4];
5954
5955	ip[0] = 0;
5956	ip[1] = 0;
5957	ip[2] = 0;
5958	ip[3] = 0;
5959
5960	if(ipinput == NULL) return NULL;
5961	ret = sscanf(ipinput, "%hhu.%hhu.%hhu.%hhu", &ip[0], &ip[1], &ip[2], &ip[3]);
5962	if(ret != 4) return NULL;
5963
5964	ipout = malloc(16);
5965	if(ipout == NULL)
5966	{
5967	err("no mem");
5968	return NULL;
5969	}
5970
5971	if(flag == 1)
5972	snprintf(ipout, 16, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
5973	else
5974	snprintf(ipout, 16, "%03d.%03d.%03d.%03d", ip[0], ip[1], ip[2], ip[3]);
5975
5976	return ipout;
5977	}
5978
5979	void setfanspeed(int speed, int aktion)
5980	{
5981	char* speedWert = NULL;
5982	char* speedSet = NULL;
5983
5984	if(speed < 0)
5985	{
5986	speedWert = getconfig("fanspeed", NULL);
5987	if(speedWert == NULL)
5988	speedSet = ostrcat(speedSet, "170", 1, 0);
5989	else
5990	speedSet = ostrcat(speedSet, speedWert, 1, 0);
5991	}
5992	else
5993	{
5994	if(speed == 0)
5995	speedSet = ostrcat(speedSet, "115", 1, 0);
5996	else if(speed == 25)
5997	speedSet = ostrcat(speedSet, "130", 1, 0);
5998	else if(speed == 50)
5999	speedSet = ostrcat(speedSet, "145", 1, 0);
6000	else if(speed == 75)
6001	speedSet = ostrcat(speedSet, "155", 1, 0);
6002	else
6003	speedSet = ostrcat(speedSet, "170", 1, 0);
6004	}
6005
6006	writesys("/proc/stb/fan/fan_ctrl", speedSet, 1);
6007
6008	if(aktion == 1)
6009	addconfig("fanspeed", speedSet);
6010
6011	free(speedSet); speedSet=NULL;
6012	}
6013
6014	void setaktres()
6015	{
6016	int m_width = 0;
6017	char* res = NULL;
6018	char* res_akt = NULL;
6019	char* res_sd = NULL;
6020	int count = 1;
6021	int sec = 0;
6022
6023	m_lock(&status.setaktresmutex, 23);
6024
6025	if(status.restimer == NULL)
6026	goto end;
6027
6028	sec = (int)status.restimer->param1;
6029
6030	if(sec > 0)
6031	{
6032	while(status.restimer->aktion == START && count <= (sec * 10))
6033	{
6034	usleep(100000);
6035	if(status.restimer->aktion != START)
6036	goto end;
6037	count++;
6038	}
6039	}
6040	if(status.restimer->aktion != START) goto end;
6041
6042	if(videoreadqwidth(status.aktservice->videodev) == 0)
6043	{
6044	if(status.restimer->aktion != START) goto end;
6045	m_width = status.videosize.w;
6046	if(m_width == 720)
6047	{
6048	res_sd = getconfig("av_videomode_autores_sd", NULL);
6049	if(res_sd == NULL)
6050	res = ostrcat(res, "576i50", 1, 0);
6051	else
6052	res = ostrcat(res, res_sd, 1, 0);
6053	}
6054	else if (m_width == 1280)
6055	res = ostrcat(res, "720p50", 1, 0);
6056	else if (m_width == 1920)
6057	res = ostrcat(res, "1080i50", 1, 0);
6058	else
6059	m_width = 0;
6060
6061	if(m_width > 0)
6062	{
6063	if(status.restimer->aktion != START) goto end;
6064	res_akt = getvideomode();
6065	if(status.restimer->aktion != START) goto end;
6066	if(ostrcmp(res_akt, res) != 0)
6067	{
6068	if(status.restimer->aktion != START) goto end;
6069	setvideomode(res, 1);
6070	changefbresolution(res, 1);
6071	/*
6072	if(status.restimer->aktion != START) goto end;
6073
6074	count = 0;
6075	while(status.restimer->aktion == START && count < 10)
6076	{
6077	usleep(100000);
6078	if(status.restimer->aktion != START)
6079	goto end;
6080	count++;
6081	}
6082
6083	if(status.restimer->aktion != START) goto end;
6084	*/
6085	screenautores(res, 5, 0);
6086	}
6087	}
6088	}
6089	else
6090	{
6091	if(status.restimer->aktion != START) goto end;
6092	textbox(_("Message"), _("ERROR cant read res"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 5, 0);
6093	}
6094
6095	end:
6096	free(res); res = NULL;
6097	status.restimer = NULL;
6098	m_unlock(&status.setaktresmutex, 23);
6099	return;
6100	}
6101
6102	char* gettimestamp()
6103	{
6104	char* timestamp = NULL;
6105	struct timeval numtime;
6106
6107	gettimeofday(&numtime, 0);
6108	timestamp = ostrcat(timestamp, olutoa(numtime.tv_sec), 1, 1);
6109	timestamp = ostrcat(timestamp, olutoa(numtime.tv_usec), 1, 1);
6110
6111	return timestamp;
6112	}
6113
6114	char* string_decode(char* input, int flag)
6115	{
6116	if(input == NULL) return input;
6117
6118	while(ostrstr(input, "\\u00") != NULL)
6119	{
6120	debug(210, "input: %s", input);
6121	input = string_replace("\\u00", "%", input, 1);
6122	debug(210, "input: %s", input);
6123	}
6124
6125	while(ostrstr(input, "&") != NULL)
6126	{
6127	debug(210, "input: %s", input);
6128	input = string_replace("&", "und", input, 1);
6129	debug(210, "input: %s", input);
6130	}
6131
6132	while(ostrstr(input, ">") != NULL)
6133	{
6134	debug(210, "input: %s", input);
6135	input = string_replace(">", ">", input, 1);
6136	debug(210, "input: %s", input);
6137	}
6138
6139	while(ostrstr(input, "<") != NULL)
6140	{
6141	debug(210, "input: %s", input);
6142	input = string_replace("<", "<", input, 1);
6143	debug(210, "input: %s", input);
6144	}
6145
6146	while(ostrstr(input, """) != NULL)
6147	{
6148	debug(210, "input: %s", input);
6149	input = string_replace(""", "\"", input, 1);
6150	debug(210, "input: %s", input);
6151	}
6152
6153	while(ostrstr(input, "&#x") != NULL)
6154	{
6155	debug(210, "out %s", input);
6156	input = string_replace("&#x", "%", input, 1);
6157	debug(210, "input: %s", input);
6158	}
6159
6160	while(ostrstr(input, "&#") != NULL)
6161	{
6162	debug(210, "input: %s", input);
6163	input = string_replace("&#", "%", input, 1);
6164	debug(210, "input: %s", input);
6165	}
6166
6167	if(flag == 1)
6168	htmldecode2(input, input);
6169	else
6170	htmldecode(input, input);
6171
6172	while(ostrstr(input, ";") != NULL)
6173	{
6174	debug(210, "input: %s", input);
6175	input = string_replace(";", NULL, input, 1);
6176	debug(210, "input: %s", input);
6177	}
6178
6179	return input;
6180	}
6181
6182	char* string_deltags(char* str)
6183	{
6184	int i = 0, y = 0, len = 0;
6185
6186	if(str == NULL) return 0;
6187
6188	len = strlen(str);
6189
6190	int skip = 0;
6191	for(i = 0; i < len; i++)
6192	{
6193	if(str[i] == '<')
6194	skip = 1;
6195	else if(str[i] == '>')
6196	skip = 0;
6197
6198	if(skip == 0 && str[i] != '>')
6199	{
6200	str[y] = str[i];
6201	y++;
6202	}
6203	}
6204	str[y] = '\0';
6205
6206	return str;
6207	}
6208
6209	char* string_striptags(char* str)
6210	{
6211	int i = 0, len = 0;
6212
6213	if(str == NULL) return 0;
6214
6215	len = strlen(str);
6216
6217	int skip = 0;
6218	for(i = 0; i < len; i++)
6219	{
6220	if(str[i] == '<')
6221	skip = 1;
6222	else if(str[i] == '>')
6223	{
6224	skip = 0;
6225	str[i] = ' ';
6226	}
6227	if(skip == 1)
6228	str[i] = ' ';
6229	}
6230
6231	return strstrip(str);
6232	}
6233
6234	char* string_resub(char* str, char* str2, char* input, int dir)
6235	{
6236	int len;
6237	char* tmpstr = NULL, pos = NULL, pos2 = NULL;
6238
6239	if(str == NULL \|\| str2 == NULL \|\| input == NULL) return NULL;
6240
6241	if(dir == 0)
6242	{
6243	len = strlen(str);
6244	pos = ostrstr(input, str);
6245	if(pos == NULL) return NULL;
6246	pos += len;
6247
6248	pos2 = ostrstr(pos, str2);
6249	if(pos2 == NULL) return NULL;
6250	}
6251	else
6252	{
6253	pos2 = ostrstr(input, str2);
6254	if(pos2 == NULL) return NULL;
6255
6256	len = strlen(str);
6257	pos = ostrrstr(input, str, pos2 - input, 0);
6258	if(pos == NULL) return NULL;
6259	pos += len;
6260	}
6261
6262	tmpstr = strndup(pos, pos2 - pos);
6263
6264	return strstrip(tmpstr);
6265	}
6266
6267	char* ostrstrcase(char* str, char* sub)
6268	{
6269	size_t len = 0;
6270
6271	if(str == NULL \|\| sub == NULL) return NULL;
6272
6273	len = strlen(sub);
6274	while(*str)
6275	{
6276	if(toupper(str) == toupper(sub) && strncasecmp(str, sub, len) == 0)
6277	return str;
6278	++str;
6279	}
6280	return NULL;
6281	}
6282
6283	//flag 0: convert port to 00021
6284	//flag 1: convert port to 21
6285	char* fixport(char* input, int flag)
6286	{
6287	char* tmpstr = NULL;
6288
6289	if(flag == 0)
6290	{
6291	int plen = strlen(input);
6292	if(plen < 5)
6293	{
6294	int i;
6295	for(i = 0; i < 5 - plen; i++)
6296	tmpstr = ostrcat(tmpstr, "0", 1, 0);
6297	}
6298	tmpstr = ostrcat(tmpstr, input, 1, 0);
6299	}
6300	else
6301	{
6302	while (input && input == '0')
6303	input++;
6304
6305	tmpstr = ostrcat(tmpstr, input, 1, 0);
6306	}
6307	return tmpstr;
6308	}
6309
6310	#endif

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

Download in other formats: