/*

 * MP3/MPlayer plugin to VDR (C++)

 *

 * (C) 2001-2009 Stefan Huelswitt <s.huelswitt@gmx.de>

 *

 * This code is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This code is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html

 */

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <errno.h>

#include "common.h"

#include "setup-mp3.h"

#include "stream.h"

#include "network.h"

#include "data.h"

#include "menu-async.h"

#include "i18n.h"

#include "version.h"

#define USE_MMAP

#define MAX_MMAP_SIZE   (32*1024*1024)

#define MP3FILE_BUFSIZE (32*1024)

#ifdef USE_MMAP

#include <sys/mman.h>

#endif

#define DEFAULT_PORT 80 // default port for streaming (HTTP)

//#define DUMP_HEAD "/var/tmp/headers"

// --- cIO ---------------------------------------------------------------------

#if 0

cIO::cIO(const char *Filename, bool Log)

:cFileInfo(Filename)

{

  log=Log;

  readpos=0;

}

cIO::~cIO()

{

}

// --- cStreamIO ---------------------------------------------------------------

cStreamIO::cStreamIO(void)

{

  data=0;

}

cStreamIO::~cStreamIO()

{

  StreamClear(true);

}

void cStreamIO::StreamClear(bool all)

{

  if(all) { free(data); data=0; }

  fill=0;

}

unsigned char *cStreamIO::StreamInit(int Size)

{

  StreamClear(true);

  size=Size; data=(unsigned char *)malloc(size);

  return data;

}

int cStreamIO::Stream(const unsigned char *rest)

{

  if(rest && fill) { // copy remaining data to start of buffer

    fill-=(rest-data);

    memmove(data,rest,fill);

    }

  else fill=0;

  unsigned long r=Read(data+fill,size-fill);

  if(r>=0) { 

    fill+=r;

    return fill;

    }

  return -1;    

}

// --- cFileIO -----------------------------------------------------------------

cFileIO::cFileIO(const char *Filename, bool Log)

:cIO(Filename,Log)

{

  fd=-1;

}

cFileIO::~cFileIO()

{

  Close();

}

bool cFileIO::Open(void)

{

  if(fd>=0) return Seek(0,SEEK_SET);

  if(FileInfo(log)) {

    if((fd=open(Filename,O_RDONLY))>=0) {

      StreamClear(false);

      readpos=0;

      return true;

      }

    else if(log) { esyslog("ERROR: open failed on %s: %s",Filename,strerror(errno)); }

    }

  Close();

  return false;

}

void cFileIO::Close(void)

{

  if(fd>=0) { close(fd); fd=-1; }

}

int cFileIO::Read(unsigned char *Data, int Size)

{

  unsigned long r=read(fd,Data,Size);

  if(r>=0) readpos+=r;

  else if(log) { esyslog("ERROR: read failed in %s: %s",Filename,strerror(errno)); }

  return r;

}

bool cFileIO::Seek(unsigned long long pos, int whence)

{

  if(pos>=0 && pos<=Filesize) {

    StreamClear(false);

    if((readpos=lseek64(fd,pos,whence))>=0) {

      if(readpos!=pos) { dsyslog("seek mismatch in %s, wanted %lld, got %lld",Filename,pos,readpos); }

      return true;

      }

    else if(log) { esyslog("ERROR: seek failed in %s: %s",Filename,strerror(errno)); }

    }

  else d(printf("mp3: bad seek call fd=%d pos=%lld name=%s\n",fd,pos,Filename))

  return false;

}

#endif

// --- cStream -----------------------------------------------------------------

cStream::cStream(const char *Filename)

:cFileInfo(Filename)

{

  fd=-1; ismmap=false; buffer=0;

}

cStream::~cStream()

{

  Close();

}

bool cStream::Open(bool log)

