recoll / Code / Diff of /src/utils/pxattr.cpp

Diff of /src/utils/pxattr.cpp [424e41] .. [3c80e5]

Switch to unified view

-a/src/utils/pxattr.cpp
+b/src/utils/pxattr.cpp
 ...
+    }
+    }
     return true;
+}
-static const string cstr_nullstring("");
+static const string nullstring("");
 bool get(const string& path, const string& _name, string *value,
      flags flags, nspace dom)
+{
     return get(-1, path, _name, value, flags, dom);
+}
 bool get(int fd, const string& _name, string *value, flags flags, nspace dom)
+{
-    return get(fd, cstr_nullstring, _name, value, flags, dom);
+    return get(fd, nullstring, _name, value, flags, dom);
+}
 bool set(const string& path, const string& _name, const string& value,
      flags flags, nspace dom)
+{
     return set(-1, path, _name, value, flags, dom);
+}
 bool set(int fd, const string& _name, const string& value,
      flags flags, nspace dom)
+{
-    return set(fd, cstr_nullstring, _name, value, flags, dom);
+    return set(fd, nullstring, _name, value, flags, dom);
+}
 bool del(const string& path, const string& _name, flags flags, nspace dom)
+{
     return del(-1, path, _name, flags, dom);
+}
 bool del(int fd, const string& _name, flags flags, nspace dom)
+{
-    return del(fd, cstr_nullstring, _name, flags, dom);
+    return del(fd, nullstring, _name, flags, dom);
+}
 bool list(const string& path, vector<string>* names, flags flags, nspace dom)
+{
     return list(-1, path, names, flags, dom);
+}
 bool list(int fd, vector<string>* names, flags flags, nspace dom)
+{
-    return list(fd, cstr_nullstring, names, flags, dom);
+    return list(fd, nullstring, names, flags, dom);
+}
+#if defined(__gnu_linux__) || defined(COMPAT1)
-static const string cstr_userstring("user.");
+static const string userstring("user.");
+#else
+static const string userstring("");
+#endif
 bool sysname(nspace dom, const string& pname, string* sname)
+{
     if (dom != PXATTR_USER) {
     errno = EINVAL;
     return false;
+     }
-    *sname = cstr_userstring + pname;
+    *sname = userstring + pname;
     return true;
+}
 bool pxname(nspace dom, const string& sname, string* pname)
+{
-    if (sname.find("user.") != 0) {
+    if (!userstring.empty() && sname.find(userstring) != 0) {
     errno = EINVAL;
     return false;
+    }
-    *pname = sname.substr(cstr_userstring.length());
+    *pname = sname.substr(userstring.length());
     return true;
+}
 } // namespace pxattr
-#else // Testing / driver ->
+#else // TEST_PXATTR Testing / driver ->
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <string.h>
+#include <ftw.h>
 #include <iostream>
+#include <fstream>
+#include <map>
+#include <algorithm>
+#include <string>
+using namespace std;
 #include "pxattr.h"
-static char *thisprog;
-static char usage [] =
-"pxattr [-h] -n name [-v value] pathname...\n"
-"pxattr [-h] -x name pathname...\n"
-"pxattr [-h] -l pathname...\n"
-" [-h] : don't follow symbolic links (act on link itself)\n"
-"pxattr -T: run tests on temp file in current directory"
-"\n"
-static void
-Usage(void)
-    fprintf(stderr, "%s: usage:\n%s", thisprog, usage);
-    exit(1);
-static int     op_flags;
-#define OPT_MOINS 0x1
-#define OPT_n   0x2
-#define OPT_v   0x4
-#define OPT_h     0x8
-#define OPT_x     0x10
-#define OPT_l     0x20
-#define OPT_T     0x40
 static void dotests()
