source: titan/titan/global.h @ 39435

Last change on this file since 39435 was 39435, checked in by gost, 6 years ago

[titan] arm.. dm900 add some function

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