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