source: titan/titan/global.h @ 26912

Last change on this file since 26912 was 26547, checked in by obi, 10 years ago

mipsel add minitv support

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