u/joerg-krause / upmpdcli - Code / Diff of /upmpd/ohmetacache.cxx

Diff of /upmpd/ohmetacache.cxx [995998] .. [36dbc7]

Switch to unified view

-a/upmpd/ohmetacache.cxx
+b/upmpd/ohmetacache.cxx
 ...
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  */
 #include <unistd.h>
 #include <fcntl.h>
+#include <string.h>
 #include <iostream>
 using namespace std;
 #include "ohmetacache.hxx"
-#include "conftree.hxx"
 #include "libupnpp/workqueue.hxx"
 #include "libupnpp/log.hxx"
-#include "base64.hxx"
 class SaveCacheTask {
 public:
     SaveCacheTask(const string& fn, const mcache_type& cache)
         : m_fn(fn), m_cache(cache)
 ...
     string m_fn;
     mcache_type m_cache;
 };
 static WorkQueue<SaveCacheTask*> saveQueue("SaveQueue");
-// We use base64 to encode names and value, and need to replace the '='
+// Encode uris and values so that they can be decoded (escape %, =, and eol)
-static const char eqesc = '*';
+static string encode(const string& in)
-static void eqtoggle(string& nm)
+{
-    int i = nm.size() - 1;
+    string out;
-    while (i >= 0) {
+    const char *cp = in.c_str();
-        if (nm[i] == '=') {
+    for (string::size_type i = 0; i < in.size(); i++) {
-            nm[i] = eqesc;
+  unsigned int c;
-        } else if (nm[i] == eqesc) {
+  const char *h = "0123456789ABCDEF";
-            nm[i] = '=';
+  c = cp[i];
-        } else {
+  if (c == '%' || c == '=' || c == '\n' || c == '\r') {
-            break;
+      out += '%';
+      out += h[(c >> 4) & 0xf];
+      out += h[c & 0xf];
+  } else {
+      out += char(c);
+  }
+    }
+    return out;
+}
+static int h2d(int c)
+{
+    if ('0' <= c && c <= '9')
+        return c - '0';
+    else if ('A' <= c && c <= 'F')
+        return 10 + c - 'A';
+    else
+        return -1;
+}
+static string decode(const string &in)
+{
+    string out;
+    const char *cp = in.c_str();
+    if (in.size() <= 2)
+        return in;
+    string::size_type i = 0;
+    for (; i < in.size() - 2; i++) {
+  if (cp[i] == '%') {
+            int d1 = h2d(cp[++i]);
+            int d2 = h2d(cp[++i]);
+            if (d1 != -1 && d2 != -1)
+                out += (d1 << 4) + d2;
+  } else {
+            out += cp[i];
+        }
-        i--;
+    }
+    while (i < in.size()) {
+        out += cp[i++];
+    }
+    return out;
+}
 bool dmcacheSave(const string& fn, const mcache_type& cache)
+{
     SaveCacheTask *tsk = new SaveCacheTask(fn, cache);
 ...
             return (void*)1;
+        }
         LOGDEB("dmcacheSave: got save task: " << tsk->m_cache.size() <<
                " entries to " << tsk->m_fn << endl);
-        // Beware that calling the constructor with a std::string
+          ofstream output(tsk->m_fn, ios::out | ios::trunc);
-        // would result in a memory-based object...
+  if (!output.is_open()) {
-        ConfSimple cs(tsk->m_fn.c_str());
-        cs.clear();
-        if (cs.getStatus() != ConfSimple::STATUS_RW) {
             LOGERR("dmcacheSave: could not open " << tsk->m_fn
                    << " for writing" << endl);
             delete tsk;
             continue;
+        }
-        cs.holdWrites(true);
         for (mcache_type::const_iterator it = tsk->m_cache.begin();
              it != tsk->m_cache.end(); it++) {
-            string name = base64_encode(it->first);
+            output << encode(it->first) << '=' << encode(it->second) << '\n';
-            eqtoggle(name);
+      if (!output.good()) {
-            string value = base64_encode(it->second);
+                LOGERR("dmcacheSave: write error while saving to " <<
-            //LOGDEB("dmcacheSave: " << name << " -> " << value << endl);
+                       tsk->m_fn << endl);
-            cs.set(name, value);
+                break;
+            }
+        }
+        output.flush();
-        if (!cs.holdWrites(false)) {
+        if (!output.good()) {
-            LOGERR("dmcacheSave: write error while saving to " <<
+            LOGERR("dmcacheSave: flush error while saving to " <<
                    tsk->m_fn << endl);
+        }
         delete tsk;
+    }
+}
+// Max size of metadata element ??
+#define LL 10*1024
 bool dmcacheRestore(const string& fn, mcache_type& cache)
+{
     // Restore is called once at startup, so seize the opportunity to start the
     // save thread
     if (!saveQueue.start(1, dmcacheSaveWorker, 0)) {
         LOGERR("dmcacheRestore: could not start save thread" << endl);
         return false;
+    }
-    // Beware that calling the constructor with a std::string
+    ifstream input;
-    // would result in a memory-based object...
+    input.open(fn, ios::in);
-    ConfSimple cs(fn.c_str(), 1);
+    if (!input.is_open()) {
-    if (!cs.ok()) {
-        LOGINF("dmcacheRestore: could not read metadata from " << fn << endl);
+        LOGERR("dmcacheRestore: could not open " << fn << endl);
         return false;
+    }
-    vector<string> names = cs.getNames("");
+    char cline[LL];
-    for (auto &name : names) {
+    for (;;) {
-        string value;
+  input.getline(cline, LL-1, '\n');
-        if (!cs.get(name, value)) {
+        if (input.eof())
-            // ??
+            break;
+        if (!input.good()) {
-            LOGDEB("dmcacheRestore: no data for found name " << name << endl);
+            LOGERR("dmcacheRestore: read error on " << fn << endl);
-            continue;
+            return false;
+        }
-        eqtoggle(name);
+        char *cp = strchr(cline, '=');
-        name = base64_decode(name);
+        if (cp == 0) {
-        value = base64_decode(value);
+            LOGERR("dmcacheRestore: no = in line !" << endl);
-        LOGDEB("dmcacheRestore: " << name << " -> " <<
+            return false;
-               value.substr(0, 20) << endl);
+        }
-        cache[name] = value;
+        *cp = 0;
+        cache[decode(cline)] = decode(cp+1);
+    }
     return true;
+}