6 files changed, 1518 insertions, 9 deletions

diff --git a/Makefile b/Makefile
index 893216b..101e521 100644
--- a/Makefile
+++ b/Makefile
@@ -1,24 +1,39 @@
 prefix?=/usr/local
 
-all: samizdat-paths.sh
+cc_files=wait_for_files samizdat-pinentry
+cpp_files=dynmenu
 
-bin_programs=$(addprefix src/, xorriso-usb.sh btrfs-functions.sh btrfs-receive-root.sh btrfs-send-root.sh var.sh grub-efi.sh keygen.sh initrd.sh qemu.sh btarfs dnsmasq-dhcp-script.sh) samizdat-paths.sh
+compiled_programs=${cc_files} ${cpp_files}
 
-# TODO: compile these here
-samizdat_execs=$(addprefix /home/d/src/samizdat/, wait_for_files samizdat-pinentry dynmenu src/samizdat-password-agent src/samizdat-gpg-agent)
+CC=gcc -std=gnu99
+CFLAGS=-Os
 
-initrd_files:=$(wildcard src/initrd/*)
+all: samizdat-paths.sh ${compiled_programs}
+
+dynmenu: src/dynmenu.cpp
+        $(CXX) $(CFLAGS) $< -o $@ -lcurses
+samizdat-pinentry: src/samizdat-pinentry.c
+        $(CC) $(CFLAGS)  $< -o $@ -lcurses
+wait_for_files: src/wait_for_files.c
+        $(CC) $(CFLAGS)  $< -o $@
+
+bin_programs=$(addprefix src/, xorriso-usb.sh btrfs-functions.sh btrfs-receive-root.sh btrfs-send-root.sh var.sh grub-efi.sh keygen.sh initrd.sh qemu.sh btarfs dnsmasq-dhcp-script.sh samizdat-password-agent samizdat-gpg-agent) samizdat-paths.sh ${cc_files}
+
+initrd_files:=$(wildcard src/initrd/*) dynmenu samizdat-pinentry wait_for_files
 initramfs_conf_files:=$(wildcard initramfs-tools/*)
 
 isolinux_files:=$(wildcard isolinux/*)
 
-.PHONY: samizdat-paths.sh
+clean:
+        rm -f samizdat-paths.sh ${compiled_programs}
+
+.PHONY: samizdat-paths.sh all clean
 samizdat-paths.sh: src/samizdat-paths.in
-        sed -e "s?PREFIX?$(prefix)?g" $< > $@
+        @sed -e "s?PREFIX?$(prefix)?g" $< > $@
 include samizdat-paths.sh
 
-install:
-        install ${bin_programs} ${samizdat_execs} ${instdir}${samizdat_bindir}
+install: ${bin_programs} samizdat-paths.sh ${compiled_programs}
+        install ${bin_programs} ${instdir}${samizdat_bindir}
         mkdir -p ${instdir}${samizdat_initrd_files_dir}
         mkdir -p ${instdir}${samizdat_child_dir}
         mkdir -p ${instdir}${samizdat_grub_efi_dir}
diff --git a/src/dynmenu.cpp b/src/dynmenu.cpp
new file mode 100644
index 0000000..d231639
--- /dev/null
+++ b/src/dynmenu.cpp
@@ -0,0 +1,821 @@
+#include <unistd.h>
+#include <curses.h>
+#include <string.h>
+#include <string>
+#include <vector>
+#include <assert.h>
+#include <algorithm>
+#include <signal.h>
+
+class DynmenuView;
+typedef DynmenuView *DynmenuViewRef; // boost::shared_ptr<DynmenuView>
+
+class Dynmenu
+{
+  std::string m_title;
+  std::string m_welcomeText;
+  std::vector<DynmenuViewRef> views;
+
+  class Item {
+    char *desc;
+    Item(const Item &i) { assert(false); }
+  public:
+    std::string id;
+    std::string key;
+    std::string cmd;
+    const char *getText() const { return desc; }
+    void setText(const char *desc) { 
+      if(this->desc) delete [] this->desc;
+      this->desc=new char[strlen(desc)+1];
+      strcpy(this->desc,desc); 
+    }
+    Item(const char *id, const char *key, const char *desc, const char *cmd) :
+      id(id), key(key), cmd(cmd) { this->desc=NULL; setText(desc); }
+    ~Item() { delete [] desc; }
+  };
+
+  std::vector<Item *> items;
+
+  typedef std::vector<Item *>::iterator ItemIterator;
+  struct has_id  : public std::binary_function<Item*,const char *,bool> {
+    bool operator ()( Item *item , const char *id) const  { return item->id==id; }
+  };
+
+  int m_selection;
+
+public:
+
+  enum notify_id { TITLE, WELCOMETEXT, SELECTION };
+  void redraw() { sendNotify(TITLE); sendNotify(WELCOMETEXT); sendNotify(SELECTION); }
+  void setTitle(const char *s) { m_title = s; sendNotify(TITLE); }
+  const char*title() const { return m_title.c_str(); }
+  void setWelcomeText(const char *s) { m_welcomeText = s; sendNotify(WELCOMETEXT); }
+  const char *welcomeText() const { return m_welcomeText.c_str(); }
+  void setItem(const char *id, const char *sortkey, const char *desc, const char *cmd);
+  void delItem(const char *id);
+  int selection() const { return m_selection; }
+  bool haveSelection() const { return m_selection >= 0; }
+  void selectItem(const char *id);
+  const char *selectedCommand() const { return haveSelection() ? items[m_selection]->cmd.c_str() : ""; }
+  void cursorUp()   { if( m_selection>0) m_selection--; sendNotify(SELECTION); }
+  void cursorDown() { if( m_selection+1<items.size()) m_selection++; sendNotify(SELECTION); }
+  Dynmenu() { m_selection = -1; }
+  ~Dynmenu() { for(int i=0;i<items.size();i++) delete items[i]; }
+
+  void registerView(DynmenuViewRef view);
+private:
+  void sendNotify(notify_id id);
+  void sendItemInsertion(int idx, const char *text);
+  void sendItemChanged(int idx, const char *text);
+  ItemIterator findItem(const char *id);
+};
+
+class DynmenuView
+{
+public:
+  virtual void notify(Dynmenu *menu, Dynmenu::notify_id id) = 0;
+  virtual void itemInserted(Dynmenu *menu, int index, const char *text ) = 0;
+  virtual void itemChanged(Dynmenu *menu, int index, const char *text ) = 0;
+  virtual ~DynmenuView() {}
+};
+
+class DynmenuSimpleView : public DynmenuView
+{
+public:
+  virtual void notify(Dynmenu *menu, Dynmenu::notify_id id) { 
+    printf("notify %p %i\n", menu, id );
+  }
+  virtual void itemInserted(Dynmenu *menu, int index, const char *text ) {
+    //printf("itemInserted %p %i \"%s\" \"%s\"\n", menu, index, text, menu->items[index]->cmd.c_str() );
+    printf("itemInserted %p %i \"%s\"\n", menu, index, text );
+  }
+  virtual void itemChanged(Dynmenu *menu, int index, const char *text ) {
+    printf("itemChanged %p %i \"%s\"\n", menu, index, text );
+  }
+  virtual ~DynmenuSimpleView() {}
+};
+
+
+Dynmenu::ItemIterator Dynmenu::findItem(const char *id)
+{
+  using namespace std;
+  ItemIterator ret = find_if( items.begin(), items.end(), bind2nd( has_id(), id )  );
+  return ret;
+}
+
+void Dynmenu::setItem(const char *id, const char *sortkey, const char *desc, const char *cmd)
+{
+  std::vector<Item*>::iterator i;
+  i = findItem(id);
+  if(i==items.end()) {
+    items.push_back( new Item(id,sortkey,desc,cmd) );
+    // TODO: sort
+    sendItemInsertion( items.size()-1, items.back()->getText() );
+    if(m_selection==-1) {
+        m_selection=items.size()-1;
+        sendNotify(SELECTION);
+    }
+  }
+  else {
+    (*i)->cmd = cmd;
+    (*i)->setText(desc);
+    (*i)->key = sortkey; // TODO: resort
+    sendItemChanged( i - items.begin(), (*i)->getText() );
+  }
+}
+
+void Dynmenu::selectItem(const char *id)
+{
+  std::vector<Item*>::iterator i;
+  i = findItem(id);
+  if(i!=items.end()) {
+    m_selection = i - items.begin();
+    sendNotify(SELECTION);
+  }
+}
+
+void Dynmenu::delItem(const char *id){}
+
+void Dynmenu::registerView(DynmenuViewRef view)
+{
+  view->notify(this,TITLE);
+  view->notify(this,WELCOMETEXT);
+  std::vector<Item*>::iterator i;
+  for(i=items.begin(); i!=items.end(); i++ ) {
+    view->itemInserted( this, i - items.begin(), (*i)->getText() );
+  }
+  view->notify(this,SELECTION);
+  views.push_back(view);
+}
+
+void Dynmenu::sendNotify(notify_id id)
+{
+  for( std::vector<DynmenuViewRef>::iterator i=views.begin(); i!=views.end(); i++ ) {
+    (*i)->notify(this, id);
+  }
+}
+void Dynmenu::sendItemInsertion(int idx, const char *text )
+{
+  for( std::vector<DynmenuViewRef>::iterator i=views.begin(); i!=views.end(); i++ ) {
+    (*i)->itemInserted(this, idx, text);
+  }
+}
+void Dynmenu::sendItemChanged(int idx, const char *text )
+{
+  for( std::vector<DynmenuViewRef>::iterator i=views.begin(); i!=views.end(); i++ ) {
+    (*i)->itemChanged(this, idx, text);
+  }
+}
+
+int _g_y = 0;
+
+#define kdprintf(fmt,...) \
+  { char buf[200]; _g_y++; sprintf( buf, fmt "\n", ## __VA_ARGS__);  mvaddnstr(_g_y,1,buf,strlen(buf)); refresh(); }
+#define dprintf(fmt,...) 
+
+
+struct TextBox
+{
+  int y,x,w,h;
+  TextBox() : y(0),x(0),w(0),h(0) {}
+  void update(int x_, int y_, int w_, int h_) { y=y_;x=x_;w=w_;h=h_; }
+};
+
+
+class LineDrawer
+{
+public:
+  virtual void drawLine(WINDOW *win, int width, int number) = 0;
+  virtual int size() const = 0;
+};
+
+class ScrollWindow
+{
+  WINDOW *win;
+  int top_index;
+  LineDrawer *drawer;
+  void getExtants(int &maxy, int &maxx, int &count);
+public:
+  void redraw();
+  ScrollWindow() : win(NULL), top_index(0), drawer(NULL) {}
+  void setWin(WINDOW *w) { win=w; redraw(); }
+  void setLineDrawer(LineDrawer *d) { drawer = d; redraw(); }
+  void doScroll(int delta);
+  void scrollTo(int start, int end);
+  void invalidate(int start, int end);
+  void changedSize();
+};
+
+void ScrollWindow::getExtants(int &maxy, int &maxx, int &count)
+{
+  getmaxyx(win,maxy,maxx);
+  count = drawer->size();
+}
+
+void ScrollWindow::redraw()
+{
+  if(!win || !drawer) return;
+  int maxy,maxx,count;
+  getExtants(maxy,maxx,count);
+  wborder(win, 0, 0, top_index>0 ? '.' : 0, count < top_index+maxy-1 ? 0 : '.' , 0, 0, 0, 0);
+  for(int y=1,i=top_index;y<maxy-1;y++) {
+    if( i<count ) {
+      wmove(win,y,1);
+      drawer->drawLine(win,maxx-2,i++);
+    }
+  }
+  wrefresh(win);
+}
+
+void ScrollWindow::invalidate(int start, int end)
+{
+  int maxy,maxx,count;
+  if( end <= top_index ) return;
+  getExtants(maxy,maxx,count);
+  if( start > top_index+maxy-2 ) return;
+
+  if(start < top_index ) start = top_index;
+  if(end > top_index+maxy-2 ) end = top_index+maxy-2;
+  //if(end > count ) end = count;  
+
+
+  int starty = 1 + start - top_index;
+  int stopy = starty + end - start;
+
+  for(int y=starty,i=start;y<stopy;y++) {
+    //if( i<count ) {
+      wmove(win,y,1);
+      drawer->drawLine(win,maxx-2,i++);
+    //}
+  }
+  wrefresh(win);
+}
+
+void ScrollWindow::scrollTo(int start, int end)
+{
+  if( start < top_index ) doScroll(start-top_index);
+  int maxy,maxx,count;
+  getExtants(maxy,maxx,count);
+  if( end > top_index+maxy-2 && start>top_index) {
+    int delta=end-top_index-maxy+2;
+    if( top_index+delta > start ) delta = start - top_index;
+    doScroll(delta);
+  }
+}
+
+void ScrollWindow::changedSize()
+{
+  int maxy,maxx,count;
+  getExtants(maxy,maxx,count);
+  wmove(win,maxy-1,1);
+  if( top_index+maxy-2<count) {
+    whline(win,'.',maxx-2);
+    wrefresh(win);
+  }
+  else if( top_index+maxy-2==count) {
+    whline(win,0,maxx-2);
+    wrefresh(win);
+  }
+}
+
+void ScrollWindow::doScroll(int delta)
+{
+  if(!win || !drawer) return;
+  //assert(delta>=-1 && delta<=1);
+  int maxy,maxx,count;
+  getExtants(maxy,maxx,count);
+
+  if( top_index+delta<0 ) delta = -top_index;
+  if (delta>0 && top_index>0 && top_index+maxy-1+delta>count) delta=count-top_index-maxy+2;
+  if (top_index+delta>count)  delta=0;
+
+  if(delta==0) return;
+  dprintf("scrolling win=%p, drawer=%p, top_index+delta=%i, v=%i, count=%i", win, drawer, top_index+delta, top_index+maxy-1+delta, count);
+
+  dprintf("scrolling %i", delta);
+
+  WINDOW *w = derwin(win, maxy-2,maxx-2,1,1);
+  scrollok(w,true);
+  wscrl(w,delta);
+  scrollok(w,false);
+  touchwin(win);
+
+  if( top_index==0 ) {
+    wmove(win,0,1);
+    whline(win,'.',maxx-2);
+  }
+  if( top_index+maxy-2==count) {
+    wmove(win,maxy-1,1);
+    whline(win,'.',maxx-2);
+  }
+  top_index += delta;
+  int y = delta<0 ? 0 : maxy-2-delta;
+  int i = y + top_index;
+  dprintf("scroll values i=%i, y=%i", i, y);
+  delta = delta<0 ? -delta : delta;
+  for(int j=0;j<delta;j++) {
+    wmove(w,y++,0);
+    if(i<count) drawer->drawLine(w,maxx-2,i++);
+    
+  }
+  wrefresh(w);
+  delwin(w);
+  if( top_index==0 ) {
+    wmove(win,0,1);
+    whline(win,0,maxx-2);
+  }
+  if( top_index+maxy-2==count) {
+    wmove(win,maxy-1,1);
+    whline(win,0,maxx-2);
+  }
+  wrefresh(win);
+}
+
+/*
+class ItemDrawer : public LineDrawer
+{
+public:
+  void drawLine(WINDOW *win, int width, int number);
+  int size() const { return 50; }
+};
+
+void ItemDrawer::drawLine(WINDOW *win, int width, int number)
+{
+  char buf[200];
+  sprintf(buf, "This is line #%i.", number );
+  waddnstr(win,buf, width);
+}
+*/
+
+class DynmenuCursesView : public DynmenuView, public LineDrawer
+{
+  int maxx, maxy;
+  WINDOW *win;
+  TextBox titleBox;
+  TextBox welcomeBox;
+  WINDOW *itemwin;
+  ScrollWindow itemScroll;
+  struct Item {
+    int top;
+    std::vector<const char *> text;
+    int compare(int line) { 
+      if(line<top) return -1;
+      else if(line>=top+text.size()) return 1;
+      else return 0; 
+    }
+  };
+  std::vector<Item> items;
+  int cached_index;
+  int selected;
+public:
+  DynmenuCursesView() : win(NULL),itemwin(NULL), maxx(0), maxy(0), cached_index(0), selected(-1) {  
+    itemScroll.setLineDrawer(this);
+  }
+  ~DynmenuCursesView() { delwin(itemwin); }
+  void show(WINDOW *win);
+  void notify(Dynmenu *menu, Dynmenu::notify_id id);
+  void itemInserted(Dynmenu *menu, int index, const char *text );
+  void itemChanged(Dynmenu *menu, int index, const char *text );
+
+  // LineDrawer interface
+  void drawLine(WINDOW *win, int width, int number);
+  int size() const { if(items.size()==0) return 0; else return items.back().top + items.back().text.size(); }
+};
+
+void DynmenuCursesView::drawLine(WINDOW *win, int width, int number )
+{
+  int i = cached_index;
+  while( items[i].compare(number)>0 && i<items.size()-1 ) i++;
+  while( items[i].compare(number)<0 && i>0 ) i--;
+  if( items[i].compare(number)!=0 ) {
+    // If out of range, clear row
+    wattroff(win, A_STANDOUT);
+    for(int i=0;i<width;i++) waddch(win,' ');
+    return;
+  }
+  cached_index = i;
+  Item &item = items[cached_index];
+  i = number - item.top;
+  const char *end = NULL;
+  if( i < item.text.size()-1 ) end = item.text[i+1]-1;
+  if(!end) for(end=item.text[i];*end;end++);
+  size_t len = end - item.text[i];
+  len = len>width ? width : len;
+  // TODO: draw selection
+  if( selected == cached_index ) 
+    wattron(win, A_STANDOUT);
+  else 
+    wattroff(win, A_STANDOUT);
+  waddnstr( win, item.text[i], len );
+  int mright = width - len;
+        for(int j=0;j<mright;j++) waddstr(win," ");
+  wattroff(win, A_STANDOUT);
+}
+
+void DynmenuCursesView::itemInserted(Dynmenu *menu, int index, const char *text)
+{
+  std::vector<Item>::iterator item = items.insert( items.begin() + index, Item() );
+  const char *p = text;
+  item->text.push_back(p);
+  for(;;) {
+    while( *p && *p!='\n' ) p++;
+    if(*p) p++;
+    if(*p) item->text.push_back(p);
+    else break;
+  }
+  int firstrow = 0;
+  if(item!=items.begin())  {
+    item->top = (item-1)->top + (item-1)->text.size();
+  }
+  else 
+    item->top = 0;
+
+  firstrow = item->top;
+  if((item+1)!=items.end()) {
+    size_t newrows = item->text.size();
+    for( item++; item!=items.end(); item++ ) item->top += newrows;
+  }
+  itemScroll.invalidate( firstrow, size() );
+  itemScroll.changedSize();
+  wrefresh(win);
+}
+
+void DynmenuCursesView::itemChanged(Dynmenu *menu, int index, const char *text)
+{
+  std::vector<Item>::iterator item = items.begin() + index;
+  size_t oldsize = item->text.size();
+  int lastrow = items.back().top + items.back().text.size();
+  item->text.clear();
+  const char *p = text;
+  item->text.push_back(p);
+  for(;;) {
+    while( *p && *p!='\n' ) p++;
+    if(*p) p++;
+    if(*p) item->text.push_back(p);
+    else break;
+  }
+  int firstrow = item->top;
+  int diff = item->text.size() - oldsize;
+  if( diff )  {
+    for( item ++; item!=items.end(); item++ ) item->top += diff;
+    item = items.end() - 1;
+  }
+  else lastrow = item->top + oldsize;
+  if( lastrow < item->top + item->text.size() ) lastrow = item->top + item->text.size();
+
+  itemScroll.invalidate( firstrow, lastrow );
+  itemScroll.changedSize();
+  wrefresh(win);
+}
+
+void getTextExtents(const char *text, int &width, int &height )
+{
+  width = 0;
+  height = 0;
+  const char *p;
+  const char *s;
+  p = text;
+  do {
+    s = p;
+    while( *p && *p!='\n' ) p++;
+    if(p-s>0) {
+      height++;
+      if(width<p-s) width=p-s;
+    } else if (*p) height++;
+    if(*p) p++;
+  } while( *p );
+}
+
+void drawText( WINDOW *win, const TextBox &b, const char *text, const bool center = false )
+{
+  int cx,cy;
+  const char *p;
+  const char *s;
+  cx = b.x;
+  cy = b.y;
+  p = text;
+  do {
+    s = p;
+    while( *p && *p!='\n' ) p++;
+    int len = p-s;
+    if(len && cy<b.y+b.h ) {
+      int offset = center ? (b.w - cx - len) / 2 : 0;
+      int res = mvwaddnstr( win, cy, cx + offset, s, len);
+    }
+    cy++;
+    if(*p) p++;
+  } while( *p );
+}
+
+void clearBox( WINDOW *win, const TextBox &b ) 
+{
+  if(b.w==0 || b.h==0 ) return;
+  dprintf("clearing: h=%i, w=%i, y=%i, x=%i", b.h, b.w, b.y,b.x);
+  WINDOW *w = derwin(win,b.h,b.w,b.y,b.x);
+  werase(w);
+  touchwin(win);
+  wrefresh(w);
+  delwin(w);
+}
+
+void DynmenuCursesView::notify(Dynmenu *menu, Dynmenu::notify_id id)
+{
+  int tx,ty, tw,th, oldbottom;
+  switch(id) {
+  case Dynmenu::TITLE:
+    getTextExtents( menu->title(), tw, th );
+    tx = 0;
+    ty = 0;
+    tw = maxx - tx;
+    dprintf("tx = %i, ty=%i, title=%s, tw=%i", tx, ty, menu->title(), tw );
+    clearBox(win,titleBox);
+    oldbottom = titleBox.y+titleBox.h;
+    titleBox.update(tx,ty,tw,th);
+    if(oldbottom!=titleBox.y+titleBox.h) { 
+      notify(menu,Dynmenu::WELCOMETEXT);
+    }
+    drawText(win,titleBox,  menu->title(), true );
+    break;
+  case Dynmenu::WELCOMETEXT:
+    getTextExtents( menu->welcomeText(), tw, th );
+    tx = ( maxx  - tw )/ 2;
+    ty = titleBox.y+titleBox.h+2;
+    clearBox(win,welcomeBox);
+    if(ty+th!=welcomeBox.y+welcomeBox.h) {
+      // Need to resize itemsBox
+      if(itemwin) {
+        werase(itemwin);
+        delwin(itemwin);
+      }
+      itemwin = derwin(win,maxy-ty-th-1,maxx-3, ty+th, 2);
+      itemScroll.setWin(itemwin);
+    }
+    welcomeBox.update(tx,ty,tw,th);
+    drawText(win,welcomeBox, menu->welcomeText() );
+    //mvwaddstr(win,ty,tx, menu->welcomeText() );
+    break;
+  case Dynmenu::SELECTION:
+    //dprintf("items=%zu, selection=%i", menu->items.size(), menu->selection() );
+    int sel=selected;
+    selected = menu->selection();
+    if(sel!=-1) 
+      itemScroll.invalidate(items[sel].top, items[sel].top+items[sel].text.size() );
+    sel = selected;
+    if(sel!=-1)  {
+      itemScroll.invalidate(items[sel].top, items[sel].top+items[sel].text.size() );
+      itemScroll.scrollTo(items[sel].top, items[sel].top+items[sel].text.size() );
+      wrefresh(itemwin);
+    }
+    break;
+  }
+  wrefresh(win);
+}
+
+void DynmenuCursesView::show(WINDOW *win)
+{
+  if( win ) {
+    this->win = win;
+    getmaxyx(win,maxy,maxx);
+    //box(win, 0, 0);
+    if(itemwin) { wrefresh(itemwin); }
+    wrefresh(win);
+  }
+  else {
+  }
+}
+
+#include <string>
+#include <cctype>
+
+using std::string;
+using std::isspace;
+
+class Parser
+{
+        int peeked;
+  void *gdata;
+        int (*getter)(void *);
+        int peek() { return peeked==-2 ? (peeked=getter(gdata)) : peeked; }
+        int get() { int retv =  peeked==-2? (peeked=getter(gdata)) : peeked; peeked=-2; return retv;}
+        bool peekedSpace() { return isspace(peek()); }
+        void skipSpace() { while(peekedSpace()) get(); }
+public:
+        enum tokentype { Identifier, String, EOL };
+        enum exception { NoGetter, SyntaxError };
+        void setCharGetter( int (*g)(void*), void *user ) { getter=g; gdata=user; }
+        void expect( tokentype t, std::string &s );
+        Parser() : peeked(-2), getter(NULL), gdata(NULL) {}
+};
+
+void Parser::expect( tokentype t, std::string &s )
+{
+        if(! getter ) throw NoGetter;
+
+        int c;
+
+        switch( t ) {
+        case Identifier:
+                skipSpace();
+                s = "";
+                while( peek()!=-1 && ! peekedSpace() ) s += (char)get() ;
+                break;
+        case String:
+                skipSpace();
+                s = "";
+                if( peek() !='"' ) throw SyntaxError;
+                get(); // peel off open-quote
+                while(peek()!='"' && peek()!=-1 ) {
+                        c = get();
+                        if( c=='\\')  {
+        c=get(); // allow escaped quotes
+        if(c=='n') c='\n';
+        else if(c=='t') c='\t';
+      }
+                        s += (char)c ;
+                }
+                get(); // peel off close-quote
+                break;
+        case EOL:
+                while( peek()!=-1 && isspace(peek()) && peek()!='\n' ) get();
+                if( !isspace(peek()) ) throw SyntaxError;
+                break;
+        }
+}
+
+
+
+
+#include <sys/select.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+#define CTRLL 12
+
+
+int buf_getc( const char **p )
+{
+  if(**p) return *((*p)++);
+  else return -1;
+}
+
+void trap_signals()
+{
+  struct sigaction s;
+  s.sa_handler = SIG_IGN;
+  int sig[] = { SIGINT, SIGTSTP, SIGQUIT, };
+  for (int i=0; i<sizeof(sig)/sizeof(sig[0]); ++i)
+    sigaction(sig[i], &s, 0);
+}
+
+void bye(void) { if (!isendwin()) endwin(); }
+
+int main(int argc, char **argv)
+{
+  // char buf1[3]; strcpy(buf1, "joehere"); printf("buf=\"%s\"\n");
+  if (argc != 2) {
+    fputs("usage: dynmenu socket-file\n", stderr);
+    return 1;
+  }
+
+  trap_signals();
+
+  Dynmenu menu;
+
+//#define SIMPLE
+#ifdef SIMPLE
+  DynmenuSimpleView view;
+#else
+  DynmenuCursesView view;
+  WINDOW *win = initscr();
+  atexit(bye);
+  curs_set(0); cbreak(); noecho(); keypad(stdscr, 1);
+  wclear(win);
+  view.show(win);
+#endif
+  menu.registerView( &view );
+  int fd;
+
+  fd_set fds;
+  int res;
+  if ((fd = open((const char *) argv[1], O_RDWR|O_NONBLOCK)) < 0) {
+    perror("error opening socket-file");
+    return 1;
+  }
+  FILE *fifo;
+  if ((fifo = fdopen(fd, "r")) == NULL) {
+    perror("error opening socket-file: fdopen");
+    return 1;
+  }
+
+  FD_ZERO(&fds); FD_SET(fd, &fds); FD_SET(0, &fds);
+top:
+  /* Note: On terminal resize, select returns -1 and sets errno to EINTR */
+  dprintf("mainloop...");
+  while ((res = select(fd+1, &fds, NULL, NULL, NULL)) >= 0)
+  {
+    if (FD_ISSET(0, &fds)) {
+      //dprintf("char !");//space!");
+      int c = getch();
+      if (c == ERR) {
+        perror("error reading stdin");
+        return 1;
+      }
+      switch (c) {
+        case KEY_UP:   case 'k': menu.cursorUp();   break;
+        case KEY_DOWN: case 'j': menu.cursorDown(); break;
+        case KEY_RIGHT: case '\n': case '\x0d': case 'l':
+        case KEY_ENTER: 
+          if (!menu.haveSelection())
+            break;
+          bye();
+          endwin();
+          execl("/bin/sh", "/bin/sh", "-c", menu.selectedCommand(), (char *) NULL);
+          perror("exec failed");
+          exit(1); 
+          break;
+
+        case 'Q': bye(); endwin(); exit(0); break;
+
+#ifndef SIMPLE
+        case 'r':
+        case CTRLL:  menu.redraw(); break;
+#endif
+/*
+        case ' ':
+          {
+            dprintf("space!");
+            static char b = 'A';
+            char buf[80]; sprintf( buf, "Letter '%c'", b++ );
+            menu.setItem( "id3", "3", buf, "id3 cmd");
+          }
+*/
+          break;
+      }
+    }
+    if (FD_ISSET(fd, &fds)) {
+      Parser *p = new Parser;
+      char line[1024];//[PIPE_BUF];
+      assert(line);
+      char *pointer = line;
+      while (fgets(line, 1024, fifo) != NULL) {
+        dprintf("%s", line );
+        try {
+          pointer = line;
+          string menuMethod(1024,' ');
+          string id(1024, ' '); string sortkey(1024, ' ');
+          string desc(1024, ' '); string cmd(1024, ' '); string dummy;
+          p->setCharGetter( (int (*)(void*))buf_getc, (void*)&pointer );
+          p->expect( Parser::Identifier, menuMethod );
+          if( menuMethod=="setItem" ) {
+            p->expect( Parser::String, id );
+            p->expect( Parser::String, sortkey );
+            p->expect( Parser::String, desc );
+            p->expect( Parser::String, cmd );
+            menu.setItem( id.c_str(), sortkey.c_str(), desc.c_str(), cmd.c_str() );
+          }
+          else if( menuMethod=="setTitle" ) {
+            p->expect( Parser::String, desc );
+            menu.setTitle( desc.c_str() );
+          }
+          else if( menuMethod=="setWelcomeText" ) {
+            p->expect( Parser::String, desc );
+            menu.setWelcomeText( desc.c_str() );
+          }
+          else if( menuMethod=="delItem" ) {
+            p->expect( Parser::String, id );
+            menu.delItem( id.c_str() );
+          }
+          else if( menuMethod=="selectItem" ) {
+            p->expect( Parser::String, id );
+            menu.selectItem( id.c_str() );
+          }
+        } 
+        catch(...) {
+          dprintf("exception");
+        }
+      }
+    }
+    FD_ZERO(&fds); 
+    if (!feof(fifo)) // will never eof if it is a fifo
+      FD_SET(fd, &fds); // could use inotify here...
+    FD_SET(0, &fds);
+  }
+  char ebuf[80] ="";
+  switch(errno) 
+  {
+    case EINTR:
+      menu.redraw();
+      goto top;
+    case EBADF: strcpy(ebuf, "EBADF"); break;
+    case EINVAL: strcpy(ebuf, "EINVAL"); break;
+    case ENOMEM: strcpy(ebuf, "ENOMEM"); break;
+    default: sprintf(ebuf, "0x%X", errno);
+  }
+  endwin();
+  printf("  errno = %s\n", ebuf );
+
+  return 0;
+}
+
+// vim:ts=2 sw=2 et:
diff --git a/src/samizdat-gpg-agent b/src/samizdat-gpg-agent
new file mode 100755
index 0000000..5b09b7b
--- /dev/null
+++ b/src/samizdat-gpg-agent
@@ -0,0 +1,31 @@
+#!/bin/sh
+export GNUPGHOME=/gpg/gnupghome
+do_ps()
+{
+  . "$GNUPGHOME"/gpg-agent-info
+  GPG_PID=${GPG_AGENT_INFO#*:}
+  GPG_PID=${GPG_PID%:*}
+  /bin/ps uwww $GPG_PID >&2
+}
+
+sh_exports()
+{
+  cat "$GNUPGHOME"/gpg-agent-info || exit
+  echo GNUPGHOME="'$GNUPGHOME'"
+  echo export GNUPGHOME GPG_AGENT_INFO SSH_AUTH_SOCK SSH_AGENT_PID
+}
+
+gpg-agent --daemon \
+  --enable-ssh-support \
+  --allow-preset-passphrase \
+  --use-standard-socket \
+  --homedir "$GNUPGHOME" \
+  --write-env-file "$GNUPGHOME"/gpg-agent-info
+
+case $? in
+  0) ;;
+  2) [ "$verbose" ] && do_ps ;;
+  *) exit $? ;;
+esac
+
+sh_exports
diff --git a/src/samizdat-password-agent b/src/samizdat-password-agent
new file mode 100755
index 0000000..0fb26c6
--- /dev/null
+++ b/src/samizdat-password-agent
@@ -0,0 +1,73 @@
+#!/bin/sh
+[ "$(id -u)" -gt 0 ] && exec sudo "$0" "$@"
+
+scan_gnupg_db()
+{
+  keylist=
+  mainkeygrip=
+  uid=
+  local IFS='
+'
+  for record in $(gpg2 --with-fingerp --with-fingerp --with-colons -K | cut -d: -f1,5,10); do
+    : "$record"
+    case "$record" in
+      fpr:*) keylist="$keylist ${record##*:}" ;;
+      sec:*)
+        if [ -z "$mainkeygrip" ]; then
+          mainkeygrip="${record#sec:}"
+          mainkeygrip="${mainkeygrip%%:*}"
+        fi ;;
+      uid:*) : ${uid:=${record#uid:*:}} ;;
+    esac
+  done
+}
+
+eval $(samizdat-gpg-agent)
+
+gpg2_test_sign()
+{
+  GPG_TTY=none gpg2 \
+    --ignore-valid-from --ignore-time-conflict --no-tty --batch --clearsign </dev/null >/dev/null 2>&1
+}
+
+if [ ! "$FORCE_PINENTRY" ] && gpg2_test_sign; then
+  echo "Made signature with default key successfully.  No additional passphrase is needed." >&2
+  exit
+fi
+
+scan_gnupg_db # get $uid
+
+if [ "$uid" ]; then
+  DESC='Please enter the passphrase to unlock the secret key for the OpenPGP certificate:%0A'"'$uid'."
+else
+  DESC='Please enter the passphrase to unlock the secret key for the OpenPGP certificate.'
+fi
+
+exec samizdat-pinentry \
+  --setdesc "$DESC" \
+  --ttyname "$(tty)" \
+  --socket "${GPG_AGENT_INFO%%:*}" \
+  --resocket /root/"${GPG_AGENT_INFO%%:*}" \
+  --tell-immediately '
+    read secret
+    for grip in '"$keylist"' -; do
+      read status || break
+      printf "< %s\n" "$status" >&2
+      [ -z "${status##OK*}" ] || break
+      [ "$grip" = - ] && break
+      printf "> PRESET_PASSPHRASE %s -1 %%s\n" "$grip" >&2
+      printf "PRESET_PASSPHRASE %s -1 %s\n" "$grip" "$secret"
+    done
+  ' \
+  --validate '
+    exec 7<&0
+    gpgoutput=$(gpg2 --batch --no-tty --ignore-valid-from --ignore-time-conflict \
+      --passphrase-fd 7 --default-key '"$mainkeygrip"' --clearsign </dev/null >/dev/null)
+    status=$?
+    case "$gpgoutput" in
+      *"Bad passphrase"*) echo "Error: Bad passphrase." ;;
+      "") [ $status -eq 0 ] || echo "Error: gpg returned $status." ;;
+      *) printf "gpg returned unexpected error (exit status $status):\n%s\n" "$gpgoutput" ;;
+    esac
+    exit $status
+  ' \
diff --git a/src/samizdat-pinentry.c b/src/samizdat-pinentry.c
new file mode 100644
index 0000000..e1f7fee
--- /dev/null
+++ b/src/samizdat-pinentry.c
@@ -0,0 +1,455 @@
+#include <error.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+
+// TODO: implement multiple ttys
+// TODO: inotify on a password file (kills pinentry)
+// TODO: secure memory
+
+
+/* Buffers:
+ *
+ * assuan info page "The implementation is line based with a maximum line size
+ * of 1000 octets.  The default IPC mechanism are Unix Domain Sockets.
+ *
+ * pinentry info page "Although it is called a PIN-Entry, it does allow to
+ * enter reasonably long strings (at least 2048 characters are supported by
+ * every pinentry).  The client using the PIN-Entry has to check for
+ * correctness."
+ */
+#define MAXLINE 1000 // It's assumed this is > 2. 
+
+
+static int
+open2(const char *argv[], int *result_in, int *result_out, pid_t *result_child)
+{
+  int pipe_out[2]; /* out of parent */
+  int pipe_in[2];  /* into parent */
+  pid_t cpid;
+
+  if (pipe(pipe_out) < 0)
+    return -1;
+  if (pipe(pipe_in) < 0)
+    return -1;
+
+  cpid = fork();
+  if (cpid < 0)
+    return -1;
+
+  if (cpid == 0) { /* child */
+    int *input = pipe_out; /* for sanity */
+    int *output = pipe_in;
+    close(output[0]);
+    close(input[1]);
+
+    /* see http://unixwiz.net/techtips/remap-pipe-fds.c.txt */
+    if (output[1] == 0)
+      if ((output[1] = dup(output[1]) < 0))
+        error(1, errno, "in child process: dup");
+    if (output[0] == 1)
+      if ((output[0] = dup(output[0]) < 0))
+        error(1, errno, "in child process: dup");
+
+    if (dup2(output[1], 1) < 0)
+      error(1, errno, "in child process: dup2");
+    if (dup2(input[0], 0) < 0)
+      error(1, errno, "in child process: dup2");
+
+    if (output[1] != 1)
+      close(output[1]);
+    if (input[0] != 0)
+      close(input[0]);
+
+    execv(argv[0],(char *const*) &argv[1]);
+    error(1, errno, "in child process: exec");
+    return -1; /* fucking warning */
+
+  } else { /* parent */
+    close(pipe_out[0]);
+    close(pipe_in[1]);
+
+    *result_in = pipe_in[0];
+    *result_out = pipe_out[1];
+    if (*result_child)
+      *result_child = cpid;
+    return 0;
+  }
+}
+
+typedef struct {
+  FILE *in, *out;
+  pid_t pid;
+} pipe2_t;
+
+
+pipe2_t fopen2(const char *argv[]) 
+{
+  pipe2_t res = { 0, 0, 0 };
+  int in = 0;
+  int out = 0;
+  if( open2(argv, &in, &out, &res.pid) < 0 )
+    error(1,0, "open2");
+  res.out = fdopen(out, "w");
+  res.in  = fdopen(in, "r");
+  return res;
+}
+
+void pinentry_send(pipe2_t pinentry, const char *msg)
+{
+  fprintf(pinentry.out, "%s\n", msg);
+  fflush(pinentry.out);
+  // printf("C: %s\n", msg);
+}
+int pinentry_get(pipe2_t pinentry, char *data, size_t len)
+{
+  char *ret=fgets(data,len,pinentry.in); 
+  char *p=ret;
+  int gotnewline=0;
+  for(;*p;p++); 
+  if(p!=ret && p[-1]=='\n') {
+    p[-1]='\0';
+    gotnewline=1;
+  }
+  if( !gotnewline ) {
+      int c = ' ';
+      do {
+        c=fgetc(pinentry.in);
+      } while( c!=-1 && c!='\n' );
+  }
+  // printf("S: %s%s", ret, gotnewline?"\n":" <truncated>\n");
+  return !gotnewline;
+}
+
+void pinentry_seterror(pipe2_t pinentry, const char *s)
+{
+    fprintf(pinentry.out,"SETERROR ");
+    pinentry_send( pinentry, s );
+    char data[4] = { 0 };
+    pinentry_get(pinentry,data,4); // OK
+}
+
+void pinentry_set(pipe2_t pinentry, const char *k, const char *v)
+{
+    fprintf(pinentry.out,"SET%s %s\n", k, v);
+    fflush(pinentry.out);
+    char data[4] = { 0 };
+    pinentry_get(pinentry,data,4); // OK
+}
+
+static const char *arg_prompt = "Passphrase:";
+static const char *arg_desc = "Enter your passphrase to unlock the secret key.                         ";
+
+int pinentry_getpin(pipe2_t pinentry, char *secret, size_t maxline)
+{
+  char data[MAXLINE] = { 0 }; 
+
+  // pinentry_send( pinentry, "OPTION lc-ctype=en_US.UTF-8");
+  // pinentry_get( pinentry, data, MAXLINE); // OK
+
+  if (strlen(arg_prompt))
+    pinentry_set( pinentry, "PROMPT", arg_prompt );
+  if (strlen(arg_desc))
+    pinentry_set( pinentry, "DESC", arg_desc );
+
+  pinentry_send( pinentry, "GETPIN");
+  int e = pinentry_get(pinentry, data, MAXLINE);
+  if( strncmp(data,"D ",2)==0 ) {
+    if(!e && strlen(data+2)<=maxline-1 ) {
+      // D <secret>
+      snprintf(secret,maxline,"%s", data+2);
+      //printf("secret = %s\n", secret);
+      pinentry_get(pinentry,data,MAXLINE); // OK
+      return 0;
+    }
+    else {
+      // SECRET TOO BIG, discarding
+      pinentry_seterror(pinentry, "Too big.");
+      return 4;
+    }
+  }
+  else if( strncmp(data,"OK",2)==0 ) {
+    // EMPTY (not an error)
+    secret[0]='\0';
+    //printf("empty secret\n");
+    return 0;
+  }
+  else if( strncmp(data,"ERR ",4)==0 ) {
+    // CANCELED (ERR 83886179 canceled)
+    // ERR 83886246 locale problem
+    // xxx printf("canceled.\n");
+    return 2;
+  }
+  else {
+    // WTF?
+    // xxx printf("Unexpected: %s\n", data);
+    char buf[1024];
+    snprintf(buf,1024,"Unexpected: %s", data );
+    pinentry_seterror(pinentry, buf);
+    return 3;
+  }
+}
+
+pipe2_t do_shell(const char *shell_code) {
+  pipe2_t ret;
+  const char *argv[] = { "/bin/sh", "/bin/sh","-c",NULL,NULL };
+  argv[3]=shell_code;
+  return fopen2(argv);
+}
+
+int validate(pipe2_t pinentry, const char *secret, const char *arg_validate)
+{
+  int retv = 0;
+  if( !arg_validate ) return 1;
+  pipe2_t validate_script = do_shell( arg_validate );
+
+  fprintf( validate_script.out, "%s\n", secret );
+  fclose( validate_script.out );
+  char error_string[1024] = "Error%0Aunspecified error";
+
+  int c;
+  char *p = error_string;
+  while( p!=&error_string[1024-4] && -1!=(c=getc( validate_script.in )) )
+    switch(c){
+    case '%':
+    case '\n':
+      snprintf(p,4, "%%%0.02X", c);
+      p+=3;
+      break;
+    default:
+      *p++ = c;
+  }
+  *p='\0';
+
+  // pinentry ruins its display if this message ends with a newline
+  while(p-3>error_string && memcmp(&p[-3],"%0A",3)==0 ) p-=3;
+  *p='\0';
+
+  fclose( validate_script.in );
+  waitpid(validate_script.pid, &retv, 0 );
+  if( retv ) {
+    fprintf(stderr, "error_string: %s\n", error_string);
+    pinentry_seterror(pinentry, error_string );
+  }
+  return !retv;
+}
+
+FILE *open_socket(const char *socket_path)
+{
+  int sok = socket(PF_LOCAL, SOCK_STREAM, 0);
+  if( sok<0 ) {
+    return NULL;
+  }
+  struct sockaddr_un address;
+  memset(&address, 0, sizeof(struct sockaddr_un));
+  address.sun_family = AF_UNIX;
+  snprintf(address.sun_path, 108, socket_path);
+  if(connect(sok, 
+              (struct sockaddr *) &address, 
+              sizeof(struct sockaddr_un)) != 0)
+  {
+    return NULL;
+  }
+  return fdopen(sok,"r+");
+}
+
+const char *arg_socket = NULL;
+const char *arg_resocket = NULL;
+const char *arg_tellsecret = NULL;
+char secret[MAXLINE]; // TODO: secure memory
+
+void tell_encoded_secret(FILE *out)
+{
+  char *encoded_secret = malloc(strlen(secret)*2 + 1);
+  for (char *p = secret; *p; ++p)
+    snprintf(encoded_secret + 2*(p - secret), 3, "%0.02X", *p);
+
+  fprintf(out, "%s\n", encoded_secret);
+  fflush(out);
+  free(encoded_secret);
+}
+
+void signal_usr1(int val)
+{
+  if( !arg_tellsecret ) {
+    fprintf(stderr, "USR1, no action\n");
+    return;
+  } else
+    fprintf(stderr, "Received SIGUSR1; will tell secret.\n");
+
+  pipe2_t tellsecret = do_shell( arg_tellsecret );
+  tell_encoded_secret(tellsecret.out);
+
+  FILE *sock = NULL;
+  if (arg_socket) sock=open_socket(arg_socket);
+
+  for (;;) {
+    char *response = 0;
+    size_t len;
+    if (sock && (getline(&response, &len, sock) > 0)) {
+      fprintf(tellsecret.out, "%s", response);
+      fflush(tellsecret.out);
+    }
+
+    if (getline(&response, &len, tellsecret.in) > 0) {
+      if (sock) {
+        fprintf(sock, "%s", response);
+        fflush(sock);
+      } else {
+        fprintf(stderr, "?> %s", response);
+      }
+    } else {
+      break;
+    }
+  }
+
+  if (sock) fclose(sock);
+  fclose(tellsecret.out);
+  fclose(tellsecret.in);
+  int status = 0;
+  waitpid(tellsecret.pid, &status, 0 );
+}
+
+void signal_usr2(int wat)
+{
+  fprintf(stderr, "Received SIGUSR2; will change socket and emulate SIGUSR1.\n");
+  if (arg_resocket)
+    arg_socket = arg_resocket;
+  signal_usr1(wat);
+}
+
+void signal_term(int val)
+{
+  // TODO: Wipe secret
+  exit(0);
+}
+
+int main(int argc, char **argv) 
+{
+  pipe2_t pinentry = { 0 };
+
+  char tty_name_buf[256];
+  if( ttyname_r(1, tty_name_buf, sizeof(tty_name_buf)) ) {
+    tty_name_buf[0]='\0';
+    //error(2,0,"ttyname_r");
+  }
+  const char *arg_ttyname = tty_name_buf;
+  const char *arg_pinentry = "/usr/bin/pinentry-curses";
+  const char *arg_validate = NULL;
+  const char *arg_pidfile = NULL; //same as "/dev/stdout";
+  int tell_at_start=0;
+
+  const char **expect = NULL;
+  int i=0;
+  for(i=1;i<argc;i++) {
+    if(expect) {
+      *expect = argv[i];
+      expect = NULL;
+    }
+    else if( strcmp(argv[i],"--setdesc")==0 )
+      expect = &arg_desc;
+    else if( strcmp(argv[i],"--setprompt")==0 )
+      expect = &arg_prompt;
+    else if( strcmp(argv[i],"--validate")==0 )
+      expect = &arg_validate;
+    else if( strcmp(argv[i],"--ttyname")==0 )
+      expect = &arg_ttyname;
+    else if( strcmp(argv[i],"--pinentry")==0 )
+      expect = &arg_pinentry;
+    else if( strcmp(argv[i],"--pidfile")==0 )
+      expect = &arg_pidfile;
+    else if( strcmp(argv[i],"--tell")==0 )
+      expect = &arg_tellsecret;
+    else if( strcmp(argv[i],"--tell-immediately")==0 ) {
+      expect = &arg_tellsecret;
+      tell_at_start=1;
+    }
+    else if( strcmp(argv[i],"--socket")==0 )
+      expect = &arg_socket;
+    else if( strcmp(argv[i],"--resocket")==0 )
+      expect = &arg_resocket;
+  }
+
+  if(!arg_ttyname || !arg_ttyname[0]) {
+    error(2,0,"unknown tty, use --ttyname");
+  }
+ 
+  // xxx printf("validate script = \n%s\n", arg_validate );
+  // xxx printf("ttyname = %s\n", arg_ttyname );
+
+  char dummy[123];
+  //fgets(dummy,sizeof(dummy),stdin);
+
+  // pinentry-curses --lc-ctype en_US.UTF-8 --ttyname /dev/pts/5
+  const char *cmd[] = {
+    NULL /* pinentry command */, 
+    "pinentry-curses",
+    "--lc-ctype", "en_US.UTF-8",
+    "--ttyname", NULL,
+    0 };
+  cmd[0] = arg_pinentry;
+  cmd[sizeof(cmd)/sizeof(cmd[0]) - 2] = arg_ttyname;
+  for(i=0; cmd[i]; i++ ) {
+    // xxx printf("cmd[%d]=%s\n", i, cmd[i] );
+  }
+
+  char data[MAXLINE];
+
+  pinentry = fopen2(cmd);
+  pinentry_get(pinentry,data,MAXLINE); // OK
+
+  int e=0;
+  while(   0!=(e=pinentry_getpin(pinentry,secret,MAXLINE))
+        || !validate(pinentry,secret, arg_validate) ) {
+      //printf("e=%d\n",e);
+      if(e==2) break; // Canceled
+    }
+
+  fclose(pinentry.out);
+  fclose(pinentry.in);
+
+  if(e) return e;
+
+  if( tell_at_start ) {
+    signal_usr1(0);
+  }
+
+  int pid = fork();
+  if( !pid ) {
+
+    if (isatty(0)) fclose(stdin);
+    if (isatty(1)) fclose(stdout);
+    if (isatty(2)) fclose(stderr);
+    setsid();
+
+    struct sigaction act = { 0 };
+    sigemptyset(&act.sa_mask);
+    sigaddset(&act.sa_mask, SIGTERM);
+    sigaddset(&act.sa_mask, SIGUSR1);
+    sigaddset(&act.sa_mask, SIGUSR2);
+    act.sa_handler = signal_usr1;
+    sigaction( SIGUSR1, &act, NULL );
+    act.sa_handler = signal_usr2;
+    sigaction( SIGUSR2, &act, NULL );
+    act.sa_handler = signal_term;
+    sigaction( SIGTERM, &act, NULL );
+
+    for(;;) {
+      pause();
+    }
+    return 0;
+  }
+
+  FILE *pidfile = arg_pidfile ? fopen(arg_pidfile,"w") : stdout;
+  fprintf(pidfile, "%d\n", pid );
+  if(arg_pidfile) fclose(pidfile);
+
+  return 0;
+}
diff --git a/src/wait_for_files.c b/src/wait_for_files.c
new file mode 100644
index 0000000..3a7f6b5
--- /dev/null
+++ b/src/wait_for_files.c
@@ -0,0 +1,114 @@
+// wait_for_files - Efficiently sleeps until the files specified on the
+// command line exist (or have existed during execution).
+// Linux 2.6.13, GNU C only.  Use gcc -std=c99
+// glibc 2.4 or define PRIVATE_INOTIFY_HEADER
+
+// #define PRIVATE_INOTIFY_HEADER "inotifytools/inotify.h"
+
+#include <errno.h>
+#include <error.h>
+#include <libgen.h>
+#include <stdbool.h>
+#include <string.h>
+#ifdef PRIVATE_INOTIFY_HEADER
+#include PRIVATE_INOTIFY_HEADER
+#else
+#include <sys/inotify.h>
+#endif
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+char *strdup(const char *s); // wtf?
+
+int main(int argc, char **argv)
+{
+  if (argc == 1) return 0;
+  --argc; ++argv;
+
+  int notify = inotify_init();
+  if (notify < 0)
+    error(-1, errno, "inotify_init error");
+
+  struct wdtab_t {
+    char *basename;
+    int wd;             // set to 0 when found
+  } wdtab[argc];
+
+  bool done = true;
+  for (int i = 0; i < argc; ++i) {
+    struct wdtab_t *p = &wdtab[i];
+
+    char *dirname_mem;
+    if (!(dirname_mem = strdup(argv[i])) ||
+        !(p->basename = strdup(argv[i])))
+      error(-1, errno, "strdup error");
+    char *dirname_val = dirname(dirname_mem);
+    p->basename = basename(p->basename);
+
+    p->wd = inotify_add_watch(notify, dirname_val, IN_CREATE|IN_MASK_ADD);
+    if (p->wd < 0)
+      error(-1, errno, "inotify_add_watch error (file: %s)", argv[i]);
+    free(dirname_mem);
+
+    struct stat dummy; 
+    if (stat(argv[i], &dummy) == 0)
+      p->wd = 0;
+    else
+      done = false;
+  }
+  if (done) return 0;
+
+  for (;;) {
+    fd_set rfds;
+    FD_ZERO(&rfds);
+    FD_SET(notify, &rfds);
+    switch (select(notify+1, &rfds, NULL, NULL, NULL)) {
+      case -1: error(-1, errno, "select error");
+      case 0: continue; // this should never happen
+    }
+
+    // is ioctl FIONREAD even documented?
+    int bytes_ready = 0;
+    if (ioctl(notify, FIONREAD, &bytes_ready) < 0)
+      error(-1, errno, "ioctl FIONREAD (inotify) error");
+    if (bytes_ready % sizeof(struct inotify_event) != 0)
+      // this should never ever ever happen, evar
+      error(-1, 0, "ioctl FIONREAD (inotify) returned bizarre result (%i)",
+            bytes_ready);
+    if (bytes_ready < sizeof(struct inotify_event))
+      continue; // bytes_ready <= 0.  this should never happen
+
+    struct inotify_event evs[bytes_ready / sizeof(struct inotify_event)];
+
+    ssize_t r;
+    if ((r = read(notify, evs, sizeof(evs))) != sizeof(evs)) {
+      if (r < 0)
+        error(-1, errno, "read error (inotify)");
+      else
+        error(1, 0, "short read (inotify, got %i, expected %i)",
+              (int) r, (int) sizeof(evs));
+    }
+
+    done = true;
+    for (int j = 0; j < sizeof(evs) / sizeof(evs[0]); ++j) {
+      struct inotify_event *ev = &evs[j];
+      for (int i = 0; i < argc; ++i) {
+        struct wdtab_t *p = &wdtab[i];
+        if (!p->wd)
+          continue;
+        else if ((ev->wd == p->wd) &&
+                 (ev->mask|IN_CREATE) &&
+                 !strcmp(ev->name, p->basename))
+        {
+          p->wd = 0;
+        } else
+          done = false;
+      }
+    }
+    if (done) return 0;
+  }
+}