Context Navigation

source: titan/titan/global.h @ 24279

Last change on this file since 24279 was 24279, checked in by nit, 10 years ago
fix
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	if(flag == 0)
3334	{
3335	free(*outbuf);
3336	*outbuf = NULL;
3337	}
3338	(void)inflateEnd(&stream);
3339	return 1;
3340	}
3341
3342	}
3343	while(stream.avail_out == 0);
3344	*outlen = maxbuf - stream.avail_out;
3345	if(flag == 0) outbuf = realloc(outbuf, *outlen);
3346
3347	(void)inflateEnd(&stream);
3348	return 0;
3349	}
3350
3351	void endianswapshort(unsigned short* value)
3352	{
3353	value = (value >> 8) \| (*value << 8);
3354	}
3355
3356	int rcnumber(int rcret)
3357	{
3358	if(rcret == getrcconfigint("rc0", NULL) \|\|
3359	rcret == getrcconfigint("rc1", NULL) \|\|
3360	rcret == getrcconfigint("rc2", NULL) \|\|
3361	rcret == getrcconfigint("rc3", NULL) \|\|
3362	rcret == getrcconfigint("rc4", NULL) \|\|
3363	rcret == getrcconfigint("rc5", NULL) \|\|
3364	rcret == getrcconfigint("rc6", NULL) \|\|
3365	rcret == getrcconfigint("rc7", NULL) \|\|
3366	rcret == getrcconfigint("rc8", NULL) \|\|
3367	rcret == getrcconfigint("rc9", NULL))
3368	return rcret;
3369	else
3370	return -9999;
3371	}
3372
3373	int checkdirext(char* dir, char* ext)
3374	{
3375	struct dirent *dirent = NULL;
3376	DIR *pdir = NULL;
3377
3378	pdir = opendir(dir);
3379	if(pdir != NULL)
3380	{
3381	while((dirent = readdir(pdir)) != NULL)
3382	{
3383	if(ostrcmp(".", dirent->d_name) != 0 && ostrcmp("..", dirent->d_name) != 0)
3384	{
3385	if(ostrstr(dirent->d_name, ext) != NULL)
3386	{
3387	closedir(pdir);
3388	return 1;
3389	}
3390	}
3391	}
3392
3393	closedir(pdir);
3394	}
3395
3396	return 0;
3397	}
3398
3399	int delallfiles(char* dir, char* ext)
3400	{
3401	struct dirent *dirent = NULL;
3402	DIR *pdir = NULL;
3403	char* tmpstr = NULL;
3404
3405	pdir = opendir(dir);
3406	if(pdir != NULL)
3407	{
3408	while((dirent = readdir(pdir)) != NULL)
3409	{
3410	if(ostrcmp(".", dirent->d_name) != 0 && ostrcmp("..", dirent->d_name) != 0)
3411	{
3412	if(ext == NULL \|\| ostrstr(dirent->d_name, ext) != NULL)
3413	{
3414	tmpstr = ostrcat(dir, "/", 0, 0);
3415	tmpstr = ostrcat(tmpstr, dirent->d_name, 1, 0);
3416	unlink(tmpstr);
3417	free(tmpstr); tmpstr = NULL;
3418	}
3419	}
3420	}
3421
3422	closedir(pdir);
3423	}
3424
3425	return 0;
3426	}
3427
3428	unsigned long getfilecount(char* dir)
3429	{
3430	unsigned long count = 0;
3431	struct dirent *dirent = NULL;
3432	DIR *pdir = NULL;
3433
3434	pdir = opendir(dir);
3435	if(pdir != NULL)
3436	{
3437	while((dirent = readdir(pdir)) != NULL)
3438	count++;
3439
3440	closedir(pdir);
3441	}
3442
3443	return count;
3444	}
3445
3446	int getfiletype(char* filename)
3447	{
3448	struct stat64 s;
3449
3450	if(filename == NULL) return -1;
3451
3452	if(stat64(filename, &s) >= 0)
3453	{
3454	if(S_ISREG(s.st_mode)) return DT_REG;
3455	if(S_ISDIR(s.st_mode)) return DT_DIR;
3456	if(S_ISCHR(s.st_mode)) return DT_CHR;
3457	if(S_ISBLK(s.st_mode)) return DT_BLK;
3458	if(S_ISFIFO(s.st_mode)) return DT_FIFO;
3459	if(S_ISLNK(s.st_mode)) return DT_LNK;
3460	}
3461
3462	return DT_UNKNOWN;
3463	}
3464
3465	int getlfiletype(char* filename)
3466	{
3467	struct stat64 s;
3468
3469	if(filename == NULL) return -1;
3470
3471	if(lstat64(filename, &s) >= 0)
3472	{
3473	if(S_ISREG(s.st_mode)) return DT_REG;
3474	if(S_ISDIR(s.st_mode)) return DT_DIR;
3475	if(S_ISCHR(s.st_mode)) return DT_CHR;
3476	if(S_ISBLK(s.st_mode)) return DT_BLK;
3477	if(S_ISFIFO(s.st_mode)) return DT_FIFO;
3478	if(S_ISLNK(s.st_mode)) return DT_LNK;
3479	}
3480
3481	return DT_UNKNOWN;
3482	}
3483
3484	unsigned long long getfullspace(char* dir)
3485	{
3486	struct statfs64 s;
3487	unsigned long long fullsize = 0;
3488
3489	if(statfs64(dir, &s) >= 0)
3490	{
3491	fullsize = s.f_blocks;
3492	fullsize *= s.f_bsize;
3493	}
3494
3495	return fullsize;
3496	}
3497
3498	unsigned long long getfreespace(char* dir)
3499	{
3500	struct statfs64 s;
3501	unsigned long long freesize = 0;
3502
3503	if(statfs64(dir, &s) >= 0)
3504	{
3505	freesize = s.f_bfree;
3506	freesize *= s.f_bsize;
3507	}
3508
3509	return freesize;
3510	}
3511
3512	int checkbit(int value, int bitpos)
3513	{
3514	int ret = 0;
3515
3516	ret = value & (1 << bitpos) ? 1: 0;
3517	return ret;
3518	}
3519
3520	int tooglebit(int value, int bitpos)
3521	{
3522	value ^= 1 << bitpos;
3523	return value;
3524	}
3525
3526	int clearbit(int value, int bitpos)
3527	{
3528	value &= ~(1 << bitpos);
3529	return value;
3530	}
3531
3532	int setbit(int value, int bitpos)
3533	{
3534	value \|= 1 << bitpos;
3535	return value;
3536	}
3537
3538	int setsystime(time_t* newtime)
3539	{
3540	if (stime(newtime))
3541	{
3542	err("can't set system time");
3543	return 1;
3544	}
3545	return 0;
3546	}
3547
3548	off64_t getfilesize(char* name)
3549	{
3550	struct stat64 sbuf;
3551
3552	if(lstat64(name, &sbuf) == -1)
3553	return 0;
3554
3555	return sbuf.st_size;
3556	}
3557
3558	time_t getfiletime(char* name, int type)
3559	{
3560	struct stat64 sbuf;
3561
3562	if(lstat64(name, &sbuf) == -1)
3563	return 0;
3564
3565	switch(type)
3566	{
3567	case 1: return sbuf.st_mtime;
3568	case 2: return sbuf.st_ctime;
3569	default: return sbuf.st_atime;
3570	}
3571	}
3572
3573	int isfile(char* name)
3574	{
3575	struct stat64 sbuf;
3576
3577	if(lstat64(name, &sbuf) == -1)
3578	return 0;
3579
3580	if(S_ISREG(sbuf.st_mode))
3581	return 1;
3582
3583	return 0;
3584	}
3585
3586	int isdir(char* name)
3587	{
3588	struct stat64 sbuf;
3589	char *rpath = NULL;
3590
3591	if(lstat64(name, &sbuf) == -1)
3592	return 0;
3593
3594	if(S_ISDIR(sbuf.st_mode))
3595	return 1;
3596
3597	if(S_ISLNK(sbuf.st_mode))
3598	{
3599	rpath = realpath(name, NULL);
3600	if(lstat64(rpath, &sbuf) == -1)
3601	{
3602	free(rpath);
3603	return 0;
3604	}
3605	free(rpath);
3606	if(S_ISDIR(sbuf.st_mode))
3607	return 1;
3608	}
3609
3610	return 0;
3611	}
3612
3613	char* getmaxsatstring(int maxsat)
3614	{
3615	char* tmpstr = NULL, *tmpnr = NULL;
3616	int i;
3617
3618	tmpstr = ostrcat(tmpstr, "1", 1, 0);
3619	for(i = 2; i <= maxsat; i++)
3620	{
3621	tmpnr = oitoa(i);
3622	tmpstr = ostrcat(tmpstr, "\n", 1, 0);
3623	tmpstr = ostrcat(tmpstr, tmpnr, 1, 1);
3624	}
3625	return tmpstr;
3626	}
3627
3628	void ostrcatbig(char** value1, char* value2, int* maxlen, int* pos)
3629	{
3630	int len = 0;
3631
3632	if(value2 == NULL)
3633	return;
3634
3635	len = strlen(value2);
3636
3637	if(len > MINMALLOC)
3638	{
3639	err("string to long");
3640	return;
3641	}
3642
3643	if(*value1 != NULL && maxlen == 0)
3644	maxlen = strlen(value1);
3645
3646	if(value1 == NULL \|\| pos + len + 1 > *maxlen)
3647	{
3648	maxlen = maxlen + (MINMALLOC * 10);
3649	value1 = realloc(value1, *maxlen);
3650	if(*value1 == NULL)
3651	{
3652	err("no memory");
3653	return;
3654	}
3655	}
3656
3657	memcpy(value1 + pos, value2, len + 1);
3658	pos = pos + len;
3659	}
3660
3661	char* ostrshrink(char* value)
3662	{
3663	int len = 0;
3664	char* buf = NULL;
3665
3666	if(value == NULL) return NULL;
3667
3668	len = strlen(value);
3669	if(len == 0) return value;
3670
3671	buf = malloc(len + 1);
3672	if(buf == NULL)
3673	return value;
3674
3675	memcpy(buf, value, len);
3676	free(value);
3677	buf[len] = '\0';
3678
3679	return buf;
3680	}
3681
3682	char* ostrcat(char* value1, char* value2, int free1, int free2)
3683	{
3684	int len = 0, len1 = 0, len2 = 0;
3685	char* buf = NULL;
3686
3687	if(value1 == NULL && value2 == NULL) return NULL;
3688
3689	if(value1 != NULL) len1 = strlen(value1);
3690	if(value2 != NULL) len2 = strlen(value2);
3691
3692	len = len1 + len2 + 1;
3693
3694	if(free1 == 1)
3695	buf = realloc(value1, len);
3696	else
3697	buf = malloc(len);
3698	if(buf == NULL)
3699	{
3700	if(free1 == 1) free(value1);
3701	if(free2 == 1) free(value2);
3702	return NULL;
3703	}
3704
3705	if(free1 == 0 && len1 > 0) memcpy(buf, value1, len1);
3706	if(len2 > 0) memcpy(buf + len1, value2, len2);
3707	buf[len - 1] = '\0';
3708
3709	if(free2 == 1) free(value2);
3710
3711	//helpfull for memleak detect
3712	//if(buf != NULL && strlen(buf) == 0x0b - 0x01)
3713	// printf("****** memleak string (%s) (%p) ******\n", buf, buf);
3714
3715	return buf;
3716	}
3717
3718	char* ollutoa(uint64_t value)
3719	{
3720	char *buf = NULL;
3721
3722	buf = malloc(MINMALLOC);
3723	if(buf == NULL)
3724	{
3725	err("no memory");
3726	return NULL;
3727	}
3728
3729	sprintf(buf, "%llu", value);
3730	buf = ostrshrink(buf);
3731
3732	return buf;
3733	}
3734
3735	char* olutoa(unsigned long value)
3736	{
3737	char *buf = NULL;
3738
3739	buf = malloc(MINMALLOC);
3740	if(buf == NULL)
3741	{
3742	err("no memory");
3743	return NULL;
3744	}
3745
3746	sprintf(buf, "%lu", value);
3747	buf = ostrshrink(buf);
3748
3749	return buf;
3750	}
3751
3752	char* oitoax(int value)
3753	{
3754	char *buf = NULL;
3755
3756	buf = malloc(MINMALLOC);
3757	if(buf == NULL)
3758	{
3759	err("no memory");
3760	return NULL;
3761	}
3762
3763	sprintf(buf, "%x", value);
3764	buf = ostrshrink(buf);
3765
3766	return buf;
3767	}
3768
3769	char* oitoa(int value)
3770	{
3771	char *buf = NULL;
3772
3773	buf = malloc(MINMALLOC);
3774	if(buf == NULL)
3775	{
3776	err("no memory");
3777	return NULL;
3778	}
3779
3780	sprintf(buf, "%d", value);
3781	buf = ostrshrink(buf);
3782
3783	return buf;
3784	}
3785
3786	char* oitoa64(off64_t value)
3787	{
3788	char *buf = NULL;
3789
3790	buf = malloc(MINMALLOC);
3791	if(buf == NULL)
3792	{
3793	err("no memory");
3794	return NULL;
3795	}
3796
3797	sprintf(buf, "%lld", value);
3798	buf = ostrshrink(buf);
3799
3800	return buf;
3801	}
3802
3803	char* oftoa64(double value, char* count)
3804	{
3805	char *buf = NULL;
3806	char* tmpstr = NULL;
3807
3808	buf = malloc(MINMALLOC);
3809	if(buf == NULL)
3810	{
3811	err("no memory");
3812	return NULL;
3813	}
3814
3815	tmpstr = ostrcat("%.", count, 0, 0);
3816	tmpstr = ostrcat(tmpstr, "f", 1, 0);
3817
3818	sprintf(buf, tmpstr, value);
3819	buf = ostrshrink(buf);
3820
3821	free(tmpstr);
3822	return buf;
3823	}
3824
3825	int ostrncmp(char* value1, char* value2, int count)
3826	{
3827	int ret = 1;
3828
3829	if(value1 != NULL && value2 != NULL)
3830	ret = strncmp(value1, value2, count);
3831
3832	return ret;
3833	}
3834
3835	int ostrcmp(char* value1, char* value2)
3836	{
3837	int ret = 1;
3838
3839	if(value1 != NULL && value2 != NULL)
3840	ret = strcmp(value1, value2);
3841
3842	return ret;
3843	}
3844
3845	int ostrcasecmp(char* value1, char* value2)
3846	{
3847	int ret = 1;
3848
3849	if(value1 != NULL && value2 != NULL)
3850	ret = strcasecmp(value1, value2);
3851
3852	return ret;
3853	}
3854
3855	char* createpath(char* dir, char* file)
3856	{
3857	char *absdir = NULL;
3858	char *pos = NULL;
3859	char* tmpdir = NULL;
3860
3861	if(dir == NULL \|\| file == NULL)
3862	{
3863	err("NULL detect");
3864	return NULL;
3865	}
3866
3867	tmpdir = ostrcat(dir, NULL, 0, 0);
3868	if(tmpdir == NULL)
3869	{
3870	err("NULL detect");
3871	return NULL;
3872	}
3873
3874	while((tmpdir[strlen(tmpdir) - 1] == '.' && tmpdir[strlen(tmpdir) - 2] != '.') \|\| tmpdir[strlen(tmpdir) - 1] == '/')
3875	tmpdir[strlen(tmpdir) - 1] = '\0';
3876
3877	while(tmpdir[strlen(tmpdir) - 1] == '.' && tmpdir[strlen(tmpdir) - 2] == '.')
3878	{
3879	tmpdir[strlen(tmpdir) - 1] = '\0';
3880	tmpdir[strlen(tmpdir) - 1] = '\0';
3881	if(tmpdir[strlen(tmpdir) - 1] == '/')
3882	tmpdir[strlen(tmpdir) - 1] = '\0';
3883	pos = strrchr(tmpdir, '/');
3884	if(pos != NULL)
3885	pos[0] = '\0';
3886	}
3887
3888	absdir = malloc(strlen(tmpdir) + strlen(file) + 2);
3889	if(absdir == NULL)
3890	{
3891	free(tmpdir);
3892	err("no memory");
3893	return NULL;
3894	}
3895
3896	if(strlen(file) > 0 \|\| strlen(tmpdir) == 0)
3897	sprintf(absdir, "%s/%s", tmpdir, file);
3898	else
3899	sprintf(absdir, "%s", tmpdir);
3900
3901	free(tmpdir);
3902	return absdir;
3903	}
3904
3905	int settimezone(char* zone)
3906	{
3907	int ret = 0;
3908	char* tmpzone = NULL, *zonepath = NULL;
3909
3910	zonepath = getconfig("zonepath", NULL);
3911	if(zonepath == NULL)
3912	{
3913	err("config zonepath not defined");
3914	return 1;
3915	}
3916
3917	tmpzone = createpath(zonepath, zone);
3918	if(tmpzone == NULL)
3919	return 1;
3920
3921	setenv("TZ", zone, 1);
3922
3923	ret = unlink(getconfig("localtimefile", NULL));
3924	if(ret != 0)
3925	perr("unlink");
3926	ret = symlink(tmpzone, getconfig("localtimefile", NULL));
3927	if(ret != 0)
3928	perr("link");
3929
3930	free(tmpzone);
3931	return ret;
3932	}
3933
3934	int delchar(char** text, int pos)
3935	{
3936	char *tmptext = NULL;
3937	int i = 0, y = 0, len = 0;
3938
3939	if(text == NULL \|\| *text == NULL)
3940	return pos;
3941
3942	len = strlen(*text);
3943	if(len == 0) return pos;
3944
3945	tmptext = malloc(strlen(*text));
3946	if(tmptext == NULL)
3947	{
3948	err("no memory");
3949	return pos;
3950	}
3951
3952	for(i = 0; i < strlen(*text); i++)
3953	{
3954	if(i == pos - 1)
3955	y++;
3956
3957	tmptext[i] = (*text)[y];
3958	y++;
3959	}
3960
3961	if(i > 0) tmptext[i - 1] = '\0';
3962	if(pos >= strlen(tmptext)) pos = strlen(tmptext);
3963
3964	free(*text);
3965	*text = tmptext;
3966	return pos;
3967	}
3968
3969
3970	int insertchar(char** text, char zeichen, int pos)
3971	{
3972	char *tmptext = NULL;
3973	int i, y = 0;
3974
3975	if(text == NULL \|\| *text == NULL)
3976	return pos;
3977
3978	tmptext = malloc(strlen(*text) + 2);
3979	if(tmptext == NULL)
3980	{
3981	err("no memory");
3982	return pos;
3983	}
3984
3985	if(strlen(*text) == 0)
3986	{
3987	tmptext[0] = zeichen;
3988	i = 1;
3989	pos = 0;
3990	}
3991	else
3992	{
3993	for(i = 0; i < strlen(*text) + 1; i++)
3994	{
3995	if(i == pos)
3996	tmptext[i] = zeichen;
3997	else
3998	{
3999	tmptext[i] = (*text)[y];
4000	y++;
4001	}
4002	}
4003	}
4004	tmptext[i] = '\0';
4005
4006	free(*text);
4007	*text = tmptext;
4008	return pos + 1;
4009	}
4010
4011	void calctext(char* buf, char* buf1, unsigned int* linecount, unsigned int* pagecount, unsigned int* poscount, int pagelen, int page)
4012	{
4013	unsigned int tmpposcount = 0;
4014
4015	*poscount = 0;
4016	*linecount = 1;
4017	*pagecount = 1;
4018
4019	page--;
4020	if(page < 0) page = 0;
4021
4022	if(buf != NULL)
4023	{
4024	while(*buf != '\0')
4025	{
4026	if(*buf == '\n')
4027	{
4028	if(*(buf + 1) == '\0') break;
4029	(*linecount)++;
4030
4031	if(linecount - 1 == pagelen page)
4032	*poscount = tmpposcount + 1;
4033	}
4034	buf++;
4035	tmpposcount++;
4036	}
4037	}
4038
4039	if(buf1 != NULL)
4040	{
4041	while(*buf1 != '\0')
4042	{
4043	if(*buf1 == '\n')
4044	{
4045	if(*(buf1 + 1) == '\0') break;
4046	(*linecount)++;
4047
4048	if(linecount - 1 == pagelen page)
4049	*poscount = tmpposcount + 1;
4050	}
4051	buf1++;
4052	tmpposcount++;
4053	}
4054	}
4055
4056	if(pagelen > 0)
4057	pagecount = (int)ceil(((float)linecount / pagelen));
4058	}
4059
4060	int initlocale(char *localepath)
4061	{
4062	setlocale(LC_ALL, "");
4063	if(bindtextdomain(PROGNAME, localepath) == NULL)
4064	{
4065	err("set bindtextdomain");
4066	return 1;
4067	}
4068	if(textdomain(PROGNAME) == NULL)
4069	{
4070	err("set textdomain");
4071	return 1;
4072	}
4073	return 0;
4074	}
4075
4076	//for langage you must
4077	//mkdir /usr/lib/locale
4078	//ln -s %titanpath%/po /usr/lib/locale/po
4079	//copy SYS_LC_MESSAGES from other language into LC_MESSAGE
4080	int setlang(char *lang)
4081	{
4082	char *ret;
4083
4084	setenv("LANG", lang, 1);
4085	setenv("LANGUAGE", lang, 1);
4086	ret = setlocale(LC_MESSAGES, lang);
4087	if(ret == NULL)
4088	{
4089	err("can't set LC_MESSAGES to %s", lang);
4090	return 1;
4091	}
4092	return 0;
4093	}
4094
4095	unsigned long readsysul(const char *filename, int line)
4096	{
4097	int i = 0, len = 0;
4098	unsigned long ret = 0;
4099	FILE *fd = NULL;
4100	char *fileline = NULL;
4101	char *buf1 = NULL;
4102
4103	fileline = malloc(MINMALLOC);
4104	if(fileline == NULL)
4105	{
4106	err("no memory");
4107	return 0;
4108	}
4109
4110	fd = fopen(filename, "r");
4111	if(fd == NULL)
4112	{
4113	perr("can't open %s", filename);
4114	free(fileline);
4115	return 0;
4116	}
4117
4118	for(i = 0; i < line; i++)
4119	{
4120	memset(fileline, 0, MINMALLOC);
4121	fgets(fileline, MINMALLOC, fd);
4122	}
4123
4124	len = strlen(fileline) - 1;
4125	if(len >= 0 && fileline[len] == '\n')
4126	fileline[len] = '\0';
4127	buf1 = ostrshrink(fileline);
4128
4129	fclose(fd);
4130
4131	if(buf1 != NULL)
4132	{
4133	ret = strtoul(buf1, NULL, 10);
4134	free(buf1); buf1 = NULL;
4135	}
4136
4137	return ret;
4138	}
4139
4140
4141	char* readsys(const char *filename, int line)
4142	{
4143	int i = 0, len = 0;
4144	FILE *fd = NULL;
4145	char *fileline = NULL;
4146	char *buf1 = NULL;
4147
4148	fileline = malloc(MINMALLOC);
4149	if(fileline == NULL)
4150	{
4151	err("no memory");
4152	return NULL;
4153	}
4154
4155	fd = fopen(filename, "r");
4156	if(fd == NULL)
4157	{
4158	perr("can't open %s", filename);
4159	free(fileline);
4160	return NULL;
4161	}
4162
4163	for(i = 0; i < line; i++)
4164	{
4165	memset(fileline, 0, MINMALLOC);
4166	fgets(fileline, MINMALLOC, fd);
4167	}
4168
4169	len = strlen(fileline) - 1;
4170	if(len >= 0 && fileline[len] == '\n')
4171	fileline[len] = '\0';
4172	buf1 = ostrshrink(fileline);
4173
4174	fclose(fd);
4175	return buf1;
4176	}
4177
4178	//flag 0: without \n
4179	//flag 1: with \n
4180	//flag 2: append without \n
4181	//flag 3: append with \n
4182	int writesys(const char filename, char value, int flag)
4183	{
4184	FILE *fd = NULL;
4185	char* tmpstr = NULL;
4186	int ret;
4187
4188	if(value == NULL)
4189	{
4190	err("NULL detect");
4191	return 1;
4192	}
4193
4194	if(flag == 2 \|\| flag == 3)
4195	fd = fopen(filename, "a");
4196	else
4197	fd = fopen(filename, "w");
4198	if(fd == NULL)
4199	{
4200	perr("can't open %s", filename);
4201	return 1;
4202	}
4203
4204	if(flag == 1 \|\| flag == 3)
4205	tmpstr = ostrcat(value, "\n", 0, 0);
4206	else
4207	tmpstr = ostrcat(value, NULL, 0, 0);
4208
4209	ret = fwrite(tmpstr, strlen(tmpstr), 1, fd);
4210	if(ret != 1)
4211	{
4212	perr("writting to %s", filename);
4213	free(tmpstr);
4214	fclose(fd);
4215	return 1;
4216	}
4217
4218	free(tmpstr);
4219	fclose(fd);
4220	return 0;
4221	}
4222
4223	//flag 0: without \n
4224	//flag 1: with \n
4225	//flag 2: append without \n
4226	//flag 3: append with \n
4227	int writesysint(const char *filename, int value, int flag)
4228	{
4229	char* tmpstr = NULL;
4230	int ret = 0;
4231
4232	tmpstr = oitoa(value);
4233	ret = writesys(filename, tmpstr, flag);
4234
4235	free(tmpstr);
4236	return ret;
4237	}
4238
4239	char* getdevcontent(char* devconfig)
4240	{
4241	char *dev = NULL;
4242	char *value = NULL;
4243
4244	dev = getconfig(devconfig, NULL);
4245
4246	if(dev == NULL)
4247	{
4248	err("NULL detect");
4249	return NULL;
4250	}
4251
4252	value = readsys(dev, 1);
4253	if(value == NULL)
4254	{
4255	err("NULL detect");
4256	return NULL;
4257	}
4258
4259	return value;
4260	}
4261
4262	char* convertspacetolf(char* value)
4263	{
4264	int i = 0;
4265
4266	while(value[i] != '\0')
4267	{
4268	if(value[i] == ' ')
4269	value[i] = '\n';
4270	i++;
4271	}
4272
4273	return value;
4274	}
4275
4276	//flag 0: all
4277	//flag 1: hdmi
4278	//flag 2: not hdmi
4279	char* getcolorformatchoices(int flag)
4280	{
4281	char *colorformatchoicesdev = NULL;
4282	char *value = NULL;
4283
4284	colorformatchoicesdev = getconfig("colorformatchoicesdev", NULL);
4285
4286	if(colorformatchoicesdev == NULL)
4287	{
4288	err("NULL detect");
4289	return NULL;
4290	}
4291
4292	value = readsys(colorformatchoicesdev, 1);
4293	if(value == NULL)
4294	{
4295	err("NULL detect");
4296	return NULL;
4297	}
4298
4299	if(flag == 1)
4300	{
4301	value = string_replace("rgb", NULL, value, 1);
4302	value = string_replace(" ", " ", value, 1);
4303	value = string_replace("cvbs", NULL, value, 1);
4304	value = string_replace(" ", " ", value, 1);
4305	value = string_replace("svideo", NULL, value, 1);
4306	value = string_replace(" ", " ", value, 1);
4307	value = string_replace("yuv", NULL, value, 1);
4308	value = string_replace(" ", " ", value, 1);
4309	}
4310	else if(flag == 2)
4311	{
4312	value = string_replace("hdmi_rgb", NULL, value, 1);
4313	value = string_replace(" ", " ", value, 1);
4314	value = string_replace("hdmi_yuv", NULL, value, 1);
4315	value = string_replace(" ", " ", value, 1);
4316	value = string_replace("hdmi_422", NULL, value, 1);
4317	value = string_replace(" ", " ", value, 1);
4318	}
4319
4320	value = strstrip(value);
4321	value = convertspacetolf(value);
4322
4323	return value;
4324	}
4325
4326	char* getaudiosourcechoices()
4327	{
4328	char *audiosourcechoicesdev = NULL;
4329	char *value = NULL;
4330
4331	audiosourcechoicesdev = getconfig("audiosourcechoicesdev", NULL);
4332
4333	if(audiosourcechoicesdev == NULL)
4334	{
4335	err("NULL detect");
4336	return NULL;
4337	}
4338
4339	value = readsys(audiosourcechoicesdev, 1);
4340	if(value == NULL)
4341	{
4342	err("NULL detect");
4343	return NULL;
4344	}
4345
4346	value = convertspacetolf(value);
4347
4348	return value;
4349	}
4350
4351	char* getac3choices()
4352	{
4353	char *ac3choicesdev = NULL;
4354	char *value = NULL;
4355
4356	ac3choicesdev = getconfig("ac3choicesdev", NULL);
4357
4358	if(ac3choicesdev == NULL)
4359	{
4360	err("NULL detect");
4361	return NULL;
4362	}
4363
4364	value = readsys(ac3choicesdev, 1);
4365	if(value == NULL)
4366	{
4367	err("NULL detect");
4368	return NULL;
4369	}
4370
4371	value = convertspacetolf(value);
4372
4373	return value;
4374	}
4375
4376	int setciclock(int slotnr, char* value)
4377	{
4378	char* ciclockdev = NULL, *tmpstr = NULL;
4379	int ret = 0;
4380
4381	ciclockdev = getconfig("ciclockdev", NULL);
4382
4383	if(ciclockdev != NULL && value != NULL)
4384	{
4385	tmpstr = malloc(MINMALLOC);
4386	if(tmpstr == NULL)
4387	{
4388	err("no mem");
4389	return 1;
4390	}
4391
4392	snprintf(tmpstr, MINMALLOC, ciclockdev, slotnr);
4393	debug(100, "set %s to %s", tmpstr, value);
4394	ret = writesys(tmpstr, value, 0);
4395
4396	free(tmpstr); tmpstr = NULL;
4397	return ret;
4398	}
4399
4400	return 0;
4401	}
4402
4403	//routes stream from tuner to ci or ci to ci
4404	int setciinput(int slotnr, char* value)
4405	{
4406	char* ciinputdev = NULL, *tmpstr = NULL;
4407	int ret = 0;
4408
4409	ciinputdev = getconfig("ciinputdev", NULL);
4410
4411	if(ciinputdev != NULL && value != NULL)
4412	{
4413	tmpstr = malloc(MINMALLOC);
4414	if(tmpstr == NULL)
4415	{
4416	err("no mem");
4417	return 1;
4418	}
4419
4420	snprintf(tmpstr, MINMALLOC, ciinputdev, slotnr);
4421	debug(100, "set %s to %s", tmpstr, value);
4422	ret = writesys(tmpstr, value, 0);
4423
4424	free(tmpstr); tmpstr = NULL;
4425	return ret;
4426	}
4427
4428	return 0;
4429	}
4430
4431	//routes stream from tuner or ci to linux
4432	int setcisource(int tunernr, char* value)
4433	{
4434	char* cisourcedev = NULL, *tmpstr = NULL;
4435	int ret = 0;
4436
4437	cisourcedev = getconfig("cisourcedev", NULL);
4438
4439	if(cisourcedev != NULL && value != NULL)
4440	{
4441	tmpstr = malloc(MINMALLOC);
4442	if(tmpstr == NULL)
4443	{
4444	err("no mem");
4445	return 1;
4446	}
4447
4448	snprintf(tmpstr, MINMALLOC, cisourcedev, tunernr);
4449	debug(100, "set %s to %s", tmpstr, value);
4450	ret = writesys(tmpstr, value, 0);
4451
4452	free(tmpstr); tmpstr = NULL;
4453	return ret;
4454	}
4455
4456	return 0;
4457	}
4458
4459	int setinput(char* value)
4460	{
4461	char* inputdev = NULL;
4462	int ret = 0;
4463
4464	inputdev = getconfig("inputdev", NULL);
4465
4466	if(inputdev != NULL && value != NULL)
4467	{
4468	debug(100, "set %s to %s", inputdev, value);
4469	ret = writesys(inputdev, value, 0);
4470	return ret;
4471	}
4472
4473	return 0;
4474	}
4475
4476	char* getinput()
4477	{
4478	char *inputdev = NULL;
4479	char *value = NULL;
4480
4481	inputdev = getconfig("inputdev", NULL);
4482
4483	if(inputdev == NULL)
4484	{
4485	err("NULL detect");
4486	return NULL;
4487	}
4488
4489	value = readsys(inputdev, 1);
4490	if(value == NULL)
4491	{
4492	err("NULL detect");
4493	return NULL;
4494	}
4495
4496	return value;
4497	}
4498
4499	int setac3(char* value)
4500	{
4501	char* ac3dev = NULL;
4502	int ret = 0;
4503
4504	ac3dev = getconfig("ac3dev", NULL);
4505
4506	if(ac3dev != NULL && value != NULL)
4507	{
4508	debug(100, "set %s to %s", ac3dev, value);
4509	ret = writesys(ac3dev, value, 0);
4510	if(ret == 0) addconfig("av_ac3mode", value);
4511	return ret;
4512	}
4513
4514	return 0;
4515	}
4516
4517	char* getac3()
4518	{
4519	char *ac3dev = NULL;
4520	char *value = NULL;
4521
4522	ac3dev = getconfig("ac3dev", NULL);
4523
4524	if(ac3dev == NULL)
4525	{
4526	err("NULL detect");
4527	return NULL;
4528	}
4529
4530	value = readsys(ac3dev, 1);
4531	if(value == NULL)
4532	{
4533	err("NULL detect");
4534	return NULL;
4535	}
4536
4537	return value;
4538	}
4539
4540	int setaudiodelaybitstream(char* value)
4541	{
4542	char* audiodelaybitstreamdev = NULL;
4543	int ret = 0;
4544
4545	audiodelaybitstreamdev = getconfig("audiodelaybitstreamdev", NULL);
4546
4547	if(audiodelaybitstreamdev != NULL && value != NULL)
4548	{
4549	debug(100, "set %s to %s", audiodelaybitstreamdev, value);
4550	ret = writesys(audiodelaybitstreamdev, value, 0);
4551	if(ret == 0) addconfig("audiodelaybitstream", value);
4552	return ret;
4553	}
4554
4555	return 0;
4556	}
4557
4558	char* getaudiodelaybitstream()
4559	{
4560	char *audiodelaybitstreamdev = NULL;
4561	char *value = NULL;
4562
4563	audiodelaybitstreamdev = getconfig("audiodelaybitstreamdev", NULL);
4564
4565	if(audiodelaybitstreamdev == NULL)
4566	{
4567	err("NULL detect");
4568	return NULL;
4569	}
4570
4571	value = readsys(audiodelaybitstreamdev, 1);
4572	if(value == NULL)
4573	{
4574	err("NULL detect");
4575	return NULL;
4576	}
4577
4578	return value;
4579	}
4580
4581	char* getpolicychoices()
4582	{
4583	char *policychoicesdev = NULL;
4584	char *value = NULL;
4585
4586	policychoicesdev = getconfig("policychoicesdev", NULL);
4587
4588	if(policychoicesdev == NULL)
4589	{
4590	err("NULL detect");
4591	return NULL;
4592	}
4593
4594	value = readsys(policychoicesdev, 1);
4595	if(value == NULL)
4596	{
4597	err("NULL detect");
4598	return NULL;
4599	}
4600
4601	value = convertspacetolf(value);
4602
4603	return value;
4604	}
4605
4606	char* getpolicy()
4607	{
4608	char *policydev = NULL;
4609	char *value = NULL;
4610
4611	policydev = getconfig("policydev", NULL);
4612
4613	if(policydev == NULL)
4614	{
4615	err("NULL detect");
4616	return NULL;
4617	}
4618
4619	value = readsys(policydev, 1);
4620	if(value == NULL)
4621	{
4622	err("NULL detect");
4623	return NULL;
4624	}
4625
4626	return value;
4627	}
4628
4629	int setpolicy(char* value)
4630	{
4631	char* policydev;
4632	int ret = 0;
4633
4634	policydev = getconfig("policydev", NULL);
4635
4636	if(policydev != NULL && value != NULL)
4637	{
4638	debug(100, "set %s to %s", policydev, value);
4639	ret = writesys(policydev, value, 0);
4640	if(ret == 0) addconfig("av_policy", value);
4641	return ret;
4642	}
4643
4644	return 0;
4645	}
4646
4647	char* getaspectchoices()
4648	{
4649	char *aspectchoicesdev = NULL;
4650	char *value = NULL;
4651
4652	aspectchoicesdev = getconfig("aspectchoicesdev", NULL);
4653
4654	if(aspectchoicesdev == NULL)
4655	{
4656	err("NULL detect");
4657	return NULL;
4658	}
4659
4660	value = readsys(aspectchoicesdev, 1);
4661	if(value == NULL)
4662	{
4663	err("NULL detect");
4664	return NULL;
4665	}
4666
4667	value = convertspacetolf(value);
4668
4669	return value;
4670	}
4671
4672	char* getaspect()
4673	{
4674	char *aspectdev = NULL;
4675	char *value = NULL;
4676
4677	aspectdev = getconfig("aspectdev", NULL);
4678
4679	if(aspectdev == NULL)
4680	{
4681	err("NULL detect");
4682	return NULL;
4683	}
4684
4685	value = readsys(aspectdev, 1);
4686	if(value == NULL)
4687	{
4688	err("NULL detect");
4689	return NULL;
4690	}
4691
4692	return value;
4693	}
4694
4695	int setaspect(char* value)
4696	{
4697	char* aspectdev;
4698	int ret = 0;
4699
4700	aspectdev = getconfig("aspectdev", NULL);
4701
4702	if(aspectdev != NULL && value != NULL)
4703	{
4704	debug(100, "set %s to %s", aspectdev, value);
4705	ret = writesys(aspectdev, value, 0);
4706	if(ret == 0)
4707	{
4708	addconfig("av_aspect", value);
4709
4710	//set policy new after change aspect
4711	char* tmpstr = getpolicy();
4712	setpolicy(tmpstr);
4713	free(tmpstr); tmpstr = NULL;
4714	}
4715	return ret;
4716	}
4717
4718	return 0;
4719	}
4720
4721	char* getvideomodechoices()
4722	{
4723	char *videomodechoicesdev = NULL;
4724	char *value = NULL;
4725
4726	videomodechoicesdev = getconfig("videomodechoicesdev", NULL);
4727
4728	if(videomodechoicesdev == NULL)
4729	{
4730	err("NULL detect");
4731	return NULL;
4732	}
4733
4734	value = readsys(videomodechoicesdev, 1);
4735	if(value == NULL)
4736	{
4737	err("NULL detect");
4738	return NULL;
4739	}
4740
4741	value = string_replace("pal", NULL, value, 1);
4742	value = string_replace(" ", " ", value, 1);
4743
4744	if(status.mcaktiv == 0)
4745	{
4746	value = string_replace("1080p60", NULL, value, 1);
4747	value = string_replace(" ", " ", value, 1);
4748	value = string_replace("1080p59", NULL, value, 1);
4749	value = string_replace(" ", " ", value, 1);
4750	value = string_replace("1080p30", NULL, value, 1);
4751	value = string_replace(" ", " ", value, 1);
4752	value = string_replace("1080p25", NULL, value, 1);
4753	value = string_replace(" ", " ", value, 1);
4754	value = string_replace("1080p24", NULL, value, 1);
4755	value = string_replace(" ", " ", value, 1);
4756	value = string_replace("1080i60", NULL, value, 1);
4757	value = string_replace(" ", " ", value, 1);
4758	value = string_replace("720p60", NULL, value, 1);
4759	value = string_replace(" ", " ", value, 1);
4760	}
4761
4762	value = strstrip(value);
4763	value = convertspacetolf(value);
4764
4765	return value;
4766	}
4767
4768	char* getmode3dchoices()
4769	{
4770	char *mode3dchoicesdev = NULL;
4771	char *value = NULL;
4772
4773	mode3dchoicesdev = getconfig("mode3dchoicesdev", NULL);
4774
4775	if(mode3dchoicesdev == NULL)
4776	{
4777	return ostrcat("off\nsbs\ntab", "", 0, 0);
4778	}
4779
4780	value = readsys(mode3dchoicesdev, 1);
4781	if(value == NULL)
4782	{
4783	err("NULL detect");
4784	return NULL;
4785	}
4786
4787	value = convertspacetolf(value);
4788
4789	return value;
4790	}
4791
4792	char* getmode3d()
4793	{
4794	char *mode3ddev = NULL;
4795	char *value = NULL;
4796
4797	mode3ddev = getconfig("mode3ddev", NULL);
4798
4799	if(mode3ddev == NULL)
4800	{
4801	err("NULL detect");
4802	return NULL;
4803	}
4804
4805	value = readsys(mode3ddev, 1);
4806	if(value == NULL)
4807	{
4808	err("NULL detect");
4809	return NULL;
4810	}
4811
4812	return value;
4813	}
4814
4815	int setmode3d(char* value)
4816	{
4817	char* mode3ddev;
4818	int ret = 0;
4819
4820	mode3ddev = getconfig("mode3ddev", NULL);
4821
4822	if(mode3ddev != NULL && value != NULL)
4823	{
4824	debug(100, "set %s to %s", mode3ddev, value);
4825	ret = writesys(mode3ddev, value, 0);
4826	if(ret == 0) addconfig("av_mode3d", value);
4827	return ret;
4828	}
4829
4830	return 0;
4831	}
4832
4833	char* getvideomode()
4834	{
4835	char *videomodedev = NULL;
4836	char *value = NULL;
4837
4838	videomodedev = getconfig("videomodedev", NULL);
4839
4840	if(videomodedev == NULL)
4841	{
4842	err("NULL detect");
4843	return NULL;
4844	}
4845
4846	value = readsys(videomodedev, 1);
4847	if(value == NULL)
4848	{
4849	err("NULL detect");
4850	return NULL;
4851	}
4852
4853	return value;
4854	}
4855
4856	void switchvideomode()
4857	{
4858	int rcret = 0;
4859	char* tmpstr = NULL;
4860	tmpstr = getvideomode();
4861	struct skin* playpolicy = getscreen("playpolicy");
4862
4863	if(tmpstr != NULL)
4864	{
4865	if(ostrcmp("pal", tmpstr) == 0 \|\| ostrncmp("576", tmpstr, 3) == 0)
4866	{
4867	setvideomode("720p50", 0);
4868	changefbresolution("720p50", 0);
4869	changetext(playpolicy, "720p50");
4870	writevfdmenu("720p50");
4871	unlink("/var/etc/.scart");
4872	}
4873	else if(ostrncmp("720", tmpstr, 3) == 0)
4874	{
4875	setvideomode("1080i50", 0);
4876	changefbresolution("1080i50", 0);
4877	changetext(playpolicy, "1080i50");
4878	writevfdmenu("1080i50");
4879	unlink("/var/etc/.scart");
4880	}
4881	else if(ostrncmp("1080", tmpstr, 4) == 0)
4882	{
4883	setvideomode("576i50", 0);
4884	changefbresolution("576i50", 0);
4885	changetext(playpolicy, "576i50");
4886	writevfdmenu("576i50 / pal");
4887	writesys("/var/etc/.scart", "0", 0);
4888	}
4889	/*
4890	int ret = textbox(_("Message"), _("Is this Videomode ok ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 10, 0);
4891	if(ret == 1 \|\| ret == 2)
4892	{
4893	setvideomode(tmpstr, 0);
4894	changefbresolution(tmpstr, 0);
4895	}
4896	*/
4897	drawscreen(playpolicy, 0, 0);
4898	while(1)
4899	{
4900	rcret = waitrc(playpolicy, 5000, 0);
4901	break;
4902	}
4903	clearscreen(playpolicy);
4904	}
4905	free(tmpstr);
4906	}
4907
4908	//flag 0: write videomode to config
4909	//flag 1: don't write videomode to config
4910	int setvideomode(char* value, int flag)
4911	{
4912	char* videomodedev;
4913	int ret = 0;
4914
4915	videomodedev = getconfig("videomodedev", NULL);
4916
4917	if(videomodedev != NULL && value != NULL)
4918	{
4919	debug(100, "set %s to %s", videomodedev, value);
4920	ret = writesys(videomodedev, value, 0);
4921	if(ret == 0 && flag == 0) addconfig("av_videomode", value);
4922	return ret;
4923	}
4924
4925	return 0;
4926	}
4927
4928	//flag 0 = hdmi
4929	//flag 1 = scart
4930	int setcolorformat(char* value, int flag)
4931	{
4932	char* colorformatdev;
4933	int ret = 0;
4934
4935	colorformatdev = getconfig("colorformatdev", NULL);
4936
4937	if(colorformatdev != NULL && value != NULL)
4938	{
4939	debug(100, "set %s to %s", colorformatdev, value);
4940	ret = writesys(colorformatdev, value, 0);
4941	if(ret == 0)
4942	{
4943	if(flag == 0)
4944	addconfig("av_colorformat", value);
4945	else
4946	addconfig("av_colorformatscart", value);
4947	}
4948	return ret;
4949	}
4950
4951	return 0;
4952	}
4953
4954	char* getcolorformat(int line)
4955	{
4956	char *colorformatdev = NULL;
4957	char *value = NULL;
4958
4959	colorformatdev = getconfig("colorformatdev", NULL);
4960
4961	if(colorformatdev == NULL)
4962	{
4963	err("NULL detect");
4964	return NULL;
4965	}
4966
4967	value = readsys(colorformatdev, line);
4968	if(value == NULL)
4969	{
4970	err("NULL detect");
4971	return NULL;
4972	}
4973
4974	return value;
4975	}
4976
4977	int setaudiosource(char* value)
4978	{
4979	char* audiosourcedev;
4980	int ret = 1;
4981
4982	audiosourcedev = getconfig("audiosourcedev", NULL);
4983
4984	if(audiosourcedev != NULL && value != NULL)
4985	{
4986	debug(100, "set %s to %s", audiosourcedev, value);
4987	ret = writesys(audiosourcedev, value, 0);
4988	if(ret == 0) addconfig("av_audiosource", value);
4989	return ret;
4990	}
4991
4992	return 0;
4993	}
4994
4995	char* getaudiosource()
4996	{
4997	char *audiosourcedev = NULL;
4998	char *value = NULL;
4999
5000	audiosourcedev = getconfig("audiosourcedev", NULL);
5001
5002	if(audiosourcedev == NULL)
5003	{
5004	err("NULL detect");
5005	return NULL;
5006	}
5007
5008	value = readsys(audiosourcedev, 1);
5009	if(value == NULL)
5010	{
5011	err("NULL detect");
5012	return NULL;
5013	}
5014
5015	return value;
5016	}
5017
5018	char* getsataswitch()
5019	{
5020	char *sataswitchdev = NULL;
5021	char *value = NULL;
5022
5023	sataswitchdev = getconfig("sataswitchdev", NULL);
5024
5025	if(sataswitchdev == NULL)
5026	{
5027	err("NULL detect");
5028	return NULL;
5029	}
5030
5031	value = readsys(sataswitchdev, 1);
5032	if(value == NULL)
5033	{
5034	err("NULL detect");
5035	return NULL;
5036	}
5037
5038	return value;
5039	}
5040
5041	int setsataswitch(char* value)
5042	{
5043	char* sataswitchdev;
5044	int ret = 1;
5045
5046	sataswitchdev = getconfig("sataswitchdev", NULL);
5047
5048	if(sataswitchdev != NULL && value != NULL)
5049	{
5050	debug(100, "set %s to %s", sataswitchdev, value);
5051	ret = writesys(sataswitchdev, value, 0);
5052	return ret;
5053	}
5054
5055	return 0;
5056	}
5057
5058	int setprogress(value)
5059	{
5060	char *progressdev;
5061
5062	progressdev = getconfig("progressdev", NULL);
5063
5064	if(progressdev != NULL)
5065	{
5066	debug(100, "set %s to %d",progressdev, value);
5067	return writesysint(progressdev, value, 0);
5068	}
5069
5070	return 0;
5071	}
5072
5073	int setmute(int value)
5074	{
5075	char* mutedev;
5076	int tmpvol, ret = 0;
5077
5078	//don't set mute 2x
5079	if(value == 1 && status.mute == 1) return 0;
5080
5081	if(value == 2)
5082	{
5083	tmpvol = getvol();
5084	tmpvol = tmpvol * 50 / 100;
5085	status.mute = value;
5086	setvol(tmpvol);
5087	}
5088	else
5089	{
5090	mutedev = getconfig("mutedev", NULL);
5091
5092	if(mutedev != NULL)
5093	{
5094	debug(100, "set %s to %d", mutedev, value);
5095	//if(status.volautochangevalue != 0 && value == 0) setvol(getvol());
5096	ret = writesysint(mutedev, value, 0);
5097	if(ret == 0) status.mute = value;
5098	if(status.volautochangevalue != 0 && value == 0) setvol(getvol());
5099	return ret;
5100	}
5101	}
5102	return 0;
5103	}
5104
5105	int setvol(int value)
5106	{
5107	char* voldev;
5108	int ret = 0, tmpvol = value;
5109
5110	voldev = getconfig("voldev", NULL);
5111
5112	if(voldev != NULL)
5113	{
5114	if(value > 100) value = 100;
5115	if(value < 0) value = 0;
5116	if(status.volautochangevalue != 0 && value != 0)
5117	{
5118	if(status.volautochange == 0)
5119	value = value - (status.volautochangevalue * value / 100);
5120	}
5121	value = 63 - value * 63 / 100;
5122	debug(100, "set %s to %d", voldev, value);
5123	ret = 0;
5124	if(status.mute == 1)
5125	status.volmute = value;
5126	else
5127	{
5128	status.volmute = -1;
5129	ret = writesysint(voldev, value, 0);
5130	}
5131	if(ret == 0 && status.mute != 2) addconfigint("vol", tmpvol);
5132	return ret;
5133	}
5134
5135	return 0;
5136	}
5137
5138	int getvol()
5139	{
5140	char *voldev = NULL;
5141	char *value = NULL;
5142	int tmpvol = -1;
5143
5144	voldev = getconfig("voldev", NULL);
5145
5146	if(voldev == NULL)
5147	{
5148	err("NULL detect");
5149	return 0;
5150	}
5151	if(status.volmute == -1)
5152	value = readsys(voldev, 1);
5153	else
5154	tmpvol = status.volmute;
5155	if(value == NULL && tmpvol == -1)
5156	{
5157	err("NULL detect");
5158	return 0;
5159	}
5160	if(status.volmute == -1)
5161	tmpvol = atoi(value);
5162	free(value);
5163	tmpvol = 100 - tmpvol * 100 / 63;
5164	if(status.volautochangevalue != 0)
5165	{
5166	if(status.volautochange == 0 && status.volautochangevalue < 100)
5167	tmpvol = tmpvol + ((tmpvol * status.volautochangevalue) / (100 - status.volautochangevalue));
5168	}
5169	return tmpvol;
5170	}
5171
5172	void setdebuglevel()
5173	{
5174	debug_level = getconfigint("debuglevel", NULL);
5175	debug(0, "set debug level to %d", debug_level);
5176	}
5177
5178	char* getxmlentry(char line, char searchstr)
5179	{
5180	char buf = NULL, buf1 = NULL, *buf2 = NULL;
5181
5182	buf = ostrstr(line, searchstr);
5183	if(buf == NULL)
5184	return NULL;
5185
5186	buf = buf + strlen(searchstr);
5187	if(buf[0] == '"')
5188	{
5189	buf = buf + 1;
5190	buf2 = strchr(buf, '"');
5191	if(buf2 == NULL)
5192	{
5193	err("strchr returns NULL");
5194	return NULL;
5195	}
5196	buf1 = strndup(buf, buf2 - buf);
5197	if(buf1 == NULL)
5198	{
5199	err("strndup failed");
5200	return NULL;
5201	}
5202	}
5203	else
5204	{
5205	buf2 = strchr(buf, ' ');
5206	if(buf2 == NULL)
5207	{
5208	buf2 = ostrstr(buf, "/>");
5209	if(buf2 == NULL)
5210	{
5211	buf2 = strchr(buf, '>');
5212	if(buf2 == NULL)
5213	{
5214	err("strchr returns NULL");
5215	return NULL;
5216	}
5217	}
5218	}
5219	buf1 = strndup(buf, buf2 - buf);
5220	if(buf1 == NULL)
5221	{
5222	err("strndup failed");
5223	return NULL;
5224	}
5225	}
5226
5227	return buf1;
5228	}
5229
5230	char* readbintomem(const char* filename, size_t size)
5231	{
5232	FILE *fd = NULL;
5233	char *fileline = NULL;
5234
5235	fileline = calloc(1, size + 1);
5236	if(fileline == NULL)
5237	{
5238	err("no memory");
5239	return NULL;
5240	}
5241
5242	fd = fopen(filename, "rb");
5243	if(fd == NULL)
5244	{
5245	perr("can't open %s", filename);
5246	free(fileline);
5247	return NULL;
5248	}
5249
5250	fread(fileline, size, 1, fd);
5251
5252	fclose(fd);
5253	return fileline;
5254	}
5255
5256	char* readfiletomem(const char* filename, int flag)
5257	{
5258	FILE *fd = NULL;
5259	char fileline = NULL, buf = NULL, *tmpbuf = NULL;
5260	int bufsize = 0, bufoldsize = 0;
5261
5262	fileline = malloc(MINMALLOC);
5263	if(fileline == NULL)
5264	{
5265	err("no memory");
5266	return NULL;
5267	}
5268
5269	fd = fopen(filename, "r");
5270	if(fd == NULL)
5271	{
5272	perr("can't open %s", filename);
5273	free(fileline);
5274	return NULL;
5275	}
5276
5277	while(fgets(fileline, MINMALLOC, fd) != NULL)
5278	{
5279	if(flag == 1)
5280	if(fileline[0] == '#' \|\| fileline[0] == '\n')
5281	continue;
5282
5283	bufoldsize = bufsize;
5284	bufsize += strlen(fileline);
5285	tmpbuf = buf; buf = realloc(buf, bufsize + 1);
5286	if(buf == NULL)
5287	{
5288	err("no memory");
5289	free(fileline);
5290	free(tmpbuf);
5291	fclose(fd);
5292	return NULL;
5293	}
5294
5295	sprintf(buf + bufoldsize, "%s", fileline);
5296	}
5297
5298	free(fileline);
5299	fclose(fd);
5300	return buf;
5301	}
5302
5303	char* readeittomem(const char* filename)
5304	{
5305	unsigned char byte;
5306	FILE *fil = NULL;
5307	char zeichen = NULL, buf = NULL, buf1 = NULL, tmpbuf1 = NULL;
5308	int buf1size = 0, buf1oldsize = 0;
5309	int Beschreibung;
5310	int len;
5311
5312	zeichen = malloc(255);
5313	if(zeichen == NULL)
5314	{
5315	err("no memory");
5316	return NULL;
5317	}
5318	buf = malloc(255);
5319	if(buf == NULL)
5320	{
5321	free(zeichen);
5322	err("no memory");
5323	return NULL;
5324	}
5325
5326	fil = fopen(filename, "r");
5327	if(fil == NULL)
5328	{
5329	err("can't open %s", filename);
5330	free(zeichen);
5331	free(buf);
5332	return NULL;
5333	}
5334	Beschreibung = 0;
5335	fseek(fil, 12, SEEK_SET); //ersten 12 Byte nicht relevant
5336	while(!feof(fil))
5337	{
5338	byte = fgetc(fil);
5339
5340	if(byte == 0x4D)
5341	{
5342	fseek(fil, 4,SEEK_CUR);
5343	byte = fgetc(fil);
5344	len = byte + 0;
5345	byte = fgetc(fil);
5346	fgets(zeichen, len, fil);
5347	if(byte != 0x05)
5348	sprintf(buf, "%c%s\n", byte, zeichen);
5349	else
5350	sprintf(buf, "%s\n", zeichen);
5351
5352	buf1oldsize = buf1size;
5353	buf1size += strlen(buf);
5354	tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
5355	if(buf1 == NULL)
5356	{
5357	err("no memory");
5358	free(zeichen);
5359	free(buf);
5360	free(tmpbuf1);
5361	fclose(fil);
5362	return NULL;
5363	}
5364	sprintf(buf1 + buf1oldsize, "%s", buf);
5365
5366	//printf("T %s\n", zeichen);
5367	byte = fgetc(fil);
5368	len = byte + 0;
5369	byte = fgetc(fil);
5370	fgets(zeichen, len, fil);
5371	if(byte != 0x05)
5372	sprintf(buf,"%c%s\n\n", byte, zeichen);
5373	else
5374	sprintf(buf,"%s\n\n", zeichen);
5375
5376	buf1oldsize = buf1size;
5377	buf1size += strlen(buf);
5378	tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
5379	if(buf1 == NULL)
5380	{
5381	err("no memory");
5382	free(zeichen);
5383	free(buf);
5384	free(tmpbuf1);
5385	fclose(fil);
5386	return NULL;
5387	}
5388	sprintf(buf1 + buf1oldsize, "%s", buf);
5389
5390	}
5391	else if(byte == 0x4E)
5392	{
5393	fseek(fil, 6, SEEK_CUR);
5394	byte = fgetc(fil);
5395	len = byte;
5396	byte = fgetc(fil);
5397	fgets(zeichen, len, fil);
5398	if(Beschreibung == 0)
5399	{
5400	if(byte != 0x05)
5401	sprintf(buf, "%c%s", byte, zeichen);
5402	else
5403	sprintf(buf, "%s", zeichen);
5404	Beschreibung = 1;
5405	}
5406	else
5407	{
5408	if(byte != 0x05)
5409	sprintf(buf, "%c%s", byte, zeichen);
5410	else
5411	sprintf(buf, "%s", zeichen);
5412	}
5413
5414	buf1oldsize = buf1size;
5415	buf1size += strlen(buf);
5416	tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
5417	if(buf1 == NULL)
5418	{
5419	err("no memory");
5420	free(zeichen);
5421	free(buf);
5422	free(tmpbuf1);
5423	fclose(fil);
5424	return NULL;
5425	}
5426	sprintf(buf1 + buf1oldsize, "%s", buf);
5427
5428	}
5429	else
5430	{
5431	byte = fgetc(fil);
5432	len= byte;
5433	fgets(zeichen, len + 1, fil);
5434	}
5435	}
5436	free(zeichen);
5437	free(buf);
5438	fclose(fil);
5439	return buf1;
5440	}
5441
5442	char* command(char* input)
5443	{
5444	char* tmpstr = NULL, *fileline = NULL;
5445	FILE *iopipe = NULL;
5446
5447	if(input == NULL) return NULL;
5448
5449	fileline = malloc(MINMALLOC);
5450	if(fileline == NULL)
5451	{
5452	err("no memory");
5453	return NULL;
5454	}
5455
5456	if((iopipe = popen(input, "r")) == NULL)
5457	{
5458	free(fileline);
5459	return NULL;
5460	}
5461
5462	while(!feof(iopipe))
5463	{
5464	if(fgets(fileline, MINMALLOC, iopipe) != NULL)
5465	tmpstr = ostrcat(tmpstr, fileline, 1, 0);
5466	}
5467
5468	free(fileline);
5469	pclose(iopipe);
5470	return tmpstr;
5471	}
5472
5473	char* string_tolower(char *str)
5474	{
5475	char *p1 = str;
5476
5477	if(str == NULL) return NULL;
5478
5479	while(*p1 != '\0')
5480	p1++ = tolower(p1);
5481
5482	return str;
5483	}
5484
5485	char* string_toupper(char *str)
5486	{
5487	char *p1 = str;
5488
5489	if(str == NULL) return NULL;
5490
5491	while(*p1 != '\0')
5492	p1++ = toupper(p1);
5493
5494	return str;
5495	}
5496
5497	char* stringreplacecharonce(char *str, char c1, char c2)
5498	{
5499	char *p1 = str;
5500
5501	if(str == NULL) return NULL;
5502
5503	while(*p1 != '\0')
5504	{
5505	if(*p1 == c1)
5506	{
5507	*p1 = c2;
5508	break;
5509	}
5510	p1++;
5511	}
5512
5513	return str;
5514	}
5515
5516	char* stringreplacechar(char *str, char c1, char c2)
5517	{
5518	char *p1 = str;
5519
5520	if(str == NULL) return NULL;
5521
5522	while(*p1 != '\0')
5523	{
5524	if(p1 == c1) p1 = c2;
5525	p1++;
5526	}
5527
5528	return str;
5529	}
5530
5531
5532	char* string_removechar(char *str)
5533	{
5534	char *p1 = str;
5535
5536	if(str == NULL) return NULL;
5537
5538	while(*p1 != '\0')
5539	{
5540	if(p1 == '.') p1 = ' ';
5541	else if(p1 == '-') p1 = ' ';
5542	else if(p1 == '_') p1 = ' ';
5543	else if(p1 == '/') p1 = ' ';
5544	p1++;
5545	}
5546
5547	return str;
5548	}
5549
5550	char* string_withchars2return(char *str)
5551	{
5552	char *p1 = str;
5553
5554	if(str == NULL) return NULL;
5555
5556	while(*p1 != '\0')
5557	{
5558	if(p1 == ' ') p1 = '\n';
5559	p1++;
5560	}
5561
5562	return str;
5563	}
5564
5565	char* string_remove_whitechars(char *text)
5566	{
5567	char p1 = text, p2 = text;
5568
5569	if(text == NULL) return NULL;
5570
5571	while(*p1 != '\0')
5572	{
5573	if(*p1 == ' ')
5574	++p1;
5575	else
5576	p2++ = p1++;
5577	}
5578	*p2 = '\0';
5579
5580	return text;
5581	}
5582
5583	char* strstrip(char *text)
5584	{
5585	char* tmpstr = text;
5586
5587	if(text == NULL) return NULL;
5588	int len = strlen(text);
5589
5590	while(isspace(tmpstr[len - 1])) tmpstr[--len] = '\0';
5591	while(tmpstr && isspace(tmpstr)) ++tmpstr, --len;
5592
5593	memmove(text, tmpstr, len + 1);
5594
5595	return text;
5596	}
5597
5598	char* string_strip_whitechars(char *text)
5599	{
5600	char p1 = text, p2 = text;
5601
5602	if(text == NULL)
5603	return NULL;
5604
5605	while(*p1 != '\0')
5606	{
5607	if(p1 == ' ' && (p1 + 1) == ' ')
5608	++p1;
5609	else
5610	p2++ = p1++;
5611	}
5612	*p2 = '\0';
5613
5614	return text;
5615	}
5616
5617	char* string_replace_all(char search, char replace, char *string, int free1)
5618	{
5619	char* tmpstr = NULL;
5620	char* searchpos = NULL;
5621
5622	if(string == NULL \|\| search == NULL)
5623	{
5624	tmpstr = ostrcat(tmpstr, string, 1, 0);
5625	if(free1 == 1) free(string);
5626	return tmpstr;
5627	}
5628
5629	searchpos = strstr(string, search);
5630	if(searchpos == NULL)
5631	{
5632	tmpstr = ostrcat(tmpstr, string, 1, 0);
5633	if(free1 == 1) free(string);
5634	return tmpstr;
5635	}
5636
5637	int count = 0;
5638	int stringlen = strlen(string);
5639	int searchlen = strlen(search);
5640	int replacelen = strlen(replace);
5641
5642	while(searchpos != NULL)
5643	{
5644	count++;
5645	searchpos = strstr(searchpos + searchlen, search);
5646	}
5647
5648	int len = stringlen - (searchlen * count) + (replacelen * count);
5649	tmpstr = calloc(1, len + 1);
5650	if(tmpstr == NULL)
5651	{
5652	err("no mem");
5653	tmpstr = ostrcat(tmpstr, string, 1, 0);
5654	if(free1 == 1) free(string);
5655	return tmpstr;
5656	}
5657
5658	len = 0;
5659	char* str = string;
5660	char* tmp = tmpstr;
5661	searchpos = strstr(str, search);
5662	while(searchpos != NULL)
5663	{
5664	len = searchpos - str;
5665	memcpy(tmp, str, len);
5666	memcpy(tmp + len, replace, replacelen);
5667	tmp += len + replacelen;
5668	str += len + searchlen;
5669	searchpos = strstr(str, search);
5670	}
5671	memcpy(tmp, str, strlen(str));
5672
5673	if(free1 == 1) free(string);
5674
5675	return tmpstr;
5676	}
5677
5678	char* string_replace_remove_last_chars(char search, char replace, char *string, int free1)
5679	{
5680	char* searchpos = NULL;
5681	char* tmpstr = NULL;
5682
5683	if(string == NULL \|\| search == NULL)
5684	{
5685	tmpstr = ostrcat(tmpstr, string, 1, 0);
5686	if(free1 == 1) free(string);
5687	return tmpstr;
5688	}
5689
5690	searchpos = ostrstr(string, search);
5691
5692	if(searchpos == NULL)
5693	{
5694	tmpstr = ostrcat(tmpstr, string, 1, 0);
5695	if(free1 == 1) free(string);
5696	return tmpstr;
5697	}
5698
5699	tmpstr = strndup(string, searchpos - string);
5700	if(replace != NULL)
5701	tmpstr = ostrcat(tmpstr, replace, 1, 0);
5702
5703	if(free1 == 1) free(string);
5704
5705	return tmpstr;
5706	}
5707
5708	char* string_replace(char search, char replace, char *string, int free1)
5709	{
5710	char* searchpos = NULL;
5711	char* tmpstr = NULL;
5712
5713	if(string == NULL \|\| search == NULL)
5714	{
5715	tmpstr = ostrcat(tmpstr, string, 1, 0);
5716	if(free1 == 1) free(string);
5717	return tmpstr;
5718	}
5719
5720	searchpos = ostrstr(string, search);
5721
5722	if(searchpos == NULL)
5723	{
5724	tmpstr = ostrcat(tmpstr, string, 1, 0);
5725	if(free1 == 1) free(string);
5726	return tmpstr;
5727	}
5728
5729	tmpstr = strndup(string, searchpos - string);
5730	if(replace != NULL)
5731	tmpstr = ostrcat(tmpstr, replace, 1, 0);
5732	tmpstr = ostrcat(tmpstr, string + (searchpos - string) + strlen(search), 1, 0);
5733
5734	if(free1 == 1) free(string);
5735
5736	return tmpstr;
5737	}
5738
5739	//flag 0: search full str
5740	//flag 1: search only end of string
5741	char* ostrrstrcase(char* str, char* search, int len, int flag)
5742	{
5743	int slen = 0;
5744	char* tmpstr = NULL;
5745
5746	if(str == NULL \|\| search == NULL) return NULL;
5747
5748	if(len == -1) len = strlen(str);
5749	slen = strlen(search);
5750	if(slen > len) return NULL;
5751
5752	for(tmpstr = str + len - slen; tmpstr >= str; tmpstr--)
5753	{
5754	if(strncasecmp(tmpstr, search, slen) == 0)
5755	return tmpstr;
5756	if(flag == 1) return NULL;
5757	}
5758
5759	return NULL;
5760	}
5761
5762	//flag 0: search full str
5763	//flag 1: search only end of string
5764	char* ostrrstr(char* str, char* search, int len, int flag)
5765	{
5766	int slen = 0;
5767	char* tmpstr = NULL;
5768
5769	if(str == NULL \|\| search == NULL) return NULL;
5770
5771	if(len == -1) len = strlen(str);
5772	slen = strlen(search);
5773	if(slen > len) return NULL;
5774
5775	for(tmpstr = str + len - slen; tmpstr >= str; tmpstr--)
5776	{
5777	if(strncmp(tmpstr, search, slen) == 0)
5778	return tmpstr;
5779	if(flag == 1) return NULL;
5780	}
5781
5782	return NULL;
5783	}
5784
5785	char* ostrstr(char* str, char* search)
5786	{
5787	char* ret = NULL;
5788
5789	if(str == NULL \|\| search == NULL) return NULL;
5790	ret = strstr(str, search);
5791
5792	return ret;
5793	}
5794
5795	int file_exist(char* filename)
5796	{
5797	if(access(filename, F_OK) == 0)
5798	return 1;
5799	else
5800	return 0;
5801	}
5802
5803	char* string_newline(char* str)
5804	{
5805	if(str == NULL) return NULL;
5806
5807	int size = strlen(str);
5808
5809	if(str[size - 1] == '\n')
5810	str[size - 1] = '\0';
5811
5812	return str;
5813	}
5814
5815	char* string_quote(char* str)
5816	{
5817	char* tmpstr = NULL;
5818
5819	tmpstr = ostrcat("\"", str, 0, 0);
5820	tmpstr = ostrcat(tmpstr, "\"", 1, 0);
5821
5822	return tmpstr;
5823	}
5824
5825	struct splitstr* strsplit(char str, char tok, int* count)
5826	{
5827	char *tmpstr = NULL;
5828	struct splitstr array = NULL, tmparray = NULL;
5829	*count = 0;
5830
5831	if(str == NULL \|\| tok == NULL)
5832	return NULL;
5833
5834	tmpstr = strtok(str, tok);
5835	while(tmpstr != NULL)
5836	{
5837	count = count + 1;
5838	tmparray = array; array = (struct splitstr)realloc(array, sizeof(struct splitstr) * (*count));
5839	if(array == NULL)
5840	{
5841	free(tmparray);
5842	return NULL;
5843	}
5844
5845	(&array[(*count) - 1])->part = tmpstr;
5846	tmpstr = strtok(NULL, tok);
5847	}
5848
5849	return array;
5850	}
5851
5852	char* string_shortname(char *tmpfilename, int mode)
5853	{
5854	debug(50, "in %s", tmpfilename);
5855
5856	// 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";
5857	char* str = NULL;
5858
5859	if(mode==1)
5860	{
5861	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";
5862	str = ostrcat(str, replacelist, 1, 0);
5863	}
5864	else if(mode==2)
5865	{
5866	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";
5867	str = ostrcat(str, replacelist, 1, 0);
5868	}
5869	else
5870	{
5871	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";
5872	str = ostrcat(str, replacelist, 1, 0);
5873	}
5874
5875	char* replace = NULL;
5876	struct splitstr* ret1 = NULL;
5877	int count = 0;
5878	int i = 0;
5879	ret1 = strsplit(str, " ", &count);
5880	int max = count - 1;
5881	int first = 1;
5882
5883	for(i = 0; i < max; i++)
5884	{
5885	struct splitstr* ret2 = NULL;
5886	int count2 = 0;
5887	int j = 0;
5888	char *tmpstr = NULL;
5889	tmpstr = ostrcat(tmpstr, tmpfilename, 1, 0);
5890	ret2 = strsplit(tmpstr, " ,.-_", &count2);
5891
5892	for(j = 0; j < count2; j++)
5893	{
5894	if(j > 0)
5895	{
5896	if(ostrcmp((&ret1[i])->part, (&ret2[j])->part) == 0)
5897	{
5898	if(mode==1)
5899	{
5900	tmpfilename = string_replace((&ret2[j])->part, replace, tmpfilename, 1);
5901	continue;
5902	}
5903	else if(mode==2)
5904	{
5905	tmpfilename = string_replace_remove_last_chars((&ret2[j])->part, replace, tmpfilename, 1);
5906	//break;
5907	continue;
5908	}
5909	else
5910	{
5911	tmpfilename = string_replace((&ret2[j])->part, replace, tmpfilename, 1);
5912	continue;
5913	}
5914	}
5915	else if(first == 1 && mode == 2)
5916	{
5917	// printf("zahl: %s\n", (&ret2[j])->part);
5918	int theCharacter = atoi((&ret2[j])->part);
5919	if(theCharacter != 0)
5920	{
5921	// printf("found zahl: %s\n", (&ret2[j])->part);
5922	if(theCharacter > 1800 && theCharacter < 2100)
5923	{
5924	// printf("found year: %s\n", (&ret2[j])->part);
5925	tmpfilename = string_replace_remove_last_chars((&ret2[j])->part, "", tmpfilename, 1);
5926	break;
5927	}
5928	}
5929	}
5930	}
5931	}
5932	free(ret2); ret2 = NULL;
5933	first = 0;
5934	free(tmpstr), tmpstr = NULL;
5935	}
5936
5937	free(ret1); ret1 = NULL;
5938	free(replace); replace = NULL;
5939	free(str); str = NULL;
5940
5941	debug(50, "out %s", tmpfilename);
5942	return tmpfilename;
5943	}
5944
5945	char* get_uuid(char* device)
5946	{
5947	debug(60, "in %s", device);
5948	char* cmd = NULL, *tmpstr = NULL;
5949
5950	if(device == NULL) return NULL;
5951
5952	cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s UUID /dev/", 1, 0);
5953	cmd = ostrcat(cmd, device, 1, 0);
5954	cmd = ostrcat(cmd, " \| cut -d'\"' -f2", 1, 0);
5955
5956	tmpstr = string_newline(command(cmd));
5957
5958	if(ostrcmp(string_newline(tmpstr), "") == 0)
5959	{
5960	free(tmpstr); tmpstr = NULL;
5961	}
5962
5963	debug(60, "out %s", cmd);
5964	free(cmd); cmd = NULL;
5965	return tmpstr;
5966	}
5967
5968	char* get_label(char* device)
5969	{
5970	debug(60, "in %s", device);
5971	char* cmd = NULL, *tmpstr = NULL;
5972
5973	if(device == NULL) return NULL;
5974
5975	cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s LABEL /dev/", 1, 0);
5976	cmd = ostrcat(cmd, device, 1, 0);
5977	cmd = ostrcat(cmd, " \| cut -d'\"' -f2", 1, 0);
5978
5979	tmpstr = string_newline(command(cmd));
5980
5981	if(tmpstr == NULL)
5982	tmpstr = ostrcat(tmpstr, "NONLABEL", 1, 0);
5983
5984	if(ostrcmp(string_newline(tmpstr), "") == 0)
5985	tmpstr = ostrcat(tmpstr, "NONLABEL", 1, 0);
5986
5987	debug(60, "out %s", cmd);
5988	free(cmd); cmd = NULL;
5989	return tmpstr;
5990	}
5991
5992	char* get_filesystem(char* device)
5993	{
5994	debug(60, "in %s", device);
5995	char* cmd = NULL, *tmpstr = NULL;
5996
5997	if(device == NULL) return NULL;
5998
5999	cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s TYPE /dev/", 1, 0);
6000	cmd = ostrcat(cmd, device, 1, 0);
6001	cmd = ostrcat(cmd, " \| cut -d'\"' -f2", 1, 0);
6002
6003	tmpstr = string_newline(command(cmd));
6004
6005	if(tmpstr == NULL)
6006	tmpstr = ostrcat(tmpstr, "NONTYPE", 1, 0);
6007
6008	if(ostrcmp(string_newline(tmpstr), "") == 0)
6009	tmpstr = ostrcat(tmpstr, "NONTYPE", 1, 0);
6010
6011	debug(60, "out %s", cmd);
6012	free(cmd); cmd = NULL;
6013	return tmpstr;
6014	}
6015
6016	//flag 0: convert ip to 000.000.000.000
6017	//flag 1: convert ip to 0.0.0.0
6018	char* fixip(char* ipinput, int flag)
6019	{
6020	debug(60, "in %s", ipinput);
6021	int ret = 0;
6022	char* ipout = NULL;
6023	unsigned char ip[4];
6024
6025	ip[0] = 0;
6026	ip[1] = 0;
6027	ip[2] = 0;
6028	ip[3] = 0;
6029
6030	if(ipinput == NULL) return NULL;
6031	ret = sscanf(ipinput, "%hhu.%hhu.%hhu.%hhu", &ip[0], &ip[1], &ip[2], &ip[3]);
6032	if(ret != 4) return NULL;
6033
6034	ipout = malloc(16);
6035	if(ipout == NULL)
6036	{
6037	err("no mem");
6038	return NULL;
6039	}
6040
6041	if(flag == 1)
6042	snprintf(ipout, 16, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
6043	else
6044	snprintf(ipout, 16, "%03d.%03d.%03d.%03d", ip[0], ip[1], ip[2], ip[3]);
6045
6046	return ipout;
6047	}
6048
6049	void setfanspeed(int speed, int aktion)
6050	{
6051	char* speedWert = NULL;
6052	char* speedSet = NULL;
6053
6054	if(speed < 0)
6055	{
6056	speedWert = getconfig("fanspeed", NULL);
6057	if(speedWert == NULL)
6058	speedSet = ostrcat(speedSet, "170", 1, 0);
6059	else
6060	speedSet = ostrcat(speedSet, speedWert, 1, 0);
6061	}
6062	else
6063	{
6064	if(speed == 0)
6065	speedSet = ostrcat(speedSet, "115", 1, 0);
6066	else if(speed == 25)
6067	speedSet = ostrcat(speedSet, "130", 1, 0);
6068	else if(speed == 50)
6069	speedSet = ostrcat(speedSet, "145", 1, 0);
6070	else if(speed == 75)
6071	speedSet = ostrcat(speedSet, "155", 1, 0);
6072	else
6073	speedSet = ostrcat(speedSet, "170", 1, 0);
6074	}
6075
6076	writesys("/proc/stb/fan/fan_ctrl", speedSet, 1);
6077
6078	if(aktion == 1)
6079	addconfig("fanspeed", speedSet);
6080
6081	free(speedSet); speedSet=NULL;
6082	}
6083
6084	void setaktres()
6085	{
6086	int m_width = 0;
6087	char* res = NULL;
6088	char* res_akt = NULL;
6089	char* res_sd = NULL;
6090	int count = 1;
6091	int sec = 0;
6092
6093	m_lock(&status.setaktresmutex, 23);
6094
6095	if(status.restimer == NULL)
6096	goto end;
6097
6098	sec = (int)status.restimer->param1;
6099
6100	if(sec > 0)
6101	{
6102	while(status.restimer->aktion == START && count <= (sec * 10))
6103	{
6104	usleep(100000);
6105	if(status.restimer->aktion != START)
6106	goto end;
6107	count++;
6108	}
6109	}
6110	if(status.restimer->aktion != START) goto end;
6111
6112	if(videoreadqwidth(status.aktservice->videodev) == 0)
6113	{
6114	if(status.restimer->aktion != START) goto end;
6115	m_width = status.videosize.w;
6116	if(m_width == 720)
6117	{
6118	res_sd = getconfig("av_videomode_autores_sd", NULL);
6119	if(res_sd == NULL)
6120	res = ostrcat(res, "576i50", 1, 0);
6121	else
6122	res = ostrcat(res, res_sd, 1, 0);
6123	}
6124	else if (m_width == 1280)
6125	res = ostrcat(res, "720p50", 1, 0);
6126	else if (m_width == 1920)
6127	res = ostrcat(res, "1080i50", 1, 0);
6128	else
6129	m_width = 0;
6130
6131	if(m_width > 0)
6132	{
6133	if(status.restimer->aktion != START) goto end;
6134	res_akt = getvideomode();
6135	if(status.restimer->aktion != START) goto end;
6136	if(ostrcmp(res_akt, res) != 0)
6137	{
6138	if(status.restimer->aktion != START) goto end;
6139	setvideomode(res, 1);
6140	changefbresolution(res, 1);
6141	/*
6142	if(status.restimer->aktion != START) goto end;
6143
6144	count = 0;
6145	while(status.restimer->aktion == START && count < 10)
6146	{
6147	usleep(100000);
6148	if(status.restimer->aktion != START)
6149	goto end;
6150	count++;
6151	}
6152
6153	if(status.restimer->aktion != START) goto end;
6154	*/
6155	screenautores(res, 5, 0);
6156	}
6157	}
6158	}
6159	else
6160	{
6161	if(status.restimer->aktion != START) goto end;
6162	textbox(_("Message"), _("ERROR cant read res"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 5, 0);
6163	}
6164
6165	end:
6166	free(res); res = NULL;
6167	status.restimer = NULL;
6168	m_unlock(&status.setaktresmutex, 23);
6169	return;
6170	}
6171
6172	char* gettimestamp()
6173	{
6174	char* timestamp = NULL;
6175	struct timeval numtime;
6176
6177	gettimeofday(&numtime, 0);
6178	timestamp = ostrcat(timestamp, olutoa(numtime.tv_sec), 1, 1);
6179	timestamp = ostrcat(timestamp, olutoa(numtime.tv_usec), 1, 1);
6180
6181	return timestamp;
6182	}
6183
6184	char* string_decode(char* input, int flag)
6185	{
6186	if(input == NULL) return input;
6187
6188	while(ostrstr(input, "\\u00") != NULL)
6189	{
6190	debug(210, "input: %s", input);
6191	input = string_replace("\\u00", "%", input, 1);
6192	debug(210, "input: %s", input);
6193	}
6194
6195	while(ostrstr(input, "&") != NULL)
6196	{
6197	debug(210, "input: %s", input);
6198	input = string_replace("&", "und", input, 1);
6199	debug(210, "input: %s", input);
6200	}
6201
6202	while(ostrstr(input, ">") != NULL)
6203	{
6204	debug(210, "input: %s", input);
6205	input = string_replace(">", ">", input, 1);
6206	debug(210, "input: %s", input);
6207	}
6208
6209	while(ostrstr(input, "<") != NULL)
6210	{
6211	debug(210, "input: %s", input);
6212	input = string_replace("<", "<", input, 1);
6213	debug(210, "input: %s", input);
6214	}
6215
6216	while(ostrstr(input, """) != NULL)
6217	{
6218	debug(210, "input: %s", input);
6219	input = string_replace(""", "\"", input, 1);
6220	debug(210, "input: %s", input);
6221	}
6222
6223	while(ostrstr(input, "&#x") != NULL)
6224	{
6225	debug(210, "out %s", input);
6226	input = string_replace("&#x", "%", input, 1);
6227	debug(210, "input: %s", input);
6228	}
6229
6230	while(ostrstr(input, "&#") != NULL)
6231	{
6232	debug(210, "input: %s", input);
6233	input = string_replace("&#", "%", input, 1);
6234	debug(210, "input: %s", input);
6235	}
6236
6237	if(flag == 1)
6238	htmldecode2(input, input);
6239	else
6240	htmldecode(input, input);
6241
6242	while(ostrstr(input, ";") != NULL)
6243	{
6244	debug(210, "input: %s", input);
6245	input = string_replace(";", NULL, input, 1);
6246	debug(210, "input: %s", input);
6247	}
6248
6249	return input;
6250	}
6251
6252	char* string_deltags(char* str)
6253	{
6254	int i = 0, y = 0, len = 0;
6255
6256	if(str == NULL) return 0;
6257
6258	len = strlen(str);
6259
6260	int skip = 0;
6261	for(i = 0; i < len; i++)
6262	{
6263	if(str[i] == '<')
6264	skip = 1;
6265	else if(str[i] == '>')
6266	skip = 0;
6267
6268	if(skip == 0 && str[i] != '>')
6269	{
6270	str[y] = str[i];
6271	y++;
6272	}
6273	}
6274	str[y] = '\0';
6275
6276	return str;
6277	}
6278
6279	char* string_striptags(char* str)
6280	{
6281	int i = 0, len = 0;
6282
6283	if(str == NULL) return 0;
6284
6285	len = strlen(str);
6286
6287	int skip = 0;
6288	for(i = 0; i < len; i++)
6289	{
6290	if(str[i] == '<')
6291	skip = 1;
6292	else if(str[i] == '>')
6293	{
6294	skip = 0;
6295	str[i] = ' ';
6296	}
6297	if(skip == 1)
6298	str[i] = ' ';
6299	}
6300
6301	return strstrip(str);
6302	}
6303
6304	char* string_resub(char* str, char* str2, char* input, int dir)
6305	{
6306	int len;
6307	char* tmpstr = NULL, pos = NULL, pos2 = NULL;
6308
6309	if(str == NULL \|\| str2 == NULL \|\| input == NULL) return NULL;
6310
6311	if(dir == 0)
6312	{
6313	len = strlen(str);
6314	pos = ostrstr(input, str);
6315	if(pos == NULL) return NULL;
6316	pos += len;
6317
6318	pos2 = ostrstr(pos, str2);
6319	if(pos2 == NULL) return NULL;
6320	}
6321	else
6322	{
6323	pos2 = ostrstr(input, str2);
6324	if(pos2 == NULL) return NULL;
6325
6326	len = strlen(str);
6327	pos = ostrrstr(input, str, pos2 - input, 0);
6328	if(pos == NULL) return NULL;
6329	pos += len;
6330	}
6331
6332	tmpstr = strndup(pos, pos2 - pos);
6333
6334	return strstrip(tmpstr);
6335	}
6336
6337	char* ostrstrcase(char* str, char* sub)
6338	{
6339	size_t len = 0;
6340
6341	if(str == NULL \|\| sub == NULL) return NULL;
6342
6343	len = strlen(sub);
6344	while(*str)
6345	{
6346	if(toupper(str) == toupper(sub) && strncasecmp(str, sub, len) == 0)
6347	return str;
6348	++str;
6349	}
6350	return NULL;
6351	}
6352
6353	//flag 0: convert port to 00021
6354	//flag 1: convert port to 21
6355	char* fixport(char* input, int flag)
6356	{
6357	char* tmpstr = NULL;
6358
6359	if(flag == 0)
6360	{
6361	int plen = strlen(input);
6362	if(plen < 5)
6363	{
6364	int i;
6365	for(i = 0; i < 5 - plen; i++)
6366	tmpstr = ostrcat(tmpstr, "0", 1, 0);
6367	}
6368	tmpstr = ostrcat(tmpstr, input, 1, 0);
6369	}
6370	else
6371	{
6372	while (input && input == '0')
6373	input++;
6374
6375	tmpstr = ostrcat(tmpstr, input, 1, 0);
6376	}
6377	return tmpstr;
6378	}
6379
6380	#endif

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

Download in other formats: