source: titan/titan/global.h @ 31136

Last change on this file since 31136 was 31136, checked in by obi, 8 years ago

mipsel disable amixer

File size: 137.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        }
1166        else
1167        {
1168                pthread_mutex_destroy(&status.drawingmutex);
1169                pthread_mutex_destroy(&status.rectimermutex);
1170                pthread_mutex_destroy(&status.servicemutex);
1171                pthread_mutex_destroy(&status.epgmutex);
1172                pthread_mutex_destroy(&status.vfdmutex);
1173                pthread_mutex_destroy(&status.channelmutex);
1174                pthread_mutex_destroy(&status.timerthreadmutex);
1175                pthread_mutex_destroy(&status.audiotrackmutex);
1176                pthread_mutex_destroy(&status.subtitlemutex);
1177                pthread_mutex_destroy(&status.dmxdevmutex);
1178                pthread_mutex_destroy(&status.rcmutex);
1179                pthread_mutex_destroy(&status.queuemutex);
1180                pthread_mutex_destroy(&status.clistmutex);
1181                pthread_mutex_destroy(&status.hddmutex);
1182                pthread_mutex_destroy(&status.linkedchannelmutex);
1183                pthread_mutex_destroy(&status.tsseekmutex);
1184                pthread_mutex_destroy(&status.accelfbmutex);
1185                pthread_mutex_destroy(&status.mediadbmutex);
1186                pthread_mutex_destroy(&status.oldentrymutex);
1187                pthread_mutex_destroy(&status.newslettermutex);
1188                pthread_mutex_destroy(&status.tithekmutex);
1189                pthread_mutex_destroy(&status.inetworkmutex);
1190                pthread_mutex_destroy(&status.textboxmutex);
1191                pthread_mutex_destroy(&status.setaktresmutex);
1192                pthread_mutex_destroy(&status.waitrcmutex);
1193        }
1194}
1195
1196int hexit(char c)
1197{
1198        if(c >= '0' && c <= '9')
1199                return c - '0';
1200        if(c >= 'a' && c <= 'f')
1201                return c - 'a' + 10;
1202        if(c >= 'A' && c <= 'F')
1203                return c - 'A' + 10;
1204
1205        return 0;
1206}
1207
1208char* htmlencode(char* from)
1209{
1210        int buflen = 0;
1211        char* buf = NULL, *to = NULL;
1212
1213        buf = calloc(1, MINMALLOC);
1214        if(buf == NULL)
1215        {
1216                err("no mem");
1217                return NULL;
1218        }
1219        to = buf;
1220
1221        for(buflen = 0; *from != '\0' && buflen < MINMALLOC; ++from)
1222        {
1223                if(isalnum(*from) || strchr("/_.-~", *from) != NULL)
1224                {
1225                        *to = *from;
1226                        ++to;
1227                        ++buflen;
1228                }
1229                else
1230                {
1231                        sprintf(to, "%%%02x", (int)*from & 0xff);
1232                        to += 3;
1233                        buflen += 3;
1234                }
1235        }
1236        *to = '\0';
1237
1238        buf = ostrshrink(buf);
1239        return buf;
1240}
1241
1242void htmldecode(char* to, char* from)
1243{
1244        if(to == NULL || from == NULL) return;
1245
1246        for(; *from != '\0'; ++to, ++from)
1247        {
1248                if(from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2]))
1249                {
1250                        *to = hexit(from[1]) * 16 + hexit(from[2]);
1251                        from += 2;
1252                }
1253                else
1254                        *to = *from;
1255        }
1256        *to = '\0';
1257}
1258
1259void htmldecode2(char* to, char* from)
1260{
1261        if(to == NULL || from == NULL) return;
1262
1263        for(; *from != '\0'; ++to, ++from)
1264        {
1265                if(from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2]) && isxdigit(from[3]) && isxdigit(from[4]))
1266                {
1267                        *to = hexit(from[1]) * 16 + hexit(from[2]) * 16 + hexit(from[3]) * 16 + hexit(from[4]);
1268                        from += 4;
1269                }
1270                else if(from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2]) && isxdigit(from[3]))
1271                {
1272                        *to = hexit(from[1]) * 16 + hexit(from[2]) * 16 + hexit(from[3]);
1273                        from += 3;
1274                }
1275                else if(from[0] == '%' && isxdigit(from[1]) && isxdigit(from[2]))
1276                {
1277                        *to = hexit(from[1]) * 16 + hexit(from[2]);
1278                        from += 2;
1279                }
1280                else
1281                        *to = *from;
1282        }
1283        *to = '\0';
1284}
1285
1286void htmldecode3(char* to, char* from)
1287{
1288        if(to == NULL || from == NULL) return;
1289
1290        for(; *from != '\0'; ++to, ++from)
1291        {
1292                if(from[0] == '\\' && from[1] == 'u' && isxdigit(from[2]) && isxdigit(from[3]) && isxdigit(from[4]) && isxdigit(from[5]) && isxdigit(from[6]) && isxdigit(from[7]))
1293                {
1294                        *to = hexit(from[2]) * 1048576 + hexit(from[3]) * 65536 + hexit(from[4]) * 4096 + hexit(from[5]) * 256 + hexit(from[6]) * 16 + hexit(from[7]);
1295                        from += 7;
1296                }
1297                if(from[0] == '\\' && from[1] == 'u' && isxdigit(from[2]) && isxdigit(from[3]) && isxdigit(from[4]) && isxdigit(from[5]))
1298                {
1299                        *to = hexit(from[2]) * 4096 + hexit(from[3]) * 256 + hexit(from[4]) * 16 + hexit(from[5]);
1300                        from += 5;
1301                }
1302                else
1303                        *to = *from;
1304        }
1305        *to = '\0';
1306}
1307
1308void setosdtransparent(int value)
1309{
1310        int ret = 255;
1311        if(value < 0) value = 0;
1312        if(value > 100) value = 100;
1313
1314        ret -= value * 2.55;
1315
1316        setfbtransparent(ret);
1317}
1318
1319struct tm* olocaltime(time_t *value)
1320{
1321        struct tm *loctime, *loctime1 = NULL;
1322
1323        loctime1 = (struct tm*)malloc(sizeof(struct tm));
1324        if(loctime1 == NULL)
1325        {
1326                err("no mem");
1327                return NULL;
1328        }
1329        loctime = localtime_r(value, loctime1);
1330
1331        return loctime;
1332}
1333
1334int setwakeuptimer(time_t waketime)
1335{
1336        char* wakeuptimerprog = NULL;
1337        struct tm *loctime = NULL;
1338        char *buf = NULL;
1339        int ret = -1;
1340
1341        wakeuptimerprog = getconfig("wakeuptimerprog", NULL);
1342
1343        if(wakeuptimerprog == NULL)
1344        {
1345                err("NULL detect");
1346                return ret;
1347        }
1348
1349        buf = malloc(MINMALLOC);
1350        if(buf == NULL)
1351        {
1352                err("no mem");
1353                return ret;
1354        }
1355
1356        loctime = olocaltime(&waketime);
1357
1358        if(loctime != NULL)
1359                ostrftime(buf, MINMALLOC, wakeuptimerprog, loctime);
1360
1361        if(buf != NULL)
1362        {
1363                debug(10, "set wake up timer (%s)", buf);
1364                ret = system(buf);
1365        }
1366
1367        free(loctime);
1368        free(buf);
1369        return ret;
1370}
1371
1372int autoresolution()
1373{
1374        char *hotpluginfo = NULL;
1375        char *value = NULL;
1376
1377        if(getconfig("av_videomode", NULL) != NULL || getconfig("av_colorformat", NULL))
1378                return 1;
1379
1380        hotpluginfo = getconfig("hotpluginfo", NULL);
1381
1382        if(hotpluginfo == NULL)
1383        {
1384                err("NULL detect");
1385                return 1;
1386        }
1387
1388        value = readsys(hotpluginfo, 1);
1389        if(value == NULL)
1390        {
1391                err("NULL detect");
1392                return 1;
1393        }
1394
1395        if(value[0] == 'y')
1396        {
1397                setvideomode("720p50", 0);
1398                changefbresolution("720p50", 0);
1399                setcolorformat("hdmi_rgb", 0);
1400        }
1401        else
1402        {
1403                setvideomode("576i50", 0);
1404                changefbresolution("576i50", 0);
1405                setcolorformat("rgb", 1);
1406        }
1407
1408        free(value);
1409        return 0;
1410}
1411
1412//TODO: can remove if new function work
1413/*
1414int writelengthfield(unsigned char *buf, unsigned int len)
1415{
1416        if(len < 127)
1417        {
1418                *buf++ = len;
1419                return 1;
1420        }
1421        else if(len < 256)
1422        {
1423                *buf++ = 0x81;
1424                *buf++ = len;
1425                return 2;
1426        }
1427        else if(len < 65535)
1428        {
1429                *buf++ = 0x82;
1430                *buf++ = len >> 8;
1431                *buf++ = len;
1432                return 3;
1433        }
1434
1435        return 0;
1436}
1437*/
1438
1439size_t writelengthfield(unsigned char * buf, unsigned int len)
1440{
1441        if(buf == NULL) return 0;
1442
1443        if(len < 128)
1444        {
1445                buf[0] = len;
1446                return 1;
1447        }
1448        else
1449        {
1450                unsigned int pos = 0;
1451                unsigned int shiftby = 8;
1452                unsigned char lenfieldsize = 1;
1453
1454                while((len >> shiftby) != 0)
1455                {
1456                        lenfieldsize++;
1457                        shiftby += 8;
1458                }
1459
1460                buf[pos++] = ((1 << 7) | lenfieldsize);
1461
1462                while(shiftby != 0)
1463                {
1464                        shiftby -= 8;
1465                        buf[pos++] = len >> shiftby;
1466                }
1467                return pos;
1468        }
1469}
1470
1471//flag 0: del non alpha/num
1472//flag 1: change all /
1473//flag 2: change all non filename conform chars
1474//flag 3: replace non alpha/num with _
1475void delspezchar(char* text, int flag)
1476{
1477        char* tmpstr = text;
1478
1479        if(text == NULL) return;
1480
1481        while(*tmpstr != '\0')
1482        {
1483                if(flag == 1 || flag == 2)
1484                {
1485                        if(tmpstr[0] == '/') tmpstr[0] = '-';
1486                        if(flag == 2)
1487                        {
1488                                if(tmpstr[0] == '§') tmpstr[0] = '-';
1489                                if(tmpstr[0] == '<') tmpstr[0] = '-';
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                        }
1506                }
1507                else if(flag == 3)
1508                {
1509                        if(!isalnum(tmpstr[0]) && tmpstr[0] != '-')
1510                                tmpstr[0] = '_';
1511                }
1512                else
1513                {
1514                        if(!isalnum(tmpstr[0]) && tmpstr[0] != '-' && tmpstr[0] != '.')
1515                                tmpstr[0] = ' ';
1516                }
1517                tmpstr++;
1518        }
1519}
1520
1521void m_lock(pthread_mutex_t *mutex, int flag)
1522{
1523        switch(flag)
1524        {
1525                case 0: debug(900, "drawingmutex lock"); break;
1526                case 1: debug(900, "rectimermutex lock"); break;
1527                case 2: debug(900, "servicemutex lock"); break;
1528                case 3: debug(900, "vfdmutex lock"); break;
1529                case 4: debug(900, "epgmutex lock"); break;
1530                case 5: debug(900, "channelmutex lock"); break;
1531                case 6: debug(900, "timerthreadmutex lock"); break;
1532                case 7: debug(900, "audiotrackmutex lock"); break;
1533                case 8: debug(900, "subtitlemutex lock"); break;
1534                case 9: debug(900, "dmxdevmutex lock"); break;
1535                case 10: debug(900, "rcmutex lock"); break;
1536                case 11: debug(900, "queuemutex lock"); break;
1537                case 12: debug(900, "clistmutex lock"); break;
1538                case 13: debug(900, "hddmutex lock"); break;
1539                case 14: debug(900, "linkedchannelmutex lock"); break;
1540                case 15: debug(900, "tsseekmutex lock"); break;
1541                case 16: debug(900, "accelfbmutex lock"); break;
1542                case 17: debug(900, "mediadbmutex lock"); break;
1543                case 18: debug(900, "oldentrymutex lock"); break;
1544                case 19: debug(900, "newslettermutex lock"); break;
1545                case 20: debug(900, "tithekmutex lock"); break;
1546                case 21: debug(900, "inetworkmutex lock"); break;
1547                case 22: debug(900, "textboxmutex lock"); break;
1548                case 23: debug(900, "setaktresmutex lock"); break;
1549                case 24: debug(900, "waitrcmutex lock"); break;
1550                default: debug(900, "unknown mutex lock"); break;
1551        }
1552        pthread_mutex_lock(mutex);
1553}
1554
1555void m_unlock(pthread_mutex_t *mutex, int flag)
1556{
1557        switch(flag)
1558        {
1559                case 0: debug(900, "drawingmutex unlock"); break;
1560                case 1: debug(900, "rectimermutex unlock"); break;
1561                case 2: debug(900, "servicemutex unlock"); break;
1562                case 3: debug(900, "vfdmutex unlock"); break;
1563                case 4: debug(900, "epgmutex unlock"); break;
1564                case 5: debug(900, "channelmutex unlock"); break;
1565                case 6: debug(900, "timerthreadmutex unlock"); break;
1566                case 7: debug(900, "audiotrackmutex unlock"); break;
1567                case 8: debug(900, "subtitlemutex unlock"); break;
1568                case 9: debug(900, "dmxdevmutex unlock"); break;
1569                case 10: debug(900, "rcmutex unlock"); break;
1570                case 11: debug(900, "queuemutex unlock"); break;
1571                case 12: debug(900, "clistmutex unlock"); break;
1572                case 13: debug(900, "hddmutex unlock"); break;
1573                case 14: debug(900, "linkedchannelmutex unlock"); break;
1574                case 15: debug(900, "tsseekmutex unlock"); break;
1575                case 16: debug(900, "accelfbmutex unlock"); break;
1576                case 17: debug(900, "mediadbmutex unlock"); break;
1577                case 18: debug(900, "oldentrymutex unlock"); break;
1578                case 19: debug(900, "newslettermutex unlock"); break;
1579                case 20: debug(900, "tithekmutex unlock"); break;
1580                case 21: debug(900, "inetworkmutex unlock"); break;
1581                case 22: debug(900, "textboxmutex unlock"); break;
1582                case 23: debug(900, "setaktresmutex unlock"); break;
1583                case 24: debug(900, "waitrcmutex unlock"); break;
1584                default: debug(900, "unknown mutex unlock"); break;
1585        }
1586        pthread_mutex_unlock(mutex);
1587}
1588
1589void debugstack(int sig, void* address, void* address1)
1590{
1591        Dl_info info, info1;
1592        void* trace[20];
1593        size_t size;
1594        size = backtrace(trace, 20);
1595
1596        FILE* fd = NULL;
1597        void* akttrace[2];
1598        int i = 0;
1599        char **strings;
1600        char **aktstring;
1601        time_t rawtime;
1602#ifdef BETA
1603        int y = 0;
1604        Dl_info info2;
1605#endif
1606
1607        char* imgversion = NULL;
1608        struct stimerthread* tnode = NULL;
1609
1610        if(isfile(getconfig("imagenamefile", NULL))     != 0)
1611                imgversion = readsys(getconfig("imagenamefile", NULL), 1);
1612        else
1613                imgversion = ostrcat("unknown", NULL, 0, 0);
1614
1615        tnode = gettimerbythread(pthread_self());
1616        if(tnode != NULL)
1617                dladdr(tnode->func, &info);
1618
1619        dladdr(address, &info1);
1620
1621        strings = backtrace_symbols(trace, size);
1622        akttrace[0] = (void*)address1;
1623        akttrace[1] = (void*)address;
1624        aktstring = backtrace_symbols(akttrace, 2); //get fault funktion name
1625
1626        fprintf(stderr, "--------------------------------------\n");
1627        fprintf(stderr, "Box: %s\n", getboxtype());
1628        fprintf(stderr, "Image: %s\n", imgversion);
1629        fprintf(stderr, "Signal: %d (%s)\n", sig, strsignal(sig));
1630        if(info1.dli_fname != NULL)
1631                fprintf(stderr, "Error in File: %s\n", info1.dli_fname);
1632        fprintf(stderr, "MainThread: %x\n", (unsigned int)status.mainthread);
1633        if(tnode != NULL && info.dli_sname != NULL)
1634                fprintf(stderr, "Error in Thread: %x (%s)\n", (unsigned int)pthread_self(), info.dli_sname);
1635        else
1636                fprintf(stderr, "Error in Thread: %x\n", (unsigned int)pthread_self());
1637       
1638        fprintf(stderr, "\nObtaining %zd stack frames:\n\n", size);
1639        for(i = 0; i < size; i++)
1640                fprintf(stderr, "%s\n", strings[i]);
1641
1642        fprintf(stderr, "\nLast functions:\n\n");
1643        fprintf(stderr, "%s\n", aktstring[0]);
1644        fprintf(stderr, "%s\n", aktstring[1]);
1645
1646#ifdef BETA     
1647        for(i = 0; i < MAXSTACKTRACE; i++)
1648        {
1649                if(stacktrace[i].pos > 0)
1650                {
1651                        fprintf(stderr, "\nObtaining %d Thread Stack frames [%p]:\n\n", stacktrace[i].pos, (void*)stacktrace[i].thread);
1652                        for(y = stacktrace[i].pos - 1; y >= 0; y--)
1653                        {
1654                                dladdr(stacktrace[i].func[y], &info2);
1655        fprintf(stderr, "%s(%s) [%p]\n", info2.dli_fname, info2.dli_sname, stacktrace[i].func[y]);
1656                        }
1657                }
1658        }
1659#endif
1660
1661        fprintf(stderr, "--------------------------------------\n");
1662
1663        char* logdir = ostrcat(getconfig("tracelog", NULL), NULL, 0, 0);
1664        if(logdir != NULL)
1665        {
1666                char* tmplogdir = dirname(logdir);
1667                if(tmplogdir != NULL)
1668                {
1669                        if(!file_exist(tmplogdir))   
1670                                mkdir(tmplogdir, 0777);
1671                }
1672                free(logdir); logdir = NULL;
1673        }
1674       
1675        //del file if greater 100KB
1676        if(getfilesize(getconfig("tracelog", NULL)) > 102400)
1677                unlink(getconfig("tracelog", NULL));
1678                       
1679        fd = fopen(getconfig("tracelog", NULL), "a");
1680        if(fd != NULL)
1681        {
1682                time(&rawtime);
1683                fprintf(fd, "Date: %s", ctime(&rawtime));
1684                fprintf(fd, "Box: %s\n", getboxtype());
1685                fprintf(fd, "Image: %s\n", imgversion);
1686                fprintf(fd, "Signal: %d (%s)\n", sig, strsignal(sig));
1687                if(info1.dli_fname != NULL)
1688                        fprintf(fd, "Error in File: %s\n", info1.dli_fname);
1689                fprintf(fd, "MainThread: %x\n", (unsigned int)status.mainthread);
1690                if(tnode != NULL && info.dli_sname != NULL)
1691                        fprintf(fd, "Error in Thread: %x (%s)\n", (unsigned int)pthread_self(), info.dli_sname);
1692                else
1693                        fprintf(fd, "Error in Thread: %x\n", (unsigned int)pthread_self());
1694                       
1695                fprintf(fd, "\nObtaining %zd stack frames:\n\n", size);
1696                for(i = 0; i < size; i++)
1697                        fprintf(fd, "%s\n", strings[i]);
1698                       
1699                fprintf(fd, "\nLast functions:\n\n");
1700                fprintf(fd, "%s\n", aktstring[0]);
1701                fprintf(fd, "%s\n", aktstring[1]);
1702
1703#ifdef BETA             
1704                for(i = 0; i < MAXSTACKTRACE; i++)
1705                {
1706                        if(stacktrace[i].pos > 0)
1707                        {
1708                                fprintf(fd, "\nObtaining %d Thread Stack frames [%p]:\n\n", stacktrace[i].pos, (void*)stacktrace[i].thread);
1709                                for(y = stacktrace[i].pos - 1; y >= 0; y--)
1710                                {
1711                                        dladdr(stacktrace[i].func[y], &info2);
1712                fprintf(fd, "%s(%s) [%p]\n", info2.dli_fname, info2.dli_sname, stacktrace[i].func[y]);
1713                                }
1714                        }
1715                }
1716#endif
1717               
1718                fprintf(fd, "--------------------------------------\n\n");
1719                fclose(fd);
1720                sync();
1721        }
1722        else
1723                perr("open %s", getconfig("tracelog", NULL));
1724
1725        free(imgversion);
1726        free(strings);
1727        free(aktstring);
1728}
1729
1730int mountauto(const char *file, const char *dir, unsigned long int flag, const void *data)
1731{
1732        int ret = -1;
1733        char* saveptr = NULL, *filesystems = NULL, *tmpfilesystems = NULL, *token = NULL;
1734
1735        filesystems = getconfig("filesystems", NULL);
1736        tmpfilesystems = ostrcat(tmpfilesystems, filesystems, 0, 0);
1737
1738        token = strtok_r(tmpfilesystems, ";", &saveptr);
1739        while(token != NULL)
1740        {
1741                ret = mount(file, dir, token, flag, data);
1742                if(ret == 0) break;
1743                token = strtok_r(NULL, ";", &saveptr);
1744        }
1745
1746        free(tmpfilesystems);
1747        return ret;
1748}
1749
1750int setwaswakuptimer(int value)
1751{
1752        char *waswakeuptimerdev = NULL, *tmpstr = NULL;
1753        int ret = 0;
1754
1755        waswakeuptimerdev = getconfig("waswakeuptimerdev", NULL);
1756
1757        if(waswakeuptimerdev != NULL)
1758        {
1759                debug(100, "set %s to %d", waswakeuptimerdev, value);
1760                tmpstr = oitoa(value);
1761                ret = writesys(waswakeuptimerdev, tmpstr, 0);
1762                free(tmpstr); tmpstr = NULL;
1763                return ret;
1764        }
1765
1766        return 0;
1767}
1768
1769int getwaswakuptimer()
1770{
1771        int ret = 0;
1772        char *waswakeuptimerdev = NULL;
1773        char *value = NULL;
1774
1775        waswakeuptimerdev = getconfig("waswakeuptimerdev", NULL);
1776
1777        if(waswakeuptimerdev == NULL)
1778        {
1779                err("NULL detect");
1780                return 0;
1781        }
1782
1783        value = readsys(waswakeuptimerdev, 1);
1784        if(value == NULL)
1785        {
1786                err("NULL detect");
1787                return 0;
1788        }
1789
1790        // start from timer
1791        if(atoi(value) == 1) ret = 1;
1792
1793        free(value);
1794        return ret;
1795}
1796
1797int getrtctime()
1798{
1799        int ret = 0;
1800        char *rtctimedev = NULL;
1801        char *value = NULL;
1802
1803        rtctimedev = getconfig("rtctimedev", NULL);
1804
1805        if(rtctimedev == NULL)
1806        {
1807                err("NULL detect");
1808                return 0;
1809        }
1810
1811        value = readsys(rtctimedev, 1);
1812        if(value == NULL)
1813        {
1814                err("NULL detect");
1815                return 0;
1816        }
1817
1818        // start from timer
1819        if(atoi(value) == 1) ret = 1;
1820
1821        free(value);
1822        return ret;
1823}
1824
1825void checkboxstart()
1826{
1827        struct rectimer* node = rectimer;
1828        int timediff = getconfigint("rectimer_timediff", NULL);
1829        int test = 0;
1830       
1831        if(node == NULL)
1832        {
1833                setcecstandby(0);
1834                return;                                                 //no record
1835        }
1836
1837        while(node != NULL)
1838        {
1839                if(node->status < 2)
1840                {
1841                        time_t akttime = time(NULL);
1842                        time_t begin = node->begin - getconfigint("wakeuptimerdevdiff", NULL);
1843
1844                        debug(400, "begin=%ld akttime1=%ld akttime2=%ld", begin, akttime - timediff, akttime + timediff);
1845
1846                        if(begin > akttime - timediff && begin < akttime + timediff)
1847                        {
1848                                debug(400, "found rectimer who has start the box");
1849                                setwaswakuptimer(1);
1850                                setcecstandby(1);
1851                                test = 1;
1852                        }
1853                }
1854                node = node->next;
1855        }
1856        if(test == 0)
1857                setcecstandby(0);
1858}
1859
1860int setwakeuptimerdev(time_t value)
1861{
1862        char* wakeuptimerdev, *tmpstr = NULL;
1863        int ret = 0;
1864        int diff = getconfigint("wakeuptimerdevdiff", NULL);
1865
1866        if(value != 0x7FFFFFFF && value - diff > time(NULL))
1867                value -= diff;
1868
1869#ifdef MIPSEL   
1870        value += 7200;
1871#endif
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        if(!ostrncmp("letterbox", tmppolicy, 8))
1915                tmpstr = ostrcat(tmpstr, "panscan", 1, 0);
1916        else if(!ostrncmp("panscan", tmppolicy, 7))
1917                tmpstr = ostrcat(tmpstr, "non", 1, 0);
1918        else if(!ostrncmp("non", tmppolicy, 3))
1919                tmpstr = ostrcat(tmpstr, "bestfit", 1, 0);
1920        else if(!ostrncmp("bestfit", tmppolicy, 7))
1921                tmpstr = ostrcat(tmpstr, "letterbox", 1, 0);
1922
1923        setpolicy(tmpstr);
1924
1925        free(tmpstr); tmpstr = NULL;
1926        free(tmppolicy); tmppolicy = NULL;
1927        return 0;
1928}
1929
1930char* getmac(char* dev)
1931{
1932        int sock = -1, i = 0;
1933        struct ifreq buf;
1934        char* tmpstr = NULL;
1935        char tmpbuf[4] = {};
1936
1937        if(dev == NULL) return NULL;
1938
1939        sock = socket(PF_INET, SOCK_DGRAM, 0);
1940        if(sock >= 0)
1941        {
1942                memset(&buf, 0x00, sizeof(buf));
1943                strcpy(buf.ifr_name, dev);
1944                ioctl(sock, SIOCGIFHWADDR, &buf);
1945                close(sock);
1946
1947                for(i = 0; i < 6; i++)
1948                {
1949                        snprintf(tmpbuf, 4, "%.2X:", (unsigned char)buf.ifr_hwaddr.sa_data[i]);
1950                        tmpstr = ostrcat(tmpstr, tmpbuf, 1, 0);
1951                }
1952                if(tmpbuf != NULL)
1953                        tmpstr[strlen(tmpstr) - 1] = '\0';
1954        }
1955
1956        return tmpstr;
1957}
1958
1959char* getdefaultgw()
1960{
1961        char* name = NULL;
1962        unsigned long def, gw, m;
1963        int flags, ref, use, metric, mtu, win, ir;
1964        struct in_addr ip;
1965
1966        FILE *fd = fopen("/proc/net/route", "r");
1967        if(fd == NULL)
1968                return NULL;
1969
1970        if(fscanf(fd, "%*[^\n]\n") < 0)
1971        {
1972                fclose(fd);
1973                return NULL;
1974        }
1975
1976        name = malloc(64);
1977        if(name == NULL)
1978        {
1979                err("no mem");
1980                return NULL;
1981        }
1982
1983        while(1)
1984        {
1985                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);
1986                if(def == 0) break;
1987                if(r != 11)
1988                {
1989                        fclose(fd);
1990                        free(name);
1991                        return NULL;
1992                }
1993                if(!(flags & 0x0001)) continue; //is interface down
1994        }
1995
1996        fclose(fd);
1997        free(name);
1998
1999        ip.s_addr = gw;
2000        if(def == 0)
2001                return inet_ntoa(ip);
2002
2003        return NULL;
2004}
2005
2006char* changefilenameext(char* filename, char* ext)
2007{
2008        char* newfilename = NULL;
2009        char* zeichen = NULL;
2010
2011        if(filename == NULL) return NULL;
2012
2013        newfilename = ostrcat(filename, NULL, 0, 0);
2014
2015        zeichen = strrchr(newfilename, '.');
2016        if(zeichen != NULL)
2017        {
2018                zeichen[0] = '\0';
2019                newfilename = ostrcat(newfilename, ext, 1, 0);
2020        }
2021
2022        return newfilename;
2023}
2024
2025int cmpfilenameext(char* filename, char* ext)
2026{
2027        char* zeichen = NULL;
2028
2029        if(filename == NULL) return 1;
2030
2031        zeichen = strrchr(filename, '.');
2032        if(zeichen != NULL)
2033        {
2034                if(ostrcasecmp(zeichen, ext) == 0) return 0;
2035        }
2036
2037        return 1;
2038}
2039
2040char* getfilenameext(char* filename)
2041{
2042        char* zeichen = NULL;
2043
2044        if(filename == NULL) return NULL;
2045
2046        zeichen = strrchr(filename, '.');
2047        if(zeichen != NULL)
2048        {
2049                return ostrcat(zeichen + 1, NULL, 0, 0);
2050        }
2051
2052        return NULL;
2053}
2054
2055char* getfilenamepng(char* filename)
2056{
2057        char* tmpstr = NULL;
2058
2059        if(filename == NULL) return NULL;
2060       
2061        if(!filelistflt(".avi .dat .divx .flv .mkv .m4v .mp4 .mov .mpg .mpeg .mts .m2ts .trp .ts .vdr .vob .wmv .rm", filename))
2062                tmpstr = ostrcat("movie", NULL, 0, 0);
2063        else if(!filelistflt(".mp3 .flac .ogg .wma .ra .wav", filename))
2064                tmpstr = ostrcat("musik", NULL, 0, 0);
2065        else if(!filelistflt(".jpg .png", filename))
2066                tmpstr = ostrcat("picture", NULL, 0, 0);
2067        else
2068                tmpstr = ostrcat(getfilenameext(filename), NULL, 1, 0);
2069
2070        if(tmpstr != NULL)
2071        {
2072                return tmpstr;
2073        }
2074
2075        return NULL;
2076}
2077
2078char* getcurrentdir(char* path)
2079{
2080        char* zeichen = NULL;
2081
2082        if(path == NULL) return NULL;
2083
2084        zeichen = strrchr(path, '/');
2085        if(zeichen != NULL)
2086        {
2087                return ostrcat(zeichen + 1, NULL, 0, 0);
2088        }
2089
2090        return NULL;
2091}
2092
2093char* convert_timesec(int sec)
2094{
2095        int hour = 0, min = 0, seconds = 0;
2096        char* buf = NULL;
2097
2098        buf = malloc(9);
2099        if(buf == NULL)
2100        {
2101                err("no mem");
2102                return NULL;
2103        }
2104
2105        seconds = sec % 60;
2106        min = (sec / 60) % 60;
2107        hour = sec / 3600;
2108
2109        if(seconds < 0) seconds = 0;
2110        if(min < 0) min = 0;
2111        if(hour < 0 || hour > 23)
2112        {
2113                hour = 0;
2114                min = 0;
2115                seconds = 0;
2116        }
2117
2118        snprintf(buf, 9, "%02d:%02d:%02d", hour, min, seconds);
2119
2120        return buf;
2121}
2122
2123int checkdate()
2124{
2125        time_t dvbtime = 0;
2126
2127        if(time(NULL) < 1072224000 || status.timeupdatecount > 3600) // 01.01.2004
2128        {
2129                if(dvbgetdate(&dvbtime, 10000000) == 0) //10 sek
2130                {
2131                        setsystime(&dvbtime);
2132                        status.timeupdatecount = 0;
2133                        return 0;
2134                }
2135                return 1;
2136        }
2137        return 0;
2138}
2139
2140void closeonexec(int fd)
2141{
2142        if(fd > -1)
2143                fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
2144}
2145
2146void startnewsletter(flag)
2147{
2148        if(flag == 1)
2149        {
2150                if(getconfigint("newsletter", NULL) == 1 && status.newsletterthread == NULL)
2151                        status.newsletterthread = addtimer(&newsletterthreadfunc, START, 1000, 1, NULL, NULL, NULL);
2152        }
2153        else if(status.newsletterthread != NULL)
2154        {
2155                status.newsletterthread->aktion = STOP;
2156                status.newsletterthread = NULL;
2157        }
2158}
2159
2160void startthumb(flag)
2161{
2162        if(flag == 1)
2163        {
2164                if(getconfigint("createthumb", NULL) == 1 && status.thumbthread == NULL)
2165                        status.thumbthread = addtimer(&thumbthread, START, 1000, 1, NULL, NULL, NULL);
2166        }
2167        else if(status.thumbthread != NULL)
2168        {
2169                status.thumbthread->aktion = STOP;
2170                status.thumbthread = NULL;
2171        }
2172}
2173
2174void starthttpd(flag)
2175{
2176        if(flag == 1)
2177        {
2178                if(getconfigint("httpdstart", NULL) == 1 && status.httpthread == NULL)
2179                {
2180                        status.httpthread = addtimer(&httpdthreadfunc, START, 10000, -1, NULL, NULL, NULL);
2181                        if(status.httpthread != NULL)
2182                                status.httpthread->flag = setbit(status.httpthread->flag, 0);
2183                }
2184        }
2185        else if(status.httpthread != NULL)
2186        {
2187                status.httpthread->aktion = STOP;
2188                status.httpthread = NULL;
2189        }
2190}
2191
2192void startrguid(flag)
2193{
2194        if(flag == 1)
2195        {
2196                if(getconfigint("rguidstart", NULL) == 1 && status.rguithread == NULL)
2197                {
2198                        status.rguithread = addtimer(&rguidthreadfunc, START, 10000, -1, NULL, NULL, NULL);
2199                        if(status.rguithread != NULL)
2200                                status.rguithread->flag = setbit(status.rguithread->flag, 0);
2201                }
2202        }
2203        else if(status.rguithread != NULL)
2204        {
2205                status.rguithread->aktion = STOP;
2206                status.rguithread = NULL;
2207        }
2208}
2209
2210int setoverclockfreq(int mode)
2211{
2212        // mode 0 = Set Standby Freq
2213        // mode 1 = Set Freq
2214
2215        if(ostrcmp(getownconfig("standby_overclock"), "0") == 0)
2216                return 1;
2217
2218        if(isfile("/proc/cpu_frequ/pll0_ndiv_mdiv") == 0)
2219                return 1;
2220
2221        char* tmpstr = NULL;
2222
2223        if(mode == 0)
2224                tmpstr = getownconfig("standby_freq");
2225        else
2226                tmpstr = getownconfig("pll0_ndiv_mdiv");
2227
2228        return writesys("/proc/cpu_frequ/pll0_ndiv_mdiv", tmpstr, 1);
2229}
2230
2231/*
2232int checkdev(char* dev)
2233{
2234        char* cmd = NULL;
2235        cmd = ostrcat(cmd, "cat ", 1, 0);
2236        cmd = ostrcat(cmd, dev, 1, 0);
2237
2238        char* tmpstr = NULL;
2239        tmpstr = string_newline(command(cmd));
2240        free(cmd), cmd = NULL;
2241
2242        if(tmpstr == NULL)
2243        {
2244                return 0;
2245        }
2246
2247        if(ostrcmp(tmpstr, "Segmentation fault") == 0)
2248        {
2249                return 0;
2250        }
2251       
2252        free(tmpstr), tmpstr = NULL;
2253        return 1;
2254}
2255*/
2256
2257int setsaturation(int value)
2258{
2259        char* saturationdev;
2260
2261        saturationdev = getconfig("saturationdev", NULL);
2262
2263        if(saturationdev != NULL /*&& checkdev(saturationdev)*/)
2264        {
2265                debug(100, "set %s to %d", saturationdev, value);
2266                return writesysint(saturationdev, value, 1);
2267        }
2268
2269        return 0;
2270}
2271
2272int setbrightness(int value)
2273{
2274        char* brightnessdev;
2275
2276        brightnessdev = getconfig("brightnessdev", NULL);
2277
2278        if(brightnessdev != NULL /*&& checkdev(brightnessdev)*/)
2279        {
2280                debug(100, "set %s to %d", brightnessdev, value);
2281                return writesysint(brightnessdev, value, 1);
2282        }
2283
2284        return 0;
2285}
2286
2287int setcontrast(int value)
2288{
2289        char* contrastdev;
2290
2291        contrastdev = getconfig("contrastdev", NULL);
2292
2293        if(contrastdev != NULL /*&& checkdev(contrastdev)*/)
2294        {
2295                debug(100, "set %s to %d", contrastdev, value);
2296                return writesysint(contrastdev, value, 1);
2297        }
2298
2299        return 0;
2300}
2301
2302int settint(int value)
2303{
2304        char* tintdev;
2305
2306        tintdev = getconfig("tintdev", NULL);
2307
2308        if(tintdev != NULL /*&& checkdev(tintdev)*/)
2309        {
2310                debug(100, "set %s to %d", tintdev, value);
2311                return writesysint(tintdev, value, 1);
2312        }
2313
2314        return 0;
2315}
2316
2317int ozip(char* inbuf, int inlen, char** outbuf, int* outlen, int level)
2318{
2319        int ret = 0;
2320        z_stream stream;
2321       
2322        if(inbuf == NULL || outbuf == NULL || inlen == 0) return 1;
2323
2324        stream.zalloc = Z_NULL;
2325        stream.zfree = Z_NULL;
2326        stream.opaque = Z_NULL;
2327        stream.avail_in = 0;
2328        stream.next_in = Z_NULL;
2329        stream.avail_out = 0;
2330        stream.next_out = Z_NULL;
2331
2332        ret = deflateInit(&stream, level);
2333        if(ret != Z_OK)
2334                return 1;
2335
2336        *outbuf = malloc(inlen);
2337        if(*outbuf == NULL)
2338        {
2339                err("no mem");
2340                (void)deflateEnd(&stream);
2341                return 1;
2342        }
2343
2344        stream.avail_in = inlen;
2345        stream.next_in = (void*)inbuf;
2346 
2347        do
2348        {
2349                stream.avail_out = inlen;
2350                stream.next_out = (void*)*outbuf;
2351
2352                ret = deflate(&stream, Z_FINISH);
2353                if(ret == Z_STREAM_ERROR)
2354                {
2355                        free(*outbuf); *outbuf = NULL;
2356                        (void)deflateEnd(&stream);
2357                        return 1;
2358                }
2359        }
2360        while(stream.avail_out == 0);
2361       
2362        char* tmpoutbuf = *outbuf;     
2363        *outlen = inlen - stream.avail_out;
2364        *outbuf = realloc(*outbuf, *outlen);
2365        if(*outbuf == NULL)
2366        {
2367                if(*outlen > 0)
2368                {
2369                        err("no mem"); 
2370                        free(tmpoutbuf);
2371                }
2372                *outlen = 0;
2373                (void)deflateEnd(&stream);
2374                return 1;
2375        }       
2376
2377        (void)deflateEnd(&stream);
2378        return 0;
2379}
2380
2381//flag 0: malloc mem
2382//flag 1: don't malloc mem
2383//flag 2: malloc mem (gzip)
2384//flag 3: don't malloc mem (gzip)
2385int ounzip(char* inbuf, int inlen, char** outbuf, int* outlen, int maxbuf, int flag)
2386{
2387        int ret = 0;
2388        z_stream stream;
2389       
2390        if(inbuf == NULL || outbuf == NULL || maxbuf == 0) return 1;
2391        if(flag == 1 && *outbuf == NULL) return 1;
2392
2393        stream.zalloc = Z_NULL;
2394        stream.zfree = Z_NULL;
2395        stream.opaque = Z_NULL;
2396        stream.avail_in = 0;
2397        stream.next_in = Z_NULL;
2398        stream.avail_out = 0;
2399        stream.next_out = Z_NULL;
2400
2401        if(flag == 2 || flag == 3)
2402        {
2403                ret = inflateInit2(&stream, 16 + MAX_WBITS);
2404                if(flag == 2) flag = 0;
2405                else if(flag == 3) flag = 1;
2406        }
2407        else
2408                ret = inflateInit(&stream);
2409        if(ret != Z_OK)
2410                return 1;
2411
2412        if(flag == 0)
2413        {
2414                *outbuf = malloc(maxbuf);
2415                if(*outbuf == NULL)
2416                {
2417                        err("no mem");
2418                        (void)inflateEnd(&stream);
2419                        return 1;
2420                }
2421        }
2422
2423        stream.avail_in = inlen;
2424        stream.next_in = (void*)inbuf;
2425
2426        int round = 0;
2427        do
2428        {
2429                stream.avail_out = maxbuf;
2430               
2431                if(flag == 0 && round > 0)
2432                {
2433                        char* tmpoutbuf = *outbuf;
2434                        *outbuf = realloc(*outbuf, maxbuf * (round + 1));
2435                        if(*outbuf == NULL)
2436                        {
2437                                err("no mem");
2438                                free(tmpoutbuf);
2439                                (void)inflateEnd(&stream);
2440                                return 1;
2441                        }
2442                        stream.next_out = (void*)(*outbuf) + maxbuf * round;
2443                }
2444                else
2445                        stream.next_out = (void*)*outbuf;
2446
2447                ret = inflate(&stream, Z_NO_FLUSH);
2448                if(ret == Z_NEED_DICT || ret == Z_DATA_ERROR || ret == Z_MEM_ERROR)
2449                {
2450                        if(flag == 0)
2451                        {
2452                                free(*outbuf);
2453                                *outbuf = NULL;
2454                        }                               
2455                        (void)inflateEnd(&stream);
2456                        return 1;
2457                }
2458
2459                round++;
2460        }
2461        while(stream.avail_out == 0);
2462       
2463        if(flag == 0)
2464        {
2465                char* tmpoutbuf = *outbuf;
2466                *outlen = (maxbuf * round) - stream.avail_out;
2467                *outbuf = realloc(*outbuf, *outlen);
2468                if(*outbuf == NULL)
2469                {
2470                        err("no mem");
2471                        if(*outlen > 0) free(tmpoutbuf);
2472                        *outlen = 0;
2473                        (void)inflateEnd(&stream);
2474                        return 1;
2475                }       
2476        }
2477        else
2478                *outlen = maxbuf - stream.avail_out;                   
2479
2480        (void)inflateEnd(&stream);
2481        return 0;
2482}
2483
2484void endianswapshort(unsigned short* value)
2485{
2486        *value = (*value >> 8) | (*value << 8);
2487}
2488
2489int rcnumber(int rcret)
2490{
2491        if(rcret == getrcconfigint("rc0", NULL) ||
2492        rcret == getrcconfigint("rc1", NULL) ||
2493        rcret == getrcconfigint("rc2", NULL) ||
2494        rcret == getrcconfigint("rc3", NULL) ||
2495        rcret == getrcconfigint("rc4", NULL) ||
2496        rcret == getrcconfigint("rc5", NULL) ||
2497        rcret == getrcconfigint("rc6", NULL) ||
2498        rcret == getrcconfigint("rc7", NULL) ||
2499        rcret == getrcconfigint("rc8", NULL) ||
2500        rcret == getrcconfigint("rc9", NULL))
2501                return rcret;
2502        else
2503                return -9999;
2504}
2505
2506int checkdirext(char* dir, char* ext)
2507{
2508        struct dirent *dirent = NULL;
2509        DIR *pdir = NULL;
2510
2511        pdir = opendir(dir);
2512        if(pdir != NULL)
2513        {
2514                while((dirent = readdir(pdir)) != NULL)
2515                {
2516                        if(ostrcmp(".", dirent->d_name) != 0 && ostrcmp("..", dirent->d_name) != 0)
2517                        {
2518                                if(ostrstr(dirent->d_name, ext) != NULL)
2519                                {
2520                                        closedir(pdir);
2521                                        return 1;
2522                                }
2523                        }
2524                }
2525
2526                closedir(pdir);
2527        }
2528
2529        return 0;
2530}
2531
2532int delallfiles(char* dir, char* ext)
2533{
2534        struct dirent *dirent = NULL;
2535        DIR *pdir = NULL;
2536        char* tmpstr = NULL;
2537
2538        pdir = opendir(dir);
2539        if(pdir != NULL)
2540        {
2541                while((dirent = readdir(pdir)) != NULL)
2542                {
2543                        if(ostrcmp(".", dirent->d_name) != 0 && ostrcmp("..", dirent->d_name) != 0)
2544                        {
2545                                if(ext == NULL || ostrstr(dirent->d_name, ext) != NULL)
2546                                {
2547                                        tmpstr = ostrcat(dir, "/", 0, 0);
2548                                        tmpstr = ostrcat(tmpstr, dirent->d_name, 1, 0);
2549                                        unlink(tmpstr);
2550                                        free(tmpstr); tmpstr = NULL;
2551                                }
2552                        }
2553                }
2554
2555                closedir(pdir);
2556        }
2557
2558        return 0;
2559}
2560
2561unsigned long getfilecount(char* dir)
2562{
2563        unsigned long count = 0;
2564        struct dirent *dirent = NULL;
2565        DIR *pdir = NULL;
2566
2567        pdir = opendir(dir);
2568        if(pdir != NULL)
2569        {
2570                while((dirent = readdir(pdir)) != NULL)
2571                        count++;
2572
2573                closedir(pdir);
2574        }
2575
2576        return count;
2577}
2578
2579int getfiletype(char* filename)
2580{
2581        struct stat64 s;
2582
2583        if(filename == NULL) return -1;
2584
2585        if(stat64(filename, &s) >= 0)
2586        {
2587                if(S_ISREG(s.st_mode)) return DT_REG;
2588                if(S_ISDIR(s.st_mode)) return DT_DIR;
2589                if(S_ISCHR(s.st_mode)) return DT_CHR;
2590                if(S_ISBLK(s.st_mode)) return DT_BLK;
2591                if(S_ISFIFO(s.st_mode)) return DT_FIFO;
2592                if(S_ISLNK(s.st_mode)) return DT_LNK;
2593        }
2594
2595        return DT_UNKNOWN;
2596}
2597
2598int getlfiletype(char* filename)
2599{
2600        struct stat64 s;
2601
2602        if(filename == NULL) return -1;
2603
2604        if(lstat64(filename, &s) >= 0)
2605        {
2606                if(S_ISREG(s.st_mode)) return DT_REG;
2607                if(S_ISDIR(s.st_mode)) return DT_DIR;
2608                if(S_ISCHR(s.st_mode)) return DT_CHR;
2609                if(S_ISBLK(s.st_mode)) return DT_BLK;
2610                if(S_ISFIFO(s.st_mode)) return DT_FIFO;
2611                if(S_ISLNK(s.st_mode)) return DT_LNK;
2612        }
2613
2614        return DT_UNKNOWN;
2615}
2616
2617unsigned long long getfullspace(char* dir)
2618{
2619        struct statfs64 s;
2620        unsigned long long fullsize = 0;
2621
2622        if(statfs64(dir, &s) >= 0)
2623        {
2624                fullsize = s.f_blocks;
2625                fullsize *= s.f_bsize;
2626        }
2627
2628        return fullsize;
2629}
2630
2631unsigned long long getfreespace(char* dir)
2632{
2633        struct statfs64 s;
2634        unsigned long long freesize = 0;
2635
2636        if(statfs64(dir, &s) >= 0)
2637        {
2638                freesize = s.f_bfree;
2639                freesize *= s.f_bsize;
2640        }
2641
2642        return freesize;
2643}
2644
2645int checkbit(int value, int bitpos)
2646{
2647        int ret = 0;
2648
2649        ret = value & (1 << bitpos) ? 1: 0;
2650        return ret;
2651}
2652
2653int tooglebit(int value, int bitpos)
2654{
2655        value ^= 1 << bitpos;
2656        return value;
2657}
2658
2659int clearbit(int value, int bitpos)
2660{
2661        value &= ~(1 << bitpos);
2662        return value;
2663}
2664
2665int setbit(int value, int bitpos)
2666{
2667        value |= 1 << bitpos;
2668        return value;
2669}
2670
2671int setsystime(time_t* newtime)
2672{
2673        if (stime(newtime))
2674        {
2675                err("can't set system time");
2676                return 1;
2677        }
2678        return 0;
2679}
2680
2681off64_t getfilesize(char* name)
2682{
2683        struct stat64 sbuf;
2684
2685        if(lstat64(name, &sbuf) == -1)
2686                return 0;
2687
2688        return sbuf.st_size;
2689}
2690
2691time_t getfiletime(char* name, int type)
2692{
2693        struct stat64 sbuf;
2694
2695        if(lstat64(name, &sbuf) == -1)
2696                return 0;
2697
2698        switch(type)
2699        {
2700                case 1: return sbuf.st_mtime;
2701                case 2: return sbuf.st_ctime;
2702                default: return sbuf.st_atime;
2703        }
2704}
2705
2706int isfile(char* name)
2707{
2708        struct stat64 sbuf;
2709
2710        if(lstat64(name, &sbuf) == -1)
2711                return 0;
2712
2713        if(S_ISREG(sbuf.st_mode))
2714                return 1;
2715
2716        return 0;
2717}
2718
2719int isdir(char* name)
2720{
2721        struct stat64 sbuf;
2722        char *rpath = NULL;
2723
2724        if(lstat64(name, &sbuf) == -1)
2725                return 0;
2726
2727        if(S_ISDIR(sbuf.st_mode))
2728                return 1;
2729
2730        if(S_ISLNK(sbuf.st_mode))
2731        {
2732                rpath = realpath(name, NULL);
2733                if(lstat64(rpath, &sbuf) == -1)
2734                {
2735                        free(rpath);
2736                        return 0;
2737                }
2738                free(rpath);
2739                if(S_ISDIR(sbuf.st_mode))
2740                        return 1;
2741        }
2742
2743        return 0;
2744}
2745
2746char* getmaxsatstring(int maxsat)
2747{
2748        char* tmpstr = NULL, *tmpnr = NULL;
2749        int i;
2750
2751        tmpstr = ostrcat(tmpstr, "1", 1, 0);
2752        for(i = 2; i <= maxsat; i++)
2753        {
2754                tmpnr = oitoa(i);
2755                tmpstr = ostrcat(tmpstr, "\n", 1, 0);
2756                tmpstr = ostrcat(tmpstr, tmpnr, 1, 1);
2757        }
2758        return tmpstr;
2759}
2760
2761void ostrcatbig(char** value1, char* value2, int* maxlen, int* pos)
2762{
2763        int len = 0;
2764
2765        if(value2 == NULL)
2766                return;
2767
2768        len = strlen(value2) + 1;
2769
2770        if(*value1 != NULL && maxlen == 0)
2771                *maxlen = strlen(*value1);
2772
2773        if(*value1 == NULL || *pos + len > *maxlen)
2774        {
2775                *maxlen = *maxlen + len + (MINMALLOC * 10);
2776                *value1 = realloc(*value1, *maxlen);
2777                if(*value1 == NULL)
2778                {
2779                        err("no mem");
2780                        return;
2781                }
2782        }
2783
2784        memcpy(*value1 + *pos, value2, len);
2785        *pos = *pos + (len - 1);
2786}
2787
2788char* ostrshrink(char* value)
2789{
2790        int len = 0;
2791        char* buf = NULL;
2792
2793        if(value == NULL) return NULL;
2794
2795        len = strlen(value);
2796        if(len == 0) return value;
2797
2798        buf = malloc(len + 1);
2799        if(buf == NULL)
2800                return value;
2801
2802        memcpy(buf, value, len);
2803        free(value);
2804        buf[len] = '\0';
2805
2806        return buf;
2807}
2808
2809char* ostrcat(char* value1, char* value2, int free1, int free2)
2810{
2811        int len = 0, len1 = 0, len2 = 0;
2812        char* buf = NULL;
2813
2814        if(value1 == NULL && value2 == NULL) return NULL;
2815
2816        if(value1 != NULL) len1 = strlen(value1);
2817        if(value2 != NULL) len2 = strlen(value2);
2818
2819        len = len1 + len2 + 1;
2820
2821        if(free1 == 1)
2822                buf = realloc(value1, len);
2823        else
2824                buf = malloc(len);
2825        if(buf == NULL)
2826        {
2827                if(free1 == 1) free(value1);
2828                if(free2 == 1) free(value2);
2829                return NULL;
2830        }
2831
2832        if(free1 == 0 && len1 > 0) memcpy(buf, value1, len1);
2833        if(len2 > 0) memcpy(buf + len1, value2, len2);
2834        buf[len - 1] = '\0';
2835
2836        if(free2 == 1) free(value2);
2837
2838        //helpfull for memleak detect
2839        //if(buf != NULL && strlen(buf) == 0x0b - 0x01)
2840        //      printf("******** memleak string (%s) (%p) ********\n", buf, buf);
2841
2842        return buf;
2843}
2844
2845char* ollutoa(uint64_t value)
2846{
2847        char *buf = NULL;
2848
2849        buf = malloc(MINMALLOC);
2850        if(buf == NULL)
2851        {
2852                err("no mem");
2853                return NULL;
2854        }
2855
2856        sprintf(buf, "%llu", value);
2857        buf = ostrshrink(buf);
2858
2859        return buf;
2860}
2861
2862char* olutoa(unsigned long value)
2863{
2864        char *buf = NULL;
2865
2866        buf = malloc(MINMALLOC);
2867        if(buf == NULL)
2868        {
2869                err("no mem");
2870                return NULL;
2871        }
2872
2873        sprintf(buf, "%lu", value);
2874        buf = ostrshrink(buf);
2875
2876        return buf;
2877}
2878
2879char* oitoax(int value)
2880{
2881        char *buf = NULL;
2882
2883        buf = malloc(MINMALLOC);
2884        if(buf == NULL)
2885        {
2886                err("no mem");
2887                return NULL;
2888        }
2889
2890        sprintf(buf, "%x", value);
2891        buf = ostrshrink(buf);
2892
2893        return buf;
2894}
2895
2896char* oitoa(int value)
2897{
2898        char *buf = NULL;
2899
2900        buf = malloc(MINMALLOC);
2901        if(buf == NULL)
2902        {
2903                err("no mem");
2904                return NULL;
2905        }
2906
2907        sprintf(buf, "%d", value);
2908        buf = ostrshrink(buf);
2909
2910        return buf;
2911}
2912
2913char* oitoa64(off64_t value)
2914{
2915        char *buf = NULL;
2916
2917        buf = malloc(MINMALLOC);
2918        if(buf == NULL)
2919        {
2920                err("no mem");
2921                return NULL;
2922        }
2923
2924        sprintf(buf, "%lld", value);
2925        buf = ostrshrink(buf);
2926
2927        return buf;
2928}
2929
2930char* oftoa64(double value, char* count)
2931{
2932        char *buf = NULL;
2933        char* tmpstr = NULL;
2934
2935        buf = malloc(MINMALLOC);
2936        if(buf == NULL)
2937        {
2938                err("no mem");
2939                return NULL;
2940        }
2941
2942        tmpstr = ostrcat("%.", count, 0, 0);
2943        tmpstr = ostrcat(tmpstr, "f", 1, 0);
2944
2945        sprintf(buf, tmpstr, value);
2946        buf = ostrshrink(buf);
2947
2948        free(tmpstr);
2949        return buf;
2950}
2951
2952int ostrncmp(char* value1, char* value2, int count)
2953{
2954        int ret = 1;
2955
2956        if(value1 != NULL && value2 != NULL)
2957                ret = strncmp(value1, value2, count);
2958
2959        return ret;
2960}
2961
2962int ostrcmp(char* value1, char* value2)
2963{
2964        int ret = 1;
2965
2966        if(value1 != NULL && value2 != NULL)
2967                ret = strcmp(value1, value2);
2968
2969        return ret;
2970}
2971
2972int ostrcasecmp(char* value1, char* value2)
2973{
2974        int ret = 1;
2975
2976        if(value1 != NULL && value2 != NULL)
2977                ret = strcasecmp(value1, value2);
2978
2979        return ret;
2980}
2981
2982char* createpath(char* dir, char* file)
2983{
2984        char *absdir = NULL;
2985        char *pos = NULL;
2986        char* tmpdir = NULL;
2987
2988        if(dir == NULL || file == NULL)
2989        {
2990                err("NULL detect");
2991                return NULL;
2992        }
2993
2994        tmpdir = ostrcat(dir, NULL, 0, 0);
2995        if(tmpdir == NULL)
2996        {
2997                err("NULL detect");
2998                return NULL;
2999        }
3000
3001        while((tmpdir[strlen(tmpdir) - 1] == '.' && tmpdir[strlen(tmpdir) - 2] != '.') || tmpdir[strlen(tmpdir) - 1] == '/')
3002                tmpdir[strlen(tmpdir) - 1] = '\0';
3003
3004        while(tmpdir[strlen(tmpdir) - 1] == '.' && tmpdir[strlen(tmpdir) - 2] == '.')
3005        {
3006                tmpdir[strlen(tmpdir) - 1] = '\0';
3007                tmpdir[strlen(tmpdir) - 1] = '\0';
3008                if(tmpdir[strlen(tmpdir) - 1] == '/')
3009                        tmpdir[strlen(tmpdir) - 1] = '\0';
3010                pos = strrchr(tmpdir, '/');
3011                if(pos != NULL)
3012                        pos[0] = '\0';
3013        }
3014
3015        absdir = malloc(strlen(tmpdir) + strlen(file) + 2);
3016        if(absdir == NULL)
3017        {
3018                free(tmpdir);
3019                err("no mem");
3020                return NULL;
3021        }
3022
3023        if(strlen(file) > 0 || strlen(tmpdir) == 0)
3024                sprintf(absdir, "%s/%s", tmpdir, file);
3025        else
3026                sprintf(absdir, "%s", tmpdir);
3027
3028        free(tmpdir);
3029        return absdir;
3030}
3031
3032int settimezone(char* zone)
3033{
3034        int ret = 0;
3035        char* tmpzone = NULL, *zonepath = NULL;
3036
3037        zonepath = getconfig("zonepath", NULL);
3038        if(zonepath == NULL)
3039        {
3040                err("config zonepath not defined");
3041                return 1;
3042        }
3043
3044        tmpzone = createpath(zonepath, zone);
3045        if(tmpzone == NULL)
3046                return 1;
3047
3048        setenv("TZ", zone, 1);
3049
3050        ret = unlink(getconfig("localtimefile", NULL));
3051        if(ret != 0)
3052                perr("unlink");
3053        ret = symlink(tmpzone, getconfig("localtimefile", NULL));
3054        if(ret != 0)
3055                perr("link");
3056
3057        free(tmpzone);
3058        return ret;
3059}
3060
3061int delchar(char** text, int pos)
3062{
3063        char *tmptext = NULL;
3064        int i = 0, y = 0, len = 0;
3065
3066        if(text == NULL || *text == NULL)
3067                return pos;
3068
3069        len = strlen(*text);
3070        if(len == 0) return pos;
3071
3072        tmptext = malloc(strlen(*text));
3073        if(tmptext == NULL)
3074        {
3075                err("no mem");
3076                return pos;
3077        }
3078
3079        for(i = 0; i < strlen(*text); i++)
3080        {
3081                if(i == pos - 1)
3082                        y++;
3083
3084                tmptext[i] = (*text)[y];
3085                y++;
3086        }
3087
3088        if(i > 0) tmptext[i - 1] = '\0';
3089        if(pos >= strlen(tmptext)) pos = strlen(tmptext);
3090
3091        free(*text);
3092        *text = tmptext;
3093        return pos;
3094}
3095
3096
3097int insertchar(char** text, char zeichen, int pos)
3098{
3099        char *tmptext = NULL;
3100        int i, y = 0;
3101
3102        if(text == NULL || *text == NULL)
3103                return pos;
3104
3105        tmptext = malloc(strlen(*text) + 2);
3106        if(tmptext == NULL)
3107        {
3108                err("no mem");
3109                return pos;
3110        }
3111
3112        if(strlen(*text) == 0)
3113        {
3114                tmptext[0] = zeichen;
3115                i = 1;
3116                pos = 0;
3117        }
3118        else
3119        {
3120                for(i = 0; i < strlen(*text) + 1; i++)
3121                {
3122                        if(i == pos)
3123                                tmptext[i] = zeichen;
3124                        else
3125                        {
3126                                tmptext[i] = (*text)[y];
3127                                y++;
3128                        }
3129                }
3130        }
3131        tmptext[i] = '\0';
3132
3133        free(*text);
3134        *text = tmptext;
3135        return pos + 1;
3136}
3137
3138void calctext(char* buf, char* buf1, unsigned int* linecount, unsigned int* pagecount, unsigned int* poscount, int pagelen, int page)
3139{
3140        unsigned int tmpposcount = 0;
3141        unsigned int pagepagelen = 0;
3142
3143        *poscount = 0;
3144        *linecount = 1;
3145        *pagecount = 1;
3146
3147        page--;
3148        if(page < 0) page = 0;
3149        pagepagelen = pagelen * page;
3150
3151        if(buf != NULL)
3152        {
3153                while(*buf != '\0')
3154                {
3155                        if(*buf == '\n')
3156                        {
3157                                if(*(buf + 1) == '\0') break;
3158                                (*linecount)++;
3159
3160                                if(*linecount - 1 == pagepagelen)
3161                                        *poscount = tmpposcount + 1;
3162                        }
3163                        buf++;
3164                        tmpposcount++;
3165                }
3166        }
3167
3168        if(buf1 != NULL)
3169        {
3170                while(*buf1 != '\0')
3171                {
3172                        if(*buf1 == '\n')
3173                        {
3174                                if(*(buf1 + 1) == '\0') break;
3175                                (*linecount)++;
3176
3177                                if(*linecount - 1 == pagepagelen)
3178                                        *poscount = tmpposcount + 1;
3179                        }
3180                        buf1++;
3181                        tmpposcount++;
3182                }
3183        }
3184
3185        if(pagelen > 0)
3186                *pagecount = (int)ceil(((float)*linecount / pagelen));
3187}
3188
3189int initlocale(char *localepath)
3190{
3191        setlocale(LC_ALL, "");
3192        if(bindtextdomain(PROGNAME, localepath) == NULL)
3193        {
3194                err("set bindtextdomain");
3195                return 1;
3196        }
3197        if(textdomain(PROGNAME) == NULL)
3198        {
3199                err("set textdomain");
3200                return 1;
3201        }
3202        return 0;
3203}
3204
3205//for langage you must
3206//mkdir /usr/lib/locale
3207//ln -s %titanpath%/po /usr/lib/locale/po
3208//copy SYS_LC_MESSAGES from other language into LC_MESSAGE
3209int setlang(char *lang)
3210{
3211        char *ret;
3212
3213        setenv("LANG", lang, 1);
3214        setenv("LANGUAGE", lang, 1);
3215        ret = setlocale(LC_MESSAGES, lang);
3216        if(ret == NULL)
3217        {
3218                err("can't set LC_MESSAGES to %s", lang);
3219                return 1;
3220        }
3221        return 0;
3222}
3223
3224unsigned long readsysul(const char *filename, int line)
3225{
3226        int i = 0, len = 0;
3227        unsigned long ret = 0;
3228        FILE *fd = NULL;
3229        char *fileline = NULL;
3230        char *buf1 = NULL;
3231
3232        fileline = malloc(MINMALLOC);
3233        if(fileline == NULL)
3234        {
3235                err("no mem");
3236                return 0;
3237        }
3238
3239        fd = fopen(filename, "r");
3240        if(fd == NULL)
3241        {
3242                perr("can't open %s", filename);
3243                free(fileline);
3244                return 0;
3245        }
3246
3247        for(i = 0; i < line; i++)
3248        {
3249                memset(fileline, 0, MINMALLOC);
3250                fgets(fileline, MINMALLOC, fd);
3251        }
3252
3253        len = strlen(fileline) - 1;
3254        if(len >= 0 && fileline[len] == '\n')
3255                fileline[len] = '\0';
3256        buf1 = ostrshrink(fileline);
3257
3258        fclose(fd);
3259
3260        if(buf1 != NULL)
3261        {
3262                ret = strtoul(buf1, NULL, 10);
3263                free(buf1); buf1 = NULL;
3264        }
3265
3266        return ret;
3267}
3268
3269unsigned long long readsysull(const char *filename, int line)
3270{
3271        int i = 0, len = 0;
3272        unsigned long long ret = 0;
3273        FILE *fd = NULL;
3274        char *fileline = NULL;
3275        char *buf1 = NULL;
3276
3277        fileline = malloc(MINMALLOC);
3278        if(fileline == NULL)
3279        {
3280                err("no mem");
3281                return 0;
3282        }
3283
3284        fd = fopen(filename, "r");
3285        if(fd == NULL)
3286        {
3287                perr("can't open %s", filename);
3288                free(fileline);
3289                return 0;
3290        }
3291
3292        for(i = 0; i < line; i++)
3293        {
3294                memset(fileline, 0, MINMALLOC);
3295                fgets(fileline, MINMALLOC, fd);
3296        }
3297
3298        len = strlen(fileline) - 1;
3299        if(len >= 0 && fileline[len] == '\n')
3300                fileline[len] = '\0';
3301        buf1 = ostrshrink(fileline);
3302
3303        fclose(fd);
3304
3305        if(buf1 != NULL)
3306        {
3307                ret = strtoull(buf1, NULL, 10);
3308                free(buf1); buf1 = NULL;
3309        }
3310
3311        return ret;
3312}
3313
3314char* readsys(const char *filename, int line)
3315{
3316        int i = 0, len = 0;
3317        FILE *fd = NULL;
3318        char *fileline = NULL;
3319        char *buf1 = NULL;
3320
3321        fileline = malloc(MINMALLOC);
3322        if(fileline == NULL)
3323        {
3324                err("no mem");
3325                return NULL;
3326        }
3327
3328        fd = fopen(filename, "r");
3329        if(fd == NULL)
3330        {
3331                perr("can't open %s", filename);
3332                free(fileline);
3333                return NULL;
3334        }
3335
3336        for(i = 0; i < line; i++)
3337        {
3338                memset(fileline, 0, MINMALLOC);
3339                fgets(fileline, MINMALLOC, fd);
3340        }
3341
3342        len = strlen(fileline) - 1;
3343        if(len >= 0 && fileline[len] == '\n')
3344                fileline[len] = '\0';
3345        buf1 = ostrshrink(fileline);
3346
3347        fclose(fd);
3348        return buf1;
3349}
3350
3351//flag 0: without \n
3352//flag 1: with \n
3353//flag 2: append without \n
3354//flag 3: append with \n
3355int writesys(const char *filename, char *value, int flag)
3356{
3357        FILE *fd = NULL;
3358        char* tmpstr = NULL;
3359        int ret;
3360
3361        if(value == NULL)
3362        {
3363                err("NULL detect");
3364                return 1;
3365        }
3366
3367        if(flag == 2 || flag == 3)
3368                fd = fopen(filename, "a");
3369        else
3370                fd = fopen(filename, "w");
3371        if(fd == NULL)
3372        {
3373                perr("can't open %s", filename);
3374                return 1;
3375        }
3376
3377        if(flag == 1 || flag == 3)
3378                tmpstr = ostrcat(value, "\n", 0, 0);
3379        else
3380                tmpstr = ostrcat(value, NULL, 0, 0);
3381
3382        ret = fwrite(tmpstr, strlen(tmpstr), 1, fd);
3383        if(ret != 1)
3384        {
3385                perr("writting to %s", filename);
3386                free(tmpstr);
3387                fclose(fd);
3388                return 1;
3389        }
3390
3391        free(tmpstr);
3392        fclose(fd);
3393        return 0;
3394}
3395
3396//flag 0: without \n
3397//flag 1: with \n
3398//flag 2: append without \n
3399//flag 3: append with \n
3400int writesysint(const char *filename, int value, int flag)
3401{
3402        char* tmpstr = NULL;
3403        int ret = 0;
3404
3405        tmpstr = oitoa(value);
3406        ret = writesys(filename, tmpstr, flag);
3407
3408        free(tmpstr);
3409        return ret;
3410}
3411
3412char* getdevcontent(char* devconfig)
3413{
3414        char *dev = NULL;
3415        char *value = NULL;
3416
3417        dev = getconfig(devconfig, NULL);
3418
3419        if(dev == NULL)
3420        {
3421                err("NULL detect");
3422                return NULL;
3423        }
3424
3425        value = readsys(dev, 1);
3426        if(value == NULL)
3427        {
3428                err("NULL detect");
3429                return NULL;
3430        }
3431
3432        return value;
3433}
3434
3435char* convertspacetolf(char* value)
3436{
3437        int i = 0;
3438
3439        while(value[i] != '\0')
3440        {
3441                if(value[i] == ' ')
3442                        value[i] = '\n';
3443                i++;
3444        }
3445
3446        return value;
3447}
3448
3449//flag 0: all
3450//flag 1: hdmi
3451//flag 2: not hdmi
3452char* getcolorformatchoices(int flag)
3453{
3454        char *colorformatchoicesdev = NULL;
3455        char *value = NULL;
3456
3457        colorformatchoicesdev = getconfig("colorformatchoicesdev", NULL);
3458
3459        if(colorformatchoicesdev == NULL)
3460        {
3461                err("NULL detect");
3462                return NULL;
3463        }
3464
3465        value = readsys(colorformatchoicesdev, 1);
3466        if(value == NULL)
3467        {
3468                err("NULL detect");
3469                return NULL;
3470        }
3471       
3472        if(flag == 1)
3473        {
3474                value = string_replace("rgb", NULL, value, 1);
3475                value = string_replace("  ", " ", value, 1);
3476                value = string_replace("cvbs", NULL, value, 1);
3477                value = string_replace("  ", " ", value, 1);
3478                value = string_replace("svideo", NULL, value, 1);
3479                value = string_replace("  ", " ", value, 1);
3480                value = string_replace("yuv", NULL, value, 1);
3481                value = string_replace("  ", " ", value, 1);
3482        }
3483        else if(flag == 2)
3484        {
3485                value = string_replace("hdmi_rgb", NULL, value, 1);
3486                value = string_replace("  ", " ", value, 1);
3487                value = string_replace("hdmi_yuv", NULL, value, 1);
3488                value = string_replace("  ", " ", value, 1);
3489                value = string_replace("hdmi_422", NULL, value, 1);
3490                value = string_replace("  ", " ", value, 1);
3491        }
3492
3493        value = strstrip(value);
3494        value = convertspacetolf(value);
3495
3496        return value;
3497}
3498
3499char* getaudiosourcechoices()
3500{
3501        char *audiosourcechoicesdev = NULL;
3502        char *value = NULL;
3503
3504        audiosourcechoicesdev = getconfig("audiosourcechoicesdev", NULL);
3505
3506        if(audiosourcechoicesdev == NULL)
3507        {
3508                err("NULL detect");
3509                return NULL;
3510        }
3511
3512        value = readsys(audiosourcechoicesdev, 1);
3513        if(value == NULL)
3514        {
3515                err("NULL detect");
3516                return NULL;
3517        }
3518
3519        value = convertspacetolf(value);
3520
3521        return value;
3522}
3523
3524char* getac3choices()
3525{
3526        char *ac3choicesdev = NULL;
3527        char *value = NULL;
3528
3529        ac3choicesdev = getconfig("ac3choicesdev", NULL);
3530
3531        if(ac3choicesdev == NULL)
3532        {
3533                err("NULL detect");
3534                return NULL;
3535        }
3536
3537        value = readsys(ac3choicesdev, 1);
3538        if(value == NULL)
3539        {
3540                err("NULL detect");
3541                return NULL;
3542        }
3543
3544        value = convertspacetolf(value);
3545
3546        return value;
3547}
3548
3549char* getaacchoices()
3550{
3551        char *aacchoicesdev = NULL;
3552        char *value = NULL;
3553
3554        aacchoicesdev = getconfig("aacchoicesdev", NULL);
3555
3556        if(aacchoicesdev == NULL)
3557        {
3558                err("NULL detect");
3559                return NULL;
3560        }
3561
3562        value = readsys(aacchoicesdev, 1);
3563        if(value == NULL)
3564        {
3565                err("NULL detect");
3566                return NULL;
3567        }
3568
3569        value = convertspacetolf(value);
3570
3571        return value;
3572}
3573
3574int setciclock(int slotnr, char* value)
3575{
3576        char* ciclockdev = NULL, *tmpstr = NULL;
3577        int ret = 0;
3578
3579        ciclockdev = getconfig("ciclockdev", NULL);
3580
3581        if(ciclockdev != NULL && value != NULL)
3582        {
3583                tmpstr = malloc(MINMALLOC);
3584                if(tmpstr == NULL)
3585                {
3586                        err("no mem");
3587                        return 1;
3588                }
3589
3590                snprintf(tmpstr, MINMALLOC, ciclockdev, slotnr);
3591                debug(100, "set %s to %s", tmpstr, value);
3592                ret = writesys(tmpstr, value, 0);
3593
3594                free(tmpstr); tmpstr = NULL;
3595                return ret;
3596        }
3597
3598        return 0;
3599}
3600
3601//routes stream from tuner to ci or ci to ci
3602int setciinput(int slotnr, char* value)
3603{
3604        char* ciinputdev = NULL, *tmpstr = NULL;
3605        int ret = 0;
3606
3607        ciinputdev = getconfig("ciinputdev", NULL);
3608
3609        if(ciinputdev != NULL && value != NULL)
3610        {
3611                tmpstr = malloc(MINMALLOC);
3612                if(tmpstr == NULL)
3613                {
3614                        err("no mem");
3615                        return 1;
3616                }
3617
3618                snprintf(tmpstr, MINMALLOC, ciinputdev, slotnr);
3619                debug(100, "set %s to %s", tmpstr, value);
3620                ret = writesys(tmpstr, value, 0);
3621
3622                free(tmpstr); tmpstr = NULL;
3623                return ret;
3624        }
3625
3626        return 0;
3627}
3628
3629//routes stream from tuner or ci to linux
3630int setcisource(int tunernr, char* value)
3631{
3632        char* cisourcedev = NULL, *tmpstr = NULL;
3633        int ret = 0;
3634
3635        cisourcedev = getconfig("cisourcedev", NULL);
3636
3637        if(cisourcedev != NULL && value != NULL)
3638        {
3639                tmpstr = malloc(MINMALLOC);
3640                if(tmpstr == NULL)
3641                {
3642                        err("no mem");
3643                        return 1;
3644                }
3645
3646                snprintf(tmpstr, MINMALLOC, cisourcedev, tunernr);
3647                debug(100, "set %s to %s", tmpstr, value);
3648                ret = writesys(tmpstr, value, 0);
3649
3650                free(tmpstr); tmpstr = NULL;
3651                return ret;
3652        }
3653
3654        return 0;
3655}
3656
3657int setinput(char* value)
3658{
3659        char* inputdev = NULL;
3660        int ret = 0;
3661
3662        inputdev = getconfig("inputdev", NULL);
3663
3664        if(inputdev != NULL && value != NULL)
3665        {
3666                debug(100, "set %s to %s", inputdev, value);
3667                ret = writesys(inputdev, value, 0);
3668                return ret;
3669        }
3670
3671        return 0;
3672}
3673
3674char* getinput()
3675{
3676        char *inputdev = NULL;
3677        char *value = NULL;
3678
3679        inputdev = getconfig("inputdev", NULL);
3680
3681        if(inputdev == NULL)
3682        {
3683                err("NULL detect");
3684                return NULL;
3685        }
3686
3687        value = readsys(inputdev, 1);
3688        if(value == NULL)
3689        {
3690                err("NULL detect");
3691                return NULL;
3692        }
3693
3694        return value;
3695}
3696
3697int setac3(char* value)
3698{
3699        char* ac3dev = NULL;
3700        int ret = 0;
3701
3702        ac3dev = getconfig("ac3dev", NULL);
3703
3704        if(ac3dev != NULL && value != NULL)
3705        {
3706                debug(100, "set %s to %s", ac3dev, value);
3707                ret = writesys(ac3dev, value, 0);
3708                if(ret == 0) addconfig("av_ac3mode", value);
3709                return ret;
3710        }
3711
3712        return 0;
3713}
3714
3715int setaac(char* value)
3716{
3717        char* aacdev = NULL;
3718        int ret = 0;
3719
3720        aacdev = getconfig("aacdev", NULL);
3721
3722        if(aacdev != NULL && value != NULL)
3723        {
3724                debug(100, "set %s to %s", aacdev, value);
3725                ret = writesys(aacdev, value, 0);
3726                if(ret == 0) addconfig("av_aacmode", value);
3727                return ret;
3728        }
3729
3730        return 0;
3731}
3732
3733char* getac3()
3734{
3735        char *ac3dev = NULL;
3736        char *value = NULL;
3737
3738        ac3dev = getconfig("ac3dev", NULL);
3739
3740        if(ac3dev == NULL)
3741        {
3742                err("NULL detect");
3743                return NULL;
3744        }
3745
3746        value = readsys(ac3dev, 1);
3747        if(value == NULL)
3748        {
3749                err("NULL detect");
3750                return NULL;
3751        }
3752
3753        return value;
3754}
3755
3756char* getaac()
3757{
3758        char *aacdev = NULL;
3759        char *value = NULL;
3760
3761        aacdev = getconfig("aacdev", NULL);
3762
3763        if(aacdev == NULL)
3764        {
3765                err("NULL detect");
3766                return NULL;
3767        }
3768
3769        value = readsys(aacdev, 1);
3770        if(value == NULL)
3771        {
3772                err("NULL detect");
3773                return NULL;
3774        }
3775
3776        return value;
3777}
3778
3779int setaudiodelaybitstream(char* value)
3780{
3781        char* audiodelaybitstreamdev = NULL;
3782        int ret = 0;
3783
3784        audiodelaybitstreamdev = getconfig("audiodelaybitstreamdev", NULL);
3785
3786        if(audiodelaybitstreamdev != NULL && value != NULL)
3787        {
3788                debug(100, "set %s to %s", audiodelaybitstreamdev, value);
3789                ret = writesys(audiodelaybitstreamdev, value, 0);
3790                if(ret == 0) addconfig("audiodelaybitstream", value);
3791                return ret;
3792        }
3793
3794        return 0;
3795}
3796
3797char* getaudiodelaybitstream()
3798{
3799        char *audiodelaybitstreamdev = NULL;
3800        char *value = NULL;
3801
3802        audiodelaybitstreamdev = getconfig("audiodelaybitstreamdev", NULL);
3803
3804        if(audiodelaybitstreamdev == NULL)
3805        {
3806                err("NULL detect");
3807                return NULL;
3808        }
3809
3810        value = readsys(audiodelaybitstreamdev, 1);
3811        if(value == NULL)
3812        {
3813                err("NULL detect");
3814                return NULL;
3815        }
3816
3817        return value;
3818}
3819
3820char* getpolicychoices()
3821{
3822        char *policychoicesdev = NULL;
3823        char *value = NULL;
3824
3825        policychoicesdev = getconfig("policychoicesdev", NULL);
3826
3827        if(policychoicesdev == NULL)
3828        {
3829                err("NULL detect");
3830                return NULL;
3831        }
3832
3833        value = readsys(policychoicesdev, 1);
3834        if(value == NULL)
3835        {
3836                err("NULL detect");
3837                return NULL;
3838        }
3839
3840        value = convertspacetolf(value);
3841
3842        return value;
3843}
3844
3845char* getpolicy()
3846{
3847        char *policydev = NULL;
3848        char *value = NULL;
3849
3850        policydev = getconfig("policydev", NULL);
3851
3852        if(policydev == NULL)
3853        {
3854                err("NULL detect");
3855                return NULL;
3856        }
3857
3858        value = readsys(policydev, 1);
3859        if(value == NULL)
3860        {
3861                err("NULL detect");
3862                return NULL;
3863        }
3864
3865        return value;
3866}
3867
3868int setpolicy(char* value)
3869{
3870        char* policydev;
3871        int ret = 0;
3872
3873        policydev = getconfig("policydev", NULL);
3874
3875        if(policydev != NULL && value != NULL)
3876        {
3877                debug(100, "set %s to %s", policydev, value);
3878                ret = writesys(policydev, value, 0);
3879                if(ret == 0) addconfig("av_policy", value);
3880                return ret;
3881        }
3882
3883        return 0;
3884}
3885
3886char* getaspectchoices()
3887{
3888        char *aspectchoicesdev = NULL;
3889        char *value = NULL;
3890
3891        aspectchoicesdev = getconfig("aspectchoicesdev", NULL);
3892
3893        if(aspectchoicesdev == NULL)
3894        {
3895                err("NULL detect");
3896                return NULL;
3897        }
3898
3899        value = readsys(aspectchoicesdev, 1);
3900        if(value == NULL)
3901        {
3902                err("NULL detect");
3903                return NULL;
3904        }
3905
3906        value = convertspacetolf(value);
3907
3908        return value;
3909}
3910
3911char* getaspect()
3912{
3913        char *aspectdev = NULL;
3914        char *value = NULL;
3915
3916        aspectdev = getconfig("aspectdev", NULL);
3917
3918        if(aspectdev == NULL)
3919        {
3920                err("NULL detect");
3921                return NULL;
3922        }
3923
3924        value = readsys(aspectdev, 1);
3925        if(value == NULL)
3926        {
3927                err("NULL detect");
3928                return NULL;
3929        }
3930
3931        return value;
3932}
3933
3934int setaspect(char* value)
3935{
3936        char* aspectdev;
3937        int ret = 0;
3938
3939        aspectdev = getconfig("aspectdev", NULL);
3940
3941        if(aspectdev != NULL && value != NULL)
3942        {
3943                debug(100, "set %s to %s", aspectdev, value);
3944                ret = writesys(aspectdev, value, 0);
3945                if(ret == 0)
3946                {
3947                        addconfig("av_aspect", value);
3948
3949                        //set policy new after change aspect
3950                        char* tmpstr = getpolicy();
3951                        setpolicy(tmpstr);
3952                        free(tmpstr); tmpstr = NULL;
3953                }
3954                return ret;
3955        }
3956
3957        return 0;
3958}
3959
3960char* getvideomodechoices()
3961{
3962        char *videomodechoicesdev = NULL;
3963        char *value = NULL;
3964
3965        videomodechoicesdev = getconfig("videomodechoicesdev", NULL);
3966
3967        if(videomodechoicesdev == NULL)
3968        {
3969                err("NULL detect");
3970                return NULL;
3971        }
3972
3973        value = readsys(videomodechoicesdev, 1);
3974        if(value == NULL)
3975        {
3976                err("NULL detect");
3977                return NULL;
3978        }
3979
3980        value = string_replace("pal", NULL, value, 1);
3981        value = string_replace("  ", " ", value, 1);
3982
3983        if(status.mcaktiv == 0)
3984        {
3985                value = string_replace("1080p60", NULL, value, 1);
3986                value = string_replace("  ", " ", value, 1);
3987                value = string_replace("1080p59", NULL, value, 1);
3988                value = string_replace("  ", " ", value, 1);
3989                value = string_replace("1080p30", NULL, value, 1);
3990                value = string_replace("  ", " ", value, 1);
3991                value = string_replace("1080p29", NULL, value, 1);
3992                value = string_replace("  ", " ", value, 1);
3993                value = string_replace("1080p25", NULL, value, 1);
3994                value = string_replace("  ", " ", value, 1);
3995                value = string_replace("1080p24", NULL, value, 1);
3996                value = string_replace("  ", " ", value, 1);
3997                value = string_replace("1080p23", NULL, value, 1);
3998                value = string_replace("  ", " ", value, 1);
3999                value = string_replace("1080i60", NULL, value, 1);
4000                value = string_replace("  ", " ", value, 1);
4001                value = string_replace("1080i59", NULL, value, 1);
4002                value = string_replace("  ", " ", value, 1);
4003                value = string_replace("1080i60", NULL, value, 1);
4004                value = string_replace("  ", " ", value, 1);
4005                value = string_replace("720p60", NULL, value, 1);
4006                value = string_replace("  ", " ", value, 1);
4007                value = string_replace("576p50", NULL, value, 1);
4008                value = string_replace("  ", " ", value, 1);
4009                value = string_replace("1280x1024_75", NULL, value, 1);
4010                value = string_replace("  ", " ", value, 1);
4011                value = string_replace("1280x1024_70", NULL, value, 1);
4012                value = string_replace("  ", " ", value, 1);
4013                value = string_replace("1280x1024_60", NULL, value, 1);
4014                value = string_replace("  ", " ", value, 1);
4015                value = string_replace("1600x1200_60", NULL, value, 1);
4016                value = string_replace("  ", " ", value, 1);
4017                value = string_replace("1024x768_100", NULL, value, 1);
4018                value = string_replace("  ", " ", value, 1);
4019                value = string_replace("1024x768_90", NULL, value, 1);
4020                value = string_replace("  ", " ", value, 1);
4021                value = string_replace("1024x768_75", NULL, value, 1);
4022                value = string_replace("  ", " ", value, 1);
4023                value = string_replace("1024x768_70", NULL, value, 1);
4024                value = string_replace("  ", " ", value, 1);
4025                value = string_replace("1024x768_60", NULL, value, 1);
4026                value = string_replace("  ", " ", value, 1);
4027        }
4028
4029        value = strstrip(value);
4030        value = convertspacetolf(value);
4031
4032        return value;
4033}
4034
4035char* getmode3dchoices()
4036{
4037        char *mode3dchoicesdev = NULL;
4038        char *value = NULL;
4039
4040        mode3dchoicesdev = getconfig("mode3dchoicesdev", NULL);
4041
4042        if(mode3dchoicesdev == NULL)
4043        {
4044                return ostrcat("off\nsbs\ntab", "", 0, 0);
4045        }
4046
4047        value = readsys(mode3dchoicesdev, 1);
4048        if(value == NULL)
4049        {
4050                err("NULL detect");
4051                return NULL;
4052        }
4053
4054        value = convertspacetolf(value);
4055
4056        return value;
4057}
4058
4059char* getmode3d()
4060{
4061        char *mode3ddev = NULL;
4062        char *value = NULL;
4063
4064        mode3ddev = getconfig("mode3ddev", NULL);
4065
4066        if(mode3ddev == NULL)
4067        {
4068                err("NULL detect");
4069                return NULL;
4070        }
4071
4072        value = readsys(mode3ddev, 1);
4073        if(value == NULL)
4074        {
4075                err("NULL detect");
4076                return NULL;
4077        }
4078
4079        return value;
4080}
4081
4082int setmode3d(char* value)
4083{
4084        char* mode3ddev;
4085        int ret = 0;
4086
4087        mode3ddev = getconfig("mode3ddev", NULL);
4088
4089        if(mode3ddev != NULL && value != NULL)
4090        {
4091                debug(100, "set %s to %s", mode3ddev, value);
4092                ret = writesys(mode3ddev, value, 0);
4093                if(ret == 0) addconfig("av_mode3d", value);
4094                return ret;
4095        }
4096
4097        return 0;
4098}
4099
4100char* getvideomode()
4101{
4102        char *videomodedev = NULL;
4103        char *value = NULL;
4104
4105        videomodedev = getconfig("videomodedev", NULL);
4106
4107        if(videomodedev == NULL)
4108        {
4109                err("NULL detect");
4110                return NULL;
4111        }
4112
4113        value = readsys(videomodedev, 1);
4114        if(value == NULL)
4115        {
4116                err("NULL detect");
4117                return NULL;
4118        }
4119
4120        return value;
4121}
4122
4123void switchvideomode()
4124{
4125        int rcret = 0;
4126        char* tmpstr = NULL, *tmpstr2 = NULL, *tmpstr3 = NULL;
4127        tmpstr = getvideomode();       
4128        struct skin* playpolicy = getscreen("playpolicy");
4129        tmpstr2 = getcolorformat(2);
4130               
4131        if(tmpstr != NULL)
4132        {
4133                if((ostrcmp("pal", tmpstr) == 0 || ostrncmp("576", tmpstr, 3) == 0) && ostrncmp("yuv", tmpstr2, 3) == 0)
4134                {
4135                        setvideomode("720p50", 0);
4136                        changefbresolution("720p50", 0);
4137                        changetext(playpolicy, "720p50 (rgb)");
4138                        writevfdmenu("720p50 (rgb)");
4139                        setcolorformat("rgb", 1);
4140                        unlink("/var/etc/.scart");
4141                }
4142                else if((ostrcmp("pal", tmpstr) == 0 || ostrncmp("576", tmpstr, 3) == 0) && ostrncmp("rgb", tmpstr2, 3) == 0)
4143                {
4144                        setvideomode("720p50", 0);
4145                        changefbresolution("720p50", 0);
4146                        changetext(playpolicy, "720p50 (yuv)");
4147                        writevfdmenu("720p50 (yuv)");
4148                        setcolorformat("yuv", 1);
4149                        unlink("/var/etc/.scart");
4150                }
4151                else if(ostrncmp("720", tmpstr, 3) == 0)
4152                {
4153                        setvideomode("1080i50", 0);
4154                        changefbresolution("1080i50", 0);
4155                        tmpstr3 = ostrcat("1080i50 (", tmpstr2, 0, 0);
4156                        tmpstr3 = ostrcat(tmpstr3, ")", 1, 0);
4157                        changetext(playpolicy, tmpstr3);
4158                        writevfdmenu(tmpstr3);
4159                        unlink("/var/etc/.scart");                     
4160                }
4161                else if(ostrncmp("1080", tmpstr, 4) == 0)
4162                {
4163                        setvideomode("576i50", 0);
4164                        changefbresolution("576i50", 0);
4165                        changetext(playpolicy, "576i50 (rgb)");
4166                        writevfdmenu("576i50 (rgb)");
4167                        setcolorformat("rgb", 1);
4168                        writesys("/var/etc/.scart", "0", 0);
4169                }
4170                /*
4171                int ret = textbox(_("Message"), _("Is this Videomode ok ?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 10, 0);
4172                if(ret == 1 || ret == 2)
4173                {
4174                        setvideomode(tmpstr, 0);
4175                        changefbresolution(tmpstr, 0);
4176                }
4177                */
4178                drawscreen(playpolicy, 0, 0);
4179                while(1)
4180                {
4181                        rcret = waitrc(playpolicy, 5000, 0);
4182                        break;
4183                }
4184                clearscreen(playpolicy);
4185        }
4186        free(tmpstr);
4187        free(tmpstr2);
4188        free(tmpstr3);
4189}
4190
4191//flag 0: write videomode to config
4192//flag 1: don't write videomode to config
4193int setvideomode(char* value, int flag)
4194{
4195        char* videomodedev;
4196        int ret = 0;
4197
4198        videomodedev = getconfig("videomodedev", NULL);
4199
4200        if(videomodedev != NULL && value != NULL)
4201        {
4202                debug(100, "set %s to %s", videomodedev, value);
4203                ret = writesys(videomodedev, value, 0);
4204                if(ret == 0 && flag == 0) addconfig("av_videomode", value);
4205                return ret;
4206        }
4207
4208        return 0;
4209}
4210
4211//flag 0 = hdmi
4212//flag 1 = scart
4213int setcolorformat(char* value, int flag)
4214{
4215        char* colorformatdev;
4216        int ret = 0;
4217
4218        colorformatdev = getconfig("colorformatdev", NULL);
4219
4220        if(colorformatdev != NULL && value != NULL)
4221        {
4222                debug(100, "set %s to %s", colorformatdev, value);
4223                ret = writesys(colorformatdev, value, 0);
4224                if(ret == 0)
4225                {
4226                        if(flag == 0)
4227                                addconfig("av_colorformat", value);
4228                        else
4229                                addconfig("av_colorformatscart", value);
4230                }
4231                return ret;
4232        }
4233
4234        return 0;
4235}
4236
4237char* getcolorformat(int line)
4238{
4239        char *colorformatdev = NULL;
4240        char *value = NULL;
4241
4242        colorformatdev = getconfig("colorformatdev", NULL);
4243
4244        if(colorformatdev == NULL)
4245        {
4246                err("NULL detect");
4247                return NULL;
4248        }
4249
4250        value = readsys(colorformatdev, line);
4251        if(value == NULL)
4252        {
4253                err("NULL detect");
4254                return NULL;
4255        }
4256
4257        return value;
4258}
4259
4260int setaudiosource(char* value)
4261{
4262        char* audiosourcedev;
4263        int ret = 1;
4264
4265        audiosourcedev = getconfig("audiosourcedev", NULL);
4266
4267        if(audiosourcedev != NULL && value != NULL)
4268        {
4269                debug(100, "set %s to %s", audiosourcedev, value);
4270                ret = writesys(audiosourcedev, value, 0);
4271                if(ret == 0) addconfig("av_audiosource", value);
4272                return ret;
4273        }
4274
4275        return 0;
4276}
4277
4278char* getaudiosource()
4279{
4280        char *audiosourcedev = NULL;
4281        char *value = NULL;
4282
4283        audiosourcedev = getconfig("audiosourcedev", NULL);
4284
4285        if(audiosourcedev == NULL)
4286        {
4287                err("NULL detect");
4288                return NULL;
4289        }
4290
4291        value = readsys(audiosourcedev, 1);
4292        if(value == NULL)
4293        {
4294                err("NULL detect");
4295                return NULL;
4296        }
4297
4298        return value;
4299}
4300
4301char* getsataswitch()
4302{
4303        char *sataswitchdev = NULL;
4304        char *value = NULL;
4305
4306        sataswitchdev = getconfig("sataswitchdev", NULL);
4307
4308        if(sataswitchdev == NULL)
4309        {
4310                err("NULL detect");
4311                return NULL;
4312        }
4313
4314        value = readsys(sataswitchdev, 1);
4315        if(value == NULL)
4316        {
4317                err("NULL detect");
4318                return NULL;
4319        }
4320
4321        return value;
4322}
4323
4324int setsataswitch(char* value)
4325{
4326        char* sataswitchdev;
4327        int ret = 1;
4328
4329        sataswitchdev = getconfig("sataswitchdev", NULL);
4330
4331        if(sataswitchdev != NULL && value != NULL)
4332        {
4333                debug(100, "set %s to %s", sataswitchdev, value);
4334                ret = writesys(sataswitchdev, value, 0);
4335                return ret;
4336        }
4337
4338        return 0;
4339}
4340
4341int setprogress(value)
4342{
4343        char *progressdev;
4344
4345        progressdev = getconfig("progressdev", NULL);
4346
4347        if(progressdev != NULL)
4348        {
4349                debug(100, "set %s to %d",progressdev, value);
4350                return writesysint(progressdev, value, 0);
4351        }
4352
4353        return 0;
4354}
4355
4356int setmute(int value)
4357{
4358        char* mutedev;
4359        int tmpvol, ret = 0;
4360
4361        //don't set mute 2x
4362        if(value == 1 && status.mute == 1) return 0;
4363
4364//      printf("mute value: %d\n", value);
4365
4366        if(value == 2)
4367        {
4368                tmpvol = getvol();
4369                tmpvol = tmpvol * 50 / 100;
4370                status.mute = value;
4371                setvol(tmpvol);
4372        }
4373        else
4374        {
4375                mutedev = getconfig("mutedev", NULL);
4376
4377                if(mutedev != NULL)
4378                {
4379                        debug(100, "set %s to %d", mutedev, value);
4380                        //if(status.volautochangevalue != 0 && value == 0) setvol(getvol());
4381                        ret = writesysint(mutedev, value, 0);
4382                        if(ret == 0) status.mute = value;
4383                        if(status.volautochangevalue != 0 && value == 0) setvol(getvol());
4384//                      if(value == 1)
4385//                      {
4386//                              printf("mute\n");
4387//                              system("amixer -c 1 set HDMI mute &");
4388//                              system("amixer -c 1 set Analog mute &");
4389//                              system("amixer -c 1 set SPDIF mute &");
4390//                              sleep(1);
4391//                      }
4392//                      else
4393//                      {
4394//                              printf("unmute\n");
4395//                              system("amixer -c 1 set HDMI unmute &");
4396//                              system("amixer -c 1 set Analog unmute &");
4397//                              system("amixer -c 1 set SPDIF unmute &");
4398//                      }
4399
4400                        return ret;
4401                }
4402        }
4403        return 0;
4404}
4405
4406int setvol(int value)
4407{
4408        char* voldev;
4409        int ret = 0, tmpvol = value;
4410
4411        voldev = getconfig("voldev", NULL);
4412       
4413        if(voldev != NULL)
4414        {
4415                if(value > 100) value = 100;
4416                if(value < 0) value = 0;
4417                if(status.volautochangevalue != 0 && value != 0)
4418                {
4419                        if(status.volautochange == 0)
4420                                value = value - (status.volautochangevalue * value / 100);
4421                }
4422                value = 63 - value * 63 / 100;
4423                debug(100, "set %s to %d", voldev, value);
4424                ret = 0;
4425                if(status.mute == 1)
4426                        status.volmute = value;
4427                else
4428                {
4429                        status.volmute = -1;
4430                        ret = writesysint(voldev, value, 0);
4431
4432#ifdef MIPSEL
4433                        struct dvbdev *audionode = NULL;
4434                        int openaudio = 0;
4435       
4436                        if(ret == 0 && status.aktservice != NULL)
4437                        {
4438                                if(status.aktservice->audiodev == NULL)
4439                                {
4440                                        audionode = audioopen(0); //we must open the audio device for change volume in external player
4441                                        openaudio = 1;
4442                                }
4443                                else
4444                                        audionode = status.aktservice->audiodev;
4445               
4446                                if(ret == 0 && audionode != NULL)
4447                                        ret = setmixer(audionode, value, value);
4448                               
4449                                if(openaudio == 1)
4450                                        audioclose(audionode, -1);
4451                        }
4452#else
4453                        if(ret == 0 && status.aktservice != NULL)
4454                                ret = setmixer(status.aktservice->audiodev, value, value);
4455#endif
4456                }
4457                if(ret == 0 && status.mute != 2) addconfigint("vol", tmpvol);
4458                return ret;
4459        }
4460
4461        return 0;
4462}
4463
4464int getvol()
4465{
4466        char *voldev = NULL;
4467        char *value = NULL;
4468        int tmpvol = -1;
4469
4470        voldev = getconfig("voldev", NULL);
4471
4472        if(voldev == NULL)
4473        {
4474                err("NULL detect");
4475                return 0;
4476        }
4477        if(status.volmute == -1)
4478                value = readsys(voldev, 1);
4479        else
4480                tmpvol = status.volmute;
4481        if(value == NULL && tmpvol == -1)
4482        {
4483                err("NULL detect");
4484                return 0;
4485        }
4486        if(status.volmute == -1)
4487                tmpvol = atoi(value);
4488        free(value);
4489        tmpvol = 100 - tmpvol * 100 / 63;
4490        if(status.volautochangevalue != 0)
4491        {
4492                if(status.volautochange == 0 && status.volautochangevalue < 100)
4493                        tmpvol = tmpvol + ((tmpvol * status.volautochangevalue) / (100 - status.volautochangevalue));
4494        }
4495        return tmpvol;
4496}
4497
4498void setdebuglevel()
4499{
4500        debug_level = getconfigint("debuglevel", NULL);
4501        debug(0, "set debug level to %d", debug_level);
4502}
4503
4504char* getxmlentry(char *line, char *searchstr)
4505{
4506        char *buf = NULL, *buf1 = NULL, *buf2 = NULL;
4507
4508        buf = ostrstr(line, searchstr);
4509        if(buf == NULL)
4510                return NULL;
4511
4512        buf = buf + strlen(searchstr);
4513        if(buf[0] == '"')
4514        {
4515                buf = buf + 1;
4516                buf2 = strchr(buf, '"');
4517                if(buf2 == NULL)
4518                {
4519                        err("strchr returns NULL");
4520                        return NULL;
4521                }
4522                buf1 = strndup(buf, buf2 - buf);
4523                if(buf1 == NULL)
4524                {
4525                        err("strndup failed");
4526                        return NULL;
4527                }
4528        }
4529        else
4530        {
4531                buf2 = strchr(buf, ' ');
4532                if(buf2 == NULL)
4533                {
4534                        buf2 = ostrstr(buf, "/>");
4535                        if(buf2 == NULL)
4536                        {
4537                                buf2 = strchr(buf, '>');
4538                                if(buf2 == NULL)
4539                                {
4540                                        err("strchr returns NULL");
4541                                        return NULL;
4542                                }
4543                        }
4544                }
4545                buf1 = strndup(buf, buf2 - buf);
4546                if(buf1 == NULL)
4547                {
4548                        err("strndup failed");
4549                        return NULL;
4550                }
4551        }
4552
4553        return buf1;
4554}
4555
4556char* readbintomem(const char* filename, size_t size)
4557{
4558        FILE *fd = NULL;
4559        char *fileline = NULL;
4560
4561        fileline = calloc(1, size + 1);
4562        if(fileline == NULL)
4563        {
4564                err("no mem");
4565                return NULL;
4566        }
4567
4568        fd = fopen(filename, "rb");
4569        if(fd == NULL)
4570        {
4571                perr("can't open %s", filename);
4572                free(fileline);
4573                return NULL;
4574        }
4575
4576        fread(fileline, size, 1, fd);
4577
4578        fclose(fd);
4579        return fileline;
4580}
4581
4582char* readfiletomem(const char* filename, int flag)
4583{
4584        FILE *fd = NULL;
4585        char *fileline = NULL, *buf = NULL, *tmpbuf = NULL;
4586        int bufsize = 0, bufoldsize = 0;
4587
4588        fileline = malloc(MINMALLOC);
4589        if(fileline == NULL)
4590        {
4591                err("no mem");
4592                return NULL;
4593        }
4594
4595        fd = fopen(filename, "r");
4596        if(fd == NULL)
4597        {
4598                perr("can't open %s", filename);
4599                free(fileline);
4600                return NULL;
4601        }
4602
4603        while(fgets(fileline, MINMALLOC, fd) != NULL)
4604        {
4605                if(flag == 1)
4606                        if(fileline[0] == '#' || fileline[0] == '\n')
4607                                continue;
4608
4609                bufoldsize = bufsize;
4610                bufsize += strlen(fileline);
4611                tmpbuf = buf;   buf = realloc(buf, bufsize + 1);
4612                if(buf == NULL)
4613                {
4614                        err("no mem");
4615                        free(fileline);
4616                        free(tmpbuf);
4617                        fclose(fd);
4618                        return NULL;
4619                }
4620
4621                sprintf(buf + bufoldsize, "%s", fileline);
4622        }
4623
4624        free(fileline);
4625        fclose(fd);
4626        return buf;
4627}
4628
4629char* readeittomem(const char* filename)
4630{
4631        unsigned char byte;
4632        FILE *fil = NULL;
4633        char *zeichen = NULL, *buf = NULL, *buf1 = NULL, *tmpbuf1 = NULL;
4634        int buf1size = 0, buf1oldsize = 0;
4635        int Beschreibung;
4636        int len;
4637
4638        zeichen = malloc(255);
4639        if(zeichen == NULL)
4640        {
4641                err("no mem");
4642                return NULL;
4643        }
4644        buf = malloc(255);
4645        if(buf == NULL)
4646        {
4647                free(zeichen);
4648                err("no mem");
4649                return NULL;
4650        }
4651
4652        fil = fopen(filename, "r");
4653        if(fil == NULL)
4654        {
4655                err("can't open %s", filename);
4656                free(zeichen);
4657                free(buf);
4658                return NULL;
4659        }
4660        Beschreibung = 0;
4661        fseek(fil, 12, SEEK_SET); //ersten 12 Byte nicht relevant
4662        while(!feof(fil))
4663        {
4664                byte = fgetc(fil);
4665
4666                if(byte == 0x4D)
4667                {
4668                        fseek(fil, 4,SEEK_CUR);
4669                        byte = fgetc(fil);
4670                        len = byte + 0;
4671                        byte = fgetc(fil);
4672                        fgets(zeichen, len, fil);
4673                        if(byte != 0x05)
4674                                sprintf(buf, "%c%s\n", byte, zeichen);
4675                        else
4676                                sprintf(buf, "%s\n", zeichen);
4677
4678                        buf1oldsize = buf1size;
4679                        buf1size += strlen(buf);
4680                        tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
4681                        if(buf1 == NULL)
4682                        {
4683                                err("no mem");
4684                                free(zeichen);
4685                                free(buf);
4686                                free(tmpbuf1);
4687                                fclose(fil);
4688                                return NULL;
4689                        }
4690                        sprintf(buf1 + buf1oldsize, "%s", buf);
4691
4692                        //printf("T %s\n", zeichen);
4693                        byte = fgetc(fil);
4694                        len = byte + 0;
4695                        byte = fgetc(fil);
4696                        fgets(zeichen, len, fil);
4697                        if(byte != 0x05)
4698                                sprintf(buf,"%c%s\n\n", byte, zeichen);
4699                        else
4700                                sprintf(buf,"%s\n\n", zeichen);
4701                               
4702                        buf1oldsize = buf1size;
4703                        buf1size += strlen(buf);
4704                        tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
4705                        if(buf1 == NULL)
4706                        {
4707                                err("no mem");
4708                                free(zeichen);
4709                                free(buf);
4710                                free(tmpbuf1);
4711                                fclose(fil);
4712                                return NULL;
4713                        }
4714                        sprintf(buf1 + buf1oldsize, "%s", buf);
4715
4716                }
4717                else if(byte == 0x4E)
4718                {
4719                        fseek(fil, 6, SEEK_CUR);
4720                        byte = fgetc(fil);
4721                        len = byte;
4722                        byte = fgetc(fil);
4723                        fgets(zeichen, len, fil);
4724                        if(Beschreibung == 0)
4725                        {
4726                                if(byte != 0x05)
4727                                        sprintf(buf, "%c%s", byte, zeichen);
4728                                else
4729                                        sprintf(buf, "%s", zeichen);
4730                                Beschreibung = 1;
4731                        }
4732                        else
4733                        {
4734                                if(byte != 0x05)
4735                                        sprintf(buf, "%c%s", byte, zeichen);
4736                                else
4737                                        sprintf(buf, "%s", zeichen);
4738                        }       
4739
4740                        buf1oldsize = buf1size;
4741                        buf1size += strlen(buf);
4742                        tmpbuf1 = buf1; buf1 = realloc(buf1, buf1size + 1);
4743                        if(buf1 == NULL)
4744                        {
4745                                err("no mem");
4746                                free(zeichen);
4747                                free(buf);
4748                                free(tmpbuf1);
4749                                fclose(fil);
4750                                return NULL;
4751                        }
4752                        sprintf(buf1 + buf1oldsize, "%s", buf);     
4753
4754                }
4755                else
4756                {
4757                        byte = fgetc(fil);
4758                        len= byte;
4759                        fgets(zeichen, len + 1, fil);
4760                } 
4761        }
4762        free(zeichen);
4763        free(buf);
4764        fclose(fil);
4765        return buf1;
4766}
4767
4768char* command(char* input)
4769{
4770        int maxlen = 0, pos = 0;
4771        char* tmpstr = NULL, *fileline = NULL;
4772        FILE *iopipe = NULL;
4773       
4774        if(input == NULL) return NULL;
4775
4776        fileline = malloc(MINMALLOC);
4777        if(fileline == NULL)
4778        {
4779                err("no mem");
4780                return NULL;
4781        }
4782
4783        if((iopipe = popen(input, "r")) == NULL)
4784        {
4785                free(fileline);
4786                return NULL;
4787        }
4788
4789        while(!feof(iopipe))
4790        {
4791                if(fgets(fileline, MINMALLOC, iopipe) != NULL)
4792                        ostrcatbig(&tmpstr, fileline, &maxlen, &pos);
4793        }
4794       
4795        if(pos > 0)
4796        {
4797                char* tmp = tmpstr;
4798                tmpstr = realloc(tmpstr, pos + 1);
4799                if(tmpstr == NULL)
4800                        tmpstr = tmp;
4801        }
4802
4803        free(fileline);
4804        pclose(iopipe);
4805        return tmpstr;
4806}
4807
4808char* string_tolower(char *str)
4809{
4810/*
4811        char *p1 = str;
4812
4813        if(str == NULL) return NULL;
4814
4815        while(*p1 != '\0')
4816                *p1++ = tolower(*p1);
4817       
4818        return str;
4819*/
4820        if(str == NULL) return NULL;
4821
4822        int i=0;
4823        while (str[i])
4824        {
4825                str[i] = tolower(str[i]);
4826                i++;
4827        }
4828        return str;
4829}
4830
4831char* string_toupper(char *str)
4832{
4833/*
4834        char *p1 = str;
4835
4836        if(str == NULL) return NULL;
4837
4838        while(*p1 != '\0')
4839                *p1++ = toupper(*p1);
4840       
4841*/
4842        if(str == NULL) return NULL;
4843
4844        int i=0;
4845        while (str[i])
4846        {
4847                str[i] = toupper(str[i]);
4848                i++;
4849        }
4850        return str;
4851}
4852
4853char* stringreplacecharonce(char *str, char c1, char c2)
4854{
4855        char *p1 = str;
4856
4857        if(str == NULL) return NULL;
4858
4859        while(*p1 != '\0')
4860        {
4861                if(*p1 == c1)
4862                {
4863                        *p1 = c2;
4864                        break;                 
4865                }                       
4866                p1++;
4867        }
4868
4869        return str;
4870}
4871
4872char* stringreplacechar(char *str, char c1, char c2)
4873{
4874        char *p1 = str;
4875
4876        if(str == NULL) return NULL;
4877
4878        while(*p1 != '\0')
4879        {
4880                if(*p1 == c1) *p1 = c2;
4881                p1++;
4882        }
4883
4884        return str;
4885}
4886
4887
4888char* string_removechar(char *str)
4889{
4890        char *p1 = str;
4891
4892        if(str == NULL) return NULL;
4893
4894        while(*p1 != '\0')
4895        {
4896                if(*p1 == '.') *p1 = ' ';
4897                else if(*p1 == '-') *p1 = ' ';
4898                else if(*p1 == '_') *p1 = ' ';
4899                else if(*p1 == '/') *p1 = ' ';
4900                p1++;
4901        }
4902
4903        return str;
4904}
4905
4906char* string_withchars2return(char *str)
4907{
4908        char *p1 = str;
4909
4910        if(str == NULL) return NULL;
4911
4912        while(*p1 != '\0')
4913        {
4914                if(*p1 == ' ') *p1 = '\n';
4915                p1++;
4916        }
4917
4918        return str;
4919}
4920
4921char* string_remove_whitechars(char *text)
4922{
4923        char *p1 = text, *p2 = text;
4924
4925        if(text == NULL) return NULL;
4926
4927        while(*p1 != '\0')
4928        {
4929                if(*p1 == ' ')
4930                        ++p1;
4931                else
4932                        *p2++ = *p1++;
4933        }
4934        *p2 = '\0';
4935
4936        return text;
4937}
4938
4939char* strstrip(char *text)
4940{
4941        char* tmpstr = text;
4942
4943        if(text == NULL) return NULL;
4944        int len = strlen(text);
4945
4946        while(isspace(tmpstr[len - 1])) tmpstr[--len] = '\0';
4947        while(*tmpstr && isspace(*tmpstr)) ++tmpstr, --len;
4948
4949        if(text != tmpstr) memmove(text, tmpstr, len + 1);
4950
4951        return text;
4952}
4953
4954char* string_strip_whitechars(char *text)
4955{
4956        char *p1 = text, *p2 = text;
4957
4958        if(text == NULL)
4959                return NULL;
4960
4961        while(*p1 != '\0')
4962        {
4963                if(*p1 == ' ' && *(p1 + 1) == ' ')
4964                        ++p1;
4965                else
4966                        *p2++ = *p1++;
4967        }
4968        *p2 = '\0';
4969
4970        return text;
4971}
4972
4973char* string_replace_all(char *search, char *replace, char *string, int free1)
4974{
4975        char* tmpstr = NULL;
4976        char* searchpos = NULL;
4977
4978        if(string == NULL || search == NULL)
4979        {
4980                tmpstr = ostrcat(tmpstr, string, 1, 0);
4981                if(free1 == 1) free(string);
4982                return tmpstr;
4983        }
4984
4985        searchpos = strstr(string, search);
4986        if(searchpos == NULL)
4987        {
4988                tmpstr = ostrcat(tmpstr, string, 1, 0);
4989                if(free1 == 1) free(string);
4990                return tmpstr;
4991        }
4992
4993        int count = 0;
4994        int stringlen = strlen(string);
4995        int searchlen = strlen(search);
4996        int replacelen = strlen(replace);
4997
4998        while(searchpos != NULL)
4999        {
5000                count++;
5001                searchpos = strstr(searchpos + searchlen, search);
5002        }
5003
5004        int len = stringlen - (searchlen * count) + (replacelen * count);
5005        tmpstr = calloc(1, len + 1);
5006        if(tmpstr == NULL)
5007        {
5008                err("no mem");
5009                tmpstr = ostrcat(tmpstr, string, 1, 0);
5010                if(free1 == 1) free(string);
5011                return tmpstr;
5012        }
5013
5014        len = 0;       
5015        char* str = string;
5016        char* tmp = tmpstr;
5017        searchpos = strstr(str, search);
5018        while(searchpos != NULL)
5019        {
5020                len = searchpos - str;
5021                memcpy(tmp, str, len);
5022                memcpy(tmp + len, replace, replacelen);
5023                tmp += len + replacelen;
5024                str += len + searchlen;
5025                searchpos = strstr(str, search);
5026        }
5027        memcpy(tmp, str, strlen(str));
5028
5029        if(free1 == 1) free(string);
5030
5031        return tmpstr;
5032}
5033
5034char* string_replace_remove_last_chars(char *search, char *replace, char *string, int free1)
5035{
5036        char* searchpos = NULL;
5037        char* tmpstr = NULL;
5038
5039        if(string == NULL || search == NULL)
5040        {
5041                tmpstr = ostrcat(tmpstr, string, 1, 0);
5042                if(free1 == 1) free(string);
5043                return tmpstr;
5044        }
5045
5046        searchpos = ostrstr(string, search);
5047
5048        if(searchpos == NULL)
5049        {
5050                tmpstr = ostrcat(tmpstr, string, 1, 0);
5051                if(free1 == 1) free(string);
5052                return tmpstr;
5053        }
5054
5055        tmpstr = strndup(string, searchpos - string);
5056        if(replace != NULL)
5057                tmpstr = ostrcat(tmpstr, replace, 1, 0);
5058
5059        if(free1 == 1) free(string);
5060
5061        return tmpstr;
5062}
5063
5064char* string_replace(char *search, char *replace, char *string, int free1)
5065{
5066        char* searchpos = NULL;
5067        char* tmpstr = NULL;
5068
5069        if(string == NULL || search == NULL)
5070        {
5071                tmpstr = ostrcat(tmpstr, string, 1, 0);
5072                if(free1 == 1) free(string);
5073                return tmpstr;
5074        }
5075
5076        searchpos = ostrstr(string, search);
5077
5078        if(searchpos == NULL)
5079        {
5080                tmpstr = ostrcat(tmpstr, string, 1, 0);
5081                if(free1 == 1) free(string);
5082                return tmpstr;
5083        }
5084
5085        tmpstr = strndup(string, searchpos - string);
5086        if(replace != NULL)
5087                tmpstr = ostrcat(tmpstr, replace, 1, 0);
5088        tmpstr = ostrcat(tmpstr, string + (searchpos - string) + strlen(search), 1, 0);
5089
5090        if(free1 == 1) free(string);
5091
5092        return tmpstr;
5093}
5094
5095//flag 0: search full str
5096//flag 1: search only end of string
5097char* ostrrstrcase(char* str, char* search, int len, int flag)
5098{
5099        int slen = 0;
5100        char* tmpstr = NULL;
5101
5102        if(str == NULL || search == NULL) return NULL;
5103
5104        if(len == -1) len = strlen(str);
5105        slen = strlen(search);
5106        if(slen > len) return NULL;
5107
5108        for(tmpstr = str + len - slen; tmpstr >= str; tmpstr--)
5109        {
5110                if(strncasecmp(tmpstr, search, slen) == 0)
5111                        return tmpstr;
5112                if(flag == 1) return NULL;
5113        }
5114
5115        return NULL;
5116}
5117
5118//flag 0: search full str
5119//flag 1: search only end of string
5120char* ostrrstr(char* str, char* search, int len, int flag)
5121{
5122        int slen = 0;
5123        char* tmpstr = NULL;
5124
5125        if(str == NULL || search == NULL) return NULL;
5126
5127        if(len == -1) len = strlen(str);
5128        slen = strlen(search);
5129        if(slen > len) return NULL;
5130
5131        for(tmpstr = str + len - slen; tmpstr >= str; tmpstr--)
5132        {
5133                if(strncmp(tmpstr, search, slen) == 0)
5134                        return tmpstr;
5135                if(flag == 1) return NULL;
5136        }
5137
5138        return NULL;
5139}
5140
5141char* ostrstr(char* str, char* search)
5142{
5143        char* ret = NULL;
5144
5145        if(str == NULL || search == NULL) return NULL;
5146        ret = strstr(str, search);
5147
5148        return ret;
5149}
5150
5151int file_exist(char* filename)
5152{
5153        if(access(filename, F_OK) == 0)
5154                return 1;
5155        else
5156                return 0;
5157}
5158
5159char* string_newline(char* str)
5160{
5161        if(str == NULL) return NULL;
5162
5163        int size = strlen(str);
5164
5165        if(str[size - 1] == '\n')
5166                str[size - 1] = '\0';
5167
5168        return str;
5169}
5170
5171char* string_quote(char* str)
5172{
5173        char* tmpstr = NULL;
5174
5175        tmpstr = ostrcat("\"", str, 0, 0);
5176        tmpstr = ostrcat(tmpstr, "\"", 1, 0);
5177
5178        return tmpstr;
5179}
5180
5181struct splitstr* strsplit(char *str, char *tok, int* count)
5182{
5183        char *tmpstr = NULL;
5184        struct splitstr *array = NULL, *tmparray = NULL;
5185        *count = 0;
5186
5187        if(str == NULL || tok == NULL)
5188                return NULL;
5189
5190        tmpstr = strtok(str, tok);
5191        while(tmpstr != NULL)
5192        {
5193                *count = *count + 1;
5194                tmparray = array; array = (struct splitstr*)realloc(array, sizeof(struct splitstr*) * (*count));
5195                if(array == NULL)
5196                {
5197                        err("no mem");
5198                        free(tmparray);
5199                        return NULL;
5200                }
5201               
5202                (&array[(*count) - 1])->part = tmpstr;
5203                tmpstr = strtok(NULL, tok);
5204        }
5205
5206        return array;
5207}
5208
5209char* string_shortname(char *tmpfilename, int mode)
5210{
5211        debug(50, "in %s", tmpfilename);
5212
5213//      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";
5214        char* str = NULL;
5215
5216        if(mode==1)
5217        {
5218                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";
5219                str = ostrcat(str, replacelist, 1, 0);
5220        }
5221        else if(mode==2)
5222        {
5223                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";
5224                str = ostrcat(str, replacelist, 1, 0);
5225        }
5226        else
5227        {
5228                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";
5229                str = ostrcat(str, replacelist, 1, 0);
5230        }
5231
5232        char* replace = NULL;
5233        struct splitstr* ret1 = NULL;
5234        int count = 0;
5235        int i = 0;
5236        ret1 = strsplit(str, " ", &count);
5237        int max = count - 1;
5238        int first = 1;
5239
5240        for(i = 0; i < max; i++)
5241        {
5242                struct splitstr* ret2 = NULL;
5243                int count2 = 0;
5244                int j = 0;
5245                char *tmpstr = NULL;
5246                tmpstr = ostrcat(tmpstr, tmpfilename, 1, 0);
5247                ret2 = strsplit(tmpstr, " ,.-_", &count2);
5248
5249                for(j = 0; j < count2; j++)
5250                {
5251                        if(j > 0)
5252                        {                                       
5253                                if(ostrcmp((&ret1[i])->part, (&ret2[j])->part) == 0)
5254                                {
5255                                        if(mode==1)
5256                                        {
5257                                                tmpfilename = string_replace((&ret2[j])->part, replace, tmpfilename, 1);
5258                                                continue;
5259                                        }
5260                                        else if(mode==2)
5261                                        {
5262                                                tmpfilename = string_replace_remove_last_chars((&ret2[j])->part, replace, tmpfilename, 1);
5263                                                //break;
5264                                                continue;
5265                                        }
5266                                        else
5267                                        {
5268                                                tmpfilename = string_replace((&ret2[j])->part, replace, tmpfilename, 1);
5269                                                continue;
5270                                        }
5271                                }
5272                                else if(first == 1 && mode == 2)
5273                                {
5274//                                      printf("zahl: %s\n", (&ret2[j])->part);
5275                                        int theCharacter = atoi((&ret2[j])->part);
5276                                        if(theCharacter != 0)
5277                                        {
5278//                                              printf("found zahl: %s\n", (&ret2[j])->part);
5279                                                if(theCharacter > 1800 && theCharacter < 2100)
5280                                                {
5281//                                                      printf("found year: %s\n", (&ret2[j])->part);
5282                                                        tmpfilename = string_replace_remove_last_chars((&ret2[j])->part, "", tmpfilename, 1);
5283                                                        break;
5284                                                }
5285                                        }
5286                                }                               
5287                        }
5288                }
5289                free(ret2); ret2 = NULL;
5290                first = 0;
5291                free(tmpstr), tmpstr = NULL;
5292        }
5293
5294        free(ret1); ret1 = NULL;
5295        free(replace); replace = NULL;
5296        free(str); str = NULL;
5297
5298        debug(50, "out %s", tmpfilename);
5299        return tmpfilename;
5300}
5301
5302char* get_uuid(char* device)
5303{
5304        debug(60, "in %s", device);
5305        char* cmd = NULL, *tmpstr = NULL;
5306       
5307        if(device == NULL) return NULL;
5308#ifdef MIPSEL           
5309        cmd = ostrcat(cmd, "blkid -w /dev/null -c /dev/null -s UUID /dev/", 1, 0);
5310#else
5311        cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s UUID /dev/", 1, 0);
5312#endif
5313        cmd = ostrcat(cmd, device, 1, 0);
5314        cmd = ostrcat(cmd, " | cut -d'\"' -f2", 1, 0);
5315
5316        tmpstr = string_newline(command(cmd));
5317
5318        if(ostrcmp(string_newline(tmpstr), "") == 0)
5319        {
5320                free(tmpstr); tmpstr = NULL;
5321        }
5322
5323        debug(60, "out %s", cmd);
5324        free(cmd); cmd = NULL;
5325        return tmpstr;
5326}
5327
5328char* get_label(char* device)
5329{
5330        debug(60, "in %s", device);
5331        char* cmd = NULL, *tmpstr = NULL;
5332
5333        if(device == NULL) return NULL;
5334#ifdef MIPSEL
5335        cmd = ostrcat(cmd, "blkid -w /dev/null -c /dev/null -s LABEL /dev/", 1, 0);
5336#else
5337        cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s LABEL /dev/", 1, 0);
5338#endif 
5339        cmd = ostrcat(cmd, device, 1, 0);
5340        cmd = ostrcat(cmd, " | cut -d'\"' -f2", 1, 0);
5341
5342        tmpstr = string_newline(command(cmd));
5343
5344        if(tmpstr == NULL)
5345                tmpstr = ostrcat(tmpstr, "NONLABEL", 1, 0);
5346
5347        if(ostrcmp(string_newline(tmpstr), "") == 0)
5348                tmpstr = ostrcat(tmpstr, "NONLABEL", 1, 0);
5349
5350        debug(60, "out %s", cmd);
5351        free(cmd); cmd = NULL;
5352        return tmpstr;
5353}
5354
5355char* get_filesystem(char* device)
5356{
5357        debug(60, "in %s", device);
5358        char* cmd = NULL, *tmpstr = NULL;
5359
5360        if(device == NULL) return NULL;
5361#ifdef MIPSEL
5362        cmd = ostrcat(cmd, "blkid -w /dev/null -c /dev/null -s TYPE /dev/", 1, 0);
5363#else
5364        cmd = ostrcat(cmd, "/bin/blkid -w /dev/null -c /dev/null -s TYPE /dev/", 1, 0);
5365#endif
5366        cmd = ostrcat(cmd, device, 1, 0);
5367        cmd = ostrcat(cmd, " | cut -d'\"' -f2", 1, 0);
5368
5369        tmpstr = string_newline(command(cmd));
5370
5371        if(tmpstr == NULL)
5372                tmpstr = ostrcat(tmpstr, "NONTYPE", 1, 0);
5373
5374        if(ostrcmp(string_newline(tmpstr), "") == 0)
5375                tmpstr = ostrcat(tmpstr, "NONTYPE", 1, 0);
5376
5377        debug(60, "out %s", cmd);
5378        free(cmd); cmd = NULL;
5379        return tmpstr;
5380}
5381
5382//flag 0: convert ip to 000.000.000.000
5383//flag 1: convert ip to 0.0.0.0
5384char* fixip(char* ipinput, int flag)
5385{
5386        debug(60, "in %s", ipinput);
5387        int ret = 0;
5388        char* ipout = NULL;
5389        unsigned char ip[4];
5390       
5391        ip[0] = 0;
5392        ip[1] = 0;
5393        ip[2] = 0;
5394        ip[3] = 0;
5395
5396        if(ipinput == NULL) return NULL;
5397        ret = sscanf(ipinput, "%hhu.%hhu.%hhu.%hhu", &ip[0], &ip[1], &ip[2], &ip[3]);
5398        if(ret != 4) return NULL;
5399
5400        ipout = malloc(16);
5401        if(ipout == NULL)
5402        {
5403                err("no mem");
5404                return NULL;
5405        }
5406
5407        if(flag == 1)
5408                snprintf(ipout, 16, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
5409        else
5410                snprintf(ipout, 16, "%03d.%03d.%03d.%03d", ip[0], ip[1], ip[2], ip[3]);
5411
5412        return ipout;
5413}
5414
5415void setfanspeed(int speed, int aktion)
5416{
5417        char* speedWert = NULL;
5418        char* speedSet = NULL;
5419        int base = 0;
5420
5421        if(checkbox("UFS922") == 1)
5422                base = 100;
5423        else
5424                base = -15;
5425               
5426
5427        if(speed < 0)
5428        {
5429                if(speed == -1)
5430                        speedWert = getconfig("fanspeed", NULL);
5431                else
5432                        speedWert = getconfig("fanspeedstandby", NULL);
5433                if(speedWert == NULL)
5434                        speedSet = ostrcat(speedSet, oitoa(base + 70), 1, 1);
5435                else
5436                        speedSet = ostrcat(speedSet, speedWert, 1, 0);
5437        }
5438        else
5439        {
5440                if(speed == 0)
5441                        speedSet = ostrcat(speedSet, oitoa(base + 15), 1, 1);
5442                else if(speed == 25)
5443                        speedSet = ostrcat(speedSet, oitoa(base + 30), 1, 1);
5444                else if(speed == 50)
5445                        speedSet = ostrcat(speedSet, oitoa(base + 45), 1, 1);
5446                else if(speed == 75)
5447                        speedSet = ostrcat(speedSet, oitoa(base + 55), 1, 1);
5448                else
5449                        speedSet = ostrcat(speedSet, oitoa(base + 70), 1, 1);
5450        }
5451
5452        if(checkbox("UFS922") == 1)
5453                writesys("/proc/stb/fan/fan_ctrl", speedSet, 1);
5454        else
5455                writesys("/proc/stb/fp/fan_pwm", speedSet, 1);
5456
5457        if(aktion == 1)
5458                addconfig("fanspeed", speedSet);
5459        else if(aktion == 2)
5460                addconfig("fanspeedstandby", speedSet);
5461
5462        free(speedSet); speedSet=NULL;
5463}
5464
5465void setaktres()
5466{
5467        int m_width = 0;
5468        char* res = NULL;
5469        char* res_akt = NULL;
5470        char* res_sd = NULL;
5471        int count = 1;
5472        int sec = 0;
5473
5474        m_lock(&status.setaktresmutex, 23);
5475
5476        if(status.restimer == NULL)
5477                goto end;
5478
5479        sec = (int)status.restimer->param1;
5480
5481        if(sec > 0)
5482        {
5483                while(status.restimer->aktion == START && count <= (sec * 10))
5484                {
5485                        usleep(100000);
5486                        if(status.restimer->aktion != START)
5487                                goto end;
5488                        count++;
5489                }
5490        }
5491        if(status.restimer->aktion != START) goto end;
5492
5493        if(videoreadqwidth(status.aktservice->videodev) == 0)
5494        {
5495                if(status.restimer->aktion != START) goto end;
5496                m_width = status.videosize.w;
5497                if(m_width == 720)
5498                {
5499                        res_sd = getconfig("av_videomode_autores_sd", NULL);
5500                        if(res_sd == NULL)
5501                                res = ostrcat(res, "576i50", 1, 0);
5502                        else
5503                                res = ostrcat(res, res_sd, 1, 0);
5504                }
5505                else if (m_width == 1280)
5506                        res = ostrcat(res, "720p50", 1, 0);
5507                else if (m_width == 1920)
5508                        res = ostrcat(res, "1080i50", 1, 0);
5509                else
5510                        m_width = 0;
5511
5512                if(m_width > 0)
5513                {
5514                        if(status.restimer->aktion != START) goto end;
5515                        res_akt = getvideomode();
5516                        if(status.restimer->aktion != START) goto end;
5517                        if(ostrcmp(res_akt, res) != 0)
5518                        {
5519                                if(status.restimer->aktion != START) goto end;
5520                                setvideomode(res, 1);
5521                                changefbresolution(res, 1);
5522/*
5523                                if(status.restimer->aktion != START) goto end;
5524
5525                                count = 0;
5526                                while(status.restimer->aktion == START && count < 10)
5527                                {
5528                                        usleep(100000);
5529                                        if(status.restimer->aktion != START)
5530                                                goto end;
5531                                        count++;
5532                                }
5533
5534                                if(status.restimer->aktion != START) goto end;
5535*/
5536                                screenautores(res, 5, 0);
5537                        }
5538                }
5539        }
5540        else
5541        {
5542                if(status.restimer->aktion != START) goto end;
5543                if(status.servicetype == 0)
5544                        textbox(_("Message"), _("ERROR cant read res"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 5, 0);
5545        }
5546
5547end:
5548        free(res); res = NULL;
5549        status.restimer = NULL;
5550        m_unlock(&status.setaktresmutex, 23);
5551        return;
5552}
5553
5554char* gettimestamp()
5555{
5556        char* timestamp = NULL;
5557        struct timeval numtime;
5558               
5559        gettimeofday(&numtime, 0);
5560        timestamp = ostrcat(timestamp, olutoa(numtime.tv_sec), 1, 1);
5561        timestamp = ostrcat(timestamp, olutoa(numtime.tv_usec), 1, 1);
5562
5563        return timestamp;
5564}
5565
5566char* string_decode(char* input, int flag)
5567{
5568        if(input == NULL) return input;
5569
5570        while(ostrstr(input, "\\u00") != NULL)
5571        {
5572                debug(210, "input: %s", input);
5573                input = string_replace("\\u00", "%", input, 1);
5574                debug(210, "input: %s", input);
5575        }
5576
5577        while(ostrstr(input, "&amp;") != NULL)
5578        {
5579                debug(210, "input: %s", input);
5580                input = string_replace("&amp;", "und", input, 1);
5581                debug(210, "input: %s", input);
5582        }
5583
5584        while(ostrstr(input, "&gt;") != NULL)
5585        {
5586                debug(210, "input: %s", input);
5587                input = string_replace("&gt;", ">", input, 1);
5588                debug(210, "input: %s", input);
5589        }
5590
5591        while(ostrstr(input, "&lt;") != NULL)
5592        {
5593                debug(210, "input: %s", input);
5594                input = string_replace("&lt;", "<", input, 1);
5595                debug(210, "input: %s", input);
5596        }
5597       
5598        while(ostrstr(input, "&quot;") != NULL)
5599        {
5600                debug(210, "input: %s", input);
5601                input = string_replace("&quot;", "\"", input, 1);
5602                debug(210, "input: %s", input);
5603        }
5604
5605        while(ostrstr(input, "&#x") != NULL)
5606        {
5607                debug(210, "out %s", input);
5608                input = string_replace("&#x", "%", input, 1);
5609                debug(210, "input: %s", input);
5610        }
5611       
5612        while(ostrstr(input, "&#") != NULL)
5613        {
5614                debug(210, "input: %s", input);
5615                input = string_replace("&#", "%", input, 1);
5616                debug(210, "input: %s", input);
5617        }
5618       
5619        if(flag == 1)
5620                htmldecode2(input, input);
5621        else
5622                htmldecode(input, input);
5623                       
5624        while(ostrstr(input, ";") != NULL)
5625        {
5626                debug(210, "input: %s", input);
5627                input = string_replace(";", NULL, input, 1);
5628                debug(210, "input: %s", input);
5629        }
5630
5631        return input;
5632}
5633
5634char* string_deltags(char* str)
5635{
5636        int i = 0, y = 0, len = 0;
5637
5638        if(str == NULL) return 0;
5639
5640        len = strlen(str);
5641
5642        int skip = 0;
5643        for(i = 0; i < len; i++)
5644        {
5645                if(str[i] == '<')
5646                        skip = 1;
5647                else if(str[i] == '>')
5648                        skip = 0;
5649
5650                if(skip == 0 && str[i] != '>')
5651                {
5652                        str[y] = str[i];
5653                        y++;
5654                }
5655        }
5656        str[y] = '\0';
5657
5658        return str;
5659}
5660
5661char* string_striptags(char* str)
5662{
5663        int i = 0, len = 0;
5664
5665        if(str == NULL) return 0;
5666       
5667        len = strlen(str);
5668
5669        int skip = 0;
5670        for(i = 0; i < len; i++)
5671        {
5672                if(str[i] == '<')
5673                        skip = 1;
5674                else if(str[i] == '>')
5675                {
5676                        skip = 0;
5677                        str[i] = ' ';
5678                }
5679                if(skip == 1)
5680                        str[i] = ' ';
5681        }       
5682
5683        return strstrip(str);
5684}
5685
5686char* string_resub(char* str, char* str2, char* input, int dir)
5687{
5688        char* tmpstr = NULL, *pos = NULL, *pos2 = NULL;
5689
5690        if(str == NULL || str2 == NULL || input == NULL) return NULL;
5691
5692        if(dir == 0)
5693        {
5694                pos = ostrstr(input, str);
5695                if(pos == NULL) return NULL;
5696                pos += strlen(str);
5697
5698                pos2 = ostrstr(pos, str2);
5699                if(pos2 == NULL) return NULL;
5700        }
5701        else
5702        {
5703                pos2 = ostrstr(input, str2);
5704                if(pos2 == NULL) return NULL;
5705
5706                pos = ostrrstr(input, str, pos2 - input, 0);
5707                if(pos == NULL) return NULL;
5708                pos += strlen(str);
5709        }
5710
5711        tmpstr = strndup(pos, pos2 - pos);
5712
5713        return strstrip(tmpstr);
5714}
5715
5716char* ostrstrcase(char* str, char* sub)
5717{
5718        size_t len = 0;
5719
5720        if(str == NULL || sub == NULL) return NULL;
5721
5722        len = strlen(sub);
5723        while(*str)
5724        {
5725                if(toupper(*str) == toupper(*sub) && strncasecmp(str, sub, len) == 0)
5726                        return str;     
5727                ++str;
5728        }
5729        return NULL;
5730}
5731
5732//flag 0: convert port to 00021
5733//flag 1: convert port to 21
5734char* fixport(char* input, int flag)
5735{
5736        char* tmpstr = NULL;
5737
5738        if(flag == 0)
5739        {
5740                int plen = strlen(input);
5741                if(plen < 5)
5742                {
5743                        int i;
5744                        for(i = 0; i < 5 - plen; i++)
5745                                tmpstr = ostrcat(tmpstr, "0", 1, 0);
5746                }
5747                tmpstr = ostrcat(tmpstr, input, 1, 0);         
5748        }
5749        else
5750        {
5751                while (*input && *input == '0')
5752                input++;
5753       
5754                tmpstr = ostrcat(tmpstr, input, 1, 0);         
5755        }
5756        return tmpstr;
5757}
5758
5759//flag 0: Mon > Montag
5760//flag 1: Mon > Mon
5761char* translate_time(char* input, int flag)
5762{
5763        char* tmpstr = NULL;
5764        if(input == NULL) return tmpstr;
5765        tmpstr = ostrcat(tmpstr, input, 1, 1); 
5766
5767        if(flag == 0)
5768        {
5769                tmpstr = string_replace_all("Mon", _("Monday"), tmpstr, 1);
5770                tmpstr = string_replace_all("Tue", _("Tuesday"), tmpstr, 1);
5771                tmpstr = string_replace_all("Wed", _("Wednesday"), tmpstr, 1);
5772                tmpstr = string_replace_all("Thu", _("Thursday"), tmpstr, 1);
5773                tmpstr = string_replace_all("Fri", _("Friday"), tmpstr, 1);
5774                tmpstr = string_replace_all("Sat", _("Saturday"), tmpstr, 1);
5775                tmpstr = string_replace_all("Sun", _("Sunday"), tmpstr, 1);
5776        }
5777        else
5778        {       
5779                tmpstr = string_replace("Mon", _("Mon"), tmpstr, 1);
5780                tmpstr = string_replace("Tue", _("Tue"), tmpstr, 1);
5781                tmpstr = string_replace("Wed", _("Wed"), tmpstr, 1);
5782                tmpstr = string_replace("Thu", _("Thu"), tmpstr, 1);
5783                tmpstr = string_replace("Fri", _("Fri"), tmpstr, 1);
5784                tmpstr = string_replace("Sat", _("Sat"), tmpstr, 1);
5785                tmpstr = string_replace("Sun", _("Sun"), tmpstr, 1);
5786        }
5787
5788        return tmpstr;
5789}
5790
5791char* gethypridtunerchoices(int dev)
5792{
5793        char *hypridtunerchoices = NULL;
5794        char *value = NULL;
5795        char *tmpstr = NULL;
5796        char *tmpstr1 = NULL;
5797        char *tmpstr2 = NULL;
5798        char *tmpstr3 = NULL;
5799        char* start = NULL;
5800
5801        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
5802
5803        if(hypridtunerchoices == NULL)
5804        {
5805                err("NULL detect");
5806                return NULL;
5807        }
5808
5809        tmpstr = readfiletomem(hypridtunerchoices, 1);
5810        if(tmpstr == NULL)
5811        {
5812                err("NULL detect");
5813                return NULL;
5814        }
5815
5816        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
5817        start = ostrcat(start, ":", 1, 0);
5818
5819        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
5820        tmpstr2 = string_resub("Mode ", ":", tmpstr1, 0);
5821        tmpstr3 = oregex(".*Mode ([0-9]{1}):.*", tmpstr1);
5822
5823        if(tmpstr2 != NULL)
5824                value = ostrcat(tmpstr2, "\n", 0, 0);
5825        if(tmpstr3 != NULL)
5826                value = ostrcat(value, tmpstr3, 1, 0);
5827
5828        free(start), start = NULL;
5829        free(tmpstr), tmpstr = NULL;
5830        free(tmpstr1), tmpstr1 = NULL;
5831        free(tmpstr2), tmpstr2 = NULL;
5832        free(tmpstr3), tmpstr3 = NULL;
5833
5834        return value;
5835}
5836
5837char* gethypridtunerchoicesvalue(int dev)
5838{
5839        char* hypridtunerchoices = NULL, *value = NULL, *tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL, *hypridlist = NULL, *start = NULL;
5840
5841        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
5842
5843        if(hypridtunerchoices == NULL)
5844        {
5845                err("NULL detect");
5846                return NULL;
5847        }
5848
5849        tmpstr = readfiletomem(hypridtunerchoices, 1);
5850        if(tmpstr == NULL)
5851        {
5852                err("NULL detect");
5853                return NULL;
5854        }
5855
5856        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
5857        start = ostrcat(start, ":", 1, 0);
5858        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
5859        free(start), start = NULL;
5860
5861        hypridlist = gethypridtunerchoices(dev);
5862
5863        int count = 0;
5864        int i = 0;
5865        struct splitstr* ret1 = NULL;
5866        ret1 = strsplit(hypridlist, "\n", &count);
5867
5868        if(ret1 != NULL)
5869        {
5870                int max = count;
5871                for(i = 0; i < max; i++)
5872                {
5873                        start = ostrcat("Mode ", ret1[i].part, 0, 0);
5874                        start = ostrcat(start, ":", 1, 0);
5875                        tmpstr2 = string_resub(start, "\n", tmpstr1, 0);
5876               
5877                        if(i > 0)
5878                                value = ostrcat(value, "\n", 1, 0);
5879               
5880                        if(tmpstr2 != NULL)
5881                                value = ostrcat(value, tmpstr2, 1, 0);
5882                               
5883                        free(tmpstr2), tmpstr2 = NULL;
5884                        free(start), start = NULL;
5885                }
5886        }
5887        free(ret1), ret1 = NULL;                       
5888        free(tmpstr1), tmpstr1 = NULL;
5889        free(hypridlist), hypridlist = NULL;
5890
5891        return value;
5892}
5893
5894char* gethypridtunerchoicesvaluename(int dev, char* hyprid)
5895{
5896        char* hypridtunerchoices = NULL, *value = NULL, *tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL, *start = NULL;
5897
5898        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
5899
5900        if(hypridtunerchoices == NULL)
5901        {
5902                err("NULL detect");
5903                return NULL;
5904        }
5905
5906        tmpstr = readfiletomem(hypridtunerchoices, 1);
5907        if(tmpstr == NULL)
5908        {
5909                err("NULL detect");
5910                return NULL;
5911        }
5912
5913        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
5914        start = ostrcat(start, ":", 1, 0);
5915        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
5916        free(start), start = NULL;
5917
5918        start = ostrcat("Mode ", hyprid, 0, 0);
5919        start = ostrcat(start, ":", 1, 0);
5920
5921        tmpstr2 = string_resub(start, "\n", tmpstr1, 0);
5922       
5923        if(tmpstr2 != NULL)
5924                value = ostrcat(value, tmpstr2, 1, 0);
5925
5926        free(tmpstr1), tmpstr1 = NULL;
5927        free(tmpstr2), tmpstr2 = NULL;
5928        free(start), start = NULL;
5929
5930        return value;
5931}
5932
5933int sethypridtuner(int dev, char* value)
5934{
5935        char* buf = NULL, *hypridtuner = NULL, *tmpstr = NULL;
5936        int ret = 0;
5937
5938        hypridtuner = getconfig("hypridtuner", NULL);
5939       
5940        if(hypridtuner != NULL)
5941        {
5942                buf = malloc(MINMALLOC);
5943                if(buf == NULL)
5944                {
5945                        err("no memory");
5946                        return 0;
5947                }
5948        }
5949
5950        sprintf(buf, hypridtuner, dev);
5951        if(buf != NULL)
5952        {
5953                printf("set %s to %s\n", buf, value);
5954                ret = writesys(buf, value, 0);
5955                free(tmpstr); tmpstr = NULL;
5956                return ret;
5957        }
5958
5959        return 0;
5960}
5961
5962int phpkit_userauth(char* link, char* user, char* pass)
5963{
5964        debug(99, "phpkit user: %s", user);
5965        debug(99, "phpkit pass: %s", pass);     
5966        debug(99, "phpkit url: %s", link);
5967
5968        int skip = 0;
5969        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;
5970
5971        tmplink = ostrcat(link, NULL, 0, 0);
5972
5973        tmphost = string_replace("http://", "", tmplink, 0);
5974        free(tmplink) , tmplink = NULL;
5975
5976        if(tmphost != NULL)
5977                pos = strchr(tmphost, '/');
5978        if(pos != NULL)
5979        {
5980                pos[0] = '\0';
5981                path = pos + 1;
5982        }
5983
5984        tmppath = ostrcat("/", path, 0, 0);
5985
5986        send = ostrcat(send, "GET ", 1, 0);
5987        send = ostrcat(send, tmppath, 1, 0);
5988        send = ostrcat(send, " HTTP/1.1\r\nHost: ", 1, 0);     
5989        send = ostrcat(send, tmphost, 1, 0);
5990        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);       
5991        debug(99, "#############################################################################################################");
5992        debug(99, "send1: %s", send);
5993        debug(99, "#############################################################################################################");
5994
5995        tmpstr = gethttpreal(tmphost, tmppath, 80, NULL, NULL, NULL, 0, send, NULL, 5000, 1);
5996        debug(99, "tmpstr: %s", tmpstr);
5997
5998        free(send), send = NULL;
5999        free(tmpstr), tmpstr = NULL;
6000
6001        if(user == NULL || pass == NULL || link == NULL) return 1;
6002
6003        hash = ostrcat("login=1&user=", user, 0, 0);
6004        hash = ostrcat(hash, "&userpw=", 1, 0);
6005        hash = ostrcat(hash, pass, 1, 1);
6006        hashlen = oitoa(strlen(hash));
6007       
6008        send = ostrcat(send, "POST ", 1, 0);
6009        send = ostrcat(send, tmppath, 1, 0);
6010        send = ostrcat(send, " HTTP/1.1\r\nContent-Length: ", 1, 0);
6011        send = ostrcat(send, hashlen, 1, 0);
6012        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);
6013        send = ostrcat(send, tmphost, 1, 0);
6014        send = ostrcat(send, "\r\nCookie: pageredir=", 1, 0);
6015        send = ostrcat(send, cookie1, 1, 0);
6016        send = ostrcat(send, "; PHPSESSID=", 1, 0);     
6017        send = ostrcat(send, cookie2, 1, 0);
6018        send = ostrcat(send, "\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\n", 1, 0);     
6019        send = ostrcat(send, hash, 1, 0);
6020        free(hash); hash = NULL;
6021        free(hashlen); hashlen = NULL;
6022
6023        debug(99, "#############################################################################################################");
6024        debug(99, "send1: %s", send);
6025        debug(99, "#############################################################################################################");
6026
6027        tmpstr = gethttpreal(tmphost, tmppath, 80, NULL, NULL, NULL, 0, send, NULL, 5000, 1);
6028        debug(99, "tmpstr: %s", tmpstr);
6029
6030        free(cookie1); cookie1 = NULL;
6031        free(cookie2); cookie2 = NULL;
6032        free(tmphost); tmphost = NULL;
6033        free(send); send = NULL;
6034        free(ip); ip = NULL;
6035        if(tmpstr == NULL) skip = 1;
6036        free(tmpstr); tmpstr = NULL;
6037        if(skip == 1) return 1;
6038        return 0;
6039}
6040
6041void changetunername(struct skin* tunernode, int adapter, int devnr, char* name, char* fehyprid)
6042{
6043        char* tmpnr = NULL, *tmpstr = NULL;
6044        tmpnr = oitoa(adapter);
6045        tmpstr = ostrcat(_("Tuner "), tmpnr, 0, 1);
6046        tmpstr = ostrcat(tmpstr, "/", 1, 0);
6047        tmpnr = oitoa(devnr);
6048        tmpstr = ostrcat(tmpstr, tmpnr, 1, 1);
6049        tmpstr = ostrcat(tmpstr, ": ", 1, 0);
6050        tmpstr = ostrcat(tmpstr, name, 1, 0);
6051        if(fehyprid != NULL)
6052        {
6053                tmpstr = ostrcat(tmpstr, " (", 1, 0);
6054                tmpstr = ostrcat(tmpstr, _("Multituner adjustable"), 1, 0);
6055                tmpstr = ostrcat(tmpstr, ")", 1, 0);
6056        }
6057        changetext(tunernode, tmpstr);
6058        free(tmpstr); tmpstr = NULL;
6059}
6060
6061char* gethypridtunername(int dev, char* hyprid)
6062{
6063        char* hypridtunerchoices = NULL, *value = NULL, *tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL, *start = NULL;
6064
6065        hypridtunerchoices = getconfig("hypridtunerchoices", NULL);
6066
6067        if(hypridtunerchoices == NULL)
6068        {
6069                err("NULL detect");
6070                return NULL;
6071        }
6072
6073        tmpstr = readfiletomem(hypridtunerchoices, 1);
6074        if(tmpstr == NULL)
6075        {
6076                err("NULL detect");
6077                return NULL;
6078        }
6079
6080        start = ostrcat("NIM Socket ", oitoa(dev), 0, 0);
6081        start = ostrcat(start, ":", 1, 0);
6082        tmpstr1 = string_resub(start, "I2C_Device", tmpstr, 0);
6083        free(start), start = NULL;
6084
6085        tmpstr2 = string_resub("Name: ", "\n", tmpstr1, 0);
6086       
6087        if(tmpstr2 != NULL)
6088                value = ostrcat(value, tmpstr2, 1, 0);
6089
6090        free(tmpstr1), tmpstr1 = NULL;
6091        free(tmpstr2), tmpstr2 = NULL;
6092        free(start), start = NULL;
6093
6094        return value;
6095}
6096
6097void convertsettings()
6098{
6099        struct menulist* mlist = NULL, *mbox = NULL;
6100        struct skin* load = getscreen("loading");
6101        int flag = 0, ret = 0;
6102        char* tmpstr = NULL;
6103
6104        addmenulist(&mlist, "Create Transponder (Sat)", _("Create Transponder (Sat)"), NULL, 0, 0);
6105        addmenulist(&mlist, "Create Transponder (Cable)", _("Create Transponder (Cable)"), NULL, 0, 0);
6106        addmenulist(&mlist, "Create Transponder (Terrestrial)", _("Create Transponder (Terrestrial)"), NULL, 0, 0);
6107        addmenulist(&mlist, "Create Transponder (All)", _("Create Transponder (All)"), NULL, 0, 0);
6108
6109        mbox = menulistbox(mlist, "createsettings", _("Select Your Serach Modus"), NULL, NULL, NULL, 1, 0);
6110        if(mbox != NULL) tmpstr = mbox->name;
6111
6112        if(ostrcmp(tmpstr, "Create Transponder (Sat)") == 0)
6113                flag = 0;
6114        else if(ostrcmp(tmpstr, "Create Transponder (Cable)") == 0)
6115                flag = 1;
6116        else if(ostrcmp(tmpstr, "Create Transponder (Terrestrial)") == 0)
6117                flag = 2;
6118        else if(ostrcmp(tmpstr, "Create Transponder (All)") == 0)
6119                flag = 3;
6120        else
6121        {
6122                freemenulist(mlist, 1); mlist = NULL;
6123                return;
6124        }
6125
6126        freemenulist(mlist, 1); mlist = NULL;
6127
6128        drawscreen(load, 0, 0);
6129
6130        if(flag == 0)
6131        {
6132                ret = converte2settings(0);
6133                if(ret == 0) return;
6134                system("cp -a /tmp/satellites.sat /mnt/settings/satellites");
6135                system("cp -a /tmp/transponder.sat /mnt/settings/transponder");
6136        }
6137        else if(flag == 1)
6138        {
6139                ret = converte2settings(1);
6140                if(ret == 0) return;
6141                system("cp -a /tmp/satellites.cable /mnt/settings/satellites");
6142                system("cp -a /tmp/transponder.cable /mnt/settings/transponder");
6143        }
6144        else if(flag == 2)
6145        {
6146                converte2settings(2);
6147                system("cp -a /tmp/satellites.ter /mnt/settings/satellites");
6148                system("cp -a /tmp/transponder.ter /mnt/settings/transponder");
6149        }
6150        else if(flag == 3)
6151        {
6152                ret = converte2settings(0);
6153                if(ret == 0) return;
6154                ret = converte2settings(1);
6155                if(ret == 0) return;
6156                ret = converte2settings(2);
6157                if(ret == 0) return;
6158                system("cp -a /tmp/satellites.sat /mnt/settings/satellites");
6159                system("cp -a /tmp/transponder.sat /mnt/settings/transponder");
6160
6161                system("cat /tmp/satellites.cable >> /mnt/settings/satellites");
6162                system("cat /tmp/transponder.cable >> /mnt/settings/transponder");
6163
6164                system("cat /tmp/satellites.ter >> /mnt/settings/satellites");
6165                system("cat /tmp/transponder.ter >> /mnt/settings/transponder");
6166        }
6167
6168//      free(tmpstr), tmpstr = NULL;
6169        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)
6170        {       
6171                //write only config file
6172                system("sync");
6173                writeallconfig(3);
6174                oshutdown(2,2);
6175                system("init 6");
6176        }
6177}
6178
6179// flag 0 = sat
6180// flag 1 = cable
6181// flag 2 = ter
6182int converte2settings(int flag)
6183{
6184        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;
6185        int incount = 0;
6186       
6187        if(flag == 0)
6188        {
6189                system("rm -rf /tmp/transponder.sat");
6190                system("rm -rf /tmp/satellites.sat");
6191                system("cp -a /var/etc/tuxbox/satellites.xml /tmp/satellites.xml");
6192                start = ostrcat("<sat ", NULL, 0, 0);
6193                end = ostrcat("</sat>", NULL, 0, 0);
6194                filename = ostrcat("/tmp/satellites.xml", NULL, 0, 0);
6195                path = ostrcat("/transponder/satellites.xml", NULL, 0, 0);
6196                transponderfile = ostrcat("/tmp/transponder.sat", NULL, 0, 0);
6197                satfile = ostrcat("/tmp/satellites.sat", NULL, 0, 0);
6198                fetype = ostrcat("0", NULL, 0, 0);
6199        }
6200        else if(flag == 1)
6201        {
6202                system("rm -rf /tmp/transponder.cable");
6203                system("rm -rf /tmp/satellites.cable");
6204                system("cp -a /var/etc/tuxbox/cables.xml /tmp/cables.xml");
6205                start = ostrcat("<cable ", NULL, 0, 0);
6206                end = ostrcat("</cable>", NULL, 0, 0);
6207                filename = ostrcat("/tmp/cables.xml", NULL, 0, 0);
6208                path = ostrcat("/transponder/cables.xml", NULL, 0, 0);
6209                transponderfile = ostrcat("/tmp/transponder.cable", NULL, 0, 0);
6210                satfile = ostrcat("/tmp/satellites.cable", NULL, 0, 0);
6211                fetype = ostrcat("1", NULL, 0, 0);
6212                incount = 4999;
6213        }
6214        else if(flag == 2)
6215        {
6216                system("rm -rf /tmp/transponder.ter");
6217                system("rm -rf /tmp/satellites.ter");
6218                system("cp -a /var/etc/tuxbox/terrestrial.xml /tmp/terrestrial.xml");
6219                start = ostrcat("<terrestrial ", NULL, 0, 0);
6220                end = ostrcat("</terrestrial>", NULL, 0, 0);
6221                filename = ostrcat("/tmp/terrestrial.xml", NULL, 0, 0);
6222                path = ostrcat("/transponder/terrestrial.xml", NULL, 0, 0);
6223                transponderfile = ostrcat("/tmp/transponder.ter", NULL, 0, 0);
6224                satfile = ostrcat("/tmp/satellites.ter", NULL, 0, 0);
6225                fetype = ostrcat("2", NULL, 0, 0);
6226                incount = 9999;
6227        }
6228
6229        if(!file_exist(filename))
6230                gethttp("atemio.dyndns.tv", path, 80, filename, HTTPAUTH, 5000, NULL, 0);
6231
6232        char* tmptext = NULL;
6233        tmptext = ostrcat(_("Error: Transponder Source file not found"), "\nfilename: ", 0, 0);
6234        tmptext = ostrcat(tmptext, transponderfile, 1, 0);
6235
6236        if(!file_exist(filename))
6237        {
6238                textbox(_("Message"), tmptext, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 0, 0);
6239                free(tmptext), tmptext = NULL;
6240                free(path), path = NULL;
6241                free(filename), filename = NULL;
6242                free(satfile), satfile = NULL;
6243                free(fetype), fetype = NULL;
6244                free(start), start = NULL;
6245                free(end), end = NULL;
6246                free(transponderfile), transponderfile = NULL;
6247                return 0;
6248        }
6249        free(tmptext), tmptext = NULL;
6250
6251        buf = readfiletomem(filename, 1);
6252        if(buf == NULL)
6253        {
6254                printf("buf: %s\n", buf);       
6255                tmptext = ostrcat(_("Error: Transponder Source file no data"), "\nfilename: ", 0, 0);
6256                tmptext = ostrcat(tmptext, transponderfile, 1, 0);
6257                textbox(_("Message"), tmptext, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 1000, 200, 0, 0);
6258                free(tmptext), tmptext = NULL;
6259                free(path), path = NULL;
6260                free(filename), filename = NULL;
6261                free(satfile), satfile = NULL;
6262                free(fetype), fetype = NULL;
6263                free(start), start = NULL;
6264                free(end), end = NULL;
6265                free(transponderfile), transponderfile = NULL;
6266                return 0;
6267        }
6268       
6269//      writesys("/tmp/convert.log", buf, 1);
6270
6271        while(ostrstr(buf, start) != NULL)
6272        {
6273                incount++;
6274                tmpstr = string_resub(start, end, buf, 0);
6275                tmpstr1 = ostrcat(tmpstr, NULL, 0, 0);
6276               
6277                //printf("name: %s\n", getxmlentry(ret1[i].part, "name="));
6278                //printf("position: %s\n", getxmlentry(ret1[i].part, "position="));
6279               
6280                name = getxmlentry(tmpstr, "name=");
6281                if(flag == 0)
6282                        orbitalpos = getxmlentry(tmpstr, "position=");
6283                else
6284                        orbitalpos = ostrcat(oitoa(incount), NULL, 1, 0);
6285                       
6286                flags = getxmlentry(tmpstr, "flags=");
6287                //string_decode(name, 0);
6288                name = string_replace_all("&amp;", "und", name, 1);
6289       
6290                line = ostrcat(line, name, 1, 0); //name
6291                line = ostrcat(line, "#", 1, 0);
6292//              line = ostrcat(line, flags, 1, 0); //flag
6293// 0 for all sat/ter/cab ???
6294                line = ostrcat(line, "0", 1, 0);
6295                line = ostrcat(line, "#", 1, 0);
6296                line = ostrcat(line, orbitalpos, 1, 0); //orbitalpos
6297                line = ostrcat(line, "#", 1, 0);
6298                line = ostrcat(line, fetype, 1, 0); //fetype
6299                printf("%s: %s\n", satfile, line);
6300                writesys(satfile, line, 3);
6301                free(line), line = NULL;
6302                               
6303                int count = 0;
6304
6305                int i = 0;
6306                struct splitstr* ret1 = NULL;
6307                ret1 = strsplit(tmpstr1, "\n", &count);
6308                if(ret1 != NULL)
6309                {
6310                        int max = count;
6311                        for(i = 0; i < max; i++)
6312                        {
6313                                if(i == 0) continue;
6314                                line = ostrcat(line, "0", 1, 0); //id
6315                                line = ostrcat(line, "#", 1, 0);
6316
6317                                line = ostrcat(line, fetype, 1, 0); //fetype
6318                                line = ostrcat(line, "#", 1, 0);
6319
6320                                if(ostrstr((ret1[i]).part, "frequency=") != NULL)
6321                                        line = ostrcat(line, getxmlentry(ret1[i].part, "frequency="), 1, 0); //frequency
6322                                else
6323                                        line = ostrcat(line, "-1", 1, 0);
6324                                line = ostrcat(line, "#", 1, 0);
6325
6326                                if(ostrstr((ret1[i]).part, "polarization=") != NULL)
6327                                        line = ostrcat(line, getxmlentry(ret1[i].part, "polarization="), 1, 0); //polarization
6328                                else
6329                                        line = ostrcat(line, "-1", 1, 0); //polarization
6330
6331                                line = ostrcat(line, "#", 1, 0);
6332                                if(orbitalpos != NULL)
6333                                        line = ostrcat(line, orbitalpos, 1, 0); //orbitalpos
6334                                else
6335                                        line = ostrcat(line, "-1", 1, 0); //orbitalpos
6336                                line = ostrcat(line, "#", 1, 0);
6337
6338                                if(ostrstr((ret1[i]).part, "symbol_rate=") != NULL)
6339                                        line = ostrcat(line, getxmlentry(ret1[i].part, "symbol_rate="), 1, 0); //symbolrate
6340                                else
6341                                        line = ostrcat(line, "-1", 1, 0);
6342                                line = ostrcat(line, "#", 1, 0);
6343
6344                                if(ostrstr((ret1[i]).part, "modulation=") != NULL)
6345                                        line = ostrcat(line, getxmlentry(ret1[i].part, "modulation="), 1, 0); //modulation
6346                                else
6347                                {
6348                                        if(flag == 2)
6349                                                line = ostrcat(line, "3", 1, 0);
6350                                        else
6351                                                line = ostrcat(line, "0", 1, 0);
6352                                }
6353                                line = ostrcat(line, "#", 1, 0);
6354
6355                                if(ostrstr((ret1[i]).part, "fec_inner=") != NULL)
6356                                        line = ostrcat(line, getxmlentry(ret1[i].part, "fec_inner="), 1, 0); //fec
6357                                else
6358                                {
6359                                        if(flag == 2)
6360                                                line = ostrcat(line, "5", 1, 0);
6361                                        else
6362                                                line = ostrcat(line, "0", 1, 0);
6363                                }
6364                                line = ostrcat(line, "#", 1, 0);
6365
6366                                if(checkbox("UFS910") == 1)
6367                                        line = ostrcat(line, "1", 1, 0); //pilot
6368                                else
6369                                        line = ostrcat(line, "2", 1, 0); //pilot
6370                                line = ostrcat(line, "#", 1, 0);
6371
6372                                if(checkbox("UFS910") == 1)
6373                                        line = ostrcat(line, "0", 1, 0); //rolloff
6374                                else
6375                                        line = ostrcat(line, "3", 1, 0); //rolloff
6376                                line = ostrcat(line, "#", 1, 0);
6377
6378                                line = ostrcat(line, "2", 1, 0); //inversion
6379                                line = ostrcat(line, "#", 1, 0);
6380
6381                                if(ostrstr((ret1[i]).part, "system=") != NULL)
6382                                        line = ostrcat(line, getxmlentry(ret1[i].part, "system="), 1, 0); //system
6383                                else
6384                                        line = ostrcat(line, "0", 1, 0); //system
6385                                line = ostrcat(line, "\n", 1, 0);
6386                        }
6387                }
6388       
6389                tmpstr2 = ostrcat(start, tmpstr, 0, 0);
6390       
6391                buf = string_replace(tmpstr2, NULL, buf, 1);
6392       
6393        //      outfile = ostrcat("/tmp/convert.", oitoa(incount), 0, 1);
6394        //      outfile = ostrcat(outfile, ".log", 1, 0);       
6395        //      writesys(outfile, buf, 2);
6396        //      writesys("/tmp/convert.log", buf, 3);
6397       
6398                writesys(transponderfile, line, 2);
6399                free(line), line = NULL;
6400       
6401                free(tmpstr), tmpstr = NULL;   
6402                free(tmpstr1), tmpstr1 = NULL;
6403                free(tmpstr2), tmpstr2 = NULL;
6404                free(ret1), ret1 = NULL;
6405                free(name), name = NULL;
6406                free(orbitalpos), orbitalpos = NULL;
6407                free(flags), flags = NULL;
6408                free(outfile), outfile = NULL; 
6409        }
6410
6411        free(path), path = NULL;
6412        free(filename), filename = NULL;
6413        free(satfile), satfile = NULL;
6414        free(transponderfile), transponderfile = NULL;
6415               
6416        free(buf), buf = NULL;
6417        free(start), start = NULL;
6418        free(end), end = NULL;
6419        free(fetype), fetype = NULL;
6420                       
6421        return 1;
6422}
6423
6424void createfav()
6425{
6426        struct skin* load = getscreen("loading");
6427        drawscreen(load, 0, 0);
6428
6429        system("rm -rf /mnt/settings/bouquets*");
6430        system("cp -a /etc/titan.restore/mnt/settings/bouquets* /mnt/settings");
6431
6432        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)
6433        {
6434                //write only config file
6435                system("sync");
6436                writeallconfig(3);
6437                oshutdown(2,2);
6438                system("init 6");
6439        }
6440}
6441
6442char* system_infos(int mode)
6443{
6444        char* tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL;
6445
6446        if(mode == 0)
6447        {
6448                tmpstr1 = ostrcat("Date = ", "", 0, 0);
6449                tmpstr1 = ostrcat(tmpstr1, gettime(NULL, "%d %B %Y"), 1, 1);
6450                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
6451
6452                tmpstr1 = ostrcat("\nTime = ", "", 0, 0);
6453                tmpstr1 = ostrcat(tmpstr1, gettime(NULL, "%H:%M:%S"), 1, 1);
6454                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
6455               
6456                tmpstr1 = ostrcat("\nUptime = ", "", 0, 0);
6457                tmpstr2 = command("uptime");
6458                if(tmpstr2 != NULL) tmpstr2 = strtok(tmpstr2, ",");
6459                tmpstr1 = ostrcat(tmpstr1, tmpstr2, 1, 1);
6460                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
6461
6462                tmpstr1 = ostrcat("\nBoxtype = ", "", 0, 0);
6463                tmpstr2 = string_toupper(command("cat /etc/model"));
6464                tmpstr1 = ostrcat(tmpstr1, tmpstr2, 1, 1);
6465                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
6466
6467                tmpstr1 = ostrcat("\nLoad = ", "", 0, 0);
6468                tmpstr2 = command("cat /proc/loadavg");
6469                tmpstr1 = ostrcat(tmpstr1, tmpstr2, 1, 1);
6470                tmpstr = ostrcat(tmpstr, tmpstr1, 1, 1);
6471        }
6472
6473        if(mode == 1)
6474        {
6475                system("ls /media/usb/* >/dev/null");
6476                system("ls /media/net/* >/dev/null");
6477                system("ls /var/swap/* >/dev/null");
6478                system("ls /mnt/swapextension/* >/dev/null");
6479                system("ls /var/backup/* >/dev/null");
6480                system("ls /media/hdd/* >/dev/null");
6481                tmpstr = command("df -h");
6482        }
6483
6484        if(mode == 2)
6485                tmpstr = command("cat /proc/version");
6486
6487        if(mode == 3)
6488        {
6489                system("ls /media/usb/* >/dev/null");
6490                system("ls /media/net/* >/dev/null");
6491                system("ls /var/swap/* >/dev/null");
6492                system("ls /mnt/swapextension/* >/dev/null");
6493                system("ls /var/backup/* >/dev/null");
6494                system("ls /media/hdd/* >/dev/null");
6495                tmpstr = command("mount");
6496        }
6497
6498        if(mode == 4)
6499        {
6500                tmpstr1 = command("ifconfig");
6501                tmpstr2 = command("route -n");
6502                tmpstr = ostrcat(tmpstr1, tmpstr2, 1, 1);
6503        }
6504
6505        if(mode == 5)
6506                tmpstr = command("free");
6507
6508        return tmpstr;
6509}
6510
6511char* system_infos_sysinfo(int mode)
6512{
6513        char* tmpstr = NULL;
6514
6515        if(mode == 0)
6516                tmpstr = command("cat /proc/cpuinfo | sed 's/\t\t/\t/'");
6517        else if(mode == 1)
6518                tmpstr = command("cat /proc/meminfo");
6519        else if(mode == 2)
6520                tmpstr = command("cat /proc/mtd");
6521        else if(mode == 3)
6522                tmpstr = command("cat /proc/modules");
6523        else if(mode == 4)
6524                tmpstr = command("cat /proc/devices");
6525        else if(mode == 5)
6526        {
6527                char* tmpstr1 = NULL, **tmpstr2 = NULL, **tmpstr3 = NULL;
6528                int i = 0, ii = 0;
6529                char* swap[] = {"Name: ", "Type: ", "Size: ", "Used: ", "Prio: "};
6530
6531                tmpstr1 = command("cat /proc/swaps | sed 's/\t/ /g; s/[ ]* / /g'");
6532                tmpstr2 = str_split(tmpstr1, "\n");
6533                if(tmpstr2 != NULL)
6534                {
6535                        free(tmpstr2[0]); tmpstr2[0] = NULL;
6536
6537                        for(i = 1; tmpstr2[i] != NULL; i++)
6538                        {
6539                                tmpstr3 = str_split(tmpstr2[i], " ");
6540                                if(tmpstr3 != NULL)
6541                                {
6542
6543                                        for(ii = 0; tmpstr3[ii] != NULL; ii++)
6544                                        {
6545                                                tmpstr = ostrcat(tmpstr, swap[ii], 1, 0);
6546                                                tmpstr = ostrcat(tmpstr, tmpstr3[ii], 1, 1);
6547                                                tmpstr = ostrcat(tmpstr, "\n", 1, 0);
6548                                        }
6549                                }
6550
6551                                tmpstr = ostrcat(tmpstr, "\n", 1, 0);
6552                                free(tmpstr2[i]); tmpstr2[i] = NULL;
6553                                free(tmpstr3); tmpstr3 = NULL;
6554                        }
6555                }
6556
6557                free(tmpstr3); tmpstr3 = NULL;
6558                free(tmpstr2); tmpstr2 = NULL;
6559                free(tmpstr1); tmpstr1 = NULL;
6560        }
6561        else if(mode == 6)
6562                tmpstr = command("top -b -n1");
6563        else if(mode == 7)
6564                tmpstr = command("ps");
6565        else if(mode == 8)
6566                tmpstr = command("cat /proc/bus/usb/devices");
6567
6568        return tmpstr;
6569}
6570
6571char* system_logs(int mode)
6572{
6573        char* tmpstr = NULL, *tmpstr1 = NULL, *tmpstr2 = NULL, *tmpstr3 = NULL, *path = NULL, *boxversion = NULL;
6574
6575        if(mode == 0)
6576        {
6577                tmpstr1 = readfiletomem("/etc/motd", 0);
6578                if(tmpstr1 != NULL) tmpstr2 = strstr(tmpstr1, "wElc0me");
6579                tmpstr3 = readfiletomem("/etc/imageinfo", 0);
6580                if(tmpstr2 == NULL)
6581                        tmpstr = ostrcat(tmpstr3, NULL, 1, 0);
6582                else
6583                        tmpstr = ostrcat(tmpstr2, tmpstr3, 1, 1);
6584        }
6585        else if(mode == 1)
6586        {
6587                if(isfile("/etc/model") == 0) return NULL;
6588                boxversion = string_tolower(readsys("/etc/model", 1));
6589
6590//              if(file_exist("/etc/.beta"))
6591                        path = ostrcat(path, "/svn/image-beta/changelog.", 1, 0);
6592//              else
6593//                      path = ostrcat(path, "/svn/image/changelog.", 1, 0);
6594
6595                path = ostrcat(path, boxversion, 1, 0);
6596                path = ostrcat(path, ".titan", 1, 0);
6597
6598//              if(file_exist("/etc/.beta"))
6599                        tmpstr1 = gethttp("beta.dyndns.tv", path, 80, NULL, HTTPAUTH, 5000, NULL, 0);
6600//              else
6601//                      tmpstr1 = gethttp("atemio.dyndns.tv", path, 80, NULL, HTTPAUTH, 5000, NULL, 0);
6602
6603                tmpstr = readfromlinetoline(tmpstr1, 37, 537, 1);
6604        }
6605        else if(mode == 2)
6606        {
6607//              if(file_exist("/etc/.beta"))
6608#ifdef MIPSEL
6609                        path = ostrcat(path, "/svn/image-beta/changelog.git.mipsel", 1, 0);
6610#else
6611                        path = ostrcat(path, "/svn/image-beta/changelog.git.sh4", 1, 0);
6612#endif
6613//              else
6614//                      path = ostrcat(path, "/svn/image/changelog.git", 1, 0);
6615
6616//              if(file_exist("/etc/.beta"))
6617                        tmpstr1 = gethttp("beta.dyndns.tv", path, 80, NULL, HTTPAUTH, 5000, NULL, 0);
6618//              else
6619//                      tmpstr1 = gethttp("atemio.dyndns.tv", path, 80, NULL, HTTPAUTH, 5000, NULL, 0);
6620
6621                tmpstr = readfromlinetoline(tmpstr1, 0, 500, 1);
6622        }
6623        else if(mode == 3)
6624        {
6625                tmpstr = readfiletomem(getconfig("tracelog", NULL), 0);
6626        }
6627
6628        free(path), path = NULL;
6629        free(boxversion), boxversion = NULL;
6630//      free(tmpstr1), tmpstr1 = NULL;
6631//      free(tmpstr2), tmpstr2 = NULL;
6632//      free(tmpstr3), tmpstr3 = NULL;
6633
6634        return tmpstr;
6635}
6636
6637char* getabout()
6638{
6639        char* text = NULL, *tmpstr = NULL, *imgversion = NULL;
6640        struct dvbdev* dvbnode = dvbdev;
6641
6642        if(isfile(getconfig("imagenamefile", NULL))     != 0)
6643                imgversion = readsys(getconfig("imagenamefile", NULL), 1);
6644        else
6645                imgversion = ostrcat("unknown", NULL, 0, 0);
6646
6647        text = ostrcat(_("Image"), ": ", 0, 0);
6648        text = ostrcat(text, PROGNAME, 1, 0);
6649        text = ostrcat(text, "\n", 1, 0);
6650        text = ostrcat(text, _("Version"), 1, 0);
6651        text = ostrcat(text, ": ", 1, 0);
6652        text = ostrcat(text, OVERSION, 1, 0);
6653        text = ostrcat(text, "\n", 1, 0);
6654        text = ostrcat(text, _("Installed:"), 1, 0);
6655        text = ostrcat(text, " ", 1, 0);
6656        text = ostrcat(text, imgversion, 1, 1);
6657        text = ostrcat(text, "\n", 1, 0);
6658        text = ostrcat(text, _("Copyright"), 1, 0);
6659        text = ostrcat(text, ": ", 1, 0);
6660        text = ostrcat(text, COPYRIGHT, 1, 0);
6661        text = ostrcat(text, "\n\n", 1, 0);
6662               
6663        while(dvbnode != NULL)
6664        {
6665                if(dvbnode->type == FRONTENDDEV && dvbnode->feinfo != NULL)
6666                {
6667                        text = ostrcat(text, _("Tuner"), 1, 0);
6668                        text = ostrcat(text, ": ", 1, 0);
6669                        if(dvbnode->feinfo->name != NULL)
6670                                text = ostrcat(text, dvbnode->feinfo->name, 1, 0);
6671                        else
6672                                text = ostrcat(text, _("unknown"), 1, 0);
6673                        text = ostrcat(text, "\n", 1, 0);
6674                        text = ostrcat(text, _("Tunertype"), 1, 0);
6675                        text = ostrcat(text, ": ", 1, 0);
6676
6677                        tmpstr = fegettypestr(dvbnode);
6678                        text = ostrcat(text, tmpstr, 1, 1);
6679                        text = ostrcat(text, "\n\n", 1, 0);
6680                }
6681                dvbnode = dvbnode->next;
6682        }
6683       
6684        char* flog = readfiletomem("/tmp/.firmware.log", 0);
6685        text = ostrcat(text, flog, 1, 1);
6686
6687        return text;
6688}
6689
6690char* getimgnamereal()
6691{
6692        char* tmpstr = NULL;
6693
6694        tmpstr = readfiletomem(getconfig("imagenamefile", NULL), 1);
6695
6696        return tmpstr;
6697}
6698
6699#endif
Note: See TracBrowser for help on using the repository browser.