{

  if(fd>=0) return Seek();

  if(FileInfo(log)) {

    if((fd=open(Filename,O_RDONLY))>=0) {

      buffpos=readpos=0; fill=0;

#ifdef USE_MMAP

      if(Filesize<=MAX_MMAP_SIZE) {

        buffer=(unsigned char *)mmap(0,Filesize,PROT_READ,MAP_SHARED,fd,0);

        if(buffer!=MAP_FAILED) {

          ismmap=true;

          return true;

          }

        else dsyslog("mmap() failed for %s: %s",Filename,strerror(errno));

        }

#endif

        buffer = new unsigned char[MP3FILE_BUFSIZE];

        if(buffer) return true;

        else { esyslog("ERROR: not enough memory for buffer: %s",Filename); }

      }

    else if(log) { esyslog("ERROR: failed to open file %s: %s",Filename,strerror(errno)); }

    }

  Close();

  return false;

}

void cStream::Close(void)

{

#ifdef USE_MMAP

  if(ismmap) { 

    munmap(buffer,Filesize); buffer=0; ismmap=false;

    }

  else {

#endif

    delete buffer; buffer=0;

#ifdef USE_MMAP

    }

#endif

  if(fd>=0) { close(fd); fd=-1; }

}

bool cStream::Seek(unsigned long long pos)

{

  if(fd>=0 && pos>=0 && pos<=Filesize) {

    buffpos=0; fill=0;

    if(ismmap) {

      readpos=pos;

      return true;

      }

    else {

      if((readpos=lseek64(fd,pos,SEEK_SET))>=0) {

        if(readpos!=pos) { dsyslog("seek mismatch in %s, wanted %lld, got %lld",Filename,pos,readpos); }

        return true;

        }

      else { esyslog("ERROR: seeking failed in %s: %d,%s",Filename,errno,strerror(errno)); }

      }

    }

  else d(printf("mp3: bad seek call fd=%d pos=%lld name=%s\n",fd,pos,Filename))

  return false;

}

bool cStream::Stream(unsigned char * &data, unsigned long &len, const unsigned char *rest)

{

  if(fd>=0) {

    if(readpos<Filesize) {

      if(ismmap) {

        if(rest && fill) readpos=(rest-buffer);   // take care of remaining data

        fill=Filesize-readpos;

        data=buffer+readpos; len=fill;

        buffpos=readpos; readpos+=fill;

        return true;

        }

      else {

        if(rest && fill) {       // copy remaining data to start of buffer

          fill-=(rest-buffer);   // remaing bytes

          memmove(buffer,rest,fill);

          }

        else fill=0;

        int r;

        do { 

          r=read(fd,buffer+fill,MP3FILE_BUFSIZE-fill);

          } while(r==-1 && errno==EINTR);

        if(r>=0) {

          buffpos=readpos-fill; readpos+=r; fill+=r;

          data=buffer; len=fill;

          return true;

          }

        else { esyslog("ERROR: read failed in %s: %d,%s",Filename,errno,strerror(errno)); }

        }

      }

    else {

      len=0;

      return true;

      }

    }

  return false;

}

// -----------------------------------------------------------------------------

#ifdef DUMP_HEAD

void Dump(const char *name, char *buffer)

{

  FILE *f=fopen(name,"a");

  if(f) {

    fprintf(f,"<<<< %s\n",buffer);

/*

    int n=strlen(buffer);

    for(int i=0 ; i<n ; i+=8) {

      fprintf(f,"%04x: ",i);

      for(int l=0 ; l<8 && i+l<n ; l++) fprintf(f,"%02x ",buffer[i+l]);

      fprintf(f,"\n");

      }

*/

    fclose(f);

    }

}

#endif

// --- cNetStream -----------------------------------------------------------------

cNetStream::cNetStream(const char *Filename)

:cStream(Filename)

{

  net=0; host=path=auth=0; cc=0;

  icyName=icyUrl=icyTitle=0; icyChanged=false;

  metaInt=0;

  InfoDone();

}

cNetStream::~cNetStream()

{

  free(host); free(path); free(auth);

  free(icyName); free(icyUrl); free(icyTitle);

}

bool cNetStream::ParseURL(const char *line, bool log)

