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   logger->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       logger->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       logger->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 //      logger->log("VDR", Log::DEBUG, "Rxd a stream packet, streamID=%lu, flag=%lu, len=%lu", streamID, flag, userDataLength);
 259     }
 260     else
 261     {
 262       logger->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       logger->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   logger->log("VDR", Log::DEBUG, "VDR said %lu to start streaming request", toReturn);
 581   delete vresp;
 582
 583   return toReturn;
 584 }
 585
 586 int VDR::stopStreaming()
 587 {
 588   VDR_RequestPacket vrp;
 589   if (!vrp.init(VDR_STOPSTREAMING, true, 0)) return 0;
 590
 591   if (TEMP_SINGLE_VDR_PR) // this block only needs to be done if it was a live stream
 592                           // TEMP_SINGLE_VDR_PR will not be set unless we are streaming a channel
 593   {
 594     edUnregister(TEMP_SINGLE_VDR_PR);
 595     delete TEMP_SINGLE_VDR_PR;
 596     TEMP_SINGLE_VDR_PR = NULL;
 597   }
 598
 599   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 600   if (vresp->noResponse()) { delete vresp; return 0; }
 601
 602   int toReturn = (int)vresp->extractULONG();
 603   delete vresp;
 604
 605   return toReturn;
 606 }
 607
 608 UCHAR* VDR::getImageBlock(ULONG position, UINT maxAmount, UINT* amountReceived)
 609 {
 610   return getBlock(position, maxAmount, amountReceived, VDR_GETIMAGEBLOCK);
 611 }
 612
 613 UCHAR* VDR::getBlock(ULLONG position, UINT maxAmount, UINT* amountReceived)
 614 {
 615   return getBlock(position, maxAmount, amountReceived, VDR_GETBLOCK);
 616 }
 617
 618 UCHAR* VDR::getBlock(ULLONG position, UINT maxAmount, UINT* amountReceived, ULONG cmd)
 619 {
 620   VDR_RequestPacket vrp;
 621   if (!vrp.init(cmd, true, sizeof(ULLONG) + sizeof(ULONG))) return NULL;
 622   if (!vrp.addULLONG(position)) return NULL;
 623   if (!vrp.addULONG(maxAmount)) return NULL;
 624
 625   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 626   if (vresp->noResponse()) { delete vresp; return NULL; }
 627
 628   if (vresp->serverError())
 629   {
 630     logger->log("VDR", Log::DEBUG, "Detected getblock 0");
 631     delete vresp;
 632     return NULL;
 633   }
 634
 635   // Special handling for getblock
 636   UCHAR* toReturn = vresp->getUserData();
 637   *amountReceived = vresp->getUserDataLength();
 638
 639   delete vresp;
 640
 641   return toReturn;
 642 }
 643
 644 ULLONG VDR::streamRecording(char* fileName, ULONG* totalFrames)
 645 {
 646   VDR_RequestPacket vrp;
 647   if (!vrp.init(VDR_STREAMRECORDING, true, strlen(fileName) + 1)) return 0;
 648   if (!vrp.addString(fileName)) return 0;
 649
 650   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 651   if (vresp->noResponse()) { delete vresp; return 0; }
 652
 653   ULLONG lengthBytes = vresp->extractULLONG();
 654   ULONG lengthFrames = vresp->extractULONG();
 655   delete vresp;
 656
 657   logger->log("VDR", Log::DEBUG, "VDR said length is: %llu %lu", lengthBytes, lengthFrames);
 658
 659   *totalFrames = lengthFrames;
 660   return lengthBytes;
 661 }
 662
 663 ULLONG VDR::positionFromFrameNumber(ULONG frameNumber)
 664 {
 665   VDR_RequestPacket vrp;
 666   if (!vrp.init(VDR_POSFROMFRAME, true, sizeof(ULONG))) return 0;
 667   if (!vrp.addULONG(frameNumber)) return 0;
 668
 669   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 670   if (vresp->noResponse()) { delete vresp; return 0; }
 671
 672   ULLONG position = vresp->extractULLONG();
 673   delete vresp;
 674
 675   logger->log("VDR", Log::DEBUG, "VDR said new position is: %llu", position);
 676
 677   return position;
 678 }
 679
 680 ULONG VDR::frameNumberFromPosition(ULLONG position)
 681 {
 682   VDR_RequestPacket vrp;
 683   if (!vrp.init(VDR_FRAMEFROMPOS, true, sizeof(ULLONG))) return 0;
 684   if (!vrp.addULLONG(position)) return 0;
 685
 686   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 687   if (vresp->noResponse()) { delete vresp; return 0; }
 688
 689   ULONG framenumber = vresp->extractULONG();
 690   delete vresp;
 691
 692   logger->log("VDR", Log::DEBUG, "VDR said new framenumber is: %u", framenumber);
 693
 694   return framenumber;
 695 }
 696
 697 bool VDR::getNextIFrame(ULONG frameNumber, ULONG direction, ULLONG* rfilePosition, ULONG* rframeNumber, ULONG* rframeLength)
 698 {
 699   VDR_RequestPacket vrp;
 700   if (!vrp.init(VDR_GETNEXTIFRAME, true, sizeof(ULONG)*2)) return false;
 701   if (!vrp.addULONG(frameNumber)) return false;
 702   if (!vrp.addULONG(direction)) return false;
 703
 704   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 705   if (vresp->noResponse()) { delete vresp; return false; }
 706
 707   if (vresp->serverError())
 708   {
 709     logger->log("VDR", Log::DEBUG, "Detected getNextIFrame error");
 710     delete vresp;
 711     return false;
 712   }
 713
 714   *rfilePosition = vresp->extractULLONG();
 715   *rframeNumber = vresp->extractULONG();
 716   *rframeLength = vresp->extractULONG();
 717
 718   delete vresp;
 719
 720 //  logger->log("VDR", Log::DEBUG, "VDR GNIF said %llu %lu %lu", *rfilePosition, *rframeNumber, *rframeLength);
 721
 722   return true;
 723 }
 724
 725 EventList* VDR::getChannelSchedule(ULONG number)
 726 {
 727   time_t now;
 728   time(&now);
 729   return getChannelSchedule(number, now, 24 * 60 * 60);
 730 }
 731
 732 EventList* VDR::getChannelSchedule(ULONG number, time_t start, ULONG duration)
 733 {
 734 // retrieve event list (vector of events) from vdr within filter window. duration is in seconds
 735
 736   VDR_RequestPacket vrp;
 737   if (!vrp.init(VDR_GETCHANNELSCHEDULE, true, sizeof(ULONG)*3)) return NULL;
 738   if (!vrp.addULONG(number)) return NULL;
 739   if (!vrp.addULONG(start)) return NULL;
 740   if (!vrp.addULONG(duration)) return NULL;
 741
 742   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 743   if (vresp->noResponse()) { delete vresp; return NULL; }
 744
 745   // received a ulong(0) - schedules error in the plugin
 746   if (vresp->serverError())
 747   {
 748     delete vresp;
 749     return NULL;
 750   }
 751
 752   EventList* eventList = new EventList();
 753
 754   while (!vresp->end())
 755   {
 756     Event* event = new Event();
 757     event->id = vresp->extractULONG();
 758     event->time = vresp->extractULONG();
 759     event->duration = vresp->extractULONG();
 760     event->title = vresp->extractString();
 761     event->subtitle = vresp->extractString();
 762     event->description = vresp->extractString();
 763     eventList->push_back(event);
 764   }
 765
 766   delete vresp;
 767
 768   logger->log("VDR", Log::DEBUG, "Success got to end of getChannelSchedule");
 769   return eventList;
 770 }
 771
 772 int VDR::configSave(const char* section, const char* key, const char* value)
 773 {
 774   VDR_RequestPacket vrp;
 775   if (!vrp.init(VDR_CONFIGSAVE, false, 0)) return 0;
 776   if (!vrp.addString(section)) return 0;
 777   if (!vrp.addString(key)) return 0;
 778   if (!vrp.addString(value)) return 0;
 779
 780   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 781   if (vresp->noResponse()) { delete vresp; return 0; }
 782
 783   int toReturn = (int)vresp->extractULONG();
 784   delete vresp;
 785
 786   return toReturn;
 787 }
 788
 789 char* VDR::configLoad(const char* section, const char* key)
 790 {
 791   VDR_RequestPacket vrp;
 792   if (!vrp.init(VDR_CONFIGLOAD, false, 0)) return NULL;
 793   if (!vrp.addString(section)) return NULL;
 794   if (!vrp.addString(key)) return NULL;
 795
 796   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 797   if (vresp->noResponse()) { delete vresp; return NULL; }
 798
 799   char* toReturn = vresp->extractString();
 800   delete vresp;
 801
 802   return toReturn;
 803 }
 804
 805 RecTimerList* VDR::getRecTimersList()
 806 {
 807   VDR_RequestPacket vrp;
 808   if (!vrp.init(VDR_GETTIMERS, true, 0)) return NULL;
 809
 810   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 811   if (vresp->noResponse()) { delete vresp; return NULL; }
 812
 813   RecTimerList* recTimerList = new RecTimerList();
 814
 815   ULONG numTimers = vresp->extractULONG();
 816   if (numTimers > 0)
 817   {
 818     RecTimer* newRecTimer;
 819     char* tempString;
 820
 821     while (!vresp->end())
 822     {
 823       newRecTimer = new RecTimer();
 824       newRecTimer->active = vresp->extractULONG();
 825       newRecTimer->recording = vresp->extractULONG();
 826       newRecTimer->pending = vresp->extractULONG();
 827       newRecTimer->priority = vresp->extractULONG();
 828       newRecTimer->lifeTime = vresp->extractULONG();
 829       newRecTimer->channelNumber = vresp->extractULONG();
 830       newRecTimer->startTime = vresp->extractULONG();
 831       newRecTimer->stopTime = vresp->extractULONG();
 832       newRecTimer->day = vresp->extractULONG();
 833       newRecTimer->weekDays = vresp->extractULONG();
 834
 835       tempString = vresp->extractString();
 836       newRecTimer->setFile(tempString);
 837       delete[] tempString;
 838
 839       recTimerList->push_back(newRecTimer);
 840       logger->log("VDR", Log::DEBUG, "TL: %lu %lu %lu %lu %lu %lu %lu %lu %s",
 841         newRecTimer->active, newRecTimer->recording, newRecTimer->pending, newRecTimer->priority, newRecTimer->lifeTime,
 842         newRecTimer->channelNumber, newRecTimer->startTime, newRecTimer->stopTime, newRecTimer->getFile());
 843     }
 844   }
 845
 846   delete vresp;
 847
 848   sort(recTimerList->begin(), recTimerList->end(), RecTimerSorter());
 849
 850   return recTimerList;
 851 }
 852
 853 ULONG VDR::setEventTimer(char* timerString)
 854 {
 855   VDR_RequestPacket vrp;
 856   if (!vrp.init(VDR_SETTIMER, true, strlen(timerString) + 1)) return 0;
 857   if (!vrp.addString(timerString)) return 0;
 858
 859   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 860   if (vresp->noResponse()) { delete vresp; return 0; }
 861
 862   ULONG toReturn = vresp->extractULONG();
 863   delete vresp;
 864
 865   return toReturn;
 866 }
 867
 868 RecInfo* VDR::getRecInfo(char* fileName)
 869 {
 870   VDR_RequestPacket vrp;
 871   if (!vrp.init(VDR_GETRECINFO, true, strlen(fileName) + 1)) return NULL;
 872   if (!vrp.addString(fileName)) return NULL;
 873
 874   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 875   if (vresp->noResponse()) { delete vresp; return NULL; }
 876
 877   if (vresp->serverError())
 878   {
 879     logger->log("VDR", Log::DEBUG, "Could not get rec info");
 880     delete vresp;
 881     return NULL;
 882   }
 883
 884   RecInfo* recInfo = new RecInfo();
 885
 886   recInfo->timerStart = vresp->extractULONG();
 887   recInfo->timerEnd = vresp->extractULONG();
 888   recInfo->resumePoint = vresp->extractULONG();
 889   recInfo->summary = vresp->extractString();
 890
 891   ULONG numComponents = vresp->extractULONG();
 892   if (numComponents)
 893   {
 894     recInfo->setNumComponents(numComponents);
 895     for (ULONG i = 0; i < numComponents; i++)
 896     {
 897       recInfo->streams[i] = vresp->extractUCHAR();
 898       recInfo->types[i] = vresp->extractUCHAR();
 899       recInfo->languages[i] = vresp->extractString();
 900       recInfo->descriptions[i] = vresp->extractString();
 901     }
 902   }
 903
 904   recInfo->print();
 905
 906   delete vresp;
 907   return recInfo;
 908 }
 909
 910 // FIXME obselete
 911 ULLONG VDR::rescanRecording(ULONG* totalFrames)
 912 {
 913   VDR_RequestPacket vrp;
 914   if (!vrp.init(VDR_RESCANRECORDING, true, 0)) return 0;
 915
 916   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 917   if (vresp->noResponse()) { delete vresp; return 0; }
 918
 919   ULLONG lengthBytes = vresp->extractULLONG();
 920   ULONG lengthFrames = vresp->extractULONG();
 921   delete vresp;
 922
 923   logger->log("VDR", Log::DEBUG, "VDR said length is: %llu %lu", lengthBytes, lengthFrames);
 924
 925   *totalFrames = lengthFrames;
 926   return lengthBytes;
 927 }
 928
 929 MarkList* VDR::getMarks(char* fileName)
 930 {
 931   VDR_RequestPacket vrp;
 932   if (!vrp.init(VDR_GETMARKS, true, strlen(fileName) + 1)) return NULL;
 933   if (!vrp.addString(fileName)) return NULL;
 934
 935   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 936   if (vresp->noResponse()) { delete vresp; return NULL; }
 937
 938   if (vresp->serverError())
 939   {
 940     delete vresp;
 941     return NULL;
 942   }
 943
 944   MarkList* markList = new MarkList();
 945
 946   while (!vresp->end())
 947   {
 948     Mark* mark = new Mark();
 949     mark->pos = vresp->extractULONG();
 950
 951     markList->push_back(mark);
 952     logger->log("VDR", Log::DEBUG, "Have added a mark to list. %lu", mark->pos);
 953   }
 954
 955   delete vresp;
 956
 957   return markList;
 958 }
 959
 960 void VDR::getChannelPids(Channel* channel)
 961 {
 962   VDR_RequestPacket vrp;
 963   if (!vrp.init(VDR_GETCHANNELPIDS, true, sizeof(ULONG))) return ;
 964   if (!vrp.addULONG(channel->number)) return ;
 965
 966   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
 967   if (vresp->noResponse()) { delete vresp; return ; }
 968
 969   // Format of response
 970   // vpid
 971   // number of apids
 972   // {
 973   //    apid
 974   //    lang string
 975   // }
 976
 977   channel->vpid = vresp->extractULONG();
 978   channel->numAPids = vresp->extractULONG();
 979
 980   for (ULONG i = 0; i < channel->numAPids; i++)
 981   {
 982     apid newapid;
 983     newapid.pid = vresp->extractULONG();
 984     newapid.name = vresp->extractString();
 985     channel->apids.push_back(newapid);
 986   }
 987
 988   channel->numDPids = vresp->extractULONG();
 989
 990   for (ULONG i = 0; i < channel->numDPids; i++)
 991   {
 992     apid newdpid;
 993     newdpid.pid = vresp->extractULONG();
 994     newdpid.name = vresp->extractString();
 995     channel->dpids.push_back(newdpid);
 996   }
 997
 998   channel->numSPids = vresp->extractULONG();
 999
1000   for (ULONG i = 0; i < channel->numSPids; i++)
1001   {
1002     apid newspid;
1003     newspid.pid = vresp->extractULONG();
1004     newspid.name = vresp->extractString();
1005     channel->spids.push_back(newspid);
1006   }
1007   channel->tpid = vresp->extractULONG();
1008
1009   delete vresp;
1010
1011   return ;
1012 }
1013
1014 /**
1015   * media List Request:
1016   * 4 flags (currently unused)
1017   * n dirname
1018   * n+1 0
1019   * Media List response:
1020   * 4 length
1021   * 4 VDR_
1022   * 4 numentries
1023   * per entry:
1024   * 4 media type
1025   * 4 time stamp
1026   * 4 flags
1027   * 4 strlen (incl. 0 Byte)
1028   * string
1029   * 0
1030 */
1031 MediaList* VDR::getMediaList(const char* parent,int mediaType)
1032 {
1033   logger->log("VDR", Log::DEBUG, "getMediaList %s,type=%d", (parent?parent:"NULL"), mediaType);
1034
1035   VDR_RequestPacket vrp;
1036   if (!vrp.init(VDR_GETMEDIALIST, false, 0)) return NULL;
1037   if (!vrp.addULONG(0)) return NULL; // unused flags
1038
1039   //name
1040   if (parent) {
1041     if (!vrp.addString(parent)) return NULL;
1042   }
1043
1044   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1045   if (vresp->noResponse()) { delete vresp; return NULL; }
1046
1047   if (vresp->serverError())
1048   {
1049     delete vresp;
1050     return NULL;
1051   }
1052
1053   if (vresp->getUserDataLength() < 12)
1054   {
1055     logger->log("VDR", Log::ERR, "receiveMediaList packet too short, expected 12, got %d", vresp->getUserDataLength());
1056     delete vresp;
1057     return NULL;
1058   }
1059
1060   MediaList* mediaList = new MediaList();
1061   ULONG code=0;
1062   code = vresp->extractULONG();
1063   ULONG numEntries = vresp->extractULONG();
1064   Log::getInstance()->log("VDR", Log::DEBUG, "receiveMediaList with %d entries",numEntries);
1065   while (!vresp->end() && numEntries >0)
1066   {
1067     Media* m = new Media();
1068     ULONG mtype = vresp->extractULONG();
1069     ULONG mtime=vresp->extractULONG();
1070     ULONG flags=0;
1071     flags=vresp->extractULONG();
1072     ULONG stsize=vresp->extractULONG();
1073     char * name=vresp->extractString();
1074     if (! name || stsize != (strlen(name)+1)) {
1075       Log::getInstance()->log("VDR", Log::ERR, "receiveMediaList invalid packet entry, read size %d, strlen %d", stsize, strlen(name)+1);
1076       delete m;
1077       delete mediaList;
1078       delete vresp;
1079       return NULL;
1080       }
1081     //ignore . and .. entries
1082     if (strcmp(name,".") == 0 || strcmp(name,"..")==0) {
1083   delete m;
1084   continue;
1085     }
1086     m->setFileName(name);
1087     m->setTime(mtime);
1088     m->setMediaType(mtype);
1089     mediaList->push_back(m);
1090     Log::getInstance()->log("VDR", Log::DEBUG, "Have added a media to list. %s, type=%d, time=%d", name,mtype,mtime);
1091     numEntries--;
1092   }
1093
1094   delete vresp;
1095   return mediaList;
1096 }
1097
1098 /**
1099   * get image Request:
1100   * 4 flags (currently unused)
1101   * 4 x size
1102   * 4 y size
1103   * n filename
1104   * n+1 0
1105   * get image response:
1106   * 4 length
1107   * 4 VDR_GETIMAGE
1108   * 4 len of image
1109 */
1110 ULONG VDR::loadImage(const char* fileName, ULONG x, ULONG y)
1111 {
1112   VDR_RequestPacket vrp;
1113   if (!vrp.init(VDR_GETIMAGE, false, 0)) return 0;
1114   if (!vrp.addULONG(0)) return 0; // unused flags
1115   if (!vrp.addULONG(x)) return 0;
1116   if (!vrp.addULONG(y)) return 0;
1117   if (!vrp.addString(fileName)) return 0;
1118
1119   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1120   if (vresp->noResponse()) { delete vresp; return 0; }
1121
1122   ULONG cmd = vresp->extractULONG();
1123   ULONG lengthBytes = vresp->extractULONG();
1124   delete vresp;
1125
1126   Log::getInstance()->log("VDR", Log::DEBUG, "getImage %s: cmd=%lu len=%lu", fileName, cmd, lengthBytes);
1127   return lengthBytes;
1128 }
1129
1130 int VDR::deleteTimer(RecTimer* delTimer)
1131 {
1132   Log::getInstance()->log("VDR", Log::DEBUG, "Delete timer called");
1133
1134   VDR_RequestPacket vrp;
1135   if (!vrp.init(VDR_DELETETIMER, false, 0)) return 0;
1136   if (!vrp.addULONG(delTimer->channelNumber)) return 0;
1137   if (!vrp.addULONG(delTimer->weekDays)) return 0;
1138   if (!vrp.addULONG(delTimer->day)) return 0;
1139   if (!vrp.addULONG(delTimer->startTime)) return 0;
1140   if (!vrp.addULONG(delTimer->stopTime)) return 0;
1141
1142   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1143   if (vresp->noResponse()) { delete vresp; return 0; }
1144
1145   int toReturn = (int)vresp->extractULONG();
1146   delete vresp;
1147
1148   return toReturn;
1149 }
1150
1151 I18n::lang_code_list VDR::getLanguageList()
1152 {
1153   I18n::lang_code_list CodeList;
1154   CodeList["en"] = "English"; // Default entry
1155   VDR_RequestPacket vrp;
1156   if (!vrp.init(VDR_GETLANGUAGELIST, false, 0)) return CodeList;
1157   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1158   if (vresp->noResponse() || vresp->end())
1159   {
1160     delete vresp;
1161     return CodeList;
1162   }
1163   CodeList.clear();
1164   while (!vresp->end())
1165   {
1166     char* c_code = vresp->extractString();
1167     char* c_name = vresp->extractString();
1168     string code = c_code;
1169     string name = c_name;
1170     CodeList[code] = name;
1171     delete[] c_code;
1172     delete[] c_name;
1173   }
1174   delete vresp;
1175   return CodeList;
1176 }
1177
1178 int VDR::getLanguageContent(const std::string code, I18n::trans_table& texts)
1179 {
1180   VDR_RequestPacket vrp;
1181   if (!vrp.init(VDR_GETLANGUAGECONTENT, false, 0)) return 0;
1182   if (!vrp.addString(code.c_str())) return 0;
1183   VDR_ResponsePacket* vresp = RequestResponse(&vrp);
1184   if (vresp->noResponse()) { delete vresp; return 0; }
1185   texts.clear();
1186   while (!vresp->end())
1187   {
1188     char* c_key = vresp->extractString();
1189     char* c_text = vresp->extractString();
1190     string key = c_key;
1191     string text = c_text;
1192     texts[key] = text;
1193     delete[] c_key;
1194     delete[] c_text;
1195   }
1196   delete vresp;
1197   return 1;
1198 }