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