source: titan/titan/global.h @ 32960

Last change on this file since 32960 was 32960, checked in by obi, 9 years ago

add frontcontroler version to getabout

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