# 
# 
# patch "administrator.cc"
#  from [057432d0959541fe206fefefff4e0e92505cf90c]
#    to [774eb6e37ccf5a2a2e6f4721198e02874dc353e9]
# 
# patch "administrator.hh"
#  from [f410edff6f46b8029139835d12c2bea8e25c53c7]
#    to [2e5057dacae5de057174d7424c7b572ab1c72258]
# 
# patch "server.cc"
#  from [983365a52930c9f80d84d2caddeda31bab5245db]
#    to [3cab80bbf862f991d609445da7b09e88724d5635]
# 
# patch "server_manager.cc"
#  from [b942b53baa1e7a3261c3e02903434cce3d47b82d]
#    to [476ddf46c53cc2b16fa0163592fd3571d2433c17]
# 
# patch "server_manager.hh"
#  from [e61db0e206910c391b221d19bdb355fe1937db84]
#    to [5dfcfa92583c640562517653691199f91250969c]
# 
# patch "sock.cc"
#  from [138d9907656c90168d47e60f470a549216d29670]
#    to [c7d1253b571db327663956556a53969b06defbbb]
# 
# patch "sock.hh"
#  from [169a677fc3106efa3d122247a6b8054f1c82d0c7]
#    to [4b136726ab92c01b4378e5bb1c1b56e2a4c11acf]
# 
# patch "usher.cc"
#  from [562ce8fab28c2fd786800f5f5659fdbbcd3cd14b]
#    to [6489eda7b440f9f5228dbd9b9e13c906cbff8b73]
# 
============================================================
--- administrator.cc	057432d0959541fe206fefefff4e0e92505cf90c
+++ administrator.cc	774eb6e37ccf5a2a2e6f4721198e02874dc353e9
@@ -10,20 +10,45 @@
 using std::max;
 #include <fstream>
 using std::ifstream;
+#include <string>
+using std::string;
+#include <vector>
+using std::vector;
+#include <map>
+using std::map;
 
 #include <boost/lexical_cast.hpp>
 using boost::lexical_cast;
 
 #include <netinet/in.h>
 
+namespace defaults
+{
+  string const listenport = "0.0.0.0:4691";
+  vector<string> operator%(vector<string> l, string const &r)
+  {
+    l.push_back(r);
+    return l;
+  }
+  map<string, vector<string> > get_defaults()
+  {
+    map<string, vector<string> > out;
+    out["monotone"] = vector<string>() % "mtn";
+    out["logdir"] = vector<string>() % "./";
+    return out;
+  }
+  map<string, vector<string> > defaults = get_defaults();
+}
+
 administrator::cstate::cstate()
  : auth(false), rdone(false)
 {
 }
 
 administrator::administrator(server_manager &sm, string const &cf)
- : port(-1), manager(sm), conffile(cf)
+ : port(-1), serverport(-1), manager(sm), conffile(cf)
 {
+  reload_conffile();
 }
 
 bool
@@ -138,17 +163,36 @@
 }
 
 void
-administrator::initialize(string const & ap)
+administrator::initialize(string const & ap, string const & sp)
 {
-  try {
-    int c = ap.find(":");
-    string a = ap.substr(0, c);
-    int p = lexical_cast<int>(ap.substr(c+1));
-    port = start(a, p);
-  } catch (errstr & s) {
-    cerr<<"Could not initialize admin port: "<<s.name<<"\n";
-    return;
-  }
+  sock oldport(-1);
+  if (!ap.empty())
+    {
+      oldport = port;
+      try {
+        port = start(ap);
+      } catch (errstr & s) {
+        cerr<<"Could not initialize admin port: "<<s.name<<"\n";
+        port = oldport;
+        return;
+      }
+      if (oldport != -1)
+        oldport.close();
+    }
+
+  if (!sp.empty())
+    {
+      oldport = serverport;
+      try {
+        serverport = start(sp);
+      } catch (errstr & s) {
+        cerr<<"Could not initialize server port: "<<s.name<<"\n";
+        serverport = oldport;
+        return;
+      }
+      if (oldport != -1)
+        oldport.close();
+    }
 }
 
 void
@@ -239,15 +283,41 @@
   bool ok = reader.get(st);
   if (!ok)
     return;
+  map<string, vector<string> > opts = defaults::defaults;
+  admins.clear();
+  string ap, sp;
+  if (serverport == -1)
+    sp = defaults::listenport;
   for (vector<basic_io::item>::iterator i = st.items.begin();
        i != st.items.end(); ++i)
     {
       if (i->key == "userpass")
         {
-          if (i->values.size() != 2)
-            return;
-          admins.insert(make_pair(i->values[0].parsed, i->values[1].parsed));
+          if (i->values.size() == 2)
+            admins.insert(make_pair(i->values[0].parsed, i->values[1].parsed));
         }
+      else if (i->key == "adminaddr")
+        {
+          if (!i->values.empty())
+            ap = i->values[0].parsed;
+        }
+      else if (i->key == "listenaddr")
+        {
+          if (!i->values.empty())
+            sp = i->values[0].parsed;
+        }
+      else
+        {
+          vector<string> vals;
+          for (std::vector<basic_io::value>::iterator j = i->values.begin();
+               j != i->values.end(); ++j)
+            {
+              vals.push_back(j->parsed);
+            }
+          opts[i->key] = vals;
+        }
     }
