source: titan/titan/global.h @ 27763

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

mipsel disable some menu entrys

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