/*

  * 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 <ctype.h>

 #include <dirent.h>

 #include <stdlib.h>

 #include <stdio.h>

 #include <stdarg.h>

 #include <errno.h>

 #include <sys/stat.h>

 #include <sys/types.h>

 #include <unistd.h>

 #include <dirent.h>

 #include <fnmatch.h>

 #include <vdr/tools.h>

 #include "common.h"

 #include "data.h"

 #include "data-src.h"

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

 const char *mountscript = "mount.sh";

 char *Quote(const char *str)

 {

   char *nstr=MALLOC(char,strlen(str)*2);

   char *p=nstr;

   while(*str) {

     switch(*str) {

       case '$':  // dollar

       case '\\': // backslash

       case '\"': // double quote

       case '`':  // back tick

                  *p++='\\'; break;

       }

     *p++=*str++;

     }

   *p=0;

   return nstr;

 }

 char *AddPath(const char *dir, const char *filename)

 {

   char *name=aprintf("%s/%s",dir,filename);

   return name;

 }

 bool CheckVDRVersion(int Version, int Major, int Minor, const char *text)

 {

   static char vv[] = VDRVERSION;

   int version, major, minor;

   if(sscanf(vv,"%d.%d.%d",&version,&major,&minor)==3) {

     if(version<Version ||

        (version==Version && major<Major) ||

        (version==Version && major==Major && minor<Minor)) {

       if(text) {

         esyslog("ERROR: %s plugin needs at least VDR version %d.%d.%d",text,Version,Major,Minor);

         fprintf(stderr,"%s plugin needs at least VDR version %d.%d.%d\n",text,Version,Major,Minor);

         }

       return false;

       }

     }

   else esyslog("ERROR: cannot parse VDR version string '%s'",vv);

   return true;

 }

 char *aprintf(const char *fmt, ...)

 {

   va_list ap;

   va_start(ap,fmt);

   char *str=0;

   if(vasprintf(&str,fmt,ap)<0);

   va_end(ap);

   return str;

 }

 // -- cScanDir --------------------------------------------------------------

 bool cScanDir::ScanDir(cFileSource *src, const char *subdir, eScanType type, const char * const *spec, const char * const *excl, bool recursiv)

 {

   bool res=true;

   char *f=0;

   char *dir=aprintf(subdir ? "%s/%s":"%s",src->BaseDir(),subdir);

   DIR *d=opendir(dir);

   if(d) {

     struct dirent64 *e;

     while((e=readdir64(d))) {

       if(!strcmp(e->d_name,".") || !strcmp(e->d_name,"..")) continue;

       free(f);

       if(!(f=AddPath(dir,e->d_name))) continue;

       struct stat64 st;

       if(stat64(f,&st)<0) {

         esyslog("ERROR: stat(1) %s: %s",f,strerror(errno));

         continue;

         }

       if(S_ISLNK(st.st_mode)) {

         char *of=f; f=ReadLink(of); free(of);

         if(!f) continue;

         if(stat64(f,&st)<0) {

           esyslog("ERROR: stat(2) %s: %s",f,strerror(errno));

           continue;

           }

         }

       if(S_ISDIR(st.st_mode)) {

         if(type==stFile && recursiv) {

           char *s=aprintf(subdir ? "%2$s/%1$s":"%s",e->d_name,subdir);

           ScanDir(src,s,type,spec,excl,recursiv);

           free(s);

           continue;

           }

         if(type!=stDir) continue;

         }

       if(S_ISREG(st.st_mode)) {

         if(type!=stFile) continue;

         if(spec) {

           bool ok=false;

           for(const char * const *m=spec; *m; m++) {

             int n=fnmatch(*m,e->d_name,FNM_CASEFOLD);

             if(n==0) { ok=true; break; }

             if(n!=FNM_NOMATCH) esyslog("ERROR: fnmatch(1) %s: %s",*m,strerror(errno));

             }

           if(!ok) continue;

           }

         if(excl) {

           bool ok=true;

           for(const char * const *m=excl; *m; m++) {

             int n=fnmatch(*m,e->d_name,FNM_CASEFOLD);

             if(n==0) { ok=false; break; }

             if(n!=FNM_NOMATCH) esyslog("ERROR: fnmatch(2) %s: %s",*m,strerror(errno));

             }

           if(!ok) continue;

           }

         }

       DoItem(src,subdir,e->d_name);

       }

     closedir(d);

     }

   else {

     esyslog("ERROR: opendir %s: %s",dir,strerror(errno));

     res=false;

     }

   free(dir); free(f);

   return res;

 }

 // -- cFileObj --------------------------------------------------------------

 cFileObj::cFileObj(cFileSource *Source, const char *Subdir, const char *Name, const eObjType Type)

 {

   path=fpath=0;

   source=Source;

   subdir=Subdir ? strdup(Subdir):0;

   name=Name ? strdup(Name):0;

   type=Type;

   Set();

 }

 cFileObj::cFileObj(const cFileObj *obj)

 {

   path=fpath=0;

   source=obj->source;

   subdir=obj->subdir ? strdup(obj->subdir):0;

   name=obj->name ? strdup(obj->name):0;

   type=obj->type;

   Set();

 }

 cFileObj::~cFileObj()

 {

   free(name);

   free(subdir);

   free(path);

   free(fpath);

 }

 int cFileObj::Compare(const cListObject &ListObject) const

 {

   cFileObj *obj=(cFileObj *)&ListObject;

   if(type==otParent) return obj->type==otParent ? 0:-1;

   if(obj->type==otParent) return 1;

   if(type==otBase) return obj->type==otBase ? 0:1;

   if(obj->type==otBase) return -1;

   if(type!=obj->type) {

     if(type==otFile) return 1;

     return -1;

     }

   return strcasecmp(path,obj->path);

 }

 void cFileObj::SplitAndSet(const char *Path)

 {

   free(subdir); subdir=0;

   const char *p=Path;

   if(Path[0]=='/') {

     int l=strlen(source->BaseDir());

     if(!strncasecmp(Path,source->BaseDir(),l)) p+=l+1;

     else {

       l=strlen(source->RealBaseDir());

       if(!strncasecmp(Path,source->RealBaseDir(),l)) p+=l+1;

       else {

         char buff[strlen(Path)+5];

         strcpy(buff,"/");

         p++;

         while(1) {

           char real[PATH_MAX+1];

           if(!realpath(buff,real)) {

             if(errno!=ENOENT && errno!=ENOTDIR)

               esyslog("ERROR: realpath: %s: %s",buff,strerror(errno));

             p=Path+1;

             break;

             }

           if(!strncasecmp(real,source->RealBaseDir(),l))

             break;

           const char *r=index(p,'/');

           if(!r) {

             esyslog("ERROR: can't find source basedir in '%s'. Outside source?",Path);

             p=Path+1;

             break;

             }

           strn0cpy(buff,Path,r-Path+1);

           p=r+1;

           }

         }

       }

     }

   const char *s=rindex(p,'/');

   if(s) {

     const int l=s-p+1;

     subdir=MALLOC(char,l);

     if(subdir) strn0cpy(subdir,p,l);

     SetName(s+1);

     }

   else

     SetName(p);

 }

 void cFileObj::SetName(const char *Name)

 {

   free(name);

   name=Name ? strdup(Name):0;

   Set();

 }

 void cFileObj::Set(void)

 {

   free(path);

   path=aprintf(subdir ? "%2$s/%1$s":"%s",name,subdir);

   free(fpath); fpath=0;

   MakeFullName(&fpath,name);

 }

 void cFileObj::MakeFullName(char **fp, const char *Name)

 {

   *fp=aprintf(subdir ? "%1$s/%3$s/%2$s":"%s/%s",source->BaseDir(),Name,subdir);

 }

 bool cFileObj::GuessType(void)

 {

   struct stat64 ds;

   if(!stat64(fpath,&ds)) {

     if(S_ISREG(ds.st_mode))      type=otFile;

     else if(S_ISDIR(ds.st_mode)) type=subdir ? otDir:otBase;

     else return false;

     return true;

     }

   return false;

 }

 bool cFileObj::Exists(void)

 {

   if(type==otFile) {

     struct stat64 ds;

     if(!stat64(fpath,&ds) &&

        S_ISREG(ds.st_mode) &&

        !access(fpath,R_OK)) return true;

     }

   return false;

 }

 bool cFileObj::TestName(const char *newName)

 {

   bool r=false;

   if(type==otFile) {

     char *fname;

     MakeFullName(&fname,newName);

     if(access(fname,F_OK)==0) r=true;

     free(fname);

     }

   return r;

 }

 bool cFileObj::Rename(const char *newName)

 {

   bool r=false;

   if(type==otFile) {

     char *fname;

     MakeFullName(&fname,newName);

     if(access(fname,F_OK) && (!rename(fpath,fname))) {

       SetName(newName);

       r=true;

       }

     free(fname);

     }

   return r;

 }

 bool cFileObj::Create(const char *newName)

 {

   bool r=false;

   if(type==otFile) {

     char *fname;

     MakeFullName(&fname,newName);

     FILE *newf;

     if(access(fname,F_OK) && (newf=fopen(fname,"w"))) {

       fclose(newf);

       SetName(newName);

       r=true;

       }

     free(fname);

     }

   return r;

 }

 bool cFileObj::Delete(void)

 {

   if(type==otFile && !unlink(fpath)) return true;

   return false;

 }

 // -- cDirList --------------------------------------------------------------

 bool cDirList::Load(cFileSource *src, const char *subdir, const char * const *excl)

 {

   static const char *excl_s[] = { ".*",0 };

   bool res=false;

   Clear();

   if(subdir) Add(new cFileObj(src,subdir,"..",otParent));

   otype=otDir;

   if(ScanDir(src,subdir,stDir,0,0,false)) {

     otype=otFile;

     if(!excl) excl=excl_s;

     if(ScanDir(src,subdir,stFile,src->Include(),excl,false)) res=true;

     }

   Sort();

   return res;

 }

 void cDirList::DoItem(cFileSource *src, const char *subdir, const char *name)

 {

   Add(new cFileObj(src,subdir,name,otype));

 }

 // -- cFileSource --------------------------------------------------------------

 cFileSource::cFileSource(void)

 {

   browsedir=browseparent=0;

   basedir=realbasedir=description=0; useCount=0;

   needsmount=false;

   include=0; incCount=0;

 }

 cFileSource::cFileSource(const char *Basedir, const char *Description, const bool NeedsMount, const char *Include)

 {

   browsedir=browseparent=0;

   basedir=realbasedir=description=0; useCount=0;

   include=0; incCount=0;

   Set(Basedir,Description,NeedsMount,Include);

 }

 cFileSource::~cFileSource()

 {

   ClearRemember();

   Clear();

 }

 void cFileSource::Clear(void)

 {

   free(basedir); basedir=0;

   free(realbasedir); realbasedir=0;

   free(description); description=0;

   for(int i=0; i<incCount; i++) free(include[i]);

   free(include); include=0; incCount=0;

 }

 void cFileSource::Set(const char *Basedir, const char *Description, const bool NeedsMount, const char *Include)

 {

   Clear();

   basedir=strdup(Basedir);

   description=strdup(Description);

   if(Include) {

     do {

       char *s=index(Include,'/');

       int l=s ? s-Include : strlen(Include);

       if(l) {

         char **s=(char **)realloc(include,(incCount+2)*sizeof(char *));

         if(s) {

           include=s;

           include[incCount]=strndup(Include,l);

           incCount++;

           include[incCount]=0;

           }

         }

       Include+=l+(s ? 1:0);

       } while(*Include>0);

     }

 #ifdef DEBUG

   if(include) {

     printf("sources: filesource %s includes (count=%d):",basedir,incCount);

     for(int i=0; i<incCount; i++) printf(" '%s'",include[i]);

     printf("\n");

     }

   else

     printf("sources: filesource %s has no includes set\n",basedir);

 #endif

   needsmount=NeedsMount;

   realbasedir=MALLOC(char,PATH_MAX+1);

   if(realpath(basedir,realbasedir)) {

     if(strcmp(basedir,realbasedir)) { esyslog("WARNING: source base %s expands to %s",basedir,realbasedir); }

     }

   else {

     switch(errno) {

       case EACCES:  esyslog("ERROR: source base %s permission denied",basedir); break;

       case ENOENT:  esyslog("ERROR: source base %s not found",basedir); break;

       case ENOTDIR: esyslog("ERROR: source base %s has invalid path",basedir); break;

       default:      esyslog("ERROR: source base %s realpath: %s",basedir,strerror(errno)); break;

       }

     strn0cpy(realbasedir,basedir,PATH_MAX);

     }

 }

 void cFileSource::SetRemember(const char *dir, const char *parent)

 {

   ClearRemember();

   if(dir) browsedir=strdup(dir);

   if(parent) browseparent=strdup(parent);

 }

 void cFileSource::ClearRemember(void)

 {

   free(browsedir); browsedir=0;

   free(browseparent); browseparent=0;

 }

 bool cFileSource::GetRemember(char * &dir, char * &parent)

 {

   dir=parent=0;

   if(browsedir) {

     if(browseparent) parent=strdup(browseparent);

     dir=strdup(browsedir);

     return true;

     }

   return false;

 }

 bool cFileSource::Parse(char *s)

 {

   char base[256], des[256], incl[256];

   int needsmount, n;

   if((n=sscanf(s,"%255[^;];%255[^;];%d;%255[^;]",base,des,&needsmount,incl))>=3) {

     char *base2=skipspace(stripspace(base));

     int l=strlen(base2);

     while(l>0 && base2[l-1]=='/') {

       esyslog("WARNING: removing trailing '/' from base %s",base2);

       base2[l-1]=0;

       l--;

       }

     Set(base2,skipspace(stripspace(des)),needsmount!=0,n>3?skipspace(stripspace(incl)):0);

     // do some checking of the basedir and issue a warning if apropriate

     if(access(realbasedir,R_OK)) { esyslog("WARNING: source base %s not found/permission denied",realbasedir); }

     else {

       struct stat64 ds;

       if(lstat64(realbasedir,&ds)) { esyslog("WARNING: can't stat source base %s",realbasedir); }

       else if(!S_ISDIR(ds.st_mode)) { esyslog("WARNING: source base %s is not a directory",realbasedir); }

       }

     return true;

     }

   return false;

 }

 bool cFileSource::Action(eAction act)

 {

   static const char *str[] = { "mount","unmount","eject","status" };

   char *cmd=aprintf("%s %s %s",mountscript,str[act],basedir);

   bool res=(system(cmd)==0);

   free(cmd);

   return res;

 }

 bool cFileSource::Mount(void)

 {

   bool res=false;

   if(needsmount && (res=Action(acMount))) ClearRemember();

   return res;

 }

 bool cFileSource::Unmount(void)

 {

   bool res=false;

   if(needsmount) {

     if(!useCount && (res=Action(acUnmount))) ClearRemember();

     }

   return res;

 }

 bool cFileSource::Eject(void)

 {

   bool res=false;

   if(needsmount) {

     if(!useCount && (res=Action(acEject))) ClearRemember();

     }

   return res;

 }

 bool cFileSource::Status(void)

 {

   if(needsmount) return Action(acStatus);

   return true;

 }

 // -- cFileSources --------------------------------------------------------------

 bool cFileSources::Load(const char *filename, bool dummy)

 {

   if(cConfig<cFileSource>::Load(filename,true)) {

     SetSource(First());

     return true;

     }

   return false;

 }

 cFileSource *cFileSources::FindSource(const char *filename)

 {

   cFileSource *src=First();

   while(src) {

     if(startswith(filename,src->RealBaseDir())) return src;

     src=Next(src);

     }

   return 0;

 }