]> git.vomp.tv Git - vompserver.git/blob - mvpclient.c
Add config path option
[vompserver.git] / mvpclient.c
1 /*
2     Copyright 2004-2005 Chris Tallon
3
4     This file is part of VOMP.
5
6     VOMP is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     VOMP is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with VOMP; if not, write to the Free Software
18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19 */
20
21 #include "mvpclient.h"
22
23 // This is here else it causes compile errors with something in libdvbmpeg
24 #include <vdr/menu.h>
25
26 MVPClient::MVPClient(char* tconfigDirExtra, int tsocket)
27  : tcp(tsocket)
28 {
29   lp = NULL;
30   rp = NULL;
31   recordingManager = NULL;
32   log = Log::getInstance();
33   loggedIn = false;
34   configDirExtra = tconfigDirExtra;
35 }
36
37 MVPClient::~MVPClient()
38 {
39   log->log("Client", Log::DEBUG, "MVP client destructor");
40   if (lp)
41   {
42     delete lp;
43     lp = NULL;
44   }
45   else if (rp)
46   {
47     writeResumeData();
48
49     delete rp;
50     delete recordingManager;
51     rp = NULL;
52     recordingManager = NULL;
53   }
54
55   if (loggedIn) cleanConfig();
56 }
57
58 ULLONG MVPClient::ntohll(ULLONG a)
59 {
60   return htonll(a);
61 }
62
63 ULLONG MVPClient::htonll(ULLONG a)
64 {
65   #if BYTE_ORDER == BIG_ENDIAN
66     return a;
67   #else
68     ULLONG b = 0;
69
70     b = ((a << 56) & 0xFF00000000000000ULL)
71       | ((a << 40) & 0x00FF000000000000ULL)
72       | ((a << 24) & 0x0000FF0000000000ULL)
73       | ((a <<  8) & 0x000000FF00000000ULL)
74       | ((a >>  8) & 0x00000000FF000000ULL)
75       | ((a >> 24) & 0x0000000000FF0000ULL)
76       | ((a >> 40) & 0x000000000000FF00ULL)
77       | ((a >> 56) & 0x00000000000000FFULL) ;
78
79     return b;
80   #endif
81 }
82
83 cChannel* MVPClient::channelFromNumber(ULONG channelNumber)
84 {
85   cChannel* channel = NULL;
86
87   for (channel = Channels.First(); channel; channel = Channels.Next(channel))
88   {
89     if (!channel->GroupSep())
90     {
91       log->log("Client", Log::DEBUG, "Looking for channel %lu::: number: %i name: '%s'", channelNumber, channel->Number(), channel->Name());
92
93       if (channel->Number() == (int)channelNumber)
94       {
95         int vpid = channel->Vpid();
96 #if VDRVERSNUM < 10300
97         int apid1 = channel->Apid1();
98 #else
99         int apid1 = channel->Apid(0);
100 #endif
101         log->log("Client", Log::DEBUG, "Found channel number %lu, vpid = %i, apid1 = %i", channelNumber, vpid, apid1);
102         return channel;
103       }
104     }
105   }
106
107   if (!channel)
108   {
109     log->log("Client", Log::DEBUG, "Channel not found");
110   }
111
112   return channel;
113 }
114
115 void MVPClient::writeResumeData()
116 {
117   config.setValueLongLong("ResumeData", (char*)rp->getCurrentRecording()->FileName(), rp->getLastPosition());
118 }
119
120 void MVPClient::sendULONG(ULONG ul)
121 {
122   UCHAR sendBuffer[8];
123   *(ULONG*)&sendBuffer[0] = htonl(4);
124   *(ULONG*)&sendBuffer[4] = htonl(ul);
125
126   tcp.sendPacket(sendBuffer, 8);
127   log->log("Client", Log::DEBUG, "written ULONG %lu", ul);
128 }
129
130 void MVPClientStartThread(void* arg)
131 {
132   MVPClient* m = (MVPClient*)arg;
133   m->run2();
134   // Nothing external to this class has a reference to it
135   // This is the end of the thread.. so delete m
136   delete m;
137   pthread_exit(NULL);
138 }
139
140 int MVPClient::run()
141 {
142   if (pthread_create(&runThread, NULL, (void*(*)(void*))MVPClientStartThread, (void *)this) == -1) return 0;
143   log->log("Client", Log::DEBUG, "MVPClient run success");
144   return 1;
145 }
146
147 void MVPClient::run2()
148 {
149   // Thread stuff
150   sigset_t sigset;
151   sigfillset(&sigset);
152   pthread_sigmask(SIG_BLOCK, &sigset, NULL);
153   pthread_detach(runThread);  // Detach
154
155   tcp.disableReadTimeout();
156
157   tcp.setSoKeepTime(3);
158   tcp.setNonBlocking();
159
160   UCHAR* buffer;
161   UCHAR* data;
162   int packetLength;
163   ULONG opcode;
164   int result = 0;
165
166   while(1)
167   {
168     log->log("Client", Log::DEBUG, "Waiting");
169     buffer = (UCHAR*)tcp.receivePacket();
170     log->log("Client", Log::DEBUG, "Received packet, length = %u", tcp.getDataLength());
171     if (buffer == NULL)
172     {
173       log->log("Client", Log::DEBUG, "Detected connection closed");
174       break;
175     }
176
177     packetLength = tcp.getDataLength() - 4;
178     opcode = ntohl(*(ULONG*)buffer);
179     data = buffer + 4;
180
181     if (!loggedIn && (opcode != 1))
182     {
183       free(buffer);
184       break;
185     }
186
187     switch(opcode)
188     {
189       case 1:
190         result = processLogin(data, packetLength);
191         break;
192       case 2:
193         result = processGetRecordingsList(data, packetLength);
194         break;
195       case 3:
196         result = processDeleteRecording(data, packetLength);
197         break;
198       case 4:
199         result = processGetSummary(data, packetLength);
200         break;
201       case 5:
202         result = processGetChannelsList(data, packetLength);
203         break;
204       case 6:
205         result = processStartStreamingChannel(data, packetLength);
206         break;
207       case 7:
208         result = processGetBlock(data, packetLength);
209         break;
210       case 8:
211         result = processStopStreaming(data, packetLength);
212         break;
213       case 9:
214         result = processStartStreamingRecording(data, packetLength);
215         break;
216       case 10:
217         result = processGetChannelSchedule(data, packetLength);
218         break;
219       case 11:
220         result = processConfigSave(data, packetLength);
221         break;
222       case 12:
223         result = processConfigLoad(data, packetLength);
224         break;
225       case 13:
226         result = processReScanRecording(data, packetLength);
227         break;
228       case 14:
229         result = processGetTimers(data, packetLength);
230         break;
231       case 15:
232         result = processSetTimer(data, packetLength);
233         break;
234       case 16:
235         result = processPositionFromFrameNumber(data, packetLength);
236         break;
237     }
238
239     free(buffer);
240     if (!result) break;
241   }
242 }
243
244 int MVPClient::processLogin(UCHAR* buffer, int length)
245 {
246   if (length != 6) return 0;
247
248   // Open the config
249
250   const char* configDir = cPlugin::ConfigDirectory(configDirExtra);
251   if (!configDir)
252   {
253     log->log("Client", Log::DEBUG, "No config dir!");
254     return 0;
255   }
256
257   char configFileName[PATH_MAX];
258   snprintf(configFileName, PATH_MAX, "%s/vomp-%02X-%02X-%02X-%02X-%02X-%02X.conf", configDir, buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5]);
259   config.init(configFileName);
260
261   // Send the login reply
262
263   time_t timeNow = time(NULL);
264   struct tm* timeStruct = localtime(&timeNow);
265   int timeOffset = timeStruct->tm_gmtoff;
266
267   UCHAR sendBuffer[12];
268   *(ULONG*)&sendBuffer[0] = htonl(8);
269   *(ULONG*)&sendBuffer[4] = htonl(timeNow);
270   *(signed int*)&sendBuffer[8] = htonl(timeOffset);
271
272   tcp.sendPacket(sendBuffer, 12);
273   log->log("Client", Log::DEBUG, "written login reply");
274
275   loggedIn = true;
276   return 1;
277 }
278
279 int MVPClient::processGetRecordingsList(UCHAR* data, int length)
280 {
281   UCHAR* sendBuffer = new UCHAR[50000]; // hope this is enough
282   int count = 4; // leave space for the packet length
283   char* point;
284
285
286   int FreeMB;
287   int Percent = VideoDiskSpace(&FreeMB);
288   int Total = (FreeMB / (100 - Percent)) * 100;
289
290   *(ULONG*)&sendBuffer[count] = htonl(Total);
291   count += sizeof(ULONG);
292   *(ULONG*)&sendBuffer[count] = htonl(FreeMB);
293   count += sizeof(ULONG);
294   *(ULONG*)&sendBuffer[count] = htonl(Percent);
295   count += sizeof(ULONG);
296
297
298   cRecordings Recordings;
299   Recordings.Load();
300
301   for (cRecording *recording = Recordings.First(); recording; recording = Recordings.Next(recording))
302   {
303     if (count > 49000) break; // just how big is that hard disk?!
304     *(ULONG*)&sendBuffer[count] = htonl(recording->start);// + timeOffset);
305     count += 4;
306
307     point = (char*)recording->Name();
308     strcpy((char*)&sendBuffer[count], point);
309     count += strlen(point) + 1;
310
311     point = (char*)recording->FileName();
312     strcpy((char*)&sendBuffer[count], point);
313     count += strlen(point) + 1;
314   }
315
316   *(ULONG*)&sendBuffer[0] = htonl(count - 4); // -4 :  take off the size field
317
318   log->log("Client", Log::DEBUG, "recorded size as %u", ntohl(*(ULONG*)&sendBuffer[0]));
319
320   tcp.sendPacket(sendBuffer, count);
321   delete[] sendBuffer;
322   log->log("Client", Log::DEBUG, "Written list");
323
324   return 1;
325 }
326
327 int MVPClient::processDeleteRecording(UCHAR* data, int length)
328 {
329   // data is a pointer to the fileName string
330
331   cRecordings Recordings;
332   Recordings.Load(); // probably have to do this
333
334   cRecording* recording = Recordings.GetByName((char*)data);
335
336   log->log("Client", Log::DEBUG, "recording pointer %p", recording);
337
338   if (recording)
339   {
340     log->log("Client", Log::DEBUG, "deleting recording: %s", recording->Name());
341
342     cRecordControl *rc = cRecordControls::GetRecordControl(recording->FileName());
343     if (!rc)
344     {
345       if (recording->Delete())
346       {
347         // Copy svdrp's way of doing this, see if it works
348         ::Recordings.DelByName(recording->FileName());
349         sendULONG(1);
350       }
351       else
352       {
353         sendULONG(2);
354       }
355     }
356     else
357     {
358       sendULONG(3);
359     }
360   }
361   else
362   {
363     sendULONG(4);
364   }
365
366   return 1;
367 }
368
369 int MVPClient::processGetSummary(UCHAR* data, int length)
370 {
371   // data is a pointer to the fileName string
372
373   cRecordings Recordings;
374   Recordings.Load(); // probably have to do this
375
376   cRecording *recording = Recordings.GetByName((char*)data);
377
378   log->log("Client", Log::DEBUG, "recording pointer %p", recording);
379
380   if (recording)
381   {
382     UCHAR* sendBuffer = new UCHAR[50000]; // hope this is enough
383     int count = 4; // leave space for the packet length
384     char* point;
385
386 #if VDRVERSNUM < 10300
387     point = (char*)recording->Summary();
388 #else
389     const cRecordingInfo *Info = recording->Info();
390     point = (char*)Info->ShortText();
391     log->log("Client", Log::DEBUG, "info pointer %p summary pointer %p", Info, point);
392     if (isempty(point))
393     {
394       point = (char*)Info->Description();
395       log->log("Client", Log::DEBUG, "description pointer %p", point);
396     }
397 #endif
398
399     if (point)
400     {
401       strcpy((char*)&sendBuffer[count], point);
402       count += strlen(point) + 1;
403     }
404     else
405     {
406       strcpy((char*)&sendBuffer[count], "");
407       count += 1;
408     }
409
410     *(ULONG*)&sendBuffer[0] = htonl(count - 4); // -4 :  take off the size field
411
412     log->log("Client", Log::DEBUG, "recorded size as %u", ntohl(*(ULONG*)&sendBuffer[0]));
413
414     tcp.sendPacket(sendBuffer, count);
415     delete[] sendBuffer;
416     log->log("Client", Log::DEBUG, "Written summary");
417
418
419   }
420   else
421   {
422     sendULONG(0);
423   }
424
425   return 1;
426 }
427
428 int MVPClient::processGetChannelsList(UCHAR* data, int length)
429 {
430   UCHAR* sendBuffer = new UCHAR[50000]; // FIXME hope this is enough
431   int count = 4; // leave space for the packet length
432   char* point;
433   ULONG type;
434
435   char* chanConfig = config.getValueString("General", "Channels");
436   int allChans = 1;
437   if (chanConfig) allChans = strcasecmp(chanConfig, "FTA only");
438
439   for (cChannel *channel = Channels.First(); channel; channel = Channels.Next(channel))
440   {
441 #if VDRVERSNUM < 10300
442     if (!channel->GroupSep() && (!channel->Ca() || allChans))
443 #else
444     if (!channel->GroupSep() && (!channel->Ca(0) || allChans))
445 #endif
446     {
447       log->log("Client", Log::DEBUG, "name: '%s'", channel->Name());
448
449       if (channel->Vpid()) type = 1;
450 #if VDRVERSNUM < 10300
451       else type = 2;
452 #else
453       else if (channel->Apid(0)) type = 2;
454       else continue;
455 #endif
456
457       if (count > 49000) break;
458       *(ULONG*)&sendBuffer[count] = htonl(channel->Number());
459       count += 4;
460
461       *(ULONG*)&sendBuffer[count] = htonl(type);
462       count += 4;
463
464       point = (char*)channel->Name();
465       strcpy((char*)&sendBuffer[count], point);
466       count += strlen(point) + 1;
467     }
468   }
469
470   *(ULONG*)&sendBuffer[0] = htonl(count - 4); // -4 :  take off the size field
471
472   log->log("Client", Log::DEBUG, "recorded size as %u", ntohl(*(ULONG*)&sendBuffer[0]));
473
474   tcp.sendPacket(sendBuffer, count);
475   delete[] sendBuffer;
476   log->log("Client", Log::DEBUG, "Written channels list");
477
478   return 1;
479 }
480
481 int MVPClient::processStartStreamingChannel(UCHAR* data, int length)
482 {
483   log->log("Client", Log::DEBUG, "length = %i", length);
484   ULONG channelNumber = ntohl(*(ULONG*)data);
485
486   cChannel* channel = channelFromNumber(channelNumber);
487   if (!channel)
488   {
489     sendULONG(0);
490     return 1;
491   }
492
493   // get the priority we should use
494   int fail = 1;
495   int priority = config.getValueLong("General", "Live priority", &fail);
496   if (!fail)
497   {
498     log->log("Client", Log::DEBUG, "Config: Live TV priority: %i", priority);
499   }
500   else
501   {
502     log->log("Client", Log::DEBUG, "Config: Live TV priority config fail");
503     priority = 0;
504   }
505
506   // a bit of sanity..
507   if (priority < 0) priority = 0;
508   if (priority > 99) priority = 99;
509
510   log->log("Client", Log::DEBUG, "Using live TV priority %i", priority);
511   lp = MVPReceiver::create(channel, priority);
512
513   if (!lp)
514   {
515     sendULONG(0);
516     return 1;
517   }
518
519   if (!lp->init())
520   {
521     delete lp;
522     lp = NULL;
523     sendULONG(0);
524     return 1;
525   }
526
527   sendULONG(1);
528   return 1;
529 }
530
531 int MVPClient::processStopStreaming(UCHAR* data, int length)
532 {
533   log->log("Client", Log::DEBUG, "STOP STREAMING RECEIVED");
534   if (lp)
535   {
536     delete lp;
537     lp = NULL;
538   }
539   else if (rp)
540   {
541     writeResumeData();
542
543     delete rp;
544     delete recordingManager;
545     rp = NULL;
546     recordingManager = NULL;
547   }
548
549   sendULONG(1);
550   return 1;
551 }
552
553 int MVPClient::processGetBlock(UCHAR* data, int length)
554 {
555   if (!lp && !rp)
556   {
557     log->log("Client", Log::DEBUG, "Get block called when no streaming happening!");
558     return 0;
559   }
560
561   ULLONG position = ntohll(*(ULLONG*)data);
562   data += sizeof(ULLONG);
563   ULONG amount = ntohl(*(ULONG*)data);
564
565   log->log("Client", Log::DEBUG, "getblock pos = %llu length = %lu", position, amount);
566
567   UCHAR sendBuffer[amount + 4];
568   ULONG amountReceived = 0; // compiler moan.
569   if (lp)
570   {
571     log->log("Client", Log::DEBUG, "getting from live");
572     amountReceived = lp->getBlock(&sendBuffer[4], amount);
573
574     if (!amountReceived)
575     {
576       // vdr has possibly disconnected the receiver
577       log->log("Client", Log::DEBUG, "VDR has disconnected the live receiver");
578       delete lp;
579       lp = NULL;
580     }
581   }
582   else if (rp)
583   {
584     log->log("Client", Log::DEBUG, "getting from recording");
585     amountReceived = rp->getBlock(&sendBuffer[4], position, amount);
586   }
587
588   if (!amountReceived)
589   {
590     sendULONG(0);
591     log->log("Client", Log::DEBUG, "written 4(0) as getblock got 0");
592   }
593   else
594   {
595     *(ULONG*)&sendBuffer[0] = htonl(amountReceived);
596     tcp.sendPacket(sendBuffer, amountReceived + 4);
597     log->log("Client", Log::DEBUG, "written ok %lu", amountReceived);
598   }
599
600   return 1;
601 }
602
603 int MVPClient::processStartStreamingRecording(UCHAR* data, int length)
604 {
605   // data is a pointer to the fileName string
606
607   recordingManager = new cRecordings;
608   recordingManager->Load();
609
610   cRecording* recording = recordingManager->GetByName((char*)data);
611
612   log->log("Client", Log::DEBUG, "recording pointer %p", recording);
613
614   if (recording)
615   {
616     rp = new RecPlayer(recording);
617
618     UCHAR sendBuffer[12];
619     *(ULONG*)&sendBuffer[0] = htonl(8);
620     *(ULLONG*)&sendBuffer[4] = htonll(rp->getTotalLength());
621
622     tcp.sendPacket(sendBuffer, 12);
623     log->log("Client", Log::DEBUG, "written totalLength");
624   }
625   else
626   {
627     delete recordingManager;
628     recordingManager = NULL;
629   }
630   return 1;
631 }
632
633 int MVPClient::processReScanRecording(UCHAR* data, int length)
634 {
635   ULLONG retval = 0;
636
637   if (!rp)
638   {
639     log->log("Client", Log::DEBUG, "Rescan recording called when no recording being played!");
640   }
641   else
642   {
643     rp->scan();
644     retval = rp->getTotalLength();
645   }
646
647   UCHAR sendBuffer[12];
648   *(ULONG*)&sendBuffer[0] = htonl(8);
649   *(ULLONG*)&sendBuffer[4] = htonll(retval);
650
651   tcp.sendPacket(sendBuffer, 12);
652   log->log("Client", Log::DEBUG, "Rescan recording, wrote new length to client");
653   return 1;
654 }
655
656 int MVPClient::processPositionFromFrameNumber(UCHAR* data, int length)
657 {
658   ULLONG retval = 0;
659
660   ULONG frameNumber = ntohl(*(ULONG*)data);
661   data += 4;
662
663   if (!rp)
664   {
665     log->log("Client", Log::DEBUG, "Rescan recording called when no recording being played!");
666   }
667   else
668   {
669     retval = rp->positionFromFrameNumber(frameNumber);
670   }
671
672   UCHAR sendBuffer[12];
673   *(ULONG*)&sendBuffer[0] = htonl(8);
674   *(ULLONG*)&sendBuffer[4] = htonll(retval);
675
676   tcp.sendPacket(sendBuffer, 12);
677   log->log("Client", Log::DEBUG, "Wrote posFromFrameNum reply to client");
678   return 1;
679 }
680
681 int MVPClient::processGetChannelSchedule(UCHAR* data, int length)
682 {
683   ULONG channelNumber = ntohl(*(ULONG*)data);
684   data += 4;
685   ULONG startTime = ntohl(*(ULONG*)data);
686   data += 4;
687   ULONG duration = ntohl(*(ULONG*)data);
688
689   log->log("Client", Log::DEBUG, "get schedule called for channel %lu", channelNumber);
690
691   cChannel* channel = channelFromNumber(channelNumber);
692   if (!channel)
693   {
694     sendULONG(0);
695     log->log("Client", Log::DEBUG, "written 0 because channel = NULL");
696     return 1;
697   }
698
699   log->log("Client", Log::DEBUG, "Got channel");
700
701 #if VDRVERSNUM < 10300
702   cMutexLock MutexLock;
703   const cSchedules *Schedules = cSIProcessor::Schedules(MutexLock);
704 #else
705   cSchedulesLock MutexLock;
706   const cSchedules *Schedules = cSchedules::Schedules(MutexLock);
707 #endif
708   if (!Schedules)
709   {
710     sendULONG(0);
711     log->log("Client", Log::DEBUG, "written 0 because Schedule!s! = NULL");
712     return 1;
713   }
714
715   log->log("Client", Log::DEBUG, "Got schedule!s! object");
716
717   const cSchedule *Schedule = Schedules->GetSchedule(channel->GetChannelID());
718   if (!Schedule)
719   {
720     sendULONG(0);
721     log->log("Client", Log::DEBUG, "written 0 because Schedule = NULL");
722     return 1;
723   }
724
725   log->log("Client", Log::DEBUG, "Got schedule object");
726
727   UCHAR* sendBuffer = (UCHAR*)malloc(100000);
728   ULONG sendBufferLength = 100000;
729   ULONG sendBufferUsed = sizeof(ULONG); // leave a hole for the entire packet length
730
731   char* empty = "";
732
733   // assign all the event info to temp vars then we know exactly what size they are
734   ULONG thisEventID;
735   ULONG thisEventTime;
736   ULONG thisEventDuration;
737   const char* thisEventTitle;
738   const char* thisEventSubTitle;
739   const char* thisEventDescription;
740
741   ULONG constEventLength = sizeof(thisEventID) + sizeof(thisEventTime) + sizeof(thisEventDuration);
742   ULONG thisEventLength;
743
744 #if VDRVERSNUM < 10300
745
746   const cEventInfo *event;
747   for (int eventNumber = 0; eventNumber < Schedule->NumEvents(); eventNumber++)
748   {
749     event = Schedule->GetEventNumber(eventNumber);
750
751     thisEventID = event->GetEventID();
752     thisEventTime = event->GetTime();
753     thisEventDuration = event->GetDuration();
754     thisEventTitle = event->GetTitle();
755     thisEventSubTitle = event->GetSubtitle();
756     thisEventDescription = event->GetExtendedDescription();
757
758 #else
759
760   for (const cEvent* event = Schedule->Events()->First(); event; event = Schedule->Events()->Next(event))
761   {
762     thisEventID = event->EventID();
763     thisEventTime = event->StartTime();
764     thisEventDuration = event->Duration();
765     thisEventTitle = event->Title();
766     thisEventSubTitle = NULL;
767     thisEventDescription = event->Description();
768
769 #endif
770
771     log->log("Client", Log::DEBUG, "Got an event object %p", event);
772
773     //in the past filter
774     if ((thisEventTime + thisEventDuration) < (ULONG)time(NULL)) continue;
775
776     //start time filter
777     if ((thisEventTime + thisEventDuration) <= startTime) continue;
778
779     //duration filter
780     if (thisEventTime >= (startTime + duration)) continue;
781
782     if (!thisEventTitle) thisEventTitle = empty;
783     if (!thisEventSubTitle) thisEventSubTitle = empty;
784     if (!thisEventDescription) thisEventDescription = empty;
785
786     thisEventLength = constEventLength + strlen(thisEventTitle) + 1 + strlen(thisEventSubTitle) + 1 + strlen(thisEventDescription) + 1;
787
788     log->log("Client", Log::DEBUG, "Done s1");
789
790     // now extend the buffer if necessary
791     if ((sendBufferUsed + thisEventLength) > sendBufferLength)
792     {
793       log->log("Client", Log::DEBUG, "Extending buffer");
794       sendBufferLength += 100000;
795       UCHAR* temp = (UCHAR*)realloc(sendBuffer, sendBufferLength);
796       if (temp == NULL)
797       {
798         free(sendBuffer);
799         UCHAR sendBuffer2[8];
800         *(ULONG*)&sendBuffer2[0] = htonl(4);
801         *(ULONG*)&sendBuffer2[4] = htonl(0);
802         tcp.sendPacket(sendBuffer2, 8);
803         log->log("Client", Log::DEBUG, "written 0 because failed to realloc packet");
804         return 1;
805       }
806       sendBuffer = temp;
807     }
808
809     log->log("Client", Log::DEBUG, "Done s2");
810
811     *(ULONG*)&sendBuffer[sendBufferUsed] = htonl(thisEventID);       sendBufferUsed += sizeof(ULONG);
812     *(ULONG*)&sendBuffer[sendBufferUsed] = htonl(thisEventTime);     sendBufferUsed += sizeof(ULONG);
813     *(ULONG*)&sendBuffer[sendBufferUsed] = htonl(thisEventDuration); sendBufferUsed += sizeof(ULONG);
814
815     strcpy((char*)&sendBuffer[sendBufferUsed], thisEventTitle);       sendBufferUsed += strlen(thisEventTitle) + 1;
816     strcpy((char*)&sendBuffer[sendBufferUsed], thisEventSubTitle);    sendBufferUsed += strlen(thisEventSubTitle) + 1;
817     strcpy((char*)&sendBuffer[sendBufferUsed], thisEventDescription); sendBufferUsed += strlen(thisEventDescription) + 1;
818
819     log->log("Client", Log::DEBUG, "Done s3 %lu", sendBufferUsed);
820   }
821
822   log->log("Client", Log::DEBUG, "Got all event data");
823
824   if (sendBufferUsed == sizeof(ULONG))
825   {
826     // No data
827     sendULONG(0);
828     log->log("Client", Log::DEBUG, "Written 0 because no data");
829   }
830   else
831   {
832     // Write the length into the first 4 bytes. It's sendBufferUsed - 4 because of the hole!
833     *(ULONG*)&sendBuffer[0] = htonl(sendBufferUsed - sizeof(ULONG));
834     tcp.sendPacket(sendBuffer, sendBufferUsed);
835     log->log("Client", Log::DEBUG, "written %lu schedules packet", sendBufferUsed);
836   }
837
838   free(sendBuffer);
839
840   return 1;
841 }
842
843 int MVPClient::processConfigSave(UCHAR* buffer, int length)
844 {
845   char* section = (char*)buffer;
846   char* key = NULL;
847   char* value = NULL;
848
849   for (int k = 0; k < length; k++)
850   {
851     if (buffer[k] == '\0')
852     {
853       if (!key)
854       {
855         key = (char*)&buffer[k+1];
856       }
857       else
858       {
859         value = (char*)&buffer[k+1];
860         break;
861       }
862     }
863   }
864
865   // if the last string (value) doesnt have null terminator, give up
866   if (buffer[length - 1] != '\0') return 0;
867
868   log->log("Client", Log::DEBUG, "Config save: %s %s %s", section, key, value);
869   if (config.setValueString(section, key, value))
870   {
871     sendULONG(1);
872   }
873   else
874   {
875     sendULONG(0);
876   }
877
878   return 1;
879 }
880
881 int MVPClient::processConfigLoad(UCHAR* buffer, int length)
882 {
883   char* section = (char*)buffer;
884   char* key = NULL;
885
886   for (int k = 0; k < length; k++)
887   {
888     if (buffer[k] == '\0')
889     {
890       key = (char*)&buffer[k+1];
891       break;
892     }
893   }
894
895   char* value = config.getValueString(section, key);
896
897   if (value)
898   {
899     UCHAR sendBuffer[4 + strlen(value) + 1];
900     *(ULONG*)&sendBuffer[0] = htonl(strlen(value) + 1);
901     strcpy((char*)&sendBuffer[4], value);
902     tcp.sendPacket(sendBuffer, 4 + strlen(value) + 1);
903
904     log->log("Client", Log::DEBUG, "Written config load packet");
905     delete[] value;
906   }
907   else
908   {
909     UCHAR sendBuffer[8];
910     *(ULONG*)&sendBuffer[0] = htonl(4);
911     *(ULONG*)&sendBuffer[4] = htonl(0);
912     tcp.sendPacket(sendBuffer, 8);
913
914     log->log("Client", Log::DEBUG, "Written config load failed packet");
915   }
916
917   return 1;
918 }
919
920 void MVPClient::cleanConfig()
921 {
922   log->log("Client", Log::DEBUG, "Clean config");
923
924   cRecordings Recordings;
925   Recordings.Load();
926
927   int numReturns;
928   int length;
929   char* resumes = config.getSectionKeyNames("ResumeData", numReturns, length);
930   char* position = resumes;
931   for(int k = 0; k < numReturns; k++)
932   {
933     log->log("Client", Log::DEBUG, "EXAMINING: %i %i %p %s", k, numReturns, position, position);
934
935     cRecording* recording = Recordings.GetByName(position);
936     if (!recording)
937     {
938       // doesn't exist anymore
939       log->log("Client", Log::DEBUG, "Found a recording that doesn't exist anymore");
940       config.deleteValue("ResumeData", position);
941     }
942     else
943     {
944       log->log("Client", Log::DEBUG, "This recording still exists");
945     }
946
947     position += strlen(position) + 1;
948   }
949
950   delete[] resumes;
951 }
952
953
954
955
956
957
958 /*
959     event = Schedule->GetPresentEvent();
960
961     fprintf(f, "\n\nCurrent event\n\n");
962
963     fprintf(f, "Event %i eventid = %u time = %lu duration = %li\n", 0, event->GetEventID(), event->GetTime(), event->GetDuration());
964     fprintf(f, "Event %i title = %s subtitle = %s\n", 0, event->GetTitle(), event->GetSubtitle());
965     fprintf(f, "Event %i extendeddescription = %s\n", 0, event->GetExtendedDescription());
966     fprintf(f, "Event %i isFollowing = %i, isPresent = %i\n", 0, event->IsFollowing(), event->IsPresent());
967
968     event = Schedule->GetFollowingEvent();
969
970     fprintf(f, "\n\nFollowing event\n\n");
971
972     fprintf(f, "Event %i eventid = %u time = %lu duration = %li\n", 0, event->GetEventID(), event->GetTime(), event->GetDuration());
973     fprintf(f, "Event %i title = %s subtitle = %s\n", 0, event->GetTitle(), event->GetSubtitle());
974     fprintf(f, "Event %i extendeddescription = %s\n", 0, event->GetExtendedDescription());
975     fprintf(f, "Event %i isFollowing = %i, isPresent = %i\n", 0, event->IsFollowing(), event->IsPresent());
976
977     fprintf(f, "\n\n");
978 */
979
980 /*
981     fprintf(f, "Event %i eventid = %u time = %lu duration = %li\n", eventNumber, event->GetEventID(), event->GetTime(), event->GetDuration());
982     fprintf(f, "Event %i title = %s subtitle = %s\n", eventNumber, event->GetTitle(), event->GetSubtitle());
983     fprintf(f, "Event %i extendeddescription = %s\n", eventNumber, event->GetExtendedDescription());
984     fprintf(f, "Event %i isFollowing = %i, isPresent = %i\n", eventNumber, event->IsFollowing(), event->IsPresent());
985
986     fprintf(f, "\n\n");
987 */
988
989 /*
990
991
992 void MVPClient::test2()
993 {
994   FILE* f = fopen("/tmp/s.txt", "w");
995
996 #if VDRVERSNUM < 10300
997   cMutexLock MutexLock;
998   const cSchedules *Schedules = cSIProcessor::Schedules(MutexLock);
999 #else
1000   cSchedulesLock MutexLock;
1001   const cSchedules *Schedules = cSchedules::Schedules(MutexLock);
1002 #endif
1003
1004   if (!Schedules)
1005   {
1006     fprintf(f, "Schedules = NULL\n");
1007     fclose(f);
1008     return;
1009   }
1010
1011   fprintf(f, "Schedules dump:\n");
1012   Schedules->Dump(f);
1013
1014
1015   const cSchedule *Schedule;
1016   int scheduleNumber = 0;
1017
1018   tChannelID tchid;
1019   cChannel *thisChannel;
1020
1021 #if VDRVERSNUM < 10300
1022   const cEventInfo *event;
1023   int eventNumber = 0;
1024 #else
1025   const cEvent *event;
1026 #endif
1027
1028 //    Schedule = Schedules->GetSchedule(channel->GetChannelID());
1029 //    Schedule = Schedules->GetSchedule();
1030   Schedule = Schedules->First();
1031   if (!Schedule)
1032   {
1033     fprintf(f, "First Schedule = NULL\n");
1034     fclose(f);
1035     return;
1036   }
1037
1038   while (Schedule)
1039   {
1040     fprintf(f, "Schedule #%i\n", scheduleNumber);
1041     fprintf(f, "-------------\n\n");
1042
1043 #if VDRVERSNUM < 10300
1044     tchid = Schedule->GetChannelID();
1045 #else
1046     tchid = Schedule->ChannelID();
1047 #endif
1048
1049 #if VDRVERSNUM < 10300
1050     fprintf(f, "ChannelID.ToString() = %s\n", tchid.ToString());
1051     fprintf(f, "NumEvents() = %i\n", Schedule->NumEvents());
1052 #else
1053 //  put the count at the end.
1054 #endif
1055
1056     thisChannel = Channels.GetByChannelID(tchid, true);
1057     if (thisChannel)
1058     {
1059       fprintf(f, "Channel Number: %p %i\n", thisChannel, thisChannel->Number());
1060     }
1061     else
1062     {
1063       fprintf(f, "thisChannel = NULL for tchid\n");
1064     }
1065
1066 #if VDRVERSNUM < 10300
1067     for (eventNumber = 0; eventNumber < Schedule->NumEvents(); eventNumber++)
1068     {
1069       event = Schedule->GetEventNumber(eventNumber);
1070       fprintf(f, "Event %i tableid = %i timestring = %s endtimestring = %s\n", eventNumber, event->GetTableID(), event->GetTimeString(), event->GetEndTimeString());
1071       fprintf(f, "Event %i date = %s isfollowing = %i ispresent = %i\n", eventNumber, event->GetDate(), event->IsFollowing(), event->IsPresent());
1072       fprintf(f, "Event %i extendeddescription = %s\n", eventNumber, event->GetExtendedDescription());
1073       fprintf(f, "Event %i subtitle = %s title = %s\n", eventNumber, event->GetSubtitle(), event->GetTitle());
1074       fprintf(f, "Event %i eventid = %u duration = %li time = %lu channelnumber = %i\n", eventNumber, event->GetEventID(), event->GetDuration(), event->GetTime(), event->GetChannelNumber());
1075       fprintf(f, "Event %u dump:\n", eventNumber);
1076       event->Dump(f);
1077       fprintf(f, "\n\n");
1078     }
1079 #else
1080 //  This whole section needs rewriting to walk the list.
1081     event = Schedule->Events()->First();
1082     while (event) {
1083       event = Schedule->Events()->Next(event);
1084     }
1085 #endif
1086
1087
1088     fprintf(f, "\nDump from object:\n");
1089     Schedule->Dump(f);
1090     fprintf(f, "\nEND\n");
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100     fprintf(f, "End of current Schedule\n\n\n");
1101
1102     Schedule = (const cSchedule *)Schedules->Next(Schedule);
1103     scheduleNumber++;
1104   }
1105
1106   fclose(f);
1107 }
1108
1109
1110
1111 */
1112
1113
1114
1115 /*
1116   const cEventInfo *GetPresentEvent(void) const;
1117   const cEventInfo *GetFollowingEvent(void) const;
1118   const cEventInfo *GetEvent(unsigned short uEventID, time_t tTime = 0) const;
1119   const cEventInfo *GetEventAround(time_t tTime) const;
1120   const cEventInfo *GetEventNumber(int n) const { return Events.Get(n); }
1121
1122
1123   const unsigned char GetTableID(void) const;
1124   const char *GetTimeString(void) const;
1125   const char *GetEndTimeString(void) const;
1126   const char *GetDate(void) const;
1127   bool IsFollowing(void) const;
1128   bool IsPresent(void) const;
1129   const char *GetExtendedDescription(void) const;
1130   const char *GetSubtitle(void) const;
1131   const char *GetTitle(void) const;
1132   unsigned short GetEventID(void) const;
1133   long GetDuration(void) const;
1134   time_t GetTime(void) const;
1135   tChannelID GetChannelID(void) const;
1136   int GetChannelNumber(void) const { return nChannelNumber; }
1137   void SetChannelNumber(int ChannelNumber) const { ((cEventInfo *)this)->nChannelNumber = ChannelNumber; } // doesn't modify the EIT data, so it's ok to make it 'const'
1138   void Dump(FILE *f, const char *Prefix = "") const;
1139
1140 */
1141
1142
1143 /*
1144 void MVPClient::test(int channelNumber)
1145 {
1146   FILE* f = fopen("/tmp/test.txt", "w");
1147
1148   cMutexLock MutexLock;
1149   const cSchedules *Schedules = cSIProcessor::Schedules(MutexLock);
1150
1151   if (!Schedules)
1152   {
1153     fprintf(f, "Schedules = NULL\n");
1154     fclose(f);
1155     return;
1156   }
1157
1158   fprintf(f, "Schedules dump:\n");
1159 //  Schedules->Dump(f);
1160
1161   const cSchedule *Schedule;
1162   cChannel *thisChannel;
1163   const cEventInfo *event;
1164
1165   thisChannel = channelFromNumber(channelNumber);
1166   if (!thisChannel)
1167   {
1168     fprintf(f, "thisChannel = NULL\n");
1169     fclose(f);
1170     return;
1171   }
1172
1173   Schedule = Schedules->GetSchedule(thisChannel->GetChannelID());
1174 //    Schedule = Schedules->GetSchedule();
1175 //  Schedule = Schedules->First();
1176   if (!Schedule)
1177   {
1178     fprintf(f, "First Schedule = NULL\n");
1179     fclose(f);
1180     return;
1181   }
1182
1183   fprintf(f, "NumEvents() = %i\n\n", Schedule->NumEvents());
1184
1185   // For some channels VDR seems to pick a random point in time to
1186   // start dishing out events, but they are in order
1187   // at some point in the list the time snaps to the current event
1188
1189
1190
1191
1192   for (int eventNumber = 0; eventNumber < Schedule->NumEvents(); eventNumber++)
1193   {
1194     event = Schedule->GetEventNumber(eventNumber);
1195     fprintf(f, "Event %i eventid = %u time = %lu duration = %li\n", eventNumber, event->GetEventID(), event->GetTime(), event->GetDuration());
1196     fprintf(f, "Event %i title = %s subtitle = %s\n", eventNumber, event->GetTitle(), event->GetSubtitle());
1197     fprintf(f, "Event %i extendeddescription = %s\n", eventNumber, event->GetExtendedDescription());
1198     fprintf(f, "\n\n");
1199   }
1200
1201   fprintf(f, "\nEND\n");
1202
1203   fclose(f);
1204 }
1205
1206 */
1207
1208
1209
1210 /*
1211
1212
1213 Right, so
1214
1215 Schedules = the collection of all the Schedule objects
1216 Schedule  = One schedule, contants all the events for a channel
1217 Event     = One programme
1218
1219
1220 Want:
1221
1222 Event ID
1223 Time
1224 Duration
1225 Title
1226 Subtitle (used for "Programmes resume at ...")
1227 Description
1228
1229 IsPresent ? easy to work out tho. Oh it doesn't always work
1230
1231 */
1232
1233 /*
1234 void MVPClient::test2()
1235 {
1236   log->log("-", Log::DEBUG, "Timers List");
1237
1238   for (int i = 0; i < Timers.Count(); i++)
1239   {
1240     cTimer *timer = Timers.Get(i);
1241     //Reply(i < Timers.Count() - 1 ? -250 : 250, "%d %s", timer->Index() + 1, timer->ToText());
1242     log->log("-", Log::DEBUG, "i=%i count=%i index=%d", i, Timers.Count(), timer->Index() + 1);
1243 #if VDRVERSNUM < 10300
1244     log->log("-", Log::DEBUG, "active=%i recording=%i pending=%i start=%li stop=%li priority=%i lifetime=%i", timer->Active(), timer->Recording(), timer->Pending(), timer->StartTime(), timer->StopTime(), timer->Priority(), timer->Lifetime());
1245 #else
1246     log->log("-", Log::DEBUG, "active=%i recording=%i pending=%i start=%li stop=%li priority=%i lifetime=%i", timer->HasFlags(tfActive), timer->Recording(), timer->Pending(), timer->StartTime(), timer->StopTime(), timer->Priority(), timer->Lifetime());
1247 #endif
1248     log->log("-", Log::DEBUG, "channel=%i file=%s summary=%s", timer->Channel()->Number(), timer->File(), timer->Summary());
1249     log->log("-", Log::DEBUG, "");
1250   }
1251
1252   // asprintf(&buffer, "%d:%s:%s  :%04d:%04d:%d:%d:%s:%s\n",
1253 //            active, (UseChannelID ? Channel()->GetChannelID().ToString() : itoa(Channel()->Number())),
1254 //            PrintDay(day, firstday), start, stop, priority, lifetime, file, summary ? summary : "");
1255 }
1256 */
1257
1258 /*
1259 Active seems to be a bool - whether the timer should be done or not. If set to inactive it stays around after its time
1260 recording is a bool, 0 for not currently recording, 1 for currently recording
1261 pending is a bool, 0 for would not be trying to record this right now, 1 for would/is trying to record this right now
1262 */
1263
1264
1265 int MVPClient::processGetTimers(UCHAR* buffer, int length)
1266 {
1267   UCHAR* sendBuffer = new UCHAR[50000]; // FIXME hope this is enough
1268   int count = 4; // leave space for the packet length
1269
1270   const char* fileName;
1271   cTimer *timer;
1272   int numTimers = Timers.Count();
1273
1274   *(ULONG*)&sendBuffer[count] = htonl(numTimers);    count += 4;
1275
1276   for (int i = 0; i < numTimers; i++)
1277   {
1278     if (count > 49000) break;
1279
1280     timer = Timers.Get(i);
1281
1282 #if VDRVERSNUM < 10300
1283     *(ULONG*)&sendBuffer[count] = htonl(timer->Active());                 count += 4;
1284 #else
1285     *(ULONG*)&sendBuffer[count] = htonl(timer->HasFlags(tfActive));       count += 4;
1286 #endif
1287     *(ULONG*)&sendBuffer[count] = htonl(timer->Recording());              count += 4;
1288     *(ULONG*)&sendBuffer[count] = htonl(timer->Pending());                count += 4;
1289     *(ULONG*)&sendBuffer[count] = htonl(timer->Priority());               count += 4;
1290     *(ULONG*)&sendBuffer[count] = htonl(timer->Lifetime());               count += 4;
1291     *(ULONG*)&sendBuffer[count] = htonl(timer->Channel()->Number());      count += 4;
1292     *(ULONG*)&sendBuffer[count] = htonl(timer->StartTime());              count += 4;
1293     *(ULONG*)&sendBuffer[count] = htonl(timer->StopTime());               count += 4;
1294
1295     fileName = timer->File();
1296     strcpy((char*)&sendBuffer[count], fileName);
1297     count += strlen(fileName) + 1;
1298   }
1299
1300   *(ULONG*)&sendBuffer[0] = htonl(count - 4); // -4 :  take off the size field
1301
1302   log->log("Client", Log::DEBUG, "recorded size as %u", ntohl(*(ULONG*)&sendBuffer[0]));
1303
1304   tcp.sendPacket(sendBuffer, count);
1305   delete[] sendBuffer;
1306   log->log("Client", Log::DEBUG, "Written timers list");
1307
1308   return 1;
1309 }
1310
1311 int MVPClient::processSetTimer(UCHAR* buffer, int length)
1312 {
1313   char* timerString = new char[strlen((char*)buffer) + 1];
1314   strcpy(timerString, (char*)buffer);
1315
1316 #if VDRVERSNUM < 10300
1317
1318   // If this is VDR 1.2 the date part of the timer string must be reduced
1319   // to just DD rather than YYYY-MM-DD
1320
1321   int s = 0; // source
1322   int d = 0; // destination
1323   int c = 0; // count
1324   while(c != 2) // copy up to date section, including the second ':'
1325   {
1326     timerString[d] = buffer[s];
1327     if (buffer[s] == ':') c++;
1328     ++s;
1329     ++d;
1330   }
1331   // now it has copied up to the date section
1332   c = 0;
1333   while(c != 2) // waste YYYY-MM-
1334   {
1335     if (buffer[s] == '-') c++;
1336     ++s;
1337   }
1338   // now source is at the DD
1339   memcpy(&timerString[d], &buffer[s], length - s);
1340   d += length - s;
1341   timerString[d] = '\0';
1342
1343   log->log("Client", Log::DEBUG, "Timer string after 1.2 conversion:");
1344   log->log("Client", Log::DEBUG, "%s", timerString);
1345
1346 #endif
1347
1348   cTimer *timer = new cTimer;
1349   if (timer->Parse((char*)timerString))
1350   {
1351     cTimer *t = Timers.GetTimer(timer);
1352     if (!t)
1353     {
1354       Timers.Add(timer);
1355 #if VDRVERSNUM < 10300
1356       Timers.Save();
1357 #else
1358       Timers.SetModified();
1359 #endif
1360       sendULONG(0);
1361       return 1;
1362     }
1363     else
1364     {
1365       sendULONG(1);
1366     }
1367   }
1368   else
1369   {
1370      sendULONG(2);
1371   }
1372   delete timer;
1373   return 1;
1374 }