source: titan/titan/global.h @ 30752

Last change on this file since 30752 was 30752, checked in by nit, 9 years ago

fix e2 transponder convert

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