rework ECM cache saving

diff --git a/cam.c b/cam.c
index 95d3d8e24da555a6c8292d6d5802573852f7fcf2..0fc0372e46ffe2d454aee80484ca1d1d11103ae8 100644 (file)
--- a/cam.c
+++ b/cam.c
@@ -618,7 +618,7 @@ cString cEcmData::ToString(bool hide)
 cEcmCache ecmcache;
 
 cEcmCache::cEcmCache(void)
-:cStructList<cEcmData>("ecm cache",ECMCACHE_FILE,SL_READWRITE|SL_MISSINGOK)
+:cStructListPlain<cEcmData>("ecm cache",ECMCACHE_FILE,SL_READWRITE|SL_MISSINGOK)
 {}
 
 void cEcmCache::New(cEcmInfo *e)
@@ -626,10 +626,9 @@ void cEcmCache::New(cEcmInfo *e)
   ListLock(true);
   cEcmData *dat;
   if(!(dat=Exists(e))) {
-    ListUnlock();
-    AutoGenWarn();
     dat=new cEcmData(e);
-    AddItem(dat,0,0);
+    Add(dat);
+    Modified();
     PRINTF(L_CORE_ECM,"cache add prgId=%d source=%x transponder=%x ecm=%x/%x",e->prgId,e->source,e->transponder,e->ecm_pid,e->ecm_table);
     }
   else {
@@ -639,8 +638,8 @@ void cEcmCache::New(cEcmInfo *e)
       }
     if(dat->Update(e))
       Modified();
-    ListUnlock();
     }
+  ListUnlock();
   e->SetCached();
 }
 
@@ -692,12 +691,12 @@ void cEcmCache::Flush(void)
   ListUnlock();
 }
 
-cStructItem *cEcmCache::ParseLine(char *line)
+bool cEcmCache::ParseLinePlain(char *line)
 {
   cEcmData *dat=new cEcmData;
-  if(dat && dat->Parse(line) && !Exists(dat)) return dat;
+  if(dat && dat->Parse(line) && !Exists(dat)) { Add(dat); return true; }
   delete dat;
-  return 0;
+  return false;
 }
 
 // -- cEcmSys ------------------------------------------------------------------

diff --git a/cam.h b/cam.h
index 697823caadac78319cd9bce16b9475d3db06a6ad..dd4ebf3d274a7a94d9b50a5851212819430a8a3e 100644 (file)
--- a/cam.h
+++ b/cam.h
@@ -41,16 +41,17 @@ class cPrg;
 
 // ----------------------------------------------------------------
 
-class cEcmCache : public cStructList<cEcmData> {
+class cEcmCache : public cStructListPlain<cEcmData> {
 private:
   cEcmData *Exists(cEcmInfo *e);
+protected:
+  virtual bool ParseLinePlain(char *line);
 public:
   cEcmCache(void);
   void New(cEcmInfo *e);
   int GetCached(cSimpleList<cEcmInfo> *list, int sid, int Source, int Transponder);
   void Delete(cEcmInfo *e);
   void Flush(void);
-  virtual cStructItem *ParseLine(char *line);
   };
 
 extern cEcmCache ecmcache;

diff --git a/data.c b/data.c
index ac96b90c0382af2a81a01eb81eb808cc9eca2e09..9a47ed08d716905bb9ece7e3e65b1a6e7ef1c356 100644 (file)
--- a/data.c
+++ b/data.c
@@ -229,20 +229,6 @@ void cStructLoader::DelItem(cStructItem *d, bool keep)
     }
 }
 