+{
     static const char *tfn = "pxattr_testtmp.xyz";
     static const char *NAMES[] = {"ORG.PXATTR.NAME1", "ORG.PXATTR.N2",
 ...
     close(fd);
     unlink(tfn);
     exit(0);
+}
+// \-quote character c in input \ -> \\, nl -> \n cr -> \rc -> \c
+static void quote(const string& in, string& out, int c)
+{
+    out.clear();
+    for (string::const_iterator it = in.begin(); it != in.end(); it++) {
+  if (*it == '\\') {
+      out += "\\\\";
+  } else if (*it == "\n"[0]) {
+      out += "\\n";
+  } else if (*it == "\r"[0]) {
+      out += "\\r";
+  } else if (*it == c) {
+      out += "\\";
+      out += c;
+  } else {
+      out += *it;
+  }
+    }
+}
+// \-unquote input \n -> nl, \r -> cr, \c -> c
+static void unquote(const string& in, string& out)
+{
+    out.clear();
+    for (unsigned int i = 0; i < in.size(); i++) {
+  if (in[i] == '\\') {
+      if (i == in.size() -1) {
+      out += in[i];
+      } else {
+      int c = in[++i];
+      switch (c) {
+      case 'n': out += "\n";break;
+      case 'r': out += "\r";break;
+      default: out += c;
+      }
+      }
+  } else {
+      out += in[i];
+  }
+    }
+}
+// Find first unquoted c in input: c preceded by odd number of backslashes
+string::size_type find_first_unquoted(const string& in, int c)
+{
+    int q = 0;
+    for (unsigned int i = 0;i < in.size(); i++) {
+  if (in[i] == '\\') {
+      q++;
+  } else if (in[i] == c) {
+      if (q&1) {
+      // quoted
+      q = 0;
+      } else {
+      return i;
+      }
+  } else {
+      q = 0;
+  }
+    }
+    return string::npos;
+}
+static const string PATH_START("Path: ");
 static void listattrs(const string& path)
+{
-    std::cout << "Path: " << path << std::endl;
     vector<string> names;
     if (!pxattr::list(path, &names)) {
+  if (errno == ENOENT) {
+      return;
+  }
     perror("pxattr::list");
     exit(1);
+    }
+    if (names.empty())
+  return;
+    // Sorting the names would not be necessary but it makes easier comparing
+    // backups
+    sort(names.begin(), names.end());
+    string quoted;
+    quote(path, quoted, 0);
+    cout << PATH_START << quoted << endl;
     for (vector<string>::const_iterator it = names.begin();
      it != names.end(); it++) {
     string value;
     if (!pxattr::get(path, *it, &value)) {
+      if (errno == ENOENT) {
+      return;
+      }
         perror("pxattr::get");
         exit(1);
+    }
-  std::cout << " " << *it << " => " << value << std::endl;
+  quote(*it, quoted, '=');
+  cout << " " << quoted << "=";
+  quote(value, quoted, 0);
+  cout << quoted << endl;
+    }
+}
 void setxattr(const string& path, const string& name, const string& value)
+{
 ...
     perror("pxattr::set");
     exit(1);
+    }
+}
+// Restore xattrs stored in file created by pxattr -lR output
+static void restore(const char *backupnm)
+{
+    istream *input;
+    ifstream fin;
+    if (!strcmp(backupnm, "stdin")) {
+  input = &cin;
+    } else {
+  fin.open(backupnm, ios::in);
+  input = &fin;
+    }
+    bool done = false;
+    int linenum = 0;
+    string path;
+    map<string, string> attrs;
+    while (!done) {
+  string line;
+  getline(*input, line);
+  if (!input->good()) {
+      if (input->bad()) {
+                cerr << "Input I/O error" << endl;
+      exit(1);
+      }
+      done = true;
+  } else {
+      linenum++;
+  }
+  // cout << "Got line " << linenum << " : [" << line << "] done " <<
+  // done << endl;
+  if (line.find(PATH_START) == 0 || done) {
+      if (!path.empty() && !attrs.empty()) {
+      for (map<string,string>::const_iterator it = attrs.begin();
+           it != attrs.end(); it++) {
+          setxattr(path, it->first, it->second);
+      }
+      }
+      if (!done) {
+      line = line.substr(PATH_START.size(), string::npos);
+      unquote(line, path);
+      attrs.clear();
+      }
+  } else if (line.empty()) {
+      continue;
+  } else {
+      // Should be attribute line
+      if (line[0] != ' ') {
+      cerr << "Found bad line (no space) at " << linenum << endl;
+      exit(1);
+      }
+      string::size_type pos = find_first_unquoted(line, '=');
+      if (pos == string::npos || pos < 2 || pos >= line.size()) {
+      cerr << "Found bad line at " << linenum << endl;
+      exit(1);
+      }
+      string qname = line.substr(1, pos-1);
+      pair<string,string> entry;
+      unquote(qname, entry.first);
+      unquote(line.substr(pos+1), entry.second);
+      attrs.insert(entry);
+  }
+    }
+}
 void  printxattr(const string &path, const string& name)
+{
-    std::cout << "Path: " << path << std::endl;
+    cout << "Path: " << path << endl;
     string value;
     if (!pxattr::get(path, name, &value)) {
+  if (errno == ENOENT) {
+      return;
+  }
     perror("pxattr::get");
     exit(1);
+    }
-    std::cout << " " << name << " => " << value << std::endl;
+    cout << " " << name << " => " << value << endl;
+}
 void delxattr(const string &path, const string& name)
