source: titan/titan/global.h @ 29681

Last change on this file since 29681 was 29681, checked in by gost, 10 years ago

[titan] mipsel... fix usb device info

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