code.vuplus.com Git - vuplus_dvbapp/blob - lib/dvb/db.cpp

   1 #include <errno.h>
   2 #include <lib/dvb/db.h>
   3 #include <lib/dvb/dvb.h>
   4 #include <lib/dvb/frontend.h>
   5 #include <lib/dvb/epgcache.h>
   6 #include <lib/base/eerror.h>
   7 #include <lib/base/estring.h>
   8 #include <dvbsi++/service_description_section.h>
   9 #include <dvbsi++/descriptor_tag.h>
  10 #include <dvbsi++/service_descriptor.h>
  11 #include <dvbsi++/satellite_delivery_system_descriptor.h>
  12
  13 DEFINE_REF(eDVBService);
  14
  15 RESULT eBouquet::addService(const eServiceReference &ref)
  16 {
  17         list::iterator it =
  18                 std::find(m_services.begin(), m_services.end(), ref);
  19         if ( it != m_services.end() )
  20                 return -1;
  21         m_services.push_back(ref);
  22         return 0;
  23 }
  24
  25 RESULT eBouquet::removeService(const eServiceReference &ref)
  26 {
  27         list::iterator it =
  28                 std::find(m_services.begin(), m_services.end(), ref);
  29         if ( it == m_services.end() )
  30                 return -1;
  31         m_services.erase(it);
  32         return 0;
  33 }
  34
  35 RESULT eBouquet::moveService(const eServiceReference &ref, unsigned int pos)
  36 {
  37         if ( pos < 0 || pos >= m_services.size() )
  38                 return -1;
  39         ++pos;
  40         list::iterator source=m_services.end();
  41         list::iterator dest=m_services.end();
  42         bool forward = false;
  43         for (list::iterator it(m_services.begin()); it != m_services.end(); ++it)
  44         {
  45                 if (dest == m_services.end() && !--pos)
  46                         dest = it;
  47                 if (*it == ref)
  48                 {
  49                         source = it;
  50                         forward = pos>0;
  51                 }
  52                 if (dest != m_services.end() && source != m_services.end())
  53                         break;
  54         }
  55         if (dest == m_services.end() || source == m_services.end() || source == dest)
  56                 return -1;
  57         while (source != dest)
  58         {
  59                 if (forward)
  60                         std::iter_swap(source++, source);
  61                 else
  62                         std::iter_swap(source--, source);
  63         }
  64         return 0;
  65 }
  66
  67 RESULT eBouquet::flushChanges()
  68 {
  69         FILE *f=fopen((CONFIGDIR"/enigma2/"+m_filename).c_str(), "w");
  70         if (!f)
  71                 return -1;
  72         if ( fprintf(f, "#NAME %s\r\n", m_bouquet_name.c_str()) < 0 )
  73                 goto err;
  74         for (list::iterator i(m_services.begin()); i != m_services.end(); ++i)
  75         {
  76                 eServiceReference tmp = *i;
  77                 std::string str = tmp.path;
  78                 if ( (i->flags&eServiceReference::flagDirectory) == eServiceReference::flagDirectory )
  79                 {
  80                         unsigned int p1 = str.find("FROM BOUQUET \"");
  81                         if (p1 == std::string::npos)
  82                         {
  83                                 eDebug("doof... kaputt");
  84                                 continue;
  85                         }
  86                         str.erase(0, p1+14);
  87                         p1 = str.find("\"");
  88                         if (p1 == std::string::npos)
  89                         {
  90                                 eDebug("doof2... kaputt");
  91                                 continue;
  92                         }
  93                         str.erase(p1);
  94                         tmp.path=str;
  95                 }
  96                 if ( fprintf(f, "#SERVICE %s\r\n", tmp.toString().c_str()) < 0 )
  97                         goto err;
  98                 if ( i->name.length() )
  99                         if ( fprintf(f, "#DESCRIPTION %s\r\n", i->name.c_str()) < 0 )
 100                                 goto err;
 101         }
 102         fclose(f);
 103         return 0;
 104 err:
 105         fclose(f);
 106         eDebug("couldn't write file %s", m_filename.c_str());
 107         return -1;
 108 }
 109
 110 RESULT eBouquet::setListName(const std::string &name)
 111 {
 112         m_bouquet_name = name;
 113         return 0;
 114 }
 115
 116 eDVBService::eDVBService()
 117         :m_flags(0)
 118 {
 119         memset(m_cache, -1, sizeof(m_cache));
 120 }
 121
 122 eDVBService::~eDVBService()
 123 {
 124 }
 125
 126 bool eDVBService::cacheEmpty()
 127 {
 128         for (int i=0; i < cacheMax; ++i)
 129                 if (m_cache[i] != -1)
 130                         return false;
 131         return true;
 132 }
 133
 134 eDVBService &eDVBService::operator=(const eDVBService &s)
 135 {
 136         m_service_name = s.m_service_name;
 137         m_service_name_sort = s.m_service_name_sort;
 138         m_provider_name = s.m_provider_name;
 139         m_flags = s.m_flags;
 140 //      m_ca = s.m_ca;
 141         memcpy(m_cache, s.m_cache, sizeof(m_cache));
 142         return *this;
 143 }
 144
 145 void eDVBService::genSortName()
 146 {
 147         m_service_name_sort = removeDVBChars(m_service_name);
 148         makeUpper(m_service_name_sort);
 149         while ((!m_service_name_sort.empty()) && m_service_name_sort[0] == ' ')
 150                 m_service_name_sort.erase(0, 1);
 151
 152                 /* put unnamed services at the end, not at the beginning. */
 153         if (m_service_name_sort.empty())
 154                 m_service_name_sort = "\xFF";
 155 }
 156
 157 RESULT eDVBService::getName(const eServiceReference &ref, std::string &name)
 158 {
 159         if (!ref.name.empty())
 160                 name = ref.name; // use renamed service name..
 161         else if (!m_service_name.empty())
 162                 name = m_service_name;
 163         else
 164                 name = "(...)";
 165         return 0;
 166 }
 167
 168 RESULT eDVBService::getEvent(const eServiceReference &ref, ePtr<eServiceEvent> &ptr, time_t start_time)
 169 {
 170         return eEPGCache::getInstance()->lookupEventTime(ref, start_time, ptr);
 171 }
 172
 173 bool eDVBService::isPlayable(const eServiceReference &ref, const eServiceReference &ignore)
 174 {
 175         ePtr<eDVBResourceManager> res_mgr;
 176         if ( eDVBResourceManager::getInstance( res_mgr ) )
 177                 eDebug("isPlayble... no res manager!!");
 178         else
 179         {
 180                 eDVBChannelID chid, chid_ignore;
 181                 ((const eServiceReferenceDVB&)ref).getChannelID(chid);
 182                 ((const eServiceReferenceDVB&)ignore).getChannelID(chid_ignore);
 183                 return res_mgr->canAllocateChannel(chid, chid_ignore);
 184         }
 185         return false;
 186 }
 187
 188 int eDVBService::checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQuery &query)
 189 {
 190         int res = 0;
 191         switch (query.m_type)
 192         {
 193         case eDVBChannelQuery::tName:
 194                 res = m_service_name_sort.find(query.m_string) != std::string::npos;
 195                 break;
 196         case eDVBChannelQuery::tProvider:
 197                 res = m_provider_name.find(query.m_string) != std::string::npos;
 198                 break;
 199         case eDVBChannelQuery::tType:
 200                 res = ref.getServiceType() == query.m_int;
 201                 break;
 202         case eDVBChannelQuery::tBouquet:
 203                 res = 0;
 204                 break;
 205         case eDVBChannelQuery::tSatellitePosition:
 206                 res = ((unsigned int)ref.getDVBNamespace().get())>>16 == (unsigned int)query.m_int;
 207                 break;
 208         case eDVBChannelQuery::tFlags:
 209                 res = (m_flags & query.m_int) == query.m_int;
 210                 break;
 211         case eDVBChannelQuery::tChannelID:
 212         {
 213                 eDVBChannelID chid;
 214                 ref.getChannelID(chid);
 215                 res = chid == query.m_channelid;
 216                 break;
 217         }
 218         case eDVBChannelQuery::tAND:
 219                 res = checkFilter(ref, *query.m_p1) && checkFilter(ref, *query.m_p2);
 220                 break;
 221         case eDVBChannelQuery::tOR:
 222                 res = checkFilter(ref, *query.m_p1) || checkFilter(ref, *query.m_p2);
 223                 break;
 224         case eDVBChannelQuery::tAny:
 225                 res = 1;
 226                 break;
 227         }
 228
 229         if (query.m_inverse)
 230                 return !res;
 231         else
 232                 return res;
 233 }
 234
 235 int eDVBService::getCacheEntry(cacheID id)
 236 {
 237         if (id >= cacheMax)
 238                 return -1;
 239         return m_cache[id];
 240 }
 241
 242 void eDVBService::setCacheEntry(cacheID id, int pid)
 243 {
 244         if (id < cacheMax)
 245                 m_cache[id] = pid;
 246 }
 247
 248 DEFINE_REF(eDVBDB);
 249
 250         /* THIS CODE IS BAD. it should be replaced by somethine better. */
 251 void eDVBDB::reloadServicelist()
 252 {
 253         eDebug("---- opening lame channel db");
 254         FILE *f=fopen(CONFIGDIR"/enigma2/lamedb", "rt");
 255         if (!f)
 256         {
 257                 struct stat s;
 258                 if ( !stat("lamedb", &s) )
 259                 {
 260                         if ( !stat(CONFIGDIR"/enigma2", &s) )
 261                         {
 262                                 rename("lamedb", CONFIGDIR"/enigma2/lamedb" );
 263                                 reloadServicelist();
 264                         }
 265                 }
 266                 return;
 267         }
 268         char line[256];
 269         if ((!fgets(line, 256, f)) || strncmp(line, "eDVB services", 13))
 270         {
 271                 eDebug("not a servicefile");
 272                 fclose(f);
 273                 return;
 274         }
 275         eDebug("reading services");
 276         if ((!fgets(line, 256, f)) || strcmp(line, "transponders\n"))
 277         {
 278                 eDebug("services invalid, no transponders");
 279                 fclose(f);
 280                 return;
 281         }
 282
 283         // clear all transponders
 284
 285         while (!feof(f))
 286         {
 287                 if (!fgets(line, 256, f))
 288                         break;
 289                 if (!strcmp(line, "end\n"))
 290                         break;
 291                 int dvb_namespace=-1, transport_stream_id=-1, original_network_id=-1;
 292                 sscanf(line, "%x:%x:%x", &dvb_namespace, &transport_stream_id, &original_network_id);
 293                 if (original_network_id == -1)
 294                         continue;
 295                 eDVBChannelID channelid = eDVBChannelID(
 296                         eDVBNamespace(dvb_namespace),
 297                         eTransportStreamID(transport_stream_id),
 298                         eOriginalNetworkID(original_network_id));
 299
 300                 ePtr<eDVBFrontendParameters> feparm = new eDVBFrontendParameters;
 301                 while (!feof(f))
 302                 {
 303                         fgets(line, 256, f);
 304                         if (!strcmp(line, "/\n"))
 305                                 break;
 306                         if (line[1]=='s')
 307                         {
 308                                 eDVBFrontendParametersSatellite sat;
 309                                 int frequency, symbol_rate, polarisation, fec, orbital_position, inversion,
 310                                         system=eDVBFrontendParametersSatellite::System::DVB_S,
 311                                         modulation=eDVBFrontendParametersSatellite::Modulation::QPSK,
 312                                         rolloff=eDVBFrontendParametersSatellite::RollOff::alpha_auto;
 313                                 sscanf(line+2, "%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &polarisation, &fec, &orbital_position, &inversion, &system, &modulation, &rolloff);
 314                                 sat.frequency = frequency;
 315                                 sat.symbol_rate = symbol_rate;
 316                                 sat.polarisation = polarisation;
 317                                 sat.fec = fec;
 318                                 sat.orbital_position =
 319                                         orbital_position < 0 ? orbital_position + 3600 : orbital_position;
 320                                 sat.inversion = inversion;
 321                                 sat.system = system;
 322                                 sat.modulation = modulation;
 323                                 sat.roll_off = rolloff;
 324                                 feparm->setDVBS(sat);
 325                         } else if (line[1]=='t')
 326                         {
 327                                 eDVBFrontendParametersTerrestrial ter;
 328                                 int frequency, bandwidth, code_rate_HP, code_rate_LP, modulation, transmission_mode, guard_interval, hierarchy, inversion;
 329                                 sscanf(line+2, "%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &bandwidth, &code_rate_HP, &code_rate_LP, &modulation, &transmission_mode, &guard_interval, &hierarchy, &inversion);
 330                                 ter.frequency = frequency;
 331                                 ter.bandwidth = bandwidth;
 332                                 ter.code_rate_HP = code_rate_HP;
 333                                 ter.code_rate_LP = code_rate_LP;
 334                                 ter.modulation = modulation;
 335                                 ter.transmission_mode = transmission_mode;
 336                                 ter.guard_interval = guard_interval;
 337                                 ter.hierarchy = hierarchy;
 338                                 ter.inversion = inversion;
 339                                 feparm->setDVBT(ter);
 340                         } else if (line[1]=='c')
 341                         {
 342                                 eDVBFrontendParametersCable cab;
 343                                 int frequency, symbol_rate,
 344                                         inversion=eDVBFrontendParametersCable::Inversion::Unknown,
 345                                         modulation=eDVBFrontendParametersCable::Modulation::Auto,
 346                                         fec_inner=eDVBFrontendParametersCable::FEC::fAuto;
 347                                 sscanf(line+2, "%d:%d:%d:%d:%d", &frequency, &symbol_rate, &inversion, &modulation, &fec_inner);
 348                                 cab.frequency = frequency;
 349                                 cab.fec_inner = fec_inner;
 350                                 cab.inversion = inversion;
 351                                 cab.symbol_rate = symbol_rate;
 352                                 cab.modulation = modulation;
 353                                 feparm->setDVBC(cab);
 354                         }
 355                 }
 356                 addChannelToList(channelid, feparm);
 357         }
 358
 359         if ((!fgets(line, 256, f)) || strcmp(line, "services\n"))
 360         {
 361                 eDebug("services invalid, no services");
 362                 return;
 363         }
 364
 365         // clear all services
 366
 367         int count=0;
 368
 369         while (!feof(f))
 370         {
 371                 if (!fgets(line, 256, f))
 372                         break;
 373                 if (!strcmp(line, "end\n"))
 374                         break;
 375
 376                 int service_id=-1, dvb_namespace, transport_stream_id=-1, original_network_id=-1, service_type=-1, service_number=-1;
 377                 sscanf(line, "%x:%x:%x:%x:%d:%d", &service_id, &dvb_namespace, &transport_stream_id, &original_network_id, &service_type, &service_number);
 378                 if (service_number == -1)
 379                         continue;
 380                 ePtr<eDVBService> s = new eDVBService;
 381                 eServiceReferenceDVB ref =
 382                                                 eServiceReferenceDVB(
 383                                                 eDVBNamespace(dvb_namespace),
 384                                                 eTransportStreamID(transport_stream_id),
 385                                                 eOriginalNetworkID(original_network_id),
 386                                                 eServiceID(service_id),
 387                                                 service_type);
 388                 count++;
 389                 fgets(line, 256, f);
 390                 if (strlen(line))
 391                         line[strlen(line)-1]=0;
 392
 393                 s->m_service_name = line;
 394                 s->genSortName();
 395
 396                 fgets(line, 256, f);
 397                 if (strlen(line))
 398                         line[strlen(line)-1]=0;
 399                 std::string str=line;
 400
 401                 if (str[1]!=':')        // old ... (only service_provider)
 402                 {
 403                         s->m_provider_name=line;
 404                 } else
 405                         while ((!str.empty()) && str[1]==':') // new: p:, f:, c:%02d...
 406                         {
 407                                 unsigned int c=str.find(',');
 408                                 char p=str[0];
 409                                 std::string v;
 410                                 if (c == std::string::npos)
 411                                 {
 412                                         v=str.substr(2);
 413                                         str="";
 414                                 } else
 415                                 {
 416                                         v=str.substr(2, c-2);
 417                                         str=str.substr(c+1);
 418                                 }
 419 //                              eDebug("%c ... %s", p, v.c_str());
 420                                 if (p == 'p')
 421                                         s->m_provider_name=v;
 422                                 else if (p == 'f')
 423                                 {
 424                                         sscanf(v.c_str(), "%x", &s->m_flags);
 425                                 } else if (p == 'c')
 426                                 {
 427                                         int cid, val;
 428                                         sscanf(v.c_str(), "%02d%04x", &cid, &val);
 429                                         s->m_cache[cid]=val;
 430                                 }/* else if (p == 'C')
 431                                 {
 432                                         int val;
 433                                         sscanf(v.c_str(), "%04x", &val);
 434                                         s->m_ca.insert(val);
 435                                 }*/
 436                         }
 437                 addService(ref, s);
 438         }
 439
 440         eDebug("loaded %d services", count);
 441
 442         fclose(f);
 443 }
 444
 445 void eDVBDB::saveServicelist()
 446 {
 447         eDebug("---- saving lame channel db");
 448         FILE *f=fopen(CONFIGDIR"/enigma2/lamedb", "w");
 449         int channels=0, services=0;
 450         if (!f)
 451                 eFatal("couldn't save lame channel db!");
 452         fprintf(f, "eDVB services /3/\n");
 453         fprintf(f, "transponders\n");
 454         for (std::map<eDVBChannelID, channel>::const_iterator i(m_channels.begin());
 455                         i != m_channels.end(); ++i)
 456         {
 457                 const eDVBChannelID &chid = i->first;
 458                 const channel &ch = i->second;
 459
 460                 fprintf(f, "%08x:%04x:%04x\n", chid.dvbnamespace.get(),
 461                                 chid.transport_stream_id.get(), chid.original_network_id.get());
 462                 eDVBFrontendParametersSatellite sat;
 463                 eDVBFrontendParametersTerrestrial ter;
 464                 eDVBFrontendParametersCable cab;
 465                 if (!ch.m_frontendParameters->getDVBS(sat))
 466                 {
 467                         if (sat.system == eDVBFrontendParametersSatellite::System::DVB_S2)
 468                         {
 469                                 fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d:%d:%d\n",
 470                                         sat.frequency, sat.symbol_rate,
 471                                         sat.polarisation, sat.fec,
 472                                         sat.orbital_position > 1800 ? sat.orbital_position - 3600 : sat.orbital_position,
 473                                         sat.inversion,
 474                                         sat.system,
 475                                         sat.modulation,
 476                                         sat.roll_off);
 477                         }
 478                         else
 479                         {
 480                                 fprintf(f, "\ts %d:%d:%d:%d:%d:%d\n",
 481                                         sat.frequency, sat.symbol_rate,
 482                                         sat.polarisation, sat.fec,
 483                                         sat.orbital_position > 1800 ? sat.orbital_position - 3600 : sat.orbital_position,
 484                                         sat.inversion);
 485                         }
 486                 }
 487                 if (!ch.m_frontendParameters->getDVBT(ter))
 488                 {
 489                         fprintf(f, "\tt %d:%d:%d:%d:%d:%d:%d:%d:%d\n",
 490                                 ter.frequency, ter.bandwidth, ter.code_rate_HP,
 491                                 ter.code_rate_LP, ter.modulation, ter.transmission_mode,
 492                                 ter.guard_interval, ter.hierarchy, ter.inversion);
 493                 }
 494                 if (!ch.m_frontendParameters->getDVBC(cab))
 495                 {
 496                         fprintf(f, "\tc %d:%d:%d:%d:%d\n",
 497                                 cab.frequency, cab.symbol_rate, cab.inversion, cab.modulation, cab.fec_inner);
 498                 }
 499                 fprintf(f, "/\n");
 500                 channels++;
 501         }
 502         fprintf(f, "end\nservices\n");
 503
 504         for (std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator i(m_services.begin());
 505                 i != m_services.end(); ++i)
 506         {
 507                 const eServiceReferenceDVB &s = i->first;
 508                 fprintf(f, "%04x:%08x:%04x:%04x:%d:%d\n",
 509                                 s.getServiceID().get(), s.getDVBNamespace().get(),
 510                                 s.getTransportStreamID().get(),s.getOriginalNetworkID().get(),
 511                                 s.getServiceType(),
 512                                 0);
 513
 514                 fprintf(f, "%s\n", i->second->m_service_name.c_str());
 515
 516                 fprintf(f, "p:%s", i->second->m_provider_name.c_str());
 517
 518                 // write cached pids
 519                 for (int x=0; x < eDVBService::cacheMax; ++x)
 520                         if (i->second->m_cache[x] != -1)
 521                                 fprintf(f, ",c:%02d%04x", x, i->second->m_cache[x]);
 522
 523 /*
 524                 // write cached ca pids
 525                 for (std::set<int>::const_iterator ca(i->second->m_ca.begin());
 526                         ca != i->second->m_ca.end(); ++ca)
 527                         fprintf(f, ",C:%04x", *ca);
 528 */
 529
 530                 if (i->second->m_flags)
 531                         fprintf(f, ",f:%x", i->second->m_flags);
 532
 533                 fprintf(f, "\n");
 534                 services++;
 535         }
 536         fprintf(f, "end\nHave a lot of bugs!\n");
 537         eDebug("saved %d channels and %d services!", channels, services);
 538         fclose(f);
 539 }
 540
 541 void eDVBDB::loadBouquet(const char *path)
 542 {
 543         std::string bouquet_name = path;
 544         if (!bouquet_name.length())
 545         {
 546                 eDebug("Bouquet load failed.. no path given..");
 547                 return;
 548         }
 549         unsigned int pos = bouquet_name.rfind('/');
 550         if ( pos != std::string::npos )
 551                 bouquet_name.erase(0, pos+1);
 552         if (bouquet_name.empty())
 553         {
 554                 eDebug("Bouquet load failed.. no filename given..");
 555                 return;
 556         }
 557         eBouquet &bouquet = m_bouquets[bouquet_name];
 558         bouquet.m_filename = bouquet_name;
 559         std::list<eServiceReference> &list = bouquet.m_services;
 560         list.clear();
 561
 562         std::string p = CONFIGDIR"/enigma2/";
 563         p+=path;
 564         eDebug("loading bouquet... %s", p.c_str());
 565         FILE *fp=fopen(p.c_str(), "rt");
 566         int entries=0;
 567         if (!fp)
 568         {
 569                 struct stat s;
 570                 if ( !stat(path, &s) )
 571                 {
 572                         rename(path, p.c_str() );
 573                         loadBouquet(path);
 574                         return;
 575                 }
 576                 eDebug("failed to open.");
 577                 if ( strstr(path, "bouquets.tv") )
 578                 {
 579                         eDebug("recreate bouquets.tv");
 580                         bouquet.m_bouquet_name="Bouquets (TV)";
 581                         bouquet.flushChanges();
 582                 }
 583                 else if ( strstr(path, "bouquets.radio") )
 584                 {
 585                         eDebug("recreate bouquets.radio");
 586                         bouquet.m_bouquet_name="Bouquets (Radio)";
 587                         bouquet.flushChanges();
 588                 }
 589                 return;
 590         }
 591         char line[256];
 592         bool read_descr=false;
 593         eServiceReference *e = NULL;
 594         while (1)
 595         {
 596                 if (!fgets(line, 256, fp))
 597                         break;
 598                 line[strlen(line)-1]=0;
 599                 if (strlen(line) && line[strlen(line)-1]=='\r')
 600                         line[strlen(line)-1]=0;
 601                 if (!line[0])
 602                         break;
 603                 if (line[0]=='#')
 604                 {
 605                         if (!strncmp(line, "#SERVICE ", 9) || !strncmp(line, "#SERVICE: ", 10))
 606                         {
 607                                 int offs = line[8] == ':' ? 10 : 9;
 608                                 eServiceReference tmp(line+offs);
 609                                 if (tmp.type != eServiceReference::idDVB)
 610                                 {
 611                                         eDebug("only DVB Bouquets supported");
 612                                         continue;
 613                                 }
 614                                 if ( (tmp.flags&eServiceReference::flagDirectory) == eServiceReference::flagDirectory )
 615                                 {
 616                                         unsigned int pos = tmp.path.rfind('/');
 617                                         if ( pos != std::string::npos )
 618                                                 tmp.path.erase(0, pos+1);
 619                                         if (tmp.path.empty())
 620                                         {
 621                                                 eDebug("Bouquet load failed.. no filename given..");
 622                                                 continue;
 623                                         }
 624                                         loadBouquet(tmp.path.c_str());
 625                                         char buf[256];
 626                                         snprintf(buf, 256, "(type == %d) FROM BOUQUET \"%s\" ORDER BY bouquet", tmp.data[0], tmp.path.c_str());
 627                                         tmp.path = buf;
 628                                 }
 629                                 list.push_back(tmp);
 630                                 e = &list.back();
 631                                 read_descr=true;
 632                                 ++entries;
 633                         }
 634                         else if (read_descr && !strncmp(line, "#DESCRIPTION ", 13))
 635                         {
 636                                 e->name = line+13;
 637                                 read_descr=false;
 638                         }
 639                         else if (!strncmp(line, "#NAME ", 6))
 640                                 bouquet.m_bouquet_name=line+6;
 641                         continue;
 642                 }
 643         }
 644         fclose(fp);
 645         eDebug("%d entries in Bouquet %s", entries, bouquet_name.c_str());
 646 }
 647
 648 void eDVBDB::reloadBouquets()
 649 {
 650         m_bouquets.clear();
 651         loadBouquet("bouquets.tv");
 652         loadBouquet("bouquets.radio");
 653 // create default bouquets when missing
 654         if ( m_bouquets.find("userbouquet.favourites.tv") == m_bouquets.end() )
 655         {
 656                 eBouquet &b = m_bouquets["userbouquet.favourites.tv"];
 657                 b.m_filename = "userbouquet.favourites.tv";
 658                 b.m_bouquet_name = "Favourites (TV)";
 659                 b.flushChanges();
 660                 eServiceReference ref;
 661                 memset(ref.data, 0, sizeof(ref.data));
 662                 ref.type=1;
 663                 ref.flags=7;
 664                 ref.data[0]=1;
 665                 ref.path="(type == 1) FROM BOUQUET \"userbouquet.favourites.tv\" ORDER BY bouquet";
 666                 eBouquet &parent = m_bouquets["bouquets.tv"];
 667                 parent.m_services.push_back(ref);
 668                 parent.flushChanges();
 669         }
 670         if ( m_bouquets.find("userbouquet.favourites.radio") == m_bouquets.end() )
 671         {
 672                 eBouquet &b = m_bouquets["userbouquet.favourites.radio"];
 673                 b.m_filename = "userbouquet.favourites.radio";
 674                 b.m_bouquet_name = "Favourites (Radio)";
 675                 b.flushChanges();
 676                 eServiceReference ref;
 677                 memset(ref.data, 0, sizeof(ref.data));
 678                 ref.type=1;
 679                 ref.flags=7;
 680                 ref.data[0]=2;
 681                 ref.path="(type == 2) FROM BOUQUET \"userbouquet.favourites.radio\" ORDER BY bouquet";
 682                 eBouquet &parent = m_bouquets["bouquets.radio"];
 683                 parent.m_services.push_back(ref);
 684                 parent.flushChanges();
 685         }
 686 }
 687
 688 eDVBDB *eDVBDB::instance;
 689
 690 eDVBDB::eDVBDB()
 691 {
 692         instance = this;
 693         reloadServicelist();
 694 }
 695
 696 eDVBDB::~eDVBDB()
 697 {
 698         instance=NULL;
 699 }
 700
 701 RESULT eDVBDB::removeService(const eServiceReference &ref)
 702 {
 703         if (ref.type == eServiceReference::idDVB)
 704         {
 705                 eServiceReferenceDVB &service = (eServiceReferenceDVB&)ref;
 706                 std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator it(m_services.find(service));
 707                 if (it != m_services.end())
 708                 {
 709                         m_services.erase(it);
 710                         return 0;
 711                 }
 712         }
 713         return -1;
 714 }
 715
 716 RESULT eDVBDB::removeServices(int dvb_namespace, int tsid, int onid, unsigned int orb_pos)
 717 {
 718         return removeServices(eDVBChannelID(eDVBNamespace(dvb_namespace), eTransportStreamID(tsid), eOriginalNetworkID(onid)), orb_pos);
 719 }
 720
 721 RESULT eDVBDB::removeServices(eDVBChannelID chid, unsigned int orbpos)
 722 {
 723         RESULT ret=-1;
 724         eDVBNamespace eNs;
 725         eTransportStreamID eTsid;
 726         eOriginalNetworkID eOnid;
 727         std::map<eDVBChannelID, channel>::iterator it(m_channels.begin());
 728         std::set<eDVBChannelID> removed_chids;
 729         while (it != m_channels.end())
 730         {
 731                 const eDVBChannelID &ch = it->first;
 732                 bool remove=true;
 733                 int system;
 734                 it->second.m_frontendParameters->getSystem(system);
 735                 if ( orbpos != 0xFFFFFFFF && system == iDVBFrontend::feSatellite )
 736                 {
 737                         eDVBFrontendParametersSatellite sat;
 738                         it->second.m_frontendParameters->getDVBS(sat);
 739                         if ((unsigned int)sat.orbital_position != orbpos)
 740                                 remove=false;
 741                 }
 742                 if ( remove && chid.dvbnamespace != eNs && chid.dvbnamespace != ch.dvbnamespace )
 743                         remove=false;
 744                 if ( remove && chid.original_network_id != eOnid && chid.original_network_id != ch.original_network_id )
 745                         remove=false;
 746                 if ( remove && chid.transport_stream_id != eTsid && chid.transport_stream_id != ch.transport_stream_id )
 747                         remove=false;
 748                 if ( remove )
 749                 {
 750                         eDebug("remove %08x %04x %04x",
 751                                 ch.dvbnamespace.get(),
 752                                 ch.original_network_id.get(),
 753                                 ch.transport_stream_id.get());
 754                         removed_chids.insert(it->first);
 755                         m_channels.erase(it++);
 756                 }
 757                 else
 758                         ++it;
 759         }
 760         if (!removed_chids.empty())
 761         {
 762                 std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator service(m_services.begin());
 763                 while(service != m_services.end())
 764                 {
 765                         eDVBChannelID chid;
 766                         service->first.getChannelID(chid);
 767                         std::set<eDVBChannelID>::iterator it(removed_chids.find(chid));
 768                         if (it != removed_chids.end())
 769                                 m_services.erase(service++);
 770                         else
 771                                 ++service;
 772                         ret=0;
 773                 }
 774         }
 775         return ret;
 776 }
 777
 778 RESULT eDVBDB::addFlag(const eServiceReference &ref, unsigned int flagmask)
 779 {
 780         if (ref.type == eServiceReference::idDVB)
 781         {
 782                 eServiceReferenceDVB &service = (eServiceReferenceDVB&)ref;
 783                 std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator it(m_services.find(service));
 784                 if (it != m_services.end())
 785                         it->second->m_flags |= ~flagmask;
 786                 return 0;
 787         }
 788         return -1;
 789 }
 790
 791 RESULT eDVBDB::removeFlag(const eServiceReference &ref, unsigned int flagmask)
 792 {
 793         if (ref.type == eServiceReference::idDVB)
 794         {
 795                 eServiceReferenceDVB &service = (eServiceReferenceDVB&)ref;
 796                 std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator it(m_services.find(service));
 797                 if (it != m_services.end())
 798                         it->second->m_flags &= ~flagmask;
 799                 return 0;
 800         }
 801         return -1;
 802 }
 803
 804 RESULT eDVBDB::removeFlags(unsigned int flagmask, int dvb_namespace, int tsid, int onid, unsigned int orb_pos)
 805 {
 806         return removeFlags(flagmask, eDVBChannelID(eDVBNamespace(dvb_namespace), eTransportStreamID(tsid), eOriginalNetworkID(onid)), orb_pos);
 807 }
 808
 809 RESULT eDVBDB::removeFlags(unsigned int flagmask, eDVBChannelID chid, unsigned int orbpos)
 810 {
 811         eDVBNamespace eNs;
 812         eTransportStreamID eTsid;
 813         eOriginalNetworkID eOnid;
 814         std::map<eDVBChannelID, channel>::iterator it(m_channels.begin());
 815         std::set<eDVBChannelID> removed_chids;
 816         while (it != m_channels.end())
 817         {
 818                 const eDVBChannelID &ch = it->first;
 819                 bool remove=true;
 820                 int system;
 821                 it->second.m_frontendParameters->getSystem(system);
 822                 if ( orbpos != 0xFFFFFFFF && system == iDVBFrontend::feSatellite )
 823                 {
 824                         eDVBFrontendParametersSatellite sat;
 825                         it->second.m_frontendParameters->getDVBS(sat);
 826                         if ((unsigned int)sat.orbital_position != orbpos)
 827                                 remove=false;
 828                 }
 829                 if ( remove && chid.dvbnamespace != eNs && chid.dvbnamespace != ch.dvbnamespace )
 830                         remove=false;
 831                 if ( remove && chid.original_network_id != eOnid && chid.original_network_id != ch.original_network_id )
 832                         remove=false;
 833                 if ( remove && chid.transport_stream_id != eTsid && chid.transport_stream_id != ch.transport_stream_id )
 834                         remove=false;
 835                 if ( remove )
 836                         removed_chids.insert(it->first);
 837                 ++it;
 838         }
 839         if (!removed_chids.empty())
 840         {
 841                 std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator service(m_services.begin());
 842                 while(service != m_services.end())
 843                 {
 844                         eDVBChannelID chid;
 845                         service->first.getChannelID(chid);
 846                         std::set<eDVBChannelID>::iterator it(removed_chids.find(chid));
 847                         if (it != removed_chids.end())
 848                                 service->second->m_flags &= ~flagmask;
 849                         ++service;
 850                 }
 851         }
 852         return 0;
 853 }
 854
 855 RESULT eDVBDB::addChannelToList(const eDVBChannelID &id, iDVBFrontendParameters *feparm)
 856 {
 857         channel ch;
 858         assert(feparm);
 859         ch.m_frontendParameters = feparm;
 860         m_channels.insert(std::pair<eDVBChannelID, channel>(id, ch));
 861         return 0;
 862 }
 863
 864 RESULT eDVBDB::removeChannel(const eDVBChannelID &id)
 865 {
 866         m_channels.erase(id);
 867         return 0;
 868 }
 869
 870 RESULT eDVBDB::getChannelFrontendData(const eDVBChannelID &id, ePtr<iDVBFrontendParameters> &parm)
 871 {
 872         std::map<eDVBChannelID, channel>::iterator i = m_channels.find(id);
 873         if (i == m_channels.end())
 874         {
 875                 parm = 0;
 876                 return -ENOENT;
 877         }
 878         parm = i->second.m_frontendParameters;
 879         return 0;
 880 }
 881
 882 RESULT eDVBDB::addService(const eServiceReferenceDVB &serviceref, eDVBService *service)
 883 {
 884         std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator it(m_services.find(serviceref));
 885         if (it == m_services.end())
 886                 m_services.insert(std::pair<eServiceReferenceDVB, ePtr<eDVBService> >(serviceref, service));
 887         return 0;
 888 }
 889
 890 RESULT eDVBDB::getService(const eServiceReferenceDVB &reference, ePtr<eDVBService> &service)
 891 {
 892         std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator i;
 893         i = m_services.find(reference);
 894         if (i == m_services.end())
 895         {
 896                 service = 0;
 897                 return -ENOENT;
 898         }
 899         service = i->second;
 900         return 0;
 901 }
 902
 903 RESULT eDVBDB::flush()
 904 {
 905         saveServicelist();
 906         return 0;
 907 }
 908
 909 RESULT eDVBDB::getBouquet(const eServiceReference &ref, eBouquet* &bouquet)
 910 {
 911         std::string str = ref.path;
 912         if (str.empty())
 913         {
 914                 eDebug("getBouquet failed.. no path given!");
 915                 return -1;
 916         }
 917         unsigned int pos = str.find("FROM BOUQUET \"");
 918         if ( pos != std::string::npos )
 919         {
 920                 str.erase(0, pos+14);
 921                 pos = str.find('"');
 922                 if ( pos != std::string::npos )
 923                         str.erase(pos);
 924                 else
 925                         str.clear();
 926         }
 927         if (str.empty())
 928         {
 929                 eDebug("getBouquet failed.. couldn't parse bouquet name");
 930                 return -1;
 931         }
 932         std::map<std::string, eBouquet>::iterator i =
 933                 m_bouquets.find(str);
 934         if (i == m_bouquets.end())
 935         {
 936                 bouquet = 0;
 937                 return -ENOENT;
 938         }
 939         bouquet = &i->second;
 940         return 0;
 941 }
 942
 943 RESULT eDVBDB::startQuery(ePtr<iDVBChannelListQuery> &query, eDVBChannelQuery *q, const eServiceReference &source)
 944 {
 945         if ( source.path.find("FROM") != std::string::npos )
 946         {
 947                 if ( source.path.find("BOUQUET") != std::string::npos )
 948                         query = new eDVBDBBouquetQuery(this, source, q);
 949                 else if ( source.path.find("SATELLITES") != std::string::npos )
 950                         query = new eDVBDBSatellitesQuery(this, source, q);
 951                 else if ( source.path.find("PROVIDERS") != std::string::npos )
 952                         query = new eDVBDBProvidersQuery(this, source, q);
 953                 else
 954                         eFatal("invalid query %s", source.toString().c_str());
 955         }
 956         else
 957                 query = new eDVBDBQuery(this, source, q);
 958         return 0;
 959 }
 960
 961 eServiceReference eDVBDB::searchReference(int tsid, int onid, int sid)
 962 {
 963         eServiceID Sid(sid);
 964         eTransportStreamID Tsid(tsid);
 965         eOriginalNetworkID Onid(onid);
 966         for (std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator sit(m_services.begin());
 967                 sit != m_services.end(); ++sit)
 968         {
 969                 if (sit->first.getTransportStreamID() == Tsid &&
 970                         sit->first.getOriginalNetworkID() == Onid &&
 971                         sit->first.getServiceID() == Sid)
 972                         return sit->first;
 973         }
 974         return eServiceReference();
 975 }
 976
 977 DEFINE_REF(eDVBDBQueryBase);
 978
 979 eDVBDBQueryBase::eDVBDBQueryBase(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query)
 980         :m_db(db), m_query(query), m_source(source)
 981 {
 982 }
 983
 984 int eDVBDBQueryBase::compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)
 985 {
 986         ePtr<eDVBService> a_service, b_service;
 987
 988         int sortmode = m_query ? m_query->m_sort : eDVBChannelQuery::tName;
 989
 990         if ((sortmode == eDVBChannelQuery::tName) || (sortmode == eDVBChannelQuery::tProvider))
 991         {
 992                 if (m_db->getService(a, a_service))
 993                         return 1;
 994                 if (m_db->getService(b, b_service))
 995                         return 1;
 996         }
 997
 998         switch (sortmode)
 999         {
1000         case eDVBChannelQuery::tName:
1001                 return a_service->m_service_name_sort < b_service->m_service_name_sort;
1002         case eDVBChannelQuery::tProvider:
1003                 return a_service->m_provider_name < b_service->m_provider_name;
1004         case eDVBChannelQuery::tType:
1005                 return a.getServiceType() < b.getServiceType();
1006         case eDVBChannelQuery::tBouquet:
1007                 return 0;
1008         case eDVBChannelQuery::tSatellitePosition:
1009                 return (a.getDVBNamespace().get() >> 16) < (b.getDVBNamespace().get() >> 16);
1010         default:
1011                 return 1;
1012         }
1013         return 0;
1014 }
1015
1016 eDVBDBQuery::eDVBDBQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query)
1017         :eDVBDBQueryBase(db, source, query)
1018 {
1019         m_cursor = m_db->m_services.begin();
1020 }
1021
1022 RESULT eDVBDBQuery::getNextResult(eServiceReferenceDVB &ref)
1023 {
1024         while (m_cursor != m_db->m_services.end())
1025         {
1026                 ref = m_cursor->first;
1027
1028                 int res = (!m_query) || m_cursor->second->checkFilter(ref, *m_query);
1029
1030                 ++m_cursor;
1031
1032                 if (res)
1033                         return 0;
1034         }
1035
1036         ref.type = eServiceReference::idInvalid;
1037
1038         return 1;
1039 }
1040
1041 eDVBDBBouquetQuery::eDVBDBBouquetQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query)
1042         :eDVBDBQueryBase(db, source, query), m_cursor(db->m_bouquets[query->m_bouquet_name].m_services.begin())
1043 {
1044 }
1045
1046 RESULT eDVBDBBouquetQuery::getNextResult(eServiceReferenceDVB &ref)
1047 {
1048         eBouquet &bouquet = m_db->m_bouquets[m_query->m_bouquet_name];
1049         std::list<eServiceReference> &list = bouquet.m_services;
1050         while (m_cursor != list.end())
1051         {
1052                 ref = *((eServiceReferenceDVB*)&(*m_cursor));
1053
1054                 std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator it =
1055                         m_db->m_services.find(ref);
1056
1057                 int res = (!m_query) || it == m_db->m_services.end() || it->second->checkFilter(ref, *m_query);
1058
1059                 ++m_cursor;
1060
1061                 if (res)
1062                         return 0;
1063         }
1064
1065         ref.type = eServiceReference::idInvalid;
1066
1067         return 1;
1068 }
1069
1070 eDVBDBListQuery::eDVBDBListQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query)
1071         :eDVBDBQueryBase(db, source, query), m_cursor(m_list.end())
1072 {
1073 }
1074
1075 RESULT eDVBDBListQuery::getNextResult(eServiceReferenceDVB &ref)
1076 {
1077         if (m_cursor != m_list.end())
1078         {
1079                 ref = *m_cursor++;
1080                 return 0;
1081         }
1082         ref.type = eServiceReference::idInvalid;
1083         return 1;
1084 }
1085
1086 int eDVBDBListQuery::compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)
1087 {
1088         if ( m_query->m_sort == eDVBChannelQuery::tSatellitePosition )
1089         {
1090                 int x = (a.getDVBNamespace().get() >> 16);
1091                 int y = (b.getDVBNamespace().get() >> 16);
1092                 if ( x > 1800 )
1093                         x -= 3600;
1094                 if ( y > 1800 )
1095                         y -= 3600;
1096                 return x < y;
1097         }
1098         return a.name < b.name;
1099 }
1100
1101 eDVBDBSatellitesQuery::eDVBDBSatellitesQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query)
1102         :eDVBDBListQuery(db, source, query)
1103 {
1104         for (std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator it(m_db->m_services.begin());
1105                 it != m_db->m_services.end(); ++it)
1106         {
1107                 int res = it->second->checkFilter(it->first, *query);
1108                 if (res)
1109                 {
1110                         unsigned int dvbnamespace = it->first.getDVBNamespace().get()&0xFFFF0000;
1111                         bool found=0;
1112                         for (std::list<eServiceReferenceDVB>::iterator i(m_list.begin()); i != m_list.end(); ++i)
1113                                 if ( (i->getDVBNamespace().get()&0xFFFF0000) == dvbnamespace )
1114                                 {
1115                                         found=true;
1116                                         break;
1117                                 }
1118                         if (!found)
1119                         {
1120                                 eServiceReferenceDVB ref;
1121                                 ref.setDVBNamespace(dvbnamespace);
1122                                 ref.flags=eServiceReference::flagDirectory;
1123                                 char buf[128];
1124                                 snprintf(buf, 128, "(satellitePosition == %d) && ", dvbnamespace>>16);
1125
1126                                 ref.path=buf+source.path;
1127                                 unsigned int pos=ref.path.find("FROM");
1128                                 ref.path.erase(pos);
1129                                 ref.path+="ORDER BY name";
1130 //                              eDebug("ref.path now %s", ref.path.c_str());
1131                                 m_list.push_back(ref);
1132
1133                                 ref.path=buf+source.path;
1134                                 pos=ref.path.find("FROM");
1135                                 ref.path.erase(pos+5);
1136                                 ref.path+="PROVIDERS ORDER BY name";
1137 //                              eDebug("ref.path now %s", ref.path.c_str());
1138                                 m_list.push_back(ref);
1139
1140                                 snprintf(buf, 128, "(satellitePosition == %d) && (flags == %d) && ", dvbnamespace>>16, eDVBService::dxNewFound);
1141                                 ref.path=buf+source.path;
1142                                 pos=ref.path.find("FROM");
1143                                 ref.path.erase(pos);
1144                                 ref.path+="ORDER BY name";
1145 //                              eDebug("ref.path now %s", ref.path.c_str());
1146                                 m_list.push_back(ref);
1147                         }
1148                 }
1149         }
1150         m_cursor=m_list.begin();
1151 }
1152
1153 eDVBDBProvidersQuery::eDVBDBProvidersQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query)
1154         :eDVBDBListQuery(db, source, query)
1155 {
1156         for (std::map<eServiceReferenceDVB, ePtr<eDVBService> >::iterator it(m_db->m_services.begin());
1157                 it != m_db->m_services.end(); ++it)
1158         {
1159                 int res = it->second->checkFilter(it->first, *query);
1160                 if (res)
1161                 {
1162                         bool found=0;
1163
1164                         const char *provider_name = it->second->m_provider_name.length() ?
1165                                 it->second->m_provider_name.c_str() :
1166                                 "Unknown";
1167
1168                         for (std::list<eServiceReferenceDVB>::iterator i(m_list.begin()); i != m_list.end(); ++i)
1169                                 if (i->name == provider_name)
1170                                 {
1171                                         found=true;
1172                                         break;
1173                                 }
1174                         if (!found)
1175                         {
1176                                 eServiceReferenceDVB ref;
1177                                 char buf[64];
1178                                 ref.name=provider_name;
1179                                 snprintf(buf, 64, "(provider == \"%s\") && ", provider_name);
1180                                 ref.path=buf+source.path;
1181                                 unsigned int pos = ref.path.find("FROM");
1182                                 ref.flags=eServiceReference::flagDirectory;
1183                                 ref.path.erase(pos);
1184                                 ref.path+="ORDER BY name";
1185 //                              eDebug("ref.path now %s", ref.path.c_str());
1186                                 m_list.push_back(ref);
1187                         }
1188                 }
1189         }
1190         m_cursor=m_list.begin();
1191 }
1192
1193 /* (<name|provider|type|bouquet|satpos|chid> <==|...> <"string"|int>)[||,&& (..)] */
1194
1195 static int decodeType(const std::string &type)
1196 {
1197         if (type == "name")
1198                 return eDVBChannelQuery::tName;
1199         else if (type == "provider")
1200                 return eDVBChannelQuery::tProvider;
1201         else if (type == "type")
1202                 return eDVBChannelQuery::tType;
1203         else if (type == "bouquet")
1204                 return eDVBChannelQuery::tBouquet;
1205         else if (type == "satellitePosition")
1206                 return eDVBChannelQuery::tSatellitePosition;
1207         else if (type == "channelID")
1208                 return eDVBChannelQuery::tChannelID;
1209         else if (type == "flags")
1210                 return eDVBChannelQuery::tFlags;
1211         else
1212                 return -1;
1213 }
1214
1215         /* never, NEVER write a parser in C++! */
1216 RESULT parseExpression(ePtr<eDVBChannelQuery> &res, std::list<std::string>::const_iterator begin, std::list<std::string>::const_iterator end)
1217 {
1218         std::list<std::string>::const_iterator end_of_exp;
1219
1220         if (begin == end)
1221         {
1222                 eDebug("empty expression!");
1223                 return 0;
1224         }
1225
1226         if (*begin == "(")
1227         {
1228                 end_of_exp = begin;
1229                 while (end_of_exp != end)
1230                         if (*end_of_exp == ")")
1231                                 break;
1232                         else
1233                                 ++end_of_exp;
1234
1235                 if (end_of_exp == end)
1236                 {
1237                         eDebug("expression parse: end of expression while searching for closing brace");
1238                         return -1;
1239                 }
1240
1241                 ++begin;
1242                 // begin..end_of_exp
1243                 int r = parseExpression(res, begin, end_of_exp);
1244                 if (r)
1245                         return r;
1246                 ++end_of_exp;
1247
1248                         /* we had only one sub expression */
1249                 if (end_of_exp == end)
1250                 {
1251 //                      eDebug("only one sub expression");
1252                         return 0;
1253                 }
1254
1255                         /* otherwise we have an operator here.. */
1256
1257                 ePtr<eDVBChannelQuery> r2 = res;
1258                 res = new eDVBChannelQuery();
1259                 res->m_sort = 0;
1260                 res->m_p1 = r2;
1261                 res->m_inverse = 0;
1262                 r2 = 0;
1263
1264                 if (*end_of_exp == "||")
1265                         res->m_type = eDVBChannelQuery::tOR;
1266                 else if (*end_of_exp == "&&")
1267                         res->m_type = eDVBChannelQuery::tAND;
1268                 else
1269                 {
1270                         eDebug("found operator %s, but only && and || are allowed!", end_of_exp->c_str());
1271                         res = 0;
1272                         return 1;
1273                 }
1274
1275                 ++end_of_exp;
1276
1277                 return parseExpression(res->m_p2, end_of_exp, end);
1278         }
1279
1280         // "begin" <op> "end"
1281         std::string type, op, val;
1282
1283         res = new eDVBChannelQuery();
1284         res->m_sort = 0;
1285
1286         int cnt = 0;
1287         while (begin != end)
1288         {
1289                 switch (cnt)
1290                 {
1291                 case 0:
1292                         type = *begin;
1293                         break;
1294                 case 1:
1295                         op = *begin;
1296                         break;
1297                 case 2:
1298                         val = *begin;
1299                         break;
1300                 case 3:
1301                         eDebug("malformed query: got '%s', but expected only <type> <op> <val>", begin->c_str());
1302                         return 1;
1303                 }
1304                 ++begin;
1305                 ++cnt;
1306         }
1307
1308         if (cnt != 3)
1309         {
1310                 eDebug("malformed query: missing stuff");
1311                 res = 0;
1312                 return 1;
1313         }
1314
1315         res->m_type = decodeType(type);
1316
1317         if (res->m_type == -1)
1318         {
1319                 eDebug("malformed query: invalid type %s", type.c_str());
1320                 res = 0;
1321                 return 1;
1322         }
1323
1324         if (op == "==")
1325                 res->m_inverse = 0;
1326         else if (op == "!=")
1327                 res->m_inverse = 1;
1328         else
1329         {
1330                 eDebug("invalid operator %s", op.c_str());
1331                 res = 0;
1332                 return 1;
1333         }
1334
1335         res->m_string = val;
1336         res->m_int = atoi(val.c_str());
1337 //      res->m_channelid = eDVBChannelID(val);
1338
1339         return 0;
1340 }
1341
1342 RESULT eDVBChannelQuery::compile(ePtr<eDVBChannelQuery> &res, std::string query)
1343 {
1344         std::list<std::string> tokens;
1345
1346         std::string current_token;
1347         std::string bouquet_name;
1348
1349 //      eDebug("splitting %s....", query.c_str());
1350         unsigned int i = 0;
1351         const char *splitchars="()";
1352         int quotemode = 0, lastsplit = 0, lastalnum = 0;
1353         while (i <= query.size())
1354         {
1355                 int c = (i < query.size()) ? query[i] : ' ';
1356                 ++i;
1357
1358                 int issplit = !!strchr(splitchars, c);
1359                 int isaln = isalnum(c);
1360                 int iswhite = c == ' ';
1361                 int isquot = c == '\"';
1362
1363                 if (quotemode)
1364                 {
1365                         iswhite = issplit = 0;
1366                         isaln = lastalnum;
1367                 }
1368
1369                 if (issplit || iswhite || isquot || lastsplit || (lastalnum != isaln))
1370                 {
1371                         if (current_token.size())
1372                                 tokens.push_back(current_token);
1373                         current_token.clear();
1374                 }
1375
1376                 if (!(iswhite || isquot))
1377                         current_token += c;
1378
1379                 if (isquot)
1380                         quotemode = !quotemode;
1381                 lastsplit = issplit;
1382                 lastalnum = isaln;
1383         }
1384
1385 //      for (std::list<std::string>::const_iterator a(tokens.begin()); a != tokens.end(); ++a)
1386 //      {
1387 //              printf("%s\n", a->c_str());
1388 //      }
1389
1390         int sort = eDVBChannelQuery::tName;
1391                 /* check for "ORDER BY ..." */
1392
1393         std::list<std::string>::iterator it = tokens.begin();
1394         while (it != tokens.end())
1395         {
1396                 if (*it == "ORDER")
1397                 {
1398                         tokens.erase(it++);
1399                         if (it != tokens.end() && *it == "BY")
1400                         {
1401                                 tokens.erase(it++);
1402                                 sort = decodeType(*it);
1403                                 tokens.erase(it++);
1404                         } else
1405                                 sort = -1;
1406                 }
1407                 else if (*it == "FROM")
1408                 {
1409                         tokens.erase(it++);
1410                         if (it != tokens.end() && *it == "BOUQUET")
1411                         {
1412                                 tokens.erase(it++);
1413                                 bouquet_name = *it;
1414                                 tokens.erase(it++);
1415                         }
1416                         else if (it != tokens.end() && *it == "SATELLITES")
1417                                 tokens.erase(it++);
1418                         else if (it != tokens.end() && *it == "PROVIDERS")
1419                                 tokens.erase(it++);
1420                         else
1421                         {
1422                                 eDebug("FROM unknown %s", (*it).c_str());
1423                                 tokens.erase(it++);
1424                         }
1425                 }
1426                 else
1427                         ++it;
1428         }
1429
1430         if (sort == -1)
1431         {
1432                 eWarning("ORDER BY .. string invalid.");
1433                 res = 0;
1434                 return -1;
1435         }
1436
1437 //      eDebug("sort by %d", sort);
1438
1439                 /* now we recursivly parse that. */
1440         int r = parseExpression(res, tokens.begin(), tokens.end());
1441
1442                 /* we have an empty (but valid!) expression */
1443         if (!r && !res)
1444         {
1445                 res = new eDVBChannelQuery();
1446                 res->m_inverse = 0;
1447                 res->m_type = eDVBChannelQuery::tAny;
1448         }
1449
1450         if (res)
1451         {
1452                 res->m_sort = sort;
1453                 res->m_bouquet_name = bouquet_name;
1454         }
1455
1456 //      eDebug("return: %d", r);
1457         return r;
1458 }
1459
1460 DEFINE_REF(eDVBChannelQuery);