path: root/muchsync.cc

#include <cstring>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <fcntl.h>
#include <getopt.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>

#include "misc.h"
#include "muchsync.h"
#include "infinibuf.h"

using namespace std;

#if 0
// This gives core dumps to make it easier to debug
struct no_such_exception_t {
  const char *what() noexcept { return "no such exception"; }
};
using whattocatch_t = no_such_exception_t;
#else
using whattocatch_t = const exception;
#endif

#define MUCHSYNC_DEFDIR "/.notmuch/muchsync"
const char muchsync_defdir[] = MUCHSYNC_DEFDIR;
const char muchsync_dbpath[] = MUCHSYNC_DEFDIR "/state.db";
const char muchsync_trashdir[] = MUCHSYNC_DEFDIR "/trash";
const char muchsync_tmpdir[] = MUCHSYNC_DEFDIR "/tmp";

constexpr char shell[] = "/bin/sh";

// Probably no win from buffering more than 128MB of input data from net
constexpr size_t max_buf_size = 0x8000000;

bool opt_fullscan;
bool opt_noscan;
bool opt_init;
bool opt_server;
bool opt_upbg;
bool opt_noup;
bool opt_nonew;
bool opt_newid;
i64 opt_newid_value;
int opt_verbose;
int opt_upbg_fd = -1;
string opt_ssh = "ssh -CTaxq";
string opt_remote_muchsync_path = "muchsync";
string opt_notmuch_config;
string opt_init_dest;

static bool
muchsync_init (const string &maildir, bool create = false)
{
  string trashbase = maildir + muchsync_trashdir + "/";
  if (!access ((maildir + muchsync_tmpdir).c_str(), 0)
      && !access ((trashbase + "ff").c_str(), 0))
    return true;

  if (create && mkdir (maildir.c_str(), 0777) && errno != EEXIST) {
    perror (maildir.c_str());
    return false;
  }

  string notmuchdir = maildir + "/.notmuch";
  if (create && access (notmuchdir.c_str(), 0) && errno == ENOENT) {
    notmuch_database_t *notmuch;
    if (!notmuch_database_create (maildir.c_str(), &notmuch))
      notmuch_database_destroy (notmuch);
  }

  string msdir = maildir + muchsync_defdir;
  for (string d : {msdir, maildir + muchsync_trashdir,
	maildir + muchsync_tmpdir}) {
    if (mkdir (d.c_str(), 0777) && errno != EEXIST) {
      perror (d.c_str());
      return false;
    }
  }

  for (int i = 0; i < 0x100; i++) {
    ostringstream os;
    os << trashbase << hex << setfill('0') << setw(2) << i;
    if (mkdir (os.str().c_str(), 0777) && errno != EEXIST) {
      perror (os.str().c_str());
      return false;
    }
  }
  return true;
}

static void
tag_stderr(string tag)
{
  infinistreambuf *isb =
    new infinistreambuf(new infinibuf_mt);
  streambuf *err = cerr.rdbuf(isb);
  thread t ([=]() {
      istream in (isb);
      ostream out (err);
      string line;
      while (getline(in, line))
	out << tag << line << endl;
    });
  t.detach();
  cerr.rdbuf(isb);
}

//[[noreturn]]
void
usage (int code = 1)
{
  (code ? cerr : cout) << "\
usage: muchsync\n\
       muchsync server [server-options]\n\
       muchsync --init maildir server [server-options]\n\
\n\
Additional options:\n\
   -C file       Specify path to notmuch config file\n\
   -F            Disable optimizations and do full maildir scan\n\
   -v            Increase verbosity\n\
   -r path       Specify path to notmuch executable on server\n\
   -s ssh-cmd    Specify ssh command and arguments\n\
   --config file Specify path to notmuch config file (same as -C)\n\
   --nonew       Do not run notmuch new first\n\
   --noup[load]  Do not upload changes to server\n\
   --upbg        Download mail in forground, then upload in background\n\
   --self        Print local replica identifier and exit\n\
   --newid       Change local replica identifier and exit\n\
   --version     Print version number and exit\n\
   --help        Print usage\n";
  exit (code);
}

static void
id_request()
{
  unique_ptr<notmuch_db> nmp;
  try {
    nmp.reset(new notmuch_db (opt_notmuch_config));
  } catch (whattocatch_t &e) { cerr << e.what() << '\n'; exit (1); }
  notmuch_db &nm = *nmp;

  string dbpath = nm.maildir + muchsync_dbpath;

  sqlite3 *db = dbopen(dbpath.c_str(), opt_newid);
  if (!db)
    exit(1);
  cleanup _c (sqlite3_close_v2, db);
  if (!opt_newid)
    cout << getconfig<i64>(db, "self") << '\n';
  else {
    sqlexec (db, "BEGIN;");
    i64 oldid = getconfig<i64>(db, "self");
    sqlexec (db, "INSERT OR IGNORE INTO sync_vector (replica, version)"
	     " VALUES (%lld, 1);", opt_newid_value);
    setconfig (db, "self", opt_newid_value);
    cout << "changing id from " << oldid << " to " << opt_newid_value << '\n';
    sqlexec (db, "COMMIT;");
  }
}

static void
server()
{
  ifdinfinistream ibin(0, max_buf_size);
  cleanup _fixbuf0 ([](streambuf *sb){ cin.rdbuf(sb); },
		   cin.rdbuf(ibin.rdbuf()));
  ofdstream ibout(1, [&ibin](bool blocked) {
      ibin.set_max_buf_size(blocked ? 0 : max_buf_size);
    });
  cleanup _fixbuf1 ([](streambuf *sb){ cout.rdbuf(sb); },
		   cout.rdbuf(ibout.rdbuf()));
  tag_stderr("[SERVER] ");

  unique_ptr<notmuch_db> nmp;
  try {
    nmp.reset(new notmuch_db (opt_notmuch_config));
  } catch (whattocatch_t &e) { cerr << e.what() << '\n'; exit (1); }
  notmuch_db &nm = *nmp;

  string dbpath = nm.maildir + muchsync_dbpath;

  if (!opt_nonew)
    nm.run_new();
  if (!muchsync_init (nm.maildir))
    exit (1);

  sqlite3 *db = dbopen(dbpath.c_str());
  if (!db)
    exit(1);
  cleanup _c (sqlite3_close_v2, db);

  try {
    if (!opt_noscan)
      sync_local_data(db, nm.maildir);
    muchsync_server(db, nm);
  }
  catch (whattocatch_t &e) {
    cerr << e.what() << '\n';
    exit(1);
  }
}


static void
cmd_iofds (int fds[2], const string &cmd)
{
  int ifds[2], ofds[2];
  if (pipe (ifds))
    throw runtime_error (string ("pipe: ") + strerror (errno));
  if (pipe (ofds)) {
    close (ifds[0]);
    close (ifds[1]);
    throw runtime_error (string (