source: titan/titan/global.h @ 40399

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

[titan] new mutex for cec

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