]> git.vomp.tv Git - vompclient.git/blob - vdr.cc
Fix removeAll in BoxStack
[vompclient.git] / vdr.cc
1 /*
2     Copyright 2004-2005 Chris Tallon
3
4     This file is part of VOMP.
5
6     VOMP is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     VOMP is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with VOMP; if not, write to the Free Software
18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19 */
20
21 #include "vdr.h"
22
23 #include "recman.h"
24 #include "tcp.h"
25 #include "log.h"
26 #include "recinfo.h"
27 #include "dsock.h"
28 #include "channel.h"
29 #include "event.h"
30 #include "wol.h"
31 #include "vdrrequestpacket.h"
32 #include "vdrresponsepacket.h"
33 #include "command.h"
34
35 VDR* VDR::instance = NULL;
36
37 VDR::VDR()
38 {
39   if (instance) return;
40   instance = this;
41   initted = 0;
42   findingServer = 0;
43   tcp = NULL;
44   connected = false;
45   maxChannelNumber = 0;
46   channelNumberWidth = 1;
47   TEMP_SINGLE_VDR_PR = NULL;
48 }
49
50 VDR::~VDR()
51 {
52   instance = NULL;
53   if (initted) shutdown();
54 }
55
56 VDR* VDR::getInstance()
57 {
58   return instance;
59 }
60
61 int VDR::init(int tport)
62 {
63   if (initted) return 0;
64   initted = 1;
65   port = tport;
66   logger = Log::getInstance();
67   return 1;
68 }
69
70 int VDR::shutdown()
71 {
72   if (!initted) return 0;
73   initted = 0;
74   disconnect();
75   return 1;
76 }
77
78 void VDR::findServers(vector<VDRServer>& servers)
79 {
80   Wol* wol = Wol::getInstance();
81   findingServer = 1;
82   char* message = "VOMP";
83
84   DatagramSocket ds(port);
85   int haveAtLeastOne = 0;
86   int retval;
87   int waitType = 1;
88   bool firstloop = true;
89   while(findingServer)
90   {
91     if (waitType == 1)
92     {
93       ds.shutdown();
94       ds.init();
95       logger->log("VDR", Log::NOTICE, "Broadcasting for server");
96       ds.send("255.255.255.255", 3024, message, strlen(message));
97       if(!firstloop) wol->doWakeUp();
98     }
99     retval = ds.waitforMessage(waitType);
100
101     if (retval == 2) // we got a reply
102     {
103       if (!strcmp(ds.getData(), "VOMP")) // echo.....
104       {
105         waitType = 2;
106       }
107       else
108       {
109         VDRServer newServer;
110         newServer.ip = new char[16];
111         strcpy(newServer.ip, ds.getFromIPA());
112
113         if (ds.getDataLength() == 0)
114         {
115           newServer.name = new char[1];
116           newServer.name[0] = '\0';
117         }
118         else
119         {
120           newServer.name = new char[strlen(ds.getData())+1];
121           strcpy(newServer.name, ds.getData());
122         }
123
124         servers.push_back(newServer);
125         waitType = 2;
126         haveAtLeastOne = 1;
127       }
128     }
129     else
130     {
131       if (haveAtLeastOne) break;
132       waitType = 1;
133       firstloop = false;
134     }
135   }
136   sort(servers.begin(), servers.end(), ServerSorter());
137 }
138
139 void VDR::cancelFindingServer()
140 {
141   findingServer = 0;
142 }
143
144 void VDR::setServerIP(char* newIP)
145 {
146   strcpy(serverIP, newIP);
147 }
148
149 int VDR::connect()
150 {
151   maxChannelNumber = 0;
152   channelNumberWidth = 1;
153
154   if (tcp) delete tcp;
155   tcp = new TCP();
156   if (tcp->connectTo(serverIP, 3024))
157   {
158     connected = true;
159     threadStart();
160     return 1;
161   }
162   else
163   {
164     return 0;
165   }
166 }
167
168 void VDR::disconnect()
169 {
170   threadCancel();
171   if (tcp) delete tcp;
172   tcp = NULL;
173   connected = false;
174   logger->log("VDR", Log::DEBUG, "Disconnect");
175 }
176
177 void VDR::setReceiveWindow(size_t size)
178 {
179   if (connected) tcp->setReceiveWindow(size);
180 }
181
182 ///////////////////////////////////////////////////////
183
184 void VDR::threadMethod()
185 {
186   logger->log("VDR", Log::DEBUG, "VDR RUN");  
187
188   threadSetKillable(); // FIXME - change this to deal with the EDRs
189   
190   ULONG channelID;
191   
192   ULONG requestID;
193   ULONG userDataLength;
194   UCHAR* userData;
195
196   ULONG streamID;
197   ULONG flag;
198
199   VDR_ResponsePacket* vresp;
200   
201   ULONG timeNow = 0;
202   ULONG lastKAsent = 0;
203   ULONG lastKArecv = time(NULL);
204   int readSuccess;
205
206   while(1) 
207   {
208     timeNow = time(NULL);
209     
210     readSuccess = tcp->readData((UCHAR*)&channelID, sizeof(ULONG));  // 2s timeout atm
211
212     if (!readSuccess)
213     {
214       logger->log("VDR", Log::DEBUG, "Net read timeout");
215       if (!tcp->isConnected()) { connectionDied(); return; } // return to stop this thread
216     }
217       
218     // Error or timeout.
219
220     /* This is the simple version of timeout system until I work out how to make it better
221        e.g. different timeout lengths for different requests, a decent keepalive system
222        running in parallel etc etc.
223       
224        Ignore the stream channel
225        Start with lastPacketReceived = 0
226        When a packet comes in, set lastPacketReceived = time(NULL)
227        loop
228        {
229          if last packet is over 20s ago
230          {
231            if lastKAsent is less than 20s ago, continue
232            
233            if lastKAsent = 0, send a KA, continue
234            
235            if lastKAsent is over 20s ago, connection is dead, kill it
236          }
237        }         
238     */
239
240     if (!lastKAsent) // have not sent a KA
241     {
242       if (lastKArecv < (timeNow - 5))
243       {
244         logger->log("VDR", Log::DEBUG, "Sending KA packet");
245         if (!sendKA(timeNow))
246         {
247           logger->log("VDR", Log::DEBUG, "Could not send KA, calling connectionDied");
248           connectionDied();
249           return;
250         }
251         lastKAsent = timeNow;
252       }
253     }
254     else
255     {
256       if (lastKAsent <= (timeNow - 10))
257       {
258         logger->log("VDR", Log::DEBUG, "lastKA over 10s ago, calling connectionDied");
259         connectionDied();
260         return;
261       }    
262     }
263
264     if (!readSuccess) continue; // no data was read but the connection is ok.
265     
266     // Data was read
267             
268     channelID = ntohl(channelID);
269    
270     if (channelID == CHANNEL_REQUEST_RESPONSE)
271     {
272       if (!tcp->readData((UCHAR*)&requestID, sizeof(ULONG))) break;
273       requestID = ntohl(requestID);
274       if (!tcp->readData((UCHAR*)&userDataLength, sizeof(ULONG))) break;
275       userDataLength = ntohl(userDataLength);
276       if (userDataLength > 5000000) break; // how big can these packets get?
277       userData = NULL;
278       if (userDataLength > 0)
279       {
280         userData = (UCHAR*)malloc(userDataLength);
281         if (!userData) break;
282         if (!tcp->readData(userData, userDataLength)) break;
283       }
284
285       vresp = new VDR_ResponsePacket();  
286       vresp->setResponse(requestID, userData, userDataLength);
287       logger->log("VDR", Log::DEBUG, "Rxd a response packet, requestID=%lu, len=%lu", requestID, userDataLength);
288
289       if (!edFindAndCall(vresp)) // makes ED lock, find receiver for vresp (using ed_cb_find() ) and then call (using ed_cb_call() )
290       {
291         // If edFindAndCall returns true, edr was called and vresp was handed off.
292         // else, delete vresp here.
293         delete vresp;
294       }
295     }
296     else if (channelID == CHANNEL_STREAM)
297     {
298       if (!tcp->readData((UCHAR*)&streamID, sizeof(ULONG))) break;
299       streamID = ntohl(streamID);
300
301       if (!tcp->readData((UCHAR*)&flag, sizeof(ULONG))) break;
302       flag = ntohl(flag);
303
304       if (!tcp->readData((UCHAR*)&userDataLength, sizeof(ULONG))) break; 
305       userDataLength = ntohl(userDataLength);
306       userData = NULL;
307       if (userDataLength > 0)
308       {
309         userData = (UCHAR*)malloc(userDataLength);
310         if (!userData) break;
311         if (!tcp->readData(userData, userDataLength)) break;
312       }
313
314       vresp = new VDR_ResponsePacket();    
315       vresp->setStream(streamID, flag, userData, userDataLength);
316 //      logger->log("VDR", Log::DEBUG, "Rxd a stream packet, streamID=%lu, flag=%lu, len=%lu", streamID, flag, userDataLength);
317
318       if (!edFindAndCall(vresp)) // makes ED lock, find receiver for vresp (using ed_cb_find() ) and then call (using ed_cb_call() )
319       {
320         // If edFindAndCall returns true, edr was called and vresp was handed off.
321         // else, delete vresp here.
322         delete vresp;
323       }
324     }
325     else if (channelID == CHANNEL_KEEPALIVE)
326     {
327       ULONG KAreply = 0;
328       if (!tcp->readData((UCHAR*)&KAreply, sizeof(ULONG))) break;
329       KAreply = (ULONG)ntohl(KAreply);
330       if (KAreply == lastKAsent) // successful KA response
331       {
332         lastKAsent = 0;
333         lastKArecv = KAreply;
334         logger->log("VDR", Log::DEBUG, "Rxd correct KA reply");
335       }
336     }
337     else
338     {
339       logger->log("VDR", Log::ERR, "Rxd a response packet on channel %lu !!", channelID);
340       break;
341     }
342
343     // Who deletes vresp?
344     // If RR, the individual protocol functions must delete vresp.
345     // If stream, the data and length is taken out in ed_cb_call and vresp is deleted there.
346   }
347  
348   connectionDied();
349 }
350
351 void VDR::connectionDied()
352 {
353   // Called from within threadMethod to do cleanup if it decides the connection has died
354
355   connected = false; // though actually it could still be connected until someone calls vdr->disconnect
356
357   // Need to wake up any waiting channel 1 request-response threads
358   // Normally this is done by a packet coming in with channelid and requestid      
359   // Instead, go through the list and for each channel 1 edr, make an empty vresp
360   // An empty vresp will have userData == NULL, which means vresp->noResponse() == true
361
362   // If it's a stream receiver, generate a stream packet with flag == connection_lost
363
364   edLock();
365   VDR_PacketReceiver* vdrpr;
366   VDR_ResponsePacket* vresp;
367   while(receivers.size())
368   {
369     vdrpr = (VDR_PacketReceiver*) *(receivers.begin());
370     if (vdrpr->receiverChannel == CHANNEL_REQUEST_RESPONSE)
371     {
372       vresp = new VDR_ResponsePacket();
373       vresp->setResponse(vdrpr->requestSerialNumber, NULL, 0);
374       logger->log("VDR", Log::DEBUG, "Timeouts: created blank response packet for request serial %lu", vdrpr->requestSerialNumber);
375       edUnlock();
376       if (!edFindAndCall(vresp)) // makes ED lock, find receiver for vresp (using ed_cb_find() ) and then call (using ed_cb_call() )
377       {
378         // If edFindAndCall returns true, edr was called and vresp was handed off.
379         // else, delete vresp here.
380         logger->log("VDR", Log::ERR, "Timeouts: no waiting thread found for request serial %lu !!!", vdrpr->requestSerialNumber);
381         delete vresp;
382       }
383       edLock();
384     }
385     else if (vdrpr->receiverChannel == CHANNEL_STREAM)
386     {
387       vresp = new VDR_ResponsePacket();
388       vresp->setStream(vdrpr->streamID, 2 /* connection-lost flag */ , NULL, 0);
389       logger->log("VDR", Log::DEBUG, "Timeouts: created blank response packet for streamid %lu", vdrpr->streamID);
390       edUnlock();
391       if (!edFindAndCall(vresp)) // makes ED lock, find receiver for vresp (using ed_cb_find() ) and then call (using ed_cb_call() )
392       {
393         // If edFindAndCall returns true, edr was called and vresp was handed off.
394         // else, delete vresp here.
395         logger->log("VDR", Log::ERR, "Timeouts: no waiting stream receiver found for streamid %lu !!!", vdrpr->streamID);
396         delete vresp;
397       }
398       edLock();
399       
400       for(EDRL::iterator i = receivers.begin(); i != receivers.end(); i++)
401         if ((VDR_PacketReceiver*)*i == vdrpr) { receivers.erase(i); break; }
402     }
403   }
404   edUnlock();
405   // Ok, all event receviers should be dealt with. just in case there weren't any, inform command
406   logger->log("VDR", Log::DEBUG, "edUnlock at end of connectionDied");
407
408   Command::getInstance()->connectionLost();
409 }
410
411 bool VDR::ed_cb_find(EDReceiver* edr, void* userTag)
412 {
413   // edr is a VDR_PacketReceiver object made in VDR::RequestResponse
414   // userTag is a VDR_ResponsePacket made in threadMethod
415
416   VDR_PacketReceiver* vdrpr = (VDR_PacketReceiver*)edr;
417   VDR_ResponsePacket* vresp = (VDR_ResponsePacket*)userTag;
418   
419   // Is vresp for vdrpr ?
420   
421   ULONG packetChannel = vresp->getChannelID();
422   if (vdrpr->receiverChannel != packetChannel) return false;
423
424   if (packetChannel == CHANNEL_REQUEST_RESPONSE)
425   {
426     if (vdrpr->requestSerialNumber == vresp->getRequestID()) return true;
427   }
428   else if (packetChannel == CHANNEL_STREAM)
429   {
430     if (vdrpr->streamID == vresp->getStreamID()) return true;
431   }
432  
433   return false;
434 }
435
436 VDR_ResponsePacket* VDR::RequestResponse(VDR_RequestPacket* vrp)
437 {
438   logger->log("VDR", Log::DEBUG, "RR %lu", vrp->getOpcode());
439
440   if (!connected)
441   {
442     logger->log("VDR", Log::DEBUG, "RR when !connected");
443     VDR_ResponsePacket* vresp = new VDR_ResponsePacket();
444     return vresp; // "no-response" return
445   }
446
447   // ED make new VDR and register
448   // make a VDR_PacketReceiver
449   // - init with serial number of request packet
450
451   VDR_PacketReceiver vdrpr;
452 //  vdrpr.requestTime = time(NULL);
453   vdrpr.receiverChannel = VDR::CHANNEL_REQUEST_RESPONSE;
454   vdrpr.requestSerialNumber = vrp->getSerial();
455
456   edRegister(&vdrpr);
457    
458   edLock();  
459
460   if ((ULONG)tcp->sendData(vrp->getPtr(), vrp->getLen()) != vrp->getLen())
461   {
462     edUnlock();
463     edUnregister(&vdrpr);
464     VDR_ResponsePacket* vresp = new VDR_ResponsePacket();
465     return vresp; // "no-response" return
466   }
467
468   // Sleep and block this thread. The sleep unlocks the mutex
469   logger->log("VDR", Log::DEBUG, "RR sleep");
470   edSleepThisReceiver(&vdrpr);
471   logger->log("VDR", Log::DEBUG, "RR unsleep");
472     
473   // Woken because a response packet has arrived, mutex will be locked
474   
475   edUnlock();
476   return vdrpr.save_vresp;
477 }
478
479 bool VDR::sendKA(ULONG timeStamp)
480 {
481   char buffer[8];
482   *(ULONG*)&buffer[0] = htonl(CHANNEL_KEEPALIVE);
483   *(ULONG*)&buffer[4] = htonl(timeStamp);
484   if ((ULONG)tcp->sendData(buffer, 8) != 8) return false;
485   return true;
486 }
487
488 /////////////////////////////////////////////////////////////////////////////
489
490 // Here VDR takes a break for the VDR_PacketReceiver helper class
491
492 bool VDR_PacketReceiver::call(void* userTag)
493 {
494   if (receiverChannel == VDR::CHANNEL_REQUEST_RESPONSE)
495   {
496     // It's a RR. Save vresp and, signal the waiting thread and return.
497     // VDR::RequestResponse will be blocking waiting for this to happen.
498     // That function has a pointer to this object and can read save_vresp.
499     save_vresp = (VDR_ResponsePacket*)userTag;
500     return true; // Signals ED to remove edr from receivers and wake up edr thread
501   }
502   
503   if (receiverChannel == VDR::CHANNEL_STREAM)
504   {
505     // It's a stream packet.
506     VDR_ResponsePacket* vresp = (VDR_ResponsePacket*)userTag;
507     streamReceiver->streamReceive(vresp->getFlag(), vresp->getUserData(), vresp->getUserDataLength());
508     delete vresp;
509     return false;
510   }
511
512   abort(); // unknown receiverChannel, should not happen
513 }
514
515 /////////////////////////////////////////////////////////////////////////////
516
517 int VDR::doLogin()
518 {
519   VDR_RequestPacket vrp;
520   if (!vrp.init(VDR_LOGIN, true, 6)) return 0;
521
522   char* mactemp[6];
523   tcp->getMAC((char*)mactemp);
524   if (!vrp.copyin((UCHAR*)mactemp, 6)) return 0;
525
526   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
527   if (vresp->noResponse()) { delete vresp; return 0; }
528
529   ULONG vdrTime = vresp->extractULONG();
530   logger->log("VDR", Log::DEBUG, "vdrtime = %lu", vdrTime);
531   long vdrTimeOffset = vresp->extractLONG();
532   logger->log("VDR", Log::DEBUG, "offset = %i", vdrTimeOffset);
533
534   delete vresp;
535
536   // Set the time and zone on the MVP
537
538 #ifndef WIN32
539   struct timespec currentTime;
540   currentTime.tv_sec = vdrTime;
541   currentTime.tv_nsec = 0;
542   int b = clock_settime(CLOCK_REALTIME, &currentTime);
543
544   logger->log("VDR", Log::DEBUG, "set clock = %u", b);
545
546   // now make a TZ variable and set it
547   char sign;
548   int hours;
549   int minutes;
550   if (vdrTimeOffset > 0) sign = '-';
551   else sign = '+';
552
553   vdrTimeOffset = abs(vdrTimeOffset);
554
555   hours = (int)vdrTimeOffset / 3600;
556   minutes = vdrTimeOffset % 3600;
557
558   logger->log("VDR", Log::DEBUG, "%c %i %i", sign, hours, minutes);
559
560   minutes = (int)minutes / 60;
561
562   logger->log("VDR", Log::DEBUG, "%c %i %i", sign, hours, minutes);
563
564   char newTZ[30];
565   sprintf(newTZ, "MVP%c%i:%i", sign, hours, minutes);
566   setenv("TZ", newTZ, 1);
567
568   logger->log("VDR", Log::DEBUG, "Timezone data: %s", newTZ);
569 #endif
570
571   return 1;
572 }
573
574 bool VDR::getRecordingsList(RecMan* recman)
575 {
576   VDR_RequestPacket vrp;
577   if (!vrp.init(VDR_GETRECORDINGLIST, true, 0)) return false;
578
579   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
580   if (vresp->noResponse()) { delete vresp; return false; }
581   
582   ULONG totalSpace = vresp->extractULONG();
583   ULONG freeSpace = vresp->extractULONG();
584   ULONG percent = vresp->extractULONG();
585   recman->setStats(totalSpace, freeSpace, percent);
586
587   ULONG start;
588   char* name;
589   char* fileName;
590
591   while (!vresp->end())
592   {
593     start = vresp->extractULONG();
594     name = vresp->extractString();
595     fileName = vresp->extractString();
596
597     recman->addEntry(start, name, fileName);
598
599     delete[] name;
600     delete[] fileName;
601   }
602
603   delete vresp;
604
605   return true;
606 }
607
608 int VDR::deleteRecording(char* fileName)
609 {
610   VDR_RequestPacket vrp;
611   if (!vrp.init(VDR_DELETERECORDING, true, strlen(fileName) + 1)) return 0;
612   if (!vrp.addString(fileName)) return 0;
613   
614   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
615   if (vresp->noResponse()) { delete vresp; return 0; }
616   
617   int toReturn = (int)vresp->extractULONG();
618   delete vresp;
619
620   return toReturn;
621 }
622
623 char* VDR::moveRecording(char* fileName, char* newPath)
624 {
625   VDR_RequestPacket vrp;
626   if (!vrp.init(VDR_MOVERECORDING, true, strlen(fileName) + 1 + strlen(newPath) + 1)) return NULL;
627   if (!vrp.addString(fileName)) return NULL;
628   if (!vrp.addString(newPath)) return NULL;
629   
630   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
631   if (vresp->noResponse()) { delete vresp; return NULL; }
632   
633   char* toReturn = NULL;
634   int success = (int)vresp->extractULONG();
635   if (success == 1)
636   {
637     toReturn = vresp->extractString();
638   }
639
640   delete vresp;
641
642   return toReturn;
643 }
644
645 ChannelList* VDR::getChannelsList(ULONG type)
646 {
647   VDR_RequestPacket vrp;
648   if (!vrp.init(VDR_GETCHANNELLIST, true, 0)) return NULL;
649
650   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
651   if (vresp->noResponse()) { delete vresp; return NULL; }
652   
653   ChannelList* chanList = new ChannelList();
654
655   while (!vresp->end())
656   {
657     Channel* chan = new Channel();
658     chan->number = vresp->extractULONG();
659     chan->type = vresp->extractULONG();
660     chan->name = vresp->extractString();
661
662     if (chan->type == type)
663     {
664       chanList->push_back(chan);
665       logger->log("VDR", Log::DEBUG, "Have added a channel to list. %lu %lu %s", chan->number, chan->type, chan->name);
666       if (chan->number > maxChannelNumber) maxChannelNumber = chan->number;
667     }
668     else
669     {
670       delete chan;
671     }
672   }
673
674   delete vresp;
675
676   if (maxChannelNumber > 99999)
677     channelNumberWidth = 6;
678   else if (maxChannelNumber > 9999)
679     channelNumberWidth = 5;
680   else if (maxChannelNumber > 999)
681     channelNumberWidth = 4;
682   else if (maxChannelNumber > 99)
683     channelNumberWidth = 3;
684   else if (maxChannelNumber > 9)
685     channelNumberWidth = 2;
686   else
687     channelNumberWidth = 1;
688
689   return chanList;
690 }
691
692 int VDR::streamChannel(ULONG number, StreamReceiver* tstreamReceiver)
693 {
694   VDR_RequestPacket vrp;
695   if (!vrp.init(VDR_STREAMCHANNEL, true, sizeof(ULONG))) return 0;
696   if (!vrp.addULONG(number)) return 0;
697   
698   
699   VDR_PacketReceiver* vdrpr = new VDR_PacketReceiver();
700   vdrpr->receiverChannel = VDR::CHANNEL_STREAM;
701   vdrpr->streamID = vrp.getSerial();
702   vdrpr->streamReceiver = tstreamReceiver;
703   edRegister(vdrpr);
704   TEMP_SINGLE_VDR_PR = vdrpr;
705   
706   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
707   if (vresp->noResponse())
708   {
709     delete vresp;
710     edUnregister(vdrpr);
711     delete vdrpr;
712     return 0;
713   }
714   
715   int toReturn = (int)vresp->extractULONG();
716   logger->log("VDR", Log::DEBUG, "VDR said %lu to start streaming request", toReturn);
717   delete vresp;
718
719   return toReturn;
720 }
721
722 int VDR::stopStreaming()
723 {
724   VDR_RequestPacket vrp;
725   if (!vrp.init(VDR_STOPSTREAMING, true, 0)) return 0;
726
727   if (TEMP_SINGLE_VDR_PR) // this block only needs to be done if it was a live stream
728                           // TEMP_SINGLE_VDR_PR will not be set unless we are streaming a channel
729   {
730     edUnregister(TEMP_SINGLE_VDR_PR);
731     delete TEMP_SINGLE_VDR_PR;
732     TEMP_SINGLE_VDR_PR = NULL;
733   }
734
735   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
736   if (vresp->noResponse()) { delete vresp; return 0; }
737   
738   int toReturn = (int)vresp->extractULONG();
739   delete vresp;
740
741   return toReturn;
742 }
743
744 UCHAR* VDR::getImageBlock(ULONG position, UINT maxAmount, UINT* amountReceived)
745 {
746   return getBlock(position, maxAmount, amountReceived, VDR_GETIMAGEBLOCK);
747 }
748
749 UCHAR* VDR::getBlock(ULLONG position, UINT maxAmount, UINT* amountReceived)
750 {
751   return getBlock(position, maxAmount, amountReceived, VDR_GETBLOCK);
752 }
753
754 UCHAR* VDR::getBlock(ULLONG position, UINT maxAmount, UINT* amountReceived, ULONG cmd)
755 {
756   VDR_RequestPacket vrp;
757   if (!vrp.init(cmd, true, sizeof(ULLONG) + sizeof(ULONG))) return NULL;
758   if (!vrp.addULLONG(position)) return NULL;
759   if (!vrp.addULONG(maxAmount)) return NULL;
760
761   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
762   if (vresp->noResponse()) { delete vresp; return NULL; }
763
764   if (vresp->serverError())
765   {
766     logger->log("VDR", Log::DEBUG, "Detected getblock 0");
767     delete vresp;
768     return NULL;
769   }
770
771   // Special handling for getblock
772   UCHAR* toReturn = vresp->getUserData();
773   *amountReceived = vresp->getUserDataLength();
774   
775   delete vresp;
776   
777   return toReturn;
778 }
779
780 ULLONG VDR::streamRecording(char* fileName, ULONG* totalFrames)
781 {
782   VDR_RequestPacket vrp;
783   if (!vrp.init(VDR_STREAMRECORDING, true, strlen(fileName) + 1)) return 0;
784   if (!vrp.addString(fileName)) return 0;
785
786   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
787   if (vresp->noResponse()) { delete vresp; return 0; }
788   
789   ULLONG lengthBytes = vresp->extractULLONG();
790   ULONG lengthFrames = vresp->extractULONG();
791   delete vresp;
792
793   logger->log("VDR", Log::DEBUG, "VDR said length is: %llu %lu", lengthBytes, lengthFrames);
794
795   *totalFrames = lengthFrames;
796   return lengthBytes;
797 }
798
799 ULLONG VDR::positionFromFrameNumber(ULONG frameNumber)
800 {
801   VDR_RequestPacket vrp;
802   if (!vrp.init(VDR_POSFROMFRAME, true, sizeof(ULONG))) return 0;
803   if (!vrp.addULONG(frameNumber)) return 0;
804
805   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
806   if (vresp->noResponse()) { delete vresp; return 0; }
807   
808   ULLONG position = vresp->extractULLONG();
809   delete vresp;
810   
811   logger->log("VDR", Log::DEBUG, "VDR said new position is: %llu", position);
812
813   return position;
814 }
815
816 ULONG VDR::frameNumberFromPosition(ULLONG position)
817 {
818   VDR_RequestPacket vrp;
819   if (!vrp.init(VDR_FRAMEFROMPOS, true, sizeof(ULLONG))) return 0;
820   if (!vrp.addULLONG(position)) return 0;
821
822   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
823   if (vresp->noResponse()) { delete vresp; return 0; }
824   
825   ULONG framenumber = vresp->extractULONG();
826   delete vresp;
827   
828   logger->log("VDR", Log::DEBUG, "VDR said new framenumber is: %u", framenumber);
829
830   return framenumber;
831 }
832
833 bool VDR::getNextIFrame(ULONG frameNumber, ULONG direction, ULLONG* rfilePosition, ULONG* rframeNumber, ULONG* rframeLength)
834 {
835   VDR_RequestPacket vrp;
836   if (!vrp.init(VDR_GETNEXTIFRAME, true, sizeof(ULONG)*2)) return false;
837   if (!vrp.addULONG(frameNumber)) return false;
838   if (!vrp.addULONG(direction)) return false;
839
840   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
841   if (vresp->noResponse()) { delete vresp; return false; }
842   
843   if (vresp->serverError())
844   {
845     logger->log("VDR", Log::DEBUG, "Detected getNextIFrame error");
846     delete vresp;
847     return false;
848   }
849
850   *rfilePosition = vresp->extractULLONG();
851   *rframeNumber = vresp->extractULONG();
852   *rframeLength = vresp->extractULONG();
853
854   delete vresp;
855
856 //  logger->log("VDR", Log::DEBUG, "VDR GNIF said %llu %lu %lu", *rfilePosition, *rframeNumber, *rframeLength);
857
858   return true;
859 }
860
861 EventList* VDR::getChannelSchedule(ULONG number)
862 {
863   time_t now;
864   time(&now);
865   return getChannelSchedule(number, now, 24 * 60 * 60);
866 }
867
868 EventList* VDR::getChannelSchedule(ULONG number, time_t start, ULONG duration)
869 {
870 // retrieve event list (vector of events) from vdr within filter window. duration is in seconds
871
872   VDR_RequestPacket vrp;
873   if (!vrp.init(VDR_GETCHANNELSCHEDULE, true, sizeof(ULONG)*3)) return NULL;
874   if (!vrp.addULONG(number)) return NULL;
875   if (!vrp.addULONG(start)) return NULL;
876   if (!vrp.addULONG(duration)) return NULL;
877
878   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
879   if (vresp->noResponse()) { delete vresp; return NULL; }
880   
881   // received a ulong(0) - schedules error in the plugin
882   if (vresp->serverError())
883   {
884     delete vresp;
885     return NULL;
886   }
887
888   EventList* eventList = new EventList();
889
890   while (!vresp->end())
891   {
892     Event* event = new Event();
893     event->id = vresp->extractULONG();
894     event->time = vresp->extractULONG();
895     event->duration = vresp->extractULONG();
896     event->title = vresp->extractString();
897     event->subtitle = vresp->extractString();
898     event->description = vresp->extractString();
899     eventList->push_back(event);
900   }
901
902   delete vresp;
903
904   logger->log("VDR", Log::DEBUG, "Success got to end of getChannelSchedule");
905   return eventList;
906 }
907
908 int VDR::configSave(const char* section, const char* key, const char* value)
909 {
910   VDR_RequestPacket vrp;
911   if (!vrp.init(VDR_CONFIGSAVE, false, 0)) return 0;
912   if (!vrp.addString(section)) return 0;
913   if (!vrp.addString(key)) return 0;
914   if (!vrp.addString(value)) return 0;
915
916   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
917   if (vresp->noResponse()) { delete vresp; return 0; }
918   
919   int toReturn = (int)vresp->extractULONG();
920   delete vresp;
921
922   return toReturn;
923 }
924
925 char* VDR::configLoad(const char* section, const char* key)
926 {
927   VDR_RequestPacket vrp;
928   if (!vrp.init(VDR_CONFIGLOAD, false, 0)) return NULL;
929   if (!vrp.addString(section)) return NULL;
930   if (!vrp.addString(key)) return NULL;
931
932   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
933   if (vresp->noResponse()) { delete vresp; return NULL; }
934   
935   char* toReturn = vresp->extractString();
936   delete vresp;
937
938   return toReturn;
939 }
940
941 RecTimerList* VDR::getRecTimersList()
942 {
943   VDR_RequestPacket vrp;
944   if (!vrp.init(VDR_GETTIMERS, true, 0)) return NULL;
945
946   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
947   if (vresp->noResponse()) { delete vresp; return NULL; }
948
949   RecTimerList* recTimerList = new RecTimerList();
950
951   ULONG numTimers = vresp->extractULONG();
952   if (numTimers > 0)
953   {
954     RecTimer* newRecTimer;
955     char* tempString;
956
957     while (!vresp->end())
958     {
959       newRecTimer = new RecTimer();
960       newRecTimer->active = vresp->extractULONG();
961       newRecTimer->recording = vresp->extractULONG();
962       newRecTimer->pending = vresp->extractULONG();
963       newRecTimer->priority = vresp->extractULONG();
964       newRecTimer->lifeTime = vresp->extractULONG();
965       newRecTimer->channelNumber = vresp->extractULONG();
966       newRecTimer->startTime = vresp->extractULONG();
967       newRecTimer->stopTime = vresp->extractULONG();
968       newRecTimer->day = vresp->extractULONG();
969       newRecTimer->weekDays = vresp->extractULONG();
970
971       tempString = vresp->extractString();
972       newRecTimer->setFile(tempString);
973       delete[] tempString;
974
975       recTimerList->push_back(newRecTimer);
976       logger->log("VDR", Log::DEBUG, "TL: %lu %lu %lu %lu %lu %lu %lu %lu %s",
977         newRecTimer->active, newRecTimer->recording, newRecTimer->pending, newRecTimer->priority, newRecTimer->lifeTime,
978         newRecTimer->channelNumber, newRecTimer->startTime, newRecTimer->stopTime, newRecTimer->getFile());
979     }
980   }
981
982   delete vresp;
983
984   sort(recTimerList->begin(), recTimerList->end(), RecTimerSorter());
985
986   return recTimerList;
987 }
988
989 ULONG VDR::setEventTimer(char* timerString)
990 {
991   VDR_RequestPacket vrp;
992   if (!vrp.init(VDR_SETTIMER, true, strlen(timerString) + 1)) return 0;
993   if (!vrp.addString(timerString)) return 0;
994
995   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
996   if (vresp->noResponse()) { delete vresp; return 0; }
997   
998   ULONG toReturn = vresp->extractULONG();
999   delete vresp;
1000
1001   return toReturn;
1002 }
1003
1004 RecInfo* VDR::getRecInfo(char* fileName)
1005 {
1006   VDR_RequestPacket vrp;
1007   if (!vrp.init(VDR_GETRECINFO, true, strlen(fileName) + 1)) return NULL;
1008   if (!vrp.addString(fileName)) return NULL;
1009   
1010   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1011   if (vresp->noResponse()) { delete vresp; return NULL; }
1012   
1013   if (vresp->serverError())
1014   {
1015     logger->log("VDR", Log::DEBUG, "Could not get rec info");
1016     delete vresp;
1017     return NULL;
1018   }
1019
1020   RecInfo* recInfo = new RecInfo();
1021
1022   recInfo->timerStart = vresp->extractULONG();
1023   recInfo->timerEnd = vresp->extractULONG();
1024   recInfo->resumePoint = vresp->extractULONG();
1025   recInfo->summary = vresp->extractString();
1026
1027   ULONG numComponents = vresp->extractULONG();
1028   if (numComponents)
1029   {
1030     recInfo->setNumComponents(numComponents);
1031     for (ULONG i = 0; i < numComponents; i++)
1032     {
1033       recInfo->streams[i] = vresp->extractUCHAR();
1034       recInfo->types[i] = vresp->extractUCHAR();
1035       recInfo->languages[i] = vresp->extractString();
1036       recInfo->descriptions[i] = vresp->extractString();
1037     }
1038   }
1039
1040   recInfo->print();
1041
1042   delete vresp;
1043   return recInfo;
1044 }
1045
1046 // FIXME obselete
1047 ULLONG VDR::rescanRecording(ULONG* totalFrames)
1048 {
1049   VDR_RequestPacket vrp;
1050   if (!vrp.init(VDR_RESCANRECORDING, true, 0)) return 0;
1051
1052   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1053   if (vresp->noResponse()) { delete vresp; return 0; }
1054   
1055   ULLONG lengthBytes = vresp->extractULLONG();
1056   ULONG lengthFrames = vresp->extractULONG();
1057   delete vresp;
1058   
1059   logger->log("VDR", Log::DEBUG, "VDR said length is: %llu %lu", lengthBytes, lengthFrames);
1060
1061   *totalFrames = lengthFrames;
1062   return lengthBytes;
1063 }
1064
1065 MarkList* VDR::getMarks(char* fileName)
1066 {
1067   VDR_RequestPacket vrp;
1068   if (!vrp.init(VDR_GETMARKS, true, strlen(fileName) + 1)) return NULL;
1069   if (!vrp.addString(fileName)) return NULL;
1070
1071   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1072   if (vresp->noResponse()) { delete vresp; return NULL; }
1073   
1074   if (vresp->serverError())
1075   {
1076     delete vresp;
1077     return NULL;
1078   }
1079
1080   MarkList* markList = new MarkList();
1081
1082   while (!vresp->end())
1083   {
1084     Mark* mark = new Mark();
1085     mark->pos = vresp->extractULONG();
1086
1087     markList->push_back(mark);
1088     logger->log("VDR", Log::DEBUG, "Have added a mark to list. %lu", mark->pos);
1089   }
1090
1091   delete vresp;
1092   
1093   return markList;
1094 }
1095
1096 void VDR::getChannelPids(Channel* channel)
1097 {
1098   VDR_RequestPacket vrp;
1099   if (!vrp.init(VDR_GETCHANNELPIDS, true, sizeof(ULONG))) return ;
1100   if (!vrp.addULONG(channel->number)) return ;
1101
1102   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1103   if (vresp->noResponse()) { delete vresp; return ; }
1104   
1105   // Format of response
1106   // vpid
1107   // number of apids
1108   // {
1109   //    apid
1110   //    lang string
1111   // }
1112
1113   channel->vpid = vresp->extractULONG();
1114   channel->numAPids = vresp->extractULONG();
1115
1116   for (ULONG i = 0; i < channel->numAPids; i++)
1117   {
1118     apid newapid;
1119     newapid.pid = vresp->extractULONG();
1120     newapid.name = vresp->extractString();
1121     channel->apids.push_back(newapid);
1122   }
1123
1124   channel->numDPids = vresp->extractULONG();
1125
1126   for (ULONG i = 0; i < channel->numDPids; i++)
1127   {
1128     apid newdpid;
1129     newdpid.pid = vresp->extractULONG();
1130     newdpid.name = vresp->extractString();
1131     channel->dpids.push_back(newdpid);
1132   }
1133
1134   channel->numSPids = vresp->extractULONG();
1135
1136   for (ULONG i = 0; i < channel->numSPids; i++)
1137   {
1138     apid newspid;
1139     newspid.pid = vresp->extractULONG();
1140     newspid.name = vresp->extractString();
1141     channel->spids.push_back(newspid);
1142   }
1143   channel->tpid = vresp->extractULONG();
1144
1145   delete vresp;
1146   
1147   return ;
1148 }
1149
1150 /**
1151   * media List Request:
1152   * 4 flags (currently unused)
1153   * n dirname
1154   * n+1 0
1155   * Media List response:
1156   * 4 length
1157   * 4 VDR_
1158   * 4 numentries
1159   * per entry:
1160   * 4 media type
1161   * 4 time stamp
1162   * 4 flags
1163   * 4 strlen (incl. 0 Byte)
1164   * string
1165   * 0
1166 */
1167 MediaList* VDR::getMediaList(const char* parent,int mediaType)
1168 {
1169   logger->log("VDR", Log::DEBUG, "getMediaList %s,type=%d", (parent?parent:"NULL"), mediaType);
1170
1171   VDR_RequestPacket vrp;
1172   if (!vrp.init(VDR_GETMEDIALIST, false, 0)) return NULL;
1173   if (!vrp.addULONG(0)) return NULL; // unused flags
1174
1175   //name
1176   if (parent) {
1177     if (!vrp.addString(parent)) return NULL;
1178   }
1179     
1180   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1181   if (vresp->noResponse()) { delete vresp; return NULL; }
1182   
1183   if (vresp->serverError())
1184   {
1185     delete vresp;
1186     return NULL;
1187   }
1188   
1189   if (vresp->getUserDataLength() < 12)
1190   {
1191     logger->log("VDR", Log::ERR, "receiveMediaList packet too short, expected 12, got %d", vresp->getUserDataLength());
1192     delete vresp;
1193     return NULL;
1194   }
1195
1196   MediaList* mediaList = new MediaList();
1197   ULONG code=0;
1198   code = vresp->extractULONG();
1199   ULONG numEntries = vresp->extractULONG();
1200   Log::getInstance()->log("VDR", Log::DEBUG, "receiveMediaList with %d entries",numEntries);
1201   while (!vresp->end() && numEntries >0)
1202   {
1203     Media* m = new Media();
1204     ULONG mtype = vresp->extractULONG();
1205     ULONG mtime=vresp->extractULONG();
1206     ULONG flags=0;
1207     flags=vresp->extractULONG();
1208     ULONG stsize=vresp->extractULONG();
1209     char * name=vresp->extractString();
1210     if (! name || stsize != (strlen(name)+1)) {
1211       Log::getInstance()->log("VDR", Log::ERR, "receiveMediaList invalid packet entry, read size %d, strlen %d", stsize, strlen(name)+1);
1212       delete m;
1213       delete mediaList;
1214       delete vresp;
1215       return NULL;
1216       }
1217     //ignore . and .. entries
1218     if (strcmp(name,".") == 0 || strcmp(name,"..")==0) {
1219   delete m;
1220   continue;
1221     }
1222     m->setFileName(name);
1223     m->setTime(mtime);
1224     m->setMediaType(mtype);
1225     mediaList->push_back(m);
1226     Log::getInstance()->log("VDR", Log::DEBUG, "Have added a media to list. %s, type=%d, time=%d", name,mtype,mtime);
1227     numEntries--;
1228   }
1229
1230   delete vresp;
1231   return mediaList;
1232 }
1233
1234 /**
1235   * get image Request:
1236   * 4 flags (currently unused)
1237   * 4 x size
1238   * 4 y size
1239   * n filename
1240   * n+1 0
1241   * get image response:
1242   * 4 length
1243   * 4 VDR_GETIMAGE
1244   * 4 len of image
1245 */
1246 ULONG VDR::loadImage(const char* fileName, ULONG x, ULONG y)
1247 {
1248   VDR_RequestPacket vrp;
1249   if (!vrp.init(VDR_GETIMAGE, false, 0)) return 0;
1250   if (!vrp.addULONG(0)) return 0; // unused flags
1251   if (!vrp.addULONG(x)) return 0;
1252   if (!vrp.addULONG(y)) return 0;
1253   if (!vrp.addString(fileName)) return 0;
1254
1255   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1256   if (vresp->noResponse()) { delete vresp; return 0; }
1257
1258   ULONG cmd = vresp->extractULONG();
1259   ULONG lengthBytes = vresp->extractULONG();
1260   delete vresp;
1261
1262   Log::getInstance()->log("VDR", Log::DEBUG, "getImage %s: cmd=%lu len=%lu", fileName, cmd, lengthBytes);
1263   return lengthBytes;
1264 }
1265
1266 int VDR::deleteTimer(RecTimer* delTimer)
1267 {
1268   Log::getInstance()->log("VDR", Log::DEBUG, "Delete timer called");
1269   
1270   VDR_RequestPacket vrp;
1271   if (!vrp.init(VDR_DELETETIMER, false, 0)) return 0;
1272   if (!vrp.addULONG(delTimer->channelNumber)) return 0;
1273   if (!vrp.addULONG(delTimer->weekDays)) return 0;    
1274   if (!vrp.addULONG(delTimer->day)) return 0;
1275   if (!vrp.addULONG(delTimer->startTime)) return 0;  
1276   if (!vrp.addULONG(delTimer->stopTime)) return 0; 
1277    
1278   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1279   if (vresp->noResponse()) { delete vresp; return 0; }
1280   
1281   int toReturn = (int)vresp->extractULONG();
1282   delete vresp;
1283
1284   return toReturn;
1285 }
1286
1287 I18n::lang_code_list VDR::getLanguageList()
1288 {
1289   I18n::lang_code_list CodeList;
1290   CodeList["en"] = "English"; // Default entry
1291   VDR_RequestPacket vrp;
1292   if (!vrp.init(VDR_GETLANGUAGELIST, false, 0)) return CodeList;
1293   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1294   if (vresp->noResponse() || vresp->end())
1295   {
1296     delete vresp;
1297     return CodeList;
1298   }
1299   CodeList.clear();
1300   while (!vresp->end())
1301   {
1302     char* c_code = vresp->extractString();
1303     char* c_name = vresp->extractString();
1304     string code = c_code;
1305     string name = c_name;
1306     CodeList[code] = name;
1307     delete[] c_code;
1308     delete[] c_name;
1309   }
1310   delete vresp;
1311   return CodeList;
1312 }
1313
1314 int VDR::getLanguageContent(const std::string code, I18n::trans_table& texts)
1315 {
1316   VDR_RequestPacket vrp;
1317   if (!vrp.init(VDR_GETLANGUAGECONTENT, false, 0)) return 0;
1318   if (!vrp.addString(code.c_str())) return 0;
1319   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1320   if (vresp->noResponse()) { delete vresp; return 0; }
1321   texts.clear();
1322   while (!vresp->end())
1323   {
1324     char* c_key = vresp->extractString();
1325     char* c_text = vresp->extractString();
1326     string key = c_key;
1327     string text = c_text;
1328     texts[key] = text;
1329     delete[] c_key;
1330     delete[] c_text;
1331   }
1332   delete vresp;
1333   return 1;
1334 }