{

  char pr[32], h[512], p[512], a[512];

  int r=sscanf(line," %31[^:]://%511[^/]%511[^\r\n]",pr,h,p);

  if(r==2) {

    d(printf("netstream: adding default path '/'\n"))

    strcpy(p,"/");

    r++;

    }

  if(r==3) {

    a[0]=0;

    char *s=index(h,'@');

    if(s) {

      *s=0;

      strcpy(a,h);

      strcpy(h,s+1);

      }

    d(printf("netstream: parsed proto='%s' host='%s' path='%s' auth='%s'\n",pr,h,p,a))

    if(!strcasecmp(pr,"http")) {

      int pp=DEFAULT_PORT;

      s=rindex(h,':');

      if(s) { *s++=0; pp=atoi(s); }

      free(host); host=strdup(h);

      free(path); path=strdup(p);

      free(auth); auth=a[0] ? strdup(a) : 0;

      port=pp;

      return true;

      }

    else if(log) esyslog("Unsupported protocol %s in: %s",pr,line);

    }

  else if(log) esyslog("Bad URL line: %s",line);

  return false;    

}

bool cNetStream::ParseURLFile(const char *name, bool log)

{

  bool res=false;

  FILE *f=fopen(name,"r");

  if(f) {

    char line[2048];

    if(fgets(line,sizeof(line),f)) {

      res=ParseURL(line,log);

      }

    else if(log) esyslog("Nothing to read from URL file %s. File empty?",name);

    fclose(f);

    }

  else if(log) esyslog("fopen() failed on URL file %s: %s",name,strerror(errno));

  return res;

}

bool cNetStream::SendRequest(void)

{

  bool res=false;

  char buff[2048];

  char *p;

  char *h=aprintf(port!=DEFAULT_PORT ? "%s:%d":"%s",host,port);

  if(MP3Setup.UseProxy) p=aprintf("http://%s%s",h,path);

  else p=aprintf("%s",path);

  char a[1024];

  a[0]=0;

  if(auth) {

    cBase64Encoder b64((uchar *)auth,strlen(auth),76);

    int q=0;

    const char *l;

    while((l=b64.NextLine())) {

      q+=snprintf(&a[q],sizeof(a)-q,"%s%s\r\n",q==0?"Authorization: Basic ":" ",l);

      }

    }

  snprintf(buff,sizeof(buff),

           "GET %s HTTP/1.0\r\n"

           "User-Agent: %s/%s\r\n"

           "Host: %s\r\n"

           "Accept: audio/mpeg\r\n"   //XXX audio/x-mpegurl, */*

           "Icy-MetaData: 1\r\n"

           "%s\r\n",

           p,PLUGIN_NAME,PluginVersion,h,a);

  free(p); free(h);  

  if(++cc==1) asyncStatus.Set(tr("Connecting to stream server ..."));

  if(net->Connect(MP3Setup.UseProxy ? MP3Setup.ProxyHost:host , MP3Setup.UseProxy ? MP3Setup.ProxyPort:port)) {

    d(printf("netstream: -> %s",buff))

    if(net->Puts(buff)>0) res=GetHTTPResponse();

    }

  if(cc--==1) asyncStatus.Set(0);

  return res;

}

bool cNetStream::ParseHeader(const char *buff, const char *name, char **value)

{

  const char *s=index(buff,':');

  if(s && !strncasecmp(buff,name,s-buff)) {

    s=skipspace(s+1);

    d(printf("netstream: found header '%s' contents '%s'\n",name,s))

    free(*value); *value=strdup(s);

    return true;

    }

  return false;

}

bool cNetStream::GetHTTPResponse(void)

