Context Navigation

source: titan/titan/global.h @ 25939

Last change on this file since 25939 was 25939, checked in by obi, 10 years ago
atemio530 add pluginbutton function
File size: 134.7 KB

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

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

Download in other formats: