source: titan/titan/global.h @ 30755

Last change on this file since 30755 was 30755, checked in by gost, 9 years ago

[titan] mipsel.. add simple cec

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