{

  bool res=false;

  char buff[1024], text[128], *newurl=0;

  int code=-1, hcount=0;

  while(net->Gets(buff,sizeof(buff))>0) {

    stripspace(buff);

#ifdef DUMP_HEAD

    Dump(DUMP_HEAD,buff);

#endif

    d(printf("netstream: <- %s\n",buff))

    hcount++;

    if(hcount==1) {   // parse status line

      if(sscanf(buff,"%*[^ ] %d %128s",&code,text)!=2) {

        esyslog("Bad HTTP response '%s' from %s:%d",buff,host,port);

        goto out;

        }

      }

    else {            // parse header lines

      if(buff[0]==0) { // headers finish if we receive a empty line

        switch(code) {

          case 200: // OK

             res=true;

             goto out;

          case 300: // MULTIPLE_CHOICES

          case 301: // MOVED_PERMANENTLY

          case 302: // MOVED_TEMPORARILY

             if(newurl) {

               if(ParseURL(newurl,true)) res=SendRequest();

               }

             else esyslog("No location header for redirection from %s:%d",host,port);

             goto out;

          default:

             esyslog("Unhandled HTTP response '%d %s' from %s:%d",code,text,host,port);

             goto out;

          }

        }

      ParseHeader(buff,"Location",&newurl);

      ParseHeader(buff,"icy-name",&icyName);

      ParseHeader(buff,"icy-url",&icyUrl);

      char *meta=0;

      if(ParseHeader(buff,"icy-metaint",&meta)) {

        metaInt=metaCnt=atol(meta);

        d(printf("netstream: meta interval set to %d\n",metaInt));

        }

      free(meta);

      }

    }

out:

  free(newurl);

  return res;

}

bool cNetStream::Open(bool log)

{

  if(net && net->Connected()) return true;

  if(!net) net=new cNet(0,0,0);

  net->Disconnect();

  if(ParseURLFile(Filename,log)) {

    buffpos=readpos=0; fill=0;

    buffer = new unsigned char[MP3FILE_BUFSIZE];

    if(buffer) {

      if(SendRequest()) {

        return true;

        }

      }

    else esyslog("Not enough memory for buffer");

    }

  Close();

  return false;

}

void cNetStream::Close(void)

{

  delete buffer; buffer=0;

  delete net; net=0;

}

bool cNetStream::Seek(unsigned long long pos)

{

  return false;

}

bool cNetStream::Stream(unsigned char * &data, unsigned long &len, const unsigned char *rest)

{

  if(net && net->Connected()) {

    if(rest && fill) {       // copy remaining data to start of buffer

      fill-=(rest-buffer);   // remaing bytes

      memmove(buffer,rest,fill);

      }

    else fill=0;

    int r=MP3FILE_BUFSIZE-fill;

    if(metaInt && r>metaCnt) r=metaCnt;

    r=net->Read(buffer+fill,r);

    if(r>=0) {

      fill+=r; data=buffer; len=fill;

      metaCnt-=r;

      if(metaInt && metaCnt<=0) {

        ParseMetaData();

        metaCnt=metaInt;

        }

      return true;

      }

    }

  return false;

}

char *cNetStream::ParseMetaString(char *buff, const char *name, char **value)

{

  char *s=index(buff,'=');

  if(s && !strncasecmp(buff,name,s-buff)) {

    char *end=index(s+2,'\'');

    if(s[1]=='\'' && end) {

      *end=0;

      s=stripspace(skipspace(s+2));

      if(strlen(s)>0) {

        d(printf("netstream: found metadata '%s' contents '%s'\n",name,s))

        free(*value); *value=strdup(s);

        }

      //else d(printf("netstream: found empty metadata '%s'\n",name))

      return end+1;

      }

    else d(printf("netstream: bad metadata format\n"))

    }

  return 0;

}

bool cNetStream::ParseMetaData(void)

{

  unsigned char byte;

  int r=net->Read(&byte,1);

  if(r<=0) return false;

  int metalen=byte*16;

  if(metalen>0) {

    char data[metalen+1];

    data[metalen]=0;

    int cnt=0;

    do {

      r=net->Read((unsigned char *)data+cnt,metalen-cnt);

      if(r<=0) return false;

      cnt+=r;

      } while(cnt<metalen);

#ifdef DUMP_HEAD

    Dump(DUMP_HEAD,data);

#endif

    char *p=data;

    while(*p && p-data<metalen) {

      char *n;

      if((n=ParseMetaString(p,"StreamTitle",&icyTitle)) ||

         (n=ParseMetaString(p,"StreamUrl",&icyUrl))) {

        p=n;

        icyChanged=true;

        }

      else  p++;

      }

    }

  return true;

}

bool cNetStream::IcyChanged(void)

{

  bool c=icyChanged;

  icyChanged=false;

  return c;

}