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