source: titan/titan/rectimer.h @ 31658

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

add getmoviedev

File size: 42.2 KB
Line 
1#ifndef RECTIMER_H
2#define RECTIMER_H
3
4void debugrectimer()
5{
6        struct rectimer* node = rectimer;
7
8        while(node != NULL)
9        {
10                printf("--------------------------------\n");
11                printf("name: %s\n", node->name);
12                printf("start: %lu end: %lu\n", node->begin, node->end);
13                printf("currently time: %ld\n", time(NULL));
14                printf("channellist: %s\n", node->channellist);
15                printf("serviceid: %d transponderid: %llu\n", node->serviceid, node->transponderid);
16                printf("--------------------------------\n");
17                node = node->next;
18        }
19}
20
21void sortrectimer()
22{
23        struct rectimer *nodea = NULL, *nodeb = NULL, *nodec = NULL, *noded = NULL;
24        struct rectimer *nodetmp = NULL, *node = rectimer;
25
26        if(node != NULL)
27        {
28                while (noded != node->next)
29                {
30                        nodec = node;
31                        nodea = node;
32                        nodeb = nodea->next;
33
34                        while (nodea != noded)
35                        {
36                                if (nodea->begin >= nodeb->begin)
37                                {
38                                        if (nodea == node)
39                                        {
40                                                nodetmp = nodeb->next;
41                                                nodeb->next = nodea;
42                                                nodea->next = nodetmp;
43                                                node = nodeb;
44                                                nodec = nodeb;
45                                        }
46                                        else
47                                        {
48                                                nodetmp = nodeb->next;
49                                                nodeb->next = nodea;
50                                                nodea->next = nodetmp;
51                                                nodec->next = nodeb;
52                                                nodec = nodeb;
53                                        }
54                                }
55                                else
56                                {
57                                        nodec = nodea;
58                                        nodea = nodea->next;
59                                }
60                                nodeb = nodea->next;
61                                if (nodeb == noded)
62                                        noded = nodea;
63                        }
64                }
65        }
66
67        struct rectimer* prev = NULL;
68        nodetmp = node;
69        while(nodetmp != NULL)
70        {
71                nodetmp->prev = prev;
72                prev = nodetmp;
73
74                nodetmp = nodetmp->next;
75        }
76
77        rectimer = node;
78}
79
80int checkrectimerconflict(struct rectimer* recnode)
81{
82        struct dvbdev* dvbnode = dvbdev;
83        struct transponder* tpnode = NULL;
84        struct rectimer* node = rectimer;
85
86        if(recnode == NULL) return 0;
87
88        while(dvbnode != NULL)
89        {
90                if(dvbnode->type == FRONTENDDEV)
91                {
92                        adddvbdev(ostrcat(dvbnode->dev, NULL, 0, 0), dvbnode->adapter, dvbnode->devnr, dvbnode->fd, FRONTENDDEV, dvbnode->feinfo, NULL, dvbnode->fehyprid, 1);
93                }
94                dvbnode = dvbnode->next;
95        }
96        dvbnode = NULL;
97
98        if(dvbdevsim == NULL) return 0;
99
100        tpnode = gettransponder(recnode->transponderid);
101        dvbnode = fegetfree(tpnode, 3, dvbdevsim);
102        if(dvbnode != NULL)
103                dvbnode->felock = 1;
104
105        while(node != NULL)
106        {
107                if(recnode != node && node->status < 2)
108                {
109                        if((recnode->begin >= node->begin && recnode->begin < node->end) || (recnode->end >= node->begin && recnode->end < node->end))
110                        {
111                                tpnode = gettransponder(node->transponderid);
112                                dvbnode = fegetfree(tpnode, 3, dvbdevsim);
113                                if(dvbnode == NULL)
114                                {
115                                        freedvbdev(1);
116                                        dvbdevsim = NULL;
117                                        return 2;
118                                }
119                                else
120                                        dvbnode->felock = 1;
121                        }
122                }
123                node = node->next;
124        }
125
126        freedvbdev(1);
127        dvbdevsim = NULL;
128        return 0;
129}
130
131int checkrectimeradd(struct rectimer* recnode, char** ret)
132{
133        if(recnode == NULL)
134        {
135                *ret = _("undefined error");
136                return 1;
137        }
138        if(recnode->begin == 0 || recnode->end == 0)
139        {
140                *ret = _("Timer starttime or endtime not ok");
141                return 1;
142        }
143        if(recnode->end <= time(NULL))
144        {
145                *ret = _("Timer endtime shorter than aktual time");
146                return 1;
147        }
148        if(recnode->end <= recnode->begin)
149        {
150                *ret = _("Timer endtime shorter than start time");
151                return 1;
152        }
153        if(recnode->serviceid < 1)
154        {
155                *ret = _("Timer service ID not ok");
156                return 1;
157        }
158        if(recnode->transponderid < 1)
159        {
160                *ret = _("Timer transponder ID not ok");
161                return 1;
162        }
163
164        if(checkrectimerconflict(recnode) != 0)
165        {
166                *ret = _("Timer conflicts with other timer\nWould you add the timer?");
167                return 2;
168        }
169
170        return 0;
171}
172
173void recrepeatecalc(struct rectimer* node)
174{
175        time_t daysec = 24 * 60 * 60;
176        struct tm* loctime = NULL;
177        int rectimerday = -1, rep = 0, i = 0, daylight = 0;
178
179        if(node->repeate == 0) return;
180        status.writerectimer = 1;
181
182        //get rectimer start day
183        loctime = olocaltime(&node->begin);
184        if(loctime != NULL)
185        {
186                rectimerday = loctime->tm_wday - 1;
187                daylight = loctime->tm_isdst;
188        }
189        free(loctime); loctime = NULL;
190        if(rectimerday == -1) rectimerday = 6;
191
192        rep = (node->repeate & 0xff) | ((node->repeate  & 0xff) << 7);
193
194        for(i = 0; i < 7; i++)
195        {
196                node->begin = node->begin + daysec;
197                node->end = node->end + daysec;
198                rectimerday++;
199                if(rectimerday > 6) rectimerday = 0;
200                if(checkbit(rep, rectimerday) == 1)
201                        break;
202        }
203
204        //check if begin > akttime
205        while(node->begin < time(NULL))
206        {
207                for(i = 0; i < 7; i++)
208                {
209                        node->begin = node->begin + daysec;
210                        node->end = node->end + daysec;
211                        rectimerday++;
212                        if(rectimerday > 6) rectimerday = 0;
213                        if(checkbit(rep, rectimerday) == 1)
214                                break;
215                }
216        }
217
218        //calc daylight
219        loctime = olocaltime(&node->begin);
220        if(loctime != NULL)
221        {
222                if(loctime->tm_isdst > daylight)
223                {
224                        node->begin = node->begin - 3600;
225                        node->end = node->end - 3600;
226                }
227                else if(loctime->tm_isdst < daylight)
228                {
229                        node->begin = node->begin + 3600;
230                        node->end = node->end + 3600;
231                }
232        }
233}
234
235int checkrectimertime(struct rectimer* node)
236{
237        //don't load old timers
238        if(time(NULL) - node->end > 604800 && (node->status == 2 || node->status == 3 || node->status == 5))
239                return 1;
240
241        if(time(NULL) > node->end && node->repeate == 0 && node->status == 0)
242                return 1;
243
244        //recalc old repeat timer
245        if(time(NULL) > node->end && node->repeate != 0 && node->status == 0)
246                recrepeatecalc(node);
247
248        return 0;
249}
250
251void copyrectimer(struct rectimer* src, struct rectimer* dst)
252{
253        dst->timestamp = ostrcat(src->timestamp, NULL, 0, 0);
254        dst->name = ostrcat(src->name, NULL, 0, 0);
255        dst->begin = src->begin;
256        dst->end = src->end;
257        dst->repeate = src->repeate;
258        dst->afterevent = src->afterevent;
259        dst->disabled = src->disabled;
260        dst->justplay = src->justplay;
261        dst->recpath = ostrcat(src->recpath, NULL, 0, 0);
262        dst->servicetype = src->servicetype;
263        dst->channellist = ostrcat(src->channellist, NULL, 0, 0);
264        dst->serviceid = src->serviceid;
265        dst->transponderid = src->transponderid;
266}
267
268struct rectimer* addrectimernode(char* line, struct rectimer* last)
269{
270        char *ret = NULL;
271        struct rectimer *newnode = NULL, *prev = NULL, *node = rectimer;
272       
273        newnode = (struct rectimer*)calloc(1, sizeof(struct rectimer));
274        if(newnode == NULL)
275        {
276                err("no memory");
277                return NULL;
278        }
279
280        status.writerectimer = 1;
281        newnode->timestamp = NULL;
282
283        if(line != NULL)
284        {
285                ret = getxmlentry(line, " begin=");
286                if(ret != NULL)
287                {
288                        newnode->begin = atol(ret);
289                        free(ret);
290                }
291                ret = getxmlentry(line, " end=");
292                if(ret != NULL)
293                {
294                        newnode->end = atol(ret);
295                        free(ret);
296                }
297                ret = getxmlentry(line, " repeated=");
298                if(ret != NULL)
299                {
300                        newnode->repeate = atoi(ret);
301                        free(ret);
302                }
303                ret = getxmlentry(line, " afterevent=");
304                if(ret != NULL)
305                {
306                        newnode->afterevent = atoi(ret);
307                        free(ret);
308                }
309                ret = getxmlentry(line, " pincode=");
310                if(ret != NULL)
311                        newnode->pincode = ret;
312                ret = getxmlentry(line, " disabled=");
313                if(ret != NULL)
314                {
315                        newnode->disabled = atoi(ret);
316                        free(ret);
317                }
318                ret = getxmlentry(line, " justplay=");
319                if(ret != NULL)
320                {
321                        newnode->justplay = atoi(ret);
322                        free(ret);
323                }
324                ret = getxmlentry(line, " serviceid=");
325                if(ret != NULL)
326                {
327                        newnode->serviceid = atoi(ret);
328                        free(ret);
329                }
330                ret = getxmlentry(line, " transponderid=");
331                if(ret != NULL)
332                {
333                        newnode->transponderid = strtoull(ret, NULL, 10);
334                        free(ret);
335                }
336                ret = getxmlentry(line, " status=");
337                if(ret != NULL)
338                {
339                        newnode->status = atol(ret);
340                        if(newnode->status == 1) newnode->status = 0;
341                        free(ret);
342                }
343                ret = getxmlentry(line, " timestamp=");
344                if(ret != NULL)
345                {
346                        newnode->timestamp = ret;
347                }
348                ret = getxmlentry(line, " name=");
349                if(ret != NULL)
350                        newnode->name = ret;
351                ret = getxmlentry(line, " recpath=");
352                if(ret != NULL)
353                        newnode->recpath = ret;
354                ret = getxmlentry(line, " channellist=");
355                if(ret != NULL)
356                        newnode->channellist = ret;
357                ret = getxmlentry(line, " errstr=");
358                if(ret != NULL)
359                        newnode->errstr = ret;
360
361                if(checkrectimertime(newnode) == 1)
362                {
363                        free(newnode);
364                        return NULL;
365                }
366        }
367        else
368        {
369                newnode->disabled = 1;
370                newnode->afterevent = getconfigint("def_rectimer_after", NULL);
371        }
372       
373        if(newnode->timestamp == NULL)
374                newnode->timestamp = gettimestamp();
375       
376        if(last == NULL)
377        {
378                while(node != NULL && newnode->begin >= node->begin)
379                {
380                        prev = node;
381                        node = node->next;
382                }
383        }
384        else
385        {
386                prev = last;
387                node = last->next;
388        }
389
390        if(prev == NULL)
391                rectimer = newnode;
392        else
393        {
394                prev->next = newnode;
395                newnode->prev = prev;
396        }
397        newnode->next = node;
398        if(node != NULL) node->prev = newnode;
399
400        return newnode;
401}
402
403struct rectimer* getrectimerbytimediff(time_t timediff)
404{
405        struct rectimer* node = rectimer;       
406        time_t akttime = time(NULL);
407
408        while(node != NULL)
409        {
410                if(node->begin > akttime && node->begin <= akttime + timediff)
411                        return node;
412
413                node = node->next;
414        }
415
416        return NULL;
417}
418
419struct rectimer* getrectimerbytimestamp(char* timestamp)
420{
421        struct rectimer* node = rectimer;       
422
423        while(node != NULL)
424        {
425                if(ostrcmp(node->timestamp, timestamp) == 0)
426                        return node;
427
428                node = node->next;
429        }
430
431        return NULL;
432}
433
434struct rectimer* getrectimerbyservice(struct service* servicenode)
435{
436        struct rectimer* node = rectimer;       
437
438        while(node != NULL)
439        {
440                if(node->servicenode == servicenode)
441                        return node;
442
443                node = node->next;
444        }
445
446        return NULL;
447}
448
449void checkrectimer(struct stimerthread* self)
450{
451        int ret = 0;
452        struct rectimer* node = NULL, *newnode = NULL;
453        struct channel* chnode = NULL;
454        time_t t = 0, begin = 0, end = 0;
455printf("checkrectimer start\n");
456
457        if(self == NULL) return;
458
459        //wait for right time
460        while(self->aktion != STOP && time(NULL) < 1072224000) // 01.01.2004
461                usleep(1 * 1000000);
462       
463        //on first start read rectimer and set cec
464        if(self->delay == 1000)
465        {
466                ret = 5;
467                while(self->aktion != STOP && ret != 0)
468                {
469                        usleep(1 * 1000000);
470                        ret = ret - 1;
471                }
472                ret = 0;
473                readrectimer(getconfig("rectimerfile", NULL));
474                checkboxstart();
475        }
476               
477        //wait for start all programs
478        ret = 30;
479        while(self->aktion != STOP && ret != 0)
480        {
481                usleep(1 * 1000000);
482                ret = ret - 1;
483        }
484        ret = 0;
485       
486        //on first start read rectimer
487        if(self->delay == 1000)
488        {
489                self->delay = 10000;
490                //readrectimer(getconfig("rectimerfile", NULL));
491                epgscancreatetimer();
492                //checkboxstart();
493        }
494
495        m_lock(&status.rectimermutex, 1);
496        t = time(NULL);
497        node = rectimer;
498       
499        while(node != NULL)
500        {
501                if(node->disabled != 0)
502                {
503                        node = node->next;
504                        continue;
505                }
506               
507                if(node->justplay == 1)
508                {
509                        begin = node->begin;
510                        end = node->end + 180;
511                }
512                else
513                {
514                        begin = node->begin;
515                        end = node->end;
516                }
517
518                if(t >= begin && t < end && node->disabled == 0 && node->status == 0)
519                {
520                        if(node->repeate != 0)
521                        {
522                                //copy repeate timer
523                                newnode = addrectimernode(NULL, NULL);
524                                if(newnode != NULL)
525                                {
526                                        copyrectimer(node, newnode);
527                                        recrepeatecalc(newnode);
528                                }
529                                node->repeate = 0;
530                                status.writerectimer = 1;
531                        }
532                        chnode = getchannel(node->serviceid, node->transponderid);
533                        if(node->justplay == 1)
534                        {
535                                //ret = servicestart(chnode, NULL, node->channellist, 0);
536                                ret = servicestart(chnode, node->channellist, NULL, 0);
537                                if(ret == 20 || ret == 22) ret = 0;
538                        }
539                        else
540                        {
541printf("########################################\n");
542printf("sdparm -C START /dev/sda\n");
543system("sdparm -C START /dev/sda");
544printf("########################################\n");
545
546                                char* moviedev = getmoviedev();
547                                if(moviedev != NULL)
548                                        hddwakeup(moviedev);
549                                free(moviedev), moviedev = NULL;
550                                 
551                                //workaround for standby recording
552                                char* cmd = NULL;
553                                cmd = ostrcat("ls -al ", getconfig("rec_path", NULL), 0, 0);
554//                              cmd = ostrcat(cmd, " >/dev/null", 1, 0);
555                                printf("cmd: %s\n", cmd);
556                                system(cmd);
557                                free(cmd), cmd = NULL;
558printf("########################################\n");
559/*
560                                sleep(5);
561                                cmd = NULL;
562                                cmd = ostrcat("ls -al ", getconfig("rec_path", NULL), 0, 0);
563//                              cmd = ostrcat(cmd, " >/dev/null", 1, 0);
564                                printf("cmd: %s\n", cmd);
565                                system(cmd);
566                                free(cmd), cmd = NULL;
567
568
569printf("########################################\n");
570
571printf("fdisk -l\n");
572system("fdisk -l");
573printf("########################################\n");
574
575printf("ls -al /media/\n");
576system("ls -al /media/");
577printf("########################################\n");
578
579printf("ls -al /media/hdd/\n");
580system("ls -al /media/hdd/");
581printf("########################################\n");
582
583printf("ls -al /media/hdd/movie/\n");
584system("ls -al /media/hdd/movie/");
585printf("########################################\n");
586
587printf("fdisk -l\n");
588system("fdisk -l");
589printf("########################################\n");
590
591printf("ls -al /media/\n");
592system("ls -al /media/");
593printf("########################################\n");
594
595printf("ls -al /media/hdd/\n");
596system("ls -al /media/hdd/");
597printf("########################################\n");
598
599printf("ls -al /media/hdd/movie/\n");
600system("ls -al /media/hdd/movie/");
601printf("########################################\n");
602
603printf("ls -al /media/autofs/\n");
604system("ls -al /media/autofs/");
605printf("########################################\n");
606
607printf("ls -al /media/autofs/sda1/\n");
608system("ls -al /media/autofs/sda1/");
609printf("########################################\n");
610*/
611                                // workaround end       
612                                ret = recordstart(chnode, -1, 0, RECTIMER, node->end, node);
613                                if(ret == 14) ret = 0;
614                        }
615
616                        if(ret != 0)
617                        {
618                                node->status = 3;
619                                status.writerectimer = 1;
620                                break;
621                        }
622                        else
623                        {
624                                if(node->justplay == 1)
625                                        node->status = 2;
626                                else
627                                        node->status = 1;
628                                status.writerectimer = 1;
629                        }
630                }
631                if(t > node->end && (node->status == 0 || node->status == 4) && node->end != 0)
632                {
633                        if(node->status == 4)
634                                node->status = 5;
635                        else
636                                node->status = 3;
637                        free(node->errstr);
638                        node->errstr = ostrcat(_("not started akttime higher than timer endtime"), NULL, 0, 0);
639                        status.writerectimer = 1;
640                }
641                //for epgscan
642                if(t >= begin && t < end && node->disabled == 0 && node->status == 4)
643                {
644                        node->status = 5;
645                        status.writerectimer = 1;
646
647                        if(status.standby == 0)
648                        {
649                                int tret = textbox(_("Message"), _("EPG Scan activate standby?"), _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 20, 0);
650
651                                if(tret == 0 || tret == 1)
652                                {
653                                        status.standby = 2;
654                                        addtimer(&screenstandby, START, 1000, 1, NULL, NULL, NULL);
655                                }
656                        }
657                }
658                node = node->next;
659        }
660
661        m_unlock(&status.rectimermutex, 1);
662
663        if(node != NULL && node->disabled == 0 && node->status < 4)
664        {
665                if(node->justplay == 1)
666                {
667                        char* retstr = servicecheckret(ret, 1);
668                        free(node->errstr);
669                        node->errstr = ostrcat(retstr, NULL, 0, 0);
670                        stringreplacecharonce(node->errstr, '\n', '\0');
671                        free(retstr); retstr = NULL;
672                }
673                else
674                {
675                        char* retstr = recordcheckret(NULL, ret, 15);
676                        free(node->errstr);
677                        node->errstr = ostrcat(retstr, NULL, 0, 0);
678                        stringreplacecharonce(node->errstr, '\n', '\0');
679                        free(retstr); retstr = NULL;
680                }
681                status.writerectimer = 1;
682        }
683
684        writerectimer(getconfig("rectimerfile", NULL), 0);
685}
686
687int addrectimer(char *buf)
688{
689        struct rectimer* node = NULL;
690        char* buf1 = buf;
691        char* line = NULL;
692
693        line = malloc(MINMALLOC);
694        if(line == NULL)
695        {
696                err("no memory");
697                return 1;
698        }
699
700        while(*buf != '\0')
701        {
702                buf++;
703                if(*buf == '\n' || *buf == '\0')
704                {
705                        if(*buf == '\n')
706                        {
707                                buf++;
708                                snprintf(line, buf - buf1, "%s", buf1);
709                        }
710                        else
711                                snprintf(line, buf - buf1 + 1, "%s", buf1);
712                        buf1 = buf;
713
714                        if(ostrstr(line, "<timer ") != NULL || ostrstr(line, "<log ") != NULL || ostrstr(line, "<epgscan ") != NULL)
715                                node = addrectimernode(line, node);
716                }
717        }
718        free(line);
719        return 0;
720}
721
722int readrectimer(char *filename)
723{
724        char *buf = NULL;
725
726        buf = readfiletomem(filename, 1);
727
728        if(buf != NULL)
729        {
730                addrectimer(buf);
731                //timers can change on load, so we save it
732                writerectimer(getconfig("rectimerfile", NULL), 0);
733                free(buf);
734        }
735        return 0;
736}
737
738//flag 0 = set mutex
739//flag 1 = don't set mutex
740void delrectimer(struct rectimer* rectimernode, int write, int flag)
741{
742        if(flag == 0) m_lock(&status.rectimermutex, 1);
743        struct rectimer *node = rectimer, *prev = rectimer;
744
745        while(node != NULL)
746        {
747                if(node == rectimernode)
748                {
749                        status.writerectimer = 1;
750
751                        //record is aktiv (del from stopservice)
752                        if(node->servicenode != NULL)
753                        {
754                                node->status = 2;
755                                free(node->errstr);
756                                node->errstr = ostrcat(_("stopped from user"), NULL, 0, 0);
757                                //stop recording
758                                node->servicenode->recendtime = 2;
759                                if(flag == 0)
760                                        m_unlock(&status.rectimermutex, 1);
761                                return;
762                        }
763
764                        if(node == rectimer)
765                        {
766                                rectimer = node->next;
767                                if(rectimer != NULL)
768                                        rectimer->prev = NULL;
769                        }
770                        else
771                        {
772                                prev->next = node->next;
773                                if(node->next != NULL)
774                                        node->next->prev = prev;
775                        }
776
777                        free(node->name);
778                        node->name = NULL;
779                       
780                        free(node->timestamp);
781                        node->timestamp = NULL;
782
783                        free(node->recpath);
784                        node->recpath = NULL;
785
786                        free(node->channellist);
787                        node->channellist = NULL;
788
789                        free(node->errstr);
790                        node->errstr = NULL;
791                       
792                        free(node->pincode);
793                        node->pincode = NULL;
794
795                        free(node);
796                        node = NULL;
797                        break;
798                }
799
800                prev = node;
801                node = node->next;
802        }
803
804        if(write == 1)
805                writerectimer(getconfig("rectimerfile", NULL), 1);
806
807        if(flag == 0)
808                m_unlock(&status.rectimermutex, 1);
809}
810
811void deloldrectimer()
812{
813        struct rectimer *node = rectimer, *prev = rectimer;
814
815        while(node != NULL)
816        {
817                prev = node;
818                node = node->next;
819                if(prev != NULL && checkrectimertime(prev) == 1)
820                        delrectimer(prev, 1, 0);
821        }
822}
823
824void freerectimer()
825{
826        struct rectimer *node = rectimer, *prev = rectimer;
827
828        while(node != NULL)
829        {
830                prev = node;
831                node = node->next;
832                if(prev != NULL)
833                        delrectimer(prev, 0, 0);
834        }
835}
836
837//flag 0: lock
838//flag 1: don't lock
839int writerectimer(const char *filename, int flag)
840{
841        FILE *fd = NULL;
842        struct rectimer *node = NULL;
843        int ret = 0;
844        char* type = NULL;
845        time_t curtime = time(NULL), rectime = 0x7FFFFFFF;
846
847        if(status.writerectimer == 0) return 0;
848
849        //check if rectimer loadet
850        if(status.rectimerthread == NULL || (status.rectimerthread != NULL && status.rectimerthread->delay == 1000))
851        {
852                err("can't write rectimer, not loaded yet");
853                return 1;
854        }
855
856        if(flag == 0) m_lock(&status.rectimermutex, 1);
857        sortrectimer();
858        node = rectimer;
859
860        fd = fopen(filename, "w");
861        if(fd == NULL)
862        {
863                if(flag == 0) m_unlock(&status.rectimermutex, 1);
864                status.writerectimer = 0;
865                perr("can't open %s", filename);
866                return 1;
867        }
868
869        while(node != NULL)
870        {
871                //don't write for del marked or old timers
872                if(checkrectimertime(node) == 1)
873                {
874                        node = node->next;
875                        continue;
876                }
877
878                if(node->name == NULL) node->name = ostrcat(node->name, NULL, 1, 0);
879                if(node->channellist == NULL) node->channellist = ostrcat(node->channellist, NULL, 1, 0);
880                if(node->errstr == NULL) node->errstr = ostrcat(node->errstr, NULL, 1, 0);
881                if(node->pincode == NULL) node->pincode = ostrcat(node->pincode, "0000", 1, 0);
882                if(node->recpath == NULL) node->recpath = ostrcat(node->recpath, NULL, 1, 0);
883                if(node->status == 0 || node->status == 1)
884                        type = "timer";
885                else if(node->status == 4 || node->status == 5)
886                        type = "epgscan";
887                else
888                        type = "log";
889
890                ret = fprintf(fd, "<%s begin=\"%lu\" end=\"%lu\" serviceid=\"%d\" transponderid=\"%llu\" channellist=\"%s\" repeated=\"%d\" name=\"%s\" afterevent=\"%d\" pincode=\"%s\" disabled=\"%d\" justplay=\"%d\", recpath=\"%s\", timestamp=\"%s\", status=\"%d\" errstr=\"%s\">\n</%s>\n", type, node->begin, node->end, node->serviceid, node->transponderid, node->channellist, node->repeate, node->name, node->afterevent, node->pincode, node->disabled, node->justplay, node->recpath, node->timestamp, node->status, node->errstr, type);
891
892                if(ret < 0)
893                {
894                        perr("writting file %s", filename);
895                }
896
897                //get wakeup time
898                if(node->status == 0 || node->status == 1 || node->status == 4)
899                {
900                        if(node->begin < rectime && node->begin > curtime)
901                                rectime = node->begin;
902                }
903                node = node->next;
904        }
905
906        fclose(fd);
907        //write wakeup time to proc
908        setwakeuptimerdev(rectime);
909        debugrectimer();
910
911        if(flag == 0) m_unlock(&status.rectimermutex, 1);
912
913        status.writerectimer = 0;
914        return 0;
915}
916
917int recrepeateget(int newnode, struct skin* repeate, struct skin* repeatetype, struct skin* day, struct skin* mon, struct skin* tue, struct skin* wed, struct skin* thur, struct skin* fri, struct skin* sat, struct skin* sun)
918{
919        unsigned char ret = 0;
920        int aktday = rectimergetaktday();
921
922        if(repeate == NULL) return 0;
923        if(repeatetype == NULL) return 0;
924
925        if(ostrcmp(repeate->ret, "0") == 0) return 0;
926
927        if(ostrcmp(repeatetype->ret, "0") == 0) return 127;
928        if(ostrcmp(repeatetype->ret, "1") == 0)
929        {
930                if(day->ret == NULL) return aktday;
931                if(ostrcmp(day->ret, "0") == 0)
932                {
933                        if(newnode == 1)
934                                return aktday;
935                        else
936                                return 1;
937                }
938                if(ostrcmp(day->ret, "1") == 0) return 2;
939                if(ostrcmp(day->ret, "2") == 0) return 4;
940                if(ostrcmp(day->ret, "3") == 0) return 8;
941                if(ostrcmp(day->ret, "4") == 0) return 16;
942                if(ostrcmp(day->ret, "5") == 0) return 32;
943                if(ostrcmp(day->ret, "6") == 0) return 64;
944        }
945        if(ostrcmp(repeatetype->ret, "2") == 0) return 31;
946        if(ostrcmp(repeatetype->ret, "3") == 0)
947        {
948                if(mon == NULL || tue == NULL || wed == NULL || thur == NULL || fri == NULL || sat == NULL || sun == NULL) return aktday;
949                if(ostrcmp(mon->ret, "1") == 0) ret = setbit(ret, 0);
950                if(ostrcmp(tue->ret, "1") == 0) ret = setbit(ret, 1);
951                if(ostrcmp(wed->ret, "1") == 0) ret = setbit(ret, 2);
952                if(ostrcmp(thur->ret, "1") == 0) ret = setbit(ret, 3);
953                if(ostrcmp(fri->ret, "1") == 0) ret = setbit(ret, 4);
954                if(ostrcmp(sat->ret, "1") == 0) ret = setbit(ret, 5);
955                if(ostrcmp(sun->ret, "1") == 0) ret = setbit(ret, 6);
956                if(ret == 0) ret = aktday;
957                return ret;
958        }
959
960        return 127;
961}
962
963void recjustplayhidden(int justplay, struct skin* end, struct skin* path, struct skin* after)
964{
965        if(justplay == 0)
966        {
967                end->hidden = NO;
968                path->hidden = NO;
969                after->hidden = NO;
970        }
971        else
972        {
973                end->hidden = YES;
974                path->hidden = YES;
975                after->hidden = YES;
976        }
977}
978
979int rectimergetaktday()
980{
981        int ret = 1;
982        struct tm* loctime = NULL;
983
984        time_t akttime = time(NULL);
985        loctime = olocaltime(&akttime);
986        if(loctime != NULL)
987        {
988                if(loctime->tm_wday == 0) ret = 64;
989                if(loctime->tm_wday == 1) ret = 1;
990                if(loctime->tm_wday == 2) ret = 2;
991                if(loctime->tm_wday == 3) ret = 4;
992                if(loctime->tm_wday == 4) ret = 8;
993                if(loctime->tm_wday == 5) ret = 16;
994                if(loctime->tm_wday == 6) ret = 32;
995        }
996        free(loctime); loctime = NULL;
997
998        return ret;
999}
1000
1001void recrepeatehidden(int repeate, struct skin* repeatetype, struct skin* day, struct skin* mon, struct skin* tue, struct skin* wed, struct skin* thur, struct skin* fri, struct skin* sat, struct skin* sun)
1002{
1003        repeatetype->hidden = YES;
1004        day->hidden = YES;
1005        mon->hidden = YES;
1006        tue->hidden = YES;
1007        wed->hidden = YES;
1008        thur->hidden = YES;
1009        fri->hidden = YES;
1010        sat->hidden = YES;
1011        sun->hidden = YES;
1012
1013        if(repeate == 0) return;
1014
1015        if(repeate == 127 && ostrcmp(repeatetype->ret, "3") != 0) //dayly
1016        {
1017                repeatetype->hidden = NO;
1018                setchoiceboxselection(repeatetype, "0");
1019                return;
1020        }
1021        if(repeate == 31 && ostrcmp(repeatetype->ret, "3") != 0) //workday
1022        {
1023                repeatetype->hidden = NO;
1024                setchoiceboxselection(repeatetype, "2");
1025                return;
1026        }
1027        if((repeate == 1 || repeate == 2 || repeate == 4 || repeate == 8 || repeate == 16 || repeate == 32 || repeate == 64) && ostrcmp(repeatetype->ret, "3") != 0) //weekly
1028        {
1029                repeatetype->hidden = NO;
1030                setchoiceboxselection(repeatetype, "1");
1031                day->hidden = NO;
1032                if(repeate == 1) setchoiceboxselection(day, "0");
1033                else if(repeate == 2) setchoiceboxselection(day, "1");
1034                else if(repeate == 4) setchoiceboxselection(day, "2");
1035                else if(repeate == 8) setchoiceboxselection(day, "3");
1036                else if(repeate == 16) setchoiceboxselection(day, "4");
1037                else if(repeate == 32) setchoiceboxselection(day, "5");
1038                else if(repeate == 64) setchoiceboxselection(day, "6");
1039                return;
1040        }
1041
1042        //user defined
1043        repeatetype->hidden = NO;
1044        setchoiceboxselection(repeatetype, "3");
1045        mon->hidden = NO;
1046        tue->hidden = NO;
1047        wed->hidden = NO;
1048        thur->hidden = NO;
1049        fri->hidden = NO;
1050        sat->hidden = NO;
1051        sun->hidden = NO;
1052        if(checkbit(repeate, 0) == 1) setchoiceboxselection(mon, "1");
1053        if(checkbit(repeate, 1) == 1) setchoiceboxselection(tue, "1");
1054        if(checkbit(repeate, 2) == 1) setchoiceboxselection(wed, "1");
1055        if(checkbit(repeate, 3) == 1) setchoiceboxselection(thur, "1");
1056        if(checkbit(repeate, 4) == 1) setchoiceboxselection(fri, "1");
1057        if(checkbit(repeate, 5) == 1) setchoiceboxselection(sat, "1");
1058        if(checkbit(repeate, 6) == 1) setchoiceboxselection(sun, "1");
1059}
1060
1061//flag 0: called from menu (manuel timer)
1062//flag 1: call from epg timer
1063void screenrectimerext(struct rectimer* node, int flag)
1064{
1065        int ret = 0, rcret = 0, edaylight = 0, bdaylight = 0, newnode = 0, tmpservicetype = 0, tmprepeate = 0;
1066        struct skin* rectimerext = getscreen("rectimerext");
1067        struct skin* listbox = getscreennode(rectimerext, "listbox");
1068        struct skin* name = getscreennode(rectimerext, "name");
1069        struct skin* justplay = getscreennode(rectimerext, "justplay");
1070        struct skin* repeate = getscreennode(rectimerext, "repeate");
1071        struct skin* repeatetype = getscreennode(rectimerext, "repeatetype");
1072        struct skin* day = getscreennode(rectimerext, "day");
1073        struct skin* mon = getscreennode(rectimerext, "mon");
1074        struct skin* tue = getscreennode(rectimerext, "tue");
1075        struct skin* wed = getscreennode(rectimerext, "wed");
1076        struct skin* thur = getscreennode(rectimerext, "thur");
1077        struct skin* fri = getscreennode(rectimerext, "fri");
1078        struct skin* sat = getscreennode(rectimerext, "sat");
1079        struct skin* sun = getscreennode(rectimerext, "sun");
1080        struct skin* begin = getscreennode(rectimerext, "begin");
1081        struct skin* end = getscreennode(rectimerext, "end");
1082        struct skin* recchannel = getscreennode(rectimerext, "channel");
1083        struct skin* path = getscreennode(rectimerext, "path");
1084        struct skin* after = getscreennode(rectimerext, "after");
1085        struct skin* pincode = getscreennode(rectimerext, "pincode");
1086        struct skin* tmp = NULL;
1087        char* tmpstr = NULL, *buf = NULL, *buf1 = NULL, *tmpchannellist = NULL;
1088        struct tm* loctime = NULL;
1089        time_t akttime = time(NULL);
1090
1091        if(node == NULL)
1092        {
1093                newnode = 1;
1094                node = addrectimernode(NULL, NULL);
1095                tmpservicetype = status.servicetype;
1096                if(tmpservicetype == 0)
1097                        tmpchannellist = ostrcat(getconfig("channellist", NULL), NULL, 0, 0);
1098                else
1099                        tmpchannellist = ostrcat(getconfig("rchannellist", NULL), NULL, 0, 0);
1100        }
1101        else
1102        {
1103                tmpservicetype = node->servicetype;
1104                tmpchannellist = ostrcat(node->channellist, NULL, 0, 0);
1105        }
1106
1107        if(node == NULL)
1108        {
1109                err("NULL detect");
1110                return;
1111        }
1112
1113        listbox->aktline = 1;
1114        listbox->aktpage = -1;
1115        begin->aktpage = 0;
1116        end->aktpage = 0;
1117        name->aktpage = 0;
1118       
1119        changeinput(name, node->name);
1120
1121        addchoicebox(justplay, "0", _("record"));
1122        addchoicebox(justplay, "1", _("switch channel"));
1123        if(newnode == 0)
1124        {
1125                tmpstr = oitoa(node->justplay);
1126                setchoiceboxselection(justplay, tmpstr);
1127                free(tmpstr); tmpstr = NULL;
1128        }
1129        else
1130                setchoiceboxselection(justplay, "0");
1131
1132        addchoicebox(repeate, "0", _("once"));
1133        addchoicebox(repeate, "1", _("repeate"));
1134        if(newnode == 0)
1135        {
1136                tmprepeate = node->repeate;
1137                if(node->repeate == 0)
1138                        setchoiceboxselection(repeate, "0");
1139                else
1140                        setchoiceboxselection(repeate, "1");
1141        }
1142        else
1143                setchoiceboxselection(repeate, "0");
1144
1145        addchoicebox(repeatetype, "0", _("daily"));
1146        addchoicebox(repeatetype, "1", _("weekly"));
1147        addchoicebox(repeatetype, "2", _("workdays"));
1148        addchoicebox(repeatetype, "3", _("user defined"));
1149        changeret(repeatetype, NULL);
1150        setchoiceboxselection(repeatetype, "0");
1151
1152        addchoicebox(day, "0", _("Monday"));
1153        addchoicebox(day, "1", _("Tuesday"));
1154        addchoicebox(day, "2", _("Wednesday"));
1155        addchoicebox(day, "3", _("Thursday"));
1156        addchoicebox(day, "4", _("Friday"));
1157        addchoicebox(day, "5", _("Saturday"));
1158        addchoicebox(day, "6", _("Sunday"));
1159        changeret(day, NULL);
1160        setchoiceboxselection(day, "0");
1161
1162        addchoicebox(mon, "0", _("no"));
1163        addchoicebox(mon, "1", _("yes"));
1164        changeret(mon, NULL);
1165        setchoiceboxselection(mon, "0");
1166
1167        addchoicebox(tue, "0", _("no"));
1168        addchoicebox(tue, "1", _("yes"));
1169        changeret(tue, NULL);
1170        setchoiceboxselection(tue, "0");
1171
1172        addchoicebox(wed, "0", _("no"));
1173        addchoicebox(wed, "1", _("yes"));
1174        changeret(wed, NULL);
1175        setchoiceboxselection(wed, "0");
1176
1177        addchoicebox(thur, "0", _("no"));
1178        addchoicebox(thur, "1", _("yes"));
1179        changeret(thur, NULL);
1180        setchoiceboxselection(thur, "0");
1181
1182        addchoicebox(fri, "0", _("no"));
1183        addchoicebox(fri, "1", _("yes"));
1184        changeret(fri, NULL);
1185        setchoiceboxselection(fri, "0");
1186
1187        addchoicebox(sat, "0", _("no"));
1188        addchoicebox(sat, "1", _("yes"));
1189        changeret(sat, NULL);
1190        setchoiceboxselection(sat, "0");
1191
1192        addchoicebox(sun, "0", _("no"));
1193        addchoicebox(sun, "1", _("yes"));
1194        changeret(sun, NULL);
1195        setchoiceboxselection(sun, "0");
1196
1197        recrepeatehidden(node->repeate, repeatetype, day, mon, tue, wed, thur, fri, sat, sun);
1198        recjustplayhidden(node->justplay, end, path, after);
1199
1200        buf = malloc(MINMALLOC);
1201        if(buf == NULL)
1202        {
1203                err("no memory");
1204                return;
1205        }
1206
1207        changemask(begin, "00:00 00-00-0000");
1208        if(newnode == 0)
1209                loctime = localtime(&node->begin);
1210        else
1211                loctime = localtime(&akttime);
1212        bdaylight = loctime->tm_isdst;
1213        strftime(buf, MINMALLOC, "%H:%M %d-%m-%Y", loctime);
1214        buf1 = ostrcat(buf, NULL, 0, 0);
1215        changeinput(begin, buf1);
1216        free(buf1); buf1 = NULL;
1217
1218        changemask(end, "00:00 00-00-0000");
1219        if(newnode == 0)
1220                loctime = localtime(&node->end);
1221        else
1222        {
1223                akttime += 300;
1224                loctime = localtime(&akttime);
1225        }
1226        edaylight = loctime->tm_isdst;
1227        strftime(buf, MINMALLOC, "%H:%M %d-%m-%Y", loctime);
1228        buf1 = ostrcat(buf, NULL, 1, 0);
1229        changeinput(end, buf1);
1230        free(buf1); buf1 = NULL;
1231
1232        if(flag == 1)
1233                recchannel->hidden = YES;
1234        else
1235                recchannel->hidden = NO;
1236
1237        changeinput(recchannel, NULL);
1238        if(newnode == 0)
1239        {
1240                recchannel->handle = (char*)getchannel(node->serviceid, node->transponderid);
1241                if(recchannel->handle != NULL)
1242                        addchoicebox(recchannel, ((struct channel*)recchannel->handle)->name, ((struct channel*)recchannel->handle)->name);
1243        }
1244        else
1245        {
1246                if(status.aktservice->channel != NULL)
1247                {
1248                        addchoicebox(recchannel, status.aktservice->channel->name, status.aktservice->channel->name);
1249                        recchannel->handle = (char*)status.aktservice->channel;
1250                }
1251        }
1252
1253        if(newnode == 0)
1254                changeinput(path, node->recpath);
1255        else
1256                changeinput(path, getconfig("rec_path", NULL));
1257
1258        addchoicebox(after, "0", _("auto"));
1259        addchoicebox(after, "1", _("nothing"));
1260        addchoicebox(after, "2", _("standby"));
1261        addchoicebox(after, "3", _("power off"));
1262        if(newnode == 0)
1263        {
1264                tmpstr = oitoa(node->afterevent);
1265                setchoiceboxselection(after, tmpstr);
1266                free(tmpstr); tmpstr = NULL;
1267        }
1268               
1269        changemask(pincode, "0000");
1270        if(newnode == 0)
1271                changeinput(pincode, node->pincode);
1272        else
1273                changeinput(pincode, "0000");
1274
1275        drawscreen(rectimerext, 0, 0);
1276        addscreenrc(rectimerext, listbox);
1277
1278        tmp = listbox->select;
1279        while(1)
1280        {
1281                addscreenrc(rectimerext, tmp);
1282                rcret = waitrc(rectimerext, 0, 2);
1283                tmp = listbox->select;
1284               
1285                if(rcret == getrcconfigint("rcred", NULL))
1286                {
1287                        if(name->ret != NULL && strlen(name->ret) > 0)
1288                        {
1289                                char* tmppath = NULL;
1290                               
1291                                tmppath = ostrcat(tmppath, name->ret, 1, 0);
1292                                tmppath = strstrip(tmppath);
1293                                delspezchar(tmppath, 2);
1294                                tmppath = ostrcat("/", tmppath, 0, 1);                         
1295                                tmppath = ostrcat(getconfig("rec_path", NULL), tmppath, 0, 1);
1296                               
1297                                if(tmppath != NULL && mkdir(tmppath, 0777) == 0)
1298                                {
1299                                        changeinput(path, tmppath);
1300                                        changetext(path, tmppath);
1301                                }
1302                                else
1303                                        textbox(_("Message"), "Can't create Path", _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1304                               
1305                                drawscreen(rectimerext, 0, 0);
1306                                free(tmppath); tmppath = NULL;
1307                        }
1308                        continue;
1309                }
1310
1311                if(listbox->select != NULL && listbox->select->ret != NULL && ostrcmp(listbox->select->name, "justplay") == 0)
1312                {
1313                        recjustplayhidden(atoi(listbox->select->ret), end, path, after);
1314                }
1315
1316                tmprepeate = recrepeateget(newnode, repeate, repeatetype, day, mon, tue, wed, thur, fri, sat, sun);
1317                if(listbox->select != NULL && (ostrcmp(listbox->select->name, "repeate") == 0 || ostrcmp(listbox->select->name, "repeatetype") == 0))
1318                {
1319                        recrepeatehidden(tmprepeate, repeatetype, day, mon, tue, wed, thur, fri, sat, sun);
1320                }
1321                drawscreen(rectimerext, 0, 0);
1322
1323                if(rcret == getrcconfigint("rcexit", NULL))
1324                {
1325                        if(newnode == 1 || flag == 1) delrectimer(node, 1, 0);
1326                        break;
1327                }
1328                if(rcret == getrcconfigint("rcok", NULL))
1329                {
1330                        if(listbox->select != NULL && ostrcmp(listbox->select->name, "path") == 0)
1331                        {
1332                                clearscreen(rectimerext);
1333                                tmpstr = screendir(listbox->select->ret, "", NULL, NULL, NULL, NULL, 0, "SELECT", 0, NULL, 0, NULL, 0, 700, 0, 650, 0, 0);
1334                                if(tmpstr != NULL)
1335                                        changeinput(listbox->select, tmpstr);
1336                                free(tmpstr); tmpstr = NULL;
1337
1338                                drawscreen(rectimerext, 0, 0);
1339                                continue;
1340                        }
1341                        if(listbox->select != NULL && ostrcmp(listbox->select->name, "channel") == 0)
1342                        {
1343                                clearscreen(rectimerext);
1344                                int saveservicetype = status.servicetype;
1345                                struct channel* tmpchnode = (struct channel*)recchannel->handle;
1346
1347                                status.servicetype = tmpservicetype;
1348                                if(tmpservicetype == 0)
1349                                {
1350                                        addconfigtmp("channellist", tmpchannellist);
1351                                        if(tmpchnode != NULL)
1352                                        {
1353                                                addconfiginttmp("serviceid", tmpchnode->serviceid);
1354                                                addconfigllutmp("transponderid", tmpchnode->transponderid);
1355                                        }
1356                                }
1357                                else
1358                                {
1359                                        addconfigtmp("rchannellist", tmpchannellist);
1360                                        if(tmpchnode != NULL)
1361                                        {
1362                                                addconfiginttmp("rserviceid", tmpchnode->serviceid);
1363                                                addconfigllutmp("rtransponderid", tmpchnode->transponderid);
1364                                        }
1365                                }
1366
1367                                screenchannellist(&tmpchnode, &tmpchannellist, 1);
1368
1369                                recchannel->handle = (char*)tmpchnode;
1370
1371                                status.servicetype = saveservicetype;
1372                                delconfigtmp("channellist");
1373                                delconfigtmp("rchannellist");
1374                                delconfigtmp("serviceid");
1375                                delconfigtmp("rserviceid");
1376                                delconfigtmp("transponderid");
1377                                delconfigtmp("rtransponderid");
1378
1379                                if((struct channel*)recchannel->handle != NULL)
1380                                {
1381                                        changeinput(listbox->select, ((struct channel*)recchannel->handle)->name);
1382                                }
1383
1384                                drawscreen(rectimerext, 0, 0);
1385                                continue;
1386                        }
1387
1388                        free(node->name); node->name = NULL;
1389                        node->name = ostrcat(name->ret, NULL, 0, 0);
1390                        if(justplay->ret != NULL)
1391                                node->justplay = atoi(justplay->ret);
1392                        if(begin->ret != NULL)
1393                        {
1394                                loctime->tm_isdst = bdaylight;
1395                                tmpstr = strptime(begin->ret, "%H:%M %d-%m-%Y", loctime);
1396                                if(tmpstr != NULL)
1397                                        node->begin = mktime(loctime);
1398
1399                                if((flag == 1 || newnode == 1) && node->justplay == 0)
1400                                        node->begin -= getconfigint("recforerun", NULL) * 60;
1401
1402                                node->begin -= (node->begin % 60);
1403
1404                                if(node->justplay == 1)
1405                                        node->end = node->begin + 1;
1406                        }
1407                        if(end->ret != NULL && node->justplay == 0)
1408                        {
1409                                loctime->tm_isdst = edaylight;
1410                                tmpstr = strptime(end->ret, "%H:%M %d-%m-%Y", loctime);
1411                                if(tmpstr != NULL)
1412                                        node->end = mktime(loctime);
1413
1414                                if((flag == 1 || newnode == 1) && node->justplay == 0)
1415                                        node->end += getconfigint("recoverrun", NULL) * 60;
1416                                node->end -= (node->end % 60);
1417                        }
1418                        if(after->ret != NULL)
1419                                node->afterevent = atoi(after->ret);
1420                               
1421                        if(pincode->ret != NULL)
1422                                node->pincode = ostrcat(pincode->ret, NULL, 0, 0);
1423                        else
1424                                node->pincode = ostrcat("0000", NULL, 0, 0);
1425
1426                        if(tmprepeate > 127) tmprepeate = 0;
1427                        node->repeate = tmprepeate;
1428
1429                        free(node->recpath); node->recpath = NULL;
1430                        node->recpath = ostrcat(path->ret, NULL, 0, 0);
1431
1432                        free(node->channellist); node->channellist = NULL;
1433                        node->channellist = tmpchannellist;
1434
1435                        node->servicetype = tmpservicetype;
1436
1437                        if(recchannel->handle != NULL)
1438                        {
1439                                node->serviceid = ((struct channel*)recchannel->handle)->serviceid;
1440                                node->transponderid = ((struct channel*)recchannel->handle)->transponderid;
1441                        }
1442
1443                        char* checkret = NULL;
1444                        ret = checkrectimeradd(node, &checkret);
1445                        if(ret != 0)
1446                        {
1447                                if(ret == 2)
1448                                {
1449                                        ret = textbox(_("Message"), checkret, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1450                                        if(ret == 2)
1451                                                ret = 99;
1452                                        else
1453                                                ret = 0;
1454                                }
1455                                if(ret == 1 || ret == 99)
1456                                {
1457                                        node->status = 3;
1458                                        free(node->errstr); node->errstr = NULL;
1459                                        node->errstr = ostrcat(checkret, NULL, 0, 0);
1460                                        stringreplacecharonce(node->errstr, '\n', '\0');
1461                                        if(ret == 1) textbox(_("Message"), checkret, _("OK"), getrcconfigint("rcok", NULL), _("EXIT"), getrcconfigint("rcexit", NULL), NULL, 0, NULL, 0, 600, 200, 0, 0);
1462                                }
1463                        }
1464
1465                        //check if record is running and change endtime
1466                        m_lock(&status.servicemutex, 2);
1467                        struct service* tmpservice = getservicebyrectimestamp(node->timestamp, 1);
1468                        if(tmpservice != NULL)
1469                                tmpservice->recendtime = node->end;
1470                        m_unlock(&status.servicemutex, 2);
1471                               
1472                        if(newnode == 1 || flag == 1) node->disabled = 0;
1473                        status.writerectimer = 1;
1474                        writerectimer(getconfig("rectimerfile", NULL), 0);
1475                        break;
1476                }
1477        }
1478
1479        if(flag == 1) resettvpic();
1480
1481        delownerrc(rectimerext);
1482        clearscreen(rectimerext);
1483}
1484
1485//flag 0: show normal
1486//flag 1: show log
1487void screenrectimer()
1488{
1489        int rcret = 0, flag = 0;
1490        struct skin* recordtimer = getscreen("rectimer");
1491        struct skin* listbox = getscreennode(recordtimer, "listbox");
1492        struct skin* b1 = getscreennode(recordtimer, "b1");
1493        struct skin* b2 = getscreennode(recordtimer, "b2");
1494        struct skin* b3 = getscreennode(recordtimer, "b3");
1495        struct skin* b4 = getscreennode(recordtimer, "b4");
1496        struct skin* tmp = NULL;
1497        struct rectimer* rectimernode = NULL;
1498        struct tm *loctime = NULL;
1499        struct channel* chnode = NULL;
1500        char* buf = NULL, *tmpstr = NULL;
1501
1502        buf = malloc(MINMALLOC);
1503        if(buf == NULL)
1504        {
1505                err("no memory");
1506                return;
1507        }
1508
1509start:
1510        deloldrectimer();
1511
1512        tmp = NULL;
1513        listbox->aktpage = -1;
1514        listbox->select = NULL;
1515        rectimernode = rectimer;
1516
1517        while(rectimernode != NULL)
1518        {
1519                if((flag == 0 && (rectimernode->status == 2 || rectimernode->status == 3)) || (flag == 1 && (rectimernode->status == 0 || rectimernode->status == 1)) || rectimernode->status == 4 || rectimernode->status == 5)
1520                {
1521                        rectimernode = rectimernode->next;
1522                        continue;
1523                }
1524
1525                tmp = addlistbox(recordtimer, listbox, tmp, 1);
1526                if(tmp != NULL)
1527                {
1528                        loctime = localtime(&rectimernode->begin);
1529                        strftime(buf, MINMALLOC, "%d-%m-%Y %H:%M", loctime);
1530                        tmpstr = ostrcat(tmpstr, buf, 1, 0);
1531                        if(rectimernode->justplay == 0)
1532                        {
1533                                tmpstr = ostrcat(tmpstr, " - ", 1, 0);
1534                                loctime = localtime(&rectimernode->end);
1535                                strftime(buf, MINMALLOC, "%d-%m-%Y %H:%M", loctime);
1536                                tmpstr = ostrcat(tmpstr, buf, 1, 0);
1537                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1538                                tmpstr = ostrcat(tmpstr, _("rec"), 1, 0);
1539                                tmpstr = ostrcat(tmpstr, " - ", 1, 0);
1540                                if(rectimernode->repeate == 0)
1541                                        tmpstr = ostrcat(tmpstr, _("once"), 1, 0);
1542                                else
1543                                        tmpstr = ostrcat(tmpstr, _("repeate"), 1, 0);
1544                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1545                        }
1546                        else
1547                        {
1548                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1549                                tmpstr = ostrcat(tmpstr, _("switch"), 1, 0);
1550                                tmpstr = ostrcat(tmpstr, " - ", 1, 0);
1551                                if(rectimernode->repeate == 0)
1552                                        tmpstr = ostrcat(tmpstr, _("once"), 1, 0);
1553                                else
1554                                        tmpstr = ostrcat(tmpstr, _("repeate"), 1, 0);
1555                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1556                        }
1557
1558                        tmpstr = ostrcat(tmpstr, "\n", 1, 0);
1559                        if(rectimernode->name != NULL)
1560                        {
1561                                if(rectimernode->name == NULL || strlen(rectimernode->name) == 0)
1562                                        tmpstr = ostrcat(tmpstr, "---", 1, 0);
1563                                else
1564                                        tmpstr = ostrcat(tmpstr, rectimernode->name, 1, 0);
1565                        }
1566                        chnode = getchannel(rectimernode->serviceid, rectimernode->transponderid);
1567                        if(chnode != NULL && chnode->name != NULL && strlen(chnode->name) > 0)
1568                        {
1569                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1570                                tmpstr = ostrcat(tmpstr, chnode->name, 1, 0);
1571                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1572                        }
1573
1574                        tmpstr = ostrcat(tmpstr, "\n", 1, 0);
1575                        if(rectimernode->status == 0)
1576                                tmpstr = ostrcat(tmpstr, _("waiting"), 1, 0);
1577                        else if(rectimernode->status == 1)
1578                                tmpstr = ostrcat(tmpstr, _("running"), 1, 0);
1579                        else if(rectimernode->status == 2)
1580                                tmpstr = ostrcat(tmpstr, _("success"), 1, 0);
1581                        else if(rectimernode->status == 3)
1582                                tmpstr = ostrcat(tmpstr, _("error"), 1, 0);
1583
1584                        if(flag == 1 && rectimernode->errstr != NULL && strlen(rectimernode->errstr) != 0)
1585                        {
1586                                tmpstr = ostrcat(tmpstr, " (", 1, 0);
1587                                tmpstr = ostrcat(tmpstr, rectimernode->errstr, 1, 0);
1588                                tmpstr = ostrcat(tmpstr, ")", 1, 0);
1589                        }
1590                       
1591                        changetext(tmp, tmpstr);
1592                        free(tmpstr); tmpstr = NULL;
1593                        tmp->handle = (char*)rectimernode;
1594                        tmp->height = 110;
1595                        tmp->type = TEXTBOX;
1596
1597                        if(rectimernode->disabled == 1)
1598                                tmp->fontcol = convertcol("deaktivcol");
1599                }
1600                rectimernode = rectimernode->next;
1601        }
1602
1603        if(flag == 0)
1604        {
1605                b1->hidden = NO;
1606                b2->hidden = NO;
1607                b3->hidden = NO;
1608                b4->hidden = NO;
1609        }
1610        else
1611        {
1612                b1->hidden = YES;
1613                b2->hidden = YES;
1614                b3->hidden = YES;
1615                b4->hidden = YES;
1616        }
1617
1618        drawscreen(recordtimer, 0, 0);
1619        addscreenrc(recordtimer, listbox);
1620
1621        while(1)
1622        {
1623                rcret = waitrc(recordtimer, 5000, 0);
1624
1625                if(flag == 0 && rcret == getrcconfigint("rcblue", NULL))
1626                {
1627                        flag = 1;
1628                        delmarkedscreennodes(recordtimer, 1);
1629                        goto start;
1630                }
1631                if(rcret == getrcconfigint("rcexit", NULL))
1632                {
1633                        if(flag == 0)
1634                                break;
1635                        else
1636                        {
1637                                flag = 0;
1638                                delmarkedscreennodes(recordtimer, 1);
1639                                goto start;
1640                        }
1641                }
1642                if(flag == 0 && rcret == getrcconfigint("rcgreen", NULL))
1643                {
1644                        clearscreen(recordtimer);
1645                        screenrectimerext(NULL, 0);
1646                        delmarkedscreennodes(recordtimer, 1);
1647                        goto start;
1648                }
1649                if(flag == 0 && listbox->select != NULL)
1650                {
1651                        if(rcret == getrcconfigint("rcok", NULL))
1652                        {
1653                                clearscreen(recordtimer);
1654                                screenrectimerext((struct rectimer*)listbox->select->handle, 0);
1655                                delmarkedscreennodes(recordtimer, 1);
1656                                goto start;
1657                        }
1658                        if(rcret == getrcconfigint("rcred", NULL))
1659                        {
1660                                delrectimer((struct rectimer*)listbox->select->handle, 1, 0);
1661                               
1662                                delmarkedscreennodes(recordtimer, 1);
1663                                goto start;
1664                        }
1665                        if(rcret == getrcconfigint("rcyellow", NULL))
1666                        {
1667                                if(((struct rectimer*)listbox->select->handle)->disabled == 1)
1668                                        ((struct rectimer*)listbox->select->handle)->disabled = 0;
1669                                else
1670                                        ((struct rectimer*)listbox->select->handle)->disabled = 1;
1671
1672                                delmarkedscreennodes(recordtimer, 1);
1673                                goto start;
1674                        }
1675                        if(rcret == RCTIMEOUT)
1676                        {
1677                                delmarkedscreennodes(recordtimer, 1);
1678                                goto start;
1679                        }
1680                }
1681        }
1682
1683        free(buf); buf = NULL;
1684        delmarkedscreennodes(recordtimer, 1);
1685        delownerrc(recordtimer);
1686        clearscreen(recordtimer);
1687}
1688
1689int addrecepg(struct channel* chnode, struct epg* epgnode, char* channellist)
1690{
1691        struct rectimer* node = NULL;
1692
1693        deloldrectimer();
1694
1695        if(chnode == NULL || epgnode == NULL)
1696                return 1;
1697
1698        node = addrectimernode(NULL, NULL);
1699        if(node != NULL)
1700        {
1701                node->name = ostrcat(epgnode->title, NULL, 0, 0);
1702                node->begin = epgnode->starttime;
1703                node->end = epgnode->endtime;
1704
1705                node->repeate = 0;
1706
1707                node->recpath = ostrcat(getconfig("rec_path", NULL), NULL, 0, 0);
1708                node->servicetype = status.servicetype;
1709                if(node->servicetype == 0)
1710                {
1711                        if(channellist == NULL)
1712                                node->channellist = ostrcat(getconfig("channellist", NULL), NULL, 0, 0);
1713                        else
1714                                node->channellist = ostrcat(channellist, NULL, 0, 0);
1715                }
1716                else
1717                {
1718                        if(channellist == NULL)
1719                                node->channellist = ostrcat(getconfig("rchannellist", NULL), NULL, 0, 0);
1720                        else
1721                                node->channellist = ostrcat(channellist, NULL, 0, 0);
1722                }
1723                node->serviceid = chnode->serviceid;
1724                node->transponderid = chnode->transponderid;
1725                screenrectimerext(node, 1);
1726        }
1727
1728        return 0;
1729}
1730
1731#endif
Note: See TracBrowser for help on using the repository browser.