+{
     if (pxattr::del(path, name) < 0) {
     perror("pxattr::del");
     exit(1);
+    }
+}
+static char *thisprog;
+static char usage [] =
+"pxattr [-h] -n name pathname [...] : show value for name\n"
+"pxattr [-h] -n name -v value pathname [...] : add/replace attribute\n"
+"pxattr [-h] -x name pathname [...] : delete attribute\n"
+"pxattr [-h] [-l] [-R] pathname [...] : list attribute names and values\n"
+" [-h] : don't follow symbolic links (act on link itself)\n"
+" [-R] : recursive listing. Args should be directory(ies)\n"
+"  For all the options above, if no pathname arguments are given, pxattr\n"
+"  will read file names on stdin, one per line.\n"
+"pxattr -S <backupfile> Restore xattrs from file created by pxattr -lR output\n"
+"               if backupfile is 'stdin', reads from stdin\n"
+"pxattr -T: run tests on temp file in current directory"
+"\n"
+;
+static void
+Usage(void)
+{
+    fprintf(stderr, "%s: usage:\n%s", thisprog, usage);
+    exit(1);
+}
+static int     op_flags;
+#define OPT_MOINS 0x1
+#define OPT_n   0x2
+#define OPT_v   0x4
+#define OPT_h     0x8
+#define OPT_x     0x10
+#define OPT_l     0x20
+#define OPT_T     0x40
+#define OPT_R     0x80
+#define OPT_S     0x100
+static string name, value;
+int processfile(const char* fn, const struct stat *sb, int typeflag)
+{
+    //cout << "processfile " << fn << " opflags " << op_flags << endl;
+    if (op_flags & OPT_l) {
+  listattrs(fn);
+    } else if (op_flags & OPT_n) {
+  if (op_flags & OPT_v) {
+      setxattr(fn, name, value);
+  } else {
+      printxattr(fn, name);
+  }
+    } else if (op_flags & OPT_x) {
+  delxattr(fn, name);
+    }
+    return 0;
+}
 int main(int argc, char **argv)
+{
-  thisprog = argv[0];
+    thisprog = argv[0];
-  argc--; argv++;
+    argc--; argv++;
-  string name, value;
-  while (argc > 0 && **argv == '-') {
+    while (argc > 0 && **argv == '-') {
-    (*argv)++;
+  (*argv)++;
-    if (!(**argv))
+  if (!(**argv))
       /* Cas du "adb - core" */
       Usage();
-    while (**argv)
+  while (**argv)
       switch (*(*argv)++) {
-      case 'T':   op_flags |= OPT_T; break;
       case 'l':  op_flags |= OPT_l; break;
-      case 'x':   op_flags |= OPT_x; if (argc < 2)  Usage();
-    name = *(++argv); argc--;
-  goto b1;
       case 'n':  op_flags |= OPT_n; if (argc < 2)  Usage();
       name = *(++argv); argc--;
-    goto b1;
+     goto b1;
+      case 'R':   op_flags |= OPT_R; break;
+      case 'S':   op_flags |= OPT_S; break;
+      case 'T':   op_flags |= OPT_T; break;
       case 'v':  op_flags |= OPT_v; if (argc < 2)  Usage();
       value = *(++argv); argc--;
-    goto b1;
+     goto b1;
+      case 'x':   op_flags |= OPT_x; if (argc < 2)  Usage();
+      name = *(++argv); argc--;
+      goto b1;
       default: Usage();  break;
+      }
-  b1: argc--; argv++;
+    b1: argc--; argv++;
+    }
-  if (argc < 1 && !(op_flags & OPT_T))
+    if (op_flags & OPT_T)  {
+  if (argc > 0)
-    Usage();
+      Usage();
-  if (op_flags & OPT_l) {
+  dotests();
-      while (argc > 0) {
+  exit(0);
-    listattrs(*argv++);argc--;
+    }
-  } else if (op_flags & OPT_n) {
-      if (op_flags & OPT_v) {
+    if (op_flags & OPT_S)  {
-    while (argc > 0) {
+  if (argc != 1)
-        setxattr(*argv++, name, value);argc--;
+      Usage();
+  restore(argv[0]);
-      } else {
+  exit(0);
-    while (argc > 0) {
-        printxattr(*argv++, name);argc--;
+    }
+    // Default option is 'list'
+    if ((op_flags&(OPT_l|OPT_n|OPT_x)) == 0)
+  op_flags |= OPT_l;
+    bool readstdin = false;
+    if (argc == 0)
+  readstdin = true;
+    for (;;) {
+  const char *fn = 0;
+  if (argc > 0) {
+      fn = *argv++;
+      argc--;
+  } else if (readstdin) {
+      static char filename[1025];
+      if (!fgets(filename, 1024, stdin))
+      break;
+      filename[strlen(filename)-1] = 0;
+      fn = filename;
+  } else
+      break;
-  } else if (op_flags & OPT_x) {
+  if (op_flags & OPT_R) {
-      while (argc > 0) {
+      if (ftw(fn, processfile, 20))
-    delxattr(*argv++, name);argc--;
+      exit(1);
+  } else {
+      processfile(fn, 0, 0);
+  }
+    }
-  } else if (op_flags & OPT_T)  {
-      dotests();
-  exit(0);
+    exit(0);
+}
 #endif // Testing pxattr