source: titan/titan/global.h @ 24101

Last change on this file since 24101 was 24091, checked in by nit, 10 years ago

fix

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