source: titan/titan/global.h @ 23991

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

[titan] fix

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