vompclientrrproc.c

   1 /*
   2     Copyright 2008 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 <stdlib.h>
  22
  23 #ifndef VOMPSTANDALONE
  24 #include <vdr/recording.h>
  25 #include <vdr/channels.h>
  26 #include <vdr/videodir.h>
  27 #include <vdr/plugin.h>
  28 #include <vdr/timers.h>
  29 #include <vdr/menu.h>
  30 #include "recplayer.h"
  31 #include "mvpreceiver.h"
  32 #endif
  33
  34 #include "vompclientrrproc.h"
  35 #include "vompclient.h"
  36 #include "log.h"
  37 #include "media.h"
  38 #include "mediaplayer.h"
  39 #include "servermediafile.h"
  40 #include "i18n.h"
  41 #include "vdrcommand.h"
  42
  43 bool ResumeIDLock;
  44
  45 #define VOMP_PROTOCOLL_VERSION 0x00000100
  46 // format is aabbccdd
  47 // cc is release protocol version, increase with every release, that changes protocoll
  48 // dd is development protocol version, set to zero at every release,
  49 // increase for every protocoll change in git
  50 // bb not equal zero should indicate a non loggytronic protocoll
  51 // aa is reserved for future use
  52
  53 VompClientRRProc::VompClientRRProc(VompClient& x)
  54  : x(x)
  55 {
  56   log = Log::getInstance();
  57   req = NULL;
  58   resp = NULL;
  59 }
  60
  61 VompClientRRProc::~VompClientRRProc()
  62 {
  63   threadStop();
  64 }
  65
  66 bool VompClientRRProc::init()
  67 {
  68   int a = threadStart();
  69   sleep(1);
  70   return a;
  71 }
  72
  73 bool VompClientRRProc::recvRequest(RequestPacket* newRequest)
  74 {
  75   /*
  76      Accept a new request
  77      Now we have a queue system is used,
  78      since on rare occasion the client fire two request at once
  79      e.g. heavily channel switching
  80      then processing only a single request would cause a deadlock in the client
  81      Marten
  82   */
  83
  84   log->log("RRProc", Log::DEBUG, "recvReq");
  85   threadLock();
  86   req_queue.push(newRequest);
  87   threadSignalNoLock();
  88   log->log("RRProc", Log::DEBUG, "recvReq set req and signalled");
  89   threadUnlock();
  90
  91   return true;
  92 }
  93
  94 void VompClientRRProc::threadMethod()
  95 {
  96   threadLock();
  97   log->log("RRProc", Log::DEBUG, "threadMethod startup");
  98
  99   if (req_queue.size() != 0)
 100   {
 101 /*
 102 -    log->log("RRProc", Log::ERR, "threadMethod err 1");
 103 -    threadUnlock();
 104 -    return;
 105
 106 That was how the code used to be.
 107
 108 TODO: Work out why this happens.
 109 */
 110
 111     log->log("RRProc", Log::ERR, "threadMethod startup with already queued packets");
 112     while (req_queue.size())
 113     {
 114       //log->log("RRProc", Log::DEBUG, "thread while");
 115       req = req_queue.front();
 116       req_queue.pop();
 117
 118       threadUnlock(); // allow recvRequest to be queuing packets while we are working on this one
 119
 120       if (!processPacket())
 121       {
 122         log->log("RRProc", Log::ERR, "processPacket exited with fail");
 123         return;
 124       }
 125
 126       threadLock();
 127     }
 128     log->log("RRProc", Log::ERR, "threadMethod startup with already queued packets done.");
 129
 130   }
 131
 132   while(1)
 133   {
 134     log->log("RRProc", Log::DEBUG, "threadMethod waiting");
 135     threadWaitForSignal();  // unlocks, waits, relocks
 136     if (req_queue.size() == 0)
 137     {
 138       log->log("RRProc", Log::INFO, "threadMethod err 2 or quit");
 139       threadUnlock();
 140       return;
 141     }
 142
 143     // signalled with something in queue
 144
 145     log->log("RRProc", Log::DEBUG, "thread woken with req, queue size: %i", req_queue.size());
 146
 147     while (req_queue.size())
 148     {
 149       //log->log("RRProc", Log::DEBUG, "thread while");
 150       req = req_queue.front();
 151       req_queue.pop();
 152
 153       threadUnlock(); // allow recvRequest to be queuing packets while we are working on this one
 154
 155       if (!processPacket())
 156       {
 157         log->log("RRProc", Log::ERR, "processPacket exited with fail");
 158         return;
 159       }
 160
 161       threadLock();
 162     }
 163
 164     // locked and run out of packets to process
 165   }
 166 }
 167
 168 bool VompClientRRProc::processPacket()
 169 {
 170   resp = new ResponsePacket();
 171   if (!resp->init(req->requestID))
 172   {
 173     log->log("RRProc", Log::ERR, "response packet init fail");
 174     delete resp;
 175
 176     if (req->data) free(req->data);
 177     delete req;
 178     req = NULL;
 179
 180     return false;
 181   }
 182
 183   int result = 0;
 184
 185   switch(req->opcode)
 186   {
 187     case 1:
 188       result = processLogin();
 189       break;
 190 #ifndef VOMPSTANDALONE
 191     case 2:
 192       result = processGetRecordingsList();
 193       break;
 194     case 3:
 195       result = processDeleteRecording();
 196       break;
 197     case 5:
 198       result = processGetChannelsList();
 199       break;
 200     case 6:
 201       result = processStartStreamingChannel();
 202       break;
 203     case 7:
 204       result = processGetBlock();
 205       break;
 206     case 8:
 207       result = processStopStreaming();
 208       break;
 209     case 9:
 210       result = processStartStreamingRecording();
 211       break;
 212     case 10:
 213       result = processGetChannelSchedule();
 214       break;
 215 #endif
 216     case 11:
 217       result = processConfigSave();
 218       break;
 219     case 12:
 220       result = processConfigLoad();
 221       break;
 222 #ifndef VOMPSTANDALONE
 223     case 13:
 224       result = processReScanRecording();         // FIXME obselete
 225       break;
 226     case 14:
 227       result = processGetTimers();
 228       break;
 229     case 15:
 230       result = processSetTimer();
 231       break;
 232     case 16:
 233       result = processPositionFromFrameNumber();
 234       break;
 235     case 17:
 236       result = processFrameNumberFromPosition();
 237       break;
 238     case 18:
 239       result = processMoveRecording();
 240       break;
 241     case 19:
 242       result = processGetIFrame();
 243       break;
 244     case 20:
 245       result = processGetRecInfo();
 246       break;
 247     case 21:
 248       result = processGetMarks();
 249       break;
 250     case 22:
 251       result = processGetChannelPids();
 252       break;
 253     case 23:
 254       result = processDeleteTimer();
 255       break;
 256 #endif
 257     case VDR_GETMEDIALIST:
 258       result = processGetMediaList();
 259       break;
 260     case VDR_OPENMEDIA:
 261       result = processOpenMedia();
 262       break;
 263     case VDR_GETMEDIABLOCK:
 264       result = processGetMediaBlock();
 265       break;
 266     case 33:
 267       result = processGetLanguageList();
 268       break;
 269     case 34:
 270       result = processGetLanguageContent();
 271       break;
 272     case VDR_GETMEDIAINFO:
 273             result = processGetMediaInfo();
 274             break;
 275     case VDR_CLOSECHANNEL:
 276             result = processCloseMediaChannel();
 277             break;
 278     case 37:
 279       result = processSetCharset();
 280       break;
 281   }
 282
 283   delete resp;
 284   resp = NULL;
 285
 286   if (req->data) free(req->data);
 287   delete req;
 288   req = NULL;
 289
 290   if (result) return true;
 291   return false;
 292 }
 293
 294 int VompClientRRProc::processLogin()
 295 {
 296   if (req->dataLength != 6) return 0;
 297
 298   // Open the config
 299
 300   char configFileName[PATH_MAX];
 301   snprintf(configFileName, PATH_MAX, "%s/vomp-%02X-%02X-%02X-%02X-%02X-%02X.conf", x.configDir, req->data[0], req->data[1], req->data[2], req->data[3], req->data[4], req->data[5]);
 302   x.config.init(configFileName);
 303
 304   // Send the login reply
 305
 306   time_t timeNow = time(NULL);
 307   struct tm* timeStruct = localtime(&timeNow);
 308   int timeOffset = timeStruct->tm_gmtoff;
 309
 310   resp->addULONG(timeNow);
 311   resp->addLONG(timeOffset);
 312   resp->addULONG(VOMP_PROTOCOLL_VERSION);
 313   resp->finalise();
 314   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 315   log->log("RRProc", Log::DEBUG, "written login reply len %lu", resp->getLen());
 316
 317   x.loggedIn = true;
 318   x.netLog(); // safe to run here since the client won't start net logging for a while yet
 319
 320   return 1;
 321 }
 322
 323 int VompClientRRProc::processSetCharset()
 324 {
 325   int charset = ntohl(*(ULONG*)req->data);
 326   if (charset>0 && charset<3)
 327   {
 328     log->log("RRProc", Log::DEBUG, "Set charset to %d", charset);
 329     x.setCharset(charset);
 330     resp->addULONG(1);
 331   }
 332   else
 333   {
 334     log->log("RRProc", Log::DEBUG, "Invalid charset %d", charset);
 335     resp->addULONG(0);
 336   }
 337   resp->finalise();
 338   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 339   return 1;
 340 }
 341
 342 int VompClientRRProc::processConfigSave()
 343 {
 344   char* section = (char*)req->data;
 345   char* key = NULL;
 346   char* value = NULL;
 347
 348   for (UINT k = 0; k < req->dataLength; k++)
 349   {
 350     if (req->data[k] == '\0')
 351     {
 352       if (!key)
 353       {
 354         key = (char*)&req->data[k+1];
 355       }
 356       else
 357       {
 358         value = (char*)&req->data[k+1];
 359         break;
 360       }
 361     }
 362   }
 363
 364   // if the last string (value) doesnt have null terminator, give up
 365   if (req->data[req->dataLength - 1] != '\0') return 0;
 366
 367   log->log("RRProc", Log::DEBUG, "Config save: %s %s %s", section, key, value);
 368   if (x.config.setValueString(section, key, value))
 369   {
 370     resp->addULONG(1);
 371   }
 372   else
 373   {
 374     resp->addULONG(0);
 375   }
 376
 377   resp->finalise();
 378   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 379
 380   return 1;
 381 }
 382
 383 int VompClientRRProc::processConfigLoad()
 384 {
 385   char* section = (char*)req->data;
 386   char* key = NULL;
 387
 388   for (UINT k = 0; k < req->dataLength; k++)
 389   {
 390     if (req->data[k] == '\0')
 391     {
 392       key = (char*)&req->data[k+1];
 393       break;
 394     }
 395   }
 396
 397   char* value = x.config.getValueString(section, key);
 398
 399   if (value)
 400   {
 401     resp->addString(value);//client coding, do not touch
 402     log->log("RRProc", Log::DEBUG, "Written config load packet");
 403     delete[] value;
 404   }
 405   else
 406   {
 407     resp->addULONG(0);
 408     log->log("RRProc", Log::DEBUG, "Written config load failed packet");
 409   }
 410
 411   resp->finalise();
 412   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 413
 414   return 1;
 415 }
 416
 417
 418 //helper for sending from a serialize buffer
 419 //insert the used len into the first 4 Bytes of the buffer
 420 void VompClientRRProc::sendPacket(SerializeBuffer *b) {
 421   resp->copyin(b->getStart(),b->getCurrent()-b->getStart());
 422   resp->finalise();
 423   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 424 }
 425
 426 /**
 427   * media List Request:
 428   * Media List response:
 429   * flags, mediaList
 430 */
 431 #define MLISTBUF 500000
 432 int VompClientRRProc::processGetMediaList()
 433 {
 434   SerializeBuffer buffer(req->data,req->dataLength);
 435   MediaURI uri(0,NULL,NULL);
 436   VDR_GetMediaListRequest request(&uri);
 437   if (request.deserialize(&buffer) != 0) {
 438     log->log("Client", Log::ERR, "getMediaList unable to deserialize");
 439     return 0;
 440   }
 441   const char *dirname=uri.getName();
 442   log->log("Client", Log::DEBUG, "getMediaList for %s", dirname);
 443
 444   MediaList * ml=NULL;
 445   if (dirname == NULL) {
 446     ml=x.media->getRootList();
 447   } else {
 448     ml=x.media->getMediaList(&uri);
 449   }
 450   if (ml == NULL) {
 451      log->log("Client", Log::ERR, "getMediaList returned NULL");
 452      return 0;
 453   }
 454   SerializeBuffer rbuf(MLISTBUF,false,true);
 455   ULONG flags=0; //TODO: real error handling by setting flags
 456   VDR_GetMediaListResponse response(&flags,ml);
 457   if (response.serialize(&rbuf) != 0) {
 458      log->log("Client", Log::ERR, "getMediaList returned NULL");
 459      delete ml;
 460      return 0;
 461   }
 462   log->log("Client", Log::DEBUG, "getMediaList size  %u", ml->size());
 463   delete ml;
 464
 465
 466   sendPacket(&rbuf);
 467   log->log("Client", Log::DEBUG, "Written Media list");
 468   return 1;
 469 }
 470 /**
 471   * openMedia Request:
 472   * openMedia response:
 473 */
 474 int VompClientRRProc::processOpenMedia()
 475 {
 476   SerializeBuffer buffer(req->data,req->dataLength);
 477   MediaURI uri(0,NULL,NULL);
 478   ULONG channel=0;
 479   ULONG xs=0;
 480   ULONG ys=0;
 481   VDR_OpenMediumRequest request(&channel,&uri,&xs,&ys);
 482   if (request.deserialize(&buffer) != 0) {
 483     log->log("Client", Log::ERR, "openMediaRequest unable to deserialize");
 484     return 0;
 485   }
 486   const char *name=uri.getName();
 487   log->log("Client", Log::DEBUG, "openMediaRequest for %s", name);
 488   ULLONG size=0;
 489   int rt=x.media->openMedium(channel,&uri,&size,xs,ys);
 490   ULONG flags=0;
 491   if (rt != 0) {
 492     size=0;
 493     flags=1;
 494     log->log("Client", Log::ERR, "openMediaRequest unable to open");
 495   }
 496   VDR_OpenMediumResponse response(&flags,&size);
 497   SerializeBuffer rbuf(response.getSerializedLen()+4,false,true);
 498   if (response.serialize(&rbuf) != 0) {
 499      log->log("Client", Log::ERR, "openMediaRequest cannot serialize");
 500      return 0;
 501   }
 502   log->log("Client", Log::DEBUG, "openMediaRequest size  %llu", size);
 503   sendPacket(&rbuf);
 504   return 1;
 505 }
 506 /**
 507   * VDR_GETMEDIABLOCK
 508   * resp
 509   * packet - no serialized response!
 510   */
 511 int VompClientRRProc::processGetMediaBlock()
 512 {
 513   SerializeBuffer buffer(req->data,req->dataLength);
 514   ULLONG position = 0;
 515   ULONG amount = 0;
 516   ULONG channel = 0;
 517   VDR_GetMediaBlockRequest request(&channel,&position,&amount);
 518   if (request.deserialize(&buffer) != 0) {
 519     log->log("Client", Log::ERR, "getMediaBlock unable to deserialize");
 520     return 0;
 521   }
 522   log->log("Client", Log::DEBUG, "getMediaBlock pos = %llu length = %lu,chan=%lu", position, amount,channel);
 523
 524   UCHAR sendBuffer[amount ];
 525   ULONG amountReceived = 0;
 526   UCHAR *rbuf=sendBuffer;
 527   int rt=x.media->getMediaBlock(channel,position,amount,&amountReceived,&rbuf);
 528   if (!amountReceived || rt != 0)
 529   {
 530     log->log("Client", Log::DEBUG, "written 4(0) as getblock got 0");
 531   }
 532   else
 533   {
 534     if (rbuf != sendBuffer) {
 535       //the provider did not use the optimized handling with using my buffer
 536       resp->copyin(rbuf,amountReceived);
 537       free(rbuf);
 538     } else {
 539       // the provider did not allocate a new buffer
 540       resp->copyin(sendBuffer,amountReceived);
 541     }
 542   }
 543   resp->finalise();
 544   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 545   log->log("Client", Log::DEBUG, "written ok %lu", amountReceived);
 546   return 1;
 547 }
 548 /**
 549   * VDR_GETMEDIAINFO
 550   */
 551
 552 int VompClientRRProc::processGetMediaInfo()
 553 {
 554   SerializeBuffer buffer(req->data,req->dataLength);
 555   ULONG channel=0;
 556   VDR_GetMediaInfoRequest request(&channel);
 557   if (request.deserialize(&buffer) != 0) {
 558     log->log("Client", Log::ERR, "getMediaInfo unable to deserialize");
 559     return 0;
 560   }
 561   log->log("Client", Log::DEBUG, "getMediaInfo chan=%lu", channel);
 562   ULONG flags=0;
 563   MediaInfo mi;
 564   int rt=x.media->getMediaInfo(channel,&mi);
 565   if (rt != 0) {
 566     flags=1;
 567     log->log("Client", Log::ERR, "getMediaInfo unable to get");
 568   }
 569   VDR_GetMediaInfoResponse response(&flags,&mi);
 570   SerializeBuffer rbuf(response.getSerializedLen()+4,false,true);
 571   if (response.serialize(&rbuf) != 0) {
 572      log->log("Client", Log::ERR, "getMediaInfo cannot serialize");
 573      return 0;
 574   }
 575   sendPacket(&rbuf);
 576   return 1;
 577 }
 578
 579 /**
 580   * VDR_CLOSECHANNEL
 581   */
 582
 583
 584 int VompClientRRProc::processCloseMediaChannel()
 585 {
 586   SerializeBuffer buffer(req->data,req->dataLength);
 587   ULONG channel=0;
 588   VDR_CloseMediaChannelRequest request(&channel);
 589   if (request.deserialize(&buffer) != 0) {
 590     log->log("Client", Log::ERR, "closeMediaChannel unable to deserialize");
 591     return 0;
 592   }
 593   ULONG flags=0;
 594   log->log("Client", Log::DEBUG, "closeMediaChannel chan=%lu", channel);
 595   int rt=x.media->closeMediaChannel(channel);
 596   if (rt != 0) {
 597     flags=1;
 598     log->log("Client", Log::ERR, "closeMediaChannel unable to get");
 599   }
 600   VDR_CloseMediaChannelResponse response(&flags);
 601   SerializeBuffer rbuf(response.getSerializedLen()+4,false,true);
 602   if (response.serialize(&rbuf) != 0) {
 603      log->log("Client", Log::ERR, "closeMediaChannel cannot serialize");
 604      return 0;
 605   }
 606   sendPacket(&rbuf);
 607   return 1;
 608 }
 609
 610
 611
 612 int VompClientRRProc::processGetLanguageList()
 613 {
 614   x.i18n.findLanguages();
 615   const I18n::lang_code_list& languages = x.i18n.getLanguageList();
 616   std::string result;
 617   I18n::lang_code_list::const_iterator iter;
 618   for (iter = languages.begin(); iter != languages.end(); ++iter)
 619   {
 620     resp->addString(iter->first.c_str()); // Source code is acsii
 621     resp->addString(x.charconvutf8->Convert(iter->second.c_str())); //translate string can be any utf-8 character
 622   }
 623   resp->finalise();
 624   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 625   return 1;
 626 }
 627
 628 int VompClientRRProc::processGetLanguageContent()
 629 {
 630   if (req->dataLength <= 0) return 0;
 631   std::string code, result;
 632   code.assign((char*)req->data, req->dataLength - 1);
 633   x.i18n.findLanguages();
 634   I18n::trans_table texts = x.i18n.getLanguageContent(code);
 635   I18n::trans_table::const_iterator iter;
 636   for (iter = texts.begin(); iter != texts.end(); ++iter)
 637   {
 638     resp->addString(iter->first.c_str());// source code is acsii since it is english
 639     resp->addString(x.charconvutf8->Convert(iter->second.c_str())); // translate text can be any unicode string, it is stored as UTF-8
 640   }
 641   resp->finalise();
 642   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 643   return 1;
 644 }
 645
 646 #ifndef VOMPSTANDALONE
 647
 648 int VompClientRRProc::processGetRecordingsList()
 649 {
 650   int FreeMB;
 651   int Percent = VideoDiskSpace(&FreeMB);
 652   int Total = (FreeMB / (100 - Percent)) * 100;
 653
 654   resp->addULONG(Total);
 655   resp->addULONG(FreeMB);
 656   resp->addULONG(Percent);
 657
 658   cRecordings Recordings;
 659   Recordings.Load();
 660
 661   for (cRecording *recording = Recordings.First(); recording; recording = Recordings.Next(recording))
 662   {
 663 #if VDRVERSNUM < 10721
 664     resp->addULONG(recording->start);
 665 #else
 666     resp->addULONG(recording->Start());
 667 #endif
 668     resp->addString(x.charconvsys->Convert(recording->Name())); //coding of recording name is system dependent
 669     resp->addString(recording->FileName());//file name are not  visible by user do not touch
 670   }
 671
 672   resp->finalise();
 673   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 674
 675   log->log("RRProc", Log::DEBUG, "Written recordings list");
 676
 677   return 1;
 678 }
 679
 680 int VompClientRRProc::processDeleteRecording()
 681 {
 682   // data is a pointer to the fileName string
 683
 684   cRecordings Recordings;
 685   Recordings.Load(); // probably have to do this
 686
 687   cRecording* recording = Recordings.GetByName((char*)req->data);
 688
 689   log->log("RRProc", Log::DEBUG, "recording pointer %p", recording);
 690
 691   if (recording)
 692   {
 693     log->log("RRProc", Log::DEBUG, "deleting recording: %s", recording->Name());
 694
 695     cRecordControl *rc = cRecordControls::GetRecordControl(recording->FileName());
 696     if (!rc)
 697     {
 698       if (recording->Delete())
 699       {
 700         // Copy svdrp's way of doing this, see if it works
 701 #if VDRVERSNUM > 10300
 702         ::Recordings.DelByName(recording->FileName());
 703 #endif
 704         resp->addULONG(1);
 705       }
 706       else
 707       {
 708         resp->addULONG(2);
 709       }
 710     }
 711     else
 712     {
 713       resp->addULONG(3);
 714     }
 715   }
 716   else
 717   {
 718     resp->addULONG(4);
 719   }
 720
 721   resp->finalise();
 722   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 723
 724   return 1;
 725 }
 726
 727 int VompClientRRProc::processMoveRecording()
 728 {
 729   log->log("RRProc", Log::DEBUG, "Process move recording");
 730   char* fileName = (char*)req->data;
 731   char* newPath = NULL;
 732
 733   for (UINT k = 0; k < req->dataLength; k++)
 734   {
 735     if (req->data[k] == '\0')
 736     {
 737       newPath = (char*)&req->data[k+1];
 738       break;
 739     }
 740   }
 741   if (!newPath) return 0;
 742
 743   cRecordings Recordings;
 744   Recordings.Load(); // probably have to do this
 745
 746   cRecording* recording = Recordings.GetByName((char*)fileName);
 747
 748   log->log("RRProc", Log::DEBUG, "recording pointer %p", recording);
 749
 750   if (recording)
 751   {
 752     cRecordControl *rc = cRecordControls::GetRecordControl(recording->FileName());
 753     if (!rc)
 754     {
 755       log->log("RRProc", Log::DEBUG, "moving recording: %s", recording->Name());
 756       log->log("RRProc", Log::DEBUG, "moving recording: %s", recording->FileName());
 757       log->log("RRProc", Log::DEBUG, "to: %s", newPath);
 758
 759       const char* t = recording->FileName();
 760
 761       char* dateDirName = NULL;   int k;
 762       char* titleDirName = NULL;  int j;
 763
 764       // Find the datedirname
 765       for(k = strlen(t) - 1; k >= 0; k--)
 766       {
 767         if (t[k] == '/')
 768         {
 769           log->log("RRProc", Log::DEBUG, "l1: %i", strlen(&t[k+1]) + 1);
 770           dateDirName = new char[strlen(&t[k+1]) + 1];
 771           strcpy(dateDirName, &t[k+1]);
 772           break;
 773         }
 774       }
 775
 776       // Find the titledirname
 777
 778       for(j = k-1; j >= 0; j--)
 779       {
 780         if (t[j] == '/')
 781         {
 782           log->log("RRProc", Log::DEBUG, "l2: %i", (k - j - 1) + 1);
 783           titleDirName = new char[(k - j - 1) + 1];
 784           memcpy(titleDirName, &t[j+1], k - j - 1);
 785           titleDirName[k - j - 1] = '\0';
 786           break;
 787         }
 788       }
 789
 790       log->log("RRProc", Log::DEBUG, "datedirname: %s", dateDirName);
 791       log->log("RRProc", Log::DEBUG, "titledirname: %s", titleDirName);
 792       log->log("RRProc", Log::DEBUG, "viddir: %s", VideoDirectory);
 793
 794       char* newPathConv = new char[strlen(newPath)+1];
 795       strcpy(newPathConv, newPath);
 796       ExchangeChars(newPathConv, true);
 797       log->log("RRProc", Log::DEBUG, "EC: %s", newPathConv);
 798
 799       char* newContainer = new char[strlen(VideoDirectory) + strlen(newPathConv) + strlen(titleDirName) + 1];
 800       log->log("RRProc", Log::DEBUG, "l10: %i", strlen(VideoDirectory) + strlen(newPathConv) + strlen(titleDirName) + 1);
 801       sprintf(newContainer, "%s%s%s", VideoDirectory, newPathConv, titleDirName);
 802       delete[] newPathConv;
 803
 804       log->log("RRProc", Log::DEBUG, "%s", newContainer);
 805
 806       struct stat dstat;
 807       int statret = stat(newContainer, &dstat);
 808       if ((statret == -1) && (errno == ENOENT)) // Dir does not exist
 809       {
 810         log->log("RRProc", Log::DEBUG, "new dir does not exist");
 811         int mkdirret = mkdir(newContainer, 0755);
 812         if (mkdirret != 0)
 813         {
 814           delete[] dateDirName;
 815           delete[] titleDirName;
 816           delete[] newContainer;
 817
 818           resp->addULONG(5);
 819           resp->finalise();
 820           x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 821           return 1;
 822         }
 823       }
 824       else if ((statret == 0) && (! (dstat.st_mode && S_IFDIR))) // Something exists but it's not a dir
 825       {
 826         delete[] dateDirName;
 827         delete[] titleDirName;
 828         delete[] newContainer;
 829
 830         resp->addULONG(5);
 831         resp->finalise();
 832         x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 833         return 1;
 834       }
 835
 836       // Ok, the directory container has been made, or it pre-existed.
 837
 838       char* newDir = new char[strlen(newContainer) + 1 + strlen(dateDirName) + 1];
 839       sprintf(newDir, "%s/%s", newContainer, dateDirName);
 840
 841       log->log("RRProc", Log::DEBUG, "doing rename '%s' '%s'", t, newDir);
 842       int renameret = rename(t, newDir);
 843       if (renameret == 0)
 844       {
 845         // Success. Test for remove old dir containter
 846         char* oldTitleDir = new char[k+1];
 847         memcpy(oldTitleDir, t, k);
 848         oldTitleDir[k] = '\0';
 849         log->log("RRProc", Log::DEBUG, "len: %i, cp: %i, strlen: %i, oldtitledir: %s", k+1, k, strlen(oldTitleDir), oldTitleDir);
 850         rmdir(oldTitleDir); // can't do anything about a fail result at this point.
 851         delete[] oldTitleDir;
 852       }
 853
 854       if (renameret == 0)
 855       {
 856 #if VDRVERSNUM > 10311
 857         // Tell VDR
 858         ::Recordings.Update();
 859 #endif
 860         // Success. Send a different packet from just a ulong
 861         resp->addULONG(1); // success
 862         resp->addString(newDir); //system depent do not convert
 863       }
 864       else
 865       {
 866         resp->addULONG(5);
 867       }
 868
 869       resp->finalise();
 870       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 871
 872       delete[] dateDirName;
 873       delete[] titleDirName;
 874       delete[] newContainer;
 875       delete[] newDir;
 876     }
 877     else
 878     {
 879       resp->addULONG(3);
 880       resp->finalise();
 881       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 882     }
 883   }
 884   else
 885   {
 886     resp->addULONG(4);
 887     resp->finalise();
 888     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 889   }
 890
 891   return 1;
 892 }
 893
 894 int VompClientRRProc::processGetChannelsList()
 895 {
 896   ULONG type;
 897
 898   char* chanConfig = x.config.getValueString("General", "Channels");
 899   int allChans = 1;
 900   if (chanConfig) allChans = strcasecmp(chanConfig, "FTA only");
 901
 902   for (cChannel *channel = Channels.First(); channel; channel = Channels.Next(channel))
 903   {
 904 #if VDRVERSNUM < 10300
 905     if (!channel->GroupSep() && (!channel->Ca() || allChans))
 906 #else
 907     if (!channel->GroupSep() && (!channel->Ca(0) || allChans))
 908 #endif
 909     {
 910       log->log("RRProc", Log::DEBUG, "name: '%s'", channel->Name());
 911
 912       if (channel->Vpid()) type = 1;
 913 #if VDRVERSNUM < 10300
 914       else type = 2;
 915 #else
 916       else if (channel->Apid(0)) type = 2;
 917       else continue;
 918 #endif
 919
 920       resp->addULONG(channel->Number());
 921       resp->addULONG(type);
 922       resp->addString(x.charconvsys->Convert(channel->Name()));
 923 #if VDRVERSNUM < 10703
 924       resp->addULONG(2);
 925 #else
 926       resp->addULONG(channel->Vtype());
 927 #endif
 928     }
 929   }
 930
 931   resp->finalise();
 932   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 933
 934   log->log("RRProc", Log::DEBUG, "Written channels list");
 935
 936   return 1;
 937 }
 938
 939 int VompClientRRProc::processGetChannelPids()
 940 {
 941   ULONG channelNumber = ntohl(*(ULONG*)req->data);
 942
 943   cChannel* channel = x.channelFromNumber(channelNumber);
 944   if (!channel)
 945   {
 946     resp->addULONG(0);
 947     resp->finalise();
 948     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
 949     return 1;
 950   }
 951
 952   ULONG numApids = 0;
 953   ULONG numDpids = 0;
 954   ULONG numSpids = 0;
 955
 956
 957 #if VDRVERSNUM < 10300
 958
 959   log->log("RRProc", Log::DEBUG, "Apid1: %i", channel->Apid1());
 960   log->log("RRProc", Log::DEBUG, "Apid2: %i", channel->Apid2());
 961
 962   if (channel->Apid2())
 963     numApids = 2;
 964   else if (channel->Apid1())
 965     numApids = 1;
 966   else
 967     numApids = 0;
 968
 969 #else
 970
 971   for (const int *Apid = channel->Apids(); *Apid; Apid++)
 972   {
 973     numApids++;
 974   }
 975   for (const int *Dpid = channel->Dpids(); *Dpid; Dpid++)
 976   {
 977     numDpids++;
 978   }
 979   for (const int *Spid = channel->Spids(); *Spid; Spid++)
 980   {
 981     numSpids++;
 982   }
 983 #endif
 984
 985
 986   // Format of response
 987   // vpid
 988   // number of apids
 989   // {
 990   //    apid
 991   //    lang string
 992   // }
 993   // number of dpids
 994   // {
 995   //    dpid
 996   //    lang string
 997   // }
 998   // number of spids
 999   // {
1000   //    spid
1001   //    lang string
1002   // }
1003   // tpid
1004
1005   resp->addULONG(channel->Vpid());
1006 #if VDRVERSNUM < 10703
1007   resp->addULONG(2);
1008 #else
1009   resp->addULONG(channel->Vtype());
1010 #endif
1011   resp->addULONG(numApids);
1012
1013 #if VDRVERSNUM < 10300
1014   if (numApids >= 1)
1015   {
1016     resp->addULONG(channel->Apid1());
1017     resp->addString("");
1018   }
1019   if (numApids == 2)
1020   {
1021     resp->addULONG(channel->Apid2());
1022     resp->addString("");
1023   }
1024   resp->addULONG(0);
1025   resp->addULONG(0);
1026 #else
1027   for (ULONG i = 0; i < numApids; i++)
1028   {
1029     resp->addULONG(channel->Apid(i));
1030     resp->addString(x.charconvsys->Convert(channel->Alang(i)));
1031   }
1032   resp->addULONG(numDpids);
1033   for (ULONG i = 0; i < numDpids; i++)
1034   {
1035     resp->addULONG(channel->Dpid(i));
1036     resp->addString(x.charconvsys->Convert(channel->Dlang(i)));
1037   }
1038   resp->addULONG(numSpids);
1039   for (ULONG i = 0; i < numSpids; i++)
1040   {
1041     resp->addULONG(channel->Spid(i));
1042     resp->addString(x.charconvsys->Convert(channel->Slang(i)));
1043   }
1044 #endif
1045   resp->addULONG(channel->Tpid());
1046   // Format of extended response, for compatibility with older client at the end
1047   // {
1048   //    atypes
1049   // }
1050   // {
1051   //    dtypes
1052   // }
1053   // {
1054   //    stypes
1055   //    comppageid
1056   //    ancpageids
1057   // }
1058 #if VDRVERSNUM < 10300
1059   if (numApids >= 1)
1060   {
1061     resp->addULONG(4);
1062   }
1063   if (numApids == 2)
1064   {
1065     resp->addULONG(4);
1066   }
1067 #else
1068   for (ULONG i = 0; i < numApids; i++)
1069   {
1070 #if VDRVERSNUM < 10715
1071     resp->addULONG(4);
1072 #else
1073     resp->addULONG(channel->Atype(i));
1074 #endif
1075   }
1076   for (ULONG i = 0; i < numDpids; i++)
1077   {
1078 #if VDRVERSNUM < 10715
1079     resp->addULONG(0x6A /*AC3*/);
1080 #else
1081     resp->addULONG(channel->Dtype(i));
1082 #endif
1083   }
1084   for (ULONG i = 0; i < numSpids; i++)
1085   {
1086 #if VDRVERSNUM < 10715
1087     resp->addULONG(0);
1088     resp->addULONG(0);
1089     resp->addULONG(0);
1090 #else
1091     resp->addULONG(channel->SubtitlingType(i));
1092     resp->addULONG(channel->CompositionPageId(i));
1093     resp->addULONG(channel->AncillaryPageId(i));
1094 #endif
1095   }
1096 #endif
1097
1098
1099   resp->finalise();
1100   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1101
1102   log->log("RRProc", Log::DEBUG, "Written channels pids");
1103
1104   return 1;
1105 }
1106
1107 int VompClientRRProc::processStartStreamingChannel()
1108 {
1109   if (x.lp)
1110   {
1111     log->log("RRProc", Log::ERR, "Client called start streaming twice");
1112     return 0;
1113   }
1114
1115   log->log("RRProc", Log::DEBUG, "req->dataLength = %i", req->dataLength);
1116   ULONG channelNumber = ntohl(*(ULONG*)req->data);
1117
1118   cChannel* channel = x.channelFromNumber(channelNumber);
1119   if (!channel)
1120   {
1121     resp->addULONG(0);
1122     resp->finalise();
1123     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1124     return 1;
1125   }
1126
1127   // get the priority we should use
1128   int fail = 1;
1129   int priority = x.config.getValueLong("General", "Live priority", &fail);
1130   if (!fail)
1131   {
1132     log->log("RRProc", Log::DEBUG, "Config: Live TV priority: %i", priority);
1133   }
1134   else
1135   {
1136     log->log("RRProc", Log::DEBUG, "Config: Live TV priority config fail");
1137     priority = 0;
1138   }
1139
1140   // a bit of sanity..
1141 #if VDRVERSNUM < 10725
1142   if (priority < 0) priority = 0;
1143 #else
1144   if (priority < -99) priority = -99;
1145 #endif
1146   if (priority > 99) priority = 99;
1147
1148   log->log("RRProc", Log::DEBUG, "Using live TV priority %i", priority);
1149   x.lp = MVPReceiver::create(channel, priority);
1150
1151   if (!x.lp)
1152   {
1153     resp->addULONG(0);
1154     resp->finalise();
1155     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1156     return 1;
1157   }
1158
1159   if (!x.lp->init(&x.tcp, req->requestID))
1160   {
1161     delete x.lp;
1162     x.lp = NULL;
1163     resp->addULONG(0);
1164     resp->finalise();
1165     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1166     return 1;
1167   }
1168
1169   resp->addULONG(1);
1170   resp->finalise();
1171   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1172   return 1;
1173 }
1174
1175 int VompClientRRProc::processStopStreaming()
1176 {
1177   log->log("RRProc", Log::DEBUG, "STOP STREAMING RECEIVED");
1178   if (x.lp)
1179   {
1180     x.lp->detachMVPReceiver();
1181     delete x.lp;
1182     x.lp = NULL;
1183   }
1184   else if (x.recplayer)
1185   {
1186     x.writeResumeData();
1187
1188     delete x.recplayer;
1189     delete x.recordingManager;
1190     x.recplayer = NULL;
1191     x.recordingManager = NULL;
1192   }
1193
1194   resp->addULONG(1);
1195   resp->finalise();
1196   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1197   return 1;
1198 }
1199
1200 int VompClientRRProc::processGetBlock()
1201 {
1202   if (x.lp)
1203   {
1204     log->log("RRProc", Log::ERR, "Get block called during live streaming");
1205     return 0;
1206   }
1207
1208   if (!x.recplayer)
1209   {
1210     log->log("RRProc", Log::ERR, "Get block called when no recording open");
1211     return 0;
1212   }
1213
1214   UCHAR* data = req->data;
1215
1216   ULLONG position = x.ntohll(*(ULLONG*)data);
1217   data += sizeof(ULLONG);
1218   ULONG amount = ntohl(*(ULONG*)data);
1219
1220   log->log("RRProc", Log::DEBUG, "getblock pos = %llu length = %lu", position, amount);
1221
1222   UCHAR sendBuffer[amount];
1223   ULONG amountReceived = x.recplayer->getBlock(&sendBuffer[0], position, amount);
1224
1225   if (!amountReceived)
1226   {
1227     resp->addULONG(0);
1228     log->log("RRProc", Log::DEBUG, "written 4(0) as getblock got 0");
1229   }
1230   else
1231   {
1232     resp->copyin(sendBuffer, amountReceived);
1233     log->log("RRProc", Log::DEBUG, "written %lu", amountReceived);
1234   }
1235
1236   resp->finalise();
1237   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1238   log->log("RRProc", Log::DEBUG, "Finished getblock, have sent %lu", resp->getLen());
1239   return 1;
1240 }
1241
1242 int VompClientRRProc::processStartStreamingRecording()
1243 {
1244   // data is a pointer to the fileName string
1245
1246   x.recordingManager = new cRecordings;
1247   x.recordingManager->Load();
1248
1249   cRecording* recording = x.recordingManager->GetByName((char*)req->data);
1250
1251   log->log("RRProc", Log::DEBUG, "recording pointer %p", recording);
1252
1253   if (recording)
1254   {
1255     x.recplayer = new RecPlayer(recording);
1256
1257     resp->addULLONG(x.recplayer->getLengthBytes());
1258     resp->addULONG(x.recplayer->getLengthFrames());
1259
1260 #if VDRVERSNUM < 10703
1261     resp->addUCHAR(true);//added for TS
1262 #else
1263     resp->addUCHAR(recording->IsPesRecording());//added for TS
1264 #endif
1265
1266     resp->finalise();
1267     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1268
1269     log->log("RRProc", Log::DEBUG, "written totalLength");
1270   }
1271   else
1272   {
1273     delete x.recordingManager;
1274     x.recordingManager = NULL;
1275   }
1276   return 1;
1277 }
1278
1279 int VompClientRRProc::processPositionFromFrameNumber()
1280 {
1281   ULLONG retval = 0;
1282
1283   ULONG frameNumber = ntohl(*(ULONG*)req->data);
1284
1285   if (!x.recplayer)
1286   {
1287     log->log("RRProc", Log::DEBUG, "Rescan recording called when no recording being played!");
1288   }
1289   else
1290   {
1291     retval = x.recplayer->positionFromFrameNumber(frameNumber);
1292   }
1293
1294   resp->addULLONG(retval);
1295   resp->finalise();
1296   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1297
1298   log->log("RRProc", Log::DEBUG, "Wrote posFromFrameNum reply to client");
1299   return 1;
1300 }
1301
1302 int VompClientRRProc::processFrameNumberFromPosition()
1303 {
1304   ULONG retval = 0;
1305
1306   ULLONG position = x.ntohll(*(ULLONG*)req->data);
1307
1308   if (!x.recplayer)
1309   {
1310     log->log("RRProc", Log::DEBUG, "Rescan recording called when no recording being played!");
1311   }
1312   else
1313   {
1314     retval = x.recplayer->frameNumberFromPosition(position);
1315   }
1316
1317   resp->addULONG(retval);
1318   resp->finalise();
1319   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1320
1321   log->log("RRProc", Log::DEBUG, "Wrote frameNumFromPos reply to client");
1322   return 1;
1323 }
1324
1325 int VompClientRRProc::processGetIFrame()
1326 {
1327   bool success = false;
1328
1329   ULONG* data = (ULONG*)req->data;
1330
1331   ULONG frameNumber = ntohl(*data);
1332   data++;
1333   ULONG direction = ntohl(*data);
1334
1335   ULLONG rfilePosition = 0;
1336   ULONG rframeNumber = 0;
1337   ULONG rframeLength = 0;
1338
1339   if (!x.recplayer)
1340   {
1341     log->log("RRProc", Log::DEBUG, "GetIFrame recording called when no recording being played!");
1342   }
1343   else
1344   {
1345     success = x.recplayer->getNextIFrame(frameNumber, direction, &rfilePosition, &rframeNumber, &rframeLength);
1346   }
1347
1348   // returns file position, frame number, length
1349
1350   if (success)
1351   {
1352     resp->addULLONG(rfilePosition);
1353     resp->addULONG(rframeNumber);
1354     resp->addULONG(rframeLength);
1355   }
1356   else
1357   {
1358     resp->addULONG(0);
1359   }
1360
1361   resp->finalise();
1362   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1363
1364   log->log("RRProc", Log::DEBUG, "Wrote GNIF reply to client %llu %lu %lu", rfilePosition, rframeNumber, rframeLength);
1365   return 1;
1366 }
1367
1368 int VompClientRRProc::processGetChannelSchedule()
1369 {
1370   ULONG* data = (ULONG*)req->data;
1371
1372   ULONG channelNumber = ntohl(*data);
1373   data++;
1374   ULONG startTime = ntohl(*data);
1375   data++;
1376   ULONG duration = ntohl(*data);
1377
1378   log->log("RRProc", Log::DEBUG, "get schedule called for channel %lu", channelNumber);
1379
1380   cChannel* channel = x.channelFromNumber(channelNumber);
1381   if (!channel)
1382   {
1383     resp->addULONG(0);
1384     resp->finalise();
1385     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1386
1387     log->log("RRProc", Log::DEBUG, "written 0 because channel = NULL");
1388     return 1;
1389   }
1390
1391   log->log("RRProc", Log::DEBUG, "Got channel");
1392
1393 #if VDRVERSNUM < 10300
1394   cMutexLock MutexLock;
1395   const cSchedules *Schedules = cSIProcessor::Schedules(MutexLock);
1396 #else
1397   cSchedulesLock MutexLock;
1398   const cSchedules *Schedules = cSchedules::Schedules(MutexLock);
1399 #endif
1400   if (!Schedules)
1401   {
1402     resp->addULONG(0);
1403     resp->finalise();
1404     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1405
1406     log->log("RRProc", Log::DEBUG, "written 0 because Schedule!s! = NULL");
1407     return 1;
1408   }
1409
1410   log->log("RRProc", Log::DEBUG, "Got schedule!s! object");
1411
1412   const cSchedule *Schedule = Schedules->GetSchedule(channel->GetChannelID());
1413   if (!Schedule)
1414   {
1415     resp->addULONG(0);
1416     resp->finalise();
1417     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1418
1419     log->log("RRProc", Log::DEBUG, "written 0 because Schedule = NULL");
1420     return 1;
1421   }
1422
1423   log->log("RRProc", Log::DEBUG, "Got schedule object");
1424
1425   const char* empty = "";
1426   bool atLeastOneEvent = false;
1427
1428   ULONG thisEventID;
1429   ULONG thisEventTime;
1430   ULONG thisEventDuration;
1431   const char* thisEventTitle;
1432   const char* thisEventSubTitle;
1433   const char* thisEventDescription;
1434
1435 #if VDRVERSNUM < 10300
1436
1437   const cEventInfo *event;
1438   for (int eventNumber = 0; eventNumber < Schedule->NumEvents(); eventNumber++)
1439   {
1440     event = Schedule->GetEventNumber(eventNumber);
1441
1442     thisEventID = event->GetEventID();
1443     thisEventTime = event->GetTime();
1444     thisEventDuration = event->GetDuration();
1445     thisEventTitle = event->GetTitle();
1446     thisEventSubTitle = event->GetSubtitle();
1447     thisEventDescription = event->GetExtendedDescription();
1448
1449 #else
1450
1451   for (const cEvent* event = Schedule->Events()->First(); event; event = Schedule->Events()->Next(event))
1452   {
1453     thisEventID = event->EventID();
1454     thisEventTime = event->StartTime();
1455     thisEventDuration = event->Duration();
1456     thisEventTitle = event->Title();
1457     thisEventSubTitle = NULL;
1458     thisEventDescription = event->Description();
1459
1460 #endif
1461
1462     //in the past filter
1463     if ((thisEventTime + thisEventDuration) < (ULONG)time(NULL)) continue;
1464
1465     //start time filter
1466     if ((thisEventTime + thisEventDuration) <= startTime) continue;
1467
1468     //duration filter
1469     if (thisEventTime >= (startTime + duration)) continue;
1470
1471     if (!thisEventTitle) thisEventTitle = empty;
1472     if (!thisEventSubTitle) thisEventSubTitle = empty;
1473     if (!thisEventDescription) thisEventDescription = empty;
1474
1475     resp->addULONG(thisEventID);
1476     resp->addULONG(thisEventTime);
1477     resp->addULONG(thisEventDuration);
1478
1479     resp->addString(x.charconvsys->Convert(thisEventTitle));
1480     resp->addString(x.charconvsys->Convert(thisEventSubTitle));
1481     resp->addString(x.charconvsys->Convert(thisEventDescription));
1482
1483     atLeastOneEvent = true;
1484   }
1485
1486   log->log("RRProc", Log::DEBUG, "Got all event data");
1487
1488   if (!atLeastOneEvent)
1489   {
1490     resp->addULONG(0);
1491     log->log("RRProc", Log::DEBUG, "Written 0 because no data");
1492   }
1493
1494   resp->finalise();
1495   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1496
1497   log->log("RRProc", Log::DEBUG, "written schedules packet");
1498
1499   return 1;
1500 }
1501
1502 int VompClientRRProc::processGetTimers()
1503 {
1504   cTimer *timer;
1505   int numTimers = Timers.Count();
1506
1507   resp->addULONG(numTimers);
1508
1509   for (int i = 0; i < numTimers; i++)
1510   {
1511     timer = Timers.Get(i);
1512
1513 #if VDRVERSNUM < 10300
1514     resp->addULONG(timer->Active());
1515 #else
1516     resp->addULONG(timer->HasFlags(tfActive));
1517 #endif
1518     resp->addULONG(timer->Recording());
1519     resp->addULONG(timer->Pending());
1520     resp->addULONG(timer->Priority());
1521     resp->addULONG(timer->Lifetime());
1522     resp->addULONG(timer->Channel()->Number());
1523     resp->addULONG(timer->StartTime());
1524     resp->addULONG(timer->StopTime());
1525     resp->addULONG(timer->Day());
1526     resp->addULONG(timer->WeekDays());
1527     resp->addString(timer->File()); //Filename is system specific and not visible by user
1528   }
1529
1530   resp->finalise();
1531   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1532
1533   log->log("RRProc", Log::DEBUG, "Written timers list");
1534
1535   return 1;
1536 }
1537
1538 int VompClientRRProc::processSetTimer()
1539 {
1540   char* timerString = new char[strlen((char*)req->data) + 1];
1541   strcpy(timerString, (char*)req->data);
1542
1543 #if VDRVERSNUM < 10300
1544
1545   // If this is VDR 1.2 the date part of the timer string must be reduced
1546   // to just DD rather than YYYY-MM-DD
1547
1548   int s = 0; // source
1549   int d = 0; // destination
1550   int c = 0; // count
1551   while(c != 2) // copy up to date section, including the second ':'
1552   {
1553     timerString[d] = req->data[s];
1554     if (req->data[s] == ':') c++;
1555     ++s;
1556     ++d;
1557   }
1558   // now it has copied up to the date section
1559   c = 0;
1560   while(c != 2) // waste YYYY-MM-
1561   {
1562     if (req->data[s] == '-') c++;
1563     ++s;
1564   }
1565   // now source is at the DD
1566   memcpy(&timerString[d], &req->data[s], req->dataLength - s);
1567   d += req->dataLength - s;
1568   timerString[d] = '\0';
1569
1570   log->log("RRProc", Log::DEBUG, "Timer string after 1.2 conversion:");
1571
1572 #endif
1573   log->log("RRProc", Log::DEBUG, "%s", timerString);
1574
1575   cTimer *timer = new cTimer;
1576   if (timer->Parse((char*)timerString))
1577   {
1578     cTimer *t = Timers.GetTimer(timer);
1579     if (!t)
1580     {
1581       Timers.Add(timer);
1582 #if VDRVERSNUM < 10300
1583       Timers.Save();
1584 #else
1585       Timers.SetModified();
1586 #endif
1587       resp->addULONG(0);
1588       resp->finalise();
1589       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1590       return 1; // FIXME - cTimer* timer is leaked here!
1591     }
1592     else
1593     {
1594       resp->addULONG(1);
1595       resp->finalise();
1596       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1597     }
1598   }
1599   else
1600   {
1601     resp->addULONG(2);
1602     resp->finalise();
1603     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1604   }
1605   delete timer;
1606   return 1;
1607 }
1608
1609 int VompClientRRProc::processDeleteTimer()
1610 {
1611   log->log("RRProc", Log::DEBUG, "Delete timer called");
1612   // get timer
1613
1614   int position = 0;
1615
1616   INT delChannel = ntohl(*(ULONG*)&req->data[position]); position += 4;
1617   INT delWeekdays = ntohl(*(ULONG*)&req->data[position]); position += 4;
1618   INT delDay = ntohl(*(ULONG*)&req->data[position]); position += 4;
1619   INT delStart = ntohl(*(ULONG*)&req->data[position]); position += 4;
1620   INT delStop = ntohl(*(ULONG*)&req->data[position]); position += 4;
1621
1622   cTimer* ti = NULL;
1623   for (ti = Timers.First(); ti; ti = Timers.Next(ti))
1624   {
1625     if  ( (ti->Channel()->Number() == delChannel)
1626      &&   ((ti->WeekDays() && (ti->WeekDays() == delWeekdays)) || (!ti->WeekDays() && (ti->Day() == delDay)))
1627      &&   (ti->StartTime() == delStart)
1628      &&   (ti->StopTime() == delStop) )
1629        break;
1630   }
1631
1632   if (!ti)
1633   {
1634     resp->addULONG(4);
1635     resp->finalise();
1636     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1637     return 1;
1638   }
1639
1640   if (!Timers.BeingEdited())
1641   {
1642     if (!ti->Recording())
1643     {
1644       Timers.Del(ti);
1645       Timers.SetModified();
1646       resp->addULONG(10);
1647       resp->finalise();
1648       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1649       return 1;
1650     }
1651     else
1652     {
1653       log->log("RRProc", Log::ERR, "Unable to delete timer - timer is running");
1654       resp->addULONG(3);
1655       resp->finalise();
1656       x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1657       return 1;
1658     }
1659   }
1660   else
1661   {
1662     log->log("RRProc", Log::ERR, "Unable to delete timer - timers being edited at VDR");
1663     resp->addULONG(1);
1664     resp->finalise();
1665     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1666     return 1;
1667   }
1668 }
1669
1670 int VompClientRRProc::processGetRecInfo()
1671 {
1672   // data is a pointer to the fileName string
1673
1674   cRecordings Recordings;
1675   Recordings.Load(); // probably have to do this
1676
1677   cRecording *recording = Recordings.GetByName((char*)req->data);
1678
1679   time_t timerStart = 0;
1680   time_t timerStop = 0;
1681   char* summary = NULL;
1682   char* shorttext = NULL;
1683   char* description = NULL;
1684   bool newsummary=false;
1685   ULONG resumePoint = 0;
1686
1687   if (!recording)
1688   {
1689     log->log("RRProc", Log::ERR, "GetRecInfo found no recording");
1690     resp->addULONG(0);
1691     resp->finalise();
1692     x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1693     return 1;
1694   }
1695
1696   /* Return packet:
1697   4 bytes: start time for timer
1698   4 bytes: end time for timer
1699   4 bytes: resume point
1700   string: summary
1701   4 bytes: num components
1702   {
1703     1 byte: stream
1704     1 byte: type
1705     string: language
1706     string: description
1707   }
1708   8 bytes: frames per second
1709   */
1710
1711   // Get current timer
1712
1713   cRecordControl *rc = cRecordControls::GetRecordControl(recording->FileName());
1714   if (rc)
1715   {
1716     timerStart = rc->Timer()->StartTime();
1717     timerStop = rc->Timer()->StopTime();
1718     log->log("RRProc", Log::DEBUG, "GRI: RC: %lu %lu", timerStart, timerStop);
1719   }
1720
1721   resp->addULONG(timerStart);
1722   resp->addULONG(timerStop);
1723
1724   // Get resume point
1725
1726 /*  char* value = x.config.getValueString("ResumeData", (char*)req->data);
1727   if (value)
1728   {
1729     resumePoint = strtoul(value, NULL, 10);
1730     delete[] value;
1731   }*/
1732
1733   char* ResumeIdC = x.config.getValueString("General", "ResumeId");
1734   int ResumeId;
1735   if (ResumeIdC) {
1736     ResumeId = atoi(ResumeIdC);
1737     delete[] ResumeIdC;
1738   }
1739   else
1740     ResumeId = 0;  //default if not defined in vomp-MAC.conf
1741
1742   while (ResumeIDLock)
1743     cCondWait::SleepMs(100);
1744   ResumeIDLock = true;
1745   int OldSetupResumeID = Setup.ResumeID;
1746   Setup.ResumeID = ResumeId;                            //UGLY: quickly change resumeid
1747 #if VDRVERSNUM < 10703
1748   cResumeFile ResumeFile(recording->FileName());        //get corresponding resume file
1749 #else
1750   cResumeFile ResumeFile(recording->FileName(), recording->IsPesRecording()); //get corresponding resume file
1751 #endif
1752   Setup.ResumeID = OldSetupResumeID;                    //and restore it back
1753   ResumeIDLock = false;
1754
1755   int resume = ResumeFile.Read();
1756   //isyslog("VOMPDEBUG: resumePoint = %i, resume = %i, ResumeId = %i",resumePoint, resume, ResumeId);
1757   if (resume >= 0)
1758     resumePoint = ResumeFile.Read();
1759
1760   log->log("RRProc", Log::DEBUG, "GRI: RP: %lu", resumePoint);
1761
1762   resp->addULONG(resumePoint);
1763
1764   // Get summary
1765
1766 #if VDRVERSNUM < 10300
1767   summary = (char*)recording->Summary();
1768 #else
1769   const cRecordingInfo *Info = recording->Info();
1770   shorttext = (char*)Info->ShortText();
1771   description = (char*) (char*)Info->Description();
1772   if (isempty(shorttext)) summary=description;
1773   else if (isempty(description)) summary=shorttext;
1774   else {
1775      int length=strlen(description)+strlen(shorttext)+4;
1776      summary=new char[length];
1777      snprintf(summary,length,"%s\n\n%s",shorttext,description);
1778      newsummary=true;
1779   }
1780
1781   if (isempty(summary)) summary = (char*)Info->Description();
1782 #endif
1783   log->log("RRProc", Log::DEBUG, "GRI: S: %s", summary);
1784   if (summary)
1785   {
1786     resp->addString(x.charconvsys->Convert(summary));
1787     if (newsummary) delete [] summary;
1788   }
1789   else
1790   {
1791     resp->addString("");
1792   }
1793
1794   // Get channels
1795
1796 #if VDRVERSNUM < 10300
1797
1798   // Send 0 for numchannels - this signals the client this info is not available
1799   resp->addULONG(0);
1800
1801 #else
1802   const cComponents* components = Info->Components();
1803
1804   log->log("RRProc", Log::DEBUG, "GRI: D1: %p", components);
1805
1806   if (!components)
1807   {
1808     resp->addULONG(0);
1809   }
1810   else
1811   {
1812     resp->addULONG(components->NumComponents());
1813
1814     tComponent* component;
1815     for (int i = 0; i < components->NumComponents(); i++)
1816     {
1817       component = components->Component(i);
1818
1819       log->log("RRProc", Log::DEBUG, "GRI: C: %i %u %u %s %s", i, component->stream, component->type, component->language, component->description);
1820
1821       resp->addUCHAR(component->stream);
1822       resp->addUCHAR(component->type);
1823
1824       if (component->language)
1825       {
1826         resp->addString(x.charconvsys->Convert(component->language));
1827       }
1828       else
1829       {
1830         resp->addString("");
1831       }
1832       if (component->description)
1833       {
1834         resp->addString(x.charconvsys->Convert(component->description));
1835       }
1836       else
1837       {
1838         resp->addString("");
1839       }
1840     }
1841   }
1842
1843 #endif
1844   double framespersec;
1845 #if VDRVERSNUM < 10703
1846   framespersec = FRAMESPERSEC;
1847 #else
1848   framespersec = Info->FramesPerSecond();
1849 #endif
1850   resp->adddouble(framespersec);
1851
1852   // Done. send it
1853
1854   resp->finalise();
1855   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1856
1857   log->log("RRProc", Log::DEBUG, "Written getrecinfo");
1858
1859   return 1;
1860 }
1861
1862
1863
1864
1865 // FIXME obselete
1866
1867 int VompClientRRProc::processReScanRecording()
1868 {
1869   if (!x.recplayer)
1870   {
1871     log->log("RRProc", Log::DEBUG, "Rescan recording called when no recording being played!");
1872     return 0;
1873   }
1874
1875   x.recplayer->scan();
1876
1877   resp->addULLONG(x.recplayer->getLengthBytes());
1878   resp->addULONG(x.recplayer->getLengthFrames());
1879   resp->finalise();
1880   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1881   log->log("RRProc", Log::DEBUG, "Rescan recording, wrote new length to client");
1882   return 1;
1883 }
1884
1885 // FIXME without client calling rescan, getblock wont work even tho more data is avail
1886
1887 int VompClientRRProc::processGetMarks()
1888 {
1889   // data is a pointer to the fileName string
1890
1891   cMarks Marks;
1892   cRecordings Recordings;
1893   Recordings.Load(); // probably have to do this
1894
1895   cRecording *recording = Recordings.GetByName((char*)req->data);
1896
1897   log->log("RRProc", Log::DEBUG, "recording pointer %p", recording);
1898
1899   if (recording)
1900   {
1901 #if VDRVERSNUM < 10703
1902     Marks.Load(recording->FileName());
1903 #else
1904     Marks.Load(recording->FileName(), recording->FramesPerSecond(), recording->IsPesRecording());
1905 #endif
1906     if (Marks.Count())
1907     {
1908       for (const cMark *m = Marks.First(); m; m = Marks.Next(m))
1909       {
1910 #if VDRVERSNUM < 10721
1911         ULLONG mposition = m->position;
1912 #else
1913         ULLONG mposition = m->Position();
1914 #endif
1915         log->log("RRProc", Log::DEBUG, "found Mark %i", mposition);
1916
1917         resp->addULONG(mposition);
1918       }
1919     }
1920     else
1921     {
1922       log->log("RRProc", Log::DEBUG, "no marks found, sending 0-mark");
1923       resp->addULONG(0);
1924     }
1925   }
1926
1927   resp->finalise();
1928   x.tcp.sendPacket(resp->getPtr(), resp->getLen());
1929
1930   log->log("RRProc", Log::DEBUG, "Written Marks list");
1931
1932   return 1;
1933 }
1934
1935 #endif // !VOMPSTANDALONE
1936
1937