Context Navigation

source: titan/titan/global.h @ 24324

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

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

Download in other formats: