Context Navigation

source: titan/titan/global.h @ 24243

Last change on this file since 24243 was 24243, checked in by nit, 10 years ago
[titan] add gzip decompress
File size: 126.9 KB

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

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

Download in other formats: