Context Navigation

source: titan/titan/global.h @ 25597

Last change on this file since 25597 was 25597, checked in by obi, 9 years ago
fix
File size: 133.9 KB

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

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

Download in other formats: