source: titan/titan/global.h @ 27941

Last change on this file since 27941 was 27941, checked in by obi, 9 years ago

fix

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