source: titan/titan/global.h @ 40020

Last change on this file since 40020 was 40020, checked in by gost, 5 years ago

[titan] add new hybrid function for future use

File size: 168.3 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* getac3pluschoices()
3698{
3699        char *ac3pluschoicesdev = NULL;
3700        char *value = NULL;
3701
3702        ac3pluschoicesdev = getconfig("ac3pluschoicesdev", NULL);
3703
3704        if(ac3pluschoicesdev == NULL)
3705        {
3706                addconfig("ac3pluschoicesdev", "/proc/stb/audio/ac3plus_choices");
3707                ac3pluschoicesdev = getconfig("ac3pluschoicesdev", NULL);
3708        }
3709
3710        value = readsys(ac3pluschoicesdev, 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* getdtshdchoices()
3723{
3724        char *dtshdchoicesdev = NULL;
3725        char *value = NULL;
3726
3727        dtshdchoicesdev = getconfig("dtshdchoicesdev", NULL);
3728
3729        if(dtshdchoicesdev == NULL)
3730        {
3731                addconfig("dtshdchoicesdev", "/proc/stb/audio/dtshd_choices");
3732                dtshdchoicesdev = getconfig("dtshdchoicesdev", NULL);
3733        }
3734
3735        value = readsys(dtshdchoicesdev, 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* getwmaprochoices()
3748{
3749        char *wmaprochoicesdev = NULL;
3750        char *value = NULL;
3751
3752        wmaprochoicesdev = getconfig("wmaprochoicesdev", NULL);
3753
3754        if(wmaprochoicesdev == NULL)
3755        {
3756                addconfig("wmaprochoicesdev", "/proc/stb/audio/wmapro_choices");
3757                wmaprochoicesdev = getconfig("wmaprochoicesdev", NULL);
3758        }
3759
3760        value = readsys(wmaprochoicesdev, 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
3772char* getac3choices()
3773{
3774        char *ac3choicesdev = NULL;
3775        char *value = NULL;
3776
3777        ac3choicesdev = getconfig("ac3choicesdev", NULL);
3778
3779        if(ac3choicesdev == NULL)
3780        {
3781                err("NULL detect");
3782                return NULL;
3783        }
3784
3785        value = readsys(ac3choicesdev, 1);
3786        if(value == NULL)
3787        {
3788                err("NULL detect");
3789                return NULL;
3790        }
3791
3792        value = convertspacetolf(value);
3793
3794        return value;
3795}
3796
3797char* getaacchoices()
3798{
3799        char *aacchoicesdev = NULL;
3800        char *value = NULL;
3801
3802        aacchoicesdev = getconfig("aacchoicesdev", NULL);
3803
3804        if(aacchoicesdev == NULL)
3805        {
3806                err("NULL detect");
3807                return NULL;
3808        }
3809
3810        value = readsys(aacchoicesdev, 1);
3811        if(value == NULL)
3812        {
3813                err("NULL detect");
3814                return NULL;
3815        }
3816
3817        value = convertspacetolf(value);
3818
3819        return value;
3820}
3821
3822char* getwsschoices()
3823{
3824        char *wsschoicesdev = NULL;
3825        char *value = NULL;
3826
3827        wsschoicesdev = getconfig("wsschoicesdev", NULL);
3828
3829        if(wsschoicesdev == NULL)
3830        {
3831                err("NULL detect");
3832                return NULL;
3833        }
3834
3835        value = readsys(wsschoicesdev, 1);
3836        if(value == NULL)
3837        {
3838                err("NULL detect");
3839                return NULL;
3840        }
3841
3842        value = convertspacetolf(value);
3843
3844        return value;
3845}
3846
3847int setciclock(int slotnr, char* value)
3848{
3849        char* ciclockdev = NULL, *tmpstr = NULL;
3850        int ret = 0;
3851
3852        ciclockdev = getconfig("ciclockdev", NULL);
3853
3854        if(ciclockdev != NULL && value != NULL)
3855        {
3856                tmpstr = malloc(MINMALLOC);
3857                if(tmpstr == NULL)
3858                {
3859                        err("no mem");
3860                        return 1;
3861                }
3862
3863                snprintf(tmpstr, MINMALLOC, ciclockdev, slotnr);
3864                debug(100, "set %s to %s", tmpstr, value);
3865                ret = writesys(tmpstr, value, 0);
3866
3867                free(tmpstr); tmpstr = NULL;
3868                return ret;
3869        }
3870
3871        return 0;
3872}
3873
3874//routes stream from tuner to ci or ci to ci
3875int setciinput(int slotnr, char* value)
3876{
3877        char* ciinputdev = NULL, *tmpstr = NULL;
3878        int ret = 0;
3879
3880        ciinputdev = getconfig("ciinputdev", NULL);
3881
3882        if(ciinputdev != NULL && value != NULL)
3883        {
3884                tmpstr = malloc(MINMALLOC);
3885                if(tmpstr == NULL)
3886                {
3887                        err("no mem");
3888                        return 1;
3889                }
3890
3891                snprintf(tmpstr, MINMALLOC, ciinputdev, slotnr);
3892                debug(100, "set %s to %s", tmpstr, value);
3893                ret = writesys(tmpstr, value, 0);
3894
3895                free(tmpstr); tmpstr = NULL;
3896                return ret;
3897        }
3898
3899        return 0;
3900}
3901
3902//routes stream from tuner or ci to linux
3903int setcisource(int tunernr, char* value)
3904{
3905        char* cisourcedev = NULL, *tmpstr = NULL;
3906        int ret = 0;
3907
3908        cisourcedev = getconfig("cisourcedev", NULL);
3909
3910        if(cisourcedev != NULL && value != NULL)
3911        {
3912                tmpstr = malloc(MINMALLOC);
3913                if(tmpstr == NULL)
3914                {
3915                        err("no mem");
3916                        return 1;
3917                }
3918
3919                snprintf(tmpstr, MINMALLOC, cisourcedev, tunernr);
3920                debug(100, "set %s to %s", tmpstr, value);
3921                ret = writesys(tmpstr, value, 0);
3922
3923                free(tmpstr); tmpstr = NULL;
3924                return ret;
3925        }
3926
3927        return 0;
3928}
3929
3930int setinput(char* value)
3931{
3932        char* inputdev = NULL;
3933        int ret = 0;
3934
3935        inputdev = getconfig("inputdev", NULL);
3936
3937        if(inputdev != NULL && value != NULL)
3938        {
3939                debug(100, "set %s to %s", inputdev, value);
3940                ret = writesys(inputdev, value, 0);
3941                return ret;
3942        }
3943
3944        return 0;
3945}
3946
3947char* getinput()
3948{
3949        char *inputdev = NULL;
3950        char *value = NULL;
3951
3952        inputdev = getconfig("inputdev", NULL);
3953
3954        if(inputdev == NULL)
3955        {
3956                err("NULL detect");
3957                return NULL;
3958        }
3959
3960        value = readsys(inputdev, 1);
3961        if(value == NULL)
3962        {
3963                err("NULL detect");
3964                return NULL;
3965        }
3966
3967        return value;
3968}
3969
3970int setac3plus(char* value)
3971{
3972        char* ac3plusdev = NULL;
3973        int ret = 0;
3974
3975        ac3plusdev = getconfig("ac3plusdev", NULL);
3976        if(ac3plusdev == NULL)
3977        {       
3978                addconfig("ac3plusdev", "/proc/stb/audio/ac3plus");
3979                ac3plusdev = getconfig("ac3plusdev", NULL);
3980        }
3981
3982        if(ac3plusdev != NULL && value != NULL)
3983        {
3984                debug(100, "set %s to %s", ac3plusdev, value);
3985                ret = writesys(ac3plusdev, value, 0);
3986                if(ret == 0) addconfig("av_ac3plusmode", value);
3987                return ret;
3988        }
3989
3990        return 0;
3991}
3992
3993int setdtshd(char* value)
3994{
3995        char* dtshddev = NULL;
3996        int ret = 0;
3997
3998        dtshddev = getconfig("dtshddev", NULL);
3999        if(dtshddev == NULL)
4000        {       
4001                addconfig("dtshddev", "/proc/stb/audio/dtshd");
4002                dtshddev = getconfig("dtshddev", NULL);
4003        }
4004
4005        if(dtshddev != NULL && value != NULL)
4006        {
4007                debug(100, "set %s to %s", dtshddev, value);
4008                ret = writesys(dtshddev, value, 0);
4009                if(ret == 0) addconfig("av_dtshdmode", value);
4010                return ret;
4011        }
4012
4013        return 0;
4014}
4015
4016int setwmapro(char* value)
4017{
4018        char* wmaprodev = NULL;
4019        int ret = 0;
4020
4021        wmaprodev = getconfig("wmaprodev", NULL);
4022        if(wmaprodev == NULL)
4023        {       
4024                addconfig("wmaprodev", "/proc/stb/audio/wmapro");
4025                wmaprodev = getconfig("wmaprodev", NULL);
4026        }
4027
4028        if(wmaprodev != NULL && value != NULL)
4029        {
4030                debug(100, "set %s to %s", wmaprodev, value);
4031                ret = writesys(wmaprodev, value, 0);
4032                if(ret == 0) addconfig("av_wmapromode", value);
4033                return ret;
4034        }
4035
4036        return 0;
4037}
4038
4039int setac3(char* value)
4040{
4041        char* ac3dev = NULL;
4042        int ret = 0;
4043
4044        ac3dev = getconfig("ac3dev", NULL);
4045
4046        if(ac3dev != NULL && value != NULL)
4047        {
4048                debug(100, "set %s to %s", ac3dev, value);
4049                ret = writesys(ac3dev, value, 0);
4050                if(ret == 0) addconfig("av_ac3mode", value);
4051                if(ostrcmp(value, "passthrough") == 0)
4052                        status.downmix = 0;
4053                else
4054                        status.downmix = 1;
4055                return ret;
4056        }
4057
4058        return 0;
4059}
4060
4061int setaac(char* value)
4062{
4063        char* aacdev = NULL;
4064        int ret = 0;
4065
4066        aacdev = getconfig("aacdev", NULL);
4067
4068        if(aacdev != NULL && value != NULL)
4069        {
4070                debug(100, "set %s to %s", aacdev, value);
4071                ret = writesys(aacdev, value, 0);
4072                if(ret == 0) addconfig("av_aacmode", value);
4073                return ret;
4074        }
4075
4076        return 0;
4077}
4078
4079int setwss(char* value)
4080{
4081        char* wssdev = NULL;
4082        int ret = 0;
4083
4084        wssdev = getconfig("wssdev", NULL);
4085
4086        if(wssdev != NULL && value != NULL)
4087        {
4088                debug(100, "set %s to %s", wssdev, value);
4089                ret = writesys(wssdev, value, 0);
4090                if(ret == 0) addconfig("av_wssmode", value);
4091                return ret;
4092        }
4093        else if(wssdev != NULL && value == NULL)
4094        {
4095                debug(100, "set %s to %s", wssdev, "auto");
4096                ret = writesys(wssdev, "auto", 0);
4097                return ret;
4098        }
4099
4100        return 0;
4101}
4102
4103char* getac3plus()
4104{
4105        char *ac3plusdev = NULL;
4106        char *value = NULL;
4107
4108        ac3plusdev = getconfig("ac3plusdev", NULL);
4109
4110        if(ac3plusdev == NULL)
4111        {
4112                err("NULL detect");
4113                return NULL;
4114        }
4115
4116        value = readsys(ac3plusdev, 1);
4117        if(value == NULL)
4118        {
4119                err("NULL detect");
4120                return NULL;
4121        }
4122
4123        return value;
4124}
4125
4126char* getdtshd()
4127{
4128        char *dtshddev = NULL;
4129        char *value = NULL;
4130
4131        dtshddev = getconfig("dtshddev", NULL);
4132
4133        if(dtshddev == NULL)
4134        {
4135                err("NULL detect");
4136                return NULL;
4137        }
4138
4139        value = readsys(dtshddev, 1);
4140        if(value == NULL)
4141        {
4142                err("NULL detect");
4143                return NULL;
4144        }
4145
4146        return value;
4147}
4148
4149char* getwmapro()
4150{
4151        char *wmaprodev = NULL;
4152        char *value = NULL;
4153
4154        wmaprodev = getconfig("wmaprodev", NULL);
4155
4156        if(wmaprodev == NULL)
4157        {
4158                err("NULL detect");
4159                return NULL;
4160        }
4161
4162        value = readsys(wmaprodev, 1);
4163        if(value == NULL)
4164        {
4165                err("NULL detect");
4166                return NULL;
4167        }
4168
4169        return value;
4170}
4171
4172char* getac3()
4173{
4174        char *ac3dev = NULL;
4175        char *value = NULL;
4176
4177        ac3dev = getconfig("ac3dev", NULL);
4178
4179        if(ac3dev == NULL)
4180        {
4181                err("NULL detect");
4182                return NULL;
4183        }
4184
4185        value = readsys(ac3dev, 1);
4186        if(value == NULL)
4187        {
4188                err("NULL detect");
4189                return NULL;
4190        }
4191
4192        return value;
4193}
4194
4195char* getaac()
4196{
4197        char *aacdev = NULL;
4198        char *value = NULL;
4199
4200        aacdev = getconfig("aacdev", NULL);
4201
4202        if(aacdev == NULL)
4203        {
4204                err("NULL detect");
4205                return NULL;
4206        }
4207
4208        value = readsys(aacdev, 1);
4209        if(value == NULL)
4210        {
4211                err("NULL detect");
4212                return NULL;
4213        }
4214
4215        return value;
4216}
4217
4218char* getwss()
4219{
4220        char *wssdev = NULL;
4221        char *value = NULL;
4222
4223        wssdev = getconfig("wssdev", NULL);
4224
4225        if(wssdev == NULL)
4226        {
4227                err("NULL detect");
4228                return NULL;
4229        }
4230
4231        value = readsys(wssdev, 1);
4232        if(value == NULL)
4233        {
4234                err("NULL detect");
4235                return NULL;
4236        }
4237
4238        return value;
4239}
4240
4241int setaudiodelaybitstream(char* value)
4242{
4243        char* audiodelaybitstreamdev = NULL;
4244        int ret = 0;
4245
4246        audiodelaybitstreamdev = getconfig("audiodelaybitstreamdev", NULL);
4247
4248        if(audiodelaybitstreamdev != NULL && value != NULL)
4249        {
4250                debug(100, "set %s to %s", audiodelaybitstreamdev, value);
4251                ret = writesys(audiodelaybitstreamdev, value, 0);
4252                if(ret == 0) addconfig("audiodelaybitstream", value);
4253                return ret;
4254        }
4255
4256        return 0;
4257}
4258
4259char* getaudiodelaybitstream()
4260{
4261        char *audiodelaybitstreamdev = NULL;
4262        char *value = NULL;
4263
4264        audiodelaybitstreamdev = getconfig("audiodelaybitstreamdev", NULL);
4265
4266        if(audiodelaybitstreamdev == NULL)
4267        {
4268                err("NULL detect");
4269                return NULL;
4270        }
4271
4272        value = readsys(audiodelaybitstreamdev, 1);
4273        if(value == NULL)
4274        {
4275                err("NULL detect");
4276                return NULL;
4277        }
4278
4279        return value;
4280}
4281
4282int setaudiodelaypcm(char* value)
4283{
4284        char* audiodelaypcmdev = NULL;
4285        int ret = 0;
4286
4287        audiodelaypcmdev = getconfig("audiodelaypcmdev", NULL);
4288
4289        if(audiodelaypcmdev != NULL && value != NULL)
4290        {
4291                debug(100, "set %s to %s", audiodelaypcmdev, value);
4292                ret = writesys(audiodelaypcmdev, value, 0);
4293                if(ret == 0) addconfig("audiodelaypcm", value);
4294                return ret;
4295        }
4296
4297        return 0;
4298}
4299
4300char* getaudiodelaypcm()
4301{
4302        char *audiodelaypcmdev = NULL;
4303        char *value = NULL;
4304
4305        audiodelaypcmdev = getconfig("audiodelaypcmdev", NULL);
4306
4307        if(audiodelaypcmdev == NULL)
4308        {
4309                err("NULL detect");
4310                return NULL;
4311        }
4312
4313        value = readsys(audiodelaypcmdev, 1);
4314        if(value == NULL)
4315        {
4316                err("NULL detect");
4317                return NULL;
4318        }
4319
4320        return value;
4321}
4322
4323
4324char* getpolicychoices()
4325{
4326        char *policychoicesdev = NULL;
4327        char *value = NULL;
4328
4329        policychoicesdev = getconfig("policychoicesdev", NULL);
4330
4331        if(policychoicesdev == NULL)
4332        {
4333                err("NULL detect");
4334                return NULL;
4335        }
4336
4337        value = readsys(policychoicesdev, 1);
4338        if(value == NULL)
4339        {
4340                err("NULL detect");
4341                return NULL;
4342        }
4343
4344#ifdef MIPSEL
4345        free(value), value = NULL;
4346//      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);
4347        value = ostrcat(_("16:9_set_bestfit_to_policy_show_justscale"), NULL, 0, 0);
4348        value = ostrcat(value, "\n", 1, 0);
4349        value = ostrcat(value, _("16:9_set_letterbox_to_policy_show_panscan"), 1, 0);
4350        value = ostrcat(value, "\n", 1, 0);
4351        value = ostrcat(value, _("16:9_set_panscan_to_policy_show_pillarbox"), 1, 0);
4352        value = ostrcat(value, "\n", 1, 0);
4353        value = ostrcat(value, _("4:3_set_bestfit_to_policy2_show_justscale"), 1, 0);
4354        value = ostrcat(value, "\n", 1, 0);
4355        value = ostrcat(value, _("4:3_set_letterbox_to_policy2_show_letterbox"), 1, 0);
4356        value = ostrcat(value, "\n", 1, 0);
4357        value = ostrcat(value, _("4:3_set_panscan_to_policy2_show_panscan"), 1, 0);
4358#else
4359        value = convertspacetolf(value);
4360#endif
4361
4362        return value;
4363}
4364
4365char* getpolicy()
4366{
4367        char *policydev = NULL;
4368        char *value = NULL;
4369
4370        policydev = getconfig("policydev", NULL);
4371
4372        if(policydev == NULL)
4373        {
4374                err("NULL detect");
4375                return NULL;
4376        }
4377
4378        value = readsys(policydev, 1);
4379
4380#ifdef MIPSEL
4381        char *aspect = NULL;
4382        aspect = getaspect();
4383        if(!ostrncmp("16:9", aspect, 4))
4384        {
4385                if(ostrcmp("bestfit", value) == 0)
4386                {
4387                        free(value), value = NULL;
4388                        value = ostrcat(_("16:9_set_bestfit_to_policy_show_justscale"), NULL, 0, 0);
4389                }
4390                else if(ostrcmp("letterbox", value) == 0)
4391                {
4392                        free(value), value = NULL;
4393                        value = ostrcat(_("16:9_set_letterbox_to_policy_show_panscan"), NULL, 0, 0);
4394                }
4395                else if(ostrcmp("panscan", value) == 0)
4396                {
4397                        free(value), value = NULL;
4398                        value = ostrcat(_("16:9_set_panscan_to_policy_show_pillarbox"), NULL, 0, 0);
4399                }
4400        }
4401        else
4402        {
4403                policydev = getconfig("policy2dev", NULL);
4404                value = readsys(policydev, 1);
4405
4406                if(ostrcmp("bestfit", value) == 0)
4407                {
4408                        free(value), value = NULL;
4409                        value = ostrcat(_("4:3_set_bestfit_to_policy2_show_justscale"), NULL, 0, 0);
4410                }
4411                else if(ostrcmp("letterbox", value) == 0)
4412                {
4413                        free(value), value = NULL;
4414                        value = ostrcat(_("4:3_set_letterbox_to_policy2_show_letterbox"), NULL, 0, 0);
4415                }
4416                else if(ostrcmp("panscan", value) == 0)
4417                {
4418                        free(value), value = NULL;
4419                        value = ostrcat(_("4:3_set_panscan_to_policy2_show_panscan"), NULL, 0, 0);
4420                }
4421        }
4422        free(aspect), aspect = NULL;
4423
4424#endif
4425
4426        if(value == NULL)
4427        {
4428                err("NULL detect");
4429                return NULL;
4430        }
4431
4432        return value;
4433}
4434
4435int setpolicy(char* value)
4436{
4437        char* policydev, *tmpstr = NULL, *tmpstr2 = NULL;
4438        int ret = 0;
4439
4440        policydev = getconfig("policydev", NULL);
4441
4442        if(policydev != NULL && value != NULL)
4443        {
4444                debug(10, "set %s to %s", policydev, value);
4445
4446#ifdef MIPSEL
4447                if(ostrcmp(_("16:9_set_bestfit_to_policy_show_justscale"), _(value)) == 0)
4448                {
4449                        tmpstr = ostrcat("bestfit", NULL, 0, 0);
4450                        tmpstr2 = ostrcat("16:9_set_bestfit_to_policy_show_justscale", NULL, 0, 0);
4451                        setaspect("set_16:9");
4452                }
4453                else if(ostrcmp(_("16:9_set_letterbox_to_policy_show_panscan"), _(value)) == 0)
4454                {
4455                        tmpstr = ostrcat("letterbox", NULL, 0, 0);
4456                        tmpstr2 = ostrcat("16:9_set_letterbox_to_policy_show_panscan", NULL, 0, 0);
4457                        setaspect("set_16:9");
4458                }
4459                else if(ostrcmp(_("16:9_set_panscan_to_policy_show_pillarbox"), _(value)) == 0)
4460                {
4461                        tmpstr = ostrcat("panscan", NULL, 0, 0);
4462                        tmpstr2 = ostrcat("16:9_set_panscan_to_policy_show_pillarbox", NULL, 0, 0);
4463                        setaspect("set_16:9");
4464                }
4465                else if(ostrcmp(_("4:3_set_bestfit_to_policy2_show_justscale"), _(value)) == 0)
4466                {
4467                        policydev = getconfig("policy2dev", NULL);
4468                        tmpstr = ostrcat("bestfit", NULL, 0, 0);
4469                        tmpstr2 = ostrcat("4:3_set_bestfit_to_policy2_show_justscale", NULL, 0, 0);
4470                        setaspect("set_4:3");
4471                }
4472                else if(ostrcmp(_("4:3_set_letterbox_to_policy2_show_letterbox"), _(value)) == 0)
4473                {
4474                        policydev = getconfig("policy2dev", NULL);
4475                        tmpstr = ostrcat("letterbox", NULL, 0, 0);
4476                        tmpstr2 = ostrcat("4:3_set_letterbox_to_policy2_show_letterbox", NULL, 0, 0);
4477                        setaspect("set_4:3");
4478                }
4479                else if(ostrcmp(_("4:3_set_panscan_to_policy2_show_panscan"), _(value)) == 0)
4480                {
4481                        policydev = getconfig("policy2dev", NULL);
4482                        tmpstr = ostrcat("panscan", NULL, 0, 0);
4483                        tmpstr2 = ostrcat("4:3_set_panscan_to_policy2_show_panscan", NULL, 0, 0);
4484                        setaspect("set_4:3");
4485                }
4486#else
4487                tmpstr = ostrcat(value, NULL, 0, 0);
4488#endif
4489                debug(10, "set change %s to %s", policydev, tmpstr);
4490                ret = writesys(policydev, tmpstr, 0);
4491
4492#ifdef MIPSEL
4493                if(ret == 0)
4494                {
4495                        debug(10, "write %s to /mnt/config/titan.cfg", tmpstr2);
4496                        addconfig("av_policy", tmpstr2);
4497                }
4498#else
4499                if(ret == 0) addconfig("av_policy", value);
4500                {
4501                        debug(10, "write %s to /mnt/config/titan.cfg", value);
4502                        addconfig("av_policy", value);
4503                }
4504#endif
4505        }
4506
4507        free(tmpstr), tmpstr = NULL;
4508        free(tmpstr2), tmpstr2 = NULL;
4509        return ret;
4510}
4511
4512char* getaspectchoices()
4513{
4514        char *aspectchoicesdev = NULL;
4515        char *value = NULL;
4516
4517        aspectchoicesdev = getconfig("aspectchoicesdev", NULL);
4518
4519        if(aspectchoicesdev == NULL)
4520        {
4521                err("NULL detect");
4522                return NULL;
4523        }
4524
4525        value = readsys(aspectchoicesdev, 1);
4526        if(value == NULL)
4527        {
4528                err("NULL detect");
4529                return NULL;
4530        }
4531
4532        value = convertspacetolf(value);
4533
4534        return value;
4535}
4536
4537char* getaspect()
4538{
4539        char *aspectdev = NULL;
4540        char *value = NULL;
4541
4542        aspectdev = getconfig("aspectdev", NULL);
4543
4544        if(aspectdev == NULL)
4545        {
4546                err("NULL detect");
4547                return NULL;
4548        }
4549
4550        value = readsys(aspectdev, 1);
4551        if(value == NULL)
4552        {
4553                err("NULL detect");
4554                return NULL;
4555        }
4556
4557        return value;
4558}
4559
4560int setaspect(char* value)
4561{
4562        char* aspectdev;
4563        int ret = 0;
4564
4565        aspectdev = getconfig("aspectdev", NULL);
4566
4567        if(aspectdev != NULL && value != NULL)
4568        {
4569                debug(10, "set %s to %s", aspectdev, value);
4570
4571                if(!ostrncmp("set_", value, 4))
4572                {
4573                        char* tmpstr = NULL;
4574                        tmpstr = ostrcat(value, NULL, 0, 0);
4575                        tmpstr = string_replace("set_", "", tmpstr, 1);
4576                        debug(10, "change %s to %s", aspectdev, tmpstr);
4577                        ret = writesys(aspectdev, tmpstr, 0);
4578                        if(ret == 0) addconfig("av_aspect", tmpstr);
4579                        free(tmpstr); tmpstr = NULL;
4580                        return ret;
4581                }
4582                else
4583                {
4584                        ret = writesys(aspectdev, value, 0);
4585
4586                        if(ret == 0)
4587                        {
4588                                addconfig("av_aspect", value);
4589
4590                                //set policy new after change aspect
4591                                char* tmpstr = getpolicy();
4592                                setpolicy(tmpstr);
4593                                free(tmpstr); tmpstr = NULL;
4594                        }
4595                }
4596                return ret;
4597        }
4598
4599        return 0;
4600}
4601
4602char* getvideomodechoices()
4603{
4604        char *videomodechoicesdev = NULL;
4605        char *value = NULL;
4606
4607        videomodechoicesdev = getconfig("videomodechoicesdev", NULL);
4608
4609        if(videomodechoicesdev == NULL)
4610        {
4611                err("NULL detect");
4612                return NULL;
4613        }
4614
4615        value = readsys(videomodechoicesdev, 1);
4616        if(value == NULL)
4617        {
4618                err("NULL detect");
4619                return NULL;
4620        }
4621
4622        value = string_replace("pal", NULL, value, 1);
4623        value = string_replace("  ", " ", value, 1);
4624
4625        if(status.mcaktiv == 0)
4626        {
4627                value = string_replace("1080p60", NULL, value, 1);
4628                value = string_replace("  ", " ", value, 1);
4629                value = string_replace("1080p59", NULL, value, 1);
4630                value = string_replace("  ", " ", value, 1);
4631                value = string_replace("1080p30", NULL, value, 1);
4632                value = string_replace("  ", " ", value, 1);
4633                value = string_replace("1080p29", NULL, value, 1);
4634                value = string_replace("  ", " ", value, 1);
4635                value = string_replace("1080p25", NULL, value, 1);
4636                value = string_replace("  ", " ", value, 1);
4637                value = string_replace("1080p24", NULL, value, 1);
4638                value = string_replace("  ", " ", value, 1);
4639                value = string_replace("1080p23", NULL, value, 1);
4640                value = string_replace("  ", " ", value, 1);
4641                value = string_replace("1080i60", NULL, value, 1);
4642                value = string_replace("  ", " ", value, 1);
4643                value = string_replace("1080i59", NULL, value, 1);
4644                value = string_replace("  ", " ", value, 1);
4645                value = string_replace("1080i60", NULL, value, 1);
4646                value = string_replace("  ", " ", value, 1);
4647                value = string_replace("720p60", NULL, value, 1);
4648                value = string_replace("  ", " ", value, 1);
4649                value = string_replace("576p50", NULL, value, 1);
4650                value = string_replace("  ", " ", value, 1);
4651                value = string_replace("1280x1024_75", NULL, value, 1);
4652                value = string_replace("  ", " ", value, 1);
4653                value = string_replace("1280x1024_70", NULL, value, 1);
4654                value = string_replace("  ", " ", value, 1);
4655                value = string_replace("1280x1024_60", NULL, value, 1);
4656                value = string_replace("  ", " ", value, 1);
4657                value = string_replace("1600x1200_60", NULL, value, 1);
4658                value = string_replace("  ", " ", value, 1);
4659                value = string_replace("1024x768_100", NULL, value, 1);
4660                value = string_replace("  ", " ", value, 1);
4661                value = string_replace("1024x768_90", NULL, value, 1);
4662                value = string_replace("  ", " ", value, 1);
4663                value = string_replace("1024x768_75", NULL, value, 1);
4664                value = string_replace("  ", " ", value, 1);
4665                value = string_replace("1024x768_70", NULL, value, 1);
4666                value = string_replace("  ", " ", value, 1);
4667                value = string_replace("1024x768_60", NULL, value, 1);
4668                value = string_replace("  ", " ", value, 1);
4669        }
4670
4671        value = strstrip(value);
4672        value = convertspacetolf(value);
4673
4674        return value;
4675}
4676
4677char* getmode3dchoices()
4678{
4679        char *mode3dchoicesdev = NULL;
4680        char *value = NULL;
4681
4682        mode3dchoicesdev = getconfig("mode3dchoicesdev", NULL);
4683
4684        if(mode3dchoicesdev == NULL)
4685        {
4686                return ostrcat("off\nsbs\ntab", "", 0, 0);
4687        }
4688
4689        value = readsys(mode3dchoicesdev, 1);
4690        if(value == NULL)
4691        {
4692                err("NULL detect");
4693                return NULL;
4694        }
4695
4696        value = convertspacetolf(value);
4697
4698        return value;
4699}
4700
4701char* getmode3d()
4702{
4703        char *mode3ddev = NULL;
4704        char *value = NULL;
4705
4706        mode3ddev = getconfig("mode3ddev", NULL);
4707
4708        if(mode3ddev == NULL)
4709        {
4710                err("NULL detect");
4711                return NULL;
4712        }
4713
4714        value = readsys(mode3ddev, 1);
4715        if(value == NULL)
4716        {
4717                err("NULL detect");
4718                return NULL;
4719        }
4720
4721        return value;
4722}
4723
4724int setmode3d(char* value)
4725{
4726        char* mode3ddev;
4727        int ret = 0;
4728
4729        mode3ddev = getconfig("mode3ddev", NULL);
4730
4731        if(mode3ddev != NULL && value != NULL)
4732        {
4733                debug(100, "set %s to %s", mode3ddev, value);
4734                ret = writesys(mode3ddev, value, 0);
4735                if(ret == 0) addconfig("av_mode3d", value);
4736                return ret;
4737        }
4738
4739        return 0;
4740}
4741
4742char* getvideomode()
4743{
4744        char *videomodedev = NULL;
4745        char *value = NULL;
4746
4747        videomodedev = getconfig("videomodedev", NULL);
4748
4749        if(videomodedev == NULL)
4750        {
4751                err("NULL detect");
4752                return NULL;
4753        }
4754
4755        value = readsys(videomodedev, 1);
4756        if(value == NULL)
4757        {
4758                err("NULL detect");
4759                return NULL;
4760        }
4761
4762        return value;
4763}
4764
4765void switchvideomode()
4766{
4767        int rcret = 0;
4768        char* tmpstr = NULL, *tmpstr2 = NULL, *tmpstr3 = NULL;
4769        tmpstr = getvideomode();
4770        struct skin* playpolicy = getscreen("playpolicy");
4771        tmpstr2 = getcolorformat(2);
4772
4773        if(tmpstr != NULL)
4774        {
4775                if((ostrcmp("pal", tmpstr) == 0 || ostrncmp("576", tmpstr, 3) == 0) && ostrncmp("yuv", tmpstr2, 3) == 0)
4776                {
4777                        setvideomode("720p50", 0);
4778                        changefbresolution("720p50", 0);
4779                        changetext(playpolicy, "720p50 (rgb)");
4780                        writevfdmenu("720p50 (rgb)");
4781                        setcolorformat("rgb", 1);
4782                        unlink("/var/etc/.scart");
4783                }
4784                else if((ostrcmp("pal", tmpstr) == 0 || ostrncmp("576", tmpstr, 3) == 0) && ostrncmp("rgb", tmpstr2, 3) == 0)
4785                {
4786                        setvideomode("720p50", 0);
4787                        changefbresolution("720p50", 0);
4788                        changetext(playpolicy, "720p50 (yuv)");
4789                        writevfdmenu("720p50 (yuv)");
4790                        setcolorformat("yuv", 1);
4791                        unlink("/var/etc/.scart");
4792                }
4793                else if(ostrncmp("720", tmpstr, 3) == 0)
4794                {
4795                        setvideomode("1080i50", 0);
4796                        changefbresolution("1080i50", 0);
4797                        tmpstr3 = ostrcat("1080i50 (", tmpstr2, 0, 0);
4798                        tmpstr3 = ostrcat(tmpstr3, ")", 1, 0);
4799                        changetext(playpolicy, tmpstr3);
4800                        writevfdmenu(tmpstr3);
4801                        unlink("/var/etc/.scart");
4802                }
4803                else if(ostrncmp("1080", tmpstr, 4) == 0)
4804                {
4805                        setvideomode("576i50", 0);
4806                        changefbresolution("576i50", 0);
4807                        changetext(playpolicy, "576i50 (rgb)");
4808                        writevfdmenu("576i50 (rgb)");
4809                        setcolorformat("rgb", 1);
4810                        writesys("/var/etc/.scart", "0", 0);
4811                }
4812                /*
4813                int ret = textbox(_("Message"), _("Is this Videomode ok ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 10, 0);
4814                if(ret == 1 || ret == 2)
4815                {
4816                        setvideomode(tmpstr, 0);
4817                        changefbresolution(tmpstr, 0);
4818                }
4819                */
4820                drawscreen(playpolicy, 0, 0);
4821                while(1)
4822                {
4823                        rcret = waitrc(playpolicy, 5000, 0);
4824                        break;
4825                }
4826                clearscreen(playpolicy);
4827        }
4828        free(tmpstr);
4829        free(tmpstr2);
4830        free(tmpstr3);
4831}
4832
4833//flag 0: write videomode to config
4834//flag 1: don't write videomode to config
4835int setvideomode(char* value, int flag)
4836{
4837        char* videomodedev;
4838        int ret = 0;
4839
4840        videomodedev = getconfig("videomodedev", NULL);
4841
4842        if(videomodedev != NULL && value != NULL)
4843        {
4844                debug(100, "set %s to %s", videomodedev, value);
4845                ret = writesys(videomodedev, value, 0);
4846                if(ret == 0 && flag == 0) addconfig("av_videomode", value);
4847                return ret;
4848        }
4849
4850        return 0;
4851}
4852
4853//flag 0 = hdmi
4854//flag 1 = scart
4855int setcolorformat(char* value, int flag)
4856{
4857        char* colorformatdev;
4858        int ret = 0;
4859
4860        colorformatdev = getconfig("colorformatdev", NULL);
4861
4862        if(colorformatdev != NULL && value != NULL)
4863        {
4864                debug(100, "set %s to %s", colorformatdev, value);
4865                ret = writesys(colorformatdev, value, 0);
4866                if(ret == 0)
4867                {
4868                        if(flag == 0)
4869                                addconfig("av_colorformat", value);
4870                        else
4871                                addconfig("av_colorformatscart", value);
4872                }
4873                return ret;
4874        }
4875
4876        return 0;
4877}
4878
4879char* getcolorformat(int line)
4880{
4881        char *colorformatdev = NULL;
4882        char *value = NULL;
4883
4884        colorformatdev = getconfig("colorformatdev", NULL);
4885
4886        if(colorformatdev == NULL)
4887        {
4888                err("NULL detect");
4889                return NULL;
4890        }
4891
4892        value = readsys(colorformatdev, line);
4893        if(value == NULL)
4894        {
4895                err("NULL detect");
4896                return NULL;
4897        }
4898
4899        return value;
4900}
4901
4902int setaudiosource(char* value)
4903{
4904        char* audiosourcedev;
4905        int ret = 1;
4906
4907        audiosourcedev = getconfig("audiosourcedev", NULL);
4908
4909        if(audiosourcedev != NULL && value != NULL)
4910        {
4911                debug(100, "set %s to %s", audiosourcedev, value);
4912                ret = writesys(audiosourcedev, value, 0);
4913                if(ret == 0) addconfig("av_audiosource", value);
4914                return ret;
4915        }
4916
4917        return 0;
4918}
4919
4920char* getaudiosource()
4921{
4922        char *audiosourcedev = NULL;
4923        char *value = NULL;
4924
4925        audiosourcedev = getconfig("audiosourcedev", NULL);
4926
4927        if(audiosourcedev == NULL)
4928        {
4929                err("NULL detect");
4930                return NULL;
4931        }
4932
4933        value = readsys(audiosourcedev, 1);
4934        if(value == NULL)
4935        {
4936                err("NULL detect");
4937                return NULL;
4938        }
4939
4940        return value;
4941}
4942
4943char* getsataswitch()
4944{
4945        char *sataswitchdev = NULL;
4946        char *value = NULL;
4947
4948        sataswitchdev = getconfig("sataswitchdev", NULL);
4949
4950        if(sataswitchdev == NULL)
4951        {
4952                err("NULL detect");
4953                return NULL;
4954        }
4955
4956        value = readsys(sataswitchdev, 1);
4957        if(value == NULL)
4958        {
4959                err("NULL detect");
4960                return NULL;
4961        }
4962
4963        return value;
4964}
4965
4966int setsataswitch(char* value)
4967{
4968        char* sataswitchdev;
4969        int ret = 1;
4970
4971        sataswitchdev = getconfig("sataswitchdev", NULL);
4972
4973        if(sataswitchdev != NULL && value != NULL)
4974        {
4975                debug(100, "set %s to %s", sataswitchdev, value);
4976                ret = writesys(sataswitchdev, value, 0);
4977                return ret;
4978        }
4979
4980        return 0;
4981}
4982
4983int setprogress(int value)
4984{
4985        char *progressdev;
4986
4987        progressdev = getconfig("progressdev", NULL);
4988
4989        if(progressdev != NULL)
4990        {
4991                debug(100, "set %s to %d",progressdev, value);
4992                if(checkbox("DM7020HD") == 1 || checkbox("DM7020HDV2") == 1 || checkbox("DM900") == 1)
4993                        return writesysint(progressdev, value, 1);
4994                else
4995                        return writesysint(progressdev, value, 0);
4996        }
4997
4998        return 0;
4999}
5000
5001int setmute(int value)
5002{
5003        char* mutedev;
5004        int tmpvol, ret = 0;
5005
5006        //don't set mute 2x
5007        if(value == 1 && status.mute == 1) return 0;
5008
5009//      printf("mute value: %d\n", value);
5010
5011        if(value == 2)
5012        {
5013                tmpvol = getvol();
5014                tmpvol = tmpvol * 50 / 100;
5015                status.mute = value;
5016                setvol(tmpvol);
5017        }
5018        else
5019        {
5020                mutedev = getconfig("mutedev", NULL);
5021
5022                if(mutedev != NULL)
5023                {
5024                        debug(100, "set %s to %d", mutedev, value);
5025                        //if(status.volautochangevalue != 0 && value == 0) setvol(getvol());
5026#ifdef MIPSEL
5027                        struct dvbdev *audionode = NULL;
5028                        int openaudio = 0;
5029                        if(status.aktservice != NULL)
5030                        {
5031                                if(status.aktservice->audiodev == NULL)
5032                                {
5033                                        audionode = audioopen(0); //we must open the audio device for set mute in external player
5034                                        openaudio = 1;
5035                                }
5036                                else
5037                                        audionode = status.aktservice->audiodev;
5038                        }
5039                        ret = audiosetmute(audionode, value);
5040                        if(openaudio == 1)
5041                                audioclose(audionode, -1);
5042#else
5043                        ret = writesysint(mutedev, value, 0);
5044#endif
5045
5046                        if(ret == 0) status.mute = value;
5047                        if(status.volautochangevalue != 0 && value == 0) setvol(getvol());
5048//                      if(value == 1)
5049//                      {
5050//                              printf("mute\n");
5051//                              system("amixer -c 1 set HDMI mute &");
5052//                              system("amixer -c 1 set Analog mute &");
5053//                              system("amixer -c 1 set SPDIF mute &");
5054//                              sleep(1);
5055//                      }
5056//                      else
5057//                      {
5058//                              printf("unmute\n");
5059//                              system("amixer -c 1 set HDMI unmute &");
5060//                              system("amixer -c 1 set Analog unmute &");
5061//                              system("amixer -c 1 set SPDIF unmute &");
5062//                      }
5063
5064                        return ret;
5065                }
5066        }
5067        return 0;
5068}
5069
5070int setvol(int value)
5071{
5072        char* voldev;
5073        int ret = 0, tmpvol = value;
5074
5075        voldev = getconfig("voldev", NULL);
5076
5077        if(voldev != NULL)
5078        {
5079                if(value > 100) value = 100;
5080                if(value < 0) value = 0;
5081                if(status.volautochangevalue != 0 && value != 0)
5082                {
5083                        if(status.volautochange == 0)
5084                                value = value - (status.volautochangevalue * value / 100);
5085                }
5086                value = 63 - value * 63 / 100;
5087                debug(100, "set %s to %d", voldev, value);
5088                ret = 0;
5089                if(status.mute == 1)
5090                        status.volmute = value;
5091                else
5092                {
5093                        status.volmute = -1;
5094                        if(file_exist(voldev))
5095                                ret = writesysint(voldev, value, 0);
5096                        else
5097                                ret = 0;
5098#ifdef MIPSEL
5099                        struct dvbdev *audionode = NULL;
5100                        int openaudio = 0;
5101
5102                        if(ret == 0 && status.aktservice != NULL)
5103                        {
5104                                if(status.aktservice->audiodev == NULL)
5105                                {
5106                                        audionode = audioopen(0); //we must open the audio device for change volume in external player
5107                                        openaudio = 1;
5108                                }
5109                                else
5110                                        audionode = status.aktservice->audiodev;
5111
5112                                if(ret == 0 && audionode != NULL)
5113                                        ret = setmixer(audionode, value, value);
5114
5115                                if(ret == 0)
5116                                        status.volume = value;
5117
5118                                if(openaudio == 1)
5119                                        audioclose(audionode, -1);
5120                        }
5121#else
5122                        if(ret == 0 && status.aktservice != NULL)
5123                                ret = setmixer(status.aktservice->audiodev, value, value);
5124#endif
5125                }
5126                if(ret == 0 && status.mute != 2) addconfigint("vol", tmpvol);
5127                return ret;
5128        }
5129
5130        return 0;
5131}
5132
5133int getvol()
5134{
5135        char *voldev = NULL;
5136        char *value = NULL;
5137        int tmpvol = -1;
5138
5139        voldev = getconfig("voldev", NULL);
5140
5141        if(voldev == NULL)
5142        {
5143                err("NULL detect");
5144                return 0;
5145        }
5146        if(status.volmute == -1)
5147        {
5148                if(file_exist(voldev))
5149                        value = readsys(voldev, 1);
5150        }
5151        else
5152                tmpvol = status.volmute;
5153        if((value == NULL && status.volume == -1) && tmpvol == -1)
5154        {
5155                err("NULL detect");
5156                return 0;
5157        }
5158        if(status.volmute == -1)
5159        {
5160                if(file_exist(voldev))
5161                        tmpvol = atoi(value);
5162                else
5163                        tmpvol = status.volume;
5164        }
5165        free(value);
5166        tmpvol = 100 - tmpvol * 100 / 63;
5167        if(status.volautochangevalue != 0)
5168        {
5169                if(status.volautochange == 0 && status.volautochangevalue < 100)
5170                        tmpvol = tmpvol + ((tmpvol * status.volautochangevalue) / (100 - status.volautochangevalue));
5171        }
5172        return tmpvol;
5173}
5174
5175void setdebuglevel()
5176{
5177        debug_level = getconfigint("debuglevel", NULL);
5178        debug(0, "set debug level to %d", debug_level);
5179}
5180
5181char* getxmlentry(char *line, char *searchstr)
5182{
5183        char *buf = NULL, *buf1 = NULL, *buf2 = NULL;
5184
5185        buf = ostrstr(line, searchstr);
5186        if(buf == NULL)
5187                return NULL;
5188
5189        buf = buf + strlen(searchstr);
5190        if(buf[0] == '"')
5191        {
5192                buf = buf + 1;
5193                if(buf[0] == '\\')
5194                {
5195                        buf = buf + 1;
5196                        if(buf[0] == '"')
5197                                buf2 = strchr(buf+1, '"');
5198                        else
5199                                buf2 = strchr(buf, '"');
5200                }
5201                else
5202                        buf2 = strchr(buf, '"');
5203                if(buf2 == NULL)
5204                {
5205                        err("strchr returns NULL");
5206                        return NULL;
5207                }
5208                buf1 = strndup(buf, buf2 - buf);
5209                if(buf1 == NULL)
5210                {
5211                        err("strndup failed");
5212                        return NULL;
5213                }
5214        }
5215        else if(buf[0] == '\'')
5216        {
5217                buf = buf + 1;
5218                buf2 = strchr(buf, '\'');
5219                if(buf2 == NULL)
5220                {
5221                        err("strchr returns NULL");
5222                        return NULL;
5223                }
5224                buf1 = strndup(buf, buf2 - buf);
5225                if(buf1 == NULL)
5226                {
5227                        err("strndup failed");
5228                        return NULL;
5229                }
5230        }
5231        else
5232        {
5233                buf2 = strchr(buf, ' ');
5234                if(buf2 == NULL)
5235                {
5236                        buf2 = ostrstr(buf, "/>");
5237                        if(buf2 == NULL)
5238                        {
5239                                buf2 = strchr(buf, '>');
5240                                if(buf2 == NULL)
5241                                {
5242                                        err("strchr returns NULL");
5243                                        return NULL;
5244                                }
5245                        }
5246                }
5247                buf1 = strndup(buf, buf2 - buf);
5248                if(buf1 == NULL)
5249                {
5250                        err("strndup failed");
5251                        return NULL;
5252                }
5253        }
5254
5255        return buf1;
5256}
5257
5258char* readbintomem(const char* filename, size_t size)
5259{
5260        FILE *fd = NULL;
5261        char *fileline = NULL;
5262
5263        fileline = calloc(1, size + 1);
5264        if(fileline == NULL)
5265        {
5266                err("no mem");
5267                return NULL;
5268        }
5269
5270        fd = fopen(filename, "rb");
5271        if(fd == NULL)
5272        {
5273                perr("can't open %s", filename);
5274                free(fileline);
5275                return NULL;
5276        }
5277
5278        fread(fileline, size, 1, fd);
5279
5280        fclose(fd);
5281        return fileline;
5282}
5283
5284char* readfiletomem(const char* filename, int flag)
5285{
5286        FILE *fd = NULL;
5287        char *fileline = NULL, *buf = NULL, *tmpbuf = NULL;
5288        int bufsize = 0, bufoldsize = 0;
5289
5290        fileline = malloc(MINMALLOC);
5291        if(fileline == NULL)
5292        {
5293                err("no mem");
5294                return NULL;
5295        }
5296
5297        fd = fopen(filename, "r");
5298        if(fd == NULL)
5299        {
5300                perr("can't open %s", filename);
5301                free(fileline);
5302                return NULL;
5303        }
5304
5305        while(fgets(fileline, MINMALLOC, fd) != NULL)
5306        {
5307                if(flag == 1)
5308                        if(fileline[0] == '#' || fileline[0] == '\n')
5309                                continue;
5310
5311                bufoldsize = bufsize;
5312                bufsize += strlen(fileline);
5313                tmpbuf = buf;   buf = realloc(buf, bufsize + 1);
5314                if(buf == NULL)
5315                {
5316                        err("no mem");
5317                        free(fileline);
5318                        free(tmpbuf);
5319                        fclose(fd);
5320                        return NULL;
5321                }
5322
5323                sprintf(buf + bufoldsize, "%s", fileline);
5324        }
5325
5326        free(fileline);
5327        fclose(fd);
5328        return buf;
5329}
5330
5331char* readeittomem(const char* filename)
5332{
5333        unsigned char byte;
5334        FILE *fil = NULL;
5335        char *zeichen = NULL, *buf = NULL, *buf1 = NULL, *tmpbuf1 = NULL;
5336        int buf1size = 0, buf1oldsize = 0;
5337        int Beschreibung;
5338        int len;
5339
5340        zeichen = malloc(255);
5341        if(zeichen == NULL)
5342        {
5343                err("no mem");
5344                return NULL;
5345        }
5346        buf = malloc(255);
5347        if(buf == NULL)
5348        {
5349                free(zeichen);
5350                err("no mem");
5351                return NULL;
5352        }
5353
5354        fil = fopen(filename, "r");
5355        if(fil == NULL)
5356        {
5357                err("can't open %s", filename);
5358                free(zeichen);
5359                free(buf);
5360                return NULL;
5361        }
5362        Beschreibung = 0;
5363        fseek(fil, 12, SEEK_SET); //ersten 12 Byte nicht relevant
5364        while(!feof(fil))
5365        {
5366                byte = fgetc(fil);
5367
5368                if(byte == 0x4D)
5369                {
5370                        fseek(fil, 4,SEEK_CUR);
5371                        byte = fgetc(fil);
5372                        len = byte + 0;
5373                        byte = fgetc(fil);
5374                        fgets(zeichen, len, fil);
5375                        if(byte != 0x05)
5376                                sprintf(buf, "%c%s\n", byte, zeichen);
5377                        else
5378                                sprintf(buf, "%s\n", zeichen);
5379
5380                        buf1oldsize = buf1size;
5381                        buf1size += strlen(buf);
5382                        tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
5383                        if(buf1 == NULL)
5384                        {
5385                                err("no mem");
5386                                free(zeichen);
5387                                free(buf);
5388                                free(tmpbuf1);
5389                                fclose(fil);
5390                                return NULL;
5391                        }
5392                        sprintf(buf1 + buf1oldsize, "%s", buf);
5393
5394                        //printf("T %s\n", zeichen);
5395                        byte = fgetc(fil);
5396                        len = byte + 0;
5397                        byte = fgetc(fil);
5398                        fgets(zeichen, len, fil);
5399                        if(byte != 0x05)
5400                                sprintf(buf,"%c%s\n\n", byte, zeichen);
5401                        else
5402                                sprintf(buf,"%s\n\n", zeichen);
5403
5404                        buf1oldsize = buf1size;
5405                        buf1size += strlen(buf);
5406                        tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
5407                        if(buf1 == NULL)
5408                        {
5409                                err("no mem");
5410                                free(zeichen);
5411                                free(buf);
5412                                free(tmpbuf1);
5413                                fclose(fil);
5414                                return NULL;
5415                        }
5416                        sprintf(buf1 + buf1oldsize, "%s", buf);
5417
5418                }
5419                else if(byte == 0x4E)
5420                {
5421                        fseek(fil, 6, SEEK_CUR);
5422                        byte = fgetc(fil);
5423                        len = byte;
5424                        byte = fgetc(fil);
5425                        fgets(zeichen, len, fil);
5426                        if(Beschreibung == 0)
5427                        {
5428                                if(byte != 0x05)
5429                                        sprintf(buf, "%c%s", byte, zeichen);
5430                                else
5431                                        sprintf(buf, "%s", zeichen);
5432                                Beschreibung = 1;
5433                        }
5434                        else
5435                        {
5436                                if(byte != 0x05)
5437                                        sprintf(buf, "%c%s", byte, zeichen);
5438                                else
5439                                        sprintf(buf, "%s", zeichen);
5440                        }
5441
5442                        buf1oldsize = buf1size;
5443                        buf1size += strlen(buf);
5444                        tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
5445                        if(buf1 == NULL)
5446                        {
5447                                err("no mem");
5448                                free(zeichen);
5449                                free(buf);
5450                                free(tmpbuf1);
5451                                fclose(fil);
5452                                return NULL;
5453                        }
5454                        sprintf(buf1 + buf1oldsize, "%s", buf);
5455
5456                }
5457                else
5458                {
5459                        byte = fgetc(fil);
5460                        len= byte;
5461                        fgets(zeichen, len + 1, fil);
5462                }
5463        }
5464        free(zeichen);
5465        free(buf);
5466        fclose(fil);
5467        return buf1;
5468}
5469
5470char* command(char* input)
5471{
5472        int maxlen = 0, pos = 0;
5473        char* tmpstr = NULL, *fileline = NULL;
5474        FILE *iopipe = NULL;
5475
5476        if(input == NULL) return NULL;
5477
5478        fileline = malloc(MINMALLOC);
5479        if(fileline == NULL)
5480        {
5481                err("no mem");
5482                return NULL;
5483        }
5484
5485        if((iopipe = popen(input, "r")) == NULL)
5486        {
5487                free(fileline);
5488                return NULL;
5489        }
5490
5491        while(!feof(iopipe))
5492        {
5493                if(fgets(fileline, MINMALLOC, iopipe) != NULL)
5494                        ostrcatbig(&tmpstr, fileline, &maxlen, &pos);
5495        }
5496
5497        if(pos > 0)
5498        {
5499                char* tmp = tmpstr;
5500                tmpstr = realloc(tmpstr, pos + 1);
5501                if(tmpstr == NULL)
5502                        tmpstr = tmp;
5503        }
5504
5505        free(fileline);
5506        pclose(iopipe);
5507        return tmpstr;
5508}
5509
5510char* string_tolower(char *str)
5511{
5512/*
5513        char *p1 = str;
5514
5515        if(str == NULL) return NULL;
5516
5517        while(*p1 != '\0')
5518                *p1++ = tolower(*p1);
5519
5520        return str;
5521*/
5522        if(str == NULL) return NULL;
5523
5524        int i=0;
5525        while (str[i])
5526        {
5527                str[i] = tolower(str[i]);
5528                i++;
5529        }
5530        return str;
5531}
5532
5533char* string_toupper(char *str)
5534{
5535/*
5536        char *p1 = str;
5537
5538        if(str == NULL) return NULL;
5539
5540        while(*p1 != '\0')
5541                *p1++ = toupper(*p1);
5542
5543*/
5544        if(str == NULL) return NULL;
5545
5546        int i=0;
5547        while (str[i])
5548        {
5549                str[i] = toupper(str[i]);
5550                i++;
5551        }
5552        return str;
5553}
5554
5555char* stringreplacecharonce(char *str, char c1, char c2)
5556{
5557        char *p1 = str;
5558
5559        if(str == NULL) return NULL;
5560
5561        while(*p1 != '\0')
5562        {
5563                if(*p1 == c1)
5564                {
5565                        *p1 = c2;
5566                        break;
5567                }
5568                p1++;
5569        }
5570
5571        return str;
5572}
5573
5574char* stringreplacechar(char *str, char c1, char c2)
5575{
5576        char *p1 = str;
5577
5578        if(str == NULL) return NULL;
5579
5580        while(*p1 != '\0')
5581        {
5582                if(*p1 == c1) *p1 = c2;
5583                p1++;
5584        }
5585
5586        return str;
5587}
5588
5589
5590char* string_removechar(char *str)
5591{
5592        char *p1 = str;
5593
5594        if(str == NULL) return NULL;
5595
5596        while(*p1 != '\0')
5597        {
5598                if(*p1 == '.') *p1 = ' ';
5599                else if(*p1 == '-') *p1 = ' ';
5600                else if(*p1 == '_') *p1 = ' ';
5601                else if(*p1 == '/') *p1 = ' ';
5602                p1++;
5603        }
5604
5605        return str;
5606}
5607
5608char* string_withchars2return(char *str)
5609{
5610        char *p1 = str;
5611
5612        if(str == NULL) return NULL;
5613
5614        while(*p1 != '\0')
5615        {
5616                if(*p1 == ' ') *p1 = '\n';
5617                p1++;
5618        }
5619
5620        return str;
5621}
5622
5623char* string_remove_whitechars(char *text)
5624{
5625        char *p1 = text, *p2 = text;
5626
5627        if(text == NULL) return NULL;
5628
5629        while(*p1 != '\0')
5630        {
5631                if(*p1 == ' ')
5632                        ++p1;
5633                else
5634                        *p2++ = *p1++;
5635        }
5636        *p2 = '\0';
5637
5638        return text;
5639}
5640
5641char* strstrip(char *text)
5642{
5643        char* tmpstr = text;
5644
5645        if(text == NULL) return NULL;
5646        int len = strlen(text);
5647
5648        while(isspace(tmpstr[len - 1])) tmpstr[--len] = '\0';
5649        while(*tmpstr && isspace(*tmpstr)) ++tmpstr, --len;
5650
5651        if(text != tmpstr) memmove(text, tmpstr, len + 1);
5652
5653        return text;
5654}
5655
5656char* string_strip_whitechars(char *text)
5657{
5658        char *p1 = text, *p2 = text;
5659
5660        if(text == NULL)
5661                return NULL;
5662
5663        while(*p1 != '\0')
5664        {
5665                if(*p1 == ' ' && *(p1 + 1) == ' ')
5666                        ++p1;
5667                else
5668                        *p2++ = *p1++;
5669        }
5670        *p2 = '\0';
5671
5672        return text;
5673}
5674
5675char* string_replace_all(char *search, char *replace, char *string, int free1)
5676{
5677        char* tmpstr = NULL;
5678        char* searchpos = NULL;
5679
5680        if(string == NULL || search == NULL)
5681        {
5682                tmpstr = ostrcat(tmpstr, string, 1, 0);
5683                if(free1 == 1) free(string);
5684                return tmpstr;
5685        }
5686
5687        searchpos = strstr(string, search);
5688        if(searchpos == NULL)
5689        {
5690                tmpstr = ostrcat(tmpstr, string, 1, 0);
5691                if(free1 == 1) free(string);
5692                return tmpstr;
5693        }
5694
5695        int count = 0;
5696        int stringlen = strlen(string);
5697        int searchlen = strlen(search);
5698        int replacelen = strlen(replace);
5699
5700        while(searchpos != NULL)
5701        {
5702                count++;
5703                searchpos = strstr(searchpos + searchlen, search);
5704        }
5705
5706        int len = stringlen - (searchlen * count) + (replacelen * count);
5707        tmpstr = calloc(1, len + 1);
5708        if(tmpstr == NULL)
5709        {
5710                err("no mem");
5711                tmpstr = ostrcat(tmpstr, string, 1, 0);
5712                if(free1 == 1) free(string);
5713                return tmpstr;
5714        }
5715
5716        len = 0;
5717        char* str = string;
5718        char* tmp = tmpstr;
5719        searchpos = strstr(str, search);
5720        while(searchpos != NULL)
5721        {
5722                len = searchpos - str;
5723                memcpy(tmp, str, len);
5724                memcpy(tmp + len, replace, replacelen);
5725                tmp += len + replacelen;
5726                str += len + searchlen;
5727                searchpos = strstr(str, search);
5728        }
5729        memcpy(tmp, str, strlen(str));
5730
5731        if(free1 == 1) free(string);
5732
5733        return tmpstr;
5734}
5735
5736char* string_replace_remove_last_chars(char *search, char *replace, char *string, int free1)
5737{
5738        char* searchpos = NULL;
5739        char* tmpstr = NULL;
5740
5741        if(string == NULL || search == NULL)
5742        {
5743                tmpstr = ostrcat(tmpstr, string, 1, 0);
5744                if(free1 == 1) free(string);
5745                return tmpstr;
5746        }
5747
5748        searchpos = ostrstr(string, search);
5749
5750        if(searchpos == NULL)
5751        {
5752                tmpstr = ostrcat(tmpstr, string, 1, 0);
5753                if(free1 == 1) free(string);
5754                return tmpstr;
5755        }
5756
5757        tmpstr = strndup(string, searchpos - string);
5758        if(replace != NULL)
5759                tmpstr = ostrcat(tmpstr, replace, 1, 0);
5760
5761        if(free1 == 1) free(string);
5762
5763        return tmpstr;
5764}
5765
5766char* string_replace(char *search, char *replace, char *string, int free1)
5767{
5768        char* searchpos = NULL;
5769        char* tmpstr = NULL;
5770
5771        if(string == NULL || search == NULL)
5772        {
5773                tmpstr = ostrcat(tmpstr, string, 1, 0);
5774                if(free1 == 1) free(string);
5775                return tmpstr;
5776        }
5777
5778        searchpos = ostrstr(string, search);
5779
5780        if(searchpos == NULL)
5781        {
5782                tmpstr = ostrcat(tmpstr, string, 1, 0);
5783                if(free1 == 1) free(string);
5784                return tmpstr;
5785        }
5786
5787        tmpstr = strndup(string, searchpos - string);
5788        if(replace != NULL)
5789                tmpstr = ostrcat(tmpstr, replace, 1, 0);
5790        tmpstr = ostrcat(tmpstr, string + (searchpos - string) + strlen(search), 1, 0);
5791
5792        if(free1 == 1) free(string);
5793
5794        return tmpstr;
5795}
5796
5797//flag 0: search full str
5798//flag 1: search only end of string
5799char* ostrrstrcase(char* str, char* search, int len, int flag)
5800{
5801        int slen = 0;
5802        char* tmpstr = NULL;
5803
5804        if(str == NULL || search == NULL) return NULL;
5805
5806        if(len == -1) len = strlen(str);
5807        slen = strlen(search);
5808        if(slen > len) return NULL;
5809
5810        for(tmpstr = str + len - slen; tmpstr >= str; tmpstr--)
5811        {
5812                if(strncasecmp(tmpstr, search, slen) == 0)
5813                        return tmpstr;
5814                if(flag == 1) return NULL;
5815        }
5816
5817        return NULL;
5818}
5819
5820//flag 0: search full str
5821//flag 1: search only end of string
5822char* ostrrstr(char* str, char* search, int len, int flag)
5823{
5824        int slen = 0;
5825        char* tmpstr = NULL;
5826
5827        if(str == NULL || search == NULL) return NULL;
5828
5829        if(len == -1) len = strlen(str);
5830        slen = strlen(search);
5831        if(slen > len) return NULL;
5832
5833        for(tmpstr = str + len - slen; tmpstr >= str; tmpstr--)
5834        {
5835                if(strncmp(tmpstr, search, slen) == 0)
5836                        return tmpstr;
5837                if(flag == 1) return NULL;
5838        }
5839
5840        return NULL;
5841}
5842
5843char* ostrstr(char* str, char* search)
5844{
5845        char* ret = NULL;
5846
5847        if(str == NULL || search == NULL) return NULL;
5848        ret = strstr(str, search);
5849
5850        return ret;
5851}
5852
5853int file_exist(char* filename)
5854{
5855        if(access(filename, F_OK) == 0)
5856                return 1;
5857        else
5858                return 0;
5859}
5860
5861char* string_newline(char* str)
5862{
5863        if(str == NULL) return NULL;
5864
5865        int size = strlen(str);
5866
5867        if(str[size - 1] == '\n')
5868                str[size - 1] = '\0';
5869
5870        return str;
5871}
5872
5873char* string_quote(char* str)
5874{
5875        char* tmpstr = NULL;
5876
5877        tmpstr = ostrcat("\"", str, 0, 0);
5878        tmpstr = ostrcat(tmpstr, "\"", 1, 0);
5879
5880        return tmpstr;
5881}
5882
5883struct splitstr* strsplit(char *str, char *tok, int* count)
5884{
5885        char *tmpstr = NULL;
5886        struct splitstr *array = NULL, *tmparray = NULL;
5887        *count = 0;
5888
5889        if(str == NULL || tok == NULL)
5890                return NULL;
5891
5892        tmpstr = strtok(str, tok);
5893        while(tmpstr != NULL)
5894        {
5895                *count = *count + 1;
5896                tmparray = array; array = (struct splitstr*)realloc(array, sizeof(struct splitstr*) * (*count));
5897                if(array == NULL)
5898                {
5899                        err("no mem");
5900                        free(tmparray);
5901                        return NULL;
5902                }
5903
5904                (&array[(*count) - 1])->part = tmpstr;
5905                tmpstr = strtok(NULL, tok);
5906        }
5907
5908        return array;
5909}
5910
5911char* string_shortname(char *tmpfilename, int mode)
5912{
5913        debug(50, "in %s", tmpfilename);
5914
5915//      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";
5916        char* str = NULL;
5917
5918        if(mode==1)
5919        {
5920                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";
5921                str = ostrcat(str, replacelist, 1, 0);
5922        }
5923        else if(mode==2)
5924        {
5925                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";
5926                str = ostrcat(str, replacelist, 1, 0);
5927        }
5928        else
5929        {
5930                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";
5931                str = ostrcat(str, replacelist, 1, 0);
5932        }
5933
5934        char* replace = NULL;
5935        struct splitstr* ret1 = NULL;
5936        int count = 0;
5937        int i = 0;
5938        ret1 = strsplit(str, " ", &count);
5939        int max = count - 1;
5940        int first = 1;
5941
5942        for(i = 0; i < max; i++)
5943        {
5944                struct splitstr* ret2 = NULL;
5945                int count2 = 0;
5946                int j = 0;
5947                char *tmpstr = NULL;
5948                tmpstr = ostrcat(tmpstr, tmpfilename, 1, 0);
5949                ret2 = strsplit(tmpstr, " ,.-_", &count2);
5950
5951                for(j = 0; j < count2; j++)
5952                {
5953                        if(j > 0)
5954                        {
5955                                if(ostrcmp((&ret1[i])->part, (&ret2[j])->part) == 0)
5956                                {
5957                                        if(mode==1)
5958                                        {
5959                                                tmpfilename = string_replace((&ret2[j])->part, replace, tmpfilename, 1);
5960                                                continue;
5961                                        }
5962                                        else if(mode==2)
5963                                        {
5964                                                tmpfilename = string_replace_remove_last_chars((&ret2[j])->part, replace, tmpfilename, 1);
5965                                                //break;
5966                                                continue;
5967                                        }
5968                                        else
5969                                        {
5970                                                tmpfilename = string_replace((&ret2[j])->part, replace, tmpfilename, 1);
5971                                                continue;
5972                                        }
5973                                }
5974                                else if(first == 1 && mode == 2)
5975                                {
5976//                                      printf("zahl: %s\n", (&ret2[j])->part);
5977                                        int theCharacter = atoi((&ret2[j])->part);
5978                                        if(theCharacter != 0)
5979                                        {
5980//                                              printf("found zahl: %s\n", (&ret2[j])->part);
5981                                                if(theCharacter > 1800 && theCharacter < 2100)
5982                                                {
5983//                                                      printf("found year: %s\n", (&ret2[j])->part);
5984                                                        tmpfilename = string_replace_remove_last_chars((&ret2[j])->part, "", tmpfilename, 1);
5985                                                        break;
5986                                                }
5987                                        }
5988                                }
5989                        }
5990                }
5991                free(ret2); ret2 = NULL;
5992                first = 0;
5993                free(tmpstr), tmpstr = NULL;
5994        }
5995
5996        free(ret1); ret1 = NULL;
5997        free(replace); replace = NULL;
5998        free(str); str = NULL;
5999
6000        debug(50, "out %s", tmpfilename);
6001        return tmpfilename;
6002}
6003
6004char* get_uuid(char* device)
6005{
6006        debug(60, "in %s", device);
6007        char* cmd = NULL, *tmpstr = NULL;
6008
6009        if(device == NULL) return NULL;
6010#ifdef MIPSEL
6011        cmd = ostrcat(cmd, "blkid -w /dev/null -c /dev/null -s UUID /dev/", 1, 0);
6012#else
6013        cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s UUID /dev/", 1, 0);
6014#endif
6015        cmd = ostrcat(cmd, device, 1, 0);
6016        cmd = ostrcat(cmd, " | cut -d'\"' -f2", 1, 0);
6017
6018        tmpstr = string_newline(command(cmd));
6019
6020        if(ostrcmp(string_newline(tmpstr), "") == 0)
6021        {
6022                free(tmpstr); tmpstr = NULL;
6023        }
6024
6025        debug(60, "out %s", cmd);
6026        free(cmd); cmd = NULL;
6027        return tmpstr;
6028}
6029
6030char* get_label(char* device)
6031{
6032        debug(60, "in %s", device);
6033        char* cmd = NULL, *tmpstr = NULL;
6034
6035        if(device == NULL) return NULL;
6036#ifdef MIPSEL
6037        cmd = ostrcat(cmd, "blkid -w /dev/null -c /dev/null -s LABEL /dev/", 1, 0);
6038#else
6039        cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s LABEL /dev/", 1, 0);
6040#endif
6041        cmd = ostrcat(cmd, device, 1, 0);
6042        cmd = ostrcat(cmd, " | cut -d'\"' -f2", 1, 0);
6043
6044        tmpstr = string_newline(command(cmd));
6045
6046        if(tmpstr == NULL)
6047                tmpstr = ostrcat(tmpstr, "NONLABEL", 1, 0);
6048
6049        if(ostrcmp(string_newline(tmpstr), "") == 0)
6050                tmpstr = ostrcat(tmpstr, "NONLABEL", 1, 0);
6051
6052        debug(60, "out %s", cmd);
6053        free(cmd); cmd = NULL;
6054        return tmpstr;
6055}
6056
6057char* get_filesystem(char* device)
6058{
6059        debug(60, "in %s", device);
6060        char* cmd = NULL, *tmpstr = NULL;
6061
6062        if(device == NULL) return NULL;
6063#ifdef MIPSEL
6064        cmd = ostrcat(cmd, "blkid -w /dev/null -c /dev/null -s TYPE /dev/", 1, 0);
6065#else
6066        cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s TYPE /dev/", 1, 0);
6067#endif
6068        cmd = ostrcat(cmd, device, 1, 0);
6069        cmd = ostrcat(cmd, " | cut -d'\"' -f2", 1, 0);
6070
6071        tmpstr = string_newline(command(cmd));
6072
6073        if(tmpstr == NULL)
6074                tmpstr = ostrcat(tmpstr, "NONTYPE", 1, 0);
6075
6076        if(ostrcmp(string_newline(tmpstr), "") == 0)
6077                tmpstr = ostrcat(tmpstr, "NONTYPE", 1, 0);
6078
6079        debug(60, "out %s", cmd);
6080        free(cmd); cmd = NULL;
6081        return tmpstr;
6082}
6083
6084//flag 0: convert ip to 000.000.000.000
6085//flag 1: convert ip to 0.0.0.0
6086char* fixip(char* ipinput, int flag)
6087{
6088        debug(60, "in %s", ipinput);
6089        int ret = 0;
6090        char* ipout = NULL;
6091        unsigned char ip[4];
6092
6093        ip[0] = 0;
6094        ip[1] = 0;
6095        ip[2] = 0;
6096        ip[3] = 0;
6097
6098        if(ipinput == NULL) return NULL;
6099        ret = sscanf(ipinput, "%hhu.%hhu.%hhu.%hhu", &ip[0], &ip[1], &ip[2], &ip[3]);
6100        if(ret != 4) return NULL;
6101
6102        ipout = malloc(16);
6103        if(ipout == NULL)
6104        {
6105                err("no mem");
6106                return NULL;
6107        }
6108
6109        if(flag == 1)
6110                snprintf(ipout, 16, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
6111        else
6112                snprintf(ipout, 16, "%03d.%03d.%03d.%03d", ip[0], ip[1], ip[2], ip[3]);
6113
6114        return ipout;
6115}
6116
6117void setfanspeed(int speed, int aktion)
6118{
6119        char* speedWert = NULL;
6120        char* speedSet = NULL;
6121        int base = 0;
6122
6123        if(checkbox("UFS922") == 1)
6124                base = 100;
6125        else
6126                base = -15;
6127
6128
6129        if(speed < 0)
6130        {
6131                if(speed == -1)
6132                        speedWert = getconfig("fanspeed", NULL);
6133                else
6134                        speedWert = getconfig("fanspeedstandby", NULL);
6135                if(speedWert == NULL)
6136                        speedSet = ostrcat(speedSet, oitoa(base + 70), 1, 1);
6137                else
6138                        speedSet = ostrcat(speedSet, speedWert, 1, 0);
6139        }
6140        else
6141        {
6142                if(speed == 0)
6143                        speedSet = ostrcat(speedSet, oitoa(base + 15), 1, 1);
6144                else if(speed == 25)
6145                        speedSet = ostrcat(speedSet, oitoa(base + 30), 1, 1);
6146                else if(speed == 50)
6147                        speedSet = ostrcat(speedSet, oitoa(base + 45), 1, 1);
6148                else if(speed == 75)
6149                        speedSet = ostrcat(speedSet, oitoa(base + 55), 1, 1);
6150                else
6151                        speedSet = ostrcat(speedSet, oitoa(base + 70), 1, 1);
6152        }
6153
6154        if(checkbox("UFS922") == 1)
6155                writesys("/proc/stb/fan/fan_ctrl", speedSet, 1);
6156        else
6157                writesys("/proc/stb/fp/fan_pwm", speedSet, 1);
6158
6159        if(aktion == 1)
6160                addconfig("fanspeed", speedSet);
6161        else if(aktion == 2)
6162                addconfig("fanspeedstandby", speedSet);
6163
6164        free(speedSet); speedSet=NULL;
6165}
6166
6167void setaktres()
6168{
6169        int m_width = 0;
6170        char* res = NULL;
6171        char* res_akt = NULL;
6172        char* res_sd = NULL;
6173        int count = 1;
6174        int sec = 0;
6175
6176        m_lock(&status.setaktresmutex, 23);
6177
6178        if(status.restimer == NULL)
6179                goto end;
6180
6181        sec = (int)status.restimer->param1;
6182
6183        if(sec > 0)
6184        {
6185                while(status.restimer->aktion == START && count <= (sec * 10))
6186                {
6187                        usleep(100000);
6188                        if(status.restimer->aktion != START)
6189                                goto end;
6190                        count++;
6191                }
6192        }
6193        if(status.restimer->aktion != START) goto end;
6194
6195        if(videoreadqwidth(status.aktservice->videodev) == 0)
6196        {
6197                if(status.restimer->aktion != START) goto end;
6198                m_width = status.videosize.w;
6199                if(m_width == 720)
6200                {
6201                        res_sd = getconfig("av_videomode_autores_sd", NULL);
6202                        if(res_sd == NULL)
6203                                res = ostrcat(res, "576i50", 1, 0);
6204                        else
6205                                res = ostrcat(res, res_sd, 1, 0);
6206                }
6207                else if (m_width == 1280)
6208                        res = ostrcat(res, "720p50", 1, 0);
6209                else if (m_width == 1920)
6210                        res = ostrcat(res, "1080i50", 1, 0);
6211                else
6212                        m_width = 0;
6213
6214                if(m_width > 0)
6215                {
6216                        if(status.restimer->aktion != START) goto end;
6217                        res_akt = getvideomode();
6218                        if(status.restimer->aktion != START) goto end;
6219                        if(ostrcmp(res_akt, res) != 0)
6220                        {
6221                                if(status.restimer->aktion != START) goto end;
6222                                setvideomode(res, 1);
6223                                changefbresolution(res, 1);
6224/*
6225                                if(status.restimer->aktion != START) goto end;
6226
6227                                count = 0;
6228                                while(status.restimer->aktion == START && count < 10)
6229                                {
6230                                        usleep(100000);
6231                                        if(status.restimer->aktion != START)
6232                                                goto end;
6233                                        count++;
6234                                }
6235
6236                                if(status.restimer->aktion != START) goto end;
6237*/
6238                                screenautores(res, 5, 0);
6239                        }
6240                }
6241        }
6242        else
6243        {
6244                if(status.restimer->aktion != START) goto end;
6245                if(status.servicetype == 0)
6246                        textbox(_("Message"), _("ERROR cant read res"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 5, 0);
6247        }
6248
6249end:
6250        free(res); res = NULL;
6251        status.restimer = NULL;
6252        m_unlock(&status.setaktresmutex, 23);
6253        return;
6254}
6255
6256char* gettimestamp()
6257{
6258        char* timestamp = NULL;
6259        struct timeval numtime;
6260
6261        gettimeofday(&numtime, 0);
6262        timestamp = ostrcat(timestamp, olutoa(numtime.tv_sec), 1, 1);
6263        timestamp = ostrcat(timestamp, olutoa(numtime.tv_usec), 1, 1);
6264
6265        return timestamp;
6266}
6267
6268char* string_decode(char* input, int flag)
6269{
6270        if(input == NULL) return input;
6271
6272        while(ostrstr(input, "\\u00") != NULL)
6273        {
6274                debug(210, "input: %s", input);
6275                input = string_replace("\\u00", "%", input, 1);
6276                debug(210, "input: %s", input);
6277        }
6278
6279        while(ostrstr(input, "&amp;") != NULL)
6280        {
6281                debug(210, "input: %s", input);
6282                input = string_replace("&amp;", "und", input, 1);
6283                debug(210, "input: %s", input);
6284        }
6285
6286        while(ostrstr(input, "&gt;") != NULL)
6287        {
6288                debug(210, "input: %s", input);
6289                input = string_replace("&gt;", ">", input, 1);
6290                debug(210, "input: %s", input);
6291        }
6292
6293        while(ostrstr(input, "&lt;") != NULL)
6294        {
6295                debug(210, "input: %s", input);
6296                input = string_replace("&lt;", "<", input, 1);
6297                debug(210, "input: %s", input);
6298        }
6299
6300        while(ostrstr(input, "&quot;") != NULL)
6301        {
6302                debug(210, "input: %s", input);
6303                input = string_replace("&quot;", "\"", input, 1);
6304                debug(210, "input: %s", input);
6305        }
6306
6307        while(ostrstr(input, "&#x") != NULL)
6308        {
6309                debug(210, "out %s", input);
6310                input = string_replace("&#x", "%", input, 1);
6311                debug(210, "input: %s", input);
6312        }
6313
6314        while(ostrstr(input, "&#") != NULL)
6315        {
6316                debug(210, "input: %s", input);
6317                input = string_replace("&#", "%", input, 1);
6318                debug(210, "input: %s", input);
6319        }
6320
6321        if(flag == 1)
6322                htmldecode2(input, input);
6323        else
6324                htmldecode(input, input);
6325
6326        while(ostrstr(input, ";") != NULL)
6327        {
6328                debug(210, "input: %s", input);
6329                input = string_replace(";", NULL, input, 1);
6330                debug(210, "input: %s", input);
6331        }
6332
6333        return input;
6334}
6335
6336char* string_deltags(char* str)
6337{
6338        int i = 0, y = 0, len = 0;
6339
6340        if(str == NULL) return 0;
6341
6342        len = strlen(str);
6343
6344        int skip = 0;
6345        for(i = 0; i < len; i++)
6346        {
6347                if(str[i] == '<')
6348                        skip = 1;
6349                else if(str[i] == '>')
6350                        skip = 0;
6351
6352                if(skip == 0 && str[i] != '>')
6353                {
6354                        str[y] = str[i];
6355                        y++;
6356                }
6357        }
6358        str[y] = '\0';
6359
6360        return str;
6361}
6362
6363char* string_striptags(char* str)
6364{
6365        int i = 0, len = 0;
6366
6367        if(str == NULL) return 0;
6368
6369        len = strlen(str);
6370
6371        int skip = 0;
6372        for(i = 0; i < len; i++)
6373        {
6374                if(str[i] == '<')
6375                        skip = 1;
6376                else if(str[i] == '>')
6377                {
6378                        skip = 0;
6379                        str[i] = ' ';
6380                }
6381                if(skip == 1)
6382                        str[i] = ' ';
6383        }
6384
6385        return strstrip(str);
6386}
6387
6388char* string_resub(char* str, char* str2, char* input, int dir)
6389{
6390        char* tmpstr = NULL, *pos = NULL, *pos2 = NULL;
6391
6392        if(str == NULL || str2 == NULL || input == NULL) return NULL;
6393
6394        if(dir == 0)
6395        {
6396                pos = ostrstr(input, str);
6397                if(pos == NULL) return NULL;
6398                pos += strlen(str);
6399
6400                pos2 = ostrstr(pos, str2);
6401                if(pos2 == NULL) return NULL;
6402        }
6403        else
6404        {
6405                pos2 = ostrstr(input, str2);
6406                if(pos2 == NULL) return NULL;
6407
6408                pos = ostrrstr(input, str, pos2 - input, 0);
6409                if(pos == NULL) return NULL;
6410                pos += strlen(str);
6411        }
6412
6413        tmpstr = strndup(pos, pos2 - pos);
6414
6415        return strstrip(tmpstr);
6416}
6417
6418char* ostrstrcase(char* str, char* sub)
6419{
6420        size_t len = 0;
6421
6422        if(str == NULL || sub == NULL) return NULL;
6423
6424        len = strlen(sub);
6425        while(*str)
6426        {
6427                if(toupper(*str) == toupper(*sub) && strncasecmp(str, sub, len) == 0)
6428                        return str;
6429                ++str;
6430        }
6431        return NULL;
6432}
6433
6434//flag 0: convert port to 00021
6435//flag 1: convert port to 21
6436char* fixport(char* input, int flag)
6437{
6438        char* tmpstr = NULL;
6439
6440        if(flag == 0)
6441        {
6442                int plen = strlen(input);
6443                if(plen < 5)
6444                {
6445                        int i;
6446                        for(i = 0; i < 5 - plen; i++)
6447                                tmpstr = ostrcat(tmpstr, "0", 1, 0);
6448                }
6449                tmpstr = ostrcat(tmpstr, input, 1, 0);
6450        }
6451        else
6452        {
6453                while (*input && *input == '0')
6454                input++;
6455
6456                tmpstr = ostrcat(tmpstr, input, 1, 0);
6457        }
6458        return tmpstr;
6459}
6460
6461//flag 0: Mon > Montag
6462//flag 1: Mon > Mon
6463//flag 2: Monday > Montag
6464//flag 3: January > Januar
6465char* translate_time(char* input, int flag)
6466{
6467        char* tmpstr = NULL;
6468        if(input == NULL) return tmpstr;
6469        tmpstr = ostrcat(tmpstr, input, 1, 1);
6470
6471        if(flag == 0)
6472        {
6473                tmpstr = string_replace_all("Mon", _("Monday"), tmpstr, 1);
6474                tmpstr = string_replace_all("Tue", _("Tuesday"), tmpstr, 1);
6475                tmpstr = string_replace_all("Wed", _("Wednesday"), tmpstr, 1);
6476                tmpstr = string_replace_all("Thu", _("Thursday"), tmpstr, 1);
6477                tmpstr = string_replace_all("Fri", _("Friday"), tmpstr, 1);
6478                tmpstr = string_replace_all("Sat", _("Saturday"), tmpstr, 1);
6479                tmpstr = string_replace_all("Sun", _("Sunday"), tmpstr, 1);
6480        }
6481        else if(flag == 2)
6482        {
6483                tmpstr = string_replace_all("Monday", _("Monday"), tmpstr, 1);
6484                tmpstr = string_replace_all("Tuesday", _("Tuesday"), tmpstr, 1);
6485                tmpstr = string_replace_all("Wednesday", _("Wednesday"), tmpstr, 1);
6486                tmpstr = string_replace_all("Thursday", _("Thursday"), tmpstr, 1);
6487                tmpstr = string_replace_all("Friday", _("Friday"), tmpstr, 1);
6488                tmpstr = string_replace_all("Saturday", _("Saturday"), tmpstr, 1);
6489                tmpstr = string_replace_all("Sunday", _("Sunday"), tmpstr, 1);
6490        }
6491        else if(flag == 3)
6492        {
6493                tmpstr = string_replace_all("January", _("January"), tmpstr, 1);
6494                tmpstr = string_replace_all("February", _("February"), tmpstr, 1);
6495                tmpstr = string_replace_all("March", _("March"), tmpstr, 1);
6496                tmpstr = string_replace_all("April", _("April"), tmpstr, 1);
6497                tmpstr = string_replace_all("May", _("May"), tmpstr, 1);
6498                tmpstr = string_replace_all("June", _("June"), tmpstr, 1);
6499                tmpstr = string_replace_all("July", _("July"), tmpstr, 1);
6500                tmpstr = string_replace_all("August", _("August"), tmpstr, 1);
6501                tmpstr = string_replace_all("September", _("September"), tmpstr, 1);
6502                tmpstr = string_replace_all("October", _("October"), tmpstr, 1);
6503                tmpstr = string_replace_all("November", _("November"), tmpstr, 1);
6504                tmpstr = string_replace_all("December", _("December"), tmpstr, 1);
6505        }
6506        else
6507        {
6508                tmpstr = string_replace("Mon", _("Mon"), tmpstr, 1);
6509                tmpstr = string_replace("Tue", _("Tue"), tmpstr, 1);
6510                tmpstr = string_replace("Wed", _("Wed"), tmpstr, 1);
6511                tmpstr = string_replace("Thu", _("Thu"), tmpstr, 1);
6512                tmpstr = string_replace("Fri", _("Fri"), tmpstr, 1);
6513                tmpstr = string_replace("Sat", _("Sat"), tmpstr, 1);
6514                tmpstr = string_replace("Sun", _("Sun"), tmpstr, 1);
6515        }
6516
6517        return tmpstr;
6518}
6519
6520char* gethypridtunerchoices(int dev)
6521{
6522        char *value = NULL;
6523        char *hypridtunerchoices = NULL;
6524        char *tmpstr = NULL;
6525        char *tmpstr1 = NULL;
6526        char* start = NULL;
6527
6528#ifdef MIPSEL
6529        char *tmpstr2 = NULL;
6530        char *tmpstr3 = NULL;
6531#endif
6532
6533
6534        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
6535
6536        if(hypridtunerchoices == NULL)
6537        {
6538                err("NULL detect");
6539                return NULL;
6540        }
6541
6542        tmpstr = readfiletomem(hypridtunerchoices, 1);
6543        if(tmpstr == NULL)
6544        {
6545                err("NULL detect");
6546                return NULL;
6547        }
6548
6549        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
6550        start = ostrcat(start, ":", 1, 0);
6551
6552#ifdef MIPSEL
6553
6554        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
6555        tmpstr2 = string_resub("Mode ", ":", tmpstr1, 0);
6556        tmpstr3 = oregex(".*Mode ([0-9]{1}):.*", tmpstr1);
6557
6558        if(tmpstr2 != NULL)
6559                value = ostrcat(tmpstr2, "\n", 0, 0);
6560        if(tmpstr3 != NULL)
6561                value = ostrcat(value, tmpstr3, 1, 0);
6562
6563        free(start), start = NULL;
6564        free(tmpstr), tmpstr = NULL;
6565        free(tmpstr1), tmpstr1 = NULL;
6566        free(tmpstr2), tmpstr2 = NULL;
6567        free(tmpstr3), tmpstr3 = NULL;
6568#else
6569        tmpstr1 = string_resub(start, "Frontend_Device", tmpstr, 0);
6570        free(start), start = NULL;
6571
6572        printf("---gethypridtunerchoices--------------------------------\n");
6573        printf("tmpstr1: %s\n", tmpstr1);
6574
6575        if(ostrstr(tmpstr1, "(T/C)") != NULL)
6576        {
6577                value = ostrcat("t", "\n", 0, 0);
6578                value = ostrcat(value, "c", 1, 0);
6579        }
6580        printf("value: %s\n", value);
6581        printf("---gethypridtunerchoices--------------------------------\n");
6582
6583        free(tmpstr1), tmpstr1 = NULL;
6584#endif
6585        return value;
6586}
6587
6588char* gethypridtunerchoicesvalue(int dev)
6589{
6590        char* hypridtunerchoices = NULL, *value = NULL, *tmpstr = NULL, *tmpstr1 = NULL, *start = NULL;
6591
6592#ifdef MIPSEL
6593        char* tmpstr2 = NULL, *hypridlist = NULL;
6594#endif
6595
6596        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
6597
6598        if(hypridtunerchoices == NULL)
6599        {
6600                err("NULL detect");
6601                return NULL;
6602        }
6603
6604        tmpstr = readfiletomem(hypridtunerchoices, 1);
6605        if(tmpstr == NULL)
6606        {
6607                err("NULL detect");
6608                return NULL;
6609        }
6610
6611        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
6612        start = ostrcat(start, ":", 1, 0);
6613#ifdef MIPSEL
6614        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
6615        free(start), start = NULL;
6616
6617        hypridlist = gethypridtunerchoices(dev);
6618
6619        int count = 0;
6620        int i = 0;
6621        struct splitstr* ret1 = NULL;
6622        ret1 = strsplit(hypridlist, "\n", &count);
6623
6624        if(ret1 != NULL)
6625        {
6626                int max = count;
6627                for(i = 0; i < max; i++)
6628                {
6629                        start = ostrcat("Mode ", ret1[i].part, 0, 0);
6630                        start = ostrcat(start, ":", 1, 0);
6631                        tmpstr2 = string_resub(start, "\n", tmpstr1, 0);
6632
6633                        if(i > 0)
6634                                value = ostrcat(value, "\n", 1, 0);
6635
6636                        if(tmpstr2 != NULL)
6637                                value = ostrcat(value, tmpstr2, 1, 0);
6638
6639                        free(tmpstr2), tmpstr2 = NULL;
6640                        free(start), start = NULL;
6641                }
6642        }
6643        free(ret1), ret1 = NULL;
6644        free(tmpstr1), tmpstr1 = NULL;
6645        free(hypridlist), hypridlist = NULL;
6646#else
6647        tmpstr1 = string_resub(start, "Frontend_Device", tmpstr, 0);
6648        free(start), start = NULL;
6649
6650        printf("---gethypridtunerchoicesvalue--------------------------------\n");
6651        printf("tmpstr1: %s\n", tmpstr1);
6652
6653        if(ostrstr(tmpstr1, "(T/C)") != NULL)
6654        {
6655                value = ostrcat("DVB-T", "\n", 0, 0);
6656                value = ostrcat(value, "DVB-C", 1, 0);
6657        }
6658        printf("value: %s\n", value);
6659        printf("---gethypridtunerchoicesvalue--------------------------------\n");
6660        free(tmpstr1), tmpstr1 = NULL;
6661#endif
6662
6663        return value;
6664}
6665
6666char* gethypridtunerchoicesvaluename(int dev, char* hyprid)
6667{
6668
6669        char* value = NULL;
6670#ifdef MIPSEL
6671        char* hypridtunerchoices = NULL, *tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL, *start = NULL;
6672
6673        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
6674
6675        if(hypridtunerchoices == NULL)
6676        {
6677                err("NULL detect");
6678                return NULL;
6679        }
6680
6681        tmpstr = readfiletomem(hypridtunerchoices, 1);
6682        if(tmpstr == NULL)
6683        {
6684                err("NULL detect");
6685                return NULL;
6686        }
6687
6688        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
6689        start = ostrcat(start, ":", 1, 0);
6690        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
6691        free(start), start = NULL;
6692
6693        start = ostrcat("Mode ", hyprid, 0, 0);
6694        start = ostrcat(start, ":", 1, 0);
6695
6696        tmpstr2 = string_resub(start, "\n", tmpstr1, 0);
6697
6698        if(tmpstr2 != NULL)
6699                value = ostrcat(value, tmpstr2, 1, 0);
6700
6701        free(tmpstr1), tmpstr1 = NULL;
6702        free(tmpstr2), tmpstr2 = NULL;
6703        free(start), start = NULL;
6704#else
6705        printf("---gethypridtunerchoicesvalue--------------------------------\n");
6706        if(ostrstr(hyprid, "t") != NULL)
6707                value = ostrcat("DVB-T", NULL, 0, 0);
6708        else if(ostrstr(hyprid, "c") != NULL)
6709                value = ostrcat("DVB-C", NULL, 0, 0);
6710        printf("value: %s\n", value);
6711        printf("---gethypridtunerchoicesvalue--------------------------------\n");
6712
6713#endif
6714        return value;
6715}
6716
6717#ifdef MIPSEL
6718int sethypridtunernew(struct dvbdev* tuner, char* value)
6719{
6720        int ret = 0;
6721
6722        char* buf = NULL, *hypridtuner = NULL, *tmpstr = NULL;
6723        char* buf1 = NULL;
6724
6725        hypridtuner = getconfig("hypridtuner", NULL);
6726
6727        if(hypridtuner != NULL)
6728        {
6729                buf = malloc(MINMALLOC);
6730                if(buf == NULL)
6731                {
6732                        err("no memory");
6733                        return 0;
6734                }
6735        }
6736
6737        sprintf(buf, hypridtuner, tuner->devnr);
6738        if(buf != NULL)
6739        {
6740                printf("set %s to %s\n", buf, value);
6741                if(file_exist(buf))
6742                {
6743                        buf1 = readsys("/sys/module/dvb_core/parameters/dvb_shutdown_timeout",1);
6744                        ret = writesys("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "0", 1);
6745                        if(ret != 0)
6746                                printf("no /sys/module/dvb_core/parameters/dvb_shutdown_timeout available\n");
6747                        if(tuner->fd > -1)
6748                        {
6749                                feclose(tuner, -1);
6750                                printf("set %s to %s\n", buf, value);
6751                                ret = writesys(buf, value, 0);
6752                                tuner->fd = feopen(tuner, NULL);
6753                        }
6754                        else
6755                        {
6756                                printf("set %s to %s\n", buf, value);
6757                                ret = writesys(buf, value, 0);
6758                        }
6759                        writesys("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", buf1, 1);     
6760                        free(tmpstr); tmpstr = NULL;
6761                        free(buf1); buf1 = NULL;
6762                }
6763                else
6764                {
6765                        return 0;
6766                }
6767        }
6768        free(buf); buf = NULL;
6769
6770        return 0;
6771}
6772#endif
6773
6774int sethypridtuner(int dev, char* value)
6775{
6776        int ret = 0;
6777
6778#ifdef MIPSEL
6779        char* buf = NULL, *hypridtuner = NULL, *tmpstr = NULL;
6780
6781        hypridtuner = getconfig("hypridtuner", NULL);
6782
6783        if(hypridtuner != NULL)
6784        {
6785                buf = malloc(MINMALLOC);
6786                if(buf == NULL)
6787                {
6788                        err("no memory");
6789                        return 0;
6790                }
6791        }
6792
6793        sprintf(buf, hypridtuner, dev);
6794        if(buf != NULL)
6795        {
6796                printf("set %s to %s\n", buf, value);
6797                ret = writesys(buf, value, 0);
6798                free(tmpstr); tmpstr = NULL;
6799                return ret;
6800        }
6801#else
6802        printf("---sethypridtuner--------------------------------\n");
6803
6804        addconfigtmp("hypridtuner", value);
6805        ret = writeconfigtmp();
6806        writeallconfig(1);
6807
6808        printf("value: %s\n", value);
6809        printf("read titan.cfg: hypridtuner=%s\n", getconfig("frontenddev", NULL));
6810        printf("---sethypridtuner--------------------------------\n");
6811
6812        return ret;
6813#endif
6814        return 0;
6815}
6816
6817int phpkit_userauth(char* link, char* user, char* pass)
6818{
6819        debug(99, "phpkit user: %s", user);
6820        debug(99, "phpkit pass: %s", pass);
6821        debug(99, "phpkit url: %s", link);
6822
6823        int skip = 0;
6824        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;
6825
6826        tmplink = ostrcat(link, NULL, 0, 0);
6827
6828        tmphost = string_replace("http://", "", tmplink, 0);
6829        free(tmplink) , tmplink = NULL;
6830
6831        if(tmphost != NULL)
6832                pos = strchr(tmphost, '/');
6833        if(pos != NULL)
6834        {
6835                pos[0] = '\0';
6836                path = pos + 1;
6837        }
6838
6839        tmppath = ostrcat("/", path, 0, 0);
6840
6841        send = ostrcat(send, "GET ", 1, 0);
6842        send = ostrcat(send, tmppath, 1, 0);
6843        send = ostrcat(send, " HTTP/1.1\r\nHost: ", 1, 0);
6844        send = ostrcat(send, tmphost, 1, 0);
6845        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);
6846        debug(99, "#############################################################################################################");
6847        debug(99, "send1: %s", send);
6848        debug(99, "#############################################################################################################");
6849
6850        tmpstr = gethttpreal(tmphost, tmppath, 80, NULL, NULL, NULL, 0, send, NULL, 5000, 1);
6851        debug(99, "tmpstr: %s", tmpstr);
6852
6853        free(send), send = NULL;
6854        free(tmpstr), tmpstr = NULL;
6855
6856        if(user == NULL || pass == NULL || link == NULL) return 1;
6857
6858        hash = ostrcat("login=1&user=", user, 0, 0);
6859        hash = ostrcat(hash, "&userpw=", 1, 0);
6860        hash = ostrcat(hash, pass, 1, 1);
6861        hashlen = oitoa(strlen(hash));
6862
6863        send = ostrcat(send, "POST ", 1, 0);
6864        send = ostrcat(send, tmppath, 1, 0);
6865        send = ostrcat(send, " HTTP/1.1\r\nContent-Length: ", 1, 0);
6866        send = ostrcat(send, hashlen, 1, 0);
6867        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);
6868        send = ostrcat(send, tmphost, 1, 0);
6869        send = ostrcat(send, "\r\nCookie: pageredir=", 1, 0);
6870        send = ostrcat(send, cookie1, 1, 0);
6871        send = ostrcat(send, "; PHPSESSID=", 1, 0);
6872        send = ostrcat(send, cookie2, 1, 0);
6873        send = ostrcat(send, "\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\n", 1, 0);
6874        send = ostrcat(send, hash, 1, 0);
6875        free(hash); hash = NULL;
6876        free(hashlen); hashlen = NULL;
6877
6878        debug(99, "#############################################################################################################");
6879        debug(99, "send1: %s", send);
6880        debug(99, "#############################################################################################################");
6881
6882        tmpstr = gethttpreal(tmphost, tmppath, 80, NULL, NULL, NULL, 0, send, NULL, 5000, 1);
6883        debug(99, "tmpstr: %s", tmpstr);
6884
6885        free(cookie1); cookie1 = NULL;
6886        free(cookie2); cookie2 = NULL;
6887        free(tmphost); tmphost = NULL;
6888        free(send); send = NULL;
6889        free(ip); ip = NULL;
6890        if(tmpstr == NULL) skip = 1;
6891        free(tmpstr); tmpstr = NULL;
6892        if(skip == 1) return 1;
6893        return 0;
6894}
6895
6896void changetunername(struct skin* tunernode, int adapter, int devnr, char* name, char* fehyprid)
6897{
6898        char* tmpnr = NULL, *tmpstr = NULL;
6899        tmpnr = oitoa(adapter);
6900        tmpstr = ostrcat(_("Tuner "), tmpnr, 0, 1);
6901        tmpstr = ostrcat(tmpstr, "/", 1, 0);
6902        tmpnr = oitoa(devnr);
6903        tmpstr = ostrcat(tmpstr, tmpnr, 1, 1);
6904        tmpstr = ostrcat(tmpstr, ": ", 1, 0);
6905        tmpstr = ostrcat(tmpstr, name, 1, 0);
6906        if(fehyprid != NULL)
6907        {
6908                tmpstr = ostrcat(tmpstr, " (", 1, 0);
6909                tmpstr = ostrcat(tmpstr, _("Multituner adjustable"), 1, 0);
6910                tmpstr = ostrcat(tmpstr, ")", 1, 0);
6911        }
6912        changetext(tunernode, tmpstr);
6913        free(tmpstr); tmpstr = NULL;
6914}
6915
6916char* gethypridtunername(int dev, char* hyprid)
6917{
6918        char* hypridtunerchoices = NULL, *value = NULL, *tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL, *start = NULL;
6919
6920        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
6921
6922        if(hypridtunerchoices == NULL)
6923        {
6924                err("NULL detect");
6925                return NULL;
6926        }
6927
6928        tmpstr = readfiletomem(hypridtunerchoices, 1);
6929        if(tmpstr == NULL)
6930        {
6931                err("NULL detect");
6932                return NULL;
6933        }
6934
6935        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
6936        start = ostrcat(start, ":", 1, 0);
6937        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
6938        free(start), start = NULL;
6939
6940        tmpstr2 = string_resub("Name: ", "\n", tmpstr1, 0);
6941
6942        if(tmpstr2 != NULL)
6943                value = ostrcat(value, tmpstr2, 1, 0);
6944
6945        free(tmpstr1), tmpstr1 = NULL;
6946        free(tmpstr2), tmpstr2 = NULL;
6947        free(start), start = NULL;
6948
6949        return value;
6950}
6951
6952void convertsettings()
6953{
6954        struct menulist* mlist = NULL, *mbox = NULL;
6955        struct skin* load = getscreen("loading");
6956        int flag = 0, ret = 0;
6957        char* tmpstr = NULL;
6958
6959        addmenulist(&mlist, "Create Satellites/Provider (Sat)", _("Create Satellites/Provider (Sat)"), NULL, 0, 0);
6960        addmenulist(&mlist, "Create Satellites/Provider (Cable)", _("Create Satellites/Provider (Cable)"), NULL, 0, 0);
6961        addmenulist(&mlist, "Create Satellites/Provider (Terrestrial)", _("Create Satellites/Provider (Terrestrial)"), NULL, 0, 0);
6962        addmenulist(&mlist, "Create Satellites/Provider (All)", _("Create Satellites/Provider (All)"), NULL, 0, 0);
6963
6964        mbox = menulistbox(mlist, "createsettings", _("Import mode"), NULL, NULL, NULL, 1, 0);
6965        if(mbox != NULL) tmpstr = mbox->name;
6966
6967        if(ostrcmp(tmpstr, "Create Satellites/Provider (Sat)") == 0)
6968                flag = 0;
6969        else if(ostrcmp(tmpstr, "Create Satellites/Provider (Cable)") == 0)
6970                flag = 1;
6971        else if(ostrcmp(tmpstr, "Create Satellites/Provider (Terrestrial)") == 0)
6972                flag = 2;
6973        else if(ostrcmp(tmpstr, "Create Satellites/Provider (All)") == 0)
6974                flag = 3;
6975        else
6976        {
6977                freemenulist(mlist, 1); mlist = NULL;
6978                return;
6979        }
6980
6981        freemenulist(mlist, 1); mlist = NULL;
6982
6983        drawscreen(load, 0, 0);
6984
6985        if(flag == 0)
6986        {
6987                ret = converte2settings(0);
6988                if(ret == 0) return;
6989                system("cp -a /tmp/satellites.sat /mnt/settings/satellites");
6990                system("cp -a /tmp/transponder.sat /mnt/settings/transponder");
6991        }
6992        else if(flag == 1)
6993        {
6994                ret = converte2settings(1);
6995                if(ret == 0) return;
6996                system("cp -a /tmp/satellites.cable /mnt/settings/satellites");
6997                system("cp -a /tmp/transponder.cable /mnt/settings/transponder");
6998        }
6999        else if(flag == 2)
7000        {
7001                converte2settings(2);
7002                system("cp -a /tmp/satellites.ter /mnt/settings/satellites");
7003                system("cp -a /tmp/transponder.ter /mnt/settings/transponder");
7004        }
7005        else if(flag == 3)
7006        {
7007                ret = converte2settings(0);
7008                if(ret == 0) return;
7009                ret = converte2settings(1);
7010                if(ret == 0) return;
7011                ret = converte2settings(2);
7012                if(ret == 0) return;
7013                system("cp -a /tmp/satellites.sat /mnt/settings/satellites");
7014                system("cp -a /tmp/transponder.sat /mnt/settings/transponder");
7015
7016                system("cat /tmp/satellites.cable >> /mnt/settings/satellites");
7017                system("cat /tmp/transponder.cable >> /mnt/settings/transponder");
7018
7019                system("cat /tmp/satellites.ter >> /mnt/settings/satellites");
7020                system("cat /tmp/transponder.ter >> /mnt/settings/transponder");
7021        }
7022
7023//      free(tmpstr), tmpstr = NULL;
7024        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);
7025        //sync usb
7026        system("sync");
7027        //enable autoscan after guirestart
7028        addconfig("autoscan", "1");
7029        //write only config file
7030        writeallconfig(3);
7031        //gui restart and write no config
7032        oshutdown(3, 2);
7033}
7034
7035// flag 0 = sat
7036// flag 1 = cable
7037// flag 2 = ter
7038int converte2settings(int flag)
7039{
7040        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;
7041        int incount = 0;
7042
7043        if(flag == 0)
7044        {
7045                system("rm -rf /tmp/transponder.sat");
7046                system("rm -rf /tmp/satellites.sat");
7047                system("cp -a /var/etc/tuxbox/satellites.xml /tmp/satellites.xml");
7048                start = ostrcat("<sat ", NULL, 0, 0);
7049                end = ostrcat("</sat>", NULL, 0, 0);
7050                filename = ostrcat("/tmp/satellites.xml", NULL, 0, 0);
7051                path = ostrcat("/transponder/satellites.xml", NULL, 0, 0);
7052                transponderfile = ostrcat("/tmp/transponder.sat", NULL, 0, 0);
7053                satfile = ostrcat("/tmp/satellites.sat", NULL, 0, 0);
7054                fetype = ostrcat("0", NULL, 0, 0);
7055        }
7056        else if(flag == 1)
7057        {
7058                system("rm -rf /tmp/transponder.cable");
7059                system("rm -rf /tmp/satellites.cable");
7060                system("cp -a /var/etc/tuxbox/cables.xml /tmp/cables.xml");
7061                start = ostrcat("<cable ", NULL, 0, 0);
7062                end = ostrcat("</cable>", NULL, 0, 0);
7063                filename = ostrcat("/tmp/cables.xml", NULL, 0, 0);
7064                path = ostrcat("/transponder/cables.xml", NULL, 0, 0);
7065                transponderfile = ostrcat("/tmp/transponder.cable", NULL, 0, 0);
7066                satfile = ostrcat("/tmp/satellites.cable", NULL, 0, 0);
7067                fetype = ostrcat("1", NULL, 0, 0);
7068                incount = 4999;
7069        }
7070        else if(flag == 2)
7071        {
7072                system("rm -rf /tmp/transponder.ter");
7073                system("rm -rf /tmp/satellites.ter");
7074                system("cp -a /var/etc/tuxbox/terrestrial.xml /tmp/terrestrial.xml");
7075                start = ostrcat("<terrestrial ", NULL, 0, 0);
7076                end = ostrcat("</terrestrial>", NULL, 0, 0);
7077                filename = ostrcat("/tmp/terrestrial.xml", NULL, 0, 0);
7078                path = ostrcat("/transponder/terrestrial.xml", NULL, 0, 0);
7079                transponderfile = ostrcat("/tmp/transponder.ter", NULL, 0, 0);
7080                satfile = ostrcat("/tmp/satellites.ter", NULL, 0, 0);
7081                fetype = ostrcat("2", NULL, 0, 0);
7082                incount = 9999;
7083        }
7084
7085        if(!file_exist(filename))
7086                gethttp("atemio.dyndns.tv", path, 80, filename, HTTPAUTH, 5000, NULL, 0);
7087
7088        char* tmptext = NULL;
7089        tmptext = ostrcat(_("Error: Transponder Source file not found"), "\nfilename: ", 0, 0);
7090        tmptext = ostrcat(tmptext, transponderfile, 1, 0);
7091
7092        if(!file_exist(filename))
7093        {
7094                textbox(_("Message"), tmptext, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 0, 0);
7095                free(tmptext), tmptext = NULL;
7096                free(path), path = NULL;
7097                free(filename), filename = NULL;
7098                free(satfile), satfile = NULL;
7099                free(fetype), fetype = NULL;
7100                free(start), start = NULL;
7101                free(end), end = NULL;
7102                free(transponderfile), transponderfile = NULL;
7103                return 0;
7104        }
7105        free(tmptext), tmptext = NULL;
7106
7107        buf = readfiletomem(filename, 1);
7108        if(buf == NULL)
7109        {
7110                printf("buf: %s\n", buf);
7111                tmptext = ostrcat(_("Error: Transponder Source file no data"), "\nfilename: ", 0, 0);
7112                tmptext = ostrcat(tmptext, transponderfile, 1, 0);
7113                textbox(_("Message"), tmptext, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 0, 0);
7114                free(tmptext), tmptext = NULL;
7115                free(path), path = NULL;
7116                free(filename), filename = NULL;
7117                free(satfile), satfile = NULL;
7118                free(fetype), fetype = NULL;
7119                free(start), start = NULL;
7120                free(end), end = NULL;
7121                free(transponderfile), transponderfile = NULL;
7122                return 0;
7123        }
7124
7125//      writesys("/tmp/convert.log", buf, 1);
7126
7127        while(ostrstr(buf, start) != NULL)
7128        {
7129                incount++;
7130                tmpstr = string_resub(start, end, buf, 0);
7131                tmpstr1 = ostrcat(tmpstr, NULL, 0, 0);
7132
7133                //printf("name: %s\n", getxmlentry(ret1[i].part, "name="));
7134                //printf("position: %s\n", getxmlentry(ret1[i].part, "position="));
7135
7136                name = getxmlentry(tmpstr, "name=");
7137                if(flag == 0)
7138                        orbitalpos = getxmlentry(tmpstr, "position=");
7139                else
7140                        orbitalpos = ostrcat(oitoa(incount), NULL, 1, 0);
7141
7142                flags = getxmlentry(tmpstr, "flags=");
7143                //string_decode(name, 0);
7144                name = string_replace_all("&amp;", "und", name, 1);
7145
7146                line = ostrcat(line, name, 1, 0); //name
7147                line = ostrcat(line, "#", 1, 0);
7148//              line = ostrcat(line, flags, 1, 0); //flag
7149// 0 for all sat/ter/cab ???
7150                line = ostrcat(line, "0", 1, 0);
7151                line = ostrcat(line, "#", 1, 0);
7152                line = ostrcat(line, orbitalpos, 1, 0); //orbitalpos
7153                line = ostrcat(line, "#", 1, 0);
7154                line = ostrcat(line, fetype, 1, 0); //fetype
7155                printf("%s: %s\n", satfile, line);
7156                writesys(satfile, line, 3);
7157                free(line), line = NULL;
7158
7159                int count = 0;
7160
7161                int i = 0;
7162                struct splitstr* ret1 = NULL;
7163                ret1 = strsplit(tmpstr1, "\n", &count);
7164                if(ret1 != NULL)
7165                {
7166                        int max = count;
7167                        for(i = 0; i < max; i++)
7168                        {
7169                                if(i == 0) continue;
7170                                line = ostrcat(line, "0", 1, 0); //id
7171                                line = ostrcat(line, "#", 1, 0);
7172
7173                                line = ostrcat(line, fetype, 1, 0); //fetype
7174                                line = ostrcat(line, "#", 1, 0);
7175
7176                                if(ostrstr((ret1[i]).part, "frequency=") != NULL)
7177                                        line = ostrcat(line, getxmlentry(ret1[i].part, "frequency="), 1, 0); //frequency
7178                                else
7179                                        line = ostrcat(line, "-1", 1, 0);
7180                                line = ostrcat(line, "#", 1, 0);
7181
7182                                if(ostrstr((ret1[i]).part, "polarization=") != NULL)
7183                                        line = ostrcat(line, getxmlentry(ret1[i].part, "polarization="), 1, 0); //polarization
7184                                else
7185                                        line = ostrcat(line, "-1", 1, 0); //polarization
7186
7187                                line = ostrcat(line, "#", 1, 0);
7188                                if(orbitalpos != NULL)
7189                                        line = ostrcat(line, orbitalpos, 1, 0); //orbitalpos
7190                                else
7191                                        line = ostrcat(line, "-1", 1, 0); //orbitalpos
7192                                line = ostrcat(line, "#", 1, 0);
7193
7194                                if(ostrstr((ret1[i]).part, "symbol_rate=") != NULL)
7195                                        line = ostrcat(line, getxmlentry(ret1[i].part, "symbol_rate="), 1, 0); //symbolrate
7196                                else
7197                                        line = ostrcat(line, "-1", 1, 0);
7198                                line = ostrcat(line, "#", 1, 0);
7199
7200                                if(ostrstr((ret1[i]).part, "modulation=") != NULL)
7201                                        line = ostrcat(line, getxmlentry(ret1[i].part, "modulation="), 1, 0); //modulation
7202                                else
7203                                {
7204                                        if(flag == 2)
7205                                                line = ostrcat(line, "3", 1, 0);
7206                                        else
7207                                                line = ostrcat(line, "0", 1, 0);
7208                                }
7209                                line = ostrcat(line, "#", 1, 0);
7210
7211                                if(ostrstr((ret1[i]).part, "fec_inner=") != NULL)
7212                                        line = ostrcat(line, getxmlentry(ret1[i].part, "fec_inner="), 1, 0); //fec
7213                                else
7214                                {
7215                                        if(flag == 2)
7216                                                line = ostrcat(line, "5", 1, 0);
7217                                        else
7218                                                line = ostrcat(line, "0", 1, 0);
7219                                }
7220                                line = ostrcat(line, "#", 1, 0);
7221
7222                                if(checkbox("UFS910") == 1)
7223                                        line = ostrcat(line, "1", 1, 0); //pilot
7224                                else
7225                                        line = ostrcat(line, "2", 1, 0); //pilot
7226                                line = ostrcat(line, "#", 1, 0);
7227
7228                                if(checkbox("UFS910") == 1)
7229                                        line = ostrcat(line, "0", 1, 0); //rolloff
7230                                else
7231                                        line = ostrcat(line, "3", 1, 0); //rolloff
7232                                line = ostrcat(line, "#", 1, 0);
7233
7234                                line = ostrcat(line, "2", 1, 0); //inversion
7235                                line = ostrcat(line, "#", 1, 0);
7236
7237                                if(ostrstr((ret1[i]).part, "system=") != NULL)
7238                                        line = ostrcat(line, getxmlentry(ret1[i].part, "system="), 1, 0); //system
7239                                else
7240                                        line = ostrcat(line, "0", 1, 0); //system
7241                                line = ostrcat(line, "\n", 1, 0);
7242                        }
7243                }
7244
7245                tmpstr2 = ostrcat(start, tmpstr, 0, 0);
7246
7247                buf = string_replace(tmpstr2, NULL, buf, 1);
7248
7249        //      outfile = ostrcat("/tmp/convert.", oitoa(incount), 0, 1);
7250        //      outfile = ostrcat(outfile, ".log", 1, 0);
7251        //      writesys(outfile, buf, 2);
7252        //      writesys("/tmp/convert.log", buf, 3);
7253
7254                writesys(transponderfile, line, 2);
7255                free(line), line = NULL;
7256
7257                free(tmpstr), tmpstr = NULL;
7258                free(tmpstr1), tmpstr1 = NULL;
7259                free(tmpstr2), tmpstr2 = NULL;
7260                free(ret1), ret1 = NULL;
7261                free(name), name = NULL;
7262                free(orbitalpos), orbitalpos = NULL;
7263                free(flags), flags = NULL;
7264                free(outfile), outfile = NULL;
7265        }
7266
7267        free(path), path = NULL;
7268        free(filename), filename = NULL;
7269        free(satfile), satfile = NULL;
7270        free(transponderfile), transponderfile = NULL;
7271
7272        free(buf), buf = NULL;
7273        free(start), start = NULL;
7274        free(end), end = NULL;
7275        free(fetype), fetype = NULL;
7276
7277        return 1;
7278}
7279
7280char* system_infos(int mode)
7281{
7282        char* tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL;
7283
7284        if(mode == 0)
7285        {
7286                tmpstr1 = ostrcat("Date = ", "", 0, 0);
7287                tmpstr1 = ostrcat(tmpstr1, gettime(NULL, "%d %B %Y"), 1, 1);
7288                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
7289
7290                tmpstr1 = ostrcat("\nTime = ", "", 0, 0);
7291                tmpstr1 = ostrcat(tmpstr1, gettime(NULL, "%H:%M:%S"), 1, 1);
7292                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
7293
7294                tmpstr1 = ostrcat("\nUptime = ", "", 0, 0);
7295                tmpstr2 = command("uptime");
7296                if(tmpstr2 != NULL) tmpstr2 = strtok(tmpstr2, ",");
7297                tmpstr1 = ostrcat(tmpstr1, tmpstr2, 1, 1);
7298                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
7299
7300                tmpstr1 = ostrcat("\nBoxtype = ", "", 0, 0);
7301                tmpstr2 = string_toupper(command("cat /etc/model"));
7302                tmpstr1 = ostrcat(tmpstr1, tmpstr2, 1, 1);
7303                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
7304
7305                tmpstr1 = ostrcat("\nLoad = ", "", 0, 0);
7306                tmpstr2 = command("cat /proc/loadavg");
7307                tmpstr1 = ostrcat(tmpstr1, tmpstr2, 1, 1);
7308                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
7309        }
7310
7311        if(mode == 1)
7312        {
7313                system("ls /media/usb/* >/dev/null");
7314                system("ls /media/net/* >/dev/null");
7315                system("ls /var/swap/* >/dev/null");
7316                system("ls /mnt/swapextension/* >/dev/null");
7317                system("ls /var/backup/* >/dev/null");
7318                system("ls /media/hdd/* >/dev/null");
7319                tmpstr = command("df -h");
7320        }
7321
7322        if(mode == 2)
7323                tmpstr = command("cat /proc/version");
7324
7325        if(mode == 3)
7326        {
7327                system("ls /media/usb/* >/dev/null");
7328                system("ls /media/net/* >/dev/null");
7329                system("ls /var/swap/* >/dev/null");
7330                system("ls /mnt/swapextension/* >/dev/null");
7331                system("ls /var/backup/* >/dev/null");
7332                system("ls /media/hdd/* >/dev/null");
7333                tmpstr = command("mount");
7334        }
7335
7336        if(mode == 4)
7337        {
7338                tmpstr1 = command("ifconfig");
7339                tmpstr2 = command("route -n");
7340                tmpstr = ostrcat(tmpstr1, tmpstr2, 1, 1);
7341        }
7342
7343        if(mode == 5)
7344                tmpstr = command("free");
7345
7346        return tmpstr;
7347}
7348
7349char* system_infos_sysinfo(int mode)
7350{
7351        char* tmpstr = NULL;
7352
7353        if(mode == 0)
7354                tmpstr = command("cat /proc/cpuinfo | sed 's/\t\t/\t/'");
7355        else if(mode == 1)
7356                tmpstr = command("cat /proc/meminfo");
7357        else if(mode == 2)
7358                tmpstr = command("cat /proc/mtd");
7359        else if(mode == 3)
7360                tmpstr = command("cat /proc/modules");
7361        else if(mode == 4)
7362                tmpstr = command("cat /proc/devices");
7363        else if(mode == 5)
7364        {
7365                char* tmpstr1 = NULL, **tmpstr2 = NULL, **tmpstr3 = NULL;
7366                int i = 0, ii = 0;
7367                char* swap[] = {"Name: ", "Type: ", "Size: ", "Used: ", "Prio: "};
7368
7369                tmpstr1 = command("cat /proc/swaps | sed 's/\t/ /g; s/[ ]* / /g'");
7370                tmpstr2 = str_split(tmpstr1, "\n");
7371                if(tmpstr2 != NULL)
7372                {
7373                        free(tmpstr2[0]); tmpstr2[0] = NULL;
7374
7375                        for(i = 1; tmpstr2[i] != NULL; i++)
7376                        {
7377                                tmpstr3 = str_split(tmpstr2[i], " ");
7378                                if(tmpstr3 != NULL)
7379                                {
7380
7381                                        for(ii = 0; tmpstr3[ii] != NULL; ii++)
7382                                        {
7383                                                tmpstr = ostrcat(tmpstr, swap[ii], 1, 0);
7384                                                tmpstr = ostrcat(tmpstr, tmpstr3[ii], 1, 1);
7385                                                tmpstr = ostrcat(tmpstr, "\n", 1, 0);
7386                                        }
7387                                }
7388
7389                                tmpstr = ostrcat(tmpstr, "\n", 1, 0);
7390                                free(tmpstr2[i]); tmpstr2[i] = NULL;
7391                                free(tmpstr3); tmpstr3 = NULL;
7392                        }
7393                }
7394
7395                free(tmpstr3); tmpstr3 = NULL;
7396                free(tmpstr2); tmpstr2 = NULL;
7397                free(tmpstr1); tmpstr1 = NULL;
7398        }
7399        else if(mode == 6)
7400                tmpstr = command("top -b -n1");
7401        else if(mode == 7)
7402                tmpstr = command("ps");
7403        else if(mode == 8)
7404        {
7405                tmpstr = command("lsusb");
7406                tmpstr = ostrcat(tmpstr, "\n-------------------------------------------\n", 1, 0);
7407                char* tmpstr2 = NULL;
7408                tmpstr2 = command("cat /proc/bus/usb/devices");
7409                tmpstr = ostrcat(tmpstr, tmpstr2, 1, 1);
7410        }
7411        return tmpstr;
7412}
7413
7414char* system_logs(int mode)
7415{
7416        char* tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL, *tmpstr3 = NULL, *path = NULL, *boxversion = NULL;
7417
7418        path = ostrcat("/svn/image/changelog.", NULL, 0, 0);
7419
7420        if(mode == 0)
7421        {
7422                tmpstr1 = readfiletomem("/etc/motd", 0);
7423                if(tmpstr1 != NULL) tmpstr2 = strstr(tmpstr1, "wElc0me");
7424                tmpstr3 = readfiletomem("/etc/imageinfo", 0);
7425                if(tmpstr2 == NULL)
7426                        tmpstr = ostrcat(tmpstr3, NULL, 1, 0);
7427                else
7428                        tmpstr = ostrcat(tmpstr2, tmpstr3, 1, 1);
7429        }
7430        else if(mode == 1)
7431        {
7432                if(isfile("/etc/model") == 0) return NULL;
7433                boxversion = string_tolower(readsys("/etc/model", 1));
7434
7435                path = ostrcat(path, boxversion, 1, 0);
7436                path = ostrcat(path, ".titan", 1, 0);
7437
7438                tmpstr1 = gethttp("atemio.dyndns.tv", path, 80, NULL, HTTPAUTH, 5000, NULL, 0);
7439
7440                tmpstr = readfromlinetoline(tmpstr1, 37, 537, 1);
7441        }
7442        else if(mode == 2)
7443        {
7444#ifdef MIPSEL
7445                path = ostrcat(path, "git.mipsel", 1, 0);
7446#else
7447                path = ostrcat(path, "git.sh4", 1, 0);
7448#endif
7449
7450                tmpstr1 = gethttp("atemio.dyndns.tv", path, 80, NULL, HTTPAUTH, 5000, NULL, 0);
7451
7452                tmpstr = readfromlinetoline(tmpstr1, 0, 500, 1);
7453        }
7454        else if(mode == 3)
7455        {
7456                tmpstr = readfiletomem(getconfig("tracelog", NULL), 0);
7457        }
7458
7459        free(path), path = NULL;
7460        free(boxversion), boxversion = NULL;
7461//      free(tmpstr1), tmpstr1 = NULL;
7462//      free(tmpstr2), tmpstr2 = NULL;
7463//      free(tmpstr3), tmpstr3 = NULL;
7464
7465        return tmpstr;
7466}
7467
7468char* getimgnamereal()
7469{
7470        char* tmpstr = NULL;
7471
7472        tmpstr = readfiletomem(getconfig("imagenamefile", NULL), 1);
7473
7474        return tmpstr;
7475}
7476
7477char* getmoviedev()
7478{
7479        char* tmpstr = NULL, *buf = NULL;
7480
7481        tmpstr = readfiletomem("/tmp/.moviedev", 1);
7482        printf("tmpstr: %s\n", tmpstr);
7483
7484        buf = oregex("sd([a-z]{1,1}).*", tmpstr);
7485        printf("buf: %s\n", buf);
7486
7487        free(tmpstr), tmpstr = NULL;
7488
7489        return buf;
7490}
7491
7492void wakeup_record_device()
7493{
7494        char* cmd = NULL, *dev = NULL;
7495
7496        dev = getmoviedev();
7497        if(dev == NULL)
7498        {
7499                cmd = ostrcat("ls -al ", getconfig("rec_path", NULL), 0, 0);
7500                cmd = ostrcat(cmd," > /dev/null 2>&1", 1, 0);
7501        }
7502        else
7503                cmd = ostrcat("sdparm -C START /dev/sd", dev, 0, 0);
7504
7505//      cmd = ostrcat(cmd, " >/dev/null", 1, 0);
7506        printf("cmd: %s\n", cmd);
7507        system(cmd);
7508        free(dev), dev = NULL;
7509        free(cmd), cmd = NULL;
7510}
7511
7512void setdefaultbouquets()
7513{
7514        if(textbox(_("Message"), _("Start Restore Default Bouquets ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 0, 0) == 1)
7515        {
7516                struct skin* load = getscreen("loading");
7517                drawscreen(load, 0, 0);
7518
7519                system("rm -f /mnt/settings/bouquets.* > /dev/null 2>&1");
7520                system("cp -a /etc/titan.restore/mnt/settings/bouquets* /mnt/settings > /dev/null 2>&1");
7521
7522                textbox(_("Message"), _("Titan will be restarted!"), _("OK"), getrcconfigint("rcok", NULL), NULL, 0, NULL, 0, NULL, 0, 1000, 200, 0, 0);
7523                //sync usb
7524                system("sync");
7525                //write only config file
7526                writeallconfig(3);
7527                //gui restart and write no config
7528                oshutdown(3, 2);
7529        }
7530}
7531
7532void setdefaultsettings()
7533{
7534        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)
7535        {
7536                struct skin* load = getscreen("loading");
7537                drawscreen(load, 0, 0);
7538
7539                system("rm -rf /mnt/settings/* > /dev/null 2>&1");
7540                system("cp -a /etc/titan.restore/mnt/settings/* /mnt/settings > /dev/null 2>&1");
7541
7542                textbox(_("Message"), _("Titan will be restarted!"), _("OK"), getrcconfigint("rcok", NULL), NULL, 0, NULL, 0, NULL, 0, 1000, 200, 0, 0);
7543                //sync usb
7544                system("sync");
7545                //write only config file
7546                writeallconfig(3);
7547                //gui restart and write no config
7548                oshutdown(3, 2);
7549        }
7550}
7551
7552void setdefaultproviders()
7553{
7554        if(textbox(_("Message"), _("Start Restore Default Providers ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 0, 0) == 1)
7555        {
7556                struct skin* load = getscreen("loading");
7557                drawscreen(load, 0, 0);
7558
7559                system("rm -f /mnt/settings/provider > /dev/null 2>&1");
7560                system("cp -a /etc/titan.restore/mnt/settings/provider /mnt/settings > /dev/null 2>&1");
7561
7562                textbox(_("Message"), _("Titan will be restarted!"), _("OK"), getrcconfigint("rcok", NULL), NULL, 0, NULL, 0, NULL, 0, 1000, 200, 0, 0);
7563                //sync usb
7564                system("sync");
7565                //write only config file
7566                writeallconfig(3);
7567                //gui restart and write no config
7568                oshutdown(3, 2);
7569        }
7570}
7571
7572void setdefaultchannels()
7573{
7574        if(textbox(_("Message"), _("Start Restore Default Channels ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 0, 0) == 1)
7575        {
7576                struct skin* load = getscreen("loading");
7577                drawscreen(load, 0, 0);
7578
7579                system("rm -f /mnt/settings/channel > /dev/null 2>&1");
7580                system("cp -a /etc/titan.restore/mnt/settings/channel /mnt/settings > /dev/null 2>&1");
7581
7582                textbox(_("Message"), _("Titan will be restarted!"), _("OK"), getrcconfigint("rcok", NULL), NULL, 0, NULL, 0, NULL, 0, 1000, 200, 0, 0);
7583                //sync usb
7584                system("sync");
7585                //write only config file
7586                writeallconfig(3);
7587                //gui restart and write no config
7588                oshutdown(3, 2);
7589        }
7590}
7591
7592void setdefaultsats()
7593{
7594        if(textbox(_("Message"), _("Start Restore Default Sats ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 0, 0) == 1)
7595        {
7596                struct skin* load = getscreen("loading");
7597                drawscreen(load, 0, 0);
7598
7599                system("rm -f /mnt/settings/satellites > /dev/null 2>&1");
7600                system("cp -a /etc/titan.restore/mnt/settings/satellites /mnt/settings > /dev/null 2>&1");
7601
7602                textbox(_("Message"), _("Titan will be restarted!"), _("OK"), getrcconfigint("rcok", NULL), NULL, 0, NULL, 0, NULL, 0, 1000, 200, 0, 0);
7603                //sync usb
7604                system("sync");
7605                //write only config file
7606                writeallconfig(3);
7607                //gui restart and write no config
7608                oshutdown(3, 2);
7609        }
7610}
7611
7612char* create_backup(char* input, int flag)
7613{
7614        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);
7615        if(flag == 0) return infotext;
7616
7617        char* tmpstr = NULL, *cmd = NULL;
7618        int merksec = status.sec;
7619
7620        status.sec = 0; //deaktivate spinner
7621        if(checkbox("DM900") == 1)
7622                cmd = ostrcat(cmd, "backupdream.sh ", 1, 0);
7623        else
7624                cmd = ostrcat(cmd, "backup.sh ", 1, 0);
7625        cmd = ostrcat(cmd, input, 1, 0);
7626
7627        if(flag == 2)
7628                cmd = ostrcat(cmd, " 1", 1, 0);
7629
7630        if(file_exist("/var/swap"))
7631        {
7632                if(!file_exist("/var/swap/logs"))
7633                         mkdir("/var/swap/logs", 777);
7634
7635                if(file_exist("/etc/.beta") && file_exist("/var/swap/logs"))
7636                        cmd = ostrcat(cmd, " > /var/swap/logs/backup_debug.log 2>&1", 1, 0);
7637        }
7638        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)
7639        {
7640                if(!file_exist("/mnt/logs"))
7641                         mkdir("/mnt/logs", 777);
7642
7643                if(file_exist("/etc/.beta") && file_exist("/mnt/logs"))
7644                        cmd = ostrcat(cmd, " > /mnt/logs/backup_debug.log 2>&1", 1, 0);
7645        }
7646        //tmpstr = command(cmd);
7647        if(system(cmd) == 0)
7648        //if(tmpstr == NULL)
7649                tmpstr = ostrcat(tmpstr, _("Backup created successfully"), 1, 0);
7650        else
7651                tmpstr = ostrcat(tmpstr, _("Backup ended with error"), 1, 0);
7652
7653        free(cmd); cmd = NULL;
7654        status.sec = merksec;
7655
7656        return tmpstr;
7657}
7658
7659char* create_backuprestore()
7660{
7661        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);
7662        return tmpstr;
7663}
7664char* randomstring(int n)
7665{
7666    int i, wert;
7667    time_t t;
7668    char* tmp = malloc(n+1);
7669
7670    /* Intializes random number generator */
7671    srand((unsigned) time(&t));
7672    for( i = 0 ; i < n ; i++ )
7673    {
7674        wert = rand() % 9;
7675        sprintf(tmp+i, "%d", wert);
7676    }
7677    tmp[i] = '\0';
7678    return tmp;
7679}
7680
7681
7682int putmsgbuffer()
7683{
7684        if(file_exist("/tmp/textbox_standby") != 1)
7685                return 1;
7686
7687        FILE *fp = fopen("/tmp/textbox_standby" , "r");
7688        if(fp == NULL)
7689        {
7690                printf("Error opening file: /tmp/textbox_standby\n");
7691                return(-1);
7692        }
7693
7694        char* caption = malloc(255);
7695        char* body = malloc(255);
7696        char* comtext1 = malloc(20);
7697        char* com1 = malloc(10);
7698        char* comtext2 = malloc(20);
7699        char* com2 = malloc(10);
7700        char* comtext3 = malloc(20);
7701        char* com3 = malloc(10);
7702        char* comtext4 = malloc(20);
7703        char* com4 = malloc(10);
7704        char* width = malloc(10);
7705        char* height = malloc(10);
7706        char* timeout = malloc(10);
7707        char* flag = malloc(10);
7708
7709        while(fgets(caption, 255, fp)!=NULL)
7710        {
7711                string_newline(caption);
7712
7713                fgets(body, 255, fp);
7714                string_newline(body);
7715                body = string_replace_all("\t", "\n", body, 1);
7716
7717                if(comtext1 == NULL)
7718                        comtext1 = malloc(20);
7719                fgets(comtext1, 20, fp);
7720                string_newline(comtext1);
7721                fgets(com1, 10, fp);
7722                string_newline(com1);
7723
7724                if(comtext2 == NULL)
7725                        comtext2 = malloc(20);
7726                fgets(comtext2, 20, fp);
7727                string_newline(comtext2);
7728                fgets(com2, 10, fp);
7729                string_newline(com2);
7730
7731                if(comtext3 == NULL)
7732                        comtext3 = malloc(20);
7733                fgets(comtext3, 20, fp);
7734                string_newline(comtext3);
7735                fgets(com3, 10, fp);
7736                string_newline(com3);
7737
7738                if(comtext4 == NULL)
7739                        comtext4 = malloc(20);
7740                fgets(comtext4, 20, fp);
7741                string_newline(comtext4);
7742                fgets(com4, 10, fp);
7743                string_newline(com4);
7744
7745                fgets(width, 10, fp);
7746                string_newline(width);
7747
7748                fgets(height, 10, fp);
7749                string_newline(height);
7750
7751                fgets(timeout, 10, fp);
7752                string_newline(timeout);
7753
7754                fgets(flag, 10, fp);
7755                string_newline(flag);
7756
7757                if(atoi(com1) == 0)
7758                {
7759                        free(comtext1);
7760                        comtext1 = NULL;
7761                }
7762                if(atoi(com2) == 0)
7763                {
7764                        free(comtext2);
7765                        comtext2 = NULL;
7766                }
7767                if(atoi(com3) == 0)
7768                {
7769                        free(comtext3);
7770                        comtext3 = NULL;
7771                }
7772                if(atoi(com4) == 0)
7773                {
7774                        free(comtext4);
7775                        comtext4 = NULL;
7776                }
7777                textbox(caption, body, comtext1, atoi(com1), comtext2, atoi(com2), comtext3, atoi(com3), comtext4, atoi(com4), atoi(width), atoi(height), atoi(timeout), atoi(flag));
7778        }
7779
7780        fclose(fp);
7781        system("rm /tmp/textbox_standby");
7782
7783        free(caption);
7784        free(body);
7785        free(comtext1);
7786        free(com1);
7787        free(comtext2);
7788        free(com2);
7789        free(comtext3);
7790        free(com3);
7791        free(comtext4);
7792        free(com4);
7793        free(width);
7794        free(height);
7795        free(timeout);
7796        free(flag);
7797
7798        return 0;
7799}
7800
7801void delunusedsat()
7802{
7803        debug(10, "delunusedsat: start");
7804        struct sat* node = sat;
7805        struct sat* prev = NULL;
7806
7807        while(node != NULL)
7808        {
7809                prev = node;
7810                node = node->next;
7811
7812                if(prev->scan != 1)
7813                        delsat(prev->name);
7814        }
7815        debug(10, "delunusedsat: end");
7816}
7817
7818void delunusedtransponder()
7819{
7820        debug(10, "delunusedtransponder: start");
7821        struct transponder* node = transponder;
7822        struct transponder* prev = NULL;
7823
7824        while(node != NULL)
7825        {
7826                prev = node;
7827                node = node->next;
7828
7829                if(getsatbyorbitalpos(prev->orbitalpos) == NULL)
7830                        deltransponder(prev);
7831        }
7832        debug(10, "delunusedtransponder: end");
7833}
7834
7835void delunusedchannel()
7836{
7837        debug(10, "delunusedchannel: start");
7838        struct channel* node = channel;
7839        struct channel* prev = NULL;
7840
7841        while(node != NULL)
7842        {
7843                prev = node;
7844                node = node->next;
7845
7846                if(prev->transponder == NULL)
7847                        delchannel(prev->serviceid, prev->transponderid, 0);
7848        }
7849        debug(10, "delunusedchannel: end");
7850}
7851
7852void delunusedbouquet()
7853{
7854        debug(10, "delunusedbouquet: start");
7855        struct mainbouquet* mnode = mainbouquet;
7856        struct bouquet* first = NULL;
7857        struct bouquet* node = NULL;
7858        struct bouquet* prev = NULL;
7859
7860        while(mnode != NULL)
7861        {
7862                first = mnode->bouquet;
7863                node = mnode->bouquet;
7864                while(node != NULL)
7865                {
7866                        prev = node;
7867                        node = node->next;
7868                        if(getchannel(prev->serviceid, prev->transponderid) == NULL)
7869                                delbouquet(prev->serviceid, prev->transponderid, &first);
7870                }
7871                mnode = mnode->next;
7872        }
7873        debug(10, "delunusedbouquet: end");
7874}
7875
7876void delunusedepgchannel()
7877{
7878        debug(10, "delunusedepgchannel: start");
7879        struct epgscanlist* node = epgscanlist;
7880        struct epgscanlist* prev = NULL;
7881
7882        while(node != NULL)
7883        {
7884                prev = node;
7885                node = node->next;
7886                if(getchannel(prev->serviceid, prev->transponderid) == NULL)
7887                        delepgscanlist(node->serviceid, node->transponderid);
7888        }
7889        debug(10, "delunusedepgchannel: end");
7890}
7891
7892void delunusedprovider()
7893{
7894        debug(10, "delunusedprovider: start");
7895        struct provider* node = provider;
7896        struct provider* prev = NULL;
7897
7898        while(node != NULL)
7899        {
7900                prev = node;
7901                node = node->next;
7902                delprovidernotused(prev);
7903        }
7904        debug(10, "delunusedprovider: end");
7905}
7906
7907int checkshutdown(int flag)
7908{
7909        int i = 0;
7910
7911        //check if record running
7912        if((flag == 1 || flag == 2 || flag == 3 || flag == 4 || flag == 5 || flag == 6) && (status.streaming > 0 || status.recording > 0 || getrectimerbytimediff(300) != NULL))
7913        {
7914                if(flag == 4 && status.fixpowerofftime > 1)
7915                {
7916                                status.fixpowerofftime = time(NULL) + 900; //check powerofftimer again in 15min
7917                                return 1;
7918                }
7919                if(flag == 5 && status.sd_timer != NULL && status.sd_timer->active)
7920                {
7921                                status.sd_timer->shutdown_time = time(NULL) + 900; //check powerofftimer again in 15min
7922                                return 1;
7923                }
7924                else if(flag == 6)
7925                {
7926                        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)
7927                                return 1;
7928                }
7929                else
7930                {
7931                        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)
7932                                return 1;
7933                }
7934        }
7935
7936        //check if download is running
7937        for(i = 0; i < MAXBGDOWNLOAD; i++)
7938        {
7939                if(bgdownload[i] != NULL && bgdownload[i]->ret == -1)
7940                {
7941                        if(flag == 6)
7942                        {
7943                                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)
7944                                        return 1;
7945                        }
7946                        else
7947                        {
7948                                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)
7949                                        return 1;
7950                        }
7951                        break;
7952
7953                }
7954        }
7955
7956        return 0;
7957}
7958
7959#endif
Note: See TracBrowser for help on using the repository browser.