Context Navigation

source: titan/titan/global.h @ 23739

Last change on this file since 23739 was 23739, checked in by obi, 10 years ago
add atemio530
File size: 124.7 KB

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

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

Download in other formats: