source: titan/titan/global.h @ 25887

Last change on this file since 25887 was 25887, checked in by obi, 8 years ago

show system backup and usb tmp install for all boxes

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