-void cStructLoader::AutoGenWarn(void)
-{
-  if(Count()==0) {
-    cStructItem *n=new cCommentItem;
-    n->SetComment("## This is a generated file. DO NOT EDIT!!");
-    cStructItem *n2=new cCommentItem;
-    n2->SetComment("## This file will be OVERWRITTEN WITHOUT WARNING!!");
-    ListLock(true);
-    Add(n);
-    Add(n2);
-    ListUnlock();
-    }
-}
-
 void cStructLoader::SetCfgDir(const char *cfgdir)
 {
   free(path);
@@ -260,19 +246,23 @@ time_t cStructLoader::MTime(void)
   return st.st_mtime;
 }
 
+void cStructLoader::CheckAccess(void)
+{
+  if(access(path,R_OK|W_OK)!=0) {
+    if(errno!=EACCES)
+      PRINTF(L_GEN_ERROR,"failed access %s: %s",path,strerror(errno));
+    PRINTF(L_GEN_WARN,"no write permission on %s. Changes will not be saved!",path);
+    SL_CLRFLAG(SL_READWRITE);
+    }
+}
+
 void cStructLoader::Load(bool reload)
 {
   if(SL_TSTFLAG(SL_DISABLED) || (reload && !SL_TSTFLAG(SL_WATCH))) return;
   FILE *f=fopen(path,"r");
   if(f) {
     int curr_mtime=MTime();
-    if(access(path,R_OK|W_OK)!=0) {
-      if(errno!=EACCES)
-        PRINTF(L_GEN_ERROR,"failed access %s: %s",path,strerror(errno));
-      PRINTF(L_GEN_WARN,"no write permission on %s. Changes will not be saved!",path);
-      SL_CLRFLAG(SL_READWRITE);
-      }
-
+    CheckAccess();
     SL_SETFLAG(SL_LOADED);
     ListLock(true);
     bool doload=false;
@@ -353,7 +343,7 @@ void cStructLoader::Load(bool reload)
 
 void cStructLoader::Purge(void)
 {
-  if(!SL_TSTFLAG(SL_DISABLED)) {
+  if(!SL_TSTFLAG(SL_DISABLED) && !SL_TSTFLAG(SL_NOPURGE)) {
     ListLock(true);
     for(cStructItem *it=First(); it;) {
       cStructItem *n=Next(it);
@@ -381,6 +371,82 @@ void cStructLoader::Save(void)
     }
 }
 
+// -- cStructLoaderPlain -------------------------------------------------------
+
+cStructLoaderPlain::cStructLoaderPlain(const char *Type, const char *Filename, int Flags)
+:cStructLoader(Type,Filename,Flags)
+{}
+
+void cStructLoaderPlain::Load(bool reload)
+{
+  if(SL_TSTFLAG(SL_DISABLED) || reload) return;
+  FILE *f=fopen(path,"r");
+  if(f) {
+    CheckAccess();
+    SL_SETFLAG(SL_LOADED);
+    ListLock(true);
+    Clear(); Modified(false);
+    PRINTF(L_GEN_INFO,"loading %s from %s",type,path);
+    int lineNum=0;
+    char buff[4096];
+    while(fgets(buff,sizeof(buff),f)) {
+      lineNum++;
+      if(!index(buff,'\n') && !feof(f)) {
+        PRINTF(L_GEN_ERROR,"file %s readbuffer overflow line#%d",path,lineNum);
+        SL_CLRFLAG(SL_LOADED);
+        break;
+        }
+      bool hasContent=false;
+      char *ls;
+      for(ls=buff; *ls; ls++) {
+        if(*ls==';' || *ls=='#') break;
+        if(*ls>' ') hasContent=true;
+        }
+      if(hasContent) {
+        *ls=0;
+        if(!ParseLinePlain(buff))
+          PRINTF(L_GEN_ERROR,"file %s has error in line #%d",path,lineNum);
+        }
+      }
+    PostLoad();
+    ListUnlock();
+    fclose(f);
+    }
+  else {
+    if(SL_TSTFLAG(SL_VERBOSE))
+      PRINTF(L_GEN_ERROR,"failed open %s: %s",path,strerror(errno));
+    if(SL_TSTFLAG(SL_MISSINGOK)) SL_SETFLAG(SL_LOADED);
+    else SL_CLRFLAG(SL_LOADED);
+    }
+  if(!SL_TSTFLAG(SL_LOADED))
+    PRINTF(L_CORE_LOAD,"loading %s terminated with error. Changes will not be saved!",path);
+}
+
+void cStructLoaderPlain::Save(void)
+{
+  if(!SL_TSTFLAG(SL_DISABLED) && SL_TSTFLAG(SL_READWRITE) && SL_TSTFLAG(SL_LOADED) && IsModified()) {
+    cSafeFile f(path);
+    if(f.Open()) {
+      ListLock(false);
+      PreSave(f);
+      for(cStructItem *it=First(); it; it=Next(it))
+        if(!it->Deleted() && !it->Save(f)) break;
+      PostSave(f);
+      f.Close();
+      Modified(false);
+      ListUnlock();
+      PRINTF(L_CORE_LOAD,"saved %s to %s",type,path);
+      }
+    }
+}
+
+void cStructLoaderPlain::PreSave(FILE *f)
+{
+  fprintf(f,"## This is a generated file. DO NOT EDIT!!\n"
+            "## This file will be OVERWRITTEN WITHOUT WARNING!!\n");
+}
+
+
 // -- cStructLoaders -----------------------------------------------------------
 
 #define RELOAD_TIMEOUT  20000

diff --git a/data.h b/data.h
index 4b8c1a8f8f2a1c71a9368a4dd00d0915074ada58..c81cb0f2a49007c2cbe8dbaec84bfb7556bd9a94 100644 (file)
--- a/data.h
+++ b/data.h
@@ -95,10 +95,11 @@ public:
 #define SL_MISSINGOK 2
 #define SL_WATCH     4
 #define SL_VERBOSE   8
+#define SL_NOPURGE   16
 #define SL_CUSTOMMASK 0xFF
 #define SL_LOADED    0x100
 #define SL_MODIFIED  0x200
-#define SL_DISABLED  0x300
+#define SL_DISABLED  0x400
 
 #define SL_SETFLAG(x) flags|=(x)
 #define SL_CLRFLAG(x) flags&=~(x)
@@ -116,14 +117,15 @@ protected:
   char *path;
   time_t mtime;
   //
+  void CheckAccess(void);
+  time_t MTime(void);
+  //
   virtual cStructItem *ParseLine(char *line)=0;
   void Modified(bool mod=true) { if(mod) SL_SETFLAG(SL_MODIFIED); else SL_CLRFLAG(SL_MODIFIED); }
   bool IsModified(void) const { return SL_TSTFLAG(SL_MODIFIED); }
   void ListLock(bool rw) { lock.Lock(rw); }
   void ListUnlock(void) { lock.Unlock(); }
-  void AutoGenWarn(void);
   virtual void PostLoad(void) {}
-  time_t MTime(void);
 public:
   cStructLoader(const char *Type, const char *Filename, int Flags);
   virtual ~cStructLoader();
@@ -133,7 +135,7 @@ public:
   void SetCfgDir(const char *cfgdir);
   virtual void Load(bool reload);
   virtual void Save(void);
-  virtual void Purge(void);
+  void Purge(void);
   void Disable(void) { SL_SETFLAG(SL_DISABLED); }
   };
 
@@ -151,11 +153,14 @@ public:
 
 class cStructLoaderPlain : public cStructLoader {
 protected:
+  virtual cStructItem *ParseLine(char *line) { return 0; }
+  virtual bool ParseLinePlain(char *line)=0;
 public:
   cStructLoaderPlain(const char *Type, const char *Filename, int Flags);
   virtual void Load(bool reload);
   virtual void Save(void);
-  virtual void Purge(void);
+  virtual void PreSave(FILE *f);
+  virtual void PostSave(FILE *f) {};
   };
 
 //--------------------------------------------------------------