+  initialize(ap, sp);
+  manager.set_opts(opts);
   manager.reload_servers();
 }
============================================================
--- administrator.hh	f410edff6f46b8029139835d12c2bea8e25c53c7
+++ administrator.hh	2e5057dacae5de057174d7424c7b572ab1c72258
@@ -18,6 +18,7 @@
 struct administrator
 {
   sock port;
+  sock serverport;
   struct cstate
   {
     bool auth;
@@ -31,7 +32,7 @@
   string conffile;
   administrator(server_manager &sm, string const &cf);
   bool process(cstate & cs);
-  void initialize(string const & ap);
+  void initialize(string const & ap, string const & sp);
   void add_to_select(int & maxfd, fd_set & rd, fd_set & wr, fd_set & er);
   void process_selected(fd_set & rd, fd_set & wr, fd_set & er);
   void reload_conffile();
============================================================
--- server.cc	983365a52930c9f80d84d2caddeda31bab5245db
+++ server.cc	3cab80bbf862f991d609445da7b09e88724d5635
@@ -15,8 +15,6 @@
 #include <boost/lexical_cast.hpp>
 using boost::lexical_cast;
 
-extern string monotone;
-
 // keep local servers around for this many seconds after the last
 // client disconnects from them (only accurate to ~10 seconds)
 int const server_idle_timeout = 60;
@@ -202,8 +200,15 @@
     throw errstr("This server is disabled.");
   map<shared_ptr<server>, server_manager::serverdata>::iterator
     i = manager.servers.find(self());
-  string logfilename(manager.get_logdir() + "/");
-  logfilename = i->second.name + ".log";
+  map<string, vector<string> > opts = manager.get_opts();
+  string logfilename;
+  if (!opts["logdir"].empty());
+    {
+      logfilename = opts["logdir"].front();
+      if (!logfilename.empty() && logfilename[logfilename.size()-1] != '/')
+        logfilename += '/';
+    }
+  logfilename += i->second.name + ".log";
   if (local && pid == -1) {
     // server needs to be started
     // we'll try 3 times, since there's a delay between our checking that
@@ -211,8 +216,7 @@
     for (int i = 0; i < 3 && pid == -1; ++i) {
       if (i > 0 || port == 0)
         find_addr(addr, port);
-      vector<string> args;
-      args.push_back(monotone);
+      vector<string> args = opts["monotone"];
       args.push_back("serve");
       args.push_back("--bind=" + addr + ":" + lexical_cast<string>(port));
       for (vector<string>::iterator j = arguments.begin();
============================================================
--- server_manager.cc	b942b53baa1e7a3261c3e02903434cce3d47b82d
+++ server_manager.cc	476ddf46c53cc2b16fa0163592fd3571d2433c17
@@ -24,7 +24,7 @@
 }
 
 server_manager::server_manager(serverlist_reader &r)
- : reader(r), logdir(".")
+ : reader(r)
 {
   reload_servers();
 }
@@ -67,6 +67,12 @@
 }
 
 void
+server_manager::set_opts(map<string, vector<string> > const & o)
+{
+  opts = o;
+}
+
+void
 server_manager::add_replace_server(shared_ptr<server> srv, serverdata const &dat)
 {
   servers.insert(make_pair(srv, dat));
============================================================
--- server_manager.hh	e61db0e206910c391b221d19bdb355fe1937db84
+++ server_manager.hh	5dfcfa92583c640562517653691199f91250969c
@@ -10,6 +10,8 @@
 using std::set;
 #include <map>
 using std::map;
+#include <vector>
+using std::vector;
 
 #include <boost/shared_ptr.hpp>
 using boost::shared_ptr;
@@ -51,7 +53,7 @@
   bool connections_allowed;
   int total_connections;
   serverlist_reader &reader;
-  string logdir;
+  map<string, vector<string> > opts;
   
   void add_replace_server(shared_ptr<server> srv, serverdata const &dat);
   void delist_server(shared_ptr<server> srv);
@@ -62,8 +64,9 @@
   server_manager(serverlist_reader &r);
   bool get_connections_allowed() {return connections_allowed;}
   int get_total_connections() {return total_connections;}
-  string get_logdir() {return logdir;}
+  map<string, vector<string> > get_opts() {return opts;}
   
+  void set_opts(map<string, vector<string> > const & o);
   void allow_connections(bool allow=true);
   string start_stop_server(string const &srv, bool start);
   void reload_servers();
============================================================
--- sock.cc	138d9907656c90168d47e60f470a549216d29670
+++ sock.cc	c7d1253b571db327663956556a53969b06defbbb
@@ -13,6 +13,9 @@
 #include <iostream>
 using std::cerr;
 
+#include <boost/lexical_cast.hpp>
+using boost::lexical_cast;
+
 sock::operator int()
 {
   if (!s)
@@ -137,7 +140,7 @@
 std::set<int*> sock::all_socks;
 
 sock
-start(string addr, int port)
+start(string const & addr, int port)
 {
   sock s = tosserr(socket(AF_INET, SOCK_STREAM, 0), "socket()");
   int yes = 1;
@@ -154,3 +157,12 @@
   listen(s, 10);
   return s;
 }
+
+sock
+start(string const & addrport)
+{
+  int c = addrport.find(":");
+  string addr = addrport.substr(0, c);
+  int port = lexical_cast<int>(addrport.substr(c+1));
+  return start(addr, port);
+}
============================================================
--- sock.hh	169a677fc3106efa3d122247a6b8054f1c82d0c7
+++ sock.hh	4b136726ab92c01b4378e5bb1c1b56e2a4c11acf
@@ -23,6 +23,7 @@
   bool write_from(buffer & buf);
 };
 
-sock start(std::string addr, int port);
+sock start(std::string const & addr, int port);
+sock start(std::string const & addrport);
 
 #endif
============================================================
--- usher.cc	562ce8fab28c2fd786800f5f5659fdbbcd3cd14b
+++ usher.cc	6489eda7b440f9f5228dbd9b9e13c906cbff8b73
@@ -47,15 +47,9 @@
 using std::pair;
 using std::make_pair;
 
-// defaults, overridden by command line
-int listenport = 4691;
-string listenaddr = "0.0.0.0";
-string monotone = "mtn";
+// defaults moved to near the top of administrator.cc
 
 
-
-
-
 string getline(std::istream & in)
 {
   string out;
@@ -109,33 +103,20 @@
   {
     int i;
     for (i = 1; i < argc; ++i) {
-      if (string(argv[i]) == "-l") {
-        string lp(argv[++i]);
-        unsigned int c = lp.find(":");
-        listenaddr = lp.substr(0, c);
-        if (c != lp.npos)
-          listenport = lexical_cast<int>(lp.substr(c+1));
-      } else if (string(argv[i]) == "-m")
-        monotone = argv[++i];
-      else if (string(argv[i]) == "-a")
-        adminstr = argv[++i];
-      else if (string(argv[i]) == "-p")
+      if (string(argv[i]) == "-p")
         pf.initialize(argv[++i]);
       else
         conffile = argv[i];
     }
     if (conffile.empty() || i != argc) {
       cerr<<"Usage:\n";
-      cerr<<"\tusher [-l addr[:port]] [-a addr:port] <config-file>\n";
+      cerr<<"\tusher [-p pidfile] <config-file>\n";
       exit (1);
     }
   }
   basic_io_serverlist_reader reader(conffile);
   server_manager manager(reader);
   administrator admin(manager, conffile);
-  admin.reload_conffile();
-  if (!adminstr.empty())
-    admin.initialize(adminstr);
 
 
   struct sigaction sa, sa_old;
@@ -149,13 +130,11 @@
   while(sigaction(SIGTERM, &sa, &sa_old) == -1 && errno == EINTR);
   while(sigaction(SIGINT, &sa, &sa_old) == -1 && errno == EINTR);
 
-  sock h(-1);
-  try {
-    h = start(listenaddr, listenport);
-  } catch (errstr & s) {
-    std::cerr<<"Error while opening socket: "<<s.name<<"\n";
-    exit (1);
-  }
+  if (admin.serverport == -1)
+    {
+      std::cerr<<"Cannot open port.\n";
+      exit(1);
+    }
 
   std::list<channel> channels;
 
@@ -165,8 +144,8 @@
     FD_ZERO (&rd);
     FD_ZERO (&wr);
     FD_ZERO (&er);
-    FD_SET (h, &rd);
-    int nfds = h;
+    FD_SET (admin.serverport, &rd);
+    int nfds = admin.serverport;
     channel *newchan = 0;
 
     for (std::list<channel>::iterator i = channels.begin();
@@ -186,12 +165,12 @@
     }
     if (done)
       return 0;
-    if (FD_ISSET(h, &rd)) {
+    if (FD_ISSET(admin.serverport, &rd)) {
       try {
         struct sockaddr_in client_address;
         unsigned int l = sizeof(client_address);
         memset(&client_address, 0, l);
-        sock cli = tosserr(accept(h, (struct sockaddr *)
+        sock cli = tosserr(accept(admin.serverport, (struct sockaddr *)
                                      &client_address, &l), "accept()");
         if (manager.get_connections_allowed())
           newchan = new channel(cli, manager);