]> git.vomp.tv Git - vompclient-marten.git/blob - vdr.cc
Mouse support (part 1)
[vompclient-marten.git] / vdr.cc
1 /*
2     Copyright 2004-2005 Chris Tallon
3
4     This file is part of VOMP.
5
6     VOMP is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10
11     VOMP is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15
16     You should have received a copy of the GNU General Public License
17     along with VOMP; if not, write to the Free Software
18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19 */
20
21 #include "vdr.h"
22 #include "recman.h"
23
24 VDR* VDR::instance = NULL;
25
26 #ifndef WIN32
27 #define MUTEX_LOCK(mutex) pthread_mutex_lock(mutex)
28 #define MUTEX_UNLOCK(mutex) pthread_mutex_unlock(mutex)
29 #else
30 #define MUTEX_LOCK(mutex) WaitForSingleObject(*(mutex), INFINITE )
31 #define MUTEX_UNLOCK(mutex) ReleaseMutex(*(mutex))
32 #endif
33
34
35 VDR::VDR()
36 {
37   if (instance) return;
38   instance = this;
39   initted = 0;
40   findingServer = 0;
41   tcp = NULL;
42 #ifndef WIN32
43   pthread_mutex_init(&mutex, NULL);
44 #else
45   mutex=CreateMutex(NULL,FALSE,NULL);
46 #endif
47   packetLength = 0;
48   packetPos = 0;
49   packet = NULL;
50   connected = false;
51 }
52
53 VDR::~VDR()
54 {
55 #ifdef WIN32
56   CloseHandle(mutex);
57 #endif
58   instance = NULL;
59   if (initted) shutdown();
60 }
61
62 VDR* VDR::getInstance()
63 {
64   return instance;
65 }
66
67 int VDR::init(int tport)
68 {
69   if (initted) return 0;
70   initted = 1;
71   port = tport;
72   logger = Log::getInstance();
73   return 1;
74 }
75
76 int VDR::shutdown()
77 {
78   if (!initted) return 0;
79   initted = 0;
80   disconnect();
81   return 1;
82 }
83
84 void VDR::findServers(vector<VDRServer>& servers)
85 {
86   findingServer = 1;
87   char* message = "VOMP";
88
89   DatagramSocket ds(port);
90   int haveAtLeastOne = 0;
91   int retval;
92   int waitType = 1;
93   while(findingServer)
94   {
95     if (waitType == 1)
96     {
97       ds.shutdown();
98       ds.init();
99       logger->log("VDR", Log::NOTICE, "Broadcasting for server");
100       ds.send("255.255.255.255", 3024, message, strlen(message));
101     }
102     retval = ds.waitforMessage(waitType);
103
104     if (retval == 2) // we got a reply
105     {
106       if (!strcmp(ds.getData(), "VOMP")) // echo.....
107       {
108         waitType = 2;
109       }
110       else
111       {
112         VDRServer newServer;
113         newServer.ip = new char[16];
114         strcpy(newServer.ip, ds.getFromIPA());
115
116         if (ds.getDataLength() == 0)
117         {
118           newServer.name = new char[1];
119           newServer.name[0] = '\0';
120         }
121         else
122         {
123           newServer.name = new char[strlen(ds.getData())+1];
124           strcpy(newServer.name, ds.getData());
125         }
126
127         servers.push_back(newServer);
128         waitType = 2;
129         haveAtLeastOne = 1;
130       }
131     }
132     else
133     {
134       if (haveAtLeastOne) break;
135       waitType = 1;
136     }
137   }
138   sort(servers.begin(), servers.end(), ServerSorter());
139 }
140
141 void VDR::cancelFindingServer()
142 {
143   findingServer = 0;
144 }
145
146 void VDR::setServerIP(char* newIP)
147 {
148   strcpy(serverIP, newIP);
149 }
150
151 int VDR::connect()
152 {
153   if (tcp) delete tcp;
154   tcp = new TCP();
155   if (tcp->connectTo(serverIP, 3024))
156   {
157     connected = true;
158     return 1;
159   }
160   else
161   {
162     return 0;
163   }
164 }
165
166 void VDR::disconnect()
167 {
168   if (tcp) delete tcp;
169   tcp = NULL;
170   connected = false;
171   Log::getInstance()->log("VDR", Log::DEBUG, "Disconnect");
172 }
173
174 void VDR::setReceiveWindow(size_t size)
175 {
176   if (connected) tcp->setReceiveWindow(size);
177 }
178
179 ///////////////////////////////////////////////////////
180
181 int VDR::getPacket()
182 {
183   packet = (UCHAR*)tcp->receivePacket();
184   if (!packet)
185   {
186     disconnect();
187     return 0;
188   }
189   packetLength = tcp->getDataLength();
190   return 1;
191 }
192
193 void VDR::freePacket()
194 {
195   // Must be called if getPacket return 1, except in getBlock
196   packetLength = 0;
197   packetPos = 0;
198   free(packet);
199   packet = NULL;
200 }
201
202 int VDR::serverError()
203 {
204   if ((packetPos == 0) && (packetLength == 4) && !ntohl(*(ULONG*)packet)) return 1;
205   else return 0;
206 }
207
208 char* VDR::extractString()
209 {
210   if (serverError()) return NULL;
211
212   int length = strlen((char*)&packet[packetPos]);
213   if ((packetPos + length) > packetLength) return NULL;
214   char* str = new char[length + 1];
215   strcpy(str, (char*)&packet[packetPos]);
216   packetPos += length + 1;
217   return str;
218 }
219
220 UCHAR VDR::extractUCHAR()
221 {
222   if ((packetPos + sizeof(UCHAR)) > packetLength) return 0;
223   UCHAR uc = packet[packetPos];
224   packetPos += sizeof(UCHAR);
225   return uc;
226 }
227
228 ULONG VDR::extractULONG()
229 {
230   if ((packetPos + sizeof(ULONG)) > packetLength) return 0;
231   ULONG ul = ntohl(*(ULONG*)&packet[packetPos]);
232   packetPos += sizeof(ULONG);
233   return ul;
234 }
235
236 ULLONG VDR::extractULLONG()
237 {
238   if ((packetPos + sizeof(ULLONG)) > packetLength) return 0;
239   ULLONG ull = ntohll(*(ULLONG*)&packet[packetPos]);
240   packetPos += sizeof(ULLONG);
241   return ull;
242 }
243
244 long VDR::extractLONG()
245 {
246   if ((packetPos + sizeof(long)) > packetLength) return 0;
247   long l = ntohl(*(long*)&packet[packetPos]);
248   packetPos += sizeof(long);
249   return l;
250 }
251
252 /////////////////////////////////////////////////////////////////////////////
253
254 int VDR::doLogin()
255 {
256   UCHAR buffer[14];
257
258   *(unsigned long*)&buffer[0] = htonl(10);
259   *(unsigned long*)&buffer[4] = htonl(VDR_LOGIN);
260
261   tcp->getMAC((char*)&buffer[8]);
262
263
264   MUTEX_LOCK(&mutex);
265   if (!connected)
266   {
267     MUTEX_UNLOCK(&mutex);
268     return 0;
269   }
270
271   int a = tcp->sendPacket(buffer, 14);
272   if (a != 14)
273   {
274     disconnect();
275     MUTEX_UNLOCK(&mutex);
276     return 0;
277   }
278
279   // reply
280
281   if (!getPacket())
282   {
283     MUTEX_UNLOCK(&mutex);
284     return 0;
285   }
286
287   ULONG vdrTime = extractULONG();
288   logger->log("VDR", Log::DEBUG, "vdrtime = %lu", vdrTime);
289   long vdrTimeOffset = extractLONG();
290   logger->log("VDR", Log::DEBUG, "offset = %i", vdrTimeOffset);
291
292   freePacket();
293   MUTEX_UNLOCK(&mutex);
294
295   // Set the time and zone on the MVP
296
297 #ifndef WIN32
298   struct timespec currentTime;
299   currentTime.tv_sec = vdrTime;
300   currentTime.tv_nsec = 0;
301   int b = clock_settime(CLOCK_REALTIME, &currentTime);
302
303   logger->log("VDR", Log::DEBUG, "set clock = %u", b);
304
305   // now make a TZ variable and set it
306   char sign;
307   int hours;
308   int minutes;
309   if (vdrTimeOffset > 0) sign = '-';
310   else sign = '+';
311
312   vdrTimeOffset = abs(vdrTimeOffset);
313
314   hours = (int)vdrTimeOffset / 3600;
315   minutes = vdrTimeOffset % 3600;
316
317   logger->log("VDR", Log::DEBUG, "%c %i %i", sign, hours, minutes);
318
319   minutes = (int)minutes / 60;
320
321   logger->log("VDR", Log::DEBUG, "%c %i %i", sign, hours, minutes);
322
323   char newTZ[30];
324   sprintf(newTZ, "MVP%c%i:%i", sign, hours, minutes);
325   setenv("TZ", newTZ, 1);
326
327   logger->log("VDR", Log::DEBUG, "Timezone data: %s", newTZ);
328 #endif
329
330   return 1;
331 }
332
333 bool VDR::getRecordingsList(RecMan* recman)
334 {
335   UCHAR buffer[8];
336
337   *(unsigned long*)&buffer[0] = htonl(4);
338   *(unsigned long*)&buffer[4] = htonl(VDR_GETRECORDINGLIST);
339
340   MUTEX_LOCK(&mutex);
341   if (!connected)
342   {
343     MUTEX_UNLOCK(&mutex);
344     return 0;
345   }
346
347   int a = tcp->sendPacket(buffer, 8);
348   if (a != 8)
349   {
350     disconnect();
351     MUTEX_UNLOCK(&mutex);
352     return false;
353   }
354
355   // reply
356
357   if (!getPacket())
358   {
359     MUTEX_UNLOCK(&mutex);
360     return false;
361   }
362
363   ULONG totalSpace = extractULONG();
364   ULONG freeSpace = extractULONG();
365   ULONG percent = extractULONG();
366   recman->setStats(totalSpace, freeSpace, percent);
367
368   ULONG start;
369   char* name;
370   char* fileName;
371
372   while (packetPos < packetLength)
373   {
374     start = extractULONG();
375     name = extractString();
376     fileName = extractString();
377
378     recman->addEntry(start, name, fileName);
379
380     delete[] name;
381     delete[] fileName;
382   }
383
384   freePacket();
385   MUTEX_UNLOCK(&mutex);
386
387   return true;
388 }
389
390 int VDR::deleteRecording(char* fileName)
391 {
392   unsigned long totalLength = 8 + strlen(fileName) + 1;
393   UCHAR* buffer = new UCHAR[totalLength];
394
395   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
396   *(unsigned long*)&buffer[4] = htonl(VDR_DELETERECORDING);
397   strcpy((char*)&buffer[8], fileName);
398
399   MUTEX_LOCK(&mutex);
400   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
401
402   unsigned int a = tcp->sendPacket(buffer, totalLength);
403   delete []buffer;
404
405   if (a != totalLength)
406   {
407     disconnect();
408     MUTEX_UNLOCK(&mutex);
409     return 0;
410   }
411
412   if (!getPacket())
413   {
414     MUTEX_UNLOCK(&mutex);
415     return 0;
416   }
417
418   int toReturn = (int)extractULONG();
419   freePacket();
420   MUTEX_UNLOCK(&mutex);
421
422   return toReturn;
423 }
424
425 char* VDR::moveRecording(char* fileName, char* newPath)
426 {
427   unsigned long totalLength = 8 + strlen(fileName) + 1 + strlen(newPath) + 1;
428   UCHAR* buffer = new UCHAR[totalLength];
429
430   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
431   *(unsigned long*)&buffer[4] = htonl(VDR_MOVERECORDING);
432   strcpy((char*)&buffer[8], fileName);
433   strcpy((char*)&buffer[8 + strlen(fileName) + 1], newPath);
434
435   MUTEX_LOCK(&mutex);
436   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
437
438   unsigned int a = tcp->sendPacket(buffer, totalLength);
439   delete []buffer;
440
441   if (a != totalLength)
442   {
443     disconnect();
444     MUTEX_UNLOCK(&mutex);
445     return 0;
446   }
447
448   if (!getPacket())
449   {
450     MUTEX_UNLOCK(&mutex);
451     return 0;
452   }
453
454   char* toReturn = NULL;
455   int success = (int)extractULONG();
456   if (success == 1)
457   {
458     toReturn = extractString();
459   }
460
461   freePacket();
462   MUTEX_UNLOCK(&mutex);
463
464   return toReturn;
465 }
466
467 ChannelList* VDR::getChannelsList(ULONG type)
468 {
469   UCHAR buffer[8];
470
471   *(unsigned long*)&buffer[0] = htonl(4);
472   *(unsigned long*)&buffer[4] = htonl(VDR_GETCHANNELLIST);
473
474   MUTEX_LOCK(&mutex);
475   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
476
477   int a = tcp->sendPacket(buffer, 8);
478   if (a != 8)
479   {
480     disconnect();
481     MUTEX_UNLOCK(&mutex);
482     return NULL;
483   }
484
485   // reply
486
487   if (!getPacket())
488   {
489     MUTEX_UNLOCK(&mutex);
490     return NULL;
491   }
492
493   ChannelList* chanList = new ChannelList();
494
495   while (packetPos < packetLength)
496   {
497     Channel* chan = new Channel();
498     chan->number = extractULONG();
499     chan->type = extractULONG();
500     chan->name = extractString();
501
502     if (chan->type == type)
503     {
504       chanList->push_back(chan);
505       Log::getInstance()->log("VDR", Log::DEBUG, "Have added a channel to list. %lu %lu %s", chan->number, chan->type, chan->name);
506     }
507     else
508     {
509       delete chan;
510     }
511   }
512
513   freePacket();
514   MUTEX_UNLOCK(&mutex);
515
516   return chanList;
517 }
518
519 int VDR::streamChannel(ULONG number)
520 {
521   UCHAR buffer[12];
522
523   *(unsigned long*)&buffer[0] = htonl(8);
524   *(unsigned long*)&buffer[4] = htonl(VDR_STREAMCHANNEL);
525   *(unsigned long*)&buffer[8] = htonl(number);
526
527   MUTEX_LOCK(&mutex);
528   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
529
530   int a = tcp->sendPacket(buffer, 12);
531
532   if (a != 12)
533   {
534     disconnect();
535     MUTEX_UNLOCK(&mutex);
536     return 0;
537   }
538
539   if (!getPacket())
540   {
541     MUTEX_UNLOCK(&mutex);
542     return 0;
543   }
544
545   int toReturn = (int)extractULONG();
546   freePacket();
547   MUTEX_UNLOCK(&mutex);
548
549   return toReturn;
550 }
551
552 int VDR::stopStreaming()
553 {
554   UCHAR buffer[8];
555
556   *(unsigned long*)&buffer[0] = htonl(4);
557   *(unsigned long*)&buffer[4] = htonl(VDR_STOPSTREAMING);
558
559   MUTEX_LOCK(&mutex);
560   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
561
562   int a = tcp->sendPacket(buffer, 8);
563
564   if (a != 8)
565   {
566     disconnect();
567     MUTEX_UNLOCK(&mutex);
568     return 0;
569   }
570
571   if (!getPacket())
572   {
573     MUTEX_UNLOCK(&mutex);
574     return 0;
575   }
576
577   int toReturn = (int)extractULONG();
578   freePacket();
579   MUTEX_UNLOCK(&mutex);
580
581   return toReturn;
582 }
583
584 UCHAR* VDR::getBlock(ULLONG position, UINT maxAmount, UINT* amountReceived)
585 {
586   UCHAR buffer[20];
587
588   *(unsigned long*)&buffer[0] = htonl(16);
589   *(unsigned long*)&buffer[4] = htonl(VDR_GETBLOCK);
590   *(ULLONG*)&buffer[8]        = htonll(position);
591   *(unsigned long*)&buffer[16] = htonl(maxAmount);
592
593   MUTEX_LOCK(&mutex);
594   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
595
596   int a = tcp->sendPacket(buffer, 20);
597   if (a != 20)
598   {
599     disconnect();
600     MUTEX_UNLOCK(&mutex);
601     return NULL;
602   }
603
604   if (!getPacket())
605   {
606     MUTEX_UNLOCK(&mutex);
607     return NULL;
608   }
609
610   if (serverError())
611   {
612     Log::getInstance()->log("VDR", Log::DEBUG, "Detected getblock 0");
613     freePacket();
614     MUTEX_UNLOCK(&mutex);
615     return NULL;
616   }
617
618   UCHAR* toReturn = packet;
619   *amountReceived = packetLength;
620   // Manually clean up instead of running freePacket to keep the block
621   packet = NULL;
622   packetLength = 0;
623   packetPos = 0;
624   MUTEX_UNLOCK(&mutex);
625
626
627   return toReturn;
628 }
629
630 ULLONG VDR::streamRecording(char* fileName, ULONG* totalFrames)
631 {
632   unsigned long totalLength = 8 + strlen(fileName) + 1;
633   UCHAR* buffer = new UCHAR[totalLength];
634
635   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
636   *(unsigned long*)&buffer[4] = htonl(VDR_STREAMRECORDING);
637   strcpy((char*)&buffer[8], fileName);
638
639   MUTEX_LOCK(&mutex);
640   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
641
642   unsigned int a = tcp->sendPacket(buffer, totalLength);
643   delete []buffer;
644
645   if (a != totalLength)
646   {
647     disconnect();
648     MUTEX_UNLOCK(&mutex);
649     return 0;
650   }
651
652   if (!getPacket())
653   {
654     MUTEX_UNLOCK(&mutex);
655     return 0;
656   }
657
658   ULLONG lengthBytes = extractULLONG();
659   ULONG lengthFrames = extractULONG();
660   freePacket();
661   MUTEX_UNLOCK(&mutex);
662
663   Log::getInstance()->log("VDR", Log::DEBUG, "VDR said length is: %llu %lu", lengthBytes, lengthFrames);
664
665   *totalFrames = lengthFrames;
666   return lengthBytes;
667 }
668
669 ULLONG VDR::positionFromFrameNumber(ULONG frameNumber)
670 {
671   unsigned long totalLength = 12;
672   UCHAR* buffer = new UCHAR[totalLength];
673
674   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
675   *(unsigned long*)&buffer[4] = htonl(VDR_POSFROMFRAME);
676   *(unsigned long*)&buffer[8] = htonl(frameNumber);
677
678   MUTEX_LOCK(&mutex);
679   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
680
681   unsigned int a = tcp->sendPacket(buffer, totalLength);
682   delete []buffer;
683
684   if (a != totalLength)
685   {
686     disconnect();
687     MUTEX_UNLOCK(&mutex);
688     return 0;
689   }
690
691   if (!getPacket())
692   {
693     MUTEX_UNLOCK(&mutex);
694     return 0;
695   }
696
697   ULLONG position = extractULLONG();
698   freePacket();
699   MUTEX_UNLOCK(&mutex);
700
701   Log::getInstance()->log("VDR", Log::DEBUG, "VDR said new position is: %llu", position);
702
703   return position;
704 }
705
706 ULONG VDR::frameNumberFromPosition(ULLONG position)
707 {
708   unsigned long totalLength = 16;
709   UCHAR* buffer = new UCHAR[totalLength];
710
711   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
712   *(unsigned long*)&buffer[4] = htonl(VDR_FRAMEFROMPOS);
713   *(ULLONG*)&buffer[8] = htonll(position);
714
715   MUTEX_LOCK(&mutex);
716   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
717
718   unsigned int a = tcp->sendPacket(buffer, totalLength);
719   delete []buffer;
720
721   if (a != totalLength)
722   {
723     disconnect();
724     MUTEX_UNLOCK(&mutex);
725     return 0;
726   }
727
728   if (!getPacket())
729   {
730     MUTEX_UNLOCK(&mutex);
731     return 0;
732   }
733
734   ULONG framenumber = extractULONG();
735   freePacket();
736   MUTEX_UNLOCK(&mutex);
737
738   Log::getInstance()->log("VDR", Log::DEBUG, "VDR said new framenumber is: %u", framenumber);
739
740   return framenumber;
741 }
742
743 bool VDR::getNextIFrame(ULONG frameNumber, ULONG direction, ULLONG* rfilePosition, ULONG* rframeNumber, ULONG* rframeLength)
744 {
745   unsigned long totalLength = 16;
746   UCHAR* buffer = new UCHAR[totalLength];
747
748   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
749   *(unsigned long*)&buffer[4] = htonl(VDR_GETNEXTIFRAME);
750   *(unsigned long*)&buffer[8] = htonl(frameNumber);
751   *(unsigned long*)&buffer[12] = htonl(direction);
752
753   MUTEX_LOCK(&mutex);
754   if (!connected) { MUTEX_UNLOCK(&mutex); return false; }
755
756   unsigned int a = tcp->sendPacket(buffer, totalLength);
757   delete []buffer;
758
759   if (a != totalLength)
760   {
761     disconnect();
762     MUTEX_UNLOCK(&mutex);
763     return false;
764   }
765
766   if (!getPacket())
767   {
768     MUTEX_UNLOCK(&mutex);
769     return false;
770   }
771
772   if (serverError())
773   {
774     Log::getInstance()->log("VDR", Log::DEBUG, "Detected getNextIFrame error");
775     freePacket();
776     MUTEX_UNLOCK(&mutex);
777     return false;
778   }
779
780   *rfilePosition = extractULLONG();
781   *rframeNumber = extractULONG();
782   *rframeLength = extractULONG();
783
784   freePacket();
785   MUTEX_UNLOCK(&mutex);
786
787 //  Log::getInstance()->log("VDR", Log::DEBUG, "VDR GNIF said %llu %lu %lu", *rfilePosition, *rframeNumber, *rframeLength);
788
789   return true;
790 }
791
792 EventList* VDR::getChannelSchedule(ULONG number)
793 {
794   time_t now;
795   time(&now);
796   return getChannelSchedule(number, now, 24 * 60 * 60);
797 }
798
799 EventList* VDR::getChannelSchedule(ULONG number, time_t start, ULONG duration)
800 {
801 // retrieve event list (vector of events) from vdr within filter window. duration is in seconds
802   UCHAR buffer[20];
803
804   *(unsigned long*)&buffer[0] = htonl(16);
805   *(unsigned long*)&buffer[4] = htonl(VDR_GETCHANNELSCHEDULE);
806   *(unsigned long*)&buffer[8] = htonl(number);
807   *(unsigned long*)&buffer[12] = htonl(start);
808   *(unsigned long*)&buffer[16] = htonl(duration);
809
810   MUTEX_LOCK(&mutex);
811   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
812
813   int a = tcp->sendPacket(buffer, 20);
814
815   if (a != 20)
816   {
817     disconnect();
818     MUTEX_UNLOCK(&mutex);
819     return NULL;
820   }
821
822   if (!getPacket())
823   {
824     MUTEX_UNLOCK(&mutex);
825     return NULL;
826   }
827
828   // received a ulong(0) - schedules error in the plugin
829   if (serverError())
830   {
831     freePacket();
832     MUTEX_UNLOCK(&mutex);
833     return NULL;
834   }
835
836   EventList* eventList = new EventList();
837
838   while (packetPos < packetLength)
839   {
840     Event* event = new Event();
841     event->id = extractULONG();
842     event->time = extractULONG();
843     event->duration = extractULONG();
844     event->title = extractString();
845     event->subtitle = extractString();
846     event->description = extractString();
847     eventList->push_back(event);
848   }
849
850   freePacket();
851   MUTEX_UNLOCK(&mutex);
852
853   Log::getInstance()->log("VDR", Log::DEBUG, "Success got to end of getChannelSchedule");
854   return eventList;
855 }
856
857 int VDR::configSave(char* section, char* key, const char* value)
858 {
859   ULONG totalLength = 8 + strlen(section) + strlen(key) + strlen(value) + 3; // 8 for headers, 3 for nulls
860   UCHAR* buffer = new UCHAR[totalLength];
861
862   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
863   *(unsigned long*)&buffer[4] = htonl(VDR_CONFIGSAVE);
864
865   int position = 8;
866   strcpy((char*)&buffer[position], section);
867   position += strlen(section) + 1;
868   strcpy((char*)&buffer[position], key);
869   position += strlen(key) + 1;
870   strcpy((char*)&buffer[position], value);
871
872   MUTEX_LOCK(&mutex);
873   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
874
875   unsigned int a = tcp->sendPacket(buffer, totalLength);
876   delete[] buffer;
877
878   if (a != totalLength)
879   {
880     disconnect();
881     MUTEX_UNLOCK(&mutex);
882     return 0;
883   }
884
885   if (!getPacket())
886   {
887     MUTEX_UNLOCK(&mutex);
888     return 0;
889   }
890
891   int toReturn = (int)extractULONG();
892   freePacket();
893   MUTEX_UNLOCK(&mutex);
894
895   return toReturn;
896 }
897
898 char* VDR::configLoad(char* section, char* key)
899 {
900   ULONG totalLength = 8 + strlen(section) + strlen(key) + 2; // 8 for headers, 2 for nulls
901   UCHAR* buffer = new UCHAR[totalLength];
902
903   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
904   *(unsigned long*)&buffer[4] = htonl(VDR_CONFIGLOAD);
905
906   int position = 8;
907   strcpy((char*)&buffer[position], section);
908   position += strlen(section) + 1;
909   strcpy((char*)&buffer[position], key);
910
911   MUTEX_LOCK(&mutex);
912   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
913
914   unsigned int a = tcp->sendPacket(buffer, totalLength);
915   delete[] buffer;
916
917   if (a != totalLength)
918   {
919     disconnect();
920     MUTEX_UNLOCK(&mutex);
921     return NULL;
922   }
923
924   if (!getPacket())
925   {
926     MUTEX_UNLOCK(&mutex);
927     return NULL;
928   }
929   char* toReturn = extractString();
930   freePacket();
931   MUTEX_UNLOCK(&mutex);
932
933   return toReturn;
934 }
935
936 RecTimerList* VDR::getRecTimersList()
937 {
938   UCHAR buffer[8];
939
940   *(unsigned long*)&buffer[0] = htonl(4);
941   *(unsigned long*)&buffer[4] = htonl(VDR_GETTIMERS);
942
943   MUTEX_LOCK(&mutex);
944   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
945
946   int a = tcp->sendPacket(buffer, 8);
947   if (a != 8)
948   {
949     disconnect();
950     MUTEX_UNLOCK(&mutex);
951     return NULL;
952   }
953
954   // reply
955
956   if (!getPacket())
957   {
958     MUTEX_UNLOCK(&mutex);
959     return NULL;
960   }
961
962   RecTimerList* recTimerList = new RecTimerList();
963
964   ULONG numTimers = extractULONG();
965   if (numTimers > 0)
966   {
967     RecTimer* newRecTimer;
968     char* tempString;
969
970     while (packetPos < packetLength)
971     {
972       newRecTimer = new RecTimer();
973       newRecTimer->active = extractULONG();
974       newRecTimer->recording = extractULONG();
975       newRecTimer->pending = extractULONG();
976       newRecTimer->priority = extractULONG();
977       newRecTimer->lifeTime = extractULONG();
978       newRecTimer->channelNumber = extractULONG();
979       newRecTimer->startTime = extractULONG();
980       newRecTimer->stopTime = extractULONG();
981
982       tempString = extractString();
983       newRecTimer->setFile(tempString);
984       delete[] tempString;
985
986       recTimerList->push_back(newRecTimer);
987       Log::getInstance()->log("VDR", Log::DEBUG, "TL: %lu %lu %lu %lu %lu %lu %lu %lu %s",
988         newRecTimer->active, newRecTimer->recording, newRecTimer->pending, newRecTimer->priority, newRecTimer->lifeTime,
989         newRecTimer->channelNumber, newRecTimer->startTime, newRecTimer->stopTime, newRecTimer->getFile());
990     }
991   }
992
993   freePacket();
994   MUTEX_UNLOCK(&mutex);
995
996   sort(recTimerList->begin(), recTimerList->end(), RecTimerSorter());
997
998   return recTimerList;
999 }
1000
1001 ULONG VDR::setEventTimer(char* timerString)
1002 {
1003   unsigned long totalLength = 8 + strlen(timerString) + 1;
1004   UCHAR* buffer = new UCHAR[totalLength];
1005
1006   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
1007   *(unsigned long*)&buffer[4] = htonl(VDR_SETTIMER);
1008   strcpy((char*)&buffer[8], timerString);
1009
1010   MUTEX_LOCK(&mutex);
1011   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
1012
1013   unsigned int a = tcp->sendPacket(buffer, totalLength);
1014   delete []buffer;
1015
1016   if (a != totalLength)
1017   {
1018     disconnect();
1019     MUTEX_UNLOCK(&mutex);
1020     return 0;
1021   }
1022
1023   if (!getPacket())
1024   {
1025     MUTEX_UNLOCK(&mutex);
1026     return 0;
1027   }
1028
1029   ULONG toReturn = extractULONG();
1030   freePacket();
1031   MUTEX_UNLOCK(&mutex);
1032
1033   return toReturn;
1034 }
1035
1036 RecInfo* VDR::getRecInfo(char* fileName)
1037 {
1038   unsigned long totalLength = 8 + strlen(fileName) + 1;
1039   UCHAR* buffer = new UCHAR[totalLength];
1040
1041   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
1042   *(unsigned long*)&buffer[4] = htonl(VDR_GETRECINFO);
1043   strcpy((char*)&buffer[8], fileName);
1044
1045   MUTEX_LOCK(&mutex);
1046   if (!connected) { MUTEX_UNLOCK(&mutex); return NULL; }
1047
1048   unsigned int a = tcp->sendPacket(buffer, totalLength);
1049   delete []buffer;
1050
1051   if (a != totalLength)
1052   {
1053     disconnect();
1054     MUTEX_UNLOCK(&mutex);
1055     return NULL;
1056   }
1057
1058   if (!getPacket())
1059   {
1060     MUTEX_UNLOCK(&mutex);
1061     return NULL;
1062   }
1063
1064   if (serverError())
1065   {
1066     Log::getInstance()->log("VDR", Log::DEBUG, "Could not get rec info");
1067     freePacket();
1068     MUTEX_UNLOCK(&mutex);
1069     return NULL;
1070   }
1071
1072   TCP::dump(packet, packetLength);
1073
1074   RecInfo* recInfo = new RecInfo();
1075
1076   recInfo->timerStart = extractULONG();
1077   recInfo->timerEnd = extractULONG();
1078   recInfo->resumePoint = extractULONG();
1079   recInfo->summary = extractString();
1080
1081   ULONG numComponents = extractULONG();
1082   if (numComponents)
1083   {
1084     recInfo->setNumComponents(numComponents);
1085     for (ULONG i = 0; i < numComponents; i++)
1086     {
1087       recInfo->streams[i] = extractUCHAR();
1088       recInfo->types[i] = extractUCHAR();
1089       recInfo->languages[i] = extractString();
1090       recInfo->descriptions[i] = extractString();
1091     }
1092   }
1093
1094   recInfo->print();
1095
1096   freePacket();
1097   MUTEX_UNLOCK(&mutex);
1098   return recInfo;
1099 }
1100
1101 // FIXME obselete
1102 ULLONG VDR::rescanRecording(ULONG* totalFrames)
1103 {
1104   unsigned long totalLength = 8;
1105   UCHAR* buffer = new UCHAR[totalLength];
1106
1107   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
1108   *(unsigned long*)&buffer[4] = htonl(VDR_RESCANRECORDING);
1109
1110   MUTEX_LOCK(&mutex);
1111   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
1112
1113   unsigned int a = tcp->sendPacket(buffer, totalLength);
1114   delete []buffer;
1115
1116   if (a != totalLength)
1117   {
1118     disconnect();
1119     MUTEX_UNLOCK(&mutex);
1120     return 0;
1121   }
1122
1123   if (!getPacket())
1124   {
1125     MUTEX_UNLOCK(&mutex);
1126     return 0;
1127   }
1128
1129   ULLONG lengthBytes = extractULLONG();
1130   ULONG lengthFrames = extractULONG();
1131   freePacket();
1132   MUTEX_UNLOCK(&mutex);
1133
1134   Log::getInstance()->log("VDR", Log::DEBUG, "VDR said length is: %llu %lu", lengthBytes, lengthFrames);
1135
1136   *totalFrames = lengthFrames;
1137   return lengthBytes;
1138 }
1139
1140 MarkList* VDR::getMarks(char* fileName)
1141 {
1142   unsigned long totalLength = 8 + strlen(fileName) + 1;
1143   UCHAR* buffer = new UCHAR[totalLength];
1144
1145   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
1146   *(unsigned long*)&buffer[4] = htonl(VDR_GETMARKS);
1147   strcpy((char*)&buffer[8], fileName);
1148
1149   MUTEX_LOCK(&mutex);
1150   if (!connected) { MUTEX_UNLOCK(&mutex); return 0; }
1151
1152   unsigned int a = tcp->sendPacket(buffer, totalLength);
1153   delete []buffer;
1154
1155   if (a != totalLength)
1156   {
1157     disconnect();
1158     MUTEX_UNLOCK(&mutex);
1159     return NULL;
1160   }
1161
1162   if (!getPacket())
1163   {
1164     MUTEX_UNLOCK(&mutex);
1165     return NULL;
1166   }
1167
1168   if (serverError())
1169   {
1170     MUTEX_UNLOCK(&mutex);
1171     return NULL;
1172   }
1173
1174   MarkList* markList = new MarkList();
1175
1176   while (packetPos < packetLength)
1177   {
1178     Mark* mark = new Mark();
1179     mark->pos = extractULONG();
1180
1181     markList->push_back(mark);
1182     Log::getInstance()->log("VDR", Log::DEBUG, "Have added a mark to list. %lu", mark->pos);
1183   }
1184
1185   freePacket();
1186   MUTEX_UNLOCK(&mutex);
1187
1188   return markList;
1189 }
1190
1191 void VDR::getChannelPids(Channel* channel)
1192 {
1193   UCHAR buffer[12];
1194
1195   *(unsigned long*)&buffer[0] = htonl(8);
1196   *(unsigned long*)&buffer[4] = htonl(VDR_GETCHANNELPIDS);
1197   *(unsigned long*)&buffer[8] = htonl(channel->number);
1198
1199   MUTEX_LOCK(&mutex);
1200   if (!connected) { MUTEX_UNLOCK(&mutex); return ; }
1201
1202   int a = tcp->sendPacket(buffer, 12);
1203
1204   if (a != 12)
1205   {
1206     disconnect();
1207     MUTEX_UNLOCK(&mutex);
1208     return ;
1209   }
1210
1211   if (!getPacket())
1212   {
1213     MUTEX_UNLOCK(&mutex);
1214     return ;
1215   }
1216
1217   // Format of response
1218   // vpid
1219   // number of apids
1220   // {
1221   //    apid
1222   //    lang string
1223   // }
1224
1225   channel->vpid = extractULONG();
1226   channel->numAPids = extractULONG();
1227
1228   for (ULONG i = 0; i < channel->numAPids; i++)
1229   {
1230     apid newapid;
1231     newapid.pid = extractULONG();
1232     newapid.name = extractString();
1233     channel->apids.push_back(newapid);
1234   }
1235
1236   freePacket();
1237   MUTEX_UNLOCK(&mutex);
1238
1239   return ;
1240 }