source: titan/titan/global.h @ 38481

Last change on this file since 38481 was 38481, checked in by obi, 6 years ago

fix record / bgdownload check before system update

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