source: titan/titan/global.h @ 44544

Last change on this file since 44544 was 44544, checked in by obi, 4 years ago

test

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