source: titan/titan/global.h @ 27765

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

enable sec

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