source: titan/titan/global.h @ 40382

Last change on this file since 40382 was 40382, checked in by obi, 5 years ago

fix

File size: 168.7 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 getrandomnum(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)
4736                {
4737                        addconfig("av_mode3d", value);
4738                        char* res = getvideomode();
4739                        if(res != NULL)
4740                        {
4741                                setvideomode("576p", 0);
4742                                sleep(1);
4743                                setvideomode(res, 0);
4744                        }
4745                        free(res); res = NULL;
4746                }
4747                return ret;
4748        }
4749
4750        return 0;
4751}
4752
4753char* getvideomode()
4754{
4755        char *videomodedev = NULL;
4756        char *value = NULL;
4757
4758        videomodedev = getconfig("videomodedev", NULL);
4759
4760        if(videomodedev == NULL)
4761        {
4762                err("NULL detect");
4763                return NULL;
4764        }
4765
4766        value = readsys(videomodedev, 1);
4767        if(value == NULL)
4768        {
4769                err("NULL detect");
4770                return NULL;
4771        }
4772
4773        return value;
4774}
4775
4776void switchvideomode()
4777{
4778        int rcret = 0;
4779        char* tmpstr = NULL, *tmpstr2 = NULL, *tmpstr3 = NULL;
4780        tmpstr = getvideomode();
4781        struct skin* playpolicy = getscreen("playpolicy");
4782        tmpstr2 = getcolorformat(2);
4783
4784        if(tmpstr != NULL)
4785        {
4786                if((ostrcmp("pal", tmpstr) == 0 || ostrncmp("576", tmpstr, 3) == 0) && ostrncmp("yuv", tmpstr2, 3) == 0)
4787                {
4788                        setvideomode("720p50", 0);
4789                        changefbresolution("720p50", 0);
4790                        changetext(playpolicy, "720p50 (rgb)");
4791                        writevfdmenu("720p50 (rgb)");
4792                        setcolorformat("rgb", 1);
4793                        unlink("/var/etc/.scart");
4794                }
4795                else if((ostrcmp("pal", tmpstr) == 0 || ostrncmp("576", tmpstr, 3) == 0) && ostrncmp("rgb", tmpstr2, 3) == 0)
4796                {
4797                        setvideomode("720p50", 0);
4798                        changefbresolution("720p50", 0);
4799                        changetext(playpolicy, "720p50 (yuv)");
4800                        writevfdmenu("720p50 (yuv)");
4801                        setcolorformat("yuv", 1);
4802                        unlink("/var/etc/.scart");
4803                }
4804                else if(ostrncmp("720", tmpstr, 3) == 0)
4805                {
4806                        setvideomode("1080i50", 0);
4807                        changefbresolution("1080i50", 0);
4808                        tmpstr3 = ostrcat("1080i50 (", tmpstr2, 0, 0);
4809                        tmpstr3 = ostrcat(tmpstr3, ")", 1, 0);
4810                        changetext(playpolicy, tmpstr3);
4811                        writevfdmenu(tmpstr3);
4812                        unlink("/var/etc/.scart");
4813                }
4814                else if(ostrncmp("1080", tmpstr, 4) == 0)
4815                {
4816                        setvideomode("576i50", 0);
4817                        changefbresolution("576i50", 0);
4818                        changetext(playpolicy, "576i50 (rgb)");
4819                        writevfdmenu("576i50 (rgb)");
4820                        setcolorformat("rgb", 1);
4821                        writesys("/var/etc/.scart", "0", 0);
4822                }
4823                /*
4824                int ret = textbox(_("Message"), _("Is this Videomode ok ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 10, 0);
4825                if(ret == 1 || ret == 2)
4826                {
4827                        setvideomode(tmpstr, 0);
4828                        changefbresolution(tmpstr, 0);
4829                }
4830                */
4831                drawscreen(playpolicy, 0, 0);
4832                while(1)
4833                {
4834                        rcret = waitrc(playpolicy, 5000, 0);
4835                        break;
4836                }
4837                clearscreen(playpolicy);
4838        }
4839        free(tmpstr);
4840        free(tmpstr2);
4841        free(tmpstr3);
4842}
4843
4844//flag 0: write videomode to config
4845//flag 1: don't write videomode to config
4846int setvideomode(char* value, int flag)
4847{
4848        char* videomodedev;
4849        int ret = 0;
4850
4851        videomodedev = getconfig("videomodedev", NULL);
4852
4853        if(videomodedev != NULL && value != NULL)
4854        {
4855                debug(100, "set %s to %s", videomodedev, value);
4856                ret = writesys(videomodedev, value, 0);
4857                if(ret == 0 && flag == 0) addconfig("av_videomode", value);
4858                return ret;
4859        }
4860
4861        return 0;
4862}
4863
4864//flag 0 = hdmi
4865//flag 1 = scart
4866int setcolorformat(char* value, int flag)
4867{
4868        char* colorformatdev;
4869        int ret = 0;
4870
4871        colorformatdev = getconfig("colorformatdev", NULL);
4872
4873        if(colorformatdev != NULL && value != NULL)
4874        {
4875                debug(100, "set %s to %s", colorformatdev, value);
4876                ret = writesys(colorformatdev, value, 0);
4877                if(ret == 0)
4878                {
4879                        if(flag == 0)
4880                                addconfig("av_colorformat", value);
4881                        else
4882                                addconfig("av_colorformatscart", value);
4883                }
4884                return ret;
4885        }
4886
4887        return 0;
4888}
4889
4890char* getcolorformat(int line)
4891{
4892        char *colorformatdev = NULL;
4893        char *value = NULL;
4894
4895        colorformatdev = getconfig("colorformatdev", NULL);
4896
4897        if(colorformatdev == NULL)
4898        {
4899                err("NULL detect");
4900                return NULL;
4901        }
4902
4903        value = readsys(colorformatdev, line);
4904        if(value == NULL)
4905        {
4906                err("NULL detect");
4907                return NULL;
4908        }
4909
4910        return value;
4911}
4912
4913int setaudiosource(char* value)
4914{
4915        char* audiosourcedev;
4916        int ret = 1;
4917
4918        audiosourcedev = getconfig("audiosourcedev", NULL);
4919
4920        if(audiosourcedev != NULL && value != NULL)
4921        {
4922                debug(100, "set %s to %s", audiosourcedev, value);
4923                ret = writesys(audiosourcedev, value, 0);
4924                if(ret == 0) addconfig("av_audiosource", value);
4925                return ret;
4926        }
4927
4928        return 0;
4929}
4930
4931char* getaudiosource()
4932{
4933        char *audiosourcedev = NULL;
4934        char *value = NULL;
4935
4936        audiosourcedev = getconfig("audiosourcedev", NULL);
4937
4938        if(audiosourcedev == NULL)
4939        {
4940                err("NULL detect");
4941                return NULL;
4942        }
4943
4944        value = readsys(audiosourcedev, 1);
4945        if(value == NULL)
4946        {
4947                err("NULL detect");
4948                return NULL;
4949        }
4950
4951        return value;
4952}
4953
4954char* getsataswitch()
4955{
4956        char *sataswitchdev = NULL;
4957        char *value = NULL;
4958
4959        sataswitchdev = getconfig("sataswitchdev", NULL);
4960
4961        if(sataswitchdev == NULL)
4962        {
4963                err("NULL detect");
4964                return NULL;
4965        }
4966
4967        value = readsys(sataswitchdev, 1);
4968        if(value == NULL)
4969        {
4970                err("NULL detect");
4971                return NULL;
4972        }
4973
4974        return value;
4975}
4976
4977int setsataswitch(char* value)
4978{
4979        char* sataswitchdev;
4980        int ret = 1;
4981
4982        sataswitchdev = getconfig("sataswitchdev", NULL);
4983
4984        if(sataswitchdev != NULL && value != NULL)
4985        {
4986                debug(100, "set %s to %s", sataswitchdev, value);
4987                ret = writesys(sataswitchdev, value, 0);
4988                return ret;
4989        }
4990
4991        return 0;
4992}
4993
4994int setprogress(int value)
4995{
4996        char *progressdev;
4997
4998        progressdev = getconfig("progressdev", NULL);
4999
5000        if(progressdev != NULL)
5001        {
5002                debug(100, "set %s to %d",progressdev, value);
5003                if(checkbox("DM7020HD") == 1 || checkbox("DM7020HDV2") == 1 || checkbox("DM900") == 1)
5004                        return writesysint(progressdev, value, 1);
5005                else
5006                        return writesysint(progressdev, value, 0);
5007        }
5008
5009        return 0;
5010}
5011
5012int setmute(int value)
5013{
5014        char* mutedev;
5015        int tmpvol, ret = 0;
5016
5017        //don't set mute 2x
5018        if(value == 1 && status.mute == 1) return 0;
5019
5020//      printf("mute value: %d\n", value);
5021
5022        if(value == 2)
5023        {
5024                tmpvol = getvol();
5025                tmpvol = tmpvol * 50 / 100;
5026                status.mute = value;
5027                setvol(tmpvol);
5028        }
5029        else
5030        {
5031                mutedev = getconfig("mutedev", NULL);
5032
5033                if(mutedev != NULL)
5034                {
5035                        debug(100, "set %s to %d", mutedev, value);
5036                        //if(status.volautochangevalue != 0 && value == 0) setvol(getvol());
5037#ifdef MIPSEL
5038                        struct dvbdev *audionode = NULL;
5039                        int openaudio = 0;
5040                        if(status.aktservice != NULL)
5041                        {
5042                                if(status.aktservice->audiodev == NULL)
5043                                {
5044                                        audionode = audioopen(0); //we must open the audio device for set mute in external player
5045                                        openaudio = 1;
5046                                }
5047                                else
5048                                        audionode = status.aktservice->audiodev;
5049                        }
5050                        ret = audiosetmute(audionode, value);
5051                        if(openaudio == 1)
5052                                audioclose(audionode, -1);
5053#else
5054                        ret = writesysint(mutedev, value, 0);
5055#endif
5056
5057                        if(ret == 0) status.mute = value;
5058                        if(status.volautochangevalue != 0 && value == 0) setvol(getvol());
5059//                      if(value == 1)
5060//                      {
5061//                              printf("mute\n");
5062//                              system("amixer -c 1 set HDMI mute &");
5063//                              system("amixer -c 1 set Analog mute &");
5064//                              system("amixer -c 1 set SPDIF mute &");
5065//                              sleep(1);
5066//                      }
5067//                      else
5068//                      {
5069//                              printf("unmute\n");
5070//                              system("amixer -c 1 set HDMI unmute &");
5071//                              system("amixer -c 1 set Analog unmute &");
5072//                              system("amixer -c 1 set SPDIF unmute &");
5073//                      }
5074
5075                        return ret;
5076                }
5077        }
5078        return 0;
5079}
5080
5081int setvol(int value)
5082{
5083        char* voldev;
5084        int ret = 0, tmpvol = value;
5085
5086        voldev = getconfig("voldev", NULL);
5087
5088        if(voldev != NULL)
5089        {
5090                if(value > 100) value = 100;
5091                if(value < 0) value = 0;
5092                if(status.volautochangevalue != 0 && value != 0)
5093                {
5094                        if(status.volautochange == 0)
5095                                value = value - (status.volautochangevalue * value / 100);
5096                }
5097                value = 63 - value * 63 / 100;
5098                debug(100, "set %s to %d", voldev, value);
5099                ret = 0;
5100                if(status.mute == 1)
5101                        status.volmute = value;
5102                else
5103                {
5104                        status.volmute = -1;
5105                        if(file_exist(voldev))
5106                                ret = writesysint(voldev, value, 0);
5107                        else
5108                                ret = 0;
5109#ifdef MIPSEL
5110                        struct dvbdev *audionode = NULL;
5111                        int openaudio = 0;
5112
5113                        if(ret == 0 && status.aktservice != NULL)
5114                        {
5115                                if(status.aktservice->audiodev == NULL)
5116                                {
5117                                        audionode = audioopen(0); //we must open the audio device for change volume in external player
5118                                        openaudio = 1;
5119                                }
5120                                else
5121                                        audionode = status.aktservice->audiodev;
5122
5123                                if(ret == 0 && audionode != NULL)
5124                                        ret = setmixer(audionode, value, value);
5125
5126                                if(ret == 0)
5127                                        status.volume = value;
5128
5129                                if(openaudio == 1)
5130                                        audioclose(audionode, -1);
5131                        }
5132#else
5133                        if(ret == 0 && status.aktservice != NULL)
5134                                ret = setmixer(status.aktservice->audiodev, value, value);
5135#endif
5136                }
5137                if(ret == 0 && status.mute != 2) addconfigint("vol", tmpvol);
5138                return ret;
5139        }
5140
5141        return 0;
5142}
5143
5144int getvol()
5145{
5146        char *voldev = NULL;
5147        char *value = NULL;
5148        int tmpvol = -1;
5149
5150        voldev = getconfig("voldev", NULL);
5151
5152        if(voldev == NULL)
5153        {
5154                err("NULL detect");
5155                return 0;
5156        }
5157        if(status.volmute == -1)
5158        {
5159                if(file_exist(voldev))
5160                        value = readsys(voldev, 1);
5161        }
5162        else
5163                tmpvol = status.volmute;
5164        if((value == NULL && status.volume == -1) && tmpvol == -1)
5165        {
5166                err("NULL detect");
5167                return 0;
5168        }
5169        if(status.volmute == -1)
5170        {
5171                if(file_exist(voldev))
5172                        tmpvol = atoi(value);
5173                else
5174                        tmpvol = status.volume;
5175        }
5176        free(value);
5177        tmpvol = 100 - tmpvol * 100 / 63;
5178        if(status.volautochangevalue != 0)
5179        {
5180                if(status.volautochange == 0 && status.volautochangevalue < 100)
5181                        tmpvol = tmpvol + ((tmpvol * status.volautochangevalue) / (100 - status.volautochangevalue));
5182        }
5183        return tmpvol;
5184}
5185
5186void setdebuglevel()
5187{
5188        debug_level = getconfigint("debuglevel", NULL);
5189        debug(0, "set debug level to %d", debug_level);
5190}
5191
5192char* getxmlentry(char *line, char *searchstr)
5193{
5194        char *buf = NULL, *buf1 = NULL, *buf2 = NULL;
5195
5196        buf = ostrstr(line, searchstr);
5197        if(buf == NULL)
5198                return NULL;
5199
5200        buf = buf + strlen(searchstr);
5201        if(buf[0] == '"')
5202        {
5203                buf = buf + 1;
5204                if(buf[0] == '\\')
5205                {
5206                        buf = buf + 1;
5207                        if(buf[0] == '"')
5208                                buf2 = strchr(buf+1, '"');
5209                        else
5210                                buf2 = strchr(buf, '"');
5211                }
5212                else
5213                        buf2 = strchr(buf, '"');
5214                if(buf2 == NULL)
5215                {
5216                        err("strchr returns NULL");
5217                        return NULL;
5218                }
5219                buf1 = strndup(buf, buf2 - buf);
5220                if(buf1 == NULL)
5221                {
5222                        err("strndup failed");
5223                        return NULL;
5224                }
5225        }
5226        else if(buf[0] == '\'')
5227        {
5228                buf = buf + 1;
5229                buf2 = strchr(buf, '\'');
5230                if(buf2 == NULL)
5231                {
5232                        err("strchr returns NULL");
5233                        return NULL;
5234                }
5235                buf1 = strndup(buf, buf2 - buf);
5236                if(buf1 == NULL)
5237                {
5238                        err("strndup failed");
5239                        return NULL;
5240                }
5241        }
5242        else
5243        {
5244                buf2 = strchr(buf, ' ');
5245                if(buf2 == NULL)
5246                {
5247                        buf2 = ostrstr(buf, "/>");
5248                        if(buf2 == NULL)
5249                        {
5250                                buf2 = strchr(buf, '>');
5251                                if(buf2 == NULL)
5252                                {
5253                                        err("strchr returns NULL");
5254                                        return NULL;
5255                                }
5256                        }
5257                }
5258                buf1 = strndup(buf, buf2 - buf);
5259                if(buf1 == NULL)
5260                {
5261                        err("strndup failed");
5262                        return NULL;
5263                }
5264        }
5265
5266        return buf1;
5267}
5268
5269char* readbintomem(const char* filename, size_t size)
5270{
5271        FILE *fd = NULL;
5272        char *fileline = NULL;
5273
5274        fileline = calloc(1, size + 1);
5275        if(fileline == NULL)
5276        {
5277                err("no mem");
5278                return NULL;
5279        }
5280
5281        fd = fopen(filename, "rb");
5282        if(fd == NULL)
5283        {
5284                perr("can't open %s", filename);
5285                free(fileline);
5286                return NULL;
5287        }
5288
5289        fread(fileline, size, 1, fd);
5290
5291        fclose(fd);
5292        return fileline;
5293}
5294
5295char* readfiletomem(const char* filename, int flag)
5296{
5297        FILE *fd = NULL;
5298        char *fileline = NULL, *buf = NULL, *tmpbuf = NULL;
5299        int bufsize = 0, bufoldsize = 0;
5300
5301        fileline = malloc(MINMALLOC);
5302        if(fileline == NULL)
5303        {
5304                err("no mem");
5305                return NULL;
5306        }
5307
5308        fd = fopen(filename, "r");
5309        if(fd == NULL)
5310        {
5311                perr("can't open %s", filename);
5312                free(fileline);
5313                return NULL;
5314        }
5315
5316        while(fgets(fileline, MINMALLOC, fd) != NULL)
5317        {
5318                if(flag == 1)
5319                        if(fileline[0] == '#' || fileline[0] == '\n')
5320                                continue;
5321
5322                bufoldsize = bufsize;
5323                bufsize += strlen(fileline);
5324                tmpbuf = buf;   buf = realloc(buf, bufsize + 1);
5325                if(buf == NULL)
5326                {
5327                        err("no mem");
5328                        free(fileline);
5329                        free(tmpbuf);
5330                        fclose(fd);
5331                        return NULL;
5332                }
5333
5334                sprintf(buf + bufoldsize, "%s", fileline);
5335        }
5336
5337        free(fileline);
5338        fclose(fd);
5339        return buf;
5340}
5341
5342char* readeittomem(const char* filename)
5343{
5344        unsigned char byte;
5345        FILE *fil = NULL;
5346        char *zeichen = NULL, *buf = NULL, *buf1 = NULL, *tmpbuf1 = NULL;
5347        int buf1size = 0, buf1oldsize = 0;
5348        int Beschreibung;
5349        int len;
5350
5351        zeichen = malloc(255);
5352        if(zeichen == NULL)
5353        {
5354                err("no mem");
5355                return NULL;
5356        }
5357        buf = malloc(255);
5358        if(buf == NULL)
5359        {
5360                free(zeichen);
5361                err("no mem");
5362                return NULL;
5363        }
5364
5365        fil = fopen(filename, "r");
5366        if(fil == NULL)
5367        {
5368                err("can't open %s", filename);
5369                free(zeichen);
5370                free(buf);
5371                return NULL;
5372        }
5373        Beschreibung = 0;
5374        fseek(fil, 12, SEEK_SET); //ersten 12 Byte nicht relevant
5375        while(!feof(fil))
5376        {
5377                byte = fgetc(fil);
5378
5379                if(byte == 0x4D)
5380                {
5381                        fseek(fil, 4,SEEK_CUR);
5382                        byte = fgetc(fil);
5383                        len = byte + 0;
5384                        byte = fgetc(fil);
5385                        fgets(zeichen, len, fil);
5386                        if(byte != 0x05)
5387                                sprintf(buf, "%c%s\n", byte, zeichen);
5388                        else
5389                                sprintf(buf, "%s\n", zeichen);
5390
5391                        buf1oldsize = buf1size;
5392                        buf1size += strlen(buf);
5393                        tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
5394                        if(buf1 == NULL)
5395                        {
5396                                err("no mem");
5397                                free(zeichen);
5398                                free(buf);
5399                                free(tmpbuf1);
5400                                fclose(fil);
5401                                return NULL;
5402                        }
5403                        sprintf(buf1 + buf1oldsize, "%s", buf);
5404
5405                        //printf("T %s\n", zeichen);
5406                        byte = fgetc(fil);
5407                        len = byte + 0;
5408                        byte = fgetc(fil);
5409                        fgets(zeichen, len, fil);
5410                        if(byte != 0x05)
5411                                sprintf(buf,"%c%s\n\n", byte, zeichen);
5412                        else
5413                                sprintf(buf,"%s\n\n", zeichen);
5414
5415                        buf1oldsize = buf1size;
5416                        buf1size += strlen(buf);
5417                        tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
5418                        if(buf1 == NULL)
5419                        {
5420                                err("no mem");
5421                                free(zeichen);
5422                                free(buf);
5423                                free(tmpbuf1);
5424                                fclose(fil);
5425                                return NULL;
5426                        }
5427                        sprintf(buf1 + buf1oldsize, "%s", buf);
5428
5429                }
5430                else if(byte == 0x4E)
5431                {
5432                        fseek(fil, 6, SEEK_CUR);
5433                        byte = fgetc(fil);
5434                        len = byte;
5435                        byte = fgetc(fil);
5436                        fgets(zeichen, len, fil);
5437                        if(Beschreibung == 0)
5438                        {
5439                                if(byte != 0x05)
5440                                        sprintf(buf, "%c%s", byte, zeichen);
5441                                else
5442                                        sprintf(buf, "%s", zeichen);
5443                                Beschreibung = 1;
5444                        }
5445                        else
5446                        {
5447                                if(byte != 0x05)
5448                                        sprintf(buf, "%c%s", byte, zeichen);
5449                                else
5450                                        sprintf(buf, "%s", zeichen);
5451                        }
5452
5453                        buf1oldsize = buf1size;
5454                        buf1size += strlen(buf);
5455                        tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
5456                        if(buf1 == NULL)
5457                        {
5458                                err("no mem");
5459                                free(zeichen);
5460                                free(buf);
5461                                free(tmpbuf1);
5462                                fclose(fil);
5463                                return NULL;
5464                        }
5465                        sprintf(buf1 + buf1oldsize, "%s", buf);
5466
5467                }
5468                else
5469                {
5470                        byte = fgetc(fil);
5471                        len= byte;
5472                        fgets(zeichen, len + 1, fil);
5473                }
5474        }
5475        free(zeichen);
5476        free(buf);
5477        fclose(fil);
5478        return buf1;
5479}
5480
5481char* command(char* input)
5482{
5483        int maxlen = 0, pos = 0;
5484        char* tmpstr = NULL, *fileline = NULL;
5485        FILE *iopipe = NULL;
5486
5487        if(input == NULL) return NULL;
5488
5489        fileline = malloc(MINMALLOC);
5490        if(fileline == NULL)
5491        {
5492                err("no mem");
5493                return NULL;
5494        }
5495
5496        if((iopipe = popen(input, "r")) == NULL)
5497        {
5498                free(fileline);
5499                return NULL;
5500        }
5501
5502        while(!feof(iopipe))
5503        {
5504                if(fgets(fileline, MINMALLOC, iopipe) != NULL)
5505                        ostrcatbig(&tmpstr, fileline, &maxlen, &pos);
5506        }
5507
5508        if(pos > 0)
5509        {
5510                char* tmp = tmpstr;
5511                tmpstr = realloc(tmpstr, pos + 1);
5512                if(tmpstr == NULL)
5513                        tmpstr = tmp;
5514        }
5515
5516        free(fileline);
5517        pclose(iopipe);
5518        return tmpstr;
5519}
5520
5521char* string_tolower(char *str)
5522{
5523/*
5524        char *p1 = str;
5525
5526        if(str == NULL) return NULL;
5527
5528        while(*p1 != '\0')
5529                *p1++ = tolower(*p1);
5530
5531        return str;
5532*/
5533        if(str == NULL) return NULL;
5534
5535        int i=0;
5536        while (str[i])
5537        {
5538                str[i] = tolower(str[i]);
5539                i++;
5540        }
5541        return str;
5542}
5543
5544char* string_toupper(char *str)
5545{
5546/*
5547        char *p1 = str;
5548
5549        if(str == NULL) return NULL;
5550
5551        while(*p1 != '\0')
5552                *p1++ = toupper(*p1);
5553
5554*/
5555        if(str == NULL) return NULL;
5556
5557        int i=0;
5558        while (str[i])
5559        {
5560                str[i] = toupper(str[i]);
5561                i++;
5562        }
5563        return str;
5564}
5565
5566char* stringreplacecharonce(char *str, char c1, char c2)
5567{
5568        char *p1 = str;
5569
5570        if(str == NULL) return NULL;
5571
5572        while(*p1 != '\0')
5573        {
5574                if(*p1 == c1)
5575                {
5576                        *p1 = c2;
5577                        break;
5578                }
5579                p1++;
5580        }
5581
5582        return str;
5583}
5584
5585char* stringreplacechar(char *str, char c1, char c2)
5586{
5587        char *p1 = str;
5588
5589        if(str == NULL) return NULL;
5590
5591        while(*p1 != '\0')
5592        {
5593                if(*p1 == c1) *p1 = c2;
5594                p1++;
5595        }
5596
5597        return str;
5598}
5599
5600
5601char* string_removechar(char *str)
5602{
5603        char *p1 = str;
5604
5605        if(str == NULL) return NULL;
5606
5607        while(*p1 != '\0')
5608        {
5609                if(*p1 == '.') *p1 = ' ';
5610                else if(*p1 == '-') *p1 = ' ';
5611                else if(*p1 == '_') *p1 = ' ';
5612                else if(*p1 == '/') *p1 = ' ';
5613                p1++;
5614        }
5615
5616        return str;
5617}
5618
5619char* string_withchars2return(char *str)
5620{
5621        char *p1 = str;
5622
5623        if(str == NULL) return NULL;
5624
5625        while(*p1 != '\0')
5626        {
5627                if(*p1 == ' ') *p1 = '\n';
5628                p1++;
5629        }
5630
5631        return str;
5632}
5633
5634char* string_remove_whitechars(char *text)
5635{
5636        char *p1 = text, *p2 = text;
5637
5638        if(text == NULL) return NULL;
5639
5640        while(*p1 != '\0')
5641        {
5642                if(*p1 == ' ')
5643                        ++p1;
5644                else
5645                        *p2++ = *p1++;
5646        }
5647        *p2 = '\0';
5648
5649        return text;
5650}
5651
5652char* strstrip(char *text)
5653{
5654        char* tmpstr = text;
5655
5656        if(text == NULL) return NULL;
5657        int len = strlen(text);
5658
5659        while(isspace(tmpstr[len - 1])) tmpstr[--len] = '\0';
5660        while(*tmpstr && isspace(*tmpstr)) ++tmpstr, --len;
5661
5662        if(text != tmpstr) memmove(text, tmpstr, len + 1);
5663
5664        return text;
5665}
5666
5667char* string_strip_whitechars(char *text)
5668{
5669        char *p1 = text, *p2 = text;
5670
5671        if(text == NULL)
5672                return NULL;
5673
5674        while(*p1 != '\0')
5675        {
5676                if(*p1 == ' ' && *(p1 + 1) == ' ')
5677                        ++p1;
5678                else
5679                        *p2++ = *p1++;
5680        }
5681        *p2 = '\0';
5682
5683        return text;
5684}
5685
5686char* string_replace_all(char *search, char *replace, char *string, int free1)
5687{
5688        char* tmpstr = NULL;
5689        char* searchpos = NULL;
5690
5691        if(string == NULL || search == NULL)
5692        {
5693                tmpstr = ostrcat(tmpstr, string, 1, 0);
5694                if(free1 == 1) free(string);
5695                return tmpstr;
5696        }
5697
5698        searchpos = strstr(string, search);
5699        if(searchpos == NULL)
5700        {
5701                tmpstr = ostrcat(tmpstr, string, 1, 0);
5702                if(free1 == 1) free(string);
5703                return tmpstr;
5704        }
5705
5706        int count = 0;
5707        int stringlen = strlen(string);
5708        int searchlen = strlen(search);
5709        int replacelen = strlen(replace);
5710
5711        while(searchpos != NULL)
5712        {
5713                count++;
5714                searchpos = strstr(searchpos + searchlen, search);
5715        }
5716
5717        int len = stringlen - (searchlen * count) + (replacelen * count);
5718        tmpstr = calloc(1, len + 1);
5719        if(tmpstr == NULL)
5720        {
5721                err("no mem");
5722                tmpstr = ostrcat(tmpstr, string, 1, 0);
5723                if(free1 == 1) free(string);
5724                return tmpstr;
5725        }
5726
5727        len = 0;
5728        char* str = string;
5729        char* tmp = tmpstr;
5730        searchpos = strstr(str, search);
5731        while(searchpos != NULL)
5732        {
5733                len = searchpos - str;
5734                memcpy(tmp, str, len);
5735                memcpy(tmp + len, replace, replacelen);
5736                tmp += len + replacelen;
5737                str += len + searchlen;
5738                searchpos = strstr(str, search);
5739        }
5740        memcpy(tmp, str, strlen(str));
5741
5742        if(free1 == 1) free(string);
5743
5744        return tmpstr;
5745}
5746
5747char* string_replace_remove_last_chars(char *search, char *replace, char *string, int free1)
5748{
5749        char* searchpos = NULL;
5750        char* tmpstr = NULL;
5751
5752        if(string == NULL || search == NULL)
5753        {
5754                tmpstr = ostrcat(tmpstr, string, 1, 0);
5755                if(free1 == 1) free(string);
5756                return tmpstr;
5757        }
5758
5759        searchpos = ostrstr(string, search);
5760
5761        if(searchpos == NULL)
5762        {
5763                tmpstr = ostrcat(tmpstr, string, 1, 0);
5764                if(free1 == 1) free(string);
5765                return tmpstr;
5766        }
5767
5768        tmpstr = strndup(string, searchpos - string);
5769        if(replace != NULL)
5770                tmpstr = ostrcat(tmpstr, replace, 1, 0);
5771
5772        if(free1 == 1) free(string);
5773
5774        return tmpstr;
5775}
5776
5777char* string_replace(char *search, char *replace, char *string, int free1)
5778{
5779        char* searchpos = NULL;
5780        char* tmpstr = NULL;
5781
5782        if(string == NULL || search == NULL)
5783        {
5784                tmpstr = ostrcat(tmpstr, string, 1, 0);
5785                if(free1 == 1) free(string);
5786                return tmpstr;
5787        }
5788
5789        searchpos = ostrstr(string, search);
5790
5791        if(searchpos == NULL)
5792        {
5793                tmpstr = ostrcat(tmpstr, string, 1, 0);
5794                if(free1 == 1) free(string);
5795                return tmpstr;
5796        }
5797
5798        tmpstr = strndup(string, searchpos - string);
5799        if(replace != NULL)
5800                tmpstr = ostrcat(tmpstr, replace, 1, 0);
5801        tmpstr = ostrcat(tmpstr, string + (searchpos - string) + strlen(search), 1, 0);
5802
5803        if(free1 == 1) free(string);
5804
5805        return tmpstr;
5806}
5807
5808//flag 0: search full str
5809//flag 1: search only end of string
5810char* ostrrstrcase(char* str, char* search, int len, int flag)
5811{
5812        int slen = 0;
5813        char* tmpstr = NULL;
5814
5815        if(str == NULL || search == NULL) return NULL;
5816
5817        if(len == -1) len = strlen(str);
5818        slen = strlen(search);
5819        if(slen > len) return NULL;
5820
5821        for(tmpstr = str + len - slen; tmpstr >= str; tmpstr--)
5822        {
5823                if(strncasecmp(tmpstr, search, slen) == 0)
5824                        return tmpstr;
5825                if(flag == 1) return NULL;
5826        }
5827
5828        return NULL;
5829}
5830
5831//flag 0: search full str
5832//flag 1: search only end of string
5833char* ostrrstr(char* str, char* search, int len, int flag)
5834{
5835        int slen = 0;
5836        char* tmpstr = NULL;
5837
5838        if(str == NULL || search == NULL) return NULL;
5839
5840        if(len == -1) len = strlen(str);
5841        slen = strlen(search);
5842        if(slen > len) return NULL;
5843
5844        for(tmpstr = str + len - slen; tmpstr >= str; tmpstr--)
5845        {
5846                if(strncmp(tmpstr, search, slen) == 0)
5847                        return tmpstr;
5848                if(flag == 1) return NULL;
5849        }
5850
5851        return NULL;
5852}
5853
5854char* ostrstr(char* str, char* search)
5855{
5856        char* ret = NULL;
5857
5858        if(str == NULL || search == NULL) return NULL;
5859        ret = strstr(str, search);
5860
5861        return ret;
5862}
5863
5864int file_exist(char* filename)
5865{
5866        if(access(filename, F_OK) == 0)
5867                return 1;
5868        else
5869                return 0;
5870}
5871
5872char* string_newline(char* str)
5873{
5874        if(str == NULL) return NULL;
5875
5876        int size = strlen(str);
5877
5878        if(str[size - 1] == '\n')
5879                str[size - 1] = '\0';
5880
5881        return str;
5882}
5883
5884char* string_quote(char* str)
5885{
5886        char* tmpstr = NULL;
5887
5888        tmpstr = ostrcat("\"", str, 0, 0);
5889        tmpstr = ostrcat(tmpstr, "\"", 1, 0);
5890
5891        return tmpstr;
5892}
5893
5894struct splitstr* strsplit(char *str, char *tok, int* count)
5895{
5896        char *tmpstr = NULL;
5897        struct splitstr *array = NULL, *tmparray = NULL;
5898        *count = 0;
5899
5900        if(str == NULL || tok == NULL)
5901                return NULL;
5902
5903        tmpstr = strtok(str, tok);
5904        while(tmpstr != NULL)
5905        {
5906                *count = *count + 1;
5907                tmparray = array; array = (struct splitstr*)realloc(array, sizeof(struct splitstr*) * (*count));
5908                if(array == NULL)
5909                {
5910                        err("no mem");
5911                        free(tmparray);
5912                        return NULL;
5913                }
5914
5915                (&array[(*count) - 1])->part = tmpstr;
5916                tmpstr = strtok(NULL, tok);
5917        }
5918
5919        return array;
5920}
5921
5922char* string_shortname(char *tmpfilename, int mode)
5923{
5924        debug(50, "in %s", tmpfilename);
5925
5926//      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";
5927        char* str = NULL;
5928
5929        if(mode==1)
5930        {
5931                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";
5932                str = ostrcat(str, replacelist, 1, 0);
5933        }
5934        else if(mode==2)
5935        {
5936                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";
5937                str = ostrcat(str, replacelist, 1, 0);
5938        }
5939        else
5940        {
5941                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";
5942                str = ostrcat(str, replacelist, 1, 0);
5943        }
5944
5945        char* replace = NULL;
5946        struct splitstr* ret1 = NULL;
5947        int count = 0;
5948        int i = 0;
5949        ret1 = strsplit(str, " ", &count);
5950        int max = count - 1;
5951        int first = 1;
5952
5953        for(i = 0; i < max; i++)
5954        {
5955                struct splitstr* ret2 = NULL;
5956                int count2 = 0;
5957                int j = 0;
5958                char *tmpstr = NULL;
5959                tmpstr = ostrcat(tmpstr, tmpfilename, 1, 0);
5960                ret2 = strsplit(tmpstr, " ,.-_", &count2);
5961
5962                for(j = 0; j < count2; j++)
5963                {
5964                        if(j > 0)
5965                        {
5966                                if(ostrcmp((&ret1[i])->part, (&ret2[j])->part) == 0)
5967                                {
5968                                        if(mode==1)
5969                                        {
5970                                                tmpfilename = string_replace((&ret2[j])->part, replace, tmpfilename, 1);
5971                                                continue;
5972                                        }
5973                                        else if(mode==2)
5974                                        {
5975                                                tmpfilename = string_replace_remove_last_chars((&ret2[j])->part, replace, tmpfilename, 1);
5976                                                //break;
5977                                                continue;
5978                                        }
5979                                        else
5980                                        {
5981                                                tmpfilename = string_replace((&ret2[j])->part, replace, tmpfilename, 1);
5982                                                continue;
5983                                        }
5984                                }
5985                                else if(first == 1 && mode == 2)
5986                                {
5987//                                      printf("zahl: %s\n", (&ret2[j])->part);
5988                                        int theCharacter = atoi((&ret2[j])->part);
5989                                        if(theCharacter != 0)
5990                                        {
5991//                                              printf("found zahl: %s\n", (&ret2[j])->part);
5992                                                if(theCharacter > 1800 && theCharacter < 2100)
5993                                                {
5994//                                                      printf("found year: %s\n", (&ret2[j])->part);
5995                                                        tmpfilename = string_replace_remove_last_chars((&ret2[j])->part, "", tmpfilename, 1);
5996                                                        break;
5997                                                }
5998                                        }
5999                                }
6000                        }
6001                }
6002                free(ret2); ret2 = NULL;
6003                first = 0;
6004                free(tmpstr), tmpstr = NULL;
6005        }
6006
6007        free(ret1); ret1 = NULL;
6008        free(replace); replace = NULL;
6009        free(str); str = NULL;
6010
6011        debug(50, "out %s", tmpfilename);
6012        return tmpfilename;
6013}
6014
6015char* get_uuid(char* device)
6016{
6017        debug(60, "in %s", device);
6018        char* cmd = NULL, *tmpstr = NULL;
6019
6020        if(device == NULL) return NULL;
6021#ifdef MIPSEL
6022        cmd = ostrcat(cmd, "blkid -w /dev/null -c /dev/null -s UUID /dev/", 1, 0);
6023#else
6024        cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s UUID /dev/", 1, 0);
6025#endif
6026        cmd = ostrcat(cmd, device, 1, 0);
6027        cmd = ostrcat(cmd, " | cut -d'\"' -f2", 1, 0);
6028
6029        tmpstr = string_newline(command(cmd));
6030
6031        if(ostrcmp(string_newline(tmpstr), "") == 0)
6032        {
6033                free(tmpstr); tmpstr = NULL;
6034        }
6035
6036        debug(60, "out %s", cmd);
6037        free(cmd); cmd = NULL;
6038        return tmpstr;
6039}
6040
6041char* get_label(char* device)
6042{
6043        debug(60, "in %s", device);
6044        char* cmd = NULL, *tmpstr = NULL;
6045
6046        if(device == NULL) return NULL;
6047#ifdef MIPSEL
6048        cmd = ostrcat(cmd, "blkid -w /dev/null -c /dev/null -s LABEL /dev/", 1, 0);
6049#else
6050        cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s LABEL /dev/", 1, 0);
6051#endif
6052        cmd = ostrcat(cmd, device, 1, 0);
6053        cmd = ostrcat(cmd, " | cut -d'\"' -f2", 1, 0);
6054
6055        tmpstr = string_newline(command(cmd));
6056
6057        if(tmpstr == NULL)
6058                tmpstr = ostrcat(tmpstr, "NONLABEL", 1, 0);
6059
6060        if(ostrcmp(string_newline(tmpstr), "") == 0)
6061                tmpstr = ostrcat(tmpstr, "NONLABEL", 1, 0);
6062
6063        debug(60, "out %s", cmd);
6064        free(cmd); cmd = NULL;
6065        return tmpstr;
6066}
6067
6068char* get_filesystem(char* device)
6069{
6070        debug(60, "in %s", device);
6071        char* cmd = NULL, *tmpstr = NULL;
6072
6073        if(device == NULL) return NULL;
6074#ifdef MIPSEL
6075        cmd = ostrcat(cmd, "blkid -w /dev/null -c /dev/null -s TYPE /dev/", 1, 0);
6076#else
6077        cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s TYPE /dev/", 1, 0);
6078#endif
6079        cmd = ostrcat(cmd, device, 1, 0);
6080        cmd = ostrcat(cmd, " | cut -d'\"' -f2", 1, 0);
6081
6082        tmpstr = string_newline(command(cmd));
6083
6084        if(tmpstr == NULL)
6085                tmpstr = ostrcat(tmpstr, "NONTYPE", 1, 0);
6086
6087        if(ostrcmp(string_newline(tmpstr), "") == 0)
6088                tmpstr = ostrcat(tmpstr, "NONTYPE", 1, 0);
6089
6090        debug(60, "out %s", cmd);
6091        free(cmd); cmd = NULL;
6092        return tmpstr;
6093}
6094
6095//flag 0: convert ip to 000.000.000.000
6096//flag 1: convert ip to 0.0.0.0
6097char* fixip(char* ipinput, int flag)
6098{
6099        debug(60, "in %s", ipinput);
6100        int ret = 0;
6101        char* ipout = NULL;
6102        unsigned char ip[4];
6103
6104        ip[0] = 0;
6105        ip[1] = 0;
6106        ip[2] = 0;
6107        ip[3] = 0;
6108
6109        if(ipinput == NULL) return NULL;
6110        ret = sscanf(ipinput, "%hhu.%hhu.%hhu.%hhu", &ip[0], &ip[1], &ip[2], &ip[3]);
6111        if(ret != 4) return NULL;
6112
6113        ipout = malloc(16);
6114        if(ipout == NULL)
6115        {
6116                err("no mem");
6117                return NULL;
6118        }
6119
6120        if(flag == 1)
6121                snprintf(ipout, 16, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
6122        else
6123                snprintf(ipout, 16, "%03d.%03d.%03d.%03d", ip[0], ip[1], ip[2], ip[3]);
6124
6125        return ipout;
6126}
6127
6128void setfanspeed(int speed, int aktion)
6129{
6130        char* speedWert = NULL;
6131        char* speedSet = NULL;
6132        int base = 0;
6133
6134        if(checkbox("UFS922") == 1)
6135                base = 100;
6136        else
6137                base = -15;
6138
6139
6140        if(speed < 0)
6141        {
6142                if(speed == -1)
6143                        speedWert = getconfig("fanspeed", NULL);
6144                else
6145                        speedWert = getconfig("fanspeedstandby", NULL);
6146                if(speedWert == NULL)
6147                        speedSet = ostrcat(speedSet, oitoa(base + 70), 1, 1);
6148                else
6149                        speedSet = ostrcat(speedSet, speedWert, 1, 0);
6150        }
6151        else
6152        {
6153                if(speed == 0)
6154                        speedSet = ostrcat(speedSet, oitoa(base + 15), 1, 1);
6155                else if(speed == 25)
6156                        speedSet = ostrcat(speedSet, oitoa(base + 30), 1, 1);
6157                else if(speed == 50)
6158                        speedSet = ostrcat(speedSet, oitoa(base + 45), 1, 1);
6159                else if(speed == 75)
6160                        speedSet = ostrcat(speedSet, oitoa(base + 55), 1, 1);
6161                else
6162                        speedSet = ostrcat(speedSet, oitoa(base + 70), 1, 1);
6163        }
6164
6165        if(checkbox("UFS922") == 1)
6166                writesys("/proc/stb/fan/fan_ctrl", speedSet, 1);
6167        else
6168                writesys("/proc/stb/fp/fan_pwm", speedSet, 1);
6169
6170        if(aktion == 1)
6171                addconfig("fanspeed", speedSet);
6172        else if(aktion == 2)
6173                addconfig("fanspeedstandby", speedSet);
6174
6175        free(speedSet); speedSet=NULL;
6176}
6177
6178void setaktres()
6179{
6180        int m_width = 0;
6181        char* res = NULL;
6182        char* res_akt = NULL;
6183        char* res_sd = NULL;
6184        int count = 1;
6185        int sec = 0;
6186
6187        m_lock(&status.setaktresmutex, 23);
6188
6189        if(status.restimer == NULL)
6190                goto end;
6191
6192        sec = (int)status.restimer->param1;
6193
6194        if(sec > 0)
6195        {
6196                while(status.restimer->aktion == START && count <= (sec * 10))
6197                {
6198                        usleep(100000);
6199                        if(status.restimer->aktion != START)
6200                                goto end;
6201                        count++;
6202                }
6203        }
6204        if(status.restimer->aktion != START) goto end;
6205
6206        if(videoreadqwidth(status.aktservice->videodev) == 0)
6207        {
6208                if(status.restimer->aktion != START) goto end;
6209                m_width = status.videosize.w;
6210                if(m_width == 720)
6211                {
6212                        res_sd = getconfig("av_videomode_autores_sd", NULL);
6213                        if(res_sd == NULL)
6214                                res = ostrcat(res, "576i50", 1, 0);
6215                        else
6216                                res = ostrcat(res, res_sd, 1, 0);
6217                }
6218                else if (m_width == 1280)
6219                        res = ostrcat(res, "720p50", 1, 0);
6220                else if (m_width == 1920)
6221                        res = ostrcat(res, "1080i50", 1, 0);
6222                else
6223                        m_width = 0;
6224
6225                if(m_width > 0)
6226                {
6227                        if(status.restimer->aktion != START) goto end;
6228                        res_akt = getvideomode();
6229                        if(status.restimer->aktion != START) goto end;
6230                        if(ostrcmp(res_akt, res) != 0)
6231                        {
6232                                if(status.restimer->aktion != START) goto end;
6233                                setvideomode(res, 1);
6234                                changefbresolution(res, 1);
6235/*
6236                                if(status.restimer->aktion != START) goto end;
6237
6238                                count = 0;
6239                                while(status.restimer->aktion == START && count < 10)
6240                                {
6241                                        usleep(100000);
6242                                        if(status.restimer->aktion != START)
6243                                                goto end;
6244                                        count++;
6245                                }
6246
6247                                if(status.restimer->aktion != START) goto end;
6248*/
6249                                screenautores(res, 5, 0);
6250                        }
6251                }
6252        }
6253        else
6254        {
6255                if(status.restimer->aktion != START) goto end;
6256                if(status.servicetype == 0)
6257                        textbox(_("Message"), _("ERROR cant read res"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 5, 0);
6258        }
6259
6260end:
6261        free(res); res = NULL;
6262        status.restimer = NULL;
6263        m_unlock(&status.setaktresmutex, 23);
6264        return;
6265}
6266
6267char* gettimestamp()
6268{
6269        char* timestamp = NULL;
6270        struct timeval numtime;
6271
6272        gettimeofday(&numtime, 0);
6273        timestamp = ostrcat(timestamp, olutoa(numtime.tv_sec), 1, 1);
6274        timestamp = ostrcat(timestamp, olutoa(numtime.tv_usec), 1, 1);
6275
6276        return timestamp;
6277}
6278
6279char* string_decode(char* input, int flag)
6280{
6281        if(input == NULL) return input;
6282
6283        while(ostrstr(input, "\\u00") != NULL)
6284        {
6285                debug(210, "input: %s", input);
6286                input = string_replace("\\u00", "%", input, 1);
6287                debug(210, "input: %s", input);
6288        }
6289
6290        while(ostrstr(input, "&amp;") != NULL)
6291        {
6292                debug(210, "input: %s", input);
6293                input = string_replace("&amp;", "und", input, 1);
6294                debug(210, "input: %s", input);
6295        }
6296
6297        while(ostrstr(input, "&gt;") != NULL)
6298        {
6299                debug(210, "input: %s", input);
6300                input = string_replace("&gt;", ">", input, 1);
6301                debug(210, "input: %s", input);
6302        }
6303
6304        while(ostrstr(input, "&lt;") != NULL)
6305        {
6306                debug(210, "input: %s", input);
6307                input = string_replace("&lt;", "<", input, 1);
6308                debug(210, "input: %s", input);
6309        }
6310
6311        while(ostrstr(input, "&quot;") != NULL)
6312        {
6313                debug(210, "input: %s", input);
6314                input = string_replace("&quot;", "\"", input, 1);
6315                debug(210, "input: %s", input);
6316        }
6317
6318        while(ostrstr(input, "&#x") != NULL)
6319        {
6320                debug(210, "out %s", input);
6321                input = string_replace("&#x", "%", input, 1);
6322                debug(210, "input: %s", input);
6323        }
6324
6325        while(ostrstr(input, "&#") != NULL)
6326        {
6327                debug(210, "input: %s", input);
6328                input = string_replace("&#", "%", input, 1);
6329                debug(210, "input: %s", input);
6330        }
6331
6332        if(flag == 1)
6333                htmldecode2(input, input);
6334        else
6335                htmldecode(input, input);
6336
6337        while(ostrstr(input, ";") != NULL)
6338        {
6339                debug(210, "input: %s", input);
6340                input = string_replace(";", NULL, input, 1);
6341                debug(210, "input: %s", input);
6342        }
6343
6344        return input;
6345}
6346
6347char* string_deltags(char* str)
6348{
6349        int i = 0, y = 0, len = 0;
6350
6351        if(str == NULL) return 0;
6352
6353        len = strlen(str);
6354
6355        int skip = 0;
6356        for(i = 0; i < len; i++)
6357        {
6358                if(str[i] == '<')
6359                        skip = 1;
6360                else if(str[i] == '>')
6361                        skip = 0;
6362
6363                if(skip == 0 && str[i] != '>')
6364                {
6365                        str[y] = str[i];
6366                        y++;
6367                }
6368        }
6369        str[y] = '\0';
6370
6371        return str;
6372}
6373
6374char* string_striptags(char* str)
6375{
6376        int i = 0, len = 0;
6377
6378        if(str == NULL) return 0;
6379
6380        len = strlen(str);
6381
6382        int skip = 0;
6383        for(i = 0; i < len; i++)
6384        {
6385                if(str[i] == '<')
6386                        skip = 1;
6387                else if(str[i] == '>')
6388                {
6389                        skip = 0;
6390                        str[i] = ' ';
6391                }
6392                if(skip == 1)
6393                        str[i] = ' ';
6394        }
6395
6396        return strstrip(str);
6397}
6398
6399char* string_resub(char* str, char* str2, char* input, int dir)
6400{
6401        char* tmpstr = NULL, *pos = NULL, *pos2 = NULL;
6402
6403        if(str == NULL || str2 == NULL || input == NULL) return NULL;
6404
6405        if(dir == 0)
6406        {
6407                pos = ostrstr(input, str);
6408                if(pos == NULL) return NULL;
6409                pos += strlen(str);
6410
6411                pos2 = ostrstr(pos, str2);
6412                if(pos2 == NULL) return NULL;
6413        }
6414        else
6415        {
6416                pos2 = ostrstr(input, str2);
6417                if(pos2 == NULL) return NULL;
6418
6419                pos = ostrrstr(input, str, pos2 - input, 0);
6420                if(pos == NULL) return NULL;
6421                pos += strlen(str);
6422        }
6423
6424        tmpstr = strndup(pos, pos2 - pos);
6425
6426        return strstrip(tmpstr);
6427}
6428
6429char* ostrstrcase(char* str, char* sub)
6430{
6431        size_t len = 0;
6432
6433        if(str == NULL || sub == NULL) return NULL;
6434
6435        len = strlen(sub);
6436        while(*str)
6437        {
6438                if(toupper(*str) == toupper(*sub) && strncasecmp(str, sub, len) == 0)
6439                        return str;
6440                ++str;
6441        }
6442        return NULL;
6443}
6444
6445//flag 0: convert port to 00021
6446//flag 1: convert port to 21
6447char* fixport(char* input, int flag)
6448{
6449        char* tmpstr = NULL;
6450
6451        if(flag == 0)
6452        {
6453                int plen = strlen(input);
6454                if(plen < 5)
6455                {
6456                        int i;
6457                        for(i = 0; i < 5 - plen; i++)
6458                                tmpstr = ostrcat(tmpstr, "0", 1, 0);
6459                }
6460                tmpstr = ostrcat(tmpstr, input, 1, 0);
6461        }
6462        else
6463        {
6464                while (*input && *input == '0')
6465                input++;
6466
6467                tmpstr = ostrcat(tmpstr, input, 1, 0);
6468        }
6469        return tmpstr;
6470}
6471
6472//flag 0: Mon > Montag
6473//flag 1: Mon > Mon
6474//flag 2: Monday > Montag
6475//flag 3: January > Januar
6476char* translate_time(char* input, int flag)
6477{
6478        char* tmpstr = NULL;
6479        if(input == NULL) return tmpstr;
6480        tmpstr = ostrcat(tmpstr, input, 1, 1);
6481
6482        if(flag == 0)
6483        {
6484                tmpstr = string_replace_all("Mon", _("Monday"), tmpstr, 1);
6485                tmpstr = string_replace_all("Tue", _("Tuesday"), tmpstr, 1);
6486                tmpstr = string_replace_all("Wed", _("Wednesday"), tmpstr, 1);
6487                tmpstr = string_replace_all("Thu", _("Thursday"), tmpstr, 1);
6488                tmpstr = string_replace_all("Fri", _("Friday"), tmpstr, 1);
6489                tmpstr = string_replace_all("Sat", _("Saturday"), tmpstr, 1);
6490                tmpstr = string_replace_all("Sun", _("Sunday"), tmpstr, 1);
6491        }
6492        else if(flag == 2)
6493        {
6494                tmpstr = string_replace_all("Monday", _("Monday"), tmpstr, 1);
6495                tmpstr = string_replace_all("Tuesday", _("Tuesday"), tmpstr, 1);
6496                tmpstr = string_replace_all("Wednesday", _("Wednesday"), tmpstr, 1);
6497                tmpstr = string_replace_all("Thursday", _("Thursday"), tmpstr, 1);
6498                tmpstr = string_replace_all("Friday", _("Friday"), tmpstr, 1);
6499                tmpstr = string_replace_all("Saturday", _("Saturday"), tmpstr, 1);
6500                tmpstr = string_replace_all("Sunday", _("Sunday"), tmpstr, 1);
6501        }
6502        else if(flag == 3)
6503        {
6504                tmpstr = string_replace_all("January", _("January"), tmpstr, 1);
6505                tmpstr = string_replace_all("February", _("February"), tmpstr, 1);
6506                tmpstr = string_replace_all("March", _("March"), tmpstr, 1);
6507                tmpstr = string_replace_all("April", _("April"), tmpstr, 1);
6508                tmpstr = string_replace_all("May", _("May"), tmpstr, 1);
6509                tmpstr = string_replace_all("June", _("June"), tmpstr, 1);
6510                tmpstr = string_replace_all("July", _("July"), tmpstr, 1);
6511                tmpstr = string_replace_all("August", _("August"), tmpstr, 1);
6512                tmpstr = string_replace_all("September", _("September"), tmpstr, 1);
6513                tmpstr = string_replace_all("October", _("October"), tmpstr, 1);
6514                tmpstr = string_replace_all("November", _("November"), tmpstr, 1);
6515                tmpstr = string_replace_all("December", _("December"), tmpstr, 1);
6516        }
6517        else
6518        {
6519                tmpstr = string_replace("Mon", _("Mon"), tmpstr, 1);
6520                tmpstr = string_replace("Tue", _("Tue"), tmpstr, 1);
6521                tmpstr = string_replace("Wed", _("Wed"), tmpstr, 1);
6522                tmpstr = string_replace("Thu", _("Thu"), tmpstr, 1);
6523                tmpstr = string_replace("Fri", _("Fri"), tmpstr, 1);
6524                tmpstr = string_replace("Sat", _("Sat"), tmpstr, 1);
6525                tmpstr = string_replace("Sun", _("Sun"), tmpstr, 1);
6526        }
6527
6528        return tmpstr;
6529}
6530
6531char* gethypridtunerchoices(int dev)
6532{
6533        char *value = NULL;
6534        char *hypridtunerchoices = NULL;
6535        char *tmpstr = NULL;
6536        char *tmpstr1 = NULL;
6537        char* start = NULL;
6538
6539#ifdef MIPSEL
6540        char *tmpstr2 = NULL;
6541        char *tmpstr3 = NULL;
6542#endif
6543
6544
6545        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
6546
6547        if(hypridtunerchoices == NULL)
6548        {
6549                err("NULL detect");
6550                return NULL;
6551        }
6552
6553        tmpstr = readfiletomem(hypridtunerchoices, 1);
6554        if(tmpstr == NULL)
6555        {
6556                err("NULL detect");
6557                return NULL;
6558        }
6559
6560        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
6561        start = ostrcat(start, ":", 1, 0);
6562
6563#ifdef MIPSEL
6564
6565        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
6566        tmpstr2 = string_resub("Mode ", ":", tmpstr1, 0);
6567        tmpstr3 = oregex(".*Mode ([0-9]{1}):.*", tmpstr1);
6568
6569        if(tmpstr2 != NULL)
6570                value = ostrcat(tmpstr2, "\n", 0, 0);
6571        if(tmpstr3 != NULL)
6572                value = ostrcat(value, tmpstr3, 1, 0);
6573
6574        free(start), start = NULL;
6575        free(tmpstr), tmpstr = NULL;
6576        free(tmpstr1), tmpstr1 = NULL;
6577        free(tmpstr2), tmpstr2 = NULL;
6578        free(tmpstr3), tmpstr3 = NULL;
6579#else
6580        tmpstr1 = string_resub(start, "Frontend_Device", tmpstr, 0);
6581        free(start), start = NULL;
6582
6583        printf("---gethypridtunerchoices--------------------------------\n");
6584        printf("tmpstr1: %s\n", tmpstr1);
6585
6586        if(ostrstr(tmpstr1, "(T/C)") != NULL)
6587        {
6588                value = ostrcat("t", "\n", 0, 0);
6589                value = ostrcat(value, "c", 1, 0);
6590        }
6591        printf("value: %s\n", value);
6592        printf("---gethypridtunerchoices--------------------------------\n");
6593
6594        free(tmpstr1), tmpstr1 = NULL;
6595#endif
6596        return value;
6597}
6598
6599char* gethypridtunerchoicesvalue(int dev)
6600{
6601        char* hypridtunerchoices = NULL, *value = NULL, *tmpstr = NULL, *tmpstr1 = NULL, *start = NULL;
6602
6603#ifdef MIPSEL
6604        char* tmpstr2 = NULL, *hypridlist = NULL;
6605#endif
6606
6607        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
6608
6609        if(hypridtunerchoices == NULL)
6610        {
6611                err("NULL detect");
6612                return NULL;
6613        }
6614
6615        tmpstr = readfiletomem(hypridtunerchoices, 1);
6616        if(tmpstr == NULL)
6617        {
6618                err("NULL detect");
6619                return NULL;
6620        }
6621
6622        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
6623        start = ostrcat(start, ":", 1, 0);
6624#ifdef MIPSEL
6625        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
6626        free(start), start = NULL;
6627
6628        hypridlist = gethypridtunerchoices(dev);
6629
6630        int count = 0;
6631        int i = 0;
6632        struct splitstr* ret1 = NULL;
6633        ret1 = strsplit(hypridlist, "\n", &count);
6634
6635        if(ret1 != NULL)
6636        {
6637                int max = count;
6638                for(i = 0; i < max; i++)
6639                {
6640                        start = ostrcat("Mode ", ret1[i].part, 0, 0);
6641                        start = ostrcat(start, ":", 1, 0);
6642                        tmpstr2 = string_resub(start, "\n", tmpstr1, 0);
6643
6644                        if(i > 0)
6645                                value = ostrcat(value, "\n", 1, 0);
6646
6647                        if(tmpstr2 != NULL)
6648                                value = ostrcat(value, tmpstr2, 1, 0);
6649
6650                        free(tmpstr2), tmpstr2 = NULL;
6651                        free(start), start = NULL;
6652                }
6653        }
6654        free(ret1), ret1 = NULL;
6655        free(tmpstr1), tmpstr1 = NULL;
6656        free(hypridlist), hypridlist = NULL;
6657#else
6658        tmpstr1 = string_resub(start, "Frontend_Device", tmpstr, 0);
6659        free(start), start = NULL;
6660
6661        printf("---gethypridtunerchoicesvalue--------------------------------\n");
6662        printf("tmpstr1: %s\n", tmpstr1);
6663
6664        if(ostrstr(tmpstr1, "(T/C)") != NULL)
6665        {
6666                value = ostrcat("DVB-T", "\n", 0, 0);
6667                value = ostrcat(value, "DVB-C", 1, 0);
6668        }
6669        printf("value: %s\n", value);
6670        printf("---gethypridtunerchoicesvalue--------------------------------\n");
6671        free(tmpstr1), tmpstr1 = NULL;
6672#endif
6673
6674        return value;
6675}
6676
6677char* gethypridtunerchoicesvaluename(int dev, char* hyprid)
6678{
6679
6680        char* value = NULL;
6681#ifdef MIPSEL
6682        char* hypridtunerchoices = NULL, *tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL, *start = NULL;
6683
6684        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
6685
6686        if(hypridtunerchoices == NULL)
6687        {
6688                err("NULL detect");
6689                return NULL;
6690        }
6691
6692        tmpstr = readfiletomem(hypridtunerchoices, 1);
6693        if(tmpstr == NULL)
6694        {
6695                err("NULL detect");
6696                return NULL;
6697        }
6698
6699        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
6700        start = ostrcat(start, ":", 1, 0);
6701        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
6702        free(start), start = NULL;
6703
6704        start = ostrcat("Mode ", hyprid, 0, 0);
6705        start = ostrcat(start, ":", 1, 0);
6706
6707        tmpstr2 = string_resub(start, "\n", tmpstr1, 0);
6708
6709        if(tmpstr2 != NULL)
6710                value = ostrcat(value, tmpstr2, 1, 0);
6711
6712        free(tmpstr1), tmpstr1 = NULL;
6713        free(tmpstr2), tmpstr2 = NULL;
6714        free(start), start = NULL;
6715#else
6716        printf("---gethypridtunerchoicesvalue--------------------------------\n");
6717        if(ostrstr(hyprid, "t") != NULL)
6718                value = ostrcat("DVB-T", NULL, 0, 0);
6719        else if(ostrstr(hyprid, "c") != NULL)
6720                value = ostrcat("DVB-C", NULL, 0, 0);
6721        printf("value: %s\n", value);
6722        printf("---gethypridtunerchoicesvalue--------------------------------\n");
6723
6724#endif
6725        return value;
6726}
6727
6728#ifdef MIPSEL
6729int sethypridtunernew(struct dvbdev* tuner, char* value)
6730{
6731        int ret = 0;
6732
6733        char* buf = NULL, *hypridtuner = NULL, *tmpstr = NULL;
6734        char* buf1 = NULL;
6735
6736        hypridtuner = getconfig("hypridtuner", NULL);
6737
6738        if(hypridtuner != NULL)
6739        {
6740                buf = malloc(MINMALLOC);
6741                if(buf == NULL)
6742                {
6743                        err("no memory");
6744                        return 0;
6745                }
6746        }
6747
6748        sprintf(buf, hypridtuner, tuner->devnr);
6749        if(buf != NULL)
6750        {
6751                printf("set %s to %s\n", buf, value);
6752                if(file_exist(buf))
6753                {
6754                        buf1 = readsys("/sys/module/dvb_core/parameters/dvb_shutdown_timeout",1);
6755                        ret = writesys("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "0", 1);
6756                        if(ret != 0)
6757                                printf("no /sys/module/dvb_core/parameters/dvb_shutdown_timeout available\n");
6758                        if(tuner->fd > -1)
6759                        {
6760                                feclose(tuner, -1);
6761                                printf("set %s to %s\n", buf, value);
6762                                ret = writesys(buf, value, 0);
6763                                tuner->fd = feopen(tuner, NULL);
6764                        }
6765                        else
6766                        {
6767                                printf("set %s to %s\n", buf, value);
6768                                ret = writesys(buf, value, 0);
6769                        }
6770                        writesys("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", buf1, 1);     
6771                        free(tmpstr); tmpstr = NULL;
6772                        free(buf1); buf1 = NULL;
6773                }
6774                else
6775                {
6776                        //fechangetype(tuner, value); ToDo for future use
6777                        return 0;
6778                }
6779        }
6780        free(buf); buf = NULL;
6781
6782        return 0;
6783}
6784#endif
6785
6786int sethypridtuner(int dev, char* value)
6787{
6788        int ret = 0;
6789
6790#ifdef MIPSEL
6791        char* buf = NULL, *hypridtuner = NULL, *tmpstr = NULL;
6792
6793        hypridtuner = getconfig("hypridtuner", NULL);
6794
6795        if(hypridtuner != NULL)
6796        {
6797                buf = malloc(MINMALLOC);
6798                if(buf == NULL)
6799                {
6800                        err("no memory");
6801                        return 0;
6802                }
6803        }
6804
6805        sprintf(buf, hypridtuner, dev);
6806        if(buf != NULL)
6807        {
6808                printf("set %s to %s\n", buf, value);
6809                ret = writesys(buf, value, 0);
6810                free(tmpstr); tmpstr = NULL;
6811                return ret;
6812        }
6813#else
6814        printf("---sethypridtuner--------------------------------\n");
6815
6816        addconfigtmp("hypridtuner", value);
6817        ret = writeconfigtmp();
6818        writeallconfig(1);
6819
6820        printf("value: %s\n", value);
6821        printf("read titan.cfg: hypridtuner=%s\n", getconfig("frontenddev", NULL));
6822        printf("---sethypridtuner--------------------------------\n");
6823
6824        return ret;
6825#endif
6826        return 0;
6827}
6828
6829int phpkit_userauth(char* link, char* user, char* pass)
6830{
6831        debug(99, "phpkit user: %s", user);
6832        debug(99, "phpkit pass: %s", pass);
6833        debug(99, "phpkit url: %s", link);
6834
6835        int skip = 0;
6836        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;
6837
6838        tmplink = ostrcat(link, NULL, 0, 0);
6839
6840        tmphost = string_replace("http://", "", tmplink, 0);
6841        free(tmplink) , tmplink = NULL;
6842
6843        if(tmphost != NULL)
6844                pos = strchr(tmphost, '/');
6845        if(pos != NULL)
6846        {
6847                pos[0] = '\0';
6848                path = pos + 1;
6849        }
6850
6851        tmppath = ostrcat("/", path, 0, 0);
6852
6853        send = ostrcat(send, "GET ", 1, 0);
6854        send = ostrcat(send, tmppath, 1, 0);
6855        send = ostrcat(send, " HTTP/1.1\r\nHost: ", 1, 0);
6856        send = ostrcat(send, tmphost, 1, 0);
6857        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);
6858        debug(99, "#############################################################################################################");
6859        debug(99, "send1: %s", send);
6860        debug(99, "#############################################################################################################");
6861
6862        tmpstr = gethttpreal(tmphost, tmppath, 80, NULL, NULL, NULL, 0, send, NULL, 5000, 1);
6863        debug(99, "tmpstr: %s", tmpstr);
6864
6865        free(send), send = NULL;
6866        free(tmpstr), tmpstr = NULL;
6867
6868        if(user == NULL || pass == NULL || link == NULL) return 1;
6869
6870        hash = ostrcat("login=1&user=", user, 0, 0);
6871        hash = ostrcat(hash, "&userpw=", 1, 0);
6872        hash = ostrcat(hash, pass, 1, 1);
6873        hashlen = oitoa(strlen(hash));
6874
6875        send = ostrcat(send, "POST ", 1, 0);
6876        send = ostrcat(send, tmppath, 1, 0);
6877        send = ostrcat(send, " HTTP/1.1\r\nContent-Length: ", 1, 0);
6878        send = ostrcat(send, hashlen, 1, 0);
6879        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);
6880        send = ostrcat(send, tmphost, 1, 0);
6881        send = ostrcat(send, "\r\nCookie: pageredir=", 1, 0);
6882        send = ostrcat(send, cookie1, 1, 0);
6883        send = ostrcat(send, "; PHPSESSID=", 1, 0);
6884        send = ostrcat(send, cookie2, 1, 0);
6885        send = ostrcat(send, "\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\n", 1, 0);
6886        send = ostrcat(send, hash, 1, 0);
6887        free(hash); hash = NULL;
6888        free(hashlen); hashlen = NULL;
6889
6890        debug(99, "#############################################################################################################");
6891        debug(99, "send1: %s", send);
6892        debug(99, "#############################################################################################################");
6893
6894        tmpstr = gethttpreal(tmphost, tmppath, 80, NULL, NULL, NULL, 0, send, NULL, 5000, 1);
6895        debug(99, "tmpstr: %s", tmpstr);
6896
6897        free(cookie1); cookie1 = NULL;
6898        free(cookie2); cookie2 = NULL;
6899        free(tmphost); tmphost = NULL;
6900        free(send); send = NULL;
6901        free(ip); ip = NULL;
6902        if(tmpstr == NULL) skip = 1;
6903        free(tmpstr); tmpstr = NULL;
6904        if(skip == 1) return 1;
6905        return 0;
6906}
6907
6908void changetunername(struct skin* tunernode, int adapter, int devnr, char* name, char* fehyprid)
6909{
6910        char* tmpnr = NULL, *tmpstr = NULL;
6911        tmpnr = oitoa(adapter);
6912        tmpstr = ostrcat(_("Tuner "), tmpnr, 0, 1);
6913        tmpstr = ostrcat(tmpstr, "/", 1, 0);
6914        tmpnr = oitoa(devnr);
6915        tmpstr = ostrcat(tmpstr, tmpnr, 1, 1);
6916        tmpstr = ostrcat(tmpstr, ": ", 1, 0);
6917        tmpstr = ostrcat(tmpstr, name, 1, 0);
6918        if(fehyprid != NULL)
6919        {
6920                tmpstr = ostrcat(tmpstr, " (", 1, 0);
6921                tmpstr = ostrcat(tmpstr, _("Multituner adjustable"), 1, 0);
6922                tmpstr = ostrcat(tmpstr, ")", 1, 0);
6923        }
6924        changetext(tunernode, tmpstr);
6925        free(tmpstr); tmpstr = NULL;
6926}
6927
6928char* gethypridtunername(int dev, char* hyprid)
6929{
6930        char* hypridtunerchoices = NULL, *value = NULL, *tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL, *start = NULL;
6931
6932        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
6933
6934        if(hypridtunerchoices == NULL)
6935        {
6936                err("NULL detect");
6937                return NULL;
6938        }
6939
6940        tmpstr = readfiletomem(hypridtunerchoices, 1);
6941        if(tmpstr == NULL)
6942        {
6943                err("NULL detect");
6944                return NULL;
6945        }
6946
6947        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
6948        start = ostrcat(start, ":", 1, 0);
6949        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
6950        free(start), start = NULL;
6951
6952        tmpstr2 = string_resub("Name: ", "\n", tmpstr1, 0);
6953
6954        if(tmpstr2 != NULL)
6955                value = ostrcat(value, tmpstr2, 1, 0);
6956
6957        free(tmpstr1), tmpstr1 = NULL;
6958        free(tmpstr2), tmpstr2 = NULL;
6959        free(start), start = NULL;
6960
6961        return value;
6962}
6963
6964void convertsettings()
6965{
6966        struct menulist* mlist = NULL, *mbox = NULL;
6967        struct skin* load = getscreen("loading");
6968        int flag = 0, ret = 0;
6969        char* tmpstr = NULL;
6970
6971        addmenulist(&mlist, "Create Satellites/Provider (Sat)", _("Create Satellites/Provider (Sat)"), NULL, 0, 0);
6972        addmenulist(&mlist, "Create Satellites/Provider (Cable)", _("Create Satellites/Provider (Cable)"), NULL, 0, 0);
6973        addmenulist(&mlist, "Create Satellites/Provider (Terrestrial)", _("Create Satellites/Provider (Terrestrial)"), NULL, 0, 0);
6974        addmenulist(&mlist, "Create Satellites/Provider (All)", _("Create Satellites/Provider (All)"), NULL, 0, 0);
6975
6976        mbox = menulistbox(mlist, "createsettings", _("Import mode"), NULL, NULL, NULL, 1, 0);
6977        if(mbox != NULL) tmpstr = mbox->name;
6978
6979        if(ostrcmp(tmpstr, "Create Satellites/Provider (Sat)") == 0)
6980                flag = 0;
6981        else if(ostrcmp(tmpstr, "Create Satellites/Provider (Cable)") == 0)
6982                flag = 1;
6983        else if(ostrcmp(tmpstr, "Create Satellites/Provider (Terrestrial)") == 0)
6984                flag = 2;
6985        else if(ostrcmp(tmpstr, "Create Satellites/Provider (All)") == 0)
6986                flag = 3;
6987        else
6988        {
6989                freemenulist(mlist, 1); mlist = NULL;
6990                return;
6991        }
6992
6993        freemenulist(mlist, 1); mlist = NULL;
6994
6995        drawscreen(load, 0, 0);
6996
6997        if(flag == 0)
6998        {
6999                ret = converte2settings(0);
7000                if(ret == 0) return;
7001                system("cp -a /tmp/satellites.sat /mnt/settings/satellites");
7002                system("cp -a /tmp/transponder.sat /mnt/settings/transponder");
7003        }
7004        else if(flag == 1)
7005        {
7006                ret = converte2settings(1);
7007                if(ret == 0) return;
7008                system("cp -a /tmp/satellites.cable /mnt/settings/satellites");
7009                system("cp -a /tmp/transponder.cable /mnt/settings/transponder");
7010        }
7011        else if(flag == 2)
7012        {
7013                converte2settings(2);
7014                system("cp -a /tmp/satellites.ter /mnt/settings/satellites");
7015                system("cp -a /tmp/transponder.ter /mnt/settings/transponder");
7016        }
7017        else if(flag == 3)
7018        {
7019                ret = converte2settings(0);
7020                if(ret == 0) return;
7021                ret = converte2settings(1);
7022                if(ret == 0) return;
7023                ret = converte2settings(2);
7024                if(ret == 0) return;
7025                system("cp -a /tmp/satellites.sat /mnt/settings/satellites");
7026                system("cp -a /tmp/transponder.sat /mnt/settings/transponder");
7027
7028                system("cat /tmp/satellites.cable >> /mnt/settings/satellites");
7029                system("cat /tmp/transponder.cable >> /mnt/settings/transponder");
7030
7031                system("cat /tmp/satellites.ter >> /mnt/settings/satellites");
7032                system("cat /tmp/transponder.ter >> /mnt/settings/transponder");
7033        }
7034
7035//      free(tmpstr), tmpstr = NULL;
7036        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);
7037        //sync usb
7038        system("sync");
7039        //enable autoscan after guirestart
7040        addconfig("autoscan", "1");
7041        //write only config file
7042        writeallconfig(3);
7043        //gui restart and write no config
7044        oshutdown(3, 2);
7045}
7046
7047// flag 0 = sat
7048// flag 1 = cable
7049// flag 2 = ter
7050int converte2settings(int flag)
7051{
7052        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;
7053        int incount = 0;
7054
7055        if(flag == 0)
7056        {
7057                system("rm -rf /tmp/transponder.sat");
7058                system("rm -rf /tmp/satellites.sat");
7059                system("cp -a /var/etc/tuxbox/satellites.xml /tmp/satellites.xml");
7060                start = ostrcat("<sat ", NULL, 0, 0);
7061                end = ostrcat("</sat>", NULL, 0, 0);
7062                filename = ostrcat("/tmp/satellites.xml", NULL, 0, 0);
7063                path = ostrcat("/transponder/satellites.xml", NULL, 0, 0);
7064                transponderfile = ostrcat("/tmp/transponder.sat", NULL, 0, 0);
7065                satfile = ostrcat("/tmp/satellites.sat", NULL, 0, 0);
7066                fetype = ostrcat("0", NULL, 0, 0);
7067        }
7068        else if(flag == 1)
7069        {
7070                system("rm -rf /tmp/transponder.cable");
7071                system("rm -rf /tmp/satellites.cable");
7072                system("cp -a /var/etc/tuxbox/cables.xml /tmp/cables.xml");
7073                start = ostrcat("<cable ", NULL, 0, 0);
7074                end = ostrcat("</cable>", NULL, 0, 0);
7075                filename = ostrcat("/tmp/cables.xml", NULL, 0, 0);
7076                path = ostrcat("/transponder/cables.xml", NULL, 0, 0);
7077                transponderfile = ostrcat("/tmp/transponder.cable", NULL, 0, 0);
7078                satfile = ostrcat("/tmp/satellites.cable", NULL, 0, 0);
7079                fetype = ostrcat("1", NULL, 0, 0);
7080                incount = 4999;
7081        }
7082        else if(flag == 2)
7083        {
7084                system("rm -rf /tmp/transponder.ter");
7085                system("rm -rf /tmp/satellites.ter");
7086                system("cp -a /var/etc/tuxbox/terrestrial.xml /tmp/terrestrial.xml");
7087                start = ostrcat("<terrestrial ", NULL, 0, 0);
7088                end = ostrcat("</terrestrial>", NULL, 0, 0);
7089                filename = ostrcat("/tmp/terrestrial.xml", NULL, 0, 0);
7090                path = ostrcat("/transponder/terrestrial.xml", NULL, 0, 0);
7091                transponderfile = ostrcat("/tmp/transponder.ter", NULL, 0, 0);
7092                satfile = ostrcat("/tmp/satellites.ter", NULL, 0, 0);
7093                fetype = ostrcat("2", NULL, 0, 0);
7094                incount = 9999;
7095        }
7096
7097        if(!file_exist(filename))
7098                gethttp("atemio.dyndns.tv", path, 80, filename, HTTPAUTH, 5000, NULL, 0);
7099
7100        char* tmptext = NULL;
7101        tmptext = ostrcat(_("Error: Transponder Source file not found"), "\nfilename: ", 0, 0);
7102        tmptext = ostrcat(tmptext, transponderfile, 1, 0);
7103
7104        if(!file_exist(filename))
7105        {
7106                textbox(_("Message"), tmptext, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 0, 0);
7107                free(tmptext), tmptext = NULL;
7108                free(path), path = NULL;
7109                free(filename), filename = NULL;
7110                free(satfile), satfile = NULL;
7111                free(fetype), fetype = NULL;
7112                free(start), start = NULL;
7113                free(end), end = NULL;
7114                free(transponderfile), transponderfile = NULL;
7115                return 0;
7116        }
7117        free(tmptext), tmptext = NULL;
7118
7119        buf = readfiletomem(filename, 1);
7120        if(buf == NULL)
7121        {
7122                printf("buf: %s\n", buf);
7123                tmptext = ostrcat(_("Error: Transponder Source file no data"), "\nfilename: ", 0, 0);
7124                tmptext = ostrcat(tmptext, transponderfile, 1, 0);
7125                textbox(_("Message"), tmptext, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 0, 0);
7126                free(tmptext), tmptext = NULL;
7127                free(path), path = NULL;
7128                free(filename), filename = NULL;
7129                free(satfile), satfile = NULL;
7130                free(fetype), fetype = NULL;
7131                free(start), start = NULL;
7132                free(end), end = NULL;
7133                free(transponderfile), transponderfile = NULL;
7134                return 0;
7135        }
7136
7137//      writesys("/tmp/convert.log", buf, 1);
7138
7139        while(ostrstr(buf, start) != NULL)
7140        {
7141                incount++;
7142                tmpstr = string_resub(start, end, buf, 0);
7143                tmpstr1 = ostrcat(tmpstr, NULL, 0, 0);
7144
7145                //printf("name: %s\n", getxmlentry(ret1[i].part, "name="));
7146                //printf("position: %s\n", getxmlentry(ret1[i].part, "position="));
7147
7148                name = getxmlentry(tmpstr, "name=");
7149                if(flag == 0)
7150                        orbitalpos = getxmlentry(tmpstr, "position=");
7151                else
7152                        orbitalpos = ostrcat(oitoa(incount), NULL, 1, 0);
7153
7154                flags = getxmlentry(tmpstr, "flags=");
7155                //string_decode(name, 0);
7156                name = string_replace_all("&amp;", "und", name, 1);
7157
7158                line = ostrcat(line, name, 1, 0); //name
7159                line = ostrcat(line, "#", 1, 0);
7160//              line = ostrcat(line, flags, 1, 0); //flag
7161// 0 for all sat/ter/cab ???
7162                line = ostrcat(line, "0", 1, 0);
7163                line = ostrcat(line, "#", 1, 0);
7164                line = ostrcat(line, orbitalpos, 1, 0); //orbitalpos
7165                line = ostrcat(line, "#", 1, 0);
7166                line = ostrcat(line, fetype, 1, 0); //fetype
7167                printf("%s: %s\n", satfile, line);
7168                writesys(satfile, line, 3);
7169                free(line), line = NULL;
7170
7171                int count = 0;
7172
7173                int i = 0;
7174                struct splitstr* ret1 = NULL;
7175                ret1 = strsplit(tmpstr1, "\n", &count);
7176                if(ret1 != NULL)
7177                {
7178                        int max = count;
7179                        for(i = 0; i < max; i++)
7180                        {
7181                                if(i == 0) continue;
7182                                line = ostrcat(line, "0", 1, 0); //id
7183                                line = ostrcat(line, "#", 1, 0);
7184
7185                                line = ostrcat(line, fetype, 1, 0); //fetype
7186                                line = ostrcat(line, "#", 1, 0);
7187
7188                                if(ostrstr((ret1[i]).part, "frequency=") != NULL)
7189                                        line = ostrcat(line, getxmlentry(ret1[i].part, "frequency="), 1, 0); //frequency
7190                                else
7191                                        line = ostrcat(line, "-1", 1, 0);
7192                                line = ostrcat(line, "#", 1, 0);
7193
7194                                if(ostrstr((ret1[i]).part, "polarization=") != NULL)
7195                                        line = ostrcat(line, getxmlentry(ret1[i].part, "polarization="), 1, 0); //polarization
7196                                else
7197                                        line = ostrcat(line, "-1", 1, 0); //polarization
7198
7199                                line = ostrcat(line, "#", 1, 0);
7200                                if(orbitalpos != NULL)
7201                                        line = ostrcat(line, orbitalpos, 1, 0); //orbitalpos
7202                                else
7203                                        line = ostrcat(line, "-1", 1, 0); //orbitalpos
7204                                line = ostrcat(line, "#", 1, 0);
7205
7206                                if(ostrstr((ret1[i]).part, "symbol_rate=") != NULL)
7207                                        line = ostrcat(line, getxmlentry(ret1[i].part, "symbol_rate="), 1, 0); //symbolrate
7208                                else
7209                                        line = ostrcat(line, "-1", 1, 0);
7210                                line = ostrcat(line, "#", 1, 0);
7211
7212                                if(ostrstr((ret1[i]).part, "modulation=") != NULL)
7213                                        line = ostrcat(line, getxmlentry(ret1[i].part, "modulation="), 1, 0); //modulation
7214                                else
7215                                {
7216                                        if(flag == 2)
7217                                                line = ostrcat(line, "3", 1, 0);
7218                                        else
7219                                                line = ostrcat(line, "0", 1, 0);
7220                                }
7221                                line = ostrcat(line, "#", 1, 0);
7222
7223                                if(ostrstr((ret1[i]).part, "fec_inner=") != NULL)
7224                                        line = ostrcat(line, getxmlentry(ret1[i].part, "fec_inner="), 1, 0); //fec
7225                                else
7226                                {
7227                                        if(flag == 2)
7228                                                line = ostrcat(line, "5", 1, 0);
7229                                        else
7230                                                line = ostrcat(line, "0", 1, 0);
7231                                }
7232                                line = ostrcat(line, "#", 1, 0);
7233
7234                                if(checkbox("UFS910") == 1)
7235                                        line = ostrcat(line, "1", 1, 0); //pilot
7236                                else
7237                                        line = ostrcat(line, "2", 1, 0); //pilot
7238                                line = ostrcat(line, "#", 1, 0);
7239
7240                                if(checkbox("UFS910") == 1)
7241                                        line = ostrcat(line, "0", 1, 0); //rolloff
7242                                else
7243                                        line = ostrcat(line, "3", 1, 0); //rolloff
7244                                line = ostrcat(line, "#", 1, 0);
7245
7246                                line = ostrcat(line, "2", 1, 0); //inversion
7247                                line = ostrcat(line, "#", 1, 0);
7248
7249                                if(ostrstr((ret1[i]).part, "system=") != NULL)
7250                                        line = ostrcat(line, getxmlentry(ret1[i].part, "system="), 1, 0); //system
7251                                else
7252                                        line = ostrcat(line, "0", 1, 0); //system
7253                                line = ostrcat(line, "\n", 1, 0);
7254                        }
7255                }
7256
7257                tmpstr2 = ostrcat(start, tmpstr, 0, 0);
7258
7259                buf = string_replace(tmpstr2, NULL, buf, 1);
7260
7261        //      outfile = ostrcat("/tmp/convert.", oitoa(incount), 0, 1);
7262        //      outfile = ostrcat(outfile, ".log", 1, 0);
7263        //      writesys(outfile, buf, 2);
7264        //      writesys("/tmp/convert.log", buf, 3);
7265
7266                writesys(transponderfile, line, 2);
7267                free(line), line = NULL;
7268
7269                free(tmpstr), tmpstr = NULL;
7270                free(tmpstr1), tmpstr1 = NULL;
7271                free(tmpstr2), tmpstr2 = NULL;
7272                free(ret1), ret1 = NULL;
7273                free(name), name = NULL;
7274                free(orbitalpos), orbitalpos = NULL;
7275                free(flags), flags = NULL;
7276                free(outfile), outfile = NULL;
7277        }
7278
7279        free(path), path = NULL;
7280        free(filename), filename = NULL;
7281        free(satfile), satfile = NULL;
7282        free(transponderfile), transponderfile = NULL;
7283
7284        free(buf), buf = NULL;
7285        free(start), start = NULL;
7286        free(end), end = NULL;
7287        free(fetype), fetype = NULL;
7288
7289        return 1;
7290}
7291
7292char* system_infos(int mode)
7293{
7294        char* tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL;
7295
7296        if(mode == 0)
7297        {
7298                tmpstr1 = ostrcat("Date = ", "", 0, 0);
7299                tmpstr1 = ostrcat(tmpstr1, gettime(NULL, "%d %B %Y"), 1, 1);
7300                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
7301
7302                tmpstr1 = ostrcat("\nTime = ", "", 0, 0);
7303                tmpstr1 = ostrcat(tmpstr1, gettime(NULL, "%H:%M:%S"), 1, 1);
7304                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
7305
7306                tmpstr1 = ostrcat("\nUptime = ", "", 0, 0);
7307                tmpstr2 = command("uptime");
7308                if(tmpstr2 != NULL) tmpstr2 = strtok(tmpstr2, ",");
7309                tmpstr1 = ostrcat(tmpstr1, tmpstr2, 1, 1);
7310                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
7311
7312                tmpstr1 = ostrcat("\nBoxtype = ", "", 0, 0);
7313                tmpstr2 = string_toupper(command("cat /etc/model"));
7314                tmpstr1 = ostrcat(tmpstr1, tmpstr2, 1, 1);
7315                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
7316
7317                tmpstr1 = ostrcat("\nLoad = ", "", 0, 0);
7318                tmpstr2 = command("cat /proc/loadavg");
7319                tmpstr1 = ostrcat(tmpstr1, tmpstr2, 1, 1);
7320                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
7321        }
7322
7323        if(mode == 1)
7324        {
7325                system("ls /media/usb/* >/dev/null");
7326                system("ls /media/net/* >/dev/null");
7327                system("ls /var/swap/* >/dev/null");
7328                system("ls /mnt/swapextension/* >/dev/null");
7329                system("ls /var/backup/* >/dev/null");
7330                system("ls /media/hdd/* >/dev/null");
7331                tmpstr = command("df -h");
7332        }
7333
7334        if(mode == 2)
7335                tmpstr = command("cat /proc/version");
7336
7337        if(mode == 3)
7338        {
7339                system("ls /media/usb/* >/dev/null");
7340                system("ls /media/net/* >/dev/null");
7341                system("ls /var/swap/* >/dev/null");
7342                system("ls /mnt/swapextension/* >/dev/null");
7343                system("ls /var/backup/* >/dev/null");
7344                system("ls /media/hdd/* >/dev/null");
7345                tmpstr = command("mount");
7346        }
7347
7348        if(mode == 4)
7349        {
7350                tmpstr1 = command("ifconfig");
7351                tmpstr2 = command("route -n");
7352                tmpstr = ostrcat(tmpstr1, tmpstr2, 1, 1);
7353        }
7354
7355        if(mode == 5)
7356                tmpstr = command("free");
7357
7358        return tmpstr;
7359}
7360
7361char* system_infos_sysinfo(int mode)
7362{
7363        char* tmpstr = NULL;
7364
7365        if(mode == 0)
7366                tmpstr = command("cat /proc/cpuinfo | sed 's/\t\t/\t/'");
7367        else if(mode == 1)
7368                tmpstr = command("cat /proc/meminfo");
7369        else if(mode == 2)
7370                tmpstr = command("cat /proc/mtd");
7371        else if(mode == 3)
7372                tmpstr = command("cat /proc/modules");
7373        else if(mode == 4)
7374                tmpstr = command("cat /proc/devices");
7375        else if(mode == 5)
7376        {
7377                char* tmpstr1 = NULL, **tmpstr2 = NULL, **tmpstr3 = NULL;
7378                int i = 0, ii = 0;
7379                char* swap[] = {"Name: ", "Type: ", "Size: ", "Used: ", "Prio: "};
7380
7381                tmpstr1 = command("cat /proc/swaps | sed 's/\t/ /g; s/[ ]* / /g'");
7382                tmpstr2 = str_split(tmpstr1, "\n");
7383                if(tmpstr2 != NULL)
7384                {
7385                        free(tmpstr2[0]); tmpstr2[0] = NULL;
7386
7387                        for(i = 1; tmpstr2[i] != NULL; i++)
7388                        {
7389                                tmpstr3 = str_split(tmpstr2[i], " ");
7390                                if(tmpstr3 != NULL)
7391                                {
7392
7393                                        for(ii = 0; tmpstr3[ii] != NULL; ii++)
7394                                        {
7395                                                tmpstr = ostrcat(tmpstr, swap[ii], 1, 0);
7396                                                tmpstr = ostrcat(tmpstr, tmpstr3[ii], 1, 1);
7397                                                tmpstr = ostrcat(tmpstr, "\n", 1, 0);
7398                                        }
7399                                }
7400
7401                                tmpstr = ostrcat(tmpstr, "\n", 1, 0);
7402                                free(tmpstr2[i]); tmpstr2[i] = NULL;
7403                                free(tmpstr3); tmpstr3 = NULL;
7404                        }
7405                }
7406
7407                free(tmpstr3); tmpstr3 = NULL;
7408                free(tmpstr2); tmpstr2 = NULL;
7409                free(tmpstr1); tmpstr1 = NULL;
7410        }
7411        else if(mode == 6)
7412                tmpstr = command("top -b -n1");
7413        else if(mode == 7)
7414                tmpstr = command("ps");
7415        else if(mode == 8)
7416        {
7417                tmpstr = command("lsusb");
7418                tmpstr = ostrcat(tmpstr, "\n-------------------------------------------\n", 1, 0);
7419                char* tmpstr2 = NULL;
7420                tmpstr2 = command("cat /proc/bus/usb/devices");
7421                tmpstr = ostrcat(tmpstr, tmpstr2, 1, 1);
7422        }
7423        return tmpstr;
7424}
7425
7426char* system_logs(int mode)
7427{
7428        char* tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL, *tmpstr3 = NULL, *path = NULL, *boxversion = NULL;
7429
7430        path = ostrcat("/svn/image/changelog.", NULL, 0, 0);
7431
7432        if(mode == 0)
7433        {
7434                tmpstr1 = readfiletomem("/etc/motd", 0);
7435                if(tmpstr1 != NULL) tmpstr2 = strstr(tmpstr1, "wElc0me");
7436                tmpstr3 = readfiletomem("/etc/imageinfo", 0);
7437                if(tmpstr2 == NULL)
7438                        tmpstr = ostrcat(tmpstr3, NULL, 1, 0);
7439                else
7440                        tmpstr = ostrcat(tmpstr2, tmpstr3, 1, 1);
7441        }
7442        else if(mode == 1)
7443        {
7444                if(isfile("/etc/model") == 0) return NULL;
7445                boxversion = string_tolower(readsys("/etc/model", 1));
7446
7447                path = ostrcat(path, boxversion, 1, 0);
7448                path = ostrcat(path, ".titan", 1, 0);
7449
7450                tmpstr1 = gethttp("atemio.dyndns.tv", path, 80, NULL, HTTPAUTH, 5000, NULL, 0);
7451
7452                tmpstr = readfromlinetoline(tmpstr1, 37, 537, 1);
7453        }
7454        else if(mode == 2)
7455        {
7456#ifdef MIPSEL
7457                path = ostrcat(path, "git.mipsel", 1, 0);
7458#else
7459                path = ostrcat(path, "git.sh4", 1, 0);
7460#endif
7461
7462                tmpstr1 = gethttp("atemio.dyndns.tv", path, 80, NULL, HTTPAUTH, 5000, NULL, 0);
7463
7464                tmpstr = readfromlinetoline(tmpstr1, 0, 500, 1);
7465        }
7466        else if(mode == 3)
7467        {
7468                tmpstr = readfiletomem(getconfig("tracelog", NULL), 0);
7469        }
7470
7471        free(path), path = NULL;
7472        free(boxversion), boxversion = NULL;
7473//      free(tmpstr1), tmpstr1 = NULL;
7474//      free(tmpstr2), tmpstr2 = NULL;
7475//      free(tmpstr3), tmpstr3 = NULL;
7476
7477        return tmpstr;
7478}
7479
7480char* getimgnamereal()
7481{
7482        char* tmpstr = NULL;
7483
7484        tmpstr = readfiletomem(getconfig("imagenamefile", NULL), 1);
7485
7486        return tmpstr;
7487}
7488
7489char* getmoviedev()
7490{
7491        char* tmpstr = NULL, *buf = NULL;
7492
7493        tmpstr = readfiletomem("/tmp/.moviedev", 1);
7494        printf("tmpstr: %s\n", tmpstr);
7495
7496        buf = oregex("sd([a-z]{1,1}).*", tmpstr);
7497        printf("buf: %s\n", buf);
7498
7499        free(tmpstr), tmpstr = NULL;
7500
7501        return buf;
7502}
7503
7504void wakeup_record_device()
7505{
7506        char* cmd = NULL, *dev = NULL;
7507
7508        if(file_exist(getconfig("skriptbeforerec", NULL)))
7509        {
7510                cmd = ostrcat(getconfig("skriptbeforerec", NULL), NULL, 0, 0);
7511                printf("cmd: %s\n", cmd);
7512                system(cmd);
7513                free(cmd), cmd = NULL;
7514        }
7515
7516        dev = getmoviedev();
7517        if(dev == NULL)
7518        {
7519                cmd = ostrcat("ls -al ", getconfig("rec_path", NULL), 0, 0);
7520                cmd = ostrcat(cmd," > /dev/null 2>&1", 1, 0);
7521        }
7522        else
7523                cmd = ostrcat("sdparm -C START /dev/sd", dev, 0, 0);
7524
7525//      cmd = ostrcat(cmd, " >/dev/null", 1, 0);
7526        printf("cmd: %s\n", cmd);
7527        system(cmd);
7528        free(dev), dev = NULL;
7529        free(cmd), cmd = NULL;
7530}
7531
7532void setdefaultbouquets()
7533{
7534        if(textbox(_("Message"), _("Start Restore Default Bouquets ?"), _("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 -f /mnt/settings/bouquets.* > /dev/null 2>&1");
7540                system("cp -a /etc/titan.restore/mnt/settings/bouquets* /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 setdefaultsettings()
7553{
7554        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)
7555        {
7556                struct skin* load = getscreen("loading");
7557                drawscreen(load, 0, 0);
7558
7559                system("rm -rf /mnt/settings/* > /dev/null 2>&1");
7560                system("cp -a /etc/titan.restore/mnt/settings/* /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 setdefaultproviders()
7573{
7574        if(textbox(_("Message"), _("Start Restore Default Providers ?"), _("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/provider > /dev/null 2>&1");
7580                system("cp -a /etc/titan.restore/mnt/settings/provider /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 setdefaultchannels()
7593{
7594        if(textbox(_("Message"), _("Start Restore Default Channels ?"), _("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/channel > /dev/null 2>&1");
7600                system("cp -a /etc/titan.restore/mnt/settings/channel /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
7612void setdefaultsats()
7613{
7614        if(textbox(_("Message"), _("Start Restore Default Sats ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 0, 0) == 1)
7615        {
7616                struct skin* load = getscreen("loading");
7617                drawscreen(load, 0, 0);
7618
7619                system("rm -f /mnt/settings/satellites > /dev/null 2>&1");
7620                system("cp -a /etc/titan.restore/mnt/settings/satellites /mnt/settings > /dev/null 2>&1");
7621
7622                textbox(_("Message"), _("Titan will be restarted!"), _("OK"), getrcconfigint("rcok", NULL), NULL, 0, NULL, 0, NULL, 0, 1000, 200, 0, 0);
7623                //sync usb
7624                system("sync");
7625                //write only config file
7626                writeallconfig(3);
7627                //gui restart and write no config
7628                oshutdown(3, 2);
7629        }
7630}
7631
7632char* create_backup(char* input, int flag)
7633{
7634        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);
7635        if(flag == 0) return infotext;
7636
7637        char* tmpstr = NULL, *cmd = NULL;
7638        int merksec = status.sec;
7639
7640        status.sec = 0; //deaktivate spinner
7641        if(checkbox("DM900") == 1)
7642                cmd = ostrcat(cmd, "backupdream.sh ", 1, 0);
7643        else
7644                cmd = ostrcat(cmd, "backup.sh ", 1, 0);
7645        cmd = ostrcat(cmd, input, 1, 0);
7646
7647        if(flag == 2)
7648                cmd = ostrcat(cmd, " 1", 1, 0);
7649
7650        if(file_exist("/var/swap"))
7651        {
7652                if(!file_exist("/var/swap/logs"))
7653                         mkdir("/var/swap/logs", 777);
7654
7655                if(file_exist("/etc/.beta") && file_exist("/var/swap/logs"))
7656                        cmd = ostrcat(cmd, " > /var/swap/logs/backup_debug.log 2>&1", 1, 0);
7657        }
7658        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)
7659        {
7660                if(!file_exist("/mnt/logs"))
7661                         mkdir("/mnt/logs", 777);
7662
7663                if(file_exist("/etc/.beta") && file_exist("/mnt/logs"))
7664                        cmd = ostrcat(cmd, " > /mnt/logs/backup_debug.log 2>&1", 1, 0);
7665        }
7666        //tmpstr = command(cmd);
7667        if(system(cmd) == 0)
7668        //if(tmpstr == NULL)
7669                tmpstr = ostrcat(tmpstr, _("Backup created successfully"), 1, 0);
7670        else
7671                tmpstr = ostrcat(tmpstr, _("Backup ended with error"), 1, 0);
7672
7673        free(cmd); cmd = NULL;
7674        status.sec = merksec;
7675
7676        return tmpstr;
7677}
7678
7679char* create_backuprestore()
7680{
7681        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);
7682        return tmpstr;
7683}
7684char* randomstring(int n)
7685{
7686    int i, wert;
7687    time_t t;
7688    char* tmp = malloc(n+1);
7689
7690    /* Intializes random number generator */
7691    srand((unsigned) time(&t));
7692    for( i = 0 ; i < n ; i++ )
7693    {
7694        wert = rand() % 9;
7695        sprintf(tmp+i, "%d", wert);
7696    }
7697    tmp[i] = '\0';
7698    return tmp;
7699}
7700
7701
7702int putmsgbuffer()
7703{
7704        if(file_exist("/tmp/textbox_standby") != 1)
7705                return 1;
7706
7707        FILE *fp = fopen("/tmp/textbox_standby" , "r");
7708        if(fp == NULL)
7709        {
7710                printf("Error opening file: /tmp/textbox_standby\n");
7711                return(-1);
7712        }
7713
7714        char* caption = malloc(255);
7715        char* body = malloc(255);
7716        char* comtext1 = malloc(20);
7717        char* com1 = malloc(10);
7718        char* comtext2 = malloc(20);
7719        char* com2 = malloc(10);
7720        char* comtext3 = malloc(20);
7721        char* com3 = malloc(10);
7722        char* comtext4 = malloc(20);
7723        char* com4 = malloc(10);
7724        char* width = malloc(10);
7725        char* height = malloc(10);
7726        char* timeout = malloc(10);
7727        char* flag = malloc(10);
7728
7729        while(fgets(caption, 255, fp)!=NULL)
7730        {
7731                string_newline(caption);
7732
7733                fgets(body, 255, fp);
7734                string_newline(body);
7735                body = string_replace_all("\t", "\n", body, 1);
7736
7737                if(comtext1 == NULL)
7738                        comtext1 = malloc(20);
7739                fgets(comtext1, 20, fp);
7740                string_newline(comtext1);
7741                fgets(com1, 10, fp);
7742                string_newline(com1);
7743
7744                if(comtext2 == NULL)
7745                        comtext2 = malloc(20);
7746                fgets(comtext2, 20, fp);
7747                string_newline(comtext2);
7748                fgets(com2, 10, fp);
7749                string_newline(com2);
7750
7751                if(comtext3 == NULL)
7752                        comtext3 = malloc(20);
7753                fgets(comtext3, 20, fp);
7754                string_newline(comtext3);
7755                fgets(com3, 10, fp);
7756                string_newline(com3);
7757
7758                if(comtext4 == NULL)
7759                        comtext4 = malloc(20);
7760                fgets(comtext4, 20, fp);
7761                string_newline(comtext4);
7762                fgets(com4, 10, fp);
7763                string_newline(com4);
7764
7765                fgets(width, 10, fp);
7766                string_newline(width);
7767
7768                fgets(height, 10, fp);
7769                string_newline(height);
7770
7771                fgets(timeout, 10, fp);
7772                string_newline(timeout);
7773
7774                fgets(flag, 10, fp);
7775                string_newline(flag);
7776
7777                if(atoi(com1) == 0)
7778                {
7779                        free(comtext1);
7780                        comtext1 = NULL;
7781                }
7782                if(atoi(com2) == 0)
7783                {
7784                        free(comtext2);
7785                        comtext2 = NULL;
7786                }
7787                if(atoi(com3) == 0)
7788                {
7789                        free(comtext3);
7790                        comtext3 = NULL;
7791                }
7792                if(atoi(com4) == 0)
7793                {
7794                        free(comtext4);
7795                        comtext4 = NULL;
7796                }
7797                textbox(caption, body, comtext1, atoi(com1), comtext2, atoi(com2), comtext3, atoi(com3), comtext4, atoi(com4), atoi(width), atoi(height), atoi(timeout), atoi(flag));
7798        }
7799
7800        fclose(fp);
7801        system("rm /tmp/textbox_standby");
7802
7803        free(caption);
7804        free(body);
7805        free(comtext1);
7806        free(com1);
7807        free(comtext2);
7808        free(com2);
7809        free(comtext3);
7810        free(com3);
7811        free(comtext4);
7812        free(com4);
7813        free(width);
7814        free(height);
7815        free(timeout);
7816        free(flag);
7817
7818        return 0;
7819}
7820
7821void delunusedsat()
7822{
7823        debug(10, "delunusedsat: start");
7824        struct sat* node = sat;
7825        struct sat* prev = NULL;
7826
7827        while(node != NULL)
7828        {
7829                prev = node;
7830                node = node->next;
7831
7832                if(prev->scan != 1)
7833                        delsat(prev->name);
7834        }
7835        debug(10, "delunusedsat: end");
7836}
7837
7838void delunusedtransponder()
7839{
7840        debug(10, "delunusedtransponder: start");
7841        struct transponder* node = transponder;
7842        struct transponder* prev = NULL;
7843
7844        while(node != NULL)
7845        {
7846                prev = node;
7847                node = node->next;
7848
7849                if(getsatbyorbitalpos(prev->orbitalpos) == NULL)
7850                        deltransponder(prev);
7851        }
7852        debug(10, "delunusedtransponder: end");
7853}
7854
7855void delunusedchannel()
7856{
7857        debug(10, "delunusedchannel: start");
7858        struct channel* node = channel;
7859        struct channel* prev = NULL;
7860
7861        while(node != NULL)
7862        {
7863                prev = node;
7864                node = node->next;
7865
7866                if(prev->transponder == NULL)
7867                        delchannel(prev->serviceid, prev->transponderid, 0);
7868        }
7869        debug(10, "delunusedchannel: end");
7870}
7871
7872void delunusedbouquet()
7873{
7874        debug(10, "delunusedbouquet: start");
7875        struct mainbouquet* mnode = mainbouquet;
7876        struct bouquet* first = NULL;
7877        struct bouquet* node = NULL;
7878        struct bouquet* prev = NULL;
7879
7880        while(mnode != NULL)
7881        {
7882                first = mnode->bouquet;
7883                node = mnode->bouquet;
7884                while(node != NULL)
7885                {
7886                        prev = node;
7887                        node = node->next;
7888                        if(getchannel(prev->serviceid, prev->transponderid) == NULL)
7889                                delbouquet(prev->serviceid, prev->transponderid, &first);
7890                }
7891                mnode = mnode->next;
7892        }
7893        debug(10, "delunusedbouquet: end");
7894}
7895
7896void delunusedepgchannel()
7897{
7898        debug(10, "delunusedepgchannel: start");
7899        struct epgscanlist* node = epgscanlist;
7900        struct epgscanlist* prev = NULL;
7901
7902        while(node != NULL)
7903        {
7904                prev = node;
7905                node = node->next;
7906                if(getchannel(prev->serviceid, prev->transponderid) == NULL)
7907                        delepgscanlist(node->serviceid, node->transponderid);
7908        }
7909        debug(10, "delunusedepgchannel: end");
7910}
7911
7912void delunusedprovider()
7913{
7914        debug(10, "delunusedprovider: start");
7915        struct provider* node = provider;
7916        struct provider* prev = NULL;
7917
7918        while(node != NULL)
7919        {
7920                prev = node;
7921                node = node->next;
7922                delprovidernotused(prev);
7923        }
7924        debug(10, "delunusedprovider: end");
7925}
7926
7927int checkshutdown(int flag)
7928{
7929        int i = 0;
7930
7931        //check if record running
7932        if((flag == 1 || flag == 2 || flag == 3 || flag == 4 || flag == 5 || flag == 6) && (status.streaming > 0 || status.recording > 0 || getrectimerbytimediff(300) != NULL))
7933        {
7934                if(flag == 4 && status.fixpowerofftime > 1)
7935                {
7936                                status.fixpowerofftime = time(NULL) + 900; //check powerofftimer again in 15min
7937                                return 1;
7938                }
7939                if(flag == 5 && status.sd_timer != NULL && status.sd_timer->active)
7940                {
7941                                status.sd_timer->shutdown_time = time(NULL) + 900; //check powerofftimer again in 15min
7942                                return 1;
7943                }
7944                else if(flag == 6)
7945                {
7946                        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)
7947                                return 1;
7948                }
7949                else
7950                {
7951                        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)
7952                                return 1;
7953                }
7954        }
7955
7956        //check if download is running
7957        for(i = 0; i < MAXBGDOWNLOAD; i++)
7958        {
7959                if(bgdownload[i] != NULL && bgdownload[i]->ret == -1)
7960                {
7961                        if(flag == 6)
7962                        {
7963                                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)
7964                                        return 1;
7965                        }
7966                        else
7967                        {
7968                                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)
7969                                        return 1;
7970                        }
7971                        break;
7972
7973                }
7974        }
7975
7976        return 0;
7977}
7978
7979#endif
Note: See TracBrowser for help on using the repository browser.