source: titan/titan/global.h @ 40828

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

update create transponder

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