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
  23 VDR* VDR::instance = NULL;
  24
  25 VDR::VDR()
  26 {
  27   if (instance) return;
  28   instance = this;
  29   initted = 0;
  30   findingServer = 0;
  31   tcp = NULL;
  32   pthread_mutex_init(&mutex, NULL);
  33 }
  34
  35 VDR::~VDR()
  36 {
  37   instance = NULL;
  38   if (initted) shutdown();
  39 }
  40
  41 VDR* VDR::getInstance()
  42 {
  43   return instance;
  44 }
  45
  46 int VDR::init(int tport)
  47 {
  48   if (initted) return 0;
  49   initted = 1;
  50   port = tport;
  51   logger = Log::getInstance();
  52   return 1;
  53 }
  54
  55 int VDR::shutdown()
  56 {
  57   if (!initted) return 0;
  58   initted = 0;
  59   disconnect();
  60   return 1;
  61 }
  62
  63 void VDR::findServers(std::vector<char*>& serverIPs)
  64 {
  65   findingServer = 1;
  66   char* message = "VOMP CLIENT";
  67   DatagramSocket ds(port);
  68
  69   int haveAtLeastOne = 0;
  70   char* newIP;
  71   int retval;
  72   int waitType = 1;
  73   while(findingServer)
  74   {
  75     if (waitType == 1)
  76     {
  77       logger->log("VDR", Log::NOTICE, "Broadcasting for server");
  78       ds.send("255.255.255.255", 3024, message, strlen(message));
  79     }
  80     retval = ds.waitforMessage(waitType);
  81
  82     if (retval == 2) // we got a reply
  83     {
  84       if (strcmp(ds.getData(), "VOMP SERVER")) // echo.....
  85       {
  86         waitType = 2;
  87       }
  88       else
  89       {
  90         newIP = new char[16];
  91         strcpy(newIP, ds.getFromIPA());
  92         serverIPs.push_back(newIP);
  93         waitType = 2;
  94         haveAtLeastOne = 1;
  95       }
  96     }
  97     else
  98     {
  99       if (haveAtLeastOne) break;
 100       waitType = 1;
 101     }
 102   }
 103 }
 104
 105 void VDR::cancelFindingServer()
 106 {
 107   findingServer = 0;
 108 }
 109
 110 void VDR::setServerIP(char* newIP)
 111 {
 112   strcpy(serverIP, newIP);
 113 }
 114
 115 int VDR::connect()
 116 {
 117   if (tcp) delete tcp;
 118   tcp = new TCP();
 119   return tcp->connectTo(serverIP, 3024);
 120 }
 121
 122 void VDR::disconnect()
 123 {
 124   if (tcp) delete tcp;
 125   tcp = NULL;
 126   Log::getInstance()->log("VDR", Log::DEBUG, "Disconnect");
 127 }
 128
 129 long VDR::getSimpleReply()
 130 {
 131   unsigned char* p = (unsigned char*)tcp->receivePacket();
 132   if (!p) return -1;
 133
 134   Log::getInstance()->log("VDR", Log::DEBUG, "tcp data length = %i", tcp->getDataLength());
 135
 136   if (tcp->getDataLength() != 4)
 137   {
 138     free(p);
 139     return -1;
 140   }
 141
 142   ULONG reply = ntohl(*(ULONG*)p);
 143
 144   Log::getInstance()->log("VDR", Log::DEBUG, "VDR said %li", reply);
 145
 146   free(p);
 147
 148   return reply;
 149 }
 150
 151 char* VDR::getStringReply()
 152 {
 153   unsigned char* p = (unsigned char*)tcp->receivePacket();
 154   if (!p) return NULL;
 155
 156   int dataLength = tcp->getDataLength();
 157
 158   Log::getInstance()->log("VDR", Log::DEBUG, "Data length %u", dataLength);
 159
 160   int count = 0;
 161
 162   char* returnText;
 163   int tLength;
 164
 165   tLength = strlen((char*)&p[count]);
 166   returnText = new char[tLength + 1];
 167   strcpy(returnText, (char*)&p[count]);
 168   count += tLength + 1;
 169
 170   free(p);
 171
 172   return returnText;
 173 }
 174
 175 /////////////////////////////////////////////////////////////////////////////
 176
 177 int VDR::doLogin()
 178 {
 179   UCHAR buffer[8];
 180
 181   *(unsigned long*)&buffer[0] = htonl(4);
 182   *(unsigned long*)&buffer[4] = htonl(VDR_LOGIN);
 183
 184   pthread_mutex_lock(&mutex);
 185   int a = tcp->sendPacket(buffer, 8);
 186   if (a != 8)
 187   {
 188     pthread_mutex_unlock(&mutex);
 189     return 0;
 190   }
 191
 192   // reply
 193
 194   UCHAR* p = tcp->receivePacket();
 195   pthread_mutex_unlock(&mutex);
 196   if (!p) return 0;
 197
 198   int count = 0;
 199
 200   unsigned long vdrTime = ntohl(*(unsigned long*)&p[count]);
 201   count += sizeof(unsigned long);
 202   Log::getInstance()->log("VDR", Log::DEBUG, "vdrtime = %lu", vdrTime);
 203
 204   struct timespec currentTime;
 205   currentTime.tv_sec = vdrTime;
 206   currentTime.tv_nsec = 0;
 207   int b = clock_settime(CLOCK_REALTIME, &currentTime);
 208
 209   Log::getInstance()->log("VDR", Log::DEBUG, "set clock = %u", b);
 210
 211   // now make a TZ variable and set it
 212   signed int vdrTimeOffset = ntohl(*(signed int*)&p[count]);
 213   Log::getInstance()->log("VDR", Log::DEBUG, "offset = %i", vdrTimeOffset);
 214
 215   char sign;
 216   int hours;
 217   int minutes;
 218   if (vdrTimeOffset > 0) sign = '-';
 219   else sign = '+';
 220
 221   vdrTimeOffset = abs(vdrTimeOffset);
 222
 223   hours = (int)vdrTimeOffset / 3600;
 224   minutes = vdrTimeOffset % 3600;
 225
 226   Log::getInstance()->log("VDR", Log::DEBUG, "%c %i %i", sign, hours, minutes);
 227
 228   minutes = (int)minutes / 60;
 229
 230   Log::getInstance()->log("VDR", Log::DEBUG, "%c %i %i", sign, hours, minutes);
 231
 232   char newTZ[30];
 233   sprintf(newTZ, "MVP%c%i:%i", sign, hours, minutes);
 234   setenv("TZ", newTZ, 1);
 235
 236   Log::getInstance()->log("VDR", Log::DEBUG, "Timezone data: %s", newTZ);
 237
 238   free(p);
 239   return 1;
 240 }
 241
 242 Directory* VDR::getRecordingsList()
 243 {
 244   UCHAR buffer[8];
 245
 246   *(unsigned long*)&buffer[0] = htonl(4);
 247   *(unsigned long*)&buffer[4] = htonl(VDR_GETRECORDINGLIST);
 248
 249   pthread_mutex_lock(&mutex);
 250   int a = tcp->sendPacket(buffer, 8);
 251   if (a != 8)
 252   {
 253     pthread_mutex_unlock(&mutex);
 254     return NULL;
 255   }
 256
 257   // reply
 258
 259   unsigned char* p = (unsigned char*)tcp->receivePacket();
 260   pthread_mutex_unlock(&mutex);
 261   if (!p) return 0;
 262
 263   Directory* recDir = new Directory();
 264   recDir->setName("/");
 265   recDir->isRoot = 1;
 266
 267   int dataLength = tcp->getDataLength();
 268
 269   Log::getInstance()->log("VDR", Log::DEBUG, "Data length %u", dataLength);
 270
 271   int count = 0;
 272
 273   Directory::totalSpace = (*(ULONG*)&p[count]);
 274   count += sizeof(ULONG);
 275   Directory::freeSpace = (*(ULONG*)&p[count]);
 276   count += sizeof(ULONG);
 277   Directory::usedPercent = (*(ULONG*)&p[count]);
 278   count += sizeof(ULONG);
 279
 280   int tLength;
 281
 282   while (count < dataLength)
 283   {
 284     Recording* rec = new Recording();
 285     rec->start = ntohl(*(unsigned long*)&p[count]);
 286     count += 4;
 287
 288     tLength = strlen((char*)&p[count]);
 289     rec->setName((char*)&p[count]);
 290
 291 //    rec->name = new char[tLength + 1];
 292 //    strcpy(rec->name, (char*)&p[count]);
 293     count += tLength + 1;
 294
 295     tLength = strlen((char*)&p[count]);
 296     rec->fileName = new char[tLength + 1];
 297     strcpy(rec->fileName, (char*)&p[count]);
 298     count += tLength + 1;
 299
 300     if(rec->isInDir())
 301     {
 302       char* dirName = rec->getDirName();
 303
 304       Directory* d = recDir->getDirByName(dirName);
 305       if (!d)
 306       {
 307         d = new Directory();
 308         d->setName(dirName);
 309         Log::getInstance()->log("VDR", Log::DEBUG, "Added a new directory = %s", d->name);
 310         recDir->dirList->add(d);
 311       }
 312
 313       d->recList->add(rec);
 314       d->recList->next();
 315     }
 316     else
 317     {
 318       recDir->recList->add(rec);
 319       recDir->recList->next();
 320     }
 321
 322     Log::getInstance()->log("VDR", Log::DEBUG, "Have added a recording to list. %lu %s", rec->start, rec->getProgName());
 323   }
 324
 325   free(p);
 326
 327   return recDir;
 328 }
 329
 330 int VDR::deleteRecording(char* fileName)
 331 {
 332   unsigned long totalLength = 8 + strlen(fileName) + 1;
 333   UCHAR buffer[totalLength];
 334
 335   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
 336   *(unsigned long*)&buffer[4] = htonl(VDR_DELETERECORDING);
 337   strcpy((char*)&buffer[8], fileName);
 338
 339   pthread_mutex_lock(&mutex);
 340   unsigned int a = tcp->sendPacket(buffer, totalLength);
 341   if (a != totalLength)
 342   {
 343     pthread_mutex_unlock(&mutex);
 344     return 0;
 345   }
 346
 347   int toReturn = getSimpleReply();
 348   pthread_mutex_unlock(&mutex);
 349   return toReturn;
 350 }
 351
 352 char* VDR::getRecordingSummary(char* fileName)
 353 {
 354   unsigned long totalLength = 8 + strlen(fileName) + 1;
 355   UCHAR buffer[totalLength];
 356
 357   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
 358   *(unsigned long*)&buffer[4] = htonl(VDR_GETSUMMARY);
 359   strcpy((char*)&buffer[8], fileName);
 360
 361   pthread_mutex_lock(&mutex);
 362   unsigned int a = tcp->sendPacket(buffer, totalLength);
 363   if (a != totalLength)
 364   {
 365     pthread_mutex_unlock(&mutex);
 366     return NULL;
 367   }
 368
 369   char* toReturn = getStringReply();
 370   pthread_mutex_unlock(&mutex);
 371   return toReturn;
 372 }
 373
 374 List* VDR::getChannelsList(ULONG type)
 375 {
 376   UCHAR buffer[8];
 377
 378   *(unsigned long*)&buffer[0] = htonl(4);
 379   *(unsigned long*)&buffer[4] = htonl(VDR_GETCHANNELLIST);
 380
 381   pthread_mutex_lock(&mutex);
 382   int a = tcp->sendPacket(buffer, 8);
 383   if (a != 8)
 384   {
 385     pthread_mutex_unlock(&mutex);
 386     return NULL;
 387   }
 388
 389   // reply
 390
 391   unsigned char* p = (unsigned char*)tcp->receivePacket();
 392   pthread_mutex_unlock(&mutex);
 393   if (!p) return NULL;
 394
 395   List* chanList = new List();
 396
 397   int dataLength = tcp->getDataLength();
 398
 399   Log::getInstance()->log("VDR", Log::DEBUG, "Data length %u", dataLength);
 400
 401   int count = 0;
 402
 403   int tLength;
 404
 405   while (count < dataLength)
 406   {
 407     Channel* chan = new Channel();
 408     chan->number = ntohl(*(unsigned long*)&p[count]);
 409     count += 4;
 410     chan->type = ntohl(*(unsigned long*)&p[count]);
 411     count += 4;
 412
 413     tLength = strlen((char*)&p[count]);
 414     chan->name = new char[tLength + 1];
 415     strcpy(chan->name, (char*)&p[count]);
 416     count += tLength + 1;
 417
 418     if (chan->type == type)
 419     {
 420       chanList->add(chan);
 421       chanList->next();
 422       Log::getInstance()->log("VDR", Log::DEBUG, "Have added a channel to list. %lu %lu %s", chan->number, chan->type, chan->name);
 423     }
 424     else
 425     {
 426       delete chan;
 427     }
 428   }
 429
 430   free(p);
 431
 432   return chanList;
 433 }
 434
 435 int VDR::streamChannel(ULONG number)
 436 {
 437   UCHAR buffer[12];
 438
 439   *(unsigned long*)&buffer[0] = htonl(8);
 440   *(unsigned long*)&buffer[4] = htonl(VDR_STREAMCHANNEL);
 441   *(unsigned long*)&buffer[8] = htonl(number);
 442
 443   pthread_mutex_lock(&mutex);
 444   int a = tcp->sendPacket(buffer, 12);
 445
 446   if (a != 12)
 447   {
 448     pthread_mutex_unlock(&mutex);
 449     return 0;
 450   }
 451
 452   int toReturn = getSimpleReply();
 453   pthread_mutex_unlock(&mutex);
 454   return toReturn;
 455 }
 456
 457 int VDR::stopStreaming()
 458 {
 459   UCHAR buffer[8];
 460
 461   *(unsigned long*)&buffer[0] = htonl(4);
 462   *(unsigned long*)&buffer[4] = htonl(VDR_STOPSTREAMING);
 463
 464   pthread_mutex_lock(&mutex);
 465   int a = tcp->sendPacket(buffer, 8);
 466
 467   if (a != 8)
 468   {
 469     pthread_mutex_unlock(&mutex);
 470     return 0;
 471   }
 472
 473   int toReturn = getSimpleReply();
 474   pthread_mutex_unlock(&mutex);
 475   return toReturn;
 476 }
 477
 478 int VDR::getBlock(UCHAR* buf, ULLONG position, int amount)
 479 {
 480   UCHAR buffer[20];
 481
 482   *(unsigned long*)&buffer[0] = htonl(16);
 483   *(unsigned long*)&buffer[4] = htonl(VDR_GETBLOCK);
 484   *(ULLONG*)&buffer[8]        = htonll(position);
 485   *(unsigned long*)&buffer[16] = htonl(amount);
 486
 487   pthread_mutex_lock(&mutex);
 488   int a = tcp->sendPacket(buffer, 20);
 489   if (a != 20)
 490   {
 491     pthread_mutex_unlock(&mutex);
 492     return 0;
 493   }
 494
 495   unsigned char* p = (unsigned char*)tcp->receivePacket();
 496   pthread_mutex_unlock(&mutex);
 497   if (!p) return 0;
 498   int dataLength = tcp->getDataLength();
 499
 500   memcpy(buf, p, dataLength);
 501   free(p);
 502   return dataLength;
 503 }
 504
 505 ULLONG VDR::streamRecording(Recording* rec)
 506 {
 507   unsigned long totalLength = 8 + strlen(rec->fileName) + 1;
 508   UCHAR buffer[totalLength];
 509
 510   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
 511   *(unsigned long*)&buffer[4] = htonl(VDR_STREAMRECORDING);
 512   strcpy((char*)&buffer[8], rec->fileName);
 513
 514   pthread_mutex_lock(&mutex);
 515   unsigned int a = tcp->sendPacket(buffer, totalLength);
 516   if (a != totalLength)
 517   {
 518     pthread_mutex_unlock(&mutex);
 519     return 0;
 520   }
 521
 522   unsigned char* p = (unsigned char*)tcp->receivePacket();
 523   pthread_mutex_unlock(&mutex);
 524   if (!p) return 0;
 525
 526   if (tcp->getDataLength() != 8)
 527   {
 528     free(p);
 529     return 0;
 530   }
 531
 532   ULLONG recordingLength = ntohll(*(ULLONG*)p);
 533
 534   Log::getInstance()->log("VDR", Log::DEBUG, "VDR said length is: %llu", recordingLength);
 535   free(p);
 536
 537   return recordingLength;
 538 }
 539
 540 int VDR::getChannelSchedule(ULONG number)
 541 {
 542   UCHAR buffer[12];
 543
 544   *(unsigned long*)&buffer[0] = htonl(8);
 545   *(unsigned long*)&buffer[4] = htonl(VDR_GETCHANNELSCHEDULE);
 546   *(unsigned long*)&buffer[8] = htonl(number);
 547
 548   pthread_mutex_lock(&mutex);
 549   int a = tcp->sendPacket(buffer, 12);
 550
 551   if (a != 12)
 552   {
 553     pthread_mutex_unlock(&mutex);
 554     return -1;
 555   }
 556
 557   unsigned char* p = (unsigned char*)tcp->receivePacket();
 558   pthread_mutex_unlock(&mutex);
 559   if (!p) return -1;
 560
 561   int dataLength = tcp->getDataLength();
 562
 563   if (dataLength != 4)
 564   {
 565     free(p);
 566     return -1;
 567   }
 568
 569   ULONG data = ntohl(*(ULONG*)p);
 570   free(p);
 571
 572   Log::getInstance()->log("VDR", Log::DEBUG, "Success got to end of getChannelSchedule %lu", data);
 573
 574   return data;
 575 }
 576
 577 ULLONG VDR::getResumePoint(char* fileName)
 578 {
 579   char* resumeString = configLoad("ResumeData", fileName);
 580   if (!resumeString) return 0;
 581
 582   ULLONG toReturn = strtoull(resumeString, NULL, 10);
 583   delete[] resumeString;
 584   return toReturn;
 585 }
 586
 587 int VDR::configSave(char* section, char* key, char* value)
 588 {
 589   ULONG totalLength = 8 + strlen(section) + strlen(key) + strlen(value) + 3; // 8 for headers, 3 for nulls
 590   UCHAR buffer[totalLength];
 591
 592   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
 593   *(unsigned long*)&buffer[4] = htonl(VDR_CONFIGSAVE);
 594
 595   int position = 8;
 596   strcpy((char*)&buffer[position], section);
 597   position += strlen(section) + 1;
 598   strcpy((char*)&buffer[position], key);
 599   position += strlen(key) + 1;
 600   strcpy((char*)&buffer[position], value);
 601
 602   pthread_mutex_lock(&mutex);
 603   unsigned int a = tcp->sendPacket(buffer, totalLength);
 604   if (a != totalLength)
 605   {
 606     pthread_mutex_unlock(&mutex);
 607     return 0;
 608   }
 609
 610   int toReturn = getSimpleReply();
 611   pthread_mutex_unlock(&mutex);
 612   return toReturn;
 613 }
 614
 615 char* VDR::configLoad(char* section, char* key)
 616 {
 617   ULONG totalLength = 8 + strlen(section) + strlen(key) + 2; // 8 for headers, 2 for nulls
 618   UCHAR buffer[totalLength];
 619
 620   *(unsigned long*)&buffer[0] = htonl(totalLength - 4);
 621   *(unsigned long*)&buffer[4] = htonl(VDR_CONFIGLOAD);
 622
 623   int position = 8;
 624   strcpy((char*)&buffer[position], section);
 625   position += strlen(section) + 1;
 626   strcpy((char*)&buffer[position], key);
 627
 628   pthread_mutex_lock(&mutex);
 629   unsigned int a = tcp->sendPacket(buffer, totalLength);
 630   if (a != totalLength)
 631   {
 632     pthread_mutex_unlock(&mutex);
 633     return NULL;
 634   }
 635
 636   char* toReturn = getStringReply();
 637   pthread_mutex_unlock(&mutex);
 638   return toReturn;
 639 }