source: titan/titan/global.h @ 37145

Last change on this file since 37145 was 36869, checked in by gost, 8 years ago

[titan] dm7020.. fix progress

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