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